Navigation Menu

Skip to content

Instantly share code, notes, and snippets.

@shawnlau

shawnlau/gist:f465a6c17f5fa3fb3fa2

Last active April 15, 2017 09:37
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save shawnlau/f465a6c17f5fa3fb3fa2 to your computer and use it in GitHub Desktop.
Save shawnlau/f465a6c17f5fa3fb3fa2 to your computer and use it in GitHub Desktop.
Download ZIP
Latest incarnation of a processing program that allows real time screen filtering
Raw
gistfile1.txt
/////////////////////////////////////////////
//Update 10 -05-15
// Up and down arrows control the flow rate of the brush for the tool you are using. (new) Now each tool has its own flow rate
// (new)The strength off the tool in current use displays in the title bar. 1 is the strongest, 500 the lightest
// Hold shift and drag the mouse to change brush size, or use the "[" and "]" keys.
// press Control while in paint mode to pick up a paint color. Press control while in clone mode to
// to set clone position. Keypad "+" zooms up. Keypad "-" zooms down. Keys "z" and "x" control the mouse easing.
// The onColor mode allows you to just draw on the color of the image. The "add Frequencies" menu item becomes enable
// only when frequencies have been separated. To separate frequencies, go to settings screen and choose a separation method.
// Blur, SNN, median etc. Set the radius. Then you must click the menu item "Separate frequencies."
// (new) Frequency split settings, effect settings and tool settings now have their own windows.
// (new) a new effect "Structure" has been added to the High Pass group.
// (new) There are now 4 levels of filters. Any filter can be applied at any level. You can apply the same filter
//at multipe levels. In the next few days, even the same filter will be able to have different settings for whatever level its on.
// This required redoing the GUI. Now the menu item is Filters, and there are two choices - Filter selection, and Filter
//adjustments. Load an image and in the filter selection choose Structure as filter 1, SNN as filter 2, Unsharp as filter 3
// and Poisterize as filter 4 for a nice effect. You can draw in this effect.
// Youll note room was left in the gui for another level of filters :)
//(new) There are 5 levels of filters. The filter adjustment window now updates to show only the ajustments available for the
// filter in use.
//(new) filters can be saved as text files and reloaded. All the settings will be saved
//(new) new filter, brightness and contrast added. Still working on a fast Kuwahara.
//Fixed many crashes
/////////////////////////////
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.*;
import java.awt.*;
import java.awt.datatransfer.*;
import javax.imageio.*;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.UnsupportedFlavorException;
//import codeanticode.tablet.*;
import g4p_controls.*;
//Tablet tablet;
PImage img,Scr,Scr2,diffScr,diffScr2,FreqScr;
PGraphics Canvas,Brush,temp,temp2,HF,LF,Posterize,SaveScr,CurFreq;
PGraphics[]uLayers;
float floatCanvas[][];
int SMW; //small window width
int SMH; // height
int SR1,SR2,SR3,SR4,PR1,PR2,PR3,PR4;
color paintColor = color(0,0,0);
int brushR = 0;
int brushG = 0;
int brushB = 0;
int BrushSize = 25;
boolean staticBrushSize = false;
float Brushspacing = 0.01;
float Easing = 0.5;
int Brushtrans = 02;
int transScale;
int realTrans = 20;
int blurRealTrans = 20;
int cloneRealTrans = 20;
int onColorRealTrans = 20;
float leftoverD = 0.0;
float DraggedOffsetX =0;
float DraggedOffsetY = 0;
float FrameOffsetX = 0;
float FrameOffsetY = 0;
float zoom = 1.0;
int PreviousX,PreviousY;
int CmouseX,CmouseY;
int previousCursor = ARROW;
int numUndo = 20;
int curUndo;
int curRedo;
int undoInstances = 0;
int redoInstances = 0;
boolean undoSaved = false;
int CloneOffsetX = 0;
int CloneOffsetY = 0;
int CloneX1 =0;
int CloneX2 = 0;
int CloneY1 = 0;
int CloneY2 = 0;
boolean C1set = false;
boolean C2set = false;
String Info;
int PosterLevel = 0;
int []scr_blur = new int[5];
int []scr_posterize = new int[5];
int []scr_erode = new int[5];
int []scr_dilate = new int[5];
float []scr_sharp = new float[5];
int []scr_usharp = new int[5];
int []scr_hiPass = new int [5];
int []scr_snnAmount = new int[5];
float []scr_structureContrast = new float[5];
int []scr_structureRadius = new int[5];
int []scr_contrast = new int[5];
int []scr_brightness = new int[5];
float []Hcontrast = new float[5];
float []Hbrightness = new float[5];
float []Lcontrast = new float[5];
float []Lbrightness = new float[5];
int curAdjustment = 0;
boolean ScreenEnhanced = false;
float eContrast = 25;
float eBrightness = 0;
boolean AddEnhanced = true;
boolean ScreenSaved = false;
int PreviousWidth;
int PreviousHeight;
int BLURRED = 0;
int MEDIAN2 = 1;
int MEDIAN3 = 2;
int COLOR = 3;
int KUWAHARA = 4;
int SNN = 5;
int SPLIT_METHOD = BLURRED;
int MedianPasses = 4;
int BlurSplit = 4;
int KuwaharaSplit = 4;
int SNNSplit = 4;
int ColorSplit = 100;
int JOINED = 0;
int LFREQ = 1;
int HFREQ = 2;
int frequencyMode = JOINED;
boolean GRAYFREQUENCY = false;
float scaleFactor = 0.30;
public abstract class Mode {
public abstract void draw();
}
public abstract class Effect{
public String name;
public abstract void saveScreen(int filter);
public abstract void updateScreen(int filter);
}
Effect []filters;
Effect normalE,blurE,posterizeE,closeHolesE,erodeE,dilateE,unSharpE,addFreqE,snnE;
Effect highPassE,colorHighPassE,structureE,sharpenE,contrastE;
Mode currentMode,previousMode;
Mode drawingMode, chooseColorMode, dragMode,cloneMode,setCloneMode,setClone2Mode,SizeBrushMode,blurMode,onColorMode;
void setup(){
size(800,800);
frame.setResizable(true);
noFill();
createGUI();
customGUI();
Canvas = createGraphics(800,800);
Canvas.beginDraw();
Canvas.noStroke();
Canvas.background(255);
Canvas.endDraw();
setupGraphics();
floatCanvas = new float[Canvas.width * Canvas.height][3];
loadFloatArray();
setupBrush();
updateInfo();
// tablet = new Tablet(this);
setupFilterAdjustments();
setupDrawModes();
setupEffects();
currentMode = drawingMode;
previousMode = drawingMode;
filters = new Effect[5];
for(int i = 0; i < 5;i++)
filters[i] = normalE;
disableAdjustments();
menu_setup();
scrSettings.setTitle(filters[0].name);
transScale = 1+ (int)((float)realTrans * ((float)BrushSize * scaleFactor));
}
void draw(){
// updateInfo();
if(height != PreviousHeight || width!= PreviousWidth)
ScreenSaved = false;
background(200);
//all this makes sure the canvas zooms from the center of the window
//and stays in the center when zoomed smaller that the window
FrameOffsetX = (width- Canvas.width * zoom)/2;
FrameOffsetY = (height - Canvas.height * zoom)/2;
if(DraggedOffsetX > -(FrameOffsetX))
DraggedOffsetX= -FrameOffsetX;
else if(DraggedOffsetX < FrameOffsetX)
DraggedOffsetX=FrameOffsetX;
if(Canvas.width * zoom < width)
DraggedOffsetX = 0;
if(DraggedOffsetY > -(FrameOffsetY))
DraggedOffsetY= -FrameOffsetY;
else if(DraggedOffsetY < FrameOffsetY)
DraggedOffsetY=FrameOffsetY;
if(Canvas.height *zoom < height)
DraggedOffsetY = 0;
CmouseX = (int)((constrain(mouseX,0,width-1)-DraggedOffsetX-FrameOffsetX)/zoom);
CmouseY = (int)(( constrain(mouseY,0,height-1)-DraggedOffsetY-FrameOffsetY)/zoom);
currentMode.draw();
if(currentMode == dragMode)
image(Canvas, DraggedOffsetX+FrameOffsetX, DraggedOffsetY+FrameOffsetY,
Canvas.width* zoom, Canvas.height * zoom);
else{
float offsetX = DraggedOffsetX+FrameOffsetX;
float offsetY = DraggedOffsetY+FrameOffsetY;
PR1 = CmouseX - SMW/2;
if(PR1 < 0) PR1 = 0;
PR3 = PR1 + SMW-1;
if(PR3 > Canvas.width -1) PR3 = Canvas.width -1;
PR1 = PR3 - SMW + 1;
PR2 = CmouseY - SMW/2;
if(PR2 < 0) PR2 = 0;
PR4 = PR2 + SMH -1;
if(PR4 > Canvas.height-1) PR4 = Canvas.height -1;
PR2 = PR4 - SMH + 1;
int p1 = SR1 = (int)(PR1 * zoom + DraggedOffsetX+FrameOffsetX);
int p2= SR2 = (int)(PR2 * zoom + DraggedOffsetY + FrameOffsetY);
int p3 =SR3 = (int)(PR3 * zoom + DraggedOffsetX+FrameOffsetX);
int p4 = SR4 = (int)(PR4 * zoom + DraggedOffsetY + FrameOffsetY);
Scr2 = createImage(PR3 - PR1 + 1,PR4 - PR2 +1, RGB);
// System.out.printf("%d,%d,%d,%d - %f,%f\n",PR1,PR2,PR3,PR4,offsetX,offsetY);
int ex = canvasToImage(PR1,PR2,PR3-PR1+1,PR4-PR2+1,Scr2);
if(ex == -1)
println(" error 1");
// Scr2.copy(Canvas,PR1,PR2,PR3-PR1,PR4-PR2,0,0,Scr2.width,Scr2.height);
for(int i = 0; i < 5;i++)
filters[i].updateScreen(i);
SR1 = FrameOffsetX < 0 ? 0 :(int)( FrameOffsetX);
SR2 = FrameOffsetY < 0 ? 0 :(int)(FrameOffsetY);
SR3 = FrameOffsetX < 0 ? width - 1 : (int)(width - 1 - FrameOffsetX);
SR4 = FrameOffsetY < 0 ? height -1 : (int)( height -1 - FrameOffsetY);
if(!ScreenSaved){
PR1 = (int)(((SR1-offsetX)/zoom)); PR2 = (int)(((SR2-offsetY)/zoom));
PR3 = (int)(((SR3 -offsetX)/zoom)); PR4 = (int)(((SR4-offsetY)/zoom));
// System.out.printf("%d,%d,%d,%d, %d,%d,%d,%d - %f,%f\n",SR1,SR2,SR3,SR4,PR1,PR2,PR3,PR4,offsetX,offsetY);
if(PR1 < 0) PR1 = 0; if(PR2 < 0) PR2 = 0;
if(FrameOffsetX >=0 && FrameOffsetY >=0){ // whole canvas is showing
Scr = createImage(Canvas.width,Canvas.height,RGB);
fastCopyScr();
}
else{
Scr = createImage(PR3 - PR1 + 1,PR4 - PR2 +1,RGB);
ex = canvasToImage(PR1,PR2,PR3-PR1+1,PR4-PR2+1,Scr);
if(ex == -1)
println(" error 2");
// Scr.copy(Canvas,PR1,PR2,PR3-PR1+1,PR4-PR2+1,0,0,Scr.width,Scr.height); //copy visible canvas are from canvas
}
for(int i = 0; i < 5;i++)
filters[i].saveScreen(i);
ScreenSaved = true;
}
if(filters[0] == normalE && filters[1] == normalE && filters[3] == normalE) //don't use the shakey screens if no effects
image(Canvas, DraggedOffsetX+FrameOffsetX, DraggedOffsetY+FrameOffsetY,
Canvas.width* zoom, Canvas.height * zoom);
else image(Scr,SR1,SR2,SR3-SR1+1,SR4-SR2+1);
if(filters[0] == normalE && filters[1] == normalE && filters[3] == normalE)
image(Canvas, DraggedOffsetX+FrameOffsetX, DraggedOffsetY+FrameOffsetY,
Canvas.width* zoom, Canvas.height * zoom);
else
image(Scr2,p1,p2,p3-p1,p4-p2); // the shakiness comes from the rounding
}
PreviousHeight = height;
PreviousWidth = width;
if(ScreenEnhanced){ // this is a screen contrast mode. Key "e" toggles it on and of, page up and down to
//change contrast.
loadPixels();
int np = width * height;
float r,g,b;
color inColor;
for(int i = 0; i< np; i++){
inColor = pixels[i];
r = (inColor >>16) & 0xFF;
g = (inColor >>8) & 0xFF;
b = inColor & 0xFF;
r = ((r - 127.5) * eContrast +127.5 + eBrightness);
g = ((g -127.5) * eContrast + 127.5 + eBrightness);
b = ((b - 127.5) * eContrast + 127.5 + eBrightness);
r = r < 0 ? 0 : r > 255 ? 255 : r;
g = g < 0 ? 0 : g > 255 ? 255 : g;
b = b < 0 ? 0 : b > 255 ? 255 : b;
pixels[i] = 0xff000000 | ((int)r << 16) | ((int)g << 8) | (int)b;
}
updatePixels();
}
ellipse(mouseX,mouseY,BrushSize * zoom ,BrushSize * zoom);
if(currentMode == cloneMode)
ellipse(mouseX+CloneOffsetX*zoom,mouseY+CloneOffsetY*zoom,BrushSize * zoom ,BrushSize * zoom);
}
public void customGUI(){
scrSettings.setVisible(false);
scrSettings.setOnTop(false);
SplitSettings.setVisible(false);
SplitSettings.setOnTop(false);
toolSettings.setVisible(false);
toolSettings.setOnTop(false);
effectSettings.setVisible(false);
effectSettings.setOnTop(false);
e1AddFreq.setVisible(false);
e2AddFreq.setVisible(false);
e3AddFreq.setVisible(false);
e4AddFreq.setVisible(false);
e5AddFreq.setVisible(false);
// view_window.papplet.frameRate(8); Future
}
void mousePressed(){
if(currentMode == drawingMode || currentMode == cloneMode || currentMode ==setClone2Mode
||currentMode ==blurMode || currentMode == onColorMode)
save_undo();
}
void mouseReleased(){
if(currentMode ==drawingMode || currentMode == cloneMode || currentMode == blurMode ||currentMode == onColorMode){
loadFloatArray();
ScreenSaved = false;
}
}
float myLine(float x1, float y1, float x2, float y2, float leftover){
float spacing = BrushSize * Brushspacing;
if ( spacing < 0.5 )
spacing = 0.5;
float deltaX = x2 - x1;
float deltaY = y2-y1;
float distance = sqrt(deltaX * deltaX + deltaY * deltaY);
float stepX = 0.0;
float stepY = 0.0;
if(distance > 0.0){
float invertDistance = 1.0/distance;
stepX = deltaX * invertDistance;
stepY = deltaY * invertDistance;
}
float offsetX = 0.0;
float offsetY = 0.0;
float totalDistance = leftover + distance;
Brush.loadPixels();
Canvas.loadPixels();
while ( totalDistance >= spacing ) {
// Increment where we put the stamp
if ( leftover > 0 ) {
// If we're making up distance we didn't cover the last
// time we drew a line, take that into account when calculating
// the offset. leftOverDistance is always < spacing.
offsetX += stepX * (spacing - leftoverD);
offsetY += stepY * (spacing - leftoverD);
leftover -= spacing;
} else {
// The normal case. The offset increment is the normalized vector
// times the spacing
offsetX += stepX * spacing;
offsetY += stepY * spacing;
}
int x = (int)(x1 + offsetX-BrushSize/2);
int y = (int)(y1 + offsetY-BrushSize/2);
// float penPressure = tablet.getPressure();
float penPressure = 1.0;
transScale = 1+ (int)((float)realTrans * ((float)BrushSize *scaleFactor));
for(int by = 0; by <Brush.height;by++, y++){
if(y < 0 || y >= Canvas.height) continue;
int index = y * Canvas.width + x;
int bindex = by * Brush.height;
int xx = x;
for(int bx= 0; bx < Brush.width;bx++,xx++,index++,bindex++){
if( xx < 0 || xx >= Canvas.width ) continue;
if( (Brush.pixels[bindex] & 0xFF) ==0)
continue;
float red = (brushR * penPressure + floatCanvas[index][0] * (transScale-penPressure) )/transScale;
float green = (brushG * penPressure + floatCanvas[index][1] * (transScale-penPressure) )/transScale;
float blue = (brushB * penPressure + floatCanvas[index][2] * (transScale-penPressure) )/transScale;
if( red > 255) red = 255; if(red <0) red = 0;
if( green > 255) green = 255; if(green <0) green = 0;
if( blue > 255) blue = 255; if(blue <0) blue = 0;
Canvas.pixels[index] = 0xFF000000|Math.round(red) << 16|Math.round(green)<< 8| Math.round(blue);
floatCanvas[index][0] = red;floatCanvas[index][1] = green; floatCanvas[index][2] = blue;
}
}
// Remove the distance we just covered
totalDistance -= spacing;
}
Canvas.updatePixels();
return totalDistance;
}
float myClone(float x1, float y1, float x2, float y2, int cOffsetX,int cOffsetY, float leftover){
float spacing = BrushSize * Brushspacing;
if ( spacing < 0.5 )
spacing = 0.5;
float deltaX = x2 - x1;
float deltaY = y2-y1;
float distance = sqrt(deltaX * deltaX + deltaY * deltaY);
float stepX = 0.0;
float stepY = 0.0;
if(distance > 0.0){
float invertDistance = 1.0/distance;
stepX = deltaX * invertDistance;
stepY = deltaY * invertDistance;
}
float offsetX = 0.0;
float offsetY = 0.0;
float totalDistance = leftover + distance;
Brush.loadPixels();
Canvas.loadPixels();
while ( totalDistance >= spacing ) {
// Increment where we put the stamp
if ( leftover > 0 ) {
// If we're making up distance we didn't cover the last
// time we drew a line, take that into account when calculating
// the offset. leftOverDistance is always < spacing.
offsetX += stepX * (spacing - leftoverD);
offsetY += stepY * (spacing - leftoverD);
leftover -= spacing;
} else {
// The normal case. The offset increment is the normalized vector
// times the spacing
offsetX += stepX * spacing;
offsetY += stepY * spacing;
}
// Calculate where to put the current stamp at
// Ka-chunk! Draw the image at the current location
// blitBrush( (int)(x1 + offsetX-BrushSize/2), (int)(y1 + offsetY-BrushSize/2));
int x = (int)(x1 + offsetX-BrushSize/2);
int y = (int)(y1 + offsetY-BrushSize/2);
// float penPressure =tablet.getPressure();
float penPressure = 1.0;
transScale = 1+ (int)((float)cloneRealTrans * ((float)BrushSize *scaleFactor));
for(int by = 0; by <Brush.height;by++, y++){
if(y < 0 || y >= Canvas.height) continue;
if(y+cOffsetY< 0 || y+cOffsetY >= Canvas.height) continue;
int index = y * Canvas.width + x;
int cindex = (y + cOffsetY) * Canvas.width + x + cOffsetX;
int bindex = by * Brush.height;
int xx = x;
for(int bx= 0; bx < Brush.width;bx++,xx++,index++,bindex++,cindex++){
if( xx < 0 || xx >= Canvas.width ) continue;
if( xx + cOffsetX < 0 || xx + cOffsetX >= Canvas.width ) continue;
if( (Brush.pixels[bindex] & 0xFF) ==0)
continue;
float red = (floatCanvas[cindex][0] * penPressure + floatCanvas[index][0] * (transScale-penPressure) )/transScale;
float green = (floatCanvas[cindex][1] * penPressure + floatCanvas[index][1] * (transScale-penPressure) )/transScale;
float blue = (floatCanvas[cindex][2] * penPressure + floatCanvas[index][2] * (transScale-penPressure) )/transScale;
if( red > 255) red = 255; if(red <0) red = 0;
if( green > 255) green = 255; if(green <0) green = 0;
if( blue > 255) blue = 255; if(blue <0) blue = 0;
Canvas.pixels[index] = 0xFF000000|Math.round(red) << 16|Math.round(green)<< 8| Math.round(blue);
floatCanvas[index][0] = red;floatCanvas[index][1] = green; floatCanvas[index][2] = blue;
}
}
// Remove the distance we just covered
totalDistance -= spacing;
}
Canvas.updatePixels();
return totalDistance;
}
float myBlur(float x1, float y1, float x2, float y2, float leftover){
float spacing = BrushSize * Brushspacing;
if ( spacing < 0.5 )
spacing = 0.5;
float deltaX = x2 - x1;
float deltaY = y2-y1;
float distance = sqrt(deltaX * deltaX + deltaY * deltaY);
float stepX = 0.0;
float stepY = 0.0;
if(distance > 0.0){
float invertDistance = 1.0/distance;
stepX = deltaX * invertDistance;
stepY = deltaY * invertDistance;
}
float offsetX = 0.0;
float offsetY = 0.0;
float totalDistance = leftover + distance;
Brush.loadPixels();
Canvas.loadPixels();
while ( totalDistance >= spacing ) {
// Increment where we put the stamp
if ( leftover > 0 ) {
// If we're making up distance we didn't cover the last
// time we drew a line, take that into account when calculating
// the offset. leftOverDistance is always < spacing.
offsetX += stepX * (spacing - leftoverD);
offsetY += stepY * (spacing - leftoverD);
leftover -= spacing;
} else {
// The normal case. The offset increment is the normalized vector
// times the spacing
offsetX += stepX * spacing;
offsetY += stepY * spacing;
}
int x = (int)(x1 + offsetX-BrushSize/2);
int y = (int)(y1 + offsetY-BrushSize/2);
// float penPressure = tablet.getPressure();
transScale = 1+ (int)((float)blurRealTrans * ((float)BrushSize *scaleFactor));
for(int by = 0; by <Brush.height;by++, y++){
if(y-1 < 0 || y+1 >= Canvas.height) continue;
int index = y * Canvas.width + x;
int bindex = by * Brush.height;
int xx = x;
for(int bx= 0; bx < Brush.width;bx++,xx++,index++,bindex++){
if( xx-1 < 0 || xx+1 >= Canvas.width ) continue;
if( (Brush.pixels[bindex] & 0xFF) ==0)
continue;
float red = (floatCanvas[index][0] * transScale +
(floatCanvas[index][0]+ floatCanvas[index + 1][0]+floatCanvas[index-1][0]+
floatCanvas[index+Canvas.width][0]+floatCanvas[index-Canvas.width][0]) / 5 )/(transScale+1);
float green = (floatCanvas[index][1] * transScale +
(floatCanvas[index][1]+ floatCanvas[index + 1][1]+floatCanvas[index-1][1]+
floatCanvas[index+Canvas.width][1]+floatCanvas[index-Canvas.width][1]) / 5 )/(transScale+1);
float blue = (floatCanvas[index][2] * transScale +
(floatCanvas[index][2]+ floatCanvas[index + 1][2]+floatCanvas[index-1][2]+
floatCanvas[index+Canvas.width][2]+floatCanvas[index-Canvas.width][2]) / 5 )/(transScale +1);
if( red > 255) red = 255; if(red <0) red = 0;
if( green > 255) green = 255; if(green <0) green = 0;
if( blue > 255) blue = 255; if(blue <0) blue = 0;
Canvas.pixels[index] = 0xFF000000|Math.round(red) << 16|Math.round(green)<< 8| Math.round(blue);
floatCanvas[index][0] = red;floatCanvas[index][1] = green; floatCanvas[index][2] = blue;
}
}
// Remove the distance we just covered
totalDistance -= spacing;
}
Canvas.updatePixels();
return totalDistance;
}
float myDrawOnColor(float x1, float y1, float x2, float y2, float leftover){
float spacing = BrushSize * Brushspacing;
if ( spacing < 0.5 )
spacing = 0.5;
float deltaX = x2 - x1;
float deltaY = y2-y1;
float distance = sqrt(deltaX * deltaX + deltaY * deltaY);
float stepX = 0.0;
float stepY = 0.0;
if(distance > 0.0){
float invertDistance = 1.0/distance;
stepX = deltaX * invertDistance;
stepY = deltaY * invertDistance;
}
float offsetX = 0.0;
float offsetY = 0.0;
float totalDistance = leftover + distance;
Brush.loadPixels();
Canvas.loadPixels();
while ( totalDistance >= spacing ) {
// Increment where we put the stamp
if ( leftover > 0 ) {
// If we're making up distance we didn't cover the last
// time we drew a line, take that into account when calculating
// the offset. leftOverDistance is always < spacing.
offsetX += stepX * (spacing - leftoverD);
offsetY += stepY * (spacing - leftoverD);
leftover -= spacing;
} else {
// The normal case. The offset increment is the normalized vector
// times the spacing
offsetX += stepX * spacing;
offsetY += stepY * spacing;
}
int val = (brushR + brushG + brushB)/3;
int cR = brushR - val + 127; //if(cR <0) cR = 0;
int cG = brushG - val + 127; //if(cG <0) cG = 0;
int cB = brushB - val + 127; //if(cB <0) cB = 0;
int x = (int)(x1 + offsetX-BrushSize/2);
int y = (int)(y1 + offsetY-BrushSize/2);
// float penPressure = tablet.getPressure();
float penPressure = 1.0;
transScale = 1+ (int)((float)onColorRealTrans * ((float)BrushSize *scaleFactor));
for(int by = 0; by <Brush.height;by++, y++){
if(y < 0 || y >= Canvas.height) continue;
int index = y * Canvas.width + x;
int bindex = by * Brush.height;
int xx = x;
for(int bx= 0; bx < Brush.width;bx++,xx++,index++,bindex++){
if( xx < 0 || xx >= Canvas.width ) continue;
if( (Brush.pixels[bindex] & 0xFF) ==0)
continue;
float value = (floatCanvas[index][0] + floatCanvas[index][1] + floatCanvas[index][2])/3 ;
float red = (floatCanvas[index][0] * transScale + cR + value -127)/(transScale+1);
float green = (floatCanvas[index][1] * transScale + cG + value-127)/(transScale+1);
float blue = (floatCanvas[index][2] * transScale + cB + value-127)/(transScale+1);
if( red > 255) red = 255; if(red <0) red = 0;
if( green > 255) green = 255; if(green <0) green = 0;
if( blue > 255) blue = 255; if(blue <0) blue = 0;
Canvas.pixels[index] = 0xFF000000|Math.round(red) << 16|Math.round(green)<< 8| Math.round(blue);
floatCanvas[index][0] = red;floatCanvas[index][1] = green; floatCanvas[index][2] = blue;
}
}
// Remove the distance we just covered
totalDistance -= spacing;
}
Canvas.updatePixels();
return totalDistance;
}
void setupBrush(){
Brush =createGraphics(BrushSize+2,BrushSize + 2);
Brush.beginDraw();
if(BrushSize == 1){
Brush.stroke(255);
Brush.point(0,0);
Brush.endDraw();
}
else{
Brush.noStroke();
Brush.fill(255);
Brush.ellipse(BrushSize/2 + 1, BrushSize/2 + 1,BrushSize,BrushSize);
Brush.endDraw();
}
}
void zoom_up(){
DraggedOffsetX = DraggedOffsetX/zoom *(zoom+0.1);
DraggedOffsetY = DraggedOffsetY/zoom *(zoom+0.1);
zoom = zoom +0.1;
if(staticBrushSize){
BrushSize = (int)(BrushSize /zoom);
if (BrushSize< 1) BrushSize = 1;
setupBrush();
}
ScreenSaved = false;
}
void zoom_down(){
if(zoom<= 0.2)
zoom = 0.2;
DraggedOffsetX = DraggedOffsetX/zoom *(zoom -0.1);
DraggedOffsetY = DraggedOffsetY/zoom *(zoom -0.1);
zoom = zoom - 0.1;
if(staticBrushSize){
BrushSize = (int)(BrushSize /zoom);
if (BrushSize < 1) BrushSize = 1;
setupBrush();
}
ScreenSaved = false;
}
void fastCopyScr(){
int pix = Scr.width * Scr.height;
for( int i =0; i < pix;i++)
Scr.pixels[i] = Canvas.pixels[i];
Scr.updatePixels();
}
int canvasToImage(int cx,int cy,int cw,int ch,PImage img){
if(cw != img.width || ch != img.height)
return -1;
int xend = cx+cw; int yend = cy + ch;
int i = 0;
Canvas.loadPixels();
img.loadPixels();
for( ; cy < yend; cy++){
int loc = cy * Canvas.width + cx;
for( int x = cx; x < xend; x++)
img.pixels[i++] = Canvas.pixels[loc++];
}
img.updatePixels();
return 0;
}
void imagetoImage(PImage source, PImage dest){
int pix = source.width * source.height;
for(int i = 0; i < pix; i++)
dest.pixels[i] = source.pixels[i];
dest.updatePixels();
}
////////////////////////// Blur
void blurImage(PImage img, int sz){
int pix = img.width * img.height;
int back,front,rsum,gsum,bsum,shift;
back = front = shift = 0;
int r[] = new int[pix];
int g[] = new int[pix];
int b[] = new int[pix];
switch(sz){
case 4:
back = -1;front = 2; shift = 2;
break;
case 8:
back = -3; front = 4; shift = 3;
break;
case 16:
back = -7; front = 8;shift = 4;
break;
case 32:
back = -15; front = 16;shift = 5;
break;
case 64:
back = -31; front = 32;shift = 6;
break;
case 128:
back = -63;front = 64; shift = 7;
break;
case 256:
back = -127;front = 128; shift = 8;
break;
case 512:
back = -255;front = 256; shift = 9;
break;
}
rsum = gsum=bsum= 0;
for(int y = 0;y <img.height;y++){
int loc = y * img.width;
rsum = gsum=bsum= 0;
for( int x =back; x <=front; x++){
int x1 =reflect(img.width,x);
rsum+= (img.pixels[loc+x1] >> 16 & 0xFF);
gsum+= (img.pixels[loc+x1] >> 8 & 0xFF);
bsum+= (img.pixels[loc+x1] & 0xFF);
}
r[loc] = (rsum >> shift) & 0xFF;
g[loc] = (gsum >> shift) & 0xFF;
b[loc] = (bsum >> shift) & 0xFF;
int drop = back -1;
for(int x = 1; x <img.width;x++){
int x1 = reflect(img.width, x + drop); //drop (subtract) pixel from back of window
rsum -= (img.pixels[loc + x1]) >>16 & 0xFF;
gsum -= (img.pixels[loc + x1]) >> 8 & 0xFF;
bsum -= (img.pixels[loc + x1]) & 0xFF;
x1 = reflect(img.width,x+front); //add new pixel to sum
rsum += (img.pixels[loc + x1]) >>16 & 0xFF;
gsum += (img.pixels[loc + x1]) >> 8 & 0xFF;
bsum += (img.pixels[loc + x1]) & 0xFF;
r[loc+x]= (rsum >> shift)&0xFF;
g[loc+x] = (gsum >> shift)& 0xFF;
b[loc+x] = (bsum >> shift) & 0xFF;
}
}
rsum = gsum=bsum= 0;
for(int x = 0; x < img.width;x++){
rsum = gsum=bsum= 0;
for(int y = back; y <= front;y++){
int y1 = reflect(img.height,y);
rsum+=r[y1 * img.width + x];
gsum+=g[y1 * img.width + x];
bsum+=b[y1 * img.width + x];
}
img.pixels[x] = 0xFF000000|(rsum >> shift & 0xFF)<<16|(gsum >>shift & 0xFF) << 8|bsum>> shift & 0xFF;
int drop = back -1;
for(int y = 1; y < img.height; y++){
int y1 = reflect(img.height,y + drop);
rsum -= r[y1 * img.width+x];
gsum -= g[y1 * img.width+x];
bsum -= b[y1 * img.width+x];
y1 = reflect(img.height,y + front);
rsum += r[y1 * img.width+x];
gsum += g[y1 * img.width+x];
bsum += b[y1 * img.width+x];
img.pixels[y * img.width + x] = 0xFF000000|(rsum >> shift & 0xFF)<<16|(gsum >>shift & 0xFF) << 8|bsum>> shift & 0xFF;
}
}
img.updatePixels();
}
// this one is not detectably slower than the above and the values aren't hard coded. I'm using this one so far.
void blurImage2(PImage img, int sz){
int pix = img.width * img.height;
int rsum,gsum,bsum;
int back, front;
int r[] = new int[pix];
int g[] = new int[pix];
int b[] = new int[pix];
if (sz > img.width) sz = img.width;
if(sz > img.height) sz = img.height;
if((sz & 1) != 0)
back = -sz/2;
else back = -sz/2 + 1;
front = sz/2;
for(int y = 0;y <img.height;y++){
int loc = y * img.width;
rsum = gsum=bsum= 0;
for( int x =back; x <=front; x++){
int x1 =reflect(img.width,x);
rsum+= (img.pixels[loc+x1] >> 16 & 0xFF);
gsum+= (img.pixels[loc+x1] >> 8 & 0xFF);
bsum+= (img.pixels[loc+x1] & 0xFF);
}
r[loc] = rsum /sz;
g[loc] = gsum /sz;
b[loc] = bsum /sz;
int drop = back -1;
for(int x = 1; x <img.width;x++){
int x1 = reflect(img.width, x + drop);
rsum -= (img.pixels[loc + x1]) >>16 & 0xFF;
gsum -= (img.pixels[loc + x1]) >> 8 & 0xFF;
bsum -= (img.pixels[loc + x1]) & 0xFF;
x1 = reflect(img.width,x+front);
rsum += (img.pixels[loc + x1]) >>16 & 0xFF;
gsum += (img.pixels[loc + x1]) >> 8 & 0xFF;
bsum += (img.pixels[loc + x1]) & 0xFF;
r[loc+x]= rsum /sz;
g[loc+x] = gsum /sz;
b[loc+x] = bsum /sz;
}
}
for(int x = 0; x < img.width;x++){
rsum = gsum=bsum= 0;
for(int y = back; y <= front;y++){
int y1 = reflect(img.height,y);
rsum+=r[y1 * img.width + x];
gsum+=g[y1 * img.width + x];
bsum+=b[y1 * img.width + x];
}
img.pixels[x] = 0xFF000000|(rsum/sz)<<16|(gsum /sz) << 8|bsum /sz;
int drop = back -1;
for(int y = 1; y < img.height; y++){
int y1 = reflect(img.height,y + drop);
rsum -= r[y1 * img.width+x];
gsum -= g[y1 * img.width+x];
bsum -= b[y1 * img.width+x];
y1 = reflect(img.height,y + front);
rsum += r[y1 * img.width+x];
gsum += g[y1 * img.width+x];
bsum += b[y1 * img.width+x];
img.pixels[y * img.width + x] = 0xFF000000|(rsum /sz)<<16|(gsum /sz) << 8|bsum /sz;
}
}
img.updatePixels();
}
void blurGraphics(PGraphics img, int sz){
int pix = img.width * img.height;
int rsum,gsum,bsum;
int back, front;
int r[] = new int[pix];
int g[] = new int[pix];
int b[] = new int[pix];
if((sz & 1) != 0)
back = -sz/2;
else back = -sz/2 + 1;
front = sz/2;
for(int y = 0;y <img.height;y++){
int loc = y * img.width;
rsum = gsum=bsum= 0;
for( int x =back; x <=front; x++){
int x1 =reflect(img.width,x);
rsum+= (img.pixels[loc+x1] >> 16 & 0xFF);
gsum+= (img.pixels[loc+x1] >> 8 & 0xFF);
bsum+= (img.pixels[loc+x1] & 0xFF);
}
r[loc] = rsum /sz;
g[loc] = gsum /sz;
b[loc] = bsum /sz;
int drop = back -1;
for(int x = 1; x <img.width;x++){
int x1 = reflect(img.width, x + drop);
rsum -= (img.pixels[loc + x1]) >>16 & 0xFF;
gsum -= (img.pixels[loc + x1]) >> 8 & 0xFF;
bsum -= (img.pixels[loc + x1]) & 0xFF;
x1 = reflect(img.width,x+front);
rsum += (img.pixels[loc + x1]) >>16 & 0xFF;
gsum += (img.pixels[loc + x1]) >> 8 & 0xFF;
bsum += (img.pixels[loc + x1]) & 0xFF;
r[loc+x]= rsum /sz;
g[loc+x] = gsum /sz;
b[loc+x] = bsum /sz;
}
}
for(int x = 0; x < img.width;x++){
rsum = gsum=bsum= 0;
for(int y = back; y <= front;y++){
int y1 = reflect(img.height,y);
rsum+=r[y1 * img.width + x];
gsum+=g[y1 * img.width + x];
bsum+=b[y1 * img.width + x];
}
img.pixels[x] = 0xFF000000|(rsum/sz)<<16|(gsum /sz) << 8|bsum /sz;
int drop = back -1;
for(int y = 1; y < img.height; y++){
int y1 = reflect(img.height,y + drop);
rsum -= r[y1 * img.width+x];
gsum -= g[y1 * img.width+x];
bsum -= b[y1 * img.width+x];
y1 = reflect(img.height,y + front);
rsum += r[y1 * img.width+x];
gsum += g[y1 * img.width+x];
bsum += b[y1 * img.width+x];
img.pixels[y * img.width + x] = 0xFF000000|(rsum /sz)<<16|(gsum /sz) << 8|bsum /sz;
}
}
img.updatePixels();
}
/////////////////////////////////////////////Filters
int Levels = 256;
int[][]canvasPix;
int[][]posterArray1 = new int[256][1];
int[][]posterArray2 = new int[256][1];
int[][]posterArray3 = new int[256][1];
int[][]posterArray4 = new int[256][1];
int[][]posterArray5 = new int[256][1];
int[][]posterArray6 = new int[256][1];
int[][]posterArray7 = new int[256][1];
int[][]posterArray8 = new int[256][1];
int[][]posterArray9 = new int[256][1];
void poster(){
if(frequencyMode != JOINED) return;
switch(PosterLevel){
case 0:
setup_posterArray();
PosterLevel++;
Levels = 0;
break;
case 1:
run_array(posterArray1);
PosterLevel++;
Levels = 2;
break;
case 2:
run_array(posterArray2);
PosterLevel++;
Levels = 4;
break;
case 3 :
run_array(posterArray3);
PosterLevel++;
Levels = 8;
break;
case 4:
run_array(posterArray4);
PosterLevel++;
Levels = 16;
break;
case 5:
run_array(posterArray5);
PosterLevel++;
Levels = 32;
break;
case 6:
run_array(posterArray6);
PosterLevel++;
Levels = 64;
break;
case 7:
run_array(posterArray7);
PosterLevel++;
Levels = 128;
break;
case 8:
end_poster();
PosterLevel = 0;
Levels = 256;
break;
}
}
void end_poster(){
if(PosterLevel == 0) return;
if(frequencyMode != JOINED) return;
int pix = Canvas.width*Canvas.height;
Canvas.beginDraw();
Canvas.loadPixels();
Posterize.beginDraw();
Posterize.loadPixels();
for( int i = 0; i < pix;i++){
int pr = Posterize.pixels[i] >> 16 & 255;
int pg = Posterize.pixels[i] >> 8 & 255;
int pb = Posterize.pixels[i] & 255;
pr+=Canvas.pixels[i]>>16 & 0xFF;
pg+=Canvas.pixels[i]>>8 & 0xFF;
pb+=Canvas.pixels[i] & 0xFF;
Canvas.pixels[i] = color(pr,pg,pb);
Posterize.pixels[i] = color(255,0,0);
}
Canvas.updatePixels();
Posterize.updatePixels();
Canvas.endDraw();
Posterize.endDraw();
PosterLevel = 0;
loadFloatArray();
ScreenSaved = false;
}
void setup_posterArray(){
int pix = Canvas.width * Canvas.height;
// canvasPix = new int[CanvasW * CanvasH][3];
array_canvas();
Canvas.beginDraw();
Canvas.loadPixels();
for(int i = 0; i < pix;i++)
Canvas.pixels[i] = 0xFF000000;
Canvas.updatePixels();
Canvas.endDraw();
for(int i= 0;i < 128;i++)
posterArray1[i][0] = 0;
for (int i = 128; i <256; i++)
posterArray1[i][0] = 128;
for(int i= 0;i < 64;i++)
posterArray2[i][0] = 0;
for (int i = 64; i <256; i++)
posterArray2[i][0] = 64;
for(int i= 0;i < 32;i++)
posterArray3[i][0] = 0;
for (int i = 32; i <256; i++)
posterArray3[i][0] = 32;
for(int i= 0;i < 16;i++)
posterArray4[i][0] = 0;
for (int i = 16; i <256; i++)
posterArray4[i][0] = 16;
for(int i= 0;i < 8;i++)
posterArray5[i][0] = 0;
for (int i = 8; i <256; i++)
posterArray5[i][0] = 8;
for(int i= 0;i < 4;i++)
posterArray6[i][0] = 0;
for (int i = 4; i <256; i++)
posterArray6[i][0] = 4;
for(int i= 0;i < 2;i++)
posterArray7[i][0] = 0;
for (int i = 2; i <256; i++)
posterArray7[i][0] = 2;
for(int i= 0;i <1;i++)
posterArray7[i][0] = 0;
for (int i = 1; i <256; i++)
posterArray7[i][0] = 1;
ScreenSaved = false;
}
void run_array(int[][] array){
int pix = Canvas.width*Canvas.height;
Canvas.beginDraw();
Canvas.loadPixels();
Posterize.beginDraw();
Posterize.loadPixels();
for( int i = 0; i < pix;i++){
int pr = Posterize.pixels[i] >> 16 & 255;
int pg = Posterize.pixels[i] >> 8 & 255;
int pb = Posterize.pixels[i] & 255;
int r = array[ pr ][0];
int g = array[ pg ][0];
int b = array[ pb][0];
pr -=r; pg-=g; pb -=b;
Posterize.pixels[i] = color(pr,pg,pb);
r+=Canvas.pixels[i]>>16 & 0xFF;
g+=Canvas.pixels[i]>>8 & 0xFF;
b+=Canvas.pixels[i] & 0xFF;
Canvas.pixels[i] = color(r,g,b);
}
Canvas.updatePixels();
Posterize.updatePixels();
Canvas.endDraw();
Posterize.endDraw();
add_layers(Posterize, Canvas, temp, 0);
Posterize.beginDraw();
Posterize.filter(GRAY);
subtract_layers(temp, Posterize, temp2, 0);
subtract_layers(temp, temp2, Posterize, 0);
Canvas.beginDraw();
Canvas.image(temp2,0,0);
Canvas.endDraw();
loadFloatArray();
ScreenSaved = false;
}
void array_canvas(){
Canvas.updatePixels();
Posterize.beginDraw();
Posterize.image(Canvas,0,0);
Posterize.endDraw();
}
void posterize(PGraphics input, int levels){
int band = 256/levels;
int pix = input.width * input.height;
int[][]mypixels = new int[pix][4];
input.beginDraw();
input.loadPixels();
for(int i= 0;i <pix;i++){
color c= input.pixels[i];
mypixels[i][0] = ((c>>16 & 0xFF)+(c>>8 & 0xFF)+(c & 0xFF) )/3;
mypixels[i][1] = (c>>16 & 0xFF)-mypixels[i][0]+127;
mypixels[i][2] = (c>>8 & 0xFF)-mypixels[i][0]+127;
mypixels[i][3] = (c & 0xFF)-mypixels[i][0]+127;
for(int j = 1; j <=3;j++){
if(mypixels[i][j] <0) mypixels[i][j] = 0;
if(mypixels[i][j] > 255) mypixels[i][j] = 255;
}
}
for(int i= 0; i < pix; i++){
int v = mypixels[i][0]/band * band;
int r = mypixels[i][1] + v - 127;
int g = mypixels[i][2] + v - 127;
int b = mypixels[i][3] + v - 127;
input.pixels[i] = color(r,g,b);
}
input.updatePixels();
input.endDraw();
}
void median2( PGraphics input, int msize){
float[]r= new float[msize];
float[]g= new float[msize];
float[]b= new float[msize];
float tpix, mred, mgreen, mblue;
int w = input.width;
int h = input.height;
int loc = 0; //location of source pixel;
int pixi; // pixel indice ffor pixel arrays
int direction = 1;
int end;
//temp2.beginDraw();
//temp2.endDraw();
//input.beginDraw();
//input.endDraw();
save_undo();
input.beginDraw();
temp.beginDraw();
input.loadPixels();
temp.loadPixels();
for(int y= 0; y< h;y++){
int x;
if(y%2==1) {
x = w -1;
direction = -1;
end = -1;
}
else{
x = 0;
direction = 1;
end = w;
}
for(; x!= end; x+= direction){
pixi = 0;
for(int kx = -msize/2; kx <= msize/2; kx++){
if(x+ kx < 0||x+ kx >= w)
loc= y * w +x;
else loc = y * w + x + kx;
r[pixi] = (input.pixels[loc]>>16)& 0xFF;
g[pixi] = (input.pixels[loc]>>8)& 0xFF;
b[pixi] = input.pixels[loc] & 0xFF;
pixi++;
}
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = r[i];
int j = i-1;
while(j >=0 && r[j]>tpix){
r[j+1]=r[j];
j = j-1;
}
r[j+1]= tpix;
}
mred = r[msize/2]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green array in order by value
tpix = g[i];
int j = i-1;
while(j >=0 && g[j]>tpix){
g[j+1]=g[j];
j = j-1;
}
g[j+1]= tpix;
}
mgreen = g[msize/2]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = b[i];
int j = i-1;
while(j >=0 && b[j]>tpix){
b[j+1]=b[j];
j = j-1;
}
b[j+1]= tpix;
}
mblue = b[msize/2]; // once sorted, the middle index should hold the median value
loc= y * w + x;
temp.pixels[loc] =0xff000000 | ((int)mred << 16) | ((int)mgreen << 8) |(int) mblue;
}
}
temp.updatePixels();
temp.endDraw();
input.updatePixels();
input.endDraw();
input.beginDraw();
temp2.beginDraw();
input.loadPixels();
temp2.loadPixels();
for(int x=0; x< w;x++){
int y;
if(x%2==1){
y = h-1;
direction = -1;
end = -1;
}
else{
y = 0;
direction =1;
end = h;
}
for(; y!=end; y+=direction){
pixi = 0;
for(int ky = -msize/2; ky <= msize/2; ky++){
if(y+ ky < 0||y+ ky >= h)
loc= y * w +x;
else loc = y * w + x + ky * w;
r[pixi] = (input.pixels[loc]>>16)& 0xFF;
g[pixi] = (input.pixels[loc]>>8)& 0xFF;
b[pixi] = input.pixels[loc] & 0xFF;
pixi++;
}
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = r[i];
int j = i-1;
while(j >=0 && r[j]>tpix){
r[j+1]=r[j];
j = j-1;
}
r[j+1]= tpix;
}
mred = r[msize/2]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = g[i];
int j = i-1;
while(j >=0 && g[j]>tpix){
g[j+1]=g[j];
j = j-1;
}
g[j+1]= tpix;
}
mgreen = g[msize/2]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = b[i];
int j = i-1;
while(j >=0 && b[j]>tpix){
b[j+1]=b[j];
j = j-1;
}
b[j+1]= tpix;
}
mblue = b[msize/2]; // once sorted, the middle index should hold the median value
loc= y * w + x;
temp2.pixels[loc] = 0xff000000 | ((int)mred << 16) | ((int)mgreen << 8) | (int)mblue;
}
}
temp2.updatePixels();
temp2.endDraw();
input.updatePixels();
input.endDraw();
input.beginDraw();
input.image(temp,0,0);
input.endDraw();
input.beginDraw();
input.tint(255,127);
input.image(temp2,0,0);
input.endDraw();
input.beginDraw();
input.noTint();
input.endDraw();
}
void median3( PGraphics input, int msize){
float[]r= new float[msize];
float[]g= new float[msize];
float[]b= new float[msize];
float tpix, mred, mgreen, mblue;
int w = input.width;
int h = input.height;
int loc = 0; //location of source pixel;
int pixi; // pixel indice ffor pixel arrays
int direction = 1;
int end;
//temp2.beginDraw();
//temp2.endDraw();
//input.beginDraw();
//input.endDraw();
save_undo();
input.beginDraw();
temp.beginDraw();
input.loadPixels();
temp.loadPixels();
for(int y= 0; y< h;y++){
int x;
if(y%2==1) {
x = w -1;
direction = -1;
end = -1;
}
else{
x = 0;
direction = 1;
end = w;
}
for(; x!= end; x+= direction){
pixi = 0;
for(int kx = -msize/2; kx <= msize/2; kx++){
if(x+ kx < 0||x+ kx >= w)
loc= y * w +x;
else loc = y * w + x + kx;
r[pixi] = (input.pixels[loc]>>16)& 0xFF;
g[pixi] = (input.pixels[loc]>>8)& 0xFF;
b[pixi] = input.pixels[loc] & 0xFF;
pixi++;
}
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = r[i];
int j = i-1;
while(j >=0 && r[j]>tpix){
r[j+1]=r[j];
j = j-1;
}
r[j+1]= tpix;
}
mred = r[msize/2 +1]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green array in order by value
tpix = g[i];
int j = i-1;
while(j >=0 && g[j]>tpix){
g[j+1]=g[j];
j = j-1;
}
g[j+1]= tpix;
}
mgreen = g[msize/2+1]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = b[i];
int j = i-1;
while(j >=0 && b[j]>tpix){
b[j+1]=b[j];
j = j-1;
}
b[j+1]= tpix;
}
mblue = b[msize/2+1]; // once sorted, the middle index should hold the median value
loc= y * w + x;
temp.pixels[loc] =0xff000000 | ((int)mred << 16) | ((int)mgreen << 8) |(int) mblue;
}
}
temp.updatePixels();
temp.endDraw();
input.updatePixels();
input.endDraw();
input.beginDraw();
temp2.beginDraw();
input.loadPixels();
temp2.loadPixels();
for(int x=0; x< w;x++){
int y;
if(x%2==1){
y = h-1;
direction = -1;
end = -1;
}
else{
y = 0;
direction =1;
end = h;
}
for(; y!=end; y+=direction){
pixi = 0;
for(int ky = -msize/2; ky <= msize/2; ky++){
if(y+ ky < 0||y+ ky >= h)
loc= y * w +x;
else loc = y * w + x + ky * w;
r[pixi] = (input.pixels[loc]>>16)& 0xFF;
g[pixi] = (input.pixels[loc]>>8)& 0xFF;
b[pixi] = input.pixels[loc] & 0xFF;
pixi++;
}
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = r[i];
int j = i-1;
while(j >=0 && r[j]>tpix){
r[j+1]=r[j];
j = j-1;
}
r[j+1]= tpix;
}
mred = r[msize/2 -1]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = g[i];
int j = i-1;
while(j >=0 && g[j]>tpix){
g[j+1]=g[j];
j = j-1;
}
g[j+1]= tpix;
}
mgreen = g[msize/2 -1]; // once sorted, the middle index should hold the median value
for(int i = 1; i < msize; i++){ // these for loops sort the red , blue and green
// array in order by value
tpix = b[i];
int j = i-1;
while(j >=0 && b[j]>tpix){
b[j+1]=b[j];
j = j-1;
}
b[j+1]= tpix;
}
mblue = b[msize/2 -1]; // once sorted, the middle index should hold the median value
loc= y * w + x;
temp2.pixels[loc] = 0xff000000 | ((int)mred << 16) | ((int)mgreen << 8) | (int)mblue;
}
}
temp2.updatePixels();
temp2.endDraw();
input.updatePixels();
input.endDraw();
input.beginDraw();
input.image(temp,0,0);
input.endDraw();
input.beginDraw();
input.tint(255,127);
input.image(temp2,0,0);
input.endDraw();
input.beginDraw();
input.noTint();
input.endDraw();
}
int[] rgb_mean_and_variance(int []vals,int x0, int y0, int x1, int y1,PGraphics gimg){
int variance;
int r_mean,g_mean,b_mean;
int min = 255;
int max = 0;
int rsum = 0;
int gsum = 0;
int bsum = 0;
int total = 0;
for(int i = y0; i <=y1; i++){
int y = reflect(gimg.height, i);
for(int j = x0;j <= x1;j++){
int x = reflect(gimg.width, j);
color c = gimg.get(x,y);
int v = ( (c>>16 & 0xFF) + (c>>8 & 0xFF) +(c & 0xFF) )/3;
if (v < min) min = v;
if ( v> max) max = v;
rsum += c >> 16 & 0xFF;
gsum += c >> 8 & 0xFF;
bsum += c & 0xFF;
total++;
}
}
variance = max- min;
r_mean = rsum/total;
g_mean = gsum/total;
b_mean = bsum/total;
int c = 0xFF000000|r_mean <<16|g_mean <<8|b_mean;
vals[0]=c;
vals[1] = variance;
return vals;
}
int rgb_kuwahara(int size,int x,int y, PGraphics gimg){
int best_color = 0;
int best_variance = 255;
int [] vals = new int[2];
vals = rgb_mean_and_variance(vals,x-size,y-size,x,y,gimg);
if(vals[1] < best_variance){
best_variance = vals[1];
best_color = vals[0];
}
vals = rgb_mean_and_variance(vals,x,y-size,x+size,y,gimg);
if(vals[1] < best_variance){
best_variance = vals[1];
best_color = vals[0];
}
vals = rgb_mean_and_variance(vals,x,y,x+size,y+size,gimg);
if(vals[1] < best_variance){
best_variance = vals[1];
best_color = vals[0];
}
vals = rgb_mean_and_variance(vals,x-size,y,x,y+size,gimg);
if(vals[1] < best_variance){
best_variance = vals[1];
best_color = vals[0];
}
return best_color;
}
void kuwahara(PGraphics input, int size){
input.updatePixels();
temp.updatePixels();
input.beginDraw();
temp.beginDraw();
temp.loadPixels();
input.loadPixels();
for(int y = 0;y< input.height;y++){
for( int x = 0; x < input.width; x++){
int c = rgb_kuwahara(size,x,y,input);
temp.pixels[y * input.width + x] = c;
}
}
temp.updatePixels();
input.updatePixels();
input.image(temp,0,0);
temp.endDraw();
input.endDraw();
}
void snn(PGraphics input, int size){ //symetric nearest neighbor
input.beginDraw();
temp.beginDraw();
input.loadPixels();
temp.loadPixels();
for(int y = 0; y < input.height;y++){
for(int x = 0; x < input.width; x++){
int rsum = 0;
int gsum = 0;
int bsum = 0;
int count = 0;
int colorC = input.pixels[y*input.width + x];
int valueC =( (colorC >>16 & 0xFF) + (colorC >>8 & 0xFF) + (colorC & 0xFF) ) /3;
for(int i = -size;i <= size;i++){
for(int j = -size; j <= size;j++){
int i1 = reflect(input.height, y+i);
int j1 = reflect(input.width, x +j);
int colorA = input.pixels[ i1 * input.width +j1];
i1= reflect(input.height, y-i);
j1 = reflect(input.width, x -j);
int colorB = input.pixels[ i1 * input.width +j1];
int valueA =( (colorA >>16 & 0xFF) + (colorA >>8 & 0xFF) + (colorA & 0xFF) ) /3;
int valueB =( (colorB >>16 & 0xFF) + (colorB >>8 & 0xFF) + (colorB & 0xFF) ) /3;
if(Math.abs(valueC - valueA) < Math.abs(valueC - valueB) ){
rsum += colorA >> 16 & 0xFF;
gsum += colorA >> 8 & 0xFF;
bsum += colorA & 0xFF;
}
else{
rsum += colorB >> 16 & 0xFF;
gsum += colorB >> 8 & 0xFF;
bsum += colorB & 0xFF;
}
count++;
}
}
rsum/= count;
gsum /= count;
bsum /= count;
temp.pixels[y * input.width + x] =
0xFF000000 | rsum << 16 | gsum <<8 | bsum;
}
}
temp.updatePixels();
input.updatePixels();
input.image(temp,0,0);
temp.endDraw();
input.endDraw();
}
void snn2(PImage input, int size){
int w = input.width;
int h = input.height;
int n = h;
if(n < w) n = w;
int r[] = new int[n];
int g[] = new int[n];
int b[] = new int[n];
int v[] = new int[n];
int count = size +1;
for(int y = 0; y< h ;y++){
int loc = y * w;
for(int x = 0;x < w; x++){
r[x] = input.pixels[loc] >> 16 & 0xFF;
g[x] = input.pixels[loc] >> 8 & 0xFF;
b[x] = input.pixels[loc] & 0xFF;
v[x] = (r[x] + g[x] + b[x])/3;
loc++;
}
loc = y * w;
for(int x = 0; x < w; x++){
int rsum = 0;
int gsum = 0;
int bsum = 0;
for(int i = -size; i <= 0; i++){
int x1 = reflect(w, x + i);
int x2 = reflect(w, x - i);
if(Math.abs(v[x] - v[x1]) < Math.abs(v[x] -v[x2]) ){
rsum+=r[x1]; gsum+=g[x1];bsum+= b[x1];
}
else{
rsum+=r[x2]; gsum+=g[x2];bsum+= b[x2];
}
}
rsum/= count; gsum /= count; bsum /= count;
input.pixels[loc] = 0xFF000000 | rsum << 16|gsum<<8|bsum;
loc++;
}
}
input.updatePixels();
for(int x = 0; x< w ;x++){
int loc = x;
for(int y = 0;y < h; y++){
r[y] = input.pixels[loc] >> 16 & 0xFF;
g[y] = input.pixels[loc] >> 8 & 0xFF;
b[y] = input.pixels[loc] & 0xFF;
v[y] = (r[y] + g[y] + b[y])/3;
loc += w;
}
loc = x;
for(int y = 0; y < h; y++){
int rsum = 0;
int gsum = 0;
int bsum = 0;
for(int i = -size; i <= 0; i++){
int y1 = reflect(h, y + i);
int y2 = reflect(h, y - i);
if(Math.abs(v[y] - v[y1]) < Math.abs(v[y] -v[y2]) ){
rsum+=r[y1]; gsum+=g[y1];bsum+= b[y1];
}
else{
rsum+=r[y2]; gsum+=g[y2];bsum+= b[y2];
}
}
rsum/= count; gsum /= count; bsum /= count;
input.pixels[loc] = 0xFF000000 | rsum << 16|gsum<<8|bsum;
loc += w;
}
}
input.updatePixels();
}
/////////////////// Frequencies
synchronized void separate_frequencies(){
if(frequencyMode != JOINED)
return;
cursor(WAIT);
noLoop();
// viewWindo.papplet.noLoop();
Canvas.beginDraw();
Canvas.endDraw();
LF.beginDraw();
LF.image(Canvas,0,0);
LF.endDraw();
if (SPLIT_METHOD == MEDIAN2){
median2(LF,3);
if(MedianPasses >=2)
median2(LF,5);
if(MedianPasses >=3)
median2(LF,7);
if(MedianPasses >=4)
median2(LF,9);
if(MedianPasses >=5)
median2(LF,11);
if(MedianPasses >=6)
median2(LF,13);
if(MedianPasses >=7)
median2(LF,15);
if(MedianPasses >=8)
median2(LF,17);
if(MedianPasses >=9)
median2(LF,19);
if(MedianPasses >=10)
median2(LF,21);
if(MedianPasses >=11)
median2(LF,23);
if(MedianPasses >=12)
median2(LF,25);
}
else if (SPLIT_METHOD == MEDIAN3){
median3(LF,3);
if(MedianPasses >=2)
median3(LF,5);
if(MedianPasses >=3)
median3(LF,7);
if(MedianPasses >=4)
median3(LF,9);
if(MedianPasses >=5)
median3(LF,11);
if(MedianPasses >=6)
median3(LF,13);
if(MedianPasses >=7)
median3(LF,15);
if(MedianPasses >=8)
median3(LF,17);
if(MedianPasses >=9)
median3(LF,19);
if(MedianPasses >=10)
median3(LF,21);
if(MedianPasses >=11)
median3(LF,23);
if(MedianPasses >=12)
median3(LF,25);
}
else if(SPLIT_METHOD == BLURRED)
// LF.filter(BLUR,BlurSplit);
blurGraphics(LF,BlurSplit);
else if(SPLIT_METHOD == COLOR){
temp.beginDraw();
temp2.beginDraw();
temp.image(LF,0,0);
temp2.image(LF,0,0);
temp2.filter(GRAY);
temp.endDraw();
temp2.endDraw();
subtract_layers(temp,temp2,LF,127);
subtract_layers(temp,LF,temp2,127);
LF.beginDraw();
LF.tint(255,0);
LF.image(temp2,0,0);
LF.noTint();
LF.endDraw();
}
else if (SPLIT_METHOD == KUWAHARA)
kuwahara(LF, KuwaharaSplit);
else if (SPLIT_METHOD == SNN)
snn2(LF,SNNSplit);
subtract_layers(Canvas,LF,HF,127);
if(GRAYFREQUENCY){
HF.beginDraw();
HF.filter(GRAY);
HF.endDraw();
}
subtract_layers(Canvas,HF,LF,127);
Canvas.beginDraw();
Canvas.image(LF,0,0);
Canvas.endDraw();
frequencyMode = LFREQ;
cursor(ARROW);
curUndo = 0;
curRedo = 0;
undoInstances = 0;
redoInstances = 0;
loadFloatArray();
CurFreq = HF;
ScreenSaved = false;
loop();
//viewWindo.papplet.loop();
}
synchronized void rejoin_frequencies(){
if(frequencyMode == JOINED)
return;
noLoop();
// viewWindo.papplet.noLoop();
Canvas.beginDraw();
Canvas.endDraw();
HF.beginDraw();
HF.endDraw();
LF.beginDraw();
LF.endDraw();
cursor(WAIT);
if(frequencyMode ==LFREQ){
LF.beginDraw();
LF.image(Canvas,0,0);
LF.endDraw();
}
else{
HF.beginDraw();
HF.image(Canvas,0,0);
HF.endDraw();
}
add_layers(LF,HF,Canvas,127);
cursor(ARROW);
frequencyMode = JOINED;
curUndo = 0;
curRedo = 0;
undoInstances = 0;
redoInstances = 0;
loadFloatArray();
ScreenSaved = false;
loop();
// viewWindo.papplet.loop();
}
synchronized void high_frequency(){
if(frequencyMode != LFREQ)
return;
noLoop();
// Canvas.beginDraw();
// Canvas.endDraw();
Canvas.updatePixels();
LF.beginDraw();
LF.image(Canvas,0,0);
LF.endDraw();
HF.updatePixels();
Canvas.beginDraw();
Canvas.image(HF,0,0);
Canvas.endDraw();
loop();
frequencyMode = HFREQ;
curUndo = 0;
curRedo = 0;
loadFloatArray();
CurFreq = LF;
ScreenSaved = false;
}
synchronized void low_frequency(){
if(frequencyMode!= HFREQ)
return;
noLoop();
// Canvas.beginDraw();
// Canvas.endDraw();
Canvas.updatePixels();
HF.beginDraw();
HF.image(Canvas,0,0);
HF.endDraw();
LF.updatePixels();
Canvas.beginDraw();
Canvas.image(LF,0,0);
Canvas.endDraw();
loop();
frequencyMode = LFREQ;
curUndo = 0;
curRedo = 0;
loadFloatArray();
CurFreq = HF;
ScreenSaved = false;
}
//////////////////// Key Handler
void keyPressed(){
switch(key){
case 'b':
flip_90CW();
break;
case '1':
curUndo =0;
curRedo = 0;
undoInstances = 0;
redoInstances = 0;
poster();
break;
case '2':
curUndo =0;
curRedo = 0;
undoInstances = 0;
redoInstances = 0;
end_poster();
break;
case 'e':
case 'E':
ScreenEnhanced = !ScreenEnhanced;
break;
case 'z':
Easing += 0.01;
if(Easing > 1) Easing = 1;
break;
case 'x':
Easing -= 0.01;
if(Easing < 0.01) Easing = 0.01;
break;
case '[':
BrushSize -=1;
if(BrushSize < 1) BrushSize = 1;
setupBrush();
transScale = 1+ (int)((float)realTrans * ((float)BrushSize *scaleFactor));
break;
case ']':
BrushSize +=1;
setupBrush();
transScale = 1+ (int)((float)realTrans * ((float)BrushSize *scaleFactor));
break;
case 'a':
if(transScale <=10)
transScale -=1;
else
transScale -=10;
if(transScale < 1) transScale = 1;
break;
case 's':
if(transScale <=10) transScale +=1;
else transScale += 10;
break;
case '+':
zoom_up();
break;
case '-':
zoom_down();
break;
case ' ':
currentMode = dragMode;
cursor(MOVE);
break;
case 'u':
case 'U':
undo();
// ScreenSaved = false;
break;
case 'r':
case 'R':
redo();
//ScreenSaved = false;
break;
case 'f':
case 'F':
flip_horizontal();
break;
case DELETE:
eBrightness -=10;
break;
case CODED:
switch(keyCode){
case CONTROL:
if(currentMode ==drawingMode ||currentMode ==onColorMode){
cursor(HAND);
currentMode = chooseColorMode;
}
else if( currentMode == cloneMode || currentMode == setClone2Mode){
currentMode = setCloneMode;
cursor(HAND);
}
break;
case 33: //page up
eContrast += 0.1;
break;
case 34: //page down
eContrast -=0.1;
break;
case 155: //insert
eBrightness +=10;
break;
case SHIFT:
currentMode = SizeBrushMode;
break;
case UP:
if(currentMode == drawingMode){
realTrans +=1;
if(realTrans > 500) realTrans= 500;
paintSlider.setValue((float)realTrans);
}
else if(currentMode == blurMode){
blurRealTrans +=1;
if(blurRealTrans >500) blurRealTrans= 500;
blurToolSlider.setValue((float)blurRealTrans);
}
else if(currentMode == onColorMode){
onColorRealTrans +=1;
if(onColorRealTrans >500) onColorRealTrans= 500;
onColorSlider.setValue((float)onColorRealTrans);
}
else if(currentMode == cloneMode ||currentMode == setCloneMode|| currentMode == setClone2Mode){
cloneRealTrans +=1;
if(cloneRealTrans > 500) cloneRealTrans= 500;
cloneSlider.setValue((float)cloneRealTrans);
}
break;
case DOWN:
if(currentMode == drawingMode){
realTrans -=1;
if(realTrans < 1) realTrans= 1;
paintSlider.setValue((float)realTrans);
}
else if(currentMode == blurMode){
blurRealTrans -=1;
if(blurRealTrans < 1) blurRealTrans= 1;
blurToolSlider.setValue((float)blurRealTrans);
}
else if(currentMode == onColorMode){
onColorRealTrans -=1;
if(onColorRealTrans < 1) onColorRealTrans= 1;
onColorSlider.setValue((float)onColorRealTrans);
}
else if(currentMode == cloneMode ||currentMode == setCloneMode|| currentMode == setClone2Mode){
cloneRealTrans -=1;
if(cloneRealTrans < 1) cloneRealTrans= 1;
cloneSlider.setValue((float)cloneRealTrans);
}
break;
case LEFT:
// currentMode = blurMode;
break;
}
}
updateInfo();
}
void keyReleased(){
if (key == ' '){
currentMode = previousMode;
cursor(previousCursor);
ScreenSaved = false;
}
else if (keyCode == CONTROL){
if(currentMode == chooseColorMode){
currentMode = previousMode;
cursor(ARROW);
}
else if(currentMode == setCloneMode){
if(C1set = false){
currentMode = cloneMode;
cursor(CROSS);
}
else{
currentMode = setClone2Mode;
cursor(CROSS);
}
}
}
else if(keyCode == SHIFT|| keyCode == LEFT)
currentMode = previousMode;
}
/////////////////////// load save
void load_image(){
String fname = null;
fname = G4P.selectInput("Input Dialog", "png,gif,jpg,jpeg", "Image files");
if(fname == null)
return;
noLoop();
img = loadImage(fname);
Canvas = createGraphics(img.width,img.height);
Canvas.beginDraw();
Canvas.image(img,0,0);
Canvas.endDraw();
setupGraphics();
floatCanvas = new float[Canvas.width * Canvas.height][3];
loadFloatArray();
int h = img.height; //process the window size
if(h > (int)((float) displayHeight * 0.9))
h = (int)((float)displayHeight * 0.9);
int w = img.width;
if(w > (int)((float)displayWidth * 0.9))
w = (int)((float)displayWidth * 0.9);
frame.setSize(w,h);
zoom = 1.0;
DraggedOffsetX = DraggedOffsetY=FrameOffsetX=FrameOffsetY= 0;
ScreenSaved = false;
loop();
}
void save_layer(){
String name= null;
name = G4P.selectOutput("Output Dialog");
if(name == null)
return;
Canvas.beginDraw();
Canvas.save(name);
Canvas.endDraw();
}
///////////////////modes
void setupDrawModes(){
chooseColorMode = new Mode() {
public void draw() {
if(mousePressed){
paintColor = Canvas.get((int)((mouseX-DraggedOffsetX-FrameOffsetX)/zoom),
(int)(( mouseY-DraggedOffsetY-FrameOffsetY)/zoom) );
brushR = paintColor>>16 & 0xFF;
brushG = paintColor>> 8 & 0xFF;
brushB = paintColor & 0xFF;
}
}
};
SizeBrushMode = new Mode() {
public void draw() {
if(mousePressed){
BrushSize += (mouseY - pmouseY);
if(BrushSize < 1) BrushSize = 1;
setupBrush();
transScale = 1+ (int)((float)realTrans * ((float)BrushSize *scaleFactor));
}
}
};
drawingMode = new Mode() {
public float x, y;
public void draw() {
float offsetX =DraggedOffsetX + FrameOffsetX;
float offsetY =DraggedOffsetY + FrameOffsetY;
if (mousePressed){
float mx = (mouseX - offsetX)/zoom;
float my = (mouseY - offsetY)/zoom;
leftoverD = myLine(x, y, x += (mx - x) * Easing, y += (my - y) * Easing,leftoverD);
}
else {
x = (mouseX -offsetX)/zoom;
y = (mouseY -offsetY)/zoom;
leftoverD = 0;
}
}
};
onColorMode = new Mode() {
public float x, y;
public void draw() {
float offsetX =DraggedOffsetX + FrameOffsetX;
float offsetY =DraggedOffsetY + FrameOffsetY;
if (mousePressed){
float mx = (mouseX - offsetX)/zoom;
float my = (mouseY - offsetY)/zoom;
leftoverD = myDrawOnColor(x, y, x += (mx - x) * Easing, y += (my - y) * Easing,leftoverD);
}
else {
x = (mouseX -offsetX)/zoom;
y = (mouseY -offsetY)/zoom;
leftoverD = 0;
}
}
};
blurMode = new Mode() {
public float x, y;
public void draw() {
float offsetX =DraggedOffsetX + FrameOffsetX;
float offsetY =DraggedOffsetY + FrameOffsetY;
if (mousePressed){
float mx = (mouseX - offsetX)/zoom;
float my = (mouseY - offsetY)/zoom;
leftoverD = myBlur(x, y, x += (mx - x) * Easing, y += (my - y) * Easing,leftoverD);
}
else {
x = (mouseX -offsetX)/zoom;
y = (mouseY -offsetY)/zoom;
leftoverD = 0;
}
}
};
dragMode = new Mode(){
public void draw(){
if(mousePressed){
DraggedOffsetX += mouseX-PreviousX;
DraggedOffsetY += mouseY-PreviousY;
PreviousX = mouseX;
PreviousY = mouseY;
}
else{
PreviousX = mouseX;
PreviousY = mouseY;
}
}
};
cloneMode = new Mode() {
public float x, y;
public void draw() {
float offsetX =DraggedOffsetX + FrameOffsetX;
float offsetY =DraggedOffsetY + FrameOffsetY;
if (mousePressed){
float mx = (mouseX - offsetX)/zoom;
float my = (mouseY - offsetY)/zoom;
if(C2set){
float cx = CloneX2;
float cy = CloneY2;
leftoverD = myClone(cx,cy, cx += (mx - cx) * Easing, cy += (my - cy) * Easing,
CloneOffsetX,CloneOffsetY,leftoverD);
C2set = C1set = false;
x = (mouseX -offsetX)/zoom;
y = (mouseY -offsetY)/zoom;
}
else
leftoverD = myClone(x, y, x += (mx - x) * Easing, y += (my - y) * Easing,
CloneOffsetX,CloneOffsetY,leftoverD);
}
else {
x = (mouseX -offsetX)/zoom;
y = (mouseY -offsetY)/zoom;
leftoverD = 0;
}
}
};
setCloneMode = new Mode() {
public void draw() {
if(mousePressed){
CloneX1 = (int)((mouseX-DraggedOffsetX-FrameOffsetX)/zoom);
CloneY1 = (int)(( mouseY-DraggedOffsetY-FrameOffsetY)/zoom);
C1set = true;
}
}
};
setClone2Mode = new Mode() {
public void draw() {
if(mousePressed){
CloneX2 = (int)((mouseX-DraggedOffsetX-FrameOffsetX)/zoom);
CloneY2 = (int)(( mouseY-DraggedOffsetY-FrameOffsetY)/zoom);
CloneOffsetX =CloneX1 - CloneX2;
CloneOffsetY = CloneY1-CloneY2;
C2set = true;
currentMode = cloneMode;
}
}
};
}
float[][]SharpMatrix = { {-1,-1,-1},
{-1,9,-1},
{-1,-1,-1} };
void setSharpMatrix(int filter){
SharpMatrix[0][0] = SharpMatrix[0][1] =SharpMatrix[0][2] =
SharpMatrix[1][0] = SharpMatrix[1][2] =
SharpMatrix[2][0] = SharpMatrix[2][1] =SharpMatrix[2][2] = scr_sharp[filter] * -1.0;
SharpMatrix[1][1] = scr_sharp[filter] * 8 + 1;
}
void setupEffects(){
normalE = new Effect(){
// public String name;
public void saveScreen(int filter){
}
public void updateScreen(int filter){
}
};
normalE.name = "Normal";
blurE = new Effect(){
public void saveScreen(int filter){
blurImage2(Scr,scr_blur[filter]);
}
public void updateScreen(int filter){
blurImage2(Scr2,scr_blur[filter]);
}
};
blurE.name = "Blur";
snnE = new Effect(){
public void saveScreen(int filter){
snn2(Scr,scr_snnAmount[filter]);
}
public void updateScreen(int filter){
snn2(Scr2,scr_snnAmount[filter]);
}
};
snnE.name = "SNN";
posterizeE = new Effect(){
public void saveScreen(int filter){
Scr.filter(POSTERIZE,scr_posterize[filter]);
}
public void updateScreen(int filter){
Scr2.filter(POSTERIZE,scr_posterize[filter]);
}
};
posterizeE.name = "Posterize";
erodeE = new Effect(){
public void saveScreen(int filter){
switch(scr_erode[filter]){
case 5:
Scr.filter(ERODE);
case 4:
Scr.filter(ERODE);
case 3:
Scr.filter(ERODE);
case 2:
Scr.filter(ERODE);
case 1:
Scr.filter(ERODE);
break;
}
}
public void updateScreen(int filter){
switch(scr_erode[filter]){
case 5:
Scr2.filter(ERODE);
case 4:
Scr2.filter(ERODE);
case 3:
Scr2.filter(ERODE);
case 2:
Scr2.filter(ERODE);
case 1:
Scr2.filter(ERODE);
break;
}
}
};
erodeE.name = "Erode";
dilateE = new Effect(){
public void saveScreen(int filter){
switch(scr_dilate[filter]){
case 5:
Scr.filter(DILATE);
case 4:
Scr.filter(DILATE);
case 3:
Scr.filter(DILATE);
case 2:
Scr.filter(DILATE);
case 1:
Scr.filter(DILATE);
break;
}
}
public void updateScreen(int filter){
switch(scr_dilate[filter]){
case 5:
Scr2.filter(DILATE);
case 4:
Scr2.filter(DILATE);
case 3:
Scr2.filter(DILATE);
case 2:
Scr2.filter(DILATE);
case 1:
Scr2.filter(DILATE);
break;
}
}
};
dilateE.name = "Dilate";
closeHolesE = new Effect(){
public void saveScreen(int filter){
switch(scr_dilate[filter]){ case 5: Scr.filter(DILATE); case 4: Scr.filter(DILATE);
case 3: Scr.filter(DILATE); case 2: Scr.filter(DILATE); case 1: Scr.filter(DILATE);
break;
}
switch(scr_erode[filter]){ case 5: Scr.filter(ERODE); case 4: Scr.filter(ERODE);
case 3:Scr.filter(ERODE); case 2: Scr.filter(ERODE); case 1:Scr.filter(ERODE);
break;
}
}
public void updateScreen(int filter){
switch(scr_dilate[filter]){case 5: Scr2.filter(DILATE);case 4: Scr2.filter(DILATE);
case 3:Scr2.filter(DILATE);case 2: Scr2.filter(DILATE);case 1: Scr2.filter(DILATE);
break;
}
switch(scr_erode[filter]){case 5: Scr2.filter(ERODE);case 4: Scr2.filter(ERODE);
case 3:Scr2.filter(ERODE);case 2: Scr2.filter(ERODE);case 1: Scr2.filter(ERODE);
break;
}
}
};
closeHolesE.name = "CloseHoles";
unSharpE = new Effect(){
public void saveScreen(int filter){
diffScr = createImage(Scr.width,Scr.height,RGB);
imagetoImage(Scr,diffScr);
// diffScr.copy(Canvas,PR1,PR2,PR3-PR1+1,PR4-PR2+1,0,0,Scr.width,Scr.height);
blurImage2(Scr, scr_usharp[filter]);
unSharp(Scr,diffScr);
// image(Scr,0,0);
}
public void updateScreen(int filter){
diffScr2 = createImage(Scr2.width,Scr2.height,RGB);
imagetoImage(Scr2, diffScr2);
// canvasToImage(PR1,PR2,PR3-PR1+1,PR4-PR2+1,diffScr2);
// diffScr2.resize(Scr2.width,Scr2.height);
// diffScr2.copy(Canvas,PR1,PR2,PR3-PR1,PR4-PR2,0,0,Scr2.width,Scr2.height);
blurImage2(Scr2,scr_usharp[filter]);
unSharp(Scr2,diffScr2);
}
};
unSharpE.name = "UnSharp";
addFreqE = new Effect(){
public void saveScreen(int filter){
FreqScr = createImage(Scr.width,Scr.height,RGB);
FreqScr.copy(CurFreq,PR1,PR2,PR3-PR1+1,PR4-PR2+1,0,0,Scr.width,Scr.height);
if (frequencyMode == HFREQ)
addFreq(Scr,FreqScr,Scr,filter);
else
addFreq(FreqScr,Scr,Scr,filter);
}
public void updateScreen(int filter){
FreqScr.resize(PR3 - PR1 + 1,PR4 - PR2 +1);
FreqScr.copy(CurFreq,PR1,PR2,PR3-PR1,PR4-PR2,0,0,Scr2.width,Scr2.height);
if (frequencyMode == HFREQ)
addFreq(Scr2,FreqScr,Scr2,filter);
else
addFreq(FreqScr,Scr2,Scr2,filter);
}
};
addFreqE.name = "AddFreq";
structureE = new Effect(){
public void saveScreen(int filter){
diffScr = createImage(Scr.width,Scr.height,RGB);
imagetoImage(Scr, diffScr);
blurImage2(Scr, scr_structureRadius[filter]);
structure(Scr,diffScr,scr_structureContrast[filter]);
}
public void updateScreen(int filter){
diffScr2 = createImage(Scr2.width,Scr2.height,RGB);
imagetoImage(Scr2, diffScr2);
blurImage2(Scr2,scr_structureRadius[filter]);
structure(Scr2,diffScr2,scr_structureContrast[filter]);
}
};
structureE.name = "Structure";
highPassE = new Effect(){
public void saveScreen(int filter){
diffScr = createImage(Scr.width,Scr.height,RGB);
imagetoImage(Scr, diffScr);
blurImage2(Scr, scr_hiPass[filter]);
hiPass(Scr,diffScr);
}
public void updateScreen(int filter){
diffScr2 = createImage(Scr2.width,Scr2.height,RGB);
imagetoImage(Scr2, diffScr2);
blurImage2(Scr2,scr_hiPass[filter]);
hiPass(Scr2,diffScr2);
}
};
highPassE.name ="HighPass";
colorHighPassE = new Effect(){
public void saveScreen(int filter){
diffScr = createImage(Scr.width,Scr.height,RGB);
imagetoImage(Scr, diffScr);
blurImage2(Scr, scr_hiPass[filter]);
hiPassColor(Scr,diffScr);
}
public void updateScreen(int filter){
diffScr2 = createImage(Scr2.width,Scr2.height,RGB);
imagetoImage(Scr2, diffScr2);
blurImage2(Scr2,scr_hiPass[filter]);
hiPassColor(Scr2,diffScr2);
}
};
colorHighPassE.name = "ColorHighPass";
sharpenE = new Effect(){
public void saveScreen(int filter){
setSharpMatrix(filter);
convolution2(Scr);
}
public void updateScreen(int filter){
setSharpMatrix(filter);
convolution2(Scr2);
}
};
sharpenE.name = "Sharpen";
contrastE = new Effect(){
public void saveScreen(int filter){
float c;
if(scr_contrast[filter] < 0){
c = 100 + scr_contrast[filter];
c /= 100.0;
}
else{
c = (float)scr_contrast[filter] /85;
c /= 1.6 * (100 - scr_contrast[filter]);
c = 1 + c * 85;
}
float b = scr_brightness[filter];
contrastBrightness(Scr,c,b);
}
public void updateScreen(int filter){
float c;
if(scr_contrast[filter] < 0){
c = 100 + scr_contrast[filter];
c /= 100.0;
}
else{
c = (float)scr_contrast[filter] /85;
c /= 1.6 * (100 - scr_contrast[filter]);
c = 1 + c * 85;
}
float b = scr_brightness[filter];
contrastBrightness(Scr2,c,b);
}
};
contrastE.name = "Contrast";
}
color convolution(int x, int y, float[][] matrix, int matrixsize, PImage img)
{
float rtotal = 0.0;
float gtotal = 0.0;
float btotal = 0.0;
int offset = matrixsize / 2;
for (int i = 0; i < matrixsize; i++){
for (int j= 0; j < matrixsize; j++){
// What pixel are we testing
int xloc = x+i-offset;
int yloc = y+j-offset;
int loc = xloc + img.width*yloc;
// Make sure we haven't walked off our image, we could do better here
loc = constrain(loc,0,img.pixels.length-1);
// Calculate the convolution
rtotal += (red(img.pixels[loc]) * matrix[i][j]);
gtotal += (green(img.pixels[loc]) * matrix[i][j]);
btotal += (blue(img.pixels[loc]) * matrix[i][j]);
}
}
// Make sure RGB is within range
rtotal = constrain(rtotal, 0, 255);
gtotal = constrain(gtotal, 0, 255);
btotal = constrain(btotal, 0, 255);
// Return the resulting color
return color(rtotal, gtotal, btotal);
}
void convolution2( PImage img)
{
int matrixsize = 3;
int mhalf = matrixsize/2;
int pix = img.width * img.height;
int r[] = new int[pix];
int g[] = new int[pix];
int b[] = new int[pix];
for(int i =0; i < pix; i++){
r[i] = img.pixels[i]>>16 & 0xFF;
g[i] = img.pixels[i]>> 8 & 0xFF;
b[i] = img.pixels[i] & 0xFF;
}
int p = 0;
for(int y =0; y < img.height; y++){
for(int x = 0; x < img.width;x++){
float rtotal = 0.0;
float gtotal = 0.0;
float btotal = 0.0;
for (int i = -mhalf; i <= mhalf; i++){
int y1 = reflect(img.height,y+i);
int loc = y1 * img.width;
for (int j= -mhalf; j <= mhalf; j++){
int x1 = reflect(img.width, x + j);
rtotal+= r[loc + x1] * SharpMatrix[i+mhalf][j+mhalf];
gtotal+= g[loc + x1] * SharpMatrix[i+mhalf][j+mhalf];
btotal += b[loc + x1] * SharpMatrix[i+mhalf][j+mhalf];
}
}
if(rtotal > 255) rtotal = 255;
else if(rtotal<0) rtotal = 0;
if(gtotal > 255) gtotal = 255;
else if(gtotal<0) gtotal = 0;
if(btotal > 255) btotal = 255;
else if(btotal<0) btotal = 0;
img.pixels[p] = 0xFF000000|(int)rtotal<<16|(int)gtotal<<8|(int)btotal;
p++;
}
}
img.updatePixels();
}
void unSharp(PImage blur, PImage norm){
int pix = blur.width * blur.height;
for(int i = 0; i < pix;i++){
int r = (norm.pixels[i]>>16 &0xFF) -(blur.pixels[i] >> 16 & 0xFF) + (norm.pixels[i] >> 16 & 0xFF);
int g = (norm.pixels[i]>>8 &0xFF) -(blur.pixels[i] >> 8 & 0xFF) + (norm.pixels[i] >> 8 & 0xFF);
int b = (norm.pixels[i] &0xFF) -(blur.pixels[i] & 0xFF) + (norm.pixels[i] & 0xFF);
if( r < 0) r = 0; if (r > 255)r = 255;
if( g < 0) g = 0; if (g > 255)g = 255;
if( b < 0) b = 0; if (b > 255)b = 255;
blur.pixels[i]=0xFF000000 | r << 16 | g << 8|b;
}
blur.updatePixels();
}
void hiPass(PImage blur, PImage norm){
int pix = blur.width * blur.height;
for(int i = 0; i < pix;i++){
int r = (norm.pixels[i]>>16 &0xFF) -(blur.pixels[i] >> 16 & 0xFF) + 127;
int g = (norm.pixels[i]>>8 &0xFF) -(blur.pixels[i] >> 8 & 0xFF) + 127;
int b = (norm.pixels[i] &0xFF) -(blur.pixels[i] & 0xFF) + 127;
if( r < 0) r = 0; if (r > 255)r = 255;
if( g < 0) g = 0; if (g > 255)g = 255;
if( b < 0) b = 0; if (b > 255)b = 255;
blur.pixels[i]=0xFF000000 | r << 16 | g << 8|b;
}
blur.updatePixels();
}
void hiPassColor(PImage blur, PImage norm){
int pix = blur.width * blur.height;
for(int i = 0; i < pix;i++){
int bv = ((blur.pixels[i]>>16 &0xFF)+(blur.pixels[i]>>8 & 0xFF)+ (blur.pixels[i] & 0xFF))/3;
int r = (norm.pixels[i]>>16 &0xFF) - bv + 127;
int g = (norm.pixels[i]>>8 &0xFF) - bv + 127;
int b = (norm.pixels[i] &0xFF) - bv + 127;
if( r < 0) r = 0; if (r > 255)r = 255;
if( g < 0) g = 0; if (g > 255)g = 255;
if( b < 0) b = 0; if (b > 255)b = 255;
blur.pixels[i]=0xFF000000 | r << 16 | g << 8|b;
}
blur.updatePixels();
}
void structure(PImage blur, PImage norm,float scontrast){
int pix = blur.width * blur.height;
for(int i = 0; i < pix;i++){
int r = (norm.pixels[i]>>16 &0xFF) -(blur.pixels[i] >> 16 & 0xFF) + 127;
r = (int)(((r - 127.5) * scontrast +127.5 ) +(blur.pixels[i]>>16 & 0xFF) - 127);
int g = (norm.pixels[i]>>8 &0xFF) -(blur.pixels[i] >> 8 & 0xFF) + 127;
g = (int)(((g - 127.5) * scontrast +127.5 ) +(blur.pixels[i]>>8 & 0xFF) - 127);
int b = (norm.pixels[i] &0xFF) -(blur.pixels[i] & 0xFF) + 127;
b = (int)(((b - 127.5) * scontrast +127.5 ) +(blur.pixels[i] & 0xFF) - 127);
if( r < 0) r = 0; if (r > 255)r = 255;
if( g < 0) g = 0; if (g > 255)g = 255;
if( b < 0) b = 0; if (b > 255)b = 255;
blur.pixels[i]=0xFF000000 | r << 16 | g << 8|b;
}
blur.updatePixels();
}
void contrastBrightness(PImage img, float contrast, float brightness){
int pix = img.width * img.height;
for(int i = 0; i < pix;i++){
int r =(int)(((img.pixels[i]>>16 &0xFF) - 127.5) *contrast + 127.5 + brightness);
int g = (int)(((img.pixels[i]>> 8 &0xFF) - 127.5) *contrast + 127.5 + brightness);
int b = (int)(((img.pixels[i] &0xFF) - 127.5) *contrast + 127.5 + brightness);
if( r < 0) r = 0; if (r > 255)r = 255;
if( g < 0) g = 0; if (g > 255)g = 255;
if( b < 0) b = 0; if (b > 255)b = 255;
img.pixels[i]=0xFF000000 | r << 16 | g << 8|b;
}
img.updatePixels();
}
////////////////////////////////////// undo
synchronized void undo(){
if(undoInstances == 0)
return;
if(curUndo == 0)
curUndo = numUndo;
noLoop();
Canvas.beginDraw();
Canvas.endDraw();
temp.beginDraw();
temp.image(Canvas,0,0);
temp.endDraw();
Canvas.beginDraw();
Canvas.image(uLayers[curUndo-1],0,0);
Canvas.endDraw();
uLayers[curUndo-1].beginDraw();
uLayers[curUndo-1].image(temp,0,0);
uLayers[curUndo-1].endDraw();
curUndo--;
undoInstances--;
redoInstances++;
if(redoInstances > numUndo)
redoInstances = numUndo;
curRedo++;
if(curRedo > numUndo)
curRedo = 0;
loadFloatArray();
ScreenSaved = false;
loop();
}
synchronized void redo(){
if(redoInstances == 0)
return;
noLoop();
Canvas.beginDraw();
Canvas.endDraw();
temp.beginDraw();
temp.image(Canvas,0,0);
temp.endDraw();
Canvas.beginDraw();
Canvas.image(uLayers[curUndo],0,0);
Canvas.endDraw();
uLayers[curUndo].beginDraw();
uLayers[curUndo].image(temp,0,0);
uLayers[curUndo].endDraw();
redoInstances--;
undoInstances++;
curUndo++;
if(curUndo == numUndo) curUndo = 0;
// ScreenSaved = false;
loadFloatArray();
ScreenSaved = false;
loop();
}
synchronized void save_undo(){
Canvas.beginDraw();
Canvas.endDraw();
uLayers[curUndo].beginDraw();
uLayers[curUndo].image(Canvas,0,0);
uLayers[curUndo].endDraw();
curUndo++;
undoInstances++;
if(undoInstances > numUndo)
undoInstances = numUndo;
if(curUndo == numUndo){
curUndo = 0;
}
}
////////////// utilities
void handleOption(int adjust){
curAdjustment = adjust;
disableAdjustments();
enableAdjustments(filters[adjust]);
updateASliders(curAdjustment);
ScreenSaved = false;
frame.toFront();
if(adjust == 0) chooseF1.setSelected(true);
else if(adjust == 1) chooseF2.setSelected(true);
else if(adjust == 2) chooseF3.setSelected(true);
else if(adjust == 3) chooseF4.setSelected(true);
else if(adjust == 4) chooseF5.setSelected(true);
}
void enableAdjustments(Effect e){
scrSettings.setTitle(e.name);
if( e==blurE){
blurSlider.setLocalColorScheme(6);
blurSlider.setEnabled(true);
}
else if(e == sharpenE){
sharpSlider.setLocalColorScheme(6);
sharpSlider.setEnabled(true);
}
else if (e == erodeE){
erodeSlider.setLocalColorScheme(6);
erodeSlider.setEnabled(true);
}
else if (e == dilateE){
dilateSlider.setLocalColorScheme(6);
dilateSlider.setEnabled(true);
}
else if (e == posterizeE){
posterizeSlider.setLocalColorScheme(6);
posterizeSlider.setEnabled(true);
}
else if (e == unSharpE){
uSharpSlider.setLocalColorScheme(6);
uSharpSlider.setEnabled(true);
}
else if (e == addFreqE){
HContrastSlider.setLocalColorScheme(6);
HContrastSlider.setEnabled(true);
HBrightnessSlider.setLocalColorScheme(6);
HBrightnessSlider.setEnabled(true);
LContrastSlider.setLocalColorScheme(6);
LContrastSlider.setEnabled(true);
LBrightnessSlider.setLocalColorScheme(6);
LBrightnessSlider.setEnabled(true);
}
else if (e == highPassE || e ==colorHighPassE){
hiPassSlider.setLocalColorScheme(6);
hiPassSlider.setEnabled(true);
}
else if( e == snnE){
snnAmountslider.setLocalColorScheme(6);
snnAmountslider.setEnabled(true);
}
else if( e == structureE){
structureRadiusSlider.setLocalColorScheme(6);
structureRadiusSlider.setEnabled(true);
structureContrastSlider.setLocalColorScheme(6);
structureContrastSlider.setEnabled(true);
}
else if ( e == contrastE){
contrastSlider.setLocalColorScheme(6);
contrastSlider.setEnabled(true);
brightnessSlider.setLocalColorScheme(6);
brightnessSlider.setEnabled(true);
}
else if( e == closeHolesE){
erodeSlider.setLocalColorScheme(6);
erodeSlider.setEnabled(true);
dilateSlider.setLocalColorScheme(6);
dilateSlider.setEnabled(true);
}
}
void disableAdjustments(){
blurSlider.setLocalColorScheme(8);
blurSlider.setEnabled(false);
sharpSlider.setLocalColorScheme(8);
sharpSlider.setEnabled(false);
erodeSlider.setLocalColorScheme(8);
erodeSlider.setEnabled(false);
dilateSlider.setLocalColorScheme(8);
dilateSlider.setEnabled(false);
posterizeSlider.setLocalColorScheme(8);
posterizeSlider.setEnabled(false);
uSharpSlider.setLocalColorScheme(8);
uSharpSlider.setEnabled(false);
HContrastSlider.setLocalColorScheme(8);
HContrastSlider.setEnabled(false);
HBrightnessSlider.setLocalColorScheme(8);
HBrightnessSlider.setEnabled(false);
LContrastSlider.setLocalColorScheme(8);
LContrastSlider.setEnabled(false);
LBrightnessSlider.setLocalColorScheme(8);
LBrightnessSlider.setEnabled(false);
hiPassSlider.setLocalColorScheme(8);
hiPassSlider.setEnabled(false);
snnAmountslider.setLocalColorScheme(8);
snnAmountslider.setEnabled(false);
structureRadiusSlider.setLocalColorScheme(8);
structureRadiusSlider.setEnabled(false);
structureContrastSlider.setLocalColorScheme(8);
structureContrastSlider.setEnabled(false);
contrastSlider.setLocalColorScheme(8);
contrastSlider.setEnabled(false);
brightnessSlider.setLocalColorScheme(8);
brightnessSlider.setEnabled(false);
}
void saveFilterSettings(){
String name= null;
name = G4P.selectOutput("Output Dialog");
if(name == null)
return;
String f= "";
for(int i = 0; i < 5;i++){
f = f +filters[i].name + ":";
if(filters[i].name == "Normal")
;
else if(filters[i].name == "Blur")
f = f + scr_blur[i];
else if (filters[i].name == "SNN")
f = f + scr_snnAmount[i];
else if ( filters[i].name =="Posterize")
f = f + scr_posterize[i];
else if ( filters[i].name =="Erode")
f = f + scr_erode[i];
else if ( filters[i].name =="Dilate")
f = f + scr_dilate[i];
else if ( filters[i].name =="CloseHoles")
f = f + scr_dilate[i] + ":" + scr_erode[i];
else if ( filters[i].name =="UnSharp")
f = f + scr_usharp[i];
else if ( filters[i].name =="AddFreq")
f = f + Hcontrast[i] + ":" + Hbrightness[i] + ":" +
Lcontrast[i] + ":" + Lbrightness[i];
else if ( filters[i].name =="Structure")
f = f + scr_structureContrast[i] + ":" + scr_structureRadius[i];
else if ( filters[i].name =="HighPass")
f = f + scr_hiPass[i];
else if ( filters[i].name =="ColorHighPass")
f = f + scr_hiPass[i];
else if ( filters[i].name =="Sharpen")
f = f + scr_sharp[i];
else if ( filters[i].name =="Contrast")
f = f + scr_contrast[i] + ":" + scr_brightness[i];
if(i < 4) f = f + "#";
}
String filterPar[] = split(f,"#");
saveStrings(name,filterPar);
}
void loadFilterSettings(){
String name = null;
name = G4P.selectInput("Load filter", "txt", ".txt files");
if(name == null)
return;
String []fparms =loadStrings(name);
for(int i = 0; i < 5;i++){
String[]f= split(fparms[i],":");
if(f[0].equals("Normal")){
GOption []fnormal = {e1Normal,e2Normal,e3Normal,e4Normal,e5Normal};
fnormal[i].setSelected(true);
filters[i] = normalE;
}
else if(f[0].equals("Blur")){
GOption []fBlur = {e1Blur,e2Blur,e3Blur,e4Blur,e5Blur};
fBlur[i].setSelected(true);
filters[i] = blurE;
scr_blur[i] = parseInt(f[1]);
}
else if(f[0].equals("SNN")){
GOption []fsnn = {e1SNN,e2SNN,e3SNN,e4SNN,e5SNN};
fsnn[i].setSelected(true);
filters[i] = snnE;
scr_snnAmount[i] = parseInt(f[1]);
}
else if(f[0].equals("Posterize")){
GOption []fpost = {e1Posterize,e2Posterize,e3Posterize,e4Posterize,e5Posterize};
fpost[i].setSelected(true);
filters[i] = posterizeE;
scr_posterize[i] = parseInt(f[1]);
}
else if(f[0].equals("Erode")){
GOption []ferode ={e1Erode,e2Erode,e3Erode,e4Erode,e5Erode};
ferode[i].setSelected(true);
filters[i] = erodeE;
scr_erode[i] = parseInt(f[1]);
}
else if(f[0].equals("Dilate")){
GOption []fdilate = {e1Dilate,e2Dilate,e3Dilate,e4Dilate,e5Dilate};
fdilate[i].setSelected(true);
filters[i] = dilateE;
scr_dilate[i] = parseInt(f[1]);
}
else if(f[0].equals("CloseHoles")){
GOption []fholes = {e1CloseHoles,e2CloseHoles,e3CloseHoles,e4CloseHoles,e5CloseHoles};
fholes[i].setSelected(true);
filters[i] = closeHolesE;
scr_dilate[i] = parseInt(f[1]);
scr_erode[i] = parseInt(f[2]);
}
else if(f[0].equals("UnSharp")){
GOption []fusharp = {e1UnSharp,e2UnSharp,e3UnSharp,e4UnSharp,e5UnSharp};
fusharp[i].setSelected(true);
filters[i] = unSharpE;
scr_usharp[i] = parseInt(f[1]);
}
else if(f[0].equals("AddFreq")){
if(frequencyMode == JOINED){
GOption []fnormal = {e1Normal,e2Normal,e3Normal,e4Normal,e5Normal};
fnormal[i].setSelected(true);
filters[i] = normalE;
}
else{
GOption [] fadd = {e1AddFreq,e2AddFreq,e3AddFreq,e4AddFreq,e5AddFreq};
fadd[i].setSelected(true);
filters[i] = addFreqE;
Hcontrast[i] = parseFloat(f[1]);
Hbrightness[i] = parseFloat(f[2]);
Lcontrast[i] = parseFloat(f[3]);
Lbrightness[i] = parseFloat(f[4]);
}
}
else if(f[0].equals("Structure")){
GOption [] fstruct = {e1Structure,e2Structure,e3Structure,e4Structure,e5Structure};
fstruct[i].setSelected(true);
filters[i] = structureE;
scr_structureContrast[i] = parseFloat(f[1]);
scr_structureRadius[i] = parseInt(f[2]);
}
else if(f[0].equals("HighPass")){
GOption [] fhp = {e1HighPass,e2HighPass,e3HighPass,e4HighPass,e5HighPass};
fhp[i].setSelected(true);
filters[i] = highPassE;
scr_hiPass[i] = parseInt(f[1]);
}
else if(f[0].equals("ColorHighPass")){
GOption [] fchp = {e1HighPassColor,e2HighPassColor,e3HighPassColor,e4HighPassColor,e5HighPassColor};
fchp[i].setSelected(true);
filters[i] = colorHighPassE;
scr_hiPass[i] = parseInt(f[1]);
}
else if(f[0].equals("Sharpen")){
GOption [] fsharp = {e1Sharpen,e2Sharpen,e3Sharpen,e4Sharpen,e5Sharpen};
fsharp[i].setSelected(true);
filters[i] = sharpenE;
scr_sharp[i] = parseFloat(f[1]);
}
else if(f[0].equals("Contrast")){
GOption [] fcon = {e1Contrast,e2Contrast,e3Contrast,e4Contrast,e5Contrast};
fcon[i].setSelected(true);
filters[i] = contrastE;
scr_contrast[i] = parseInt(f[1]);
scr_brightness[i] = parseInt(f[2]);
}
}
curAdjustment = 0;
chooseF1.setSelected(true);
disableAdjustments();
enableAdjustments(filters[0]);
ScreenSaved = false;
}
void updateASliders(int f){
blurSlider.setValue(scr_blur[f]);
sharpSlider.setValue(scr_sharp[f]);
erodeSlider.setValue(scr_erode[f]);
dilateSlider.setValue(scr_dilate[f]);
posterizeSlider.setValue(scr_posterize[f]);
uSharpSlider.setValue(scr_usharp[f]);
HContrastSlider.setValue(Hcontrast[f]);
HBrightnessSlider.setValue(Hbrightness[f]);
LContrastSlider.setValue(Lcontrast[f]);
LBrightnessSlider.setValue(Lbrightness[f]);
hiPassSlider.setValue(scr_hiPass[f]);
snnAmountslider.setValue(scr_snnAmount[f]);
structureRadiusSlider.setValue(scr_structureRadius[f]);
structureContrastSlider.setValue(scr_structureContrast[f]);
contrastSlider.setValue(scr_contrast[f]);
brightnessSlider.setValue(scr_brightness[f]);
}
void setupFilterAdjustments(){
for( int i =0; i < 5;i++){
scr_blur[i] = 5;
scr_posterize[i] = 8;
scr_erode[i] = 2;
scr_dilate[i] = 2;
scr_sharp[i] = 1.0;
scr_usharp[i] = 64;
scr_hiPass[i] = 64;
scr_snnAmount[i] = 3;
scr_structureContrast[i] = 8.0;
scr_structureRadius[i] = 4;
Hcontrast[i] = 1.0;
Hbrightness[i] = 0.0;
Lcontrast[i] = 1.0;
Lbrightness[i] = 0.0;
scr_contrast[i] = 1;
scr_brightness[i] = 0;
}
}
void updateInfo(){
if(currentMode == drawingMode)
Info = "Paint Strength:" + realTrans;
else if(currentMode == blurMode)
Info = "Blur Strength:" + blurRealTrans;
else if( currentMode == cloneMode||
currentMode == setCloneMode||
currentMode == setClone2Mode)
Info = "Clone Strength:" + cloneRealTrans;
else if(currentMode == onColorMode)
Info = "On Color Strength:" + onColorRealTrans;
else return;
Info = Info + " Easing" + Easing;
if(ScreenEnhanced) Info = Info + " Screen Contrast:" + eContrast +
" Screen Brightness:" + eBrightness;
frame.setTitle(Info);
}
synchronized void flip_90CW(){
int pix = 0;
temp = createGraphics(Canvas.height,Canvas.width);
temp2 = createGraphics(Canvas.height,Canvas.width);
temp2.updatePixels();
Canvas.loadPixels();
temp.loadPixels();
for(int cx = 0; cx< Canvas.width; cx++)
for(int cy = Canvas.height -1; cy >=0; cy--)
temp.pixels[pix++] =Canvas.pixels[cy* Canvas.width + cx];
temp.updatePixels();
Canvas = createGraphics(temp.width, temp.height);
Canvas.beginDraw();
Canvas.image(temp,0,0);
Canvas.endDraw();
pix = 0;
HF.beginDraw();
HF.endDraw();
HF.loadPixels();
temp.loadPixels();
for(int hfx = 0; hfx< HF.width; hfx++)
for(int hfy = HF.height -1; hfy >=0; hfy--)
temp.pixels[pix++] =HF.pixels[hfy* HF.width + hfx];
temp.updatePixels();
HF = createGraphics(temp.width, temp.height);
HF.beginDraw();
HF.image(temp,0,0);
HF.endDraw();
pix = 0;
LF.beginDraw();
LF.endDraw();
LF.loadPixels();
temp.loadPixels();
for(int lfx = 0; lfx< LF.width; lfx++)
for(int lfy = LF.height -1; lfy >=0; lfy--)
temp.pixels[pix++] =LF.pixels[lfy* LF.width + lfx];
temp.updatePixels();
LF = createGraphics(temp.width, temp.height);
LF.beginDraw();
LF.image(temp,0,0);
LF.endDraw();
pix = 0;
Posterize.beginDraw();
Posterize.endDraw();
Posterize.loadPixels();
temp.loadPixels();
for(int px = 0; px< Posterize.width; px++)
for(int py = Posterize.height -1; py >=0; py--)
temp.pixels[pix++] =Posterize.pixels[py * Posterize.width + px];
temp.updatePixels();
Posterize = createGraphics(temp.width, temp.height);
Posterize.beginDraw();
Posterize.image(temp,0,0);
Posterize.endDraw();
uLayers = new PGraphics[numUndo];
for(int i = 0; i < numUndo; i++){
uLayers[i]= createGraphics(Canvas.width,Canvas.height);
uLayers[i].beginDraw();
uLayers[i].endDraw();
}
SaveScr = createGraphics(Canvas.width,Canvas.height);
SaveScr.beginDraw();
SaveScr.endDraw();
img = createImage(Canvas.width,Canvas.height,RGB);
curUndo =0;
curRedo = 0;
undoInstances = 0;
redoInstances = 0;
if(frequencyMode == HFREQ)
CurFreq = LF;
else CurFreq = HF;
loadFloatArray();
ScreenSaved = false;
}
synchronized void flip_horizontal(){
int x, x2,y;
int w = temp.width;
int h = temp.height;
Canvas.beginDraw();
Canvas.endDraw();
temp.beginDraw();
temp.endDraw();
Canvas.beginDraw();
Canvas.beginDraw();
temp.image(Canvas,0,0);
Canvas.loadPixels();
temp.loadPixels();
for(y= 0; y < h;y++){
for(x=0,x2 = w-1;x < w; x++,x2--){
Canvas.pixels[y * w + x] =
temp.pixels[y*w+x2];
}
}
Canvas.updatePixels();
temp.endDraw();
Canvas.endDraw();
if(frequencyMode == LFREQ){
HF.beginDraw();
HF.endDraw();
temp.beginDraw();
temp.endDraw();
HF.beginDraw();
temp.beginDraw();
temp.image(HF,0,0);
HF.loadPixels();
temp.loadPixels();
for(y= 0; y < h;y++){
for(x=0,x2 = w-1;x < w; x++,x2--){
HF.pixels[y * w + x] =
temp.pixels[y*w+x2];
}
}
HF.updatePixels();
temp.endDraw();
HF.endDraw();
curUndo = 0;
curRedo = 0;
}
if(frequencyMode ==HFREQ){
LF.beginDraw();
LF.endDraw();
temp.beginDraw();
temp.endDraw();
LF.beginDraw();
temp.beginDraw();
temp.image(LF,0,0);
LF.loadPixels();
temp.loadPixels();
for(y= 0; y < h;y++){
for(x=0,x2 = w-1;x < w; x++,x2--){
LF.pixels[y * w + x] =
temp.pixels[y*w+x2];
}
}
LF.updatePixels();
temp.endDraw();
LF.endDraw();
curUndo = 0;
curRedo = 0;
}
if(PosterLevel != 0){
Posterize.beginDraw();
Posterize.endDraw();
temp.beginDraw();
temp.endDraw();
Posterize.beginDraw();
temp.beginDraw();
temp.image(Posterize,0,0);
Posterize.loadPixels();
temp.loadPixels();
for(y= 0; y < h;y++){
for(x=0,x2 = w-1;x < w; x++,x2--){
Posterize.pixels[y * w + x] =
temp.pixels[y*w+x2];
}
}
Posterize.updatePixels();
temp.endDraw();
Posterize.endDraw();
curUndo = 0;
curRedo = 0;
}
loadFloatArray();
ScreenSaved = false;
}
void loadFloatArray(){
int pix = Canvas.width * Canvas.height;
Canvas.loadPixels();
for(int i = 0; i < pix; i++){
floatCanvas[i][0] =Canvas.pixels[i]>> 16 & 0xFF;
floatCanvas[i][1] =Canvas.pixels[i]>> 8 & 0xFF;
floatCanvas[i][2] =Canvas.pixels[i] & 0xFF;
}
}
void setupGraphics(){
uLayers = new PGraphics[numUndo];
for(int i = 0; i < numUndo; i++){
uLayers[i]= createGraphics(Canvas.width,Canvas.height);
uLayers[i].beginDraw();
uLayers[i].endDraw();
}
temp = createGraphics(Canvas.width,Canvas.height);
temp.beginDraw();
temp.endDraw();
temp2 = createGraphics(Canvas.width,Canvas.height);
temp2.beginDraw();
temp2.endDraw();
Posterize = createGraphics(Canvas.width,Canvas.height);
Posterize.beginDraw();
Posterize.endDraw();
HF = createGraphics(Canvas.width,Canvas.height);
HF.beginDraw();
HF.endDraw();
LF = createGraphics(Canvas.width,Canvas.height);
LF.beginDraw();
LF.endDraw();
Scr = createImage(Canvas.width,Canvas.height,ARGB);
diffScr = createImage(Canvas.width,Canvas.height,ARGB);
FreqScr = createImage(Canvas.width,Canvas.height,ARGB);
SMW = Canvas.width > 400 ? 400:Canvas.width;
SMH = Canvas.height > 400 ? 400:Canvas.height;
Scr2 = createImage(SMW,SMH,ARGB);
diffScr2 = createImage(SMW,SMH,RGB);
SaveScr = createGraphics(Canvas.width,Canvas.height);
SaveScr.beginDraw();
SaveScr.endDraw();
curUndo =0;
curRedo = 0;
undoInstances = 0;
redoInstances = 0;
}
synchronized void add_layers(PGraphics orig, PGraphics filtered, PGraphics result, int offset){
int or,og,ob,fr,fg,fb,dr,dg,db;
color o,f,d;
orig.beginDraw();
filtered.beginDraw();
result.beginDraw();
orig.loadPixels();
filtered.loadPixels();
result.loadPixels();
int pix = orig.width * orig.height;
int i;
for(i = 0; i < pix; i++){
o = orig.pixels[i];
f = filtered.pixels[i];
or = (int)o >> 16 & 0xFF; og = (int)o >> 8 & 0xFF; ob = (int)o & 0xFF;
fr = (int)f >> 16 & 0xFF; fg = (int)f >> 8 & 0xFF; fb = (int)f & 0xFF;
dr = or+fr - offset; dg = og+fg- offset; db = ob+fb -offset;
if(dr < 0) dr = 0;
else if( dr>255) dr = 255;
if(dg < 0) dg = 0;
else if( dg>255) dg = 255;
if(db < 0) db = 0;
else if( db>255) db = 255;
result.pixels[i] = color(dr,dg,db);
}
result.updatePixels();
filtered.updatePixels();
orig.updatePixels();
result.endDraw();
filtered.endDraw();
orig.endDraw();
}
synchronized void subtract_layers(PGraphics orig, PGraphics filtered, PGraphics result, int offset){
int or,og,ob,fr,fg,fb,dr,dg,db;
color o,f,d;
orig.beginDraw();
filtered.beginDraw();
result.beginDraw();
orig.loadPixels();
filtered.loadPixels();
result.loadPixels();
int pix = orig.width * orig.height;
for(int i = 0; i < pix; i++){
o = orig.pixels[i];
f = filtered.pixels[i];
or = (int)o >> 16 & 0xFF; og = (int)o >> 8 & 0xFF; ob = (int)o & 0xFF;
fr = (int)f >> 16 & 0xFF; fg = (int)f >> 8 & 0xFF; fb = (int)f & 0xFF;
dr = or-fr+ offset; dg = og-fg+ offset; db = ob-fb+ offset;
if(dr < 0) dr = 0;
else if( dr>255) dr = 255;
if(dg < 0) dg = 0;
else if( dg>255) dg = 255;
if(db < 0) db = 0;
else if( db>255) db = 255;
result.pixels[i] = color(dr,dg,db);
}
result.updatePixels();
filtered.updatePixels();
orig.updatePixels();
result.endDraw();
filtered.endDraw();
orig.endDraw();
}
void addFreq(PImage high, PImage low, PImage result,int filter){
int pix = high.width * high.height;
int total = 0;
for(int i = 0; i < pix; i++){
float r= (((high.pixels[i] >> 16 & 0xFF) -127.5 )* Hcontrast[filter] +127.5 + Hbrightness[filter]) +
(((low.pixels[i] >> 16 & 0xFF) -127.5 )* Lcontrast[filter] +127.5 + Lbrightness[filter]) - 127;
float g= (((high.pixels[i] >> 8 & 0xFF) -127.5 )* Hcontrast[filter] +127.5 + Hbrightness[filter]) +
(((low.pixels[i] >> 8 & 0xFF) -127.5 )* Lcontrast[filter] +127.5 + Lbrightness[filter]) - 127;
float b= (((high.pixels[i] & 0xFF) -127.5 )* Hcontrast[filter] +127.5 + Hbrightness[filter]) +
(((low.pixels[i] & 0xFF) -127.5 )* Lcontrast[filter] +127.5 + Lbrightness[filter]) - 127;
if(r < 0) r =0;else if(r > 255) r = 255;
if(g < 0) g =0;else if(g > 255) g = 255;
if(b < 0) b =0;else if(b > 255) b = 255;
result.pixels[i]=0xFF000000|(int)r<<16|(int)g<<8|(int)b;
total++;
}
result.updatePixels();
}
int reflect(int max, int num){
if(num < 0)
return -num -1;
if (num >= max)
return 2*max-num-1;
return num;
}
/////////////////////////// gui
/* =========================================================
* ==== WARNING ===
* =========================================================
* The code in this tab has been generated from the GUI form
* designer and care should be taken when editing this file.
* Only add/edit code inside the event handlers i.e. only
* use lines between the matching comment tags. e.g.
void myBtnEvents(GButton button) { //_CODE_:button1:12356:
// It is safe to enter your event code here
} //_CODE_:button1:12356:
* Do not rename this tab!
* =========================================================
*/
synchronized public void win_draw1(GWinApplet appc, GWinData data) { //_CODE_:scrSettings:582490:
appc.background(230);
} //_CODE_:scrSettings:582490:
public void blurSlider_change(GSlider source, GEvent event) { //_CODE_:blurSlider:835574:
scr_blur[curAdjustment] = blurSlider.getValueI();
ScreenSaved = false;
frame.toFront();
} //_CODE_:blurSlider:835574:
public void sharpSlider_change1(GSlider source, GEvent event) { //_CODE_:sharpSlider:834581:
scr_sharp[curAdjustment] = sharpSlider.getValueF();
setSharpMatrix(curAdjustment);
ScreenSaved = false;
frame.toFront();
} //_CODE_:sharpSlider:834581:
public void erodeSlider_change(GSlider source, GEvent event) { //_CODE_:erodeSlider:943991:
scr_erode[curAdjustment] = erodeSlider.getValueI();
ScreenSaved=false;
frame.toFront();
} //_CODE_:erodeSlider:943991:
public void dilateSlider_change(GSlider source, GEvent event) { //_CODE_:dilateSlider:920466:
scr_dilate[curAdjustment] = dilateSlider.getValueI();
ScreenSaved=false;
frame.toFront();
} //_CODE_:dilateSlider:920466:
public void posterizeSlider_change(GSlider source, GEvent event) { //_CODE_:posterizeSlider:767696:
scr_posterize[curAdjustment] = posterizeSlider.getValueI();
ScreenSaved = false;
frame.toFront();
} //_CODE_:posterizeSlider:767696:
public void buttonAccept_click(GButton source, GEvent event) { //_CODE_:buttonAccept:791069:
scrSettings.setVisible(false);
frame.toFront();
} //_CODE_:buttonAccept:791069:
public void uSharpSlider_change(GSlider source, GEvent event) { //_CODE_:uSharpSlider:753656:
scr_usharp[curAdjustment] = uSharpSlider.getValueI();
ScreenSaved=false;
frame.toFront();
} //_CODE_:uSharpSlider:753656:
public void HContrastSlider_change(GSlider source, GEvent event) { //_CODE_:HContrastSlider:438832:
Hcontrast[curAdjustment] = HContrastSlider.getValueF();
ScreenSaved=false;
} //_CODE_:HContrastSlider:438832:
public void HBrightnessSlider_change(GSlider source, GEvent event) { //_CODE_:HBrightnessSlider:276920:
Hbrightness[curAdjustment] = HBrightnessSlider.getValueF();
ScreenSaved=false;
frame.toFront();
} //_CODE_:HBrightnessSlider:276920:
public void LContrastSlider_change(GSlider source, GEvent event) { //_CODE_:LContrastSlider:340177:
Lcontrast[curAdjustment] = LContrastSlider.getValueF();
ScreenSaved=false;
frame.toFront();
} //_CODE_:LContrastSlider:340177:
public void LBrightnessSlider_change(GSlider source, GEvent event) { //_CODE_:LBrightnessSlider:232138:
Lbrightness[curAdjustment] = LBrightnessSlider.getValueF();
ScreenSaved=false;
frame.toFront();
} //_CODE_:LBrightnessSlider:232138:
public void hiPassSlider_change(GSlider source, GEvent event) { //_CODE_:hiPassSlider:440386:
scr_hiPass[curAdjustment] = hiPassSlider.getValueI();
ScreenSaved=false;
frame.toFront();
} //_CODE_:hiPassSlider:440386:
public void snnAmountslider_change(GSlider source, GEvent event) { //_CODE_:snnAmountslider:473315:
scr_snnAmount[curAdjustment] = snnAmountslider.getValueI();
ScreenSaved=false;
frame.toFront();
} //_CODE_:snnAmountslider:473315:
public void structureRadiusSlider_change(GSlider source, GEvent event) { //_CODE_:structureRadiusSlider:833746:
scr_structureRadius[curAdjustment] = structureRadiusSlider.getValueI();
ScreenSaved=false;
frame.toFront();
} //_CODE_:structureRadiusSlider:833746:
public void structureContrastSlider_change(GSlider source, GEvent event) { //_CODE_:structureContrastSlider:475605:
scr_structureContrast[curAdjustment] = structureContrastSlider.getValueF();
ScreenSaved=false;
frame.toFront();
} //_CODE_:structureContrastSlider:475605:
public void chooseF1_clicked(GOption source, GEvent event) { //_CODE_:chooseF1:407009:
curAdjustment = 0;
updateASliders(0);
disableAdjustments();
enableAdjustments(filters[0]);
} //_CODE_:chooseF1:407009:
public void chooseF2_clicked(GOption source, GEvent event) { //_CODE_:chooseF2:928101:
curAdjustment = 1;
updateASliders(1);
disableAdjustments();
enableAdjustments(filters[1]);
} //_CODE_:chooseF2:928101:
public void chooseF3_clicked(GOption source, GEvent event) { //_CODE_:chooseF3:392387:
curAdjustment = 2;
updateASliders(2);
disableAdjustments();
enableAdjustments(filters[2]);
} //_CODE_:chooseF3:392387:
public void chooseF4_clicked(GOption source, GEvent event) { //_CODE_:chooseF4:200932:
curAdjustment = 3;
updateASliders(3);
disableAdjustments();
enableAdjustments(filters[3]);
} //_CODE_:chooseF4:200932:
public void chooseF5_clicked(GOption source, GEvent event) { //_CODE_:chooseF5:664060:
curAdjustment = 4;
updateASliders(4);
disableAdjustments();
enableAdjustments(filters[4]);
} //_CODE_:chooseF5:664060:
public void contrastSlider_change(GSlider source, GEvent event) { //_CODE_:contrastSlider:523335:
scr_contrast[curAdjustment] = contrastSlider.getValueI();
ScreenSaved=false;
frame.toFront();
println("contrastSlider - GSlider >> GEvent." + event + " @ " + millis());
} //_CODE_:contrastSlider:523335:
public void brightnessSlider_change(GSlider source, GEvent event) { //_CODE_:brightnessSlider:843716:
scr_brightness[curAdjustment] = brightnessSlider.getValueI();
ScreenSaved=false;
frame.toFront();
println("slider1 - GSlider >> GEvent." + event + " @ " + millis());
} //_CODE_:brightnessSlider:843716:
synchronized public void win_draw_split(GWinApplet appc, GWinData data) { //_CODE_:SplitSettings:902607:
appc.background(230);
} //_CODE_:SplitSettings:902607:
public void kuwaharaSplit_clicked(GOption source, GEvent event) { //_CODE_:kuwaharSplitOption:559695:
SPLIT_METHOD = KUWAHARA;
frame.toFront();
} //_CODE_:kuwaharSplitOption:559695:
public void smmSplitOption_clicked(GOption source, GEvent event) { //_CODE_:snnSplitOption:669064:
SPLIT_METHOD = SNN;
frame.toFront();
} //_CODE_:snnSplitOption:669064:
public void blurSplitOption_clicked(GOption source, GEvent event) { //_CODE_:blurSplitOption:880047:
SPLIT_METHOD = BLURRED;
frame.toFront();
} //_CODE_:blurSplitOption:880047:
public void MedianSplitOption_clicked(GOption source, GEvent event) { //_CODE_:MedianSplitOption:202196:
SPLIT_METHOD = MEDIAN2;
frame.toFront();
} //_CODE_:MedianSplitOption:202196:
public void ColorSplitOption_clicked(GOption source, GEvent event) { //_CODE_:ColorSplitOption:501144:
SPLIT_METHOD = COLOR;
frame.toFront();
} //_CODE_:ColorSplitOption:501144:
public void kuwaharaSplitSlider_change(GSlider source, GEvent event) { //_CODE_:kuwaharaSplitSlider:452463:
KuwaharaSplit = kuwaharaSplitSlider.getValueI();
frame.toFront();
} //_CODE_:kuwaharaSplitSlider:452463:
public void snnSplitSlider_change(GSlider source, GEvent event) { //_CODE_:snnSplitSlider:289929:
SNNSplit = snnSplitSlider.getValueI();
frame.toFront();
} //_CODE_:snnSplitSlider:289929:
public void blurSplitSlider_change(GSlider source, GEvent event) { //_CODE_:blurSplitSlider:953624:
BlurSplit = blurSplitSlider.getValueI();
frame.toFront();
} //_CODE_:blurSplitSlider:953624:
public void medianSplitSlider_change(GSlider source, GEvent event) { //_CODE_:medianSplitSlider:540657:
MedianPasses = medianSplitSlider.getValueI();
frame.toFront();
} //_CODE_:medianSplitSlider:540657:
public void colorSplitSlider_change(GSlider source, GEvent event) { //_CODE_:colorSplitSlider:309129:
ColorSplit = colorSplitSlider.getValueI();
frame.toFront();
} //_CODE_:colorSplitSlider:309129:
public void splitSettingsCloseButton_click(GButton source, GEvent event) { //_CODE_:splitSettingsCloseButton:304137:
SplitSettings.setVisible(false);
frame.toFront();
} //_CODE_:splitSettingsCloseButton:304137:
synchronized public void toolSettings_draw(GWinApplet appc, GWinData data) { //_CODE_:toolSettings:868710:
appc.background(230);
} //_CODE_:toolSettings:868710:
public void paintSlider_change(GSlider source, GEvent event) { //_CODE_:paintSlider:453770:
realTrans = paintSlider.getValueI();
frame.toFront();
} //_CODE_:paintSlider:453770:
public void cloneSlider_change(GSlider source, GEvent event) { //_CODE_:cloneSlider:834019:
cloneRealTrans = cloneSlider.getValueI();
} //_CODE_:cloneSlider:834019:
public void blurToolSlider_change(GSlider source, GEvent event) { //_CODE_:blurToolSlider:521364:
blurRealTrans = blurToolSlider.getValueI();
frame.toFront();
} //_CODE_:blurToolSlider:521364:
public void onColorSlider_change(GSlider source, GEvent event) { //_CODE_:onColorSlider:875225:
onColorRealTrans = onColorSlider.getValueI();
frame.toFront();
} //_CODE_:onColorSlider:875225:
public void toolsCloseButton_click(GButton source, GEvent event) { //_CODE_:toolsCloseButton:296890:
toolSettings.setVisible(false);
frame.toFront();
} //_CODE_:toolsCloseButton:296890:
synchronized public void effectsSettings_draw(GWinApplet appc, GWinData data) { //_CODE_:effectSettings:773518:
appc.background(230);
} //_CODE_:effectSettings:773518:
public void e1Normal_clicked(GOption source, GEvent event) { //_CODE_:e1Normal:637210:
filters[0]= normalE;
handleOption( 0);
} //_CODE_:e1Normal:637210:
public void e1Blur_clicked(GOption source, GEvent event) { //_CODE_:e1Blur:993961:
filters[0]= blurE;
handleOption( 0);
} //_CODE_:e1Blur:993961:
public void e1Posterized_clicked(GOption source, GEvent event) { //_CODE_:e1Posterize:595270:
filters[0]= posterizeE;
handleOption( 0);
} //_CODE_:e1Posterize:595270:
public void e1Erode_clicked(GOption source, GEvent event) { //_CODE_:e1Erode:740749:
filters[0]= erodeE;
handleOption( 0);
} //_CODE_:e1Erode:740749:
public void e1Dialate_clicked(GOption source, GEvent event) { //_CODE_:e1Dilate:868304:
filters[0]= dilateE;
handleOption( 0);
} //_CODE_:e1Dilate:868304:
public void e1CloseHoles_clicked(GOption source, GEvent event) { //_CODE_:e1CloseHoles:209830:
filters[0]= closeHolesE;
handleOption( 0);
} //_CODE_:e1CloseHoles:209830:
public void e1SNN_clicked(GOption source, GEvent event) { //_CODE_:e1SNN:619572:
filters[0]= snnE;
handleOption( 0);
} //_CODE_:e1SNN:619572:
public void e1UnSharp_clicked(GOption source, GEvent event) { //_CODE_:e1UnSharp:397178:
filters[0]= unSharpE;
handleOption( 0);
} //_CODE_:e1UnSharp:397178:
public void e1HighPass_clicked(GOption source, GEvent event) { //_CODE_:e1HighPass:591804:
filters[0]= highPassE;
handleOption( 0);
} //_CODE_:e1HighPass:591804:
public void e1HighPassColor_clicked(GOption source, GEvent event) { //_CODE_:e1HighPassColor:602567:
filters[0]= colorHighPassE;
handleOption( 0);
} //_CODE_:e1HighPassColor:602567:
public void e1Structure_clicked(GOption source, GEvent event) { //_CODE_:e1Structure:390730:
filters[0]= structureE;
handleOption( 0);
} //_CODE_:e1Structure:390730:
public void e1Sharpen_clicked(GOption source, GEvent event) { //_CODE_:e1Sharpen:269817:
filters[0]= sharpenE;
handleOption( 0);
} //_CODE_:e1Sharpen:269817:
public void e1AddFreq_clicked(GOption source, GEvent event) { //_CODE_:e1AddFreq:504840:
filters[0]= addFreqE;
handleOption( 0);
} //_CODE_:e1AddFreq:504840:
public void e1Contrast_clicked(GOption source, GEvent event) { //_CODE_:e1Contrast:786115:
filters[0] = contrastE;
handleOption( 0);
} //_CODE_:e1Contrast:786115:
public void e2Normal_clicked(GOption source, GEvent event) { //_CODE_:e2Normal:660376:
filters[1] = normalE;
handleOption(1);
} //_CODE_:e2Normal:660376:
public void e2Blur_clicked(GOption source, GEvent event) { //_CODE_:e2Blur:358785:
filters[1] = blurE;
handleOption(1);
} //_CODE_:e2Blur:358785:
public void e2Posterize_clicked(GOption source, GEvent event) { //_CODE_:e2Posterize:674448:
filters[1] = posterizeE;
handleOption(1);
} //_CODE_:e2Posterize:674448:
public void e2Erode_clicked(GOption source, GEvent event) { //_CODE_:e2Erode:446145:
filters[1] = erodeE;
handleOption(1);
} //_CODE_:e2Erode:446145:
public void esDialate_clicked(GOption source, GEvent event) { //_CODE_:e2Dilate:767971:
filters[1] = dilateE;
handleOption(1);
} //_CODE_:e2Dilate:767971:
public void e2CloseHoles_clicked(GOption source, GEvent event) { //_CODE_:e2CloseHoles:592897:
filters[1] = closeHolesE;
handleOption(1);
} //_CODE_:e2CloseHoles:592897:
public void e2SNN_clicked(GOption source, GEvent event) { //_CODE_:e2SNN:415774:
filters[1] = snnE;
handleOption(1);
} //_CODE_:e2SNN:415774:
public void e2UnSharp_clicked(GOption source, GEvent event) { //_CODE_:e2UnSharp:940522:
filters[1] = unSharpE;
handleOption(1);
} //_CODE_:e2UnSharp:940522:
public void e2HighPass_clicked(GOption source, GEvent event) { //_CODE_:e2HighPass:559398:
filters[1] = highPassE;
handleOption(1);
} //_CODE_:e2HighPass:559398:
public void e2HighPassColor_clicked(GOption source, GEvent event) { //_CODE_:e2HighPassColor:731712:
filters[1] = colorHighPassE;
handleOption(1);
} //_CODE_:e2HighPassColor:731712:
public void e2Structure_clicked(GOption source, GEvent event) { //_CODE_:e2Structure:631918:
filters[1] = structureE;
handleOption(1);
} //_CODE_:e2Structure:631918:
public void e2Sharpen_clicked(GOption source, GEvent event) { //_CODE_:e2Sharpen:373610:
filters[1] = sharpenE;
handleOption(1);
} //_CODE_:e2Sharpen:373610:
public void e2AddFreq_clicked(GOption source, GEvent event) { //_CODE_:e2AddFreq:232741:
filters[1] = addFreqE;
handleOption(1);
} //_CODE_:e2AddFreq:232741:
public void e2Contrast_clicked(GOption source, GEvent event) { //_CODE_:e2Contrast:838857:
filters[1] = contrastE;
handleOption(1);
} //_CODE_:e2Contrast:838857:
public void e3Normal_clicked(GOption source, GEvent event) { //_CODE_:e3Normal:461106:
filters[2] = normalE;
handleOption(2);
} //_CODE_:e3Normal:461106:
public void e3Blur_clicked(GOption source, GEvent event) { //_CODE_:e3Blur:553153:
filters[2] = blurE;
handleOption(2);
} //_CODE_:e3Blur:553153:
public void e3Posterize_clicked(GOption source, GEvent event) { //_CODE_:e3Posterize:635772:
filters[2] = posterizeE;
handleOption(2);
} //_CODE_:e3Posterize:635772:
public void e3Erode_clicked(GOption source, GEvent event) { //_CODE_:e3Erode:208608:
filters[2] = erodeE;
handleOption(2);
} //_CODE_:e3Erode:208608:
public void e3Dilate_clicked(GOption source, GEvent event) { //_CODE_:e3Dilate:734714:
filters[2] = dilateE;
handleOption(2);
} //_CODE_:e3Dilate:734714:
public void e3CloseHoles_clicked(GOption source, GEvent event) { //_CODE_:e3CloseHoles:680854:
filters[2] = closeHolesE;
handleOption(2);
} //_CODE_:e3CloseHoles:680854:
public void e3SNN_clicked(GOption source, GEvent event) { //_CODE_:e3SNN:488813:
filters[2] = snnE;
handleOption(2);
} //_CODE_:e3SNN:488813:
public void e3UnSharp_clicked(GOption source, GEvent event) { //_CODE_:e3UnSharp:344246:
filters[2] = unSharpE;
handleOption(2);
} //_CODE_:e3UnSharp:344246:
public void e3HighPass_clicked(GOption source, GEvent event) { //_CODE_:e3HighPass:884220:
filters[2] = highPassE;
handleOption(2);
} //_CODE_:e3HighPass:884220:
public void e3HighPassColor_clicked(GOption source, GEvent event) { //_CODE_:e3HighPassColor:699264:
filters[2] = colorHighPassE;
handleOption(2);
} //_CODE_:e3HighPassColor:699264:
public void e3Structure_clicked(GOption source, GEvent event) { //_CODE_:e3Structure:545034:
filters[2] = structureE;
handleOption(2);
} //_CODE_:e3Structure:545034:
public void e3Sharpen_clicked(GOption source, GEvent event) { //_CODE_:e3Sharpen:437199:
filters[2] = sharpenE;
handleOption(2);
} //_CODE_:e3Sharpen:437199:
public void e3AddFreq_clicked(GOption source, GEvent event) { //_CODE_:e3AddFreq:750756:
filters[2] = addFreqE;
handleOption(2);
} //_CODE_:e3AddFreq:750756:
public void e3Contrast_clicked(GOption source, GEvent event) { //_CODE_:e3Contrast:677595:
filters[2] = contrastE;
handleOption(2);
} //_CODE_:e3Contrast:677595:
public void effectSettingsClose_click(GButton source, GEvent event) { //_CODE_:effectSettingsClose:226284:
effectSettings.setVisible(false);
frame.toFront();
} //_CODE_:effectSettingsClose:226284:
public void effectSettingsAdjustment_click(GButton source, GEvent event) { //_CODE_:effectSettingsAdjustments:781617:
scrSettings.setVisible(true);
frame.toFront();
} //_CODE_:effectSettingsAdjustments:781617:
public void e4Normal_clicked(GOption source, GEvent event) { //_CODE_:e4Normal:774521:
filters[3] = normalE;
handleOption(3);
} //_CODE_:e4Normal:774521:
public void e4Blur_clicked(GOption source, GEvent event) { //_CODE_:e4Blur:483020:
filters[3] = blurE;
handleOption(3);
} //_CODE_:e4Blur:483020:
public void e4Posterized_clicked(GOption source, GEvent event) { //_CODE_:e4Posterize:838577:
filters[3] = posterizeE;
handleOption(3);
} //_CODE_:e4Posterize:838577:
public void e4Erode_clicked(GOption source, GEvent event) { //_CODE_:e4Erode:857186:
filters[3] = erodeE;
handleOption(3);
} //_CODE_:e4Erode:857186:
public void e4Dilate_clicked(GOption source, GEvent event) { //_CODE_:e4Dilate:993465:
filters[3] = dilateE;
handleOption(3);
} //_CODE_:e4Dilate:993465:
public void e4CloseHoles_clicked(GOption source, GEvent event) { //_CODE_:e4CloseHoles:415077:
filters[3] = closeHolesE;
handleOption(3);
} //_CODE_:e4CloseHoles:415077:
public void e4SNN_clicked(GOption source, GEvent event) { //_CODE_:e4SNN:647264:
filters[3] = snnE;
handleOption(3);
} //_CODE_:e4SNN:647264:
public void e4UnSharp_clicked(GOption source, GEvent event) { //_CODE_:e4UnSharp:467970:
filters[3] = unSharpE;
handleOption(3);
} //_CODE_:e4UnSharp:467970:
public void e4HighPass_clicked(GOption source, GEvent event) { //_CODE_:e4HighPass:479492:
filters[3] = highPassE;
handleOption(3);
} //_CODE_:e4HighPass:479492:
public void e4HighPassColor_clicked(GOption source, GEvent event) { //_CODE_:e4HighPassColor:387271:
filters[3] = colorHighPassE;
handleOption(3);
} //_CODE_:e4HighPassColor:387271:
public void e4Structure_clicked(GOption source, GEvent event) { //_CODE_:e4Structure:487541:
filters[3] = structureE;
handleOption(3);
} //_CODE_:e4Structure:487541:
public void e4Sharpen_clicked(GOption source, GEvent event) { //_CODE_:e4Sharpen:434670:
filters[3] = sharpenE;
handleOption(3);
} //_CODE_:e4Sharpen:434670:
public void e4AddFreq_clicked(GOption source, GEvent event) { //_CODE_:e4AddFreq:695217:
filters[3] = addFreqE;
handleOption(3);
} //_CODE_:e4AddFreq:695217:
public void e4Contrast_clicked(GOption source, GEvent event) { //_CODE_:e4Contrast:793449:
filters[3] = contrastE;
handleOption(3);
} //_CODE_:e4Contrast:793449:
public void filterSaveButton_click(GButton source, GEvent event) { //_CODE_:filterSaveButton:386494:
saveFilterSettings();
} //_CODE_:filterSaveButton:386494:
public void loadFilterButton_click(GButton source, GEvent event) { //_CODE_:loadFilterButton:950937:
loadFilterSettings();
} //_CODE_:loadFilterButton:950937:
public void e5Normal_clicked(GOption source, GEvent event) { //_CODE_:e5Normal:403775:
filters[4] = normalE;
handleOption(4);
} //_CODE_:e5Normal:403775:
public void e5Blur_clicked(GOption source, GEvent event) { //_CODE_:e5Blur:241296:
filters[4] = blurE;
handleOption(4);
} //_CODE_:e5Blur:241296:
public void e5Posterize_clicked(GOption source, GEvent event) { //_CODE_:e5Posterize:698720:
filters[4] = posterizeE;
handleOption(4);
} //_CODE_:e5Posterize:698720:
public void e5Erode_clicked(GOption source, GEvent event) { //_CODE_:e5Erode:561389:
filters[4] = erodeE;
handleOption(4);
} //_CODE_:e5Erode:561389:
public void e5Dilate_clicked(GOption source, GEvent event) { //_CODE_:e5Dilate:255199:
filters[4] = dilateE;
handleOption(4);
} //_CODE_:e5Dilate:255199:
public void e5CloseHoles_clicked(GOption source, GEvent event) { //_CODE_:e5CloseHoles:225416:
filters[4] = closeHolesE;
handleOption(4);
} //_CODE_:e5CloseHoles:225416:
public void e5Snn_clicked(GOption source, GEvent event) { //_CODE_:e5SNN:651973:
filters[4] = snnE;
handleOption(4);
} //_CODE_:e5SNN:651973:
public void e5UnSharp_clicked(GOption source, GEvent event) { //_CODE_:e5UnSharp:931725:
filters[4] = unSharpE;
handleOption(4);
} //_CODE_:e5UnSharp:931725:
public void e5HighPass_clicked(GOption source, GEvent event) { //_CODE_:e5HighPass:878694:
filters[4] = highPassE;
handleOption(4);
} //_CODE_:e5HighPass:878694:
public void e5HighPassColor_clicked(GOption source, GEvent event) { //_CODE_:e5HighPassColor:332196:
filters[4] = colorHighPassE;
handleOption(4);
} //_CODE_:e5HighPassColor:332196:
public void e5Structure_clicked(GOption source, GEvent event) { //_CODE_:e5Structure:670013:
filters[4] = structureE;
handleOption(4);
} //_CODE_:e5Structure:670013:
public void e5Sharpen_clicked(GOption source, GEvent event) { //_CODE_:e5Sharpen:549079:
filters[4] = sharpenE;
handleOption(4);
} //_CODE_:e5Sharpen:549079:
public void e5AddFreq_clicked(GOption source, GEvent event) { //_CODE_:e5AddFreq:814891:
filters[4] = addFreqE;
handleOption(4);
} //_CODE_:e5AddFreq:814891:
public void e5Contrast_clicked(GOption source, GEvent event) { //_CODE_:e5Contrast:989237:
filters[4] = contrastE;
handleOption(4);
} //_CODE_:e5Contrast:989237:
// Create all the GUI controls.
// autogenerated do not edit
public void createGUI(){
G4P.messagesEnabled(false);
G4P.setGlobalColorScheme(GCScheme.BLUE_SCHEME);
G4P.setCursor(ARROW);
if(frame != null)
frame.setTitle("Sketch Window");
scrSettings = new GWindow(this, "Effect Settings", 200, 0, 400, 600, false, JAVA2D);
scrSettings.addDrawHandler(this, "win_draw1");
blurSlider = new GSlider(scrSettings.papplet, 4, 112, 192, 32, 8.0);
blurSlider.setShowValue(true);
blurSlider.setLimits(2, 1, 64);
blurSlider.setNbrTicks(64);
blurSlider.setNumberFormat(G4P.INTEGER, 0);
blurSlider.setOpaque(false);
blurSlider.addEventHandler(this, "blurSlider_change");
labelBlur = new GLabel(scrSettings.papplet, 4, 92, 192, 20);
labelBlur.setText("Blur Amount");
labelBlur.setTextBold();
labelBlur.setOpaque(false);
sharpSlider = new GSlider(scrSettings.papplet, 0, 268, 396, 32, 8.0);
sharpSlider.setShowValue(true);
sharpSlider.setLimits(1.0, 0.0, 15.0);
sharpSlider.setNbrTicks(15);
sharpSlider.setNumberFormat(G4P.DECIMAL, 1);
sharpSlider.setOpaque(false);
sharpSlider.addEventHandler(this, "sharpSlider_change1");
labelSharp = new GLabel(scrSettings.papplet, 96, 248, 192, 20);
labelSharp.setText("Sharp Amount");
labelSharp.setTextBold();
labelSharp.setOpaque(false);
erodeSlider = new GSlider(scrSettings.papplet, 0, 164, 192, 32, 8.0);
erodeSlider.setShowValue(true);
erodeSlider.setLimits(1, 1, 5);
erodeSlider.setNbrTicks(5);
erodeSlider.setNumberFormat(G4P.INTEGER, 0);
erodeSlider.setOpaque(false);
erodeSlider.addEventHandler(this, "erodeSlider_change");
labelErode = new GLabel(scrSettings.papplet, 4, 144, 192, 20);
labelErode.setText("Erode Amount");
labelErode.setTextBold();
labelErode.setOpaque(false);
dilateSlider = new GSlider(scrSettings.papplet, 200, 164, 192, 32, 8.0);
dilateSlider.setShowValue(true);
dilateSlider.setLimits(1, 1, 5);
dilateSlider.setNbrTicks(5);
dilateSlider.setNumberFormat(G4P.INTEGER, 0);
dilateSlider.setOpaque(false);
dilateSlider.addEventHandler(this, "dilateSlider_change");
labelDilate = new GLabel(scrSettings.papplet, 200, 144, 192, 20);
labelDilate.setText("Dilate Amount");
labelDilate.setTextBold();
labelDilate.setOpaque(false);
posterizeSlider = new GSlider(scrSettings.papplet, -4, 216, 396, 32, 8.0);
posterizeSlider.setShowValue(true);
posterizeSlider.setLimits(8, 2, 64);
posterizeSlider.setNbrTicks(62);
posterizeSlider.setNumberFormat(G4P.INTEGER, 0);
posterizeSlider.setOpaque(false);
posterizeSlider.addEventHandler(this, "posterizeSlider_change");
labelPosterize = new GLabel(scrSettings.papplet, 108, 196, 192, 20);
labelPosterize.setText("Posterize Levels");
labelPosterize.setTextBold();
labelPosterize.setOpaque(false);
buttonAccept = new GButton(scrSettings.papplet, 160, 564, 80, 30);
buttonAccept.setText("Close");
buttonAccept.setTextBold();
buttonAccept.addEventHandler(this, "buttonAccept_click");
splitMethodGroup = new GToggleGroup();
usharpLabel = new GLabel(scrSettings.papplet, 108, 300, 180, 20);
usharpLabel.setText("USharp Amount");
usharpLabel.setTextBold();
usharpLabel.setOpaque(false);
uSharpSlider = new GSlider(scrSettings.papplet, 0, 320, 396, 32, 8.0);
uSharpSlider.setShowValue(true);
uSharpSlider.setLimits(64, 2, 256);
uSharpSlider.setNbrTicks(129);
uSharpSlider.setNumberFormat(G4P.INTEGER, 0);
uSharpSlider.setOpaque(false);
uSharpSlider.addEventHandler(this, "uSharpSlider_change");
HContrastSlider = new GSlider(scrSettings.papplet, 0, 476, 192, 32, 8.0);
HContrastSlider.setShowValue(true);
HContrastSlider.setLimits(1.0, -10.0, 30.0);
HContrastSlider.setNbrTicks(61);
HContrastSlider.setNumberFormat(G4P.DECIMAL, 1);
HContrastSlider.setOpaque(false);
HContrastSlider.addEventHandler(this, "HContrastSlider_change");
HContrastLabel = new GLabel(scrSettings.papplet, 4, 456, 192, 20);
HContrastLabel.setText("High Freq Contrast");
HContrastLabel.setTextBold();
HContrastLabel.setOpaque(false);
HBrightnessSlider = new GSlider(scrSettings.papplet, 0, 528, 192, 32, 8.0);
HBrightnessSlider.setShowValue(true);
HBrightnessSlider.setLimits(0, -100, 100);
HBrightnessSlider.setNbrTicks(10);
HBrightnessSlider.setNumberFormat(G4P.INTEGER, 0);
HBrightnessSlider.setOpaque(false);
HBrightnessSlider.addEventHandler(this, "HBrightnessSlider_change");
HBrightnessLabel = new GLabel(scrSettings.papplet, 0, 508, 192, 20);
HBrightnessLabel.setText("High Freq Brightness");
HBrightnessLabel.setTextBold();
HBrightnessLabel.setOpaque(false);
LContrastLabel = new GLabel(scrSettings.papplet, 196, 456, 200, 20);
LContrastLabel.setText("Low Freq Contrast");
LContrastLabel.setTextBold();
LContrastLabel.setOpaque(false);
LContrastSlider = new GSlider(scrSettings.papplet, 196, 476, 200, 32, 8.0);
LContrastSlider.setShowValue(true);
LContrastSlider.setLimits(1.0, -5.0, 5.0);
LContrastSlider.setNbrTicks(11);
LContrastSlider.setNumberFormat(G4P.DECIMAL, 1);
LContrastSlider.setOpaque(false);
LContrastSlider.addEventHandler(this, "LContrastSlider_change");
LBrightnessSlider = new GSlider(scrSettings.papplet, 196, 528, 200, 32, 8.0);
LBrightnessSlider.setShowValue(true);
LBrightnessSlider.setLimits(0, -100, 100);
LBrightnessSlider.setNbrTicks(20);
LBrightnessSlider.setNumberFormat(G4P.INTEGER, 0);
LBrightnessSlider.setOpaque(false);
LBrightnessSlider.addEventHandler(this, "LBrightnessSlider_change");
LBrightnessLabel = new GLabel(scrSettings.papplet, 200, 508, 192, 20);
LBrightnessLabel.setText("Low Freq Brightness");
LBrightnessLabel.setTextBold();
LBrightnessLabel.setOpaque(false);
hiPassSlider = new GSlider(scrSettings.papplet, 0, 372, 396, 32, 8.0);
hiPassSlider.setShowValue(true);
hiPassSlider.setLimits(64, 2, 256);
hiPassSlider.setNumberFormat(G4P.INTEGER, 0);
hiPassSlider.setOpaque(false);
hiPassSlider.addEventHandler(this, "hiPassSlider_change");
hiPassLable = new GLabel(scrSettings.papplet, 108, 352, 188, 20);
hiPassLable.setText("High Pass Amount");
hiPassLable.setTextBold();
hiPassLable.setOpaque(false);
snnAmountslider = new GSlider(scrSettings.papplet, 200, 112, 192, 32, 8.0);
snnAmountslider.setShowValue(true);
snnAmountslider.setLimits(3, 0, 10);
snnAmountslider.setNumberFormat(G4P.INTEGER, 0);
snnAmountslider.setOpaque(false);
snnAmountslider.addEventHandler(this, "snnAmountslider_change");
snnAmountLabel = new GLabel(scrSettings.papplet, 200, 92, 192, 20);
snnAmountLabel.setText("SNN Amount");
snnAmountLabel.setTextBold();
snnAmountLabel.setOpaque(false);
structureRadiusLabel = new GLabel(scrSettings.papplet, 4, 404, 184, 20);
structureRadiusLabel.setText("Structure Radius");
structureRadiusLabel.setTextBold();
structureRadiusLabel.setOpaque(false);
structureContrasLabel = new GLabel(scrSettings.papplet, 204, 404, 172, 20);
structureContrasLabel.setText("Structure Contrast");
structureContrasLabel.setTextBold();
structureContrasLabel.setOpaque(false);
structureRadiusSlider = new GSlider(scrSettings.papplet, 4, 424, 188, 32, 8.0);
structureRadiusSlider.setShowValue(true);
structureRadiusSlider.setLimits(4, 2, 25);
structureRadiusSlider.setNumberFormat(G4P.INTEGER, 0);
structureRadiusSlider.setOpaque(false);
structureRadiusSlider.addEventHandler(this, "structureRadiusSlider_change");
structureContrastSlider = new GSlider(scrSettings.papplet, 196, 424, 196, 32, 8.0);
structureContrastSlider.setShowValue(true);
structureContrastSlider.setLimits(8.0, 0.0, 40.0);
structureContrastSlider.setNumberFormat(G4P.DECIMAL, 1);
structureContrastSlider.setOpaque(false);
structureContrastSlider.addEventHandler(this, "structureContrastSlider_change");
filterChoice = new GToggleGroup();
chooseF1 = new GOption(scrSettings.papplet, 24, 4, 68, 20);
chooseF1.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
chooseF1.setText(" Filter 1");
chooseF1.setTextBold();
chooseF1.setOpaque(false);
chooseF1.addEventHandler(this, "chooseF1_clicked");
chooseF2 = new GOption(scrSettings.papplet, 92, 4, 68, 20);
chooseF2.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
chooseF2.setText(" Filter 2");
chooseF2.setTextBold();
chooseF2.setOpaque(false);
chooseF2.addEventHandler(this, "chooseF2_clicked");
chooseF3 = new GOption(scrSettings.papplet, 160, 4, 68, 20);
chooseF3.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
chooseF3.setText(" Filter 3");
chooseF3.setTextBold();
chooseF3.setOpaque(false);
chooseF3.addEventHandler(this, "chooseF3_clicked");
chooseF4 = new GOption(scrSettings.papplet, 228, 4, 68, 20);
chooseF4.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
chooseF4.setText(" Filter 4");
chooseF4.setTextBold();
chooseF4.setOpaque(false);
chooseF4.addEventHandler(this, "chooseF4_clicked");
chooseF5 = new GOption(scrSettings.papplet, 296, 4, 68, 20);
chooseF5.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
chooseF5.setText(" Filter 5");
chooseF5.setTextBold();
chooseF5.setOpaque(false);
chooseF5.addEventHandler(this, "chooseF5_clicked");
filterChoice.addControl(chooseF1);
chooseF1.setSelected(true);
filterChoice.addControl(chooseF2);
filterChoice.addControl(chooseF3);
filterChoice.addControl(chooseF4);
filterChoice.addControl(chooseF5);
contrastSlider = new GSlider(scrSettings.papplet, 4, 60, 192, 32, 8.0);
contrastSlider.setShowValue(true);
contrastSlider.setLimits(0, -100, 100);
contrastSlider.setNumberFormat(G4P.INTEGER, 0);
contrastSlider.setOpaque(false);
contrastSlider.addEventHandler(this, "contrastSlider_change");
scrContrastLabel = new GLabel(scrSettings.papplet, 24, 40, 140, 20);
scrContrastLabel.setText("Contrast");
scrContrastLabel.setTextBold();
scrContrastLabel.setOpaque(false);
brightnessSlider = new GSlider(scrSettings.papplet, 200, 60, 192, 32, 8.0);
brightnessSlider.setShowValue(true);
brightnessSlider.setLimits(0, -100, 100);
brightnessSlider.setNumberFormat(G4P.INTEGER, 0);
brightnessSlider.setOpaque(false);
brightnessSlider.addEventHandler(this, "brightnessSlider_change");
brightnessLabel = new GLabel(scrSettings.papplet, 228, 40, 144, 20);
brightnessLabel.setText("Brightness");
brightnessLabel.setTextBold();
brightnessLabel.setOpaque(false);
SplitSettings = new GWindow(this, "Frequency Split Settings", 0, 0, 400, 200, false, JAVA2D);
SplitSettings.addDrawHandler(this, "win_draw_split");
SplitMethods = new GToggleGroup();
kuwaharSplitOption = new GOption(SplitSettings.papplet, 12, 12, 120, 20);
kuwaharSplitOption.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
kuwaharSplitOption.setText(" Kuwahara Split");
kuwaharSplitOption.setTextBold();
kuwaharSplitOption.setOpaque(false);
kuwaharSplitOption.addEventHandler(this, "kuwaharaSplit_clicked");
snnSplitOption = new GOption(SplitSettings.papplet, 140, 12, 112, 20);
snnSplitOption.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
snnSplitOption.setText(" SNN Split");
snnSplitOption.setTextBold();
snnSplitOption.setOpaque(false);
snnSplitOption.addEventHandler(this, "smmSplitOption_clicked");
blurSplitOption = new GOption(SplitSettings.papplet, 280, 12, 108, 20);
blurSplitOption.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
blurSplitOption.setText(" Blur Split");
blurSplitOption.setTextBold();
blurSplitOption.setOpaque(false);
blurSplitOption.addEventHandler(this, "blurSplitOption_clicked");
MedianSplitOption = new GOption(SplitSettings.papplet, 28, 68, 120, 20);
MedianSplitOption.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
MedianSplitOption.setText(" Median Split");
MedianSplitOption.setTextBold();
MedianSplitOption.setOpaque(false);
MedianSplitOption.addEventHandler(this, "MedianSplitOption_clicked");
ColorSplitOption = new GOption(SplitSettings.papplet, 224, 68, 120, 20);
ColorSplitOption.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
ColorSplitOption.setText(" Color Split");
ColorSplitOption.setTextBold();
ColorSplitOption.setOpaque(false);
ColorSplitOption.addEventHandler(this, "ColorSplitOption_clicked");
SplitMethods.addControl(kuwaharSplitOption);
SplitMethods.addControl(snnSplitOption);
SplitMethods.addControl(blurSplitOption);
blurSplitOption.setSelected(true);
SplitMethods.addControl(MedianSplitOption);
SplitMethods.addControl(ColorSplitOption);
kuwaharaSplitSlider = new GSlider(SplitSettings.papplet, 12, 32, 120, 32, 8.0);
kuwaharaSplitSlider.setShowValue(true);
kuwaharaSplitSlider.setLimits(4, 1, 10);
kuwaharaSplitSlider.setNumberFormat(G4P.INTEGER, 0);
kuwaharaSplitSlider.setOpaque(false);
kuwaharaSplitSlider.addEventHandler(this, "kuwaharaSplitSlider_change");
snnSplitSlider = new GSlider(SplitSettings.papplet, 136, 32, 120, 32, 8.0);
snnSplitSlider.setShowValue(true);
snnSplitSlider.setLimits(4, 1, 10);
snnSplitSlider.setNumberFormat(G4P.INTEGER, 0);
snnSplitSlider.setOpaque(false);
snnSplitSlider.addEventHandler(this, "snnSplitSlider_change");
blurSplitSlider = new GSlider(SplitSettings.papplet, 256, 32, 140, 32, 8.0);
blurSplitSlider.setShowValue(true);
blurSplitSlider.setLimits(4, 2, 20);
blurSplitSlider.setNumberFormat(G4P.INTEGER, 0);
blurSplitSlider.setOpaque(false);
blurSplitSlider.addEventHandler(this, "blurSplitSlider_change");
medianSplitSlider = new GSlider(SplitSettings.papplet, 12, 92, 148, 32, 8.0);
medianSplitSlider.setShowValue(true);
medianSplitSlider.setLimits(4, 0, 12);
medianSplitSlider.setNumberFormat(G4P.INTEGER, 0);
medianSplitSlider.setOpaque(false);
medianSplitSlider.addEventHandler(this, "medianSplitSlider_change");
colorSplitSlider = new GSlider(SplitSettings.papplet, 172, 92, 216, 32, 8.0);
colorSplitSlider.setShowValue(true);
colorSplitSlider.setLimits(100, 0, 100);
colorSplitSlider.setNumberFormat(G4P.INTEGER, 0);
colorSplitSlider.setOpaque(false);
colorSplitSlider.addEventHandler(this, "colorSplitSlider_change");
splitSettingsCloseButton = new GButton(SplitSettings.papplet, 144, 144, 80, 30);
splitSettingsCloseButton.setText("Close");
splitSettingsCloseButton.setTextBold();
splitSettingsCloseButton.addEventHandler(this, "splitSettingsCloseButton_click");
toolSettings = new GWindow(this, "Tool Settings", 0, 0, 400, 300, false, JAVA2D);
toolSettings.addDrawHandler(this, "toolSettings_draw");
darkerLabel = new GLabel(toolSettings.papplet, 0, 0, 152, 20);
darkerLabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
darkerLabel.setText("Darker (DownArrow)");
darkerLabel.setTextBold();
darkerLabel.setOpaque(false);
lighterLabel = new GLabel(toolSettings.papplet, 260, 0, 136, 24);
lighterLabel.setTextAlign(GAlign.RIGHT, GAlign.MIDDLE);
lighterLabel.setText("Lighter (Up Arrow)");
lighterLabel.setTextItalic();
lighterLabel.setOpaque(false);
paintLabel = new GLabel(toolSettings.papplet, 140, 20, 80, 20);
paintLabel.setText("Paint");
paintLabel.setOpaque(false);
paintSlider = new GSlider(toolSettings.papplet, 4, 40, 392, 32, 8.0);
paintSlider.setShowValue(true);
paintSlider.setLimits(20, 1, 500);
paintSlider.setNumberFormat(G4P.INTEGER, 0);
paintSlider.setOpaque(false);
paintSlider.addEventHandler(this, "paintSlider_change");
cloneLabel = new GLabel(toolSettings.papplet, 140, 72, 80, 20);
cloneLabel.setText("Clone");
cloneLabel.setOpaque(false);
cloneSlider = new GSlider(toolSettings.papplet, 4, 92, 392, 32, 8.0);
cloneSlider.setShowValue(true);
cloneSlider.setLimits(20, 1, 500);
cloneSlider.setNumberFormat(G4P.INTEGER, 0);
cloneSlider.setOpaque(false);
cloneSlider.addEventHandler(this, "cloneSlider_change");
blurLabel = new GLabel(toolSettings.papplet, 140, 124, 80, 20);
blurLabel.setText("Blur");
blurLabel.setOpaque(false);
blurToolSlider = new GSlider(toolSettings.papplet, 4, 144, 392, 32, 8.0);
blurToolSlider.setShowValue(true);
blurToolSlider.setLimits(20, 1, 500);
blurToolSlider.setNumberFormat(G4P.INTEGER, 0);
blurToolSlider.setOpaque(false);
blurToolSlider.addEventHandler(this, "blurToolSlider_change");
onColorlabel = new GLabel(toolSettings.papplet, 108, 176, 148, 20);
onColorlabel.setText("Draw On Color");
onColorlabel.setOpaque(false);
onColorSlider = new GSlider(toolSettings.papplet, 4, 196, 392, 32, 8.0);
onColorSlider.setShowValue(true);
onColorSlider.setLimits(20, 1, 500);
onColorSlider.setNumberFormat(G4P.INTEGER, 0);
onColorSlider.setOpaque(false);
onColorSlider.addEventHandler(this, "onColorSlider_change");
toolsCloseButton = new GButton(toolSettings.papplet, 148, 244, 80, 30);
toolsCloseButton.setText("Close");
toolsCloseButton.setTextBold();
toolsCloseButton.addEventHandler(this, "toolsCloseButton_click");
effectSettings = new GWindow(this, "Filter Selection", 0, 0, 400, 475, false, JAVA2D);
effectSettings.addDrawHandler(this, "effectsSettings_draw");
effect1Label = new GLabel(effectSettings.papplet, 100, 4, 52, 20);
effect1Label.setText("Filter 1");
effect1Label.setOpaque(false);
effect2Label = new GLabel(effectSettings.papplet, 152, 4, 52, 20);
effect2Label.setText("Filter 2");
effect2Label.setOpaque(false);
effect3Label = new GLabel(effectSettings.papplet, 204, 4, 52, 20);
effect3Label.setText("Filter 3");
effect3Label.setOpaque(false);
normalELabel = new GLabel(effectSettings.papplet, 4, 24, 104, 20);
normalELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
normalELabel.setText("Normal (no effect)");
normalELabel.setOpaque(false);
line1Label = new GLabel(effectSettings.papplet, 4, 44, 392, 8);
line1Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line1Label.setText("---------------------------------------------------------------------------------------------");
line1Label.setOpaque(false);
blurELabel = new GLabel(effectSettings.papplet, 4, 48, 80, 20);
blurELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
blurELabel.setText("Blur");
blurELabel.setOpaque(false);
line2Label = new GLabel(effectSettings.papplet, 4, 68, 396, 8);
line2Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line2Label.setText("---------------------------------------------------------------------------------------------");
line2Label.setOpaque(false);
posterizeELabel = new GLabel(effectSettings.papplet, 4, 72, 80, 20);
posterizeELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
posterizeELabel.setText("Posterize");
posterizeELabel.setOpaque(false);
line3Label = new GLabel(effectSettings.papplet, 4, 92, 392, 8);
line3Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line3Label.setText("---------------------------------------------------------------------------------------------");
line3Label.setOpaque(false);
erodeELabel = new GLabel(effectSettings.papplet, 4, 96, 80, 20);
erodeELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
erodeELabel.setText("Erode");
erodeELabel.setOpaque(false);
line4Label = new GLabel(effectSettings.papplet, 4, 116, 388, 8);
line4Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line4Label.setText("---------------------------------------------------------------------------------------------");
line4Label.setOpaque(false);
dialateELabel = new GLabel(effectSettings.papplet, 4, 120, 80, 20);
dialateELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
dialateELabel.setText("Dilate");
dialateELabel.setOpaque(false);
line5Label = new GLabel(effectSettings.papplet, 4, 140, 392, 8);
line5Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line5Label.setText("---------------------------------------------------------------------------------------------");
line5Label.setOpaque(false);
effect1OptionGroup = new GToggleGroup();
e1Normal = new GOption(effectSettings.papplet, 116, 28, 20, 20);
e1Normal.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Normal.setOpaque(false);
e1Normal.addEventHandler(this, "e1Normal_clicked");
e1Blur = new GOption(effectSettings.papplet, 116, 52, 24, 20);
e1Blur.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Blur.setOpaque(false);
e1Blur.addEventHandler(this, "e1Blur_clicked");
e1Posterize = new GOption(effectSettings.papplet, 116, 76, 24, 20);
e1Posterize.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Posterize.setOpaque(false);
e1Posterize.addEventHandler(this, "e1Posterized_clicked");
e1Erode = new GOption(effectSettings.papplet, 116, 100, 28, 20);
e1Erode.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Erode.setOpaque(false);
e1Erode.addEventHandler(this, "e1Erode_clicked");
e1Dilate = new GOption(effectSettings.papplet, 116, 124, 28, 20);
e1Dilate.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Dilate.setOpaque(false);
e1Dilate.addEventHandler(this, "e1Dialate_clicked");
e1CloseHoles = new GOption(effectSettings.papplet, 116, 148, 24, 20);
e1CloseHoles.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1CloseHoles.setOpaque(false);
e1CloseHoles.addEventHandler(this, "e1CloseHoles_clicked");
e1SNN = new GOption(effectSettings.papplet, 116, 172, 24, 20);
e1SNN.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1SNN.setOpaque(false);
e1SNN.addEventHandler(this, "e1SNN_clicked");
e1UnSharp = new GOption(effectSettings.papplet, 116, 196, 24, 20);
e1UnSharp.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1UnSharp.setOpaque(false);
e1UnSharp.addEventHandler(this, "e1UnSharp_clicked");
e1HighPass = new GOption(effectSettings.papplet, 116, 220, 20, 20);
e1HighPass.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1HighPass.setOpaque(false);
e1HighPass.addEventHandler(this, "e1HighPass_clicked");
e1HighPassColor = new GOption(effectSettings.papplet, 116, 244, 32, 20);
e1HighPassColor.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1HighPassColor.setOpaque(false);
e1HighPassColor.addEventHandler(this, "e1HighPassColor_clicked");
e1Structure = new GOption(effectSettings.papplet, 116, 268, 36, 20);
e1Structure.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Structure.setOpaque(false);
e1Structure.addEventHandler(this, "e1Structure_clicked");
e1Sharpen = new GOption(effectSettings.papplet, 116, 292, 32, 20);
e1Sharpen.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Sharpen.setOpaque(false);
e1Sharpen.addEventHandler(this, "e1Sharpen_clicked");
e1AddFreq = new GOption(effectSettings.papplet, 116, 312, 36, 20);
e1AddFreq.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1AddFreq.setOpaque(false);
e1AddFreq.addEventHandler(this, "e1AddFreq_clicked");
e1Contrast = new GOption(effectSettings.papplet, 116, 336, 28, 20);
e1Contrast.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e1Contrast.setOpaque(false);
e1Contrast.addEventHandler(this, "e1Contrast_clicked");
effect1OptionGroup.addControl(e1Normal);
e1Normal.setSelected(true);
effect1OptionGroup.addControl(e1Blur);
effect1OptionGroup.addControl(e1Posterize);
effect1OptionGroup.addControl(e1Erode);
effect1OptionGroup.addControl(e1Dilate);
effect1OptionGroup.addControl(e1CloseHoles);
effect1OptionGroup.addControl(e1SNN);
effect1OptionGroup.addControl(e1UnSharp);
effect1OptionGroup.addControl(e1HighPass);
effect1OptionGroup.addControl(e1HighPassColor);
effect1OptionGroup.addControl(e1Structure);
effect1OptionGroup.addControl(e1Sharpen);
effect1OptionGroup.addControl(e1AddFreq);
effect1OptionGroup.addControl(e1Contrast);
closeHolesELable = new GLabel(effectSettings.papplet, 4, 144, 80, 20);
closeHolesELable.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
closeHolesELable.setText("Close holes");
closeHolesELable.setOpaque(false);
line6Label = new GLabel(effectSettings.papplet, 4, 164, 388, 8);
line6Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line6Label.setText("---------------------------------------------------------------------------------------------");
line6Label.setOpaque(false);
snnELabel = new GLabel(effectSettings.papplet, 4, 168, 160, 20);
snnELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
snnELabel.setText("SNN");
snnELabel.setOpaque(false);
line7Label = new GLabel(effectSettings.papplet, 4, 188, 388, 8);
line7Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line7Label.setText("---------------------------------------------------------------------------------------------");
line7Label.setOpaque(false);
unSharpELabel = new GLabel(effectSettings.papplet, 4, 192, 80, 20);
unSharpELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
unSharpELabel.setText("UnSharp");
unSharpELabel.setOpaque(false);
line8Label = new GLabel(effectSettings.papplet, 4, 212, 388, 8);
line8Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line8Label.setText("---------------------------------------------------------------------------------------------");
line8Label.setOpaque(false);
highPassELabel = new GLabel(effectSettings.papplet, 4, 216, 80, 20);
highPassELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
highPassELabel.setText("High Pass");
highPassELabel.setOpaque(false);
line9Label = new GLabel(effectSettings.papplet, 4, 236, 388, 8);
line9Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line9Label.setText("---------------------------------------------------------------------------------------------");
line9Label.setOpaque(false);
highPassColorELabel = new GLabel(effectSettings.papplet, 4, 240, 104, 20);
highPassColorELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
highPassColorELabel.setText("High Pass Color");
highPassColorELabel.setOpaque(false);
line10Label = new GLabel(effectSettings.papplet, 4, 260, 388, 8);
line10Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line10Label.setText("---------------------------------------------------------------------------------------------");
line10Label.setOpaque(false);
structureELabel = new GLabel(effectSettings.papplet, 4, 264, 80, 20);
structureELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
structureELabel.setText("Structure");
structureELabel.setOpaque(false);
line11Label = new GLabel(effectSettings.papplet, 4, 284, 388, 8);
line11Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line11Label.setText("---------------------------------------------------------------------------------------------");
line11Label.setOpaque(false);
sharpenELabel = new GLabel(effectSettings.papplet, 4, 288, 80, 20);
sharpenELabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
sharpenELabel.setText("Sharpen");
sharpenELabel.setOpaque(false);
line12Label = new GLabel(effectSettings.papplet, 4, 308, 392, 8);
line12Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line12Label.setText("---------------------------------------------------------------------------------------------");
line12Label.setOpaque(false);
addFreqLabel = new GLabel(effectSettings.papplet, 4, 312, 116, 20);
addFreqLabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
addFreqLabel.setText("Add Frequencies");
addFreqLabel.setOpaque(false);
effect2OptionGroup = new GToggleGroup();
e2Normal = new GOption(effectSettings.papplet, 164, 28, 40, 20);
e2Normal.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Normal.setOpaque(false);
e2Normal.addEventHandler(this, "e2Normal_clicked");
e2Blur = new GOption(effectSettings.papplet, 164, 52, 32, 20);
e2Blur.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Blur.setOpaque(false);
e2Blur.addEventHandler(this, "e2Blur_clicked");
e2Posterize = new GOption(effectSettings.papplet, 164, 76, 48, 20);
e2Posterize.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Posterize.setOpaque(false);
e2Posterize.addEventHandler(this, "e2Posterize_clicked");
e2Erode = new GOption(effectSettings.papplet, 164, 100, 40, 20);
e2Erode.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Erode.setOpaque(false);
e2Erode.addEventHandler(this, "e2Erode_clicked");
e2Dilate = new GOption(effectSettings.papplet, 164, 124, 36, 20);
e2Dilate.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Dilate.setOpaque(false);
e2Dilate.addEventHandler(this, "esDialate_clicked");
e2CloseHoles = new GOption(effectSettings.papplet, 164, 148, 44, 20);
e2CloseHoles.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2CloseHoles.setOpaque(false);
e2CloseHoles.addEventHandler(this, "e2CloseHoles_clicked");
e2SNN = new GOption(effectSettings.papplet, 164, 172, 32, 20);
e2SNN.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2SNN.setOpaque(false);
e2SNN.addEventHandler(this, "e2SNN_clicked");
e2UnSharp = new GOption(effectSettings.papplet, 164, 196, 44, 20);
e2UnSharp.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2UnSharp.setOpaque(false);
e2UnSharp.addEventHandler(this, "e2UnSharp_clicked");
e2HighPass = new GOption(effectSettings.papplet, 164, 220, 40, 20);
e2HighPass.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2HighPass.setOpaque(false);
e2HighPass.addEventHandler(this, "e2HighPass_clicked");
e2HighPassColor = new GOption(effectSettings.papplet, 164, 244, 48, 20);
e2HighPassColor.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2HighPassColor.setOpaque(false);
e2HighPassColor.addEventHandler(this, "e2HighPassColor_clicked");
e2Structure = new GOption(effectSettings.papplet, 164, 268, 44, 20);
e2Structure.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Structure.setOpaque(false);
e2Structure.addEventHandler(this, "e2Structure_clicked");
e2Sharpen = new GOption(effectSettings.papplet, 164, 292, 52, 20);
e2Sharpen.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Sharpen.setOpaque(false);
e2Sharpen.addEventHandler(this, "e2Sharpen_clicked");
e2AddFreq = new GOption(effectSettings.papplet, 164, 312, 32, 20);
e2AddFreq.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2AddFreq.setOpaque(false);
e2AddFreq.addEventHandler(this, "e2AddFreq_clicked");
e2Contrast = new GOption(effectSettings.papplet, 164, 336, 32, 20);
e2Contrast.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e2Contrast.setOpaque(false);
e2Contrast.addEventHandler(this, "e2Contrast_clicked");
effect2OptionGroup.addControl(e2Normal);
e2Normal.setSelected(true);
effect2OptionGroup.addControl(e2Blur);
effect2OptionGroup.addControl(e2Posterize);
effect2OptionGroup.addControl(e2Erode);
effect2OptionGroup.addControl(e2Dilate);
effect2OptionGroup.addControl(e2CloseHoles);
effect2OptionGroup.addControl(e2SNN);
effect2OptionGroup.addControl(e2UnSharp);
effect2OptionGroup.addControl(e2HighPass);
effect2OptionGroup.addControl(e2HighPassColor);
effect2OptionGroup.addControl(e2Structure);
effect2OptionGroup.addControl(e2Sharpen);
effect2OptionGroup.addControl(e2AddFreq);
effect2OptionGroup.addControl(e2Contrast);
effect3OptionGroup = new GToggleGroup();
e3Normal = new GOption(effectSettings.papplet, 216, 28, 36, 20);
e3Normal.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Normal.setOpaque(false);
e3Normal.addEventHandler(this, "e3Normal_clicked");
e3Blur = new GOption(effectSettings.papplet, 216, 52, 44, 20);
e3Blur.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Blur.setOpaque(false);
e3Blur.addEventHandler(this, "e3Blur_clicked");
e3Posterize = new GOption(effectSettings.papplet, 216, 76, 44, 20);
e3Posterize.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Posterize.setOpaque(false);
e3Posterize.addEventHandler(this, "e3Posterize_clicked");
e3Erode = new GOption(effectSettings.papplet, 216, 100, 44, 20);
e3Erode.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Erode.setOpaque(false);
e3Erode.addEventHandler(this, "e3Erode_clicked");
e3Dilate = new GOption(effectSettings.papplet, 216, 124, 44, 20);
e3Dilate.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Dilate.setOpaque(false);
e3Dilate.addEventHandler(this, "e3Dilate_clicked");
e3CloseHoles = new GOption(effectSettings.papplet, 216, 148, 44, 20);
e3CloseHoles.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3CloseHoles.setOpaque(false);
e3CloseHoles.addEventHandler(this, "e3CloseHoles_clicked");
e3SNN = new GOption(effectSettings.papplet, 216, 172, 36, 20);
e3SNN.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3SNN.setOpaque(false);
e3SNN.addEventHandler(this, "e3SNN_clicked");
e3UnSharp = new GOption(effectSettings.papplet, 216, 196, 40, 20);
e3UnSharp.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3UnSharp.setOpaque(false);
e3UnSharp.addEventHandler(this, "e3UnSharp_clicked");
e3HighPass = new GOption(effectSettings.papplet, 216, 220, 36, 20);
e3HighPass.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3HighPass.setOpaque(false);
e3HighPass.addEventHandler(this, "e3HighPass_clicked");
e3HighPassColor = new GOption(effectSettings.papplet, 216, 244, 36, 20);
e3HighPassColor.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3HighPassColor.setOpaque(false);
e3HighPassColor.addEventHandler(this, "e3HighPassColor_clicked");
e3Structure = new GOption(effectSettings.papplet, 216, 268, 44, 20);
e3Structure.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Structure.setOpaque(false);
e3Structure.addEventHandler(this, "e3Structure_clicked");
e3Sharpen = new GOption(effectSettings.papplet, 216, 292, 44, 20);
e3Sharpen.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Sharpen.setOpaque(false);
e3Sharpen.addEventHandler(this, "e3Sharpen_clicked");
e3AddFreq = new GOption(effectSettings.papplet, 216, 312, 44, 20);
e3AddFreq.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3AddFreq.setOpaque(false);
e3AddFreq.addEventHandler(this, "e3AddFreq_clicked");
e3Contrast = new GOption(effectSettings.papplet, 216, 336, 36, 20);
e3Contrast.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e3Contrast.setOpaque(false);
e3Contrast.addEventHandler(this, "e3Contrast_clicked");
effect3OptionGroup.addControl(e3Normal);
e3Normal.setSelected(true);
effect3OptionGroup.addControl(e3Blur);
effect3OptionGroup.addControl(e3Posterize);
effect3OptionGroup.addControl(e3Erode);
effect3OptionGroup.addControl(e3Dilate);
effect3OptionGroup.addControl(e3CloseHoles);
effect3OptionGroup.addControl(e3SNN);
effect3OptionGroup.addControl(e3UnSharp);
effect3OptionGroup.addControl(e3HighPass);
effect3OptionGroup.addControl(e3HighPassColor);
effect3OptionGroup.addControl(e3Structure);
effect3OptionGroup.addControl(e3Sharpen);
effect3OptionGroup.addControl(e3AddFreq);
effect3OptionGroup.addControl(e3Contrast);
effectSettingsClose = new GButton(effectSettings.papplet, 164, 432, 80, 30);
effectSettingsClose.setText("Close");
effectSettingsClose.setTextBold();
effectSettingsClose.addEventHandler(this, "effectSettingsClose_click");
effectSettingsAdjustments = new GButton(effectSettings.papplet, 8, 392, 148, 30);
effectSettingsAdjustments.setText("Filter Adjustments");
effectSettingsAdjustments.setTextBold();
effectSettingsAdjustments.addEventHandler(this, "effectSettingsAdjustment_click");
effect4Label = new GLabel(effectSettings.papplet, 256, 4, 52, 20);
effect4Label.setText("Filter 4");
effect4Label.setOpaque(false);
effect4OptionGroup = new GToggleGroup();
e4Normal = new GOption(effectSettings.papplet, 268, 28, 32, 20);
e4Normal.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Normal.setOpaque(false);
e4Normal.addEventHandler(this, "e4Normal_clicked");
e4Blur = new GOption(effectSettings.papplet, 268, 52, 32, 20);
e4Blur.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Blur.setOpaque(false);
e4Blur.addEventHandler(this, "e4Blur_clicked");
e4Posterize = new GOption(effectSettings.papplet, 268, 76, 32, 20);
e4Posterize.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Posterize.setOpaque(false);
e4Posterize.addEventHandler(this, "e4Posterized_clicked");
e4Erode = new GOption(effectSettings.papplet, 268, 100, 32, 20);
e4Erode.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Erode.setOpaque(false);
e4Erode.addEventHandler(this, "e4Erode_clicked");
e4Dilate = new GOption(effectSettings.papplet, 268, 124, 32, 20);
e4Dilate.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Dilate.setOpaque(false);
e4Dilate.addEventHandler(this, "e4Dilate_clicked");
e4CloseHoles = new GOption(effectSettings.papplet, 268, 148, 32, 20);
e4CloseHoles.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4CloseHoles.setOpaque(false);
e4CloseHoles.addEventHandler(this, "e4CloseHoles_clicked");
e4SNN = new GOption(effectSettings.papplet, 268, 172, 32, 20);
e4SNN.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4SNN.setOpaque(false);
e4SNN.addEventHandler(this, "e4SNN_clicked");
e4UnSharp = new GOption(effectSettings.papplet, 268, 196, 32, 20);
e4UnSharp.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4UnSharp.setOpaque(false);
e4UnSharp.addEventHandler(this, "e4UnSharp_clicked");
e4HighPass = new GOption(effectSettings.papplet, 268, 220, 32, 20);
e4HighPass.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4HighPass.setOpaque(false);
e4HighPass.addEventHandler(this, "e4HighPass_clicked");
e4HighPassColor = new GOption(effectSettings.papplet, 268, 244, 32, 20);
e4HighPassColor.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4HighPassColor.setOpaque(false);
e4HighPassColor.addEventHandler(this, "e4HighPassColor_clicked");
e4Structure = new GOption(effectSettings.papplet, 268, 268, 32, 20);
e4Structure.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Structure.setOpaque(false);
e4Structure.addEventHandler(this, "e4Structure_clicked");
e4Sharpen = new GOption(effectSettings.papplet, 268, 292, 32, 20);
e4Sharpen.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Sharpen.setOpaque(false);
e4Sharpen.addEventHandler(this, "e4Sharpen_clicked");
e4AddFreq = new GOption(effectSettings.papplet, 268, 312, 32, 20);
e4AddFreq.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4AddFreq.setOpaque(false);
e4AddFreq.addEventHandler(this, "e4AddFreq_clicked");
e4Contrast = new GOption(effectSettings.papplet, 268, 336, 32, 20);
e4Contrast.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e4Contrast.setOpaque(false);
e4Contrast.addEventHandler(this, "e4Contrast_clicked");
effect4OptionGroup.addControl(e4Normal);
e4Normal.setSelected(true);
effect4OptionGroup.addControl(e4Blur);
effect4OptionGroup.addControl(e4Posterize);
effect4OptionGroup.addControl(e4Erode);
effect4OptionGroup.addControl(e4Dilate);
effect4OptionGroup.addControl(e4CloseHoles);
effect4OptionGroup.addControl(e4SNN);
effect4OptionGroup.addControl(e4UnSharp);
effect4OptionGroup.addControl(e4HighPass);
effect4OptionGroup.addControl(e4HighPassColor);
effect4OptionGroup.addControl(e4Structure);
effect4OptionGroup.addControl(e4Sharpen);
effect4OptionGroup.addControl(e4AddFreq);
effect4OptionGroup.addControl(e4Contrast);
filterSaveButton = new GButton(effectSettings.papplet, 164, 392, 80, 30);
filterSaveButton.setText("Save");
filterSaveButton.setTextBold();
filterSaveButton.addEventHandler(this, "filterSaveButton_click");
loadFilterButton = new GButton(effectSettings.papplet, 256, 392, 80, 30);
loadFilterButton.setText("Load");
loadFilterButton.setTextBold();
loadFilterButton.addEventHandler(this, "loadFilterButton_click");
contrastLabel = new GLabel(effectSettings.papplet, 4, 336, 132, 20);
contrastLabel.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
contrastLabel.setText("ContrastBrightness");
contrastLabel.setOpaque(false);
line13Label = new GLabel(effectSettings.papplet, 4, 332, 388, 8);
line13Label.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
line13Label.setText("---------------------------------------------------------------------------------------------");
line13Label.setOpaque(false);
filter5Label = new GLabel(effectSettings.papplet, 308, 4, 52, 20);
filter5Label.setText("Filter 5");
filter5Label.setOpaque(false);
effect5OptionGroup = new GToggleGroup();
e5Normal = new GOption(effectSettings.papplet, 320, 28, 32, 20);
e5Normal.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Normal.setOpaque(false);
e5Normal.addEventHandler(this, "e5Normal_clicked");
e5Blur = new GOption(effectSettings.papplet, 320, 52, 32, 20);
e5Blur.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Blur.setOpaque(false);
e5Blur.addEventHandler(this, "e5Blur_clicked");
e5Posterize = new GOption(effectSettings.papplet, 320, 76, 32, 20);
e5Posterize.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Posterize.setOpaque(false);
e5Posterize.addEventHandler(this, "e5Posterize_clicked");
e5Erode = new GOption(effectSettings.papplet, 320, 100, 32, 20);
e5Erode.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Erode.setOpaque(false);
e5Erode.addEventHandler(this, "e5Erode_clicked");
e5Dilate = new GOption(effectSettings.papplet, 320, 124, 28, 20);
e5Dilate.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Dilate.setOpaque(false);
e5Dilate.addEventHandler(this, "e5Dilate_clicked");
e5CloseHoles = new GOption(effectSettings.papplet, 320, 148, 32, 20);
e5CloseHoles.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5CloseHoles.setOpaque(false);
e5CloseHoles.addEventHandler(this, "e5CloseHoles_clicked");
e5SNN = new GOption(effectSettings.papplet, 320, 172, 32, 20);
e5SNN.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5SNN.setOpaque(false);
e5SNN.addEventHandler(this, "e5Snn_clicked");
e5UnSharp = new GOption(effectSettings.papplet, 320, 196, 40, 20);
e5UnSharp.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5UnSharp.setOpaque(false);
e5UnSharp.addEventHandler(this, "e5UnSharp_clicked");
e5HighPass = new GOption(effectSettings.papplet, 320, 220, 36, 20);
e5HighPass.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5HighPass.setOpaque(false);
e5HighPass.addEventHandler(this, "e5HighPass_clicked");
e5HighPassColor = new GOption(effectSettings.papplet, 320, 244, 40, 20);
e5HighPassColor.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5HighPassColor.setOpaque(false);
e5HighPassColor.addEventHandler(this, "e5HighPassColor_clicked");
e5Structure = new GOption(effectSettings.papplet, 320, 268, 36, 20);
e5Structure.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Structure.setOpaque(false);
e5Structure.addEventHandler(this, "e5Structure_clicked");
e5Sharpen = new GOption(effectSettings.papplet, 320, 292, 36, 16);
e5Sharpen.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Sharpen.setOpaque(false);
e5Sharpen.addEventHandler(this, "e5Sharpen_clicked");
e5AddFreq = new GOption(effectSettings.papplet, 320, 312, 32, 20);
e5AddFreq.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5AddFreq.setOpaque(false);
e5AddFreq.addEventHandler(this, "e5AddFreq_clicked");
e5Contrast = new GOption(effectSettings.papplet, 320, 336, 32, 20);
e5Contrast.setTextAlign(GAlign.LEFT, GAlign.MIDDLE);
e5Contrast.setOpaque(false);
e5Contrast.addEventHandler(this, "e5Contrast_clicked");
effect5OptionGroup.addControl(e5Normal);
e5Normal.setSelected(true);
effect5OptionGroup.addControl(e5Blur);
effect5OptionGroup.addControl(e5Posterize);
effect5OptionGroup.addControl(e5Erode);
effect5OptionGroup.addControl(e5Dilate);
effect5OptionGroup.addControl(e5CloseHoles);
effect5OptionGroup.addControl(e5SNN);
effect5OptionGroup.addControl(e5UnSharp);
effect5OptionGroup.addControl(e5HighPass);
effect5OptionGroup.addControl(e5HighPassColor);
effect5OptionGroup.addControl(e5Structure);
effect5OptionGroup.addControl(e5Sharpen);
effect5OptionGroup.addControl(e5AddFreq);
effect5OptionGroup.addControl(e5Contrast);
}
// Variable declarations
// autogenerated do not edit
GWindow scrSettings;
GSlider blurSlider;
GLabel labelBlur;
GSlider sharpSlider;
GLabel labelSharp;
GSlider erodeSlider;
GLabel labelErode;
GSlider dilateSlider;
GLabel labelDilate;
GSlider posterizeSlider;
GLabel labelPosterize;
GButton buttonAccept;
GToggleGroup splitMethodGroup;
GLabel usharpLabel;
GSlider uSharpSlider;
GSlider HContrastSlider;
GLabel HContrastLabel;
GSlider HBrightnessSlider;
GLabel HBrightnessLabel;
GLabel LContrastLabel;
GSlider LContrastSlider;
GSlider LBrightnessSlider;
GLabel LBrightnessLabel;
GSlider hiPassSlider;
GLabel hiPassLable;
GSlider snnAmountslider;
GLabel snnAmountLabel;
GLabel structureRadiusLabel;
GLabel structureContrasLabel;
GSlider structureRadiusSlider;
GSlider structureContrastSlider;
GToggleGroup filterChoice;
GOption chooseF1;
GOption chooseF2;
GOption chooseF3;
GOption chooseF4;
GOption chooseF5;
GSlider contrastSlider;
GLabel scrContrastLabel;
GSlider brightnessSlider;
GLabel brightnessLabel;
GWindow SplitSettings;
GToggleGroup SplitMethods;
GOption kuwaharSplitOption;
GOption snnSplitOption;
GOption blurSplitOption;
GOption MedianSplitOption;
GOption ColorSplitOption;
GSlider kuwaharaSplitSlider;
GSlider snnSplitSlider;
GSlider blurSplitSlider;
GSlider medianSplitSlider;
GSlider colorSplitSlider;
GButton splitSettingsCloseButton;
GWindow toolSettings;
GLabel darkerLabel;
GLabel lighterLabel;
GLabel paintLabel;
GSlider paintSlider;
GLabel cloneLabel;
GSlider cloneSlider;
GLabel blurLabel;
GSlider blurToolSlider;
GLabel onColorlabel;
GSlider onColorSlider;
GButton toolsCloseButton;
GWindow effectSettings;
GLabel effect1Label;
GLabel effect2Label;
GLabel effect3Label;
GLabel normalELabel;
GLabel line1Label;
GLabel blurELabel;
GLabel line2Label;
GLabel posterizeELabel;
GLabel line3Label;
GLabel erodeELabel;
GLabel line4Label;
GLabel dialateELabel;
GLabel line5Label;
GToggleGroup effect1OptionGroup;
GOption e1Normal;
GOption e1Blur;
GOption e1Posterize;
GOption e1Erode;
GOption e1Dilate;
GOption e1CloseHoles;
GOption e1SNN;
GOption e1UnSharp;
GOption e1HighPass;
GOption e1HighPassColor;
GOption e1Structure;
GOption e1Sharpen;
GOption e1AddFreq;
GOption e1Contrast;
GLabel closeHolesELable;
GLabel line6Label;
GLabel snnELabel;
GLabel line7Label;
GLabel unSharpELabel;
GLabel line8Label;
GLabel highPassELabel;
GLabel line9Label;
GLabel highPassColorELabel;
GLabel line10Label;
GLabel structureELabel;
GLabel line11Label;
GLabel sharpenELabel;
GLabel line12Label;
GLabel addFreqLabel;
GToggleGroup effect2OptionGroup;
GOption e2Normal;
GOption e2Blur;
GOption e2Posterize;
GOption e2Erode;
GOption e2Dilate;
GOption e2CloseHoles;
GOption e2SNN;
GOption e2UnSharp;
GOption e2HighPass;
GOption e2HighPassColor;
GOption e2Structure;
GOption e2Sharpen;
GOption e2AddFreq;
GOption e2Contrast;
GToggleGroup effect3OptionGroup;
GOption e3Normal;
GOption e3Blur;
GOption e3Posterize;
GOption e3Erode;
GOption e3Dilate;
GOption e3CloseHoles;
GOption e3SNN;
GOption e3UnSharp;
GOption e3HighPass;
GOption e3HighPassColor;
GOption e3Structure;
GOption e3Sharpen;
GOption e3AddFreq;
GOption e3Contrast;
GButton effectSettingsClose;
GButton effectSettingsAdjustments;
GLabel effect4Label;
GToggleGroup effect4OptionGroup;
GOption e4Normal;
GOption e4Blur;
GOption e4Posterize;
GOption e4Erode;
GOption e4Dilate;
GOption e4CloseHoles;
GOption e4SNN;
GOption e4UnSharp;
GOption e4HighPass;
GOption e4HighPassColor;
GOption e4Structure;
GOption e4Sharpen;
GOption e4AddFreq;
GOption e4Contrast;
GButton filterSaveButton;
GButton loadFilterButton;
GLabel contrastLabel;
GLabel line13Label;
GLabel filter5Label;
GToggleGroup effect5OptionGroup;
GOption e5Normal;
GOption e5Blur;
GOption e5Posterize;
GOption e5Erode;
GOption e5Dilate;
GOption e5CloseHoles;
GOption e5SNN;
GOption e5UnSharp;
GOption e5HighPass;
GOption e5HighPassColor;
GOption e5Structure;
GOption e5Sharpen;
GOption e5AddFreq;
GOption e5Contrast;
/////////////////////////////////////////// menu
MenuBar myMenu;
Menu fileMenu,viewMenu,freqMenu,clipMenu,filterMenu,toolMenu;
MenuItem fileLoad,fileSave,viewOpen,viewClose,viewFlip,freqSplit, freqJoin,freqHigh,freqLow, splitBlur,splitMed,
splitPref,clipCopy,clipPaste,filterAdjustments,filterSelection,toolPaint,toolClone,toolOnColor,toolBlur,toolStrength;
myMenuListener menuListen;
void menu_setup(){
//this doesn't demonstrate best coding practice, just a simple method
//create the MenuBar Object
menuListen = new myMenuListener();
myMenu = new MenuBar();
//create the top level button
fileMenu = new Menu("File");
viewMenu = new Menu("View");
freqMenu = new Menu ("Frequency");
// freqSMenu = new Menu("Frequency Split");
clipMenu = new Menu("Clip Board");
filterMenu = new Menu("Filters");
toolMenu = new Menu("Tool");
//create all the Menu Items and add the menuListener to check their state.
fileLoad = new MenuItem("Load Layer");
fileLoad.addActionListener(menuListen);
fileSave = new MenuItem("Save Layer");
fileSave.addActionListener(menuListen);
viewOpen = new MenuItem("View Open");
viewOpen.addActionListener(menuListen);
viewClose = new MenuItem("View Close");
viewClose.addActionListener(menuListen);
viewFlip = new MenuItem("Flip View");
viewFlip.addActionListener(menuListen);
freqSplit = new MenuItem("Split Frequencies");
freqSplit.addActionListener(menuListen);
freqJoin = new MenuItem("Join Frequencies");
freqJoin.addActionListener(menuListen);
freqJoin.setEnabled(false);
freqHigh = new MenuItem("High Frequency");
freqHigh.addActionListener(menuListen);
freqHigh.setEnabled(false);
freqLow = new MenuItem("Low Frequency");
freqLow.addActionListener(menuListen);
freqLow.setEnabled(false);
splitPref = new MenuItem("Frequency settings");
splitPref.addActionListener(menuListen);
splitBlur = new MenuItem("Blur");
splitBlur.addActionListener(menuListen);
splitMed = new MenuItem("Median");
splitMed.addActionListener(menuListen);
clipCopy = new MenuItem("Copy");
clipCopy.addActionListener(menuListen);
clipPaste = new MenuItem("Paste");
clipPaste.addActionListener(menuListen);
filterAdjustments = new MenuItem("Filter Adjustments");
filterAdjustments.addActionListener(menuListen);
filterSelection = new MenuItem("Filter Selection");
filterSelection.addActionListener(menuListen);
toolPaint = new MenuItem("Paint");
toolPaint.addActionListener(menuListen);
toolPaint.setEnabled(false);
toolClone = new MenuItem("Clone");
toolClone.addActionListener(menuListen);
toolOnColor = new MenuItem("Draw on Color");
toolOnColor.addActionListener(menuListen);
toolBlur = new MenuItem("Blur");
toolBlur.addActionListener(menuListen);
toolStrength = new MenuItem("Tool Settings");
toolStrength.addActionListener(menuListen);
fileMenu.add(fileLoad);
fileMenu.add(fileSave);
viewMenu.add(viewOpen);
viewMenu.add(viewClose);
viewMenu.addSeparator();
viewMenu.add(viewFlip);
freqMenu.add(freqSplit);
freqMenu.add(freqJoin);
freqMenu.addSeparator();
freqMenu.add(freqHigh);
freqMenu.add(freqLow);
freqMenu.addSeparator();
freqMenu.add(splitPref);
//freqSMenu.add(splitBlur);
// freqSMenu.add(splitMed);
clipMenu.add(clipCopy);
clipMenu.add(clipPaste);
filterMenu.add(filterSelection);
filterMenu.add(filterAdjustments);
toolMenu.add(toolPaint);
toolMenu.add(toolClone);
toolMenu.add(toolOnColor);
toolMenu.add(toolBlur);
toolMenu.addSeparator();
toolMenu.add(toolStrength);
// add the button to the menu
myMenu.add(fileMenu);
myMenu.add(viewMenu);
myMenu.add(freqMenu);
myMenu.add(clipMenu);
myMenu.add(filterMenu);
myMenu.add(toolMenu);
//add the menu to the frame!
frame.setMenuBar(myMenu);
}
class myMenuListener implements ActionListener,ItemListener{
myMenuListener(){
}
public void actionPerformed(ActionEvent e) {
MenuItem source = (MenuItem)(e.getSource());
String s = "Action event detected."
+ " Event source: " + source.getLabel()
+ " (an instance of " + getClassName(source) + ")";
// println(s);
if(source.equals(filterAdjustments)){
scrSettings.setVisible(true);
frame.toFront();
}
if(source.equals(filterSelection)){
effectSettings.setVisible(true);
frame.toFront();
}
if(source.equals(splitPref)){
SplitSettings.setVisible(true);
frame.toFront();
}
if(source.equals(toolStrength)){
toolSettings.setVisible(true);
frame.toFront();
}
//if(source.equals(clipCopy)){
// copy_layer();
//}
//if(source.equals(clipPaste)){
// paste_layer();
//}
if(source.equals(toolClone)){
currentMode = cloneMode;
previousMode = cloneMode;
C1set = false;
C2set = false;
// PaintTool = CLONE;
previousCursor = CROSS;
cursor(CROSS);
toolClone.setEnabled(false);
toolPaint.setEnabled(true);
toolOnColor.setEnabled(true);
toolBlur.setEnabled(true);
updateInfo();
}
if(source.equals(toolPaint)){
currentMode = drawingMode;
previousMode = drawingMode;
// PaintTool = PAINT;
previousCursor = ARROW;
cursor(ARROW);
toolClone.setEnabled(true);
toolOnColor.setEnabled(true);
toolPaint.setEnabled(false);
toolBlur.setEnabled(true);
updateInfo();
}
if(source.equals(toolOnColor)){
currentMode = onColorMode;
previousMode =onColorMode;
previousCursor = ARROW;
cursor(ARROW);
toolClone.setEnabled(true);
toolPaint.setEnabled(true);
toolOnColor.setEnabled(false);
toolBlur.setEnabled(true);
updateInfo();
}
if(source.equals(toolBlur)){
currentMode = blurMode;
previousMode =blurMode;
previousCursor = ARROW;
cursor(ARROW);
toolClone.setEnabled(true);
toolPaint.setEnabled(true);
toolOnColor.setEnabled(true);
toolBlur.setEnabled(false);
updateInfo();
}
if(source.equals(freqSplit)){
separate_frequencies();
freqSplit.setEnabled(false);
freqJoin.setEnabled(true);
freqHigh.setEnabled(true);
frequencyMode = LFREQ;
e1AddFreq.setVisible(true);
e2AddFreq.setVisible(true);
e3AddFreq.setVisible(true);
e4AddFreq.setVisible(true);
e5AddFreq.setVisible(true);
ScreenSaved= false;
}
if(source.equals(freqJoin)){
rejoin_frequencies();
freqSplit.setEnabled(true);
freqJoin.setEnabled(false);
frequencyMode = JOINED;
freqHigh.setEnabled(false);
freqLow.setEnabled(false);
if(filters[0] == addFreqE){
filters[0]= normalE;
e1Normal.setSelected(true);
}
if(filters[1] == addFreqE){
filters[1]= normalE;
e2Normal.setSelected(true);
}
if(filters[2] == addFreqE){
filters[2]= normalE;
e3Normal.setSelected(true);
}
if(filters[3] == addFreqE){
filters[3]= normalE;
e4Normal.setSelected(true);
}
if(filters[4] == addFreqE){
filters[4]= normalE;
e5Normal.setSelected(true);
}
e1AddFreq.setVisible(false);
e2AddFreq.setVisible(false);
e3AddFreq.setVisible(false);
e4AddFreq.setVisible(false);
e5AddFreq.setVisible(false);
// if(currentFE == AddFreqFE){
// currentFE = NormalFE;
// drawNoFirst.setState(true);
// drawHighFreq.setState(false);
// SCR_SELECTED = drawNoFirst;
// }
ScreenSaved= false;
}
if(source.equals(freqHigh)){
high_frequency();
freqLow.setEnabled(true);
freqHigh.setEnabled(false);
frequencyMode = HFREQ;
ScreenSaved= false;
}
if(source.equals(freqLow)){
low_frequency();
freqLow.setEnabled(false);
freqHigh.setEnabled(true);
frequencyMode = LFREQ;
ScreenSaved= false;
}
if(source.equals(fileLoad)){
load_image();
}
if(source.equals(fileSave)){
save_layer();
}
}
public void itemStateChanged(ItemEvent e) {
MenuItem source = (MenuItem)(e.getSource());
String s = "Item event detected."
+ " Event source: " + source.getLabel()
+ " (an instance of " + getClassName(source) + ")"
+ " New state: "
+ ((e.getStateChange() == ItemEvent.SELECTED) ?
"selected":"unselected");
// println(s);
}
}
//gets the class name of an object
protected String getClassName(Object o) {
String classString = o.getClass().getName();
int dotIndex = classString.lastIndexOf(".");
return classString.substring(dotIndex+1);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment