import javax.microedition.lcdui.Image;


public class Lib_resize
{
/// вот этот метод изменяет размеры Image


  public static Image resize_image(Image oldImage,int newW,int newH){
/// init sizes of images
    int oldW = oldImage.getWidth();
    int oldH = oldImage.getHeight();
    

/// grab oldImage -> int[] // в мидлете по другому
    int[] pixels = new int[oldW*oldH];

   oldImage.getRGB(pixels,0,oldW,0, 0, oldW, oldH);
    

/// resize code /not optimized/
    int[] lines = new int[newW*oldH];
    int[] columns = new int[newW * newH];




    if (true){
///Быстрый алгоритм
      if (newW < oldW){
        for (int k = 0; k < oldH; k++) { // trough all lines
          int i = k * oldW; // index in old pix
          int j = k * newW; // index in new pix
          int part = newW;
          int addon = 0, r=0, g=0, b=0, a=0;
          for (int m=0; m<newW; m++){ ///OPTI ijm!!! need???
            int total = oldW;
            int R=0, G=0, B=0, A=0;
            if (addon!=0){
              R=r*addon; G=g*addon; B=b*addon; A=a*addon;
              total-=addon;
            }
            while (0<total){
              a = (pixels[i] >> 24) & 0xff;
              r = (pixels[i] >> 16) & 0xff;
              g = (pixels[i] >>  8) & 0xff;
              b =  pixels[i++]      & 0xff;
              if (total>part){
                R+=r*part; G+=g*part; B+=b*part; A+=a*part;
              }
              else{
                R+=r*total; G+=g*total; B+=b*total; A+=a*total;
                addon = part - total;
///set new pixel
                lines[j++]=((R/oldW)<<16)|((G/oldW)<<8)|
                    (B/oldW)|((A/oldW)<<24); // A??
              }
              total-=part;
            }
          }
        }
      }
      else{ /// newW > oldW
        int part = oldW;
        for (int k = 0; k < oldH; k++) { // trough all lines
          int i = k * oldW; // index in old pix
          int j = k * newW; // index in new pix
          int total= 0;
          int r=0, g=0, b=0, a=0;
          for (int m=0; m<newW; m++){
            int R=0, G=0, B=0, A=0;
            if (total>=part){
              R=r*part; G=g*part; B=b*part; A=a*part;
              total-=part;
            }
            else{
              if (0!=total){
                R=r*total; G=g*total; B=b*total; A=a*total;
              }
              a = (pixels[i] >> 24) & 0xff;
              r = (pixels[i] >> 16) & 0xff;
              g = (pixels[i] >>  8) & 0xff;
              b =  pixels[i++]      & 0xff;
              int addon = part - total;
              R+=r*addon; G+=g*addon; B+=b*addon; A+=a*addon;
              total=newW - addon;
            }
///set new pixel
            lines[j++]=((R/oldW)<<16)|((G/oldW)<<8)|
               (B/oldW)|((A/oldW)<<24); // A??
          }
        }
      }
/// проходим по столбцам
      if (newH < oldH) {
        for (int k = 0; k < newW; k++) { // trough columns
        int i = k; // index in lines pix
        int j = k; // index in new pix
        int part = newH;
        int addon = 0, r=0, g=0, b=0, a=0;
        for (int m=0; m<newH; m++){
          int total = oldH;
          int R=0, G=0, B=0, A=0;
          if (addon!=0){
            R=r*addon; G=g*addon; B=b*addon; A=a;//*addon;
            total-=addon;
          }
          while (0<total){
//            a = (lines[i] >> 24) & 0xff;// may no rotate
            a =  lines[i] & 0xff000000;
            r = (lines[i] >> 16) & 0xff;
            g = (lines[i] >> 8)  & 0xff;
            b =  lines[i]        & 0xff;
            i+=newW;
            if (total>part){
              R+=r*part; G+=g*part; B+=b*part; A+=a;//*part;
            }
            else{
              R+=r*total; G+=g*total; B+=b*total; A+=a;//*total;
              addon = part - total;
///set new pixel
              if (0!=A)
              columns[j]=((R/oldH)<<16)|((G/oldH)<<8)|
                 (B/oldH)|0xff000000; // A??
              else
              columns[j]=0;//((R/oldH)<<16)|((G/oldH)<<8)|(B/oldH); // A??
              j+=newW;
            }
            total-=part;
          }
        }
      }
    }
    else{
      int part = oldH;
      for (int k = 0; k < newW; k++) { // trough all lines
        int i = k; // index in old pix
        int j = k; // index in new pix
        int total= 0;
        int r=0, g=0, b=0, a=0;
        for (int m=0; m<newH; m++){
          int R=0, G=0, B=0, A=0;
          if (total>=part){
            R=r*part; G=g*part; B=b*part; A=a;//*part;
            total-=part;
          }
          else{
            if (0!=total){
              R=r*total; G=g*total; B=b*total; A=a;//*total;
            }
//            a = (lines[i] >> 24) & 0xff;// may no rotate
            a =  lines[i] & 0xff000000;
            r = (lines[i] >> 16) & 0xff;
            g = (lines[i] >>  8) & 0xff;
            b =  lines[i]        & 0xff;
            i+=newW;
            int addon = part - total;
            R+=r*addon; G+=g*addon; B+=b*addon; A+=a;//*addon;
            total=newH - addon;
          }
///set new pixel
          if (0!=A)
          columns[j]=((R/oldH)<<16)|((G/oldH)<<8)|
             (B/oldH)|0xff000000; // A??
          else
          columns[j]=0;//((R/oldH)<<16)|((G/oldH)<<8)|(B/oldH);

          j+=newW;
        }
      }
    }
  }



///медленный алгоритм (зато простой)
    else{//not fast
      for (int k = 0; k < oldH; k++) {
        int id = k * oldW;
        int a = (pixels[id] >> 24) & 0xff,
            r = (pixels[id] >> 16) & 0xff,
            g = (pixels[id] >> 8) & 0xff,
            b = pixels[id] & 0xff,
            t = newW;
        for (int i = 0; i < newW; i++) {
          int A = 0, R = 0, G = 0, B = 0;
          for (int j = 0; j < oldW; j++) {
            A += a;
            R += r;
            G += g;
            B += b;
            t--;
            if (0 == t) {
              id++;
              t = newW;
              if (id < oldW * oldH) {
                a = (pixels[id] >> 24) & 0xff;
                r = (pixels[id] >> 16) & 0xff;
                g = (pixels[id] >> 8) & 0xff;
                b = pixels[id] & 0xff;
              }
            }
          } /// A???
          lines[i + k * newW] = ( (R / oldW) << 16) | ( (G / oldW) << 8) |
              (B / oldW) | ((A/oldW)<<24); // A??
        }
      }
// проходим по столбцам
      for (int k = 0; k < newW; k++) {
          int id = k; // upper line
          int a = (lines[id] >> 24) & 0xff,
              r = (lines[id] >> 16) & 0xff,
              g = (lines[id] >> 8) & 0xff,
              b = lines[id] & 0xff,
              t = newH;
          for (int i = 0; i < newH; i++) {
            int A = 0, R = 0, G = 0, B = 0;
            for (int j = 0; j < oldH; j++) {
              A += a;
              R += r;
              G += g;
              B += b;
              t--;
              if (0 == t) {
                id += newW;
                t = newH;
                if (id < newW * oldH) {
                  a = (lines[id] >> 24) & 0xff;
                  r = (lines[id] >> 16) & 0xff;
                  g = (lines[id] >> 8) & 0xff;
                  b = lines[id] & 0xff;
                }
              }
            } /// A???
            columns[i * newW + k] = ( (R / oldH) << 16) | ( (G / oldH) << 8) |
                (B / oldH) | ((A/oldW)<<24); // A??
          }
        }
      }
   
      return Image.createRGBImage(columns,newW,newH,true);
  }


}