位图转换：创建从透明位图排除透明边的位图

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; 
    } 

有谁知道如何实现这一目标？

编辑：

我得到它的工作使用下面的算法来寻找左，右，上，下值：

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. 复制，请你

现在的问题仍然是图像就是你考虑一个透明像素。阿尔法透明度计数？如果是这样的话，直到你决定它透明到足以从图像中删除多少阿尔法？

Answer 2

我认为这是一个比较有效的，它对于我来说

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

的伟大工程，要找到自己的位图的非透明区域，跨在x和y的位图进行迭代，并找到最小值和最大值的不透明区域。然后裁剪位图到这些坐标。

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); 
}