ColorImages.h

Go to the documentation of this file.

 
/* *************************************************************************/
#ifndef COLORIMAGES
#define COLORIMAGES
 
#include <type_traits>
#include <climits>
#include <memory>
#include <vector>
#include <string>
#include "CppAddons.h"
 
 
 
/* =============================================================================
 
                RGB COLORS AND PALETTES
            
==============================================================================*/
            
 
/* ***************************************************************************
*
*    Class: RGBColor
*
*******************************************************************************/
 
class RGBColor
{
 public:
 
    using CompLevel = uint8_t;
 
    static constexpr double kMaxRGBDist2 = 255.0 * 255.0 * 3.0;
 
    
    RGBColor(CompLevel r = 0, CompLevel g = 0, CompLevel b = 0) { set(r,g,b); }
        
    RGBColor(const CompLevel * rgb) { set(rgb); }
    
    RGBColor(const RGBColor &) = default;
    RGBColor(RGBColor &&) = default;
    RGBColor & operator=(const RGBColor &) = default;
    RGBColor & operator=(RGBColor &&) = default;
    
    virtual ~RGBColor(void) = default;
    
          
    CompLevel r(void) const noexcept { return(rgb_[0]); }
 
    CompLevel g(void) const noexcept { return(rgb_[1]); }
 
    CompLevel b(void) const noexcept { return(rgb_[2]); }   
    
    const CompLevel * rgb(void) const noexcept { return(rgb_); }
 
    void rgbRead(CompLevel * rgb) const noexcept { std::copy(rgb_,rgb_+3,rgb); }
    
    void setR(CompLevel r) noexcept { rgb_[0] = r; }
 
    void setG(CompLevel g) noexcept { rgb_[1] = g; }
    
    void setB(CompLevel b) noexcept { rgb_[2] = b; }    
    
    void set(CompLevel r, CompLevel g, CompLevel b) noexcept
        { rgb_[0] = r; rgb_[1] = g; rgb_[2] = b; }
 
    void set(const CompLevel * rgb) noexcept { std::copy(rgb,rgb + 3,rgb_); }
        
    
 
    void vector(const RGBColor & oth, double * rgbv) const noexcept;
 
    double rgbDistance2(const RGBColor & oth) const;
    
    void setFromHTMLString(const std::string & c);
 
    std::string getHTMLString(void) const;
 
    
    bool operator==(const RGBColor & oth) const noexcept
        { return((rgb_[0] == oth.rgb_[0]) &&
                 (rgb_[1] == oth.rgb_[1]) &&
                 (rgb_[2] == oth.rgb_[2])); }
 
    bool operator!=(const RGBColor & oth) const noexcept
        { return(!operator==(oth)); }
    
 
    std::string to_string(void) const;
 
    
 private:
 
    CompLevel rgb_[3];
};
 
 
/* ***************************************************************************
*
*    Class: RGBPalette
*
*******************************************************************************/
 
class RGBPalette
{
 public:
 
    using Size = uint32_t;
    
    using Index = Size;
        
 
    RGBPalette(Size s);
    
 
    RGBPalette(const RGBColor::CompLevel * rgbs, Size s);
        
    RGBPalette(const RGBPalette &) = delete;
    RGBPalette & operator=(const RGBPalette &) = delete;
    RGBPalette(RGBPalette && oth) = default;
    RGBPalette & operator=(RGBPalette &&) = default;
    
    virtual ~RGBPalette(void) = default;
    
    Size numColors(void) const noexcept { return(static_cast<Size>(pal_.size())); }
    
    const RGBColor & operator[](Index ind) const;   
    
    RGBColor & operator[](Index ind);
 
 
    Index closestColor(const RGBColor & col) const noexcept;
 
    std::string to_string(void) const;
 
 private:
 
    std::vector<RGBColor> pal_;
};
 
 
 
/* =============================================================================
 
                IMAGES
            
==============================================================================*/
 
 
/* ***************************************************************************
*
*    Type: ImageCoordDim
*
*******************************************************************************/
 
using ImageCoordDim = unsigned;
 
 
/* ***************************************************************************
*
*    Template class: RasterCursor
*
*******************************************************************************/
 
 
template <ImageCoordDim CELLW = 1, ImageCoordDim CELLH = 1>
class RasterCursor
{
 public:
 
 
    RasterCursor(ImageCoordDim wimage,
                 ImageCoordDim himage): wimg_{wimage},himg_{himage}
        { if ((wimage == 0) || (himage == 0))
            RUNTIMEEXCEP("Cannot create cursor for empty image");
          resetRegion(); } 
          
    RasterCursor(const RasterCursor &) = default;
    RasterCursor(RasterCursor &&) = default;
    RasterCursor & operator=(const RasterCursor &) = default;
    RasterCursor & operator=(RasterCursor &&) = default;
    virtual ~RasterCursor(void) = default;
    
 
    constexpr ImageCoordDim cellW(void) const noexcept { return(CELLW); }
 
    constexpr ImageCoordDim cellH(void) const noexcept { return(CELLH); }
 
 
    void setRegion(ImageCoordDim xmin, ImageCoordDim xlength,
                   ImageCoordDim ymin, ImageCoordDim ylength)
        { regionleft_ = xmin; regionright_ = xmin + xlength - 1;
          regiontop_ = ymin; regionbottom_ = ymin + ylength - 1;
          if (regionright_ >= wimg_) 
            {   regionright_ = wimg_ - 1; 
                xlength = regionright_ - xmin + 1; }
          if (regionbottom_ >= himg_)
            {   regionbottom_ = himg_ - 1;
                ylength = regionbottom_ - ymin + 1; }
          if ((xlength == 0) || (ylength == 0) ||
              (regionright_ < xmin) || (regionbottom_ < ymin))
            RUNTIMEEXCEP("Invalid region [l" + 
                         std::to_string(xmin) + ",w" +
                         std::to_string(xlength) + ",t" +
                         std::to_string(ymin) + ",h" +
                         std::to_string(ylength) +
                         " within image of " +
                         std::to_string(wimg_) + "x" +
                         std::to_string(himg_) + 
                         " for a cursor");
          reset();
          lastcellx_ = xmin + lastAllowedCoord(xlength,CELLW);
          regionwidthm1cell_ = lastcellx_ - xmin;
              sizeonecellrow_ = static_cast<size_t>(CELLH) *
                                static_cast<size_t>(wimg_); }
          
    void resetRegion(void) { setRegion(0,wimg_,0,himg_); }
    
    bool inside(void) const noexcept 
        { return((x_ >= regionleft_) && (x_ <= regionright_) &&
                 (y_ >= regiontop_) && (y_ <= regionbottom_)); }
 
 
    RasterCursor<1,1> subCursor(void) const
        { checkInside(); RasterCursor<1,1> resc{wimg_,himg_}; 
          resc.setRegion(x_,CELLW,y_,CELLH);
          return(resc); }
                 
 
 
    void set(ImageCoordDim xc, ImageCoordDim yc) noexcept
        { setPixel(regionleft_ + xc * CELLW, regiontop_ + yc * CELLH); }
                    
    void reset(void) noexcept { setPixel(regionleft_,regiontop_); }
            
 
    ImageCoordDim x(void) const noexcept 
        { return((x_ - regionleft_) / CELLW); }
 
 
    ImageCoordDim y(void) const noexcept 
        { return((y_ - regiontop_) / CELLH);}               
 
 
    ImageCoordDim xPixel(void) const noexcept { return(x_); }
 
 
    ImageCoordDim yPixel(void) const noexcept { return(y_); }            
 
 
    size_t globalOffset(void) const { checkInside(); return(offset_); } 
    
 
    bool right(void) noexcept
        {   if ((!inside()) || (x_ >= lastcellx_)) return(false);
            x_ += CELLW; offset_ += CELLW; return(true); }
            
 
    bool forward(void) noexcept
        {   if (!inside()) return(false);
            if (!right()) // then, x_ == lastcellx_
                { x_ = regionleft_; y_ += CELLH; 
                  offset_ = offset_ - 
                            static_cast<size_t>(regionwidthm1cell_) + 
                            sizeonecellrow_;
                  lastrowchange_ = true; }
            else lastrowchange_ = false;
            return(inside()); }
                                                    
 
    bool lastChangedRow(void) const noexcept { return(lastrowchange_); }                                     
                                 
 
    std::string to_string(bool summary = true) const
        { std::string res{"RasterCursor<"};
          res += std::to_string(CELLW) + "," + std::to_string(CELLH) +
                 ">[@(" + std::to_string(x_) + "," + std::to_string(y_) +
                 "), offs " + std::to_string(offset_) + ", region (l" +
                 std::to_string(regionleft_) + ",r" + 
                 std::to_string(regionright_) + ",t" +
                 std::to_string(regiontop_) + ",b" +
                 std::to_string(regionbottom_);
          if (!summary) 
            res += "; lastcellx " +
                 std::to_string(lastcellx_) + ", regionwidth-1cell " +
                 std::to_string(regionwidthm1cell_) + ")," + 
                 (inside() ? "in" : "out") + "," +
                 (lastChangedRow() ? "changedRow" : "no-row-changed");
          res += "]";
          return(res); }
    
 private:
 
    static constexpr ImageCoordDim lastAllowedCoord(ImageCoordDim avdim,
                                                    ImageCoordDim celldim) 
                                                                    noexcept
        { return(celldim <= avdim ? // cell length <= available length
                    (avdim % celldim == 0 ? avdim - celldim :
                                        avdim - (avdim % celldim)) :
                    0); } // cell length > available length
 
    
    ImageCoordDim wimg_,himg_;
    
    ImageCoordDim x_,y_; // in pixels, not in cells, ignoring region.
    size_t offset_; // in the whole image, ignoring region.
    ImageCoordDim regionleft_,regionright_,regiontop_,regionbottom_;
    ImageCoordDim regionwidthm1cell_,lastcellx_;
    size_t sizeonecellrow_;
    bool lastrowchange_;
    
 
    void checkInside(void) const
        { if (!inside()) 
            RUNTIMEEXCEP("Tried to access out of range RasterImage cursor: " 
                         + to_string()); }
        
    constexpr size_t offsetOfPixel(ImageCoordDim x,ImageCoordDim y) noexcept
        { return(static_cast<size_t>(x_) + static_cast<size_t>(y_) * 
                 static_cast<size_t>(wimg_)); }
 
    void setPixel(ImageCoordDim x, ImageCoordDim y) noexcept
        { x_ = x; y_ = y; offset_ = offsetOfPixel(x_,y_);
          lastrowchange_ = false; }
 
 
    static_assert((CELLW > 0) && (CELLH > 0),
                  "RasterCursor tessellation must have non-empty cells");
};
 
 
/* ***************************************************************************
*
*    Template class: RasterImage
*
*******************************************************************************/
 
 
template <typename PixelType>
class RasterImage
{
 public:
 
    RasterImage(void) = default;
    
 
    RasterImage(ImageCoordDim w, ImageCoordDim h): w_{w}, h_{h}
        { if ((w != 0) && (h != 0))
            {   numofpxs_ = static_cast<size_t>(w_) * static_cast<size_t>(h_);
                pimg_ = SafeImgPtr(new PixelType [numofpxs_]); } }
            
    RasterImage(const RasterImage &) = delete;
    RasterImage(RasterImage && oth) { moveFrom(std::move(oth)); }
    RasterImage & operator=(const RasterImage &) = delete;
    RasterImage & operator=(RasterImage && oth)
        { if (this != &oth) moveFrom(std::move(oth)); return(*this); }
    
    
    virtual ~RasterImage(void) = default;
    
    bool empty(void) const noexcept { return(!pimg_); }
    ImageCoordDim width(void) const noexcept { checkEmptied(); return(w_); }
    ImageCoordDim height(void) const noexcept { checkEmptied(); return(h_); }
    size_t numPixels(void) const noexcept { checkEmptied(); return(numofpxs_); }
 
    template <ImageCoordDim CELLW = 1, ImageCoordDim CELLH = 1>
    RasterCursor<CELLW,CELLH> makeCursor(void) const
        { checkEmptied(); return(RasterCursor<CELLW,CELLH>{w_,h_}); }
 
    template <ImageCoordDim CELLW = 1, ImageCoordDim CELLH = 1>
    PixelType & pixel(const RasterCursor<CELLW,CELLH> & cursor) 
        { checkEmptied(); return(pimg_.get()[cursor.globalOffset()]); }
 
    template <ImageCoordDim CELLW = 1, ImageCoordDim CELLH = 1>
    const PixelType & pixel(const RasterCursor<CELLW,CELLH> & cursor) const
        { checkEmptied(); return(pimg_.get()[cursor.globalOffset()]); }
 
    PixelType * contigContent(void) noexcept 
        { checkEmptied(); return(pimg_.get()); }
    const PixelType * contigContent(void) const noexcept 
        { checkEmptied(); return(pimg_.get()); }
    
 private:
 
    using SafeImgPtr = std::unique_ptr< PixelType [] >;
 
    ImageCoordDim w_,h_;
    size_t numofpxs_;
    SafeImgPtr pimg_;    
    
    void checkEmptied(void) const 
        { if (empty()) RUNTIMEEXCEP("Emptied RasterImage"); }
    
    void moveFrom(RasterImage && oth)
        { w_ = oth.w_; h_ = oth.h_; numofpxs_ = oth.numofpxs_; 
          pimg_ = std::move(oth.pimg_); }
 
};
 
 
/* ***************************************************************************
*
*    Template class: RGBImage
*
*******************************************************************************/
 
 
using ThreeBytes = uint8_t[3];
 
 
using RGBImage = RasterImage<ThreeBytes>;
 
 
/* ***************************************************************************
*
*    Template class: PalettizedImage
*
*******************************************************************************/
 
 
template <typename ColorIndex>
class PalettizedImage: public RasterImage<ColorIndex>
{
 public:
 
    using Base = RasterImage<ColorIndex>;
 
    PalettizedImage(void) = default;
    
 
    PalettizedImage(const RGBPalette & pal,
                    unsigned w, unsigned h):Base{w,h}, 
                                            pal_{&pal} 
        { if (bits_of_value(pal.numColors()) > 
              FIntTraits<ColorIndex>::sizeinbits)
            RUNTIMEEXCEP("Incompatible palette for given PalettizedImage"); }
            
    PalettizedImage(const RGBPalette & pal,
                    const RGBImage & img):  PalettizedImage{pal,
                                                            img.width(),
                                                            img.height()}
        {
            auto rgbcur = img.makeCursor(); // 1 pixel resolution
            auto thiscur = this->makeCursor(); // 1 pixel resolution
            do this->pixel(thiscur) = pal.closestColor(
                    RGBColor{reinterpret_cast<const uint8_t *>(
                                img.pixel(rgbcur))});
            while (rgbcur.forward() && thiscur.forward());
        }
            
    PalettizedImage(const PalettizedImage &) = delete;
    PalettizedImage(PalettizedImage && oth) { moveFrom(std::move(oth)); }
    PalettizedImage & operator=(const PalettizedImage &) = delete;
    PalettizedImage & operator=(PalettizedImage && oth)
        { if (this != &oth) moveFrom(std::move(oth)); return(*this); }
    
    virtual ~PalettizedImage(void) = default;
    
    
    const RGBPalette & palette(void) const noexcept 
        { checkEmptied(); return(*pal_); }
 
    RGBImage toRGBImg(void) const
        {
            RGBImage res{Base::width(),Base::height()};
            auto pixcur = Base::makeCursor(); // scan pixel per pixel
            auto rgbcur = res.makeCursor();
            do
            {
                auto pixcolind = Base::pixel(pixcur);
                const RGBColor & rgbc = (*pal_)[pixcolind];
                auto & p = res.pixel(rgbcur);
                p[0] = rgbc.r();
                p[1] = rgbc.g();
                p[2] = rgbc.b();
            } while (pixcur.forward() && rgbcur.forward());
            return(res);
        }
        
 private:
 
    const RGBPalette * pal_;
    
    void checkEmptied(void) const 
        { if (Base::empty()) RUNTIMEEXCEP("Emptied palettized image"); }
    
    void moveFrom(PalettizedImage && oth)
        { Base::operator=(std::move(oth)); pal_ = oth.pal_; }
 
    static_assert(std::is_arithmetic<ColorIndex>::value &&
                  std::is_unsigned<ColorIndex>::value,
                  "ColorIndex template argument must be an unsigned type");
};
 
 
 
#endif
 // ColorPalettes