Occurrences.hh

Go to the documentation of this file.

#ifndef _OCCURRENCESHH_
#define _OCCURRENCESHH_

#include <openmodeller/om_defs.hh>
#include <openmodeller/Occurrence.hh>
#include <openmodeller/Configurable.hh>
#include <openmodeller/Environment.hh>
#include <openmodeller/Normalizable.hh>
#include <openmodeller/Normalizer.hh>
#include <openmodeller/refcount.hh>
#include <openmodeller/env_io/GeoTransform.hh>

#include <vector>
#include <string>

/****************************************************************/
/************************* Occurrences **************************/

class OccurrencesImpl;
typedef ReferenceCountedPointer<OccurrencesImpl> OccurrencesPtr;
typedef ReferenceCountedPointer<const OccurrencesImpl> ConstOccurrencesPtr;

typedef std::vector<Scalar> ScalarVector;

dllexp void splitOccurrences(const OccurrencesPtr& occurrences, 
           OccurrencesPtr& trainOccurrences, 
           OccurrencesPtr& testOccurrences,
         double propTrain);

dllexp void splitOccurrences(const OccurrencesPtr& occurrences, 
           OccurrencesPtr& trainOccurrences, 
           OccurrencesPtr& testOccurrences);


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

public:

  typedef std::vector<OccurrencePtr>::const_iterator const_iterator;
  typedef std::vector<OccurrencePtr>::iterator iterator;

  inline OccurrencesImpl( double default_abundance ) :
    default_abundance_( default_abundance ),
    label_( ),
    cs_( GeoTransform::getDefaultCS() ),
    gt_( 0 ),
    occur_( )
  {
    initGeoTransform();
  };

  inline OccurrencesImpl( const std::string& label, 
        const std::string& coord_system=GeoTransform::getDefaultCS() ) :
    default_abundance_( 0.0 ),
    label_( label ),
    cs_( coord_system ),
    gt_( 0 ),
    occur_()
  {
    initGeoTransform();
  };

  ~OccurrencesImpl();

  OccurrencesImpl* clone() const;

  void reserve( int estimate ) { occur_.reserve( estimate ); }

  char const * label() const { return label_.c_str(); }

  char const * coordSystem() const { return cs_.c_str(); }

  /* Indicates whether the object contains environmental samples
   * that can be used instead of a full blown Environment object
   */
  bool hasEnvironment() const;

  /* Dimension of environmental space in samples stored in this object
   */
  int dimension() const;

  void setLabel( const std::string& label );

  void setCoordinateSystem( const std::string& cs );

  void createOccurrence( const std::string& id, 
                         Coord longitude, Coord latitude,
       Scalar error, Scalar abundance,
       int num_attributes = 0, Scalar *attributes = 0,
       int num_env = 0, Scalar *env = 0 );

  void createOccurrence( const std::string& id, 
                         Coord longitude, Coord latitude,
       Scalar error, Scalar abundance,
       std::vector<double> attributes,
       std::vector<double> env);

  void insert( const OccurrencePtr& );

  iterator erase( const iterator& it );

  int numAttributes() const { return 0; }

  int numOccurrences() const { return occur_.size(); }

  bool isEmpty() const { return occur_.empty(); }

  ConstOccurrencePtr operator[]( int i ) const { return occur_[i]; }

  const_iterator begin() const { return occur_.begin(); }
  const_iterator end() const { return occur_.end(); }
  iterator begin() { return occur_.begin(); }
  iterator end() { return occur_.end(); }

  ConstOccurrencePtr getRandom() const;

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

  void normalize( Normalizer * normalizerPtr, size_t categoricalThreshold=0 );

  void resetNormalization();

  void setEnvironment( const EnvironmentPtr& env, 
           const char *type = "Sample" );

  void appendFrom(const OccurrencesPtr& source);

  std::vector<ScalarVector> getEnvironmentMatrix();

  void dump( std::string msg="" ) const;

  virtual ConfigurationPtr getConfiguration() const;

  virtual void setConfiguration( const ConstConfigurationPtr & );

private:

  void initGeoTransform();

  double default_abundance_;

  std::string label_; // Label for the list of occurrences (e.g. species name)
  std::string cs_;   // Coordinate system name

  GeoTransform *gt_; // Object to transform between different coordinate systems

  std::vector< OccurrencePtr > occur_;  // Occurrences
};


#endif