bug fixes

baselib/ColorSpace.cpp

@@ -1,4 +1,4 @@
-/** 
+/**
  * @file ColorSpace.cpp
  * @brief __DESC__
  * @author Michael Koch
@@ -20,153 +20,152 @@ using namespace std;
 using namespace NICE;
 
 //bad position for this function
-void ColorSpace::ColorImagetoMultiChannelImage(const NICE::ColorImage &imgrgb,NICE::MultiChannelImageT<double> &genimg)
+void ColorSpace::ColorImagetoMultiChannelImage(  const NICE::ColorImage &imgrgb, NICE::MultiChannelImageT<double> &genimg )
 {
-     genimg.reInit(imgrgb.width(),imgrgb.height(),3,true);
-     for(int y=0;y<imgrgb.height();y++)
-     {
-          for(int x=0;x<imgrgb.width();x++)
-          {
-               double r,g,b;
-               r=imgrgb.getPixelQuick(x,y,0);
-               g=imgrgb.getPixelQuick(x,y,1);
-               b=imgrgb.getPixelQuick(x,y,2);
-               genimg.set(x,y,r,0);
-               genimg.set(x,y,g,1);
-               genimg.set(x,y,b,2);
-          }
-     }
+  genimg.reInit( imgrgb.width(), imgrgb.height(), 3, true );
+  for ( int y = 0;y < imgrgb.height();y++ )
+  {
+    for ( int x = 0;x < imgrgb.width();x++ )
+    {
+      double r, g, b;
+      r = imgrgb.getPixelQuick( x, y, 0 );
+      g = imgrgb.getPixelQuick( x, y, 1 );
+      b = imgrgb.getPixelQuick( x, y, 2 );
+      genimg.set( x, y, r, 0 );
+      genimg.set( x, y, g, 1 );
+      genimg.set( x, y, b, 2 );
+    }
+  }
 }
 
-/*
+
 //TODO test it
-int checkRange(int in,int min=0,int max=255)
+int checkRange( int in, int min = 0, int max = 255 )
 {
-     int out=in;
-     
-     if(in<min)
-     {
-          out=min;
-     }
-     if(in>max)
-     {
-          out=max;
-     }
-     return out;
+  int out = in;
+
+  if ( in < min )
+  {
+    out = min;
+  }
+  if ( in > max )
+  {
+    out = max;
+  }
+  return out;
 }
 
-NICE::ColorImage ColorSpace::rgbtohsl(const NICE::ColorImage &imgrgb)
+NICE::MultiChannelImageT<double> ColorSpace::rgbtohsl( const NICE::MultiChannelImageT<double> &imgrgb )
 {
-     NICE::ColorImage imghsl (imgrgb.width(), imgrgb.height());
-
-     for(int x=0;x<imgrgb.width();x++)
-     {
-          for(int y=0;y<imgrgb.height();y++)
-          {
-               double R,G,B,H,S,L;
-
-               R=(double)imgrgb.getPixel(x,y,0)/255.0;
-               G=(double)imgrgb.getPixel(x,y,1)/255.0;
-               B=(double)imgrgb.getPixel(x,y,2)/255.0;
-               ColorConversion::ccRGBtoHSL(R,G,B,&H,&S,&L);
-               imghsl.setPixel(x,y,0,(int)round(H*255.0));
-               imghsl.setPixel(x,y,1,(int)round(S*255.0));
-               imghsl.setPixel(x,y,2,(int)round(L*255.0));
-          }
-     }     
-     return imghsl;
+  NICE::MultiChannelImageT<double> imghsl( imgrgb.width(), imgrgb.height(), 3 );
+
+  for ( int x = 0;x < imgrgb.width();x++ )
+  {
+    for ( int y = 0;y < imgrgb.height();y++ )
+    {
+      double R, G, B, H, S, L;
+
+      R = ( double )imgrgb.get( x, y, 0 );
+      G = ( double )imgrgb.get( x, y, 1 );
+      B = ( double )imgrgb.get( x, y, 2 );
+      ColorConversion::ccRGBtoHSL( R, G, B, &H, &S, &L );
+      imghsl.set( x, y, H, 0 );
+      imghsl.set( x, y, S, 1 );
+      imghsl.set( x, y, L, 2 );
+    }
+  }
+  return imghsl;
 }
 
-NICE::ColorImage ColorSpace::hsltorgb(const NICE::ColorImage &imghsl)
+NICE::MultiChannelImageT<double> ColorSpace::hsltorgb( const NICE::MultiChannelImageT<double> &imghsl )
 {
-     NICE::ColorImage imgrgb (imghsl.width(), imghsl.height());
-
-     for(int x=0;x<imghsl.width();x++)
-     {
-          for(int y=0;y<imghsl.height();y++)
-          {
-               double R,G,B,H,S,L;
-               H=(double)imghsl.getPixel(x,y,0)/255.0;
-               S=(double)imghsl.getPixel(x,y,1)/255.0;
-               L=(double)imghsl.getPixel(x,y,2)/255.0;
-             
-               ColorConversion::ccHSLtoRGB(H,S,L,&R,&G,&B);
-
-               imgrgb.setPixel(x,y,0,(int)round(R*255.0));
-
-               imgrgb.setPixel(x,y,1,(int)round(G*255.0));
-
-               imgrgb.setPixel(x,y,2,(int)round(B*255.0));
-          }
-     }     
-     return imgrgb;
+  NICE::MultiChannelImageT<double> imgrgb( imghsl.width(), imghsl.height(), 3 );
+
+  for ( int x = 0;x < imghsl.width();x++ )
+  {
+    for ( int y = 0;y < imghsl.height();y++ )
+    {
+      double R, G, B, H, S, L;
+      H = ( double )imghsl.get( x, y, 0 );
+      S = ( double )imghsl.get( x, y, 1 );
+      L = ( double )imghsl.get( x, y, 2 );
+
+      ColorConversion::ccHSLtoRGB( H, S, L, &R, &G, &B );
+
+      imgrgb.set( x, y, ( int )round( R*255.0 ), 0 );
+      imgrgb.set( x, y, ( int )round( G*255.0 ), 1 );
+      imgrgb.set( x, y, ( int )round( B*255.0 ), 2 );
+    }
+  }
+  return imgrgb;
 }
-        
-NICE::ColorImage ColorSpace::rgbtolab(const NICE::ColorImage &imgrgb)
+
+NICE::MultiChannelImageT<double> ColorSpace::rgbtolab( const NICE::MultiChannelImageT<double> &imgrgb )
 {
-     NICE::ColorImage imglab (imgrgb.width(), imgrgb.height());
-     //preprocessing RGB to XYZ
-     for(int x=0;x<imgrgb.width();x++)
-     {
-          for(int y=0;y<imgrgb.height();y++)
-          {
-               double R,G,B,X,Y,Z,L,a,b;
-               R=(double)imgrgb.getPixel(x,y,0)/255.0;
-               G=(double)imgrgb.getPixel(x,y,1)/255.0;
-               B=(double)imgrgb.getPixel(x,y,2)/255.0;
-               ColorConversion::ccRGBtoXYZ(R,G,B,&X,&Y,&Z,0);
-               ColorConversion::ccXYZtoCIE_Lab(X,Y,Z,&L,&a,&b,0);
-               imglab.setPixel(x,y,0,(int)round(L*255.0));
-               imglab.setPixel(x,y,1,(int)round(a*255.0));
-               imglab.setPixel(x,y,2,(int)round(b*255.0));
-          }
-     }     
-	 showImage ( *imglab.getChannel(0), "L" );
-     return imglab;
+  NICE::MultiChannelImageT<double> imglab( imgrgb.width(), imgrgb.height(), 3 );
+  //preprocessing RGB to XYZ
+  for ( int x = 0;x < imgrgb.width();x++ )
+  {
+    for ( int y = 0;y < imgrgb.height();y++ )
+    {
+      double R, G, B, X, Y, Z, L, a, b;
+      R = ( double )imgrgb.get( x, y, 0 ) / 255.0;
+      G = ( double )imgrgb.get( x, y, 1 ) / 255.0;
+      B = ( double )imgrgb.get( x, y, 2 ) / 255.0;
+      
+      ColorConversion::ccRGBtoXYZ( R, G, B, &X, &Y, &Z, 0 );
+      ColorConversion::ccXYZtoCIE_Lab( X, Y, Z, &L, &a, &b, 0 );
+      
+      imglab.set( x, y, L, 0 );
+      imglab.set( x, y, a, 1 );
+      imglab.set( x, y, b, 2 );
+    }
+  }
+  return imglab;
 }
 
-NICE::ColorImage ColorSpace::labtorgb(const NICE::ColorImage &imglab)
+NICE::MultiChannelImageT<double> ColorSpace::labtorgb( const NICE::MultiChannelImageT<double> &imglab )
 {
-     NICE::ColorImage imgrgb (imglab.width(), imglab.height());
-     //preprocessing RGB to XYZ
-     for(int x=0;x<imglab.width();x++)
-     {
-          for(int y=0;y<imglab.height();y++)
-          {
-               double R,G,B,X,Y,Z,L,a,b;
-               L=(double)imglab.getPixel(x,y,0)/255.0;
-               a=(double)imglab.getPixel(x,y,1)/255.0;
-               b=(double)imglab.getPixel(x,y,2)/255.0;
-               
-               ColorConversion::ccCIE_LabtoXYZ(L,a,b,&X,&Y,&Z,0);
-               ColorConversion::ccXYZtoRGB(X,Y,Z,&R,&G,&B,0);
-               imgrgb.setPixel(x,y,0,(int)round(R*255.0));
-               imgrgb.setPixel(x,y,1,(int)round(G*255.0));
-               imgrgb.setPixel(x,y,2,(int)round(B*255.0));
-          }
-     }     
-     return imgrgb;
+  NICE::MultiChannelImageT<double> imgrgb( imglab.width(), imglab.height(), 3 );
+  //preprocessing RGB to XYZ
+  for ( int x = 0;x < imglab.width();x++ )
+  {
+    for ( int y = 0;y < imglab.height();y++ )
+    {
+      double R, G, B, X, Y, Z, L, a, b;
+      L = imglab.get( x, y, 0 );
+      a = imglab.get( x, y, 1 );
+      b = imglab.get( x, y, 2 );
+
+      ColorConversion::ccCIE_LabtoXYZ( L, a, b, &X, &Y, &Z, 0 );
+      ColorConversion::ccXYZtoRGB( X, Y, Z, &R, &G, &B, 0 );
+      imgrgb.set( x, y, round( R*255.0 ), 0 );
+      imgrgb.set( x, y, round( G*255.0 ), 1 );
+      imgrgb.set( x, y, round( B*255.0 ), 2 );
+    }
+  }
+  return imgrgb;
 }
-NICE::ColorImage ColorSpace::rgbtolms(const NICE::ColorImage &imgrgb)
-{
-     NICE::ColorImage imglms=NICE::ColorImage(imgrgb.width(),imgrgb.height());
-     //preprocessing RGB to XYZ
-     for(int x=0;x<imgrgb.width();x++)
-     {
-          for(int y=0;y<imgrgb.height();y++)
-          {
-               double R,G,B,X,Y,Z,L,M,S;
-               R=(double)imgrgb.getPixelQuick(x,y,0)/255.0;
-               G=(double)imgrgb.getPixelQuick(x,y,1)/255.0;
-               B=(double)imgrgb.getPixelQuick(x,y,2)/255.0;
-               
-               ColorConversion::ccRGBtoXYZ(R,G,B,&X,&Y,&Z,0);
-               ColorConversion::ccXYZtoLMS(X,Y,Z,&L,&M,&S);
-               imglms.setPixelQuick(x,y,0,checkRange((int)round(L*255.0)));
-               imglms.setPixelQuick(x,y,1,checkRange((int)round(M*255.0)));
-               imglms.setPixelQuick(x,y,2,checkRange((int)round(S*255.0)));
-          }
-     }     
-     return imglms;
-}*/
 
+NICE::MultiChannelImageT<double> ColorSpace::rgbtolms( const NICE::MultiChannelImageT<double> &imgrgb )
+{
+  NICE::MultiChannelImageT<double> imglms = NICE::MultiChannelImageT<double>( imgrgb.width(), imgrgb.height() );
+  //preprocessing RGB to XYZ
+  for ( int x = 0;x < imgrgb.width();x++ )
+  {
+    for ( int y = 0;y < imgrgb.height();y++ )
+    {
+      double R, G, B, X, Y, Z, L, M, S;
+      R = imgrgb.get( x, y, 0 ) / 255.0;
+      G = imgrgb.get( x, y, 1 ) / 255.0;
+      B = imgrgb.get( x, y, 2 ) / 255.0;
+
+      ColorConversion::ccRGBtoXYZ( R, G, B, &X, &Y, &Z, 0 );
+      ColorConversion::ccXYZtoLMS( X, Y, Z, &L, &M, &S );
+      imglms.set( x, y, L, 0 );
+      imglms.set( x, y, M, 1 );
+      imglms.set( x, y, S, 2 );
+    }
+  }
+  return imglms;
+}

baselib/ColorSpace.h

@@ -1,4 +1,4 @@
-/** 
+/**
 * @file ColorSpace.h
 * @brief color space conversion routines
 * @author Michael Koch
@@ -22,44 +22,41 @@ namespace OBJREC {
 class ColorSpace
 {
 
-    protected:
-
-    public:
-	enum {
-	    COLORSPACE_RGB = 0,
-	    COLORSPACE_HSL,
-	    COLORSPACE_LAB,
-        COLORSPACE_LMS,
-        COLORSPACE_OPP,
-	    NUM_COLORSPACES
-	};
+protected:
+
+public:
+  enum {
+    COLORSPACE_RGB = 0,
+    COLORSPACE_HSL,
+    COLORSPACE_LAB,
+    COLORSPACE_LMS,
+    COLORSPACE_OPP,
+    NUM_COLORSPACES
+  };
 //bad position choose better one
-    static void ColorImagetoMultiChannelImage(const NICE::ColorImage &imgrgb,NICE::MultiChannelImageT<double> &genimg);
-    
-#if 0	//entfernt, da Probleme mit Wertebereich, bitte GenericImage und generisches convert benutzen
-         /** convert RGB to hsl*/
-        static NICE::ColorImage rgbtohsl(const NICE::ColorImage &imgrgb);
-        /** convert hsl to RGB*/
-        static NICE::ColorImage hsltorgb(const NICE::ColorImage &imghsl);
-        
-        /** convert RGB to LAB*/
-        static NICE::ColorImage rgbtolab(const NICE::ColorImage &imgrgb);
-        
-        /** convert LAB to RGB*/
-        static NICE::ColorImage labtorgb(const NICE::ColorImage &imglab);
-        
-        /** convert RGB to LMS*/
-        
-        static NICE::ColorImage rgbtolms(const NICE::ColorImage &imgrgb);*/
-#endif
+  static void ColorImagetoMultiChannelImage( const NICE::ColorImage &imgrgb, NICE::MultiChannelImageT<double> &genimg );
+
+  /** convert RGB to hsl*/
+  static NICE::MultiChannelImageT<double> rgbtohsl( const NICE::MultiChannelImageT<double> &imgrgb );
+  /** convert hsl to RGB*/
+  static NICE::MultiChannelImageT<double> hsltorgb( const NICE::MultiChannelImageT<double> &imghsl );
+
+  /** convert RGB to LAB*/
+  static NICE::MultiChannelImageT<double> rgbtolab( const NICE::MultiChannelImageT<double> &imgrgb );
+
+  /** convert LAB to RGB*/
+  static NICE::MultiChannelImageT<double> labtorgb( const NICE::MultiChannelImageT<double> &imglab );
+
+  /** convert RGB to LMS*/
+  static NICE::MultiChannelImageT<double> rgbtolms( const NICE::MultiChannelImageT<double> &imgrgb );
 
-	template<class SrcPixelType,class DstPixelType>
-	static void convert ( NICE::MultiChannelImageT<DstPixelType> & dst, 
-			      const NICE::MultiChannelImageT<SrcPixelType> & src,
-			      int dstColorSpace = COLORSPACE_HSL, 
-			      int srcColorSpace = COLORSPACE_RGB,
-			      double dstM = 255.0,
-			      double srcM = 255.0);
+  template<class SrcPixelType, class DstPixelType>
+  static void convert( NICE::MultiChannelImageT<DstPixelType> & dst,
+                       const NICE::MultiChannelImageT<SrcPixelType> & src,
+                       int dstColorSpace = COLORSPACE_HSL,
+                       int srcColorSpace = COLORSPACE_RGB,
+                       double dstM = 255.0,
+                       double srcM = 255.0 );
 };
 
 } // namespace

features/fpfeatures/HaarFeature.cpp

@@ -1,4 +1,4 @@
-/** 
+/**
 * @file HaarFeature.cpp
 * @brief simple haar like feature
 * @author Erik Rodner
@@ -16,69 +16,69 @@ using namespace std;
 using namespace NICE;
 
 
-void HaarFeature::explode ( FeaturePool & featurePool, bool variableWindow ) const
+void HaarFeature::explode( FeaturePool & featurePool, bool variableWindow ) const
 {
-    HaarFeature *hf = new HaarFeature ( *this );
-
-    hf->pos1 = 0;
-    hf->pos2 = 0;
-    hf->type = HAARTYPE_HORIZONTAL;  
-    for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_y - 1 ; hf->pos1 += hf->step_y )
-	featurePool.addFeature ( hf->clone(), hf->step_y / (double)( HAARTYPE_NUMTYPES * hf->window_size_y ) );
-
-    hf->pos1 = 0;
-    hf->pos2 = 0;
-    hf->type = HAARTYPE_VERTICAL;
-    for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_x - 1; hf->pos1 += hf->step_x )
-	featurePool.addFeature ( hf->clone(), hf->step_x / (double)( HAARTYPE_NUMTYPES * hf->window_size_x ) );
-
-    hf->type = HAARTYPE_DIAGONAL;
-    hf->pos1 = 0;
-    hf->pos2 = 0;
-    for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_x - 1; hf->pos1 += hf->step_x )
-	for ( hf->pos2 = 0 ; hf->pos2 < hf->window_size_y - 1 ; hf->pos2 += hf->step_y )
-	    featurePool.addFeature ( hf->clone(), 
-		hf->step_x * hf->step_y / (double)( HAARTYPE_NUMTYPES * hf->window_size_x * hf->window_size_y ) );
-
-    hf->pos1 = 0;
-    hf->pos2 = 0;
-    hf->type = HAARTYPE_3BLOCKS;
-    for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_x - 2*hf->step_x ; hf->pos1 += hf->step_x )
-	for ( hf->pos2 = hf->pos1 + hf->step_x; hf->pos2 < hf->window_size_x - hf->step_x ; hf->pos2 += hf->step_x )
-	    featurePool.addFeature ( hf->clone(), 
-		(2.0 * hf->step_x) / ( HAARTYPE_NUMTYPES * (hf->window_size_x - hf->step_x) ) 	);
-
-    delete hf;
+  HaarFeature *hf = new HaarFeature( *this );
+
+  hf->pos1 = 0;
+  hf->pos2 = 0;
+  hf->type = HAARTYPE_HORIZONTAL;
+  for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_y - 1 ; hf->pos1 += hf->step_y )
+    featurePool.addFeature( hf->clone(), hf->step_y / ( double )( HAARTYPE_NUMTYPES * hf->window_size_y ) );
+
+  hf->pos1 = 0;
+  hf->pos2 = 0;
+  hf->type = HAARTYPE_VERTICAL;
+  for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_x - 1; hf->pos1 += hf->step_x )
+    featurePool.addFeature( hf->clone(), hf->step_x / ( double )( HAARTYPE_NUMTYPES * hf->window_size_x ) );
+
+  hf->type = HAARTYPE_DIAGONAL;
+  hf->pos1 = 0;
+  hf->pos2 = 0;
+  for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_x - 1; hf->pos1 += hf->step_x )
+    for ( hf->pos2 = 0 ; hf->pos2 < hf->window_size_y - 1 ; hf->pos2 += hf->step_y )
+      featurePool.addFeature( hf->clone(),
+                              hf->step_x * hf->step_y / ( double )( HAARTYPE_NUMTYPES * hf->window_size_x * hf->window_size_y ) );
+
+  hf->pos1 = 0;
+  hf->pos2 = 0;
+  hf->type = HAARTYPE_3BLOCKS;
+  for ( hf->pos1 = 0 ; hf->pos1 < hf->window_size_x - 2*hf->step_x ; hf->pos1 += hf->step_x )
+    for ( hf->pos2 = hf->pos1 + hf->step_x; hf->pos2 < hf->window_size_x - hf->step_x ; hf->pos2 += hf->step_x )
+      featurePool.addFeature( hf->clone(),
+                              ( 2.0 * hf->step_x ) / ( HAARTYPE_NUMTYPES * ( hf->window_size_x - hf->step_x ) ) );
+
+  delete hf;
 }
 
 Feature *HaarFeature::clone() const
 {
-    HaarFeature *fp =  new HaarFeature(*this);
-    return fp;
+  HaarFeature *fp =  new HaarFeature( *this );
+  return fp;
 }
 
 
 /************* HaarFeature **************/
 HaarFeature::HaarFeature( const Config *conf )
 {
-    window_size_x = conf->gI("HaarFeature", "window_size_x", 24 );
-    window_size_y = conf->gI("HaarFeature", "window_size_y", 24 );
-    step_x = conf->gI("HaarFeature", "step_x", 1 );
-    step_y = conf->gI("HaarFeature", "step_y", 1 );
+  window_size_x = conf->gI( "HaarFeature", "window_size_x", 24 );
+  window_size_y = conf->gI( "HaarFeature", "window_size_y", 24 );
+  step_x = conf->gI( "HaarFeature", "step_x", 1 );
+  step_y = conf->gI( "HaarFeature", "step_y", 1 );
 }
 
-HaarFeature::HaarFeature ( int _window_size_x,	
-			   int _window_size_y,
-			   int _step_x,
-			   int _step_y )
+HaarFeature::HaarFeature( int _window_size_x,
+                          int _window_size_y,
+                          int _step_x,
+                          int _step_y )
 {
-    window_size_x = _window_size_x;
-    window_size_y = _window_size_y;
-    pos1 = 1;
-    pos2 = 0;
-    step_x = _step_x;
-    step_y = _step_y;
-    type = HaarFeature::HAARTYPE_HORIZONTAL;
+  window_size_x = _window_size_x;
+  window_size_y = _window_size_y;
+  pos1 = 1;
+  pos2 = 0;
+  step_x = _step_x;
+  step_y = _step_y;
+  type = HaarFeature::HAARTYPE_HORIZONTAL;
 }
 
 HaarFeature::~HaarFeature()
@@ -87,134 +87,134 @@ HaarFeature::~HaarFeature()
 
 double HaarFeature::val( const Example *example ) const
 {
-    const NICE::MultiChannelImageT<long> & img = example->ce->getLChannel ( CachedExample::L_INTEGRALIMAGE ); 
-
-    const long *integralImage = img.data[0];
-    int xsize = img.xsize;
-    int ysize = img.ysize;
-
-    int x = example->x;
-    int y = example->y;
-    long tl, tr, bl, br;
-
-    int exwidth = example->width;
-    if ( exwidth != 0 ) 
-    {
-	int exheight = example->height;
-	tl = (x - exwidth/2) + (y - exheight/2)*xsize;
-	tr = tl + exwidth - 1;
-	bl = tl + (exheight - 1)*xsize;
-	br = bl + exwidth - 1;
-    } else {
-	tl = (x - window_size_x/2) + (y - window_size_y/2)*xsize;
-	tr = tl + window_size_x - 1;
-	bl = tl + (window_size_y - 1)*xsize;
-	br = bl + (window_size_x - 1);
-    }
-
-    assert ( tl < xsize*ysize );
-    assert ( tr < xsize*ysize );
-    if ( br >= xsize*ysize ) 
-    {
-	fprintf (stderr, "xsize=%d, ysize=%d, x=%d, y=%d, wsy=%d, wsx=%d\n",
-		xsize, ysize, x, y, window_size_x, window_size_y );
-	fprintf (stderr, "example: %d x %d\n",
-		example->width, example->height );
-
-    }
-    assert ( bl < xsize*ysize );
-    assert ( br < xsize*ysize );
-    assert ( pos1 >= 0 );
-    assert ( pos2 >= 0 );
-
-    double value;
-    if ( type == HaarFeature::HAARTYPE_HORIZONTAL )
-    {
-	long ml = tl + xsize*pos1;
-	long mr = tr + xsize*pos1;
-	assert ( (ml >= 0) && (ml < xsize*ysize) );
-	assert ( (mr >= 0) && (mr < xsize*ysize) );
-	value = 2*integralImage[mr];
-	value -= 2*integralImage[ml];
-	value +=   integralImage[tl];
-	value +=   integralImage[tr];
-	value -=   integralImage[bl];
-	value -=   integralImage[br];
-    } else if ( type == HaarFeature::HAARTYPE_VERTICAL ) {
-	long mt = tl + pos1;
-	long mb = bl + pos1;
-	assert ( (mt >= 0) && (mt < xsize*ysize) );
-	assert ( (mb >= 0) && (mb < xsize*ysize) );
-
-	value = 2*integralImage[mb];
-	value -= 2*integralImage[mt];
-	value +=   integralImage[tl];
-	value +=   integralImage[tr];
-	value -=   integralImage[bl];
-	value -=   integralImage[br];
-    } else if ( type == HaarFeature::HAARTYPE_DIAGONAL ) {
-	int p2o = pos2*xsize;
-	assert ( (p2o >= 0) && (p2o < xsize*ysize) );
-	assert ( (tl+pos1 >= 0) && (tl+pos1 < xsize*ysize) );
-	assert ( (tl+p2o >= 0) && (tl+p2o < xsize*ysize) );
-	assert ( (bl+pos1 >= 0) && (bl+pos1 < xsize*ysize) );
-	assert ( (tr+p2o >= 0) && (tr+p2o < xsize*ysize) );
-	assert ( (tl+pos1+p2o >= 0) && (tl+pos1+p2o < xsize*ysize) );
-
-	value = integralImage[tl];
-	value += integralImage[bl];
-	value += integralImage[br];
-	value += integralImage[tr];
-	value -= 2 * ( 
-		  integralImage[tl+pos1]
-		+ integralImage[tl+p2o]
-		+ integralImage[bl+pos1]
-		+ integralImage[tr+p2o]
-	     );
-	value += 4 * integralImage[tl + pos1 + p2o];
-
-    } else if ( type == HaarFeature::HAARTYPE_3BLOCKS ) {
-	assert ( (tl+pos1 >= 0) && (tl+pos1 < xsize*ysize) );
-	assert ( (bl+pos2 >= 0) && (bl+pos2 < xsize*ysize) );
-	assert ( (tl+pos2 >= 0) && (tl+pos2 < xsize*ysize) );
-	assert ( (bl+pos1 >= 0) && (bl+pos1 < xsize*ysize) );
-	value = integralImage[tl];
-	value +=  integralImage[br];
-	value -=  integralImage[bl];
-	value -=  integralImage[tr];
-	value += 2 * (
-		- integralImage[tl+pos1]
-		- integralImage[bl+pos2]
-		+ integralImage[tl+pos2]
-		+ integralImage[bl+pos1]
-	    );
-    } else {
-	return -1;
-    }
-
-    assert ( finite(value) );
-
-    return value;
+  const NICE::MultiChannelImageT<long> & img = example->ce->getLChannel( CachedExample::L_INTEGRALIMAGE );
+
+  const long *integralImage = img.data[0];
+  int xsize = img.xsize;
+  int ysize = img.ysize;
+
+  int x = example->x;
+  int y = example->y;
+  long tl, tr, bl, br;
+
+  int exwidth = example->width;
+  if ( exwidth != 0 )
+  {
+    int exheight = example->height;
+    tl = ( x - exwidth / 2 ) + ( y - exheight / 2 ) * xsize;
+    tr = tl + exwidth - 1;
+    bl = tl + ( exheight - 1 ) * xsize;
+    br = bl + exwidth - 1;
+  } else {
+    tl = ( x - window_size_x / 2 ) + ( y - window_size_y / 2 ) * xsize;
+    tr = tl + window_size_x - 1;
+    bl = tl + ( window_size_y - 1 ) * xsize;
+    br = bl + ( window_size_x - 1 );
+  }
+
+  assert( tl < xsize*ysize );
+  assert( tr < xsize*ysize );
+  if ( br >= xsize*ysize )
+  {
+    fprintf( stderr, "xsize=%d, ysize=%d, x=%d, y=%d, wsy=%d, wsx=%d\n",
+             xsize, ysize, x, y, window_size_x, window_size_y );
+    fprintf( stderr, "example: %d x %d\n",
+             example->width, example->height );
+
+  }
+  assert( bl < xsize*ysize );
+  assert( br < xsize*ysize );
+  assert( pos1 >= 0 );
+  assert( pos2 >= 0 );
+
+  double value;
+  if ( type == HaarFeature::HAARTYPE_HORIZONTAL )
+  {
+    long ml = tl + xsize * pos1;
+    long mr = tr + xsize * pos1;
+    assert(( ml >= 0 ) && ( ml < xsize*ysize ) );
+    assert(( mr >= 0 ) && ( mr < xsize*ysize ) );
+    value = 2 * integralImage[mr];
+    value -= 2 * integralImage[ml];
+    value +=   integralImage[tl];
+    value +=   integralImage[tr];
+    value -=   integralImage[bl];
+    value -=   integralImage[br];
+  } else if ( type == HaarFeature::HAARTYPE_VERTICAL ) {
+    long mt = tl + pos1;
+    long mb = bl + pos1;
+    assert(( mt >= 0 ) && ( mt < xsize*ysize ) );
+    assert(( mb >= 0 ) && ( mb < xsize*ysize ) );
+
+    value = 2 * integralImage[mb];
+    value -= 2 * integralImage[mt];
+    value +=   integralImage[tl];
+    value +=   integralImage[tr];
+    value -=   integralImage[bl];
+    value -=   integralImage[br];
+  } else if ( type == HaarFeature::HAARTYPE_DIAGONAL ) {
+    int p2o = pos2 * xsize;
+    assert(( p2o >= 0 ) && ( p2o < xsize*ysize ) );
+    assert(( tl + pos1 >= 0 ) && ( tl + pos1 < xsize*ysize ) );
+    assert(( tl + p2o >= 0 ) && ( tl + p2o < xsize*ysize ) );
+    assert(( bl + pos1 >= 0 ) && ( bl + pos1 < xsize*ysize ) );
+    assert(( tr + p2o >= 0 ) && ( tr + p2o < xsize*ysize ) );
+    assert(( tl + pos1 + p2o >= 0 ) && ( tl + pos1 + p2o < xsize*ysize ) );
+
+    value = integralImage[tl];
+    value += integralImage[bl];
+    value += integralImage[br];
+    value += integralImage[tr];
+    value -= 2 * (
+               integralImage[tl+pos1]
+               + integralImage[tl+p2o]
+               + integralImage[bl+pos1]
+               + integralImage[tr+p2o]
+             );
+    value += 4 * integralImage[tl + pos1 + p2o];
+
+  } else if ( type == HaarFeature::HAARTYPE_3BLOCKS ) {
+    assert(( tl + pos1 >= 0 ) && ( tl + pos1 < xsize*ysize ) );
+    assert(( bl + pos2 >= 0 ) && ( bl + pos2 < xsize*ysize ) );
+    assert(( tl + pos2 >= 0 ) && ( tl + pos2 < xsize*ysize ) );
+    assert(( bl + pos1 >= 0 ) && ( bl + pos1 < xsize*ysize ) );
+    value = integralImage[tl];
+    value +=  integralImage[br];
+    value -=  integralImage[bl];
+    value -=  integralImage[tr];
+    value += 2 * (
+               - integralImage[tl+pos1]
+               - integralImage[bl+pos2]
+               + integralImage[tl+pos2]
+               + integralImage[bl+pos1]
+             );
+  } else {
+    return -1;
+  }
+
+  assert( finite( value ) );
+
+  return value;
 }
 
-void HaarFeature::restore (istream & is, int format)
+void HaarFeature::restore( istream & is, int format )
 {
-    is >> type;
-    is >> window_size_x;
-    is >> window_size_y;
-    is >> pos1;
-    is >> pos2;
+  is >> type;
+  is >> window_size_x;
+  is >> window_size_y;
+  is >> pos1;
+  is >> pos2;
 }
 
-void HaarFeature::store (ostream & os, int format) const
+void HaarFeature::store( ostream & os, int format ) const
 {
-    os << "HAARFEATURE" << " " << type << " " 
-       << window_size_x << " " << window_size_y 
-       << " " << pos1 << " " << pos2;
+  os << "HAARFEATURE" << " " << type << " "
+  << window_size_x << " " << window_size_y
+  << " " << pos1 << " " << pos2;
 }
 
-void HaarFeature::clear ()
+void HaarFeature::clear()
 {
-    // nothing to do in my opinion
+  // nothing to do in my opinion
 }
 

features/localfeatures/LFColorWeijer.cpp

@@ -1,5 +1,5 @@
 #include "vislearning/features/localfeatures/LFColorWeijer.h"
-  
+
 #include <fstream>
 #include <iostream>
 #include "vislearning/baselib/ColorSpace.h"
@@ -11,482 +11,482 @@ using namespace std;
 using namespace NICE;
 
 //! color representation for visualization
-const int colors[11][3] = 
+const int colors[11][3] =
 {
-	{0,     0,   0}, // black
-	{0,     0, 255}, // blue
-	{165,  42,  42}, // brown
-	{190, 190, 190}, // grey
-	{  0, 255,   0}, // green
-	{255, 165,   0}, // orange
-	{255, 192, 203}, // pink
-	{160,  32, 240}, // purple
-	{255,   0,   0}, // red
-	{255, 255, 255}, // white
-	{255, 255,   0}, // yellow
+  {0,     0,   0}, // black
+  {0,     0, 255}, // blue
+  {165,  42,  42}, // brown
+  {190, 190, 190}, // grey
+  {  0, 255,   0}, // green
+  {255, 165,   0}, // orange
+  {255, 192, 203}, // pink
+  {160,  32, 240}, // purple
+  {255,   0,   0}, // red
+  {255, 255, 255}, // white
+  {255, 255,   0}, // yellow
 };
 
 
-LFColorWeijer::LFColorWeijer(const Config *c)
+LFColorWeijer::LFColorWeijer( const Config *c )
 {
-	conf = c;
-	
-	bin[0] = conf->gI("LFColorWeijer", "binL", 10);
-	bin[1] = conf->gI("LFColorWeijer", "bina", 20);
-	bin[2] = conf->gI("LFColorWeijer", "binb", 20);
-
-	maxv[0] =  100.0;
-	maxv[1] =   80.0;
-	maxv[2] =   50.0;
-
-	minv[0] =    0.0;
-	minv[1] = -105.0;
-	minv[2] = -200.0;
-
-	tfile = conf->gS("LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/color.txt");
-
-	for (int i = 0; i < 3; i++)
-	{
-		interval[i] = (maxv[i] - minv[i]) / (double)bin[i];
-	}
-
-	ifstream test(tfile.c_str());
-
-	if (test)
-	{
-		restore();
-	}
-	else
-	{
-		train();
-	}
+  conf = c;
+
+  bin[0] = conf->gI( "LFColorWeijer", "binL", 10 );
+  bin[1] = conf->gI( "LFColorWeijer", "bina", 20 );
+  bin[2] = conf->gI( "LFColorWeijer", "binb", 20 );
+
+  maxv[0] =  100.0;
+  maxv[1] =   80.0;
+  maxv[2] =   50.0;
+
+  minv[0] =    0.0;
+  minv[1] = -105.0;
+  minv[2] = -200.0;
+
+  tfile = conf->gS( "LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/color.txt" );
+
+  for ( int i = 0; i < 3; i++ )
+  {
+    interval[i] = ( maxv[i] - minv[i] ) / ( double )bin[i];
+  }
+
+  ifstream test( tfile.c_str() );
+
+  if ( test )
+  {
+    restore();
+  }
+  else
+  {
+    train();
+  }
 }
 
 LFColorWeijer::~LFColorWeijer()
 {
-	for(uint i = 0; i < hist.size(); i++)
-	{
-		for(uint j = 0; j < hist[i].size(); j++)
-		{
-			hist[i][j].clear();
-		}
-		hist[i].clear();
-	}
-	hist.clear();
+  for ( uint i = 0; i < hist.size(); i++ )
+  {
+    for ( uint j = 0; j < hist[i].size(); j++ )
+    {
+      hist[i][j].clear();
+    }
+    hist[i].clear();
+  }
+  hist.clear();
 }
 
 int LFColorWeijer::getDescSize() const
 {
-	return LASTCOLOR;
+  return LASTCOLOR;
 }
 
 void LFColorWeijer::store()
 {
-	ofstream fout(tfile.c_str(), ios_base::app);
-
-	fout << hist.size() << " " << hist[0].size() << " " << hist[0][0].size() << " " << hist[0][0][0].size() << endl;
-
-	for (uint i = 0; i < hist.size(); i++)
-	{
-		for (uint i0 = 0; i0 < hist[i].size(); i0++)
-		{
-			for (uint i1 = 0; i1 < hist[i][i0].size(); i1++)
-			{
-				for (uint i2 = 0; i2 < hist[i][i0][i1].size(); i2++)
-				{
-					fout << hist[i][i0][i1][i2] << " ";
-				}
-			}
-		}
-	}
+  ofstream fout( tfile.c_str(), ios_base::app );
+
+  fout << hist.size() << " " << hist[0].size() << " " << hist[0][0].size() << " " << hist[0][0][0].size() << endl;
+
+  for ( uint i = 0; i < hist.size(); i++ )
+  {
+    for ( uint i0 = 0; i0 < hist[i].size(); i0++ )
+    {
+      for ( uint i1 = 0; i1 < hist[i][i0].size(); i1++ )
+      {
+        for ( uint i2 = 0; i2 < hist[i][i0][i1].size(); i2++ )
+        {
+          fout << hist[i][i0][i1][i2] << " ";
+        }
+      }
+    }
+  }
 }
 
 void LFColorWeijer::smooth()
 {
-	int size0 = (int)hist.size();
-	int size1 = (int)hist[0].size();
-	int size2 = (int)hist[0][0].size();
-	int size3 = (int)hist[0][0][0].size();
-	for(int i0 = 0; i0 < size1; i0++)
-	{
-		for(int i1 = 0; i1 < size2; i1++)
-		{
-			for(int i2 = 0; i2 < size3; i2++)
-			{
-				double maxval = 0.0;
-				for(int i = 0; i < size0; i++)
-				{
-					maxval = std::max(maxval, hist[i][i0][i1][i2]);
-				}
-				if(maxval == 0.0)
-				{
-					for(int i = 0; i < size0; i++)
-					{
-						int anz = 0;
-						for(int a0 = std::max(i0-1,0); a0 <= std::min(i0+1,size1-1); a0++)
-						{
-							for(int a1 = std::max(i1-1,0); a1 <= std::min(i1+1,size2-1); a1++)
-							{
-								for(int a2 = std::max(i2-1,0); a2 <= std::min(i2+1,size3-1); a2++)
-								{
-									anz++;
-									hist[i][i0][i1][i2] += hist[i][a0][a1][a2];
-								}
-							}
-						}
-						hist[i][i0][i1][i2] /= anz;
-					}
-				}
-			}
-		}
-	}
+  int size0 = ( int )hist.size();
+  int size1 = ( int )hist[0].size();
+  int size2 = ( int )hist[0][0].size();
+  int size3 = ( int )hist[0][0][0].size();
+  for ( int i0 = 0; i0 < size1; i0++ )
+  {
+    for ( int i1 = 0; i1 < size2; i1++ )
+    {
+      for ( int i2 = 0; i2 < size3; i2++ )
+      {
+        double maxval = 0.0;
+        for ( int i = 0; i < size0; i++ )
+        {
+          maxval = std::max( maxval, hist[i][i0][i1][i2] );
+        }
+        if ( maxval == 0.0 )
+        {
+          for ( int i = 0; i < size0; i++ )
+          {
+            int anz = 0;
+            for ( int a0 = std::max( i0 - 1, 0 ); a0 <= std::min( i0 + 1, size1 - 1 ); a0++ )
+            {
+              for ( int a1 = std::max( i1 - 1, 0 ); a1 <= std::min( i1 + 1, size2 - 1 ); a1++ )
+              {
+                for ( int a2 = std::max( i2 - 1, 0 ); a2 <= std::min( i2 + 1, size3 - 1 ); a2++ )
+                {
+                  anz++;
+                  hist[i][i0][i1][i2] += hist[i][a0][a1][a2];
+                }
+              }
+            }
+            hist[i][i0][i1][i2] /= anz;
+          }
+        }
+      }
+    }
+  }
 }
 
 void LFColorWeijer::restore()
 {
-	int size0, size1, size2, size3;
-	ifstream fin(tfile.c_str());
-	fin >> size0;
-	fin >> size1;
-	fin >> size2;
-	fin >> size3;
-	hist.clear();
-
-	for (int i = 0; i < size0; i++)
-	{
-		vector<vector<vector<double> > > v2;
-
-		for (int i0 = 0; i0 < size1; i0++)
-		{
-			vector<vector<double> > v1;
-
-			for (int i1 = 0; i1 < size2; i1++)
-			{
-				vector<double> v0;
-
-				for (int i2 = 0; i2 < size3; i2++)
-				{
-					double val;
-					fin >> val;
-					v0.push_back(val);
-				}
-
-				v1.push_back(v0);
-			}
-
-			v2.push_back(v1);
-		}
-
-		hist.push_back(v2);
-	}
+  int size0, size1, size2, size3;
+  ifstream fin( tfile.c_str() );
+  fin >> size0;
+  fin >> size1;
+  fin >> size2;
+  fin >> size3;
+  hist.clear();
+
+  for ( int i = 0; i < size0; i++ )
+  {
+    vector<vector<vector<double> > > v2;
+
+    for ( int i0 = 0; i0 < size1; i0++ )
+    {
+      vector<vector<double> > v1;
+
+      for ( int i1 = 0; i1 < size2; i1++ )
+      {
+        vector<double> v0;
+
+        for ( int i2 = 0; i2 < size3; i2++ )
+        {
+          double val;
+          fin >> val;
+          v0.push_back( val );
+        }
+
+        v1.push_back( v0 );
+      }
+
+      v2.push_back( v1 );
+    }
+
+    hist.push_back( v2 );
+  }
 }
 
-int LFColorWeijer::getDescriptors ( const NICE::Image & img, VVector & positions, VVector & features ) const
+int LFColorWeijer::getDescriptors( const NICE::Image & img, VVector & positions, VVector & features ) const
 {
-	cerr << "this are COLOR Features, they won't work on gray value images" << endl;
-	exit(-1);
+  cerr << "this are COLOR Features, they won't work on gray value images" << endl;
+  exit( -1 );
 }
 
-int LFColorWeijer::getDescriptors(const NICE::ColorImage & img, VVector & positions, VVector & features) const
+int LFColorWeijer::getDescriptors( const NICE::ColorImage & img, VVector & positions, VVector & features ) const
 {
-	// in Lab umwandeln
-	for (int i = 0; i < (int)positions.size(); i++)
-	{
-			vector<double> vals;
-			vector<int> b;
-			int x = positions[i][0];
-			int y = positions[i][1];
-			
-			double R,G,B,X,Y,Z;
-			vector<double> lab(3,0.0);
-			
-			R=(double)img.getPixel(x,y,0)/255.0;
-			G=(double)img.getPixel(x,y,1)/255.0;
-			B=(double)img.getPixel(x,y,2)/255.0;
-			
-			ColorConversion::ccRGBtoXYZ(R,G,B,&X,&Y,&Z,0);
-			ColorConversion::ccXYZtoCIE_Lab(X,Y,Z,&lab[0],&lab[1],&lab[2],0);
-			
-			for (int i = 0; i < 3; i++)
-			{
-				int val = (int)((lab[i] - minv[i]) / interval[i]);
-				val = std::min(val, bin[i] - 1);
-				val = std::max(val, 0);
-				b.push_back(val);
-			}
-
-			Vector feat(hist.size());
-			
-			for (uint i = 0; i < hist.size(); i++)
-			{
-				feat[i] = hist[i][b[0]][b[1]][b[2]];
-			}
-			features.push_back(feat);
-	}
-	
-	return 1;
+  // in Lab umwandeln
+  for ( int i = 0; i < ( int )positions.size(); i++ )
+  {
+    vector<double> vals;
+    vector<int> b;
+    int x = positions[i][0];
+    int y = positions[i][1];
+
+    double R, G, B, X, Y, Z;
+    vector<double> lab( 3, 0.0 );
+
+    R = ( double )img.getPixel( x, y, 0 ) / 255.0;
+    G = ( double )img.getPixel( x, y, 1 ) / 255.0;
+    B = ( double )img.getPixel( x, y, 2 ) / 255.0;
+
+    ColorConversion::ccRGBtoXYZ( R, G, B, &X, &Y, &Z, 0 );
+    ColorConversion::ccXYZtoCIE_Lab( X, Y, Z, &lab[0], &lab[1], &lab[2], 0 );
+
+    for ( int i = 0; i < 3; i++ )
+    {
+      int val = ( int )(( lab[i] - minv[i] ) / interval[i] );
+      val = std::min( val, bin[i] - 1 );
+      val = std::max( val, 0 );
+      b.push_back( val );
+    }
+
+    Vector feat( hist.size() );
+
+    for ( uint i = 0; i < hist.size(); i++ )
+    {
+      feat[i] = hist[i][b[0]][b[1]][b[2]];
+    }
+    features.push_back( feat );
+  }
+
+  return 1;
 }
 
-void LFColorWeijer::visualizeFeatures ( NICE::Image & mark, const VVector & positions,	size_t color ) const
+void LFColorWeijer::visualizeFeatures( NICE::Image & mark, const VVector & positions, size_t color ) const
 {
-	
+
 }
 
-void LFColorWeijer::add(vector<vector<vector<double> > > &dest, vector<vector<vector<double> > > &src)
+void LFColorWeijer::add( vector<vector<vector<double> > > &dest, vector<vector<vector<double> > > &src )
 {
-	for(uint i0 = 0; i0 < src.size(); i0++)
-	{
-		for(uint i1 = 0; i1 < src[i0].size(); i1++)
-		{
-			for(uint i2 = 0; i2 < src[i0][i1].size(); i2++)
-			{
-				dest[i0][i1][i2] += src[i0][i1][i2];
-			}
-		}
-	}
+  for ( uint i0 = 0; i0 < src.size(); i0++ )
+  {
+    for ( uint i1 = 0; i1 < src[i0].size(); i1++ )
+    {
+      for ( uint i2 = 0; i2 < src[i0][i1].size(); i2++ )
+      {
+        dest[i0][i1][i2] += src[i0][i1][i2];
+      }
+    }
+  }
 }
 
-int LFColorWeijer::findColor(string &fn)
+int LFColorWeijer::findColor( string &fn )
 {
-	if(fn.find("black") != string::npos)
-		return BLACK;
-	if(fn.find("blue") != string::npos)
-		return BLUE;
-	if(fn.find("brown") != string::npos)
-		return BROWN;
-	if(fn.find("grey") != string::npos)
-		return GREY;
-	if(fn.find("green") != string::npos)
-		return GREEN;
-	if(fn.find("orange") != string::npos)
-		return ORANGE;
-	if(fn.find("pink") != string::npos)
-		return PINK;
-	if(fn.find("purple") != string::npos)
-		return PURPLE;
-	if(fn.find("red") != string::npos)
-		return RED;
-	if(fn.find("white") != string::npos)
-		return WHITE;
-	if(fn.find("yellow") != string::npos)
-		return YELLOW;
-	
-	return -1;
+  if ( fn.find( "black" ) != string::npos )
+    return BLACK;
+  if ( fn.find( "blue" ) != string::npos )
+    return BLUE;
+  if ( fn.find( "brown" ) != string::npos )
+    return BROWN;
+  if ( fn.find( "grey" ) != string::npos )
+    return GREY;
+  if ( fn.find( "green" ) != string::npos )
+    return GREEN;
+  if ( fn.find( "orange" ) != string::npos )
+    return ORANGE;
+  if ( fn.find( "pink" ) != string::npos )
+    return PINK;
+  if ( fn.find( "purple" ) != string::npos )
+    return PURPLE;
+  if ( fn.find( "red" ) != string::npos )
+    return RED;
+  if ( fn.find( "white" ) != string::npos )
+    return WHITE;
+  if ( fn.find( "yellow" ) != string::npos )
+    return YELLOW;
+
+  return -1;
 }
 
 vector<vector<vector<double > > > LFColorWeijer::createTable()
 {
-	vector<vector<vector<double> > > h;
-	for(int i0 = 0; i0 < bin[0]; i0++)
-	{
-		vector<vector< double > > vec;
-		for(int i1 = 0; i1 < bin[1]; i1++)
-		{
-			vector<double> v;
-			for(int i2 = 0; i2 < bin[2]; i2++)
-			{
-				v.push_back(0.0);
-			}
-			vec.push_back(v);
-		}
-		h.push_back(vec);
-	}
-	return h;
+  vector<vector<vector<double> > > h;
+  for ( int i0 = 0; i0 < bin[0]; i0++ )
+  {
+    vector<vector< double > > vec;
+    for ( int i1 = 0; i1 < bin[1]; i1++ )
+    {
+      vector<double> v;
+      for ( int i2 = 0; i2 < bin[2]; i2++ )
+      {
+        v.push_back( 0.0 );
+      }
+      vec.push_back( v );
+    }
+    h.push_back( vec );
+  }
+  return h;
 }
 
-void LFColorWeijer::normalize(vector<vector<vector<double> > > &tab)
+void LFColorWeijer::normalize( vector<vector<vector<double> > > &tab )
 {
-	double sum = 0.0;
-	
-	for(uint i0 = 0; i0 < tab.size(); i0++)
-	{
-		for(uint i1 = 0; i1 < tab[i0].size(); i1++)
-		{
-			for(uint i2 = 0; i2 < tab[i0][i1].size(); i2++)
-			{
-				sum += tab[i0][i1][i2];
-			}
-		}
-	}
-	
-	for(uint i0 = 0; i0 < tab.size(); i0++)
-	{
-		for(uint i1 = 0; i1 < tab[i0].size(); i1++)
-		{
-			for(uint i2 = 0; i2 < tab[i0][i1].size(); i2++)
-			{
-				tab[i0][i1][i2] /= sum;
-			}
-		}
-	}
-	
-	return;
+  double sum = 0.0;
+
+  for ( uint i0 = 0; i0 < tab.size(); i0++ )
+  {
+    for ( uint i1 = 0; i1 < tab[i0].size(); i1++ )
+    {
+      for ( uint i2 = 0; i2 < tab[i0][i1].size(); i2++ )
+      {
+        sum += tab[i0][i1][i2];
+      }
+    }
+  }
+
+  for ( uint i0 = 0; i0 < tab.size(); i0++ )
+  {
+    for ( uint i1 = 0; i1 < tab[i0].size(); i1++ )
+    {
+      for ( uint i2 = 0; i2 < tab[i0][i1].size(); i2++ )
+      {
+        tab[i0][i1][i2] /= sum;
+      }
+    }
+  }
+
+  return;
 }
 
-void LFColorWeijer::createHist(const ColorImage &cimg, vector<vector<vector<double> > > &hist, Image &mask)
+void LFColorWeijer::createHist( const ColorImage &cimg, vector<vector<vector<double> > > &hist, Image &mask )
 {
-	// in Lab umwandeln
-	NICE::MultiChannelImageT<double> genimg, imglab;
-
-	ColorSpace::ColorImagetoMultiChannelImage(cimg, genimg);
-	ColorSpace::convert(imglab, genimg, ColorSpace::COLORSPACE_LAB, ColorSpace::COLORSPACE_RGB);
-	
-	for(int y = 0; y < cimg.height(); y++)
-	{
-		for(int x = 0; x < cimg.width(); x++)
-		{
-			if(mask.getPixel(x,y) == 0)
-				continue;
-			vector<int> b;
-			for(int i = 0; i < 3; i++)
-			{
-				int val =(int)((imglab.get(x,y,i)-minv[i])/interval[i]);
-				val = std::min(val, bin[i]-1);
-				b.push_back(val);
-			}
-			hist[b[0]][b[1]][b[2]]++;
-		}
-	}
+  // in Lab umwandeln
+  NICE::MultiChannelImageT<double> genimg, imglab;
+
+  ColorSpace::ColorImagetoMultiChannelImage( cimg, genimg );
+  ColorSpace::convert( imglab, genimg, ColorSpace::COLORSPACE_LAB, ColorSpace::COLORSPACE_RGB );
+
+  for ( int y = 0; y < cimg.height(); y++ )
+  {
+    for ( int x = 0; x < cimg.width(); x++ )
+    {
+      if ( mask.getPixel( x, y ) == 0 )
+        continue;
+      vector<int> b;
+      for ( int i = 0; i < 3; i++ )
+      {
+        int val = ( int )(( imglab.get( x, y, i ) - minv[i] ) / interval[i] );
+        val = std::min( val, bin[i] - 1 );
+        b.push_back( val );
+      }
+      hist[b[0]][b[1]][b[2]]++;
+    }
+  }
 }
 
 void LFColorWeijer::train()
 {
-	cout << "train Starts" << endl;
-	for(int i = 0; i < LASTCOLOR; i++)
-	{
-		vector<vector<vector<double> > > h = createTable();
-		hist.push_back(h);
-	}
-	
-	string dir = conf->gS("LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/ebay/");
-	string images = conf->gS("LFColorWeijer", "table", "test_images.txt");
-	string mask = conf->gS("LFColorWeijer", "table", "mask_images.txt");
-		
-	string imagesfn;
-	string maskfn;
-	
-	ifstream finimg( (dir+images).c_str());
-	ifstream finmask( (dir+mask).c_str());
-	cout << dir+images << endl;
-	cout << dir+mask << endl;
-	// lese bilder und masken ein
-	while( finimg >> imagesfn && finmask >> maskfn)
-	{
-		Image mimg(dir+maskfn);
-		cout << dir+maskfn << endl;
-		ColorImage cimg(dir+imagesfn);
-			
-		int col = findColor(imagesfn);
-		vector<vector<vector<double> > > tab = createTable();
-			
-		createHist(cimg, tab, mimg); // erzeuge Lab Histogramm des Bildes
-			
-		normalize(tab);
-			
-		add(hist[col], tab);
-	}
-	finimg.close();
-	finmask.close();
-		
-		// normalisiere alle lookuptables
-	for(uint i = 0; i < hist.size(); i++)
-	{
-		normalize(hist[i]);
-	}
-		
-	smooth();
-	store();
+  cout << "train Starts" << endl;
+  for ( int i = 0; i < LASTCOLOR; i++ )
+  {
+    vector<vector<vector<double> > > h = createTable();
+    hist.push_back( h );
+  }
+
+  string dir = conf->gS( "LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/ebay/" );
+  string images = conf->gS( "LFColorWeijer", "table", "test_images.txt" );
+  string mask = conf->gS( "LFColorWeijer", "table", "mask_images.txt" );
+
+  string imagesfn;
+  string maskfn;
+
+  ifstream finimg(( dir + images ).c_str() );
+  ifstream finmask(( dir + mask ).c_str() );
+  cout << dir + images << endl;
+  cout << dir + mask << endl;
+  // lese bilder und masken ein
+  while ( finimg >> imagesfn && finmask >> maskfn )
+  {
+    Image mimg( dir + maskfn );
+    cout << dir + maskfn << endl;
+    ColorImage cimg( dir + imagesfn );
+
+    int col = findColor( imagesfn );
+    vector<vector<vector<double> > > tab = createTable();
+
+    createHist( cimg, tab, mimg ); // erzeuge Lab Histogramm des Bildes
+
+    normalize( tab );
+
+    add( hist[col], tab );
+  }
+  finimg.close();
+  finmask.close();
+
+  // normalisiere alle lookuptables
+  for ( uint i = 0; i < hist.size(); i++ )
+  {
+    normalize( hist[i] );
+  }
+
+  smooth();
+  store();
 }
 
-void LFColorWeijer::visualizeFeatures ( NICE::ColorImage & out, const VVector & features, const VVector & position ) const
+void LFColorWeijer::visualizeFeatures( NICE::ColorImage & out, const VVector & features, const VVector & position ) const
 {
-	for(int i = 0; i < (int)position.size(); i++)
-	{
-		int maxpos = 0;
-		double maxval = 0.0;
-		for(int j = 0; j < (int)features[i].size(); j++)
-		{
-			if(maxval < features[i][j])
-			{
-				maxval = features[i][j];
-				maxpos = j;
-			}
-		}
-		
-		out.setPixel(position[i][0],position[i][1],colors[maxpos][0],colors[maxpos][1],colors[maxpos][2]);
-	}
+  for ( int i = 0; i < ( int )position.size(); i++ )
+  {
+    int maxpos = 0;
+    double maxval = 0.0;
+    for ( int j = 0; j < ( int )features[i].size(); j++ )
+    {
+      if ( maxval < features[i][j] )
+      {
+        maxval = features[i][j];
+        maxpos = j;
+      }
+    }
+
+    out.setPixel( position[i][0], position[i][1], colors[maxpos][0], colors[maxpos][1], colors[maxpos][2] );
+  }
 }
 
-void LFColorWeijer::visualizeFeatures ( const NICE::ColorImage & cimg) const
+void LFColorWeijer::visualizeFeatures( const NICE::ColorImage & cimg ) const
 {
-	ColorImage out;
-	visualizeFeatures(cimg, out);
+  ColorImage out;
+  visualizeFeatures( cimg, out );
 }
 
-void LFColorWeijer::visualizeFeatures ( const NICE::ColorImage & cimg, NICE::ColorImage &out) const
+void LFColorWeijer::visualizeFeatures( const NICE::ColorImage & cimg, NICE::ColorImage &out ) const
 {
-	VVector pos, feats;
-	for(int y = 0; y < cimg.height(); y++)
-	{
-		for(int x = 0; x < cimg.width(); x++)
-		{
-			Vector vec(2);
-			vec[0] = x;
-			vec[1] = y;
-			pos.push_back(vec);
-		}
-	}
-	
-	getDescriptors(cimg, pos, feats);
-	
-	out.resize(cimg.width(), cimg.height());
-	out.set(0,0,0);
-	visualizeFeatures ( out, feats, pos);
-	ColorImage combinedout(cimg.width()*2, cimg.height());
-	
-	int width = (int)cimg.width();
-	
-	for(int y = 0; y < (int)cimg.height(); y++)
-	{
-		for(int x = 0; x < width; x++)
-		{
-			combinedout.setPixel(x,y,cimg.getPixel(x,y,0), cimg.getPixel(x,y,1),cimg.getPixel(x,y,2));
-			combinedout.setPixel(x+width,y,out.getPixel(x,y,0), out.getPixel(x,y,1),out.getPixel(x,y,2));
-		}
-	}
-	
-	showImage(combinedout, "Ergebnis");
+  VVector pos, feats;
+  for ( int y = 0; y < cimg.height(); y++ )
+  {
+    for ( int x = 0; x < cimg.width(); x++ )
+    {
+      Vector vec( 2 );
+      vec[0] = x;
+      vec[1] = y;
+      pos.push_back( vec );
+    }
+  }
+
+  getDescriptors( cimg, pos, feats );
+
+  out.resize( cimg.width(), cimg.height() );
+  out.set( 0, 0, 0 );
+  visualizeFeatures( out, feats, pos );
+  ColorImage combinedout( cimg.width()*2, cimg.height() );
+
+  int width = ( int )cimg.width();
+
+  for ( int y = 0; y < ( int )cimg.height(); y++ )
+  {
+    for ( int x = 0; x < width; x++ )
+    {
+      combinedout.setPixel( x, y, cimg.getPixel( x, y, 0 ), cimg.getPixel( x, y, 1 ), cimg.getPixel( x, y, 2 ) );
+      combinedout.setPixel( x + width, y, out.getPixel( x, y, 0 ), out.getPixel( x, y, 1 ), out.getPixel( x, y, 2 ) );
+    }
+  }
+
+  showImage( combinedout, "result" );
 }
 
-void LFColorWeijer::getFeats(const ColorImage &img, MultiChannelImageT<double> &feats)
+void LFColorWeijer::getFeats( const ColorImage &img, MultiChannelImageT<double> &feats )
 {
-	int width = (int)img.width();
-	int height = (int)img.height();
-	feats.reInit(width, height, hist.size(), true);
-	
-	NICE::MultiChannelImageT<double> genimg, imglab;
-	
-	ColorSpace::ColorImagetoMultiChannelImage (img, genimg);
-	ColorSpace::convert(imglab, genimg, ColorSpace::COLORSPACE_LAB, ColorSpace::COLORSPACE_RGB);
-	
-	for(int y = 0; y < height; y++)
-	{
-		for(int x = 0; x < width; x++)
-		{
-			for (uint i = 0; i < hist.size(); i++)
-			{
-				vector<double> b(3,0.0);
-				for (int j = 0; j < 3; j++)
-				{
-					int val = (int)((imglab.get(x,y,j) - minv[j]) / interval[j]);
-					val = std::min(val, bin[j] - 1);
-					val = std::max(val, 0);
-					b[j] = val;
-				}
-				feats.set(x, y, hist[i][b[0]][b[1]][b[2]], i);
-			}
-		}
-	}
-	
-	return;
+  int width = ( int )img.width();
+  int height = ( int )img.height();
+  feats.reInit( width, height, hist.size(), true );
+
+  NICE::MultiChannelImageT<double> genimg, imglab;
+
+  ColorSpace::ColorImagetoMultiChannelImage( img, genimg );
+  ColorSpace::convert( imglab, genimg, ColorSpace::COLORSPACE_LAB, ColorSpace::COLORSPACE_RGB );
+
+  for ( int y = 0; y < height; y++ )
+  {
+    for ( int x = 0; x < width; x++ )
+    {
+      for ( uint i = 0; i < hist.size(); i++ )
+      {
+        vector<double> b( 3, 0.0 );
+        for ( int j = 0; j < 3; j++ )
+        {
+          int val = ( int )(( imglab.get( x, y, j ) - minv[j] ) / interval[j] );
+          val = std::min( val, bin[j] - 1 );
+          val = std::max( val, 0 );
+          b[j] = val;
+        }
+        feats.set( x, y, hist[i][b[0]][b[1]][b[2]], i );
+      }
+    }
+  }
+
+  return;
 }