HaarFeature.h

/* XBoost: Ada-Boost and Friends on Haar/ICF/HOG Features, Library and ToolBox
 *
 * Copyright (c) 2008-2014 Paolo Medici <medici@ce.unipr.it>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef _HAAR_FEATURE_H
#define _HAAR_FEATURE_H

#include <vector>
#include <iostream>

struct HaarNode {
  int sign;     // multiplier   
  int x,y;      // posizion of feature

public:  

  HaarNode() { }
  HaarNode(int _sign, int _x, int _y) : sign(_sign), x(_x), y(_y) 
  { 
  }

  inline int operator()(const unsigned int *pIntImage, long stride) const
        {
        return (int)(pIntImage[x + y * stride]) * sign;
        }
};

std::istream & operator >> (std::istream & in, HaarNode & d);
std::ostream & operator << (std::ostream & out, const HaarNode & s);

typedef int (* Evaluate_t)(const unsigned int *pIntImage, int stride, const HaarNode *node);

extern const Evaluate_t ievaluate[];

struct CollapsedHaarFeature;

struct HaarFeature : public std::vector<HaarNode> {

  const char *name; // for debug purpose (remember to remove in final version)

public:

  typedef unsigned int InputDataType;
  
  typedef int DescriptorType;

  typedef CollapsedHaarFeature OptimizedType;
  
  enum { InvokeParam = 2 };
  
public:  

 HaarFeature() : name(NULL) { }

 HaarFeature(const HaarFeature &src, int scale, long offset, long stride)
 {
         //rescale(scale,scale);
          //std::cout << "allocate features @ scale "<<scale <<std::endl;

          this->resize(src.size());
          std::vector<HaarNode>::iterator nodes=this->begin();
          int j=0;
          for(std::vector<HaarNode>::const_iterator i=src.begin();i!=src.end();++i)
          {
                  int x = (int)(i->x * scale + scale - 1);
                  int y = (int)(i->y * scale + scale - 1);
                  nodes[j].sign=i->sign;
                  nodes[j].x = x;
                  nodes[j].y = y;
                  ++j;
          }
 }


 inline const char *debug_name() const { return name; }
 inline void debug_name(const char *str) { name = str; }
 
 static std::string signature() { return "haar"; }
  
void invert_polarity()
{
  for(std::vector<HaarNode>::iterator i=this->begin();i!=this->end();i++)
    i->sign = - i->sign;
}
  
#if 0
 int response(const unsigned int *pIntImage, int stride) const
  {
  for(std::vector<HaarNode> i=m_nodes.begin();i!=m_nodes.end();i++)
    sum += node[i](pIntImage, stride);
  }
#else
 inline int response(const unsigned int *pIntImage, int stride) const
  {
  return ievaluate[size()](pIntImage, stride, &(*this)[0]);
  }
#endif

  inline int operator() (const unsigned int *pIntImage, int stride) const
  {
    return response(pIntImage, stride);
  }

 void rescale(int sx, int sy)
 {
  for(std::vector<HaarNode>::iterator i = this->begin(); i!= this->end(); ++i)
         i->x = (i->x * sx + sx - 1), i->y = (i->y * sy + sy - 1);
 }
};


 std::istream & operator >> (std::istream & in, HaarFeature & s);
 std::ostream & operator << (std::ostream & out, const HaarFeature & s);

#endif