import java.awt.*;
/*
JiglDemo is an applet that demonstrates the abilities and functionality
of
the JIGL library. It is meant to be changed to reflect
additions or changes
to JIGL. JiglDemo was written to allow new features of
JIGL to be easily and quickly
added to the application for testing. The following basic
structure can be used to
add features:
- add a MenuItem (or Menu, if necessary) to
MainWindow menu bar
- add a dialog, if necessary, to the project
that will get user input
- add an appropriate method to ImagePanel
to perform the new feature
- in MainWindow's actionPerformed method,
catch action on that menu item
and start the dialog, if necessary,
or call the method in ImagePanel
- if a dialog was used, catch that dialog's
windowClosing event in MainWindow's
windowClosing method, and call the new
method added to ImagePanel
The process is fairly repetitive, and much of the code can be
copied from existing features.
This class just starts and stops the application window.
The window frame is the MainWindow
class, and it contains an ImagePanel object that does most of
the work. The MainWindow mostly
just monitors user actions, launches appropriate dialog boxes,
and passes information along from
the dialogs to the ImagePanel.
Author: Nathan Moon
Date: 18-May-99
*/
public class JiglDemo extends java.applet.Applet
{
public static final int MAX_IMAGES = 6;
public static final int MAIN_HEIGHT = 350;
public static final int MAIN_WIDTH = 550;
public static final int MAIN_MAX_HEIGHT = 800;
public static final int MAIN_MAX_WIDTH = 800;
protected MainWindow m_mainWindow = null;
public void init()
{
System.out.println("called init\n");
m_mainWindow = new MainWindow(MAX_IMAGES);
}
/**public void start()
called when applet's page is loaded (or reloaded)
*/
public void start()
{
System.out.println("called start\n");
if (m_mainWindow != null){
m_mainWindow.dispose();
m_mainWindow = null;
}
m_mainWindow = new MainWindow(MAX_IMAGES);
m_mainWindow.setSize(MAIN_WIDTH,MAIN_HEIGHT);
m_mainWindow.setVisible(true);
}
/** public void stop()
called when applet's page is unloaded (user browses to
other page or closes browser)
*/
public void stop()
{
System.out.println("called stop\n");
m_mainWindow.setVisible(false);
}
}
/**********
FILE MainWindow.java
**********/
import jigl.gui.CloseableFrame;
import java.awt.event.*;
import java.awt.*;
import jigl.image.*;
import jigl.image.utils.ImageGenerator;
/*
// header - edit "Data/yourJavaHeader" to customize
// contents - edit "EventHandlers/Java file/onCreate" to customize
//
*/
/**
MainWindow holds the Panel that displays the images, the status
bar,
the menu bar, etc. Acts as a message relayer.
*/
class MainWindow extends CloseableFrame implements ActionListener
{
//ImagePanel holds and displays the images
protected ImagePanel m_imagePanel = null;
//panel for status bar messages
protected StatusPanel m_statusPanel = null;
//TODO: put clip in levelops?? convolve in utilities??
add fft to utilities???
//menu bar
protected MenuBar m_menuBar = null;
protected Menu m_menuFile, m_menuEdit, m_menuBasicOps, m_menuLevelOps,
m_menuMorph, m_menuWarp, m_menuUtils, m_menuROI;
protected MenuItem m_miNew, m_miOpenGray, m_miOpenColor, m_miClose,
m_miQuit, m_miLoad,//file menu items
m_miUndo, m_miCopy, m_miCut, m_miPaste, m_miZoomIn, m_miZoomOut,//edit
menu items
m_miClip, m_miConvolve,
m_miAddImg, m_miSubImg, m_miMultImg, m_miDivImg,//basic operations menu
items
m_miNeg, m_miThresh,
m_miScale, m_miWindow,//level operations menu items
m_miDilate, m_miErode,
m_miOpenMorph, m_miCloseMorph, //morphology menu items
m_miTrans, m_miRot,
m_miResize,//warp menu items
m_miNoise,//utilities
menu items
m_miSetROI, m_miClearROI;//region
of interest menu items
//constructor
public MainWindow(int maxImages)
{
setLayout(new BorderLayout(20,20));
setBackground(Color.lightGray);
setTitle("Jigl Demonstration Application");
m_menuBar = new MenuBar();
setMenuBar(m_menuBar);
m_statusPanel = new StatusPanel();
add(m_statusPanel,BorderLayout.SOUTH);
m_statusPanel.setROI(null);//no ROI selected
m_statusPanel.setText("Welcome to the JIGL Example Program!");
ScrollPane scroll = new ScrollPane(ScrollPane.SCROLLBARS_AS_NEEDED);
m_imagePanel = new ImagePanel(this,maxImages);
scroll.add(m_imagePanel);
add(scroll,BorderLayout.CENTER);
// add(m_imagePanel,BorderLayout.CENTER);
//Set up the font for the menu bar
Font font=new Font("JIGL font",Font.PLAIN, 10);
m_menuBar.setFont(font);
//Build the file menu
m_menuFile = new Menu("File", true);
m_menuBar.add(m_menuFile);
m_miOpenGray = new MenuItem("Open Sample GrayImage");
m_menuFile.add(m_miOpenGray);
m_miOpenColor = new MenuItem("Open Sample ColorImage");
m_menuFile.add(m_miOpenColor);
m_miNew = new MenuItem("Create a New Image...");
m_menuFile.add(m_miNew);
m_miLoad = new MenuItem("Load an image from a URL...");
m_menuFile.add(m_miLoad);
m_miClose = new MenuItem("Close");
m_menuFile.add(m_miClose);
m_menuFile.addSeparator();
m_miQuit = new MenuItem("Quit");
m_menuFile.add(m_miQuit);
/* these file menu items can be used
if this is an application rather than an applet
m_miNew = new MenuItem("New...");
m_menuFile.add(m_miNew);
m_miQuit = new MenuItem("Open...");
m_miQuit.setShortcut(new MenuShortcut(KeyEvent.VK_O));
m_menuFile.add(m_miQuit);
m_miOpen = new MenuItem("Close");
m_menuFile.add(m_miOpen);
m_miClose = new MenuItem("Save...");
m_menuFile.add(m_miClose);
m_menuFile.addSeparator();
m_miSave = new MenuItem("Quit");
m_menuFile.add(m_miSave);
*/
//Build the edit menu.
m_menuEdit = new Menu("Edit");
m_menuBar.add(m_menuEdit);
m_miUndo = new MenuItem("Undo");
m_menuEdit.add(m_miUndo);
m_menuEdit.addSeparator();
m_miCopy = new MenuItem("Copy");
m_menuEdit.add(m_miCopy);
m_miCut = new MenuItem("Cut");
m_menuEdit.add(m_miCut);
m_miPaste = new MenuItem ("Paste");
m_menuEdit.add(m_miPaste);
m_menuEdit.addSeparator();
m_miZoomIn = new MenuItem("Zoom In");
m_menuEdit.add(m_miZoomIn);
m_miZoomOut = new MenuItem ("Zoom Out");
m_menuEdit.add(m_miZoomOut);
//Build the basic operations menu.
m_menuBasicOps = new Menu("Basic Operations");
m_menuBar.add(m_menuBasicOps);
m_miClip = new MenuItem("Clip...");
m_menuBasicOps.add(m_miClip);
m_miConvolve = new MenuItem("Convolve");
m_menuBasicOps.add(m_miConvolve);
m_menuBasicOps.addSeparator();
m_miAddImg = new MenuItem("Add an image...");
m_menuBasicOps.add(m_miAddImg);
m_miSubImg = new MenuItem("Subtract an image...");
m_menuBasicOps.add(m_miSubImg);
m_miMultImg = new MenuItem("Multiply an image...");
m_menuBasicOps.add(m_miMultImg);
m_miDivImg = new MenuItem("Divide by an image...");
m_menuBasicOps.add(m_miDivImg);
//Build level operations menu.
m_menuLevelOps = new Menu("Level Operations");
m_menuBar.add(m_menuLevelOps);
m_miNeg = new MenuItem("Negate");
m_menuLevelOps.add(m_miNeg);
m_miThresh = new MenuItem("Threshold...");
m_menuLevelOps.add(m_miThresh);
m_miScale = new MenuItem("Scale...");
m_menuLevelOps.add(m_miScale);
m_miWindow = new MenuItem("Window...");
m_menuLevelOps.add(m_miWindow);
//Build the morph menu
m_menuMorph = new Menu("Morphology");
m_menuBar.add(m_menuMorph);
m_miDilate = new MenuItem("Dilate...");
m_menuMorph.add(m_miDilate);
m_miErode = new MenuItem("Erode...");
m_menuMorph.add(m_miErode);
m_miOpenMorph = new MenuItem("Open...");
m_menuMorph.add(m_miOpenMorph);
m_miCloseMorph = new MenuItem("Close...");
m_menuMorph.add(m_miCloseMorph);
//Build the warp menu
m_menuWarp = new Menu("Warping");
m_menuBar.add(m_menuWarp);
m_miTrans = new MenuItem("Translate...");
m_menuWarp.add(m_miTrans);
m_miRot = new MenuItem("Rotate...");
m_menuWarp.add(m_miRot);
m_miResize = new MenuItem("Resize...");
m_menuWarp.add(m_miResize);
//build the utilities menu
m_menuUtils = new Menu("Utilities");
m_menuBar.add(m_menuUtils);
m_miNoise = new MenuItem("Add Noise to image...");
m_menuUtils.add(m_miNoise);
//build the ROI menu
m_menuROI = new Menu("Region of Interest");
m_menuBar.add(m_menuROI);
m_miSetROI = new MenuItem("Set Region of Interest");
m_menuROI.add(m_miSetROI);
m_miClearROI = new MenuItem("Clear Region of Interest");
m_menuROI.add(m_miClearROI);
//Register this main window as an ActionListener
for all menu items.
m_menuFile.addActionListener(this);
m_menuEdit.addActionListener(this);
m_menuBasicOps.addActionListener(this);
m_menuLevelOps.addActionListener(this);
m_menuMorph.addActionListener(this);
m_menuUtils.addActionListener(this);
m_menuROI.addActionListener(this);
m_menuWarp.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
//FILE MENU
if (e.getActionCommand() == "Open Sample GrayImage")
{
m_statusPanel.appendText("\nOpening GrayImage...");
//read in the image
jigl.image.Image image = getURLImage("http://orca.cs.byu.edu/jigl/beta/demoApp/TandL.pgm");
m_statusPanel.setText(m_imagePanel.addImage(image));
sizeToFit();
}
else if (e.getActionCommand()=="Open Sample ColorImage")
{
m_statusPanel.appendText("Opening ColorImage...");
//read in the image
jigl.image.Image image = getURLImage("http://orca.cs.byu.edu/jigl/beta/demoApp/TandL.ppm");
m_statusPanel.setText(m_imagePanel.addImage(image));
sizeToFit();
}
else if (e.getActionCommand()=="Create a New Image...")
{
//start up a NewImageDialog
NewImageDialog dlg = new NewImageDialog(this);
dlg.addWindowListener(this);//so the main widow will know
when the dialog is closed
dlg.show();
}
else if (e.getActionCommand() == "Load an image from a URL...")
{
//start up a LoadImageDialog
LoadImageDialog dlg = new LoadImageDialog(this,LoadImageDialog.TYPE_NEW);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Close")
{
m_statusPanel.appendText("Closing image...");
m_statusPanel.setText(m_imagePanel.closeImage());
sizeToFit();
}
else if (e.getActionCommand()=="Quit")
{
m_statusPanel.appendText("Quitting demo...");
m_statusPanel.setText(m_imagePanel.quit());//allow image
panel to do cleanup??
// JiglDemo.closeGUI();//closes this window (just hides
it really)
this.setVisible(false);
}
//EDIT MENU
else if (e.getActionCommand()=="Undo")
{
m_statusPanel.appendText("Undoing last action...");
m_statusPanel.setText(m_imagePanel.undoCurrent());
}
else if (e.getActionCommand()=="Zoom In")
{
m_statusPanel.appendText("Zooming in...");
m_statusPanel.setText(m_imagePanel.zoomInCurrent());
}
else if (e.getActionCommand()=="Zoom Out")
{
m_statusPanel.appendText("Zooming out...");
m_statusPanel.setText(m_imagePanel.zoomOutCurrent());
}
//BASIC OPERATIONS MENU
else if (e.getActionCommand()=="Clip...")
{
LevelOpDialog dlg = new LevelOpDialog(this,LevelOpDialog.TYPE_CLIP);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Convolve")
{
KernelOpDialog dlg = new KernelOpDialog(this,KernelOpDialog.TYPE_CONVOLVE);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Add an image...")
{
LoadImageDialog dlg = new LoadImageDialog(this,LoadImageDialog.TYPE_ADD);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Subtract an image...")
{
LoadImageDialog dlg = new LoadImageDialog(this,LoadImageDialog.TYPE_SUBTRACT);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Multiply an image...")
{
LoadImageDialog dlg = new LoadImageDialog(this,LoadImageDialog.TYPE_MULTIPLY);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Divide by an image...")
{
LoadImageDialog dlg = new LoadImageDialog(this,LoadImageDialog.TYPE_DIVIDE);
dlg.addWindowListener(this);
dlg.show();
}
//LEVEL OPERATIONS MENU
else if (e.getActionCommand()=="Negate")
{
m_statusPanel.appendText("Negating...");
m_statusPanel.setText(m_imagePanel.negateCurrent());
}
else if (e.getActionCommand()=="Threshold...")
{
LevelOpDialog dlg = new LevelOpDialog(this,LevelOpDialog.TYPE_THRESHOLD);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Scale...")
{
LevelOpDialog dlg = new LevelOpDialog(this,LevelOpDialog.TYPE_SCALE);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Window...")
{
LevelOpDialog dlg = new LevelOpDialog(this,LevelOpDialog.TYPE_WINDOW);
dlg.addWindowListener(this);
dlg.show();
}
//MORPHOLOGY MENU
else if (e.getActionCommand()=="Dilate...")
{
KernelOpDialog dlg = new KernelOpDialog(this,KernelOpDialog.TYPE_DILATE);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Erode...")
{
KernelOpDialog dlg = new KernelOpDialog(this,KernelOpDialog.TYPE_ERODE);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Open...")
{
KernelOpDialog dlg = new KernelOpDialog(this,KernelOpDialog.TYPE_OPEN);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Close...")
{
KernelOpDialog dlg = new KernelOpDialog(this,KernelOpDialog.TYPE_CLOSE);
dlg.addWindowListener(this);
dlg.show();
}
//WARP MENU
else if (e.getActionCommand()=="Resize...")
{
WarpOpDialog dlg = new WarpOpDialog(this,WarpOpDialog.TYPE_RESIZE);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Rotate...")
{
WarpOpDialog dlg = new WarpOpDialog(this,WarpOpDialog.TYPE_ROTATE);
dlg.addWindowListener(this);
dlg.show();
}
else if (e.getActionCommand()=="Translate...")
{
WarpOpDialog dlg = new WarpOpDialog(this,WarpOpDialog.TYPE_TRANSLATE);
dlg.addWindowListener(this);
dlg.show();
}
//UTILITIES MENU
else if (e.getActionCommand()=="Add Noise to image...")
{
NoiseDialog dlg = new NoiseDialog(this);
dlg.addWindowListener(this);
dlg.show();
}
//REGION OF INTEREST MENU
else if (e.getActionCommand()=="Set Region of Interest")
{
m_statusPanel.appendText("Setting the Region of Interest...");
m_statusPanel.setText(m_imagePanel.setROICurrent());
}
else if (e.getActionCommand()=="Clear Region of Interest")
{
m_statusPanel.appendText("Clear Region of Interest");
m_statusPanel.setText(m_imagePanel.clearROICurrent());
}
else
{
m_statusPanel.appendText("Unknown command!!!!!!!!!");
}
}//end actionPerformed()
protected void processNewImageDialog(NewImageDialog dlg)
{
if (dlg.clickedOK())
{
m_statusPanel.setText("Creating new image...");
int width = dlg.getImageWidth();
int height = dlg.getImageHeight();
jigl.image.Image image = null;
if (dlg.getType() == NewImageDialog.UNIFORM)
{
float color = dlg.getColor();
image = ImageGenerator.uniform(width,height,color);
}
else if (dlg.getType() == NewImageDialog.SINUSOIDAL)
{
float freq = dlg.getFrequency();
float phase = dlg.getPhase();
String orientation = dlg.getOrientation();
if (NewImageDialog.HORIZONTAL == orientation)
{
image = ImageGenerator.sinusoid(width,height,ImageGenerator.HORIZONTAL,freq,phase);
}
else//vertical
{
image = ImageGenerator.sinusoid(width,height,ImageGenerator.VERTICAL,freq,phase);
}
}
else if (dlg.getType() == NewImageDialog.GAUSSIAN)
{
float meanX = dlg.getMeanX();
float meanY = dlg.getMeanY();
float stdDev = dlg.getStdDeviation();
image = ImageGenerator.gaussian(width,height,meanX,meanY,stdDev);
}
else if (dlg.getType() == NewImageDialog.RAMP)
{
int orient;
int direc;
if (dlg.getOrientation() == NewImageDialog.HORIZONTAL)
{
orient = ImageGenerator.HORIZONTAL;
}
else
{
orient = ImageGenerator.VERTICAL;
}
if (dlg.getDirection() == NewImageDialog.ASCENDING)
{
direc = ImageGenerator.ASCENDING;
}
else
{
direc = ImageGenerator.DESCENDING;
}
image = ImageGenerator.ramp(width,height,orient,direc);
}
else if (dlg.getType() == NewImageDialog.STRIPES)
{
float color1 = dlg.getColor1();
float color2 = dlg.getColor2();
Float freq = new Float(dlg.getFrequency());
int orient;
if (dlg.getOrientation() == NewImageDialog.HORIZONTAL)
{
orient = ImageGenerator.HORIZONTAL;
}
else
{
orient = ImageGenerator.VERTICAL;
}
image = ImageGenerator.stripes(width,height,color1,color2,orient,freq.intValue());
}
if (null != image)
{
m_statusPanel.setText(m_imagePanel.addImage(image));
sizeToFit();
}
else
{
m_statusPanel.setText("Sorry, an error occurred");
}
}
}
protected void processLevelOpDialog(LevelOpDialog dlg)
{
if (dlg.clickedOK())
{
float max = dlg.getMax();
float min = dlg.getMin();
switch(dlg.getType())
{
case LevelOpDialog.TYPE_CLIP:
m_statusPanel.setText("Performing clip...");
m_statusPanel.setText(m_imagePanel.clipCurrent(min,max));
break;
case LevelOpDialog.TYPE_THRESHOLD:
m_statusPanel.setText("Performing threshold...");
m_statusPanel.setText(m_imagePanel.thresholdCurrent(max));
break;
case LevelOpDialog.TYPE_SCALE:
m_statusPanel.setText("Performing scale...");
m_statusPanel.setText(m_imagePanel.scaleCurrent(min,max));
break;
case LevelOpDialog.TYPE_WINDOW:
m_statusPanel.setText("Performing window...");
m_statusPanel.setText(m_imagePanel.windowCurrent(min,max));
break;
default:
m_statusPanel.setText("An error occurred.
Sorry.");
break;
}
}
}
protected void processKernelOpDialog(KernelOpDialog dlg)
{
if (dlg.clickedOK())
{
ImageKernel kernel = dlg.getKernel();
int x = dlg.getKernelX();
int y = dlg.getKernelY();
switch(dlg.getType())
{
case KernelOpDialog.TYPE_CONVOLVE:
m_statusPanel.setText("Performing convolve...");
m_statusPanel.setText(m_imagePanel.convolveCurrent(kernel));
break;
case KernelOpDialog.TYPE_DILATE:
m_statusPanel.setText("Performing dilate...");
m_statusPanel.setText(m_imagePanel.dilateCurrent(kernel,x,y));
break;
case KernelOpDialog.TYPE_ERODE:
m_statusPanel.setText("Performing erode...");
m_statusPanel.setText(m_imagePanel.erodeCurrent(kernel,x,y));
break;
case KernelOpDialog.TYPE_OPEN:
m_statusPanel.setText("Performing open...");
m_statusPanel.setText(m_imagePanel.openCurrent(kernel,x,y));
break;
case KernelOpDialog.TYPE_CLOSE:
m_statusPanel.setText("Performing close...");
m_statusPanel.setText(m_imagePanel.closeCurrent(kernel,x,y));
break;
default:
m_statusPanel.setText("Unable to identify
option chosen.");
break;
}
}
}
protected void processWarpOpDialog(WarpOpDialog dlg)
{
if (dlg.clickedOK())
{
switch(dlg.getType())
{
case WarpOpDialog.TYPE_TRANSLATE:
m_statusPanel.setText("Translating image...");
m_statusPanel.setText(m_imagePanel.translateCurrent(dlg.getXParam(),dlg.getYParam()));
break;
case WarpOpDialog.TYPE_ROTATE:
m_statusPanel.setText("Rotating image...");
m_statusPanel.setText(m_imagePanel.rotateCurrent(dlg.getDegrees()));
break;
case WarpOpDialog.TYPE_RESIZE:
m_statusPanel.setText("Resizing image...");
m_statusPanel.setText(m_imagePanel.resizeCurrent(dlg.getXParam(),dlg.getYParam()));
break;
default:
m_statusPanel.setText("Unable to identify
warp type.");
break;
}
}
}
protected void processNoiseDialog(NoiseDialog dlg)
{
if (dlg.clickedOK())
{
m_statusPanel.setText("Adding noise to image...");
m_statusPanel.setText(m_imagePanel.addNoiseCurrent(dlg.getType(),dlg.getStdDeviation(),dlg.getRange()));
}
}
protected jigl.image.Image getURLImage(String path)
{
try
{
ImageInputStream iis = new ImageInputStream(path,0);
jigl.image.Image image = iis.read();
iis.close();
return image;
}
catch(Exception ex)
{
m_statusPanel.setText("Open failed! Error:\n" +
ex.toString());
return null;
}
}
protected void processLoadImageDialog(LoadImageDialog dlg)
{
if (dlg.clickedOK())
{
m_statusPanel.setText("Opening image...");
jigl.image.Image image = getURLImage(dlg.getPath());
if (null == image)
{
return;//couldn't open image
}
switch(dlg.getType())
{
case LoadImageDialog.TYPE_NEW:
m_statusPanel.setText(m_imagePanel.addImage(image));
sizeToFit();
break;
case LoadImageDialog.TYPE_ADD:
m_statusPanel.appendText("Adding to current
image...");
m_statusPanel.setText(m_imagePanel.addToCurrent(image));
break;
case LoadImageDialog.TYPE_SUBTRACT:
m_statusPanel.appendText("Subtracting from
current image...");
m_statusPanel.setText(m_imagePanel.subtractFromCurrent(image));
break;
case LoadImageDialog.TYPE_MULTIPLY:
m_statusPanel.appendText("Multiplying with
current image...");
m_statusPanel.setText(m_imagePanel.multiplyWithCurrent(image));
break;
case LoadImageDialog.TYPE_DIVIDE:
m_statusPanel.appendText("Dividing with current
image...");
m_statusPanel.setText(m_imagePanel.divideWithCurrent(image));
break;
default:
m_statusPanel.setText("An error occurred.");
break;
}
}
}
public void windowClosing(WindowEvent e)
{
if (e.getWindow() instanceof NewImageDialog)
{
processNewImageDialog((NewImageDialog)e.getWindow());
}
else if (e.getWindow() instanceof LevelOpDialog)
{
processLevelOpDialog((LevelOpDialog)e.getWindow());
}
else if (e.getWindow() instanceof KernelOpDialog)
{
processKernelOpDialog((KernelOpDialog)e.getWindow());
}
else if (e.getWindow() instanceof WarpOpDialog)
{
processWarpOpDialog((WarpOpDialog)e.getWindow());
}
else if (e.getWindow() instanceof NoiseDialog)
{
processNoiseDialog((NoiseDialog)e.getWindow());
}
else if (e.getWindow() instanceof LoadImageDialog)
{
processLoadImageDialog((LoadImageDialog)e.getWindow());
}
super.windowClosing(e);
}
public void setStatusROI(ROI roi)
{
m_statusPanel.setROI(roi);
}
public void setStatusText(String text)
{
m_statusPanel.setText(text);
}
public void appendStatusText(String text)
{
m_statusPanel.appendText(text);
}
public void sizeToFit()
{
validate();
// Dimension d = getPreferredSize();//doesn't work because of
the scrollpane
Dimension d = m_imagePanel.getPreferredSize();
Dimension dcurr = this.getSize();
int width = d.width + 50;
int height = d.height + 150;
//don't go smaller that the current window size, or larger than
the maximum
if (width < dcurr.width)
{
width = dcurr.width;
}
else if (width > JiglDemo.MAIN_MAX_WIDTH)
{
width = JiglDemo.MAIN_MAX_WIDTH;
}
if (height < dcurr.height)
{
height = dcurr.height;
}
else if (height > JiglDemo.MAIN_MAX_HEIGHT)
{
height = JiglDemo.MAIN_MAX_HEIGHT;
}
setSize(width,height);
validate();//causes the window to redraw
}
}//end class MainWindow
/***********
FILE ImagePanel.java
***********/
import java.awt.Panel;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.event.*;
import jigl.image.*;
import jigl.gui.*;
import jigl.image.levelOps.*;
import jigl.image.morph.*;
import jigl.image.utils.*;
import jigl.image.warp.*;
/*
ImagePanel is a Panel class that displays the images for JiglDemo.
Basically it contains
a jigl.gui.ImageCanvas array and a jigl.image.Image array that
are used to display and hold (respectively)
the images. Supports an undo image that allows undo of
one previous action. Supports
mouse-drawn selection boxes on the image canvases. All
actions performed are on the currently
selected image, which is set by clicking an image. Supports
a Region of Interest for each image.
After a selection box is drawn on the image with the mouse,
the ROI can be set to that box.
*/
class ImagePanel extends Panel implements MouseListener,MouseMotionListener
{
protected int
m_nMaxImages;
protected jigl.gui.ImageCanvas[] m_canvasArray = null;
protected Image[]
m_imageArray = null;
protected ROI[]
m_ROIArray = null;
protected Image
m_undoImage = null;
protected int
m_nCurrentImage = -1;
protected MainWindow m_parent = null;
/**default constructor. max images displayable will be
0.*/
public ImagePanel()
{
m_nMaxImages = 0;
}
/**contructor. expects parent to be a MainWindow, but will
work with a normal frame.
@param parent parent frame
@param nMaxImages maximum number of image that can be displayed
in the panel
*/
public ImagePanel(Frame parent, int nMaxImages)
{
if (parent instanceof MainWindow)
{
m_parent = (MainWindow)parent;
}
m_nMaxImages = nMaxImages;
m_canvasArray = new jigl.gui.ImageCanvas[m_nMaxImages];
m_imageArray = new jigl.image.Image[m_nMaxImages];
m_ROIArray = new ROI[m_nMaxImages];
for (int i = 0; i < m_nMaxImages; i++)
{
m_canvasArray[i] = null;
m_imageArray[i] = null;
m_ROIArray[i] = null;
}
}
/** returns the index of the new image, -1 if there is no room
*/
protected int imageIndex()
{
int i = 0;
while (i < m_nMaxImages && m_imageArray[i] != null)
{
i++;
}
if (i < m_nMaxImages)
{//found a slot
return i;
}
return -1;
}
//FILE MENU OPTIONS
/**
called when the user adds a sample image (gray or color),
new image, or image from URL
@param image image to add to the panel
@return message about results of adding the image.
*/
public String addImage(Image image)
{
int index = imageIndex();
if (-1 == index)
{
return "Too many images open!";
}
//store the new image
m_imageArray[index] = image;
try
{
m_canvasArray[index] = new jigl.gui.ImageCanvas(image);
}
catch(Exception e)
{
return "Unable to add image! Error:\n" + e.toString();
}
//display the image in the panel
add(m_canvasArray[index]);
//handle mouse events from the canvas
m_canvasArray[index].addMouseListener(this);
m_canvasArray[index].addMouseMotionListener(this);
//"select" the image
m_nCurrentImage = index;
return "Image opened.";
}
/**removes the currently selected image from the panel
@return message about the results of closing the image
*/
public String closeImage()
{
if (-1 == m_nCurrentImage)
{
return "No image selected.";
}
else
{
remove(m_canvasArray[m_nCurrentImage]);
m_canvasArray[m_nCurrentImage] = null;
m_imageArray[m_nCurrentImage] = null;
m_ROIArray[m_nCurrentImage] = null;
m_undoImage = null;
m_nCurrentImage = -1;//no currently selected image
return "Image closed.";
}
}
public String quit()
{
//none needed
return "Cleaning up...";
}
//EDIT MENU OPTIONS
/** allows undo of action performed (immediately) previously*/
public String undoCurrent()
{
if (-1 == m_nCurrentImage || null == m_undoImage)
{
return "Nothing to undo.";
}
jigl.image.Image temp = m_undoImage;
m_undoImage = m_imageArray[m_nCurrentImage];
m_imageArray[m_nCurrentImage] = temp;
try
{
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch (Exception e)
{
return "An error occurred: \n" + e.toString();
}
redrawCurrent();
return "Undone!";
}
/** doubles the size of the current image
Does not support ROI*/
public String zoomInCurrent()
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
return doZoom((float)2,(float)2);
}
/** halves the size of the current image
Does not support ROI*/
public String zoomOutCurrent()
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
return doZoom((float)0.5,(float)0.5);
}
//BASIC OPERATIONS OPTIONS
/** supports ROI*/
public String clipCurrent(float min, float max)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
Clip clip = new Clip(min,max);
return doOp(clip);
}
/** supports ROI*/
public String convolveCurrent(ImageKernel kernel)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
Convolve convolve = new Convolve(kernel);
return doOp(convolve);
}
/** adds the image passed as parameter to the current image.
Does not support ROI.*/
public String addToCurrent(Image image)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
if (image.getClass() == m_imageArray[m_nCurrentImage].getClass())
{
Image sizedImage = sizeToCurrent(image);
if (sizedImage instanceof GrayImage)
{
m_imageArray[m_nCurrentImage] = ((GrayImage)m_imageArray[m_nCurrentImage]).add((GrayImage)sizedImage);
}
else if (sizedImage instanceof RealGrayImage)
{
m_imageArray[m_nCurrentImage] = ((RealGrayImage)m_imageArray[m_nCurrentImage]).add((RealGrayImage)sizedImage);
}
else if (sizedImage instanceof ColorImage)
{
m_imageArray[m_nCurrentImage] = ((ColorImage)m_imageArray[m_nCurrentImage]).add((ColorImage)sizedImage);
}
else if (sizedImage instanceof RealColorImage)
{
m_imageArray[m_nCurrentImage] = ((RealColorImage)m_imageArray[m_nCurrentImage]).add((RealColorImage)sizedImage);
}
else
{
return "Add not supported for this image type";
}
try
{
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch (Exception e)
{
return "An error occurred: \n" + e.toString();
}
return "Add complete";
}
else
{
return "Image types must be the same";
}
}
/** Does not support ROI*/
public String subtractFromCurrent(Image image)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
if (image.getClass() == m_imageArray[m_nCurrentImage].getClass())
{
Image sizedImage = sizeToCurrent(image);
if (sizedImage instanceof GrayImage)
{
m_imageArray[m_nCurrentImage] = ((GrayImage)m_imageArray[m_nCurrentImage]).subtract((GrayImage)sizedImage);
}
else if (sizedImage instanceof RealGrayImage)
{
m_imageArray[m_nCurrentImage] = ((RealGrayImage)m_imageArray[m_nCurrentImage]).subtract((RealGrayImage)sizedImage);
}
else if (sizedImage instanceof ColorImage)
{
m_imageArray[m_nCurrentImage] = ((ColorImage)m_imageArray[m_nCurrentImage]).subtract((ColorImage)sizedImage);
}
else if (sizedImage instanceof RealColorImage)
{
m_imageArray[m_nCurrentImage] = ((RealColorImage)m_imageArray[m_nCurrentImage]).subtract((RealColorImage)sizedImage);
}
else
{
return "Add not supported for this image type";
}
try
{
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch (Exception e)
{
return "An error occurred: \n" + e.toString();
}
return "Subtract complete";
}
else
{
return "Image types must be the same";
}
}
/** Does not support ROI*/
public String multiplyWithCurrent(Image image)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
if (image.getClass() == m_imageArray[m_nCurrentImage].getClass())
{
Image sizedImage = sizeToCurrent(image);
if (sizedImage instanceof GrayImage)
{
m_imageArray[m_nCurrentImage] = ((GrayImage)m_imageArray[m_nCurrentImage]).multiply((GrayImage)sizedImage);
}
else if (sizedImage instanceof RealGrayImage)
{
m_imageArray[m_nCurrentImage] = ((RealGrayImage)m_imageArray[m_nCurrentImage]).multiply((RealGrayImage)sizedImage);
}
else if (sizedImage instanceof ColorImage)
{
m_imageArray[m_nCurrentImage] = ((ColorImage)m_imageArray[m_nCurrentImage]).multiply((ColorImage)sizedImage);
}
else if (sizedImage instanceof RealColorImage)
{
m_imageArray[m_nCurrentImage] = ((RealColorImage)m_imageArray[m_nCurrentImage]).multiply((RealColorImage)sizedImage);
}
else
{
return "Add not supported for this image type";
}
try
{
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch (Exception e)
{
return "An error occurred: \n" + e.toString();
}
return "Multiply complete";
}
else
{
return "Image types must be the same";
}
}
/** Does not support ROI*/
public String divideWithCurrent(Image image)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
if (image.getClass() == m_imageArray[m_nCurrentImage].getClass())
{
Image sizedImage = sizeToCurrent(image);
if (sizedImage instanceof GrayImage)
{
m_imageArray[m_nCurrentImage] = ((GrayImage)m_imageArray[m_nCurrentImage]).divide((GrayImage)sizedImage);
}
else if (sizedImage instanceof RealGrayImage)
{
m_imageArray[m_nCurrentImage] = ((RealGrayImage)m_imageArray[m_nCurrentImage]).divide((RealGrayImage)sizedImage);
}
else if (sizedImage instanceof ColorImage)
{
m_imageArray[m_nCurrentImage] = ((ColorImage)m_imageArray[m_nCurrentImage]).divide((ColorImage)sizedImage);
}
else if (sizedImage instanceof RealColorImage)
{
m_imageArray[m_nCurrentImage] = ((RealColorImage)m_imageArray[m_nCurrentImage]).divide((RealColorImage)sizedImage);
}
else
{
return "Add not supported for this image type";
}
try
{
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch (Exception e)
{
return "An error occurred: \n" + e.toString();
}
return "Divide complete";
}
else
{
return "Image types must be the same";
}
}
//LEVEL OPERATIONS OPTIONS
/** Supports ROI*/
public String negateCurrent()
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
Negate negate = new Negate();
return doOp(negate);
}
/** Supports ROI*/
public String thresholdCurrent(float max)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
Threshold threshold = new Threshold(max);
return doOp(threshold);
}
/** Supports ROI*/
public String scaleCurrent(float min, float max)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
Scale scale = new Scale(min,max);
return doOp(scale);
}
/** Supports ROI*/
public String windowCurrent(float min, float max)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
jigl.image.levelOps.Window w = new jigl.image.levelOps.Window(min,max);
return doOp(w);
}
//MORPHOLOGY OPTIONS
/** Supports ROI*/
public String dilateCurrent(ImageKernel kernel, int x, int y)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
GDilate dilate = new GDilate(kernel,x,y);
return doOp(dilate);
}
/** Supports ROI*/
public String erodeCurrent(ImageKernel kernel, int x, int y)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
GErode erode = new GErode(kernel,x,y);
return doOp(erode);
}
/** Supports ROI*/
public String openCurrent(ImageKernel kernel, int x, int y)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
GOpen open = new GOpen(kernel,x,y);
return doOp(open);
}
/** Supports ROI*/
public String closeCurrent(ImageKernel kernel, int x, int y)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
GClose close = new GClose(kernel,x,y);
return doOp(close);
}
//WARP OPTIONS
/** Does not support ROI*/
public String resizeCurrent(float x, float y)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
ScaleTransform scale = new ScaleTransform(x,y);
return doWarpOp(scale);
}
/** Does not support ROI*/
public String rotateCurrent(float angleInDegrees)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
float x = (float)(m_imageArray[m_nCurrentImage].X())/2;
float y = (float)(m_imageArray[m_nCurrentImage].Y())/2;
RotateAboutTransform rotate = new RotateAboutTransform((float)((angleInDegrees*Math.PI)/180),x,y);
return doWarpOp(rotate);
}
/** Does not support ROI*/
public String translateCurrent(float x, float y)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
TranslateTransform translate = new TranslateTransform(x,y);
return doWarpOp(translate);
}
//UTILITIES OPTIONS
/** Supports ROI*/
public String addNoiseCurrent(int type, float stdDev, float range)
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = m_imageArray[m_nCurrentImage].copy();
try
{
switch(type)
{
case NoiseDialog.TYPE_UNIFORM:
m_imageArray[m_nCurrentImage] = Noise.uniform(m_imageArray[m_nCurrentImage],range,m_ROIArray[m_nCurrentImage]);
break;
case NoiseDialog.TYPE_GAUSSIAN:
m_imageArray[m_nCurrentImage] = Noise.gaussian(m_imageArray[m_nCurrentImage],stdDev,m_ROIArray[m_nCurrentImage]);
break;
case NoiseDialog.TYPE_POISSON:
m_imageArray[m_nCurrentImage] = Noise.poisson(m_imageArray[m_nCurrentImage],m_ROIArray[m_nCurrentImage]);
break;
default:
break;
}
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch(Exception e)
{
return "An error occurred:\n" + e.toString();
}
redrawCurrent();
return "Noise added.";
}
//REGION OF INTEREST OPTIONS
public String setROICurrent()
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
m_undoImage = null;
int ux = m_canvasArray[m_nCurrentImage].mouseux;
int uy = m_canvasArray[m_nCurrentImage].mouseuy;
int lx = m_canvasArray[m_nCurrentImage].mouselx;
int ly = m_canvasArray[m_nCurrentImage].mousely;
if (lx < 0) lx = 0;
if (ly < 0) ly = 0;
if (lx > m_canvasArray[m_nCurrentImage].imWidth()) lx = m_canvasArray[m_nCurrentImage].imWidth();
if (ly > m_canvasArray[m_nCurrentImage].imHeight()) ly = m_canvasArray[m_nCurrentImage].imHeight();
if (boxIsBigEnough(ux,uy,lx,ly))
{
m_ROIArray[m_nCurrentImage] = new ROI(ux,uy,lx,ly);
if (null != m_parent)
{
m_parent.setStatusROI(m_ROIArray[m_nCurrentImage]);
}
return "Region of interest set.";
}
else
{
return "No region of interest specified";
}
}
public String clearROICurrent()
{
if (-1 == m_nCurrentImage)
{
return "No image selected";
}
if (null == m_ROIArray[m_nCurrentImage])
{
return "No region of interest set";
}
m_undoImage = null;
m_ROIArray[m_nCurrentImage] = null;
if (null != m_parent)
{
m_parent.setStatusROI(null);
}
return "Region of interest cleared.";
}
//supplemental methods
protected Image sizeToCurrent(Image image)
{
int w = m_imageArray[m_nCurrentImage].X();
int h = m_imageArray[m_nCurrentImage].Y();
int[] intcolor = new int[3];
float[] floatcolor = new float[3];
intcolor[0] = intcolor[1] = intcolor[2] = 0;
floatcolor[0] = floatcolor[1] = floatcolor[2] = (float)0;
if (image instanceof GrayImage) return ((GrayImage)image).addbuffer(w,h,0);
else if (image instanceof RealGrayImage) return ((RealGrayImage)image).addbuffer(w,h,(float)0);
else if (image instanceof ColorImage) return ((ColorImage)image).addbuffer(w,h,intcolor);
else if (image instanceof RealColorImage) return ((RealColorImage)image).addbuffer(w,h,floatcolor);
else return image;
}
protected String doZoom(float x, float y)
{
m_canvasArray[m_nCurrentImage].setOffScreen(x,y);
java.awt.Image tempImage = m_canvasArray[m_nCurrentImage].getJavaImage();
if (m_imageArray[m_nCurrentImage] instanceof ColorImage)
m_imageArray[m_nCurrentImage] = new ColorImage(tempImage);
else if (m_imageArray[m_nCurrentImage] instanceof RealColorImage)
m_imageArray[m_nCurrentImage] = new RealColorImage(tempImage);
else if (m_imageArray[m_nCurrentImage] instanceof RealGrayImage)
m_imageArray[m_nCurrentImage] = new RealGrayImage(tempImage);
else m_imageArray[m_nCurrentImage] = new GrayImage(tempImage);
try
{
m_canvasArray[m_nCurrentImage].setImage(tempImage);
}
catch(Exception e)
{
return "An error occurred:\n" + e.toString();
}
//display the image
redrawCurrent();
return "Zoom complete.";
}
protected String doWarpOp(PointMapper op)
{
try
{
Mapper mapper = new Mapper(m_imageArray[m_nCurrentImage],0);
m_imageArray[m_nCurrentImage] = mapper.applyTransformation(op);
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch(Exception e)
{
return "An error occurred:\n" + e.toString();
}
redrawCurrent();
return "Warp completed.";
}
protected String doOp(Operator op)
{
jigl.image.Image image = m_imageArray[m_nCurrentImage];
if (image instanceof ColorImage || image instanceof RealColorImage)//apply
op to each plane
{
try
{
if (image instanceof ColorImage)
{
((ColorImage)image).setPlane(0,(GrayImage)op.apply(((ColorImage)image).plane(0),m_ROIArray[m_nCurrentImage]));
((ColorImage)image).setPlane(1,(GrayImage)op.apply(((ColorImage)image).plane(1),m_ROIArray[m_nCurrentImage]));
((ColorImage)image).setPlane(2,(GrayImage)op.apply(((ColorImage)image).plane(2),m_ROIArray[m_nCurrentImage]));
}
else
{
((RealColorImage)image).setPlane(0,(RealGrayImage)op.apply(((RealColorImage)image).plane(0),m_ROIArray[m_nCurrentImage]));
((RealColorImage)image).setPlane(1,(RealGrayImage)op.apply(((RealColorImage)image).plane(1),m_ROIArray[m_nCurrentImage]));
((RealColorImage)image).setPlane(2,(RealGrayImage)op.apply(((RealColorImage)image).plane(2),m_ROIArray[m_nCurrentImage]));
}
m_imageArray[m_nCurrentImage] = image;
}
catch(Exception e)
{
return "An error occurred:\n" + e.toString();
}
}
else //image is a Gray or RealGray image
{
try
{
m_imageArray[m_nCurrentImage] = op.apply(image,m_ROIArray[m_nCurrentImage]);
}
catch(Exception e)
{
return "An Error occurred:\n" + e.toString();
}
}
try
{
m_canvasArray[m_nCurrentImage].setImage(m_imageArray[m_nCurrentImage]);
}
catch (Exception e)
{
return "An error occurred while clipping: \n" + e.toString();
}
redrawCurrent();
return "Done.";
}
public void redrawCurrent()
{
m_canvasArray[m_nCurrentImage].setVisible(true);
m_canvasArray[m_nCurrentImage].validate();
this.validate();
if (null != m_parent)
{
m_parent.sizeToFit();
}
}
public void redrawAll()
{
for (int i = 0; i < m_nMaxImages; i++)
{
m_canvasArray[m_nCurrentImage].setVisible(true);
m_canvasArray[m_nCurrentImage].validate();
}
this.validate();
if (null != m_parent)
{
m_parent.sizeToFit();
}
}
//these go along with mouse events
//box must be bigger than 5X5 to count
protected boolean boxIsBigEnough(int ux, int uy, int lx, int
ly)
{
int xdiff = ux - lx;
int ydiff = uy - ly;
if (-5 < xdiff && xdiff < 5 && -5 <
ydiff && ydiff < 5)
{
return false;
}
else
{
return true;
}
}
protected void selectImage(jigl.gui.ImageCanvas canvas)
{
for (int x = 0; x < m_nMaxImages; x++)
{
if (m_canvasArray[x] == canvas && m_nCurrentImage
!= x)
{
m_nCurrentImage = x;
m_undoImage = null;
if (null != m_parent)
{
if (null == m_ROIArray[x])
{
m_parent.setStatusROI(null);
}
else
{
m_parent.setStatusROI(m_ROIArray[x]);
}
}
return;//found the image
}
}
}
protected void drawBox(jigl.gui.ImageCanvas canvas)
{
if (boxIsBigEnough(canvas.mouseux,canvas.mouseuy,canvas.mouselx,canvas.mousely))
{
Graphics graphics = canvas.getGraphics();
graphics.setXORMode(Color.white);
graphics.drawLine (canvas.mouseux,canvas.mouseuy,canvas.mouselx,canvas.mouseuy);
graphics.drawLine (canvas.mouseux,canvas.mousely,canvas.mouselx,canvas.mousely);
graphics.drawLine (canvas.mouseux,canvas.mouseuy,canvas.mouseux,canvas.mousely);
graphics.drawLine (canvas.mouselx,canvas.mouseuy,canvas.mouselx,canvas.mousely);
}
}
protected void clearBox(jigl.gui.ImageCanvas canvas)
{
drawBox(canvas);
canvas.mouseux = 0;
canvas.mouseuy = 0;
canvas.mouselx = 0;
canvas.mousely = 0;
}
//MouseListener methods
public void mousePressed(MouseEvent e)
{
if (e.getComponent() instanceof jigl.gui.ImageCanvas)
{
jigl.gui.ImageCanvas canvas = (jigl.gui.ImageCanvas)e.getComponent();
selectImage(canvas);
clearBox(canvas);
canvas.mouseux = e.getX();
canvas.mouseuy = e.getY();
canvas.mouselx = e.getX();
canvas.mousely = e.getY();
}
}
public void mouseReleased(MouseEvent e)
{
if (e.getComponent() instanceof jigl.gui.ImageCanvas)
{
selectImage((jigl.gui.ImageCanvas)e.getComponent());
}
}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseClicked(MouseEvent e)
{
if (e.getComponent() instanceof jigl.gui.ImageCanvas)
{
jigl.gui.ImageCanvas canvas = (jigl.gui.ImageCanvas)e.getComponent();
selectImage(canvas);
clearBox(canvas);
}
}
//MouseMotionListener methods
public void mouseDragged(MouseEvent e)
{
if (e.getComponent() instanceof jigl.gui.ImageCanvas)
{
jigl.gui.ImageCanvas canvas = (jigl.gui.ImageCanvas)e.getComponent();
selectImage(canvas);
drawBox(canvas);
canvas.mouselx = e.getX();
canvas.mousely = e.getY();
drawBox(canvas);
}
}
public void mouseMoved(MouseEvent e){}
}
/*************
FILE StatusPanel.java
************/
import java.awt.*;
import jigl.image.ROI;
/*
// header - edit "Data/yourJavaHeader" to customize
// contents - edit "EventHandlers/Java file/onCreate" to customize
//
*/
class StatusPanel extends Panel
{
protected static final String ROItext = " Region of Interest:
";
// protected Label m_statusROI = new Label();
protected TextArea m_statusROI = new TextArea("",1,45,TextArea.SCROLLBARS_NONE);
protected TextArea m_statusText = new TextArea("",1,45,TextArea.SCROLLBARS_VERTICAL_ONLY);
public StatusPanel()
{
Font font = new Font("JIGL font",Font.PLAIN, 10);
FlowLayout flow = new FlowLayout(FlowLayout.LEFT);
flow.setVgap(0);
setLayout(flow);
m_statusROI.setFont(font);
m_statusROI.setEditable(false);
m_statusROI.setVisible(true);
m_statusROI.validate();
m_statusText.setFont(font);
m_statusText.setEditable(false);
m_statusText.setVisible(true);
m_statusText.validate();
add(m_statusText);
add(m_statusROI);
}
public void setText(String text)
{
m_statusText.setText(text);
}
public void appendText(String text)
{
m_statusText.append("\n" + text);
}
public void setROI(ROI roi)
{
if (null == roi)
{
m_statusROI.setText(ROItext + "Not Selected");
}
else
{
String part = ROItext + "{(" + roi.ux() + "," + roi.uy()
+ "),(" + roi.lx() + "," + roi.ly() + ")}";
m_statusROI.setText(part);
}
m_statusROI.validate();
}
}
/***************
FILE KernelOpDialog.java
**************/
import java.awt.event.*;
import java.awt.*;
import jigl.image.ImageKernel;
/*
Kernel operations include the following:
Convolve
Dilate
Erode
Open
Close
Each of these requires definition of a kernel matrix.
m_size is a drop-down
box that allows changing the kernel size. The type of
dialog must be specified
in the constructor, and must be a defined type.
*/
class KernelOpDialog extends Dialog implements ActionListener,WindowListener,ItemListener
{
protected int m_type;
protected int m_kernelType;
protected Panel m_kernelPanel;
protected CheckboxGroup m_checkGroup;
public static final int TYPE_CONVOLVE = 0;
public static final int TYPE_DILATE = 1;
public static final int TYPE_ERODE = 2;
public static final int TYPE_OPEN = 3;
public static final int TYPE_CLOSE = 4;
//kernel numbers
protected TextField m_00,m_01,m_02,m_03,m_04,m_10,m_11,m_12,m_13,m_14,m_20,m_21,m_22,m_23,m_24,
m_30,m_31,m_32,m_33,m_34,m_40,m_41,m_42,m_43,m_44;
//kernel center
protected TextField m_x,m_y;
protected Choice m_size;
protected Checkbox m_userCheck,m_uniformCheck,m_sobelXCheck,m_sobelYCheck,m_prewittXCheck,m_prewittYCheck,
m_laplacianCheck,m_laplacian8Check,m_unsharpCheck,m_unsharp8Check,m_dxxCheck,m_dyyCheck,m_dxyCheck;
protected final String OK = "Okay";
protected final String CANCEL = "Cancel";
protected final String THREEXTHREE = "3 X 3";
protected final String FOURXFOUR = "4 X 4";
protected final String FIVEXFIVE = "5 X 5";
protected final String USER = "User defined";
protected final String UNIFORM = "Uniform";
protected final String SOBELX = "Sobel X";
protected final String SOBELY = "Sobel Y";
protected final String PREWITTX = "Prewitt X";
protected final String PREWITTY = "Prewitt Y";
protected final String LAPLACIAN = "Laplacian";
protected final String LAPLACIAN8 = "Laplacian 8";
protected final String UNSHARP = "Unsharp";
protected final String UNSHARP8 = "Unsharp 8";
protected final String DXX = "dxx";
protected final String DYY = "dyy";
protected final String DXY = "dxy";
//default kernel types
protected final int KERNEL_TYPE_USER = 20;
/* protected final int TYPE_UNIFORM = 21;
protected final int TYPE_SOBELX = 22;
protected final int TYPE_SOBELY = 23;
protected final int TYPE_PREWITTX = 24;
protected final int TYPE_PREWITTY = 25;
protected final int TYPE_LAPLACIAN = 26;
protected final int TYPE_LAPLACIAN8 = 27;
protected final int TYPE_UNSHARP = 28;
protected final int TYPE_UNSHARP8 = 29;
protected final int TYPE_DXX = 30;
protected final int TYPE_DYY = 31;
protected final int TYPE_DXY = 32;*/
protected boolean m_bOK = false;//set to true when the user clicks
"Okay"
protected Frame m_parent;
public KernelOpDialog(Frame parent, int dlgType)
{
super(parent,"Define Kernel");
if (dlgType == TYPE_CONVOLVE)
{
setLayout(new BorderLayout(20,10));
}
else
{
setLayout(new BorderLayout(110,10));
}
setModal(false);
setResizable(false);
setSize(200,300);
setLocation(parent.getLocation());
addWindowListener(this);
m_parent = parent;
m_type = dlgType;
m_kernelType = KERNEL_TYPE_USER;
//initialize dialog fields
//OK and Cancel buttons
Panel OKPanel = new Panel();
Button OKButton = new Button(OK);
Button CancelButton = new Button(CANCEL);
OKButton.addActionListener(this);
CancelButton.addActionListener(this);
OKPanel.add(OKButton);
OKPanel.add(CancelButton);
add(OKPanel,BorderLayout.SOUTH);
//string and size drop-down
m_checkGroup = new CheckboxGroup();
m_userCheck = new Checkbox(USER,m_checkGroup,true);
m_userCheck.addItemListener(this);
m_uniformCheck = new Checkbox(UNIFORM,m_checkGroup,false);
m_uniformCheck.addItemListener(this);
m_sobelXCheck = new Checkbox(SOBELX,m_checkGroup,false);
m_sobelXCheck.addItemListener(this);
m_sobelYCheck = new Checkbox(SOBELY,m_checkGroup,false);
m_sobelYCheck.addItemListener(this);
m_prewittXCheck = new Checkbox(PREWITTX,m_checkGroup,false);
m_prewittXCheck.addItemListener(this);
m_prewittYCheck = new Checkbox(PREWITTY,m_checkGroup,false);
m_prewittYCheck.addItemListener(this);
m_laplacianCheck = new Checkbox(LAPLACIAN,m_checkGroup,false);
m_laplacianCheck.addItemListener(this);
m_laplacian8Check = new Checkbox(LAPLACIAN8,m_checkGroup,false);
m_laplacian8Check.addItemListener(this);
m_unsharpCheck = new Checkbox(UNSHARP,m_checkGroup,false);
m_unsharpCheck.addItemListener(this);
m_unsharp8Check = new Checkbox(UNSHARP8,m_checkGroup,false);
m_unsharp8Check.addItemListener(this);
m_dxxCheck = new Checkbox(DXX,m_checkGroup,false);
m_dxxCheck.addItemListener(this);
m_dyyCheck = new Checkbox(DYY,m_checkGroup,false);
m_dyyCheck.addItemListener(this);
m_dxyCheck = new Checkbox(DXY,m_checkGroup,false);
m_dxyCheck.addItemListener(this);
Panel sizePanel = new Panel();
Label label;
switch(m_type)
{
case TYPE_CONVOLVE: label = new Label("Choose convolve
kernel. Size:");
break;
case TYPE_DILATE: label = new Label("Define dilate kernel.
Size:");
break;
case TYPE_ERODE: label = new Label("Define erode kernel.
Size:");
break;
case TYPE_OPEN: label = new Label("Define open kernel.
Size:");
break;
case TYPE_CLOSE: label = new Label("Define close kernel.
Size:");
break;
default: label = new Label("An error occurred. Click 'Okay'");
break;
}
m_size = new Choice();
m_size.add(THREEXTHREE);
m_size.add(FOURXFOUR);
m_size.add(FIVEXFIVE);
m_size.addItemListener(this);
sizePanel.add(label);
Panel defaultPanel = new Panel();
defaultPanel.setLayout(new GridLayout(5,3));
defaultPanel.add(m_userCheck);
defaultPanel.add(m_prewittYCheck);
defaultPanel.add(m_dxxCheck);
defaultPanel.add(m_uniformCheck);
defaultPanel.add(m_laplacianCheck);
defaultPanel.add(m_dyyCheck);
defaultPanel.add(m_sobelXCheck);
defaultPanel.add(m_laplacian8Check);
defaultPanel.add(m_dxyCheck);
defaultPanel.add(m_sobelYCheck);
defaultPanel.add(m_unsharpCheck);
defaultPanel.add(m_prewittXCheck);
defaultPanel.add(m_unsharp8Check);
if (m_type == TYPE_CONVOLVE)
{
add(defaultPanel,BorderLayout.WEST);
}
sizePanel.add(m_size);
m_x = new TextField("3",2);
m_y = new TextField("3",2);
if (m_type != TYPE_CONVOLVE)
{
sizePanel.add(new Label("Center location"));
sizePanel.add(new Label("x:"));
sizePanel.add(m_x);
sizePanel.add(new Label("y:"));
sizePanel.add(m_y);
}
add(sizePanel,BorderLayout.NORTH);
//kernel edit boxes
Panel centerPanel = new Panel(new BorderLayout());
m_kernelPanel = new Panel(new GridLayout(5,5));
centerPanel.add(m_kernelPanel,BorderLayout.NORTH);
centerPanel.add(new Panel(),BorderLayout.CENTER);
m_00 = new TextField("1",3);
m_01 = new TextField("1",3);
m_02 = new TextField("1",3);
m_03 = new TextField("1",3);
m_04 = new TextField("1",3);
m_10 = new TextField("1",3);
m_11 = new TextField("1",3);
m_12 = new TextField("1",3);
m_13 = new TextField("1",3);
m_14 = new TextField("1",3);
m_20 = new TextField("1",3);
m_21 = new TextField("1",3);
m_22 = new TextField("1",3);
m_23 = new TextField("1",3);
m_24 = new TextField("1",3);
m_30 = new TextField("1",3);
m_31 = new TextField("1",3);
m_32 = new TextField("1",3);
m_33 = new TextField("1",3);
m_34 = new TextField("1",3);
m_40 = new TextField("1",3);
m_41 = new TextField("1",3);
m_42 = new TextField("1",3);
m_43 = new TextField("1",3);
m_44 = new TextField("1",3);
//they get added down y, so the order is mixed up here
m_kernelPanel.add(m_00);
m_kernelPanel.add(m_10);
m_kernelPanel.add(m_20);
m_kernelPanel.add(m_30);
m_kernelPanel.add(m_40);
m_kernelPanel.add(m_01);
m_kernelPanel.add(m_11);
m_kernelPanel.add(m_21);
m_kernelPanel.add(m_31);
m_kernelPanel.add(m_41);
m_kernelPanel.add(m_02);
m_kernelPanel.add(m_12);
m_kernelPanel.add(m_22);
m_kernelPanel.add(m_32);
m_kernelPanel.add(m_42);
m_kernelPanel.add(m_03);
m_kernelPanel.add(m_13);
m_kernelPanel.add(m_23);
m_kernelPanel.add(m_33);
m_kernelPanel.add(m_43);
m_kernelPanel.add(m_04);
m_kernelPanel.add(m_14);
m_kernelPanel.add(m_24);
m_kernelPanel.add(m_34);
m_kernelPanel.add(m_44);
add(centerPanel,BorderLayout.CENTER);
if (m_type != TYPE_CONVOLVE)
{
add(new Panel(),BorderLayout.EAST);
add(new Panel(),BorderLayout.WEST);
}
m_size.select(FIVEXFIVE);
setSize(getPreferredSize());
}
public void itemStateChanged(ItemEvent e)
{
if (e.getStateChange() == ItemEvent.SELECTED)
{
if (e.getItem() instanceof String)
{
String selected = (String)e.getItem();
if (selected == FIVEXFIVE)
{
changeKernel5X5();
}
else if (selected == FOURXFOUR)
{
changeKernel4X4();
}
else if (selected == THREEXTHREE)
{
changeKernel3X3();
}
else if (selected == USER)
{
m_size.select(FIVEXFIVE);
changeKernel5X5();
activateAll();
m_kernelType = KERNEL_TYPE_USER;
}
else if (selected == UNIFORM)
{
m_kernelType = ImageKernel.UNIFORM;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == SOBELX)
{
m_kernelType = ImageKernel.SOBEL_X;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == SOBELY)
{
m_kernelType = ImageKernel.SOBEL_Y;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == PREWITTX)
{
m_kernelType = ImageKernel.PREWITT_X;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == PREWITTY)
{
m_kernelType = ImageKernel.PREWITT_Y;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == LAPLACIAN)
{
m_kernelType = ImageKernel.LAPLACIAN;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == LAPLACIAN8)
{
m_kernelType = ImageKernel.LAPLACIAN_8;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == UNSHARP)
{
m_kernelType = ImageKernel.UNSHARP;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == UNSHARP8)
{
m_kernelType = ImageKernel.UNSHARP_8;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == DXX)
{
m_kernelType = ImageKernel.D_XX;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == DYY)
{
m_kernelType = ImageKernel.D_YY;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
else if (selected == DXY)
{
m_kernelType = ImageKernel.D_XY;
m_size.select(THREEXTHREE);
changeKernel3X3();
setKernelByDefault(m_kernelType);
deactivateAll();
}
}
validate();
}
}
protected void setKernelByDefault(int kernelType)
{
ImageKernel kernel;
try
{
kernel = new ImageKernel(kernelType);
}
catch(Exception e)
{
return;
}
m_11.setText(String.valueOf(kernel.get(0,0)));
m_12.setText(String.valueOf(kernel.get(0,1)));
m_13.setText(String.valueOf(kernel.get(0,2)));
m_21.setText(String.valueOf(kernel.get(1,0)));
m_22.setText(String.valueOf(kernel.get(1,1)));
m_23.setText(String.valueOf(kernel.get(1,2)));
m_31.setText(String.valueOf(kernel.get(2,0)));
m_32.setText(String.valueOf(kernel.get(2,1)));
m_33.setText(String.valueOf(kernel.get(2,2)));
}
protected void changeKernel5X5()
{
m_00.setVisible(true);
m_01.setVisible(true);
m_02.setVisible(true);
m_03.setVisible(true);
m_04.setVisible(true);
m_10.setVisible(true);
m_11.setVisible(true);
m_12.setVisible(true);
m_13.setVisible(true);
m_14.setVisible(true);
m_20.setVisible(true);
m_21.setVisible(true);
m_22.setVisible(true);
m_23.setVisible(true);
m_24.setVisible(true);
m_30.setVisible(true);
m_31.setVisible(true);
m_32.setVisible(true);
m_33.setVisible(true);
m_34.setVisible(true);
m_40.setVisible(true);
m_41.setVisible(true);
m_42.setVisible(true);
m_43.setVisible(true);
m_44.setVisible(true);
}
protected void changeKernel4X4()
{
m_00.setVisible(true);
m_01.setVisible(true);
m_02.setVisible(true);
m_03.setVisible(true);
m_04.setVisible(false);
m_10.setVisible(true);
m_11.setVisible(true);
m_12.setVisible(true);
m_13.setVisible(true);
m_14.setVisible(false);
m_20.setVisible(true);
m_21.setVisible(true);
m_22.setVisible(true);
m_23.setVisible(true);
m_24.setVisible(false);
m_30.setVisible(true);
m_31.setVisible(true);
m_32.setVisible(true);
m_33.setVisible(true);
m_34.setVisible(false);
m_40.setVisible(false);
m_41.setVisible(false);
m_42.setVisible(false);
m_43.setVisible(false);
m_44.setVisible(false);
}
protected void changeKernel3X3()
{
m_00.setVisible(false);
m_01.setVisible(false);
m_02.setVisible(false);
m_03.setVisible(false);
m_04.setVisible(false);
m_10.setVisible(false);
m_11.setVisible(true);
m_12.setVisible(true);
m_13.setVisible(true);
m_14.setVisible(false);
m_20.setVisible(false);
m_21.setVisible(true);
m_22.setVisible(true);
m_23.setVisible(true);
m_24.setVisible(false);
m_30.setVisible(false);
m_31.setVisible(true);
m_32.setVisible(true);
m_33.setVisible(true);
m_34.setVisible(false);
m_40.setVisible(false);
m_41.setVisible(false);
m_42.setVisible(false);
m_43.setVisible(false);
m_44.setVisible(false);
}
protected void deactivateAll()
{
m_size.setEnabled(false);
m_x.setEnabled(false);
m_y.setEnabled(false);
m_00.setEnabled(false);
m_01.setEnabled(false);
m_02.setEnabled(false);
m_03.setEnabled(false);
m_04.setEnabled(false);
m_10.setEnabled(false);
m_11.setEnabled(false);
m_12.setEnabled(false);
m_13.setEnabled(false);
m_14.setEnabled(false);
m_20.setEnabled(false);
m_21.setEnabled(false);
m_22.setEnabled(false);
m_23.setEnabled(false);
m_24.setEnabled(false);
m_30.setEnabled(false);
m_31.setEnabled(false);
m_32.setEnabled(false);
m_33.setEnabled(false);
m_34.setEnabled(false);
m_40.setEnabled(false);
m_41.setEnabled(false);
m_42.setEnabled(false);
m_43.setEnabled(false);
m_44.setEnabled(false);
validate();
}
protected void activateAll()
{
m_size.setEnabled(true);
m_x.setEnabled(true);
m_y.setEnabled(true);
m_00.setEnabled(true);
m_01.setEnabled(true);
m_02.setEnabled(true);
m_03.setEnabled(true);
m_04.setEnabled(true);
m_10.setEnabled(true);
m_11.setEnabled(true);
m_12.setEnabled(true);
m_13.setEnabled(true);
m_14.setEnabled(true);
m_20.setEnabled(true);
m_21.setEnabled(true);
m_22.setEnabled(true);
m_23.setEnabled(true);
m_24.setEnabled(true);
m_30.setEnabled(true);
m_31.setEnabled(true);
m_32.setEnabled(true);
m_33.setEnabled(true);
m_34.setEnabled(true);
m_40.setEnabled(true);
m_41.setEnabled(true);
m_42.setEnabled(true);
m_43.setEnabled(true);
m_44.setEnabled(true);
validate();
}
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand() == OK)
{
m_bOK = true;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
else if (e.getActionCommand() == CANCEL)
{
m_bOK = false;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
}
//implemented functions from WindowListener
public void windowClosing(WindowEvent e)
{
if (e.getComponent() == this)
{
this.dispose();
}
}
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public int getType()
{
return m_type;
}
public int getKernelX()
{
String size = m_size.getSelectedItem();
if (m_type == TYPE_CONVOLVE)
{
return 0;
}
int val = (new Integer(m_x.getText())).intValue();
if (size == THREEXTHREE)
{
//3 X 3 changes the 0,0 coordinate to the 1,1 position
return val-1;
}
else
{
return val;
}
}
public int getKernelY()
{
String size = m_size.getSelectedItem();
if (m_type == TYPE_CONVOLVE)
{
return 0;
}
int val = (new Integer(m_y.getText())).intValue();
if (size == THREEXTHREE)
{
//3 X 3 changes the 0,0 coordinate to the 1,1 position
return val-1;
}
else
{
return val;
}
}
public ImageKernel getKernel()
{
if (KERNEL_TYPE_USER == m_kernelType)
{
String size = m_size.getSelectedItem();
float[][] data;
if (size == FIVEXFIVE)
{
data = new float[5][5];
data[0][0] = (new Float(m_00.getText())).floatValue();
data[0][1] = (new Float(m_01.getText())).floatValue();
data[0][2] = (new Float(m_02.getText())).floatValue();
data[0][3] = (new Float(m_03.getText())).floatValue();
data[0][4] = (new Float(m_04.getText())).floatValue();
data[1][0] = (new Float(m_10.getText())).floatValue();
data[1][1] = (new Float(m_11.getText())).floatValue();
data[1][2] = (new Float(m_12.getText())).floatValue();
data[1][3] = (new Float(m_13.getText())).floatValue();
data[1][4] = (new Float(m_14.getText())).floatValue();
data[2][0] = (new Float(m_20.getText())).floatValue();
data[2][1] = (new Float(m_21.getText())).floatValue();
data[2][2] = (new Float(m_22.getText())).floatValue();
data[2][3] = (new Float(m_23.getText())).floatValue();
data[2][4] = (new Float(m_24.getText())).floatValue();
data[3][0] = (new Float(m_30.getText())).floatValue();
data[3][1] = (new Float(m_31.getText())).floatValue();
data[3][2] = (new Float(m_32.getText())).floatValue();
data[3][3] = (new Float(m_33.getText())).floatValue();
data[3][4] = (new Float(m_34.getText())).floatValue();
data[4][0] = (new Float(m_40.getText())).floatValue();
data[4][1] = (new Float(m_41.getText())).floatValue();
data[4][2] = (new Float(m_42.getText())).floatValue();
data[4][3] = (new Float(m_43.getText())).floatValue();
data[4][4] = (new Float(m_44.getText())).floatValue();
}
else if (size == FOURXFOUR)
{
data = new float[4][4];
data[0][0] = (new Float(m_00.getText())).floatValue();
data[0][1] = (new Float(m_01.getText())).floatValue();
data[0][2] = (new Float(m_02.getText())).floatValue();
data[0][3] = (new Float(m_03.getText())).floatValue();
data[1][0] = (new Float(m_10.getText())).floatValue();
data[1][1] = (new Float(m_11.getText())).floatValue();
data[1][2] = (new Float(m_12.getText())).floatValue();
data[1][3] = (new Float(m_13.getText())).floatValue();
data[2][0] = (new Float(m_20.getText())).floatValue();
data[2][1] = (new Float(m_21.getText())).floatValue();
data[2][2] = (new Float(m_22.getText())).floatValue();
data[2][3] = (new Float(m_23.getText())).floatValue();
data[3][0] = (new Float(m_30.getText())).floatValue();
data[3][1] = (new Float(m_31.getText())).floatValue();
data[3][2] = (new Float(m_32.getText())).floatValue();
data[3][3] = (new Float(m_33.getText())).floatValue();
}
else if (size == THREEXTHREE)
{
data = new float[3][3];
data[0][0] = (new Float(m_11.getText())).floatValue();
data[0][1] = (new Float(m_12.getText())).floatValue();
data[0][2] = (new Float(m_13.getText())).floatValue();
data[1][0] = (new Float(m_21.getText())).floatValue();
data[1][1] = (new Float(m_22.getText())).floatValue();
data[1][2] = (new Float(m_23.getText())).floatValue();
data[2][0] = (new Float(m_31.getText())).floatValue();
data[2][1] = (new Float(m_32.getText())).floatValue();
data[2][2] = (new Float(m_33.getText())).floatValue();
}
else
{
data = new float[3][3];//uninitialized
}
return new ImageKernel(data);
}
else
{
//default kernel type
try
{
return new ImageKernel(m_kernelType);
}
catch(Exception e)
{
return new ImageKernel(new float[3][3]);//uninitialized
}
}
}
public boolean clickedOK()
{
return m_bOK;
}
}
/***************
FILE LevelOpDialog.java
***************/
import java.awt.event.*;
import java.awt.*;
/*
Level operations include the following:
Clip
Threshold
Scale
Window
Each of these requires a max and min value, except Threshold,
which only requires a max.
The type of dialog must be specified in the constructor, and
must be a defined type.
*/
class LevelOpDialog extends Dialog implements ActionListener,WindowListener
{
protected int m_type;
public static final int TYPE_CLIP = 0;
public static final int TYPE_THRESHOLD = 1;
public static final int TYPE_SCALE = 2;
public static final int TYPE_WINDOW = 3;
protected TextField m_maxField,m_minField;
protected final String OK = "Okay";
protected final String CANCEL = "Cancel";
protected boolean m_bOK = false;//set to true when the user clicks
"Okay"
protected Frame m_parent;
public LevelOpDialog(Frame parent, int dlgType)
{
super(parent,"Choose parameters");
setModal(false);
setResizable(false);
setLocation(parent.getLocation());
addWindowListener(this);
m_parent = parent;
m_type = dlgType;
//initialize dialog fields
//OK and Cancel buttons
Panel OKPanel = new Panel();
Button OKButton = new Button(OK);
Button CancelButton = new Button(CANCEL);
OKButton.addActionListener(this);
CancelButton.addActionListener(this);
OKPanel.add(OKButton);
OKPanel.add(CancelButton);
add(OKPanel,BorderLayout.SOUTH);
//input edit boxes
Panel maxMinPanel = new Panel();
Label maxLabel = new Label("Max:");
Label minLabel = new Label("Min:");
m_maxField = new TextField("200");
m_minField = new TextField("50");
if (m_type != TYPE_THRESHOLD)
{
maxMinPanel.add(minLabel);
maxMinPanel.add(m_minField);
}
maxMinPanel.add(maxLabel);
maxMinPanel.add(m_maxField);
add(maxMinPanel,BorderLayout.CENTER);
//text
Panel textPanel = new Panel();
Label text = new Label();
switch(m_type)
{
case TYPE_CLIP: text.setText("Enter clip parameters:");
break;
case TYPE_THRESHOLD: text.setText("Enter threshold parameter");
break;
case TYPE_SCALE: text.setText("Enter scale parameters");
break;
case TYPE_WINDOW: text.setText("Enter window parameters");
break;
default: m_maxField.setEditable(false);
m_minField.setEditable(false);
text.setText("An error occurred.
Click Okay.");
break;
}
textPanel.add(text);
add(textPanel,BorderLayout.NORTH);
setSize(getPreferredSize());
}
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand() == OK)
{
m_bOK = true;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
else if (e.getActionCommand() == CANCEL)
{
m_bOK = false;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
}
//implemented functions from WindowListener
public void windowClosing(WindowEvent e)
{
if (e.getComponent() == this)
{
this.dispose();
}
}
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public int getType()
{
return m_type;
}
public float getMax()
{
return (new Float(m_maxField.getText())).floatValue();
}
public float getMin()
{
return (new Float(m_minField.getText())).floatValue();
}
public boolean clickedOK()
{
return m_bOK;
}
}
/***************
FILE LoadImageDialog.java
***************/
import java.awt.*;
import java.awt.event.*;
/*
// header - edit "Data/yourJavaHeader" to customize
// contents - edit "EventHandlers/Java file/onCreate" to customize
//
*/
class LoadImageDialog extends Dialog implements ActionListener,WindowListener
{
protected TextField m_path = new TextField("http://",50);
protected int m_type;
public static final int TYPE_NEW = 0;
public static final int TYPE_ADD = 1;
public static final int TYPE_SUBTRACT = 2;
public static final int TYPE_MULTIPLY = 3;
public static final int TYPE_DIVIDE = 4;
protected final String OK = "Okay";
protected final String CANCEL = "Cancel";
protected boolean m_bOK = false;//set to true when the user clicks
"Okay"
protected Frame m_parent;
public LoadImageDialog(Frame parent,int type)
{
super(parent,"Load URL image");
setModal(false);
setResizable(false);
setLocation(parent.getLocation());
m_type = type;
addWindowListener(this);
//Okay and Cancel buttons
Panel OKPanel = new Panel();
Button OKButton = new Button(OK);
Button CancelButton = new Button(CANCEL);
OKButton.addActionListener(this);
CancelButton.addActionListener(this);
OKPanel.add(OKButton);
OKPanel.add(CancelButton);
add(OKPanel,BorderLayout.SOUTH);
//text
Panel textPanel = new Panel();
Label text = new Label();
switch(m_type)
{
case TYPE_NEW: text.setText("Enter path of image to open:");
break;
case TYPE_ADD: text.setText("Enter path of image to add
to current image:");
break;
case TYPE_SUBTRACT: text.setText("Enter path of image
to subtract from current image:");
break;
case TYPE_MULTIPLY: text.setText("Enter path of image
to multiply with current image:");
break;
case TYPE_DIVIDE: text.setText("Enter path of image to
divide with current image:");
break;
default:
text.setText("An error occurred. Click Okay.");
break;
}
textPanel.add(text);
add(textPanel,BorderLayout.NORTH);
//edit box
Panel pathPanel = new Panel();
pathPanel.add(m_path);
add(pathPanel,BorderLayout.CENTER);
}
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand() == OK)
{
m_bOK = true;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
else if (e.getActionCommand() == CANCEL)
{
m_bOK = false;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
}
//implemented functions from WindowListener
public void windowClosing(WindowEvent e)
{
if (e.getComponent() == this)
{
this.dispose();
}
}
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public int getType()
{
return m_type;
}
public String getPath()
{
return m_path.getText();
}
public boolean clickedOK()
{
return m_bOK;
}
}
/**************
FILE NewImageDialog.java
*************/
import java.awt.event.*;
import java.awt.*;
/*
// header - edit "Data/yourJavaHeader" to customize
// contents - edit "EventHandlers/Java file/onCreate" to customize
//
*/
class NewImageDialog extends Dialog implements ActionListener,ItemListener,WindowListener
{
protected TextField sizeX,sizeY,color,meanX,meanY,stdDeviation,stripefrequency,sinfrequency,phase,color1,color2;
protected Choice type,ramporientation,sinorientation,stripeorientation,direction;
protected Panel uniformPanel = new Panel();
protected Panel rampPanel = new Panel();
protected Panel gaussianPanel = new Panel();
protected Panel sinusoidalPanel = new Panel();
protected Panel stripesPanel = new Panel();
protected Panel currentPanel = null;
protected String m_type;
public static final String SINUSOIDAL = "Sinusoidal";
public static final String UNIFORM = "Uniform";
public static final String RAMP = "Ramp";
public static final String GAUSSIAN = "Gaussian";
public static final String STRIPES = "Stripes";
public static final String HORIZONTAL = "Horizontal";
public static final String VERTICAL = "Vertical";
public static final String ASCENDING = "Ascending";
public static final String DESCENDING = "Descending";
protected final String OK = "Okay";
protected final String CANCEL = "Cancel";
protected boolean m_bOK = false;//set to true when the user clicks "Okay"
protected Frame m_parent;
public NewImageDialog(Frame parent)
{
super(parent,"Create New Image");
m_parent = parent;
//non modal, non resizable dialog
setModal(false);
setResizable(false);
addWindowListener(this);
Panel OKPanel = new Panel();
Panel typeSizePanel = new Panel();
Label colorlabel,sizeXlabel,sizeYlabel,meanXlabel,meanYlabel,stdDeviationlabel,stripefrequencylabel,
sinfrequencylabel,phaselabel,color1label,color2label,ramporientationlabel,typelabel,sinorientationlabel,
stripeorientationlabel,directionlabel;
Button OKButton = new Button(OK);
Button CancelButton = new Button(CANCEL);
OKButton.addActionListener(this);
CancelButton.addActionListener(this);
OKPanel.add(OKButton);
OKPanel.add(CancelButton);
typelabel = new Label("Type");
type = new Choice();
type.add(UNIFORM);
type.add(RAMP);
type.add(GAUSSIAN);
type.add(SINUSOIDAL);
type.add(STRIPES);
type.addItemListener(this);
sizeXlabel = new Label("Width");
sizeYlabel = new Label("Height");
sizeX = new TextField("300",5);
sizeY = new TextField("300",5);
typeSizePanel.setLayout(new GridLayout(2,3));
typeSizePanel.add(typelabel);
typeSizePanel.add(sizeXlabel);
typeSizePanel.add(sizeYlabel);
typeSizePanel.add(type);
typeSizePanel.add(sizeX);
typeSizePanel.add(sizeY);
colorlabel = new Label("Color");
color = new TextField("0",5);
meanXlabel = new Label("Mean X");
meanX = new TextField("0",5);
meanYlabel = new Label("Mean Y");
meanY = new TextField("255",5);
stdDeviationlabel = new Label("Std. Deviation");
stdDeviation = new TextField("8",5);
stripefrequencylabel = new Label("Frequency");
stripefrequency = new TextField("1",5);
sinfrequencylabel = new Label("Frequency");
sinfrequency = new TextField("1",5);
phaselabel = new Label("Phase");
phase = new TextField("255",5);
color1label = new Label("Color #1");
color1 = new TextField("0",5);
color2label = new Label("Color #2");
color2 = new TextField("255",5);
ramporientationlabel = new Label("Orientation");
ramporientation = new Choice();
ramporientation.add(HORIZONTAL);
ramporientation.add(VERTICAL);
sinorientationlabel = new Label("Orientation");
sinorientation = new Choice();
sinorientation.add(HORIZONTAL);
sinorientation.add(VERTICAL);
stripeorientationlabel = new Label("Orientation");
stripeorientation = new Choice();
stripeorientation.add(HORIZONTAL);
stripeorientation.add(VERTICAL);
directionlabel = new Label("Direction");
direction = new Choice();
direction.add(ASCENDING);
direction.add(DESCENDING);
uniformPanel.setLayout(new GridLayout(2,1));
uniformPanel.add(colorlabel);
uniformPanel.add(color);
rampPanel.setLayout(new GridLayout(2,2));
rampPanel.add(ramporientationlabel);
rampPanel.add(directionlabel);
rampPanel.add(ramporientation);
rampPanel.add(direction);
gaussianPanel.setLayout(new GridLayout(2,3));
gaussianPanel.add(meanXlabel);
gaussianPanel.add(meanYlabel);
gaussianPanel.add(stdDeviationlabel);
gaussianPanel.add(meanX);
gaussianPanel.add(meanY);
gaussianPanel.add(stdDeviation);
sinusoidalPanel.setLayout(new GridLayout(2,3));
sinusoidalPanel.add(sinfrequencylabel);
sinusoidalPanel.add(phaselabel);
sinusoidalPanel.add(sinorientationlabel);
sinusoidalPanel.add(sinfrequency);
sinusoidalPanel.add(phase);
sinusoidalPanel.add(sinorientation);
stripesPanel.setLayout(new GridLayout(2,4));
stripesPanel.add(color1label);
stripesPanel.add(color2label);
stripesPanel.add(stripefrequencylabel);
stripesPanel.add(stripeorientationlabel);
stripesPanel.add(color1);
stripesPanel.add(color2);
stripesPanel.add(stripefrequency);
stripesPanel.add(stripeorientation);
add(OKPanel,BorderLayout.SOUTH);
add(typeSizePanel,BorderLayout.NORTH);
//starts off with uniform selected
type.select(UNIFORM);
m_type = UNIFORM;
add(uniformPanel,BorderLayout.CENTER);
currentPanel = uniformPanel;
setSize(getPreferredSize());
}
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand() == OK)
{
m_bOK = true;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
else if (e.getActionCommand() == CANCEL)
{
m_bOK = false;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
}
public void itemStateChanged(ItemEvent e)
{
if (e.getStateChange() == ItemEvent.SELECTED)
{
if (e.getItem() instanceof String)
{
String selected = (String)e.getItem();
remove(currentPanel);
if (selected == SINUSOIDAL)
{
currentPanel = sinusoidalPanel;
m_type = selected;
}
else if (selected == UNIFORM)
{
currentPanel = uniformPanel;
m_type = selected;
}
else if (selected == GAUSSIAN)
{
currentPanel = gaussianPanel;
m_type = selected;
}
else if (selected == RAMP)
{
currentPanel = rampPanel;
m_type = selected;
}
else if (selected == STRIPES)
{
currentPanel = stripesPanel;
m_type = selected;
}
else
{
}
add(currentPanel,BorderLayout.CENTER);
validate();
setSize(getPreferredSize());
validate();
}
else
{
}
}
}
//implemented functions from WindowListener
public void windowClosing(WindowEvent e)
{
if (e.getComponent() == this)
{
this.dispose();
}
}
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public String getType()
{
return m_type;
}
public float getColor()
{
return (new Float(color.getText())).floatValue();
}
public float getColor1()
{
return (new Float(color1.getText())).floatValue();
}
public float getColor2()
{
return (new Float(color2.getText())).floatValue();
}
public String getDirection()
{
return direction.getSelectedItem();
}
public float getMeanX()
{
return (new Float(meanX.getText())).floatValue();
}
public float getMeanY()
{
return (new Float(meanY.getText())).floatValue();
}
public float getPhase()
{
return (new Float(phase.getText())).floatValue();
}
public String getOrientation()
{
if (m_type == SINUSOIDAL)
{
return sinorientation.getSelectedItem();
}
else if (m_type == STRIPES)
{
return stripeorientation.getSelectedItem();
}
else//ramp is default
{
return ramporientation.getSelectedItem();
}
}
public float getFrequency()
{
if (m_type == SINUSOIDAL)
{
return (new Float(sinfrequency.getText())).floatValue();
}
else//stripe is default
{
return (new Float(stripefrequency.getText())).floatValue();
}
}
public int getImageWidth()
{
return (new Integer(sizeX.getText())).intValue();
}
public int getImageHeight()
{
return (new Integer(sizeY.getText())).intValue();
}
public float getStdDeviation()
{
return (new Float(stdDeviation.getText())).floatValue();
}
public boolean clickedOK()
{
return m_bOK;
}
}
/*****************
FILE NoiseDialog.java
****************/
import java.awt.event.*;
import java.awt.*;
/*
// header - edit "Data/yourJavaHeader" to customize
// contents - edit "EventHandlers/Java file/onCreate" to customize
//
*/
class NoiseDialog extends Dialog implements ActionListener,ItemListener,WindowListener
{
protected TextField m_stdDeviation,m_range;
protected Choice m_typeChoice;
protected Panel m_uniformPanel = new Panel();
protected Panel m_gaussianPanel = new Panel();
protected Panel m_currentPanel = null;
protected int m_type;
public static final String UNIFORM = "Uniform";
public static final String GAUSSIAN = "Gaussian";
public static final String POISSON = "Poisson";
public static final int TYPE_UNIFORM = 0;
public static final int TYPE_GAUSSIAN = 1;
public static final int TYPE_POISSON = 2;
protected final String OK = "Okay";
protected final String CANCEL = "Cancel";
protected boolean m_bOK = false;//set to true when the user clicks "Okay"
protected Frame m_parent;
public NoiseDialog(Frame parent)
{
super(parent,"Noise Type");
m_parent = parent;
//non modal, non resizable dialog
setModal(false);
setResizable(false);
addWindowListener(this);
Panel OKPanel = new Panel();
Panel typePanel = new Panel();
Label stdDevLabel,rangeLabel;
Button OKButton = new Button(OK);
Button CancelButton = new Button(CANCEL);
OKButton.addActionListener(this);
CancelButton.addActionListener(this);
OKPanel.add(OKButton);
OKPanel.add(CancelButton);
add(OKPanel,BorderLayout.SOUTH);
Label typelabel = new Label("Select noise type:");
m_typeChoice = new Choice();
m_typeChoice.add(UNIFORM);
m_typeChoice.add(GAUSSIAN);
m_typeChoice.add(POISSON);
m_typeChoice.addItemListener(this);
typePanel.add(typelabel);
typePanel.add(m_typeChoice);
add(typePanel,BorderLayout.NORTH);
rangeLabel = new Label("Range (0 - 255): ");
m_range = new TextField("0",3);
m_uniformPanel.add(rangeLabel);
m_uniformPanel.add(m_range);
stdDevLabel = new Label("Std. Deviation: ");
m_stdDeviation = new TextField("0",3);
m_gaussianPanel.add(stdDevLabel);
m_gaussianPanel.add(m_stdDeviation);
//starts off with uniform selected
m_typeChoice.select(UNIFORM);
m_type = TYPE_UNIFORM;
add(m_uniformPanel,BorderLayout.CENTER);
m_currentPanel = m_uniformPanel;
setSize(getPreferredSize());
}
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand() == OK)
{
m_bOK = true;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
else if (e.getActionCommand() == CANCEL)
{
m_bOK = false;
processWindowEvent(new WindowEvent(this,WindowEvent.WINDOW_CLOSING));
}
}
public void itemStateChanged(ItemEvent e)
{
if (e.getStateChange() == ItemEvent.SELECTED)
{
if (e.getItem() instanceof String)
{
String selected = (String)e.getItem();
if (m_currentPanel != null)
{
remove(m_currentPanel);
}
if (selected == UNIFORM)
{
m_currentPanel = m_uniformPanel;
m_type = TYPE_UNIFORM;
add(m_currentPanel,BorderLayout.CENTER);
}
else if (selected == GAUSSIAN)
{
m_currentPanel = m_gaussianPanel;
m_type = TYPE_GAUSSIAN;
add(m_currentPanel,BorderLayout.CENTER);
}
else if (selected == POISSON)
{
m_currentPanel = null;
m_type = TYPE_POISSON;
}
else
{
}
validate();
setSize(getPreferredSize());
validate();
}
else
{
}
}
}
//implemented functions from WindowListener
public void windowClosing(WindowEvent e)
{
if (e.getComponent() == this)
{
this.dispose();
}
}
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public int getType()
{
return m_type;
}
public float getRange()
{
return (new Float(m_range.getText())).floatValue();
}
public float getStdDeviation()
{
return (new Float(m_stdDeviation.getText())).floatValue();
}
public boolean clickedOK()
{
return m_bOK;
}
}
/*******************
FILE WarpOpDialog.java
*******************/
import java.awt.event.*;
import java.awt.*;
/*
// header - edit "Data/yourJavaHeader" to customize
/