import ij.IJ;
import ij.ImageJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.gui.ImageCanvas;
import ij.gui.ImageWindow;
import ij.plugin.PlugIn;
import ij.process.ImageProcessor;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Panel;

import javax.swing.BorderFactory;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.border.TitledBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
 * Opens an image window and adds a panel below the image
 */
public class GRDM_U2_S0531722 implements PlugIn {

    ImagePlus imp; // ImagePlus object
    private int[] origPixels;
    private int width;
    private int height;

    public static void main(String args[]) {
        //new ImageJ();
        IJ.open("D:/Downloads/ij144/ImageJ/plugins/Pictures/orchid.jpg");
        //IJ.open("Z:/Pictures/Beispielbilder/orchid.jpg");

        GRDM_U2_S0531722 pw = new GRDM_U2_S0531722();
        pw.imp = IJ.getImage();
        pw.run("");
    }

    public void run(String arg) {
        if (imp == null)
            imp = WindowManager.getCurrentImage();
        if (imp == null) {
            return;
        }
        CustomCanvas cc = new CustomCanvas(imp);

        storePixelValues(imp.getProcessor());

        new CustomWindow(imp, cc);
    }

    private void storePixelValues(ImageProcessor ip) {
        width = ip.getWidth();
        height = ip.getHeight();

        origPixels = ((int[]) ip.getPixels()).clone();
    }

    class CustomCanvas extends ImageCanvas {

        CustomCanvas(ImagePlus imp) {
            super(imp);
        }

    } // CustomCanvas inner class

    class CustomWindow extends ImageWindow implements ChangeListener {

        private JSlider jSliderBrightness;
        private JSlider jSlider2;
        private JSlider jSlider3;
        private JSlider jSlider4;
        private double brightness;
        private double kontrast=1.0d;
        private double sättigung=1.0d;
        private double hue;

        CustomWindow(ImagePlus imp, ImageCanvas ic) {
            super(imp, ic);
            addPanel();
        }

        void addPanel() {
            // JPanel panel = new JPanel();
            Panel panel = new Panel();

            panel.setLayout(new GridLayout(4, 1));
            jSliderBrightness = makeTitledSilder("Helligkeit", -28, 228, 64); // (str,minValue,MaxValue,default-Wert
            jSlider2 = makeTitledSilder("Kontrast", 0, 100, 0);
            jSlider3 = makeTitledSilder("Sättigungt", 0, 50, 0);
            jSlider4 = makeTitledSilder("Hue", 0, 360, 0);
            panel.add(jSliderBrightness);
            panel.add(jSlider2);
            panel.add(jSlider3);
            panel.add(jSlider4);

            add(panel);

            pack();
        }

        private JSlider makeTitledSilder(String string, int minVal, int maxVal,
                int val) {

            JSlider slider = new JSlider(JSlider.HORIZONTAL, minVal, maxVal,
                    val);
            Dimension preferredSize = new Dimension(width, 50);
            slider.setPreferredSize(preferredSize);
            TitledBorder tb = new TitledBorder(
                    BorderFactory.createEtchedBorder(), string,
                    TitledBorder.LEFT, TitledBorder.ABOVE_BOTTOM, new Font(
                            "Sans", Font.PLAIN, 11));
            slider.setBorder(tb);
            slider.setMajorTickSpacing((maxVal - minVal) / 10);
            slider.setPaintTicks(true);
            slider.addChangeListener(this);

            return slider;
        }

        private void setSliderTitle(JSlider slider, String str) {
            TitledBorder tb = new TitledBorder(
                    BorderFactory.createEtchedBorder(), str, TitledBorder.LEFT,
                    TitledBorder.ABOVE_BOTTOM, new Font("Sans", Font.PLAIN, 11));
            slider.setBorder(tb);
        }

        // stellt die Intervalle der jeweiligen Slider dar

        public void stateChanged(ChangeEvent e) {
            JSlider slider = (JSlider) e.getSource();

            // Slider : helligkeit

            if (slider == jSliderBrightness) {
                brightness = slider.getValue() - 100;
                String str = "Helligkeit :" + brightness;
                setSliderTitle(jSliderBrightness, str);
            }

            // Slider : Kontrast

            if (slider == jSlider2) {
                kontrast =(slider.getValue() / 10.0d);
                String str = "Kontrast :" + kontrast;
                setSliderTitle(jSlider2, str);
            }

            // Slider Sättigung

            if (slider == jSlider3) {
                sättigung = slider.getValue()/10.0d; // casten zu
                                                                // float und                                                // weden
                String str = "Sättigung :" + sättigung;
                setSliderTitle(jSlider3, str);
            }

            // Slider : Hue bzw Farbton

            if (slider == jSlider4) {
                hue = slider.getValue();
                String str = "Hue :" + hue+"°";
                setSliderTitle(jSlider4, str);
            }

            changePixelValues(imp.getProcessor());

            imp.updateAndDraw();
        }

        // Methode zur Farbtransformation bzw inversen Transformation

        private void changePixelValues(ImageProcessor ip) {

            // Array fuer den Zugriff auf die Pixelwerte
            int[] pixels = (int[]) ip.getPixels();

            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    int pos = y * width + x;
                    int argb = origPixels[pos]; // Lesen der Originalwerte

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

            // Transformation von RGB -> 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 und  Brightness:
            Kontrast und Hellugkeit werden zusammen berechnet. Die Formel ergibt sich
            aus den beiden jeweiligen Geradengleichungen für Kontrast und Helligkeit:
            f(x) = (x-128) und f(x)= 128 + h. X ist hierbei die Pixelintensität,also die
            Luminanz.Der Wert 128 beschreibt den Mittelwert der Intensität des Bildes.
            Der Kontrast beschreibt den Unterschied zwischen Hell-und Dunkelbereichen. Demnach
            ist der Kontrast größer, je höher der Abstand zwischen den Bereichen wird.

            Hue und Sättigung:
            Mithilfer der Fabrdrehung lässt sich die Sättigung und der Farbton(hue) errechnen.
            Hierbei bleibt der Winkel konstant. Die Formel der Farbdrehung lautet :
            [CbNeu] = [ cos(Alpha) + sin(Alpha)] * [ Cb]
            [CrNeu] = [ -sin(Alpha) + cos(Alpha)] * [Cr]
            Wenn man die beiden Vektoren nun miteinander ausmultipliziert, ergibt sich die
            Formel, wie im Code. Der Winkel ist hierbei der Farbton(hue).
            Wir multiplizieren anschließend mit der Sättigung, um die Sättigung zu erhöhen. */

            double Yneu = kontrast * ( Y - 128) + 128 + brightness;
            double Cbneu = ((Math.cos(hue)* Cb) + (Math.sin(hue)* Cr)*sättigung);
            double Crneu = ((-Math.sin(hue)*Cb)+ (Math.cos(hue)*Cr)*sättigung);

            // Rücktransformation von YCbCr -> RGB
            double rn = (Yneu + 1.402 * Crneu);
            double gn = (Yneu - 0.3441*Cbneu - 0.7141*Crneu);
            double bn = (Yneu + 1.772*Cbneu);



                    // für R
                    if (r > 255) {
                        r = 255;
                    }
                    if (r < 0) {
                        r = 0;
                    }


                    // für G
                    if (g > 255) {
                        g = 255;
                    }
                    if (g < 0) {
                        g = 0;
                    }


                    // für B
                    if (b > 255) {
                        b = 255;
                    }
                    if (b < 0) {
                        b = 0;
                    }


                    pixels[pos] = (0xFF << 24) | (r << 16) | (g << 8) | b;
                }
            }
        }

    } // CustomWindow inner class
}