FeaturePoint.h

Go to the documentation of this file.

#ifndef   gra_FeaturePoint_H__
#define   gra_FeaturePoint_H__

#include "../oo/ObjBase.h"

#include "../math/Vector.h"

#include <string>
#include <typeinfo>
#include <cstdlib>
#include <cstdio>

namespace meow {

template <class Scalar, class Description,
         class Position = Vector<Scalar     >,
         class Feature  = Vector<Description> >

class FeaturePoint: public ObjBase {
private:
  Position pos_;
  Feature  des_;
public:
  FeaturePoint() {
  }

  FeaturePoint(size_t pDim, size_t dDim):
  pos_(pDim, Scalar(0)), des_(dDim, Description(0)) {
  }

  FeaturePoint(Position const& v, Feature const& d):
  pos_(v), des_(d) {
  }

  FeaturePoint(FeaturePoint const& fp):
  pos_(fp.pos_), des_(fp.des_) {
  }

  ~FeaturePoint() {
  }

  FeaturePoint& copyFrom(FeaturePoint const& fp) {
    pos_.copyFrom(fp.pos_);
    des_.copyFrom(fp.des_);
    return *this;
  }

  FeaturePoint& referenceFrom(FeaturePoint const& fp) {
    pos_.referenceFrom(fp.pos_);
    des_.referenceFrom(fp.des_);
    return *this;
  }

  Position position() const {
    return pos_;
  }

  Position& positionGet() {
    return pos_;
  }

  Feature description() const {
    return des_;
  }

  Feature& descriptionGet() {
    return des_;
  }

  Position position(Position const& p) {
    pos_.copyFrom(p);
    return position();
  }

  Feature description(Feature const& d) {
    des_.copyFrom(d);
    return description();
  }

  Scalar position(size_t index) const {
    return position()(index);
  }

  Description description(size_t index) const {
    return des_(index);
  }

  Scalar position(size_t i, Scalar const& s) {
    pos_.scalar(i, s);
    return position()(i);
  }

  Description description(size_t i, Description const& d) {
    des_.scalar(i, d);
    return description()(i);
  }

  FeaturePoint& operator=(FeaturePoint const& fp) {
    return copyFrom(fp);
  }

  Scalar const& operator()(size_t i) const {
    return position(i);
  }

  Description operator[](size_t i) const {
    return description(i);
  }

  bool write(FILE* f, bool bin, unsigned int fg) const {
    if (bin) {
      double tmp;
      int a, b;
      a = position().dimension();
      b = description().dimension();
      if (fwrite(&a, sizeof(a), 1, f) < 1) return false;
      if (fwrite(&b, sizeof(b), 1, f) < 1) return false;
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fwrite(&(tmp = position(i)), sizeof(tmp), 1, f) < 1) return false;
      }
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fwrite(&(tmp = description(i)), sizeof(tmp), 1, f) < 1)
          return false;
      }
    }
    else {
      int a, b;
      a = position().dimension();
      b = description().dimension();
      if (fprintf(f, "%d %d\n", a, b) < 2) return false;
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fprintf(f, "%f ", (double)position(i)) < 1) return false;
      }
      fprintf(f, "\n");
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fprintf(f, "%f ", (double)description(i)) < 1) return false;
      }
      fprintf(f, "\n");
    }
    return true;
  }

  bool read(FILE* f, bool bin, unsigned int fg) {
    if (bin) {
      double tmp;
      int a, b;
      if (fread(&a, sizeof(a), 1, f) < 1) return false;
      if (fread(&b, sizeof(b), 1, f) < 1) return false;
      position(Position((size_t)a, Scalar(0)));
      description(Feature((size_t)b, Description(0)));
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fread(&tmp, sizeof(tmp), 1, f) < 1) return false;
        position(i, tmp);
      }
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fread(&tmp, sizeof(tmp), 1, f) < 1) return false;
        description(i, tmp);
      }
    }
    else {
      double tmp;
      int a, b;
      if (fscanf(f, "%d %d", &a, &b) < 2) return false;
      position(Position((size_t)a, Scalar(0)));
      description(Feature((size_t)b, Description(0)));
      for (size_t i = 0, I = position().dimension(); i < I; ++i) {
        if (fscanf(f, "%lf", &tmp) < 1) return false;
        position(i, tmp);
      }
      for (size_t i = 0, I = description().dimension(); i < I; ++i) {
        if (fscanf(f, "%lf", &tmp) < 1) return false;
        description(i, tmp);
      }
    }
    return true;
  }

  ObjBase* create() const {
    return new FeaturePoint();
  }

  ObjBase* copyFrom(ObjBase const& b) {
    return &(copyFrom(*(FeaturePoint const*)b));
  }

  char const* ctype() const {
    return typeid(*this).name();
  }

  std::string type() const {
    return std::string(ctype());
  }
};

} // meow

#endif // gra_FeaturePoint_H__