i_pixel.h

Go to the documentation of this file.

/*
 * $Id: i_pixel.h 17393 2014-08-23 20:19:14Z predoehl $
 */

#ifndef KJB_CPP_PIXEL_H
#define KJB_CPP_PIXEL_H

#include <l/l_sys_std.h>
#include <l/l_debug.h>
#include <l_cpp/l_util.h>
#include <i/i_float.h>

#include <algorithm> /* for min and max */
#include <sstream>
#include <iomanip>

namespace kjb 
{

std::string pixel_as_hex_triplet_string( const kjb_c::Pixel* );

struct PixelRGBA : public kjb_c::Pixel
{
    PixelRGBA()
        : kjb_c::Pixel()
    {
        // hit KJB(UNTESTED_CODE());
    }

    PixelRGBA(const kjb_c::Pixel& p)
    {
        // hit KJB(UNTESTED_CODE());
        r = p.r;
        g = p.g;
        b = p.b;
        extra.alpha = p.extra.alpha;
    }

    PixelRGBA( float rr, float gg, float bb, float aa = 255.0f )
    {
        // hit KJB(UNTESTED_CODE());
        r = rr;
        g = gg;
        b = bb;
        extra.alpha = aa;
    }

    static PixelRGBA create_gray( float f )
    {
        // hit KJB(UNTESTED_CODE());
        return PixelRGBA( f, f, f );
    }


    static
    void ow_clamp_channel( float* chan )
    {
        // hit KJB(UNTESTED_CODE());
        *chan = std::min( 255.0f, std::max( 0.0f, *chan ) );
    }

    static
    void ow_clamp_channel( float* chan, float minval, float maxval )
    {
        KJB(UNTESTED_CODE());
        *chan = std::min( maxval, std::max( minval, *chan ) );
    }

    PixelRGBA& ow_clamp()
    {
        // hit KJB(UNTESTED_CODE());
        ow_clamp_channel( & this -> r );
        ow_clamp_channel( & this -> g );
        ow_clamp_channel( & this -> b );
        ow_clamp_channel( & this -> extra.alpha );
        return *this;
    }

    PixelRGBA& ow_clamp( float minval, float maxval )
    {
        KJB(UNTESTED_CODE());
        ow_clamp_channel( & this -> r, minval, maxval );
        ow_clamp_channel( & this -> g, minval, maxval );
        ow_clamp_channel( & this -> b, minval, maxval );
        ow_clamp_channel( & this -> extra.alpha, minval, maxval );
        return *this;
    }

    PixelRGBA clamp() const
    {
        // hit KJB(UNTESTED_CODE());
        PixelRGBA clamped( *this );
        clamped.ow_clamp();
        return clamped;
    }

    PixelRGBA clamp( float minval, float maxval ) const
    {
        KJB(UNTESTED_CODE());
        PixelRGBA clamped( *this );
        clamped.ow_clamp( minval, maxval );
        return clamped;
    }

    PixelRGBA& ow_floor()
    {
        KJB(UNTESTED_CODE());
        r = floorf( r );
        g = floorf( g );
        b = floorf( b );
        extra.alpha = floorf( extra.alpha );
        return *this;
    }

    PixelRGBA floor() const
    {
        KJB(UNTESTED_CODE());
        PixelRGBA floored( *this );
        floored.ow_floor();
        return floored;
    }

    PixelRGBA& operator+=( const kjb_c::Pixel& p )
    {
        // hit KJB(UNTESTED_CODE());
        r += p.r;
        g += p.g;
        b += p.b;
        extra.alpha += p.extra.alpha;
        return *this;
    }

    PixelRGBA operator+( const kjb_c::Pixel& p ) const
    {
        // hit KJB(UNTESTED_CODE());
        PixelRGBA sum( *this );
        sum += p;
        return sum;
    }

    PixelRGBA& operator*=(const PixelRGBA& p)
    {
        // hit KJB(UNTESTED_CODE());
        r *= p.r;
        g *= p.g;
        b *= p.b;
        extra.alpha *= p.extra.alpha;
        return *this;
    }

    PixelRGBA& operator*=( float k )
    {
        // hit KJB(UNTESTED_CODE());
        r *= k;
        g *= k;
        b *= k;
        extra.alpha *= k;
        return *this;
    }

    bool operator==( const kjb_c::Pixel& p ) const
    {
        KJB(UNTESTED_CODE());
        return r==p.r && g==p.g && b==p.b && extra.alpha==p.extra.alpha;
    }

    bool operator!=( const kjb_c::Pixel& p ) const
    {
        KJB(UNTESTED_CODE());
        return ! operator==( p );
    }

    std::string as_hex_triplet() const
    {
        return pixel_as_hex_triplet_string( this );
    }
};


inline
PixelRGBA operator*(const PixelRGBA& p, const PixelRGBA& q)
{
    // hit KJB(UNTESTED_CODE());
    PixelRGBA product = p;
    product *= q;
    return product;
}

inline
PixelRGBA operator*( const PixelRGBA& p, double k )
{
    // hit KJB(UNTESTED_CODE());
    PixelRGBA scaled = p;
    scaled *= k;
    return scaled;
}

inline
PixelRGBA operator*( double k, const PixelRGBA& p )
{
    // hit KJB(UNTESTED_CODE());
    return p*k;
}


inline
kjb_c::Pixel abs(const kjb_c::Pixel& p)
{
    kjb_c::Pixel q;
    q.r = fabsf(p.r);
    q.g = fabsf(p.g);
    q.b = fabsf(p.b);

    return q;
}

inline
std::string pixel_as_hex_triplet_string( const kjb_c::Pixel* p )
{
    kjb::PixelRGBA q( *p );
    q.ow_clamp();
    std::ostringstream trip;
    trip    << "#" << std::hex << std::setfill('0')
            << std::setw(2) << int(q.r)
            << std::setw(2) << int(q.g)
            << std::setw(2) << int(q.b);
    return trip.str();
}

inline
std::string pixel_as_hex_triplet_string( const kjb_c::Pixel& p )
{
    return pixel_as_hex_triplet_string( &p );
}


} //namespace kjb

#endif