Sampler.hh

Go to the documentation of this file.

#ifndef _SAMPLERHH_
#define _SAMPLERHH_

#include <openmodeller/om_defs.hh>
#include <openmodeller/Occurrences.hh>
#include <openmodeller/Occurrence.hh>
#include <openmodeller/Environment.hh>
#include <openmodeller/Configurable.hh>
#include <openmodeller/Normalizable.hh>
#include <openmodeller/Normalizer.hh>

#include <openmodeller/refcount.hh>

class ModelImpl;
typedef ReferenceCountedPointer<ModelImpl> Model;

/****************************************************************/
/*************************** Sampler ****************************/

class SamplerImpl;
typedef ReferenceCountedPointer<SamplerImpl> SamplerPtr;
typedef ReferenceCountedPointer<const SamplerImpl> ConstSamplerPtr;

dllexp SamplerPtr createSampler(const EnvironmentPtr& env,
       const OccurrencesPtr& presence,
       const OccurrencesPtr& absence = OccurrencesPtr() );

dllexp SamplerPtr createSampler( const ConstConfigurationPtr& config );

dllexp void splitSampler(const SamplerPtr& orig, SamplerPtr *train, SamplerPtr *test, double propTrain);

dllexp SamplerPtr cloneSampler(const SamplerPtr& orig);

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

public:

  SamplerImpl();
  SamplerImpl( const EnvironmentPtr& env,
         const OccurrencesPtr& presences,
         const OccurrencesPtr& absence,
         bool  isNormalized=false);
  ~SamplerImpl();

  EnvironmentPtr getEnvironment() { return _env; }
  ConstEnvironmentPtr getEnvironment() const { return _env; }

  OccurrencesPtr getPresences() { return _presence; }
  ConstOccurrencesPtr getPresences() const { return _presence; }

  OccurrencesPtr getAbsences() { return _absence; }
  ConstOccurrencesPtr getAbsences() const { return _absence; }

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

  void normalize( Normalizer * normalizerPtr );

  bool isNormalized() const { return _normalized; }

  void resetNormalization();

  int numIndependent() const;

  int numDependent() const;

  int numPresence() const;

  int numAbsence() const;

  ConstOccurrencePtr getOneSample( ) const;

  ConstOccurrencePtr getPresence() const 
  { return getRandomOccurrence( _presence ); }

  ConstOccurrencePtr getPresence( int index ) const 
  { return _presence->operator[]( index ); }

  ConstOccurrencePtr getAbsence() const 
  { return getRandomOccurrence( _absence ); }

  ConstOccurrencePtr getAbsence( int index ) const 
  { return _absence->operator[]( index ); }

  OccurrencePtr generateRandomSample( Scalar abundance=1.0 ) const;

  OccurrencePtr getPseudoAbsence() const;

  OccurrencePtr getPseudoPresence() const;

  OccurrencePtr getPseudoAbsence( const Model& model, const Scalar threshold ) const;

  OccurrencePtr getPseudoPresence( const Model& model, const Scalar threshold ) const;

  OccurrencePtr getPseudoAbsenceOutsideInterval( const Sample * minimum, const Sample * maximum ) const;

  OccurrencePtr getPseudoPresenceInsideInterval( const Sample * minimum, const Sample * maximum ) const;

  OccurrencesPtr getPseudoAbsences( const int& numPoints, const Model& model, const Scalar threshold=0.5, const bool geoUnique=false, const bool envUnique=false, const int idSequenceStart=1) const;

  OccurrencesPtr getPseudoPresences( const int& numPoints, const Model& model, const Scalar threshold=0.5, const bool geoUnique=false, const bool envUnique=false, const int idSequenceStart=1) const;

  OccurrencesPtr getPseudoAbsences( const int& numPoints, const Sample * minimum, const Sample * maximum, const bool geoUnique=false, const bool envUnique=false, const int idSequenceStart=1) const;

  OccurrencesPtr getPseudoPresences( const int& numPoints, const Sample * minimum, const Sample * maximum, const bool geoUnique=false, const bool envUnique=false, const int idSequenceStart=1) const;

  int isCategorical( int i );

  void environmentallyUnique( );

  bool isEnvironmentallyUnique( const OccurrencesPtr& occurrences, const OccurrencePtr& point ) const;

  void spatiallyUnique( );

  bool isSpatiallyUnique( const OccurrencesPtr& occurrences, const OccurrencePtr& point ) const;

  ConfigurationPtr getConfiguration() const;

  void setConfiguration ( const ConstConfigurationPtr& );

  void dump() const;

private:

  ConstOccurrencePtr getRandomOccurrence( const OccurrencesPtr& occur ) const;

  // this was former method ::initialize()
  void setEnvironmentInOccurrences();

  // Remove sample duplicates accross the environment given one of the occurrences 
  // type (presence / absence)
  void environmentallyUnique( OccurrencesPtr& occurrencesPtr, const char *type );

  // Remove sample duplicates accross the geographic space given one of the occurrences 
  // type (presence / absence)
  void spatiallyUnique( OccurrencesPtr& occurrencesPtr, const char *type );

  OccurrencesPtr _presence;
  OccurrencesPtr _absence;
  EnvironmentPtr _env;
  bool _normalized;
};


#endif