Konwersja bitmap: Tworzenie mapy bitowej, która wyklucza przezroczyste boki z przezroczystej bitmapy

Question

Mam zestaw bitmap. Wszystkie są do pewnego stopnia przezroczyste i nie wiem z góry, które części są przezroczyste. Chciałbym utworzyć nową bitmapę z oryginalnej bitmapy, która wyklucza przezroczyste części, ale w kwadracie. Myślę, że ten obraz wyjaśnia:

wiem jak stworzyć bitmapę wyjścia z istniejącej mapy bitowej, ale nie wiem, w jaki sposób dowiedzieć się, która część jest przezroczysta i jak używać, aby osiągnąć mój cel.

To jak mam zamiar to zrobić:

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

Czy ktoś wie, jak to osiągnąć?

EDIT:

mam pracować za pomocą następującego algorytmu znaleźć lewy, prawy, górny i wartości dolne:

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

Jeśli wszystkie zdjęcia, które chcesz przyciąć są bardziej lub mniej w środku oryginalnego płótna, domyślam się, że możesz coś takiego:

1. Zacznij od każdej granicy, idąc do wewnątrz, szukając obrazu nieprzezroczyste piksele
2. Po znalezieniu lewego górnego i prawego dolnego rogu, otrzymasz pożądany cel.
3. skopiować obraz jak należy

Teraz pozostaje pytanie, co uważasz za przezroczystą piksel. Czy liczy się alfa trasparency? jeśli tak, to ile alfa, dopóki nie zdecydujesz, że jest wystarczająco przezroczyste, aby je wyciąć z obrazu?

Answer 2

myślę, że to jest nieco bardziej wydajny i działa świetnie dla mnie

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

Aby znaleźć nieprzezroczystą powierzchnię swojej bitmapy iteracyjne poprzek bitmapy w x i y i znaleźć min i max nieprzejrzystego regionu. Następnie przycinaj bitmapę do tych współrzędnych.

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