Observation.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 Observations.h
 
  \brief This file contains a class to represent an observation.
*/
 
#ifndef __TERRALIB_ST_INTERNAL_OBSERVATION_H
#define __TERRALIB_ST_INTERNAL_OBSERVATION_H
 
//ST
#include "../../Config.h"
 
//Boost
#include <boost/ptr_container/ptr_vector.hpp>
 
// Forward declarations
namespace te { namespace dt { class AbstractData; class DateTime; class DateTimePeriod;
                              class DateTimeInstant; } }
 
namespace te { namespace gm { class Geometry; } }
 
namespace te
{
  namespace st
  {
    /*!
      \class Observation
 
      \brief A class to represent an observation.
 
      An observation is a result of a measurement associated to a discrete 
      time instant or period which assigns values to a phenomenon. It follows
      the OGC's Observation and Measurement (O&M) specification.
      An observation is composed of: (1) a phenomenon time, (2) a valid time, 
      (3) a result time, (4) observed values. 
 
      \ingroup st
 
      \sa ObservationDataSet AbstractData DateTime 
    */
    class TESTEXPORT Observation
    {
      public:
 
        /*! \brief It constructs an empty Observation 
        */
        Observation();           
        
        /*! 
          \brief Constructor. 
          
          \param phTime  A pointer to phenomenon time. 
 
          \note It will take the ownership of the DateTime input pointer.
        */
        Observation(te::dt::DateTime* phTime);
        
        /*! 
          \brief Constructor. 
          
          \param phTime   A pointer to phenomenon time. 
          \param obsValue A observed value.
 
          \note It will take the ownership of the DateTime and AbstractData input pointers.
        */
        Observation(te::dt::DateTime* phTime, te::dt::AbstractData* obsValue);
 
        /*! 
          \brief Constructor. 
          
          \param phTime     A pointer to phenomenon time.
          \param geom       The observation location.
          \param obsValues  The observed values. 
 
          \note It will take the ownership of the input pointers.
        */
        Observation(te::dt::DateTime* phTime, te::gm::Geometry* geom, 
                    const boost::ptr_vector<te::dt::AbstractData>& obsValues);
 
        /*! 
          \brief Constructor. 
          
          \param phTime     A pointer to phenomenon time.
          \param resTime    A pointer to the result time.
          \param valTime    A pointer to the valid time.
          \param geom       The observation location.
          \param obsValues  The observed values. 
 
         \note It will take the ownership of the input pointers.
        */
        Observation(te::dt::DateTime* phTime, te::dt::DateTimeInstant* resTime, 
                    te::dt::DateTimePeriod* valTime, te::gm::Geometry* geom,
                    const boost::ptr_vector<te::dt::AbstractData>& obsValues);           
 
         /*! \brief Copy constructor. */
        Observation(const Observation& obs); 
 
        /*! 
          \brief Assignment operator.
        */
        const Observation& operator=(const Observation& rhs);
        
        /*!
          \brief It returns the phenomenon time.
 
          \return A pointer to the phenomenon time.
 
          \note The caller will NOT take the ownership of the returned pointer.
        */
        te::dt::DateTime* getTime() const;
        
        /*!
          \brief It sets the phenomenon time.
 
          \param A pointer to the the phenomenon time.
 
          \note It will take the ownership of the input pointer.
        */
        void setTime(te::dt::DateTime* phTime);
 
        /*!
          \brief It returns the result time.
 
          \return A pointer to the result time.
 
          \note The caller will NOT take the ownership of the returned pointer.
        */
        te::dt::DateTimeInstant* getResultTime() const;
        
        /*!
          \brief It sets the result time.
 
          \param A pointer to the result time.
 
          \note It will take the ownership of the input pointer.
         */
        void setResultTime(te::dt::DateTimeInstant* resTime);
 
         /*!
          \brief It returns the valid time.
 
          \return A pointer to the valid time.
 
          \note The caller will NOT take the ownership of the returned pointer.
        */
        te::dt::DateTimePeriod* getValidTime() const;
        
        /*!
          \brief It sets the valid time.
 
          \param A pointer to the valid time.
 
          \note It will take the ownership of the input pointer.
         */
        void setValidTime(te::dt::DateTimePeriod* valTime);
 
        /*!
          \brief It returns the observed values.
 
          \return A reference to the observed values.
 
          \note The caller will NOT take the ownership of the returned pointer.
        */
        boost::ptr_vector<te::dt::AbstractData>& getObservedValues();
 
        /*!
          \brief It returns the idx-th observed value.
 
          \return A pointer to the idx-th observed value.
 
          \note The caller will NOT take the ownership of the returned pointer.
        */
        const te::dt::AbstractData* getObservedValue(int idx = 0) const;        
 
        /*!
          \brief It adds an observed value.
 
          \param A pointer to the observed value to be added.
 
          \note It will take the ownership of the input pointer.
        */
        void addValue(te::dt::AbstractData* value);
 
        /*!
          \brief It sets the observed values.
 
          \param A reference to the observed values.
 
          \note It will take the ownership of the input pointer.
        */
        void setValues(const boost::ptr_vector<te::dt::AbstractData>& values);
 
        /*!
          \brief It returns the observation location or region.
 
          \return A pointer to the geometry.
 
          \note The caller will NOT take the ownership of the returned pointer.
        */
        te::gm::Geometry* getGeometry() const;
 
        /*!
          \brief It sets the observation location or region.
 
          \param geom A pointer to the observation location or region.
 
          \note It will take the ownership of the input pointer.
        */
        void setGeometry(te::gm::Geometry* geom);
 
        /*!
          \brief It returns a clone of this object.
          
          \return A clone of this object.
 
          \note The caller will take the ownership of the input pointer.  
        */
        Observation* clone() const;
        
        /*! \brief Virtual destructor. */
        virtual ~Observation();        
 
      private:
 
        std::unique_ptr<te::dt::DateTime>         m_phTime;               //!< The phenomenon time
        std::unique_ptr<te::dt::DateTimeInstant>  m_resultTime;           //!< The result time
        std::unique_ptr<te::dt::DateTimePeriod>   m_validTime;            //!< The valid time
        boost::ptr_vector<te::dt::AbstractData> m_observedValues;       //!< The observed values
        std::unique_ptr<te::gm::Geometry>         m_geometry;             //!< The observation location
    };
 
  } // end namespace st
}   // end namespace te
 
#endif  // __TERRALIB_ST_INTERNAL_OBSERVATION_H