Occurrence.hh

Go to the documentation of this file.

#ifndef _OCCURRENCEHH_
#define _OCCURRENCEHH_

#include <openmodeller/om_defs.hh>
#include <openmodeller/Sample.hh>
#include <openmodeller/Normalizer.hh>

#include <openmodeller/refcount.hh>

#include <string>

/****************************************************************/
/************************** Occurrence **************************/

class OccurrenceImpl;
typedef ReferenceCountedPointer< OccurrenceImpl > OccurrencePtr;
typedef ReferenceCountedPointer< const OccurrenceImpl > ConstOccurrencePtr;

class dllexp OccurrenceImpl : private ReferenceCountedObject
{
  friend class ReferenceCountedPointer<OccurrenceImpl>;
  friend class ReferenceCountedPointer<const OccurrenceImpl>;
public:

  OccurrenceImpl( ) :
    id_( ),
    x_( 0.0 ),
    y_( 0.0 ),
    error_( 0.0 ),
    abundance_( 0.0 ),
    attr_(),
    unnormEnv_(),
    normEnv_()
  {}

  OccurrenceImpl( const std::string& id, 
                  Coord x, Coord y, Scalar error,
      Scalar abundance,
      int num_attributes=0,
      Scalar *attributes=0,
      int num_env=0,
      Scalar *env=0) :
    id_( id ),
    x_( x ),
    y_( y ),
    error_( error ),
    abundance_( abundance ),
    attr_( num_attributes, attributes ),
    unnormEnv_( num_env, env ),
    normEnv_()
  { }

  OccurrenceImpl( const std::string& id, 
                  Coord x, Coord y, Scalar error,
      Scalar abundance,
      std::vector<Scalar> attributes,
      std::vector<Scalar> env) :
    id_( id ),
    x_( x ),
    y_( y ),
    error_( error ),
    abundance_( abundance ),
    attr_( attributes ),
    unnormEnv_( env ),
    normEnv_()
  { }

  OccurrenceImpl( const std::string& id, 
                  Coord x, Coord y, Scalar error,
      Scalar abundance,
      const Sample& attributes,
      const Sample& env) :
    id_( id ),
    x_( x ),
    y_( y ),
    error_( error ),
    abundance_( abundance ),
    attr_( attributes ),
    unnormEnv_( env ),
    normEnv_()
  { }

  OccurrenceImpl( const std::string& id, 
                  Coord x, Coord y,
                  Scalar abundance,
                  int num_attributes=0,
                  Scalar *attributes=0 ) :
    id_( id ),
    x_( x ),
    y_( y ),
    error_( -1.0 ),
    abundance_( abundance ),
    attr_( num_attributes, attributes ),
    unnormEnv_(),
    normEnv_()
  { }

  ~OccurrenceImpl();

  OccurrenceImpl( const OccurrenceImpl& rhs ) :
    id_( rhs.id_ ),
    x_( rhs.x_ ),
    y_( rhs.y_ ),
    error_( rhs.error_ ),
    abundance_( rhs.abundance_ ),
    attr_( rhs.attr_ ),
    unnormEnv_( rhs.unnormEnv_ ),
    normEnv_( rhs.normEnv_ )
  {};

  OccurrenceImpl& operator=(const OccurrenceImpl & );

  // Access to the locality information.
  std::string id() const   { return id_; }
  Coord  x() const         { return x_; }
  Coord  y() const         { return y_; }
  Scalar error() const     { return error_; }
  Scalar abundance() const { return abundance_; }

  Sample const & attributes() const { return attr_; }

  Sample const & environment() const; 

  Sample const & originalEnvironment() const; 

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

  void setNormalizedEnvironment( const Sample& s );

  void setUnnormalizedEnvironment( const Sample& s );

  bool hasEnvironment() const;

  void setId( const std::string& id );

  void setAbundance( Scalar value );

  void dump() const;

private:

  std::string id_; // Unique identifier
  Coord  x_; // Longitude
  Coord  y_; // Latitude
  Scalar error_;  // coordinate uncertanty in meters (unused so far)
  Scalar abundance_; // used only to distinguish between presence (1) and absence (0)

  Sample attr_; // extra attributes
  Sample unnormEnv_; // unnormalized environment
  Sample normEnv_; // normalized enviroment
};

#endif