drwnPixelSegModel.h

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnPixelSegModel.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <cassert>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>

#include "Eigen/Core"

#include "cv.h"
#include "highgui.h"

#include "drwnBase.h"
#include "drwnIO.h"
#include "drwnML.h"
#include "drwnPGM.h"
#include "drwnVision.h"

using namespace std;

// drwnPixelSegModel class ------------------------------------------------

class drwnPixelSegModel : public drwnWriteable {
 protected:
    drwnSegImagePixelFeatures *_featureGenerator;

    vector<double> _classTrainingWeights;

    vector<drwnBoostedClassifier *> _pixelClassModels;

    drwnFeatureWhitener _pixelFeatureWhitener;
    drwnTMultiClassLogistic<drwnBiasJointFeatureMap> _pixelUnaryModel;
    //drwnTMultiClassLogistic<drwnSquareJointFeatureMap> _pixelUnaryModel;
    //drwnTMultiClassLogistic<drwnQuadraticJointFeatureMap> _pixelUnaryModel;

    double _pixelContrastWeight;

    double _longRangeEdgeWeight;
    unsigned _longRangeMatchRadius;
    double _longRangeEdgeThreshold;

    double _robustPottsWeight;

 public:
    drwnPixelSegModel();
    drwnPixelSegModel(const drwnPixelSegModel& model);
    virtual ~drwnPixelSegModel();

    // i/o
    const char *type() const { return "pixelSegModel"; }
    virtual void clear();
    virtual bool save(drwnXMLNode& xml) const;
    virtual bool load(drwnXMLNode& xml);

    int numLabels() const { return _pixelUnaryModel.numClasses(); }

    // feature generation
    void setFeatureGenerator(const drwnSegImagePixelFeatures& featureGenerator);
    const drwnSegImagePixelFeatures& getFeatureGenerator() const {
        return *_featureGenerator;
    }

    // learning
    void learnTrainingClassWeights(const vector<string>& baseNames);
    void learnBoostedPixelModels(const vector<string>& baseNames, int subSample = 0);
    void learnPixelUnaryModel(const vector<string>& baseNames, int subSample = 0);
    void learnPixelContrastWeight(const vector<string>& baseNames);
    void learnPixelContrastWeight(double weight);
    void learnLongRangePairwiseWeight(const vector<string>& baseNames, double threshold, unsigned radius = 4);
    void learnLongRangePairwiseWeight(double weight, double threshold, unsigned radius = 4);
    void learnRobustPottsWeight(const vector<string>& baseNames);
    void learnRobustPottsWeight(double weight);
    void learnPixelContrastAndRobustPottsWeights(const vector<string>& baseNames);
    void learnPixelContrastAndLongRangeWeights(const vector<string>& baseNames, double threshold, unsigned radius = 4);

    double getPairwiseContrastWeight() const { return _pixelContrastWeight; }
    double getLongRangePairwiseWeight() const { return _longRangeEdgeWeight; }
    double getRobustPottsWeight() const { return _robustPottsWeight; }

    // inference
    void cacheUnaryPotentials(drwnSegImageInstance *instance) const;
    void cacheLongRangeEdges(drwnSegImageInstance *instance) const;
    double inferPixelLabels(drwnSegImageInstance *instance) const;
    virtual double inferPixelLabels(const vector<string>& baseNames,
        vector<MatrixXi>& predictedLabels) const;
    virtual double energy(drwnSegImageInstance *instance) const;

 protected:
    void computeBoostedResponses(const vector<double>& x, vector<double>& y) const;
    void cacheBoostedPixelResponses(drwnSegImageInstance &instance) const;

    void buildSampledTrainingSet(const vector<string>& baseNames, const char *labelExt,
        int nLabels, vector<vector<double> >& featureVectors, vector<int>& featureLabels,
        int subSample, bool bRawFeatures) const;

    void crossValidateWeights(const vector<string>& baseNames,
        const vector<double>& pairwiseContrastValues,
        const vector<double>& robustPottsValues, const vector<double>& longRangeValues);
};