Environment.hh

Go to the documentation of this file.

#ifndef _ENVIRONMENTHH_
#define _ENVIRONMENTHH_

#include <openmodeller/om_defs.hh>
#include <openmodeller/refcount.hh>
#include <openmodeller/Configurable.hh>
#include <openmodeller/Normalizable.hh>
#include <openmodeller/Normalizer.hh>
#include <openmodeller/Sample.hh>

#include <vector>
#include <string>
#include <utility>

class Map;
class SampledData;

class EnvironmentImpl;
typedef ReferenceCountedPointer<EnvironmentImpl> EnvironmentPtr;
typedef ReferenceCountedPointer<const EnvironmentImpl> ConstEnvironmentPtr;

/****************************************************************/
/************************* Environment **************************/

EnvironmentPtr dllexp createEnvironment( const std::vector<std::string>& categs,
          const std::vector<std::string>& maps,
          const std::string& mask_file );

EnvironmentPtr dllexp createEnvironment( const std::vector<std::string>& categs,
          const std::vector<std::string>& maps );

EnvironmentPtr dllexp createEnvironment( const ConstConfigurationPtr& config );

EnvironmentPtr dllexp createEnvironment( );


class dllexp EnvironmentImpl : public Configurable, public Normalizable, private ReferenceCountedObject
{
  friend class ReferenceCountedPointer<EnvironmentImpl>;
  friend class ReferenceCountedPointer<const EnvironmentImpl>;

  friend EnvironmentPtr dllexp createEnvironment( const std::vector<std::string>& categs,
             const std::vector<std::string>& maps,
             const std::string& mask_file );
  
  friend EnvironmentPtr dllexp createEnvironment( const std::vector<std::string>& categs,
             const std::vector<std::string>& maps );

  friend EnvironmentPtr dllexp createEnvironment( const ConstConfigurationPtr& config );

  friend EnvironmentPtr dllexp createEnvironment( );

  typedef std::pair<std::string, Map*> layer;
  typedef std::vector<layer> layers;

  EnvironmentImpl();

  EnvironmentImpl( const std::vector<std::string>& categs,
       const std::vector<std::string>& maps, 
       const std::string& mask_file = "" );

public:

  ~EnvironmentImpl();

  EnvironmentImpl* clone() const;

  unsigned int numLayers() const { return _layers.size(); }

  size_t numCategoricalLayers() const;

  int isCategorical( int i );

  void getMinMax( Sample * min, Sample * max ) const;

  void normalize( Normalizer * normalizerPtr );

  void resetNormalization();

  Sample get( Coord x, Coord y ) const;

  Sample getNormalized( Coord x, Coord y ) const;
  Sample getUnnormalized( Coord x, Coord y ) const;

  Sample getRandom( Coord *x = 0, Coord *y = 0 ) const;

  int checkCoordinates( Coord x, Coord y ) const;

  int getRegion( Coord *xmin, Coord *ymin, Coord *xmax,
                 Coord *ymax ) const;

  int getExtremes( Sample* min, Sample* max ) const;

  Map * getLayer(int index) const { return _layers[index].second; }

  int changeMask( const std::string& mask_file );

  Map * getMask() const { return _mask.second; }

  const std::string& getLayerPath(int index) const { return _layers[index].first; }

  const std::string& getMaskPath() const { return _mask.first; }

  void removeLayer(unsigned int index);

  virtual ConfigurationPtr getConfiguration() const;

  virtual void setConfiguration( const ConstConfigurationPtr & );

private:

  void initialize( const std::vector<std::string>& categs,
       const std::vector<std::string>& maps, 
       const std::string& mask_file="" );

  /* utility function to extract unnormalized environment vector
   * Only needed to prevent unnecessary memory copy due to Sample
   * not having a reasonable copy constructor/temporary
   */
  void getUnnormalizedInternal( Sample *, Coord x, Coord y ) const;

  /* utility to clear the mask information.  Deallocates memory.  Does not computeRegion() */
  void clearMask();

  /* utility to clear the layer information, deallocates memory.  Does not computeRegion() */
  void clearLayers();

  /* utility to construct a ConfigurationPtr representation of a Layer.
     Does not properly set the Configuration name.
     Is a member function so it can access the private typedefs. */
  static ConfigurationPtr getLayerConfig( const layer& l, bool basicConfig=false );

  /* load specified layers. Zeros in map_refs are populated with Map instances based on the
     corresponding ids in the other vector */
  static void loadLayers( const std::vector<std::string>& map_ids, std::vector<Map*>& map_refs, int categ=0 );

  /* utility to construct a layer pair object.
     It is declared a member so it has access to the private typedef for layer */
  static layer makeLayer( const ConstConfigurationPtr& config, Map *map );
  static layer makeLayer( const std::string& filename, int categ );
  static layer makeLayer( const std::string& filename, Map *map );

  int changeLayers( const std::vector<std::string>& categs, 
        const std::vector<std::string>& maps );

  void calcRegion();

  layers _layers; 
  layer _mask;   

  Coord _xmin; 
  Coord _ymin; 
  Coord _xmax; 
  Coord _ymax; 

  Normalizer * _normalizerPtr; 
};


#endif