ColoredImage Class Reference

Class representing a bitmap image colored based on hue/sat/gamma settings. More...

#include <src/image.h>

Classes
struct	Private

Public Member Functions
	ColoredImage (uint32_t width, uint32_t height, const uint8_t *greyLevels, const uint8_t *alphaLevels, int saturation, int hue, int gamma)
	~ColoredImage ()
bool	save (const DString &fileName)

Static Public Member Functions
static void	hsl2rgb (double h, double s, double l, double *pRed, double *pGreen, double *pBlue)

Private Attributes
std::unique_ptr< Private >	p

Detailed Description

Class representing a bitmap image colored based on hue/sat/gamma settings.

Definition at line 57 of file image.h.

Constructor & Destructor Documentation

ColoredImage()

ColoredImage::ColoredImage	(	uint32_t	width,
		uint32_t	height,
		const uint8_t *	greyLevels,
		const uint8_t *	alphaLevels,
		int	saturation,
		int	hue,
		int	gamma )

Definition at line 437 of file image.cpp.

                                             : p(std::make_unique<Private>())
{
  p->hasAlpha = alphaLevels!=nullptr;
  p->width    = width;
  p->height   = height;
  p->data.resize(width*height*4);
  for (uint32_t i=0;i<width*height;i++)
  {
    double red=0.0, green=0.0, blue=0.0;
    hsl2rgb(hue/360.0,                            // hue
            saturation/255.0,                     // saturation
            pow(greyLevels[i]/255.0,gamma/100.0), // luma (gamma corrected)
            &red,&green,&blue);
    Byte r = static_cast<Byte>(red  *255.0);
    Byte g = static_cast<Byte>(green*255.0);
    Byte b = static_cast<Byte>(blue *255.0);
    Byte a = alphaLevels ? alphaLevels[i] : 255;
    p->data[i*4+0]=r;
    p->data[i*4+1]=g;
    p->data[i*4+2]=b;
    p->data[i*4+3]=a;
  }
}

References hsl2rgb(), and p.

Referenced by ~ColoredImage().

~ColoredImage()

ColoredImage::~ColoredImage ( )

default

References ColoredImage().

Member Function Documentation

hsl2rgb()

void ColoredImage::hsl2rgb ( double h, double s, double l, double * pRed, double * pGreen, double * pBlue )

static

Definition at line 373 of file image.cpp.

{
  double r = l;   // default to gray
  double g = l;
  double b = l;
  double v = (l <= 0.5) ? (l * (1.0 + s)) : (l + s - l * s);
  if (v > 0)
  {
    double m       = l + l - v;
    double sv      = ( v - m ) / v;
    h      *= 6.0;
    int sextant = static_cast<int>(h);
    double fract   = h - sextant;
    double vsf     = v * sv * fract;
    double mid1    = m + vsf;
    double mid2    = v - vsf;
    switch (sextant)
    {
      case 0:
        r = v;
        g = mid1;
        b = m;
        break;
      case 1:
        r = mid2;
        g = v;
        b = m;
        break;
      case 2:
        r = m;
        g = v;
        b = mid1;
        break;
      case 3:
        r = m;
        g = mid2;
        b = v;
        break;
      case 4:
        r = mid1;
        g = m;
        b = v;
        break;
      case 5:
        r = v;
        g = m;
        b = mid2;
        break;
    }
  }
  *pRed   = r;
  *pGreen = g;
  *pBlue  = b;
}

Referenced by ColoredImage(), getDirectoryBackgroundColor(), Image::Image(), and replaceColorMarkers().

save()

bool ColoredImage::save

(

const DString &

fileName

)

Definition at line 465 of file image.cpp.

{
  uint8_t *buffer = nullptr;
  size_t bufferSize = 0;
  LodePNG_Encoder encoder;
  LodePNG_Encoder_init(&encoder);
  encoder.infoPng.color.colorType = p->hasAlpha ? 6 : 2; // 2=RGB 24 bit, 6=RGBA 32 bit
  encoder.infoRaw.color.colorType = 6; // 6=RGBA 32 bit
  LodePNG_encode(&encoder, &buffer, &bufferSize, &p->data[0], p->width, p->height);
  LodePNG_saveFile(buffer, bufferSize, fileName.data());
  LodePNG_Encoder_cleanup(&encoder);
  free(buffer);
  return true;
}

References DString::data(), and p.

Member Data Documentation

p

std::unique_ptr<Private> ColoredImage::p

private

Definition at line 71 of file image.h.

Referenced by ColoredImage(), and save().

---

The documentation for this class was generated from the following files:

• src/image.h
• src/image.cpp