"Sharpening" an image

Question

Given an image I have to write a method that will "Sharpen" it. By sharpen, follow the formula newColorValue = (oldColorValue - min) * maxPossiblePixelValue / (max - min) where max and min are the maximum and minimum color values in the surrounding neighborhood. I wrote code that I think SHOULD work but it does random things. The first time I run it it doesn't do anything, and then when I try to sharpen again, I get values that are out of the color range which doesn't seem to make sense. There's a GUI already written and when you click "sharpen" this code executes.
public void execute (Pixmap target)
         ourDialog.show();
        Dimension neighborhood = ourDialog.getSize();
        Dimension bounds = target.getSize();
        int maxRed=0,maxGreen=0,maxBlue=0;
        int minRed=255,minGreen=255,minBlue=255;
        int newRed=0,newGreen=0,newBlue=0;
        for(int x = neighborhood.width/2; x < bounds.width-neighborhood.width/2 ; x++)
             for(int y = neighborhood.height/2; y < bounds.height-neighborhood.height/2; y++)
                  for(int xneighs = x-neighborhood.width/2; xneighs <= x+neighborhood.width/2 ; xneighs ++)
                       for(int yneighs = y-neighborhood.height/2; yneighs <= y+neighborhood.height/2 ; yneighs ++)
                            if(!(x==xneighs && y==yneighs))
                                 maxRed=Math.max(target.getColor(xneighs,yneighs).getRed(), maxRed);
                                 maxGreen=Math.max(target.getColor(xneighs,yneighs).getGreen(), maxGreen);     
                                 maxBlue=Math.max(target.getColor(xneighs,yneighs).getBlue(), maxBlue);     
                                 minRed=Math.min(target.getColor(xneighs,yneighs).getRed(),minRed);
                                 minGreen=Math.min(target.getColor(xneighs,yneighs).getGreen(),minGreen);
                                 minBlue=Math.min(target.getColor(xneighs,yneighs).getBlue(),minBlue);     
             if(!(maxRed==minRed || maxBlue==minBlue || maxGreen==minGreen))
                  newRed = (target.getColor(x,y).getRed()-minRed)*255/(maxRed-minRed);
                  newGreen = (target.getColor(x,y).getGreen()-minGreen)*255/(maxGreen-minGreen);
                 newBlue = (target.getColor(x,y).getBlue()-minBlue)*255/(maxBlue-minBlue);
             else
                  newRed = target.getColor(x,y).getRed()/2;
                  newGreen = target.getColor(x,y).getGreen()/2;
                  newBlue = target.getColor(x,y).getBlue()/2;
               target.setColor(x,y,new Color(newRed,newGreen,newBlue));
        }

Answer 1

The first time I run it it doesn't do anything, and then when I try to sharpen again, I get values that are out of the color
range which doesn't seem to make sense.That can't be true. If you get runtime errors the second time, then the first time did do something: it changed the state of some object (target?) so that out of range values occured when execute() was invoked again. I point this out in case you are confusing "doesn't do anything" with "doesn't change the image on the screen".
I would start by making sure that the rest of the GUI stuff is working correctly. That is add a System.out.println() to ensure that execute() is being executed, and then make sure that any change it makes to target's pixels is being reflected within the GUI. (For instance you could have execute() change all of the pixels to green.)
Then if pixel values are becoming out of range (<0, >255?) insert code to see at exactly what place that is occuring. Check the values of newXXX after they have been calculated and if they are out of range print the values of target pixel, minXXX and maxXXX on which they are based. (I'd be suspicious of the if block near the end.)
I am not sure I understand the if/else blocks at the end. You seem to be checking minXXX==maxXXX for all of the colours similtaneously. For instance if the blue values of all the neighbouring pixels are zero (or 255), you are halving the red and green pixel values are well. Is this what you mean to do?
[Edit] Further to that if block at the end. Consider a neighbourbood semi-width of 1, and a group of adjacent pixels whose red values look like this:1    1    1
1    255  1
1    1    2getRed=255, minRed=1 and maxRed=2 (I think I'm right in thinking that getRed doesn't participate in the min/max calculation). So maxRed==minRed is false and the if block is entered.
newRed = (255-1)*255/(2-1) > 255
So you have a problem.