Help me to sort out the error

Question

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
class Image01 extends Frame{ //controlling class
Image rawImage; //ref to raw image file fetched from disk
Image modImage; //ref to modified image
int rawWidth;
int rawHeight;
int[][][] threeDPix;
int[][][] threeDPixMod;
int[] oneDPix;
int inTop; //Inset values for the container object
int inLeft;
double slope;//Controls the slope of the line
String inputData;//Obtained via the TextField
TextField inputField;//Reference to TextField
ImgIntfc02 imageProcessingObject;
//=====================================================//
public static void main(String[] args)
     Image01 obj = new Image01(); //instantiate this object
obj.repaint(); //render the image
     } //end main
//=====================================================//
public Image01()
{                                          //constructor
//Get an image from the specified file in the current
Label instructions = new Label(
"Type a slope value and Replot.");
add(instructions);
inputField = new TextField("1.0",5);
add(inputField);
// directory on the local hard disk.
rawImage =
Toolkit.getDefaultToolkit().getImage("myco.jpeg");
//Use a MediaTracker object to block until the image
// is loaded or ten seconds has elapsed.
MediaTracker tracker = new MediaTracker(this);
tracker.addImage(rawImage,1);
try
{                                         //because waitForID throws InterruptedException
if(!tracker.waitForID(1,10000))
System.out.println("Load error.");
System.exit(1);
//end if
catch(InterruptedException e)
System.out.println(e);
this.setVisible(true);//make the Frame visible
rawWidth = rawImage.getWidth(this); //Raw image has been loaded. Establish width and
rawHeight = rawImage.getHeight(this); // height of the raw image.
inTop = this.getInsets().top; //Get and store inset data for the Frame object so
inLeft = this.getInsets().left; // that it can be easily avoided.
this.setSize(800,800);
//this.setSize(inLeft+rawWidth,inTop+2*rawHeight); //Use the insets and the size of the raw image to
this.setTitle("Copyright 1997, Baldwin"); // establish the overall size of the Frame object.
this.setBackground(Color.yellow); //Make the Frame object twice the height of the
// image so that the raw image and the modified image
// can both be rendered on the Frame object.
int[] oneDPix = new int[rawWidth * rawHeight]; //Declare an array object to receive the pixel
     // representation of the image
//Convert the rawImage to numeric pixel representation
try
//because grapPixels() throws InterruptedException
//Instantiate a PixelGrabber object specifying
// pix as the array in which to put the numeric
// pixel data.
PixelGrabber pgObj = new PixelGrabber(rawImage,0,0,rawWidth,rawHeight,oneDPix,0,rawWidth);
//Invoke the grabPixels() method on the PixelGrabber
// object to actually convert the image to an array
// of numeric pixel data stored in pix. Also test
// for success in the process.
     if(pgObj.grabPixels() && ((pgObj.getStatus() & ImageObserver.ALLBITS) != 0))
          for(int cnt = 0; cnt < (rawWidth*rawHeight);cnt++)
               oneDPix[cnt] = oneDPix[cnt];
} //end for loop
               threeDPix = convertToThreeDim(oneDPix,imgCols,imgRows);
               int[][][] convertToThreeDim(int[] oneDPix,int imgCols,int imgRows)
//Create the new 3D array to be populated
// with color data.
int[][][] data =
new int[imgRows][imgCols][4];
for(int row = 0;row < imgRows;row++){
//Extract a row of pixel data into a
// temporary array of ints
int[] aRow = new int[imgCols];
for(int col = 0; col < imgCols;col++){
int element = row * imgCols + col;
aRow[col] = oneDPix[element];
}//end for loop on col
//Move the data into the 3D array. Note
// the use of bitwise AND and bitwise right
// shift operations to mask all but the
// correct set of eight bits.
for(int col = 0;col < imgCols;col++){
//Alpha data
data[row][col][0] = (aRow[col] >> 24)
& 0xFF;
//System.out.println(data[row][col][0]);
//Red data
data[row][col][1] = (aRow[col] >> 16)
& 0xFF;
//Green data
data[row][col][2] = (aRow[col] >> 8)
& 0xFF;
//Blue data
data[row][col][3] = (aRow[col])
& 0xFF;
}//end for loop on col
}//end for loop on row
return data;
}//end convertToThreeDim
threeDPixMod =imageProcessingObject.processImg(threeDPix,imgRows,imgCols);
public int[][][] processImg(
int[][][] threeDPix,
int imgRows,
int imgCols){
//Display some interesting information
System.out.println("Program test");
System.out.println("Width = " + imgCols);
System.out.println("Height = " + imgRows);
//Make a working copy of the 3D array to
// avoid making permanent changes to the
// image data.
int[][][] temp3D =
new int[imgRows][imgCols][4];
for(int row = 0;row < imgRows;row++){
for(int col = 0;col < imgCols;col++){
temp3D[row][col][0] =
threeDPix[row][col][0];
temp3D[row][col][1] =
threeDPix[row][col][1];
temp3D[row][col][2] =
threeDPix[row][col][2];
temp3D[row][col][3] =
threeDPix[row][col][3];
}//end inner loop
}//end outer loop
//Get slope value from the TextField
slope = Double.parseDouble(
inputField.getText());
//Draw a white diagonal line on the image
for(int col = 0;col < imgCols;col++){
int row = (int)(slope*col);
if(row > imgRows -1)break;
//Set values for alpha, red, green, and
// blue colors.
temp3D[row][col][0] = (byte)0xff;
temp3D[row][col][1] = (byte)0xff;
temp3D[row][col][2] = (byte)0xff;
temp3D[row][col][3] = (byte)0xff;
}//end for loop
//Return the modified array of image data.
return temp3D;
}//end processImg
oneDPix = convertToOneDim(
threeDPixMod,imgCols,imgRows);
int[] convertToOneDim( int[][][] data,int imgCols,int imgRows){
//Create the 1D array of type int to be
// populated with pixel data, one int value
// per pixel, with four color and alpha bytes
// per int value.
int[] oneDPix = new int[
imgCols * imgRows * 4];
//Move the data into the 1D array. Note the
// use of the bitwise OR operator and the
// bitwise left-shift operators to put the
// four 8-bit bytes into each int.
for(int row = 0,cnt = 0;row < imgRows;row++){
for(int col = 0;col < imgCols;col++){
oneDPix[cnt] = ((data[row][col][0] << 24)
& 0xFF000000)
| ((data[row][col][1] << 16)
& 0x00FF0000)
| ((data[row][col][2] << 8)
& 0x0000FF00)
| ((data[row][col][3])
& 0x000000FF);
cnt++;
}//end for loop on col
}//end for loop on row
return oneDPix;
}//end convertToOneDim
modImg = createImage(
new MemoryImageSource(
imgCols,imgRows,oneDPix,0,imgCols));
//end if statement
     else System.out.println("Pixel grab not successful");
catch(InterruptedException e)
System.out.println(e);
modImage = this.createImage(new MemoryImageSource(rawWidth,rawHeight,pix,0,rawWidth)); //Use the createImage() method to create a new image
// from the array of pixel values.s
this.addWindowListener(new WindowAdapter() //Anonymous inner-class listener to terminate program
          //anonymous class definition
          public void windowClosing(WindowEvent e)
     System.exit(0);                                              //terminate the program
          }//end windowClosing()
} //end WindowAdapter
);//end addWindowListener
}//end constructor
//=======================================================//
//Override the paint method to display both the rawImage
// and the modImage on the same Frame object.
public void paint(Graphics g)
          if(modImage != null)
               g.drawImage(rawImage,inLeft+50,inTop+50,this);
               g.drawImage(modImage,inLeft+50,inTop+rawHeight+100,this);
          }//end if
     }//end paint()
}//end Image05 class
//=======================================================//

Answer 1

You won't get much help with a post like this: no context, no stack trace, no code formatting...