PaletteRaster.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/rp/PaletteRaster.h

\brief Raster functions to generate palette image.
*/

#ifndef __TERRALIB_RP_INTERNAL_PALETTERASTER_H
#define __TERRALIB_RP_INTERNAL_PALETTERASTER_H



// TerraLib
#include "Config.h"
#include "../raster/Band.h"
#include "../raster/Grid.h"
#include "../raster/Raster.h"
#include "../maptools/RasterTransform.h"

//stl
#include <list>

namespace te
{
  namespace rp
  {

#define   NCUBESDIM 32  //!<  Number of cubes in a dimension
#define   CUBESIZE   8  //!<  CUBESIZE = 256 / NCUBESDIM

    //! \class CubeColor
    //! \brief Defines a cubic volume in the RGB color space
    //!
    //!  The class CubeColor defines a cube of size CUBESIZE (=8) centered
    //!  in a given point in RGB color space. It allows the insertion of
    //!  RGB triplets, calculation of the mean color value (per color)
    //!  of triplets inserted and keeping control of population of
    //!  inserted colors as well.
    //! from Spring code
    class TERPEXPORT CubeColor
    {
    public:

      /*!
      \brief CubeColor constructor
      \param ir:  Red component of color cube center
      \param ig:  Green component of color cube center
      \param ib:  Blue component of color cube center
      */
      CubeColor(int ir, int ig, int ib);

      /*!
      \brief Destructor
      */
      ~CubeColor() {}

      /*!
      \brief Inserts a triple rgb in CubeColor.
      \param r: red component of color
      \param g: green component of color
      \param b: blue component of color
      */
      void InsertTripleRGB(int r, int g, int b);

      /*!
      \brief Get red component of cube center
      \return Index of color red
      */
      int IndexR() { return m_ibr; }

      /*!
      \brief Get green component of cube center
      \return Index of color green
      */
      int IndexG() { return m_ibg; }

      /*!
      \brief Get blue component of cube center
      \return Index of color blue
      */
      int IndexB() { return m_ibb; }

      /*!
      \brief Get i-th mean color component value.
      \param i: color component ( 0 = red, 1 = green, 2 = blue )
      \return i-th mean color component value
      */
      double Mean(int i) { return (i < 3 && i >= 0) ? (m_mean[i]) : (0); }
  
      /*!
      \brief Get number of Image rgb triples in the CubeColor
      \return the population of CubeColor
      */
      double Pop() { return m_pop; }

      /*!
      \brief Get the index of GroupColor associated with CubeColor
      \return the index of CubeColor in the GroupColor.
      */
      int GroupColorIndex() { return m_igc; }

      /*!
      \brief Sets group color index
      */
      void SetGroupColorIndex(int index) { m_igc = index; }

    protected:
      int   m_ibr,    //!< Index of color red   in the color cube space
        m_ibg,    //!< Index of color green in the color cube space
        m_ibb;    //!< Index of color blue  in the color cube space
      int   m_igc;    //!< Index of GroupColor associated with CubeColor
      double  m_mean[3];  //!< Mean of triples from an Image rgb belonging to this CubeColor
      double  m_pop;    //!< Number of Image rgb triples in the CubeColor

    };

    //! \class GroupColor
    //! \brief Defines a classification context
    //!
    //!  The class GroupColor is a container of CubeColor objects allowing
    //!  the generation of statistics ( mean value and standard deviation )
    //!  of the colors in the group.
    //! from Spring code
    class TERPEXPORT GroupColor
    {
      public:

      /*!
      \brief Constructor
      \param ident: group color identifier
      */
      GroupColor(int ident);
    
      /*!
      \brief Destructor
      */
      ~GroupColor();

      /*!
      \brief Inserts a CubeColor in the List.
      \param cc:  a CubeColor object
      */
      void InsertCubeColor(CubeColor *cc);
 
      /*!
      \brief Removes the current item from the list.
      */
      CubeColor* RemoveCubeColor();

      /*!
      \brief Returns the number of CubeColors in this GroupColor
      \return TRUE:  successs or FALSE: failure
      */
      size_t GetNCubeColors() { return m_CClist.size(); }

      /*!
      \brief Splits the GroupColor in two ones. The new GroupColor will have
      its id given by newgcid. The list of ColorCubes in the
      original GroupColor will be divided with the new GroupColor.
      \param newgcid: new group color identifier
      \return pointer to CubeColor (NULL if empty)
      */
      GroupColor* Split(int newgcid);

      /*!
      \brief Return Mean[i] of GroupColor
      \param i: color component ( 0 = red, 1 = green, 2 = blue )
      */
      double Mean(int i) { return (i < 3 && i >= 0 && m_pop != 0) ? ((double)m_Ex[i] / m_pop) : ((double)0); }
 
      /*!
      \brief Returns the biggest variance
      */
      double MaxVar() { return m_varmax; }
 
     private:
      int       m_id;     //!< Id of GroupColor
      double      m_Ex[3];    //!< Expectation of means of CubeColors belonging to this GroupColor
      double      m_Ex2[3];   //!< Expectation of squared means of CubeColors belonging to this GroupColor
      double      m_var[3];   //!< Variance in each dimension of CubeColors belonging to this GroupColor
      double      m_varmax;   //!< Biggest variance
      double      m_pop;    //!< population of group color
      std::list<CubeColor*> m_CClist; //!< List of pointers to CubeColors
      std::list<CubeColor*>::iterator m_itCC; //!< iterator to CubeColors list

    };

    //! \class Codifima
    //!
    //! \brief Defines a Codifima class
    //!
    //!  The class Codifima
    //!  describing the images in use (attribute images, classified images,
    //!  segmented images) and training data set as well.
    //! from Spring code

    class TERPEXPORT Codifima
    {
    protected:

      bool    AllocateMatclass();
      bool  AllocateHist();
      void    DeallocateMatclass();
      void    DeallocateHist();
      bool  histogram_3d();
      int color_generation();
      bool  image_codifying();
      bool    k_means();
      void    Clear();

    public:
      /*!
      \brief Codifies a rgb raster to a paletta raster
      \param inputRaster input rgb raster
      \param rasterTransform RasterTransformation of input raster
      \param outRasterPtr output platter raster
      \paeam palettesize number of colors of palette( default = 256)
      */
       Codifima(const te::rst::Raster& inputRaster,
        te::map::RasterTransform& rasterTransform,
        te::rst::Raster& outRasterPtr,
        int palettesize = 256);

      /*!
      \brief Normal destructor
      */
      ~Codifima() { Clear(); }

      /*!
      \brief Aplies the method
      \return true or false
      */
      bool Apply();

      /*!
      \brief Gets the generated palette
      */
      std::vector< te::rst::BandProperty::ColorEntry > getPalette() { return m_palette; }

      protected:
        const te::rst::Raster* m_inputRaster; //!< input rgb raster
        te::map::RasterTransform* m_rasterTransform; //!< Raster Transformation from input raster
        te::rst::Raster *m_outputRaster; //!< output palette raster
        std::vector< te::rst::BandProperty::ColorEntry > m_palette; //!< generated palette

        te::rst::Band *m_outBand; //!< output band

        unsigned int m_outNCols; //!< output columns number
        unsigned int m_outNRows; //!< output rows number

        int   m_ngc;      //!< number of GroupColors
        int m_firstvr,  //!< fisrt valid red value
          m_lastvr, //!<  last valid red value
          m_firstvg,  //!<  fisrt valid green value
          m_lastvg, //!<  last valid green value
          m_firstvb,  //!<  fisrt valid blue value
          m_lastvb; //!<  last valid blue value

        short m_blockr[256],  //!< red grouping block
          m_blockg[256],  //!< green grouping block
          m_blockb[256];  //!< blue grouping block
        double  **m_lut;  //!< lut - values ​​found for each channel (R,G,B)
        int   m_finalcolors;  //!< final number of colors found
        GroupColor  **m_GC;   //!< array of GroupColors
        std::list<CubeColor*> m_CClist; //!< list of CubeColors present in the Image
        CubeColor ****hist; //!< histogram of CubeColors
        int   ***matclass;  //!< classification matrix
    };

  } // end namespace rp
}   // end namespace te

#endif