Merge lp:projekt-programowanie into lp:projekt-programowanie/gui

[Jakub Brzeski]

Test of merging.

=== modified file '.bzrignore'
--- .bzrignore	2012-04-06 16:18:15 +0000
+++ .bzrignore	2012-04-17 18:42:22 +0000
@@ -1,7 +1,8 @@
 ./.idea
 ./target
-./manager.iml
 ./.classpath
 ./.project
 ./.settings
 ./.bzignore
+./bin
+./*.iml

=== modified file 'pom.xml'
--- pom.xml	2012-04-08 22:13:36 +0000
+++ pom.xml	2012-04-17 18:42:22 +0000
@@ -1,10 +1,10 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>manager</groupId>
     <artifactId>net.launchpad.projekt-programowanie</artifactId>
-    <version>0.1</version>
+    <version>0.5</version>
     <packaging>jar</packaging>
 
     <name>Menadżer plików i edytor grafiki</name>
@@ -15,6 +15,13 @@
         <powermock.version>1.4.12</powermock.version>
     </properties>
 
+    <repositories>
+        <repository>
+            <id>mandubian-mvn</id>
+            <url>http://mandubian-mvn.googlecode.com/svn/trunk/mandubian-mvn/repository</url>
+        </repository>
+    </repositories>
+
     <dependencies>
         <dependency>
             <groupId>junit</groupId>
@@ -46,6 +53,41 @@
             <version>${powermock.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.sun.mail</groupId>
+            <artifactId>javax.mail</artifactId>
+            <version>1.4.5</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.gdata</groupId>
+            <artifactId>gdata-client-1.0</artifactId>
+            <version>1.41.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.gdata</groupId>
+            <artifactId>gdata-client-meta-1.0</artifactId>
+            <version>1.41.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.gdata</groupId>
+            <artifactId>gdata-core-1.0</artifactId>
+            <version>1.41.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.gdata</groupId>
+            <artifactId>gdata-media-1.0</artifactId>
+            <version>1.41.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.gdata</groupId>
+            <artifactId>gdata-photos-2.0</artifactId>
+            <version>1.41.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.gdata</groupId>
+            <artifactId>gdata-photos-meta-2.0</artifactId>
+            <version>1.41.1</version>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

=== modified file 'src/main/java/manager/editor/ColorCMY.java'
--- src/main/java/manager/editor/ColorCMY.java	2012-04-09 18:10:58 +0000
+++ src/main/java/manager/editor/ColorCMY.java	2012-04-17 18:42:22 +0000
@@ -8,79 +8,79 @@
 	private float mCyan, mMagenta, mYellow;
 	
 	/**
-	 * @param C - kanał cyjan [0,255]
-	 * @param M - kanał purpura [0,255]
-	 * @param Y - kanał żółty [0,255]
+	 * @param mC - kanał cyjan [0,255]
+	 * @param mM - kanał purpura [0,255]
+	 * @param mY - kanał żółty [0,255]
 	 */
-	public ColorCMY(int C, int M, int Y){
-		setC(C);
-		setM(M);
-		setY(Y);
+	public ColorCMY(int mC, int mM, int mY){
+		setC(mC);
+		setM(mM);
+		setY(mY);
 	}
 	/**
-	 * @param C - kanał cyjan [0,1]
-	 * @param M - kanał purpura [0,1]
-	 * @param Y - kanał żółty [0,1]
+	 * @param mC - kanał cyjan [0,1]
+	 * @param mM - kanał purpura [0,1]
+	 * @param mY - kanał żółty [0,1]
 	 */
-	public ColorCMY(float C, float M, float Y){
-		setC(C); 
-		setM(M); 
-		setY(Y);
+	public ColorCMY(float mC, float mM, float mY){
+		setC(mC); 
+		setM(mM); 
+		setY(mY);
 	}
 	
 	/**
 	 * @return kanał cyjan [0,1]
 	 */
-	public float getC(){return mCyan;}
+	public final float getC(){return mCyan;}
 	/**
 	 * @return kanał purpura [0,1]
 	 */
-	public float getM(){return mMagenta;}
+	public final float getM(){return mMagenta;}
 	/**
 	 * @return kanał żółty [0,1]
 	 */
-	public float getY(){return mYellow;}
+	public final float getY(){return mYellow;}
 	
 	/**
 	 * Ustawia wartość kanału cyjanu
-	 * @param C - kanał cyjan [0,1]
+	 * @param mC - kanał cyjan [0,1]
 	 */
-	public void setC(float C){
-		mCyan = Math.max(0.0f, Math.min(1.0f, C));
+	public final void setC(float mC){
+		mCyan = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mC));
 	}
 	/**
 	 * Ustawia wartość kanału purpury
-	 * @param M - kanał purpury [0,1]
+	 * @param mM - kanał purpury [0,1]
 	 */
-	public void setM(float M){
-		mMagenta = Math.max(0.0f, Math.min(1.0f, M));
+	public final void setM(float mM){
+		mMagenta = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mM));
 	}
 	/**
 	 * Ustawia wartość kanału żółtego
-	 * @param B - kanał żółty [0,1]
+	 * @param mY - kanał żółty [0,1]
 	 */
-	public void setY(float Y){
-		mYellow = Math.max(0.0f, Math.min(1.0f, Y));
+	public final void setY(float mY){
+		mYellow = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mY));
 	}
 	/**
 	 * Ustawia wartość kanału cyjanu
-	 * @param C - kanał cyjan [0,255]
+	 * @param mC - kanał cyjan [0,255]
 	 */
-	public void setC(int C){
-		mCyan = Math.max(0.0f, Math.min(255.0f, (float)C/255.0f));
+	public final void setC(int mC){
+		mCyan = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, (float)mC/ColorConverter.RGBCMY_BYTE_MAX));
 	}
 	/**
 	 * Ustawia wartość kanału purpury
-	 * @param M - kanał purpury [0,255]
+	 * @param mM - kanał purpury [0,255]
 	 */
-	public void setM(int M){
-		mMagenta = Math.max(0.0f, Math.min(255.0f, (float)M/255.0f));
+	public final void setM(int mM){
+		mMagenta = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, (float)mM/ColorConverter.RGBCMY_BYTE_MAX));
 	}
 	/**
 	 * Ustawia wartość kanału żółtego
-	 * @param Y - kanał żółty [0,255]
+	 * @param mY - kanał żółty [0,255]
 	 */
-	public void setY(int Y){
-		mYellow = Math.max(0.0f, Math.min(255.0f, (float)Y/255.0f));
+	public final void setY(int mY){
+		mYellow = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, (float)mY/ColorConverter.RGBCMY_BYTE_MAX));
 	}
 }
\ No newline at end of file

=== modified file 'src/main/java/manager/editor/ColorConverter.java'
--- src/main/java/manager/editor/ColorConverter.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/ColorConverter.java	2012-04-17 18:42:22 +0000
@@ -2,41 +2,82 @@
 
 /**
  * Klasa konwertująca pomiędzy przestrzeniami barw
+ * Próba stworzenia obiektu tej klasy nawet przy pomocy refleksji
+ * skończy się wyrzuceniem wyjątku <b>UnsupportedOperationException</b>
  * @author Patryk
  */
-public class ColorConverter {
+public final class ColorConverter {
+	/**
+	 * Stała opisuje precyzje porównywania floatów
+	 */
+	public static final float FLOAT_PRECISION = 0.00001f;
+	/**
+	 * Kąt pełny palety barw (Hue) służy do zapętlenia wartości (modulo)
+	 */
+	public static final int HUE_CHANNEL_PRECISION = 360;
+	/**
+	 * Kąt wyznaczający podział koła barw na podzbiory do konwersji RGB -> HSV i odwrotnie
+	 */
+	public static final float HUE_CIRCLE_SPLITTER = 60.0f;
+	/**
+	 * Maksymalna dopuszczalna wartość kanału barwy (Hue) zarówno w 
+	 * modelu barw jak i w bitmapie
+	 */
+	public static final float HUE_MAX = 359.999f;
+	/**
+	 * Maksymalna wartość kanałów RGB, CMY oraz SV (z modelu HSV) w modelach barw
+	 */
+	public static final float RGBCMY_FLOAT_MAX = 1.0f;
+	/**
+	 * Maksymalna wartość kanałów RGB i CMY w bitmapie
+	 */
+	public static final float RGBCMY_BYTE_MAX = 255.0f;
+	/**
+	 * Stosunek udziału koloru czerwonego w barwie wykrywanej przez ludzkie oko
+	 */
+	public static final float RED_LUMINOSITY = 0.21f;
+	/**
+	 * Stosunek udziału koloru zielonego w barwie wykrywanej przez ludzkie oko
+	 */
+	public static final float GREEN_LUMINOSITY =  0.71f;
+	/**
+	 * Stosunek udziału koloru niebieskiego w barwie wykrywanej przez ludzkie oko
+	 */
+	public static final float BLUE_LUMINOSITY = 0.07f;
+	
+	private ColorConverter(){throw new UnsupportedOperationException();};
 	/**
 	 * @param color - kolor z przestrzeni CMY
 	 * @return odpowiadający kolor z przestrzeni RGB
 	 */
 	public static ColorRGB cmyTOrgb(ColorCMY color){
-		return new ColorRGB(1.0f-color.getC(), 1.0f-color.getM(), 1.0f-color.getY());
+		return new ColorRGB(RGBCMY_FLOAT_MAX-color.getC(), RGBCMY_FLOAT_MAX-color.getM(), RGBCMY_FLOAT_MAX-color.getY());
 	}
 	/**
 	 * @param color - kolor z przestrzeni HSV
 	 * @return odpowiadający kolor z przestrzeni RGB
 	 */
 	public static ColorRGB hsvTOrgb(ColorHSV color){
-		float R=0,G=0,B=0,I,f,p,q,t;
-		float H = color.getH();
-		float S = color.getS();
-		float V = color.getV();
-		if(V == 0.0f) R=G=B=0.0f;
+		float mR=0,mG=0,mB=0,mI,f,p,q,t;
+		float mH = color.getH();
+		float mS = color.getS();
+		float mV = color.getV();
+		if(Math.abs(mV) < FLOAT_PRECISION) {mR=0.0f; mG=0.0f; mB=0.0f;}
 		else{
-		 H /= 60.0f;
-		 I = (int)Math.floor(H);
-		 f = H-I;
-		 p = V*(1.0f-S);
-		 q = V*(1.0f-(S*f));
-		 t = V*(1.0f-(S*(1.0f-f)));
-		 if (I==0) {R=V; G=t; B=p;}
-		 else if (I==1) {R=q; G=V; B=p;}
-		 else if (I==2) {R=p; G=V; B=t;}
-		 else if (I==3) {R=p; G=q; B=V;}
-		 else if (I==4) {R=t; G=p; B=V;}
-		 else if (I==5) {R=V; G=p; B=q;}
+		 mH /= HUE_CIRCLE_SPLITTER;
+		 mI = (int)Math.floor(mH);
+		 f = mH-mI;
+		 p = mV*(RGBCMY_FLOAT_MAX-mS);
+		 q = mV*(RGBCMY_FLOAT_MAX-(mS*f));
+		 t = mV*(RGBCMY_FLOAT_MAX-(mS*(RGBCMY_FLOAT_MAX-f)));
+		 if (mI==0) {mR=mV; mG=t; mB=p;}
+		 else if (mI==1) {mR=q; mG=mV; mB=p;}
+		 else if (mI==2) {mR=p; mG=mV; mB=t;}
+		 else if (mI==3) {mR=p; mG=q; mB=mV;}
+		 else if (mI==4) {mR=t; mG=p; mB=mV;}
+		 else if (mI==5) {mR=mV; mG=p; mB=q;}
 		}
-		return new ColorRGB(R,G,B);
+		return new ColorRGB(mR,mG,mB);
 	}
 	
 	/**
@@ -44,7 +85,7 @@
 	 * @return odpowiadający kolor z przestrzeni CMY
 	 */
 	public static ColorCMY rgbTOcmy(ColorRGB color){
-		return new ColorCMY(1.0f-color.getR(), 1.0f-color.getG(), 1.0f-color.getB());
+		return new ColorCMY(RGBCMY_FLOAT_MAX-color.getR(), RGBCMY_FLOAT_MAX-color.getG(), RGBCMY_FLOAT_MAX-color.getB());
 	}
 	/**
 	 * @param color - kolor z przestrzeni HSV
@@ -59,25 +100,25 @@
 	 * @return odpowiadający kolor z przestrzeni HSV
 	 */
 	public static ColorHSV rgbTOhsv(ColorRGB color){
-		float H=0.0f,S=0.0f,V=0.0f,R,G,B,x,I,f;
-		R = color.getR();
-		G = color.getG();
-		B = color.getB();
-		x = Math.min(Math.min(R, G), B);
-		V = Math.max(Math.max(R, G), B);
-		if (x == V) H=S=0.0f;
+		float mH=0.0f,mS=0.0f,mV=0.0f,mR,mG,mB,x,mI,f;
+		mR = color.getR();
+		mG = color.getG();
+		mB = color.getB();
+		x = Math.min(Math.min(mR, mG), mB);
+		mV = Math.max(Math.max(mR, mG), mB);
+		if (Math.abs(x - mV) < FLOAT_PRECISION) {mH=0.0f; mS=0.0f;}
 		else {
-			if(R == x) f = G-B;
-			else if(G == x) f = B-R;
-			else f = R-G;
+			if(Math.abs(mR - x) < FLOAT_PRECISION) {f = mG-mB;}
+			else if(Math.abs(mG - x) < FLOAT_PRECISION) {f = mB-mR;}
+			else {f = mR-mG;}
 			
-			if(R == x) I=3.0f;
-			else if(G == x) I=5.0f;
-			else I=1.0f;
-			H = (float)( (int)((I-f/(V-x))*60.0f) )%360;
-			S = ((V-x)/V);
+			if(Math.abs(mR - x) < FLOAT_PRECISION) {mI=3.0f;}
+			else if(Math.abs(mG - x) < FLOAT_PRECISION) {mI=5.0f;}
+			else {mI=1.0f;}
+			mH = (float)( (int)((mI-f/(mV-x))*HUE_CIRCLE_SPLITTER) ) % HUE_CHANNEL_PRECISION;
+			mS = ((mV-x)/mV);
 		}		
-		return new ColorHSV(H,S,V);
+		return new ColorHSV(mH,mS,mV);
 	}
 	/**
 	 * @param color - kolor z przestrzeni CMY

=== modified file 'src/main/java/manager/editor/ColorHSV.java'
--- src/main/java/manager/editor/ColorHSV.java	2012-04-09 18:10:58 +0000
+++ src/main/java/manager/editor/ColorHSV.java	2012-04-17 18:42:22 +0000
@@ -8,48 +8,48 @@
 	private float mHue, mSaturation, mValue;
 	
 	/**
-	 * @param H - Barwa [0,359]
-	 * @param S - Nasycenie [0,1]
-	 * @param V - Jasność [0,1]
+	 * @param mH - Barwa [0,359]
+	 * @param mS - Nasycenie [0,1]
+	 * @param mV - Jasność [0,1]
 	 */
-	public ColorHSV(float H, float S, float V){
-		setH(H);
-		setS(S);
-		setV(V);
+	public ColorHSV(float mH, float mS, float mV){
+		setH(mH);
+		setS(mS);
+		setV(mV);
 	}
 	
 	/**
 	 * @return wartość kanału barwy [0,359]
 	 */
-	public float getH(){return mHue;}
+	public final float getH(){return mHue;}
 	/**
 	 * @return wartość kanału nasycenia [0,1]
 	 */
-	public float getS(){return mSaturation;}
+	public final float getS(){return mSaturation;}
 	/**
 	 * @return wartość kanału jasności [0,1]
 	 */
-	public float getV(){return mValue;}
+	public final float getV(){return mValue;}
 	
 	/**
 	 * Ustawia wartość kanału barwy dla koloru
-	 * @param H - kanał barwy
+	 * @param mH - kanał barwy
 	 */
-	public void setH(float H){
-		mHue = Math.max(0.0f, Math.min(359.9f, H));
+	public final void setH(float mH){
+		mHue = Math.max(0.0f, Math.min(ColorConverter.HUE_MAX, mH));
 	}
 	/**
 	 * Ustawia wartość kanału nasycenia dla koloru
-	 * @param S - kanał nasycenia
+	 * @param mS - kanał nasycenia
 	 */
-	public void setS(float S){
-		mSaturation = Math.max(0.0f, Math.min(1.0f, S));
+	public final void setS(float mS){
+		mSaturation = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mS));
 	}
 	/**
 	 * Ustawia wartość kanału jasności dla koloru
-	 * @param V - kanał jasności
+	 * @param mV - kanał jasności
 	 */
-	public void setV(float V){
-		mValue = Math.max(0.0f, Math.min(1.0f, V));
+	public final void setV(float mV){
+		mValue = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mV));
 	}
 }

=== modified file 'src/main/java/manager/editor/ColorRGB.java'
--- src/main/java/manager/editor/ColorRGB.java	2012-04-09 18:10:58 +0000
+++ src/main/java/manager/editor/ColorRGB.java	2012-04-17 18:42:22 +0000
@@ -8,79 +8,79 @@
 	private float mRed, mGreen, mBlue;
 	
 	/**
-	 * @param R - kanał czerwony [0,255]
-	 * @param G - kanał zielony [0,255]
-	 * @param B - kanał niebieski [0,255]
+	 * @param mR - kanał czerwony [0,255]
+	 * @param mG - kanał zielony [0,255]
+	 * @param mB - kanał niebieski [0,255]
 	 */
-	public ColorRGB(int R, int G, int B){
-		setR(R);
-		setG(G);
-		setB(B);
+	public ColorRGB(int mR, int mG, int mB){
+		setR(mR);
+		setG(mG);
+		setB(mB);
 	}
 	/**
-	 * @param R - kanał czerwony [0,1]
-	 * @param G - kanał zielony [0,1]
-	 * @param B - kanał niebieski [0,1]
+	 * @param mR - kanał czerwony [0,1]
+	 * @param mG - kanał zielony [0,1]
+	 * @param mB - kanał niebieski [0,1]
 	 */
-	public ColorRGB(float R, float G, float B){
-		setR(R); 
-		setG(G); 
-		setB(B);
+	public ColorRGB(float mR, float mG, float mB){
+		setR(mR); 
+		setG(mG); 
+		setB(mB);
 	}
 	
 	/**
 	 * @return kanał czerwony [0,1]
 	 */
-	public float getR(){return mRed;}
+	public final float getR(){return mRed;}
 	/**
 	 * @return kanał zielony [0,1]
 	 */
-	public float getG(){return mGreen;}
+	public final float getG(){return mGreen;}
 	/**
 	 * @return kanał niebieski [0,1]
 	 */
-	public float getB(){return mBlue;}
+	public final float getB(){return mBlue;}
 	
 	/**
 	 * Ustawia wartość kanału czerwonego
-	 * @param R - kanał czerwony [0,1]
+	 * @param mR - kanał czerwony [0,1]
 	 */
-	public void setR(float R){
-		mRed = Math.max(0.0f, Math.min(1.0f, R));
+	public final void setR(float mR){
+		mRed = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mR));
 	}
 	/**
 	 * Ustawia wartość kanału zielonego
-	 * @param G - kanał zielony [0,1]
+	 * @param mG - kanał zielony [0,1]
 	 */
-	public void setG(float G){
-		mGreen = Math.max(0.0f, Math.min(1.0f, G));
+	public final void setG(float mG){
+		mGreen = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mG));
 	}
 	/**
 	 * Ustawia wartość kanału niebieskiego
-	 * @param B - kanał niebieski [0,1]
+	 * @param mB - kanał niebieski [0,1]
 	 */
-	public void setB(float B){
-		mBlue = Math.max(0.0f, Math.min(1.0f, B));
+	public final void setB(float mB){
+		mBlue = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mB));
 	}
 	/**
 	 * Ustawia wartość kanału czerwonego
-	 * @param R - kanał czerwony [0,255]
+	 * @param mR - kanał czerwony [0,255]
 	 */
-	public void setR(int R){
-		mRed = Math.max(0.0f, Math.min(255.0f, (float)R/255.0f));
+	public final void setR(int mR){
+		mRed = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, (float)mR/ColorConverter.RGBCMY_BYTE_MAX));
 	}
 	/**
 	 * Ustawia wartość kanału zielonego
-	 * @param G - kanał zielony [0,255]
+	 * @param mG - kanał zielony [0,255]
 	 */
-	public void setG(int G){
-		mGreen = Math.max(0.0f, Math.min(255.0f, (float)G/255.0f));
+	public final void setG(int mG){
+		mGreen = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, (float)mG/ColorConverter.RGBCMY_BYTE_MAX));
 	}
 	/**
 	 * Ustawia wartość kanału niebieskiego
-	 * @param B - kanał niebieski [0,255]
+	 * @param mB - kanał niebieski [0,255]
 	 */
-	public void setB(int B){
-		mBlue = Math.max(0.0f, Math.min(255.0f, (float)B/255.0f));
+	public final void setB(int mB){
+		mBlue = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, (float)mB/ColorConverter.RGBCMY_BYTE_MAX));
 	}
 }

=== modified file 'src/main/java/manager/editor/EditWindow.java'
--- src/main/java/manager/editor/EditWindow.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/EditWindow.java	2012-04-17 18:42:22 +0000
@@ -1,19 +1,233 @@
 package manager.editor;
 
 import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 import java.awt.image.BufferedImage;
-
-public class EditWindow extends JDialog {
-    /**
-     * @param image - referencja do objektu klasy BufferedImage przechowująca obraz do edycji
-     */
-    public EditWindow(BufferedImage image) {
-    }
-
-    /**
-     * @return przetworzony obraz
-     */
-    public BufferedImage getTransformedImage() {
-        return null;
-    }
+import java.util.LinkedList;
+
+/**
+ * Klasa reprezentuje okno dialogowe w którym dokonywana jest edycja obrazu
+ * @author Marcin Regdos
+ */
+public class EditWindow extends JFrame implements ActionListener  {
+	private JPanel contentPane;
+	private PixelData PDImage;
+	private LinkedList<PixelData> history;
+	private ImageViewer mainImageViewer;
+	private String [] filterNamesGUI;
+	private String [] filterCategoryNamesGUI;
+	//private IFilter [] filters;
+	private int [] filterType;
+	private JMenuItem [] JMenuFilterButtons;
+	private JMenu [] JMenuFilterCategories;
+	private FilterGUI [] filters;
+	private int nFilters=17;
+	private int nCategories=6;
+	private static class FilterGUI{
+		String name, nameGUI;
+		FWindowType window;
+		IFilter filter;
+		FilterGUI(String name, String nameGUI, FWindowType window, IFilter Filter){
+			this.name=name;
+			this.nameGUI=nameGUI;
+			this.window=window;
+			this.filter=Filter;
+		}
+	}
+	private enum FWindowType{
+		WindowRange, WindowResize, WindowMatrix, WindowLUT, WindowHistogram, NoWindow, WindowGallery
+	}
+	private void InitGui(){
+		setTitle("Edytor plików graficznych");
+		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		setBounds(100, 100, 600, 600);
+		InitMenu();
+		contentPane = new JPanel();
+		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
+		contentPane.setLayout(new BorderLayout(0, 0));
+		setContentPane(contentPane);
+
+		JToolBar toolBar = new JToolBar();
+		contentPane.add(toolBar, BorderLayout.NORTH);
+
+		JButton buttonUndo = new JButton("Cofnij");
+		toolBar.add(buttonUndo);
+		buttonUndo.setActionCommand("undo");
+		buttonUndo.addActionListener(this);
+		JButton bClose = new JButton("Zamknij");
+		toolBar.add(bClose);
+		bClose.setActionCommand("close");
+		bClose.addActionListener(this);
+		JButton bsClose = new JButton("Zapisz i zamknij");
+		toolBar.add(bsClose);
+		bsClose.setActionCommand("applyclose");
+		bsClose.addActionListener(this);
+
+	}
+	private void InitFiltersToGUI(){
+		filterNamesGUI =new String[]{
+				"Detekcja krawędzi", "Filtr LUT", "Filtr matrycowy", "Histogram", "Obrót w lewo", "Obrót w prawo", "Symetria", "Uwypuklenie", "Wygładzenie", "Wyostrzanie", "Zmiana rozmiaru"
+		};
+		filterCategoryNamesGUI=new String[]{
+				"Edycja", "Filtry podstawowe", "Filtry kolorystyczne","Inne", "Filtry kanałowe", "Własne filtry", 
+		};
+		filters=new FilterGUI[]{
+				new FilterGUI("FilterBrightness","Jasność", FWindowType.WindowRange, new FilterBrightness() ),
+				new FilterGUI("FilterContrast","Kontrast", FWindowType.WindowRange, new FilterContrast() ),
+				new FilterGUI("FilterGamma","Korekta gamma", FWindowType.WindowRange, new FilterGamma() ),
+				new FilterGUI("FilterExposure","Korekta ekspozycji", FWindowType.WindowRange, new FilterExposure() ),
+				new FilterGUI("FilterSepia","Sepia", FWindowType.WindowRange, new FilterSepia() ),
+				new FilterGUI("FilterColorAccent","Akcent kolorystyczny", FWindowType.WindowRange, new FilterColorAccent() ),
+				new FilterGUI("FilterBinaryzation","Binaryzacja", FWindowType.WindowRange, new FilterBinaryzation() ),
+				new FilterGUI("FilterSolarize","Solaryzacja", FWindowType.WindowRange, new FilterSolarize() ),
+				new FilterGUI("FilterRGBCorrection","Korekta RGB", FWindowType.WindowRange, new FilterRGBCorrection() ),
+				new FilterGUI("FilterCMYCorrection","Korekta CMY", FWindowType.WindowRange, new FilterCMYCorrection() ),
+				new FilterGUI("FilterHSBCorrection", "Korekta HSV", FWindowType.WindowRange, new FilterHSVCorrection() ),
+				new FilterGUI("grayScaleLightness", "Skala szarości (jasność)", FWindowType.NoWindow, FilterFactory.grayScaleLightness()),
+				new FilterGUI("grayScaleAverage", "Skala szarości (średnia)", FWindowType.NoWindow, FilterFactory.grayScaleAverage()),
+				new FilterGUI("grayScaleLuminosity", "Skala szarości (nasycenie)", FWindowType.NoWindow, FilterFactory.grayScaleLuminosity()),
+				new FilterGUI("MatrixFilter", "Filtr macierzowy", FWindowType.WindowMatrix, null),
+				new FilterGUI("LUTFilter", "Filtr LUT", FWindowType.WindowLUT, null),
+				new FilterGUI("Resize", "Zmień rozmiar", FWindowType.WindowResize, null),
+		};
+		JMenuFilterButtons=new JMenuItem[nFilters];
+		JMenuFilterCategories=new JMenu[nCategories];
+
+	}
+	private void InitMenu(){
+		JMenuBar menuBar = new JMenuBar();
+		setJMenuBar(menuBar);
+		for (int i=0; i<nCategories; ++i){
+			JMenuFilterCategories[i]=new JMenu(filterCategoryNamesGUI[i]);
+			menuBar.add(JMenuFilterCategories[i]);
+		}
+		for (int i=0; i<nFilters; ++i){
+			JMenuFilterButtons[i]=new JMenuItem(filters[i].nameGUI);
+			JMenuFilterButtons[i].setActionCommand(filters[i].name);
+			JMenuFilterButtons[i].addActionListener(this);
+		}
+		JMenuFilterCategories[1].add(JMenuFilterButtons[0]);
+		JMenuFilterCategories[1].add(JMenuFilterButtons[1]);
+		JMenuFilterCategories[1].add(JMenuFilterButtons[2]);
+		JMenuFilterCategories[1].add(JMenuFilterButtons[3]);
+		JMenuFilterCategories[2].add(JMenuFilterButtons[4]);
+		JMenuFilterCategories[2].add(JMenuFilterButtons[5]);
+		JMenuFilterCategories[2].add(JMenuFilterButtons[11]);
+		JMenuFilterCategories[2].add(JMenuFilterButtons[12]);
+		JMenuFilterCategories[2].add(JMenuFilterButtons[13]);
+		JMenuFilterCategories[3].add(JMenuFilterButtons[6]);
+		JMenuFilterCategories[3].add(JMenuFilterButtons[7]);
+		JMenuFilterCategories[4].add(JMenuFilterButtons[8]);
+		JMenuFilterCategories[4].add(JMenuFilterButtons[9]);
+		JMenuFilterCategories[4].add(JMenuFilterButtons[10]);
+		JMenuFilterCategories[5].add(JMenuFilterButtons[14]);
+		JMenuFilterCategories[5].add(JMenuFilterButtons[15]);
+		JMenuItem mHistogram = new JMenuItem("Histogram");
+		mHistogram.setActionCommand("mHistogram");
+		mHistogram.addActionListener(this);
+		menuBar.add(mHistogram);
+		
+		JMenuItem mUndo = new JMenuItem("Cofnij");
+		mUndo.setActionCommand("undo");
+		mUndo.addActionListener(this);
+		JMenuFilterCategories[0].add(mUndo);
+		JMenuFilterCategories[0].add(JMenuFilterButtons[16]);
+		//mEdycja.add(mUndo);
+	}
+
+	/**
+	 * Konstruktor - wymagany jest obraz do edycji
+	 * @param image - referencja do objektu klasy BufferedImage przechowująca obraz do edycji
+	 */
+	public EditWindow(BufferedImage image) {
+		if (image==null){
+			return;
+		}
+		InitFiltersToGUI();
+		mainImageViewer=new ImageViewer(image, 400, 400);
+		PDImage=new PixelData(image);
+		history=new LinkedList<PixelData>();
+		InitGui();
+		getContentPane().add(mainImageViewer);
+		this.setVisible(true);
+	}
+	/**
+	 * Zwraca obraz po edycji. Jeśli użytkownik nie zdecydował się na zastosowanie zmian, obraz jest nullem
+	 * @return przetworzony obraz
+	 * 
+	 */
+	public BufferedImage getTransformedImage() {
+		this.setVisible(true);
+		if (PDImage==null){
+			return null;
+		}
+		return PDImage.toBufferedImage();
+	}
+	private void undo (){
+		if (history.isEmpty()==false){
+			PDImage=history.pollLast();
+			mainImageViewer.setImage(PDImage.toBufferedImage());
+		}else{
+			JOptionPane.showMessageDialog(this,"Brak wcześniejszej wersji","error", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+	private void apply (PixelData newPixelData){
+		if (newPixelData==null)return;
+		history.add(PDImage);
+		PDImage=newPixelData;	
+		mainImageViewer.setImage(PDImage.toBufferedImage());
+	}
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (e.getActionCommand().equals("undo")) {
+			undo();
+			return;
+		} 
+		if (e.getActionCommand().equals("close")) {
+			PDImage=null;
+			this.setVisible(false);
+			this.dispose();
+			return;
+		} 
+		if (e.getActionCommand().equals("applyclose")) {
+			this.setVisible(false);
+			this.dispose();
+			return;
+		} 
+		if (e.getActionCommand().equals("mHistogram")) {
+			new WindowHistogram(null);
+			return;
+		} 
+		for (int i=0; i<filters.length; ++i){
+			if (e.getActionCommand().equals(filters[i].name)) {
+				switch(filters[i].window){
+				case WindowRange: 
+					apply (new WindowRange(PDImage, (IFilterRange)filters[i].filter, filters[i].nameGUI).showDialog()); 
+					filters[i].filter.reset();
+					break;
+				case WindowMatrix: 
+					apply (new WindowMatrix(PDImage).showDialog()); 
+					break;	
+				case WindowLUT: 
+					apply (new WindowLUT(PDImage).showDialog()); 
+					break;
+				case WindowResize: 
+					apply (new WindowResize(PDImage).showDialog()); 
+					break;	
+				case NoWindow:
+					PixelData tdata= (PixelData)PDImage.clone();
+					filters[i].filter.apply(PDImage, tdata);
+					apply (tdata); 
+					break;		
+				case WindowGallery:
+					break;	
+				}
+				return;
+			}
+		}	
+	} 
 }

=== modified file 'src/main/java/manager/editor/FilterBinaryzation.java'
--- src/main/java/manager/editor/FilterBinaryzation.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/FilterBinaryzation.java	2012-04-17 18:42:22 +0000
@@ -8,28 +8,40 @@
  */
 public class FilterBinaryzation implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(0.0f, 255.0f, 127.5f)	
+		new Range(0.0f, ColorConverter.RGBCMY_BYTE_MAX, ColorConverter.RGBCMY_BYTE_MAX / 2.0f, "Próg")	
 	};
 
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		float prog = mRange[0].getValue(), gray;
 		original.toRGB(); temp.toRGB();
-		for(int j=0;j<original.mHeight;j++)
-			for(int i=0;i<original.mWidth;i++){
-				gray = (original.mData[3*(j*original.mWidth+i)]+original.mData[3*(j*original.mWidth+i)+1]+original.mData[3*(j*original.mWidth+i)+2])/3.0f;
-				if(gray < prog) temp.mData[3*(j*original.mWidth+i)] = temp.mData[3*(j*original.mWidth+i)+1] = temp.mData[3*(j*original.mWidth+i)+2] = 0.0f;
-				else temp.mData[3*(j*original.mWidth+i)] = temp.mData[3*(j*original.mWidth+i)+1] = temp.mData[3*(j*original.mWidth+i)+2] = 255.0f;
+		for(int j=0;j<mHeight;j++){
+			for(int i=0;i<mWidth;i++){
+				gray = (origData[PixelData.PIXEL_SIZE*(j*mWidth+i)]+
+						origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1]+
+						origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2]) / ((float)PixelData.PIXEL_SIZE);
+				if(gray < prog) {
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = 0.0f;
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = 0.0f;
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = 0.0f;
+				} else {
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = ColorConverter.RGBCMY_BYTE_MAX;
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = ColorConverter.RGBCMY_BYTE_MAX;
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = ColorConverter.RGBCMY_BYTE_MAX;
+				}
 			}
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -37,7 +49,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterBrightness.java'
--- src/main/java/manager/editor/FilterBrightness.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterBrightness.java	2012-04-17 18:42:22 +0000
@@ -6,22 +6,25 @@
  */
 public class FilterBrightness implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(-128.0f, 128.0f, 0.0f)	
+		new Range(-ColorConverter.RGBCMY_BYTE_MAX / 2.0f, ColorConverter.RGBCMY_BYTE_MAX / 2.0f, 0.0f, "Jasność")	
 	};
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		if(original.getWidth() != temp.getWidth() || original.getHeight() != temp.getHeight()){ 
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		float delta = mRange[0].getValue();
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mData.length;i++)
-			temp.mData[i] = Math.max(0.0f, Math.min(255.0f, original.mData[i] + mRange[0].getValue()));
+		for(int i=0;i<origData.length;i++){
+			tempData[i] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, origData[i] + delta));
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -29,7 +32,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterCMYCorrection.java'
--- src/main/java/manager/editor/FilterCMYCorrection.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterCMYCorrection.java	2012-04-17 18:42:22 +0000
@@ -6,34 +6,37 @@
  */
 public class FilterCMYCorrection implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-			new Range(-128.0f, 128.0f, 0.0f),
-			new Range(-128.0f, 128.0f, 0.0f),
-			new Range(-128.0f, 128.0f, 0.0f)
+			new Range(-ColorConverter.RGBCMY_BYTE_MAX/2.0f, ColorConverter.RGBCMY_BYTE_MAX/2.0f, 0.0f, "Cyjan"),
+			new Range(-ColorConverter.RGBCMY_BYTE_MAX/2.0f, ColorConverter.RGBCMY_BYTE_MAX/2.0f, 0.0f, "Purpura"),
+			new Range(-ColorConverter.RGBCMY_BYTE_MAX/2.0f, ColorConverter.RGBCMY_BYTE_MAX/2.0f, 0.0f, "Żółty")
 		};
 
 		@Override
-		public void apply(PixelData original, PixelData temp)
-				throws IllegalArgumentException {
-			if(original == null || temp == null) throw new NullPointerException();
-			if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+		public void apply(PixelData original, PixelData temp) {
+			int mWidth = original.getWidth(), mHeight = original.getHeight();
+			if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 				throw new IllegalArgumentException();
+			}
+			float[] origData = original.getData();
+			float[] tempData = temp.getData();
 			original.toCMY(); temp.toCMY();
-			float C,M,Y;
-			float Cd = mRange[0].getValue(), Md = mRange[1].getValue(), Yd = mRange[2].getValue();
-			for(int i=0;i<original.mWidth;i++)
-				for(int j=0;j<original.mHeight;j++){
-					C = original.mData[3*(i*original.mHeight+j)];
-					M = original.mData[3*(i*original.mHeight+j)+1];
-					Y = original.mData[3*(i*original.mHeight+j)+2];
-					temp.mData[3*(i*original.mHeight+j)] = Math.max(0.0f, Math.min(255.0f, C+Cd));
-					temp.mData[3*(i*original.mHeight+j)+1] = Math.max(0.0f, Math.min(255.0f, M+Md));
-					temp.mData[3*(i*original.mHeight+j)+2] = Math.max(0.0f, Math.min(255.0f, Y+Yd));
+			float mC,mM,mY;
+			float dC = mRange[0].getValue(), dM = mRange[1].getValue(), dY = mRange[2].getValue();
+			for(int i=0;i<mWidth;i++){
+				for(int j=0;j<mHeight;j++){
+					mC = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)];
+					mM = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1];
+					mY = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2];
+					tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mC+dC));
+					tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mM+dM));
+					tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mY+dY));
 				}	
+			}
 		}
 
 		@Override
 		public PixelData apply(PixelData image) {
-			if(image == null) return null;
+			if(image == null) {return null;}
 			PixelData ret = (PixelData)image.clone();
 			apply(image, image);
 			return ret;
@@ -41,7 +44,29 @@
 
 		@Override
 		public Range[] getRangeTable() {
-			return mRange;
+			return mRange.clone();
+		}
+
+		@Override
+		public void setRangeTable(Range[] table) {
+			if(table == null || table.length != mRange.length){
+				throw new IllegalArgumentException();
+			}
+			for(int i=0;i<table.length;i++){
+				if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+					throw new IllegalArgumentException();
+				}
+			}
+			for(int i=0;i<table.length;i++){
+				mRange[i].setValue(table[i].getValue());
+			}
+		}
+		
+		@Override
+		public void reset() {
+			for(int i=0;i<mRange.length;i++){
+				mRange[i].reset();
+			}
 		}
 
 }

=== modified file 'src/main/java/manager/editor/FilterColorAccent.java'
--- src/main/java/manager/editor/FilterColorAccent.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/FilterColorAccent.java	2012-04-17 18:42:22 +0000
@@ -11,36 +11,43 @@
  */
 public class FilterColorAccent implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(0.0f, 359.9f, 0.0f),
-		new Range(0.0f, 180.0f, 10.0f)
+		new Range(0.0f, 360.0f, 0.0f, "Barwa"),
+		new Range(0.0f, 180.0f, 10.0f, "Tolerancja")
 	};
 	
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp){
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toHSV(); temp.toHSV();
-		float Hue = mRange[0].getValue(), Tol = mRange[1].getValue();
-		float Hmax = Hue+Tol, Hmin = Hue-Tol;
-		float H=0,S=0,V=0;
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				H = original.mData[3*(j*original.mWidth+i)];
-				S = original.mData[3*(j*original.mWidth+i)+1];
-				V = original.mData[3*(j*original.mWidth+i)+2];
-				if((Hmin <= H && H <= Hmax) || (Hmin <= H-360.0f && H-360.0f <= Hmax) || (Hmin <= H+360.0f && H+360.0f <= Hmax))
-					temp.mData[3*(j*original.mWidth+i)+1] = S;
-				else temp.mData[3*(j*original.mWidth+i)+1] = 0.0f;
-				temp.mData[3*(j*original.mWidth+i)] = H;
-				temp.mData[3*(j*original.mWidth+i)+2] = V;
+		float mHue = mRange[0].getValue(), mTol = mRange[1].getValue();
+		float mHmax = mHue+mTol, mHmin = mHue-mTol;
+		float mH=0,mS=0,mV=0;
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mH = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)];
+				mS = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1];
+				mV = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2];
+				if((mHmin <= mH && mH <= mHmax) || 
+						(mHmin <= mH - ColorConverter.HUE_MAX && mH - ColorConverter.HUE_MAX <= mHmax) || 
+						(mHmin <= mH + ColorConverter.HUE_MAX && mH + ColorConverter.HUE_MAX <= mHmax)){
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = mS;
+				} else {
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = 0.0f;
+				}
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = mH;
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = mV;
 			}
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -48,7 +55,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterContrast.java'
--- src/main/java/manager/editor/FilterContrast.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterContrast.java	2012-04-17 18:42:22 +0000
@@ -6,25 +6,29 @@
  */
 public class FilterContrast implements IFilterRange {
 	private final Range[] mRange = new Range[]{
-			new Range(0.1f, 10.0f, 1.0f)
+			new Range(0.1f, 10.0f, 1.0f, "Kontrast")
 	};
 
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp){
+		if(original.getWidth() != temp.getWidth() || original.getHeight() != temp.getHeight()){
 			throw new IllegalArgumentException();
-		float mLUT[] = new float[256];
-		for(int i=0;i<256;i++) mLUT[i] = Math.max(0.0f, Math.min(255.0f, mRange[0].getValue()*((float)i-127.5f)+127.5f));
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		float mLUT[] = new float[PixelData.RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<PixelData.RGBCMY_CHANNEL_PRECISION;i++){
+			mLUT[i] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mRange[0].getValue()*((float)i-PixelData.RGBCMY_CHANNEL_PRECISION/2.0f) + PixelData.RGBCMY_CHANNEL_PRECISION/2.0f));
+		}
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mData.length;i++)
-			temp.mData[i] = mLUT[(int)original.mData[i]];
+		for(int i=0;i<origData.length;i++){
+			tempData[i] = mLUT[(int)origData[i]];
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -32,7 +36,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterExposure.java'
--- src/main/java/manager/editor/FilterExposure.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterExposure.java	2012-04-17 18:42:22 +0000
@@ -8,24 +8,26 @@
  */
 public class FilterExposure implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(-3.0f, 3.0f, 0.0f)
+		new Range(-3.0f, 3.0f, 0.0f, "EV")
 	};
 
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		if(original.getWidth() != temp.getWidth() || original.getHeight() != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		float coef = (float)Math.pow(2.0f, mRange[0].getValue());
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mData.length;i++)
-			temp.mData[i] = Math.max(0.0f, Math.min(255.0f, coef*original.mData[i]));
+		for(int i=0;i<origData.length;i++){
+			tempData[i] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, coef*origData[i]));
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -33,7 +35,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterFactory.java'
--- src/main/java/manager/editor/FilterFactory.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/FilterFactory.java	2012-04-17 18:42:22 +0000
@@ -4,9 +4,12 @@
 
 /**
  * Fabryka Filtrów - generuje filtry gotowe do aplikowania na obrazie
+ * próba stworzenia obiektu tej klasy nawet przy użyciu refleksji skończy się
+ * wyrzuceniem wyjątku <b>UnsupportedOperationException</b>
  * @author Patryk
  */
-public class FilterFactory {
+public final class FilterFactory {
+	private FilterFactory(){throw new UnsupportedOperationException();}
 	/**
 	 * @return Filtr tworzący negatyw obrazu
 	 */
@@ -43,19 +46,19 @@
 	/**
 	 * @return Filtr odpowiedzialny za korekcję kanałów RGB
 	 */
-	public static IFilterRange RGBCorrection(){
+	public static IFilterRange rgbCorrection(){
 		return new FilterRGBCorrection();
 	}
 	/**
 	 * @return Filtr odpowiedzialny za korekcję kanałów CMY
 	 */
-	public static IFilterRange CMYCorrection(){
+	public static IFilterRange cmyCorrection(){
 		return new FilterCMYCorrection();
 	}
 	/**
 	 * @return Filtr odpowiedzialny za korekcję kanałów HSV
 	 */
-	public static IFilterRange HSVCorrection(){
+	public static IFilterRange hsvCorrection(){
 		return new FilterHSVCorrection();
 	}
 	/**
@@ -101,55 +104,84 @@
 		return new FilterColorAccent();
 	}
 	
+	//LUT
+	
+	/**
+	 * @return Filtr odpowiedzialny za kanałowa korektę RGB tablicą LUT
+	 */
+	public static IFilterLUT lutRGBCorrection(){
+		return new FilterLUTCorrectionRGB();
+	}
+	/**
+	 * @return Filtr odpowiedzialny za kanałowa korektę CMY tablicą LUT
+	 */
+	public static IFilterLUT lutCMYCorrection(){
+		return new FilterLUTCorrectionCMY();
+	}
+	/**
+	 * @return Filtr odpowiedzialny za kanałowa korektę HSV tablicą LUT
+	 */
+	public static IFilterLUT lutHSVCorrection(){
+		return new FilterLUTCorrectionHSV();
+	}
+	
 	//EDGE DETECTING
 	
 	/**
 	 * @return Filtr wykrywający krawędzie ukierunkowany na pionowe krawędzie
 	 */
 	public static IFilter edgeDetectionVertical(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,0,0, -1,1,0, 0,0,0}));
+		float[] mCoef = new float[]{0,0,0, -1,1,0, 0,0,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie ukierunkowany na poziome krawędzie
 	 */
 	public static IFilter edgeDetectionHorizontal(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,-1,0, 0,1,0, 0,0,0}));
+		float[] mCoef = new float[]{0,-1,0, 0,1,0, 0,0,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie ukierunkowany na skośne krawędzie
 	 */
 	public static IFilter edgeDetectionDiagonal1(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,0,0, 0,1,0, 0,0,0}));
+		float[] mCoef = new float[]{-1,0,0, 0,1,0, 0,0,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie ukierunkowany na skośne krawędzie
 	 */
 	public static IFilter edgeDetectionDiagonal2(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,0,-1, 0,1,0, 0,0,0}));
+		float[] mCoef = new float[]{0,0,-1, 0,1,0, 0,0,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie metodą Sobel'a typ poziomy
 	 */
 	public static IFilter edgeDetectionSobelHorizontal(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,2,1,0,0,0,-1,-2,-1}));
+		float[] mCoef = new float[]{1,2,1, 0,0,0, -1,-2,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie metodą Sobel'a typ pionowy
 	 */
 	public static IFilter edgeDetectionSobelVertical(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,0,-1,2,0,-2,1,0,-1}));
+		float[] mCoef = new float[]{1,0,-1, 2,0,-2, 1,0,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie metodą Prewitt'a typ poziomy
 	 */
 	public static IFilter edgeDetectionPrewittHorizontal(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,-1,0,0,0,1,1,1}));
+		float[] mCoef = new float[]{-1,-1,-1, 0,0,0, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr wykrywający krawędzie metodą Prewitt'a typ pionowy
 	 */
 	public static IFilter edgeDetectionPrewittVertical(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,0,-1,1,0,-1,1,0,-1}));
+		float[] mCoef = new float[]{1,0,-1 ,1,0,-1, 1,0,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	
 	//EDGE DETECTING LAPLACE
@@ -159,39 +191,45 @@
 	 * go zdolność do tworzenia ostrzejszych krawędzi
 	 */
 	public static IFilter edgeDetectionLaplace1(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,-1,0, -1,4,-1, 0,-1,0}));
+		float[] mCoef = new float[]{0,-1,0, -1,4,-1, 0,-1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr Laplace'a do wielokierunkowego wykrywania krawędzi - od pozostałych filtrów odróżnia
 	 * go zdolność do tworzenia ostrzejszych krawędzi
 	 */
 	public static IFilter edgeDetectionLaplace2(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,-1, -1,8,-1, -1,-1,-1}));
+		float[] mCoef = new float[]{-1,-1,-1, -1,8,-1, -1,-1,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr Laplace'a do wielokierunkowego wykrywania krawędzi - od pozostałych filtrów odróżnia
 	 * go zdolność do tworzenia ostrzejszych krawędzi
 	 */
 	public static IFilter edgeDetectionLaplace3(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,-2,1, -2,4,-2, 1,-2,1}));
+		float[] mCoef = new float[]{1,-2,1, -2,4,-2, 1,-2,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr Laplace'a do przekątniowego wykrywania krawędzi
 	 */
 	public static IFilter edgeDetectionLaplaceDiagonal(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,0,-1, 0,4,0, -1,0,-1}));
+		float[] mCoef = new float[]{-1,0,-1, 0,4,0, -1,0,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr Laplace'a do wykrywania krawędzi poziomych
 	 */
 	public static IFilter edgeDetectionLaplaceHorizontal(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,-1,0, 0,2,0, 0,-1,0}));
+		float[] mCoef = new float[]{0,-1,0, 0,2,0, 0,-1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr Laplace'a do wykrywania krawędzi pionowych
 	 */
 	public static IFilter edgeDetectionLaplaceVertical(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,0,0, -1,2,-1, 0,0,0}));
+		float[] mCoef = new float[]{0,0,0, -1,2,-1, 0,0,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	
 	//GRADIENT DIRECTIONAL EDGE DETECTING
@@ -200,49 +238,57 @@
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku wschodnim
 	 */
 	public static IFilter edgeDetectionGradientDirectionalEast(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,1,1, -1,-2,1, -1,1,1}));
+		float[] mCoef = new float[]{-1,1,1, -1,-2,1, -1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku południowo-wschodnim
 	 */
 	public static IFilter edgeDetectionGradientDirectionalSouthEast(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,1, -1,-2,1, 1,1,1}));
+		float[] mCoef = new float[]{-1,-1,1, -1,-2,1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku południowym
 	 */
 	public static IFilter edgeDetectionGradientDirectionalSouth(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,-1, 1,-2,1, 1,1,1}));
+		float[] mCoef = new float[]{-1,-1,-1, 1,-2,1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku południowo-zachodnim
 	 */
 	public static IFilter edgeDetectionGradientDirectionalSouthWest(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,-1,-1, 1,-2,-1, 1,1,1}));
+		float[] mCoef = new float[]{1,-1,-1, 1,-2,-1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku zachodnim
 	 */
 	public static IFilter edgeDetectionGradientDirectionalWest(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,-1, 1,-2,-1, 1,1,-1}));
+		float[] mCoef = new float[]{1,1,-1, 1,-2,-1, 1,1,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku północno-zachodnim
 	 */
 	public static IFilter edgeDetectionGradientDirectionalNorthWest(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 1,-2,-1, 1,-1,-1}));
+		float[] mCoef = new float[]{1,1,1, 1,-2,-1, 1,-1,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku północnym
 	 */
 	public static IFilter edgeDetectionGradientDirectionalNorth(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 1,-2,1, -1,-1,-1}));
+		float[] mCoef = new float[]{1,1,1, 1,-2,1, -1,-1,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr gradientowy wykrywający krawędzie w kierunku północn0-wschodnim
 	 */
 	public static IFilter edgeDetectionGradientDirectionalNorthEast(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, -1,-2,1, -1,-1,1}));
+		float[] mCoef = new float[]{1,1,1, -1,-2,1, -1,-1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	
 	//LOW PASS FILTERS
@@ -252,23 +298,24 @@
 	 * aktualnego pixela wraz ze swoimi 8 sąsiadami
 	 */
 	public static IFilter lowPassAverage3x3(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 1,1,1, 1,1,1}));
+		float[] mCoef = new float[]{1,1,1, 1,1,1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy uśredniający - podstawowy filtr uśredniający, uśrednia wartość
 	 * aktualnego pixela wraz ze swoimi 24 sąsiadami
 	 */
 	public static IFilter lowPassAverage5x5(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1}));
+		float[] mCoef = new float[]{1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy uśredniający - podstawowy filtr uśredniający, uśrednia wartość
 	 * aktualnego pixela wraz ze swoimi 20 sąsiadami (leżacymi najbliżej na kole)
 	 */
 	public static IFilter lowPassAverageCircle(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{0,1,1,1,0, 1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1, 0,1,1,1,0}));
+		float[] mCoef = new float[]{0,1,1,1,0, 1,1,1,1,1, 1,1,1,1,1, 1,1,1,1,1, 0,1,1,1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy uśredniający - uśrednia wartość
@@ -276,44 +323,48 @@
 	 * niż w przypadku filtru klasycznego
 	 */
 	public static IFilter lowPassLP1(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 1,2,1, 1,1,1}));
+		float[] mCoef = new float[]{1,1,1, 1,2,1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy uśredniający - uśrednia wartość
 	 * aktualnego pixela wraz ze swoimi 8 sąsiadami, jeszcze mniejsze rozmycie niż w przypadku LP1
 	 */
 	public static IFilter lowPassLP2(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 1,4,1, 1,1,1}));
+		float[] mCoef = new float[]{1,1,1, 1,4,1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy uśredniający - uśrednia wartość
 	 * aktualnego pixela wraz ze swoimi 8 sąsiadami, jeszcze mniejsze rozmycie niż w przypadku LP2 i LP1
 	 */
 	public static IFilter lowPassLP3(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 1,12,1, 1,1,1}));
+		float[] mCoef = new float[]{1,1,1, 1,12,1, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy piramidalny - nazwa bierze się od rozkładu czynników w macierzy,
 	 * które układają się wysokościowo w piramidę - waga pixela maleje wraz z oddalaniem od źródła
 	 */
 	public static IFilter lowPassPyramid(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{1,2,3,2,1, 2,4,6,4,2, 3,6,9,6,3, 2,4,6,4,2, 1,2,3,2,1}));
+		float[] mCoef = new float[]{1,2,3,2,1, 2,4,6,4,2, 3,6,9,6,3, 2,4,6,4,2, 1,2,3,2,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy stożkowy - nazwa bierze się od rozkładu czynników w macierzy,
 	 * które układają się wysokościowo w stożek - waga pixela maleje wraz z oddalaniem od źródła
 	 */
 	public static IFilter lowPassConical(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{0,0,1,0,0, 0,2,2,2,0, 1,2,5,2,1, 0,2,2,2,0, 0,0,1,0,0}));
+		float[] mCoef = new float[]{0,0,1,0,0, 0,2,2,2,0, 1,2,5,2,1, 0,2,2,2,0, 0,0,1,0,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy Gaussa - wartość wynikowa jest wynikiem funkcji rozkładu
 	 * normalnego - krzywej Gaussa - znaczenie punktu maleje wraz z oddalaniem od źródła
 	 */
 	public static IFilter lowPassGauss1(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,2,1, 2,4,2, 1,2,1}));
+		float[] mCoef = new float[]{1,2,1, 2,4,2, 1,2,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy Gaussa - wartość wynikowa jest wynikiem funkcji rozkładu
@@ -321,8 +372,8 @@
 	 * dokładniejszy od Gauss1 - analizuje większą liczbę pixeli
 	 */
 	public static IFilter lowPassGauss2(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{1,1,2,1,1, 1,2,4,2,1, 2,4,8,4,2, 1,2,4,2,1, 1,1,2,1,1}));
+		float[] mCoef = new float[]{1,1,2,1,1, 1,2,4,2,1, 2,4,8,4,2, 1,2,4,2,1, 1,1,2,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy Gaussa - wartość wynikowa jest wynikiem funkcji rozkładu
@@ -330,8 +381,8 @@
 	 * zmienione czynniki w stosunku do Gauss2
 	 */
 	public static IFilter lowPassGauss3(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{0,1,2,1,0, 1,4,8,4,1, 2,8,16,8,2, 1,4,8,4,1, 0,1,2,1,0}));
+		float[] mCoef = new float[]{0,1,2,1,0, 1,4,8,4,1, 2,8,16,8,2, 1,4,8,4,1, 0,1,2,1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy Gaussa - wartość wynikowa jest wynikiem funkcji rozkładu
@@ -339,21 +390,21 @@
 	 * zmienione czynniki w stosunku do Gauss2 i Gauss3
 	 */
 	public static IFilter lowPassGauss4(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{1,4,7,4,1, 4,16,26,16,4, 7,26,41,26,7, 4,16,26,16,4, 1,4,7,4,1}));
+		float[] mCoef  =new float[]{1,4,7,4,1, 4,16,26,16,4, 7,26,41,26,7, 4,16,26,16,4, 1,4,7,4,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr dolnoprzepustowy Gaussa - wersja 7x7 - obejmuje 49 pixeli
 	 */
 	public static IFilter lowPassGauss5(){
-		return new FilterMatrixAdapter(new Matrix(
-				new float[]{1,1,2,2,2,1,1, 
-						1,2,2,4,2,2,1, 
-						2,2,4,8,4,2,2,
-						2,4,8,16,8,4,2,
-						2,2,4,8,4,2,2,
-						1,2,2,4,2,2,1, 
-						1,1,2,2,2,1,1}));
+		float[] mCoef = new float[]{1,1,2,2,2,1,1, 
+				1,2,2,4,2,2,1, 
+				2,2,4,8,4,2,2,
+				2,4,8,16,8,4,2,
+				2,2,4,8,4,2,2,
+				1,2,2,4,2,2,1, 
+				1,1,2,2,2,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	
 	//HIGH PASS FILTERS
@@ -363,26 +414,30 @@
 	 * jest to podstawowy filtr wyostrzający szumy i krawędzie
 	 */
 	public static IFilter highPassMeanRemoval(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,-1, -1,9,-1, -1,-1,-1}));
+		float[] mCoef = new float[]{-1,-1,-1, -1,9,-1, -1,-1,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr górnoprzepustowy - wyostrzający charakteryzuje się mniejszym wyostrzeniem szumów niż
 	 * MeanRemoval
 	 */
 	public static IFilter highPassHP1(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,-1,0, -1,5,-1, 0,-1,0}));
+		float[] mCoef = new float[]{0,-1,0, -1,5,-1, 0,-1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr górnoprzepustowy - wyostrzający w stosunku do HP1 zmienione współczynniki
 	 */
 	public static IFilter highPassHP2(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,-2,1, -2,5,-2, 1,-2,1}));
+		float[] mCoef = new float[]{1,-2,1, -2,5,-2, 1,-2,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr górnoprzepustowy - wyostrzający większy nacisk na dany pixel niż w HP1
 	 */
 	public static IFilter highPassHP3(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,-1,0, -1,20,-1, 0,-1,0}));
+		float[] mCoef = new float[]{0,-1,0, -1,20,-1, 0,-1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	
 	//EMBOSSING FILTERS
@@ -392,55 +447,63 @@
 	 * działa w kierunku wschodnim
 	 */
 	public static IFilter embossEast(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,0,1, -1,1,1, -1,0,1}));
+		float[] mCoef = new float[]{-1,0,1, -1,1,1, -1,0,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku południowo-wschodnim
 	 */
 	public static IFilter embossSouthEast(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,0, -1,1,1, 0,1,1}));
+		float[] mCoef = new float[]{-1,-1,0, -1,1,1, 0,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku południowym
 	 */
 	public static IFilter embossSouth(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{-1,-1,-1, 0,1,0, 1,1,1}));
+		float[] mCoef = new float[]{-1,-1,-1, 0,1,0, 1,1,1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku południowo-zachodnim
 	 */
 	public static IFilter embossSouthWest(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,-1,-1, 1,1,-1, 1,1,0}));
+		float[] mCoef = new float[]{0,-1,-1, 1,1,-1, 1,1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku zachodnim
 	 */
 	public static IFilter embossWest(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,0,-1, 1,1,-1, 1,0,-1}));
+		float[] mCoef = new float[]{1,0,-1, 1,1,-1, 1,0,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku północno-zachodnim
 	 */
 	public static IFilter embossNorthWest(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,0, 1,1,-1, 0,-1,-1}));
+		float[] mCoef = new float[]{1,1,0, 1,1,-1, 0,-1,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku północnym
 	 */
 	public static IFilter embossNorth(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{1,1,1, 0,1,0, -1,0,-1}));
+		float[] mCoef = new float[]{1,1,1, 0,1,0, -1,0,-1};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 	/**
 	 * @return Filtr uwypuklający - wprowadza złudzenie wypukłości tworząc efekt płaskorzeźby,
 	 * działa w kierunku północno-wschodnim
 	 */
 	public static IFilter embossNorthEast(){
-		return new FilterMatrixAdapter(new Matrix(new float[]{0,1,1, -1,1,1, -1,-1,0}));
+		float[] mCoef = new float[]{0,1,1, -1,1,1, -1,-1,0};
+		return new FilterMatrixAdapter(new Matrix(mCoef));
 	}
 }

=== modified file 'src/main/java/manager/editor/FilterGamma.java'
--- src/main/java/manager/editor/FilterGamma.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterGamma.java	2012-04-17 18:42:22 +0000
@@ -6,26 +6,30 @@
  */
 public class FilterGamma implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(0.2f, 5.0f, 1.0f)	
+		new Range(0.2f, 5.0f, 1.0f, "Gamma")	
 	};
 	
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		if(original.getWidth() != temp.getWidth() || original.getHeight() != temp.getHeight()){
 			throw new IllegalArgumentException();
-		float mLUT[] = new float[256];
-		float gamma = 1 / mRange[0].getValue();
-		for(int i=0;i<256;i++) mLUT[i] = 255.0f * (float)Math.pow((float)i/255.0f, gamma);
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		float mLUT[] = new float[PixelData.RGBCMY_CHANNEL_PRECISION];
+		float gamma = 1.0f / mRange[0].getValue();
+		for(int i=0;i<PixelData.RGBCMY_CHANNEL_PRECISION;i++) {
+			mLUT[i] = ColorConverter.RGBCMY_BYTE_MAX * (float)Math.pow((float)i/ColorConverter.RGBCMY_BYTE_MAX, gamma);
+		}
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mData.length;i++)
-			temp.mData[i] = mLUT[(int)original.mData[i]];
+		for(int i=0;i<origData.length;i++){
+			tempData[i] = mLUT[(int)origData[i]];
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -33,7 +37,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterGrayScale.java'
--- src/main/java/manager/editor/FilterGrayScale.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterGrayScale.java	2012-04-17 18:42:22 +0000
@@ -16,41 +16,52 @@
 		mType = type;
 	}
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp){
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		float gray=0.0f,R,G,B;
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				R = original.mData[3*(i*original.mHeight+j)];
-				G = original.mData[3*(i*original.mHeight+j)+1];
-				B = original.mData[3*(i*original.mHeight+j)+2];
+		float gray=0.0f,mR,mG,mB;
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mR = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)];
+				mG = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1];
+				mB = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2];
 				switch(mType){
 				case LIGHTNESS:
-					gray = (Math.max(R, Math.max(G, B)) + Math.min(R, Math.min(G, B)))/2.0f;
+					gray = (Math.max(mR, Math.max(mG, mB)) + Math.min(mR, Math.min(mG, mB)))/2.0f;
 					break;
 				case AVERAGE:
-					gray = (R+G+B)/3.0f;
+					gray = (mR+mG+mB)/(float)PixelData.PIXEL_SIZE;
 					break;
 				case LUMINOSITY:
-					gray = 0.21f*R + 0.71f*G + 0.07f*B;
+					gray = ColorConverter.RED_LUMINOSITY * mR + 
+					ColorConverter.GREEN_LUMINOSITY * mG + 
+					ColorConverter.BLUE_LUMINOSITY * mB;
+					break;
+				default:
+					gray = 0.0f;
 					break;
 				}
-				temp.mData[3*(i*original.mHeight+j)] = gray;
-				temp.mData[3*(i*original.mHeight+j)+1] = gray;
-				temp.mData[3*(i*original.mHeight+j)+2] = gray;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = gray;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = gray;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = gray;
 			}
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 
 }

=== modified file 'src/main/java/manager/editor/FilterHSVCorrection.java'
--- src/main/java/manager/editor/FilterHSVCorrection.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/FilterHSVCorrection.java	2012-04-17 18:42:22 +0000
@@ -6,36 +6,39 @@
  */
 public class FilterHSVCorrection implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-			new Range(-180.0f, 180.0f, 0.0f),
-			new Range(-0.5f, 0.5f, 0.0f),
-			new Range(-0.5f, 0.5f, 0.0f)
+			new Range(-ColorConverter.HUE_MAX/2.0f, ColorConverter.HUE_MAX/2.0f, 0.0f, "Barwa"),
+			new Range(-ColorConverter.RGBCMY_FLOAT_MAX/2.0f, ColorConverter.RGBCMY_FLOAT_MAX/2.0f, 0.0f, "Nasycenie"),
+			new Range(-ColorConverter.RGBCMY_FLOAT_MAX/2.0f, ColorConverter.RGBCMY_FLOAT_MAX/2.0f, 0.0f, "Jasność")
 		};
 
 		@Override
-		public void apply(PixelData original, PixelData temp)
-				throws IllegalArgumentException {
-			if(original == null || temp == null) throw new NullPointerException();
-			if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+		public void apply(PixelData original, PixelData temp){
+			int mWidth = original.getWidth(), mHeight = original.getHeight();
+			if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 				throw new IllegalArgumentException();
+			}
+			float[] origData = original.getData();
+			float[] tempData = temp.getData();
 			original.toHSV(); temp.toHSV();
-			float H,S,V;
-			float Hd = mRange[0].getValue(), Sd = mRange[1].getValue(), Vd = mRange[2].getValue();
-			for(int i=0;i<original.mWidth;i++)
-				for(int j=0;j<original.mHeight;j++){
-					H = original.mData[3*(i*original.mHeight+j)];
-					S = original.mData[3*(i*original.mHeight+j)+1];
-					V = original.mData[3*(i*original.mHeight+j)+2];
-					H+=Hd; if(H >= 360.0f) H -= 360.0f;
-					if(H < 0.0f) H += 360.0f;
-					temp.mData[3*(i*original.mHeight+j)] = H;
-					temp.mData[3*(i*original.mHeight+j)+1] = Math.max(0.0f, Math.min(1.0f, S+Sd));
-					temp.mData[3*(i*original.mHeight+j)+2] = Math.max(0.0f, Math.min(1.0f, V+Vd));
+			float mH,mS,mV;
+			float dH = mRange[0].getValue(), dS = mRange[1].getValue(), dV = mRange[2].getValue();
+			for(int i=0;i<mWidth;i++){
+				for(int j=0;j<mHeight;j++){
+					mH = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)];
+					mS = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1];
+					mV = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2];
+					mH+=dH; if(mH >= ColorConverter.HUE_MAX) {mH -= ColorConverter.HUE_MAX;}
+					if(mH < 0.0f) {mH += ColorConverter.HUE_MAX;}
+					tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = mH;
+					tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mS+dS));
+					tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_FLOAT_MAX, mV+dV));
 				}	
+			}
 		}
 
 		@Override
 		public PixelData apply(PixelData image) {
-			if(image == null) return null;
+			if(image == null) {return null;}
 			PixelData ret = (PixelData)image.clone();
 			apply(image, image);
 			return ret;
@@ -43,6 +46,28 @@
 
 		@Override
 		public Range[] getRangeTable() {
-			return mRange;
+			return mRange.clone();
+		}
+
+		@Override
+		public void setRangeTable(Range[] table) {
+			if(table == null || table.length != mRange.length){
+				throw new IllegalArgumentException();
+			}
+			for(int i=0;i<table.length;i++){
+				if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+					throw new IllegalArgumentException();
+				}
+			}
+			for(int i=0;i<table.length;i++){
+				mRange[i].setValue(table[i].getValue());
+			}
+		}
+		
+		@Override
+		public void reset() {
+			for(int i=0;i<mRange.length;i++){
+				mRange[i].reset();
+			}
 		}
 }

=== modified file 'src/main/java/manager/editor/FilterImageResizeBilinear.java'
--- src/main/java/manager/editor/FilterImageResizeBilinear.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterImageResizeBilinear.java	2012-04-17 18:42:22 +0000
@@ -20,38 +20,41 @@
 	 * zapisuje obraz original do obrazu image odpowiednio go skalując
 	 */
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		float ratioX = (float)original.mWidth/(float)temp.mWidth;
-		float ratioY = (float)original.mHeight/(float)temp.mHeight;
+	public void apply(PixelData original, PixelData temp) {
+		int mOrigWidth = original.getWidth(), mOrigHeight = original.getHeight();
+		int mTempWidth = temp.getWidth(), mTempHeight = temp.getHeight();
+		float ratioX = (float)mOrigWidth/(float)mTempWidth;
+		float ratioY = (float)mOrigHeight/(float)mTempHeight;
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		float ip,jp,Rbeg,Rend,Gbeg,Gend,Bbeg,Bend,coef; 
+		float ip,jp,mRbeg,mRend,mGbeg,mGend,mBbeg,mBend,coef; 
 		int indIbeg, indIend, indJbeg, indJend;
-		for(int j=0;j<temp.mHeight;j++)
-			for(int i=0;i<temp.mWidth;i++){
+		for(int j=0;j<mTempHeight;j++){
+			for(int i=0;i<mTempWidth;i++){
 				ip = (float)i*ratioX;
 				jp = (float)j*ratioY;
 				//wspolrzene kraty próbkowania
-				if((int)ip >= original.mWidth) indIbeg = original.mWidth-1; else indIbeg = (int)ip;
-				if((int)jp >= original.mHeight) indJbeg = original.mHeight-1; else indJbeg = (int)jp;
-				if(indIbeg + 1 >= original.mWidth) indIend = original.mWidth-1; else indIend = indIbeg+1;
-				if(indJbeg + 1 >= original.mHeight) indJend = original.mHeight-1; else indJend = indJbeg+1;
-				jp = Math.min(original.mHeight, jp); ip = Math.min(original.mWidth, ip);
+				if((int)ip >= mOrigWidth) {indIbeg = mOrigWidth-1;} else {indIbeg = (int)ip;}
+				if((int)jp >= mOrigHeight) {indJbeg = mOrigHeight-1;} else {indJbeg = (int)jp;}
+				if(indIbeg + 1 >= mOrigWidth) {indIend = mOrigWidth-1;} else {indIend = indIbeg+1;}
+				if(indJbeg + 1 >= mOrigHeight) {indJend = mOrigHeight-1;} else {indJend = indJbeg+1;}
+				jp = Math.min(mOrigHeight, jp); ip = Math.min(mOrigWidth, ip);
 				//probkowanie poziome
 				coef = ip-(float)indIbeg;
-				Rbeg = original.mData[3*(indJbeg*original.mWidth+indIbeg)] * coef + original.mData[3*(indJbeg*original.mWidth+indIend)] * (1.0f-coef);
-				Gbeg = original.mData[3*(indJbeg*original.mWidth+indIbeg)+1] * coef + original.mData[3*(indJbeg*original.mWidth+indIend)+1] * (1.0f-coef);
-				Bbeg = original.mData[3*(indJbeg*original.mWidth+indIbeg)+2] * coef + original.mData[3*(indJbeg*original.mWidth+indIend)+2] * (1.0f-coef);
-				Rend = original.mData[3*(indJend*original.mWidth+indIbeg)] * coef + original.mData[3*(indJend*original.mWidth+indIend)] * (1.0f-coef);
-				Gend = original.mData[3*(indJend*original.mWidth+indIbeg)+1] * coef + original.mData[3*(indJend*original.mWidth+indIend)+1] * (1.0f-coef);
-				Bend = original.mData[3*(indJend*original.mWidth+indIbeg)+2] * coef + original.mData[3*(indJend*original.mWidth+indIend)+2] * (1.0f-coef);
+				mRbeg = origData[PixelData.PIXEL_SIZE*(indJbeg*mOrigWidth+indIbeg)] * coef + origData[PixelData.PIXEL_SIZE*(indJbeg*mOrigWidth+indIend)] * (1.0f-coef);
+				mGbeg = origData[PixelData.PIXEL_SIZE*(indJbeg*mOrigWidth+indIbeg)+1] * coef + origData[PixelData.PIXEL_SIZE*(indJbeg*mOrigWidth+indIend)+1] * (1.0f-coef);
+				mBbeg = origData[PixelData.PIXEL_SIZE*(indJbeg*mOrigWidth+indIbeg)+2] * coef + origData[PixelData.PIXEL_SIZE*(indJbeg*mOrigWidth+indIend)+2] * (1.0f-coef);
+				mRend = origData[PixelData.PIXEL_SIZE*(indJend*mOrigWidth+indIbeg)] * coef + origData[PixelData.PIXEL_SIZE*(indJend*mOrigWidth+indIend)] * (1.0f-coef);
+				mGend = origData[PixelData.PIXEL_SIZE*(indJend*mOrigWidth+indIbeg)+1] * coef + origData[PixelData.PIXEL_SIZE*(indJend*mOrigWidth+indIend)+1] * (1.0f-coef);
+				mBend = origData[PixelData.PIXEL_SIZE*(indJend*mOrigWidth+indIbeg)+2] * coef + origData[PixelData.PIXEL_SIZE*(indJend*mOrigWidth+indIend)+2] * (1.0f-coef);
 				//probkowanie pionowe
 				coef = jp-(float)indJbeg;
-				temp.mData[3*(j*temp.mWidth+i)] = Rbeg * coef + Rend * (1.0f-coef);
-				temp.mData[3*(j*temp.mWidth+i)+1] = Gbeg * coef + Gend * (1.0f-coef);
-				temp.mData[3*(j*temp.mWidth+i)+2] = Bbeg * coef + Bend * (1.0f-coef);
+				tempData[PixelData.PIXEL_SIZE*(j*mTempWidth+i)] = mRbeg * coef + mRend * (1.0f-coef);
+				tempData[PixelData.PIXEL_SIZE*(j*mTempWidth+i)+1] = mGbeg * coef + mGend * (1.0f-coef);
+				tempData[PixelData.PIXEL_SIZE*(j*mTempWidth+i)+2] = mBbeg * coef + mBend * (1.0f-coef);
 			}
+		}
 	}
 	/**
 	 * Odwrotnie niż w przypadku zwykłych filtrów zwraca obraz zmodyfikowany, 
@@ -60,9 +63,12 @@
 	 */
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = new PixelData(mWidth, mHeight);
 		apply(image, ret);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 }

=== modified file 'src/main/java/manager/editor/FilterImageResizeNearestNeighbour.java'
--- src/main/java/manager/editor/FilterImageResizeNearestNeighbour.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterImageResizeNearestNeighbour.java	2012-04-17 18:42:22 +0000
@@ -14,25 +14,28 @@
 	 * zapisuje obraz original do obrazu image odpowiednio go skalując
 	 */
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		float ratioX = (float)original.mWidth/(float)temp.mWidth;
-		float ratioY = (float)original.mHeight/(float)temp.mHeight;
+	public void apply(PixelData original, PixelData temp){
+		int mOrigWidth = original.getWidth(), mOrigHeight = original.getHeight();
+		int mTempWidth = temp.getWidth(), mTempHeight = temp.getHeight();
+		float ratioX = (float)mOrigWidth/(float)mTempWidth;
+		float ratioY = (float)mOrigHeight/(float)mTempHeight;
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
 		float ip,jp; int indI, indJ;
-		for(int j=0;j<temp.mHeight;j++)
-			for(int i=0;i<temp.mWidth;i++){
+		for(int j=0;j<mTempHeight;j++){
+			for(int i=0;i<mTempWidth;i++){
 				ip = (float)i*ratioX;
 				jp = (float)j*ratioY;
-				if((float)((int)ip+1)-ip < ip-(float)((int)ip)) indI = (int)ip+1; else indI = (int)ip;
-				if((float)((int)jp+1)-jp < jp-(float)((int)jp)) indJ = (int)jp+1; else indJ = (int)jp;
-				indI = Math.max(0, Math.min(indI, original.mWidth-1));
-				indJ = Math.max(0, Math.min(indJ, original.mHeight-1));
-				temp.mData[3*(j*temp.mWidth+i)] = original.mData[3*(indJ*original.mWidth+indI)];
-				temp.mData[3*(j*temp.mWidth+i)+1] = original.mData[3*(indJ*original.mWidth+indI)+1];
-				temp.mData[3*(j*temp.mWidth+i)+2] = original.mData[3*(indJ*original.mWidth+indI)+2];
+				if((float)((int)ip+1)-ip < ip-(float)((int)ip)) {indI = (int)ip+1;} else {indI = (int)ip;}
+				if((float)((int)jp+1)-jp < jp-(float)((int)jp)) {indJ = (int)jp+1;} else {indJ = (int)jp;}
+				indI = Math.max(0, Math.min(indI, mOrigWidth-1));
+				indJ = Math.max(0, Math.min(indJ, mOrigHeight-1));
+				tempData[PixelData.PIXEL_SIZE*(j*mTempWidth+i)] = origData[PixelData.PIXEL_SIZE*(indJ*mOrigWidth+indI)];
+				tempData[PixelData.PIXEL_SIZE*(j*mTempWidth+i)+1] = origData[PixelData.PIXEL_SIZE*(indJ*mOrigWidth+indI)+1];
+				tempData[PixelData.PIXEL_SIZE*(j*mTempWidth+i)+2] = origData[PixelData.PIXEL_SIZE*(indJ*mOrigWidth+indI)+2];
 			}
+		}
 	}
 	/**
 	 * Odwrotnie niż w przypadku zwykłych filtrów zwraca obraz zmodyfikowany, 
@@ -41,9 +44,12 @@
 	 */
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = new PixelData(mWidth, mHeight);
 		apply(image, ret);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 }

=== modified file 'src/main/java/manager/editor/FilterImageRotate270.java'
--- src/main/java/manager/editor/FilterImageRotate270.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterImageRotate270.java	2012-04-17 18:42:22 +0000
@@ -9,18 +9,22 @@
 	 * zapisuje obraz original do obrazu image obracając go
 	 */
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mHeight || original.mHeight != temp.mWidth)
+	public void apply(PixelData original, PixelData temp) {
+		int mOrigWidth = original.getWidth(), mOrigHeight = original.getHeight();
+		int mTempWidth = temp.getWidth(), mTempHeight = temp.getHeight();
+		if(mOrigWidth != mTempHeight || mOrigHeight != mTempWidth){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				temp.mData[3*((temp.mHeight-1-i)*temp.mWidth+j)] = original.mData[3*(j*original.mWidth+i)];
-				temp.mData[3*((temp.mHeight-1-i)*temp.mWidth+j)+1] = original.mData[3*(j*original.mWidth+i)+1];
-				temp.mData[3*((temp.mHeight-1-i)*temp.mWidth+j)+2] = original.mData[3*(j*original.mWidth+i)+2];
+		for(int i=0;i<mOrigWidth;i++){
+			for(int j=0;j<mOrigHeight;j++){
+				tempData[PixelData.PIXEL_SIZE*((mTempHeight-1-i)*mTempWidth+j)] = origData[PixelData.PIXEL_SIZE*(j*mOrigWidth+i)];
+				tempData[PixelData.PIXEL_SIZE*((mTempHeight-1-i)*mTempWidth+j)+1] = origData[PixelData.PIXEL_SIZE*(j*mOrigWidth+i)+1];
+				tempData[PixelData.PIXEL_SIZE*((mTempHeight-1-i)*mTempWidth+j)+2] = origData[PixelData.PIXEL_SIZE*(j*mOrigWidth+i)+2];
 			}
+		}
 	}
 	/**
 	 * Odwrotnie niż w przypadku zwykłych filtrów zwraca obraz zmodyfikowany, 
@@ -29,10 +33,12 @@
 	 */
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
-		PixelData ret = new PixelData(image.mHeight, image.mWidth);
+		if(image == null) {return null;}
+		PixelData ret = new PixelData(image.getHeight(), image.getWidth());
 		apply(image, ret);
 		return ret;
 	}
-
+	
+	@Override
+	public void reset() {}
 }

=== modified file 'src/main/java/manager/editor/FilterImageRotate90.java'
--- src/main/java/manager/editor/FilterImageRotate90.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterImageRotate90.java	2012-04-17 18:42:22 +0000
@@ -9,18 +9,22 @@
 	 * zapisuje obraz original do obrazu image obracając go
 	 */
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mHeight || original.mHeight != temp.mWidth)
+	public void apply(PixelData original, PixelData temp){
+		int mOrigWidth = original.getWidth(), mOrigHeight = original.getHeight();
+		int mTempWidth = temp.getWidth(), mTempHeight = temp.getHeight();
+		if(mOrigWidth != mTempHeight || mOrigHeight != mTempWidth){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				temp.mData[3*(i*temp.mWidth+temp.mWidth-1-j)] = original.mData[3*(j*original.mWidth+i)];
-				temp.mData[3*(i*temp.mWidth+temp.mWidth-1-j)+1] = original.mData[3*(j*original.mWidth+i)+1];
-				temp.mData[3*(i*temp.mWidth+temp.mWidth-1-j)+2] = original.mData[3*(j*original.mWidth+i)+2];
+		for(int i=0;i<mOrigWidth;i++){
+			for(int j=0;j<mOrigHeight;j++){
+				tempData[PixelData.PIXEL_SIZE*(i*mTempWidth+mTempWidth-1-j)] = origData[PixelData.PIXEL_SIZE*(j*mOrigWidth+i)];
+				tempData[PixelData.PIXEL_SIZE*(i*mTempWidth+mTempWidth-1-j)+1] = origData[PixelData.PIXEL_SIZE*(j*mOrigWidth+i)+1];
+				tempData[PixelData.PIXEL_SIZE*(i*mTempWidth+mTempWidth-1-j)+2] = origData[PixelData.PIXEL_SIZE*(j*mOrigWidth+i)+2];
 			}
+		}
 	}
 	/**
 	 * Odwrotnie niż w przypadku zwykłych filtrów zwraca obraz zmodyfikowany, 
@@ -29,10 +33,13 @@
 	 */
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
-		PixelData ret = new PixelData(image.mHeight, image.mWidth);
+		if(image == null) {return null;}
+		PixelData ret = new PixelData(image.getHeight(), image.getWidth());
 		apply(image, ret);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 
 }

=== modified file 'src/main/java/manager/editor/FilterImageSymetryOX.java'
--- src/main/java/manager/editor/FilterImageSymetryOX.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterImageSymetryOX.java	2012-04-17 18:42:22 +0000
@@ -9,18 +9,21 @@
 	 * zapisuje obraz original do obrazu image odbijając go wzdłuż osi pionowej
 	 */
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight)
+	public void apply(PixelData original, PixelData temp){
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				temp.mData[3*(j*original.mWidth+original.mWidth-i-1)] = original.mData[3*(j*original.mWidth+i)];
-				temp.mData[3*(j*original.mWidth+original.mWidth-i-1)+1] = original.mData[3*(j*original.mWidth+i)+1];
-				temp.mData[3*(j*original.mWidth+original.mWidth-i-1)+2] = original.mData[3*(j*original.mWidth+i)+2];
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+mWidth-i-1)] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)];
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+mWidth-i-1)+1] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1];
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+mWidth-i-1)+2] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2];
 			}
+		}
 	}
 	/**
 	 * Odwrotnie niż w przypadku zwykłych filtrów zwraca obraz zmodyfikowany, 
@@ -29,9 +32,12 @@
 	 */
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
-		PixelData ret = new PixelData(image.mWidth, image.mHeight);
+		if(image == null) {return null;}
+		PixelData ret = new PixelData(image.getWidth(), image.getHeight());
 		apply(image, ret);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 }

=== modified file 'src/main/java/manager/editor/FilterImageSymetryOY.java'
--- src/main/java/manager/editor/FilterImageSymetryOY.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterImageSymetryOY.java	2012-04-17 18:42:22 +0000
@@ -9,18 +9,21 @@
 	 * zapisuje obraz original do obrazu image odbijając go wzdłuż osi poziomej
 	 */
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight)
+	public void apply(PixelData original, PixelData temp){
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				temp.mData[3*((original.mHeight-1-j)*original.mWidth+i)] = original.mData[3*(j*original.mWidth+i)];
-				temp.mData[3*((original.mHeight-1-j)*original.mWidth+i)+1] = original.mData[3*(j*original.mWidth+i)+1];
-				temp.mData[3*((original.mHeight-1-j)*original.mWidth+i)+2] = original.mData[3*(j*original.mWidth+i)+2];
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				tempData[PixelData.PIXEL_SIZE*((mHeight-1-j)*mWidth+i)] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)];
+				tempData[PixelData.PIXEL_SIZE*((mHeight-1-j)*mWidth+i)+1] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1];
+				tempData[PixelData.PIXEL_SIZE*((mHeight-1-j)*mWidth+i)+2] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2];
 			}
+		}
 	}
 	/**
 	 * Odwrotnie niż w przypadku zwykłych filtrów zwraca obraz zmodyfikowany, 
@@ -29,9 +32,12 @@
 	 */
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
-		PixelData ret = new PixelData(image.mWidth, image.mHeight);
+		if(image == null) {return null;}
+		PixelData ret = new PixelData(image.getWidth(), image.getHeight());
 		apply(image, ret);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 }
\ No newline at end of file

=== added file 'src/main/java/manager/editor/FilterLUTCorrectionCMY.java'
--- src/main/java/manager/editor/FilterLUTCorrectionCMY.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/FilterLUTCorrectionCMY.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,73 @@
+package manager.editor;
+
+/**
+ * Filtr umożliwiający kanałową korekte CMY przy pomocy tablicy LUT
+ * @author Patryk
+ */
+public class FilterLUTCorrectionCMY implements IFilterLUT{
+	private LUTTable[] mTable = new LUTTable[3];
+	
+	public FilterLUTCorrectionCMY(){
+		for(int i=0;i<mTable.length;i++){
+			mTable[i] = new LUTTable(null);
+		}
+	}
+
+	@Override
+	public void apply(PixelData original, PixelData temp) {
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
+			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		original.toCMY(); temp.toCMY();
+		float mC,mM,mY;
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mC = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)] / ColorConverter.RGBCMY_BYTE_MAX;
+				mM = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] / ColorConverter.RGBCMY_BYTE_MAX;
+				mY = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] / ColorConverter.RGBCMY_BYTE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = mTable[0].getValue(mC) * ColorConverter.RGBCMY_BYTE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = mTable[1].getValue(mM) * ColorConverter.RGBCMY_BYTE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = mTable[2].getValue(mY) * ColorConverter.RGBCMY_BYTE_MAX;
+			}	
+		}
+	}
+
+	@Override
+	public PixelData apply(PixelData image) {
+		if(image == null) {return null;}
+		PixelData ret = (PixelData)image.clone();
+		apply(image, image);
+		return ret;
+	}
+
+	@Override
+	public LUTTable[] getConversionTable() {
+		return mTable.clone();
+	}
+
+	@Override
+	public void setConversionTable(LUTTable[] table) {
+		if(table == null || table.length != mTable.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i] == null){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mTable[i] = table[i];
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mTable.length;i++){
+			mTable[i].reset();
+		}
+	}
+
+}

=== added file 'src/main/java/manager/editor/FilterLUTCorrectionHSV.java'
--- src/main/java/manager/editor/FilterLUTCorrectionHSV.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/FilterLUTCorrectionHSV.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,73 @@
+package manager.editor;
+
+/**
+ * Filtr umożliwiający kanałową korekte HSV przy pomocy tablicy LUT
+ * @author Patryk
+ */
+public class FilterLUTCorrectionHSV implements IFilterLUT{
+	private LUTTable[] mTable = new LUTTable[3];
+	
+	public FilterLUTCorrectionHSV(){
+		for(int i=0;i<mTable.length;i++){
+			mTable[i] = new LUTTable(null);
+		}
+	}
+
+	@Override
+	public void apply(PixelData original, PixelData temp) {
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
+			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		original.toHSV(); temp.toHSV();
+		float mH,mS,mV;
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mH = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)] / ColorConverter.HUE_MAX;
+				mS = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1];
+				mV = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2];
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = mTable[0].getValue(mH) * ColorConverter.HUE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = mTable[1].getValue(mS);
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = mTable[2].getValue(mV);
+			}	
+		}
+	}
+
+	@Override
+	public PixelData apply(PixelData image) {
+		if(image == null) {return null;}
+		PixelData ret = (PixelData)image.clone();
+		apply(image, image);
+		return ret;
+	}
+
+	@Override
+	public LUTTable[] getConversionTable() {
+		return mTable.clone();
+	}
+
+	@Override
+	public void setConversionTable(LUTTable[] table) {
+		if(table == null || table.length != mTable.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i] == null){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mTable[i] = table[i];
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mTable.length;i++){
+			mTable[i].reset();
+		}
+	}
+
+}

=== added file 'src/main/java/manager/editor/FilterLUTCorrectionRGB.java'
--- src/main/java/manager/editor/FilterLUTCorrectionRGB.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/FilterLUTCorrectionRGB.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,73 @@
+package manager.editor;
+
+/**
+ * Filtr umożliwiający kanałową korektę RGB przy pomocy tablicy LUT
+ * @author Patryk
+ */
+public class FilterLUTCorrectionRGB implements IFilterLUT{
+	private LUTTable[] mTable = new LUTTable[3];
+	
+	public FilterLUTCorrectionRGB(){
+		for(int i=0;i<mTable.length;i++){
+			mTable[i] = new LUTTable(null);
+		}
+	}
+
+	@Override
+	public void apply(PixelData original, PixelData temp) {
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
+			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		original.toRGB(); temp.toRGB();
+		float mR,mG,mB;
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mR = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)] / ColorConverter.RGBCMY_BYTE_MAX;
+				mG = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] / ColorConverter.RGBCMY_BYTE_MAX;
+				mB = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] / ColorConverter.RGBCMY_BYTE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = mTable[0].getValue(mR) * ColorConverter.RGBCMY_BYTE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = mTable[1].getValue(mG) * ColorConverter.RGBCMY_BYTE_MAX;
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = mTable[2].getValue(mB) * ColorConverter.RGBCMY_BYTE_MAX;
+			}	
+		}
+	}
+
+	@Override
+	public PixelData apply(PixelData image) {
+		if(image == null) {return null;}
+		PixelData ret = (PixelData)image.clone();
+		apply(image, image);
+		return ret;
+	}
+
+	@Override
+	public LUTTable[] getConversionTable() {
+		return mTable.clone();
+	}
+
+	@Override
+	public void setConversionTable(LUTTable[] table) {
+		if(table == null || table.length != mTable.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i] == null){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mTable[i] = table[i];
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mTable.length;i++){
+			mTable[i].reset();
+		}
+	}
+
+}

=== modified file 'src/main/java/manager/editor/FilterMatrixAdapter.java'
--- src/main/java/manager/editor/FilterMatrixAdapter.java	2012-04-07 13:25:56 +0000
+++ src/main/java/manager/editor/FilterMatrixAdapter.java	2012-04-17 18:42:22 +0000
@@ -6,51 +6,58 @@
  */
 public class FilterMatrixAdapter implements IFilterMatrix{
 	private Matrix mMatrix;
+	private final Matrix mDefault;
 	
 	FilterMatrixAdapter(Matrix mat){
 		mMatrix = mat;
+		mDefault = new Matrix(mMatrix.getTable());
 	}
 
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp){
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
 		int matSize = mMatrix.getSize();
 		int center = matSize/2, ip, jp;
 		float[] matTable = mMatrix.getTable();
-		float sum = 0.0f, R,G,B; 
-		for(int i=0;i<matTable.length;i++) sum += matTable[i];
-		for(int j=0;j<original.mHeight;j++)
-			for(int i=0;i<original.mWidth;i++){
-				R = G = B = 0.0f;
+		float sum = 0.0f, mR,mG,mB; 
+		for(int i=0;i<matTable.length;i++) {
+			sum += matTable[i];
+		}
+		for(int j=0;j<mHeight;j++){
+			for(int i=0;i<mWidth;i++){
+				mR=0.0f; mG=0.0f; mB = 0.0f;
 				for(int mj=0;mj<matSize;mj++){
 					jp = j+mj-center;
 					for(int mi=0;mi<matSize;mi++){
 						ip = i+mi-center;
-						if(ip >= 0 && ip < original.mWidth && jp >= 0 && jp < original.mHeight){
-							R += original.mData[3*(jp*original.mWidth+ip)] * matTable[mj*matSize+mi];
-							G += original.mData[3*(jp*original.mWidth+ip)+1] * matTable[mj*matSize+mi];
-							B += original.mData[3*(jp*original.mWidth+ip)+2] * matTable[mj*matSize+mi];
+						if(ip >= 0 && ip < mWidth && jp >= 0 && jp < mHeight){
+							mR += origData[PixelData.PIXEL_SIZE*(jp*mWidth+ip)] * matTable[mj*matSize+mi];
+							mG += origData[PixelData.PIXEL_SIZE*(jp*mWidth+ip)+1] * matTable[mj*matSize+mi];
+							mB += origData[PixelData.PIXEL_SIZE*(jp*mWidth+ip)+2] * matTable[mj*matSize+mi];
 						}
 					}
 				}
 				if(sum != 0.0f){
-					R /= sum;
-					G /= sum;
-					B /= sum;
+					mR /= sum;
+					mG /= sum;
+					mB /= sum;
 				}
-				temp.mData[3*(j*original.mWidth+i)] = Math.max(0.0f, Math.min(255.0f, R));
-				temp.mData[3*(j*original.mWidth+i)+1] = Math.max(0.0f, Math.min(255.0f, G));
-				temp.mData[3*(j*original.mWidth+i)+2] = Math.max(0.0f, Math.min(255.0f, B));
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mR));
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mG));
+				tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mB));
 			}
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(ret, image);
 		return ret;
@@ -65,5 +72,10 @@
 	public void setMatrix(Matrix matrix) {
 		mMatrix = matrix;
 	}
+	
+	@Override
+	public void reset() {
+		mMatrix = new Matrix(mDefault.getTable());
+	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterNegative.java'
--- src/main/java/manager/editor/FilterNegative.java	2012-04-07 10:12:47 +0000
+++ src/main/java/manager/editor/FilterNegative.java	2012-04-17 18:42:22 +0000
@@ -6,20 +6,26 @@
  */
 public class FilterNegative implements IFilter {
 	@Override
-	public void apply(PixelData original, PixelData temp) 
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp){
+		if(original.getWidth() != temp.getWidth() || original.getHeight() != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mData.length;i++) temp.mData[i] = 255.0f - original.mData[i];
+		for(int i=0;i<origData.length;i++) {
+			tempData[i] = ColorConverter.RGBCMY_BYTE_MAX - origData[i];
+		}
 	}
 	
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {}
 }

=== modified file 'src/main/java/manager/editor/FilterRGBCorrection.java'
--- src/main/java/manager/editor/FilterRGBCorrection.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterRGBCorrection.java	2012-04-17 18:42:22 +0000
@@ -6,34 +6,37 @@
  */
 public class FilterRGBCorrection implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(-128.0f, 128.0f, 0.0f),
-		new Range(-128.0f, 128.0f, 0.0f),
-		new Range(-128.0f, 128.0f, 0.0f)
+		new Range(-ColorConverter.RGBCMY_BYTE_MAX/2.0f, ColorConverter.RGBCMY_BYTE_MAX/2.0f, 0.0f, "Czerwony"),
+		new Range(-ColorConverter.RGBCMY_BYTE_MAX/2.0f, ColorConverter.RGBCMY_BYTE_MAX/2.0f, 0.0f, "Zielony"),
+		new Range(-ColorConverter.RGBCMY_BYTE_MAX/2.0f, ColorConverter.RGBCMY_BYTE_MAX/2.0f, 0.0f, "Niebieski")
 	};
 
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		original.toRGB(); temp.toRGB();
-		float R,G,B;
-		float Rd = mRange[0].getValue(), Gd = mRange[1].getValue(), Bd = mRange[2].getValue();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				R = original.mData[3*(i*original.mHeight+j)];
-				G = original.mData[3*(i*original.mHeight+j)+1];
-				B = original.mData[3*(i*original.mHeight+j)+2];
-				temp.mData[3*(i*original.mHeight+j)] = Math.max(0.0f, Math.min(255.0f, R+Rd));
-				temp.mData[3*(i*original.mHeight+j)+1] = Math.max(0.0f, Math.min(255.0f, G+Gd));
-				temp.mData[3*(i*original.mHeight+j)+2] = Math.max(0.0f, Math.min(255.0f, B+Bd));
+		float mR,mG,mB;
+		float dR = mRange[0].getValue(), dG = mRange[1].getValue(), dB = mRange[2].getValue();
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mR = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)];
+				mG = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1];
+				mB = origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2];
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mR+dR));
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mG+dG));
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, mB+dB));
 			}	
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -41,7 +44,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterSepia.java'
--- src/main/java/manager/editor/FilterSepia.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/FilterSepia.java	2012-04-17 18:42:22 +0000
@@ -6,29 +6,34 @@
  */
 public class FilterSepia implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-		new Range(20.0f, 50.0f, 30.0f)
+		new Range(20.0f, 50.0f, 30.0f, "Nasycenie")
 	};
 
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp){
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		float det = mRange[0].getValue(), grey;
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				grey = 0.21f*temp.mData[3*(i*original.mHeight+j)] + 0.71f*temp.mData[3*(i*original.mHeight+j)+1] + 0.07f*temp.mData[3*(i*original.mHeight+j)+2];
-				temp.mData[3*(i*original.mHeight+j)] = Math.min(255.0f, grey+2*det);
-				temp.mData[3*(i*original.mHeight+j)+1] = Math.min(255.0f, grey+det);
-				temp.mData[3*(i*original.mHeight+j)+2] = Math.min(255.0f, grey);
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				grey = ColorConverter.RED_LUMINOSITY * origData[PixelData.PIXEL_SIZE*(i*mHeight+j)] + 
+						ColorConverter.GREEN_LUMINOSITY * origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] + 
+						ColorConverter.BLUE_LUMINOSITY * origData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2];
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)] = Math.min(ColorConverter.RGBCMY_BYTE_MAX, grey+2*det);
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+1] = Math.min(ColorConverter.RGBCMY_BYTE_MAX, grey+det);
+				tempData[PixelData.PIXEL_SIZE*(i*mHeight+j)+2] = Math.min(ColorConverter.RGBCMY_BYTE_MAX, grey);
 			}
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -36,6 +41,28 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 }

=== modified file 'src/main/java/manager/editor/FilterSolarize.java'
--- src/main/java/manager/editor/FilterSolarize.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/FilterSolarize.java	2012-04-17 18:42:22 +0000
@@ -12,28 +12,31 @@
  */
 public class FilterSolarize implements IFilterRange{
 	private final Range[] mRange = new Range[]{
-			new Range(0.0f, 255.0f, 127.5f)
+			new Range(0.0f, ColorConverter.RGBCMY_BYTE_MAX, ColorConverter.RGBCMY_BYTE_MAX/2.0f, "Próg")
 	};
 	
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		if(original.getWidth() != temp.getWidth() || original.getHeight() != temp.getHeight()){
 			throw new IllegalArgumentException();
-		float mLUT[] = new float[256];
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
+		float mLUT[] = new float[PixelData.RGBCMY_CHANNEL_PRECISION];
 		float prog = mRange[0].getValue();
-		for(int i=0;i<256;i++) 
-			if(i < prog) mLUT[i] = (float)i;
-			else mLUT[i] = (float)(255-i);
+		for(int i=0;i<PixelData.RGBCMY_CHANNEL_PRECISION;i++) {
+			if(i < prog) {mLUT[i] = (float)i;}
+			else {mLUT[i] = ColorConverter.RGBCMY_BYTE_MAX-(float)i;}
+		}
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mData.length;i++)
-			temp.mData[i] = mLUT[(int)original.mData[i]];
+		for(int i=0;i<origData.length;i++){
+			tempData[i] = mLUT[(int)origData[i]];
+		}
 	}
 
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
@@ -41,7 +44,29 @@
 
 	@Override
 	public Range[] getRangeTable() {
-		return mRange;
+		return mRange.clone();
+	}
+
+	@Override
+	public void setRangeTable(Range[] table) {
+		if(table == null || table.length != mRange.length){
+			throw new IllegalArgumentException();
+		}
+		for(int i=0;i<table.length;i++){
+			if(table[i].getMin() != mRange[i].getMin() || table[i].getMax() != mRange[i].getMax()){
+				throw new IllegalArgumentException();
+			}
+		}
+		for(int i=0;i<table.length;i++){
+			mRange[i].setValue(table[i].getValue());
+		}
+	}
+	
+	@Override
+	public void reset() {
+		for(int i=0;i<mRange.length;i++){
+			mRange[i].reset();
+		}
 	}
 
 }

=== modified file 'src/main/java/manager/editor/FilterTexturer.java'
--- src/main/java/manager/editor/FilterTexturer.java	2012-04-09 18:10:58 +0000
+++ src/main/java/manager/editor/FilterTexturer.java	2012-04-17 18:42:22 +0000
@@ -18,7 +18,7 @@
 	 * aby pracować
 	 */
 	FilterTexturer(ITextureGenerator generator){
-		if(generator == null) throw new NullPointerException();
+		if(generator == null) {throw new NullPointerException();}
 		mGenerator = generator;
 	}
 	/**
@@ -52,46 +52,58 @@
 	}
 	
 	@Override
-	public void apply(PixelData original, PixelData temp)
-			throws IllegalArgumentException {
-		if(original == null || temp == null) throw new NullPointerException();
-		if(original.mWidth != temp.mWidth || original.mHeight != temp.mHeight) 
+	public void apply(PixelData original, PixelData temp) {
+		int mWidth = original.getWidth(), mHeight = original.getHeight();
+		if(mWidth != temp.getWidth() || mHeight != temp.getHeight()){
 			throw new IllegalArgumentException();
+		}
+		float[] origData = original.getData();
+		float[] tempData = temp.getData();
 		float gray; ColorRGB mCol = new ColorRGB(0,0,0);
 		original.toRGB(); temp.toRGB();
-		for(int i=0;i<original.mWidth;i++)
-			for(int j=0;j<original.mHeight;j++){
-				mGenerator.getValue((float)i/(float)original.mWidth, (float)j/(float)original.mHeight, mCol);
+		for(int i=0;i<mWidth;i++){
+			for(int j=0;j<mHeight;j++){
+				mGenerator.getValue((float)i/(float)mWidth, (float)j/(float)mHeight, mCol);
 				switch(mMode){
 				case ADD:
-					temp.mData[3*(j*original.mWidth+i)] = Math.min(255.0f, original.mData[3*(j*original.mWidth+i)] + mCol.getR()*255.0f);
-					temp.mData[3*(j*original.mWidth+i)+1] = Math.min(255.0f, original.mData[3*(j*original.mWidth+i)+1] + mCol.getG()*255.0f);
-					temp.mData[3*(j*original.mWidth+i)+2] = Math.min(255.0f, original.mData[3*(j*original.mWidth+i)+2] + mCol.getB()*255.0f);
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = Math.min(ColorConverter.RGBCMY_BYTE_MAX, origData[PixelData.PIXEL_SIZE*(j*mWidth+i)] + mCol.getR()*ColorConverter.RGBCMY_BYTE_MAX);
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = Math.min(ColorConverter.RGBCMY_BYTE_MAX, origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] + mCol.getG()*ColorConverter.RGBCMY_BYTE_MAX);
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = Math.min(ColorConverter.RGBCMY_BYTE_MAX, origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] + mCol.getB()*ColorConverter.RGBCMY_BYTE_MAX);
 					break;
 				case SUBSTRACT:
-					temp.mData[3*(j*original.mWidth+i)] = Math.max(0.0f, original.mData[3*(j*original.mWidth+i)] - mCol.getR()*255.0f);
-					temp.mData[3*(j*original.mWidth+i)+1] = Math.max(0.0f, original.mData[3*(j*original.mWidth+i)+1] - mCol.getG()*255.0f);
-					temp.mData[3*(j*original.mWidth+i)+2] = Math.max(0.0f, original.mData[3*(j*original.mWidth+i)+2] - mCol.getB()*255.0f);
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = Math.max(0.0f, origData[PixelData.PIXEL_SIZE*(j*mWidth+i)] - mCol.getR()*ColorConverter.RGBCMY_BYTE_MAX);
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = Math.max(0.0f, origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] - mCol.getG()*ColorConverter.RGBCMY_BYTE_MAX);
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = Math.max(0.0f, origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] - mCol.getB()*ColorConverter.RGBCMY_BYTE_MAX);
 					break;
 				case MULTIPLY:
-					temp.mData[3*(j*original.mWidth+i)] = original.mData[3*(j*original.mWidth+i)] * mCol.getR();
-					temp.mData[3*(j*original.mWidth+i)+1] = original.mData[3*(j*original.mWidth+i)+1] * mCol.getG();
-					temp.mData[3*(j*original.mWidth+i)+2] = original.mData[3*(j*original.mWidth+i)+2] * mCol.getB();
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)] * mCol.getR();
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] * mCol.getG();
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] * mCol.getB();
 					break;
 				case MASK:
-					gray = 0.21f*original.mData[3*(j*original.mWidth+i)] + 0.71f*original.mData[3*(j*original.mWidth+i)+1] + 0.07f*original.mData[3*(j*original.mWidth+i)+2];
-					temp.mData[3*(j*original.mWidth+i)] = gray * mCol.getR();
-					temp.mData[3*(j*original.mWidth+i)+1] = gray * mCol.getG();
-					temp.mData[3*(j*original.mWidth+i)+2] = gray * mCol.getB();
+					gray = 0.21f*origData[PixelData.PIXEL_SIZE*(j*mWidth+i)] + 
+					0.71f*origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] + 
+					0.07f*origData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2];
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)] = gray * mCol.getR();
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+1] = gray * mCol.getG();
+					tempData[PixelData.PIXEL_SIZE*(j*mWidth+i)+2] = gray * mCol.getB();
+					break;
+				default:
 					break;
 				}
 			}
+		}
 	}
 	@Override
 	public PixelData apply(PixelData image) {
-		if(image == null) return null;
+		if(image == null) {return null;}
 		PixelData ret = (PixelData)image.clone();
 		apply(image, image);
 		return ret;
 	}
+	
+	@Override
+	public void reset() {
+		mMode = TexturingMode.ADD;
+	}
 }

=== modified file 'src/main/java/manager/editor/Gradient.java'
--- src/main/java/manager/editor/Gradient.java	2012-04-10 17:51:49 +0000
+++ src/main/java/manager/editor/Gradient.java	2012-04-17 18:42:22 +0000
@@ -10,6 +10,10 @@
  * @author Patryk
  */
 public class Gradient {
+	/**
+	 * Klasa opisująca kolor wraz z jego relatywnym położeniem w gradiencie
+	 * @author Patryk
+	 */
 	public static class ColorPos implements Comparable<ColorPos>{
 		private ColorRGB mColor = new ColorRGB(0,0,0);
 		private float mPos;
@@ -36,26 +40,30 @@
 		 * gdy pos > 1 przypisane zostanie 1
 		 * @param pos - pozycja w gradiencie [0,1]
 		 */
-		public void setPos(float pos){
+		public final void setPos(float pos){
 			mPos = Math.max(0.0f, Math.min(1.0f, pos));
 		}
 		/**
 		 * Ustawia kolor, jesli argument jest <b>null</b> kolor nie zostanie zmieniony
 		 * @param rgb - kolor z przestrzeni barw RGB
 		 */
-		public void setColor(ColorRGB rgb){
-			if(rgb != null) mColor = rgb;
+		public final void setColor(ColorRGB rgb){
+			if(rgb != null) {
+				mColor = rgb;
+			}
 		}
 		@Override
 		public int compareTo(ColorPos arg0) {
-			if(mPos < arg0.mPos) return -1;
-			if(mPos > arg0.mPos) return 1;
-			return 0;
+			return Float.valueOf(mPos).compareTo(arg0.mPos);
 		}
 		@Override
 		public boolean equals(Object obj){
-			if(obj == null || !(obj instanceof ColorPos)) return false;
-			return ((ColorPos)obj).mPos == mPos;
+			if(!(obj instanceof ColorPos)) {return false;}
+			return Float.valueOf((((ColorPos)obj).mPos)).equals(mPos);
+		}
+		@Override
+		public int hashCode(){
+			return Float.valueOf(mPos).hashCode();
 		}
 	}
 	
@@ -83,7 +91,6 @@
 	 * @param ref - referencja do wyniku
 	 */
 	public void interpolate(float pos, ColorRGB ref){
-		if(ref == null) throw new NullPointerException();
 		if(lista.size() == 0){
 			ref.setR(0);
 			ref.setG(0);
@@ -96,7 +103,8 @@
 		} else {
 			ColorPos prev, last;
 			Iterator<ColorPos> iter = lista.iterator();
-			prev = last = iter.next();
+			prev = iter.next(); 
+			last = prev;
 			while(iter.hasNext() && last.getPos() <= pos){
 				prev = last;
 				last = iter.next();

=== modified file 'src/main/java/manager/editor/Histogram.java'
--- src/main/java/manager/editor/Histogram.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/Histogram.java	2012-04-17 18:42:22 +0000
@@ -24,7 +24,7 @@
      * @return częstotliwość wystąpień danego argumentu
      */
     public int getValue(int argument) {
-    	if(argument < 0 || argument >= mData.length) return 0;
+    	if(argument < 0 || argument >= mData.length) {return 0;}
         return mData[argument];
     }
     /**

=== modified file 'src/main/java/manager/editor/IFilter.java'
--- src/main/java/manager/editor/IFilter.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/IFilter.java	2012-04-17 18:42:22 +0000
@@ -14,7 +14,7 @@
      * @param temp - obraz tymczasowy
      * @throws IllegalArgumentException - gdy rozmiar temp jest niezgodny z rozmiarem original
      */
-    public void apply(PixelData original, PixelData temp) throws IllegalArgumentException;
+    void apply(PixelData original, PixelData temp);
 
     /**
      * Aplikuje filtr na obraz i wynik zapisuje w nim samym, ale zwraca kopię przed wprowadzeniem zmian
@@ -23,5 +23,10 @@
      * @param image - obraz na którym aplikujemy filtr
      * @return kopia obrazu przed zastosowaniem filtru lub null gdy <b>image</b> jest null
      */
-    public PixelData apply(PixelData image);
+    PixelData apply(PixelData image);
+    
+    /**
+     * Resetuje ustawienia filtru do wartości podstawoaych
+     */
+    void reset();
 }

=== modified file 'src/main/java/manager/editor/IFilterLUT.java'
--- src/main/java/manager/editor/IFilterLUT.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/IFilterLUT.java	2012-04-17 18:42:22 +0000
@@ -6,13 +6,17 @@
  */
 public interface IFilterLUT extends IFilter {
     /**
+     * Zwraca tablice funckji LUT (filtr może pracować wielokanałowo)
      * @return tablica funkcji LUT
      */
-    public LUTTable getConversionTable();
+    LUTTable[] getConversionTable();
 
     /**
-     * Ustawia funkcję LUT która będzie parametrem pracy filtru
+     * Ustawia tablicę funkcji LUT które będą parametrami pracy filtru.
+     * Gdy rozmiar tablicy podanej jako argument się nie zgadza lub któryś jej element jest nullem
+     * wyrzuca wyjątek
      * @param table - nowa tablica
+     * @throws IllegalArgumentException - gdy tablica jest nieodpowiednia
      */
-    public void setConversionTable(LUTTable table);
+    void setConversionTable(LUTTable[] table);
 }
\ No newline at end of file

=== modified file 'src/main/java/manager/editor/IFilterMatrix.java'
--- src/main/java/manager/editor/IFilterMatrix.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/IFilterMatrix.java	2012-04-17 18:42:22 +0000
@@ -8,11 +8,11 @@
     /**
      * @return macierz przekształcenia
      */
-    public Matrix getMatrix();
+    Matrix getMatrix();
 
     /**
      * Ustawia nową macierz przekształcenia
      * @param matrix - nowa macierz przekształcenia
      */
-    public void setMatrix(Matrix matrix);
+    void setMatrix(Matrix matrix);
 }

=== modified file 'src/main/java/manager/editor/IFilterRange.java'
--- src/main/java/manager/editor/IFilterRange.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/IFilterRange.java	2012-04-17 18:42:22 +0000
@@ -7,7 +7,16 @@
  */
 public interface IFilterRange extends IFilter {
     /**
+     * Zwraca tablicę dozwolonych zakresów
      * @return tablica dozwolonych zakresów
      */
-    public Range[] getRangeTable();
+    Range[] getRangeTable();
+    
+    /**
+     * Ustawia tablice zakresów, jeśli zakresy są niedozwolone (np różnią się krańcami lub
+     * jest ich niedozwolona dla danego filtru ilość zostanie rzucony wyjątek)
+     * @param table - nowa tablica zakresów z ustawionymi wartościami
+     * @throws IllegalArgumentException
+     */
+    void setRangeTable(Range[] table);
 }

=== modified file 'src/main/java/manager/editor/ITextureGenerator.java'
--- src/main/java/manager/editor/ITextureGenerator.java	2012-04-09 18:10:58 +0000
+++ src/main/java/manager/editor/ITextureGenerator.java	2012-04-17 18:42:22 +0000
@@ -9,7 +9,7 @@
 	 * Zwraca wynik pracy generatora na podanych współrzędnych pod referencje <b>temp</b>
 	 * @param fx - współrzędna pozioma w teksturze z przedziału [0,1]
 	 * @param fy - współrzędna pionowa w teksturze z przedziału [0,1]
-	 * @return Kolor pixela tekstury w przestrzeni barw RGB
+	 * @param temp - referencja na obiekt w którym ma być zapisany wynik
 	 */
-	public void getValue(float fx, float fy, ColorRGB temp);
+	void getValue(float fx, float fy, ColorRGB temp);
 }

=== added file 'src/main/java/manager/editor/IWindowFilter.java'
--- src/main/java/manager/editor/IWindowFilter.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/IWindowFilter.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,11 @@
+package manager.editor;
+/**
+ * Podstawowy interfejs reprezentujący okienko służace do modyfikacji ustawień danego filtru
+ * @author  Marcin Regdos
+ */
+public interface IWindowFilter {
+	/**
+     * Zwraca zmodyfikowaną przez filtr kopię obrazu. Jeśli użytkownik nie zastosuje filtru, zwraca nulla.
+     */
+	public PixelData showDialog();
+}

=== modified file 'src/main/java/manager/editor/ImageMaker.java'
--- src/main/java/manager/editor/ImageMaker.java	2012-04-08 17:57:35 +0000
+++ src/main/java/manager/editor/ImageMaker.java	2012-04-17 18:42:22 +0000
@@ -8,9 +8,12 @@
  * Klasa ta jest wyróżniona, gdyż z uwagi na fakt, że większość jej filtrów tworzy obraz fizycznie innych 
  * rozmiarów, posiadają one odwróconą metodę <b>PixelData apply(PixelData)</b> (zwracany jest obraz PO
  * obróbce a nie jak w wszystkich innych filtrach PRZED, zaś parametr jest nie zmieniany)
+ * Próba utworzenia obiektu tej kalsy nawet przy użyciu refleksji 
+ * skończy się wyjątkiem <b>UnsupportedOperationException</B>
  * @author Patryk
  */
-public class ImageMaker {
+public final class ImageMaker {
+	private ImageMaker(){throw new UnsupportedOperationException();}
 	/**
 	 * @param width - długość obrazu wynikowego
 	 * @param height - wysokość obrazu wynikowego

=== added file 'src/main/java/manager/editor/ImagePanel.java'
--- src/main/java/manager/editor/ImagePanel.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/ImagePanel.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,50 @@
+package manager.editor;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Image;
+import javax.swing.JPanel;
+
+/**
+ * Kontrolka do wyswietlania obrazu
+ * Nie korzystac bezposrednio, nalezy uzyc ImageViewer
+ * @author Marcin Regdos
+ */
+class ImagePanel extends JPanel  {
+	private static final long serialVersionUID = 1L;
+	private Image image; //? BufferedImage
+	private int zoom;
+	public ImagePanel (Image image){
+		this.image=image;
+		zoom=100;
+	}
+	/**
+     * Zmiana obrazu
+     * @param image - nowy obraz
+     */
+	void changeImage (Image image){
+		this.image=image;
+		this.repaint();
+	}
+	void changeZoom (int zoom){
+		this.zoom=zoom;
+		this.repaint();
+	}
+	@Override
+	protected void paintComponent(Graphics g){
+		super.paintComponents(g);
+		g.setColor(Color.GRAY);
+		g.fillRect(0, 0, this.getWidth(), this.getHeight());
+		if (image!=null){
+			g.drawImage(image, 0, 0, image.getWidth(null)*zoom/100,  image.getHeight(null)*zoom/100, null);
+		}
+	}
+	public Dimension getPreferredSize() {
+        if (image==null) {
+            return new Dimension(1, 1);
+        } else {
+            return new java.awt.Dimension(image.getWidth(null)*zoom/100, image.getHeight(null)*zoom/100);
+        }
+    }
+}

=== added file 'src/main/java/manager/editor/ImageViewer.java'
--- src/main/java/manager/editor/ImageViewer.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/ImageViewer.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,66 @@
+package manager.editor;
+
+import java.awt.Color;
+import java.awt.Image;
+import javax.swing.BorderFactory;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSpinner;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+/**
+ * Kontrolka do wyswietlania obrazu (scroll)
+ * @author Marcin Regdos
+ */
+public class ImageViewer extends JPanel implements ChangeListener{
+	private static final long serialVersionUID = 1L;
+	private ImagePanel iPanel;
+	private JPanel topPanel;
+	private JScrollPane scrollPane;
+	private JSpinner zoomSpinner;
+	private int height, width;
+	/**
+     * Zostanie utworzona nowa kontrolka
+     * @param image  wyswietlany obraz
+     * @param width szerokosc kontrolki
+     * @param height wysokosc kontrolki
+     */
+	public ImageViewer (Image image, int width, int height){
+		this.height=height;
+		this.width=width;
+		iPanel=new ImagePanel(image);
+		zoomSpinner =new JSpinner (new SpinnerNumberModel(100, 10,1000,10)); 
+		zoomSpinner.addChangeListener(this);
+		
+		topPanel=new JPanel();
+		topPanel.add(new JLabel ("Zoom"));
+		topPanel.add(zoomSpinner);
+		
+		scrollPane = new JScrollPane(iPanel);
+		scrollPane.setViewportBorder(BorderFactory.createLineBorder(Color.BLACK));
+		scrollPane.setWheelScrollingEnabled(true);
+		scrollPane.setColumnHeaderView(topPanel);
+		scrollPane.setPreferredSize(new  java.awt.Dimension(this.width, this.height));
+		//scrollPane.setSize(scrollPane.getPreferredSize());
+		this.setPreferredSize(scrollPane.getPreferredSize());
+		this.add(scrollPane);
+		this.repaint();
+	}
+	/**
+     * Zmiana wyswietlanego obrazu
+     * @param image - nowy obraz
+     */
+	public void setImage (Image image){
+		iPanel.changeImage(image);
+	}
+	@Override
+	public void stateChanged(ChangeEvent arg0) {
+		iPanel.changeZoom((Integer)zoomSpinner.getValue());	
+		this.revalidate();
+		//this.repaint();
+	}
+}
+

=== modified file 'src/main/java/manager/editor/LUTTable.java'
--- src/main/java/manager/editor/LUTTable.java	2012-04-10 17:51:49 +0000
+++ src/main/java/manager/editor/LUTTable.java	2012-04-17 18:42:22 +0000
@@ -15,7 +15,7 @@
 	 * @param vals - tablica wartości funkcji
 	 * @throws IllegalArgumentException - gdy w podanej tablicy znajdzą sie wartosci z poza [0,1]
 	 */
-	LUTTable(float[] vals) throws IllegalArgumentException{
+	LUTTable(float[] vals){
 		setConversionTable(vals);
 	}
 	
@@ -23,12 +23,12 @@
 	 * @param arg - argumnet z dziedziny [0,1]
 	 * @return interpolowana wartosc funkcji LUT na argumencie <b>arg</b>
 	 */
-	public float getValue(float arg){
-		if(arg <= 0.0f) return mData[0];
-		if(arg >= 1.0f) return mData[mData.length-1];
+	public final float getValue(float arg){
+		if(arg <= 0.0f) {return mData[0];}
+		if(arg >= 1.0f) {return mData[mData.length-1];}
 		float delta = 1.0f/(mData.length-1);
 		int beg = (int)(arg/delta);
-		if(delta*beg == arg) return mData[beg];
+		if(Math.abs(delta*beg - arg) < ColorConverter.FLOAT_PRECISION) {return mData[beg];}
 		float hdet = (mData[beg+1] - mData[beg])/delta;
 		return mData[beg] + hdet * (arg-beg*delta);
 	}
@@ -40,12 +40,25 @@
      * @param table - nowa tablica konwersji
      * @throws IllegalArgumentException - gdy w podanej tablicy znajdą sie wartosci z poza [0,1]
      */
-    public void setConversionTable(float[] table) throws IllegalArgumentException{
-    	if(table != null) for(int i=0;i<table.length;i++) if(table[i] < 0.0f || table[i] > 1.0f) throw new IllegalArgumentException();
+    public final void setConversionTable(float[] table){
+    	if(table != null) {
+    		for(int i=0;i<table.length;i++){
+    			if(table[i] < 0.0f || table[i] > 1.0f) {
+    				throw new IllegalArgumentException();
+    			}
+    		}
+    	}
     	if(table == null || table.length < 2){
 			mData = new float[2];
 			mData[0] = 0.0f;
 			mData[1] = 1.0f;
-		} else mData = table.clone();
+		} else {mData = table.clone();}
+    }
+    
+    /**
+     * Resetuje ustawienia tablicy LUT
+     */
+    public final void reset(){
+    	mData = new float[]{0.0f,1.0f};
     }
 }

=== modified file 'src/main/java/manager/editor/Matrix.java'
--- src/main/java/manager/editor/Matrix.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/Matrix.java	2012-04-17 18:42:22 +0000
@@ -8,6 +8,7 @@
  *
  */
 public class Matrix {
+	private static final int MinimumMatrixSize = 3;
 	private int mSize;
 	private float[] mData;
 	
@@ -17,8 +18,10 @@
 	 * @param size - rozmiar boku macierzy, dozwolone są tylko liczby nieparzyste
 	 * @throws IllegalArgumentException - gdy rozmiar jets nie prawidłowy
 	 */
-	public Matrix(int size) throws IllegalArgumentException{
-		if(size <= 0 || size%2==0) throw new IllegalArgumentException();
+	public Matrix(int size){
+		if(size <= 0 || size%2==0){
+			throw new IllegalArgumentException();
+		}
 		mSize = size;
 		mData = new float[size*size];
 		mData[size*size/2] = 1.0f;
@@ -30,8 +33,10 @@
      * @throws IllegalArgumentException gdy rozmiar tablicy jest niedozwolony 
      * (nie opisuje mecierzy 3x3 5x5 itd)
      */
-    public Matrix(float[] table) throws IllegalArgumentException {
-    	if(table == null) throw new NullPointerException();
+    public Matrix(float[] table){
+    	if(table == null) {
+    		throw new IllegalArgumentException();
+    	}
     	setFromTable(table);
     }
 
@@ -54,10 +59,14 @@
      * @param table - tablica z wartościami pól macierzy
      * @throws IllegalArgumentException gdy rozmiar macierzy jest niedozwolony
      */
-    public void setFromTable(float[] table) throws IllegalArgumentException {
-    	if(table == null) throw new NullPointerException();
+    public final void setFromTable(float[] table){
+    	if(table == null) {
+    		throw new IllegalArgumentException();
+    	}
     	int size = (int)Math.sqrt(table.length);
-    	if(size*size != table.length || size < 3 || size%2==0) throw new IllegalArgumentException();
+    	if(size*size != table.length || size < MinimumMatrixSize || size%2==0){
+    		throw new IllegalArgumentException();
+    	}
     	mSize = size;
     	mData = table.clone();
     }

=== modified file 'src/main/java/manager/editor/PixelData.java'
--- src/main/java/manager/editor/PixelData.java	2012-04-10 11:51:18 +0000
+++ src/main/java/manager/editor/PixelData.java	2012-04-17 18:42:22 +0000
@@ -1,6 +1,7 @@
 package manager.editor;
 
 import java.awt.image.BufferedImage;
+import manager.editor.Histogram.HistogramChannel;
 
 /**
  * Reprezentuje tablice pixeli obrazu. Może przechowywać dane w 3 przestrzeniach kolorów
@@ -11,24 +12,41 @@
  *
  */
 public class PixelData implements Cloneable {
+	/**
+	 * Rozmiar danych zajmowanych w tablicy przez każdego pixela w bajtach
+	 */
+	public static final int PIXEL_SIZE = 3;
+	/**
+	 * Tablicowa precyzja zapisu kanałów Saturation i Value (modelu HSV)
+	 */
+	public static final int SV_CHANNEL_PRECISON = 100;
+	/**
+	 * Tablicowa precyzja zapisu kanałów Hue (modelu HSV)
+	 */
+	public static final int HUE_CHANNEL_PRECISION = 360;
+	/**
+	 * Tablicowa precyzja zapisu kanałów RGB i CMY
+	 */
+	public static final int RGBCMY_CHANNEL_PRECISION = 256;
+	
 	private enum DataType{
 		RGB, CMY, HSV;
 	}
 	private DataType mDataType = DataType.RGB;
-	int mWidth, mHeight;
-	float[] mData;
+	private int mWidth, mHeight;
+	private float[] mData;
 	
 	/**
 	 * Tworzy nowy obraz o podanych wymiarach
 	 * @param width - długość obrazu
 	 * @param height - wysokość obrazu
-	 * @throws IllegalArgumentException - gdy width lub height sa < 1
+	 * @throws IllegalArgumentException - gdy width lub height są < 1
 	 */
-	public PixelData(int width, int height) throws IllegalArgumentException{
-		if(width <= 0 || height <= 0) throw new IllegalArgumentException();
+	public PixelData(int width, int height) {
+		if(width <= 0 || height <= 0) {throw new IllegalArgumentException();}
 		mWidth = width;
 		mHeight = height;
-		mData = new float[width*height*3];
+		mData = new float[width*height*PIXEL_SIZE];
 	}
 	
     /**
@@ -39,41 +57,66 @@
     	mHeight = image.getHeight();
     	mData = image.getRaster().getPixels(0, 0, mWidth, mHeight, (float[])null);
     }
+    
+    /**
+     * Zwraca szerokość obrazu
+     * @return Szerokość obrazu
+     */
+    public int getWidth(){
+    	return mWidth;
+    }
+    
+    /**
+     * Zwraca wysokość obrazu
+     * @return Wysokość obrazu
+     */
+    public int getHeight(){
+    	return mHeight;
+    }
+    
+    /**
+     * Zwraca tablicę danych o pixelach
+     * @return tablica danych pixeli
+     */
+    final float[] getData(){
+    	return mData;
+    }
 
     /**
      * Transformuje obraz do przestrzeni barw RGB
      */
     public void toRGB() {
     	if(mDataType == DataType.CMY){
-    		for(int i=0;i<mData.length;i++) mData[i] = 255.0f - mData[i];
+    		for(int i=0;i<mData.length;i++) {mData[i] = ColorConverter.RGBCMY_BYTE_MAX - mData[i];}
     	} 
     	if(mDataType == DataType.HSV){
-    		float H,S,V,R=0.0f,G=0.0f,B=0.0f;
-    		float f,p,q,t; int I;
-    		for(int i=0;i<mWidth;i++)
+    		float mH,mS,mV,mR=0.0f,mG=0.0f,mB=0.0f;
+    		float f,p,q,t; int mI;
+    		for(int i=0;i<mWidth;i++){
     			for(int j=0;j<mHeight;j++){
-    				H = mData[3*(i*mHeight+j)];
-    				S = mData[3*(i*mHeight+j)+1];
-    				V = mData[3*(i*mHeight+j)+2];
-    				if(V == 0.0f) R=G=B=0.0f;
+    				mH = mData[PIXEL_SIZE*(i*mHeight+j)];
+    				mS = mData[PIXEL_SIZE*(i*mHeight+j)+1];
+    				mV = mData[PIXEL_SIZE*(i*mHeight+j)+2];
+    				if(Math.abs(mV) < ColorConverter.FLOAT_PRECISION) {mR=0.0f; mG=0.0f; mB=0.0f;}
     				else{
-    				 H /= 60.0f;
-    				 I = (int)Math.floor(H);
-    				 f = H-I;
-    				 p = V*(1.0f-S);
-    				 q = V*(1.0f-(S*f));
-    				 t = V*(1.0f-(S*(1.0f-f)));
-    				 if (I==0) {R=V; G=t; B=p;}
-    				 else if (I==1) {R=q; G=V; B=p;}
-    				 else if (I==2) {R=p; G=V; B=t;}
-    				 else if (I==3) {R=p; G=q; B=V;}
-    				 else if (I==4) {R=t; G=p; B=V;}
-    				 else if (I==5) {R=V; G=p; B=q;}
+    				 mH /= ColorConverter.HUE_CIRCLE_SPLITTER;
+    				 mI = (int)Math.floor(mH);
+    				 f = mH-mI;
+    				 p = mV*(1.0f-mS);
+    				 q = mV*(1.0f-(mS*f));
+    				 t = mV*(1.0f-(mS*(1.0f-f)));
+    				 if (mI==0) {mR=mV; mG=t; mB=p;}
+    				 else if (mI==1) {mR=q; mG=mV; mB=p;}
+    				 else if (mI==2) {mR=p; mG=mV; mB=t;}
+    				 else if (mI==3) {mR=p; mG=q; mB=mV;}
+    				 else if (mI==4) {mR=t; mG=p; mB=mV;}
+    				 else if (mI==5) {mR=mV; mG=p; mB=q;}
     				}
-    				mData[3*(i*mHeight+j)] = Math.max(0.0f, Math.min(255.0f, 255.0f * R));
-    				mData[3*(i*mHeight+j)+1] = Math.max(0.0f, Math.min(255.0f, 255.0f * G));
-    				mData[3*(i*mHeight+j)+2] = Math.max(0.0f, Math.min(255.0f, 255.0f * B));
+    				mData[PIXEL_SIZE*(i*mHeight+j)] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, ColorConverter.RGBCMY_BYTE_MAX * mR));
+    				mData[PIXEL_SIZE*(i*mHeight+j)+1] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, ColorConverter.RGBCMY_BYTE_MAX * mG));
+    				mData[PIXEL_SIZE*(i*mHeight+j)+2] = Math.max(0.0f, Math.min(ColorConverter.RGBCMY_BYTE_MAX, ColorConverter.RGBCMY_BYTE_MAX * mB));
     			}
+    		}
     	}
     	mDataType = DataType.RGB;
     }
@@ -82,33 +125,34 @@
      * Transformuje obraz do przestrzeni barw HSV
      */
     public void toHSV() {
-    	if(mDataType == DataType.CMY) toRGB();
+    	if(mDataType == DataType.CMY) {toRGB();}
     	if(mDataType == DataType.RGB){
-    		float H=0.0f,S=0.0f,V=0.0f,R,G,B,x,f,I;
-    		for(int i=0;i<mWidth;i++)
+    		float mH=0.0f,mS=0.0f,mV=0.0f,mR,mG,mB,x,f,mI;
+    		for(int i=0;i<mWidth;i++){
     			for(int j=0;j<mHeight;j++){
-    				R = mData[3*(i*mHeight+j)] / 255.0f;
-    				G = mData[3*(i*mHeight+j)+1] / 255.0f;
-    				B = mData[3*(i*mHeight+j)+2] / 255.0f;
-    				x = Math.min(Math.min(R, G), B);
-    				V = Math.max(Math.max(R, G), B);
-    				if (x == V) H=S=0.0f;
+    				mR = mData[PIXEL_SIZE*(i*mHeight+j)] / ColorConverter.RGBCMY_BYTE_MAX;
+    				mG = mData[PIXEL_SIZE*(i*mHeight+j)+1] / ColorConverter.RGBCMY_BYTE_MAX;
+    				mB = mData[PIXEL_SIZE*(i*mHeight+j)+2] / ColorConverter.RGBCMY_BYTE_MAX;
+    				x = Math.min(Math.min(mR, mG), mB);
+    				mV = Math.max(Math.max(mR, mG), mB);
+    				if (Math.abs(x - mV) < ColorConverter.FLOAT_PRECISION) {mH=0.0f; mS=0.0f;}
     				else {
-    					if(R == x) f = G-B;
-    					else if(G == x) f = B-R;
-    					else f = R-G;
+    					if(Math.abs(mR - x) < ColorConverter.FLOAT_PRECISION) {f = mG-mB;}
+    					else if(Math.abs(mG - x) < ColorConverter.FLOAT_PRECISION) {f = mB-mR;}
+    					else {f = mR-mG;}
     					
-    					if(R == x) I=3.0f;
-    					else if(G == x) I=5.0f;
-    					else I=1.0f;
-    					H = (float)( (int)((I-f/(V-x))*60.0f) )%360;
-    					S = ((V-x)/V);
+    					if(Math.abs(mR - x) < ColorConverter.FLOAT_PRECISION) {mI=3.0f;}
+    					else if(Math.abs(mG - x) < ColorConverter.FLOAT_PRECISION) {mI=5.0f;}
+    					else {mI=1.0f;}
+    					mH = (float)( (int)((mI-f/(mV-x))*ColorConverter.HUE_CIRCLE_SPLITTER) )%HUE_CHANNEL_PRECISION;
+    					mS = ((mV-x)/mV);
     				}
     				
-    	            mData[3*(i*mHeight+j)] = H;
-    	            mData[3*(i*mHeight+j)+1] = S;
-    	            mData[3*(i*mHeight+j)+2] = V;
+    	            mData[PIXEL_SIZE*(i*mHeight+j)] = mH;
+    	            mData[PIXEL_SIZE*(i*mHeight+j)+1] = mS;
+    	            mData[PIXEL_SIZE*(i*mHeight+j)+2] = mV;
     			}
+    		}
     	}
     	mDataType = DataType.HSV;
     }
@@ -117,8 +161,10 @@
      * Transformuje obraz do przestrzeni barw CMY
      */
     public void toCMY() {
-    	if(mDataType == DataType.HSV) toRGB();
-    	if(mDataType == DataType.RGB) for(int i=0;i<mData.length;i++) mData[i] = 255.0f - mData[i];
+    	if(mDataType == DataType.HSV) {toRGB();}
+    	if(mDataType == DataType.RGB) {
+    		for(int i=0;i<mData.length;i++) {mData[i] = ColorConverter.RGBCMY_BYTE_MAX - mData[i];} 
+    	}
     	mDataType = DataType.CMY;
     }
 
@@ -149,9 +195,8 @@
      * @throws IllegalArgumentException - gdy rozmiar <b>image</b>  nie zgadza się z rozmiarem danych PixelData
      * Należy wtedy użyc metody <b>toBufferedData()</b>
      */
-    public void toBufferedImage(BufferedImage image) throws IllegalArgumentException{
-    	if(image == null) throw new NullPointerException();
-    	if(image.getWidth() != mWidth || image.getHeight() != mHeight) throw new IllegalArgumentException();
+    public void toBufferedImage(BufferedImage image) {
+    	if(image.getWidth() != mWidth || image.getHeight() != mHeight) {throw new IllegalArgumentException();}
     	toRGB();
     	image.getRaster().setPixels(0, 0, mWidth, mHeight, mData);
     }
@@ -161,43 +206,104 @@
      * @return <b>Histogram</b> zwierający informacje o danym kanale.
      */
     public Histogram getHistogram(Histogram.HistogramChannel channel) {
-    	int table[] = null;
-    	if(channel == Histogram.HistogramChannel.RED){
-    		table = new int[256]; toRGB();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)mData[3*(i*mHeight+j)]]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.GREEN){
-    		table = new int[256]; toRGB();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)mData[3*(i*mHeight+j)+1]]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.BLUE){
-    		table = new int[256]; toRGB();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)mData[3*(i*mHeight+j)+2]]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.CYAN){
-    		table = new int[256]; toCMY();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)mData[3*(i*mHeight+j)]]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.MAGENTA){
-    		table = new int[256]; toCMY();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)mData[3*(i*mHeight+j)+1]]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.YELLOW){
-    		table = new int[256]; toCMY();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)mData[3*(i*mHeight+j)+2]]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.HUE){
-    		table = new int[360]; toHSV();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[((int)mData[3*(i*mHeight+j)])%360]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.SATURATION){
-    		table = new int[100]; toHSV();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)(mData[3*(i*mHeight+j)+1]*100.0f)]++;
-    	}
-    	if(channel == Histogram.HistogramChannel.VALUE){
-    		table = new int[100]; toHSV();
-    		for(int i=0;i<mWidth;i++) for(int j=0;j<mHeight;j++) table[(int)(mData[3*(i*mHeight+j)+2]*100.0f)]++;
-    	}
-        return new Histogram(table, channel);
+    	if(channel == Histogram.HistogramChannel.RED) {return getHistogramRed();}
+    	else if(channel == Histogram.HistogramChannel.GREEN) {return getHistogramGreen();}
+    	else if(channel == Histogram.HistogramChannel.BLUE) {return getHistogramBlue();}
+    	else if(channel == Histogram.HistogramChannel.CYAN) {return getHistogramCyan();}
+    	else if(channel == Histogram.HistogramChannel.MAGENTA) {return getHistogramMagenta();}
+    	else if(channel == Histogram.HistogramChannel.YELLOW) {return getHistogramYellow();}
+    	else if(channel == Histogram.HistogramChannel.HUE) {return getHistogramHue();}
+    	else if(channel == Histogram.HistogramChannel.SATURATION) {return getHistogramSaturation();}
+    	return getHistogramValue();
+    }
+    
+    private Histogram getHistogramRed(){
+    	toRGB();
+    	int[] table = new int[RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)mData[PIXEL_SIZE*(i*mHeight+j)]]++;
+			}
+		}
+    	return new Histogram(table, HistogramChannel.RED);
+    }
+    private Histogram getHistogramGreen(){
+    	toRGB();
+    	int[] table = new int[RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)mData[PIXEL_SIZE*(i*mHeight+j)+1]]++;
+			}
+		}
+    	return new Histogram(table, HistogramChannel.GREEN);
+    }
+    private Histogram getHistogramBlue(){
+    	toRGB();
+    	int[] table = new int[RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)mData[PIXEL_SIZE*(i*mHeight+j)+2]]++;
+			}
+		}
+    	return new Histogram(table, HistogramChannel.BLUE);
+    }
+    
+    private Histogram getHistogramCyan(){
+    	toCMY();
+    	int[] table = new int[RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)mData[PIXEL_SIZE*(i*mHeight+j)]]++;
+			}
+		}
+    	return new Histogram(table, HistogramChannel.CYAN);
+    }
+    private Histogram getHistogramMagenta(){
+    	toCMY();
+    	int[] table = new int[RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)mData[PIXEL_SIZE*(i*mHeight+j)+1]]++;
+			}
+		}
+    	return new Histogram(table, HistogramChannel.MAGENTA);
+    }
+    private Histogram getHistogramYellow(){
+    	toCMY();
+    	int[] table = new int[RGBCMY_CHANNEL_PRECISION];
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)mData[PIXEL_SIZE*(i*mHeight+j)+2]]++;
+			}
+		}
+    	return new Histogram(table, HistogramChannel.YELLOW);
+    }
+    
+    private Histogram getHistogramHue(){
+    	int[] table = new int[HUE_CHANNEL_PRECISION]; toHSV();
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[((int)mData[PIXEL_SIZE*(i*mHeight+j)])%HUE_CHANNEL_PRECISION]++;
+			}
+		}
+		return new Histogram(table, HistogramChannel.HUE);
+    }
+    private Histogram getHistogramSaturation(){
+    	int[] table = new int[SV_CHANNEL_PRECISON]; toHSV();
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)(mData[PIXEL_SIZE*(i*mHeight+j)+1]*(float)SV_CHANNEL_PRECISON)]++;
+			}
+		}
+		return new Histogram(table, HistogramChannel.SATURATION);
+    }
+    private Histogram getHistogramValue(){
+    	int[] table = new int[SV_CHANNEL_PRECISON]; toHSV();
+		for(int i=0;i<mWidth;i++) {
+			for(int j=0;j<mHeight;j++) {
+				table[(int)(mData[PIXEL_SIZE*(i*mHeight+j)+2]*(float)SV_CHANNEL_PRECISON)]++;
+			}
+		}
+		return new Histogram(table, HistogramChannel.VALUE);
     }
 }

=== added file 'src/main/java/manager/editor/Point.java'
--- src/main/java/manager/editor/Point.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/Point.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,18 @@
+package manager.editor;
+
+/**
+ * Klasa opisująca puntk w przestrzeni pracy gradientu tj bitmapie mapowanej 
+ * układem współrzędnych o granicach 0 i 1  (można wylatywać poza przedział pracy, bo
+ * generatory gradientowe obsługują takie sytuacje jako rozciągnięcie gradientu w przestrzeni
+ * o większym rozmiarze i nałożenie wyszczególniony fragment przestrzeni tj własnie 0 do 1)
+ * @author Patryk
+ */
+public class Point {
+	public float x;
+	public float y;
+	
+	public Point(float mX, float mY){
+		x = mX;
+		y = mY;
+	}
+}

=== modified file 'src/main/java/manager/editor/Range.java'
--- src/main/java/manager/editor/Range.java	2012-04-07 09:14:46 +0000
+++ src/main/java/manager/editor/Range.java	2012-04-17 18:42:22 +0000
@@ -7,17 +7,21 @@
  * 
  */
 public class Range {
-	private float mMin, mMax, mValue;
+	private float mMin, mMax, mValue, mDefault;
+	private final String mName;
 	
     /**
      * Zostanie utworzony obiekt  reprezentujący przedział [min(a,b), max(a,b)]
      * @param a - jeden z krańców przedziału
      * @param b - jeden z krańców przedziału
+     * @param name - nazwa przedziału
      */
-    public Range(float a, float b) {
+    public Range(float a, float b, String name) {
     	mMin = Math.min(a, b);
     	mMax = Math.max(a, b);
     	mValue = (a+b)/2.0f;
+    	mName = name;
+    	mDefault = mValue;
     }
     
     /**
@@ -26,10 +30,19 @@
      * @param a - jeden z krańców przedziału
      * @param b - jeden z krańców przedziału
      * @param val - wartość wyróżniona
+     * @param name - nazwa przedziału
      */
-    public Range(float a, float b, float val){
-    	this(a,b);
+    public Range(float a, float b, float val, String name){
+    	this(a,b,name);
     	setValue(val);
+    	mDefault = mValue;
+    }
+    
+    /**
+     * Resetuje ustawienia przedzialu tzn ustawia wartośc w przedziale na domyślną
+     */
+    public void reset(){
+    	setValue(mDefault);
     }
 
     /**
@@ -43,7 +56,7 @@
      * @return interpolowana pozycja wartości wyróżnionej w przedziale -> należy do [0,1]
      */
     public float getInterpolatedValue(){
-    	if(mMin == mMax) return 0.0f;
+    	if(mMin == mMax) {return 0.0f;}
     	return (mValue - mMin) / (mMax - mMin);
     }
 
@@ -62,14 +75,21 @@
     }
     
     /**
+     * @return nazwa przedziału
+     */
+    public String getName(){
+    	return mName;
+    }
+    
+    /**
      * Ustawia wartość wyróżnioną
      * @param value - Wartość z przedziału [0,1] reprezentująca wyskalowane położenie 
      * wartości wybranej wewnątrz przedziału. Gdy <b>value</b> < 0 zostaje domyślnie przypisane <b>value = 0</b>
      * gdy <b>value</b> > 1 zostaje domyślnie przypisane <b>value = 1</b>
      */
-    public void interpolate(float value){
-    	if(value > 1.0f) value = 1.0f;
-    	if(value < 0.0f) value = 0.0f;
+    public final void interpolate(float value){
+    	if(value > 1.0f) {value = 1.0f;}
+    	if(value < 0.0f) {value = 0.0f;}
     	mValue = mMin + (mMax-mMin)*value;
     }
 
@@ -78,10 +98,10 @@
      * @param value - wartość wyróżniona z przedziału, gdy value < minimum to domyślnie value = minimum
      * gdy value > maximum  to domyślnie value = maximum
      */
-    public void setValue(float value) {
-    	if(value < mMin) mValue = mMin;
-    	else if(value > mMax) mValue = mMax;
-    	else mValue = value;
+    public final void setValue(float value) {
+    	if(value < mMin) {mValue = mMin;}
+    	else if(value > mMax) {mValue = mMax;}
+    	else {mValue = value;}
     }
 
     @Override

=== added file 'src/main/java/manager/editor/TextureGeneratorGradientCircle.java'
--- src/main/java/manager/editor/TextureGeneratorGradientCircle.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/TextureGeneratorGradientCircle.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,69 @@
+package manager.editor;
+
+/**
+ * Klasa implementująca gradientowy generatur tekstur działający w trybie kołowym.
+ * Generator generuje tekstury będące gradientami kołowymi o danym środku i promieniu 
+ * wyznaczonym przez dwa punkty w przestrzeni RxR
+ * @author Patryk
+ */
+public class TextureGeneratorGradientCircle implements ITextureGenerator{
+	private Gradient mGrad;
+	private Point mBegin, mEnd;
+	private float mRadius;
+	/**
+	 * Ustawia wektor kierunkowy dla gradientu, wyznacza on środek oraz promień gradientu. 
+	 * Jeśli punkty wyznaczają wektor zerowy lub gradient jest nullem
+	 * zostaje rzucony wyjątek
+	 * @param beg - początek wektora
+	 * @param end - koniec wektora
+	 * @throws IllegalArgumentException - gdy wektor podany jako argument jest wektorem zerowym
+	 * @throws NullPointerException - gdy gradient jest nullem
+	 */
+	TextureGeneratorGradientCircle(Gradient grad, Point beg, Point end){
+		setVector(beg, end);
+		setGradient(grad);
+	}
+	/**
+	 * Ustawia wektor kierunkowy dla gradientu, wyznacza on środek oraz promień gradientu. 
+	 * Jeśli punkty wyznaczają wektor zerowy lub gradient jest nullem
+	 * zostaje rzucony wyjątek
+	 * @param beg - początek wektora
+	 * @param end - koniec wektora
+	 * @throws IllegalArgumentException - gdy wektor podany jako argument jest wektorem zerowym
+	 */
+	public final void setVector(Point beg, Point end){
+		if(Math.abs(beg.x - end.x) < ColorConverter.FLOAT_PRECISION && 
+				Math.abs(beg.y - end.y) < ColorConverter.FLOAT_PRECISION){
+			throw new IllegalArgumentException();
+		}
+		mBegin = beg;
+		mEnd = end;
+		float dX = mEnd.x-mBegin.x;
+		float dY = mEnd.y-mBegin.y;
+		mRadius = (float)Math.sqrt(dX*dX+dY*dY);
+	}
+	
+	/**
+	 * Zwraca gradient generujący
+	 * @return aktulany gradient generujący
+	 */
+	public Gradient getGradient(){
+		return mGrad;
+	}
+	
+	/**
+	 * Ustawia gradient generujący teksture, gdy <b>null</b> rzuca wyjątek, 
+	 * bo generator musi na czymś pracować
+	 * @param grad - Gradient który posłuży do generacji tekstury
+	 */
+	public final void setGradient(Gradient grad){
+		if(grad == null) {throw new NullPointerException();}
+		mGrad = grad;
+	}
+	
+	@Override
+	public void getValue(float fx, float fy, ColorRGB temp) {
+		float distance = (float)Math.sqrt((mBegin.x-fx)*(mBegin.x-fx) + (mBegin.y-fy)*(mBegin.y-fy));
+		mGrad.interpolate(Math.max(0.0f, Math.min(1.0f, distance/mRadius)), temp);
+	}
+}

=== removed file 'src/main/java/manager/editor/TextureGeneratorGradientHorizontal.java'
--- src/main/java/manager/editor/TextureGeneratorGradientHorizontal.java	2012-04-10 17:51:49 +0000
+++ src/main/java/manager/editor/TextureGeneratorGradientHorizontal.java	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-package manager.editor;
-
-/**
- * Klasa implementująca gradientowy generatur tekstur działający w kierunku poziomym
- * @author Patryk
- */
-public class TextureGeneratorGradientHorizontal implements ITextureGenerator{
-	private Gradient mGrad;
-	
-	/**
-	 * @param grad - referencja na Gradient który posłuży do generacji tekstury
-	 */
-	public TextureGeneratorGradientHorizontal(Gradient grad){
-		setGradient(grad);
-	}
-	
-	/**
-	 * Zwraca gradient generujący
-	 * @return aktulany gradient generujący
-	 */
-	public Gradient getGradient(){
-		return mGrad;
-	}
-	
-	/**
-	 * Ustawia gradient generujący teksture, gdy <b>null</b> rzuca wyjątek, 
-	 * bo generator musi na czymś pracować
-	 * @param grad - Gradient który posłuży do generacji tekstury
-	 */
-	public void setGradient(Gradient grad){
-		if(grad == null) throw new NullPointerException();
-		mGrad = grad;
-	}
-	
-	@Override
-	public void getValue(float fx, float fy, ColorRGB temp) {
-		mGrad.interpolate(Math.max(0.0f, Math.min(1.0f, fx)), temp);
-	}
-}

=== added file 'src/main/java/manager/editor/TextureGeneratorGradientLinear.java'
--- src/main/java/manager/editor/TextureGeneratorGradientLinear.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/TextureGeneratorGradientLinear.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,65 @@
+package manager.editor;
+
+/**
+ * Klasa implementująca gradientowy generatur tekstur działający w trybie liniowym.
+ * Generator generuje tekstury w dowolnym kierunku i skali (jest bardzo uniwersalny)
+ * @author Patryk
+ */
+public class TextureGeneratorGradientLinear implements ITextureGenerator{
+	private Gradient mGrad;
+	private Point mBegin, mEnd;
+	/**
+	 * Ustawia wektor kierunkowy dla gradientu wzdłuż którego zostaje wyznaczany
+	 * gradient liniowy. Jeśli punkty wyznaczają wektor zerowy lub gradient jest nullem
+	 * zostaje rzucony wyjątek
+	 * @param beg - początek wektora
+	 * @param end - koniec wektora
+	 * @throws IllegalArgumentException - gdy wektor podany jako argument jest wektorem zerowym
+	 * @throws NullPointerException - gdy gradient jest nullem
+	 */
+	TextureGeneratorGradientLinear(Gradient grad, Point beg, Point end){
+		setVector(beg, end);
+		setGradient(grad);
+	}
+	/**
+	 * Ustawia wektor kierunkowy dla gradientu wzdłuż którego zostaje wyznaczany
+	 * gradient liniowy. Jeśli punkty wyznaczają wektor zerowy zostaje rzucony wyjątek
+	 * @param beg - początek wektora
+	 * @param end - koniec wektora
+	 * @throws IllegalArgumentException - gdy wektor podany jako argument jest wektorem zerowym
+	 */
+	public final void setVector(Point beg, Point end){
+		if(Math.abs(beg.x - end.x) < ColorConverter.FLOAT_PRECISION && 
+				Math.abs(beg.y - end.y) < ColorConverter.FLOAT_PRECISION){
+			throw new IllegalArgumentException();
+		}
+		mBegin = beg;
+		mEnd = end;
+	}
+	
+	/**
+	 * Zwraca gradient generujący
+	 * @return aktulany gradient generujący
+	 */
+	public Gradient getGradient(){
+		return mGrad;
+	}
+	
+	/**
+	 * Ustawia gradient generujący teksture, gdy <b>null</b> rzuca wyjątek, 
+	 * bo generator musi na czymś pracować
+	 * @param grad - Gradient który posłuży do generacji tekstury
+	 */
+	public final void setGradient(Gradient grad){
+		if(grad == null) {throw new NullPointerException();}
+		mGrad = grad;
+	}
+	
+	@Override
+	public void getValue(float fx, float fy, ColorRGB temp) {
+		float x = fx - mBegin.x, y = fy - mBegin.y;
+		float a = mEnd.x - mBegin.x, b = mEnd.y - mBegin.y;
+		float len = a*a+b*b;
+		mGrad.interpolate(Math.max(0.0f, Math.min(1.0f, (a*x+b*y)/len)), temp);
+	}
+}

=== removed file 'src/main/java/manager/editor/TextureGeneratorGradientVertical.java'
--- src/main/java/manager/editor/TextureGeneratorGradientVertical.java	2012-04-10 17:51:49 +0000
+++ src/main/java/manager/editor/TextureGeneratorGradientVertical.java	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-package manager.editor;
-
-/**
- * Klasa implementująca gradientowy generatur tekstur działający w kierunku pionowym
- * @author Patryk
- */
-public class TextureGeneratorGradientVertical implements ITextureGenerator{
-	private Gradient mGrad;
-	
-	/**
-	 * @param grad - referencja na Gradient który posłuży do generacji tekstury
-	 */
-	public TextureGeneratorGradientVertical(Gradient grad){
-		setGradient(grad);
-	}
-	
-	/**
-	 * Zwraca gradient generujący
-	 * @return aktulany gradient generujący
-	 */
-	public Gradient getGradient(){
-		return mGrad;
-	}
-	
-	/**
-	 * Ustawia gradient generujący teksture, gdy <b>null</b> rzuca wyjątek, 
-	 * bo generator musi na czymś pracować
-	 * @param grad - Gradient który posłuży do generacji tekstury
-	 */
-	public void setGradient(Gradient grad){
-		if(grad == null) throw new NullPointerException();
-		mGrad = grad;
-	}
-	
-	@Override
-	public void getValue(float fx, float fy, ColorRGB temp) {
-		mGrad.interpolate(Math.max(0.0f, Math.min(1.0f, fy)), temp);
-	}
-}

=== added file 'src/main/java/manager/editor/TexturerFactory.java'
--- src/main/java/manager/editor/TexturerFactory.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/TexturerFactory.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,83 @@
+package manager.editor;
+
+/**
+ * Klasa udostępnia generatory tekstur
+ * Próba utworzenia obiektu tej klasy nawet przy użyciu refleksji 
+ * skończy się wyjątkiem <b>UnsupportedOperationException</B>
+ * @author Patryk
+ */
+public final class TexturerFactory {
+	private TexturerFactory(){
+		throw new UnsupportedOperationException();
+	}
+	
+	/**
+	 * Zwraca monochromatyczna maskę
+	 * @param color - kolor maski
+	 * @return monochromatyczy generator tekstur
+	 */
+	public static FilterTexturer monochromatic(ColorRGB color){
+		return new FilterTexturer(new TextureGeneratorMonochromatic(color));
+	}
+	/**
+	 * Zwraca monochromatyczna maskę
+	 * @param color - kolor maski
+	 * @return monochromatyczy generator tekstur
+	 */
+	public static FilterTexturer monochromatic(ColorCMY color){
+		return new FilterTexturer(new TextureGeneratorMonochromatic(color));
+	}
+	/**
+	 * Zwraca monochromatyczna maskę
+	 * @param color - kolor maski
+	 * @return monochromatyczy generator tekstur
+	 */
+	public static FilterTexturer monochromatic(ColorHSV color){
+		return new FilterTexturer(new TextureGeneratorMonochromatic(color));
+	}
+	
+	/**
+	 * Zwraca pionowy generator gradientowy o interpolacji liniowej
+	 * @param grad - gradient na którym pracuje generator
+	 * @return generator tekstur będących pionowymi gradientami liniowymi
+	 */
+	public static FilterTexturer gradientLinearVertical(Gradient grad){
+		return new FilterTexturer(new TextureGeneratorGradientLinear(grad, new Point(0,0), new Point(0,1)));
+	}
+	/**
+	 * Zwraca poziomy generator gradientowy o interpolacji liniowej
+	 * @param grad - gradient na którym pracuje generator
+	 * @return generator tekstur będących poziomymi gradientami liniowymi
+	 */
+	public static FilterTexturer gradientLinearHorizontal(Gradient grad){
+		return new FilterTexturer(new TextureGeneratorGradientLinear(grad, new Point(0,0), new Point(1,0)));
+	}
+	/**
+	 * Zwraca skośny generator gradientowy o interpolacji liniowej pracujący na przekątnej
+	 * lewy górny do prawy dolny
+	 * @param grad - gradient na którym pracuje generator
+	 * @return generator tekstur będących skośnymi gradientami liniowymi
+	 */
+	public static FilterTexturer gradientLinearDiagonal1(Gradient grad){
+		return new FilterTexturer(new TextureGeneratorGradientLinear(grad, new Point(0,0), new Point(1,1)));
+	}
+	/**
+	 * Zwraca skośny generator gradientowy o interpolacji liniowej pracujący na przekątnej
+	 * prawy górny do lewy dolny
+	 * @param grad - gradient na którym pracuje generator
+	 * @return generator tekstur będących skosnymi gradientami liniowymi
+	 */
+	public static FilterTexturer gradientLinearDiagonal2(Gradient grad){
+		return new FilterTexturer(new TextureGeneratorGradientLinear(grad, new Point(1,0), new Point(0,1)));
+	}
+	
+	
+	/**
+	 * Zwraca kołowy generator gradientowy
+	 * @param grad - gradient na którym pracuje generator
+	 * @return generator tekstur będących kołowymi gradientami
+	 */
+	public static FilterTexturer gradientCircle(Gradient grad){
+		return new FilterTexturer(new TextureGeneratorGradientCircle(grad, new Point(0.5f,0.5f), new Point(0,0)));
+	}
+}

=== added file 'src/main/java/manager/editor/WindowHistogram.java'
--- src/main/java/manager/editor/WindowHistogram.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/WindowHistogram.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,17 @@
+package manager.editor;
+
+import javax.swing.JDialog;
+
+/**
+ * Klasa reprezentująca okienko z informacjami histogramu - informacje 
+ * o kanałach badanego obrazu
+ * @author Wojtek Jędras
+ */
+public class WindowHistogram extends JDialog{
+    /**
+     * Kontruktor pobierający informacje o obrazie które potem będzie wyświetlał
+     * @param table - tablica historgamów pobranych z obrazu
+     */
+    public WindowHistogram(Histogram[] table) {
+    }
+}

=== added file 'src/main/java/manager/editor/WindowLUT.java'
--- src/main/java/manager/editor/WindowLUT.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/WindowLUT.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,24 @@
+package manager.editor;
+
+import javax.swing.JDialog;
+
+/**
+ * Klasa reprezentująca okienko do nieliniowej edycji kanałowej (LUTTable)
+ * @author Mikołaj Bińkowski
+ */
+public class WindowLUT extends JDialog{
+	/**
+	 * Konstruktor wymaga podania obrazu na którym będziemy pracować
+	 * @param image - obraz do edycji
+	 */
+	WindowLUT(PixelData image){
+	}
+	
+	/**
+	 * Zwraca obraz po edycji
+	 * @return obraz po edycji
+	 */
+	public PixelData showDialog(){
+		return null;
+	}
+}

=== added file 'src/main/java/manager/editor/WindowMatrix.java'
--- src/main/java/manager/editor/WindowMatrix.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/WindowMatrix.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,269 @@
+package manager.editor;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import javax.swing.GroupLayout;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.JToggleButton;
+import javax.swing.LayoutStyle;
+
+/**
+ * Klasa reprezentująca okienko do własnoręcznego zdefiniowania macierzy
+ * do filtru macierzowego aplikowanego dla obrazu
+ * @author Mikołaj Bińkowski
+ */
+public class WindowMatrix extends JDialog implements IWindowFilter{
+    private int mode;
+    PixelData inputData;
+    PixelData tempData;
+    PixelData returnData;
+    private float[][] matrix;
+    private JTextField fields[][];
+    private JButton applyButton;
+    private JButton previewButton;
+    private JButton abortButton;
+    private JToggleButton modeButton[];
+    private JPanel imagePanel;
+
+    /**
+     * Konstruktor wymaga podania obrazu na którym pracujemy
+     * @param image - obraz
+     */
+    WindowMatrix(PixelData image){
+        this.setTitle("title");
+        this.setModal(true);
+        //    this.setSize(new Dimension(200,150));
+            this.setLocation(100,100);
+            this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+            inputData=image;
+            tempData=null;
+            returnData=null;
+            imagePanel=new ImageViewer(image.toBufferedImage(), 320, 240);
+            initComponents();
+            mode=-1;
+            enableTextSpaces();
+	}
+
+        @SuppressWarnings("unchecked")
+    private void initComponents() {
+
+        applyButton = new JButton();
+        previewButton = new JButton();
+        abortButton = new JButton();
+        modeButton = new JToggleButton[3];
+        fields = new JTextField[7][7];
+        for(int i=0;i<3;i++){
+            modeButton[i] = new JToggleButton();
+        }
+        for(int i=0;i<49;i++){
+            fields[i/7][i%7]=new JTextField();
+        }
+
+        setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
+
+        applyButton.setText("Wykonaj");
+        previewButton.setText("Podglad");
+        abortButton.setText("Anuluj");
+        modeButton[0].setText("3x3");
+        modeButton[1].setText("5x5");
+        modeButton[2].setText("7x7");
+
+        applyButton.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                applyMousePressed(evt);
+            }
+        });
+        previewButton.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                previewMousePressed(evt);
+            }
+        });
+        abortButton.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(java.awt.event.MouseEvent evt) {
+                abortMousePressed(evt);
+            }
+        });
+        modeButton[0].addMouseListener(new MouseAdapter() {
+                @Override
+                public void mousePressed(java.awt.event.MouseEvent evt) {
+                    modeMousePressed(evt,0);
+                }
+            });
+        modeButton[1].addMouseListener(new MouseAdapter() {
+                @Override
+                public void mousePressed(java.awt.event.MouseEvent evt) {
+                    modeMousePressed(evt,1);
+                }
+            });
+        modeButton[2].addMouseListener(new MouseAdapter() {
+                @Override
+                public void mousePressed(java.awt.event.MouseEvent evt) {
+                    modeMousePressed(evt,2);
+                }
+            });
+
+        GroupLayout layout = new GroupLayout(getContentPane());
+
+        GroupLayout.ParallelGroup x = layout.createParallelGroup(GroupLayout.Alignment.LEADING);
+        GroupLayout.SequentialGroup y = layout.createSequentialGroup();
+
+        GroupLayout.SequentialGroup xSeq[]=new GroupLayout.SequentialGroup[7];
+        GroupLayout.ParallelGroup yPar[]=new GroupLayout.ParallelGroup[7];
+
+   //     x.addComponent(imagePanel);
+        y.addGap(20,20,20);
+
+        for(int i=0;i<7;i++){
+            xSeq[i]= layout.createSequentialGroup();
+            xSeq[i].addGap(400,400,400);
+            yPar[i]= layout.createParallelGroup();
+            for(int j=0;j<7;j++){
+                xSeq[i].addComponent(fields[i][j], GroupLayout.PREFERRED_SIZE, 25, GroupLayout.PREFERRED_SIZE);
+                yPar[i].addComponent(fields[i][j], GroupLayout.PREFERRED_SIZE, 25, GroupLayout.PREFERRED_SIZE);
+            }
+            xSeq[i].addContainerGap(20, Short.MAX_VALUE);
+
+            x.addGroup(xSeq[i]);
+            y.addGroup(yPar[i]);
+      }
+
+        getContentPane().setLayout(layout);
+        layout.setHorizontalGroup(x
+             .addGroup(layout.createSequentialGroup()
+                .addGap(20,20,20)
+                .addComponent(imagePanel)
+                .addContainerGap(20, Short.MAX_VALUE)
+                )
+             .addGroup(layout.createSequentialGroup()
+                .addGap(40, 40, 40)
+                .addComponent(modeButton[0])
+                .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
+                .addComponent(modeButton[1])
+                .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
+                .addComponent(modeButton[2])
+                .addGap(110, 110, 110)
+                .addComponent(applyButton)
+                .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
+                .addComponent(previewButton)
+                .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
+                .addComponent(abortButton)
+                .addContainerGap(20, Short.MAX_VALUE))
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(GroupLayout.Alignment.LEADING)
+            .addGroup(GroupLayout.Alignment.LEADING, layout.createSequentialGroup()
+                .addGap(20,20,20)
+                .addComponent(imagePanel)
+                )
+            .addGroup(GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
+                .addGroup(y)
+                .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED, 100, Short.MAX_VALUE)
+                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
+                    .addComponent(applyButton)
+                    .addComponent(previewButton)
+                    .addComponent(abortButton)
+                    .addComponent(modeButton[0])
+                    .addComponent(modeButton[1])
+                    .addComponent(modeButton[2])
+                    )
+                .addContainerGap()
+                )
+        );
+        pack();
+    }
+
+    private void enableTextSpaces(){
+        int v = (7-mode)/2;
+        int i, j;
+        for(i=0;i<49;i++){
+            fields[i/7][i%7].setEnabled(false);
+        }
+        for(j=v;j<7-v;j++){
+            for(i=v;i<7-v;i++){
+                fields[i][j].setEnabled(true);
+            }
+        }
+    }
+
+    private Matrix createMatrix(){
+        if(mode==-1){
+            throw new IllegalArgumentException();
+        }
+        int v=(7-mode)/2;
+        int i, j;
+        float tab[]= new float[mode*mode];
+        for(i=v;i<7-v;i++){
+            for(j=v;j<7-v;j++){
+                try{
+                    tab[i-v+mode*(j-v)]=Float.parseFloat(fields[i][j].getText());
+                } catch(NumberFormatException e){
+                    throw e;
+                }
+                System.out.println(tab[i-v+mode*(j-v)]=Float.parseFloat(fields[i][j].getText()));
+            }
+        }
+        return new Matrix(tab);
+    }
+
+    private void applyMousePressed(MouseEvent evt) {
+        try{
+            IFilter filter = new FilterMatrixAdapter(createMatrix());
+            inputData = filter.apply(inputData);
+            imagePanel=new ImageViewer(inputData.toBufferedImage(), 320, 240);
+            returnData = inputData;
+        } catch(NumberFormatException e){
+            throw e;
+        }
+    }
+
+    private void previewMousePressed(MouseEvent evt) {
+        try{
+            IFilter filter = new FilterMatrixAdapter(createMatrix());
+            tempData = filter.apply(inputData);
+            imagePanel=new ImageViewer(tempData.toBufferedImage(), 320, 240);
+        } catch(NumberFormatException e){
+            throw e;
+        }
+    }
+
+    private void abortMousePressed(MouseEvent evt) {
+        this.setVisible(false);
+        returnData=null;
+        //   throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    private void modeMousePressed(MouseEvent evt, int i){
+        if(modeButton[i].isSelected()){
+            mode=-1;
+            enableTextSpaces();
+            return;
+        }
+        mode = 3+2*i;
+        enableTextSpaces();
+        modeButton[0].setSelected(false);
+        for(int j=0;j<3;j++){
+            if((i!=j)&&(modeButton[j].isSelected())){
+                modeButton[j].setSelected(false);
+            }
+        }
+    }
+
+	/**
+	 * Zwraca obraz po edycji
+	 * @return obraz po edycji
+	 */
+    public PixelData getTransformedImage(){
+        return returnData;
+    }
+
+    public PixelData showDialog() {
+        this.setVisible(true);
+        return returnData;
+    }
+}
\ No newline at end of file

=== added file 'src/main/java/manager/editor/WindowRange.java'
--- src/main/java/manager/editor/WindowRange.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/WindowRange.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,151 @@
+package manager.editor;
+
+import java.awt.BorderLayout;
+import java.awt.FlowLayout;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JPanel;
+import javax.swing.border.EmptyBorder;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.JSlider;
+import javax.swing.JLabel;
+import javax.swing.BoxLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+
+/**
+ * Klasa reprezentująca okno do modyfikacji filtrów zakresowych
+ * @author Marcin Regdos
+ */
+public class WindowRange extends JDialog implements ChangeListener, ActionListener, IWindowFilter {
+
+	private final JPanel contentPanel = new JPanel();
+
+	private final PixelData image;
+	private PixelData timage;
+	private final IFilterRange filter;
+	private Range[] ranges;
+	private JLabel [] jlabels;
+	private JSlider [] fSliders;
+	private ImageViewer preview;
+	/**
+	 * Konstruktor wymaga podania obrazu na którym filtr ma pracować oraz samego filtru
+	 * @param image  obraz do edycji
+	 * * @param iFilter filtr zakresowy
+	 */
+	WindowRange(PixelData image, IFilterRange iFilter, String name){
+		this.setModalityType(JDialog.DEFAULT_MODALITY_TYPE);
+		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+		this.image=image;
+		this.filter=iFilter;
+		ranges=filter.getRangeTable();
+		jlabels=new  JLabel [ranges.length];
+		fSliders=new JSlider [ranges.length];
+		timage=(PixelData) image.clone();
+		this.setTitle(name);
+		InitGui();
+		filter.apply(image, timage);
+		preview.setImage(timage.toBufferedImage());
+
+	}
+	private void InitGui() {
+		this.setSize(450, 450);
+		
+		getContentPane().setLayout(new BorderLayout());
+		contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
+		getContentPane().add(contentPanel, BorderLayout.CENTER);
+		contentPanel.setLayout(new BorderLayout(0, 0));
+		{
+			JPanel DescrAndSlidersPanel = new JPanel();
+			JPanel DescrPanel = new JPanel();
+			JPanel SlidersPanel = new JPanel();
+			contentPanel.add(DescrAndSlidersPanel, BorderLayout.CENTER);
+			DescrAndSlidersPanel.setLayout(new BoxLayout(DescrAndSlidersPanel, BoxLayout.X_AXIS));
+			DescrAndSlidersPanel.add(DescrPanel);
+			DescrAndSlidersPanel.add(SlidersPanel);
+			SlidersPanel.setLayout(new BoxLayout(SlidersPanel, BoxLayout.Y_AXIS));
+			DescrPanel.setLayout(new BoxLayout(DescrPanel, BoxLayout.Y_AXIS));
+			for (int i=0; i<ranges.length;++i){
+				{
+					jlabels[i] = new JLabel();
+					DescrPanel.add(jlabels[i]);
+				}
+				{
+					fSliders[i] = new JSlider(0, 100, new Float((ranges[i].getValue()-ranges[i].getMin())/(ranges[i].getMax()-ranges[i].getMin())*100).intValue());
+					fSliders[i].setToolTipText("Zakres od "+ ranges[i].getMin() + " do " + ranges[i].getMax());
+					fSliders[i].addChangeListener(this);
+					SlidersPanel.add(fSliders[i]);
+					jlabels[i].setText(ranges[i].getName());
+					}
+			}
+
+		}
+		preview =new ImageViewer(timage.toBufferedImage(), 300, 300);
+		contentPanel.add(preview, BorderLayout.NORTH);
+		{
+			JPanel buttonPane = new JPanel();
+			buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT));
+			getContentPane().add(buttonPane, BorderLayout.SOUTH);
+			JButton revertButton = new JButton("Resetuj filtr");
+			revertButton.setActionCommand("reset");
+			buttonPane.add(revertButton);
+			revertButton.addActionListener(this);
+			{
+				JButton okButton = new JButton("Zastosuj");
+				okButton.setActionCommand("OK");
+				buttonPane.add(okButton);
+				okButton.addActionListener(this);
+			}
+			{
+				JButton cancelButton = new JButton("Anuluj");
+				cancelButton.setActionCommand("Cancel");
+				buttonPane.add(cancelButton);
+				cancelButton.addActionListener(this);
+			}
+			
+		}
+
+
+	}
+	public void stateChanged(ChangeEvent e) {
+		JSlider source = (JSlider)e.getSource();
+		//if (!source.getValueIsAdjusting()) {
+			for (int i=0; i<ranges.length;++i){
+				if (source==fSliders[i]){
+					ranges[i].interpolate(new Integer (fSliders[i].getValue()).floatValue()/100);
+				}
+			}
+			filter.setRangeTable(ranges);
+			filter.apply(image, timage);
+			preview.setImage(timage.toBufferedImage());
+		//}
+	}
+	@Override
+	public PixelData showDialog(){
+		this.setVisible(true);
+		return timage;
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		if ("OK".equals(e.getActionCommand())) {
+			this.setVisible(false);
+			this.dispose();
+			return;
+		} 
+		if ("Cancel".equals(e.getActionCommand())) {
+			timage=null;
+			this.setVisible(false);
+			this.dispose();
+			return;
+		}
+		if (e.getActionCommand().equals("reset")){
+			filter.reset();
+			for (int i=0; i<ranges.length;++i){
+					fSliders[i].setValue( new Float((ranges[i].getValue()-ranges[i].getMin())/(ranges[i].getMax()-ranges[i].getMin())*100).intValue());
+			}
+			return;
+		}
+	} 
+}

=== added file 'src/main/java/manager/editor/WindowResize.java'
--- src/main/java/manager/editor/WindowResize.java	1970-01-01 00:00:00 +0000
+++ src/main/java/manager/editor/WindowResize.java	2012-04-17 18:42:22 +0000
@@ -0,0 +1,214 @@
+package manager.editor;
+
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import javax.swing.*;
+
+/**
+ * Klasa opisuje okno dialogowe s�u��ce zmianie rozmiaru obrazka
+ * @author Wojtek J�dras
+ */
+
+public class WindowResize extends JDialog implements ActionListener, IWindowFilter
+{
+    private PixelData iMage;
+    private ButtonGroup buttonGroup1;
+    private ButtonGroup buttonGroup2;
+    private JButton jButton1;
+    private JButton jButton2;
+    private JLabel jLabel1;
+    private JLabel jLabel2;
+    private JLabel jLabel3;
+    private JLabel jLabel4;
+    private JRadioButton jRadioButton1;
+    private JRadioButton jRadioButton2;
+    private JRadioButton jRadioButton3;
+    private JRadioButton jRadioButton4;
+    private JTextField jTextField1;
+    private JTextField jTextField2;
+   
+    /**
+     * Konstruktor - wymagany jest obraz do edycji
+     * @param image - referencja do objektu klasy PixelData przechowuj�ca obraz do edycji
+     */
+   
+    public WindowResize(PixelData image)
+	{
+            iMage = image;
+            initComponents();
+        }
+
+                    
+        
+        private void initComponents()
+        {
+            this.setModal(true);
+            buttonGroup1 = new ButtonGroup();
+            buttonGroup2 = new ButtonGroup();
+            jLabel1 = new JLabel();
+            jRadioButton1 = new JRadioButton();
+            jRadioButton2 = new JRadioButton();
+            jLabel2 = new JLabel();
+            jRadioButton3 = new JRadioButton();
+            jRadioButton4 = new JRadioButton();
+            jLabel3 = new JLabel();
+            jLabel4 = new JLabel();
+            jTextField1 = new JTextField();
+            jTextField2 = new JTextField();
+            jButton1 = new JButton();
+            jButton2 = new JButton();
+            
+            setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
+            
+            jLabel1.setText("Algorytm kowersji:");
+            
+            buttonGroup1.add(jRadioButton1);
+            jRadioButton1.setSelected(true);
+            jRadioButton1.setText("Dwuliniowy");
+            
+             buttonGroup1.add(jRadioButton2);
+            jRadioButton2.setText("Najbli�szy s�siad");
+            
+            jLabel2.setText("Zmiana rozmiaru:");
+            
+            jButton1.setText("OK");
+            jButton2.setText("Anuluj");
+            jLabel3.setText("W poziomie:");
+            jLabel4.setText("W pionie:");
+
+            buttonGroup2.add(jRadioButton3);
+            jRadioButton3.setSelected(true);
+            jRadioButton3.setText("Piksele");
+            
+            buttonGroup2.add(jRadioButton4);
+            jRadioButton4.setText("Warto�� procentowa");
+            
+		
+            jButton1.addActionListener(this);
+            jButton2.addActionListener(this);
+        
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
+        getContentPane().setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGroup(layout.createSequentialGroup()
+                .addContainerGap()
+                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                    .addGroup(layout.createSequentialGroup()
+                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                            .addComponent(jLabel1)
+                            .addGroup(layout.createSequentialGroup()
+                                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                                    .addGroup(layout.createSequentialGroup()
+                                        .addGap(39, 39, 39)
+                                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+                                            .addComponent(jLabel3)
+                                            .addComponent(jLabel4)))
+                                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
+                                        .addComponent(jRadioButton1)
+                                        .addGap(8, 8, 8))
+                                    .addGroup(layout.createSequentialGroup()
+                                        .addGap(10, 10, 10)
+                                        .addComponent(jRadioButton3)))
+                                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
+                                    .addGroup(layout.createSequentialGroup()
+                                        .addGap(32, 32, 32)
+                                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                                            .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, 55, javax.swing.GroupLayout.PREFERRED_SIZE)
+                                            .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, 55, javax.swing.GroupLayout.PREFERRED_SIZE))
+                                        .addGap(0, 0, Short.MAX_VALUE))
+                                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
+                                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 4, Short.MAX_VALUE)
+                                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                                            .addComponent(jRadioButton2, javax.swing.GroupLayout.Alignment.TRAILING)
+                                            .addComponent(jRadioButton4, javax.swing.GroupLayout.Alignment.TRAILING))))))
+                        .addContainerGap())
+                    .addGroup(layout.createSequentialGroup()
+                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
+                            .addComponent(jLabel2)
+                            .addComponent(jButton1, javax.swing.GroupLayout.PREFERRED_SIZE, 63, javax.swing.GroupLayout.PREFERRED_SIZE))
+                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+                        .addComponent(jButton2)
+                        .addGap(35, 35, 35))))