global-vg-pyramid-maker.h

Go to the documentation of this file.

// Copyright 2007, Massachusetts Institute of Technology.
// The use of this code is permitted for research only. There is
// absolutely no warranty for this software.
//
// Author: John Lee (jjl@mit.edu)
//
// TODO(jjl): global_used_bins is no longer needed.

#ifndef PYRAMIDS_GLOBAL_VG_PYRAMID_MAKER_H
#define PYRAMIDS_GLOBAL_VG_PYRAMID_MAKER_H

#include <vector>
#include <iostream>
#include <set>
#include "pyramids/vg-pyramid-maker.h"
#include "point_set/point-set-list.h"
#include "util/sparse-vector.h"
#include "histograms/multi-resolution-histogram.h"
#include "util/distance-computer.h"
#include "clustering/hierarchical-clusterer.h"
#include "util/tree-node.h"
#include "util/tree.cc"

namespace libpmk {

class GlobalVGPyramidMaker : public VGPyramidMaker {
 public:
   GlobalVGPyramidMaker(const HierarchicalClusterer& clusterer,
                        const DistanceComputer& distance_computer);
   ~GlobalVGPyramidMaker();


   void Preprocess(const PointSetList& point_sets);

   virtual MultiResolutionHistogram* MakePyramid(const PointSet& point_set);


   void ReadFromStream(istream& input_stream);


   void ReadFromFile(const char* filename);


   void WriteToStream(ostream& output_stream) const;


   void WriteToFile(const char* filename) const;

 protected:

   virtual pair<LargeIndex, vector<double> >
      GetMembershipPath(const Feature& f);

 private:
   class IndexNode : public TreeNode {
   public:
      IndexNode() : TreeNode() {}
      IndexNode(const LargeIndex& index) : TreeNode(index) {}
      virtual ~IndexNode() { }

      virtual void Combine(const TreeNode& other) {
         const set<int>& other_indices = 
            static_cast<const IndexNode&>(other).indices_;
         for (set<int>::iterator iter = other_indices.begin();
              iter != other_indices.end(); ++iter) {
            indices_.insert(*iter);
         }
      }

      const set<int>& GetIndices() const {
         return indices_;
      }

      void AddIndex(int index) {
         indices_.insert(index);
      }
      
   protected:
      virtual void ReadData(istream& input_stream) {
         int32_t size;
         input_stream.read((char *)&size, sizeof(int32_t));
         for (int ii = 0; ii < size; ++ii) {
            int32_t index;
            input_stream.read((char *)&index, sizeof(int32_t));
            indices_.insert((int)index);
         }
      }
      
      virtual void WriteData(ostream& output_stream) const {
         int32_t size = (int32_t)indices_.size();
         output_stream.write((char *)&size, sizeof(int32_t));
         for (set<int>::iterator iter = indices_.begin();
              iter != indices_.end(); ++iter) {
            int32_t index = *iter;
            output_stream.write((char *)&index, sizeof(int32_t));
         }
      }
      
   private:
      set<int> indices_;
   };


   auto_ptr<MultiResolutionHistogram> global_pyramid_;
   vector<vector<bool> > global_used_bins_;
   bool preprocessed_;
};
}  // namespace libpmk

#endif  // PYRAMIDS_GLOBAL_VG_PYRAMID_MAKER_H

---