camellia 2.5.10-i486-linux

data/inc/camellia_internals.h

@@ -0,0 +1,192 @@
+/** \file camellia_internals.h
+ *  \brief Camellia Image Processing Library header file
+ *  \author Bruno STEUX (ENSMP)
+ *    
+ *  Camellia Image Processing Library
+ *
+
+    The Camellia Image Processing Library is an open source low-level image processing library.
+    As it uses the IplImage structure to describe images, it is a good replacement to the IPL (Intel) library
+    and a good complement to the OpenCV library. It includes a lot of functions for image processing
+    (filtering, morphological mathematics, labeling, warping, loading/saving images, etc.),
+    some of them being highly optimized; It is also cross-platform and robust. It is doxygen-documented
+    and examples of use are provided.
+
+    This software library is an outcome of the Camellia european project (IST-2001-34410).
+    It was developped by the Ecole des Mines de Paris (ENSMP), in coordination with
+    the other partners of the project.
+
+  ==========================================================================
+
+    Copyright (c) 2002-2006, Ecole des Mines de Paris - Centre de Robotique
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer
+          in the documentation and/or other materials provided with the distribution.
+        * Neither the name of the Ecole des Mines de Paris nor the names of
+          its contributors may be used to endorse or promote products
+          derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  ==========================================================================
+
+*/
+
+#ifndef _CAMELLIA_INTERNALS_H_
+#define _CAMELLIA_INTERNALS_H_
+
+// Binary images management
+#ifdef CAM_64BITS
+#ifdef _WIN32
+#define CAM_BIT_BLOCK unsigned __int64
+#else
+#define CAM_BIT_BLOCK unsigned long long int
+#endif
+#define CAM_BIT_BLOCK_SIZE_SHIFT 6
+#ifndef CAM_BIG_ENDIAN
+#ifdef _WIN32
+#define CAM_BIT_BLOCK_SWAP(x) (	\
+    (((x)&0x00000000000000ffi64)<<56)| \
+    (((x)&0x000000000000ff00i64)<<40)| \
+    (((x)&0x0000000000ff0000i64)<<24)| \
+    (((x)&0x00000000ff000000i64)<< 8)| \
+    (((x)&0x000000ff00000000i64)>> 8)| \
+    (((x)&0x0000ff0000000000i64)>>24)| \
+    (((x)&0x00ff000000000000i64)>>40)| \
+    (((x)&0xff00000000000000i64)>>56))
+#else
+#define CAM_BIT_BLOCK_SWAP(x) (	\
+    (((x)&0x00000000000000ffull)<<56)| \
+    (((x)&0x000000000000ff00ull)<<40)| \
+    (((x)&0x0000000000ff0000ull)<<24)| \
+    (((x)&0x00000000ff000000ull)<< 8)| \
+    (((x)&0x000000ff00000000ull)>> 8)| \
+    (((x)&0x0000ff0000000000ull)>>24)| \
+    (((x)&0x00ff000000000000ull)>>40)| \
+    (((x)&0xff00000000000000ull)>>56))
+#endif //_WIN32
+#else
+#define CAM_BIT_BLOCK_SWAP(x) (x)
+#endif
+#else
+#define CAM_BIT_BLOCK unsigned int
+#define CAM_BIT_BLOCK_SIZE_SHIFT 5
+#ifndef CAM_BIG_ENDIAN
+#define CAM_BIT_BLOCK_SWAP(x) ((((x)&0x000000ff)<<24)|(((x)&0x0000ff00)<<8)|(((x)&0x00ff0000)>>8)|(((x)&0xff000000)>>24))
+#else
+#define CAM_BIT_BLOCK_SWAP(x) (x)
+#endif
+#endif
+#define CAM_BIT_BLOCK_SIZE (sizeof(CAM_BIT_BLOCK)*8)
+
+// Internal functions
+typedef struct {
+    unsigned char *srcptr;
+    unsigned char *dstptr;
+    CamROI srcroi;   // Source ROI after clipping
+    CamROI dstroi;   // Dest ROI after clipping
+    int srcchoffset; // Channel offset for the source
+    int dstchoffset; // Channel offset for the destination image
+    int nChannels;   // Number of effective channels (considering ROIs)
+    int srcinc;      // Pixel to pixel increment
+    int dstinc;      // Pixel to pixel increment
+    int srclinc;     // Line to line increment
+    int dstlinc;     // Line to line increment
+    int srcpinc;     // Plane to plane increment
+    int dstpinc;     // Plane to plane increment
+
+    int mask_xOffset;// Offset when mask doesn't fit within image boundaries
+    int mask_yOffset;// Offset when mask doesn't fit within image boundaries
+    CamRLEImage *mask; // Mask to be applied to the operation
+    CamRLEImage auto_mask; // Automatically allocated if provided mask is not RLE
+} CamInternalROIPolicyStruct;
+
+#define CAM_MASK_SUPPORT 1
+#define CAM_IGNORE_COI_MISMATCH 2
+#define CAM_NO_ROI_INTERSECTION 4
+
+int camInternalROIPolicy(CamImage* src, CamImage *dst, CamInternalROIPolicyStruct *res, int options);
+void camInternalROIPolicyExit(CamInternalROIPolicyStruct *res); // Call to this function is necessary only when the caller manages image bit-masking
+
+const char *camGetErrorStr();
+void camSetErrorStr(const char *s);
+
+// Check arguments
+#ifndef CAM_OPTIMIZE
+#define CAM_CHECK_ARGS(function, condition) \
+if (!(condition)) {camError(#function, "Bad argument : " #condition);return 0;}
+#else
+#define CAM_CHECK_ARGS(function, condition)
+#endif
+
+#ifndef CAM_OPTIMIZE
+#define CAM_CHECK_ARGS2(function, condition, text) \
+if (!(condition)) {camError(#function, "Bad argument : " #text);return 0;}
+#else
+#define CAM_CHECK_ARGS2(function, condition, text)
+#endif
+
+#ifndef CAM_OPTIMIZE
+#define CAM_CHECK(function, condition) \
+if (!(condition)) {camError(#function, NULL);return 0;}
+#else
+#define CAM_CHECK(function, condition)
+#endif
+
+// Mask management macros
+
+#define INIT_MASK_MANAGEMENT \
+    if (iROI.mask) { \
+        run=iROI.mask->runs+1; \
+        while (run->line!=iROI.mask_yOffset) run++; \
+    } else { \
+        run=NULL; \
+    }
+
+#define BEGIN_MASK_MANAGEMENT(code) \
+    startx=-iROI.mask_xOffset; \
+do { \
+    if (!iROI.mask) { \
+        endx=width; \
+    } else { \
+        do { \
+            while ((run->value==0)&&(run->line==y+iROI.mask_yOffset)) { \
+                startx+=run->length; \
+                run++; \
+            } \
+            if (run->line!=y+iROI.mask_yOffset) break; \
+            endx=startx+run->length; \
+        } while ((endx<=0)&&(run++)); \
+        if (run->line!=y+iROI.mask_yOffset) break; \
+        if (startx<0) startx=0; \
+        if (startx>width) startx=width; \
+        if (endx>width) endx=width; \
+        code \
+    }
+
+#define END_MASK_MANAGEMENT \
+    if (iROI.mask) { \
+        startx=endx; \
+        run++; \
+    } \
+} while ((run)&&(run->line==y+iROI.mask_yOffset));
+
+#endif
+

data/lib/camellia-fox.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require_gem 'fxruby'
+
+require 'camellia'
+include Camellia
+
+class Fox::FXImage
+  def to_camellia
+    s=FXStream.new
+    mem=" "*(width*height*4)
+    s.open(FXStreamSave, width*height*4, mem)
+    unbound_savePixels=FXImage.instance_method(:savePixels)
+    bound_savePixels=unbound_savePixels.bind(self)
+    bound_savePixels.call(s)
+    image=CamImage.new(width, height, CAM_DEPTH_8U, CAM_COLORMODEL_RGBA)
+    image.set_pixels(mem)
+    return image
+  end
+end
+
+class Camellia::CamImage
+  def to_fox(app, picture=nil)
+    if picture==nil
+      pict=FXImage.new(app, nil, IMAGE_OWNED|IMAGE_KEEP, width, height)
+    else
+      pict=picture
+    end if
+    image=CamImage.new(width, height, CAM_DEPTH_8U, CAM_COLORMODEL_RGBA)
+    copy(image)
+    FXStream.new { |stream|
+      stream.open(FXStreamLoad, image.imageSize, image.to_s)
+      unbound_loadPixels=FXImage.instance_method(:loadPixels)
+      bound_loadPixels=unbound_loadPixels.bind(pict)
+      bound_loadPixels.call(stream)
+    }
+    return pict
+  end
+end
+

data/test/test_arithm.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestArithm < Test::Unit::TestCase
+  def test_arithm
+    source=CamImage.new
+    # load picture chess.pgm
+    source.load_pgm("resources/chess.pgm")
+    n=source.arithm(source,source,CAM_SUB)
+    # resulting pixel sum should be 0
+    assert_equal(n,0)
+  end
+end

data/test/test_color_labeling.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestLabeling < Test::Unit::TestCase
+  def test_labeling
+
+    # load picture alfa156.bmp
+    image=CamImage.new
+    image.load_bmp("resources/alfa156.bmp")
+    yuv=image.to_yuv
+    
+    # set color clusters
+    clusters=CamTable.new
+    clusters.set([
+      # Ymin Ymax Umin Umax Vmin Vmax
+        0,   60,  0,   255, 0,   255, # Black
+        230, 255, 0,   255, 0,   255, # White
+        0,   255, 0,   255, 140, 255  # Red
+    ])
+    cluster_colors=[cam_rgb(0,0,0),cam_rgb(255,255,255),cam_rgb(255,0,0)]
+    
+    # threshold and encode
+    encoded=yuv.encode_color(clusters)
+    puts "Number of runs : #{encoded.nb_runs}"
+    
+    # labeling
+    blobs=encoded.labeling!    
+    puts "#{blobs.nb_blobs} blobs detected"
+    
+    # print and deaw the results 
+    i=0
+    blobs.each {|b|
+      puts "Blob #{i} : Val=#{b.value} (#{b.top},#{b.left},#{b.width},#{b.height}) Surface=#{b.surface}"
+      image.draw_rectangle(b.left,b.top,b.left+b.width-1,b.top+b.height-1,cluster_colors[b.value-1])
+      i=i+1
+    }
+    
+    # save the result
+    image.save_bmp("output/ruby_alfa156_labeling.bmp")
+    
+    # assertions
+    assert_equal(encoded.nb_runs,3026)
+    assert_equal(blobs.nb_blobs,190)
+  end
+end

data/test/test_copy.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestCopy < Test::Unit::TestCase
+  def test_copy
+    source=CamImage.new
+    # load picture alfa156.bmp
+    source.load_bmp("resources/alfa156.bmp")
+    dest=CamImage.new(source.width,source.height,CAM_DEPTH_8U,CAM_COLORMODEL_RGBA)
+    source.copy(dest)
+    dest.save_bmp("output/copy_alfa156.bmp")
+  end
+end

data/test/test_draw.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+
+class TestDraw < Test::Unit::TestCase
+  def test_draw
+    image=CamImage.new(320,240,CAM_DEPTH_8U,CAM_COLORMODEL_RGB)
+    font=CamBitmapFont.new('resources/fonts/xenon2.bmp')
+    image.set!(0)
+    image.draw_line(0,0,320,240,cam_rgb(255,0,0))
+    image.fill_color(50,100,cam_rgb(255,0,0))
+    image.draw_text_bitmap('Hello World',100,140,font)
+    image.save_bmp('output/drawing_ruby.bmp')
+  end
+end

data/test/test_fixed_filters.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestFixedFilters < Test::Unit::TestCase
+  def test_fixed_filters
+    source=CamImage.new
+    result=CamImage.new
+    # load picture chess.pgm
+    source.load_pgm("resources/chess.pgm")
+    # gaussian filtering 3x3
+    source.fixed_filter(result,CAM_GAUSSIAN_3x3);
+    # save the result
+    result.save_pgm("output/ruby_chess_gaussian_3x3.pgm");
+    # gaussian filtering 5x5
+    source.fixed_filter(result,CAM_GAUSSIAN_5x5);
+    # save the result
+    result.save_pgm("output/ruby_chess_gaussian_5x5.pgm");
+    # gaussian filtering 7x7
+    source.fixed_filter(result,CAM_GAUSSIAN_7x7);
+    # save the result
+    result.save_pgm("output/ruby_chess_gaussian_7x7.pgm");
+  end
+end

data/test/test_fox.rb

@@ -0,0 +1,106 @@
+require 'rubygems'
+require_gem 'fxruby'
+include Fox
+
+require_gem 'camellia'
+require 'camellia-fox.rb'
+include Camellia
+
+class ImageWindow < FXMainWindow
+
+  def initialize(app)
+    # Invoke base class initializer first
+    super(app, "Camellia/FXRuby test", nil, nil, DECOR_ALL, 0, 0, 440, 240)
+
+    contents = FXHorizontalFrame.new(self,
+      LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0, 0, 0, 0, 0)
+
+    # RIGHT pane for the buttons
+    buttonFrame = FXVerticalFrame.new(contents, (FRAME_SUNKEN|LAYOUT_FILL_Y|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 10, 10)
+
+    # Label above the buttons  
+    FXLabel.new(buttonFrame, "Button Frame", nil,
+      JUSTIFY_CENTER_X|LAYOUT_FILL_X);
+    
+    # Horizontal divider line
+    FXHorizontalSeparator.new(buttonFrame, SEPARATOR_RIDGE|LAYOUT_FILL_X)
+
+    # Erode button
+    erodeBtn = FXButton.new(buttonFrame,
+      "Erode Image...\tGrey scale erosion",
+      nil, nil, 0, (FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 5, 5) { |button|
+      button.connect(SEL_COMMAND, method(:onCmdErode))
+    }
+    
+    # Save button
+    saveBtn = FXButton.new(buttonFrame,
+      "Save Image...\tRead back image and save to file",
+      nil, nil, 0, (FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 5, 5)
+    saveBtn.connect(SEL_COMMAND, method(:onCmdRestore))
+    
+    # Exit button
+    FXButton.new(buttonFrame, "E&xit\tQuit FXRuby test", nil,
+      getApp(), FXApp::ID_QUIT, (FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 5, 5)
+  
+    # Create a FXBMPImage and load a picture from disk 
+    @picture=FXBMPImage.new(getApp(), nil, IMAGE_KEEP|IMAGE_OWNED, 320, 240);
+    FXFileStream.open('resources/alfa156.bmp', FXStreamLoad) { |stream| @picture.loadPixels(stream) }
+    @picture.render
+    source=@picture.to_camellia
+    @image=source.to_yuv
+    @image.set_roi(CamROI.new(@image,1)) # Select Y plane (B&W)
+
+    @imgFrame=FXImageFrame.new(contents,@picture)
+
+    # Make a tip
+    FXToolTip.new(getApp())
+  end
+
+  # Create and initialize
+  def create
+    # Create the windows
+    super
+
+    # Make the main window appear
+    show(PLACEMENT_SCREEN)
+  end
+
+  # Restore image from offscreen pixmap
+  def onCmdRestore(sender, sel, ptr)
+    saveDialog = FXFileDialog.new(self, "Save as BMP")
+    if saveDialog.execute != 0
+      @picture.restore
+      # Get back a CamImage and save it
+      @picture.to_camellia.save_bmp(saveDialog.filename)  
+    end
+    return 1
+  end
+  
+  # Erode image
+  def onCmdErode(sender, sel, ptr)
+    @image.erode_circle5!
+    @image.to_fox(getApp(),@picture)
+    @picture.render
+    @imgFrame.update
+  end
+  
+end
+
+if __FILE__ == $0
+  # Make application
+  application = FXApp.new("Camellia/FXRuby", "Camellia/FXRuby test")
+
+  # Make the main window
+  ImageWindow.new(application)
+
+  # Create the application window and resources
+  application.create
+
+  # Run the application
+  application.run
+end
+

data/test/test_fox2.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+require_gem 'fxruby'
+include Fox
+
+require_gem 'camellia'
+require 'camellia-fox.rb'
+include Camellia
+
+class ImageWindow < FXMainWindow
+
+  def initialize(app)
+    # Invoke base class initializer first
+    super(app, "Camellia/FXRuby test", nil, nil, DECOR_ALL, 0, 0, 440, 240)
+
+    contents = FXHorizontalFrame.new(self,
+      LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0, 0, 0, 0, 0)
+
+    # RIGHT pane for the buttons
+    buttonFrame = FXVerticalFrame.new(contents, (FRAME_SUNKEN|LAYOUT_FILL_Y|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 10, 10)
+
+    # Label above the buttons  
+    FXLabel.new(buttonFrame, "Button Frame", nil,
+      JUSTIFY_CENTER_X|LAYOUT_FILL_X);
+    
+    # Horizontal divider line
+    FXHorizontalSeparator.new(buttonFrame, SEPARATOR_RIDGE|LAYOUT_FILL_X)
+
+    # Erode button
+    erodeBtn = FXButton.new(buttonFrame,
+      "Erode Image...\tGrey scale erosion",
+      nil, nil, 0, (FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 5, 5) { |button|
+      button.connect(SEL_COMMAND, method(:onCmdErode))
+    }
+    
+    # Save button
+    saveBtn = FXButton.new(buttonFrame,
+      "Save Image...\tRead back image and save to file",
+      nil, nil, 0, (FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 5, 5)
+    saveBtn.connect(SEL_COMMAND, method(:onCmdRestore))
+    
+    # Exit button
+    FXButton.new(buttonFrame, "E&xit\tQuit FXRuby test", nil,
+      getApp(), FXApp::ID_QUIT, (FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|
+      LAYOUT_TOP|LAYOUT_LEFT), 0, 0, 0, 0, 10, 10, 5, 5)
+  
+    # Load image using Camellia
+    source=CamImage.new
+    source.load_bmp("resources/alfa156.bmp")
+    @image=source.to_yuv
+    @image.set_roi(CamROI.new(@image,1)) # Select Y plane (B&W)
+    
+    # Create a FXImage from the Camellia image
+    @picture=@image.to_fox(getApp())
+    @picture.render
+
+    @imgFrame=FXImageFrame.new(contents,@picture)
+
+    # Make a tip
+    FXToolTip.new(getApp())
+  end
+
+  # Create and initialize
+  def create
+    # Create the windows
+    super
+
+    # Make the main window appear
+    show(PLACEMENT_SCREEN)
+  end
+
+  # Restore image from offscreen pixmap
+  def onCmdRestore(sender, sel, ptr)
+    saveDialog = FXFileDialog.new(self, "Save as BMP")
+    if saveDialog.execute != 0
+      @picture.restore
+      # Get back a CamImage and save it
+      @picture.to_camellia.save_bmp(saveDialog.filename)  
+    end
+    return 1
+  end
+  
+  # Erode image
+  def onCmdErode(sender, sel, ptr)
+    @image.erode_circle5!
+    @image.to_fox(getApp(),@picture)
+    @picture.render
+    @imgFrame.update
+  end
+  
+end
+
+if __FILE__ == $0
+  # Make application
+  application = FXApp.new("Camellia/FXRuby", "Camellia/FXRuby test")
+
+  # Make the main window
+  ImageWindow.new(application)
+
+  # Create the application window and resources
+  application.create
+
+  # Run the application
+  application.run
+end
+

data/test/test_histogram.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestHistogram < Test::Unit::TestCase
+  def test_histogram
+    source=CamImage.new
+    # load picture alfa156.bmp
+    source.load_bmp("resources/alfa156.bmp")
+    # convert to YUV
+    yuv=CamImage.new
+    yuv=source.to_yuv
+    # compute the histogram
+    result=CamImage.new
+    yuv.histogram_2_channels(2,3,result)
+    # save the result
+    result.save_pgm("output/alfa156_histo.pgm")
+  end
+end

data/test/test_hough.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestHough < Test::Unit::TestCase
+  def test_hough
+    image=CamImage.new(100,100)
+    # Draw a filled circle in mask
+    image.set!(0)
+    image.draw_circle(40,40,50,128)
+    image.fill_color(40,40,128)
+    res=image.hough_circle(10,40,60)
+    puts "Found a circle at (#{res[1]},#{res[2]}) (radius=#{res[3]}) (confidence=#{res[0]})"
+    assert((res[1]-40).abs<=1)
+    assert((res[2]-40).abs<=1)
+   
+    for i in 1..3 do
+    	# Load an image with a road sign
+    	image.load_bmp("resources/road#{i}.bmp")
+    	yuv=CamImage.new
+	image.to_yuv(yuv)
+	yuv.set_roi(CamROI.new(1,8,8,image.width-16,image.height-128))
+	yuv.fixed_filter!(CAM_GAUSSIAN_3x3)
+	res=yuv.hough_circle(100,6,25)
+    	image.draw_circle(res[1],res[2],res[3],cam_rgb(255,0,0))
+    	image.save_bmp("output/road_circle_hough#{i}.bmp")
+   	puts "Found a circle at (#{res[1]},#{res[2]}) (radius=#{res[3]}) (confidence=#{res[0]})"
+    end
+  end
+end

data/test/test_labeling.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestLabeling < Test::Unit::TestCase
+  def test_labeling
+    image=CamImage.new
+    # load picture alfa156.bmp
+    image.load_bmp("resources/alfa156.bmp")
+    yuv=image.to_yuv
+    # consider only the V plane (red)
+    yuv.set_roi(CamROI.new(yuv,3)) 
+    # threshold and encode
+    thr=yuv.encode_threshold(150)
+    # labeling
+    blobs=thr.labeling!
+    puts "#{blobs.nb_blobs} blobs detected"
+    # draw rectangle on all detected blobs 
+    blobs.each {|b| image.draw_rectangle(b.left,b.top,b.left+b.width-1,b.top+b.height-1,cam_rgb(255,0,0))}
+    # save the resulting picture
+    image.save_bmp("output/ruby_alfa156_labeling.bmp")
+    # find out the biggest blob
+    sorted=blobs.sort {|a,b| b.surface<=>a.surface}
+    puts "The bigger blob is at position (#{sorted[0].cx},#{sorted[0].cy}) and its surface is #{sorted[0].surface}"
+    # assertions
+    assert_equal(blobs.nb_blobs,12)
+    assert_equal(sorted[0].cx,170)
+    assert_equal(sorted[0].cy,128)
+    assert_equal(sorted[0].surface,601)
+  end
+end

data/test/test_mask.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'lib/camellia'
+include Camellia
+class TestMask < Test::Unit::TestCase
+  def test_mask
+    source=CamImage.new
+    # load picture chess.pgm
+    source.load_pgm("resources/chess.pgm")
+    mask=CamImage.new(source.width,source.height)
+    # draw a filled circle in mask
+    mask.set!(0)
+    mask.draw_circle(mask.width/2,mask.height/2,50,255)
+    n=mask.fill_color(mask.width/2,mask.height/2,255)
+    assert_equal(n,7837) # number of pixels filled with color
+    # encode the mask and associate it to the source image
+    encoded_mask=mask.encode
+    source.mask=encoded_mask
+    encoded_mask.inverse!
+    dest=CamImage.new
+    source.copy(dest) # copies only the mask! not like dup or clone!
+    # and then compute a sobel inside
+    encoded_mask.inverse!
+    b=source.sobel_v_abs(dest) # sobel only on the mask 
+    dest.save_pgm("output/ruby_chess_sobel_mask.pgm")
+    # checking types
+    assert_equal(source.class,Camellia::CamImage)
+    assert_equal(encoded_mask.class,Camellia::CamRLEImage)
+
+    # use a non compressed mask
+    source.mask=mask
+    source.set!(0)
+    source.save_pgm("output/ruby_chess_hole.pgm");
+  end
+end