I have a Bitmap Image loaded to a 2D Array. Now I want to detect the outer edge pixels of the bitmap for efficient pixel-exact-collison-detection. The red pixel represent the edge which should be detected.
Is there a simple algorithm to achieve this result?




Thanks in advance, pryndl!

I have an simple array. Now I want to pass this array over to a two dimensional array.

1. char pic[] = {
2. 11,7,
3. 0xC0,0x00,
4. 0x67,0x00,
5. 0x26,0x80,
6. 0x5F,0x60,
7. 0x26,0x80,
8. 0x67,0x00,
9. 0xC0,0x00};
10. char[][] images;
11. images = new char[1][pic.length];
12. for(int i = 0; i < pic.length; i++){
13.     images[0][i]=pic[i];
14. }

Is there a way to do this without a loop? Or with pointers, so I don't need extra space?

I've written a code to display a array of pixels.
I'm quite new to programming and would like to learn how to code more efficient.
So my questions is, if there is a much faster way to do this, cause i'm about to programm a little game upon this function.

1. final int QUANT = 4;  // size of 'game pixels'
2. void setup(){
3.   size(200,200);
4.   background(255);
5.  
6.   // defines the bitmap image that should be displayed
7.   byte[][] bild =
8.   {{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
9.    {0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0},
10.    {0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0},
11.    {0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1},
12.    {0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0},
13.    {0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0},
14.    {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
15.  
16.   // calls the function to display the image at x=1,y=3
17.   draw_img(1,3,bild);
18. }
19. void draw_img(int _x,int _y, byte[][] img){
20.  
21.   // following loops go through every pixel of the image
22.   for(int y = 0; y < img.length; y++){
23.     for(int x = 0; x < img[y].length; x++){
24.      
25.      // checks if current pixel is black (1)
26.      if(img[y][x]==1){
27.      
28.       // draws pixels in size of QUANT
29.       for(int i = 0; i < QUANT; i++){
30.        for(int j = 0; j < QUANT; j++){
31.         set(x*QUANT+j+_x*QUANT, y*QUANT+i+_y*QUANT, color(0));
32.        }
33.       }
34.      }
35.     }
36.   }
37. }

The result looks like this:















Thank you!