camellia 2.5.10-i486-linux

data/ext/INSTALL

@@ -0,0 +1,9 @@
+swig -ruby -c++ camellia_ruby.i
+ruby extconf.rb
+make clean
+make
+cp camellia.so ../lib
+sudo make install
+sudo ruby install.rb
+
+

data/ext/Makefile

@@ -0,0 +1,139 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/i486-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr
+exec_prefix = $(prefix)
+sitedir = $(DESTDIR)/usr/local/lib/site_ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+datadir = $(prefix)/share
+includedir = $(prefix)/include
+infodir = $(prefix)/info
+sysconfdir = $(DESTDIR)/etc
+mandir = $(datadir)/man
+libdir = $(exec_prefix)/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+sitearchdir = $(sitelibdir)/$(sitearch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(exec_prefix)/libexec
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+CFLAGS   =  -fPIC -Wall -g -O2  -fPIC 
+CPPFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)  
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS =   
+LDSHARED = g++ -shared -lCamellia
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby1.8
+RUBY_SO_NAME = ruby1.8
+arch = i486-linux
+sitearch = i486-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby1.8
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = $(libdir)
+LIBPATH =  -L"$(libdir)"
+DEFFILE = 
+
+CLEANFILES = 
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lcrypt -lm   -lc
+SRCS = camellia_ruby_wrap.cxx
+OBJS = camellia_ruby_wrap.o
+TARGET = camellia
+DLLIB = $(TARGET).so
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile extconf.h conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.c.o:
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) $(DLDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/camellia_ruby.i

@@ -0,0 +1,308 @@
+/* File : camellia_ruby.i */
+%module camellia
+
+%{
+#include "../inc/camellia.h"
+%}
+
+%include "cstring.i"
+
+%trackobjects;
+
+// Bash
+%rename("dealloc!") CamImage::dealloc();
+
+%rename("erode_square3!") CamImage::erode_square3();
+%rename("erode_circle5!") CamImage::erode_circle5();
+%rename("erode_circle7!") CamImage::erode_circle7();
+%rename("dilate_square3!") CamImage::dilate_square3();
+%rename("dilate_circle5!") CamImage::dilate_circle5();
+%rename("dilate_circle7!") CamImage::dilate_circle7();
+%rename("morpho_gradient_square3!") CamImage::morpho_gradient_square3();
+%rename("morpho_gradient_circle5!") CamImage::morpho_gradient_circle5();
+%rename("morpho_gradient_circle7!") CamImage::morpho_gradient_circle7();
+%rename("morpho_maths!") CamImage::morpho_maths(const CamMorphoMathsKernel &ker);
+%rename("erode_3x3!") CamImage::erode_3x3(const CamMorphoMathsKernel &ker);
+%rename("dilate_3x3!") CamImage::dilate_3x3(const CamMorphoMathsKernel &ker);
+%rename("erode_5x5!") CamImage::erode_5x5(const CamMorphoMathsKernel &ker);
+%rename("dilate_5x5!") CamImage::dilate_5x5(const CamMorphoMathsKernel &ker);
+%rename("erode_7x7!") CamImage::erode_7x7(const CamMorphoMathsKernel &ker);
+%rename("dilate_7x7!") CamImage::dilate_7x7(const CamMorphoMathsKernel &ker);
+%rename("threshold!") CamImage::threshold();
+%rename("threshold_inv!") CamImage::threshold_inv();
+%rename("abs!") CamImage::abs();
+%rename("set!") CamImage::set(int color);
+
+%rename("linear_filter_3x3!") CamImage::linear_filter_3x3(const CamLinearFilterKernel &ker);
+%rename("linear_filter_5x5!") CamImage::linear_filter_5x5(const CamLinearFilterKernel &ker);
+%rename("linear_filter_abs_3x3!") CamImage::linear_filter_abs_3x3(const CamLinearFilterKernel &ker);
+%rename("linear_filter_abs_5x5!") CamImage::linear_filter_abs_5x5(const CamLinearFilterKernel &ker);
+%rename("sep_filter_3x3!") CamImage::sep_filter_3x3(const CamSepFilterKernel &ker);
+%rename("sep_filter_5x5!") CamImage::sep_filter_5x5(const CamSepFilterKernel &ker);
+%rename("sep_filter_7x7!") CamImage::sep_filter_7x7(const CamSepFilterKernel &ker);
+%rename("sep_filter_abs_3x3!") CamImage::sep_filter_abs_3x3(const CamSepFilterKernel &ker);
+%rename("sep_filter_abs_5x5!") CamImage::sep_filter_abs_5x5(const CamSepFilterKernel &ker);
+%rename("sep_filter_abs_7x7!") CamImage::sep_filter_abs_7x7(const CamSepFilterKernel &ker);
+%rename("sobel_v!") CamImage::sobel_v();
+%rename("sobel_h!") CamImage::sobel_h();
+%rename("sobel_v_abs!") CamImage::sobel_v_abs();
+%rename("sobel_h_abs!") CamImage::sobel_h_abs();
+%rename("fixed_filter!") CamImage::fixed_filter(int filter);
+%rename("hierarchical_watershed_regions!") CamImage::hierarchical_watershed_regions(const CamTableOfBasins &tob);
+
+%rename("arithm!") CamImage::arithm(int operation, int c1=0, int c2=0, int c3=0);
+
+%rename("apply_lut!") CamImage::apply_lut(const CamTable &LUT);
+%rename("apply_lut!") CamRLEImage::apply_lut(const CamTable &LUT);
+
+%rename("inverse!") CamRLEImage::inverse();
+%rename("labeling!") CamRLEImage::labeling(); 
+%rename("labeling!") CamRLEImage::labeling(CamBlobs &results);
+
+// Predicates
+%rename("allocated?") CamImage::allocated() const;
+
+// Other renaming
+%rename("cam_rgb") camRGB(int r, int g, int b);
+%rename("cam_rgba") camRGBA(int r, int g, int b);
+%rename("cam_set_viewer") camSetImageViewer;
+%rename("nb_runs") CamRLEImage::nbRuns;
+%rename("nb_blobs") CamBlobs::nbBlobs;
+
+// Aliases
+%alias CamRLEImage::labeling "labelling!";
+%alias CamImage::set_mask "mask=";
+
+// Ruby idioms
+%alias CamImage::get_pixels "to_s";
+%alias CamImage::clone "dup";
+
+%newobject CamImage::clone;
+%newobject CamImage::encode;
+%newobject CamImage::encode_threshold;
+%newobject CamImage::encode_threshold_inv;
+%newobject CamImage::encode_threshold_lut;
+%newobject CamImage::labeling;
+%newobject CamImage::to_yuv;
+%newobject CamImage::to_rgb;
+%newobject CamRLEImage::erode_cross;
+%newobject CamRLEImage::erode_3x3;
+%newobject CamRLEImage::erode_3x2;
+
+// Garbage collection
+%markfunc CamImage "mark_CamImage";
+
+// Typemaps
+
+// Correct string allocation for to_s
+%cstring_output_allocate_size(char **result, int *len, delete[](*$1));
+
+%include "typemaps.i"
+%apply int *OUTPUT { int &xc };
+%apply int *OUTPUT { int &yc };
+%apply int *OUTPUT { int &rc };
+
+%typemap(in) (const char *pixels, int sz)
+{
+	$1=STR2CSTR($input);
+	$2=(int)RSTRING($input)->len;
+}
+
+%typemap(in) (const int* const array, int sz)
+{
+	Check_Type($input, T_ARRAY);
+	$2=RARRAY($input)->len;
+	if ($2) {
+		$1=new int[$2];
+		for (int i=0;i!=$2;i++) {
+			VALUE inst = rb_ary_entry($input, i);
+			$1[i]=NUM2INT(inst);
+		}
+	} else {
+		$1=NULL;
+	}
+}
+
+%typemap(freearg) (const int* const array, int sz)
+{
+	if ($1) delete[] $1;
+}
+
+// Include header
+
+%include "../inc/camellia.h"
+
+// Additionnal defitions
+
+#define CAM_COLORMODEL_GREY 0
+#define CAM_COLORMODEL_RGB  1
+#define CAM_COLORMODEL_RGBA 2
+#define CAM_COLORMODEL_YUV  3
+
+%mixin CamTable "Enumerable";
+
+struct CamTable {
+    int size;              ///< Number of valid entries
+    CamTable(int s=0);
+	bool set(const int* const array, int sz);
+};
+
+%extend CamTable {
+	int __getitem__(int n) {
+		if ((n>=0)&&(n<self->size)&&(n<CAM_TABLE_SIZE)) return self->t[n];
+		else camError("CamTable","Index out of range");
+		return self->t[0];
+	};
+	void __setitem__(int n, int val) {
+		if ((n>=0)&&(n<self->size)&&(n<CAM_TABLE_SIZE)) self->t[n]=val;
+		else camError("CamTable","Index out of range");
+	};
+	void each() {
+		for (int i=0;i<self->size;i++) {
+			VALUE obj = INT2FIX(self->t[i]);
+			if (obj != Qnil) {
+				rb_yield(obj);
+			}
+		}
+	};
+};
+
+struct CamRLEImage {
+    int id;             ///< Frame id (user dependent)
+%immutable;
+    int height;			///< Image height
+    int width;			///< Image width
+    int nbRuns;			///< The number of runs
+    int allocated;		///< Number of runs allocated
+%mutable;
+
+    CamRLEImage() {allocated=0; runs=NULL; nbRuns=0;}   ///< Default constructor
+    CamRLEImage(int nbruns);                            ///< Constructor with max number of runs parameter
+    CamRLEImage(const CamRLEImage &image);              ///< Copy constructor
+    ~CamRLEImage();                                     ///< Default destructor
+
+    CamRLEImage* clone() const;                         ///< Clone RLE image (using CamRLEClone() function)
+    bool alloc(int nbruns);                             ///< Allocator (C++ wrapping of CamRLEAllocate() function)
+    bool realloc(int nbruns);                           ///< Reallocator (C++ wrapping of CamRLEReallocate() function)
+
+    bool encode(const CamImage &image);                             ///< C++ wrapping for CamRLEEncode() function
+    bool encode_lut(const CamImage &image, const CamTable &LUT);    ///< C++ wrapping for CamRLEEncodeLUT() function
+    bool encode_threshold(const CamImage &image, int threshold);    ///< C++ wrapping for CamRLEEncodeThreshold() function
+    bool encode_threshold_inv(const CamImage &image, int threshold);///< C++ wrapping for CamRLEEncodeThresholdInv() function
+    bool encode_color(const CamImage &image, const CamTable &clusters); ///< C++ wrapping for camCamRLEEncodeColor() function
+    CamBlobs* labeling();											///< C++ wrapping for CamRLELabeling() function
+    bool labeling(CamBlobs &results);								///< C++ wrapping for CamRLELabeling() function
+    bool blob_analysis(CamBlobs &results) const;					///< C++ wrapping for CamRLEBlobAnalysis() function
+    bool apply_lut(const CamTable &LUT);                            ///< C++ wrapping for CamRLEApplyLUT() function
+    bool apply_lut(CamRLEImage &dest, const CamTable &LUT) const;   ///< C++ wrapping for CamRLEApplyLUT() function
+    bool decode(CamImage &dest) const;                              ///< C++ wrapping for CamRLEDecode() function            
+    bool decode(CamImage &dest, const CamTable &LUT) const;         ///< C++ wrapping for CamRLEDecode() function
+    bool decode_blobs(CamImage &dest) const;                        ///< C++ wrapping for CamRLEDecodeBlobs() function            
+    bool decode_blobs(CamImage &dest, const CamTable &LUT) const;   ///< C++ wrapping for CamRLEDecodeBlos() function
+    bool inverse();                                                 ///< C++ wrapping for CamRLEInverse() function
+    bool erode_cross(CamRLEImage &dest) const;                      ///< C++ wrapping for CamRLEErodeCross() function 
+    CamRLEImage *erode_cross() const;                               ///< C++ wrapping for CamRLEErodeCross() function 
+    bool erode_3x3(CamRLEImage &dest) const;                        ///< C++ wrapping for CamRLEErode3x3() function 
+    CamRLEImage *erode_3x3() const;                                 ///< C++ wrapping for CamRLEErode3x3() function 
+    bool erode_3x2(CamRLEImage &dest) const;                        ///< C++ wrapping for CamRLEErode3x2() function 
+    CamRLEImage *erode_3x2() const;                                 ///< C++ wrapping for CamRLEErode3x2() function 
+};
+
+%immutable;
+typedef struct {
+    int id;
+    int left;		///< Leftmost coordinate of the blob
+    int top;		///< Topmost coordinate of the blob
+    int width;		///< Width of the blob
+    int height;		///< Height of the blob
+    int surface;	///< Number of pixels covered by this blob
+    int cx;			///< Center of gravity (x)
+    int cy;			///< Center of gravity (y)
+    int value;	    ///< Blob value, or average pixel value in the original image
+    int min;		///< Minimum pixel value in the original image
+    int max;		///< Maximum pixel value in the original image
+    void *misc;		///< Additional user-dependant blob information
+} CamBlobInfo;
+
+%mixin CamBlobs "Enumerable";
+
+struct CamBlobs {
+    int nbBlobs;			///< Number of valid blobs
+    CamBlobs() {nbBlobs=0;} ///< Default constructor
+};
+
+%extend CamBlobs {
+	CamBlobInfo __getitem__(int n) {
+		if ((n>=0)&&(n<self->nbBlobs)) return self->blobInfo[n];
+		else camError("CamBlobs","Index out of range");
+		return self->blobInfo[0];
+	};
+	void each() {
+		for (int i=0;i<self->nbBlobs;i++) {
+			VALUE obj = SWIG_NewPointerObj((new CamBlobInfo(self->blobInfo[i])), SWIGTYPE_p_CamBlobInfo, SWIG_POINTER_OWN);
+			if (obj != Qnil) {
+				rb_yield(obj);
+			}
+		}
+	};	
+};
+
+%mixin CamTableOfBasins "Enumerable";
+
+struct CamTableOfBasins
+{
+    int nbBasins;
+    void get_rid_of(CamBasin &basin) {basin.surface=-1;}
+};
+
+%extend CamTableOfBasins {
+	CamBasin __getitem__(int n) {
+		if ((n>=0)&&(n<self->nbBasins)) return self->tab[n];
+		else camError("CamTableOfBasins","Index out of range");
+		return self->tab[0];
+	};
+	void each() {
+		for (int i=0;i<self->nbBasins;i++) {
+			VALUE obj = SWIG_NewPointerObj(&self->tab[i], SWIGTYPE_p_CamBasin, 0 );
+			if (obj != Qnil) {
+				rb_yield(obj);
+			}
+		}
+	};	
+};
+
+%mutable;
+
+// Garbage collection implementation (mark & sweep)
+%header %{
+static void mark_CamImage(void *ptr) {
+	CamImage *image=(CamImage*)ptr;
+	if (image->roi) {
+		VALUE object = SWIG_RubyInstanceFor(image->roi);
+		if (object != Qnil) {
+			rb_gc_mark(object);
+		}
+	}
+	if (image->mask) {
+		VALUE object = SWIG_RubyInstanceFor(image->mask);
+		if (object != Qnil) {
+			rb_gc_mark(object);
+		}
+	}
+}
+%}
+
+// Exception handling
+%header %{
+	void camErrorRuby(char *module, char *error)
+	{
+		rb_raise(rb_eRuntimeError,"Error in %s : %s",module,error);	
+	}
+%}
+
+// Set ruby error function
+%init %{
+	camSetErrorFunct(camErrorRuby);
+%}
+
+