Hi,
I want to create down-scaled Bitmaps ( original Bitmap loaded from asset) with high quality comparable to the quality of bitmaps scaled with professional software like Paint.net (in Paint.NET the algorithm for scaling is choosen in a field called Interpolation. The highest setting uses supersampling)?

I understand how to implement supersampling for anti-aliasing. For anti-aliasing-purpose the original image is rendered in higher resolution and then gets downsampled. For Example to get a target image of 100x100 you would render the scene to 200x200 and then downsampling it with a 2x2 grid.

But, how the algorithm can handle downsampling from let's say 400x400 to 175x175 for scaling-purpose. The grid must be ~ 2.285x2.285 in this case. So how can supersampling be implemented for scaling-purpose?

I tried this code:

1. public static Bitmap downscaleBitmap(Bitmap src, int targetWidth, int targetHeight, int off){
2.         float r = (src.getWidth()-off)/(float)targetWidth;
3.         float s = (src.getHeight()-off)/(float)targetHeight;
4.         Bitmap target = Bitmap.createBitmap(Math.round(src.getWidth()/r), Math.round(src.getHeight()/s), Config.ARGB_8888);
5.         r = src.getWidth()/(float)target.getWidth();
6.         s = src.getHeight()/(float)target.getHeight();
7.         int argb;
8.         int red;
9.         int green;
10.         int blue;
11.         int alpha;
12.         float wx;
13.         float wy;
14.         float n;
15.         for(int i=0;i<target.getWidth();++i){
16.             for(int j=0;j<target.getHeight();++j){
17.                 red = 0;
18.                 green = 0;
19.                 blue = 0;
20.                 alpha = 0;
21.                 n=0;
22.                 for(int k =(int)(i*r);k<roundUp((i+1)*r);++k){
23.                     if(k<i*r){
24.                         wx = k-i*r+1;
25.                     }else{
26.                         if(k+1>(i+1)*r)
27.                             wx = (i+1)*r-k;
28.                         else
29.                             wx = 1;
30.                     }
31.                     for(int l=(int)(j*s);l<roundUp((j+1)*s);++l){
32.                         if(l<j*s){
33.                             wy = l-j*s+1;
34.                         }else{
35.                             if(l+1>(j+1)*s)
36.                                 wy = (j+1)*s-l;
37.                             else
38.                                 wy = 1;
39.                         }
40.                         n+=wy*wx;
41.                         argb=src.getPixel(k, l);
42.                         red += wx*wy*Color.red(argb);
43.                         green += wx*wy*Color.green(argb);
44.                         blue += wx*wy*Color.blue(argb);
45.                         alpha += wx*wy*Color.alpha(argb);
46.                     }
47.                 }
48.                 target.setPixel(i, j, Color.argb((int)(alpha/n), (int)(red/n), (int)(green/n), (int)(blue/n)));
49.             }
50.         }
51.         return target;
52.     }

The following image shows the same 100x100 bitmap scaled to 54x54. The left one is scaled by Paint.Net and the right one by my algorithm. Doesn't look good for my implementation... How can I improve my code?



thx & regards

PS: I work with Java on Android, but I think my question is more generel then android-specific..

EDIT:
I changed my code + added a bit blur to the bitmap before scaling like amnon.owed suggests. The result is pretty good on my smartphone. Even a bit better then the "Paint.Net-version" !