RasterSymbolizer.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/se/RasterSymbolizer.h
 
  \brief The RasterSymbolizer describes how to render raster/matrix-coverage data (e.g., satellite photos, DEMs).
*/
 
#ifndef __TERRALIB_SE_INTERNAL_RASTERSYMBOLIZER_H
#define __TERRALIB_SE_INTERNAL_RASTERSYMBOLIZER_H
 
// TerraLib
#include "Symbolizer.h"
 
namespace te
{
  namespace fe { class PropertyName; }
 
  namespace se
  {
// Forward declarations
    class ChannelSelection;
    class ColorMap;
    class ContrastEnhancement;
    class ImageOutline;
    class ParameterValue;
    class ShadedRelief;
 
    /*!
      \class RasterSymbolizer
      
      \brief The RasterSymbolizer describes how to render raster/matrix-coverage data (e.g., satellite photos, DEMs).
 
      A RasterSymbolizer is used to specify the rendering of
      raster/matrix-coverage data (e.g., satellite images, DEMs).
      <br>
      Geometry-type transformations are also system-dependent and
      it is assumed that this capability will be little used.
 
      \ingroup se
 
      \sa Symbolizer, te::fe::PropertyName, ParameterValue, ChannelSelection, ColorMap, ContrastEnhancement, ShadedRelief, ImageOutline
    */
    class TESEEXPORT RasterSymbolizer : public Symbolizer
    {
      public:
 
        TE_DEFINE_VISITABLE
 
        /*!
          \enum OverlapBehavior
 
          \brief OverlapBehavior tells a system how to behave when multiple
                 raster images in a layer overlap each other, for example with
                 satellite-image scenes.
        */
        enum OverlapBehavior
        {
          LATEST_ON_TOP,      /*!< It refers to the time the scene was captured.       */
          EARLIEST_ON_TOP,    /*!< It refers to the time the scene was captured.       */
          AVERAGE,            /*!< It means to average multiple scenes together. This
                                   can produce blurry results if the source images
                                   are not perfectly aligned in their geo-referencing. */
          RANDOM,             /*!< It means to select an image (or piece thereof)
                                   randomly and place it on top.                       */
          NO_BEHAVIOR
        };
 
        /** @name Initializer Methods
         *  Methods related to instantiation and destruction.
         */
        //@{
 
        /*! \brief It initializes a new RasterSymbolizer. */
        RasterSymbolizer();
 
        /*!
          \brief Copy constructor.
 
          \param rhs The other raster symbolizer.
        */
        RasterSymbolizer(const RasterSymbolizer& rhs);
 
        /*! \brief Destructor. */
        ~RasterSymbolizer();
 
        //@}
 
        /** @name Accessor methods
         *  Methods used to get or set properties.
         */
        //@{
 
        void setGeometry(te::fe::PropertyName* g);
 
        void setOpacity(ParameterValue* p);
        
        void setGain(ParameterValue* p);
        
        void setOffset(ParameterValue* p);
 
        void setNoDataValue(ParameterValue* p);
        
        void setChannelDomain(ParameterValue* p);
 
        ParameterValue* getOpacity() const { return m_opacity; }
 
        ParameterValue* getGain() const { return m_gain; }
 
        ParameterValue* getOffset() const { return m_offset; }
 
        ParameterValue* getNoDataValue() const { return m_noDataValue; }
        
        ParameterValue* getChannelDomain() const { return m_channelDomain; }
 
        void setChannelSelection(ChannelSelection* c);
 
        te::se::ChannelSelection* getChannelSelection() const { return m_channelSelection; }
 
        void setOverlapBehavior(OverlapBehavior b);
 
        OverlapBehavior getOverlapBehavior() const { return m_overlapBehavior; }
 
        void setColorMap(ColorMap* c);
 
        te::se::ColorMap* getColorMap() const { return m_colorMap; }
 
        void setContrastEnhancement(ContrastEnhancement* c);
 
        te::se::ContrastEnhancement* getContrastEnhancement() const { return m_contrastEnhancement; }
 
        void setShadedRelief(ShadedRelief* s);
 
        ShadedRelief* getShadedRelief() const { return m_shadedRelief; }
 
        void setImageOutline(ImageOutline* i);
 
        te::se::ImageOutline* getImageOutline() const { return m_imageOutline; }
 
        const std::string& getType() const;
 
        //@}
 
        /*! \brief It creates a new copy of this object. */
        Symbolizer* clone() const;
 
      private:
 
        te::fe::PropertyName* m_geometry;           //!< The interpretation of Geometry is system-dependent, as raster data may be organized differently from feature data, though omitting this element selects the default raster-data source. (Optional)
        ParameterValue* m_opacity;                  //!< An Opacity of 0.0 can be selected for the main raster to avoid rendering the main-raster pixels, or an opacity can be used for a PolygonSymbolizer Fill to allow the main-raster data be visible through the fill. (Optional)
        ParameterValue* m_gain;                     //!< It defines the gain value used to renderer the main raster pixels, a initial value could be 1.0. (Optional)
        ParameterValue* m_offset;                   //!< It defines the offset value used to renderer the main raster pixels, a initial value could be 0.0. (Optional)
        ParameterValue* m_noDataValue;              //!< It defines the no data value used to renderer the main raster pixels, a initial value is infinite value. (Optional)
        ParameterValue* m_channelDomain;            //!< It defines The channel domain (real, imaginary, i.e.) to use as source (see te::map::RasterTransform::ChannelDomain for reference).
        ChannelSelection* m_channelSelection;       //!< It specifies the false-color channel selection for a multi-spectral raster source (such as a multi-band satellite-imagery source). (Optional)
        OverlapBehavior m_overlapBehavior;          //!< It tells a system how to behave when multiple raster images in a layer overlap each other, for example with satellite-image scenes. (Optional)
        ColorMap* m_colorMap;                       //!< It defines either the colors of a pallette-type raster source or the mapping of numeric pixel values to colors. (Optional)
        ContrastEnhancement* m_contrastEnhancement; //!< It defines contrast enhancement for a channel of a false-color image or for a color image. (Optional)
        ShadedRelief* m_shadedRelief;               //!< It selects the application of relief shading (or "hill shading") to an image for a three-dimensional visual effect. (Optional)
        ImageOutline* m_imageOutline;               //!< It specifies how individual source rasters in a multi-raster set (such as a set of satellite-image scenes) should be outlined to make the individual-image locations visible. (Optional)
 
        static const std::string sm_type;           //!< A static data member used in the implementation of getType method.
    };
 
  } // end namespace se
}   // end namespace te
 
#endif  // __TERRALIB_SE_INTERNAL_RASTERSYMBOLIZER_H