Legacy ImageMagick Discussions Archive

Code: Select all

convert netscape: -unique-colors txt:-

Code: Select all

   segment_image   segment.png   segment.gif

Code: Select all

#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
// Windows Header Files:
#include <windows.h>
#include <tchar.h>

#include <wand/MagickWand.h>

// It appears that, for a queue, the worst case memory requirement is 2*height bytes
// whereas for a stack it is on the order of width*height/3 bytes

// To prepare a photo you can usually just change its number of colours to 2
// which reduces the image to black and white. Then use a white paint brush
// to paint over the black areas (such as buildings) which aren't birds. 
// Then save the file as GIF or PNG - but NOT jpg or other lossy compression.

#define MARKED 127
struct queue {
   int y;
   int x;
};
struct queue *queue,*top, *bottom;

int this_count,this_x,this_y,last_count,last_x,last_y;

// This allocates 3*height bytes for the queue and allows the amount
// to be changed easily
#define QUEUE_WIDTH 3
// A macro to add a pixel to the queue if it is within the bounds of the
// image and is black, in which case the pixel is MARKED so that its neighbours
// can't add it again
#define addq(yy,xx) \
	this_count++;\
   if((yy) >= 0 && (yy) < height && (xx) >= 0 && (xx) < width) {\
      if(*(mi + (yy)*width + (xx)) == 0) {\
         top->y = (yy);\
         top++->x = (xx);\
         *(mi + (yy)*width + (xx)) = MARKED;\
         if(top >= queue + ((QUEUE_WIDTH)*height)) {\
            top = queue;\
         }\
         if(top == bottom) {\
            MessageBox(NULL,"Queue Overflow","",MB_OK);\
            return -1;\
         }\
      }\
   }

// Returns -1 on error or a count of the birds (black blobs) in the image.
// If black_count is not NULL, the number of black pixels in the image is returned
// It also finds the largest blob and leaves it size and the x,y coordinate of
// one of its pixels in global variables
int MagickBirdCount(MagickWand *m_wand,int *black_count)
{
   register unsigned char *p;
   register int i,j;
   int height,width,birdcount;
   int x,y;
   int bcount;
   unsigned char *mi = NULL;

   if(m_wand == NULL)return -1;
   height = MagickGetImageHeight(m_wand);
   width = MagickGetImageWidth(m_wand);
   if(height*width < 1)return -1;

   if(MagickGetImageDepth(m_wand) != 8) {
      MessageBox(NULL,"Image depth is not eight bits","",MB_OK);
      return -1;
   }
   // Allocate space for the queue
   queue = (struct queue *)AcquireMagickMemory(height*(QUEUE_WIDTH)*sizeof(struct queue));
   if(queue == NULL) {
      MessageBox(NULL,"AcquireMagickMemory failed to allocate the queue","",MB_OK);
      return -1;
   }

   // Allocate space for the image
   mi = AcquireMagickMemory(height*width);
   if(mi == NULL) {
      MessageBox(NULL,"AcquireMagickMemory failed to allocate image memory","",MB_OK);
      RelinquishMagickMemory(queue);
      return -1;
   }
   // and read it into the new array
   if(!MagickGetImagePixels(m_wand,0,0,width,height,"R",CharPixel,mi)) {
      MessageBox(NULL,"MagickGetImagePixels failed","",MB_OK);
      RelinquishMagickMemory(queue);
      RelinquishMagickMemory(mi);
      return -1;
   }

   // The process is to scan the image until a black pixel is found, add
   // it to the queue and count it as a bird.
   // Then take a pixel off the queue and add back to the queue any of its neighbouring
   // pixels which are black. Repeat this until the queue is empty.
   // Then scan for the next black pixel and repeat until all pixels have been examined
   p = mi;
   birdcount = bcount = 0;

   for(j=0;j<height;j++) {
      for(i=0;i<width;i++,p++) {
         if(*p != 255)bcount++;
         // Skip anything except black
         if(*p)continue;
         // Found a black pixel - count it as a bird
         birdcount++;
         this_count = 0;
         this_y = j;
         this_x = i;
         top = bottom = queue;
         // Add this pixel to the queue
         addq(j,i);
         // Now find and mark all neighbouring pixels which are also black
         while(top != bottom) {
            // Get the next element from the bottom of the queue
            y = bottom->y;
            x = bottom->x;
            bottom++;
            if(top == bottom)top = bottom = queue;
            else if(bottom >= queue + ((QUEUE_WIDTH)*height)) {
               bottom = queue;
            }
            // Now add all the neighbours of this element to the queue
            addq(y-1,x-1);
            addq(y-1,x);
            addq(y-1,x+1);
            addq(y,x-1);
            addq(y,x+1);
            addq(y+1,x-1);
            addq(y+1,x);
            addq(y+1,x+1);
         }
         if(this_count > last_count) {
            last_count = this_count;
            last_y = this_y;
            last_x = this_x;
         }
      }
   }
   if(black_count)*black_count = bcount;
   RelinquishMagickMemory(mi);
   RelinquishMagickMemory(queue);
   return birdcount;
}

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{

	MagickWand *m_wand = NULL;
	PixelWand *p_wand = NULL;
	extern int last_count,last_x,last_y;


	MagickWandGenesis();

	m_wand = NewMagickWand();

	if(!MagickReadImage(m_wand,"48879665cd8.png")) {
		MessageBox(NULL,"ReadImage failed","",MB_OK);
		m_wand = DestroyMagickWand(m_wand);
		MagickWandTerminus();
		return 0;
	}

	// This finds the largest blob
	if(MagickBirdCount(m_wand,NULL) == -1) {
		if(m_wand)m_wand = DestroyMagickWand(m_wand);
		if(p_wand)p_wand = DestroyPixelWand(p_wand);
		MagickWandTerminus();
		MessageBox(NULL,"MagickBirdCount failed to find any blobs","",MB_OK);
		return -1;
	}
	// and this flood fills the largest blob with red
	p_wand = NewPixelWand();
	PixelSetColor(p_wand,"red");
	MagickFloodfillPaintImage(m_wand,AllChannels,p_wand,0,NULL,last_x,last_y,MagickFalse);

	// Save the modified image
	MagickWriteImage(m_wand,"blob.gif");

	if(m_wand)m_wand = DestroyMagickWand(m_wand);
	if(p_wand)p_wand = DestroyPixelWand(p_wand);
	
	MagickWandTerminus();

	return 0;
}

Code: Select all

   segment_image  input.png  gif:- |\
       convert gif:- -layers CompareOverlay segments.gif

Code: Select all

  segment_image  input.png  segment_%02d.png

Code: Select all

  segment_image  input.png miff:- |\
    convert miff:- -bordercolor blue -border 0x0 segment_%02d.jpg

Code: Select all

   convert input.png -transparent white miff:- |\
      segment_image - segment_%02d.png