/* ---- This file is part of SECONDO. Copyright (C) 2004, University in Hagen, Department of Computer Science, Database Systems for New Applications. SECONDO is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. SECONDO 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 General Public License for more details. You should have received a copy of the GNU General Public License along with SECONDO; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ---- //paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}] //paragraph [10] Footnote: [{\footnote{] [}}] //[TOC] [\tableofcontents] [1] Header file of the Temporal Algebra September - November 2007 Sascha Vaut 1 Overview The type system of the HierarchicalGeo Algebra can be seen below. 2 Defines, includes, and constants */ #ifndef _HIERARCHICALGEO_ALGEBRA_H_ #define _HIERARCHICALGEO_ALGEBRA_H_ #endif #include #include #include #include "NestedList.h" #include "ListUtils.h" #include "QueryProcessor.h" #include "Algebra.h" #include "Attribute.h" #include "StandardTypes.h" #include "Algebras/Temporal/TemporalAlgebra.h" #include "Algebras/Spatial/SpatialAlgebra.h" #include "Algebras/MovingRegion/MovingRegionAlgebra.h" #include "Tools/Flob/DbArray.h" #include "Algebras/Rectangle/RectangleAlgebra.h" #include "DateTime.h" extern NestedList* nl; extern QueryProcessor* qp; class CUPoint; class CMPoint; template class HierarchicalEntity; typedef HierarchicalEntity HCUPoint; class HCMPoint; class HMPoint; /* Forward declarations. 3 C++ Classes (Definition) 3.1 Uncertain This class represents an epsilon-value of type real. It will be used in type constructors of all ~uncertain~ Datatypes. */ //template struct Uncertain { public: /* 3.1.1 Constructors */ Uncertain() {} /* The simple constructor. This constructor should not be used. */ Uncertain( bool is_defined):epsilon(0),def(is_defined) {} /* Use this constructor when declaring uncertain object variables etc. */ Uncertain( const double& _epsilon ): epsilon ( _epsilon ), def ( true ) {} /* The creation of an uncertain value, setting the epsilon value. */ Uncertain( const Uncertain& rhs) : epsilon(rhs.epsilon), def(rhs.def) {} virtual ~Uncertain() {} /* 3.1.2 Member functions */ virtual bool IsValid() const { if (epsilon >= 0 && def) return true; return false; } /* Checks if the Uncertain is valid or not. This function should be used for debugging purposes only. An uncertain is valid if the following conditions are true: 1 ~alpha~ and ~epsilon~ are defined 2 ~epsilon~ $>=$ 0 3 ~defined~ $==$ TRUE */ double GetEpsilon() const { return epsilon; } void SetEpsilon(double e) { epsilon = e; } /* Returns the epsilon value of the Uncertain value. */ virtual bool UncertainIsDefined() const { return def; } /* Checks if the Uncertain value is defined or not. If it is not defined, only the epsilon value is set. The Alpha value is left to be set later. */ virtual void UncertainSetDefined( bool defined ) { this->def = defined; } /* Sets the argument ~defined~ to the given boolean value. */ /* 3.1.3 Attributes */ double epsilon; /* The possible difference between the original value and the given value. */ protected: bool def; /* The flag that indicates if the value is defined or not. */ }; /* 3.2 CUPoint This class will be used in the ~cupoint~ type constructor, i.e., the type constructor for the uncertain temporal unit of point values. */ class CUPoint : public temporalalgebra::UPoint, public Uncertain { public: /* 3.2.1 Constructors and Destructor */ CUPoint() {} /* The simple constructor. This constructor should not be used. */ CUPoint( const bool is_defined ): temporalalgebra::UPoint(false), Uncertain(is_defined) { } CUPoint( const double epsilon ): temporalalgebra::UPoint(false), Uncertain(epsilon) { } /* The simple constructor, only defining the epsilon-value. */ CUPoint( const temporalalgebra::UPoint& source): temporalalgebra::UPoint( source ), Uncertain( 0.0 ) { } /* A constructor to create an uncertain unit point from a unit point. */ CUPoint( const double epsilon, const temporalalgebra::UPoint& source): temporalalgebra::UPoint( source ), Uncertain( epsilon ) { } /* A constructor to create an uncertain unit point from the given epsilon-value and unit point. This constructor should only be used to create test-data! */ CUPoint( const double epsilon, const temporalalgebra::Interval& interval, const Point& p0, const Point& p1 ): temporalalgebra::UPoint( interval, p0, p1 ), Uncertain (epsilon) { } CUPoint( const double epsilon, const temporalalgebra::Interval& interval, const double x0, const double y0, const double x1, const double y1 ): temporalalgebra::UPoint( interval, x0, y0, x1, y1 ), Uncertain (epsilon) { } CUPoint( const CUPoint& source ) : temporalalgebra::UPoint(source), Uncertain(source) { } /* The copy-constructor. */ virtual ~CUPoint() {} /* The destructor. 3.2.3 The Temporal Functions */ virtual void TemporalFunction( const Instant& t, Point& result, bool ignoreLimits = false ) const; virtual bool Passes( const Point& val ) const { return D_Passes( val ); } bool Passes( const Region& val ) const { return D_Passes( val ); } virtual bool At( const Point& val, TemporalUnit& result ) const { return false; } virtual void AtInterval( const temporalalgebra::Interval& i, TemporalUnit& result ) const; void USpeed( temporalalgebra::UReal& result ) const {} void UVelocity( temporalalgebra::UPoint& result ) const {} void Intersection(const temporalalgebra::UPoint &other, temporalalgebra::UPoint &result) const {} virtual bool EqualValue( const UPoint& i ) const { return ( AlmostEqual( p0, i.p0 ) && AlmostEqual( p1, i.p1 ) ); } void Translate(const double x, const double y, const datetime::DateTime& duration) {} /* 3.2.4 Additional Uncertain-Temporal Functions */ void UTrajectory( const double e, Region& region ) const; /* The only difference of this function to the function 'UTrajectory()' of the TemporalAlgebra is the result-Type. To include the uncertainty of an uncertain spatio-temporal object, the trajectory of such an object is defined as a region-value, which represents the area, the uncertain object may possibly pass. */ bool D_Passes( const Point& p ) const; bool D_Passes( const Region& r ) const; /* The function-name D\_Passes() is a shorthand for 'Definitely\_Passes'. It returns TRUE, if there is a point in time, when the uncertain spatio-temporal object lies on or inside the given spatial object, and FALSE, when there may be no such point in time. Refering to a (certain) point-object, this will never occur if the uncertainty-value epsilon is greater than 0. */ bool P_Passes( const Point& val ) const; bool P_Passes( const Region& val ) const; /* P\_Passes() stands for 'Possibly\_Passes' and returns TRUE if there may be a point in time, when the uncertain spatio-temporal object lies on or inside the given spatial object. FALSE is only returned when there is certainly no such point in time. */ void D_At( const Point& p, CUPoint& result ) const; void D_At( const Region& r, CMPoint& result ) const; /* The function D\_At ('Definitely\_At') returns that part(s) of the CUPoint, that lie(s) definitely on or inside the given spatal object. Refering to a (certain) point-object, the returned CUPoint is empty if the uncertainty-value epsilon is greater than 0. Refering to a region-object, there may be more than one CUPoints to be returned, so the result-type is a CMPoint. */ void P_At( const Point& p, CUPoint& result ) const; void P_At( const Region& r, CMPoint& result ) const; /* The function P\_At is a shorthand for 'Possibly\_At' and returns that part of the CUPoint, which possibly lies on or inside the given spatal object. */ void AtInstant( const Instant& t, temporalalgebra::Intime& result ) const; void Set(double e, temporalalgebra::Interval t, Point p0, Point p1) { } void UnitSetDefined( bool def ) { temporalalgebra::UPoint::SetDefined( def ); } bool UnitIsDefined() const { return temporalalgebra::UPoint::IsDefined(); } bool UnitIsValid() const { return TemporalUnit::IsValid(); } bool UncertainIsValid() const { return Uncertain::IsValid(); } bool IsValid() const { return UnitIsValid() && Uncertain::IsValid(); } virtual const Rectangle<3> BoundingBox(const Geoid* geoid = 0) const { if(geoid){ if(!geoid->IsDefined() || !IsDefined()){ return Rectangle<3>(false); } assert(false); return Rectangle<3>(false); } double minMax[] = {MIN( p0.GetX(), p1.GetX() )-epsilon, MAX( p0.GetX(), p1.GetX() )+epsilon, MIN( p0.GetY(), p1.GetY() )-epsilon, MAX( p0.GetY(), p1.GetY() )+epsilon, timeInterval.start.ToDouble(), timeInterval.end.ToDouble()}; return Rectangle<3>( true, minMax ); } virtual const Rectangle<2> BBox2D() const { double minMax[] = {MIN( p0.GetX(), p1.GetX() )-epsilon, MAX( p0.GetX(), p1.GetX() )+epsilon, MIN( p0.GetY(), p1.GetY() )-epsilon, MAX( p0.GetY(), p1.GetY() )+epsilon}; return Rectangle<2>( true, minMax); } /* For this is an uncertain temporalalgebra::UPoint-value, the returned Rectangle<3> is enlarged by the epsilon-value. 3.2.5 Functions to be part of relations */ bool IsDefined() const { return UnitIsDefined() && UncertainIsDefined(); } void SetDefined( const bool defined ) { UnitSetDefined( defined ); UncertainSetDefined( defined ); } inline virtual size_t Sizeof() const { return sizeof( *this ); } inline virtual int Compare( const Attribute* arg ) const { CUPoint* up2 = (CUPoint*) arg; if (!UnitIsDefined() && !up2->UnitIsDefined()) return 0; if (!UnitIsDefined()) return -1; if (!up2->UnitIsDefined()) return 1; int cmp = timeInterval.CompareTo(up2->timeInterval); if(cmp) return cmp; if(p0p0) return -1; if(p0>up2->p0) return 1; if(p1>up2->p1) return 1; if(p1p1) return -1; if( epsilon < up2->GetEpsilon() ) return -1; if( epsilon > up2->GetEpsilon() ) return 1; return 0; } inline virtual bool Adjacent( const Attribute* arg ) const { return false; } std::ostream& Print( std::ostream& os ) const { if(IsDefined()) { os << "CUPoint: " << "( "; os << epsilon << "( "; timeInterval.Print(os); os << ", "; p0.Print(os); os << ", "; p1.Print(os); os << " ) ) "; return os; } else return os << "CUPoint: (undef) "; } inline virtual size_t HashValue() const { return 0; } inline virtual CUPoint* Clone() const { CUPoint *res; res = new CUPoint(epsilon, timeInterval, p0, p1 ); res->SetDefined( IsDefined() ); return res; } virtual void CopyFrom( const Attribute* right ) { const CUPoint* i = (const CUPoint*)right; if( i->UncertainIsDefined() ) epsilon = i->epsilon; else epsilon = 0.0; UncertainSetDefined( true ); UnitSetDefined( i->UnitIsDefined() ); if(i->UnitIsDefined() ) { timeInterval = i->timeInterval; p0 = i->p0; p1 = i->p1; } else { timeInterval = temporalalgebra::Interval(); p0 = Point( false, 0.0, 0.0); p1 = Point( false, 0.0, 0.0); } } static const std::string BasicType() {return "cupoint"; } static const bool checkType(const ListExpr type){ return listutils::isSymbol(type,BasicType()); } /* 3.2.6 Attributes */ //Point p0, p1; }; /* 3.3 CMPoint the implementation of an uncertain temporalalgebra::MPoint */ class CMPoint : public temporalalgebra::Mapping< CUPoint, Point >, public Uncertain { public: /* 3.3.1 Constructors and Destructor */ CMPoint() {} /* The simple constructor. This constructor should not be used. */ CMPoint( const int n ): temporalalgebra::Mapping< CUPoint, Point >( n ), Uncertain( true ) { epsilon = 0.0; bbox = Rectangle<3>(false); } /* The constructor. Initializes space for ~n~ elements. */ /* 3.3.2 Modifications of Inherited Functions Overwrites the function defined in temporalalgebra::Mapping, mostly in order to maintain the object's bounding box. Also, some methods can be improved using a check on bbox. */ void Clear(); void Add( const CUPoint& unit ); void MergeAdd(const CUPoint& unit); bool EndBulkLoad( const bool sort = true, const bool dummy = false ); void Restrict( const std::vector< std::pair >& intervals ); bool Present( const Instant& t ) const; bool Present( const temporalalgebra::Periods& t ) const; void AtInstant( const Instant& t, temporalalgebra::Intime& result ) const; void AtPeriods( const temporalalgebra::Periods& p, CMPoint& result ) const; void Trajectory( Region& region ); /* Functions to be part of relations */ std::ostream& Print( std::ostream &os ) const; virtual Attribute* Clone() const; void CopyFrom( const Attribute* right ); static const std::string BasicType() {return "cmpoint"; } static const bool checkType(const ListExpr type){ return listutils::isSymbol(type,BasicType()); } inline virtual size_t Sizeof() const { return sizeof( *this ); } /* 3.3.3 Additional Uncertain-Temporal Functions */ //void Trajectory( Region& region ) const; /* The only difference of this function to the function 'Trajectory()' of the TemporalAlgebra is the result-Type. To include the uncertainty of an uncertain spatio-temporal object, the trajectory of such an object is defined as a region-value, which represents the area, the uncertain object may possibly pass. */ bool D_Passes( const Point& p ) const; bool D_Passes( const Region& r ) const; /* The function-name D\_Passes() is a shorthand for 'Definitely\_Passes'. It returns TRUE, if there is a point in time, when the uncertain spatio-temporal object lies on or inside the given spatial object, and FALSE, when there may be no such point in time. Refering to a (certain) point-object, this will never occur if the uncertainty-value epsilon is greater than 0. */ bool P_Passes( const Point& p ) const; bool P_Passes( const Region& r ) const; /* P\_Passes() stands for 'Possibly\_Passes' and returns TRUE if there may be a point in time, when the uncertain spatio-temporal object lies on or inside the given spatial object. FALSE is only returned when there is certainly no such point in time. */ void D_At( const Point& p, CMPoint& result ) const; void D_At( const Region& r, CMPoint& result ) const; /* The function D\_At ('Definitely\_At') returns that part of the CMPoint, which lies definitely on or inside the given spatial object. Refering to a (certain) point-object, the returned CMPoint is empty if the uncertainty-value epsilon is greater than 0. */ void P_At( const Point& val, CMPoint& result ) const; void P_At( const Region& val, CMPoint& result ) const; /* The function P\_At is a shorthand for 'Possibly\_At' and returns that part of the CMPoint, which possibly lies on or inside the given spatial object. 3.3.3.6 ~epsilon~ */ void RestoreEpsilon(); /* 3.3.3.7 ~BoundingBox~ Returns the CMPoint's minimum bounding rectangle */ // return the stored bbox Rectangle<3> BoundingBox() const; Rectangle<2> BBox2D() const; // recompute bbox, if necessary void RestoreBoundingBox(const bool force = false); private: Rectangle<3> bbox; }; /* 3.4 HierarchicalEntity This template class offers attributes and operations to store datatypes in a hierarchical structure. */ template class HierarchicalEntity: public Attribute { public: /* 3.4.1 Constructors */ HierarchicalEntity() {} /* The simple constructor. This constructor should not be used. */ HierarchicalEntity( const HierarchicalEntity& entity): Attribute(true), value(), generalizedby( entity.GetGeneralizedby() ), layer( entity.GetLayer() ), index( entity.GetIndex() ), originstart( entity.GetOriginstart() ), originend( entity.GetOriginend() ) { value.CopyFrom( &entity.value ); } /* The copy-constructor. */ HierarchicalEntity( const Alpha& alpha, const int l, const int idx, const int start, const int end ): Attribute(true), value(), generalizedby( -1 ), layer( l ), index( idx ), originstart( start ), originend( end ) { value.CopyFrom( &alpha ); } /* The creation of a HierarchicalEntity, setting the typically allready known attributes. */ HierarchicalEntity( const Alpha& alpha, const int genby, const int l, const int idx, const int start, const int end ): Attribute(true), value(), generalizedby( genby ), layer( l ), index( idx ), originstart( start ), originend( end ) { value.CopyFrom( &alpha ); } /* A constructor which sets all attributes (usually unsed by the in-function). */ ~HierarchicalEntity() {} /* 3.4.2 Member functions */ inline bool IsValid() const { if( index > -1 ) return true; return false; } inline bool IsLeaf() const { if( index > -1 && originstart == originend ) return true; return false; } inline bool IsRoot() const { if( index > -1 && generalizedby == -1 ) return true; return false; } inline void SetIndex(const int idx) { index = idx; } inline void SetLayer(const int l) { layer = l; } inline int GetLayer() const { return layer; } inline int GetIndex() const { return index; } inline int GetGeneralizedby() const { return generalizedby; } inline void SetGeneralizedby(const int idx) { if( generalizedby == -1 ) generalizedby = idx; else { std::cout << "Error in HierarchicalEntity::SetGeneralizedby():" << " The Index" "of the Generalization of this Entity is already set!\n"; std::cerr << "Error in HierarchicalEntity::SetGeneralizedby(): " << "The Index" "of the Generalization of this Entity is already set!\n"; } } inline int GetOriginstart() const { return originstart; } inline void SetOriginstart(const int start) { originstart = start; } inline int GetOriginend() const { return originend; } inline void SetOriginend(const int end) { originend = end; } /* 3.4.3 Functions to be part of relations */ inline bool IsDefined() const { return IsValid(); } inline void SetDefined(bool defined) {} inline size_t Sizeof() const { return sizeof( *this ); } /* For HierarchicalEntity is a container-element, providing an order of units within a hierarchical structure, only the layer- and index-values are compared. The order of the contained units is ignored here! */ inline int Compare( const Attribute* arg ) const { HierarchicalEntity* other = (HierarchicalEntity*) arg; if( !IsDefined() && !other->IsDefined() ) return 0; if( !IsDefined() ) return -1; if( !other->IsDefined() ) return 1; if( layer < other->GetLayer() ) return -1; if( layer > other->GetLayer() ) return 1; else { // the layer-values are equal if( index < other->GetIndex() ) return -1; if( index > other->GetIndex() ) return 1; } return 0; } bool Adjacent( const Attribute* arg ) const { HierarchicalEntity* other = (HierarchicalEntity*) arg; if( IsDefined() && other->IsDefined() && layer == other->GetLayer() ) { if( index+1 == other->GetIndex() || index-1 == other->GetIndex() ) return true; } return false; } HierarchicalEntity* Clone() const { return (new HierarchicalEntity( *this) ); } inline std::ostream& Print( std::ostream &os ) const { if( !IsDefined() ) { return os << "(HierarchicalEntity: undefined)"; } os << "(HierarchicalEntity: " << generalizedby << " " << layer << " " << index << " " << originstart << " " << originend << "\n\t"; value.Print(os); os << "\n)" << endl; return os; } virtual size_t HashValue() const { return 0; } virtual void CopyFrom( const Attribute* right ) { const HierarchicalEntity* i = (const HierarchicalEntity*)right; generalizedby = i->GetGeneralizedby(); layer = i->GetLayer(); index = i->GetIndex(); originstart = i->GetOriginstart(); originend = i->GetOriginend(); value.CopyFrom( &i->value ); } /* 3.4.4 Attributes */ Alpha value; /* The object to be stored in the hierarchical structure */ protected: int generalizedby; /* The index of the fathernode, containing a generalization that includes all of its sons. */ int layer; /* The position in the array. */ int index; /* The position in the array. */ int originstart; /* The index of the first entity, generalized by this entity. */ int originend; /* The index of the last entity, generalized by this entity. */ }; /* 3.6 HCUPoint represents an uncertain unit point (CUPoint) within an hierarchical structure. */ typedef HierarchicalEntity HCUPoint; /* 3.7 HCMPoint The type Hierarchical Uncertain Moving Point defines a hierarchical structure in which up to 5 various Generalizations of a particular moving point can be stored. Every unit of such an uncertain moving point is encapsulated within an object called HierarchicalEntity. Such an Entity defines the position in the hierarchical structure. Every uncertain unit point of an upper layer (one of the layers 0 to 4) generalizes a number of uncertain unit points within the layer below. */ class HCMPoint : public Attribute { public: /* 3.7.1 Constructors and Destructor */ HCMPoint() {} /* The simple constructor. This constructor should not be used. */ HCMPoint( const int n ): Attribute(true), layer0epsilon( -1 ), layer1epsilon( -1 ), layer2epsilon( -1 ), layer3epsilon( -1 ), layer4epsilon( -1 ), layer0( 0 ), layer1( 0 ), layer2( 0 ), layer3( 0 ), layer4( n ), canDestroy( false ), epsilon( -1 ), factor( -1 ) { bbox = Rectangle<3>(false); } HCMPoint( const int n, const double e, const double f ): Attribute(true), layer0epsilon( -1 ), layer1epsilon( -1 ), layer2epsilon( -1 ), layer3epsilon( -1 ), layer4epsilon( -1 ), layer0( 0 ), layer1( 0 ), layer2( 0 ), layer3( 0 ), layer4( n ), canDestroy( false ), epsilon( e ), factor( f ) { bbox = Rectangle<3>(false); } /* A constructor, initializing space for ~n~ entities in the bottom layer. */ ~HCMPoint() { if( canDestroy ) { layer0.Destroy(); layer1.Destroy(); layer2.Destroy(); layer3.Destroy(); layer4.Destroy(); } } /* The destructor. */ void Destroy() { canDestroy = true; } /* This function should be called before the destructor if one wants to destroy the persistent arrays of hierarchical entities. It marks the persistent arrays for destroying. The destructor will perform the real destroying. 3.7.2 Member Functions */ inline bool IsEmpty() const; double GetLayerepsilon( const int layer ) const; void SetLayerepsilon( const int layer, const double epsilon ); inline double GetLayer0epsilon() const { return layer0epsilon; } inline void SetLayer0epsilon(const double epsilon) { layer0epsilon = epsilon; } inline double GetLayer1epsilon() const { return layer1epsilon; } inline void SetLayer1epsilon(const double epsilon) { layer1epsilon = epsilon; } inline double GetLayer2epsilon() const { return layer2epsilon; } inline void SetLayer2epsilon(const double epsilon) { layer2epsilon = epsilon; } inline double GetLayer3epsilon() const { return layer3epsilon; } inline void SetLayer3epsilon(const double epsilon) { layer3epsilon = epsilon; } inline double GetLayer4epsilon() const { return layer4epsilon; } inline void SetLayer4epsilon(const double epsilon) { layer4epsilon = epsilon; } inline void SetEpsilon(const double e) { epsilon = e; } inline double GetEpsilon() const { return epsilon; } inline void SetFactor(const double f) { factor = f; } inline double GetFactor() const { return factor; } inline void Get( const int layer, const int i, HCUPoint& hcup ) const; inline void Get( const int layer, const int i, CUPoint& cup ) const; inline void Put( const int layer, const int i, HCUPoint& hcup); inline int GetNoComponents() const; inline void ResizeLayer( const int layer, const int n ); inline void TrimLayerToSize( const int layer ); inline int LayerSize( const int layer ) const; int Position( int layer, const Instant& t ); int Position( int layer, const Instant& t, const int start, const int end ); inline void GetFirstLayer( int& layer, int& size ) const; void DefTime( temporalalgebra::Periods& p ); bool Present( const Instant& i ); int Generalize(const int layer, const bool checkBreakPoints, const datetime::DateTime dur); void Simplify(const int min, const int max, const int layer, bool* useleft, bool* useright, double* realepsilon, const double epsilon); /* Checks all Units in the most uncertain Layer of the HCMPoint, if the given temporalalgebra::Periods-Value is completely inside the Definition-time of the HCMPoint-object. */ bool Present( const temporalalgebra::Periods& p ); /* Checks, if the given Point-Value lies inside the BoundingBox of this HCMPoint. If so, it calls a recursive Function to determine if the HCMPoint definitely- passes the given Point-value. */ bool D_Passes( const Point& p ); /* This recursive function determines, by a pre-order run through the hierarchical structure, if the HCMPoint definitely-passes the given Point-value. */ bool D_Passes( const int layer, const int start, const int end, const Point& p ); /* Checks, if the given Region-Value intersects the BoundingBox of this HCMPoint. If so, it calls a recursive Function to determine if the HCMPoint definitely- passes the given Region-value. */ bool D_Passes( const Region& r ); /* This recursive Function determines, by an in-order run through the hierarchical structure, if the HCMPoint definitely-passes the given Region-value. */ bool D_Passes( const int layer, const int start, const int end, const Region& r ); /* Checks, if the given Point-Value lies inside the BoundingBox of this HCMPoint. If so, it calls a recursive Function to determine if the HCMPoint possibly- passes the given Point-value. */ bool P_Passes( const Point& p ); /* This recursive function determines, by a pre-order run through the hierarchical structure, if the HCMPoint possibly-passes the given Point-value. */ bool P_Passes( const int layer, const int start, const int end, const Point& p ); /* Checks, if the given Region-Value intersects the BoundingBox of this HCMPoint. If so, it calls a recursive Function to determine if the HCMPoint possibly- passes the given Region-value. */ bool P_Passes( const Region& r ); /* This recursive Function determines, by a pre-order run through the hierarchical structure, if the HCMPoint possibly-passes the given Region-value. */ bool P_Passes( const int layer, const int start, const int end, const Region& r ); void AtInstant( const Instant& t, temporalalgebra::Intime& result ); int AtInstant( const int layer, const int start, const int end, const Instant& t, temporalalgebra::Intime& result ); void AtPeriods( const temporalalgebra::Periods& p, CMPoint& result); int AtPeriods( const int layer, const int start, const int end, const temporalalgebra::Periods& p, CMPoint& result ); void D_At( const Point& p, CMPoint& result ); bool D_At( const int layer, const int start, const int end, const Point& p, CMPoint& result); void D_At( const Region& r, CMPoint& result ); bool D_At( const int layer, const int start, const int end, const Region& r, CMPoint& result ); void P_At( const Point& p, CMPoint& result ); bool P_At( const int layer, const int start, const int end, const Point& p, CMPoint& result); void P_At( const Region& r, CMPoint& result ); bool P_At( const int layer, const int start, const int end, const Region& r, CMPoint& result ); /* */ void Get( const int i, HCUPoint& hcup ) const; void GetCMPoint( const double epsilon, CMPoint& result ); void Add( const HCUPoint& hcup ); //void GetGeneralization( const double epsilon, const Unit*& upi ) const; /* Returns the unit ~upi~ at the position ~i~ in the mapping. */ void Clear(); /* Remove all entities in all DBArrays. */ bool IsValid() const; /* This functions tests if a ~HMPoint~ is in a valid format. It is used for debugging purposes only. The ~HMPoint~ is valid, if the following conditions are true: 1 Each entity is valid 2 Each entity within the layers 0 to 4 has defined indices pointing to its origin-entity. 3 Each entity within the layers 1 to 5 has a defined index 'generalizedby'. 3.7.3 Functions to be part of relations */ inline bool IsDefined() const { return true; } inline void SetDefined( bool Defined ) {} inline size_t Sizeof() const { return sizeof( *this ); } inline int Compare( const Attribute *arg ) const; inline bool Adjacent( const Attribute *arg ) const { return false; } inline Attribute* Clone() const; inline std::ostream& Print( std::ostream &os ) const; inline size_t HashValue() const { return 0; } inline void CopyFrom( const Attribute* right ); inline int NumOfFLOBs() const { return 5; } inline Flob* GetFLOB( const int i); static const std::string BasicType() {return "hcmpoint"; } static const bool checkType(const ListExpr type){ return listutils::isSymbol(type,BasicType()); } /* 3.7.3.7 ~BoundingBox~ Returns the HCMPoint's minimum bounding rectangle */ // return the stored bbox Rectangle<3> BoundingBox() const; // return a bbox without the 3rd (temporal) Dimension Rectangle<2> BBox2D() const; // recompute bbox, if necessary void RestoreBoundingBox(const bool force = false); /* 3.7.4 Attributes */ double layer0epsilon, layer1epsilon, layer2epsilon, layer3epsilon, layer4epsilon; /* 5 variables of type double, to store the uncertainty-value of each layer. */ DbArray layer0, layer1, layer2, layer3, layer4; /* 5 DBArrays to store the entities depending on their epsilon-value. */ protected: bool canDestroy; double epsilon; double factor; /* A flag indicating if the destructor should destroy also the persistent array of intervals. */ Rectangle<3> bbox; /* Represents the bounding box of the hcmpoint. */ }; /* 3.8 HMPoint the HierarchicalMovingPoint Type, contains a set of CUPoints from which every Generalization of the corresponding temporalalgebra::MPoint can be extracted. This type also contains the UPoints of the origin temporalalgebra::MPoint as CUPoint-Objects with an epsilon-value = 0. */ class HMPoint : public HCMPoint { public: /* 3.8.1 Constructors and Destructor */ HMPoint() {} /* The simple constructor. This constructor should not be used. */ HMPoint( const int n ): HCMPoint( 0 ), certainlayer( n ) { } /* A constructor, initializing space for ~n~ entities in the bottom layer. */ HMPoint( const double e, const double f, const temporalalgebra::MPoint& m ): HCMPoint( 0, e, f ), certainlayer( m.GetNoComponents() ) { } /* This constructor creates a new HMPoint from the given temporalalgebra::MPoint-object. The units of the temporalalgebra::MPoint will be stored in hierarchical entities in the DBArray layer5. The layers 4 to 0 will be filled with generalizations of this i temporalalgebra::MPoint, which are computed using the given values epsilon and faktor. */ ~HMPoint() { if( canDestroy ) certainlayer.Destroy(); } /* The destructor. */ /* 3.8.2 member functions */ void clear() { HCMPoint::Clear(); certainlayer.clean(); } /* It is necessary to overload the function IsEmpty to ensure that it uses the right function GetNoComponents. */ inline bool IsEmpty() const { return (GetNoComponents() == 0); } int GetNoComponents() const { int noComponents = HCMPoint::GetNoComponents() + certainlayer.Size(); return noComponents; } void Get( const int layer, const int i, HCUPoint& hcup ) const; void Get( const int layer, const int i, CUPoint& cup ) const; //void Get( const int layer, const int i, temporalalgebra::UPoint // const*& up ) const; void Get( const int i, HCUPoint& ntt ) const; void GetCMPoint( const double epsilon, CMPoint& result ); void GetMPoint( temporalalgebra::MPoint& result ); void Put( const int layer, const int i, HCUPoint& hcup); inline int LayerSize( const int layer ) const; void ResizeLayer( const int layer, const int n ); void Add( const HCUPoint& hcup ); int Position( int layer, const Instant& t, const int start, const int end ); int Generalize(const int layer, const bool checkBreakPoints, const datetime::DateTime dur); void Simplify(const int min, const int max, const int layer, bool* useleft, bool* useright, double* realepsilon, const double epsilon); bool D_Passes( const Point& p ); bool D_Passes( const int layer, const int start, const int end, const Point& p ); bool D_Passes( const Region& r ); bool D_Passes( const int layer, const int start, const int end, const Region& r ); void D_At( const Point& p, temporalalgebra::MPoint& result ); bool D_At( const int layer, const int start, const int end, const Point& p, temporalalgebra::MPoint& result); void D_At( const Region& r, temporalalgebra::MPoint& result ); bool D_At( const int layer, const int start, const int end, const Region& r, temporalalgebra::MPoint& result ); void AtInstant( const Instant& t, temporalalgebra::Intime& result ); int AtInstant( const int layer, const int start, const int end, const Instant& t, temporalalgebra::Intime& result ); void AtPeriods( const temporalalgebra::Periods& p, temporalalgebra::MPoint& result); int AtPeriods( const int layer, const int start, const int end, const temporalalgebra::Periods& p, temporalalgebra::MPoint& result ); void ReduceHierarchy( const double epsilon, HCMPoint& result ); /* 3.8.3 functions to be part of relations */ inline std::ostream& Print( std::ostream &os ) const; inline int Compare( const Attribute *arg ) const; inline Attribute* Clone() const; inline void CopyFrom( const Attribute* right ); inline size_t Sizeof() const { return sizeof( *this ); } inline int NumOfFLOBs() const { return 6; } inline Flob* GetFLOB( const int i); static const std::string BasicType() {return "hmpoint"; } static const bool checkType(const ListExpr type){ return listutils::isSymbol(type,BasicType()); } /* 3.8.4 Attributes */ DbArray certainlayer; /* The DBArray ~certainlayer~ stores only HCUPoint-objects with an epsilon-value of 0. */ }; /* 3.9 Some auxiliary functions */ void Circle( const Point p, const double radius, const int n, Region& result); /* Computes a cirular shaped region around Point p, with the given radius. This region consists of n pairs of halfsegments. */ bool FindDefPassingPoint( const HalfSegment& chs, const HalfSegment& rgnhs, const double epsilon, Point& defPP); /* This function tries to find a point on halfsegment chs, that has exactly the distance of espilon to the halfsegment rgnhs and lies on the inner side of rgnhs. Therefore rgnhs must belong to a region, so that the Attribute insideAbove is evaluable. If such a point exists, the parameter defPP is set to this value and TRUE is returned. Otherwise FALSE is returned. */ bool FindPosPassingPoint( const HalfSegment& chs, const HalfSegment& rgnhs, const double epsilon, Point& posPP); /* Does the same as 'FindDefPassingPoint', but it tries to find that point on the outer side of the halfsegment rgnhs. If such a point exists, the parameter posPP is set to this value and TRUE is returned. Otherwise FALSE is returned. */ void Generalize( const double epsilon, const double factor, const temporalalgebra::MPoint& source, const bool checkBreakPoints, const datetime::DateTime dur, HMPoint& result); /* This Function inserts a temporalalgebra::MPoint-object into the certainlayer of a HMPoint and computes up to 5 generalizations of this temporalalgebra::MPoint which are stored in the layers 0 to 4. */ void Generalize( const double epsilon, const double factor, const int layer, const CMPoint& source, const bool checkBreakPoints, const datetime::DateTime dur, HMPoint& result); static bool IsBreakPoint(const CUPoint* u,const datetime::DateTime& duration); /* This is an auxiliary function for the 'generalize'-algorithm. */ static bool connected(const CUPoint* u1, const temporalalgebra::UPoint* u2); /* This function checks whether the end point of the first unit is equal to the start point of the second unit and if the time difference is at most a single instant. 4 Type Constructors 4.1 Type Constructor ~uncertain~ Type ~uncertain~ represents a pair ( epsilon ( )). 4.1.1 List Representation The list representation of an ~uncertain~ is ---- ( epsilon ( ) ) ---- For example a cpoint: ---- ( 20.5 ( 329.456 22.289 ) ) ---- 4.2 Function describing the signature of the Type Constructor 4.2.2 ~In~-function */ /*template Word InUncertain( const ListExpr typeInfo, const ListExpr instance, const int errorPos, ListExpr& errorInfo, bool& correct) { string errmsg; if ( nl->ListLength( instance ) == 2 ) { ListExpr first = nl->First( instance ); // the epsilon value ListExpr second = nl->Second( instance ); // the Alpha-Object { if ( nl->IsAtom(first) && nl->AtomType(first) == RealType ) { correct = true; Alpha *value = (Alpha *)InFun( nl->TheEmptyList(), second, errorPos, errorInfo, correct ).addr; if ( correct == false ) { delete value; return SetWord( Address(0) ); } else // if correct { Uncertain *uncertain = new Uncertain ( nl->RealValue(first), *value); delete value; return SetWord( uncertain ); } } else { errmsg = "InUncertain(): First arg must be of type Real."; errorInfo = nl->Append(errorInfo, nl->StringAtom(errmsg)); } } } correct = false; return SetWord(Address (0) ); }*/ /* 4.2.3 ~Out~-function */ /*template ListExpr OutUncertain( ListExpr typeInfo, Word value ) { Uncertain* uncertain = (Uncertain*)(value.addr); if( uncertain->IsDefined() ) return nl->TwoElemList( nl->RealAtom( &uncertain->GetEpsilon()), OutFun( nl->TheEmptyList(), SetWord( &uncertain->value ) ) ); // Up to now the previous line sems to contain an error: // If the OutUncertain-function is mentioned in the typeconstructor // ~uncertainpoint~ (see HierarchicalGeoAlgebra.cpp line 316) // the compiler returns the following error message: // 'HierarchicalGeoAlgebra.h: In function ‘ListExpr OutUncertain // (ListExpr, Word) [with Alpha = Point, ListExpr (* OutFun) // (ListExpr, Word) = OutPoint]’: // HierarchicalGeoAlgebra.cpp:328: instantiated from here // HierarchicalGeoAlgebra.h:613: error: invalid lvalue in unary ‘&' // I got no idea for the reason of this message. (Sascha Vaut) else return nl->SymbolAtom("undef"); }*/ /* 4.2.4 ~Create~-function */ //template Word CreateUncertain( const ListExpr typeInfo ) { return (SetWord( new Uncertain() )); } /* 4.2.5 ~Delete~-function */ //template void DeleteUncertain( const ListExpr typeInfo, Word& w ) { delete (Uncertain *)w.addr; w.addr = 0; } /* 4.2.6 ~Close~-function */ //template void CloseUncertain( const ListExpr typeInfo, Word& w ) { delete (Uncertain *)w.addr; w.addr = 0; } /* 4.2.7 ~Clone~-function */ //template Word CloneUncertain( const ListExpr typeInfo, const Word& w ) { Uncertain *uncertain = (Uncertain *)w.addr; return SetWord( new Uncertain( *uncertain ) ); } /* 4.2.8 ~Sizeof~-function */ //template int SizeOfUncertain() { return sizeof(Uncertain); } /* 4.2.9 ~Cast~-function */ //template void* CastUncertain(void* addr) { return new (addr) Uncertain; } /* 4.3 Value mapping functions for class Uncertain 4.3.1 Value mapping functions of operator ~epsilon~ */ //template int UncertainEpsilon( Word* args, Word& result, int message, Word& local, Supplier s ) { result = qp->ResultStorage( s ); Uncertain* u = (Uncertain*)args[0].addr; if( u->UncertainIsDefined() ) { // +++++ for debugging purposes only +++ cout << "epsilon ist = " << u->GetEpsilon() << "\n"; ((CcReal*)result.addr)->Set( u->GetEpsilon() ); } else ((CcReal*)result.addr)->SetDefined( false ); return 0; }