@PluginInfo(name="Flou Gaussien", category="Flou")
public class GaussianBlurPlugin extends GenericAppImagePlugin {

	public GaussianBlurPlugin() {
		setPluginName("Gaussian Blur");
		setLongProcessing(true);
		setRefreshable(true);
		setCacheable(true);
		addParameter(new IntSliderParameter("rayon", "Rayon", 0,10,0));
		addParameter(new DoubleTextFieldParameter("sigma", "Sigma", 1));
		
	}
	@Override
	public BufferedImage filter() throws Exception {
		Kernel k = PredefinedKernel.getGaussianKernel(getIntValue("rayon"), getDoubleValue("sigma"));
		ConvolveOperator op = new ConvolveOperator(k, new BorderExtenderCopy());
		return op.compute(getInputImage());
		
	}
}

public MonFiltre() {
		ComboBoxParameter p = new ComboBoxParameter("convolve", "Type de convolution");
		p.addItem("laplace", "Laplacien");
		p.addItem("sobelV", "Sobel Vertical");
		p.addItem("sobelH", "Sobel Horizontal");
		p.addItem("prewittH", "Prewitt Horizontal");
		p.addItem("prewittW", "Prewitt Vertical");
		p.addItem("mdif", "MDIF");
		p.addItem("mediumSmooth", "Medium Smooth");
		
		addParameter(p);
}

String convolve = getStringValue("convolve"); //clef convolve
		if(convolve.equals("laplace")) //clef laplace
			//code métier

public MonFiltre() {
  addParameter(new CheckBoxParameter("border", "Border Extender", false));
}

					
if(getBooleanValue("border"))				
  //traitement

					
addParameter(new IntTextFieldParameter("window", "Half-Window size", 1));

			
//pour récuperer la valeur		
int window = getIntValue("window");

					
addParameter(new DoubleSliderParameter("sigma", "Sigma", 0.0, 50.0, 0.1, 0.0));

					
double sigma = getDoubleValue("sigma");

					
addParameter(new IntSliderParameter("sigma", "Sigma", 0, 50, 20));

	
RadioButtonGroupParameter p = new RadioButtonGroupParameter("radio", "Sélection canal à griser");
p.addItem("all", "Aucun");
p.addItem("red", "Rouge");
p.addItem("green", "Vert");
p.addItem("blue", "Bleu");
addParameter(p);				

String color = getStringValue("radio");
if(color.equals("red"))
 //...	

addParameter(new ImageParameter("image", "Sélectionner une image");	

BufferedImage imageChoisie = getImageValue("image");

addParameter(new ColorParameter("color", "Couleur Masque", COLOR.BLACK);	

Color color = getColorValue("color");

addParameter(new FileParameter("fichier", "Nom du fichier", {"jpg", "png"}, Mode.FILES);	
addParameter(new FileParameter("folder", "Nom du dossier",Mode.FOLDERS);	

File file = getFileValue("fichier");

 
@PluginInfo(name="Gray Filter", "Couleurs")
public class GrayFilter extends GenericAppImagePlugin {
	String getLabel(String key) {
		return MillieGUIProperties.getLabel(key);
	}
	
	public GrayFilter() {
		setPluginName(getLabel("gray.title"));
		setRefreshable(true);
		setCacheable(true);
		
		RadioButtonGroupParameter p = new RadioButtonGroupParameter("radio", getLabel("gray.title"));
		p.addItem("all", getLabel("gray.all"));
		p.addItem("red", getLabel("gray.red"));
		p.addItem("green", getLabel("gray.green"));
		p.addItem("blue", getLabel("gray.blue"));
		addParameter(p);
	}

	@Override
	public BufferedImage filter() throws Exception {
		
		BufferedImage output = new BufferedImage(getInputImage().getWidth(), getInputImage().getHeight(), getInputImage().getType());
		
		String color = getStringValue("radio");
		
		for(int y=0; y<output.getHeight(); y++)
			for(int x=0; x<output.getWidth(); x++) {
				int rgb = getInputImage().getRGB(x, y);
				int rgbOut = 0;
				
				if(color.equals("red"))
					rgbOut = (rgb>>16)&0xFF;
				if(color.equals("green"))
					rgbOut = (rgb>>8)&0xFF;
				if(color.equals("blue"))
					rgbOut = (rgb>>0)&0xFF;
				if(color.equals("all"))
					rgbOut = (int)((0.30 * ((rgb >> 16) & 0xff) + 
								0.59 * ((rgb >> 8) & 0xff) + 
								0.11 * (rgb & 0xff)));
				rgbOut =  (rgbOut << 16) + (rgbOut << 8) + (rgbOut << 0);
				
				output.setRGB(x, y, rgbOut);
			}
		
		return output;
	}

}

 
@PluginInfo(name="HSL Filter", "Couleurs")
public class HSLFilter extends GenericAppImagePlugin {
	private String getLabel(String key) {
		return MillieGUIProperties.getLabel(key);
	}
	
	BufferedImage output;
	/**
	 * On ajoute des caches qui contient les couleurs HSL de l'image d'entrée pour éviter de recalculer à chaque fois
	 * les couleurs HSL
	 */
	double[][] cacheH;
	double[][] cacheS;
	double[][] cacheL;
	
	
	public HSLFilter() {
		setRefreshable(true);
		setReinitializable(true);
		setPluginName(getLabel("hsl.title"));
		
		ComboBoxParameter choice = new ComboBoxParameter("type", getLabel("hsl.visualisation"));
		choice.addItem("all", getLabel("hsl.all"));
		choice.addItem("l", getLabel("hsl.l"));
		choice.addItem("s", getLabel("hsl.s"));
		choice.addItem("h", getLabel("hsl.h"));
		
		addParameter(choice);
		addParameter(new IntSliderParameter("s", getLabel("hsl.s"), -100,100,0));
		addParameter(new IntSliderParameter("l", getLabel("hsl.l"), -100,100,0));
		addParameter(new IntSliderParameter("h", getLabel("hsl.h"), -180,180,0));
	}
	
	public void setup() {
		output = new BufferedImage(getInputImage().getWidth(),
				 getInputImage().getHeight(),
				 getInputImage().getType());
		cacheH = new double[output.getWidth()][ output.getHeight()];
		cacheS = new double[output.getWidth()][ output.getHeight()];
		cacheL = new double[output.getWidth()][ output.getHeight()];
		
		double[] hsl = new double[3];
		for(int j=0; j<output.getHeight(); j++)
			for(int i=0; i<output.getWidth();i++) {
				int rgb = getInputImage().getRGB(i, j);
				
				ColorUtils.RGBToHSL(rgb, hsl);
				cacheH[i][j] = hsl[0];
				cacheS[i][j] = hsl[1];
				cacheL[i][j] = hsl[2];
			}
	}
	

	
	@Override
	public BufferedImage filter() throws Exception {
		int h = getIntValue("h");
		int s = getIntValue("s")/5; //change un peu les valeurs pour ne pas trop modifier d'un coup l'image.
		int l = getIntValue("l")/2;
		
		String type = getStringValue("type");
		double sMaxFactor = 5;
		double lMaxFactor = 1;
		double[] hsl = new double[3];
		
		for(int j=0; j<output.getHeight(); j++)
			for(int i=0; i<output.getWidth();i++) {
				
				hsl[0] = cacheH[i][j]; //on récupère du cache les valeurs HSL
				hsl[1] = cacheS[i][j];
				hsl[2] = cacheL[i][j];
				
				hsl[0] = ((hsl[0] + h)%360);
				
				//on recalcule les valeurs HSL
				if(s>=0)
					hsl[1]*= (sMaxFactor*(s/100.0) +1); 
				else
					hsl[1]/= (sMaxFactor*(-s/100.0)+1);
				
				if(l>=0)
					hsl[2] *= lMaxFactor*(l/100.0) +1;
				else
					hsl[2] /= (lMaxFactor*(-l/100.0) +1);
				
				
				hsl[1]  = between01(hsl[1] );
				hsl[2]  = between01(hsl[2] );
				
				int hslColor = 0;
				
				//suivant le type de visualisation, on écrit la couleur que l'on souhaite
				if(type.equals("all"))
					hslColor = ColorUtils.HSLToRGB(hsl);
				if(type.equals("l"))
					hslColor = ColorUtils.getGrayColor((int) (hsl[2]*255.0)); 
				if(type.equals("s"))
					hslColor = ColorUtils.getGrayColor((int) (hsl[1]*255.0)); 
				if(type.equals("h"))
					hslColor = ColorUtils.HSLToRGB(new double[]{hsl[0], 0.5, 0.5}); //ColorUtils.getGrayColor((int) (hsl[0]*255.0/360.0)); 
				
				
				output.setRGB(i, j, hslColor);
			}
		
		return output;
	}
	
	double between01(double t) {
		if(t<0) return 0;
		if(t>1) return 1;
		return t;
	}

}

 
@PluginInfo(name="UnNoise", "Restauration")
public class UnNoisePlugin extends GenericAppPluginImage {
	
	public UnNoisePlugin() {
		setPluginName("UnNoise Filter");
		setLongProcessing(true);
		
		ComboBoxParameter p = new ComboBoxParameter("estimator", "Type d'estimation");
		p.addItem("road", "Road");
		p.addItem("variance", "Variance");
		
		addParameter(p);
		addParameter(new IntSliderParameter("aperture", "Ouverture fenêtre", 1, 20, 2));
		addParameter(new DoubleSliderParameter("variance", "Facteur variance", 0.0, 10.0, 0.1, 1.0));
		addParameter(new IntSliderParameter("it", "Itérations", 1,30, 5));
		
	}
	
	@Override
	public BufferedImage filter() throws Exception {
		String estimator = getStringValue("estimator");
		int estimatorI;
		if(estimator.equals("road"))
			estimatorI = UnNoiseOperator.ROAD;
		else 
			estimatorI = UnNoiseOperator.VARIANCE;
		
		int aperture = getIntValue("aperture");
		double variance = getDoubleValue("variance");
		int it = getIntValue("it");
		
		UnNoiseOperator op = new UnNoiseOperator(estimatorI, aperture, variance, it);
			
		Image input = ImageConverter.convert(getInputImage());
		Image out = new Image(input.getNumComponents());
		op.compute(out, input);
		
		return ImageConverter.convert(out);
	}

}
	

 
	@PluginInfo(name="Flou Local", category="Flou")
public class LocalBlurPlugin extends AreaAppImagePlugin {
    Kernel kernel;
    
	public LocalConvolvePlugin() {
		kernel = PredefinedKernel.WEAK_BLUR;
		addRayonParameter("Rayon", 1, 50);
	}
	
	double square(double a) {
		return a*a;
	}
	

	@Override
	public void filter(BufferedImage input) throws Exception {
		int x = getX();
		int y = getY();
		int rayon = getRayonParameter();
		
		int leftpadding = kernel.getLeftPadding();
		int rightpadding = kernel.getRightPadding();
		int toppadding = kernel.getTopPadding();
		int bottompadding = kernel.getBottomPadding();
		
		int[][] colors = new int[2*rayon+1][2*rayon+1];
		
		for(int dx=x-rayon; dx<x+rayon; dx++)
			for(int dy=y-rayon; dy<y+rayon; dy++) {
				//hors du champ
				if(dx<leftpadding || dx>= input.getWidth() - rightpadding|| dy<toppadding || dy>=input.getHeight()-bottompadding) //si hors des bords, on continue
					continue;
				if(square(dx-x)+square(dy-y)>square(rayon)) //hors du cercle
					continue;
				double r = 0;
				double g = 0;
				double b = 0;
				
				//calcul de la convolution dans le point
				for (int kj = 0; kj < kernel.getHeight(); kj++)
					for (int ki = 0; ki < kernel.getWidth(); ki++) {
						int currentX = dx + ki - kernel.getXOrigin();
						int currentY = dy + kj	- kernel.getYOrigin();
						int rgb = input.getRGB(currentX, currentY);
						
						r += kernel.getElement(ki, kj) * ((rgb>>16)&0xFF);
						g += kernel.getElement(ki, kj) * ((rgb>>8)&0xFF);
						b += kernel.getElement(ki, kj) * ((rgb>>0)&0xFF);
					}
				int dR = (int) r;
				int dG = (int) g;
				int dB = (int) b;
				if(dR>255) dR=255; if(dR<0) dR=0;
				if(dG>255) dG=255; if(dG<0) dG=0;
				if(dB>255) dB=255; if(dB<0) dB=0;
				
				int out = (dR<<16)+(dG<<8)+dB;
				colors[dx-x+rayon][dy-y+rayon] = out;
				
			}
		//on remet les couleurs du buffer dans l'image
		for(int dx=x-rayon; dx<x+rayon; dx++)
			for(int dy=y-rayon; dy<y+rayon; dy++) {
				if(dx<leftpadding || dx>= input.getWidth() - rightpadding|| dy<toppadding || dy>=input.getHeight()-rightpadding) //si hors des bords, on continue
					continue;
				if(square(dx-x)+square(dy-y)>square(rayon)) //hors du cercle
					continue;
				input.setRGB(dx, dy, colors[dx-x+rayon][dy-y+rayon]);
			}
	}

}

	

 					
@PluginInfo(name="Crop", category="crop")
public class CropFilter extends RectangularAppImagePlugin {
	public CropFilter() {
		setPluginName(MillieGUIProperties.getLabel("crop.title"));
	}

	@Override
	public BufferedImage filter() throws Exception {
		BufferedImage input = getInputImage();
		int newWidth = getEndX()-getStartX();
		int newHeight = getEndY()-getStartY();
		
		BufferedImage output = new BufferedImage(newWidth, newHeight, input.getType());
		Graphics2D g = output.createGraphics();
		g.drawImage(input, 0, 0, newWidth, newHeight, getStartX(), getStartY(), getEndX(), getEndY(), null);		
		g.dispose();
		
		return output;
		
	}

 			
    @PluginInfo(name="Dilatation", cateogyr="Morphologique")		
	public class DilatePlugin extends NoParameterAppImagePlugin {

	@Override
	public BufferedImage filter(BufferedImage input) throws Exception {
		Image in = ImageConverter.convert(input);
		Image out = ImageConverter.convert(getInputImage());
		DilateOperator op = new DilateOperator(new BorderExtenderCopy());
	
		op.compute(out, in);
		
		return ImageConverter.convert(out);
		
	}
}

 			
@PluginInfo(name="Automate sur dossier", category="Automation")
public class AutomateFolderPlugin extends AppPlugin {
	private Map<String, Automate> caches = new HashMap<String, Automate>();
	static private Logger logger = LoggerManager.getLogger();
	
	public AutomateFolderPlugin() {
		addParameter(new FileParameter("folder", "Dossier", Mode.FOLDERS));
		addParameter(new FileParameter("output", "Dossier de sortie", Mode.FOLDERS));
		
		setLongProcessing(true);
		List<Automate> automates = AutomateManager.getInstance().listAll();
		if(automates.size()==0) {
			throw new IllegalStateException("Aucun automate enregistré");
		}
		
		ComboBoxEntry[] entries = new ComboBoxEntry[automates.size()];
		int pos = 0;
		for(Automate automate : automates) {
			caches.put(automate.getName(), automate);
			ComboBoxEntry entry = new ComboBoxEntry(automate.getName(), automate.getName());
			entries[pos] = entry;
			pos++;
		}
		
		addParameter(new ComboBoxParameter("script", "Choix du script", entries));
		
		setWithMultipleExecution(true);
	}
	
	@Override
	public void cancel() throws Exception {
	}

	@Override
	public void execute() throws Exception {
		File folder = getFileValue("folder");
		File output = getFileValue("output");
		String script = getStringValue("script");
		
		if(folder.isFile()&&!output.isFile() || !folder.isFile() && output.isFile()) {
			throw new IllegalArgumentException("Dossier d'entrée et de sortie pas du même type");
		}
		
		File[] files = null;
		if(folder.isFile()) {
			files = new File[]{folder};
		}
		else {
			files = folder.listFiles();
		}
		int progress = (int) (100.f/files.length);
		notifyProgress(progress);
		
		for(File f : files) {
			logger.info("Treat file " + f);
			BufferedImage input = javax.imageio.ImageIO.read(f);
			ImageBean imageBean = new ImageBean();
			imageBean.setBufferedImage(input);
			imageBean.setFile(f);
			imageBean.setFileName(f.getName());
			
			Automate automate = caches.get(script);
			
			FakeAppImageActions actions = new FakeAppImageActions();
			
			actions.setImageBean(imageBean);
			
			automate.setAppImageActions(actions);
			automate.setMessageManager(getMessageManager());
			automate.setAppImageEventsManager(new FakeAppImageEventsManager());
			
			automate.execute();
			
			BufferedImage imoutput = imageBean.getBufferedImage();
			if(output.isFile()) {
				ImageIO.write(imoutput, MillieUtils.getFormat(output.getName()), output);
			}
			else {
				String[] tokens = f.getName().split("\\.");
				if(tokens.length!=2)
					throw new IllegalArgumentException("Fichier avec un point");
				
				File file = new File(output.getAbsolutePath() + "/" + tokens[0] + "_t."+ tokens[1]);
				ImageIO.write(imoutput, tokens[1], file);
			}
			
			progress+= (int) (100.f/files.length);
			notifyProgress(progress);
		}
	}

	@Override
	public void finish() throws Exception {
	}
}