import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.*;
import java.io.*;


/** Reconstructs a 3D image of a spherical object from six different 2D views.
 * Where each of the six 2D views corresponds one side of a cube.
 * @author Chris Tsang and Gurinder Kler
 * @version 1.0.0
 * @date March 7, 2002
 */
public class Run3D_ implements PlugIn{
    
    /** Run in an ImageJ plugin corresponds to main in a java program
     * @param arg a string argument, is not used in this program
     */    
    public void run(String arg) {
        
        CenterImage centered= new CenterImage();
        XYZ coordinates = new XYZ();
        ImageRadius calcradius= new ImageRadius();
        
        int radius=0;
        int centerX=0;
        int centerY=0;
        
        /*int radius=98;
        int centerX=160;
        int centerY=120;*/
        int view;
        int[] idlist=WindowManager.getIDList();
        IntVariables intVars = new IntVariables(0,0,0);
        int validCount=0;   //counts the number of validVoxels
        int countVoxels=0;  //number of voxels in sphereVoxels
        long time=System.currentTimeMillis();
        long time2=time;
        
        //Finds Count of Valid Voxels
        //validCount = surfaceVoxelCount(h, w, centerX, centerY, radius);
        validCount = surfaceVoxelCount(radius*2, radius*2, radius, radius, radius);
        //IJ.showMessage("validCount is "+validCount);
        
        //Creates a Voxel array of size of validCount, ie the valid number of voxels
        //initializes voxelValue coordinates to 0,0,0
        //voxelValue are the pixels for one of the six views
        Voxel[] voxelValue = new Voxel[validCount];
        for (int a = 0; a<validCount; a++){
            voxelValue[a] = new Voxel();
        }
        Voxel[] sphereVoxels = new Voxel[(validCount*6)];
        for (int a = 0; a<(validCount*6); a++){
            sphereVoxels[a] = new Voxel();
        }
        
        //IJ.setColumnHeadings("view, x \t countVoxels, y \t time, z \t numViews \t Grey");
        ImageProcessor[] projections = new ImageProcessor[6];
        orderProjections(projections);
        
        int width = projections[0].getWidth();
        int height=projections[0].getHeight();
        centerx=width/2;        
        centery=height/2;
        
        // Setup to write data to a file
        try {
            String dirName = "c:/ImageJ/plugins";   // Directory for the file
            String fileName = "Results.txt";    // The file name
            String fileName2 ="Results.bin";
            
            File myDir = new File(dirName);      // Define directory object
            
            if(!myDir.exists())           // If directory does not exist
                myDir.mkdir();              // ...create it
            else
                if(!myDir.isDirectory())    // Verify it is a directory
                { // It is not
                    System.err.println(dirName+" is not a directory");
                    return;
                }
            
            // Create the file object
            File myFile = new File(myDir, fileName);
            myFile.createNewFile();        // If it doesn't exist, create it
            
            File myFile2 = new File(myDir, fileName2);
            myFile2.createNewFile();        // If it doesn't exist, create it
            
            // Create a buffered print stream for the file
            //            PrintStream ps = new PrintStream(new FileOutputStream(myFile));
            PrintStream ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(myFile)));
            DataOutputStream binStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(myFile2)));
            
            //Processing all six images
            for(int i=0;i<idlist.length;i++){
            //for(int i=0;i<1;i++){

                centered.radiusSize(projections[i], radius);
                radius=calcradius.getRadius(projections[i].getProcessor());
                view=i;
                coordinates.runCoordinates(projections[i], radius, centerX, centerY, "image "+i, intVars, view, voxelValue);
                intVars.set(countVoxels, 0,0);
                weight(voxelValue, sphereVoxels, radius, validCount, view, intVars);
                countVoxels=intVars.getA();
                IJ.write(i+"\t"+countVoxels+"\t"+((System.currentTimeMillis()-time2)/1000.0/60.0));
                time2=System.currentTimeMillis();
                

                //da3Image is the image of the wieghted greyscale redrawn
                ImagePlus da3Image = NewImage.createByteImage("datitleinmain "+i, radius*2, radius*2, 1, NewImage.FILL_BLACK);
                ImageProcessor da3_ip = da3Image.getProcessor();
                byte[] pixels3ip = (byte[]) da3_ip.getPixels();
                int validCount2=0;
                //redraws sphere first view from weighted greyscales
                for (int b=0; b<validCount; b++){
                    //int x=sphereVoxels[b].getX();
                    //int y=sphereVoxels[b].getZ();
                    int x=0;
                    int y=0;
                    switch (view){
                        case 0:     //top originally had x,z calculated y
                            x=voxelValue[b].getX();
                            y=voxelValue[b].getZ();
                            if (b==0) IJ.write("Case "+view);
                            break;
                        case 1:     //bottom originally had x,z calculated y
                            x=voxelValue[b].getX();
                            y=voxelValue[b].getZ();
                            if (b==0) IJ.write("Case "+view);
                            break;
                        case 2:     //left originally had y,z calculated x
                            x=voxelValue[b].getZ();
                            y=voxelValue[b].getY();
                            if (b==0) IJ.write("Case "+view);
                            break;
                        case 3:     //right originally had y,z calculated x
                            x=voxelValue[b].getZ();
                            y=voxelValue[b].getY();
                            if (b==0) IJ.write("Case "+view);
                            break;
                        case 4:     //front originally had x,y calculated z
                            x=voxelValue[b].getX();
                            y=voxelValue[b].getY();
                            if (b==0) IJ.write("Case "+view);
                            break;
                        case 5:     //back originally had x,y calculated z
                            x=voxelValue[b].getX();
                            y=voxelValue[b].getY();
                            if (b==0) IJ.write("Case "+view);
                            break;
                    }
                    
                    int w=radius*2;
                    //if (b<10)
                    //IJ.write(a +"\t"+voxelValue[a].getGrey());
                    //da3_ip.putPixel(x, y, 0xff & voxelValue[a].getGrey());
                    pixels3ip[x+y*w]=voxelValue[b].getGrey();
                    
                }
                da3Image.show();
                da3Image.updateAndDraw();
                //            }
            }
            
            ImagePlus da4Image = NewImage.createByteImage("da4thimage", radius*2, radius*2, 1, NewImage.FILL_BLACK);
            ImageProcessor da4_ip = da4Image.getProcessor();
            byte[] pixels4ip = (byte[]) da4_ip.getPixels();
            int validCount2=0;
            //redraws sphere from valid voxels
            for (int b=0; b<validCount; b++){
                int x=sphereVoxels[b].getX();
                int y=sphereVoxels[b].getZ();
                int w=radius*2;
                //if (b<10)
                //IJ.write(a +"\t"+voxelValue[a].getGrey());
                //da3_ip.putPixel(x, y, 0xff & voxelValue[a].getGrey());
                pixels4ip[x+y*w]=sphereVoxels[b].getGrey();
            }
            da4Image.show();
            da4Image.updateAndDraw();
            IJ.write("Total time in minutes is "+(time2-time)/1000.0/60.0);
            
            for (int b=0; b< countVoxels; b++){
                ps.println(sphereVoxels[b].getX()+" "+sphereVoxels[b].getY() +" "+sphereVoxels[b].getZ() +" "+(0xff & sphereVoxels[b].getGrey()) +" "+sphereVoxels[b].getNumViews());
                binStream.writeInt(sphereVoxels[b].getX());
                binStream.writeInt(sphereVoxels[b].getY());
                binStream.writeInt(sphereVoxels[b].getZ());
                binStream.writeInt(0xff & sphereVoxels[b].getGrey());
                binStream.writeInt(sphereVoxels[b].getNumViews());
                
                //IJ.write(sphereVoxels[b].getX() +"\t"+ sphereVoxels[b].getY() +"\t"+ sphereVoxels[b].getZ() +"\t"+ sphereVoxels[b].getNumViews() +"\t"+ (0xff & sphereVoxels[b].getGrey()));
            }
            ps.close();
            binStream.close();
        }
        catch(IOException e)                 // Catch any output errors
        {
            System.out.println("IOException " + e + " occurred");
        }
    }//run
    /** Returns count of valid number of pixels in image with current radius
     * @param h is height of image frame
     * @param w is width of image frame
     * @param centerX is the center of the image frame in the x direction
     * @param centerY is the center of the image framein the y direction
     * @param radius is the radius of the circle being processed
     * @return returns count of valid number of pixels in image with current radius
     */    
    public int surfaceVoxelCount(int h, int w, int centerX, int centerY, int radius){
        int offset,i;
        int validCount=0;
        
        for (int y=0; y < h; y++) {
            offset = y*w;
            for (int x=0; x<w; x++) {
                i = offset + x;
                if ((Math.sqrt((centerX-x)*(centerX-x)+(centerY-y)*(centerY-y))) <= radius){
                    validCount++;
                }
            }
        }
        return validCount;
    }
    
    /** Orders the projections in order: top, bottom, left, right, front, back
     * @param projections is an array of ImageProcessors, which is ordered in the form: top, bottom,
     * left, right, front, back
     */    
    public void orderProjections(ImageProcessor[] projections){
        ImagePlus image=WindowManager.getCurrentImage();
        //int stacksize=image.getStackSize();
        //ImageStack combinedstack=new ImageStack(3*width,4*height);
        String title=new String();
        int[] ids=WindowManager.getIDList();
        
        try{
            for(int i=0;i<ids.length;i++) {
                title=positionTitle(image=WindowManager.getImage(ids[i]));
                if(title.equals("top")){
                    projections[0]=image.getProcessor();
                    IJ.write("top found");
                }
                if(title.equals("bottom")){
                    projections[1]=image.getProcessor();
                    IJ.write("bottom found");
                }
                if(title.equals("left")){
                    projections[2]=image.getProcessor();
                    IJ.write("left found");
                }
                if(title.equals("right")){
                    projections[3]=image.getProcessor();
                    IJ.write("right found");
                }
                if(title.equals("front")){
                    projections[4]=image.getProcessor();
                    IJ.write("front found");
                }
                if(title.equals("back")){
                    projections[5]=image.getProcessor();
                    IJ.write("back found");
                }
                
            }
            //            WindowManager.closeAllWindows();
            
        }//try
        
        catch(NullPointerException e) {
            IJ.showMessage("You must name your stacks with the following convention <Picture Title>_top,<Picture Title>_bottom ....etc.");
            
        }//catch
    }//orderProjections
    
    /** Determines the position title of the image
     * @param workpic is an Imageplus whose title is wanted
     * @return returns the title type of the image, ie top, bottom, left, right, front, back
     */    
    public String positionTitle( ImagePlus workpic){
        String pictitle= new String();
        int index;
        int index2;
        String[] titles={ "top","bottom","left","right","front","back"};
        boolean found=false;
        
        pictitle=workpic.getTitle();
        index=pictitle.indexOf('_');
        index2=pictitle.indexOf('.');
        
        index++;
        try{
            pictitle=pictitle.substring(index,index2);
        }
        catch(StringIndexOutOfBoundsException e){
            pictitle=("none");
        }
        return pictitle;
    }//positionTitle
    
    /** Determines the weight of greyscales of image with Voxels voxelValue and stores
     * date in image with Voxels sphereVoxels
     * @param voxelValue Are the voxels of one of the six original views to have its greyscales weighted
     * @param sphereVoxels Is where the voxels of the sphere are stored with its new calculated greyscales
     * @param radius Is the radius of the sphere
     * @param validCount Is the number of valid pixels in each of the six views
     * @param view Is the current view being calculated, 0 to 5
     * @param intVars Is a class which is used to pass integer variables, in this case intA is
     * countVoxels, which keeps track of the number of voxels in sphereVoxels
     */    
    public void weight(Voxel[] voxelValue, Voxel[] sphereVoxels, int radius, int validCount, int view, IntVariables intVars){
        byte currentGrey;
        int index=0;
        int i;
        int countVoxels=intVars.getA();
        double temp1=0;
        double temp2=0;
        //IJ.setColumnHeadings("x \t y \t z \t origGrey \t newGrey \t weight");
        
        temp2=radius*radius;
        //validCount=100;
        for (int a=0; a<validCount; a++){
            //find xyz
            //currentGrey=(int)Math.pow((voxelValue[a].getY()/radius), 2.0);
            //currentGrey=(byte)((voxelValue[a].getY()*voxelValue[a].getY()/(radius*radius))*(255-(0xff & voxelValue[a].getGrey())));
            switch (view){
                case 0:     //top originally had x,z calculated y
                    temp1=(voxelValue[a].getY()-radius)*(voxelValue[a].getY()-radius);
                    break;
                case 1:     //bottom originally had x,z calculated y
                    temp1=(voxelValue[a].getY()-radius)*(voxelValue[a].getY()-radius);
                    break;
                case 2:     //left originally had y,z calculated x
                    temp1=(voxelValue[a].getX()-radius)*(voxelValue[a].getX()-radius);
                    break;
                case 3:     //right originally had y,z calculated x
                    temp1=(voxelValue[a].getX()-radius)*(voxelValue[a].getX()-radius);
                    break;
                case 4:     //front originally had x,y calculated z
                    temp1=(voxelValue[a].getZ()-radius)*(voxelValue[a].getZ()-radius);
                    break;
                case 5:     //back originally had x,y calculated z
                    temp1=(voxelValue[a].getZ()-radius)*(voxelValue[a].getZ()-radius);
                    break;
            }
            
            currentGrey=(byte)((temp1/temp2)*(0xff & voxelValue[a].getGrey()));
            index = findXYZ(sphereVoxels, voxelValue[a], countVoxels);
            //if (a<10)
            //  IJ.write(voxelValue[a].getX()+"\t"+voxelValue[a].getY()+"\t"+voxelValue[a].getZ()+"\t"+(0xff & voxelValue[a].getGrey())+"\t"+currentGrey+"\t"+(temp1/temp2));
            voxelValue[a].setGrey(currentGrey);
            if (index==-1){
                //add voxelValue[a] with new weight in greyscale.
                sphereVoxels[countVoxels].set(voxelValue[a].getX(), voxelValue[a].getY(), voxelValue[a].getZ(), currentGrey);
                countVoxels++;
                sphereVoxels[countVoxels].addNumViews();
            }
            else{
                //add to weighted grey scale
                //             IJ.showMessage("fucked up");
                currentGrey=(byte)((0xff & currentGrey)+ (0xff & sphereVoxels[index].getGrey()));
                sphereVoxels[index].setGrey(currentGrey);
                sphereVoxels[index].addNumViews();
            }
            
        }
        intVars.set(countVoxels, 0, 0);
    }//weight
    
    /** Finds the xyz location of voxel toFind in voxel array sphereVoxels
     * @param sphereVoxels is the array of voxels to be searched
     * @param toFind is the voxel being looked for
     * @param countVoxels is the number of voxels in array sphereVoxels
     * @return returns the index of where toFind voxel is located, if not in array retruns -1
     */    
    public int findXYZ(Voxel[] sphereVoxels, Voxel toFind, int countVoxels){
        int x=toFind.getX();
        int y=toFind.getY();
        int z=toFind.getZ();
        
        for (int i=0; i<countVoxels; i++){
            if (x==sphereVoxels[i].getX() && y==sphereVoxels[i].getY() && z==sphereVoxels[i].getZ())
                return i;
        }
        return -1;
    }//findXYZ
    
}//Run3D_

/** Calculates the third coordinate and redraws the original image in an image
 * frame with width=height=diameter of sphere
 */
class XYZ {
    //public void runCoordinates(ImagePlus images, int radius, int centerX, int centerY, String title, IntVariables intVars, int view, Voxel[] voxelValue) {
    /** Calculates the third coordinate and redraws the original image in an image
     * frame with width=height=diameter of sphere
     * @param ip is the imageProcessor to be worked on
     * @param radius is the radius of the image
     * @param centerX is the center of the image frame in the x direction
     * @param centerY is the center of the image framein the y direction
     * @param title is the title to be given to the new image frame of size
     * width=height=diameter of sphere
     * @param intVars Is a class which is used to pass integer variables, it is not used in this case
     * @param view is the current view being processed, 0 to 5
     * @param voxelValue are the voxels in the current view that are returned with all three
     * coordinate values
     */    
    public void runCoordinates(ImageProcessor ip, int radius, int centerX, int centerY, String title, IntVariables intVars, int view, Voxel[] voxelValue) {
        //ImageProcessor ip = images.getProcessor();
        
        int w = ip.getWidth();  //width of frame
        int h = ip.getHeight(); //height of frame
        int validCount=0;
        
        byte[] pixelsOrig = (byte[]) ip.getPixels();
        
        ip.setRoi(centerX-radius, centerY-radius, radius+radius, radius+radius);
        Rectangle roi = ip.getRoi();
        ImagePlus da2Image = NewImage.createByteImage(title, roi.width, roi.height, 1, NewImage.FILL_BLACK);
        ImageProcessor da2_ip = da2Image.getProcessor();
        
        //creates window to fit exactly one circle
        radiusSize(roi, da2Image, da2_ip, pixelsOrig, w);
        w=da2_ip.getWidth();
        h=da2_ip.getHeight();
        centerX=radius;
        centerY=radius;
        byte[] pixels2ip = (byte[]) da2_ip.getPixels();
        
        //valid Voxel will store true if the Voxel at the coordinate is valid
        //initialize all validVoxel values to false
        boolean[] validVoxel= new boolean[w*h];
        for (int i=0; i < validVoxel.length; i++)
            validVoxel[i]=false;
        
        //Finds Valid Voxels; stores validity in validVoxel
        //Finds Count of Valid Voxels
        validCount = surfaceVoxel(h, w, centerX, centerY, radius, validVoxel);
        
        //Calculates the third coordinate
        thirdCoordinate(radius, h, w, validVoxel, voxelValue, pixels2ip, view);
        
        //prints first 10 set of coordinates
        //        for (int a=0; a<10; a++)
        //            IJ.write(a+"\t"+voxelValue[a].getX()+"\t"+voxelValue[a].getY()+"\t"+ voxelValue[a].getZ()+"\n");
        //redraws sphere with everything out of radius cut
/*        for (int a=0; a<validCount; a++){
            int x=voxelValue[a].getX();
            int y=voxelValue[a].getY();
            //pixels[x+y*radius]=voxelValue[a].getGrey();
            pixels[x+y*w]=voxelValue[a].getGrey();
        }
 */
        //IJ.setColumnHeadings("a \t validVoxelGrey \t pixels3ip");
        ImagePlus da3Image = NewImage.createByteImage("datitle", roi.width, roi.height, 1, NewImage.FILL_BLACK);
        ImageProcessor da3_ip = da3Image.getProcessor();
        byte[] pixels3ip = (byte[]) da3_ip.getPixels();
        int validCount2=0;
        //redraws sphere from valid voxels

        
    }//public void runCoordinates
    
    
    /** copys image from original into smaller frame that fits circle perfectly,
     * ie centered at x=r, y=r and length=2r, width=2r
     * @param roi is a rectangle, the region of interest here is square around the circular image
     * with width=length=2r
     * @param da2Image is the ImagePlus where the new image with width=length=2r is to be stored
     * @param da2_ip is the ImageProcessor where the new image with width=length=2r is to be stored
     * @param pixelsOrig are the pixels from the original view to be redrawn in the new image frame
     * @param w is the width of the image frame
     */    
    public void radiusSize(Rectangle roi, ImagePlus da2Image, ImageProcessor da2_ip, byte[] pixelsOrig, int w){
        //        IJ.setColumnHeadings("d \t e \t pos2 \t pos");
        byte[] pixelsRoi = (byte[]) da2_ip.getPixels();
        int d=0;
        int e=0;
        for (int i=roi.y; i<roi.y+roi.height; i++) {
            int offset1 =i*w;
            int offset2 =d*roi.width;
            e=0;
            for (int j=roi.x; j<roi.x+roi.width; j++) {
                int pos = offset1+j;
                int pos2= offset2+e;
                da2_ip.putPixel(e, d, 0xff & pixelsOrig[pos]);
                //pixelsRoi[pos2]=(byte)pixelsOrig[pos];
                //IJ.write(d+"\t"+e+"\t"+pos2+"\t"+pos+"\n");
                e++;
            }
            d++;
        }
        
        //        daImage.setRoi(centerX-radius, centerY-radius, radius+radius, radius+radius);
        da2Image.show();
        da2Image.updateAndDraw();
    }//radiusSize
    
    //Finds Valid Surface Voxels
    /** Finds valid surface voxels in image and returns validCount, the valid number
     * of pixels in image
     * @param h is the height of the image
     * @param w is the width of the image
     * @param centerX is the center of the image frame in the x direction
     * @param centerY is the center of the image framein the y direction
     * @param radius is the radius of the image
     * @param validVoxel is a boolean array that returns true values for voxels which are within the
     * circle of the image
     * @return returns count of valid number of pixels in image with current radius
     */    
    public int surfaceVoxel(int h, int w, int centerX, int centerY, int radius, boolean[] validVoxel){
        int offset,i;
        int validCount=0;
        
        for (int y=0; y < h; y++) {
            offset = y*w;
            for (int x=0; x<w; x++) {
                i = offset + x;
                if ((Math.sqrt((centerX-x)*(centerX-x)+(centerY-y)*(centerY-y))) <= radius){
                    validVoxel[i]=true;
                    validCount++;
                }
            }
        }
        return validCount;
    }
    
    //Calculates the third coordinate
    /** Given two coordinates of a sphere, calculates the third coordinate of the sphere
     * @param radius is the radius of the image
     * @param h is the height of the image
     * @param w is the width of the image
     * @param validVoxel is a boolean array that is true for voxels which are within the
     * circle of the image
     * @param voxelValue is an array of the voxels within the circle of the 2D image, it is where the
     * xyz coordinates are stored for that view
     * @param pixels2ip are the pixel greyscales of the original image
     * @param view is the current view being processed, 0 to 5
     */    
    public void thirdCoordinate(int radius, int h, int w, boolean[] validVoxel, Voxel[] voxelValue, byte[] pixels2ip, int view){
        double temp1, temp2;
        int third, z2;
        int offset, i;
        
        //IJ.setColumnHeadings("validCount \t x \t y \t z \t z2");
        int validCount2=0;
        //      int a = 1;
        int b = 2*radius*(-1);
        for (int y=0; y < h; y++) {
            offset = y*w;
            for (int x=0; x<w; x++) {
                i = offset + x;
                if (validVoxel[i]==true){
                    int c = (y-radius)*(y-radius)+(x-radius)*(x-radius);
                    //temp1 = (((-1)*b + Math.sqrt(b*b-4*a*c))/(2*a));
                    temp1 = (((-1)*b + Math.sqrt(b*b-4*c))/(2));
                    //temp2 = (((-1)*b - Math.sqrt(b*b-4*a*c))/(2*a));
                    temp2 = (((-1)*b - Math.sqrt(b*b-4*c))/(2));
                    switch (view){
                        case 0:     //top given x,z get y
                            //                            temp1 = (((-1)*b + Math.sqrt(b*b-4*c))/(2));
                            third = (int)Math.rint(temp1);
                            voxelValue[validCount2].set(x,third,y, pixels2ip[i]);
                            break;
                        case 1:     //bottom given x,z get y
                            //                            temp2 = (((-1)*b - Math.sqrt(b*b-4*c))/(2));
                            third = (int)Math.rint(temp2);
                            voxelValue[validCount2].set(x,third,y, pixels2ip[i]);
                            break;
                        case 2:     //left given y,z get x
                            //                            temp2 = (((-1)*b - Math.sqrt(b*b-4*c))/(2));
                            third = (int)Math.rint(temp2);
                            voxelValue[validCount2].set(third, y, x, pixels2ip[i]);
                            break;
                        case 3:     //right given y,z get x
                            //                            temp1 = (((-1)*b + Math.sqrt(b*b-4*c))/(2));
                            third = (int)Math.rint(temp1);
                            voxelValue[validCount2].set(third, y, x, pixels2ip[i]);
                            break;
                        case 4:     //front given x,y get z
                            //                            temp2 = (((-1)*b - Math.sqrt(b*b-4*c))/(2));
                            third = (int)Math.rint(temp1);
                            voxelValue[validCount2].set(x, y, third, pixels2ip[i]);
                            break;
                        case 5:     //back given x,y get z
                            //                            temp1 = (((-1)*b + Math.sqrt(b*b-4*c))/(2));
                            third = (int)Math.rint(temp2);
                            voxelValue[validCount2].set(x, y, third, pixels2ip[i]);
                            break;
                    }
                    third = (int)Math.rint(temp1);
                    z2 = (int)Math.rint(temp2);
                    
                    //if (validCount2 <10)
                    //  IJ.write(validCount2+"\t"+voxelValue[validCount2].getX()+"\t"+voxelValue[validCount2].getY()+"\t"+third+"\t"+z2+"\n");
                    validCount2++;
                }
            }
        }
    }//thirdCoordinate
    
}//xyz class

//stores the xyz of the sphere surface
/** Stores the xyz of the sphere surface
 */
class Voxel{
    // Class variables
    //    static int count=0;
    
    // Instance variables
    /** x is the x coordinate
     */    
    int x;              
    /** y is the y coordinate
     */    
    int y;              
    /** z is the z coordinate
     */    
    int z;              
    /** grey is the greyscale value of voxel at xyz
     */    
    byte grey;          
    /** numViews is the number of different views projecting onto the voxel
     */    
    int numViews;       
    /** Initialize a sphere surface voxel coordinates to 0,0,0
     */    
    Voxel(){
        x=y=z=0;
        grey = (byte)0;
        numViews=0;
    }
    // Store Voxel surface coordinates at x,y,z
    /** Store Voxel surface coordinates at x,y,z, and greyscale at grey
     * @param x is the x coordinate
     * @param y is the y coordinate
     * @param z is the z coordinate
     * @param grey is the greyscale value of voxel at xyz
     */    
    Voxel(int x, int y, int z, byte grey){
        // Set the coordinates of the center
        this.x = x;
        this.y = y;
        this.z = z;
        this.grey = grey;
    }
    /** Sets the x,y,z and grey values
     * @param x is the x coordinate
     * @param y is the y coordinate
     * @param z is the z coordinate
     * @param grey is the greyscale value of voxel at xyz
     */    
    public void set(int x, int y, int z, byte grey){
        this.x = x;
        this.y = y;
        this.z = z;
        this.grey = grey;
    }
    /** returns x coordinate
     * @return returns x coordinate
     */    
    public int getX(){
        return x;
    }
    /** returns y coordinate
     * @return returns y coordinate
     */    
    public int getY(){
        return y;
    }
    /** returns z coordinate
     * @return returns z coordinate
     */
    public int getZ(){
        return z;
    }
     /** returns grey
     * @return returns grey
     */    
    public byte getGrey(){
        return grey;
    }
    /** sets grey value
     * @param grey is the greyscale value
     */    
    public void setGrey(byte grey){
        this.grey = grey;
    }
    /** Increments numViews
     */    
    public void addNumViews(){
     numViews++;
 }
 /** returns numViews
  * @return returns numViews
  */ 
 public int getNumViews(){
     return numViews;
 }
}//Voxel

/** Stores three int variables, to allow for passing of integers through methods
 */
class IntVariables{
    int a, b, c;
    
    //Initialize values to 0
    IntVariables(){
        a=b=c=0;
    }
    // Store int variables a,b,c
    IntVariables(int a, int b, int z){
        // Set the coordinates of the center
        this.a = a;
        this.b = b;
        this.c = c;
    }
    public void set(int a, int b, int c){
        this.a = a;
        this.b = b;
        this.c = c;
    }
    public int getA(){
        return a;
    }
    public int getB(){
        return b;
    }
    public int getC(){
        return c;
    }
}

/** The CenterImage_ plugin allows the user to center an image
 *in an image window based on a default threshold value or a
 *user input threshold value. The images to be processed need to
 *be 8-bit greyscale
 */

class CenterImage_ implements PlugInFilter {
    ImagePlus imp;
    
    /**
     * The setup method checks whether the image that is currently opened
     * is an 8-bit greyscale image.
     *
     * @param arg string input from the user
     * @param imp the current ImagePlus object that is opened
     * @return true if the image that is opened is 8-bit greyscale
     */
    
    public int setup(String arg, ImagePlus imp) {
        this.imp = imp;
        return DOES_8G;
    }
    
    /**
     *The run method performs the centering of the image.
     *
     *@param ip current ImageProcessor that is opened
     */
    
    public void run(ImageProcessor ip)  {
        
        int width = ip.getWidth();
        int height=ip.getHeight();
        int centerx=width/2;        // horiztonal midpoint of image
        int centery=height/2;      // vertical midpoint of image
        int avgcenterx=0,         // average of all the centers in x
        avgcentery=0,	         // aveargae of all the centers in y
        xshift=0,               // difference of avgcenter and centerx of picture
        yshift=0,              // difference of avgcenter and centery of picture
        radius=0;
        
        // determines the average horizontal and vertical center of spherical object
        avgcenterx=AverageCenterX(ip,height,width);
        avgcentery=AverageCenterY(ip,height,width);
        
        // determines whether the position of the spherical object is greater or less than
        // the center of the whole image
        xshift=centerx-avgcenterx;
        yshift=centery-avgcentery;
        
        IJ.write("xshift " +xshift+" yshift "+yshift);
        
        // shift the pixels of picture so the spherical object is centered in the image
        if(xshift!=0)
            if(xshift>0)
                XShiftRight(xshift,ip,height,width);
            else
                XShiftLeft(xshift,ip,height,width);
        
        if(yshift!=0)
            if(yshift<0)
                YShiftUp(yshift,ip,height,width);
            else
                YShiftDown(yshift,ip,height,width);
        
    }//run
    
    /**
     * The AverageCenterX function finds the number of valid pixels within a picture based on a threshold value.
     *
     * @param ip current ImageProcessor that is opened
     * @param height height of the current image
     * @param width  width of the current image
     * @return the average center of the spherical object in the horizontal direction
     */
    
    public int AverageCenterX(ImageProcessor ip,int height,int width){
        
        byte[] pixels = (byte[])ip.getPixels();      //returns reference to all the pixels in an image
        int offset, i;
        int centerx=width/2;
        int centery=height/2;
        int valid,			          //valid is a count of all valid pixels in a row
        cvalid,			                 //cvalid is a count of consecutive valid pixels
        cvalidmax;                              //cvalidmax is  the max of the consecutive valid pixels in a row
        int sumco;                             //sumco is the sum of the valid pixel locations
        int[]  centers=new int[height];       //stores the calculated center for each row.
        int totalcenter=0;                   //the sum of all calculated centers
        int avgcenter=0,                    //average of all the centers
        numrows=0,                         //the number of rows with valid pixels
        xshift=0,                         //difference of avgcenter and centerx of picture
        yshift=0;                        //difference of avgcenter and centery of picture
        //int validb, valida;
        //IJ.setColumnHeadings("row \t validb \t sumco \t valida \t cvalidmax \t average");
        
        
        //for each row of pixels determine how many valid pixels fall within the threshold
        
        for (int y=0; y<height; y++) {
            offset=y*width;
            cvalidmax=0;
            cvalid=0;
            valid=0;
            sumco=0;
            
            
            //validb=valid;
            for (int x=0; x<width; x++) {
                i = offset + x;
                if((0xff & pixels[i])>23){
                    valid++;
                    cvalid++;
                    sumco+=x;
                    if(cvalid>cvalidmax)
                        cvalidmax=cvalid;
                    
                }
                else
                    cvalid=0;
            }
            //valida=valid;
            //if the value of valid pixels is greater than 10 calculate the center of the object within that row
            if(cvalidmax >10){
                centers[y]=sumco/valid;
                totalcenter+=centers[y];
                numrows++;
                
            }
            else
                centers[y]=0;
            //  IJ.write(y+"\t"+validb+"\t"+sumco+"\t"+valida +"\t"+cvalidmax+"\t"+centers[y]+"\t");
        }
        
        if (numrows>0)
            avgcenter=totalcenter/numrows;
        else
            IJ.showMessage("Error \n numrows is "+numrows);
        
        IJ.write("Valid number of rows: "+numrows+"\n"+
        "Average center of object: "+avgcenter+"\n"+
        "Midpoints of picture(wxh): "+width/2+"  "+height/2);
        
        return avgcenter;
        
    }//AverageCenterX
    /**
     * The AverageCenterY function finds the number of valid pixels within a picture based on a threshold value.
     *
     * @param ip current ImageProcessor that is opened
     * @param height height of the current image
     * @param width  width of the current image
     * @return the average center of the spherical object in the horizontal direction
     */
    public int AverageCenterY(ImageProcessor ip,int height,int width){
        byte[] pixels = (byte[])ip.getPixels();        //returns reference to all the pixels in an image
        int offset, i;
        int centerx=width/2;
        int centery=height/2;
        int valid,                                  //valid is a count of all valid pixels in a row
        cvalid,                                    //cvalid is a count of consecutive valid pixels
        cvalidmax;                                //cvalidmax is  the max of the consecutive valid pixels in a row
        int sumco;                               //sumco is the sum of the valid pixel locations
        int[]  centers=new int[width];          //stores the calculated center for each column.
        int totalcenter=0;                     //the sum of all calculated centers
        int avgcenter=0,                      //average of all the centers
        numrows=0,                           //the number of rows with valid pixels
        xshift=0,                           //difference of avgcenter and centerx of picture
        yshift=0;                          //difference of avgcenter and centery of picture
        //int validb=0, valida=0;
        //for each column of pixels determine how many valid pixels fall within the threshold
        for(int x=0;x<width;x++){
            cvalidmax=0;
            cvalid=0;
            valid=0;
            sumco=0;
            
            for (int y=0; y<height; y++) {
                i = width*y+x;
                if((0xff & pixels[i])>23){
                    valid++;
                    cvalid++;
                    sumco+=y;
                    if(cvalid>cvalidmax)
                        cvalidmax=cvalid;
                    
                }
                else
                    cvalid=0;
            }
            //valida=valid;
            //if the value of valid pixels is greater than 10 calculate the center of the object within that row
            
            if(cvalidmax >10){
                centers[x]=sumco/valid;
                totalcenter+=centers[x];
                numrows++;
                
            }
            else
                centers[x]=0;
        }
        
        if (numrows>0)
            avgcenter=totalcenter/numrows;
        else
            IJ.showMessage("Error \n numrows is "+numrows);
        
        IJ.write("Valid number of rows: "+numrows+"\n"+
        "Average center of object: "+avgcenter+"\n"+
        "Midpoints of picture(wxh): "+width/2+"  "+height/2);
        
        return avgcenter;
        
    }//AverageCenterY
    
/* The XShiftRight method shifts the pixels in the picture 'shiftx' times
 * towards the horizontal center of the image window.
 *
 * @param shiftx number of right shifts required to shift image to center
 * @param ip current ImageProcessor that is opened
 * @param height height of the current image
 * @param width  width of the current image
 */
    public void XShiftRight(int shiftx,ImageProcessor ip,int height,int width){
        
        byte[] pixels = (byte[])ip.getPixels();
        int offset=0;
        byte tempixel=0, prevpixel=0;
        int  i=0;
        
        for(int shifts=0;shifts<shiftx;shifts++){
            for(int y=0;y<height;y++){
                offset=y*width;
                
                for (int x=0; x<width; x++) {
                    i = offset + x;
                    if(x==0){
                        prevpixel=(byte)pixels[i];
                        pixels[i]=(byte)pixels[width-1+offset];
                        
                    }
                    else{
                        tempixel=pixels[i];
                        pixels[i]=(byte)prevpixel;
                        prevpixel=(byte)tempixel;
                    }
                }
            }
        }
        
    }//XshiftRight
    
/* The XShiftLeft method shifts the pixels in the picture 'shiftx' times
 * towards the horizontal center of the image window
 *
 * @param shiftx number of left shifts required to shift image to center
 * @param ip current ImageProcessor that is opened
 * @param height height of the current image
 * @param width  width of the current image
 */
    
    public void XShiftLeft(int shiftx,ImageProcessor ip,int height,int width){
        
        byte[] pixels = (byte[])ip.getPixels();
        int offset=0;
        byte tempixel=0,nextpixel=0;
        int  i=0;
        for(int shifts=0;shifts<Math.abs(shiftx);shifts++){
            for(int y=0;y<height;y++){
                offset=y*width;
                
                for (int x=width-1; x>=0; x--) {
                    i = offset + x;
                    if(x==width-1){
                        nextpixel=(byte)pixels[i];
                        pixels[i]=(byte)pixels[offset];
                    }
                    else{
                        tempixel=(byte)pixels[i];
                        pixels[i]=(byte)nextpixel;
                        nextpixel=(byte)tempixel;
                    }
                }
            }
        }
        
        
    }//XshiftRight
    
/* The YShiftUp method shifts the pixels in the picture 'shiftx' times
 * towards the vertical center of the image window.
 *
 * @param shiftx number of left shifts required to shift image to center
 * @param ip current ImageProcessor that is opened
 * @param height height of the current image
 * @param width  width of the current image
 */
    
    public void YShiftUp(int shifty,ImageProcessor ip,int height,int width){
        
        byte[] pixels = (byte[])ip.getPixels();
        int offset=0;
        byte tempixel=0,nextpixel=0;
        int  i=0;
        
        for(int shifts=0;shifts<Math.abs(shifty);shifts++){
            for(int x=0;x<width;x++){
                for (int y=height-1; y>=0; y--) {
                    i = width*y+x;
                    if(y==height-1){
                        nextpixel=(byte)pixels[i];
                        pixels[i]=(byte)pixels[x];
                    }
                    else{
                        tempixel=(byte)pixels[i];
                        pixels[i]=(byte)nextpixel;
                        nextpixel=(byte)tempixel;
                    }
                }
            }
        }
        
    }//YShiftUp
    
/* The YShiftDown method shifts the pixels in the picture 'shiftx' times
 * towards the vertical center of the image window.
 *
 * @param shiftx number of left shifts required to shift image to center
 * @param ip current ImageProcessor that is opened
 * @param height height of the current image
 * @param width  width of the current image
 */
    public void YShiftDown(int shifty,ImageProcessor ip,int height,int width){
        
        byte[] pixels = (byte[])ip.getPixels();
        int offset=0;
        byte tempixel=0,nextpixel=0;
        int  i=0;
        
        for(int shifts=0;shifts<shifty;shifts++){
            for(int x=0;x<width;x++){
                for (int y=0; y<height; y++) {
                    i = width*y+x;
                    if(y==0){
                        nextpixel=(byte)pixels[i];
                        pixels[i]=(byte)pixels[(height-1)*width+x];
                    }
                    else{
                        tempixel=(byte)pixels[i];
                        pixels[i]=(byte)nextpixel;
                        nextpixel=(byte)tempixel;
                    }
                }
            }
        }
        
    }//YShiftDown
    
    
}//CenterImage_

class ImageRadius_ implements PlugInFilter {
    ImagePlus imp;
    /**
     * The setup method checks whether the image that is currently opened
     * is an 8-bit greyscale image.
     *
     * @param arg string input from the user
     * @param imp the current ImagePlus object that is opened
     * @return true if the image that is opened is 8-bit greyscale
     */
    
    public int setup(String arg, ImagePlus imp) {
        this.imp = imp;
        return DOES_8G;
    }
    
    /**
     *The run method finds the radius of the spherical object.
     *
     *@param ip current ImageProcessor that is opened
     */
    
    public void run(ImageProcessor ip) {
        int height=ip.getHeight();
        int width=ip.getWidth();
        int center=height/2;
        int[] lastpoint=new int[630];                         // last valid radius point on image
        int notvalid=0,                         // number of invalid points ie. edge of radius
        validradii=0,							// radius that meets the minimimum accepted value
		maxradius=0,                         
        totalradii=0,                         // number of valid radii
        sumradii=0,                          // sum of all valid radii
        averageradii=0,                 // average radii of all 4 quadrants of picture
        threshold=(int)IJ.getNumber("Enter the threshold",32.0); // compared threshold level
        double x1=(double)width/2.0,       
        y1=(double)height/2.0,
        estrad=IJ.getNumber("Enter estimated radius(pixel)",105.0), // estimated maximum horizontal radius
        //esty=IJ.getNumber("Enter the y estimated radius(pixel)",105.0),// estimated maximum vertical radius   
        x2=0.0,
        y2=0.0;
        int number=0;
        
        IJ.setColumnHeadings("x \t y \t lastpoint");
        //calculate the new angle to retrieve points from 
            for(double i=0.0;i<=2*Math.PI;i+=0.01){
            x2=x1+estrad*Math.cos(i);
            y2=y1+estrad*Math.sin(i);
            
            double[] pixels=ip.getLine(x1,y1,x2,y2);
        //find the lastpoint of object (radius) of the array of pixels
            for (int j=0;j<pixels.length;j++){
                
                if((int)pixels[j]<threshold)
                    notvalid++;
                else{
                    lastpoint[number]=j;
                    notvalid=0;
                }
                if(notvalid>3)
                    break;
            }
			if(lastpoint[number]>maxradius)
			maxradius=lastpoint[number];
			IJ.write("lastpoint "+lastpoint[number]);
          
        number++;
		}
		//check to see if the lastpoint is valid (maxradius-3)
		for(int k=0;k<number;k++){
		if(lastpoint[k]>=(maxradius-3)){
		 		validradii++;
                totalradii+=lastpoint[k];
				}
				
				/*
		  if(lastpoint>90){
                validradii++;
                totalradii+=lastpoint;
                //IJ.write("lastpoint "+lastpoint);
            }
            */
			}
        averageradii=totalradii/validradii;
        IJ.write("Radius of spherical object:"+averageradii);
        //IJ.write("number"+number);
		//IJ.write("maxradius"+maxradius);    
    }//run
    
    
}//imageradius