Image.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <string.h>  // for memcpy
 
#include "MEM_guardedalloc.h"
 
namespace Freestyle {
 
//
// Image base class, for all types of images
//

class FrsImage {
 public:
  FrsImage()
  {
    _storedWidth = 0;
    _storedHeight = 0;
    _width = 0;
    _height = 0;
    _Ox = 0;
    _Oy = 0;
  }

  FrsImage(const FrsImage &brother)
  {
    _storedWidth = brother._storedWidth;
    _storedHeight = brother._storedHeight;
    _width = brother._width;
    _height = brother._height;
    _Ox = brother._Ox;
    _Oy = brother._Oy;
  }

  FrsImage(uint w, uint h)
  {
    _width = w;
    _height = h;
    _storedWidth = w;
    _storedHeight = h;
    _Ox = 0;
    _Oy = 0;
  }

  FrsImage(uint w, uint h, uint sw, uint sh, uint ox, uint oy)
  {
    _width = w;
    _height = h;
    _storedWidth = sw;
    _storedHeight = sh;
    _Ox = ox;
    _Oy = oy;
  }

  FrsImage &operator=(const FrsImage &brother)
  {
    _width = brother._width;
    _height = brother._height;
    _storedWidth = brother._storedWidth;
    _storedHeight = brother._storedHeight;
    _Ox = brother._Ox;
    _Oy = brother._Oy;
    return *this;
  }

  virtual ~FrsImage() {}

  inline uint width() const
  {
    return _width;
  }

  inline uint height() const
  {
    return _height;
  }

  virtual float pixel(uint x, uint y) const = 0;

  virtual void setArray(float *array,
                        uint width,
                        uint height,
                        uint sw,
                        uint sh,
                        uint x,
                        uint y,
                        bool copy = true) = 0;

  virtual float *getArray() = 0;
 
 protected:
  uint _width;
  uint _height;
  uint _storedWidth;
  uint _storedHeight;
  uint _Ox;  // origin of the stored part
  uint _Oy;  // origin of the stored part
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:FrsImage")
};
 
//
// RGBImage
//
class RGBImage : public FrsImage {
 public:
  RGBImage() : FrsImage()
  {
    _rgb = 0;
  }
 
  RGBImage(const RGBImage &brother) : FrsImage(brother)
  {
    _rgb = new float[3 * _storedWidth * _storedHeight];
    memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
  }
 
  RGBImage(uint w, uint h) : FrsImage(w, h)
  {
    _rgb = new float[3 * _width * _height];
  }
 
  RGBImage(float *rgb, uint w, uint h) : FrsImage(w, h)
  {
    _rgb = new float[3 * _width * _height];
    memcpy(_rgb, rgb, 3 * _width * _height * sizeof(float));
  }

  RGBImage(float *rgb, uint w, uint h, uint sw, uint sh, uint ox, uint oy)
      : FrsImage(w, h, sw, sh, ox, oy)
  {
    _rgb = new float[3 * _storedWidth * _storedHeight];
    memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
  }
 
  RGBImage &operator=(const RGBImage &brother)
  {
    dynamic_cast<FrsImage &>(*this) = brother;
    _rgb = new float[3 * _storedWidth * _storedHeight];
    memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
    return *this;
  }
 
  virtual ~RGBImage()
  {
    if (_rgb) {
      delete[] _rgb;
    }
  }
 
  inline float getR(uint x, uint y) const
  {
    return _rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3];
  }
 
  inline float getG(uint x, uint y) const
  {
    return _rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3 + 1];
  }
 
  inline float getB(uint x, uint y) const
  {
    return _rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3 + 2];
  }
 
  virtual void setPixel(uint x, uint y, float r, float g, float b)
  {
    float *tmp = &(_rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3]);
    *tmp = r;
    tmp++;
    *tmp = g;
    tmp++;
    *tmp = b;
  }
 
  virtual float pixel(uint x, uint y) const
  {
    float res = 0.0f;
    float *tmp = &(_rgb[3 * (y - _Oy) * _storedWidth + (x - _Ox) * 3]);
    res += 11.0f * (*tmp);
    tmp++;
    res += 16.0f * (*tmp);
    tmp++;
    res += 5.0f * (*tmp);
    return res / 32.0f;
  }

  virtual void setArray(
      float *rgb, uint width, uint height, uint sw, uint sh, uint x, uint y, bool copy = true)
  {
    _width = width;
    _height = height;
    _storedWidth = sw;
    _storedHeight = sh;
    _Ox = x;
    _Oy = y;
    if (!copy) {
      _rgb = rgb;
      return;
    }
 
    memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
  }
 
  virtual float *getArray()
  {
    return _rgb;
  }
 
 protected:
  float *_rgb;
};
 
//
// GrayImage
//
 
class GrayImage : public FrsImage {
 public:
  GrayImage() : FrsImage()
  {
    _lvl = 0;
  }
 
  GrayImage(const GrayImage &brother) : FrsImage(brother)
  {
    _lvl = new float[_storedWidth * _storedHeight];
    memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(*_lvl));
  }

  GrayImage(uint w, uint h) : FrsImage(w, h)
  {
    _lvl = new float[_width * _height];
  }
 
  GrayImage(float *lvl, uint w, uint h) : FrsImage(w, h)
  {
    _lvl = new float[_width * _height];
    memcpy(_lvl, lvl, _width * _height * sizeof(*_lvl));
  }

  GrayImage(float *lvl, uint w, uint h, uint sw, uint sh, uint ox, uint oy)
      : FrsImage(w, h, sw, sh, ox, oy)
  {
    _lvl = new float[_storedWidth * _storedHeight];
    memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
  }
 
  GrayImage &operator=(const GrayImage &brother)
  {
    dynamic_cast<FrsImage &>(*this) = brother;
    _lvl = new float[_storedWidth * _storedHeight];
    memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(float));
    return *this;
  }
 
  virtual ~GrayImage()
  {
    if (_lvl) {
      delete[] _lvl;
    }
  }
 
  inline void setPixel(uint x, uint y, float v)
  {
    _lvl[(y - _Oy) * _storedWidth + (x - _Ox)] = v;
  }
 
  inline float pixel(uint x, uint y) const
  {
    return _lvl[(y - _Oy) * _storedWidth + (x - _Ox)];
  }

  void setArray(
      float *lvl, uint width, uint height, uint sw, uint sh, uint x, uint y, bool copy = true)
  {
    _width = width;
    _height = height;
    _storedWidth = sw;
    _storedHeight = sh;
    _Ox = x;
    _Oy = y;
    if (!copy) {
      _lvl = lvl;
      return;
    }
 
    memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
  }

  virtual float *getArray()
  {
    return _lvl;
  }
 
 protected:
  float *_lvl;
};
 
} /* namespace Freestyle */