regarding zooming of pictures nd web page connectivity

Forum for J2ME mobile games related topics including programming doubts, books and other resources for J2ME game development

regarding zooming of pictures nd web page connectivity

Postby uvrpavan » Sun Mar 25, 2007 7:14 am

hello!
i am trying to prepare a application in which i need to display a map of big size. how to reduce or increase the sizes of the pictures from our applicatioin. and how to put a hyper link connection from our game or an application?
uvrpavan
 
Posts: 19
Joined: Sun Feb 11, 2007 8:52 am

Image Zooming Subroutine - From MobileGD.com

Postby DevelopmentTeam » Mon Mar 26, 2007 3:56 am

Code: Select all
// fixed point constants
   private static final int FP_SHIFT = 13;
   private static final int FP_ONE = 1 << FP_SHIFT;
   private static final int FP_HALF = 1 << (FP_SHIFT - 1);
   
   // resampling modes - valid values for the mode parameter of resizeImage()
   // any other value will default to MODE_BOX_FILTER because of the way the conditionals are set in resizeImage()
   public static final int MODE_POINT_SAMPLE = 0;
   public static final int MODE_BOX_FILTER = 1;
   
   /**
    * getPixels
    * Wrapper for pixel grabbing techniques.
    * I separated this step into it's own function so that other APIs (Nokia, Motorola, Siemens, etc.) can
    * easily substitute the MIDP 2.0 API (Image.getRGB()).
    * @param src The source image whose pixels we are grabbing.
    * @return An int array containing the pixels in 32 bit ARGB format.
    */
   int[] getPixels(Image src) {
      int w = src.getWidth();
      int h = src.getHeight();
      int[] pixels = new int[w * h];
      src.getRGB(pixels,0,w,0,0,w,h);
      return pixels;
   }
   
   /**
    * drawPixels
    * Wrapper for pixel drawing function.
    * I separated this step into it's own function so that other APIs (Nokia, Motorola, Siemens, etc.) can
    * easily substitute the MIDP 2.0 API (Image.createRGBImage()).
    * @param pixels int array containing the pixels in 32 bit ARGB format.
    * @param w The width of the image to be created.
    * @param h The height of the image to be created. This parameter is actually superfluous, because it
    * must equal pixels.length / w.
    * @return The image created from the pixel array.
    */
   Image drawPixels(int[] pixels, int w, int h) {
      return Image.createRGBImage(pixels,w,h,true);
   }
   
   /**
    * resizeImage
    * Gets a source image along with new size for it and resizes it.
    * @param src The source image.
    * @param destW The new width for the destination image.
    * @param destH The new heigth for the destination image.
    * @param mode A flag indicating what type of resizing we want to do. It currently supports two type:
    * MODE_POINT_SAMPLE - point sampled resizing, and MODE_BOX_FILTER - box filtered resizing (default).
    * @return The resized image.
    */
   Image resizeImage(Image src, int destW, int destH, int mode) {
      int srcW = src.getWidth();
      int srcH = src.getHeight();
     
      // create pixel arrays
      int[] destPixels = new int[destW * destH]; // array to hold destination pixels
      int[] srcPixels = getPixels(src); // array with source's pixels
     
      if (mode == MODE_POINT_SAMPLE) {
         // simple point smapled resizing
         // loop through the destination pixels, find the matching pixel on the source and use that
         for (int destY = 0; destY < destH; ++destY) {
            for (int destX = 0; destX < destW; ++destX) {
               int srcX = (destX * srcW) / destW;
               int srcY = (destY * srcH) / destH;
               destPixels[destX + destY * destW] = srcPixels[srcX + srcY * srcW];
            }
         }
      }
      else {
         // precalculate src/dest ratios
         int ratioW = (srcW << FP_SHIFT) / destW;
         int ratioH = (srcH << FP_SHIFT) / destH;
         
         int[] tmpPixels = new int[destW * srcH]; // temporary buffer for the horizontal resampling step
         
         // variables to perform additive blending
         int argb; // color extracted from source
         int a, r, g, b; // separate channels of the color
         int count; // number of pixels sampled for calculating the average
         
         // the resampling will be separated into 2 steps for simplicity
         // the first step will keep the same height and just stretch the picture horizontally
         // the second step will take the intermediate result and stretch it vertically
         
         // horizontal resampling
         for (int y = 0; y < srcH; ++y) {
            for (int destX = 0; destX < destW; ++destX) {
               count = 0; a = 0; r = 0; b = 0; g = 0; // initialize color blending vars
               int srcX = (destX * ratioW) >> FP_SHIFT; // calculate beginning of sample
               int srcX2 = ((destX + 1) * ratioW) >> FP_SHIFT; // calculate end of sample
               
               // now loop from srcX to srcX2 and add up the values for each channel
               do {
                  argb = srcPixels[srcX + y * srcW];
                  a += ((argb & 0xff000000) >> 24); // alpha channel
                  r += ((argb & 0x00ff0000) >> 16); // red channel
                  g += ((argb & 0x0000ff00) >> 8); // green channel
                  b += (argb & 0x000000ff); // blue channel
                  ++count; // count the pixel
                  ++srcX; // move on to the next pixel
               }
               while (srcX <= srcX2 && srcX + y * srcW < srcPixels.length);
               
               // average out the channel values
               a /= count;
               r /= count;
               g /= count;
               b /= count;
               
               // recreate color from the averaged channels and place it into the temporary buffer
               tmpPixels[destX + y * destW] = ((a << 24) | (r << 16) | (g << 8) | b);
            }
         }
         
         // vertical resampling of the temporary buffer (which has been horizontally resampled)
         System.out.println("Vertical resampling...");
         for (int x = 0; x < destW; ++x) {
            for (int destY = 0; destY < destH; ++destY) {
               count = 0; a = 0; r = 0; b = 0; g = 0; // initialize color blending vars
               int srcY = (destY * ratioH) >> FP_SHIFT; // calculate beginning of sample
               int srcY2 = ((destY + 1) * ratioH) >> FP_SHIFT; // calculate end of sample
               
               // now loop from srcY to srcY2 and add up the values for each channel
               do {
                  argb = tmpPixels[x + srcY * destW];
                  a += ((argb & 0xff000000) >> 24); // alpha channel
                  r += ((argb & 0x00ff0000) >> 16); // red channel
                  g += ((argb & 0x0000ff00) >> 8); // green channel
                  b += (argb & 0x000000ff); // blue channel
                  ++count; // count the pixel
                  ++srcY; // move on to the next pixel
               }
               while (srcY <= srcY2 && x + srcY * destW < tmpPixels.length);
               
               // average out the channel values
               a /= count; a = (a > 255) ? 255 : a;
               r /= count; r = (r > 255) ? 255 : r;
               g /= count; g = (g > 255) ? 255 : g;
               b /= count; b = (b > 255) ? 255 : b;
               
               // recreate color from the averaged channels and place it into the destination buffer
               destPixels[x + destY * destW] = ((a << 24) | (r << 16) | (g << 8) | b);
            }
         }
      }
     
      // return a new image created from the destination pixel buffer
      return drawPixels(destPixels,destW,destH);
   }


The code was posted here, http://www.mobilegd.com/index.php?optio ... topic=34.0
User avatar
DevelopmentTeam
Site Admin
 
Posts: 661
Joined: Tue Aug 15, 2006 8:39 am
Location: India


Return to J2ME Games

Who is online

Users browsing this forum: Yahoo [Bot] and 1 guest

cron