Finding the difference between two images using their samples

Helps in finding the difference between two images by obtaining their samples and comparing them. The number of bands assosiated with each image is also compared, along with their width and height.

File file1 = new File("C:\Documents and Settings\515956\Desktop\Raj_image.jpg"); 
File file2 = new File("C:\Documents and Settings\515956\Desktop\Local_image.jpg");  
BufferedImage image1 = ImageIO.read(file1); 
BufferedImage image2 = ImageIO.read(file2);

Raster r1 = image1.getData();
Raster r2 = image2.getData(); 
boolean ret; // Stores result. 
// Check image sizes and number of bands. If there are different
// then no need to compare images as they are definitely not equal. 

System.out.println("image1 band"+r1.getNumBands()+"  image2 band"+r2.getNumBands()+"  image1 width"+r1.getWidth()+"  image2 width"+ r2.getWidth()+"  image1 height"+ r1.getHeight()+"  image2 height"+r2.getHeight()); 

if (r1.getNumBands() != r2.getNumBands() ||   r1.getWidth() != r2.getWidth() ||   r1.getHeight() != r2.getHeight()) {  
 ret = false;
 System.out.println("Primary comparison failure");

} 

else {  
 // #Bands and image bounds match so compare each sample in turn. 
 ret = true;   
 search:   
  for (int i=0; i<r1.getNumBands(); ++i) { 
   for (int x=0; x<r1.getWidth(); ++x) {    
    for (int y=0; y<r1.getHeight(); ++y) {  


     if (r1.getSample(x, y, i) != r2.getSample(x, y, i)) {     
      // At least one sample differs so result is false; 
      ret = false; 
      System.out.println("sample difference");
      // Use labeled break to terminate all loops.
      break
      search;   
     }   
    }    
   }   
  }   

}
System.out.println(ret);

[ Read More ]

Picture Browser

This component lets user browse for pictures in his phone and select one

package mypackage;

import java.io.IOException;
import java.io.InputStream;

import javax.microedition.io.Connector;
import javax.microedition.io.file.FileConnection;

import net.rim.device.api.system.Bitmap;
import net.rim.device.api.system.DeviceInfo;
import net.rim.device.api.system.EncodedImage;
import net.rim.device.api.ui.Color;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.XYEdges;
import net.rim.device.api.ui.component.BitmapField;
import net.rim.device.api.ui.component.ButtonField;
import net.rim.device.api.ui.container.MainScreen;
import net.rim.device.api.ui.decor.Border;
import net.rim.device.api.ui.decor.BorderFactory;
import net.rim.device.api.ui.picker.FilePicker;

public class MyBrowseScreen extends MainScreen implements FilePicker.Listener{

 ButtonField browsePictures;
 private FilePicker _filePicker;
 BitmapField profilePictureField;
 Graphics graphics;
 Bitmap noImageBitmap = Bitmap.getBitmapResource("btn_discover.png");// any default bitmap to be displayed
 
 public MyBrowseScreen(){
  
  
  
  _filePicker = FilePicker.getInstance();
  _filePicker.setListener(this);
 
  profilePictureField = new BitmapField(noImageBitmap);
  profilePictureField.setBorder(BorderFactory.createRoundedBorder(
    new XYEdges(3, 3, 3, 3),
    Color.BLACK,100,
    Border.STYLE_FILLED));
  add(profilePictureField);
  
  browsePictures = new ButtonField("Browse",100){
   protected boolean navigationClick(int status, int time) {
    
    _filePicker.setTitle("Choose a picture");
    _filePicker.setView(FilePicker.VIEW_PICTURES);
    _filePicker.show();
    
    return super.navigationClick(status, time);
   }
  };
  
  add(browsePictures);
  
 }
 
 
 

 public void selectionDone(String selected) {
  

  if (selected != null && selected.length() > 0) {
   FileConnection fc;
   try {

    fc = (FileConnection) Connector.open(selected);
    InputStream is = fc.openDataInputStream();
    byte[] data_bytes = new byte[(int) fc.fileSize()];
    is.read(data_bytes);
    EncodedImage en_image = EncodedImage.createEncodedImage(data_bytes, 0, -1);
    Bitmap picture = en_image.getBitmap();
    
    // resize bitmap to bitmap field size
    picture = getResizedBitmap(noImageBitmap.getHeight(), noImageBitmap.getWidth(), en_image.getBitmap());

    is.close();
    fc.close();
    
    // in torch devices the image from camera gallery comes inverted so we need to rotate it
    if(selected.indexOf("camera")!=-1 && Integer.parseInt(DeviceInfo.getDeviceName().substring(0, 4)) == 9800){
     
     try {
      picture = rotateImage(picture, 90);
     } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
    
    profilePictureField.setBitmap(picture);
    

    invalidate();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }

  }

 }
 
 public void setBitmap(Bitmap profilePic){
 
  profilePic = getResizedBitmap(noImageBitmap.getHeight(),noImageBitmap.getWidth(),profilePic);
  profilePictureField.setBitmap(profilePic);
 }
 
 public static Bitmap getResizedBitmap(int resizeHeight, int resizeWidth,
   Bitmap bitmap) {

  Bitmap scaleBitmap = new Bitmap(resizeWidth, resizeHeight);
  bitmap.scaleInto(scaleBitmap, Bitmap.FILTER_BILINEAR);
  return scaleBitmap;

 }
 
  public static Bitmap rotateImage(Bitmap image, int angle) throws Exception
     {
      if(angle == 0)
      {
       return image; 
      }
      else if(angle != 180 && angle != 90 && angle != 270)
      {
       throw new Exception("Invalid angle");
      }
      
      int width = image.getWidth();
      int height = image.getHeight();
      
      Bitmap rotated = new Bitmap(width, height);
    
      int[] rowData = new int[width];
      int[] rotatedData = new int[width * height];
      
      int rotatedIndex = 0;
      
      for(int i = 0; i < height; i++)
      {
       image.getARGB(rowData, 0, width, 0, i, width, 1);
       
      
       for(int j = 0; j < width; j++)
       {
        rotatedIndex = 
         angle == 90 ? (height - i - 1) + j * height : 
         (angle == 270 ? i + height * (width - j - 1) : 
          width * height - (i * width + j) - 1
         );
      
        rotatedData[rotatedIndex] = rowData[j];
       }
      }
      
      if(angle == 90 || angle == 270)
      {
       rotated.setARGB(rotatedData, 0, width, 0, 0, width, height);
       return rotated;
      }
      else
      {
       rotated.setARGB(rotatedData, 0, width, 0, 0, height, width);
       return rotated; 
      }
     }


 
}

[ Read More ]

Cropping of image using Java

When a user wants to set a picture as profile pic he will need the functionaly for cropping the picture.

import net.rim.device.api.system.Bitmap;
import net.rim.device.api.system.Display;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.MenuItem;
import net.rim.device.api.ui.TouchEvent;
import net.rim.device.api.ui.UiApplication;
import net.rim.device.api.ui.component.BitmapField;
import net.rim.device.api.ui.component.ButtonField;
import net.rim.device.api.ui.container.MainScreen;

public final class MyCropScreen extends MainScreen {
 
 Graphics graphics;
 int initialLeftPoint = 80;
 
 int touchX ;
 int touchY ;

 int crop_rectangle_x[] = new int[4];
 int crop_rectangle_y[] = new int[4];

 int crop_rect_width;

 int pointerToPoint;

 Bitmap picture;

 ButtonField save;
 BitmapField field;

 boolean downInsideCropArea = false;
 boolean onCropLine = false;
 int lastMovePointSize = 0;

 
 /**
  * 
  * @param bitmap bitmap to be cropped
  * @param browseScreenInstance  screen instance to which cropped bitmap is to be set
  */
 public MyCropScreen(final Bitmap bitmap, final MyBrowseScreen browseScreenInstance) {

  picture = bitmap;
  Bitmap blank_surface = new Bitmap(Bitmap.getDefaultType(),
    picture.getWidth(), picture.getHeight());
  graphics = Graphics.create(blank_surface);
  graphics.drawBitmap(0, 0, picture.getWidth(), picture.getHeight(),
    picture, 0, 0);

  crop_rectangle_x[0] = crop_rectangle_x[3] = initialLeftPoint;
  crop_rectangle_x[1] = crop_rectangle_x[2] = Display.getWidth() - initialLeftPoint;

  crop_rectangle_y[0] = crop_rectangle_y[1] = (Display.getHeight() - (crop_rectangle_x[2] - crop_rectangle_x[0])) / 2;
  crop_rectangle_y[2] = crop_rectangle_y[3] = crop_rectangle_y[0] + (crop_rectangle_x[2] - crop_rectangle_x[0]);

  graphics.drawOutlinedPath(crop_rectangle_x, crop_rectangle_y, null, null, true);

  crop_rect_width = crop_rectangle_x[1] - crop_rectangle_x[0];

  field = new BitmapField(blank_surface) {
   protected boolean touchEvent(TouchEvent message) {

    int eventCode = message.getEvent();
    
    
    if(eventCode == TouchEvent.DOWN ){
     
     // Get the screen coordinates of the touch event
     
     touchX = message.getX(1);
     touchY = message.getY(1);
    }

    if (eventCode == TouchEvent.DOWN || downInsideCropArea
      || onCropLine) {

     if ((onCropLine || onTheCropLine(touchX, touchY)) && !downInsideCropArea) {

      onCropLine = true;

      if (eventCode == TouchEvent.MOVE) {

       System.out.println(" inside move");
       int size = message.getMovePointsSize();

       int moveX[] = new int[size];
       int moveY[] = new int[size];

       message.getMovePoints(1, moveX, moveY,
         new int[size]);

       if (size == 1) {

        cropPoints(moveX[0], moveY[0], touchX, touchY);
        

         graphics.clear();
         graphics.drawBitmap(0, 0,
           picture.getWidth(),
           picture.getHeight(), picture, 0, 0);
         graphics.drawOutlinedPath(crop_rectangle_x, crop_rectangle_y, null, null,
           true);
         invalidate();

        
       }

       for (int i = lastMovePointSize; i < size
         && size > 1; i++) {

        cropPoints(moveX[i], moveY[i], moveX[i - 1],
          moveY[i - 1]);

        

         graphics.clear();
         graphics.drawBitmap(0, 0,
           picture.getWidth(),
           picture.getHeight(), picture, 0, 0);
         graphics.drawOutlinedPath(crop_rectangle_x, crop_rectangle_y, null, null,
           true);
         invalidate();

        
       }

       lastMovePointSize = size;
       System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + ","
         + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
       System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + ","
         + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);
       System.out.println("ON CROP MOVE");

      }else{
       System.out.println(" outside move on crop event code is "+eventCode);
      }

     } else {

      if (downInsideCropArea || insideCropRect(touchX, touchY)) {

       downInsideCropArea = true;

       
       if (eventCode == TouchEvent.MOVE) {

        int size = message.getMovePointsSize();

        int moveX[] = new int[size];
        int moveY[] = new int[size];

        message.getMovePoints(1, moveX, moveY,
          new int[size]);

        if (size == 1) {

         int movementX = moveX[0] - touchX;
         int movementY = moveY[0] - touchY;
         
         int x_new[] = { crop_rectangle_x[0] + movementX,
           crop_rectangle_x[0] + movementX + crop_rect_width,           
           crop_rectangle_x[0] + movementX + crop_rect_width,
           crop_rectangle_x[0] + movementX };
         int y_new[] = { crop_rectangle_y[0] + movementY,
           crop_rectangle_y[0] + movementY ,
           crop_rectangle_y[0] + movementY + crop_rect_width,           
           crop_rectangle_y[0] + movementY + crop_rect_width};
         
         
         
         if (isPointInsidePicture(x_new, y_new)) {

        
          crop_rectangle_x = x_new;
          crop_rectangle_y = y_new;
          graphics.clear();
          graphics.drawBitmap(0, 0,
            picture.getWidth(),
            picture.getHeight(), picture,
            0, 0);
          graphics.drawOutlinedPath(crop_rectangle_x, crop_rectangle_y, null,
            null, true);
          invalidate();

         }

        }

        for (int i = lastMovePointSize; i < size
          && size > 1; i++) {

         int movementX = moveX[i] - moveX[i - 1];
         int movementY = moveY[i] - moveY[i - 1];
         
         int x_new[] = { crop_rectangle_x[0] + movementX,
           crop_rectangle_x[0] + movementX + crop_rect_width,           
           crop_rectangle_x[0] + movementX + crop_rect_width,
           crop_rectangle_x[0] + movementX };
         int y_new[] = { crop_rectangle_y[0] + movementY,
           crop_rectangle_y[0] + movementY ,
           crop_rectangle_y[0] + movementY + crop_rect_width,           
           crop_rectangle_y[0] + movementY + crop_rect_width};
         
         
         
         if (isPointInsidePicture(x_new, y_new)) {

          crop_rectangle_x = x_new;
          crop_rectangle_y = y_new;

         System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + ","
           + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
         System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + ","
           + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);
         System.out.println(movementX + ","
           + movementY);

        

          graphics.clear();
          graphics.drawBitmap(0, 0,
            picture.getWidth(),
            picture.getHeight(), picture,
            0, 0);
          graphics.drawOutlinedPath(crop_rectangle_x, crop_rectangle_y, null,
            null, true);
          invalidate();

         }

        }

        lastMovePointSize = size;
       }

      } else {
       lastMovePointSize = 0;
       downInsideCropArea = false;
      }
     }
    }

    if (eventCode == TouchEvent.UP) {
     lastMovePointSize = 0;
     downInsideCropArea = false;
     onCropLine = false;
    }

    

    return true;
   }
  };
  add(field);

  MenuItem crop = new MenuItem("crop", 0, 0) {

   public void run() {

    Bitmap croppedBitmap = cropImage(bitmap, crop_rectangle_x[0], crop_rectangle_y[0],
      (crop_rectangle_x[2] - crop_rectangle_x[0]), (crop_rectangle_y[3] - crop_rectangle_y[0]));
    browseScreenInstance.setBitmap(croppedBitmap);
    UiApplication.getUiApplication().popScreen(MyCropScreen.this);
   };
  };

  addMenuItem(crop);

 }

 
 // This method determines what the next crop points should be
 public void cropPoints(int movementX, int movementY, int touchX, int touchY) {

  int diff = 0;

  if ((touchX < crop_rectangle_x[0] + 3 && touchX > crop_rectangle_x[0] - 5)) {

   if (movementX >= 1) {
    
    diff = crop_rectangle_x[0] - movementX;
    crop_rectangle_x[0] = crop_rectangle_x[3] = movementX;
    crop_rectangle_y[0] = crop_rectangle_y[1] = crop_rectangle_y[0] - diff;
    crop_rectangle_x[1] = crop_rectangle_x[2] = crop_rectangle_x[2] + diff;
    crop_rectangle_y[2] = crop_rectangle_y[3] = crop_rectangle_y[2] + diff;
   }
   

   System.out.println("diff " + diff + "move x " + movementX);
   System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + "," + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
   System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + "," + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);

  } else if ((touchX < crop_rectangle_x[1] + 3 && touchX > crop_rectangle_x[1] - 5)) {

   if (movementX <= (Display.getWidth() - 1)) {
    
    diff = crop_rectangle_x[1] - movementX;
    crop_rectangle_x[0] = crop_rectangle_x[3] = crop_rectangle_x[0] + diff;
    crop_rectangle_y[0] = crop_rectangle_y[1] = crop_rectangle_y[0] + diff;
    crop_rectangle_x[1] = crop_rectangle_x[2] = movementX;
    crop_rectangle_y[2] = crop_rectangle_y[3] = crop_rectangle_y[2] - diff;
   }
   
   System.out.println("diff " + diff + "move x " + movementX);
   System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + "," + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
   System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + "," + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);

  } else if ((touchY < crop_rectangle_y[0] + 3 && touchY > crop_rectangle_y[0] - 5)) {

   if(movementY >= 1){
    
    diff = crop_rectangle_y[0] - movementY;
    crop_rectangle_x[0] = crop_rectangle_x[3] = crop_rectangle_x[0] - diff;
    crop_rectangle_y[0] = crop_rectangle_y[1] = movementY;
    crop_rectangle_x[1] = crop_rectangle_x[2] = crop_rectangle_x[2] + diff;
    crop_rectangle_y[2] = crop_rectangle_y[3] = crop_rectangle_y[2] + diff;

   }
   
   System.out.println("diff " + diff + "move x " + movementY);
   System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + "," + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
   System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + "," + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);

  } else if ((touchY < crop_rectangle_y[2] + 3 && touchY > crop_rectangle_y[2] - 5)) {

   if(movementY <= (Display.getHeight() - 1)){
   
    diff = crop_rectangle_y[2] - movementY;
    crop_rectangle_x[0] = crop_rectangle_x[3] = crop_rectangle_x[0] + diff;
    crop_rectangle_y[0] = crop_rectangle_y[1] = crop_rectangle_y[0] + diff;
    crop_rectangle_x[1] = crop_rectangle_x[2] = crop_rectangle_x[2] - diff;
    crop_rectangle_y[2] = crop_rectangle_y[3] = movementY;
   }
   

   System.out.println("diff " + diff + "move x " + movementY);
   System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + "," + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
   System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + "," + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);

  }

  crop_rect_width = crop_rectangle_x[1] - crop_rectangle_x[0];
 }

 // This method determines if the touched point is inside the given picture or not
 public boolean isPointInsidePicture(int x[], int y[]) {

  if (x[0] >= 1 && x[1] <= (Display.getWidth() - 1) && y[0] >= 1
    && y[2] <= (Display.getHeight() - 1)) {

   return true;
  }

  return false;
 }

 // This method determines if the touched point is inside the crop rectangle or not
 public boolean insideCropRect(int touchX, int touchY) {

  if (crop_rectangle_x[0] < touchX && crop_rectangle_x[1] > touchX && crop_rectangle_y[0] < touchY && crop_rectangle_y[2] > touchY) {
   System.out.println("inside rect");
   return true;

  }
  
  System.out.println("outside rect");
  System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + ","
    + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
  System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + ","
    + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);
  return false;
 }

 // This method determines if the touched point is on the crop rectangle or not
 public boolean onTheCropLine(int touchX, int touchY) {

  if ((touchX < crop_rectangle_x[0] + 3 && touchX > crop_rectangle_x[0] - 5)
    || (touchX < crop_rectangle_x[1] + 3 && touchX > crop_rectangle_x[1] - 5)
    || (touchY < crop_rectangle_y[0] + 3 && touchY > crop_rectangle_y[0] - 5)
    || (touchY < crop_rectangle_y[2] + 3 && touchY > crop_rectangle_y[2] - 5)) {
   
   
   System.out.println("on crop region");
   return true;

  }
  System.out.println("outside crop"+touchX+" ,"+touchY);
  System.out.println(crop_rectangle_x[0] + "," + crop_rectangle_x[1] + ","
    + crop_rectangle_x[2] + "," + crop_rectangle_x[3]);
  System.out.println(crop_rectangle_y[0] + "," + crop_rectangle_y[1] + ","
    + crop_rectangle_y[2] + "," + crop_rectangle_y[3]);
  return false;
 }

 // This method returns the image after cropping
 public Bitmap cropImage(Bitmap image, int x, int y, int width, int height) {
  Bitmap result = new Bitmap(width, height);
  Graphics g = Graphics.create(result);
  g.drawBitmap(0, 0, width, height, image, x, y);
  return result;
 }
}

[ Read More ]