protected void fileSaveXML() {
JFileChooser chooser = null;
if (currentFile == null) {
chooser = new JFileChooser(startDirectory);
} else {
chooser = new JFileChooser(currentFile);
}
int returnVal = chooser.showSaveDialog(gw);
if (returnVal == JFileChooser.APPROVE_OPTION) {
currentFile = chooser.getSelectedFile();
generalXML.saveGraph(currentFile);
}
}
protected void fileOpenXML() {
JFileChooser chooser = null;
if (currentFile == null) {
chooser = new JFileChooser(startDirectory);
} else {
chooser = new JFileChooser(currentFile);
}
int returnVal = chooser.showOpenDialog(gw);
if (returnVal == JFileChooser.APPROVE_OPTION) {
currentFile = chooser.getSelectedFile();
generalXML.loadGraph(currentFile);
}
gp.update(gp.getGraphics());
}
protected void fileSaveSimple() {
JFileChooser chooser = null;
if (currentFile == null) {
chooser = new JFileChooser(startDirectory);
} else {
chooser = new JFileChooser(currentFile);
if (!currentFile.isDirectory()) {
chooser.setSelectedFile(currentFile);
}
}
int returnVal = chooser.showSaveDialog(gw);
if (returnVal == JFileChooser.APPROVE_OPTION) {
currentFile = chooser.getSelectedFile();
graph.saveSimple(currentFile);
}
}
/** Open a file and load the image. */
public void openFile() {
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File("."));
String[] extensions = ImageIO.getReaderFileSuffixes();
chooser.setFileFilter(new FileNameExtensionFilter("Image files", extensions));
int r = chooser.showOpenDialog(this);
if (r != JFileChooser.APPROVE_OPTION) return;
try {
Image img = ImageIO.read(chooser.getSelectedFile());
image =
new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_RGB);
image.getGraphics().drawImage(img, 0, 0, null);
} catch (IOException e) {
JOptionPane.showMessageDialog(this, e);
}
repaint();
}
/** ****************** Open & Read an Image ********************** */
void OpenImage2() {
int returnVal = jfc.showOpenDialog(IPToolKit.this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
file1 = jfc.getSelectedFile();
String path = file.getAbsolutePath();
// image = Toolkit.getDefaultToolkit().getImage(path);
try {
try {
inImage1 = new FileImageInputStream(file1);
len1 = (int) inImage1.length();
byteArray1 = new byte[len1];
// System.out.println(len);
inImage1.read(byteArray1, 0, len1);
image1 = Toolkit.getDefaultToolkit().createImage(byteArray1);
MediaTracker t = new MediaTracker(this);
t.addImage(image1, 0);
try {
t.waitForID(1);
} catch (Exception eeee) {
System.out.println(eeee);
}
w1 = image1.getWidth(null);
h1 = image1.getHeight(null);
// System.out.println(w+"\t"+h);
} catch (Exception fnfe) {
JOptionPane.showMessageDialog(this, "File: Not Found");
}
} catch (Exception ice) {
JOptionPane.showMessageDialog(this, "File I/O Error");
}
}
}
protected void filePNG() {
JFileChooser chooser = null;
File pngFile = null;
if (currentFile == null) {
chooser = new JFileChooser(startDirectory);
} else {
pngFile = new File(currentFile.getName() + ".png");
chooser = new JFileChooser(pngFile);
if (!currentFile.isDirectory()) {
chooser.setSelectedFile(currentFile);
}
}
if (pngFile == null) return;
try {
BufferedImage image = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
paint(image.getGraphics());
ImageIO.write(image, "png", pngFile);
} catch (Exception e) {
}
return;
/* JFileChooser chooser = null;
File pngFile = null;
if (currentFile == null) {
chooser = new JFileChooser(startDirectory);
} else {
pngFile = new File(currentFile.getName()+".png");
chooser = new JFileChooser(pngFile);
if (!currentFile.isDirectory()) {
chooser.setSelectedFile(currentFile);
}
}
int returnVal = chooser.showSaveDialog(gw);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File pngFile = chooser.getSelectedFile();
int maxX = Integer.MIN_VALUE;
int minX = Integer.MAX_VALUE;
int maxY = Integer.MIN_VALUE;
int minY = Integer.MAX_VALUE;
while(Node node : getNodes()) {
if(node.getX() > maxX) {
maxX = node.getX();
}
if(node.getX() < minX) {
minX = node.getX();
}
if(node.getY() > maxY) {
maxY = node.getY();
}
if(node.getY() < minY) {
minY = node.getY();
}
}
BufferedImage image = new BufferedImage(maxX-minX+50,maxY-minY+50,BufferedImage.TYPE_INT_RGB);
ImageIO.write(image,"png",pngFile);
}
*/ }
public void actionPerformed(ActionEvent e) {
if (e.getSource() == b) {
JFrame frame2 = new JFrame();
JFileChooser chooser = new JFileChooser(".");
int option =
chooser.showOpenDialog(
frame2); // parentComponent must a component like JFrame, JDialog...
if (option == JFileChooser.APPROVE_OPTION) {
File selectedFile = chooser.getSelectedFile();
path = selectedFile.getAbsolutePath();
}
try {
loadImage();
} catch (IOException ioe) {
System.out.println(ioe.getMessage());
}
} else if (e.getSource() == c) {
gaussianBlur();
// filtered = grayscale.filter(filtered, null);
sobel();
// thinImage();
nonMax();
float lowThreshold = 2.5f;
float highThreshold = 7.5f;
int low = Math.round(lowThreshold * MAGNITUDE_SCALE);
int high = Math.round(highThreshold * MAGNITUDE_SCALE);
performHysteresis(low, high);
thresholdEdges();
writeEdges(data);
Hough();
ImageIcon icon1 = new ImageIcon(res);
lbl1.setIcon(icon1);
ImageIcon icon2 = new ImageIcon(filtered);
lbl2.setIcon(icon2);
filterBtn.setSelected(true);
}
if (e.getSource() == findCircles) {
try {
accSize = Integer.parseInt(inputCircles.getText());
res = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics g = res.getGraphics();
g.drawImage(img, 0, 0, null);
g.dispose();
findMaxima();
ImageIcon icon1 = new ImageIcon(res);
lbl1.setIcon(icon1);
} catch (Exception err) {
System.out.println("Not a valid integer");
}
} else if (e.getSource() == filterBtn) {
ImageIcon icon2 = new ImageIcon(filtered);
lbl2.setIcon(icon2);
} else if (e.getSource() == sobelBtn) {
ImageIcon icon2 = new ImageIcon(sobel);
lbl2.setIcon(icon2);
} else if (e.getSource() == nonMaxBtn) {
ImageIcon icon2 = new ImageIcon(nonMax);
lbl2.setIcon(icon2);
} else if (e.getSource() == accumulator) {
buildAccumulator(whichRadius.getValue());
}
}
public void actionPerformed(ActionEvent e) {
String arg = (String) e.getActionCommand();
/** ******************** Open an Image **************** */
if (e.getSource() == m_Open) {
int returnVal = jfc.showOpenDialog(IPToolKit.this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
file = jfc.getSelectedFile();
String path = file.getAbsolutePath();
// image = Toolkit.getDefaultToolkit().getImage(path);
try {
try {
inImage = new FileImageInputStream(file);
len = (int) inImage.length();
byteArray = new byte[len];
// System.out.println(len);
inImage.read(byteArray, 0, len);
image = Toolkit.getDefaultToolkit().createImage(byteArray);
MediaTracker t = new MediaTracker(this);
t.addImage(image, 0);
try {
t.waitForID(0);
} catch (Exception eeee) {
System.out.println(eeee);
}
w = image.getWidth(null);
h = image.getHeight(null);
// System.out.println(w+"\t"+h);
} catch (Exception fnfe) {
JOptionPane.showMessageDialog(this, "File: Not Found");
}
} catch (Exception ice) {
JOptionPane.showMessageDialog(this, "File I/O Error");
}
}
if (image != null) {
pix_temp = new int[h * w];
ImageIcon icon = new ImageIcon(image);
lbl_img.setIcon(icon);
setVisible(true);
}
pix_temp = pixel_grab(image, w, h);
pix_temp = pix_pack(pix_temp, w, h);
grayImageDisplay(w, h, pix_temp);
}
/** ****************** Add one image to another ************** */
if (e.getSource() == mAddImg) {
OpenImage2();
pix_temp1 = new int[w * h];
pix_res = new int[w * h];
pix_temp1 = pixel_grab(image1, w1, h1);
pix_temp1 = pix_pack(pix_temp1, w1, h1);
for (int s = 0; s < w * h; s++) {
pix_res[s] = pix_temp[s] + pix_temp1[s];
}
;
pix_temp1 = saturate(pix_temp1, w, h);
imageResultDisplay(w, h, pix_res);
}
/**
* *********************** Add Constant value and then use Satuartion technique ***************
*/
if (e.getSource() == mAddSat) {
String add_value;
Image img_add = image;
pixel_add = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
add_value = JOptionPane.showInputDialog("Enter Value you wish to add to the image");
int number = Integer.parseInt(add_value);
for (int r = 0; r < w * h; r++) {
pixel_add[r] = number + pixel_result[r];
}
pixel_add = saturate(pixel_add, w, h);
pixel_add = pix_pack(pixel_add, w, h);
imageResultDisplay(w, h, pixel_add);
}
/** ************ Add constant by Wrap Around technique ********** */
if (e.getSource() == mAddWrap) {
String add_value;
Image img_add = image;
pixel_add = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
add_value = JOptionPane.showInputDialog("Enter Value you wish to add to the image");
int number = Integer.parseInt(add_value);
for (int r = 0; r < w * h; r++) {
pixel_add[r] = number + pixel_result[r];
}
pixel_add = WrapAround(pixel_add, w, h);
pixel_add = pix_pack(pixel_add, w, h);
imageResultDisplay(w, h, pixel_add);
}
/** ****************** Subtract one image from another ************** */
if (e.getSource() == mSubImg) {
OpenImage2();
pix_temp1 = new int[w * h];
pix_res = new int[w * h];
pix_temp1 = pixel_grab(image1, w1, h1);
pix_temp1 = pix_pack(pix_temp1, w1, h1);
for (int s = 0; s < w * h; s++) {
pix_res[s] = pix_temp[s] - pix_temp1[s];
}
pix_temp1 = saturate(pix_temp1, w1, h1);
imageResultDisplay(w1, h1, pix_res);
}
/**
* *********************** Subtract Constant value and then use Satuartion technique
* ***************
*/
if (e.getSource() == mSubSat) {
String sub_value;
Image img_add = image;
pixel_sub = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
sub_value = JOptionPane.showInputDialog("Enter Value you wish to subtract from the image");
int number = Integer.parseInt(sub_value);
for (int r = 0; r < w * h; r++) {
pixel_sub[r] = pixel_result[r] - number;
}
pixel_sub = saturate(pixel_sub, w, h);
pixel_sub = pix_pack(pixel_sub, w, h);
imageResultDisplay(w, h, pixel_sub);
}
/** ************ Subtract constant by Wrap Around technique ********** */
if (e.getSource() == mSubWrap) {
String sub_value;
Image img_add = image;
pixel_sub = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
sub_value = JOptionPane.showInputDialog("Enter Value you wish to add to the image");
int number = Integer.parseInt(sub_value);
for (int r = 0; r < w * h; r++) {
pixel_sub[r] = pixel_result[r] - number;
}
pixel_sub = WrapAround(pixel_sub, w, h);
pixel_sub = pix_pack(pixel_sub, w, h);
imageResultDisplay(w, h, pixel_sub);
}
/** ****************** Multiply one image with another ************** */
if (e.getSource() == mMulImg) {
OpenImage2();
pix_temp1 = new int[w * h];
pix_res = new int[w * h];
pix_temp1 = pixel_grab(image1, w1, h1);
pix_temp1 = pix_pack(pix_temp1, w1, h1);
for (int s = 0; s < w * h; s++) {
pix_res[s] = pix_temp[s] * pix_temp1[s];
}
pix_temp1 = saturate(pix_temp1, w1, h1);
imageResultDisplay(w1, h1, pix_res);
}
/**
* *********************** Multiply Constant value and then use Satuartion technique
* ***************
*/
if (e.getSource() == mMulSat) {
String mul_value;
Image img_mul = image;
pixel_mul = new int[w * h];
pixel_result = pixel_grab(img_mul, w, h);
mul_value = JOptionPane.showInputDialog("Enter Value you wish to multiply to the image");
int number = Integer.parseInt(mul_value);
for (int r = 0; r < w * h; r++) {
pixel_mul[r] = pixel_result[r] * number;
}
pixel_mul = saturate(pixel_mul, w, h);
pixel_mul = pix_pack(pixel_mul, w, h);
imageResultDisplay(w, h, pixel_mul);
}
/** ************ Multiply constant by Wrap Around technique ********** */
if (e.getSource() == mMulWrap) {
String mul_value;
Image img_mul = image;
pixel_mul = new int[w * h];
pixel_result = pixel_grab(img_mul, w, h);
mul_value = JOptionPane.showInputDialog("Enter Value you wish to multiply to the image");
int number = Integer.parseInt(mul_value);
for (int r = 0; r < w * h; r++) {
pixel_mul[r] = pixel_result[r] * number;
}
pixel_mul = WrapAround(pixel_mul, w, h);
pixel_mul = pix_pack(pixel_mul, w, h);
imageResultDisplay(w, h, pixel_mul);
}
/** ****************** Divide one image by another ************** */
if (e.getSource() == mDivImg) {
OpenImage2();
pix_temp1 = new int[w * h];
pix_res = new int[w * h];
pix_temp1 = pixel_grab(image1, w1, h1);
pix_temp1 = pix_pack(pix_temp1, w1, h1);
for (int s = 0; s < w * h; s++) {
pix_res[s] = pix_temp1[s] / pix_temp[s];
}
// pix_temp1 = saturate(pix_temp1,w1,h1);
pix_temp1 = WrapAround(pix_temp1, w, h);
imageResultDisplay(w1, h1, pix_res);
}
/**
* *********************** Divide by Constant value and then use Saturation technique
* ***************
*/
if (e.getSource() == mDivSat) {
String div_value;
Image img_add = image;
pixel_div = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
div_value = JOptionPane.showInputDialog("Enter value to divide the image by");
int number = Integer.parseInt(div_value);
for (int r = 0; r < w * h; r++) {
pixel_div[r] = pixel_result[r] / number;
}
pixel_div = saturate(pixel_div, w, h);
pixel_div = pix_pack(pixel_div, w, h);
imageResultDisplay(w, h, pixel_div);
}
/** ************ Divide constant by Wrap Around technique ********** */
if (e.getSource() == mDivWrap) {
String div_value;
Image img_add = image;
pixel_div = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
div_value = JOptionPane.showInputDialog("Enter value to divide image by");
int number = Integer.parseInt(div_value);
for (int r = 0; r < w * h; r++) {
pixel_div[r] = pixel_result[r] / number;
}
pixel_div = WrapAround(pixel_div, w, h);
pixel_div = pix_pack(pixel_div, w, h);
imageResultDisplay(w, h, pixel_div);
}
/** ******************** Thresholding ************* */
if (e.getSource() == mThreshold) {
String thresh_value;
Image img_add = image;
pixel_result = pixel_grab(img_add, w, h);
thresh_value = JOptionPane.showInputDialog("Enter value to threshold the image");
int number = Integer.parseInt(thresh_value);
for (int r = 0; r < w * h; r++) {
if (pixel_result[r] >= number) pixel_result[r] = 255;
else if (pixel_result[r] <= number) pixel_result[r] = 0;
}
pixel_result = pix_pack(pixel_result, w, h);
imageResultDisplay(w, h, pixel_result);
}
if (e.getSource() == m_Save) {
FileImageOutputStream src_img;
int returnVal = jfc.showSaveDialog(IPToolKit.this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File fileR = jfc.getSelectedFile();
String fileToSave = file.getAbsolutePath();
if (!fileToSave.toLowerCase().endsWith(".jpg")) {
fileR = new File(fileToSave + ".jpg");
}
try {
src_img = new FileImageOutputStream(fileR);
buf_img = getImageFromArray(pixel_result, w, h);
ImageIO.write(buf_img, "jpg", src_img);
} catch (IOException ex8) {
System.out.println(ex8);
}
}
// }
}
/** ***************************** Increase brightness **************** */
if (e.getSource() == mBright) {
String bright_value;
Image img_add = image;
pixel_result = pixel_grab(img_add, w, h);
bright_value = JOptionPane.showInputDialog("Enter value to increase brightness");
int number = Integer.parseInt(bright_value);
for (int r = 0; r < w * h; r++) {
pixel_result[r] = pixel_result[r] + number;
}
pixel_result = saturate(pixel_result, w, h);
pixel_result = pix_pack(pixel_result, w, h);
imageResultDisplay(w, h, pixel_result);
}
/** ****************** Contrast Strtching *************** */
if (e.getSource() == mContrast) {
String cont_value1, cont_value2;
Image img_add = image;
pixel_cont = new int[w * h];
pixel_result = pixel_grab(img_add, w, h);
cont_value1 = JOptionPane.showInputDialog("Enter lower limit for contrast stretch");
int number = Integer.parseInt(cont_value1);
cont_value2 = JOptionPane.showInputDialog("Enter higher limit for contrast stretch");
int number1 = Integer.parseInt(cont_value2);
for (int r = 0; r < w * h; r++) {
if (pixel_result[r] <= number1) {
pixel_cont[r] = pixel_result[r] - 50;
if (pixel_cont[r] < 0) pixel_cont[r] = 0;
} else if (pixel_result[r] >= number) {
pixel_cont[r] = pixel_result[r] + 50;
if (pixel_cont[r] > 255) pixel_cont[r] = 255;
} else pixel_cont[r] = pixel_result[r];
}
pixel_cont = saturate(pixel_cont, w, h);
pixel_cont = pix_pack(pixel_cont, w, h);
imageResultDisplay(w, h, pixel_cont);
}
/** ******************* Low Pass Filter ****************** */
if (e.getSource() == mlowPass) {
int mask[][] = {{1, 1, 1}, {1, 1, 1}, {1, 1, 1}};
pixel_result = pixel_grab(image, w, h);
int pix_tempLow[][] = new int[h][w];
pix_tempLow = OneD_ArrayToTwoD_Array(w, h, pixel_result);
pix_tempLow = MaskOperation(w, h, pix_tempLow, mask);
int pix_temp1D[] = new int[(w) * (h)];
pix_temp1D = TwoD_ArrayToOneD_Array(w, h, pix_tempLow);
pix_temp1D = restrict(pix_temp1D);
pix_temp1D = pix_pack(pix_temp1D, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_temp1D);
}
/** ********************* High Pass Filter *************** */
if (e.getSource() == mhighPass) {
int mask[][] = {{-1, -1, -1}, {-1, 8, -1}, {-1, -1, -1}};
pixel_result = pixel_grab(image, w, h);
int pix_tempLow[][] = new int[h][w];
pix_tempLow = OneD_ArrayToTwoD_Array(w, h, pixel_result);
pix_tempLow = MaskOperation(w, h, pix_tempLow, mask);
int pix_temp1D[] = new int[(w) * (h)];
pix_temp1D = TwoD_ArrayToOneD_Array(w, h, pix_tempLow);
pix_temp1D = saturate(pix_temp1D, w - 2, h - 2);
pix_temp1D = restrict(pix_temp1D);
pix_temp1D = pix_pack(pix_temp1D, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_temp1D);
}
/** *************************** High Boost Filter **************** */
if (e.getSource() == mhighBoost) {
int mask[][] = {{-1, -1, -1}, {-1, 9, -1}, {-1, -1, -1}};
pixel_result = pixel_grab(image, w, h);
int pix_tempLow[][] = new int[h][w];
pix_tempLow = OneD_ArrayToTwoD_Array(w, h, pixel_result);
pix_tempLow = MaskOperation(w, h, pix_tempLow, mask);
int pix_temp1D[] = new int[(w) * (h)];
pix_temp1D = TwoD_ArrayToOneD_Array(w, h, pix_tempLow);
pix_temp1D = saturate(pix_temp1D, w - 2, h - 2);
pix_temp1D = restrict(pix_temp1D);
pix_temp1D = pix_pack(pix_temp1D, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_temp1D);
}
if (e.getSource() == m_Save) {
for (int i = 0; i < w * h; i++) {
System.out.println(pixel_result[i]);
}
FileImageOutputStream src_img;
int returnVal = jfc.showSaveDialog(IPToolKit.this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File fileR = jfc.getSelectedFile();
String fileToSave = file.getAbsolutePath();
if (!fileToSave.toLowerCase().endsWith(".jpg")) {
fileR = new File(fileToSave + ".jpg");
}
try {
src_img = new FileImageOutputStream(fileR);
buf_img = getImageFromArray(pixel_result, w, h);
ImageIO.write(buf_img, "jpg", src_img);
} catch (IOException ex8) {
System.out.println(ex8);
}
}
}
/** ********************* Invert and image ************ */
if (e.getSource() == mInvert) {
Image img_Invert = image;
pixel_result = new int[w * h];
pixel_result = pixel_grab(img_Invert, w, h);
for (int r = 0; r < w * h; r++) {
pixel_result[r] = 255 - pixel_result[r];
}
// pixel_div = saturate(pixel_div,w,h);
pixel_result = pix_pack(pixel_result, w, h);
imageResultDisplay(w, h, pixel_result);
}
/** *************************** Median Filter **************** */
if (arg.equals("Median")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = median_filter(p2d);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Prewits Horizontal Edge Detection ******************* */
if (arg.equals("Prewits Horizontal")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
int mask[][] = {{-1, -1, -1}, {0, 0, 0}, {1, 1, 1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres = saturate(pres, w - 2, h - 2);
pres = restrict(pres);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Prewits Vertical Edge Detection ******************* */
if (arg.equals("Prewits Vertical")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
int mask[][] = {{-1, 0, 1}, {-1, 0, 1}, {-1, 0, 1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres = saturate(pres, w - 2, h - 2);
pres = restrict(pres);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Prewits Edge Detection ******************* */
if (arg.equals("Prewits Both")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres1[] = new int[h * w];
int pres2[] = new int[h * w];
int pres[] = new int[h * w];
int mask1[][] = {{-1, -1, -1}, {0, 0, 0}, {1, 1, 1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask1);
pres1 = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres1 = saturate(pres1, w - 2, h - 2);
pres1 = restrict(pres1);
int mask2[][] = {{-1, 0, 1}, {-1, 0, 1}, {-1, 0, 1}};
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask2);
pres2 = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres2 = saturate(pres2, w - 2, h - 2);
pres2 = restrict(pres2);
for (int i = 0; i < ((h - 2) * (w - 2)); i++) {
pres[i] = pres1[i] + pres2[i];
}
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Sobel Horizontal Edge Detection ******************* */
if (arg.equals("Sobel Horizontal")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
int mask[][] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres = saturate(pres, w - 2, h - 2);
pres = restrict(pres);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Sobel Vertical Edge Detection ******************* */
if (arg.equals("Sobel Vertical")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
int mask[][] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres = saturate(pres, w - 2, h - 2);
pres = restrict(pres);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Sobel Edge Detection ******************* */
if (arg.equals("Sobel Both")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres1[] = new int[h * w];
int pres2[] = new int[h * w];
int pres[] = new int[h * w];
int mask1[][] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask1);
pres1 = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres1 = saturate(pres1, w - 2, h - 2);
pres1 = restrict(pres1);
int mask2[][] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask2);
pres2 = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres2 = saturate(pres2, w - 2, h - 2);
pres2 = restrict(pres2);
for (int i = 0; i < ((h - 2) * (w - 2)); i++) {
pres[i] = pres1[i] + pres2[i];
}
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Roberts Edge Detection ******************* */
if (arg.equals("Roberts")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
int mask[][] = {{1, 0}, {0, -1}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
for (int i = 1; i < h - 1; i++) {
for (int j = 1; j < w - 1; j++) {
pp2d[i][j] =
((mask[0][0] * p2d[i - 1][j - 1] + mask[1][0] * p2d[i + 1][j - 1])
+ (mask[0][1] * p2d[i - 1][j + 1] + mask[1][1] * p2d[i + 1][j + 1]))
/ 2;
}
}
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres = saturate(pres, w - 2, h - 2);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Mean Filter ******************* */
if (arg.equals("Mean")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = mean_filt(p2d);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Laplacian Edge Detector ******************* */
if (arg.equals("Laplacian")) {
int[] pix_grabed = new int[w * h];
int[][] p2d = new int[h][w];
int[][] pp2d = new int[h][w];
int pix_pcked[] = new int[w * h];
int pres[] = new int[h * w];
int mask[][] = {{0, -2, 0}, {-2, 8, -2}, {0, -2, 0}};
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
pp2d = MaskOperation(w, h, p2d, mask);
pres = TwoD_ArrayToOneD_Array(w, h, pp2d);
pres = saturate(pres, w - 2, h - 2);
pres = restrict(pres);
pix_pcked = pix_pack(pres, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pix_pcked);
}
/** ********************** Histogram Equalization ******************* */
if (arg.equals("Histogram Equalization")) {
int[] pix_grabed = new int[h * w];
int pres[] = new int[h * w];
int cnt_pix[] = new int[256];
int pixx[] = new int[h * w];
int pix_pcked[] = new int[h * w];
int pix_res[] = new int[h * w];
int len = h * w;
int res = 0;
pix_grabed = pixel_grab(image, w, h);
for (int i = 0; i < h * w; i++) {
pixx[i] = pix_grabed[i];
}
for (int i = 0; i < 256; i++) {
cnt_pix[i] = 0;
}
for (int i = 0; i < len; i++) {
int ind = pixx[i];
cnt_pix[ind]++;
}
for (int i = 0; i < w * h; i++) {
float a = 0;
for (int j = 0; j < (pixx[i] + 1); j++) {
float b = (float) cnt_pix[j];
float c = (float) (h * w);
a = a + (b / c);
}
res = (int) (a * 255);
if (res > 255) res = 255;
pix_res[i] = (0xff000000 | (res << 16) | (res << 8) | res);
}
pix_pcked = pix_pack(pix_res, w, h);
imageResultDisplay(w, h, pix_pcked);
}
if (arg.equals("Connected Component")) {
int pix_grabed[] = new int[h * w];
int p2d[][] = new int[h][w];
conect_input = new int[h][w];
conect_output = new int[h][w];
int x1 = x_cor;
int y1 = y_cor;
pix_grabed = pixel_grab(image, w, h);
p2d = OneD_ArrayToTwoD_Array(w, h, pix_grabed);
s = 0;
t = 0;
obj_size = 0;
intensity = p2d[y1][x1];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
conect_input[i][j] = p2d[i][j];
conect_output[i][j] = 0;
}
}
connect(y1, x1);
int pixx[] = new int[h * w];
int pp[] = new int[h * w];
pixx = TwoD_ArrayToOneD_Array(w, h, conect_output);
pixx = saturate(pixx, w - 2, h - 2);
pp = pix_pack(pixx, w - 2, h - 2);
imageResultDisplay(w - 2, h - 2, pp);
}
/** ********************** Blending ******************* */
if (arg.equals("Blending")) {
int size;
int hei, wid;
if (h1 > h) hei = h1;
else hei = h;
if (w1 > w) wid = w1;
else wid = w;
size = hei * wid;
int pix_img1[] = new int[size];
int pix_img2[] = new int[size];
int pix_res[] = new int[size];
int pixx[] = new int[h1 * w1];
double x = 0.5;
pix_img1 = pixel_grab(image, w, h);
OpenImage2();
pix_img2 = pixel_grab(image1, w1, h1);
// grayImageDisplay(w1,h1,pixx)
for (int i = 0; i < size; i++) {
pix_res[i] = (int) ((x * pix_img1[i]) + ((1 - x) * (pix_img2[i])));
}
int pix_pcked[] = new int[size];
pix_pcked = pix_pack(pix_res, wid, hei);
imageResultDisplay(wid, hei, pix_pcked);
}
/** ****************** Quit OR Exit **************** */
if (arg.equals("Exit")) {
System.exit(0);
}
}
public void actionPerformed(ActionEvent evt) {
Graphics g = getGraphics();
if (evt.getSource() == openItem) {
JFileChooser chooser = new JFileChooser();
common.chooseFile(chooser, "./images", 0); // 设置默认目录,过滤文件
int r = chooser.showOpenDialog(null);
if (r == JFileChooser.APPROVE_OPTION) {
String name = chooser.getSelectedFile().getAbsolutePath();
// 装载图像
iImage = common.openImage(name, new MediaTracker(this));
// 取载入图像的宽和高
iw = iImage.getWidth(null);
ih = iImage.getHeight(null);
bImage = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = bImage.createGraphics();
g2.drawImage(iImage, 0, 0, null);
loadflag = true;
repaint();
}
} else if (evt.getSource() == rotateItem) // 内置旋转
{
setTitle("第4章 图像几何变换 内置旋转 作者 孙燮华");
common.draw(g, iImage, bImage, common.getParam("旋转角(度):", "30"), 0, 0);
} else if (evt.getSource() == scaleItem) // 内置缩放
{
setTitle("第4章 图像几何变换 内置缩放 作者 孙燮华");
// 参数选择面板
Parameters pp = new Parameters("参数", "x方向:", "y方向:", "1.5", "1.5");
setPanel(pp, "内置缩放");
float x = pp.getPadx();
float y = pp.getPady();
common.draw(g, iImage, bImage, x, y, 1);
} else if (evt.getSource() == shearItem) // 内置错切
{
setTitle("第4章 图像几何变换 内置错切 作者 孙燮华");
Parameters pp = new Parameters("参数", "x方向:", "y方向:", "0.5", "0.5");
setPanel(pp, "内置错切");
float x = pp.getPadx();
float y = pp.getPady();
common.draw(g, iImage, bImage, x, y, 2);
} else if (evt.getSource() == transItem) // 内置平移
{
setTitle("第4章 图像几何变换 内置平移 作者 孙燮华");
Parameters pp = new Parameters("参数", "x方向:", "y方向:", "100", "50");
setPanel(pp, "内置平移");
float x = pp.getPadx();
float y = pp.getPady();
common.draw(g, iImage, bImage, x, y, 3);
} else if (evt.getSource() == rotItem) // 旋转算法
{
setTitle("第4章 图像几何变换 旋转算法 作者 孙燮华");
pix = common.grabber(iImage, iw, ih);
// 旋转,输出图像宽高
int owh = (int) (Math.sqrt(iw * iw + ih * ih + 0.5));
opix = geom.imRotate(pix, common.getParam("旋转角(度):", "30"), iw, ih, owh);
// 将数组中的象素产生一个图像
MemoryImageSource memoryImage =
new MemoryImageSource(owh, owh, ColorModel.getRGBdefault(), opix, 0, owh);
oImage = createImage(memoryImage);
common.draw(g, iImage, oImage, iw, ih, owh, 4);
} else if (evt.getSource() == mirItem) // 镜象算法(type:5)
{
setTitle("第4章 图像几何变换 镜象算法 作者 孙燮华");
Parameters pp = new Parameters("选择镜象类型", "水平", "垂直");
setPanel(pp, "镜象算法");
pix = common.grabber(iImage, iw, ih);
opix = geom.imMirror(pix, iw, ih, pp.getRadioState());
ImageProducer ip = new MemoryImageSource(iw, ih, opix, 0, iw);
oImage = createImage(ip);
common.draw(g, iImage, oImage, iw, ih, 0, 5);
} else if (evt.getSource() == shrItem) // 错切算法(type:6)
{
setTitle("第4章 图像几何变换 错切算法 作者 孙燮华");
Parameters pp = new Parameters("参数", "x方向:", "y方向:", "0.5", "0.5");
setPanel(pp, "错切算法");
pix = common.grabber(iImage, iw, ih);
float shx = pp.getPadx();
float shy = pp.getPady();
// 计算包围盒的宽和高
int ow = (int) (iw + (ih - 1) * shx);
int oh = (int) ((iw - 1) * shy + ih);
if (shx > 0 && shy > 0) {
opix = geom.imShear(pix, shx, shy, iw, ih, ow, oh);
ImageProducer ip = new MemoryImageSource(ow, oh, opix, 0, ow);
oImage = createImage(ip);
common.draw(g, iImage, oImage, iw, ih, 0, 6);
} else JOptionPane.showMessageDialog(null, "参数必须为正数!");
} else if (evt.getSource() == trnItem) {
setTitle("第4章 图像几何变换 平移算法 作者 孙燮华");
Parameters pp = new Parameters("参数", "x方向:", "y方向:", "100", "50");
setPanel(pp, "平移算法");
pix = common.grabber(iImage, iw, ih);
int tx = (int) pp.getPadx();
int ty = (int) pp.getPady();
if (tx > 0 && ty > 0) {
int ow = iw + tx;
int oh = ih + ty;
opix = geom.imTrans(pix, tx, ty, iw, ih, ow, oh);
ImageProducer ip = new MemoryImageSource(ow, oh, opix, 0, ow);
oImage = createImage(ip);
common.draw(g, iImage, oImage, iw, ih, 0, 7);
} else JOptionPane.showMessageDialog(null, "参数必须为正数!");
} else if (evt.getSource() == nearItem) {
setTitle("第4章 图像几何变换 最邻近插值算法 作者 孙燮华");
pix = common.grabber(iImage, iw, ih);
float p =
(Float.valueOf(JOptionPane.showInputDialog(null, "输入缩放参数(0.1-3.0)", "1.50")))
.floatValue();
int ow = (int) (p * iw); // 计算目标图宽高
int oh = (int) (p * ih);
opix = geom.nearNeighbor(pix, iw, ih, ow, oh, p);
ImageProducer ip = new MemoryImageSource(ow, oh, opix, 0, ow);
oImage = createImage(ip);
common.draw(g, oImage, "最邻近插值", p);
} else if (evt.getSource() == linrItem) {
setTitle("第4章 图像几何变换 双线性插值算法 作者 孙燮华");
pix = common.grabber(iImage, iw, ih);
float p =
(Float.valueOf(JOptionPane.showInputDialog(null, "输入缩放参数(0.1-3.0)", "1.50")))
.floatValue();
int ow = (int) (p * iw); // 计算目标图宽高
int oh = (int) (p * ih);
opix = geom.bilinear(pix, iw, ih, ow, oh, p);
ImageProducer ip = new MemoryImageSource(ow, oh, opix, 0, ow);
oImage = createImage(ip);
common.draw(g, oImage, "双线性插值", p);
} else if (evt.getSource() == cubicItem) {
setTitle("第4章 图像几何变换 三次卷积插值算法 作者 孙燮华");
pix = common.grabber(iImage, iw, ih);
float p =
(Float.valueOf(JOptionPane.showInputDialog(null, "输入缩放参数(1.1-3.0)", "1.50")))
.floatValue();
if (p < 1) {
JOptionPane.showMessageDialog(null, "参数p必须大于1!");
return;
}
int ow = (int) (p * iw); // 计算目标图宽高
int oh = (int) (p * ih);
opix = geom.scale(pix, iw, ih, ow, oh, p, p);
ImageProducer ip = new MemoryImageSource(ow, oh, opix, 0, ow);
oImage = createImage(ip);
common.draw(g, oImage, "三次卷积插值", p);
} else if (evt.getSource() == okButton) dialog.dispose();
else if (evt.getSource() == exitItem) System.exit(0);
}
public void actionPerformed(ActionEvent evt)
{
Graphics graph = getGraphics();
MediaTracker tracker = new MediaTracker(this);
if (evt.getSource() == openItem)
{
JFileChooser chooser = new JFileChooser();
common.chooseFile(chooser, "./images", 0);
int r = chooser.showOpenDialog(null);
if(r == JFileChooser.APPROVE_OPTION)
{
String name = chooser.getSelectedFile().getAbsolutePath();
if(runflag)
{
loadflag = false;
runflag = false;
}
if(!loadflag)
{
iImage = common.openImage(name, tracker);
iw = iImage.getWidth(null);
ih = iImage.getHeight(null);
repaint();
}
else if(loadflag && (!runflag))
{
iImage2 = common.openImage(name, tracker);
common.draw(graph, iImage, "pic 1", iImage2, "pic 2");
repaint();
}
}
loadflag = true;
}
else if (evt.getSource() == grayItem)
{
setTitle("图像预处理");
if(loadflag)
{
pixels = common.grabber(iImage, iw, ih);
pixels = elements.toGray(pixels, iw, ih);
showPix(graph, pixels, "gray pic");
repaint();
}
}
else if (evt.getSource() == contrastItem)
{
setTitle("图像预处理");
if(loadflag)
{
pixels = common.grabber(iImage, iw, ih);
int con = common.getParam("type in contrast level(-100~100)","0");
double contrast = (double)con/100.0;
pixels = doContrast(pixels, iw, ih, contrast);
showPix(graph, pixels, "contrast pic");
repaint();
}
}
else if (evt.getSource() == exitItem)
System.exit(0);
}
public void actionPerformed(ActionEvent ev) {
String s = ev.getActionCommand();
if (s == null) {
if (ev.getSource() instanceof JMenuItem) {
JMenuItem i;
s = ((JMenuItem) ev.getSource()).getText();
}
}
/*
// button replace by toolbar
if (s.equals("Execute")) {
execute();
} else
*/
if (s.equals("Exit")) {
windowClosing(null);
} else if (s.equals("Transfer")) {
Transfer.work(null);
} else if (s.equals("Dump")) {
Transfer.work(new String[] {"-d"});
} else if (s.equals("Restore")) {
Transfer.work(new String[] {"-r"});
} else if (s.equals("Logging on")) {
javaSystem.setLogToSystem(true);
} else if (s.equals("Logging off")) {
javaSystem.setLogToSystem(false);
} else if (s.equals("Refresh Tree")) {
refreshTree();
} else if (s.startsWith("#")) {
int i = Integer.parseInt(s.substring(1));
txtCommand.setText(sRecent[i]);
} else if (s.equals("Connect...")) {
connect(ConnectionDialogSwing.createConnection(fMain, "Connect"));
refreshTree();
} else if (s.equals("Results in Grid")) {
iResult = 0;
pResult.removeAll();
pResult.add(gScrollPane, BorderLayout.CENTER);
pResult.doLayout();
gResult.fireTableChanged(null);
pResult.repaint();
} else if (s.equals("Open Script...")) {
JFileChooser f = new JFileChooser(".");
f.setDialogTitle("Open Script...");
// (ulrivo): set default directory if set from command line
if (defDirectory != null) {
f.setCurrentDirectory(new File(defDirectory));
}
int option = f.showOpenDialog(fMain);
if (option == JFileChooser.APPROVE_OPTION) {
File file = f.getSelectedFile();
if (file != null) {
StringBuffer buf = new StringBuffer();
ifHuge = DatabaseManagerCommon.readFile(file.getAbsolutePath());
if (4096 <= ifHuge.length()) {
buf.append("This huge file cannot be edited. Please execute\n");
txtCommand.setText(buf.toString());
} else {
txtCommand.setText(ifHuge);
}
}
}
} else if (s.equals("Save Script...")) {
JFileChooser f = new JFileChooser(".");
f.setDialogTitle("Save Script");
// (ulrivo): set default directory if set from command line
if (defDirectory != null) {
f.setCurrentDirectory(new File(defDirectory));
}
int option = f.showSaveDialog(fMain);
if (option == JFileChooser.APPROVE_OPTION) {
File file = f.getSelectedFile();
if (file != null) {
DatabaseManagerCommon.writeFile(file.getAbsolutePath(), txtCommand.getText());
}
}
} else if (s.equals("Save Result...")) {
JFileChooser f = new JFileChooser(".");
f.setDialogTitle("Save Result...");
// (ulrivo): set default directory if set from command line
if (defDirectory != null) {
f.setCurrentDirectory(new File(defDirectory));
}
int option = f.showSaveDialog(fMain);
if (option == JFileChooser.APPROVE_OPTION) {
File file = f.getSelectedFile();
if (file != null) {
showResultInText();
DatabaseManagerCommon.writeFile(file.getAbsolutePath(), txtResult.getText());
}
}
} else if (s.equals("Results in Text")) {
iResult = 1;
pResult.removeAll();
pResult.add(txtResultScroll, BorderLayout.CENTER);
pResult.doLayout();
showResultInText();
pResult.repaint();
} else if (s.equals("AutoCommit on")) {
try {
cConn.setAutoCommit(true);
} catch (SQLException e) {
}
} else if (s.equals("AutoCommit off")) {
try {
cConn.setAutoCommit(false);
} catch (SQLException e) {
}
} else if (s.equals("Commit")) {
try {
cConn.commit();
} catch (SQLException e) {
}
} else if (s.equals("Insert test data")) {
insertTestData();
} else if (s.equals("Rollback")) {
try {
cConn.rollback();
} catch (SQLException e) {
}
} else if (s.equals("Disable MaxRows")) {
try {
sStatement.setMaxRows(0);
} catch (SQLException e) {
}
} else if (s.equals("Set MaxRows to 100")) {
try {
sStatement.setMaxRows(100);
} catch (SQLException e) {
}
} else if (s.equals("SELECT")) {
showHelp(DatabaseManagerCommon.selectHelp);
} else if (s.equals("INSERT")) {
showHelp(DatabaseManagerCommon.insertHelp);
} else if (s.equals("UPDATE")) {
showHelp(DatabaseManagerCommon.updateHelp);
} else if (s.equals("DELETE")) {
showHelp(DatabaseManagerCommon.deleteHelp);
} else if (s.equals("CREATE TABLE")) {
showHelp(DatabaseManagerCommon.createTableHelp);
} else if (s.equals("DROP TABLE")) {
showHelp(DatabaseManagerCommon.dropTableHelp);
} else if (s.equals("CREATE INDEX")) {
showHelp(DatabaseManagerCommon.createIndexHelp);
} else if (s.equals("DROP INDEX")) {
showHelp(DatabaseManagerCommon.dropIndexHelp);
} else if (s.equals("CHECKPOINT")) {
showHelp(DatabaseManagerCommon.checkpointHelp);
} else if (s.equals("SCRIPT")) {
showHelp(DatabaseManagerCommon.scriptHelp);
} else if (s.equals("SHUTDOWN")) {
showHelp(DatabaseManagerCommon.shutdownHelp);
} else if (s.equals("SET")) {
showHelp(DatabaseManagerCommon.setHelp);
} else if (s.equals("Test Script")) {
showHelp(DatabaseManagerCommon.testHelp);
}
}