IntegralImagePreprocessors.h

Go to the documentation of this file.

/* 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 _INTEGRAL_IMAGE_PREPROCS_H
#define _INTEGRAL_IMAGE_PREPROCS_H

#include <Descriptor/IntegralImageData.h>
#include "IntegralImage.h"

#include <string.h>

class IntegralImagePreprocessor {
public:

    typedef IntegralImageData DataType;

    typedef IntegralImageParams ParamType;

    typedef std::pair<DataType, ParamType> ReturnType;

public:

    IntegralImagePreprocessor() { }

    IntegralImagePreprocessor(std::istream & in) {

    }

    void GetConf(char* strconf) const
    {
      if(strconf)
        strconf[0] = 0;
    }

    void Configure(char* strconf) const
    {
      // NOTHING
    }
    
    void Configure(std::istream & in) {
      // NOTHING
    }

    unsigned int DataSize(unsigned int width, unsigned int height) const
    {
        return sizeof(uint32_t) * (width + 1) * (height + 1);
    }

    void Serialize(unsigned char *buf, const IntegralImageData & src, int n) const
    {
        memcpy(buf, src.data, n);
    }

    void DeSerialize(IntegralImageData & dst, const unsigned char *buf, int n) const
    {
        dst.data = new uint32_t[n/4];
        memcpy(dst.data, buf, n);
    }
    
    static void GetParam(IntegralImageParams & params, unsigned int width, unsigned int height)
    {
      params.stride = width+1;//width
      params.width = width;
      params.height = height;
    }

    template<class T>
    static bool Process(std::pair<IntegralImageData, IntegralImageParams> & out, const T *image, unsigned int width, unsigned int height, long stride)
    {
        IntegralImageHandle<uint32_t> integral_image;
        integral_image.Build(image, width, height, stride, true); // NOTE: costruisco una EXTENDEND integral image, il punto (1,1) corrisponde al punto (0,0)

        out.first.data = integral_image.data;
        
        out.second.width = width; // pattern geometry (not integral_image)
        out.second.height = height; // pattern geometry
        out.second.stride = integral_image.width; // stride for integral image (uint32_t)
                return true;
    }
    
    static bool Process(std::pair<IntegralImageData, IntegralImageParams> & out, const IntegralImageHandle<uint32_t> & src)
    {
        out.first.data = src.data;
        
        out.second.width = src.width-1; // pattern geometry (not integral_image)
        out.second.height = src.height-1; // pattern geometry
        out.second.stride = src.width; // stride for integral image (uint32_t)
                return true;
    }    

};


#endif