SourceDataSet.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 _SOURCE_DATA_SET_H
#define _SOURCE_DATA_SET_H


#include "IO/pnmio.h"
#include "IO/datasetin.h"
#include "Image.h"
#include "DataSet.h"
#include "Utility/ImageUtils.h"

#include <stdio.h> // sprintf
#include <stdlib.h> // rand

template<class TPreprocessorType, class Aggregator>
class SourceDataSet: public TPreprocessorType, public DataSet<Aggregator> {
public:

    typedef DataSetHandle<Aggregator> DataSetType;

    DECLARE_AGGREGATOR

private:
    bool m_initialized;

    bool m_export_data_set;

    std::string m_export_path;

public:

    SourceDataSet() : m_initialized(false), m_export_data_set(false) { }

    bool ImportImage(const ImageHandle & image, int category);

    void SetExportFolder(const std::string & folder) {
        m_export_data_set = true;
        m_export_path = folder;
    }
};


extern int frameidx;

// Import a GrayScale Image
template<class TPreprocessorType, class Aggregator>
bool SourceDataSet<TPreprocessorType, Aggregator>::ImportImage(const ImageHandle & image, int category)
{
    typename TPreprocessorType::ReturnType data; // processed data (pair of <DATA, PARAMS> )

    if(m_export_data_set)
    {
        char buffer[256];
        int count = this->templates.size();
        if(category == 1)
            sprintf(buffer, "%s/P%06u_%u.pgm", m_export_path.c_str(), count, frameidx);
        else
            sprintf(buffer, "%s/N%06u_%u.pgm", m_export_path.c_str(), count, frameidx);
        pnm_write(image, buffer);
    }

    // il proceprocessor converte da image a ReturnType (un pair composto dal dato e dalla geometria)
    if(image.bpp == 1)
    {
        TPreprocessorType::Process(data, (unsigned char *) image.data, image.width, image.height, image.stride );
    }
    else if(image.bpp == 2)
    {
        TPreprocessorType::Process(data, (unsigned short *) image.data, image.width, image.height, image.stride );
    }
    else
    {
        std::cerr << "Invalid bpp = " << image.bpp << " for this data set" << std::endl;
        return false;
    }

    if(!m_initialized)
    {
        // set the parameters on DataSet
        this->SetParams(data.second);
        m_initialized = true;
    }
    else
    {
        // verificare che la geometria sia corretta
        if(!( static_cast<const ParamType &>(*this) == data.second))
        {
            std::cerr << "invalid geometry" << std::endl;
            return false;
        }
    }

    // import the data inside the DataSet
    this->Import(data.first, category);
    return true;
}

template<class DataSetType>
bool RandomExtract(DataSetType & set, const ImageHandle & img, const size & set_geometry, int nRand, const std::vector<datasetobject> & object)
{
    if(img.width < set_geometry.width || img.height < set_geometry.height)
    {
        std::cerr << "the image is too small to be used during negative random extraction" << std::endl;
        return false;
    }

    // for any candidate in the set
    for(int k=0; k<nRand; ++k)
    {
        int x0 = rand() % (img.width - set_geometry.width);
        int y0 = rand() % (img.height - set_geometry.height);
        rect roi(x0, y0, x0 + set_geometry.width, y0 + set_geometry.height);

        bool collision = false;
        // Check Collision
        for(std::vector<datasetobject>::const_iterator i = object.begin(); i != object.end(); ++i)
            if(overlap(roi, i->roi))
            {
                collision = true;
                break;
            }

        if(!collision)
        {
            if(!set.ImportImage(img.crop(roi), -1)) // only negative
            {
                std::cerr << "Failed to import pattern";
                return false;
            }
        }
    }
    return true;
}

// struct LoadSetParams {
//   bool sz_valid;
//   size sz;
//   int nRand;
//   float scale_factor;
// };

template<class DataSetType>
bool LoadSet(DataSetType & set, datasetin & in, const size & sz, int nRand)
{
    datasetitem item;
    size set_geometry = sz; //

    if(set_geometry.width != 0 || set_geometry.height!=0)
        std::cout << "LoadSet with geometry " << set_geometry.width << 'x' << set_geometry.height << std::endl;

    // iterate on input data
    while(in.next(item))
    {
//         bool have_negative = false;
        Image img;
        if(!pnm_load(item.filename.c_str(), img))
        {
            std::cout << "Warn: \'" << item.filename << "' failed to load: skip." << std::endl;
        }
        else
        {
            // for any candidate in the set (positive/negative)
            for(std::vector<datasetobject>::const_iterator i = item.object.begin(); i != item.object.end(); ++i)
                if(i->category != 0) // DO NOT CARE
                {
                    rect roi = i->roi;

                    // whole image ROI
                    if(roi.x0 == 0 && roi.y0 == 0 && roi.x1 == 0 && roi.y1 == 0)
                    {
                        roi.x1 = img.width;
                        roi.y1 = img.height;
                    }

                    if(roi.x0 < 0 || roi.y0 < 0 || roi.x1 > (int) img.width || roi.y1 > (int) img.height)
                    {
                        std::cout << "Warn: ROI #" << (i - item.object.begin()) << " is out of image " << item.filename << std::endl;
                    }
                    else
                    {

                        if(set_geometry.width == 0 && set_geometry.height==0)
                        {
                            set_geometry.width = roi.width();
                            set_geometry.height = roi.height();
                            std::cout << "Geometry: " << set_geometry.width << 'x' << set_geometry.height << std::endl;
                        }

                        if(set_geometry == roi.extension()) // se sono uguali viene fatto un Crop
                        {
                            if(!set.ImportImage(img.crop(roi), i->category))
                                std::cerr << "Failed to import image " << item.filename << std::endl;
                        }
                        else
                        {
                            // resize
                            Image img2;
//                     std::cout << item.filename << " convert " << roi.width() << 'x' << roi.height() << " to " << set_geometry.width << 'x' << set_geometry.height << '\n';
                            img2.alloc(set_geometry.width, set_geometry.height, 1);
                            Resample(img2, img.crop(roi), rect(0,0, roi.width(), roi.height()));
                            set.ImportImage(img2, i->category);
                        }

                    }

                }

            // se e' un file da estrazione automatica di negativi, li usa
            if(item.auto_negative && (nRand>0))
            {
                if(set_geometry.width == 0 || set_geometry.height == 0)
                {
                    std::cerr << "Error: Invalid geometry for random sample extraction. Check -r <w> <h> option." << std::endl;
                }
                else
                {
                    std::cout << "Extract random from " << item.filename << " ID:" << frameidx << std::endl;
                    std::vector<datasetobject> list = item.object;

                    // for all octaves:
                    for(;;) {

                        RandomExtract(set, img, set_geometry, nRand, list);

                        if(img.width > 2 * set_geometry.width && img.height > 2 * set_geometry.height)
                        {
                            Image out;
                            out.alloc(img.width/2, img.height/2, 1);
                            Downsample2X(out, img);

                            for(std::vector<datasetobject>::iterator i = list.begin(); i != list.end(); ++i)
                            {   
                                i->roi.x0 /= 2;
                                i->roi.y0 /= 2;
                                i->roi.x1 = (i->roi.x1+1)/2;
                                i->roi.y1 = (i->roi.y1+1)/2;
                            }

                            std::swap(img, out);
                        }
                        else
                            break;
                    }

                }

                frameidx++;
            }

        }

    }

    frameidx = 0;
    return true;
}

#endif