Photo.h

Go to the documentation of this file.

#ifndef   gra_Photo_H__
#define   gra_Photo_H__

#include "Bitmap.h"

#include "../Self.h"

#include "../geo/Vectors.h"
#include "../math/utility.h"
#include "../math/Matrix.h"
#include "../math/Transformations.h"

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

#include <vector>
#include <cmath>
#include <string>
#include <typeinfo>
#include <cstdlib>

namespace meow {

template<class Pixel>
class Photo: public ObjBase {
private:
  struct Myself {
    Bitmap<Pixel>            bmp_;
    Vector2D<double>           c_;
    PhotoProjection<double> proj_;

    Myself(): proj_(3) {
    }

    Myself(Myself const& b): bmp_(b.bmp_), c_(b.c_), proj_(b.proj_) {
    }

    ~Myself() {
    }
  };

  Self<Myself> const self;

  Vector2D<double> bitmapCoord(Vector2D<double> const& yx) const {
    return Vector2D<double>(yx.x() + center().x(), -yx.y() + center().y());
  }
public:
  Photo(): self() {
    self()->proj_.focal(1.0);
  }

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

  Photo(Bitmap<Pixel> const& bmp): self() {
    reset(bmp);
  }

  Photo(Bitmap<Pixel> const& bmp, double f): self() {
    reset(bmp, f);
  }

  Photo(Bitmap<Pixel> const& bmp, double f, Vector2D<double> const& c): self() {
    reset(bmp, f, c);
  }

  ~Photo() {
  }

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

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

  void reset(Bitmap<Pixel> const& bmp) {
    bitmap(bmp);
    focal(sqrt(squ(width()) + squ(height())));
    center(Vector2D<double>(bmp.width() / 2, bmp.height() / 2));
  }

  void reset(Bitmap<Pixel> const& bmp, double f) {
    bitmap(bmp);
    focal(f);
    center(Vector2D<double>(bmp.width() / 2, bmp.height() / 2));
  }

  void reset(Bitmap<Pixel> const& bmp, double f, Vector2D<double> const& c) {
    bitmap(bmp);
    focal(f);
    center(c);
  }

  Bitmap<Pixel> const& bitmap() const {
    return self->bmp_;
  }

  Bitmap<Pixel>& bitmapGet() {
    return self()->bmp_;
  }

  Bitmap<Pixel> const& bitmap(Bitmap<Pixel> const& bmp) {
    self()->bmp_.copyFrom(bmp);
    return bitmap();
  }

  double focal() const {
    return self->proj_.focal();
  }

  double focal(double f) {
    self()->proj_.focal(f);
    return focal();
  }

  PhotoProjection<double> projection() const {
    return self->proj_;
  }

  PhotoProjection<double> projection(PhotoProjection<double> const& p) {
    if (p.dimension() == 3) {
      self()->proj_ = p;
    }
    return projection();
  }

  Vector2D<double> const& center() const {
    return self->c_;
  }

  Vector2D<double>& centerGet() {
    return self()->c_;
  }

  Vector2D<double> const& center(Vector2D<double> const& c) {
    self()->c_ = c;
    return center();
  }

  size_t width() const {
    return self->bmp_.width();
  }

  size_t height() const {
    return self->bmp_.height();
  }

  Pixel pixel(size_t y, size_t x) const {
    return self->bmp_.pixel(y, x);
  }

  Pixel pixel(size_t y, size_t x, Pixel const& p) {
    self()->bmp_.pixel(y, x, p);
    return pixel(y, x);
  }

  bool inside(Vector2D<double> const& yx) const {
    Vector2D<double> c = bitmapCoord(yx);
    ssize_t h_max = (ssize_t)height() - 1;
    ssize_t w_max = (ssize_t)width () - 1;
    return (0 <= c.y() && c.y() <= h_max && 0 <= c.x() && c.x() <= w_max);
  }

  bool inside(Vector3D<double> const& p) const {
    if (p.z() > 0) return false;
    return inside(Vector2D<double>(self->proj_.transformate(p.matrix())));
  }

  Pixel color(Vector2D<double> const& yx) const {
    if (!inside(yx)) return Pixel(0);
    Vector2D<double> c(bitmapCoord(yx));
    int y0 = (int)c.y();
    int x0 = (int)c.x();
    double h[2] = {1 - (c.y() - y0), c.y() - y0};
    double w[2] = {1 - (c.x() - x0), c.x() - x0};
    Pixel sum(0);
    for (int dy = 0; dy < 2; dy++)
      for (int dx = 0; dx < 2; dx++) {
        sum = sum + bitmap().pixel(
          std::min(y0 + dy, (int)height() - 1),
          std::min(x0 + dx, (int)width () - 1)) * (w[dy] * h[dx]);
      }
    return sum;
  }

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

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

  bool write(FILE* f, bool bin, unsigned int fg) const {
    if (bitmap().write(f, bin, fg) == false) return false;
    if (bin) {
      double tmp;
      if (fwrite(&(tmp = center().x()), sizeof(tmp), 1, f) < 1) return false;
      if (fwrite(&(tmp = center().y()), sizeof(tmp), 1, f) < 1) return false;
      if (fwrite(&(tmp = focal()), sizeof(tmp), 1, f) < 1) return false;
    }
    else {
      if (fprintf(f, "%f %f\n", center().x(), center().y()) < 2) return false;
      if (fprintf(f, "%f\n", focal()) < 1) return false;
    }
    return true;
  }

  bool read(FILE* f, bool bin, unsigned int fg) {
    if (bitmapGet().read(f, bin, fg) == false) return false;
    double tmp[3];
    if (bin) {
      if (fread(tmp, sizeof(double), 3, f) < 3) return false;
    }
    else {
      if (fscanf(f, "%lf %lf %lf", tmp + 0, tmp + 1, tmp + 2) < 3) return false;
    }
    centerGet().x(tmp[0]);
    centerGet().y(tmp[1]);
    focal(tmp[2]);
    return true;
  }

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

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

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

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

} // meow

#endif // gra_Photo_H__