Camera.h

Go to the documentation of this file.

#ifndef   gra_Camera_H__
#define   gra_Camera_H__

#include "Photo.h"
#include "IdentityPoints.h"
#include "../Self.h"
#include "../math/utility.h"
#include "../math/LinearTransformations.h"
#include "../math/methods.h"
#include "../oo/ObjBase.h"

namespace meow {

template<class Pixel>
class Camera: public ObjBase {
public:
  typedef IdentityPoints<int, double, Vector2D<double> > FixedPoints2D;
private:
  struct Myself {
    Photo<Pixel>         photo_;
    Rotation3D<double>     rot_;
    FixedPoints2D      fixed2D_;

    Myself(): fixed2D_(2) {
    }

    Myself(Myself const& v):
    photo_(v.photo_), rot_(v.rot_), fixed2D_(v.fixed2D_) {
    }

    ~Myself() {
    }
  };

  Self<Myself> const self;
public:
  Camera(): self() {
  }

  Camera(Camera const& b): self(b.self, Self<Myself>::COPY_FROM) {
  }

  ~Camera() {
  }

  Camera& copyFrom(Camera const& b) {
    self().copyFrom(b.self);
    return *this;
  }

  Camera& referenceFrom(Camera const& b) {
    self().referenceFrom(b.self);
    return *this;
  }

  Photo<Pixel> photo() const {
    return self->photo_;
  }

  Photo<Pixel>& photoGet() {
    return self()->photo_;
  }

  Photo<Pixel> photo(Photo<Pixel> const& pho) {
    self()->photo_.copyFrom(pho);
    return photo();
  }

  Rotation3D<double> rotation() const {
    return self->rot_;
  }

  Rotation3D<double>& rotationGet() {
    return self()->rot_;
  }

  Rotation3D<double> rotation(Rotation3D<double> const& rot) {
    self()->rot_.copyFrom(rot);
    return rotation();
  }

  FixedPoints2D fixedPoints2D() const {
    return self->fixed2D_;
  }

  FixedPoints2D& fixedPoints2DGet() const {
    return self()->fixed2D_;
  }

  FixedPoints2D fixedPoints2D(FixedPoints2D const& fps2d) const {
    if (fps2d.dimension() == 2) {
      self()->fixed2D_.copyFrom(fps2d);
    }
    return fixedPoints2D();
  }

  Vector<double> fixedPoint2D(int i) {
    return self->fixed2D_.identityPoint(i);
  }

  bool inside(Vector3D<double> const& p) const {
    return self->photo_.inside(
      Vector3D<double>(rotation().transformate(p.matrix())));
  }

  Pixel color(Vector3D<double> const& p) const {
    return self->photo_.color(
      Vector3D<double>(rotation().transformate(p.matrix())));
  }

  Camera& operator=(Camera const& b) {
    return copyFrom(b);
  }

  bool write(FILE* f, bool bin, unsigned int fg) const {
    if (bin) {
      double tmp;
      for (size_t i = 0; i < 3; ++i) {
        if (fwrite(&(tmp = rotation().theta(i)), sizeof(tmp), 1, f) < 1)
          return false;
      }
    }
    else {
      for (size_t i = 0; i < 3; ++i) {
        if (fprintf(f, "%f ", rotation().theta(i)) < 1) return false;
      }
      fprintf(f, "\n");
    }
    return (fixedPoints2D().write(f, bin, fg) && photo().write(f, bin, fg));
  }

  bool read(FILE* f, bool bin, unsigned int fg) {
    if (bin) {
      double tmp;
      for (size_t i = 0; i < 3; ++i) {
        if (fread(&tmp, sizeof(tmp), 1, f) < 1) {
          return false;
        }
        rotationGet().theta(i, tmp);
      }
    }
    else {
      double a;
      for (size_t i = 0; i < 3; ++i) {
        if (fscanf(f, "%lf", &a) < 1) return false;
        rotationGet().theta(i, a);
      }
    }
    return (fixedPoints2DGet().read(f, bin, fg) && photoGet().read(f, bin, fg));
  }

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

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

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

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

} // meow

#endif // gra_Camera_H__