0.8.1

svn path=/trunk/; revision=4710

1 files changed, 775 insertions, 0 deletions

diff --git a/externals/gridflow/optional/rblti/rblti.i b/externals/gridflow/optional/rblti/rblti.i
new file mode 100644
index 00000000..0cb9686f
--- /dev/null
+++ b/externals/gridflow/optional/rblti/rblti.i
@@ -0,0 +1,775 @@
+//******************************************************************************
+// rblti, Copyright 2005 by Mathieu Bouchard and Heri Andria
+// pylti, Copyright 2005 by Michael Neuroth
+// a wrapper for ltilib using SWIG
+
+%module rblti
+%rename(inplace_add) operator +=;
+%rename(inplace_sub) operator -=;
+%rename(inplace_mul) operator *=;
+%rename(inplace_div) operator /=;
+%rename(not_equal)   operator !=;
+%include "std_list_ruby.i"
+%include "std_string.i"
+//%include "std_list.i"
+//%include "std_vector.i" 
+//%include "std_map.i"
+
+using namespace std;
+
+// sollte nach dem include der std_*.i Dateien stehen, ansonsten gibt swig einen Fehlercode zurueck !
+//%feature("autodoc","1")
+
+std::string _getStdString(std::string * pStr);
+bool _setStdString(std::string * pStr, const std::string & strValue);
+
+// for the access to c arrays
+%include "carrays.i"
+%array_functions(float,floatArray)
+%array_functions(double,doubleArray)
+%array_functions(int,intArray)
+%array_class(float,floatArr)
+%array_class(double,doubleArr)
+%array_class(int,intArr)
+
+//test:
+//namespace std {
+//    %template(sdmap) map<string,double>;		// TODO: does not work yet ...
+//}
+//namespace std {
+//    %template(vectordouble) vector<double>;
+//}
+
+// **************************************************************************
+// **************************************************************************
+// This part is for the c++ wrapper compile phase !
+// This code will be copied into the wrapper-code (generated from swig)
+%{
+#include <string>
+
+// TODO: to be removed, only for tests
+std::string _getStdString(std::string * pStr) {return *pStr;}
+bool _setStdString(std::string * pStr, const std::string & strValue) {
+    if(pStr) *pStr = strValue;
+    return !!pStr;
+}
+// </to-be-removed>
+
+#undef PACKAGE_NAME
+#undef PACKAGE_TARNAME
+#undef PACKAGE_STRING
+#undef PACKAGE_VERSION
+
+#include "ltiObject.h"
+//#include "ltiTypes.h"
+#include "ltiIoHandler.h"
+#include "ltiIoObject.h"
+#include "ltiMathObject.h"
+#include "ltiRGBPixel.h"
+#include "ltiPoint.h"
+#include "ltiPointList.h"
+#include "ltiPolygonPoints.h"
+#include "ltiGeometry.h"
+#include "ltiGenericVector.h"           // MODIFIED for SWIG !
+#include "ltiVector.h"
+#include "ltiArray.h"
+#include "ltiGenericMatrix.h"           // MODIFIED for SWIG !
+#include "ltiMatrix.h"                  // MODIFIED for SWIG !
+#include "ltiTree.h"
+#include "ltiHistogram.h"
+#include "ltiImage.h"
+#include "ltiContour.h"
+#include "ltiLinearKernels.h"
+#include "ltiGradientKernels.h"
+#include "ltiHessianKernels.h"
+#include "ltiLaplacianKernel.h"
+#include "ltiSecondDerivativeKernels.h"
+
+#include "ltiFunctor.h"
+// durch SWIG manipulierte typ parameters in functor wieder zurueck benennen
+#define _functor functor               // wegen Namenskonflikt mit schon deklarierter Klasse und dem Trick ueber den namespace um die Parameter-Klassen zu generieren (gen_ltilib_class.py)
+#define _functor_parameters parameters // sezte den aus dem XML generierten Parameter-Klassen-Namen wieder zurueck auf den urspruenglichen Namen
+// notwendig fuer die plain Methoden lti::write(...) und lti::read(...)
+namespace lti {typedef lti::functor::parameters functor_parameters;}
+#include "ltiModifier.h"
+#define _modifier modifier
+#define _modifier_parameters parameters
+namespace lti {typedef lti::modifier::parameters modifier_parameters;}
+#include "ltiFilter.h"
+#define _filter filter
+#define _filter_parameters parameters
+namespace lti {typedef lti::filter::parameters filter_parameters;}
+#include "ltiIOFunctor.h"
+#define _ioFunctor ioFunctor
+#define _ioFunctor_parameters parameters
+namespace lti {typedef lti::ioFunctor::parameters ioFunctor_parameters;}
+#include "ltiBMPFunctor.h"
+#define _ioBMP ioBMP
+#define _ioBMP_parameters parameters
+#define lti_ioBMP_parameters ioBMP_parameters      // TODO: PATCH !
+namespace lti {typedef lti::ioBMP::parameters ioBMP_parameters;}
+#include "ltiJPEGFunctor.h"
+#define _ioJPEG ioJPEG
+#define _ioJPEG_parameters parameters
+#define lti_ioJPEG_parameters ioJPEG_parameters      // TODO: PATCH !
+namespace lti {typedef lti::ioJPEG::parameters ioJPEG_parameters;}
+#include "ltiPNGFunctor.h"
+#define _ioPNG ioPNG
+#define _ioPNG_parameters parameters
+#define lti_ioPNG_parameters ioPNG_parameters     
+namespace lti {typedef lti::ioPNG::parameters ioPNG_parameters;}
+#include "ltiALLFunctor.h"
+#define _ioImage ioImage
+#define _ioImage_parameters parameters
+#define ioImage_parameters parameters                   // TODO: PATCH !
+namespace lti {typedef lti::ioImage::parameters ioImage_parameters;}
+#include "ltiViewerBase.h"
+#define _viewerBase viewerBase
+#define _viewerBase_parameters parameters
+namespace lti {typedef lti::viewerBase::parameters viewerBase_parameters;}
+#include "ltiExternViewer.h"
+#define _externViewer externViewer
+#define _externViewer_parameters parameters
+namespace lti {typedef lti::externViewer::parameters externViewer_parameters;}
+#include "ltiSplitImage.h"
+#include "ltiSplitImageTorgI.h"
+
+#include "ltiUsePalette.h"
+#define _usePalette usePalette
+#define _usePalette_parameters parameters
+namespace lti {typedef lti::usePalette::parameters usePalette_parameters;}
+#include "ltiTransform.h"
+#define _transform transform
+#define _transform_parameters parameters
+namespace lti {typedef lti::transform::parameters transform_parameters;}
+#include "ltiGradientFunctor.h"
+#define _gradientFunctor gradientFunctor
+#define _gradientFunctor_parameters parameters
+#define lti_gradientFunctor_parameters gradientFunctor_parameters      // TODO: PATCH !
+namespace lti {typedef lti::gradientFunctor::parameters gradientFunctor_parameters;}
+#include "ltiColorContrastGradient.h"
+#define _colorContrastGradient colorContrastGradient
+#define _colorContrastGradient_parameters parameters
+#define lti_colorContrastGradient_parameters colorContrastGradient_parameters      // TODO: PATCH !
+namespace lti {typedef lti::colorContrastGradient::parameters colorContrastGradient_parameters;}
+#include "ltiEdgeDetector.h"
+#define _edgeDetector edgeDetector
+#define _edgeDetector_parameters parameters
+namespace lti {typedef lti::edgeDetector::parameters edgeDetector_parameters;}
+#include "ltiClassicEdgeDetector.h"
+#define _classicEdgeDetector classicEdgeDetector
+#define _classicEdgeDetector_parameters parameters
+namespace lti {typedef lti::classicEdgeDetector::parameters classicEdgeDetector_parameters;}
+#include "ltiCannyEdges.h"
+#define _cannyEdges cannyEdges
+#define _cannyEdges_parameters parameters
+namespace lti {typedef lti::cannyEdges::parameters cannyEdges_parameters;}
+#include "ltiConvolution.h"
+#define _convolution convolution
+#define _convolution_parameters parameters
+namespace lti {typedef lti::convolution::parameters convolution_parameters;}
+#include "ltiSegmentation.h"
+#define _segmentation segmentation
+#define _segmentation_parameters parameters
+namespace lti {typedef lti::segmentation::parameters segmentation_parameters;}
+#include "ltiRegionGrowing.h"
+#define _regionGrowing regionGrowing
+#define _regionGrowing_parameters parameters
+namespace lti {typedef lti::regionGrowing::parameters regionGrowing_parameters;}
+#include "ltiObjectsFromMask.h"
+#define _objectsFromMask objectsFromMask
+#define _objectsFromMask_parameters parameters
+#define _objectsFromMask_objectStruct objectStruct
+namespace lti {
+typedef lti::objectsFromMask::objectStruct objectStruct;
+typedef lti::objectsFromMask::objectStruct objectsFromMask_objectStruct;
+typedef lti::objectsFromMask::parameters objectsFromMask_parameters;
+}
+////TODO: add better tree support !!!
+////#define _tree tree
+//#define _tree_objectStruct_node node
+//#define _tree tree<objectStruct>
+//namespace lti {
+//typedef lti::tree<objectStruct>::node tree_objectStruct_node;
+//}
+#include "ltiPolygonApproximation.h"
+#define _polygonApproximation polygonApproximation
+#define _polygonApproximation_parameters parameters
+namespace lti {typedef lti::polygonApproximation::parameters polygonApproximation_parameters;}
+#include "ltiColorQuantization.h"
+#define _colorQuantization colorQuantization
+#define _colorQuantization_parameters parameters
+namespace lti {typedef lti::colorQuantization::parameters colorQuantization_parameters;}
+#include "ltiKMColorQuantization.h"
+#define _kMColorQuantization kMColorQuantization
+#define _kMColorQuantization_parameters parameters
+namespace lti {
+typedef lti::kMColorQuantization::parameters kMColorQuantization_parameters;
+//typedef lti::kMColorQuantization::parameters lti_kMColorQuantization_parameters;
+}
+typedef lti::kMColorQuantization::parameters lti_kMColorQuantization_parameters;
+#include "ltiMeanShiftSegmentation.h"
+#define _meanShiftSegmentation meanShiftSegmentation
+#define _meanShiftSegmentation_parameters parameters
+namespace lti {typedef lti::meanShiftSegmentation::parameters meanShiftSegmentation_parameters;}
+#include "ltiKMeansSegmentation.h"
+#define _kMeansSegmentation kMeansSegmentation
+#define _kMeansSegmentation_parameters parameters
+namespace lti {
+typedef lti::kMeansSegmentation::parameters kMeansSegmentation_parameters;
+//typedef lti::kMeansSegmentation::parameters lti_kMeansSegmentation_parameters;
+}
+typedef lti::kMeansSegmentation::parameters lti_kMeansSegmentation_parameters;
+
+#include "ltiWhiteningSegmentation.h"
+#define _whiteningSegmentation whiteningSegmentation
+#define _whiteningSegmentation_parameters parameters
+namespace lti {typedef lti::whiteningSegmentation::parameters whiteningSegmentation_parameters;}
+#include "ltiCsPresegmentation.h"
+#define _csPresegmentation csPresegmentation
+#define _csPresegmentation_parameters parameters
+namespace lti {typedef lti::csPresegmentation::parameters csPresegmentation_parameters;}
+#include "ltiFeatureExtractor.h"
+#define _featureExtractor featureExtractor
+#define _featureExtractor_parameters parameters
+namespace lti {typedef lti::featureExtractor::parameters featureExtractor_parameters;}
+#include "ltiGlobalFeatureExtractor.h"
+#define _globalFeatureExtractor globalFeatureExtractor
+#define _globalFeatureExtractor_parameters parameters
+namespace lti {typedef lti::globalFeatureExtractor::parameters globalFeatureExtractor_parameters;}
+#include "ltiGeometricFeatures.h"
+#define _geometricFeatures geometricFeatures
+#define _geometricFeatures_parameters parameters
+namespace lti {typedef lti::geometricFeatures::parameters geometricFeatures_parameters;}
+#include "ltiChromaticityHistogram.h"
+#define _chromaticityHistogram chromaticityHistogram
+#define _chromaticityHistogram_parameters parameters
+namespace lti {typedef lti::chromaticityHistogram::parameters chromaticityHistogram_parameters;}
+#include "ltiLocalFeatureExtractor.h"
+#define _localFeatureExtractor localFeatureExtractor
+#define _localFeatureExtractor_parameters parameters
+namespace lti {typedef lti::localFeatureExtractor::parameters localFeatureExtractor_parameters;}
+#include "ltiLocalMoments.h"
+#define _localMoments localMoments
+#define _localMoments_parameters parameters
+namespace lti {typedef lti::localMoments::parameters localMoments_parameters;}
+#include "ltiMorphology.h"
+#define _morphology morphology
+#define _morphology_parameters parameters
+namespace lti {typedef lti::morphology::parameters morphology_parameters;}
+#include "ltiDilation.h"
+#define _dilation dilation
+#define _dilation_parameters parameters
+namespace lti {typedef lti::dilation::parameters dilation_parameters;}
+#include "ltiErosion.h"
+#define _erosion erosion
+#define _erosion_parameters parameters
+namespace lti {typedef lti::erosion::parameters erosion_parameters;}
+#include "ltiDistanceTransform.h"
+#define _distanceTransform distanceTransform
+#define _distanceTransform_parameters parameters
+namespace lti {typedef lti::distanceTransform::parameters distanceTransform_parameters;}
+#include "ltiSkeleton.h"
+#define _skeleton skeleton
+#define _skeleton_parameters parameters
+namespace lti {typedef lti::skeleton::parameters skeleton_parameters;}
+#include "ltiClassifier.h"
+#define _classifier classifier
+#define _classifier_parameters parameters
+#define _classifier_outputTemplate outputTemplate
+#define _classifier_outputVector outputVector
+namespace lti {
+typedef lti::classifier::parameters classifier_parameters;
+typedef lti::classifier::outputTemplate classifier_outputTemplate;
+typedef lti::classifier::outputVector classifier_outputVector;
+}
+#include "ltiSupervisedInstanceClassifier.h"
+#define _supervisedInstanceClassifier supervisedInstanceClassifier
+#define _supervisedInstanceClassifier_parameters parameters
+namespace lti {typedef lti::supervisedInstanceClassifier::parameters supervisedInstanceClassifier_parameters;}
+/* TODO
+#include "ltiDecisionTree.h"
+#define _decisionTree decisionTree
+#define _decisionTree_parameters parameters
+namespace lti {
+typedef lti::decisionTree::parameters decisionTree_parameters;
+}
+*/
+
+#include "ltiSplitImageToHSI.h"
+#include "ltiSplitImageToHSV.h"
+#include "ltiSplitImageToHLS.h"
+#include "ltiSplitImageToRGB.h"
+#include "ltiSplitImageToYUV.h"
+
+typedef std::ostream ostream;
+typedef std::istream istream;
+
+using namespace lti;
+
+#include "lti_manual.h"
+
+%}
+// **************************************************************************
+// This part is for the swig parser phase !
+// This code will be used by swig to build up the type hierarchy.
+// for successful mapping of const ubyte & to simple data types !!!
+typedef unsigned      char ubyte;
+typedef   signed      char  byte;
+typedef unsigned short int uint16;
+typedef   signed short int  int16;
+typedef unsigned       int uint32;
+typedef   signed       int  int32;
+/* #ifdef LOSEDOWS
+typedef unsigned   __int64 uint64;
+typedef signed     __int64  int64;
+#else
+typedef unsigned long long uint64;
+typedef   signed long long  int64;
+#endif */
+typedef point<int> ipoint;
+
+%include "ltiObject.h"
+%include "ltiIoHandler.h"
+%include "ltiIoObject.h"
+%include "ltiMathObject.h"
+%include "ltiRGBPixel.h"
+%include "ltiPoint.h"
+namespace lti {
+    %template(ipoint) tpoint<int>;
+    %template(fpoint) tpoint<float>;
+    %template(dpoint) tpoint<double>;
+}
+%template(list_ipoint) std::list<lti::ipoint>;
+%include "ltiPointList.h"
+%extend lti::tpointList {
+// TODO: add a better (pythonic) support for iterators
+void * createIterator()
+{
+    lti::tpointList<T>::iterator * pIter = new lti::tpointList<T>::iterator;
+    (*pIter) = self->begin();
+    return (void *) (pIter);
+}
+void deleteIterator(void *p) 
+{
+    lti::tpointList<T>::iterator * pIter = (lti::tpointList<T>::iterator *)p;
+    delete pIter;
+}
+bool isEnd(void *p) 
+{
+    lti::tpointList<T>::iterator * pIter = (lti::tpointList<T>::iterator *)p;
+    return *pIter == self->end();
+}
+tpoint<T> nextElement(void * p) 
+{
+    lti::tpointList<T>::iterator * pIter = (lti::tpointList<T>::iterator *)p;
+    tpoint<T> aPointOut = *(*pIter);
+    ++(*pIter);
+    return aPointOut;
+}
+}
+namespace lti {
+    %template(pointList) tpointList<int>;
+}
+%include "ltiPolygonPoints.h"
+namespace lti {
+//    %template(ipolygonPoints) tpolygonPoints<int>;        // PATCH in ltiPolygonPoints.h
+}
+%include "ltiGeometry.h"
+namespace lti {
+//TODO:    %template(iintersection) intersection<ipoint>;
+}
+%include "ltiGenericVector.h"
+%extend lti::genericVector {
+    // add index support for python (Warning: this is Python-specific!) 
+	const T & __getitem__( int index )
+	{
+		return self->at(index);
+	}
+	void __setitem__( int index, const T & value )
+	{
+		(*self)[index] = value;
+	}
+}
+namespace lti {
+    %template(dgenericVector)   genericVector<double>;
+    %template(fgenericVector)   genericVector<float>;
+    %template(igenericVector)   genericVector<int>;
+    %template(bgenericVector)   genericVector<ubyte>;
+    %template(rgbgenericVector) genericVector<rgbPixel>;
+}
+%include "ltiVector.h"
+namespace lti {
+    %template(dvector) vector<double>;
+    %template(fvector) vector<float>;
+    %template(ivector) vector<int>;
+    %template(uvector) vector<ubyte>;
+    %template(palette) vector<rgbPixel>;
+}
+%include "ltiArray.h"
+namespace lti {
+    %template(iarray) array<int>;
+    %template(farray) array<float>;
+    %template(darray) array<double>;
+    %template(barray) array<ubyte>;
+}
+%include "ltiGenericMatrix.h"
+%extend lti::genericMatrix {
+    // add index support for python (Warning: this is Python-specific!) 
+	const T & __getitem__( int index )
+	{
+		return self->at(index);
+	}
+	void __setitem__( int index, const genericVector<T> & value )
+	{
+		(*self)[index] = value;
+	}
+    // TODO: check
+    // The original at()-method makes some problems! is it because of 'inline' ?
+    const T & at( int row, int col )
+    {
+        return self->at(row,col);
+    }
+    void setAt( int row, int col, const T & value )
+    {
+		(*self)[row][col] = value;
+    }
+}
+namespace lti {
+    %template(bgenericMatrix) genericMatrix<ubyte>;
+    %template(igenericMatrix) genericMatrix<int>;
+    %template(fgenericMatrix) genericMatrix<float>;
+    %template(dgenericMatrix) genericMatrix<double>;
+    %template(rgbPixelgenericMatrix) genericMatrix<rgbPixel>;
+}
+%include "ltiMatrix.h"
+namespace lti {
+    %template(imatrix) matrix<int>;
+    %template(fmatrix) matrix<float>;
+    %template(dmatrix) matrix<double>;
+    %template(bmatrix) matrix<ubyte>;
+    %template(rgbPixelmatrix) matrix<rgbPixel>;
+}
+%include "ltiHistogram.h"
+//namespace lti {
+//    %template(histogram) thistogram<double>;
+//}
+
+%include "ltiImage.h"
+%include "ltiContour.h"
+
+// has to be included AFTER the definition of borderPoints !!!
+%include "_objectsFromMask_objectStruct.h"
+#include "_objectsFromMask_objectStruct.h"
+
+// TODO: add better tree support !
+//%include "ltiTree.h"
+//namespace lti {
+//    //%template(tree_objectStruct) tree<objectsFromMask_objectStruct>;    // does not work because of a syntactical difference to tree<objectStruct>, unforunately is swig not so clever to handel that :-(
+//    %template(tree_objectStruct) tree<objectStruct>;    
+//}
+////#define node tree_objectStruct_node
+//%include "_tree_node.h"
+
+%include "ltiLinearKernels.h"
+namespace lti {
+    %template(ikernel1D) kernel1D<int>;
+    %template(fkernel1D) kernel1D<float>;
+    %template(dkernel1D) kernel1D<double>;
+    %template(bkernel1D) kernel1D<ubyte>;
+    %template(ikernel2D) kernel2D<int>;
+    %template(fkernel2D) kernel2D<float>;
+    %template(dkernel2D) kernel2D<double>;
+    %template(bkernel2D) kernel2D<ubyte>;
+    %template(isepKernel) sepKernel<int>;
+    %template(fsepKernel) sepKernel<float>;
+    %template(dsepKernel) sepKernel<double>;
+    %template(usepKernel) sepKernel<ubyte>;
+}
+%include "ltiGradientKernels.h"
+namespace lti {
+    // TODO %template(igradientKernelX) gradientKernelX<int>;
+}
+%include "ltiHessianKernels.h"
+%include "ltiLaplacianKernel.h"
+%include "ltiSecondDerivativeKernels.h"
+namespace lti {
+    %template(iandoKernelXX) andoKernelXX<int>;
+    %template(iandoKernelXY) andoKernelXY<int>;
+    %template(iandoKernelYY) andoKernelYY<int>;
+    %template(fandoKernelXX) andoKernelXX<float>;
+    %template(fandoKernelXY) andoKernelXY<float>;
+    %template(fandoKernelYY) andoKernelYY<float>;
+}
+
+// TODO: ok: mit SWIG 1.3.21 !!! und SWIG 1.3.24 + VC7
+%template(list_ioPoints) std::list<lti::ioPoints>;
+%template(list_borderPoints) std::list<lti::borderPoints>;
+%template(list_areaPoints) std::list<lti::areaPoints>;
+
+// parameters in functor (eindeutig) umbenennen
+#define parameters functor_parameters
+%include "_functor_parameters.h"
+%include "ltiFunctor.h"
+#undef parameters
+
+#define parameters modifier_parameters
+%include "_modifier_parameters.h"
+%include "ltiModifier.h"
+#undef parameters
+
+#define parameters filter_parameters
+%include "_filter_parameters.h"
+%include "ltiFilter.h"
+#undef parameters
+
+#define parameters ioFunctor_parameters
+%include "_ioFunctor_parameters.h"
+%include "ltiIOFunctor.h"
+#undef parameters
+
+#define parameters ioBMP_parameters
+%include "_ioBMP_parameters.h"
+%include "ltiBMPFunctor.h"
+#undef parameters
+
+#define parameters ioJPEG_parameters
+%include "_ioJPEG_parameters.h"
+%include "ltiJPEGFunctor.h"
+#undef parameters
+
+#define parameters ioPNG_parameters
+%include "_ioPNG_parameters.h"
+%include "ltiPNGFunctor.h"
+#undef parameters
+
+#define parameters ioImage_parameters
+%include "_ioImage_parameters.h"
+%include "ltiALLFunctor.h"
+#undef parameters
+
+#define parameters viewerBase_parameters
+%include "_viewerBase_parameters.h"
+%include "ltiViewerBase.h"
+#undef parameters
+
+#define parameters externViewer_parameters
+%include "_externViewer_parameters.h"
+%include "ltiExternViewer.h"
+#undef parameters
+
+%include "ltiSplitImage.h"
+%include "ltiSplitImageTorgI.h"
+
+#define parameters usePalette_parameters
+%include "_usePalette_parameters.h"
+%include "ltiUsePalette.h"
+#undef parameters
+
+#define parameters transform_parameters
+%include "_transform_parameters.h"
+%include "ltiTransform.h"
+#undef parameters
+
+#define parameters gradientFunctor_parameters
+%include "_gradientFunctor_parameters.h"
+%include "ltiGradientFunctor.h"
+#undef parameters
+
+#define parameters colorContrastGradient_parameters
+%include "_colorContrastGradient_parameters.h"
+%include "ltiColorContrastGradient.h"
+#undef parameters
+
+#define parameters edgeDetector_parameters
+%include "_edgeDetector_parameters.h"
+%include "ltiEdgeDetector.h"
+#undef parameters
+
+#define parameters classicEdgeDetector_parameters
+%include "_classicEdgeDetector_parameters.h"
+%include "ltiClassicEdgeDetector.h"
+#undef parameters
+
+#define parameters cannyEdges_parameters
+%include "_cannyEdges_parameters.h"
+%include "ltiCannyEdges.h"
+#undef parameters
+
+// TODO: problems with private class accumulator !!! --> can we solve this with generated header file out of the XML-output ?
+#define parameters convolution_parameters
+%include "_convolution_parameters.h"
+%include "ltiConvolution.h"
+#undef parameters
+
+#define parameters segmentation_parameters
+%include "_segmentation_parameters.h"
+%include "ltiSegmentation.h"
+#undef parameters
+
+#define parameters regionGrowing_parameters
+%include "_regionGrowing_parameters.h"
+%include "ltiRegionGrowing.h"
+#undef parameters
+
+////#define objectStruct objectsFromMask_objectStruct
+//%include "_objectsFromMask_objectStruct.h"
+////%include "ltiObjectsFromMask.h"
+////#undef objectStruct
+
+#define parameters objectsFromMask_parameters
+%include "_objectsFromMask_parameters.h"
+%include "ltiObjectsFromMask.h"
+#undef parameters
+
+#define parameters polygonApproximation_parameters
+%include "_polygonApproximation_parameters.h"
+%include "ltiPolygonApproximation.h"
+#undef parameters
+
+#define parameters colorQuantization_parameters
+%include "_colorQuantization_parameters.h"
+%include "ltiColorQuantization.h"
+#undef parameters
+
+#define parameters kMColorQuantization_parameters
+%include "_kMColorQuantization_parameters.h"
+%include "ltiKMColorQuantization.h"
+#undef parameters
+
+#define parameters meanShiftSegmentation_parameters
+%include "_meanShiftSegmentation_parameters.h"
+%include "ltiMeanShiftSegmentation.h"
+#undef parameters
+
+#define parameters kMeansSegmentation_parameters
+%include "_kMeansSegmentation_parameters.h"
+%include "ltiKMeansSegmentation.h"
+#undef parameters
+
+%extend lti::_kMeansSegmentation::_kMeansSegmentation_parameters {
+// TODO: is there a better way to support complex attributes ?
+// a helper method to set complex attributes of a parameters-class
+void setQuantParameters(const lti::_kMColorQuantization::kMColorQuantization_parameters & value) 
+{
+    self->quantParameters = value;
+} 
+};
+
+#define parameters whiteningSegmentation_parameters
+%include "_whiteningSegmentation_parameters.h"
+%include "ltiWhiteningSegmentation.h"
+#undef parameters
+
+#define parameters csPresegmentation_parameters
+%include "_csPresegmentation_parameters.h"
+%include "ltiCsPresegmentation.h"
+#undef parameters
+
+#define parameters featureExtractor_parameters
+%include "_featureExtractor_parameters.h"
+%include "ltiFeatureExtractor.h"
+#undef parameters
+
+#define parameters globalFeatureExtractor_parameters
+%include "_globalFeatureExtractor_parameters.h"
+%include "ltiGlobalFeatureExtractor.h"
+#undef parameters
+
+#define parameters localFeatureExtractor_parameters
+%include "_localFeatureExtractor_parameters.h"
+%include "ltiLocalFeatureExtractor.h"
+#undef parameters
+
+#define parameters localMoments_parameters
+%include "_localMoments_parameters.h"
+%include "ltiLocalMoments.h"
+#undef parameters
+
+#define parameters geometricFeatures_parameters
+%include "_geometricFeatures_parameters.h"
+%include "ltiGeometricFeatures.h"
+#undef parameters
+
+#define parameters chromaticityHistogram_parameters
+%include "_chromaticityHistogram_parameters.h"
+%include "ltiChromaticityHistogram.h"
+#undef parameters
+
+#define parameters morphology_parameters
+%include "_morphology_parameters.h"
+%include "ltiMorphology.h"
+#undef parameters
+
+#define parameters dilation_parameters
+%include "_dilation_parameters.h"
+%include "ltiDilation.h"
+#undef parameters
+
+#define parameters erosion_parameters
+%include "_erosion_parameters.h"
+%include "ltiErosion.h"
+#undef parameters
+
+#define parameters distanceTransform_parameters
+%rename (distanceTransform_sedMask) lti::distanceTransform::sedMask;
+%include "_distanceTransform_parameters.h"
+%include "ltiDistanceTransform.h"
+#undef parameters
+
+#define parameters skeleton_parameters
+%include "_skeleton_parameters.h"
+%include "ltiSkeleton.h"
+#undef parameters
+
+#define parameters classifier_parameters
+#define outputTemplate classifier_outputTemplate
+#define outputVector classifier_outputVector
+%include "_classifier_outputVector.h"
+%include "_classifier_outputTemplate.h"
+%include "_classifier_parameters.h"
+%include "ltiClassifier.h"
+#undef parameters
+
+#define parameters supervisedInstanceClassifier_parameters
+//%include "_supervisedInstanceClassifier_parameters.h"
+%include "ltiSupervisedInstanceClassifier.h"
+#undef parameters
+
+//#define parameters decisionTree_parameters
+//%include "_decisionTree_parameters.h"
+//%include "ltiDecisionTree.h"
+//#undef parameters
+
+%include "ltiSplitImageToHSI.h"
+%extend lti::splitImageToHSI {
+    // transfer the HSI value as a rgbPixel (TODO: maybe better as a Python tuple? How?)
+    lti::rgbPixel apply( const rgbPixel &pixel )
+    {
+        ubyte H, S, I;
+        self->apply( pixel, H, S, I );
+        return lti::rgbPixel( H, S, I );
+    }
+/* TODO --> does not work !
+    int[3] apply( const rgbPixel &pixel )
+    {
+        int ret[3];
+        ubyte H, S, I;
+        self->apply( pixel, H, S, I );
+        ret[0] = H;
+        ret[1] = S;
+        ret[2] = I;
+        return ret;
+    }
+*/    
+}
+%include "ltiSplitImageToHSV.h"
+%include "ltiSplitImageToHLS.h"
+%include "ltiSplitImageToRGB.h"
+%include "ltiSplitImageToYUV.h"
+
+// **************************************************************************
+
+%include "lti_manual.h"
+
+