fimRgba.hpp

//
// Copyright (c) Singular Inversions Inc. 2001.
//
// Created:     Authors:        Change:
// 12/5/01      ABeatty         Create
//
// The arithmetic operators are all designed to be compatible with a
// pre-alpha-weighted approach.
//
 
#ifndef FIM_RGBA_H
#define FIM_RGBA_H
 
#include "algs.hpp"
 
namespace Fg {
 
typedef enum
{
    FIMRGBA_R = 0,
    FIMRGBA_G,
    FIMRGBA_B,
    FIMRGBA_A,
    FIMRGBA_SIZE
 
}   FimRgbaE;
 
template<class T>
struct  FimRgbaT
{
    T   c[FIMRGBA_SIZE];
 
    typedef T pixel_index_type;
 
    FimRgbaT() {}
    explicit FimRgbaT(T v) {c[0]=c[1]=c[2]=c[3]=v; }
    FimRgbaT(T red,T green,T blue,T alpha)
    {
        c[FIMRGBA_R] = red;
        c[FIMRGBA_G] = green;
        c[FIMRGBA_B] = blue;
        c[FIMRGBA_A] = alpha;
    }
    FimRgbaT(const FimRgbaT& rhs) = default;
    FimRgbaT &      operator=(FimRgbaT const &) = default;
 
        // The conversion constructor. Note that this must be explicit for safety and also
        // requires the CC to be explicitly defined.
    template<class U>
    explicit FimRgbaT(const FimRgbaT<U>& v)
        {for (uint ii=0; ii<FIMRGBA_SIZE; ++ii) futConvert(v.c[ii],c[ii]); }
 
    const FimRgbaT  operator+(const FimRgbaT& v) const
        {return FimRgbaT<T>(c[0]+v.c[0],c[1]+v.c[1],c[2]+v.c[2],c[3]+v.c[3]); }
 
    void operator+=(const FimRgbaT& v)
        {for (uint ii=0; ii<FIMRGBA_SIZE; ++ii) c[ii] = c[ii] + v.c[ii]; }
 
    const FimRgbaT  operator*(T v) const
        {return FimRgbaT<T>(c[0]*v,c[1]*v,c[2]*v,c[3]*v); }
 
    FimRgbaT operator/(T v) const 
        {return FimRgbaT(c[0]/v,c[1]/v,c[2]/v,c[3]/v); }
 
    void operator*=(T v)
        {c[0] *= v;c[1] *= v;c[2] *= v;c[3] *= v; }
};
 
// **************************************************************************
// **************************************************************************
 
typedef FimRgbaT<uchar>     FimRgbaUbC;
typedef FimRgbaT<schar>     FimRgbaSbC;
typedef FimRgbaT<ushort>    FimRgbaUsC;
typedef FimRgbaT<short>     FimRgbaSsC;
typedef FimRgbaT<float>     FimRgbaFC;
 
inline FimRgbaFC
operator*(FimRgbaUbC pix, float v)
{
    return FimRgbaFC(float(pix.c[0])*v,
                     float(pix.c[1])*v,
                     float(pix.c[2])*v,
                     float(pix.c[3])*v);
}
inline FimRgbaFC
operator*(FimRgbaSbC pix, float v)
{
    return FimRgbaFC(float(pix.c[0])*v,
                     float(pix.c[1])*v,
                     float(pix.c[2])*v,
                     float(pix.c[3])*v);
}
inline FimRgbaFC
operator*(FimRgbaSsC pix, float v)
{
    return FimRgbaFC(float(pix.c[0])*v,
                     float(pix.c[1])*v,
                     float(pix.c[2])*v,
                     float(pix.c[3])*v);
}
 
template<class T,class U>
void
futConvert(const FimRgbaT<T> &a,FimRgbaT<U> &b)
{
    for (uint ii=0; ii<FIMRGBA_SIZE; ++ii)
        futConvert(a.c[ii],b.c[ii]);
}
 
}
 
#endif