MoleculeProcessor.h

Go to the documentation of this file.

/*
 * MoleculeProcessor.h
 *
 *  Created on: Oct 20, 2010
 *      Author: erublee
 */

#ifndef MOLECULEPROCESSOR_H_
#define MOLECULEPROCESSOR_H_

#include "pano_core/ImageAtom.h"
#include "pano_core/ImageMolecule.h"

#include <list>
#include <map>
#include <set>

namespace pano
{

class MoleculeProcessor
{

private:
  MoleculeProcessor();
public:
  static const std::string SHOW_PAIRS;

  static const std::string GRAPHVIZ_FILENAME;

  static const std::string VERBOSE_GRAPHVIZ_FILENAME;

  static AtomPair matchwithFitter(cv::Ptr<ImageAtom> atom1, cv::Ptr<ImageAtom> atom2, ModelFitter& modelfitter);
  static AtomPair matchwithFitter(cv::Ptr<ImageAtom> atom1, cv::Ptr<ImageAtom> atom2, cv::Ptr<ModelFitter> modelfitter){
     return matchwithFitter(atom1,atom2,*modelfitter);
    }

  static std::list<AtomPair> queryWithAtom(const ImageMolecule& molecule, cv::Ptr<ImageAtom> atom2,
                                           cv::Ptr<ModelFitter> modelfitter, float angle_thresh = -1.0);

  static void create_num_steps_map(const ImageMolecule& mol, const cv::Ptr<ImageAtom> anchor_atom, const cv::Ptr<
      ImageAtom>& atom, std::map<cv::Ptr<ImageAtom>, size_t>& num_steps_map,
                                   std::map<cv::Ptr<ImageAtom>, std::set<std::string> > atoms_queried, std::map<
                                       cv::Ptr<ImageAtom>, bool>& node_lock, const std::string& graphvizDbgFilename =
                                       std::string(""));

  static void getCyclePairsAndAtoms(const ImageMolecule& mol, const std::map<cv::Ptr<ImageAtom>, size_t>& num_steps,
                                    const cv::Ptr<ImageAtom>& in_atom,
                                    std::map<cv::Ptr<ImageAtom>, AtomPair>& atom_to_pair_map,
                                    std::list<cv::Ptr<ImageAtom> >& atomchain, std::list<AtomPair>& cyclePairs);

  enum TFinder
  {
    DIJKSTRA
  };

  static void findAndSetTrinsics(ImageMolecule& mol, TFinder WAY);
};

class MoleculeGlob;

struct Globber
{
  static const std::string VERBOSE;
  MoleculeGlob* glob;
  cv::Ptr<ModelFitter> fitter;
  Globber(MoleculeGlob*glob, cv::Ptr<ModelFitter> fitter) :
    glob(glob), fitter(fitter)
  {
  }
  void operator()(cv::Ptr<ImageAtom> atom);

};

class MoleculeGlob : public serializable
{

public:
  MoleculeGlob();

  float minDistToAtom(const ImageAtom & atom) const;

  cv::Ptr<ImageAtom> minDistAtom( const ImageAtom & atom) const;

  cv::Ptr<ImageAtom> queryAtomToGlob( cv::Ptr<ModelFitter> fitter,
                         const ImageAtom& atom, std::list<AtomPair>& pairs, bool clone = true);

  cv::Ptr<ImageAtom> addAtomToGlob(cv::Ptr<ModelFitter> fitter, const ImageAtom& atom);

  Globber getGlobber(cv::Ptr<ModelFitter> fitter)
  {
    return Globber(this, fitter);
  }

  cv::Ptr<ImageMolecule> getBiggestMolecule() const;

  void truncateMolecules(cv::Ptr<ImageMolecule> mol_in = cv::Ptr<ImageMolecule>());

  void addPrefittedPairs(const std::list<AtomPair>& pairs, cv::Ptr<ImageAtom> atom = cv::Ptr<ImageAtom>());

  void addPrefittedPairs(const std::vector<AtomPair>& pairs, cv::Ptr<ImageAtom> atom= cv::Ptr<ImageAtom>());

  void reset()
  {
    molecules.clear();
  }

  void addMolecule(cv::Ptr<ImageMolecule> molecule)
  {
    molecules.insert(molecule);
  }

  const std::set<cv::Ptr<ImageMolecule> > & getMolecules() const
  {
    return molecules;
  }

  void overideDirectory(std::string directory);

  std::set<cv::Ptr<ImageMolecule> > & getMolecules()
  {
    return molecules;
  }

  cv::Ptr<ImageMolecule> getMerged() const;

  void batchFindAndSetTrinsics();

  /*
   * serializable functions
   */
  virtual int version() const
  {
    return 0;
  }

  virtual void serialize(cv::FileStorage& fs) const;
  virtual void deserialize(const cv::FileNode& fn);
  void setMatcher(cv::Ptr<cv::DescriptorMatcher> matcher);
private:
  void generateMasks(const ImageAtom& atom, std::vector<cv::Mat>& masks)const;
  void addAtomDescriptors(cv::Ptr<ImageAtom> atom);
  std::set<cv::Ptr<ImageMolecule> > molecules;
  int uid_count_;
  friend struct PairGlobber;

  std::vector<cv::Ptr<ImageAtom> > atoms_;
  std::map<int,int> atom_uids_idxs_;
  std::vector<cv::Mat> all_descriptions_;
  cv::Ptr<cv::DescriptorMatcher> matcher_;

};

struct MoleculePeeler
{
  void operator()(cv::Ptr<ImageMolecule>& mol)
  {
    mol->peelAtoms();
  }
};

}

#endif // MOLECULEPROCESSOR_H