depth first search

#ifdef _OPENMP
#pragma omp for schedule(static, 1)
#endif /* _OPENMP */
for( i = first; (i < first + count) && next; i++ )

image = cv.cvCreateImage(size, cv.IPL_DEPTH_8U, 3)
image.imageData = data # set some data

def PIL2Ipl(input):
    """Converts a PIL image to the OpenCV/IPL CvMat data format.
 
    Supported input image formats are:
        RGB
        L
        F
    """
 
    if not isinstance(input, PIL.Image.Image):
       raise TypeError, 'must be called with PIL.Image.Image!'
 
    size = cv.cvSize(input.size[0], input.size[1])
 
    # mode dictionary:
    # (pil_mode : (ipl_depth, ipl_channels, color model, channel Seq)
    mode_list = {
        "RGB" : (cv.IPL_DEPTH_8U, 3),
        "L"   : (cv.IPL_DEPTH_8U, 1),
        "F"   : (cv.IPL_DEPTH_32F, 1)
        }
 
    if not mode_list.has_key(input.mode):
        raise ValueError, 'unknown or unsupported input mode'
 
    modes = mode_list[input.mode]    
 
    result = cv.cvCreateImage(
        size,
        modes[0], # depth
        modes[1]  # channels
        )
 
    # set imageData
    result.imageData=input.tostring() #FAIL!
 
    return result

%module iplimage
%{
#include "cv.h"
void set(CvMat *self, char *string);
%}
 
void set(CvMat *self, char *string);

#include "cv.h"
 
void set(CvMat * self, char *string)
{
	int depth = CV_MAT_DEPTH(self->type);
	int cn = CV_MAT_CN(self->type);
	int step = self->step ? self->step : CV_ELEM_SIZE(self->type) * self->cols;
	long line;
	long pixel;
 
	if (depth == CV_8U && cn==3){
		// RGB case
		// The data is reordered beause OpenCV uses BGR instead of RGB
 
		for (line = 0; line < self->rows; ++line)
			for (pixel = 0; pixel < self->cols; ++pixel)
			{
				// In OpenCV the beginning of the lines are aligned
				// to 4 Bytes. So use step instead of cols.
				long position = line*step + pixel*3;
				long sourcepos = line*self->cols*3 + pixel*3;
				self->data.ptr[position  ] = string[sourcepos+2];
				self->data.ptr[position+1] = string[sourcepos+1];
				self->data.ptr[position+2] = string[sourcepos  ];
			}
	}
	else if (depth == CV_8U && cn==1)
	{
		// Grayscale 8bit case
 
		for (line = 0; line < self->rows; ++line)
		{
			// In OpenCV the beginning of the lines are aligned
			// to 4 Bytes. So use step instead of cols.
			memcpy
				(
				 self->data.ptr + line*step,
				 string + line*self->cols,
				 step
				);
		}
	}
	else if ( depth == CV_32F )
	{
		// float (32bit) case
		for (line = 0; line < self->rows; ++line)
		{
			// here we don not have to care about alignment as the Floats are
			// as long as the alignment
			memcpy
				(
				 self->data.ptr + line*step,
				 string + line*self->cols*sizeof(float),
				 step
				);
		}
	}
	else if ( depth == CV_64F )
	{
		// double (64bit) case
		for (line = 0; line < self->rows; ++line)
		{
			// here we don not have to care about alignment as the Floats are
			// as long as the alignment
			memcpy
				(
				 self->data.ptr + line*step,
				 string + line*self->cols*sizeof(double),
				 step
				);
		}
	}
	else
	{
	}
}

CFLAGS= `pkg-config --cflags opencv`
LDFLAGS= `pkg-config --libs opencv` -L.
CXX=g++
 
_iplimage.so: iplimage.c
	swig -python iplimage.i
	$(CXX) $(CFLAGS) -I/usr/include/python2.5 -c iplimage.c iplimage_wrap.c
	$(CXX) $(LDFLAGS) -shared iplimage.o iplimage_wrap.o -o _iplimage.so

%module blobs
 
%exception
    {
    try { $action } 
    catch (...) 
        {
        return NULL;
        } 
    }
 
 
%include "exception.i"
 
%typemap(in) IplImage * (IplImage header){
	void * vptr;
	int res = SWIG_ConvertPtr($input, (&vptr), $descriptor( CvMat * ), 0);
	if ( res == -1 ){
		SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
		SWIG_fail;
	}
	$1 = cvGetImage((CvMat *)vptr, &header);
}
 
%typemap(in) IplImage *mask{
	if ($input == Py_None){
	   $1 = NULL;
	}
	else {
		SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage *mask : masks not supported yet.");
		SWIG_fail;
	}
}
 
%typecheck(SWIG_TYPECHECK_POINTER) IplImage * {
  void *ptr;
  if (SWIG_ConvertPtr($input, (void **) &ptr, $descriptor( CvMat * ), 0) == -1) {
    $1 = 0;
    PyErr_Clear();
  } else {
    $1 = 1;
  }
}
 
%{
#include "BlobResult.h"
#include "Blob.h"
%}
%include "BlobResult.h"
%include "Blob.h"