import javax.swing.*;
import javax.swing.border.TitledBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.event.*;
import java.awt.*;
import java.io.File;
import java.util.Arrays;

public class Histo extends JPanel {

    // some constants
    //
    private static final long serialVersionUID = 1L;
    private static final int histWidth = 256;
    private static final int histHeight = 272;
    private static final int layoutBorder = 10;
    private static final int maxImageWidth = 600;
    private static final int maxImageHeight = 600;

    // main frame
    //
    private static JFrame frame;

    // layout items
    //
    private ImageView imgView;                  // image view
    private ImageView histoView;                // histogram view
    private JLabel[]  label = new JLabel[12];   // text display

    // Image TitledBorder
    //
    private TitledBorder imgBorder;

    // Originalbild
    //
    private ImageView imgViewOriginal;

    // Dateiname
    //
    private String filename;

    // Slider
    //
    private JSlider brightnessSlider;
    private JSlider contrastSlider;
    private JSlider saturationSlider;

    // statistische Werte
    //
    private int minValue = 0;
    private int maxValue = 0;
    private double avgValue = 0.0; // Mittelwert, Durchschnitt
    private int mdnValue = 0; // Median
    private double varValue = 0.0; // Varianz
    private double entValue = 0.0; // Entropie

    public Histo() {
        super(new BorderLayout(layoutBorder, layoutBorder));

        // load the default image
        File input = new File("mountains.png");
        filename = input.getName();

        if(!input.canRead()) input = openFile(); // file not found, choose another image

        imgView = new ImageView(input);
        imgView.setMaxSize(new Dimension(maxImageWidth, maxImageHeight));

        // save original image
        imgViewOriginal = new ImageView(input);

        // create an empty histogram image
        histoView = new ImageView(histWidth, histHeight);

        // load image button
        JButton load = new JButton("Open Image");
        load.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                File input = openFile();
                if(input != null) {
                    imgView.loadImage(input);
                    imgView.setMaxSize(new Dimension(maxImageWidth, maxImageHeight));
                    imgViewOriginal = new ImageView(input);
                    filename = input.getName();
                    frame.pack();
                    resetImage();
                }
            }
        });

        // south panel
        JPanel southPanel = new JPanel(new BorderLayout());

        // text display
        JPanel statsPanel = new JPanel(new GridLayout(3, 2));
        TitledBorder statsBorder = BorderFactory.createTitledBorder("Bildwerte");
        statsPanel.setBorder(statsBorder);

        String[] string = {"", "", "", "", "", "", "", "", "", "", "", ""};

        for (int i = 0; i < 12; i++) {
            label[i] = new JLabel(string[i]);
            statsPanel.add(label[i]);
        }

        southPanel.add(statsPanel, BorderLayout.NORTH);

        // control panel
        JPanel controlPanel = new JPanel(new BorderLayout());

        // brightness slider
        brightnessSlider = new JSlider(-128,128,0);
        brightnessSlider.setMinorTickSpacing(16);
        brightnessSlider.setPaintTicks(true);
        TitledBorder brightnessBorder = BorderFactory.createTitledBorder("Helligkeit");
        brightnessSlider.setBorder(brightnessBorder);
        brightnessSlider.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent arg0) {
                changeImage();
            }
        });
        controlPanel.add(brightnessSlider, BorderLayout.NORTH);

        // contrast slider
        contrastSlider = new JSlider(0,80,20);
        contrastSlider.setMinorTickSpacing(10);
        contrastSlider.setPaintTicks(true);
        TitledBorder contrastBorder = BorderFactory.createTitledBorder("Kontrast");
        contrastSlider.setBorder(contrastBorder);
        contrastSlider.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent arg0) {
                changeImage();
            }
        });
        controlPanel.add(contrastSlider, BorderLayout.CENTER);

        // saturation slider
        saturationSlider = new JSlider(0,80,20);
        saturationSlider.setMinorTickSpacing(10);
        saturationSlider.setPaintTicks(true);
        TitledBorder saturationBorder = BorderFactory.createTitledBorder("Sättigung");
        saturationSlider.setBorder(saturationBorder);
        saturationSlider.addChangeListener(new ChangeListener() {
            public void stateChanged(ChangeEvent arg0) {
                changeImage();
            }
        });
        controlPanel.add(saturationSlider, BorderLayout.SOUTH);

        //
        southPanel.add(controlPanel, BorderLayout.SOUTH);

        // Bild + Histogramm
        JPanel imgPanel = new JPanel();
        imgBorder = BorderFactory.createTitledBorder(filename);
        imgPanel.setBorder(imgBorder);
        imgPanel.add(imgView);

        JPanel histoPanel = new JPanel();
        TitledBorder histoBorder = BorderFactory.createTitledBorder("Histogramm");
        histoPanel.setBorder(histoBorder);
        histoPanel.add(histoView);

        JPanel images = new JPanel(new FlowLayout());
        images.add(imgPanel);
        images.add(histoPanel);

        add(load, BorderLayout.NORTH);
        add(images, BorderLayout.CENTER);
        add(southPanel, BorderLayout.SOUTH);

        setBorder(BorderFactory.createEmptyBorder(layoutBorder,layoutBorder,layoutBorder,layoutBorder));

        // perform the initial scaling
        resetImage();
    }

    private File openFile() {
        JFileChooser chooser = new JFileChooser();
        FileNameExtensionFilter filter = new FileNameExtensionFilter("Images (*.jpg, *.png, *.gif)", "jpg", "png", "gif");
        chooser.setFileFilter(filter);
        int ret = chooser.showOpenDialog(this);
        if(ret == JFileChooser.APPROVE_OPTION) return chooser.getSelectedFile();
        return null;
    }

    private static void createAndShowGUI() {
        // create and setup the window
        frame = new JFrame("Bildanalyse");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JComponent newContentPane = new Histo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);

        // display the window.
        frame.pack();
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Dimension screenSize = toolkit.getScreenSize();
        frame.setLocation((screenSize.width - frame.getWidth()) / 2, (screenSize.height - frame.getHeight()) / 2);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }

    private void resetImage() {
        // a new image has been laoded
        updateHistogram();
    }

    private void changeImage() {

        int pixels[] = imgViewOriginal.getPixels().clone();

        int brightness = brightnessSlider.getValue();
        double contrast = contrastSlider.getValue() / 20.0;
        double saturation = saturationSlider.getValue() / 20.0;

        for (int pos = 0; pos < pixels.length; pos++) {

            // get pixel
            int c = pixels[pos];

            // get RGB values
            int r = (c & 0xff0000) >> 16;
            int g = (c & 0x00ff00) >> 8;
            int b = (c & 0x0000ff);

            // Farbtransformation von RGB zu YCbCr
            double Y = 0.299 * r + 0.587 * g + 0.114 * b;
            double Cb = -0.168736 * r - 0.331264 * g + 0.5 * b;
            double Cr = 0.5 * r - 0.418688 * g - 0.081312 * b;

            // Kontrast
            Y = contrast * (Y - 128) + 128;

            // Helligkeit
            Y = Y + brightness;

            // Sättigung
            Cb = Cb * saturation;
            Cr = Cr * saturation;

            // Farbtransformation von YCbCr zu RGB
            r = (int)(Y + 1.402 * Cr);
            g = (int)(Y - 0.3441 * Cb - 0.7141 * Cr);
            b = (int)(Y + 1.772 * Cb);

            // Überlauf verhindern
            r = (r > 255) ? 255 : ((r < 0) ? 0 : r);
            g = (g > 255) ? 255 : ((g < 0) ? 0 : g);
            b = (b > 255) ? 255 : ((b < 0) ? 0 : b);

            // restore pixel
            pixels[pos] = 0xFF000000 + ((r & 0xff) << 16) + ((g & 0xff) << 8) + (b & 0xff);
        }

        imgView.setPixels(pixels);

        updateHistogram();
    }

    private void updateHistogram() {

        drawHistogram();

        updateText();
    }

    private void updateText() {

        imgBorder.setTitle(filename);

        /*
        label[0].setText("Maximum: " + maxValue);
        label[1].setText("Mittelwert: " + format(avgValue, 2));
        label[2].setText("Minimum: " + minValue);
        label[3].setText("Varianz: " + format(varValue, 2));
        label[4].setText("Median: " + mdnValue);
        label[5].setText("Entropie: " + format(entValue, 2));
        */
        label[0].setText("Maxium:");
        label[1].setText("" + maxValue);
        label[2].setText("Mittelwert:");
        label[3].setText(format(avgValue, 2));
        label[4].setText("Minimum:");
        label[5].setText("" + minValue);
        label[6].setText("Varianz:");
        label[7].setText(format(varValue, 2));
        label[8].setText("Median:");
        label[9].setText("" + mdnValue);
        label[10].setText("Entropie:");
        label[11].setText(format(entValue, 2));
    }

    public String format(double x, int len) {
        double d = 1;

        for (int i = 0; i < len; i++) d *= 10;

        x = Math.round(x * d) / d;

        return Double.toString(x).replace('.', ',');
    }

    void drawHistogram() {

        // Statistische Größen initialisieren
        minValue = 255;
        maxValue = 0;
        avgValue = 0;

        // Helligkeitswerte
        int brightness[] = new int[256];

        // Anzahl aller Helligkeitswerte = 0 setzen
        Arrays.fill(brightness, 0);

        // maximaler Helligkeitswert
        int maxBrightness = 0;

        // Bild auslesen
        int imgPixels[] = imgView.getPixels();

        // Anzahl der Helligkeitswerte zählen
        for(int imgPos = 0; imgPos < imgPixels.length; imgPos++) {

            int argb = imgPixels[imgPos];

            int r = (argb >> 16) & 0xff;
            int g = (argb >> 8) & 0xff;
            int b = argb & 0xff;

            int color = (int)(0.299 * r + 0.587 * g + 0.114 * b);

            brightness[color]++;

            if(brightness[color] > maxBrightness) {

                maxBrightness = brightness[color];
            }

            if(color > maxValue) {

                maxValue = color;
            }
            if(color < minValue) {

                minValue = color;
            }
        }

        //
        //histoView = new ImageView(histWidth, imgView.getHeight());

        // Histogramm auslesen
        int histPixels[] = histoView.getPixels();

        // Histogramm initialisieren
        Arrays.fill(histPixels, 0xffffffff);

        // Histogramm zeichnen
        int histSize = 256;

        for(int x = 0; x < histSize; x++) {

            double factor = (double)brightness[x] / maxBrightness;

            avgValue += x * brightness[x];

            int maxY = (int)(histSize * factor);

            for(int y = 0; y < histSize; y++) {

                if(y >= (histSize - maxY)) {

                    int histPos = y * histSize + x;

                    histPixels[histPos] = 0xff000000;
                    //histPixels[histPos] = (0xff << 24) | (int)(Math.random() * 0xffffff);
                }
            }
        }

        // Statistische Größen berechnen
        avgValue = avgValue / imgView.getPixels().length;

        // Median bestimmen
        int mid = (int)(imgPixels.length / 2);

        for(int x = 0; x < histSize; x++) {

            for(int i = 0; i < brightness[x]; i++) {

                if(mid == 0) {

                    mdnValue = x;

                    break;
                }

                mid--;
            }

            if(mid == 0) break;
        }

        // Graukeil zeichnen
        for (int x = 0; x < histSize; x++) {

            for(int y = 257; y < histHeight; y++) {

                int color = (0xff << 24) | (x << 16) | (x << 8) | x;

                histPixels[y * histSize + x] = color;
            }
        }

        // Histogramm aktualisieren
        histoView.applyChanges();
    }
}