Bitmap.h

Go to the documentation of this file.

#ifndef   gra_Bitmap_H__
#define   gra_Bitmap_H__

#include "../math/utility.h"
#include "../math/Matrix.h"

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

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

namespace meow {

const unsigned int kBitmapReadWritePixels = 0x1;

template<class Pixel>
class Bitmap: public ObjBase {
private:
  Matrix<Pixel> matrix_;

  static std::vector<double> gaussianFactor1(double sigma) {
    double sigma2 = squ(sigma);
    size_t width = std::max(ceil((double)(sigma * 2)), 0.0);
    std::vector<double> factor(width + 1 + width);
    for (size_t x = 0; x < width; x++) {
      double e = exp(-(squ((double)x)) / (2.0 * sigma2));
      factor[width - x - 1] = e;
      factor[width + x + 1] = e;
    }
    factor[width] = 1.0;
    return factor;
  }

  static std::vector<double> gradianceFactor1(double sigma) {
    double sigma2 = squ(sigma), ss = sigma * 2;
    size_t width = std::max(ceil(ss), 1.0);
    std::vector<double> factor(width + 1 + width);
    for (size_t x = 0; x < width; x++) {
      double e = exp(-(squ((double)x)) / (2.0 * sigma2));
      factor[width - x - 1] =  (double)x * e;
      factor[width + x + 1] = -(double)x * e;
    }
    factor[width] = 0.0;
    return factor;
  }

  Bitmap xyBlur(std::vector<double> const& factor,
                ssize_t dx, ssize_t dy) const {
    if (factor.size() <= 1)
      return *this;
    Bitmap ret(height(), width(), Pixel(0));
    ssize_t w = factor.size() / 2;
    for (size_t y = 0, Y = height(); y < Y; y++)
      for (size_t x = 0, X = width(); x < X; x++) {
        Pixel   sum(0);
        double fsum(0);
        for (ssize_t i = -w; i <= w; i++) {
          ssize_t x2 = (ssize_t)x + dx * i;
          ssize_t y2 = (ssize_t)y + dy * i;
          if (0 <= x2 && x2 < (ssize_t)X && 0 <= y2 && y2 < (ssize_t)Y) {
            sum  = sum  + pixel(y2, x2) * factor[i + w];
            fsum = fsum + fabs(factor[i + w]);
          }
        }
        ret.pixel(y, x, sum / fsum);
      }
    return ret;
  }
public:
  Bitmap() {
  }

  Bitmap(Bitmap const& b): matrix_(b.matrix_) {
  }

  Bitmap(Matrix<Pixel> const& b): matrix_(b) {
  }

  Bitmap(size_t h, size_t w, Pixel const& p): matrix_(h, w, p) {
  }

  ~Bitmap() {
  }

  Bitmap& copyFrom(Bitmap const& b) {
    matrix_.copyFrom(b.matrix_);
    return *this;
  }

  Bitmap& referenceFrom(Bitmap const& b) {
    matrix_.referenceFrom(b.matrix_);
    return *this;
  }

  void reset(size_t h, size_t w, Pixel const& p) {
    matrix_.reset(h, w, p);
  }

  void clear() {
    matrix_.clear();
  }

  size_t height() const {
    return matrix_.rows();
  }

  size_t width() const {
    return matrix_.cols();
  }

  size_t size() const {
    return matrix_.size();
  }

  size_t height(size_t h2, Pixel const& p) {
    return matrix_.rows(h2, p);
  }

  size_t width(size_t w2, Pixel const& p) {
    return matrix_.cols(w2, p);
  }

  size_t size(size_t h2, size_t w2, Pixel const& p) {
    return matrix_.size(h2, w2, p);
  }

  Pixel pixel(size_t y, size_t x) const {
    return matrix_.entry(y, x);
  }

  Pixel pixel(size_t y, size_t x, Pixel const& p) {
    return matrix_.entry(y, x, p);
  }

  void pixels(ssize_t yFirst, ssize_t yLast,
              ssize_t xFirst, ssize_t xLast,
              Pixel const& p) {
    return matrix_.entries(yFirst, yLast, xFirst, xLast, p);
  }

  Matrix<Pixel> matrix() const {
    return matrix_;
  }

  Matrix<Pixel>& matrixGet() {
    return matrix_;
  }

  Matrix<Pixel> matrix(Matrix<Pixel> const& p) {
    matrix_.copyFrom(p);
    return matrix();
  }

  Bitmap gaussian(double radiusY, double radiusX) const {
    return (xyBlur(gaussianFactor1(radiusY), 1, 0).
            xyBlur(gaussianFactor1(radiusX), 0, 1));
  }

  Bitmap& gaussianed(double radiusY, double radiusX) {
    return copyFrom(gaussian(radiusY, radiusX));
  }

  Bitmap gradianceX(double radiusY, double radiusX) const {
    return (xyBlur(gaussianFactor1(radiusY), 1, 0).
            xyBlur(gradianceFactor1(radiusX), 0, 1));
  }

  Bitmap<Pixel>& gradiancedX(double radiusY, double radiusX) {
    return copyFrom(gradianceX(radiusY, radiusX));
  }

  Bitmap<Pixel> gradianceY (double radiusY, double radiusX) const {
    return (xyBlur(gaussianFactor1(radiusX), 0, 1).
            xyBlur(gradianceFactor1(radiusY), 1, 0));
  }

  Bitmap<Pixel>& gradiancedY(double radiusY, double radiusX) {
    return copyFrom(gradianceY(radiusY, radiusX));
  }

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

  Pixel operator()(size_t y, size_t x) const {
    return pixel(y, x);
  }

  Pixel const& operator()(size_t y, size_t x, Pixel const& p) const {
    return pixel(y, x, p);
  }

  bool write(FILE* f, bool bin, unsigned int fg) const {
    if (fg & kBitmapReadWritePixels)
      return false;
    if (bin) {
      long tmp;
      if (fwrite(&(tmp = matrix_.cols()), sizeof(tmp), 1, f) < 1) return false;
      if (fwrite(&(tmp = matrix_.rows()), sizeof(tmp), 1, f) < 1) return false;
    }
    else {
      if (fprintf(f, "%ld %ld\n", (long)matrix_.cols(), (long)matrix_.rows())
          < 2) return false;
    }
    return true;
  }

  bool read(FILE* f, bool bin, unsigned int fg) {
    if (fg & kBitmapReadWritePixels)
      return false;
    long tmp1, tmp2;
    if (bin) {
      if (fread(&tmp1, sizeof(tmp1), 1, f) < 1) return false;
      if (fread(&tmp2, sizeof(tmp2), 1, f) < 1) return false;
    }
    else {
      if (fscanf(f, "%ld %ld", &tmp1, &tmp2) < 2) return false;
    }
    matrix_.size(tmp1, tmp2, Pixel(0));
    return true;
  }

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

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

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

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


} // meow

#endif // gra_Bitmap_H__