along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/MRegionOps3/SetOps.h
along dfd1e74548 firs commit
2026-01-23 17:03:45 +08:00

2039 lines
48 KiB
C++
Raw Blame History

/*
----
This file is part of SECONDO.
Copyright (C) 2008, 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}}]
//[TOC] [\tableofcontents]
//[ue] [\"u]
//[ae] [\"a]
//[oe] [\"o]
//[x] [$\times $]
//[->] [$\rightarrow $]
[1] Implementation of the MRegionOps3Algebra
April - November 2008, M. H[oe]ger for bachelor thesis.
Mai - November 2017, U. Wiesecke for master thesis.
[TOC]
1 Introduction
This file essentially contains the definitions of several classes which
provides the core functionality of the three set operators
~intersection~, ~union~ and ~minus~ with the signature \\
mregion [x] mregion [->] mregion \\
used in the ~MovingRegionAlgebra~.
2 Defines and Includes
*/
#include "PointVectorSegment.h"
#include "NumericUtil.h"
#include "DateTime.h"
#include "Algebras/Temporal/TemporalAlgebra.h"
#include "Algebras/MovingRegion/MovingRegionAlgebra.h"
#include <gmp.h>
#include <gmpxx.h>
#include <set>
#include <vector>
#include <list>
#include <string>
#ifndef SETOPS_H
#define SETOPS_H
namespace temporalalgebra {
namespace mregionops3 {
class PFace;
/*
3 Enumeration
3.1 SourceFlag
Indicates the source unit of a ~RationalPoint3DExt~.
*/
enum SourceFlag {
UNIT_A,
UNIT_B
};
/*
3.2 Enumeration State
Used in the class ~PFace~ to indicate it's current state.
*/
enum State {
UNKNOWN,
RELEVANT,
CRITICAL,
NOT_RELEVANT
};
/*
3.3 Enumeration Border
Used in the class ~PFace~ to indicate the border.
*/
enum Border {
LEFT,
RIGHT
};
/*
3.4 Enumeration SetOp
Indicates the kind of set operation.
*/
enum SetOp {
INTERSECTION,
UNION,
MINUS
};
/*
3.5 Enumeration SetOp
Indicates the kind of predicate operation.
*/
enum PredicateOp {
INTERSECTS,
INSIDE
};
/*
4 Class RationalPoint3DExt
This datastructure is used in the class ~RationalPointExtSet~.
It simply extends ~Point3D~ with the attribute ~sourceFlag~.
*/
class RationalPoint3DExt : public RationalPoint3D {
public:
/*
4.1 Constructors
*/
RationalPoint3DExt();
RationalPoint3DExt(const mpq_class& a, const mpq_class& b,
const mpq_class& c, SourceFlag sourceFlag);
/*
4.2 Setter and getter methods
*/
void setSourceFlag(SourceFlag flag);
SourceFlag getSourceFlag()const;
/*
4.3 Operators and Predicates
4.3.1 operator $<$
*/
bool operator < (const RationalPoint3DExt& point) const;
/*
4.3.2 Operator <<
Print the object values to stream.
*/
friend std::ostream& operator <<(std::ostream& os,
const RationalPoint3DExt& point);
private:
/*
4.4 Attributes
4.4.1 sourceFlag
An enum, indicating the ~PFace~, this ~RationalPoint3DExt~ belongs to.
Possible values are:
* $PFACE\_A$
* $PFACE\_B$
*/
SourceFlag sourceFlag;
};
/*
5 Class RationalPoint3DExtSet
This set is used in the class ~PFace~ to compute the intersection segment of
two ~PFaces~.
*/
class RationalPoint3DExtSet {
public:
/*
5.1 Constructors
*/
RationalPoint3DExtSet();
/*
5.2 Methods, operators and predicates
5.2.1 insert
Inserts point, if point isn't already inserted.
*/
void insert(const RationalPoint3DExt& point);
/*
5.2.2 size
Returns the number of points in the set.
*/
size_t size() const;
/*
5.2.3 getIntersectionSegment
Returns ~true~, if there is an intersection segment and writes it to result.
*/
bool getIntersectionSegment(RationalSegment3D& result) const;
/*
5.2.4 Operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const RationalPoint3DExtSet& points);
/*
5.2.5 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
private:
/*
5.3 Attributes
5.3.1 points
A ~std::set~, using the overloaded operator $<$ for comparison.
*/
std::set<RationalPoint3DExt> points;
};
/*
6 Class RationalPlane3D
The class implements operations for planes in the (x, y, t)-Space.
Here, methods and operators were realized that support the intersection
of two P-Faces.
*/
class RationalPlane3D{
public:
/*
6.1 Constructors
*/
RationalPlane3D();
RationalPlane3D(const RationalPlane3D& plane);
RationalPlane3D(const PFace& pf);
/*
6.2 Getter methods
*/
RationalPoint3D getPointOnPlane() const;
RationalVector3D getNormalVector() const;
/*
6.3 Methods, operators and predicates
6.3.1 distance2ToPlane
*/
mpq_class distance2ToPlane(const RationalPoint3D& point) const;
/*
6.3.2 isParallelTo
Returns ~true~, if this ~RationalPlane3D~ is parallel to the
~RationalPlane3D~ plane.
*/
bool isParallelTo(const RationalPlane3D& plane) const;
/*
6.3.3 isCoplanarTo
Returns ~true~, if this ~RationalPlane3D~ is coplanar to the argument.
*/
bool isCoplanarTo(const RationalPlane3D& plane)const;
/*
6.3.4 intersection
The method determines the intersection of a segment in the (x, y, t)-
Space with the plane of a p-face.
*/
bool intersection(const Segment3D segment, RationalPoint3D& result)const;
/*
The method determines the intersections of another P-Face in the (x, y, t)-
space with the plane of a P-Face.
*/
void intersection(const PFace& other, SourceFlag sourceFlag,
RationalPoint3DExtSet& intPointSet)const;
/*
7.3.4 operator =
*/
RationalPlane3D& operator =(const RationalPlane3D& point);
/*
6.3.5 Operator <<
Print the object values to stream.
*/
friend std::ostream& operator <<(std::ostream& os,
const RationalPlane3D& plane);
/*
6.3.6 isLeftSideInner
The method determines, for a directed intersection segment, whether the left
side of the segment is inside the plane of the other P-Face.
*/
bool isLeftSideInner(const RationalSegment3D segment,
const RationalPlane3D other)const;
/*
6.3.7 transform
The method transforms a point from the three-dimensional space to the plane
of the P-Face as a two-dimensional point.
*/
RationalPoint2D transform(const RationalPoint3D& point) const;
/*
The method transforms a segment from the three-dimensional space to the plane
of the P-Face as a two-dimensional segment.
*/
RationalSegment2D transform(const RationalSegment3D& segment) const;
/*
The method transforms all segments from three-dimensional space onto the plane
of the P-Face as two-dimensional segments.
*/
void transform(const std::vector<RationalSegment3D>& segment3D,
std::vector<RationalSegment2D>& segment2D) const;
private:
/*
6.4 Private methods
6.4.1 Setter methods
*/
void set(const RationalVector3D& normalVector,
const RationalPoint3D& pointOnPlane);
void set(const RationalPlane3D& plane);
/*
6.5 Attributes
*/
RationalVector3D normalVector;
RationalVector3D wVector;
RationalPoint3D pointOnPlane;
};
/*
7 Class IntersectionPoint
The class implements the representation of a point in the (x, y, t, w)-space.
The coordinates of the point include its position in the (x, y, t)-space and
the local coordinates that the point has on the surface of a P-Face in the
(w, t)-Space. The specified point belongs to a intersection segment associated
with a P-Face. The position of the point in the (w, t) coordinate system is
needed for sorting the intersection segments and in the (x, y, t) coordinate
system for performing the plane sweep.
*/
class IntersectionPoint {
public:
/*
7.1 Constructors
*/
IntersectionPoint();
IntersectionPoint(const IntersectionPoint& point);
IntersectionPoint(const RationalPoint3D& point3D,
const RationalPoint2D& point2D);
IntersectionPoint(mpq_class x, mpq_class y, mpq_class z, mpq_class w);
/*
7.2 Getter methods
*/
RationalPoint3D getRationalPoint3D() const;
RationalPoint2D getRationalPoint2D() const;
mpq_class getX()const;
mpq_class getY()const;
mpq_class getZ()const;
mpq_class getW()const;
mpq_class getT()const;
Rectangle<3> getBoundingBox()const;
/*
7.3 Methods, operators and predicates
7.3.1 Operator <<
Print the object values to stream.
*/
friend std::ostream& operator <<(std::ostream& os,
const IntersectionPoint& point);
/*
7.3.2 operator =
*/
IntersectionPoint& operator =(const IntersectionPoint& point);
/*
7.3.3 operator ==
*/
bool operator ==(const IntersectionPoint& point) const;
private:
/*
7.4 Private methods
7.4.1 set
*/
void set(const IntersectionPoint& point);
/*
7.5 Attributes
*/
mpq_class x;
mpq_class y;
mpq_class z;
mpq_class w;
};
/*
8 Class IntersectionSegment
The class implements the representation of a intersection segment with start
and end points in (x, y, t, w) space. The coordinate components for the
surface always refer to a certain P-Face. A intersection segment also has
a predicate that specifies more information about the intersection segment.
*/
class IntersectionSegment{
public:
/*
8.1 Constructors
*/
IntersectionSegment();
IntersectionSegment(const IntersectionSegment& segment);
IntersectionSegment(const IntersectionPoint& tail,
const IntersectionPoint& head,
const Predicate& predicate = UNDEFINED);
IntersectionSegment(const RationalSegment3D& segment3D,
const RationalSegment2D& segment2D,
const Predicate& predicate = UNDEFINED);
/*
8.2 Getter methods
*/
RationalSegment3D getRationalSegment3D()const;
RationalSegment2D getRationalSegment2D()const;
IntersectionPoint getTail() const;
IntersectionPoint getHead() const;
Predicate getPredicate()const;
/*
8.3 Methods, operators and predicates
8.3.1 Operator <<
Print the object values to stream.
*/
friend std::ostream& operator <<(std::ostream& os,
const IntersectionSegment& segment);
/*
8.3.2 operator =
*/
IntersectionSegment& operator =(const IntersectionSegment& segment);
/*
8.3.3 operator ==
*/
bool operator ==( const IntersectionSegment& segment) const;
/*
8.3.5 isOrthogonalToTAxis
Returns ~true~, if this is parallel to the xy-plane.
*/
bool isOrthogonalToTAxis()const;
/*
8.3.6 isOutOfRange
Returns ~true~, if this is out of the t-value.
*/
bool isOutOfRange(mpq_class t) const;
/*
8.3.7 isLeftOf
Returns ~true~, if this is left of intSeg.
*/
bool isLeftOf(const IntersectionSegment& intSeg) const;
/*
8.3.8 evaluate
Returns the point (in xyt-coords) on this segment with t-coord t.
*/
RationalPoint3D evaluate(mpq_class t) const;
private:
/*
8.4 Private methods
8.4.1 Setter methods
*/
void set(const IntersectionPoint& tail,const IntersectionPoint& head,
const Predicate& predicate);
void set(const IntersectionSegment& segment);
/*
8.5 Attributes
*/
IntersectionPoint tail;
IntersectionPoint head;
Predicate predicate;
};
/*
9 Struct IntSegCompare
This struct implements the ~IntersectionSegment~ order,
used in ~IntSegContainer~.
*/
struct IntSegCompare {
bool operator()(const IntersectionSegment* const& s1,
const IntersectionSegment* const& s2) const;
};
/*
10 Class PlaneSweepAccess
The class defines an interface for methods of the class Selftest.
*/
class PlaneSweepAccess {
public:
/*
10.1 Destructor
*/
virtual ~PlaneSweepAccess();
/*
10.2 Methods and Operators
10.2.1 first
first step in the Plane Sweep.
*/
virtual void first(mpq_class t1, mpq_class t2, Point3DContainer& points,
SegmentContainer& segments, bool pFaceIsCritical);
/*
10.2.2 next
next step in the Plane Sweep.
*/
virtual void next(mpq_class t1, mpq_class t2, Point3DContainer& points,
SegmentContainer& segments, bool pFaceIsCritical);
};// PlaneSweepAccess
/*
11 Class IntSegContainer
This class implemented a container object in which intersection segments
are stored. The saved intersection segments are sorted.
Same intersection segments are not recorded multiple times.
The class provides all the methods needed for the plane sweep to
form the segments of the PResultFace.
*/
class IntSegContainer: public PlaneSweepAccess{
public:
/*
11.1 Constructor
*/
IntSegContainer();
IntSegContainer(const IntSegContainer& container);
/*
11.2 Destructor
*/
~IntSegContainer();
/*
11.3 Methods and Operators
11.3.1 addIntSeg
Adds seg to the set of ~IntersectionSegments~.
*/
void addIntSeg(const IntersectionSegment& seg);
/*
11.3.2 size
Adds seg to the set of ~IntersectionSegments~.
*/
size_t size()const;
/*
11.3.3 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
11.3.4 operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const IntSegContainer& container);
/*
11.3.5 operator ==
*/
bool operator ==(const IntSegContainer& container)const;
/*
11.3.6 operator =
*/
IntSegContainer& operator =(const IntSegContainer& container);
/*
11.3.7 first
The method determines all segments in decomposed form for the first step
during the plane sweep.
*/
void first(mpq_class t1, mpq_class t2, Point3DContainer& points,
SegmentContainer& segments, bool pFaceIsCritical);
/*
11.3.8 next
The method determines all segments in decomposed form for all further steps
during the plane sweep.
*/
void next(mpq_class t1, mpq_class t2, Point3DContainer& points,
SegmentContainer& segments, bool pFaceIsCritical);
private:
/*
11.4 Private methods
11.4.1 hasMoreSegsToInsert
*/
bool hasMoreSegsToInsert(mpq_class t) const;
/*
11.4.2 set
*/
void set(const IntSegContainer& container);
/*
11.5 Attributes
11.5.1 intSegs, intSegIter
A ~std::set~ to store the ~IntersectionSegments~ using the order
provided by ~IntSegCompare~ and a suitable iterator.
*/
std::set<IntersectionSegment*, IntSegCompare> intSegs;
std::set<IntersectionSegment*, IntSegCompare>::iterator intSegIter;
/*
11.5.2 orthogonal, active
A ~std::list~ to store the active ~IntersectionSegments~ and the a
orthogonal ~IntersectionSegments~during the plane-sweep.
*/
std::list<IntersectionSegment*> active;
};
/*
12 struct DoubleCompare
The structure supports the class GlobalTimeValues in sorting the
time instants with structure changes.
*/
struct DoubleCompare {
bool operator()(const mpq_class& d1, const mpq_class& d2) const;
};
/*
13 class GlobalTimeValues
All times at which structural changes take place are recorded in an object
of this class. These time values are retrieved during the plan sweep
to determine the segments for the result P-Fcae.
This class is also used to support scaling of the t-axis using appropriate
methods. There are methods for this which, in addition to the scaled time
values, can also determine and process the original time values.
*/
class GlobalTimeValues{
public:
/*
13.1 Constructor
*/
GlobalTimeValues(double scale = 1,
double orginalStartTime = 0,
double orginalEndTime = 1);
GlobalTimeValues(const Interval<Instant>& orginalInterval);
/*
13.2 Getter and setter methods
*/
void setScaleFactor(double scaleFactor);
Interval<Instant> getOrginalInterval()const;
Interval<Instant> getScaledInterval()const;
double getOrginalStartTime()const;
double getOrginalEndTime()const;
double getScaledStartTime()const;
double getScaledEndTime()const;
/*
13.3 Methods, operators and predicates
13.3.1 Method addTimeValue
*/
void addTimeValue(mpq_class t);
/*
13.2.2 addStartAndEndtime
Inserts the start and end time of the time interval
*/
void addStartAndEndtime();
/*
13.3.3 size
*/
size_t size()const;
/*
13.3.4 print
*/
std::ostream& print(std::ostream& os, std::string prefix) const;
/*
13.3.5 Operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const GlobalTimeValues& timeValues);
/*
13.3.6 Operator ==
*/
bool operator ==(const GlobalTimeValues& other)const;
/*
13.3.7 scaledFirst
*/
bool scaledFirst(mpq_class& t1, mpq_class& t2);
/*
13.3.8 orginalFirst
*/
bool orginalFirst(mpq_class& t1, mpq_class& t2);
/*
13.3.9 scaledNext
*/
bool scaledNext(mpq_class& t1, mpq_class& t2);
/*
13.3.10 orginalNext
*/
bool orginalNext(mpq_class& t1, mpq_class& t2);
/*
13.3.11 createInterval
*/
Interval<Instant> createInterval(double start, double end,
bool lc = true, bool rc = false) const;
private:
/*
13.4 Private methods
13.4.1 computeOrginalTimeValue
*/
mpq_class computeOrginalTimeValue(mpq_class scaledTimeValue)const;
/*
13.5 Attributes
*/
std::set<mpq_class, DoubleCompare> time;
std::set<mpq_class, DoubleCompare>::const_iterator timeIter;
mpq_class t1;
mpq_class t2;
mpq_class orginalT1;
mpq_class orginalT2;
double orginalStartTime;
double orginalEndTime;
double scale;
}; // GlobalTimeValues
/*
14 class PResultFace
This class implements the representation of the result P-Face. In contrast to
the P-Faces, the result P-Faces are not stored in decomposed form (segments,
points). Objects of these classes are formed from the layers of P-Faces if
they belong to the result. This class provides methods that support the
creation of the results region unit.
*/
class PResultFace{
public:
static constexpr double medianHSZoom = 100;
/*
14.1 Constructors
*/
PResultFace();
PResultFace(const PResultFace& other);
PResultFace(const Segment3D& left, const Segment3D& right);
PResultFace(const Segment3D& left, const Segment3D& right,
int faceno, int cycleno, int edgeno, bool leftDomPoint,
bool insideAbove);
PResultFace(const MSegmentData& mSeg,
const GlobalTimeValues& timeValues);
/*
14.2 Getter and setter methods
*/
int getFaceNo() const;
int getCycleNo() const;
int getSegmentNo() const;
bool getInsideAbove() const;
Point3D getLeftStart() const;
Point3D getLeftEnd() const;
Point3D getRightStart() const;
Point3D getRightEnd() const;
HalfSegment getMedianHS() const;
Rectangle<2> getBoundingRec()const;
MSegmentData getMSegmentData() const;
bool isLeftDomPoint() const;
void setLeftDomPoint(bool ldp);
void setSegmentNo(int sn);
/*
14.3 Methods, operators and predicates
14.3.1 copyIndicesFrom
*/
void copyIndicesFrom(const HalfSegment* hs);
/*
14.3.2 LessByMedianHS
Returns ~true~, if the median ~HalfSegment~ of this is
lower than the median ~HalfSegment~ of ms,
according to the ~HalfSegment~ order, specified in the ~SpatialAlgebra~.
*/
bool lessByMedianHS(const PResultFace& other) const;
/*
14.3.3 LogicLess
Returns ~true~, if the median ~HalfSegment~ of this is
lower than the median ~HalfSegment~ of ms,
similar to ~HalfSegment::LogicCompare~, specified in the ~SpatialAlgebra~.
*/
bool logicLess(const PResultFace& other) const;
/*
14.3.4 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
14.3.5 operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const PResultFace& prFace);
/*
14.3.6 operator ==
*/
bool operator ==(const PResultFace& other)const;
/*
14.3.7 operator =
*/
PResultFace& operator =(const PResultFace& other);
bool checkBorder( double e)const;
void merge(const PResultFace& other);
protected:
/*
14.4 Private methods
14.4.1 Setter Methods
*/
void set(const PResultFace& other);
void set(const Point3D leftStart, const Point3D leftEnd,
const Point3D rightStart, const Point3D rightEnd);
/*
14.4.2 createMedianHS
*/
void createMedianHS();
/*
14.4.3 getBoundingRec
*/
Rectangle<2> getBoundingRec(const Point3D& point)const;
/*
14.5 Attributes
*/
Point3D leftStart;
Point3D leftEnd;
Point3D rightStart;
Point3D rightEnd;
HalfSegment medianHS;
bool insideAbove;
Rectangle<2> boundingRect;
}; // PResultFace
/*
15 Class CriticalPResultFace
When intersecting two coplanar P-Paces, the resulting result P-faces are
stored as critical result P-faces. For objects of this class, after acquiring
all critical result P-Faces, another processing step is necessary.
All necessary methods for this processing step are implemented in the class.
*/
class CriticalPResultFace {
public:
/*
15.1 Constructors
*/
CriticalPResultFace();
CriticalPResultFace(const CriticalPResultFace& other);
CriticalPResultFace(const Segment3D& left, const Segment3D& right,
SourceFlag source, Predicate predicate);
/*
15.2 Getter methods
*/
Point3D getMidPoint()const;
Segment3D getLeft() const;
Segment3D getRight() const;
Predicate getPredicate()const;
PResultFace getPResultFace()const;
/*
15.3 Methods, operators and predicates
15.3.1 isPartOfUnitA
*/
bool isPartOfUnitA() const;
/*
15.3.2 createMedianHS
*/
bool hasEqualNormalVector(const CriticalPResultFace& other) const;
/*
15.3.3 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
15.3.4 operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const CriticalPResultFace& cprFace);
/*
15.3.5 operator ==
*/
bool operator ==(const CriticalPResultFace& other)const;
/*
15.3.6 operator =
*/
CriticalPResultFace& operator =(const CriticalPResultFace& other);
/*
15.3.7 print
*/
bool operator <(const CriticalPResultFace& other) const;
private:
/*
15.4 Private methods
15.4.1 Setter Methods
*/
void set(const CriticalPResultFace& other);
void set(const Segment3D& left, const Segment3D& right,
SourceFlag source, Predicate predicate);
/*
15.4 Attributes
*/
SourceFlag source;
Predicate predicate;
Segment3D left;
Segment3D right;
Point3D midPoint;
RationalVector3D normalVector;
};
/*
16 class ResultUnit
In order to be able to generate a result region unit, result P-Faces and
critical result P-Faces are formed from all layers that exist in the same
time interval and assigned to an object of this type. After the critical
result P-Faces have been processed, moving segments may be generated
from the result P-Faces of the object to produce a result region unit.
The class provides methods for all these functions.
*/
class ResultUnit{
public:
/*
16.1 Constructors
*/
ResultUnit();
ResultUnit(double orginalStartTime,double orginalEndTime);
ResultUnit(const ResultUnit& other);
/*
16.2 Methods, operators and predicates
16.2.1 addPResultFace
*/
void addPResultFace(PResultFace& prFace, bool completely);
void addPResultFace(const CriticalPResultFace& cprFace);
void addCPResultFace(const CriticalPResultFace& cprFace);
/*
16.2.2 getTimeInterval
*/
Interval<Instant> getTimeInterval() const;
/*
15.2.3 size
*/
size_t size();
/*
16.2.4 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
16.2.5 operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const ResultUnit& unit);
/*
16.2.6 operator ==
*/
bool operator ==(const ResultUnit& unit) const;
/*
16.2.7 operator =
*/
ResultUnit& operator = (const ResultUnit& unit);
/*
16.2.4 finalize
*/
void finalize();
/*
16.2.4 convertToURegionEmb
*/
URegionEmb* convertToURegionEmb(DbArray<MSegmentData>* segments) const;
/*
16.2.4 evaluateCriticalMSegmens
*/
void evaluateCriticalMSegmens(SetOp setOp);
bool merge(double e);
private:
/*
16.3 Private methods
16.3.1 set
*/
void set(const ResultUnit& other);
/*
16.3.2 less
*/
static bool less(const PResultFace& prf1, const PResultFace& prf2);
/*
16.3.3 logicLess
*/
static bool logicLess(const PResultFace& prf1, const PResultFace& prf2);
/*
16.3.4 copyCriticalMSegmens
*/
void copyCriticalMSegmens(const CriticalPResultFace& cprf, SetOp setOp);
/*
16.4 Attributes
*/
std::vector<PResultFace> prFaces;
std::vector<CriticalPResultFace> mCSegments;
double orginalStartTime;
double orginalEndTime;
};// ResultUnit
/*
17 class Layer
The segments that are created in the sweep plan belong to different result units
depending on the time interval in which they are defined. An object of the class
Layer represents within a P-Face a layer that records all segments of a time
interval. Using methods of this class, the determination and passing on of
predicates is realized. From the stored segments, the result P-Faces or the
critical result P-Faces are finally formed. For all these functions, the class
provides appropriate methods.
*/
class Layer {
public:
/*
17.1 Constructor
*/
Layer(bool iscritical = false);
Layer(const Layer& layer);
/*
17.3.1 Method addOrthSegment
Adds an orthogonal segment to the layer
*/
void addOrthSegment(const Segment& segment);
/*
17.3.4 Method addNonOrthSegment
Adds a non-orthogonal segment to layer
*/
void addNonOrthSegment(const Segment& segment);
/*
17.3.5 Method setPredicateFromPredeccor
Sets the predicate of the segment at the left boundary according
to the information of the predecessor
*/
void setPredicateFromPredecessor(Predicate predicate);
/*
17.3.6 Method setPredicateFromSuccessor
Sets the predicate of the segment at the left boundary according
to the information of the successor
*/
void setPredicateFromSuccessor(Predicate predicate);
/*
17.3.7 Method getPredicateForPredecessor
Returns the predicate for the left segment of the successor
*/
Predicate getPredicateForPredecessor()const;
/*
17.3.8 Method getPredicateForSuccessor
Returns the predicate for the left segment of the predecessor
*/
Predicate getPredicateForSuccessor()const;
/*
17.3.9 Method getBorderPredicate
Returns the predicates for the left and right border
*/
void getBorderPredicates(Predicate& left, Predicate& right)const;
/*
17.3.10 Method setBorderPrediacte
sets the predicates for the left and right border
*/
void setBorderPrediactes(Predicate left, Predicate right);
/*
17.3.11 Method evaluate
Determines the predicates of all segments of a layer with the help
of the intersegment segments
*/
bool evaluate();
/*
17.3.12 Method print
Output the content into a stream
*/
std::ostream& print(std::ostream& os,std::string prefix)const;
/*
17.3.13 Operator <<
*/
friend std::ostream& operator <<(std::ostream& os, const Layer& layer);
/*
17.3.14 Operator ==
Comparison operator, compare two objects for equality.
*/
bool operator ==(const Layer& layer)const;
/*
17.3.15 Operator ==
Assignment operator
*/
Layer& operator =(const Layer& other);
/*
17.3.16 Method intersects
The method determines whether an intersection is within a layer. The result is
returned via the reference predicate. If an evaluation of the layer is possible,
the return value is "true"
*/
bool intersects(bool& predicate)const;
/*
17.3.17 Method inside
The method determines whether a layer is within the other region unit.
The result is returned via the reference predicate. If an evaluation of the
layer is possible, the return value is "true"
*/
bool inside(bool& predicate)const;
/*
17.3.18 Method getResultUnit
In the result unit, the moving segments of the layer are created and stored
which correspond to the desired predicate. Critical moving segments are
recorded seperately in the results unit.
*/
void getResultUnit(Predicate soughtPredicate, bool reverse,
const Point3DContainer& points, ResultUnit& unit,
SourceFlag source)const;
private:
/*
17.4.1 Method getBorderPredicate
Returns the predicate of the area bounded by the segment
*/
Predicate getBorderPredicate(const Segment& segment, Border border)const;
/*
17.4.2 Method getAreaPredicate
Returns the predicate of the surface bounded by the left and right segments
*/
Predicate getAreaPredicate(size_t left, size_t right, size_t orthogonal,
bool orthSegmentExist)const;
/*
17.4.3 Method print
Outputs a vector into a stream
*/
void print(std::ostream& os, std::vector<size_t> values)const;
/*
17.4.4 Method set
Applies the attributes of another object of the same class
*/
void set(const Layer& layer);
/*
17.5 Attributes
*/
SegmentContainer segments;
std::vector<size_t> orthSegments;
std::vector<size_t> nonOrthSegments;
size_t touchAbove;
size_t touchBelow;
bool isCritical;
}; // class Layer
/*
18 class LayerContainer
Within a P-Face, a layer of segments is generated for each time interval used
in the plane sweep. All layers within a P-Face are stored in an object of the
class LayerContainer. The class provides appropriate methods for identifying
and passing predicates between layers and beyond the boundaries of the P-Face.
*/
class LayerContainer {
public:
/*
18.1 Constructor
*/
LayerContainer(size_t size = 0, bool isCritcal = false);
LayerContainer(const LayerContainer& other);
LayerContainer(Point3DContainer& points,
GlobalTimeValues &timeValues,
PlaneSweepAccess &access,
bool isCritcal);
/*
18.3.1 Method addOrthSegment
Add the orthogonal segment to the specified layer
*/
void addOrthSegment(size_t layer, const Segment& segment);
/*
18.3.2 Method addNonOrthSegment
Add the non-orthogonal segment to the specified layer
*/
void addNonOrthSegment(size_t layer, const Segment& segment);
/*
18.3.3 Method print
Output the content into a stream
*/
std::ostream& print(std::ostream& os,std::string prefix)const;
/*
18.3.4 Operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const LayerContainer& layerContainer);
/*
18.3.5 Method evaluate
In all layers of a P-Face, the predicates of the intersegment segments or
boundaries are evaluated. If all layers of the P-PFace could be evaluated,
the return value is "true".
*/
bool evaluate();
/*
18.3.6 Method getBorderPredicates
Returns the predicate for the left and right boundary of the layers
of a P-Faces.
*/
void getBorderPredicates(Predicate& left, Predicate& right)const;
/*
18.3.7 Operator ==
Comparison operator, compare two objects for equality.
*/
bool operator ==(const LayerContainer& other)const;
/*
18.3.8 Operator =
Assignment operator
*/
LayerContainer& operator =(const LayerContainer& other);
/*
18.3.9 Method intersects
*/
bool intersects(std::vector<bool>& predicate)const;
/*
18.3.10 Method inside
*/
bool inside(std::vector<bool>& predicate)const;
/*
18.3.11 Method getResultUnit
In the result unit, the moving segments of the given layer are created
and stored, which correspond to the desired predicate. Critical moving
segments are recorded seperately in the results unit.
*/
void getResultUnit(size_t layer, Predicate soughtPredicate,
bool reverse, const Point3DContainer& points,
ResultUnit& unit, SourceFlag source)const;
private:
/*
18.4 Private methods
18.4.1 Method set
Applies the attributes of another object of the same class
*/
void set(const LayerContainer& other);
/*
18.5 Attributes
*/
std::vector<Layer> layers;
};// LayerContainer
/*
19 Class PFace
Objects of this class and the components contained in them represent the main
processing objects of the implemented algorithms. For this purpose, the cuts
between P-Faces are determined and the generated intersection segments are
assigned to the relevant P-faces. In the next step, layers with segments of
the result P-Faces are formed from the intersection segments during the plane
sweep. The determination and passing on of the predicates in the layers and
beyond the P-Faces are also organized at the level of the P-Faces. For all these
functions, appropriate methods are implemented in the class.
*/
class PFace: public PResultFace, public PlaneSweepAccess {
friend class Selftest;
public:
/*
19.1 Constructors
*/
PFace(size_t left, size_t right,const Point3DContainer& points,
const SegmentContainer& segments);
PFace(const MSegmentData& mSeg, const GlobalTimeValues& timeValues,
Point3DContainer& points,
SegmentContainer& segments);
PFace(const PFace& pf);
/*
19.2 Setter and Getter methods
*/
void set(const PFace& pf);
void setState(State state);
State getState() const;
/*
19.3 Methods, operators and predicates
19.3.1 existsIntSegs
*/
bool existsIntSegs()const;
/*
19.3.2 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
19.3.3 Operator <<
Print the object values to stream.
*/
friend std::ostream& operator <<(std::ostream& os, const PFace& pf);
/*
19.3.4 intersectionOnPlane
*/
bool intersectionOnPlane(PFace& other,
const RationalPlane3D& planeSelf,
GlobalTimeValues &timeValues);
/*
19.3.5 intersection
Computes the intersection of this ~PFace~ with other.
*/
bool intersection(PFace& other,GlobalTimeValues &timeValues);
/*
19.3.6 toString
*/
static std::string toString(State state);
/*
19.3.7 addIntSeg
*/
void addIntSeg(const IntersectionSegment& seg);
void addIntSeg(const RationalPlane3D &planeSelf,
const RationalPlane3D &planeOther,
const RationalSegment3D &intSeg,
GlobalTimeValues &timeValues);
/*
19.3.8 addBorder
The method adds the left and right border of the P-Face to the
intersection segments.Te predicate "Undefined" is used.
*/
void addBorder(const RationalPlane3D &plane,
Predicate predicate);
/*
The method adds the left and right border of the P-Face to the
intersection segments. The predicates used are set to the predicates
of the border segments of the P-Face.
*/
void addBorder(const SegmentContainer& segments,
Predicate predicate);
/*
19.3.9 setBorderPredicate
The method sets the predicate of the border segment of the P-Face
to the specified value.
*/
void setBorderPredicate(SegmentContainer& segment, Predicate predicate);
/*
19.3.10 Operator =
*/
PFace& operator =(const PFace& pf);
/*
19.3.11 Operator ==
*/
bool operator ==(const PFace& pf)const;
/*
19.3.12 first
*/
void first(mpq_class t1, mpq_class t2, Point3DContainer& points,
SegmentContainer& segments, bool pFaceIsCritical);
/*
19.3.13 next
*/
void next(mpq_class t1, mpq_class t2, Point3DContainer& points,
SegmentContainer& segments, bool pFaceIsCritical);
/*
19.3.14 finalize
*/
bool finalize(Point3DContainer& points, SegmentContainer& segments,
GlobalTimeValues& timeValues);
/*
19.3.15 intersects
*/
bool intersects(Point3DContainer& points, GlobalTimeValues& timeValues,
std::vector<bool>& predicate);
/*
19.3.16 inside
*/
bool inside(Point3DContainer& points, GlobalTimeValues& timeValues,
std::vector<bool>& predicate);
/*
19.3.17 getResultUnit
*/
void getResultUnit(size_t slide, Predicate predicate, bool reverse,
const Point3DContainer& points, ResultUnit& unit,
SourceFlag source);
private:
/*
19.4 Private methods
19.4.1 Method getBorderSegments
The method determines all or only the segments for the left and right edges
of a P-Face, depending on the boolean variable "all".
*/
void getBorderSegments(bool all, std::vector<RationalSegment3D>& borders);
/*
19.4.2 Method intersection
The method calculates the segment of the intersection for the edge segments
of a P-Face and a segment. All segments are exists on the plane of the
P-Face. If a section segment exists, the return value is "true".
*/
bool intersection(const std::vector<RationalSegment2D>& borders,
const RationalSegment2D& segment,
RationalSegment2D& result);
/*
19.4.3 Method map
The method transfers the points of a segment in the plane to a segment
in the (x, y, t) space. The points of the intersection must lie on the
original segment of the plane. The segment on the plane must be an
transformation of the segment in space.
*/
RationalSegment3D map(const RationalSegment3D& orginal3D,
const RationalSegment2D& orginal2D,
const RationalSegment2D& intersection);
/*
19.4.4 createBorder
Creates a segment for the boder of a P-Face. Whether it is the left or
right edge is defined by the value of "border".
*/
IntersectionSegment createBorder(const RationalPlane3D &planeSelf,
Border border, Predicate predicate);
/*
19.5 Attributes
*/
IntSegContainer intSegs;
LayerContainer layers;
State state;
size_t left;
size_t right;
};// class PFace
/*
20 Class FaceCycleInfo
In order to ensure the functionality of the algorithm, information about faces
and cycles of the input region units in the source units must be acquired.
Objects of this class ensure that intersection information is generated for at
least one P-Face of each face and cycle of the region unit. The class provides
suitable methods for the necessary functions.
*/
class FaceCycleInfo {
public:
/*
20.1 Constructor
*/
FaceCycleInfo();
/*
20.2 Setter and Getter methods
*/
void setFirstIndex(size_t firstIndex);
void setTouch();
bool getTouch() const;
size_t getFirstIndex() const;
private:
/*
20.3 Attributes
*/
size_t firstIndex;
bool touch;
};
/*
21 class SourceUnit
The input region units are mapped as objects of this class to perform the
desired operations. The moving segments of the input region units are
stored as P-Faces in the objects. This class provides methods for
bundling the described algorithms for the P-Faces at the next higher
level of abstraction and providing appropriate functions for the set
operations.
*/
class SourceUnit{
public:
/*
21.1 Constructors and Destructor
*/
SourceUnit();
SourceUnit(const SourceUnit& other);
~SourceUnit();
/*
21.2 Methods, operators and predicates
21.2.1 addPFace
*/
void addPFace(const Segment& left, const Segment& right,
const Point3DContainer& points);
/*
21.2.2 addMSegmentData
*/
void addMSegmentData(const MSegmentData& mSeg,
const GlobalTimeValues& timeValues,
Point3DContainer& points);
/*
21.2.3 isEmpty
*/
bool isEmpty()const;
/*
21.2.4 intersect
*/
bool intersect(const SourceUnit& other)const;
/*
21.2.5 addToResultUnit
*/
void addToResultUnit(ResultUnit& result)const;
/*
21.2.6 intersection
*/
void intersection(SourceUnit& other, GlobalTimeValues& timeValues);
/*
21.2.7 intersectionFast
*/
void intersectionFast(SourceUnit& other, GlobalTimeValues& timeValues);
/*
21.2.8 finalize
*/
bool finalize(Point3DContainer& points, GlobalTimeValues& timeValues,
Predicate predicateconst, SourceUnit& other);
/*
21.2.9 intersects
*/
void intersects(Point3DContainer& points, GlobalTimeValues& timeValues,
SourceUnit& other, std::vector<bool>& predicate);
/*
21.2.10 inside
*/
void inside(Point3DContainer& points, GlobalTimeValues& timeValues,
SourceUnit& other, std::vector<bool>& predicate);
/*
21.2.11 getResultUnit
*/
void getResultUnit(size_t slide, Predicate predicate,bool reverse,
const Point3DContainer& points, ResultUnit& unit,
SourceFlag source);
/*
21.2.12 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
21.2.13 Operator <<
Print the object values to stream.
*/
friend std::ostream& operator <<(std::ostream& os,
const SourceUnit& unit);
/*
21.2.14 Operator ==
*/
bool operator ==(const SourceUnit& unit)const;
/*
21.2.15 operator =
*/
SourceUnit& operator =(const SourceUnit& unit);
/*
21.2.16 createTestRegion
*/
void createTestRegion();
/*
21.2.17 isInside
*/
bool isInside(const PFace* pFace);
/*
21.2.18 createFaceCycleEntry
*/
void createFaceCycleEntry(const PFace* pf, size_t index);
/*
21.2.19 touchFaceCycleEntry
*/
void touchFaceCycleEntry(const PFace* pf);
/*
21.2.20 checkFaceCycleEntrys
*/
void checkFaceCycleEntrys(SourceUnit& other);
/*
21.2.21 printFaceCycleEntrys
*/
void printFaceCycleEntrys();
/*
21.2.22 reSort
*/
void reSort();
private:
/*
21.3 Private methods
21.3.1 lessByMedianHS
*/
static bool lessByMedianHS(const PFace* pf1, const PFace *pf2);
/*
21.3.2 logicLess
*/
static bool logicLess(const PFace* pf1, const PFace *pf2);
/*
21.3.3 set
*/
void set(const SourceUnit& other);
/*
21.4 Attributes
*/
std::vector<PFace*> pFaces;
mmrtree::RtreeT<2, size_t> pFaceTree;
SegmentContainer segments;
std::vector<size_t> itersectedPFace;
Region testRegion;
bool testRegionDefined;
std::vector<std::vector<FaceCycleInfo>> faceCycleInfo;
};// class SourceUnit
/*
22 Class SourceUnitPair
In this class, processing is performed for set operations from the two source
units to the result unit. For this purpose, an object of the class has two
source units, from which one or more result units are calculated. The class
provides suitable methods for the set operations to be performed, which
exclusively relate to the internal representation. Methods are also provided
for storing or reading out region units into the internal data structure.
*/
class SourceUnitPair {
public:
/*
22.1 Constructors
*/
SourceUnitPair(double orginalStartTime = 0,double orginalEndTime = 1,
double scale = 1);
SourceUnitPair(const Interval<Instant>& orginalInterval);
/*
22.2 Methods, operators and predicates
22.2.1 setScaleFactor
*/
void setScaleFactor(double scale);
/*
22.2.2 addPFace
*/
void addPFace(SourceFlag flag, Segment3D& left, Segment3D& right);
/*
22.2.3 addMSegmentData
*/
void addMSegmentData(const MSegmentData& mSeg, SourceFlag sourceFlag);
/*
22.2.4 operate
*/
bool operate(SetOp setOp);
/*
22.2.5 predicate
*/
bool predicate(PredicateOp predicateOp);
/*
22.2.6 print
*/
std::ostream& print(std::ostream& os, std::string prefix)const;
/*
22.2.7 operator <<
*/
friend std::ostream& operator <<(std::ostream& os,
const SourceUnitPair& unitPair);
/*
22.2.8 countResultUnits
*/
size_t countResultUnits()const;
/*
22.2.9 getResultUnit
*/
ResultUnit getResultUnit(size_t slide)const;
/*
22.2.10 createResultMRegion
*/
void createResultMRegion( MRegion* resMRegion);
/*
22.2.11 createResultMBool
*/
void createResultMBool(MBool* resMBool, bool lc, bool rc );
/*
22.2.12 createSourceUnit
*/
void createSourceUnit(const Interval<Instant>& interval, MRegion* mregion,
SourceFlag sourceFlag);
private:
/*
22.3 Attributes
*/
SourceUnit unitA;
SourceUnit unitB;
std::vector<ResultUnit> result;
std::vector<bool> predicates;
GlobalTimeValues timeValues;
Point3DContainer points;
};
/*
23 class SetOperator
In this class, the processing for set operations from moving input regions to
moving result regions is realized. For this purpose, the refinement partition
first generates pairs of source region units defined over the same time
interval. An object of the SourceUnitPair class organizes the processing of
the two source units until the result is several result units. From these,
region units are formed and added to the moving region of the result.
*/
class SetOperator {
public:
/*
23.1 Constructors
*/
SetOperator(MRegion* const _mRegionA, MRegion* const _mRegionB,
MRegion* const _mRegionResult);
/*
23.2 Method operate
*/
void operate(SetOp setOp);
private:
/*
23.3 Attributes
*/
MRegion* const mRegionA;
MRegion* const mRegionB;
MRegion* const mRegionResult;
}; // class SetOperator
/*
24 class PredicateOperator
In this class, the processing of the predicate operations from moving input
regions to a moving Boolean value is realized.
*/
class PredicateOperator {
public:
/*
24.1 Constructors
*/
PredicateOperator(MRegion* const _mRegionA, MRegion* const _mRegionB,
MBool* const _mBool);
/*
23.2 Method operate
*/
void operate(PredicateOp predicateOp);
private:
/*
24.4 Attributes
*/
MRegion* const mRegionA;
MRegion* const mRegionB;
MBool* const mBool;
}; // class PredicateOperator
} // end of namespace mregionops3
} // end of namespace temporalalgebra
#endif
// SETOPS_H
Reference in New Issue View Git Blame Copy Permalink