import ij.IJ;
import ij.ImageJ;
import ij.ImagePlus;
import ij.gui.GenericDialog;
import ij.plugin.filter.PlugInFilter;
import ij.process.ImageProcessor;
import java.util.*;


public class Process_Pixels implements PlugInFilter {

    public ImagePlus imp;
    public double radiusd;
    public int radius;
    public boolean dialogCanceled = false;

    @Override
    public int setup(String arg, ImagePlus imp) {
        this.imp = imp;
        return DOES_ALL;
    }

    @Override
    public void run(ImageProcessor ip) {
        doDialog();
        if (dialogCanceled) return;
        int height = ip.getHeight();
        int width = ip.getWidth();

        List<Integer> rMedianZeroList = new ArrayList<Integer>();
        List<Integer> rMedianOneList = new ArrayList<Integer>();
        List<Integer> rMedianTwoList = new ArrayList<Integer>();
        List<Integer> rMedianThreeList = new ArrayList<Integer>();
        List<Integer> rMedianFourList = new ArrayList<Integer>();

        List<Integer> gMedianZeroList = new ArrayList<Integer>();
        List<Integer> gMedianOneList = new ArrayList<Integer>();
        List<Integer> gMedianTwoList = new ArrayList<Integer>();
        List<Integer> gMedianThreeList = new ArrayList<Integer>();
        List<Integer> gMedianFourList = new ArrayList<Integer>();

        List<Integer> bMedianZeroList = new ArrayList<Integer>();
        List<Integer> bMedianOneList = new ArrayList<Integer>();
        List<Integer> bMedianTwoList = new ArrayList<Integer>();
        List<Integer> bMedianThreeList = new ArrayList<Integer>();
        List<Integer> bMedianFourList = new ArrayList<Integer>();

        int maxR, maxG, maxB;
        int minR, minG, minB;
        int posX, posY;

        int[] RGB = new int[3];
        int[] mRGB = new int[3];
        ImageProcessor copy = ip.duplicate();
        radius = (int) radiusd;
        int k = ((radius*2)+1)/2;

        // Pętla odpowiadające do chodzenia po obrazie
        for(int x = 0; x < width; x ++){
            for(int y = 0; y < height; y++){
                // Czyszczenie list median
                rMedianZeroList.clear();
                gMedianZeroList.clear();
                bMedianZeroList.clear();
                rMedianOneList.clear();
                gMedianOneList.clear();
                bMedianOneList.clear();
                rMedianTwoList.clear();
                gMedianTwoList.clear();
                bMedianTwoList.clear();
                rMedianThreeList.clear();
                gMedianThreeList.clear();
                bMedianThreeList.clear();
                rMedianFourList.clear();
                gMedianFourList.clear();
                bMedianFourList.clear();

                copy.getPixel(x, y, mRGB);  // AKTUALNY PIKSEL

                // Wypełnienie list median
                posX = radius * (-1);
                for(int xx = 0; xx < (radius*2)+1; xx++){
                    posY = radius * (-1);
                    for(int yy = 0; yy < (radius*2)+1; yy++){
                        if(x+posX >= 0 && y+posY>=0 && x+posX <= width && y+posY <= height) { // Jeżeli piksel macierzy sąsiedztwa znajduje się na obrazie
                            copy.getPixel((x + posX), (y + posY), RGB);
                            // Median Zero
                            rMedianZeroList.add(RGB[0]);
                            gMedianZeroList.add(RGB[1]);
                            bMedianZeroList.add(RGB[2]);
                            // Median One
                            if (xx == k) {
                                rMedianOneList.add(RGB[0]);
                                gMedianOneList.add(RGB[1]);
                                bMedianOneList.add(RGB[2]);
                            }
                            // Median Two
                            if (yy == k) {
                                rMedianTwoList.add(RGB[0]);
                                gMedianTwoList.add(RGB[1]);
                                bMedianTwoList.add(RGB[2]);
                            }
                            // Median Three
                            if (xx == yy) {
                                rMedianThreeList.add(RGB[0]);
                                gMedianThreeList.add(RGB[1]);
                                bMedianThreeList.add(RGB[2]);
                            }
                            // Median Four
                            if ((radius * 2) - xx == yy) {
                                rMedianFourList.add(RGB[0]);
                                gMedianFourList.add(RGB[1]);
                                bMedianFourList.add(RGB[2]);
                            }
                        }
                        posY++;
                    }
                    posX++;
                }

                // Obliczenie MIN / MAX
                maxR = Math.max(median(rMedianOneList), Math.max(median(rMedianTwoList), Math.max(median(rMedianThreeList), median(rMedianThreeList))));
                minR = Math.min(median(rMedianOneList), Math.max(median(rMedianTwoList), Math.max(median(rMedianThreeList), median(rMedianThreeList))));
                maxG = Math.max(median(gMedianOneList), Math.max(median(gMedianTwoList), Math.max(median(gMedianThreeList), median(gMedianThreeList))));
                minG = Math.min(median(gMedianOneList), Math.max(median(gMedianTwoList), Math.max(median(gMedianThreeList), median(gMedianThreeList))));
                maxB = Math.max(median(bMedianOneList), Math.max(median(bMedianTwoList), Math.max(median(bMedianThreeList), median(bMedianThreeList))));
                minB = Math.min(median(bMedianOneList), Math.max(median(bMedianTwoList), Math.max(median(bMedianThreeList), median(bMedianThreeList))));

                // Ostateczny wybór wartości
                if(Math.abs(maxR - median(rMedianZeroList)) >= Math.abs(median(rMedianZeroList) - minR)){
                    RGB[0] = maxR;
                }else{
                    RGB[0] = minR;
                }

                if(Math.abs(maxG - median(gMedianZeroList)) >= Math.abs(median(gMedianZeroList) - minG)){
                    RGB[1] = maxG;
                }else{
                    RGB[1] = minG;
                }

                if(Math.abs(maxB - median(gMedianZeroList)) >= Math.abs(median(gMedianZeroList) - minB)){
                    RGB[2] = maxB;
                }else{
                    RGB[2] = minB;
                }

                // Wstawienie zmienionego piksela do obrazu
                ip.putPixel(x, y, RGB);
            }
        }
    }

    public void doDialog() {
        GenericDialog gd = new GenericDialog("Lab 5");
        gd.addNumericField("Podaj wartość promienia: ", 0, 0);
        gd.showDialog();
        radiusd = gd.getNextNumber();
    }

    public Integer median(List<Integer> values){
        Collections.sort(values);
        if(values.size() % 2 ==  1) {
            return values.get((values.size())/2);
        }else{
            int upper = values.get((values.size())/2);
            int lower = values.get((values.size()/2)-1);
            return (upper+lower)/2;
        }
    }
    public static void main(String[] args) {
        // set the plugins.dir property to make the plugin appear in the Plugins menu
        Class<?> clazz = Process_Pixels.class;
        String url = clazz.getResource("/" + clazz.getName().replace('.', '/') + ".class").toString();
        String pluginsDir = url.substring("file:".length(), url.length() - clazz.getName().length() - ".class".length());
        System.setProperty("plugins.dir", pluginsDir);

        // start ImageJ
        new ImageJ();

        // open the Lena sample
        ImagePlus image = IJ.openImage("http://imagej.nih.gov/ij/images/lena-std.tif");
        image.show();

        // run the plugin
        IJ.runPlugIn(clazz.getName(), "");
        System.out.print("Koniec");
    }
}