From ba994f4404b6eadcab4e0ead46ef4d3ffeceb024 Mon Sep 17 00:00:00 2001
From: Antoine Villeret <avilleret@users.sourceforge.net>
Date: Thu, 10 Jul 2014 14:39:22 +0000
Subject: lots of changes ! 1. switch to a new build system based on automake
 (because we need to check for some lib on ./configure before make) 2. sort
 files in different directory 3. add some new features (some of them need
 OpenCV >= 2.4.5)

svn path=/trunk/externals/pix_opencv/; revision=17324
---
 src/pix_opencv_floodfill.cc | 442 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 442 insertions(+)
 create mode 100644 src/pix_opencv_floodfill.cc

(limited to 'src/pix_opencv_floodfill.cc')

diff --git a/src/pix_opencv_floodfill.cc b/src/pix_opencv_floodfill.cc
new file mode 100644
index 0000000..f41d3c0
--- /dev/null
+++ b/src/pix_opencv_floodfill.cc
@@ -0,0 +1,442 @@
+
+//
+// GEM - Graphics Environment for Multimedia
+//
+// zmoelnig@iem.kug.ac.at
+//
+// Implementation file
+//
+//    Copyright (c) 1997-2000 Mark Danks.
+//    Copyright (c) Günther Geiger.
+//    Copyright (c) 2001-2002 IOhannes m zmoelnig. forum::für::umläute. IEM
+//    Copyright (c) 2002 James Tittle & Chris Clepper
+//    For information on usage and redistribution, and for a DISCLAIMER OF ALL
+//    WARRANTIES, see the file, "GEM.LICENSE.TERMS" in this distribution.
+//
+/////////////////////////////////////////////////////////
+
+#include "pix_opencv_floodfill.h"
+#include <stdio.h>
+
+CPPEXTERN_NEW(pix_opencv_floodfill)
+
+/////////////////////////////////////////////////////////
+//
+// pix_opencv_floodfill
+//
+/////////////////////////////////////////////////////////
+// Constructor
+//
+/////////////////////////////////////////////////////////
+
+pix_opencv_floodfill :: pix_opencv_floodfill()
+{ 
+  int i;
+
+  comp_xsize=320;
+  comp_ysize=240;
+
+  inlet_new(this->x_obj, &this->x_obj->ob_pd, gensym("float"), gensym("lo_diff"));
+  inlet_new(this->x_obj, &this->x_obj->ob_pd, gensym("float"), gensym("up_diff"));
+  m_dataout = outlet_new(this->x_obj, &s_anything);
+
+  x_lo = 20;
+  x_up = 20;
+  x_connectivity = 4;
+  x_color = 1;
+
+  for ( i=0; i<MAX_COMPONENTS; i++)
+  {
+       x_xcomp[i] = -1;
+       x_ycomp[i] = -1;
+       x_r[i] = rand() & 255;
+       x_g[i] = rand() & 255;
+       x_b[i] = rand() & 255;
+  }
+
+  rgba = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 4 );
+  rgb = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 3 );
+  grey = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 1 );
+
+}
+
+/////////////////////////////////////////////////////////
+// Destructor
+//
+/////////////////////////////////////////////////////////
+pix_opencv_floodfill :: ~pix_opencv_floodfill()
+{
+  // Destroy cv_images
+  cvReleaseImage( &rgba );
+  cvReleaseImage( &rgb );
+  cvReleaseImage( &grey );
+}
+
+/////////////////////////////////////////////////////////
+// processImage
+//
+/////////////////////////////////////////////////////////
+void pix_opencv_floodfill :: processRGBAImage(imageStruct &image)
+{
+  int i, k;
+  int im;
+  int marked;
+  CvConnectedComp comp;
+  int flags = x_connectivity + ( 255 << 8 ) + CV_FLOODFILL_FIXED_RANGE;
+
+  if ((this->comp_xsize!=image.xsize)&&(this->comp_ysize!=image.ysize)) 
+  {
+
+    this->comp_xsize=image.xsize;
+    this->comp_ysize=image.ysize;
+
+    cvReleaseImage( &rgba );
+    cvReleaseImage( &rgb );
+    cvReleaseImage( &grey );
+
+    rgba = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 4 );
+    rgb = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 3 );
+    grey = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 1 );
+  }
+
+  memcpy( rgba->imageData, image.data, image.xsize*image.ysize*4 );
+  cvCvtColor(rgba, grey, CV_BGRA2GRAY);
+  cvCvtColor(rgba, rgb, CV_BGRA2BGR);
+
+  // mark recognized components
+  for ( i=0; i<MAX_COMPONENTS; i++ )
+  {
+     if ( x_xcomp[i] != -1 )
+     {
+       if ( x_color )
+       {
+          CvPoint seed = cvPoint(x_xcomp[i],x_ycomp[i]);
+          CvScalar color = CV_RGB( x_r[i], x_g[i], x_b[i] );
+          cvFloodFill( rgb, seed, color, CV_RGB( x_lo, x_lo, x_lo ),
+                       CV_RGB( x_up, x_up, x_up ), &comp, flags, NULL );
+       }
+       else
+       {
+          CvPoint seed = cvPoint(x_xcomp[i],x_ycomp[i]);
+          CvScalar brightness = cvRealScalar((x_r[i]*2 + x_g[i]*7 + x_b[i] + 5)/10);
+          cvFloodFill( grey, seed, brightness, cvRealScalar(x_lo),
+                       cvRealScalar(x_up), &comp, flags, NULL );
+       }
+       SETFLOAT(&x_list[0], i);
+       SETFLOAT(&x_list[1], comp.rect.x);
+       SETFLOAT(&x_list[2], comp.rect.y);
+       SETFLOAT(&x_list[3], comp.rect.width);
+       SETFLOAT(&x_list[4], comp.rect.height);
+       outlet_list( m_dataout, 0, 5, x_list );
+     }
+  }
+
+  if ( !x_color )
+  {
+    cvCvtColor(grey, rgba, CV_GRAY2BGRA);
+  }
+  else
+  {
+    cvCvtColor(rgb, rgba, CV_BGR2BGRA);
+  }
+
+  memcpy( image.data, rgba->imageData, image.xsize*image.ysize*4 );
+}
+
+void pix_opencv_floodfill :: processRGBImage(imageStruct &image)
+{ 
+  int i, k;
+  int im;
+  int marked;
+  CvConnectedComp comp;
+  int flags = x_connectivity + ( 255 << 8 ) + CV_FLOODFILL_FIXED_RANGE;
+
+  if ((this->comp_xsize!=image.xsize)&&(this->comp_ysize!=image.ysize)) 
+  {
+
+    this->comp_xsize=image.xsize;
+    this->comp_ysize=image.ysize;
+
+    cvReleaseImage( &rgba );
+    cvReleaseImage( &rgb );
+    cvReleaseImage( &grey );
+
+    rgba = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 4 );
+    rgb = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 3 );
+    grey = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 1 );
+  }
+
+  memcpy( rgb->imageData, image.data, image.xsize*image.ysize*3 );
+
+  if ( !x_color )
+  {
+    cvCvtColor(rgb, grey, CV_BGR2GRAY);
+  }
+
+  // mark recognized components
+  for ( i=0; i<MAX_COMPONENTS; i++ )
+  {
+     if ( x_xcomp[i] != -1 )
+     {
+       if ( x_color )
+       {
+          CvPoint seed = cvPoint(x_xcomp[i],x_ycomp[i]);
+          CvScalar color = CV_RGB( x_r[i], x_g[i], x_b[i] );
+          cvFloodFill( rgb, seed, color, CV_RGB( x_lo, x_lo, x_lo ),
+                       CV_RGB( x_up, x_up, x_up ), &comp, flags, NULL );
+       }
+       else
+       {
+          CvPoint seed = cvPoint(x_xcomp[i],x_ycomp[i]);
+          CvScalar brightness = cvRealScalar((x_r[i]*2 + x_g[i]*7 + x_b[i] + 5)/10);
+          cvFloodFill( grey, seed, brightness, cvRealScalar(x_lo),
+                       cvRealScalar(x_up), &comp, flags, NULL );
+       }
+       SETFLOAT(&x_list[0], i);
+       SETFLOAT(&x_list[1], comp.rect.x);
+       SETFLOAT(&x_list[2], comp.rect.y);
+       SETFLOAT(&x_list[3], comp.rect.width);
+       SETFLOAT(&x_list[4], comp.rect.height);
+       outlet_list( m_dataout, 0, 5, x_list );
+     }
+  }
+
+  if ( !x_color )
+  {
+    cvCvtColor(grey, rgb, CV_GRAY2BGR);
+  }
+
+  memcpy( image.data, rgb->imageData, image.xsize*image.ysize*3 );
+}
+
+void pix_opencv_floodfill :: processYUVImage(imageStruct &image)
+{
+  post( "pix_opencv_floodfill : yuv format not supported" );
+}
+    	
+void pix_opencv_floodfill :: processGrayImage(imageStruct &image)
+{ 
+  int i, k;
+  int im;
+  int marked;
+  CvConnectedComp comp;
+  int flags = x_connectivity + ( 255 << 8 ) + CV_FLOODFILL_FIXED_RANGE;
+
+  if ((this->comp_xsize!=image.xsize)&&(this->comp_ysize!=image.ysize)) 
+  {
+
+    this->comp_xsize=image.xsize;
+    this->comp_ysize=image.ysize;
+
+    cvReleaseImage( &rgba );
+    cvReleaseImage( &rgb );
+    cvReleaseImage( &grey );
+
+    rgba = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 4 );
+    rgb = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 3 );
+    grey = cvCreateImage( cvSize(comp_xsize, comp_ysize), 8, 1 );
+  }
+
+  memcpy( grey->imageData, image.data, image.xsize*image.ysize );
+
+  // mark recognized components
+  for ( i=0; i<MAX_COMPONENTS; i++ )
+  {
+     if ( x_xcomp[i] != -1 )
+     {
+       CvPoint seed = cvPoint(x_xcomp[i],x_ycomp[i]);
+       CvScalar brightness = cvRealScalar((x_r[i]*2 + x_g[i]*7 + x_b[i] + 5)/10);
+       cvFloodFill( grey, seed, brightness, cvRealScalar(x_lo),
+                       cvRealScalar(x_up), &comp, flags, NULL );
+       SETFLOAT(&x_list[0], i);
+       SETFLOAT(&x_list[1], comp.rect.x);
+       SETFLOAT(&x_list[2], comp.rect.y);
+       SETFLOAT(&x_list[3], comp.rect.width);
+       SETFLOAT(&x_list[4], comp.rect.height);
+       outlet_list( m_dataout, 0, 5, x_list );
+     }
+  }
+
+  memcpy( image.data, grey->imageData, image.xsize*image.ysize );
+}
+
+/////////////////////////////////////////////////////////
+// static member function
+//
+/////////////////////////////////////////////////////////
+
+void pix_opencv_floodfill :: obj_setupCallback(t_class *classPtr)
+{
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::colorMessCallback,
+		  gensym("color"), A_FLOAT, A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::fillcolorMessCallback,
+		  gensym("fillcolor"), A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::connectivityMessCallback,
+		  gensym("connectivity"), A_FLOAT, A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::markMessCallback,
+		  gensym("mark"), A_FLOAT, A_FLOAT, A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::deleteMessCallback,
+		  gensym("delete"), A_FLOAT, A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::clearMessCallback,
+		  gensym("clear"), A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::updiffMessCallback,
+		  gensym("up_diff"), A_FLOAT, A_NULL);
+  class_addmethod(classPtr, (t_method)&pix_opencv_floodfill::lodiffMessCallback,
+		  gensym("lo_diff"), A_FLOAT, A_NULL);
+}
+
+void  pix_opencv_floodfill :: colorMessCallback(void *data, t_floatarg color)
+{
+    GetMyClass(data)->colorMess((float)color);
+}
+
+void  pix_opencv_floodfill :: fillcolorMessCallback(void *data, t_floatarg index, t_floatarg r, t_floatarg g, t_floatarg b)
+{
+    GetMyClass(data)->fillcolorMess(index, r, g, b);
+}
+
+void  pix_opencv_floodfill :: connectivityMessCallback(void *data, t_floatarg connectivity)
+{
+    GetMyClass(data)->connectivityMess(connectivity);
+}
+
+void  pix_opencv_floodfill :: markMessCallback(void *data, t_floatarg px, t_floatarg py)
+{
+    GetMyClass(data)->markMess(px, py);
+}
+
+void  pix_opencv_floodfill :: deleteMessCallback(void *data, t_floatarg index)
+{
+    GetMyClass(data)->deleteMess((float)index);
+}
+
+void  pix_opencv_floodfill :: clearMessCallback(void *data)
+{
+    GetMyClass(data)->clearMess();
+}
+
+void  pix_opencv_floodfill :: updiffMessCallback(void *data, t_floatarg updiff)
+{
+    GetMyClass(data)->updiffMess((float)updiff);
+}
+
+void  pix_opencv_floodfill :: lodiffMessCallback(void *data, t_floatarg lodiff)
+{
+    GetMyClass(data)->lodiffMess((float)lodiff);
+}
+
+void  pix_opencv_floodfill :: colorMess(float color)
+{
+    if ( ( (int)color == 0 ) || ( (int)color == 1 ) )
+    {
+       x_color = (int)color;
+    }
+}
+
+void  pix_opencv_floodfill :: fillcolorMess(float index, float r, float g, float b)
+{
+    if ( ( (int)index <= 0 ) || ( (int)index > MAX_COMPONENTS ) )
+    {
+       post( "pix_opencv_floodfill : wrong color index : %d", (int)index );
+       return;
+    }
+
+    if ( ( (int)r >= 0 ) || ( (int)r <= 255 ) )
+    {
+       x_r[(int)index-1] = (int)r;
+    }
+
+    if ( ( (int)g >= 0 ) || ( (int)g <= 255 ) )
+    {
+       x_g[(int)index-1] = (int)g;
+    }
+
+    if ( ( (int)b >= 0 ) || ( (int)b <= 255 ) )
+    {
+       x_b[(int)index-1] = (int)b;
+    }
+}
+
+void  pix_opencv_floodfill :: connectivityMess(float connectivity)
+{
+    if ( ( connectivity != 4.0 ) && ( connectivity != 8.0 ) )
+    {
+       return;
+    }
+
+    x_connectivity = (int)connectivity;
+}
+
+void  pix_opencv_floodfill :: markMess(float fpx, float fpy)
+{
+  int i;
+  int inserted;
+  int px, py;
+
+    if ( ( fpx < 0.0 ) || ( fpx > comp_xsize ) || ( fpy < 0.0 ) || ( fpy > comp_ysize ) )
+    {
+      return;
+    }
+
+    px = (int)fpx;
+    //py = comp_ysize-(int)fpy;
+    py = (int)fpy;
+    inserted = 0;
+    for ( i=0; i<MAX_COMPONENTS; i++)
+    {
+       if ( x_xcomp[i] == -1 )
+       {
+         x_xcomp[i] = px;
+         x_ycomp[i] = py;
+         // post( "pix_opencv_floodfill : inserted point (%d,%d)", px, py );
+         inserted = 1;
+         break;
+       }
+    }
+    if ( !inserted )
+    {
+       post( "pix_opencv_floodfill : max markers reached" );
+    }
+}
+
+void  pix_opencv_floodfill :: deleteMess(float index)
+{
+  int i;
+
+    if ( ( index < 1.0 ) || ( index > MAX_COMPONENTS ) )
+    {
+       return;
+    }
+
+    x_xcomp[(int)index-1] = -1;
+    x_ycomp[(int)index-1] = -1;
+
+}
+
+void  pix_opencv_floodfill :: clearMess(void)
+{
+  int i;
+
+    for ( i=0; i<MAX_COMPONENTS; i++)
+    {
+      x_xcomp[i] = -1;
+      x_ycomp[i] = -1;
+    }
+
+}
+
+void  pix_opencv_floodfill :: updiffMess(float updiff)
+{
+  if ( ( (int)updiff >= 0 ) && ( (int)updiff <= 255 ) )
+  {
+     x_up = (int)updiff;
+  }
+}
+
+void  pix_opencv_floodfill :: lodiffMess(float lodiff)
+{
+  if ( ( (int)lodiff >= 0 ) && ( (int)lodiff <= 255 ) )
+  {
+     x_lo = (int)lodiff;
+  }
+}
-- 
cgit v1.2.1