ColorTransform.h

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

    TerraLib is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.

    TerraLib is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file terralib/color/ColorTransform.h

  \brief A class to transform .
*/

#ifndef __TERRALIB_COLOR_INTERNAL_COLOR_TRANSFORM_H
#define __TERRALIB_COLOR_INTERNAL_COLOR_TRANSFORM_H

// TerraLib
#include "Config.h"
#include "RGBAColor.h"

// STL 
#include <cassert>
#include <cstdlib>
#include <climits>
#include <cmath>

namespace te
{
  namespace color
  {
    /*!
      \class ColorTransform

      \brief A class to transform RGBA color to HSV, HSL and CMYK.

      \ingroup color
    */
    class TECOLOREXPORT ColorTransform
    {
      public:
      
        enum Spec { Invalid, Rgb, Hsv, Cmyk, Hsl };
   
        /** @name Initializer Methods
         *  Methods related to instantiation and destruction.
         */
        //@{

        /*! \brief Default constructor of a new color. */
        ColorTransform();

        /*!
          \brief It initializes a new with the given color transform.

          \param colt The color transform.
         */
        ColorTransform(const ColorTransform& colt);

        /*!
          \brief It initializes a new color with the given RGBAColor.

          \param color The RGBAColor.
         */
        ColorTransform(const RGBAColor& color);

        /*!
          \brief It initializes a new color with the given rgba value.

          \param rgba The rgba value.
         */
        ColorTransform(const int& rgba);

        /*!
          \brief It initializes a new color.

          \param r Red component (range from 0 to 255).
          \param g Green component (range from 0 to 255).
          \param b Blue component (range from 0 to 255).
          \param a Alpha component. A range from 0 to 255 (see the macro TE_OPAQUE and TE_TRANSPARENT for the values of totally transparent and totally opaque).
         */
        ColorTransform(const int r, const int g, const int b, const int a=255);

        /*! \brief Destructor */
        ~ColorTransform();

        /*!
          \brief Assigns a copy of a color transform and returns a reference to it.

          \param color The color transfom to be copied.

          \return Returns a reference to it.
        */
        te::color::ColorTransform& operator=(const ColorTransform& colt);

        /*!
          \brief It sets the color.

          \param r Red component (range from 0 to 255).
          \param g Green component (range from 0 to 255).
          \param b Blue component (range from 0 to 255).
          \param a Alpha component. A range from 0 to 255 (see the macro TE_OPAQUE and TE_TRANSPARENT for the values of totally transparent and totally opaque).
         */
        void setRgba(int r, int g, int b, int a);

        /*!
          \brief It sets the color.

          \param rgba The color represented by a number of 4 bytes, where the values ??are in the following order: alpha, red, green and blue. The alpha is the most significant byte.
         */
        void setRgba(int rgba);

        /*!
          \brief It sets the color.

          \param cor The RGBA color.
         */
        void setColor(const RGBAColor& cor);

        /*!
          \brief It gets the color value.

          \param r Red component.
          \param g Green component.
          \param b Blue component.
          \param a Alpha component.
         */
        void getRgba(int* r, int* g, int* b, int* a=0) const;

        /*!
          \brief It returns the color value (0xAARRGGBB).

          \return It returns a number of 4 bytes. The values are on the following order: alpha, red, green and blue. The alpha is the most significant byte.
         */
        int getRgba() const;

        /*!
          \brief It returns the RGBA color.

          \return The RGBA color.
         */
        te::color::RGBAColor getColor() const;

        /*!
          \brief It returns the red component.

          \return The red component.
         */
        int getRed() const;

        /*!
          \brief It returns the green component.

          \return The green component.
         */
        int getGreen() const;

        /*!
          \brief It returns the blue component.

          \return The blue component.
         */
        int getBlue() const;

        /*!
          \brief It returns the alpha component.

          \return The alpha component.
         */
        int getAlpha() const;

        /*!
          \brief It sets the red component.
         */
        void setRed(int red);

        /*!
          \brief It sets the green component.
         */
        void setGreen(int green);

        /*!
          \brief It sets the blue component.
         */
        void setBlue(int blue);

        /*!
          \brief It sets the alpha component.
         */
        void setAlpha(int alpha);

        /*!
          \brief It returns the color tranform in Rgb spec.

          \return The color transform in Rgb spec.

          \note If spec is not RGB, it creates and returns an equivalent.
         */
        te::color::ColorTransform toRgb() const;

        /*!
          \brief It returns the color tranform in Hsv spec.

          \return The color transform in Hsv spec.

          \note If spec is not HSV, it creates and returns an equivalent.
         */
        te::color::ColorTransform toHsv() const;

        /*!
          \brief It returns the color tranform in Hsl spec.

          \return The color transform in Hsl spec.

          \note If spec is not HSL, it creates and returns an equivalent.
         */
        te::color::ColorTransform toHsl() const;

        /*!
          \brief It returns the color tranform in Cmyk spec.

          \return The color transform in Cmyk spec.

          \note If spec is not CMYK, it creates and returns an equivalent.
         */
        te::color::ColorTransform toCmyk() const;

        /*!
          \brief It returns the hue component of this color.

          \return The hue value.

          \note The color is implicitly converted to HSV.
        */
        int getHsvHue() const;

        /*!
          \brief It returns the saturation component of this color.

          \return The saturation value.

          \note The color is implicitly converted to HSV.
        */
        int getHsvSaturation() const;

        /*!
          \brief It returns the value component of this color.

          \return The value.

          \note The color is implicitly converted to HSV.
        */
        int getValue() const;

        /*!
          \brief It gets the h, s, v components of this color.

          \param h The hue component.
          \param s The saturation component.
          \param v The value component.
          \param a The alpha component.

          \note The color is implicitly converted to HSV.
        */
        void getHsv(int *h, int *s, int *v, int *a = 0) const;

        /*!
          \brief It sets the h, s, v components of this color.

          \param h The hue component.
          \param s The saturation component.
          \param v The value component.
          \param a The alpha component.

          \note The color is converted to HSV.
        */
        void setHsv(int h, int s, int v, int a = 255);

        /*!
          \brief It gets the cyan component of this color.

          \note The color is implicitly converted to Cmyk.
        */
        int getCyan() const;

        /*!
          \brief It gets the magenta component of this color.

          \note The color is implicitly converted to Cmyk.
        */
        int getMagenta() const;

        /*!
          \brief It gets the yellow component of this color.

          \note The color is implicitly converted to Cmyk.
        */
        int getYellow() const;

        /*!
          \brief It gets the black component of this color.

          \note The color is implicitly converted to Cmyk.
        */
        int getBlack() const;

        /*!
          \brief It gets the c, m, y, k components of this color.

          \param c The cyan component.
          \param m The magenta component.
          \param y The yellow component.
          \param k The black component.
          \param a The alpha component.

          \note The color is implicitly converted to Cmyk.
        */
        void getCmyk(int *c, int *m, int *y, int *k, int *a = 0);

        /*!
          \brief It sets the c, m, y, k components of this color.

          \param c The cyan component.
          \param m The magenta component.
          \param y The yellow component.
          \param k The black component.
          \param a The alpha component.

          \note The color is converted to Cmyk.
        */
        void setCmyk(int c, int m, int y, int k, int a = 255);

        /*!
          \brief It returns the hue component of this color.

          \return The hue value.

          \note The color is implicitly converted to HSL.
        */
        int getHslHue() const;

        /*!
          \brief It returns the saturation component of this color.

          \return The saturation value.

          \note The color is implicitly converted to HSL.
        */
        int getHslSaturation() const;

        /*!
          \brief It returns the lightness component of this color.

          \return The lightness value.

          \note The color is implicitly converted to HSL.
        */
        int getLightness() const;

        /*!
          \brief It gets the h, s, l components of this color.

          \param h The cyan component.
          \param s The magenta component.
          \param l The yellow component.
          \param a The alpha component.

          \note The color is implicitly converted to HSL.
        */
        void getHsl(int *h, int *s, int *l, int *a = 0) const;

        /*!
          \brief It sets the h, s, l components of this color.

          \param h The cyan component.
          \param s The magenta component.
          \param l The yellow component.
          \param a The alpha component.

          \note The color is converted to HSL.
        */
        void setHsl(int h, int s, int l, int a = 255);

        /*!
          \brief It compares the color tranforms are iqual.

          \param colt The color transform to be compared.
            
          \return Returns true if this color transform has the same properties.
       */
        bool operator==(const ColorTransform& colt) const;

        /*!
          \brief It compares the color tranforms are different.

          \param colt The color transform to be compared.
            
          \return Returns true if this color transform has not the same properties.
       */
        bool operator!=(const ColorTransform& colt) const;

        //@}

      private:

        /*!
          \brief Marks the color transform as invalid and sets all components to zero (alpha is set to fully opaque).
         */
        void invalidate();

        /*!
          \brief It checks if the color is valid.

          \return True if valid color.
         */
        inline bool isValid() const;

        /*!
          \brief It rounds the double value to int value.

          \return The int value rounded.
         */
        int round(double d) const;

        /*!
          \brief It compares the double valuea are iqual.

          \param p1 First value.
          \param p2 Second value.

          \return True if values are equal.
         */
        bool fuzzyCompare(double p1, double p2) const;

        /*!
          \brief It verifies the double is null.

          \param d Value to be verified.

          \return True if value is null.
         */
        bool fuzzyIsNull(double d) const;

        template <typename T>
        const T& vMin(const T &a, const T &b) const {if (a < b) return a; return b;}


      private:
        Spec m_spec;

        union 
        {
          struct 
          {
            unsigned short alpha;
            unsigned short red;
            unsigned short green;
            unsigned short blue;
            unsigned short pad;
          } argb;

          struct 
          {
            unsigned short alpha;
            unsigned short hue;
            unsigned short saturation;
            unsigned short value;
            unsigned short pad;
          } ahsv;

          struct 
          {
            unsigned short alpha;
            unsigned short cyan;
            unsigned short magenta;
            unsigned short yellow;
            unsigned short black;
          } acmyk;

          struct 
          {
            unsigned short alpha;
            unsigned short hue;
            unsigned short saturation;
            unsigned short lightness;
            unsigned short pad;
          } ahsl;

          unsigned short array[5];
        } m_params;
    };

    inline void ColorTransform::invalidate()
    {
        m_spec = Invalid;
        m_params.argb.alpha = USHRT_MAX;
        m_params.argb.red = 0;
        m_params.argb.green = 0;
        m_params.argb.blue = 0;
        m_params.argb.pad = 0;
    }

    inline bool ColorTransform::isValid() const
    { 
      return m_spec != Invalid; 
    }

    inline int ColorTransform::round(double d) const
    { 
      return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); 
    }

    inline bool ColorTransform::fuzzyCompare(double p1, double p2) const
    {
        return (fabs(p1 - p2) <= 0.000000000001 * vMin(fabs(p1), fabs(p2)));
    }

    inline bool ColorTransform::fuzzyIsNull(double d) const
    {
        return fabs(d) <= 0.000000000001;
    }

    //template <typename T>
    //inline const T& vMin(const T &a, const T &b) const
    //{
    //  if (a < b) 
    //    return a; 
    //  return b; 
    //}

  }   // end namespace color
}     // end namespace te

#endif  // __TERRALIB_COLOR_INTERNAL_COLOR_TRANSFORM_H