ビットマップ変換：透明なビットマップから透明な部分を除外するビットマップの作成

Question

ビットマップのセットがあります。それらはある程度透明ですが、どの部分が透明であるかは事前に分かりません。私は透明な部分を除いた元のビットマップから新しいビットマップを作成したいが、正方形にしたい。

は、私は、既存のマップのうち、ビットマップを作成する方法を知っているが、私は一部が透明であるかを調べる方法がわからないと達成するためにそれを使用する方法：私は、このイメージがそれを説明すると思います私の目標。

これは私がこれを行うことを計画する方法である：

public Bitmap cutImage(Bitmap image) { 
     Bitmap newBitmap = null; 

     int width = image.getWidth(); 
     int height = image.getHeight(); 

     newBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); 

     Canvas canvas = new Canvas(newBitmap); 

     //This is where I need to find out correct values of r1 and r1. 

     Rect r1 = new Rect(?, ?, ?, ?); 
     Rect r2 = new Rect(?, ?, ?, ?); 

     canvas.drawBitmap(image, r1, r2, null); 

     return newBitmap; 
    } 

誰もがこれを達成する方法を知っていますか？

EDIT：

私はそれを左、右、上、下の値を見つけるために、次のアルゴリズムを使用して動作しました：あなたはトリミングしたいすべての画像は、多かれ少なかれある場合

private int x1; 
private int x2; 
private int y1; 
private int y2; 

private void findRectValues(Bitmap image) 
{ 
    for(int x = 0; x < image.getWidth(); x++) 
    { 
     for(int y = 0; y < image.getHeight(); y++) 
     { 
      if(image.getPixel(x, y) != Color.TRANSPARENT) 
      { 
       System.out.println("X1 is: " + x); 
       x1 = x; 
       break; 
      } 
     } 

     if(x1 != 0) 
      break; 

    } 

    for(int x = image.getWidth()-1; x > 0; x--) 
    { 
     for(int y = 0; y < image.getHeight(); y++) 
     { 
      if(image.getPixel(x, y) != Color.TRANSPARENT) 
      { 
       System.out.println("X2 is: " + x); 
       x2 = x; 
       break; 
      } 
     } 

     if(x2 != 0) 
      break; 

    } 

    for(int y = 0; y < image.getHeight(); y++) 
    { 
     for(int x = 0; x < image.getWidth(); x++) 
     { 
      if(image.getPixel(x, y) != Color.TRANSPARENT) 
      { 
       System.out.println("Y1 is: " + y); 
       y1 = y; 
       break; 
      } 
     } 

     if(y1 != 0) 
      break; 

    } 

    for(int y = image.getHeight()-1; y > 0; y--) 
    { 
     for(int x = 0; x < image.getWidth(); x++) 
     { 
      if(image.getPixel(x, y) != Color.TRANSPARENT) 
      { 
       System.out.println("Y2 is: " + y); 
       y2 = y; 
       break; 
      } 
     } 

     if(y2 != 0) 
      break; 

    } 
} 

Answer 1

元のキャンバスの中央には、次のようなものがあります：

1. 不透明ピクセル
2. 左上のピクセルと右下を見つけたら、目的のターゲットを取得します。
3. コピー画像あなたは今

を喜ばせるよう、疑問が残るが、あなたは透明画素考えるものです。アルファTrasparencyはカウントされますか？もしそうなら、あなたはそれが画像から切り取られるのに十分透明であると判断するまで、どのくらいのアルファ？

Answer 2

私は、これはもう少し効率的だと思うし、それは、あなたのビットマップの非透明領域を見つけ、xとyのビットマップ全体で反復処理し、最小値と最大値を見つけるために私

public Bitmap cropBitmapToBoundingBox(Bitmap picToCrop, int unusedSpaceColor) { 
    int[] pixels = new int[picToCrop.getHeight() * picToCrop.getWidth()]; 
    int marginTop = 0, marginBottom = 0, marginLeft = 0, marginRight = 0, i; 
    picToCrop.getPixels(pixels, 0, picToCrop.getWidth(), 0, 0, 
      picToCrop.getWidth(), picToCrop.getHeight()); 

    for (i = 0; i < pixels.length; i++) { 
     if (pixels[i] != unusedSpaceColor) { 
      marginTop = i/picToCrop.getWidth(); 
      break; 
     } 
    } 

    outerLoop1: for (i = 0; i < picToCrop.getWidth(); i++) { 
     for (int j = i; j < pixels.length; j += picToCrop.getWidth()) { 
      if (pixels[j] != unusedSpaceColor) { 
       marginLeft = j % picToCrop.getWidth(); 
       break outerLoop1; 
      } 
     } 
    } 

    for (i = pixels.length - 1; i >= 0; i--) { 
     if (pixels[i] != unusedSpaceColor) { 
      marginBottom = (pixels.length - i)/picToCrop.getWidth(); 
      break; 
     } 
    } 

    outerLoop2: for (i = pixels.length - 1; i >= 0; i--) { 
     for (int j = i; j >= 0; j -= picToCrop.getWidth()) { 
      if (pixels[j] != unusedSpaceColor) { 
       marginRight = picToCrop.getWidth() 
         - (j % picToCrop.getWidth()); 
       break outerLoop2; 
      } 
     } 
    } 

    return Bitmap.createBitmap(picToCrop, marginLeft, marginTop, 
      picToCrop.getWidth() - marginLeft - marginRight, 
      picToCrop.getHeight() - marginTop - marginBottom); 
} 

Answer 3

のために素晴らしい作品不透明領域の次に、それらの座標にビットマップをトリミングします。

Bitmap CropBitmapTransparency(Bitmap sourceBitmap) 
{ 
    int minX = sourceBitmap.getWidth(); 
    int minY = sourceBitmap.getHeight(); 
    int maxX = -1; 
    int maxY = -1; 
    for(int y = 0; y < sourceBitmap.getHeight(); y++) 
    { 
     for(int x = 0; x < sourceBitmap.getWidth(); x++) 
     { 
      int alpha = (sourceBitmap.getPixel(x, y) >> 24) & 255; 
      if(alpha > 0) // pixel is not 100% transparent 
      { 
       if(x < minX) 
        minX = x; 
       if(x > maxX) 
        maxX = x; 
       if(y < minY) 
        minY = y; 
       if(y > maxY) 
        maxY = y; 
      } 
     } 
    } 
    if((maxX < minX) || (maxY < minY)) 
     return null; // Bitmap is entirely transparent 

    // crop bitmap to non-transparent area and return: 
    return Bitmap.createBitmap(sourceBitmap, minX, minY, (maxX - minX) + 1, (maxY - minY) + 1); 
}