Legacy ImageMagick Discussions Archive

Code: Select all

#include <windows.h>
#include <wand/magick_wand.h>
#include <stdio.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*heigth/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 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;

// 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) \
	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
int MagickBirdCount(MagickWand *m_wand,int *black_count)
{
	register unsigned char *p;
	register int i,j;
	int height,width,birdcount;
	int x,y;
	int depth;
	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;

	depth = MagickGetImageDepth(m_wand);
	if(depth != 1) {
		MessageBox(NULL,"Image bit depth is more than one","",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++;
			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(black_count)*black_count = bcount;
	RelinquishMagickMemory(mi);
	RelinquishMagickMemory(queue);
	return birdcount;
}