descriptor.hpp

/* $Id$ */

#ifndef SAMS_DESCRIPTOR_HPP
#define SAMS_DESCRIPTOR_HPP

#include <string>
#include "kernel/keyValueFile.hpp"
#include "image/Image.hpp"

#include <fstream>
#include "boost/archive/xml_iarchive.hpp"
#include "jmath/jblas.hpp"
#include "jmath/pca.hpp"
#include "sams/feature.hpp"

namespace jafar {
  namespace sams {

    class DescriptorFactory {
    public:
      virtual ~DescriptorFactory() {};
      virtual bool generate(const jafar::image::Image& img_,
        std::vector<jafar::sams::Feature *>& fVec_) const {};
    }; // class DescriptorFactory

    class SIFTFactory : public DescriptorFactory {
    public:
      class Params : public jafar::kernel::KeyValueFileLoad {
      public:
        double magnif;
        double sigma0;
        int dim;
        int odim;
        double fvGradHicap;

        Params(double magnif_=3.0, double sigma0_=1.5, int dim_=4, int odim_=8, double fvGradHicap_=0.2) :
        magnif(magnif_), sigma0(sigma0_), dim(dim_), odim(odim_), fvGradHicap(fvGradHicap_) {};

      protected:
        void loadKeyValueFile(jafar::kernel::KeyValueFile const & keyValueFile) {
          JFR_TRACE_BEGIN;
          keyValueFile.getItem("magnif",magnif);
          keyValueFile.getItem("sigma0",sigma0);
          keyValueFile.getItem("dim",dim);
          keyValueFile.getItem("odim",odim);
          keyValueFile.getItem("fvGradHicap",fvGradHicap);
          JFR_TRACE_END("SIFTFactory::Params::loadKeyValueFile");
        };
      }; // class Params

      SIFTFactory() : params() {};
      SIFTFactory(Params params_) : params(params_) {};
      SIFTFactory(std::string const & fileName_) {
        params.load(fileName_);
      };
      virtual ~SIFTFactory() {};
      virtual bool generate(const jafar::image::Image& img_,
      std::vector<jafar::sams::Feature *>& fVec_) const {
        jblas::mat mag;
        jblas::mat dir;
        preproc(img_,mag,dir);
        computeOrientations(fVec_,mag,dir);
        computeDescriptors(fVec_,mag,dir);
        return true;
      };

    private:
      Params params;
      void preproc(const jafar::image::Image& img_,
        jblas::mat& mag_,
        jblas::mat& dir_) const;
      void computeOrientations(std::vector<jafar::sams::Feature *>& fVec_,
        const jblas::mat& mag_,
        const jblas::mat& dir_) const;
      void computeDescriptors(std::vector<jafar::sams::Feature *>& fVec_,
        const jblas::mat& mag_,
        const jblas::mat& dir_) const;


    }; // class SIFTFactory

    class GIFTFactory : public DescriptorFactory {
    public:
      class Params : public jafar::kernel::KeyValueFileLoad{
      public:
        int supportWidth;
        int dim;
        int odim;
        double fvGradHicap;

        Params(int sw_=45,int dim_=4, int odim_=8, double fvGradHicap_=0.2) :
          supportWidth(sw_), dim(dim_), odim(odim_), fvGradHicap(fvGradHicap_) {};
        
      protected:
        void loadKeyValueFile(jafar::kernel::KeyValueFile const & keyValueFile) {
          JFR_TRACE_BEGIN;
          keyValueFile.getItem("supportWidth", supportWidth);
          keyValueFile.getItem("dim", dim);
          keyValueFile.getItem("odim", odim);
          keyValueFile.getItem("fvGradHicap", fvGradHicap);
          JFR_TRACE_END("GIFTFactory::Params::loadKeyValueFile");
        };
      }; //class Params

      GIFTFactory() : params() {};
      GIFTFactory(Params params_) : params(params_) {};
      GIFTFactory(std::string const & fileName_) {
        params.load(fileName_);
      };
      virtual ~GIFTFactory() {};
      virtual bool generate(const jafar::image::Image& img_,
          std::vector<jafar::sams::Feature *>& fVec_) const;
    
    private:
      Params params;
    };

    class GreyDescFactory : public DescriptorFactory {
    public:

      class Params {
      public:
        int dim;
        bool usePCA;
        jafar::jmath::PCA pca;

        Params(int dim_=121, bool usePCA_=false, std::string const & fileName_="") : 
        dim(dim_), usePCA(usePCA_) {
    // if (usePCA) {
    //      JFR_PRECOND( fileName_ != "", "GreyDescFactory::Params: you must specify a filename for the PCA data");
    //      std::ifstream ifs(fileName_.c_str());
    //      boost::archive::xml_iarchive iar(ifs);
    //      iar >> BOOST_SERIALIZATION_NVP(pca);
    //    }
        };

      }; // class Params

      GreyDescFactory() : params() {};
      GreyDescFactory(Params params_) : params(params_) {};
      GreyDescFactory(std::string const & fileName_) : params(121,true,fileName_) {
      };
      virtual ~GreyDescFactory() {};
      virtual bool generate(const jafar::image::Image& img_,
        std::vector<jafar::sams::Feature *>& fVec_) const;

    private:
      Params params;
    }; // class GreyFactory
  }
} // namespace jafar

#endif // SAMS_DESCRIPTOR_HPP


// AUTORIGHTS
// Copyright (c) 2006 The Regents of the University of California
// All Rights Reserved.
// 
// Created by Andrea Vedaldi (UCLA VisionLab)
// 
// Permission to use, copy, modify, and distribute this software and its
// documentation for educational, research and non-profit purposes,
// without fee, and without a written agreement is hereby granted,
// provided that the above copyright notice, this paragraph and the
// following three paragraphs appear in all copies.
// 
// This software program and documentation are copyrighted by The Regents
// of the University of California. The software program and
// documentation are supplied "as is", without any accompanying services
// from The Regents. The Regents does not warrant that the operation of
// the program will be uninterrupted or error-free. The end-user
// understands that the program was developed for research purposes and
// is advised not to rely exclusively on the program for any reason.
// 
// This software embodies a method for which the following patent has
// been issued: "Method and apparatus for identifying scale invariant
// features in an image and use of same for locating an object in an
// image," David G. Lowe, US Patent 6,711,293 (March 23,
// 2004). Provisional application filed March 8, 1999. Asignee: The
// University of British Columbia.
// 
// IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
// FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
// INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND
// ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE UNIVERSITY OF
// CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
// BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE
// MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.