draw_blobs.c

it runs for blob detection with opencv

/*
**  Source file for blobdetect. (c) 2004 Per-Erik Forssen
**
**  This program is free software; you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation; either version 2 of the License, or
**  (at your option) any later version.
**  
**  See the file COPYING for details.
**
*/

#ifndef WIN32
#include <string.h>
#endif
#include "mex.h"
#include "image_buffer.h"
#include "extract_blobs.h"
#include "visualise.h"

/*
** Function to check wether an argument is
** a double 2d matrix of given size
** -1 as size means any size
*/
int has_size(const mxArray *arg,int mdims,int *msize)
{
const int *dims;
int k,retval;
  dims = mxGetDimensions(arg);
  retval=1;
  if(mxGetClassID(arg) != mxDOUBLE_CLASS) retval=0;
  if(mxGetNumberOfDimensions(arg) != mdims) retval=0;
  for(k=0;k<mdims;k++) {
    if((msize[k] != -1) && (dims[k] != msize[k])) retval=0;
  }
  return retval;
}
/*
** Copy dimensions of a buffer struct
** to a list of integers.
*/
void copy_dims(int *out_dims,buffer *bf)
{
   out_dims[0]=bf->rows;
   out_dims[1]=bf->cols;
   out_dims[2]=bf->ndim;
}
/*
**  mexFunction is the interface function to MATLAB.
**
** plhs - pointer to left-hand OUTPUT mxArrays
** nlhs - number of left-hand OUTPUT arrays
** prhs - pointer to right-hand INPUT mxArrays
** nrhs - number of right-hand INPUT arrays
**
*/
void mexFunction(int nlhs, mxArray *plhs[],
		 int nrhs, const mxArray *prhs[])
{
fpnum bkgr_green[] = {0.0,1.0,0.0}; /* Background colour */
buffer *bf_mvec,*bf_pvec,*bf_pvecn,*bf_rimg,*bf_blobimg;
buffer *bf_bkgr;
ibuffer *bf_limg;
const int *arg_dims;
int arg_ndims,grxfl;
int out_dims[]={0,0,0};

/* Argument count check */
 if((nrhs <3)||(nrhs>4)) {
   if(nrhs !=0) mexPrintf("Error: 3-4 input arguments expected.\n");
   goto mexErrExit;
 }
    
/* Parse arg 1 (label image) */
 arg_dims = mxGetDimensions(prhs[0]);
 arg_ndims = mxGetNumberOfDimensions(prhs[0]);
 if(mxGetClassID(prhs[0]) != mxUINT32_CLASS) {
   mexPrintf("Type mismatch: <Limg> should be of class uint32.\n");
   goto mexErrExit;
 }
 if(arg_ndims !=2) {
   mexPrintf("Type mismatch: <Limg> should be 2D.\n");
   goto mexErrExit;
 }
 bf_limg=ibuffer_new0((int *)mxGetPr(prhs[0]),arg_dims[0],
		      arg_dims[1],arg_dims[2]);
 /* Copy image size */
 out_dims[0]=arg_dims[0];
 out_dims[1]=arg_dims[1];

/* Parse arg 2 (mvec) */
 arg_dims = mxGetDimensions(prhs[1]);
 arg_ndims = mxGetNumberOfDimensions(prhs[1]);
 if(mxGetClassID(prhs[1]) != mxDOUBLE_CLASS) {
   mexPrintf("Type mismatch: <mvec> should be of class double.\n");
   goto mexErrExit;
 }
 if(arg_ndims !=2) {
   mexPrintf("Type mismatch: <mvec> should be 2D.\n");
   goto mexErrExit;
 }
 bf_mvec=buffer_new0((double *)mxGetPr(prhs[1]),arg_dims[0],
		     arg_dims[1],1);

/* Parse arg 3 (pvec) */
 arg_dims = mxGetDimensions(prhs[2]);
 arg_ndims = mxGetNumberOfDimensions(prhs[2]);
 if(mxGetClassID(prhs[2]) != mxDOUBLE_CLASS) {
   mexPrintf("Type mismatch: <pvec> should be of class double.\n");
   goto mexErrExit;
 }
 if(arg_ndims !=2) {
   mexPrintf("Type mismatch: <pvec> should be 2D.\n");
   goto mexErrExit;
 }
 bf_pvec=buffer_new0((double *)mxGetPr(prhs[2]),arg_dims[0],
		     arg_dims[1],1);

#if DEBUG
 printf("PVEC ");
 buffer_pdims(bf_pvec);
#endif
 /* Copy number of colour bands */
 out_dims[2]=arg_dims[0];

 /* Parse arg 4 (bkgr) */
 if(nrhs==4) {
   arg_dims = mxGetDimensions(prhs[3]);
   arg_ndims = mxGetNumberOfDimensions(prhs[3]);
   if(arg_ndims != 2) {
     mexPrintf("Type mismatch: <bkgr> should be 2D.\n");
     goto mexErrExit;     
   }
   bf_bkgr=buffer_new0((double *)mxGetPr(prhs[3]),arg_dims[0],
		       arg_dims[1],1);
 } else {
   bf_bkgr=buffer_new0(bkgr_green,3,1,1);  /* Use default */
 }

 /* Extend grey to RGB? */
 grxfl=0;
 if(out_dims[2]==1) {
   grxfl=1;
   pvec_to_rgb(bf_pvec,&bf_pvecn);
   out_dims[2]=3;
 }
/* Call visualisation functions */
 if(nlhs>0) {
   /* Create an empty green image */
   plhs[0] = mxCreateNumericArray(3,out_dims,mxDOUBLE_CLASS,mxREAL);
   bf_blobimg = buffer_new0(mxGetPr(plhs[0]),out_dims[0],out_dims[1],
			    out_dims[2]);
   buffer_paint(bf_blobimg,bf_bkgr);

   /* Visualise blobs in the green image */
   if(grxfl)
     draw_ellipses(bf_blobimg,bf_mvec,bf_pvecn);
   else
     draw_ellipses(bf_blobimg,bf_mvec,bf_pvec);
   free(bf_blobimg);
 }
 if(nlhs>1) {
   /* Create an empty green image */
   plhs[1] = mxCreateNumericArray(3,out_dims,mxDOUBLE_CLASS,mxREAL);
   bf_rimg = buffer_new0(mxGetPr(plhs[1]),out_dims[0],out_dims[1],
			 out_dims[2]);
   buffer_paint(bf_rimg,bf_bkgr);
   
   /* Visualise blobs in the green image */
   if(grxfl)
     draw_regions(bf_rimg,bf_limg,bf_pvecn);
   else
     draw_regions(bf_rimg,bf_limg,bf_pvec);
   free(bf_rimg);
 }

/* Free memory */
 free(bf_limg);  /* Only release struct */
 free(bf_mvec);  /* Only release struct */
 free(bf_pvec);  /* Only release struct */
 if(grxfl) buffer_free(bf_pvecn);
     
/* Jump to normal exit */
 goto mexExit;

/* Exit with error message */
mexErrExit:
 mexPrintf("Usage: [<Bimg>,[,<Simg>]]=draw_blobs(<Limg>,<mvec>,<pvec>[,<bkgr>])\n");
mexExit: {}
}