along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/RobustPlaneSweep/RobustPlaneSweepAlgebra.cpp

3330 lines
66 KiB
C++
Raw Normal View History

firs commit
2026-01-23 17:03:45 +08:00
/*
----
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}}]
//[TOC] [\tableofcontents]
//[_] [\_]
[1] Implementation file for the class ~RobustPlaneSweepAlgebra~
[TOC]
1 Overview
This file contains all structs and classes required for the
RobustPlaneSweepAlgebra.
1 Includes and defines
*/
// #define OUTPUT_HALFSEGMENTS
#include "Algebras/Spatial/SpatialAlgebra.h"
#include "RobustPlaneSweepAlgebra.h"
#include "Algebras/Temporal/TemporalAlgebra.h"
#include "Algebras/Spatial/DLine.h"
#include "Algorithm/Hobby.h"
#include "RobustOperators.h"
using namespace temporalalgebra;
using namespace std;
namespace RobustPlaneSweep
{
/*
1 Data classes
1.1 Data class for operations with two HalfSegment-Collections (Line or Region)
*/
template<class TINPUT1, class TINPUT2>
class HalfSegmentHalfSegmentData :
public IntersectionAlgorithmData
{
/*
1.1.1 Member variables
*/
private:
const TINPUT1& _source1;
int _source1Index;
int _source1Size;
HalfSegment _source1segment;
const TINPUT2& _source2;
int _source2Index;
int _source2Size;
HalfSegment _source2segment;
public:
/*
1.1.1 Constructor
*/
HalfSegmentHalfSegmentData(const TINPUT1& source1,
const TINPUT2& source2) :
_source1(source1),
_source1Index(0),
_source1Size(-1),
_source2(source2),
_source2Index(0),
_source2Size(-1)
{
#ifdef OUTPUT_HALFSEGMENTS
cout.precision(15);
#endif
}
/*
1.1.1 Destructor
*/
~HalfSegmentHalfSegmentData()
{
}
/*
1.1.1 ~InitializeFetch~
*/
void InitializeFetch()
{
#ifdef OUTPUT_HALFSEGMENTS
cout << "\n";
#endif
_source1Index = 0;
_source1Size = _source1.Size();
if (_source1Index < _source1Size) {
_source1.Get(_source1Index, _source1segment);
}
_source2Index = 0;
_source2Size = _source2.Size();
if (_source2Index < _source2Size) {
_source2.Get(_source2Index, _source2segment);
}
}
/*
1.1.1 ~FetchInput~
*/
bool FetchInput(HalfSegment &segment,
Point &point,
bool &belongsToSecondGeometry)
{
point.SetDefined(false);
if (_source1Index < _source1Size && _source2Index < _source2Size) {
if (_source1segment.Compare(_source2segment) < 0) {
belongsToSecondGeometry = false;
} else {
belongsToSecondGeometry = true;
}
} else if (_source1Index < _source1Size) {
belongsToSecondGeometry = false;
} else if (_source2Index < _source2Size) {
belongsToSecondGeometry = true;
} else {
return false;
}
if (!belongsToSecondGeometry) {
segment = _source1segment;
if ((++_source1Index) < _source1Size) {
_source1.Get(_source1Index, _source1segment);
}
} else {
segment = _source2segment;
if ((++_source2Index) < _source2Size) {
_source2.Get(_source2Index, _source2segment);
}
}
#ifdef OUTPUT_HALFSEGMENTS
if (!segment.IsLeftDomPoint()) {
cout << "// ";
}
cout << "s.Add(new LineSegment(" <<
(belongsToSecondGeometry?"1":"0") << ", " <<
(segment.attr.edgeno) << ", " <<
" new Base.Point(" <<
segment.GetLeftPoint().GetX() << "," <<
segment.GetLeftPoint().GetY() << "), " <<
" new Base.Point(" <<
segment.GetRightPoint().GetX() << "," <<
segment.GetRightPoint().GetY() << "), " <<
(segment.attr.insideAbove?"true":"false") <<
"));\n";
#endif
return true;
}
/*
1.1.1 ~GetBoundingBox~
*/
const Rectangle<2> GetBoundingBox()
{
return _source1.BoundingBox().Union(_source2.BoundingBox());
}
/*
1.1.1 ~FirstGeometryIsRegion~
*/
bool FirstGeometryIsRegion() const
{
return std::is_same<TINPUT1, Region>::value;
}
/*
1.1.1 ~SecondGeometryIsRegion~
*/
bool SecondGeometryIsRegion() const
{
return std::is_same<TINPUT2, Region>::value;
}
};
/*
1.1 Data class for operations with HalfSegment-Collection and Point(s)
*/
template<class THALFSEGMENT, class TPOINTS>
class HalfSegmentPointsData :
public IntersectionAlgorithmData
{
};
/*
1.1 Template specialization class for operations with
HalfSegment-Collection x Points
*/
template<class THALFSEGMENT>
class HalfSegmentPointsData<THALFSEGMENT, Points> :
public IntersectionAlgorithmData
{
/*
1.1.1 Member variables
*/
private:
const THALFSEGMENT& _source1;
int _source1Index;
int _source1Size;
HalfSegment _source1segment;
const Points& _source2;
int _source2Index;
int _source2Size;
Point _source2Point;
public:
/*
1.1.1 Constructor
*/
HalfSegmentPointsData(const THALFSEGMENT& source1,
const Points& source2) :
_source1(source1),
_source1Index(0),
_source1Size(-1),
_source2(source2),
_source2Index(0),
_source2Size(-1)
{
}
/*
1.1.1 Destructor
*/
~HalfSegmentPointsData()
{
}
/*
1.1.1 ~InitializeFetch~
*/
void InitializeFetch()
{
_source1Index = 0;
_source1Size = _source1.Size();
if (_source1Index < _source1Size) {
_source1.Get(_source1Index, _source1segment);
}
_source2Index = 0;
_source2Size = _source2.Size();
if (_source2Index < _source2Size) {
_source2.Get(_source2Index, _source2Point);
}
}
/*
1.1.1 ~FetchInput~
*/
bool FetchInput(HalfSegment &segment,
Point &point,
bool &belongsToSecondGeometry)
{
if (_source1Index < _source1Size && _source2Index < _source2Size) {
if (_source1segment.GetDomPoint() < _source2Point) {
belongsToSecondGeometry = false;
} else {
belongsToSecondGeometry = true;
}
} else if (_source1Index < _source1Size) {
belongsToSecondGeometry = false;
} else if (_source2Index < _source2Size) {
belongsToSecondGeometry = true;
} else {
return false;
}
if (!belongsToSecondGeometry) {
point.SetDefined(false);
segment = _source1segment;
if ((++_source1Index) < _source1Size) {
_source1.Get(_source1Index, _source1segment);
}
#ifdef OUTPUT_HALFSEGMENTS
if (!segment.IsLeftDomPoint()) {
cout << "// ";
}
cout << "s.Add(new LineSegment(" <<
(belongsToSecondGeometry?"1":"0") << ", " <<
(segment.attr.edgeno) << ", " <<
" new Base.Point(" <<
segment.GetLeftPoint().GetX() << "," <<
segment.GetLeftPoint().GetY() << "), " <<
" new Base.Point(" <<
segment.GetRightPoint().GetX() << "," <<
segment.GetRightPoint().GetY() << "), " <<
(segment.attr.insideAbove?"true":"false") <<
"));\n";
#endif
} else {
point = _source2Point;
if ((++_source2Index) < _source2Size) {
_source2.Get(_source2Index, _source2Point);
}
#ifdef OUTPUT_HALFSEGMENTS
cout << "s.Add(new LineSegment(" <<
(belongsToSecondGeometry?"1":"0") << ", " <<
"-1, " <<
" new Base.Point(" <<
point.GetX() << "," <<
point.GetY() << "), " <<
" new Base.Point(" <<
point.GetX() << "," <<
point.GetY() << "), " <<
"false" <<
"));\n";
#endif
}
return true;
}
/*
1.1.1 ~GetBoundingBox~
*/
const Rectangle<2> GetBoundingBox()
{
return _source1.BoundingBox().Union(_source2.BoundingBox());
}
/*
1.1.1 ~FirstGeometryIsRegion~
*/
bool FirstGeometryIsRegion() const
{
return std::is_same<THALFSEGMENT, Region>::value;
}
/*
1.1.1 ~SecondGeometryIsRegion~
*/
bool SecondGeometryIsRegion() const
{
return false;
}
};
/*
1.1 Template specialization class for operations with
HalfSegment-Collection x Point
*/
template<class THALFSEGMENT>
class HalfSegmentPointsData<THALFSEGMENT, Point> :
public IntersectionAlgorithmData
{
/*
1.1.1 Member variables
*/
private:
const THALFSEGMENT& _source1;
int _source1Index;
int _source1Size;
HalfSegment _source1segment;
const Point& _source2Point;
bool _source2PointRead;
public:
/*
1.1.1 Constructor
*/
HalfSegmentPointsData(const THALFSEGMENT& source1,
const Point& source2) :
_source1(source1),
_source1Index(0),
_source1Size(-1),
_source2Point(source2),
_source2PointRead(false)
{
}
/*
1.1.1 Destructor
*/
~HalfSegmentPointsData()
{
}
/*
1.1.1 ~InitializeFetch~
*/
void InitializeFetch()
{
_source1Index = 0;
_source1Size = _source1.Size();
if (_source1Index < _source1Size) {
_source1.Get(_source1Index, _source1segment);
}
_source2PointRead = false;
}
/*
1.1.1 ~FetchInput~
*/
bool FetchInput(HalfSegment &segment,
Point &point,
bool &belongsToSecondGeometry)
{
if (_source1Index < _source1Size && !_source2PointRead) {
if (_source1segment.GetDomPoint() < _source2Point) {
belongsToSecondGeometry = false;
} else {
belongsToSecondGeometry = true;
}
} else if (_source1Index < _source1Size) {
belongsToSecondGeometry = false;
} else if (!_source2PointRead) {
belongsToSecondGeometry = true;
} else {
return false;
}
if (!belongsToSecondGeometry) {
point.SetDefined(false);
segment = _source1segment;
if ((++_source1Index) < _source1Size) {
_source1.Get(_source1Index, _source1segment);
}
#ifdef OUTPUT_HALFSEGMENTS
if (!segment.IsLeftDomPoint()) {
cout << "// ";
}
cout << "s.Add(new LineSegment(" <<
(belongsToSecondGeometry?"1":"0") << ", " <<
(segment.attr.edgeno) << ", " <<
" new Base.Point(" <<
segment.GetLeftPoint().GetX() << "," <<
segment.GetLeftPoint().GetY() << "), " <<
" new Base.Point(" <<
segment.GetRightPoint().GetX() << "," <<
segment.GetRightPoint().GetY() << "), " <<
(segment.attr.insideAbove?"true":"false") <<
"));\n";
#endif
} else {
point = _source2Point;
_source2PointRead = true;
#ifdef OUTPUT_HALFSEGMENTS
cout << "s.Add(new LineSegment(" <<
(belongsToSecondGeometry?"1":"0") << ", " <<
"-1, " <<
" new Base.Point(" <<
point.GetX() << "," <<
point.GetY() << "), " <<
" new Base.Point(" <<
point.GetX() << "," <<
point.GetY() << "), " <<
"false" <<
"));\n";
#endif
}
return true;
}
/*
1.1.1 ~GetBoundingBox~
*/
const Rectangle<2> GetBoundingBox()
{
return _source1.BoundingBox().Union(_source2Point.BoundingBox());
}
/*
1.1.1 ~FirstGeometryIsRegion~
*/
bool FirstGeometryIsRegion() const
{
return std::is_same<THALFSEGMENT, Region>::value;
}
/*
1.1.1 ~SecondGeometryIsRegion~
*/
bool SecondGeometryIsRegion() const
{
return false;
}
};
/*
1.1 Enum class for set operation types
*/
enum class SetOpType
{
Union = 1,
Intersection = 2,
Minus = 3
};
/*
1.1 Data class for line set operations
*/
class LineLineSetOp :
public HalfSegmentHalfSegmentData<Line, Line>
{
/*
1.1.1 Member variables
*/
private:
SetOpType _setOpType;
Line& _result;
int _outputSegments;
public:
/*
1.1.1 Constructor
*/
LineLineSetOp(const Line& source1,
const Line& source2,
SetOpType setOpType,
Line& result) :
HalfSegmentHalfSegmentData<Line, Line>(source1, source2),
_setOpType(setOpType),
_result(result),
_outputSegments(0)
{
}
/*
1.1.1 Destructor
*/
~LineLineSetOp()
{
}
/*
1.1.1 ~OutputData~
*/
bool OutputData() const
{
return true;
}
/*
1.1.1 ~OutputHalfSegment~
*/
void OutputHalfSegment(const HalfSegment& segment,
const InternalAttribute& attribute)
{
switch (_setOpType) {
case SetOpType::Union:
break;
case SetOpType::Intersection:
if (!attribute.IsBoundaryInBoth()) {
return;
}
break;
case SetOpType::Minus:
if (attribute.IsBoundaryInSecond()) {
return;
}
break;
default:
throw new std::logic_error("setOpType");
}
// cout << "O:" << _outputSegments << "\n";
HalfSegment s1 = segment;
HalfSegment s2 = segment;
s1.SetLeftDomPoint(true);
s2.SetLeftDomPoint(false);
s1.attr.edgeno = _outputSegments;
s2.attr.edgeno = _outputSegments;
_result += s1;
_result += s2;
_outputSegments++;
}
/*
1.1.1 ~SetOp~
*/
static void SetOp(const Line& line1,
const Line& line2,
SetOpType setOpType,
Line& result)
{
result.StartBulkLoad();
LineLineSetOp data(line1, line2, setOpType, result);
Hobby hobby(&data);
hobby.DetermineIntersections();
result.EndBulkLoad(true, false);
}
};
/*
1.1 Data class for region set operations
*/
class RegionRegionSetOp :
public HalfSegmentHalfSegmentData<Region, Region>
{
/*
1.1.1 Member variables
*/
private:
SetOpType _setOpType;
Region& _result;
int _outputSegments;
public:
/*
1.1.1 Constructor
*/
RegionRegionSetOp(const Region& source1,
const Region& source2,
SetOpType setOpType,
Region& result) :
HalfSegmentHalfSegmentData<Region, Region>(source1, source2),
_setOpType(setOpType),
_result(result),
_outputSegments(0)
{
}
/*
1.1.1 Destructor
*/
~RegionRegionSetOp()
{
}
/*
1.1.1 ~OutputData~
*/
bool OutputData() const
{
return true;
}
/*
1.1.1 ~OutputHalfSegment~
*/
void OutputHalfSegment(const HalfSegment& segment,
const InternalAttribute& attribute)
{
bool include;
bool insideAbove;
switch (_setOpType) {
case SetOpType::Union:
include = attribute.IsInUnionRegion(insideAbove);
break;
case SetOpType::Intersection:
include = attribute.IsInIntersectionRegion(insideAbove);
break;
case SetOpType::Minus:
include = attribute.IsInMinusRegion(insideAbove);
break;
default:
throw new std::logic_error("setOpType");
}
#ifdef OUTPUT_HALFSEGMENTS
cout << "O: " <<
_outputSegments << " (" <<
segment.GetLeftPoint().GetX() << "," <<
segment.GetLeftPoint().GetY() << ") - (" <<
segment.GetRightPoint().GetX() << "," <<
segment.GetRightPoint().GetY() << ") (" <<
(attribute.IsFirstAbove()?"A":"_") <<
(attribute.IsFirstBelow()?"B":"_") << "/" <<
(attribute.IsSecondAbove()?"A":"_") <<
(attribute.IsSecondBelow()?"B":"_") << ")" <<
(include?" Inc ":" - ") <<
(insideAbove?" Above ":" Below ") <<
"\n";
#endif
if (!include) {
return;
}
// cout << "O:" << _outputSegments << "\n";
HalfSegment s1 = segment;
HalfSegment s2 = segment;
s1.SetLeftDomPoint(true);
s2.SetLeftDomPoint(false);
s1.attr.edgeno = _outputSegments;
s1.attr.insideAbove = insideAbove;
s2.attr.edgeno = _outputSegments;
s2.attr.insideAbove = insideAbove;
_result += s1;
_result += s2;
_outputSegments++;
}
/*
1.1.1 ~SetOp~
*/
static void SetOp(const Region& region1,
const Region& region2,
SetOpType setOpType,
Region& result)
{
result.StartBulkLoad();
RegionRegionSetOp data(region1, region2, setOpType, result);
Hobby hobby(&data);
hobby.DetermineIntersections();
result.EndBulkLoad();
}
};
/*
1.1 Data class for region/line set operations
*/
class RegionLineSetOp :
public HalfSegmentHalfSegmentData<Region, Line>
{
/*
1.1.1 Member variables
*/
private:
SetOpType _setOpType;
Line& _result;
int _outputSegments;
public:
/*
1.1.1 Constructor
*/
RegionLineSetOp(const Region& source1,
const Line& source2,
SetOpType setOpType,
Line& result) :
HalfSegmentHalfSegmentData<Region, Line>(source1, source2),
_setOpType(setOpType),
_result(result),
_outputSegments(0)
{
}
/*
1.1.1 Destructor
*/
~RegionLineSetOp()
{
}
/*
1.1.1 ~OutputData~
*/
bool OutputData() const
{
return true;
}
/*
1.1.1 ~OutputHalfSegment~
*/
void OutputHalfSegment(const HalfSegment& segment,
const InternalAttribute& attribute)
{
bool include;
switch (_setOpType) {
case SetOpType::Intersection:
include = (attribute.GetFirst() != BoundaryType::OutsideInterior &&
attribute.IsBoundaryInSecond());
break;
case SetOpType::Minus:
include = (attribute.GetFirst() == BoundaryType::OutsideInterior &&
attribute.IsBoundaryInSecond());
break;
default:
throw new std::logic_error("setOpType");
}
if (!include) {
return;
}
// cout << "O:" << _outputSegments << "\n";
HalfSegment s1 = segment;
HalfSegment s2 = segment;
s1.SetLeftDomPoint(true);
s2.SetLeftDomPoint(false);
s1.attr.edgeno = _outputSegments;
s2.attr.edgeno = _outputSegments;
_result += s1;
_result += s2;
_outputSegments++;
}
/*
1.1.1 ~SetOp~
*/
static void SetOp(const Region& region,
const Line& line,
SetOpType setOpType,
Line& result)
{
// set result to a highly estimated value to avoid
// frequent enlargements of the underlying DbArray
result.Resize(line.Size());
result.StartBulkLoad();
RegionLineSetOp data(region, line, setOpType, result);
Hobby hobby(&data);
hobby.DetermineIntersections();
result.EndBulkLoad();
}
};
/*
1.1 Data class for {region, line} x {region, line} intersects operator
*/
template<class TINPUT1, class TINPUT2>
class RegionLineIntersects :
public HalfSegmentHalfSegmentData<TINPUT1, TINPUT2>
{
/*
1.1.1 Member variables
*/
private:
bool _intersects;
public:
/*
1.1.1 Constructor
*/
RegionLineIntersects(const TINPUT1& source1,
const TINPUT2& source2) :
HalfSegmentHalfSegmentData<TINPUT1, TINPUT2>(source1, source2),
_intersects(false)
{
}
/*
1.1.1 Destructor
*/
~RegionLineIntersects()
{
}
/*
1.1.1 ~OnGeometryIntersectionFound~
*/
bool OnGeometryIntersectionFound()
{
_intersects = true;
return true;
}
/*
1.1.1 ~Intersects~
*/
static bool Intersects(const TINPUT1& source1,
const TINPUT2& source2)
{
RegionLineIntersects<TINPUT1, TINPUT2> data(source1, source2);
BentleyOttmann bentleyOttmann(&data);
bentleyOttmann.DetermineIntersections();
return data._intersects;
}
};
/*
1.1 Data class for {region, line} x points set operations
*/
template<class THALFSEGMENT, class TPOINTS>
class RegionLinePointsSetOp :
public HalfSegmentPointsData<THALFSEGMENT, TPOINTS>
{
/*
1.1.1 Member Variables
*/
private:
SetOpType _setOpType;
Points& _result;
public:
/*
1.1.1 Constructor
*/
RegionLinePointsSetOp(const THALFSEGMENT& source1,
const TPOINTS& source2,
SetOpType setOpType,
Points& result) :
HalfSegmentPointsData<THALFSEGMENT, TPOINTS>(source1, source2),
_setOpType(setOpType),
_result(result)
{
}
/*
1.1.1 Destructor
*/
~RegionLinePointsSetOp()
{
}
/*
1.1.1 ~OutputData~
*/
bool OutputData() const
{
return true;
}
/*
1.1.1 ~OutputHalfSegment~
*/
void OutputHalfSegment(const HalfSegment& segment,
const InternalAttribute& attribute)
{
}
/*
1.1.1 ~OutputPoint~
*/
void OutputPoint(const Point& point,
const InternalAttribute& attribute)
{
bool include;
switch (_setOpType) {
case SetOpType::Intersection:
include = (attribute.GetFirst() != BoundaryType::OutsideInterior);
break;
case SetOpType::Minus:
include = (attribute.GetFirst() == BoundaryType::OutsideInterior);
break;
default:
throw new std::logic_error("setOpType");
}
if (!include) {
return;
}
_result += point;
}
/*
1.1.1 ~SetOp~
*/
static void SetOp(const THALFSEGMENT& source,
const TPOINTS& points,
SetOpType setOpType,
Points& result)
{
result.StartBulkLoad();
RegionLinePointsSetOp data(source, points, setOpType, result);
BentleyOttmann bentleyOttmann(&data);
bentleyOttmann.DetermineIntersections();
result.EndBulkLoad();
}
};
/*
1.1 Data class for {region, line} x {point, points} intersects operator
*/
template<class THALFSEGMENT, class TPOINTS>
class RegionLinePointsIntersects :
public HalfSegmentPointsData<THALFSEGMENT, TPOINTS>
{
/*
1.1.1 Member variables
*/
private:
bool _intersects;
public:
/*
1.1.1 Constructor
*/
RegionLinePointsIntersects(const THALFSEGMENT& source1,
const Points& source2) :
HalfSegmentPointsData<THALFSEGMENT, TPOINTS>(source1, source2),
_intersects(false)
{
}
/*
1.1.1 Destructor
*/
~RegionLinePointsIntersects()
{
}
/*
1.1.1 ~OnGeometryIntersectionFound~
*/
bool OnGeometryIntersectionFound()
{
_intersects = true;
return true;
}
/*
1.1.1 ~Intersects~
*/
static bool Intersects(const THALFSEGMENT& source,
const Points& points)
{
RegionLinePointsIntersects data(source, points);
BentleyOttmann bentleyOttmann(&data);
bentleyOttmann.DetermineIntersections();
return data._intersects;
}
};
/*
1.1 Data class for crossing operator
*/
class CrossingsData :
public HalfSegmentHalfSegmentData<Line, Line>
{
private:
/*
1.1.1 Internal Point comparer struct.
The coordinates were integer values and the transformation should be
deterministic, so there is no need for AlmostEqual.
*/
struct PointComparer
{
size_t operator()(const Point &x) const
{
return ((size_t)((int)x.GetX())) ^ ((size_t)((int)x.GetY()));
}
bool operator()(const Point &x, const Point &y) const
{
return (x.GetX() == y.GetX()) && (x.GetY() == y.GetY());
}
};
/*
1.1.1 Member Variables
*/
std::unordered_set<Point, PointComparer> _overlappingPoints;
std::vector<Point> _possibleCrossings;
Points& _result;
public:
/*
1.1.1 Constructor
*/
CrossingsData(const Line& source1,
const Line& source2,
Points& result) :
HalfSegmentHalfSegmentData<Line, Line>(source1, source2),
_result(result)
{
}
/*
1.1.1 Destructor
*/
~CrossingsData()
{
}
/*
1.1.1 ~FirstGeometryIsRegion~
*/
bool FirstGeometryIsRegion() const
{
return false;
}
/*
1.1.1 ~SecondGeometryIsRegion~
*/
bool SecondGeometryIsRegion() const
{
return false;
}
/*
1.1.1 ~ReportIntersections~
*/
bool ReportIntersections() const
{
return true;
}
/*
1.1.1 ~ReportIntersection~
*/
void ReportIntersection(const Point& intersectionPoint,
const bool overlappingIntersection)
{
if (overlappingIntersection) {
_overlappingPoints.insert(intersectionPoint);
} else {
_possibleCrossings.push_back(intersectionPoint);
}
}
/*
1.1.1 ~OutputFinished~
*/
virtual void OutputFinished()
{
for (std::vector<Point>::const_iterator i = _possibleCrossings.begin();
i != _possibleCrossings.end(); ++i) {
if (_overlappingPoints.find (*i) == _overlappingPoints.end()) {
_result += *i;
}
}
}
/*
1.1.1 ~Crossings~
*/
static void Crossings(const Line& line1,
const Line& line2,
Points& result)
{
result.Clear();
if (!line1.IsDefined() || !line2.IsDefined()) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (line1.IsEmpty() || line2.IsEmpty()) {
return;
}
// assert(line1.IsOrdered());
// assert(line2.IsOrdered());
result.StartBulkLoad();
if (line1.BoundingBox().IntersectsUD(line2.BoundingBox())) {
CrossingsData data(line1, line2, result);
BentleyOttmann bo(&data);
bo.DetermineIntersections();
}
result.EndBulkLoad(true, true); // sort and remove duplicates
}
};
/*
1.1 Data class for line minize
*/
class LineMinize : public IntersectionAlgorithmData
{
/*
1.1.1 Member Variables
*/
private:
const Line& _source;
int _currentSourceIndex;
Line& _result;
int _outputSegments;
public:
/*
1.1.1 Constructor
*/
LineMinize(const Line& src, Line& result) :
_source(src),
_currentSourceIndex(0),
_result(result),
_outputSegments(0)
{
}
/*
1.1.1 Destructor
*/
~LineMinize()
{
}
/*
1.1.1 ~InitializeFetch~
*/
void InitializeFetch()
{
_currentSourceIndex = 0;
}
/*
1.1.1 ~FetchInput~
*/
bool FetchInput(HalfSegment &segment,
Point& point,
bool &belongsToSecondGeometry)
{
point.SetDefined(false);
if (_currentSourceIndex < _source.Size()) {
_source.Get(_currentSourceIndex++, segment);
belongsToSecondGeometry = false;
return true;
} else {
return false;
}
}
/*
1.1.1 ~OutputData~
*/
bool OutputData() const
{
return true;
}
/*
1.1.1 ~OutputHalfSegment~
*/
void OutputHalfSegment(const HalfSegment& segment,
const InternalAttribute& attribute)
{
HalfSegment s1 = segment;
HalfSegment s2 = segment;
s1.SetLeftDomPoint(true);
s2.SetLeftDomPoint(false);
s1.attr.edgeno = _outputSegments;
s2.attr.edgeno = _outputSegments;
_result += s1;
_result += s2;
_outputSegments++;
}
/*
1.1.1 ~GetBoundingBox~
*/
const Rectangle<2> GetBoundingBox()
{
return _source.BoundingBox();
}
/*
1.1.1 ~FirstGeometryIsRegion~
*/
bool FirstGeometryIsRegion() const
{
return false;
}
/*
1.1.1 ~SecondGeometryIsRegion~
*/
bool SecondGeometryIsRegion() const
{
return false;
}
/*
1.1.1 ~IsInputOrderedByX~
*/
bool IsInputOrderedByX() const
{
return false;
}
/*
1.1.1 ~Realminize~
*/
static void Realminize(const Line& src, Line& result)
{
result.Clear();
if (!src.IsDefined()) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (src.Size() == 0) { // empty line, nothing to realminize
return;
}
result.StartBulkLoad();
LineMinize data(src, result);
Hobby hobby(&data);
hobby.DetermineIntersections();
// BentleyOttmann bo(&data);
// bo.DetermineIntersections();
result.StartBulkLoad(); // ordered = true
result.EndBulkLoad(true, false);
}
};
/*
1.1 Data class for conversion from DLine to Line
*/
class DLineToLine : public IntersectionAlgorithmData
{
/*
1.1.1 Member Variables
*/
private:
const DLine& _source;
size_t _currentSourceIndex;
Line& _result;
int _outputSegments;
public:
/*
1.1.1 Constructor
*/
DLineToLine(const DLine& src, Line& result) :
_source(src),
_currentSourceIndex(0),
_result(result),
_outputSegments(0)
{
}
/*
1.1.1 Destructor
*/
~DLineToLine()
{
}
/*
1.1.1 ~InitializeFetch~
*/
void InitializeFetch()
{
_currentSourceIndex = 0;
}
/*
1.1.1 ~FetchInput~
*/
bool FetchInput(HalfSegment &segment,
Point &point,
bool &belongsToSecondGeometry)
{
point.SetDefined(false);
// there is no Size()-method?
while (_currentSourceIndex < _source.HashValue()) {
SimpleSegment s;
_source.get(_currentSourceIndex++, s);
Point p1 = Point(true, s.x1, s.y1);
Point p2 = Point(true, s.x2, s.y2);
if (!AlmostEqual(p1, p2)) {
segment = HalfSegment(true, p1, p2);
belongsToSecondGeometry = false;
return true;
}
}
return false;
}
/*
1.1.1 ~OutputData~
*/
bool OutputData() const
{
return true;
}
/*
1.1.1 ~IsInputOrderedByX~
*/
bool IsInputOrderedByX() const
{
return false;
}
/*
1.1.1 ~OutputHalfSegment~
*/
void OutputHalfSegment(const HalfSegment& segment,
const InternalAttribute& attribute)
{
// cout << "O:" << _outputSegments << "\n";
HalfSegment s1 = segment;
HalfSegment s2 = segment;
s1.SetLeftDomPoint(true);
s2.SetLeftDomPoint(false);
s1.attr.edgeno = _outputSegments;
s2.attr.edgeno = _outputSegments;
_result += s1;
_result += s2;
_outputSegments++;
}
/*
1.1.1 ~OutputPoint~
*/
void OutputPoint(const Point& poiint,
const InternalAttribute& attribute)
{
throw new std::logic_error("there shouldn't be any points to output!");
}
/*
1.1.1 ~GetBoundingBox~
*/
const Rectangle<2> GetBoundingBox()
{
if (_source.HashValue() == 0) {
return Rectangle<2>(false);
}
double minX = 1e300;
double maxX = -1e300;
double minY = 1e300;
double maxY = -1e300;
SimpleSegment segment;
for (size_t i = 0; i < _source.HashValue(); i++) {
_source.get(i, segment);
if (segment.x1 < minX) {
minX = segment.x1;
}
if (segment.y1 < minY) {
minY = segment.y1;
}
if (segment.x2 < minX) {
minX = segment.x2;
}
if (segment.y2 < minY) {
minY = segment.y2;
}
if (segment.x1 > maxX) {
maxX = segment.x1;
}
if (segment.y1 > maxY) {
maxY = segment.y1;
}
if (segment.x2 > maxX) {
maxX = segment.x2;
}
if (segment.y2 > maxY) {
maxY = segment.y2;
}
}
double minMax[] = {minX, maxX, minY, maxY};
return Rectangle<2>(true,minMax );
}
/*
1.1.1 ~FirstGeometryIsRegion~
*/
bool FirstGeometryIsRegion() const
{
return false;
}
/*
1.1.1 ~SecondGeometryIsRegion~
*/
bool SecondGeometryIsRegion() const
{
return false;
}
/*
1.1.1 ~ToLine~
*/
static void ToLine(const DLine& src, Line& result)
{
result.Clear();
if (!src.IsDefined()) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (src.HashValue() == 0) { // empty line, nothing to realminize
return;
}
result.StartBulkLoad();
DLineToLine data(src, result);
Hobby hobby(&data);
hobby.DetermineIntersections();
result.StartBulkLoad(); // ordered = true
result.EndBulkLoad(true, false);
}
};
/*
1 Operators with strongly typed parameters
1.1 Trajectory2 operator
*/
void MPointTrajectory(MPoint* mpoint, Line& line)
{
line.Clear();
if (!mpoint->IsDefined()) {
line.SetDefined(false);
return;
}
line.SetDefined(true);
line.StartBulkLoad();
HalfSegment hs;
UPoint unit;
int edgeno = 0;
int size = mpoint->GetNoComponents();
if (size > 0)
line.Resize(size);
Point p0(false); // starting point
Point p1(false); // end point of the first unit
Point p_last(false); // last point of the connected segment
for (int i = 0; i < size; i++) {
mpoint->Get(i, unit);
if (!AlmostEqual(unit.p0, unit.p1)) {
if (!p0.IsDefined()) { // first unit
p0 = unit.p0;
p1 = unit.p1;
p_last = unit.p1;
} else { // segment already exists
if (p_last != unit.p0) { // spatial jump
hs.Set(true, p0, p_last);
hs.attr.edgeno = ++edgeno;
line += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
line += hs;
p0 = unit.p0;
p1 = unit.p1;
p_last = unit.p1;
} else { // an extension, check direction
if (!AlmostEqual(p0, unit.p1)) {
HalfSegment tmp(true, p0, unit.p1);
double dist = tmp.Distance(p1);
double dist2 = tmp.Distance(p_last);
if (AlmostEqual(dist, 0.0) && AlmostEqual(dist2, 0.0)) {
p_last = unit.p1;
} else {
hs.Set(true, p0, p_last);
hs.attr.edgeno = ++edgeno;
line += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
line += hs;
p0 = unit.p0;
p1 = unit.p1;
p_last = unit.p1;
}
}
}
}
}
}
if (p0.IsDefined() && p_last.IsDefined() && !AlmostEqual(p0, p_last)) {
hs.Set(true, p0, p_last);
hs.attr.edgeno = ++edgeno;
line += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
line += hs;
}
Line line2(0);
LineMinize::Realminize(line, line2);
line.CopyFrom(&line2);
line2.Destroy();
}
/*
1.1 Intersection2 operator
1.1.1 Points $\times$ Line $\rightarrow$ Points
*/
void IntersectionOp(const Points& points,
const Line& line,
Points& result)
{
RegionLinePointsSetOp<Line, Points>::SetOp(line,
points,
SetOpType::Intersection,
result);
}
/*
1.1.1 Points $\times$ Region $\rightarrow$ Points
*/
void IntersectionOp(const Points& points,
const Region& region,
Points& result)
{
RegionLinePointsSetOp<Region, Points>::SetOp(region,
points,
SetOpType::Intersection,
result);
}
/*
1.1.1 Line $\times$ Point $\rightarrow$ Points
*/
void IntersectionOp(const Line& line,
const Point& point,
Points& result)
{
RegionLinePointsSetOp<Line, Point>::SetOp(line,
point,
SetOpType::Intersection,
result);
}
/*
1.1.1 Line $\times$ Points $\rightarrow$ Points
*/
void IntersectionOp(const Line& line,
const Points& points,
Points& result)
{
RegionLinePointsSetOp<Line, Points>::SetOp(line,
points,
SetOpType::Intersection,
result);
}
/*
1.1.1 Line $\times$ Line $\rightarrow$ Line
*/
void IntersectionOp(const Line& line1,
const Line& line2,
Line& result)
{
LineLineSetOp::SetOp(line1,
line2,
SetOpType::Intersection,
result);
}
/*
1.1.1 Region $\times$ Point $\rightarrow$ Points
*/
void IntersectionOp(const Region& region,
const Point& point,
Points& result)
{
RegionLinePointsSetOp<Region, Point>::SetOp(region,
point,
SetOpType::Intersection,
result);
}
/*
1.1.1 Region $\times$ Points $\rightarrow$ Points
*/
void IntersectionOp(const Region& region,
const Points& points,
Points& result)
{
RegionLinePointsSetOp<Region, Points>::SetOp(region,
points,
SetOpType::Intersection,
result);
}
/*
1.1.1 Region $\times$ Line $\rightarrow$ Line
*/
void IntersectionOp(const Region& region,
const Line& line,
Line& result)
{
RegionLineSetOp::SetOp(region,
line,
SetOpType::Intersection,
result);
}
/*
1.1.1 Region $\times$ Region $\rightarrow$ Region
*/
void IntersectionOp(const Region& region1,
const Region& region2,
Region& result)
{
RegionRegionSetOp::SetOp(region1,
region2,
SetOpType::Intersection,
result);
}
/*
1.1 Union2 operator
1.1.1 Line $\times$ Line $\rightarrow$ Line
*/
void UnionOp(const Line& line1,
const Line& line2,
Line& result)
{
LineLineSetOp::SetOp(line1,
line2,
SetOpType::Union,
result);
}
/*
1.1.1 Region $\times$ Region $\rightarrow$ Region
*/
void UnionOp(const Region& region1,
const Region& region2,
Region& result)
{
RegionRegionSetOp::SetOp(region1,
region2,
SetOpType::Union,
result);
}
/*
1.1 Minus2 operator
1.1.1 Point $\times$ Line $\rightarrow$ Points
*/
void MinusOp(const Point& point,
const Line& line,
Points& result)
{
RegionLinePointsSetOp<Line, Point>::SetOp(line,
point,
SetOpType::Minus,
result);
}
/*
1.1.1 Point $\times$ Region $\rightarrow$ Points
*/
void MinusOp(const Point& point,
const Region& region,
Points& result)
{
RegionLinePointsSetOp<Region, Point>::SetOp(region,
point,
SetOpType::Minus,
result);
}
/*
1.1.1 Points $\times$ Line $\rightarrow$ Points
*/
void MinusOp(const Points& points,
const Line& line,
Points& result)
{
RegionLinePointsSetOp<Line, Points>::SetOp(line,
points,
SetOpType::Minus,
result);
}
/*
1.1.1 Points $\times$ Region $\rightarrow$ Points
*/
void MinusOp(const Points& points,
const Region& region,
Points& result)
{
RegionLinePointsSetOp<Region, Points>::SetOp(region,
points,
SetOpType::Minus,
result);
}
/*
1.1.1 Line $\times$ Line $\rightarrow$ Line
*/
void MinusOp(const Line& line1,
const Line& line2,
Line& result)
{
LineLineSetOp::SetOp(line1,
line2,
SetOpType::Minus,
result);
}
/*
1.1.1 Line $\times$ Region $\rightarrow$ Line
*/
void MinusOp(const Line& line,
const Region& region,
Line& result)
{
RegionLineSetOp::SetOp(region,
line,
SetOpType::Minus,
result);
}
/*
1.1.1 Region $\times$ Region $\rightarrow$ Region
*/
void MinusOp(const Region& region1,
const Region& region2,
Region& result)
{
RegionRegionSetOp::SetOp(region1,
region2,
SetOpType::Minus,
result);
}
/*
1.1 Intersects2 operator
1.1.1 Points $\times$ Line
*/
bool IntersectsOp(const Points& points,
const Line& line)
{
return
RegionLinePointsIntersects<Line, Points>::Intersects(line, points);
}
/*
1.1.1 Points $\times$ Region
*/
bool IntersectsOp(const Points& points,
const Region& region)
{
return
RegionLinePointsIntersects<Region, Points>::Intersects(region, points);
}
/*
1.1.1 Line $\times$ Line
*/
bool IntersectsOp(const Line& line1,
const Line& line2)
{
return RegionLineIntersects<Line, Line>::Intersects(line1, line2);
}
/*
1.1.1 Line $\times$ Region
*/
bool IntersectsOp(const Line& line,
const Region& region)
{
return RegionLineIntersects<Line, Region>::Intersects(line, region);
}
/*
1.1.1 Region $\times$ Region
*/
bool IntersectsOp(const Region& region1,
const Region& region2)
{
return RegionLineIntersects<Region, Region>::Intersects(region1, region2);
}
/*
1.1 Crossings2 operator
*/
void CrossingsLine(const Line& line1,
const Line& line2,
Points& result)
{
CrossingsData::Crossings(line1,
line2,
result);
}
/*
1.1 ToLine operator
*/
void ToLine(const DLine& dline,
Line& result)
{
DLineToLine::ToLine(dline, result);
}
/*
1 Helpers
1.1 ~SpatialReturnFirstParameter~
*/
template<class T1, class T2, class TResult>
int SpatialReturnFirstParameter(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
T1* arg1 = static_cast<T1*>(args[0].addr);
T2* arg2 = static_cast<T2*>(args[1].addr);
TResult* res = static_cast<TResult*>(result.addr);
res->Clear();
if (!arg1->IsDefined() || !arg2->IsDefined()) {
res->SetDefined(false);
} else {
res->SetDefined(true);
res->CopyFrom(arg1);
}
return 0;
}
/*
1.1 ~SpatialReturnSecondParameter~
*/
template<class T1, class T2, class TResult>
int SpatialReturnSecondParameter(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
T1* arg1 = static_cast<T1*>(args[0].addr);
T2* arg2 = static_cast<T2*>(args[1].addr);
TResult* res = static_cast<TResult*>(result.addr);
res->Clear();
if (!arg1->IsDefined() || !arg2->IsDefined()) {
res->SetDefined(false);
} else {
res->SetDefined(true);
res->CopyFrom(arg2);
}
return 0;
}
/*
1.1 Helper template to determine the size of an object
*/
template<class T>
struct SizeHelper
{
static int Size(const T* obj)
{
return obj->Size();
}
};
/*
1.1 Template specialization to determine the size of an point (always 1)
*/
template<>
struct SizeHelper<Point>
{
static int Size(const Point* obj)
{
return 1;
}
};
/*
1 Operator with Secondo parameters
1.1 Trajectory2
*/
int MPointTrajectory(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
Line *line = ((Line*)result.addr);
MPoint *mpoint = ((MPoint*)args[0].addr);
MPointTrajectory(mpoint, *line);
return 0;
}
/*
1.1 Intersection2
*/
template<class T1, class T2, class TResult, bool reverseT1T2>
int SpatialIntersectionGeneric(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
T1* arg1;
T2* arg2;
if (!reverseT1T2) {
arg1 = static_cast<T1*>(args[0].addr);
arg2 = static_cast<T2*>(args[1].addr);
} else {
arg1 = static_cast<T1*>(args[1].addr);
arg2 = static_cast<T2*>(args[0].addr);
}
TResult* res = static_cast<TResult*>(result.addr);
res->Clear();
if (!arg1->IsDefined() || !arg2->IsDefined()) {
res->SetDefined(false);
} else {
res->SetDefined(true);
if (SizeHelper<T1>::Size(arg1) == 0 || SizeHelper<T2>::Size(arg2) == 0
|| !(arg1->BoundingBox().IntersectsUD(arg2->BoundingBox()))) {
// empty result
// Clear doesn't clear everything?
res->StartBulkLoad();
res->EndBulkLoad();
} else {
IntersectionOp(*arg1, *arg2, *res);
}
}
return 0;
}
/*
1.1 Minus2
*/
template<class T1, class T2, class TResult>
int SpatialMinusGeneric(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
T1* arg1 = static_cast<T1*>(args[0].addr);
T2* arg2 = static_cast<T2*>(args[1].addr);
TResult* res = static_cast<TResult*>(result.addr);
res->Clear();
if (!arg1->IsDefined() || !arg2->IsDefined()) {
res->SetDefined(false);
} else {
res->SetDefined(true);
if (SizeHelper<T1>::Size(arg1) == 0) {
// empty result;
// Clear doesn't clear everything?
res->StartBulkLoad();
res->EndBulkLoad();
} else if (std::is_same<T1, TResult>::value
&& (SizeHelper<T2>::Size(arg2) == 0 ||
!(arg1->BoundingBox().IntersectsUD(arg2->BoundingBox())))) {
res->CopyFrom(arg1);
} else {
MinusOp(*arg1, *arg2, *res);
}
}
return 0;
}
/*
1.1 Union2
*/
template<class T1, class T2, class TResult>
int robustUnionT(T1* arg1, T2*arg2, TResult* res){
res->Clear();
if (!arg1->IsDefined() || !arg2->IsDefined()) {
res->SetDefined(false);
} else {
res->SetDefined(true);
if (std::is_same<T2, TResult>::value && SizeHelper<T1>::Size(arg1) == 0) {
res->CopyFrom(arg2);
} else if (std::is_same<T1, TResult>::value
&& SizeHelper<T2>::Size(arg2) == 0) {
res->CopyFrom(arg1);
} else if (!(arg1->BoundingBox().IntersectsUD(arg2->BoundingBox()))) {
res->StartBulkLoad();
int edgeno = 0;
int s = arg1->Size();
HalfSegment hs;
for (int i = 0; i < s; i++) {
arg1->Get(i, hs);
if (hs.IsLeftDomPoint()) {
HalfSegment HS(hs);
HS.attr.edgeno = edgeno;
(*res) += HS;
HS.SetLeftDomPoint(false);
(*res) += HS;
edgeno++;
}
}
s = arg2->Size();
for (int i = 0; i < s; i++) {
arg2->Get(i, hs);
if (hs.IsLeftDomPoint()) {
HalfSegment HS(hs);
HS.attr.edgeno = edgeno;
(*res) += HS;
HS.SetLeftDomPoint(false);
(*res) += HS;
edgeno++;
}
}
if (std::is_same<TResult, Region>::value) {
res->EndBulkLoad();
} else {
res->EndBulkLoad(true, false);
}
} else {
UnionOp(*arg1, *arg2, *res);
}
}
return 0;
}
template<class T1, class T2, class TResult>
int SpatialUnionGeneric(
Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
T1* arg1 = static_cast<T1*>(args[0].addr);
T2* arg2 = static_cast<T2*>(args[1].addr);
TResult* res = static_cast<TResult*>(result.addr);
return robustUnionT<T1,T2,TResult>(arg1,arg2,res);
}
void robustUnion(Region& arg1, Region& arg2, Region& result){
robustUnionT<Region,Region,Region>(&arg1,&arg2,&result);
}
void robustUnion(Line& arg1, Line& arg2, Line& result){
robustUnionT<Line,Line,Line>(&arg1,&arg2,&result);
}
/*
1.1 Crossings2
*/
int CrossingsLine(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
Line* arg1 = static_cast<Line*>(args[0].addr);
Line* arg2 = static_cast<Line*>(args[1].addr);
Points* res = static_cast<Points*>(result.addr);
CrossingsLine(*arg1, *arg2, *res);
return 0;
}
/*
1.1 ToLine
*/
int ToLine(Word* args,
Word& result,
int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
DLine* arg1 = static_cast<DLine*>(args[0].addr);
Line* res = static_cast<Line*>(result.addr);
ToLine(*arg1, *res);
return 0;
}
/*
1.1 Intersects2
*/
template<class A, class B, bool symm>
int SpatialIntersectsVM(Word* args, Word& result, int message,
Word& local,
Supplier s)
{
result = qp->ResultStorage(s);
CcBool* res = static_cast<CcBool*>(result.addr);
A* a;
B* b;
if (symm) {
a = static_cast<A*>(args[1].addr);
b = static_cast<B*>(args[0].addr);
} else {
a = static_cast<A*>(args[0].addr);
b = static_cast<B*>(args[1].addr);
}
if (!a->IsDefined() || !b->IsDefined()) {
res->Set(false, false);
} else if (!(a->BoundingBox().IntersectsUD(b->BoundingBox()))) {
res->Set(true, false);
} else {
bool result = IntersectsOp(*a, *b);
res->Set(true, result);
}
return 0;
}
/*
1 Operator definitions
1.1 Signatures
1.1.1 Trajectory2
*/
const string TemporalSpecTrajectory =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>mpoint -> line</text--->"
"<text> trajectory2( _ )</text--->"
"<text>Get the trajectory of the corresponding"
" moving point object.</text--->"
"<text>trajectory2( mp1 )</text--->"
") )";
/*
1.1.1 ToLine
*/
const string ToLineSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>dline -> line</text--->"
"<text>toline( _ )</text--->"
"<text>Converts a dline into a line</text--->"
"<text>toline( dline )</text--->"
") )";
/*
1.1.1 Intersection2
*/
const string SpatialIntersectionSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>{point, points, line, region } x"
" {point, points, line, region} -> T, "
" where T = points if any point or point type is one of the "
" arguments or the argument having the smaller dimension </text--->"
"<text>intersection2(arg1, arg2)</text--->"
"<text>intersection of two spatial objects</text--->"
"<text>query intersection2(tiergarten, thecenter) </text--->"
") )";
/*
1.1.1 Minus2
*/
const string SpatialMinusSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>{point, points, line, region } x"
" {point, points, line, sline region} -> T "
" </text--->"
"<text>arg1 minus2 arg2</text--->"
"<text>difference of two spatial objects</text--->"
"<text>query tiergarten minus2 thecenter </text--->"
") )";
/*
1.1.1 Union2
*/
const string SpatialUnionSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>{point , points, line, region } x"
" {point, points, line, region} -> T "
" </text--->"
"<text>arg1 union2 arg2</text--->"
"<text>union of two spatial objects</text--->"
"<text>query tiergarten union2 thecenter </text--->"
") )";
/*
1.1.1 Crossings2
*/
const string SpatialSpecCrossings =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>(line x line) -> points</text--->"
"<text>crossings2( _, _ )</text--->"
"<text>crossing points of two lines.</text--->"
"<text>query crossings2(line1, line2)</text--->"
") )";
/*
1.1.1 Intersects2
*/
const string SpatialSpecIntersects =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" )"
"( <text>(points||line||region x points||line||region) -> bool"
" </text--->"
"<text>_ intersects2 _</text--->"
"<text>TRUE, iff both arguments intersect.</text--->"
"<text>query region1 intersects2 region2</text--->"
") )";
/*
1.1 Value Mapping
1.1.1 Intersection2
*/
ValueMapping spatialintersectionVM[] = {
SpatialIntersectionGeneric<Line, Point, Points, true>,
SpatialIntersectionGeneric<Region, Point, Points, true>,
SpatialIntersectionGeneric<Points, Line, Points, false>,
SpatialIntersectionGeneric<Points, Region, Points, false>,
SpatialIntersectionGeneric<Line, Point, Points, false>,
SpatialIntersectionGeneric<Line, Points, Points, false>,
SpatialIntersectionGeneric<Line, Line, Line, false>,
SpatialIntersectionGeneric<Region, Line, Line, true>,
SpatialIntersectionGeneric<Region, Point, Points, false>,
SpatialIntersectionGeneric<Region, Points, Points, false>,
SpatialIntersectionGeneric<Region, Line, Line, false>,
SpatialIntersectionGeneric<Region, Region, Region, false>
};
/*
1.1.1 Minus2
*/
ValueMapping spatialminusVM[] = {
SpatialMinusGeneric<Point, Line, Points>,
SpatialMinusGeneric<Point, Region, Points>,
SpatialMinusGeneric<Points, Line, Points>,
SpatialMinusGeneric<Points, Region, Points>,
SpatialReturnFirstParameter<Line, Point, Line>,
SpatialReturnFirstParameter<Line, Points, Line>,
SpatialMinusGeneric<Line, Line, Line>,
SpatialMinusGeneric<Line, Region, Line>,
SpatialReturnFirstParameter<Region, Point, Region>,
SpatialReturnFirstParameter<Region, Points, Region>,
SpatialReturnFirstParameter<Region, Line, Region>,
SpatialMinusGeneric<Region, Region, Region>
};
/*
1.1.1 Union2
*/
ValueMapping spatialunionVM[] = {
SpatialReturnSecondParameter<Point, Line, Line>,
SpatialReturnSecondParameter<Point, Region, Region>,
SpatialReturnSecondParameter<Points, Line, Line>,
SpatialReturnSecondParameter<Points, Region, Region>,
SpatialReturnFirstParameter<Line, Point, Line>,
SpatialReturnFirstParameter<Line, Points, Line>,
SpatialUnionGeneric<Line, Line, Line>,
SpatialReturnSecondParameter<Line, Region, Region>,
SpatialReturnFirstParameter<Region, Point, Region>,
SpatialReturnFirstParameter<Region, Points, Region>,
SpatialReturnFirstParameter<Region, Line, Region>,
SpatialUnionGeneric<Region, Region, Region>
};
/*
1.1.1 Intersects
*/
ValueMapping spatialintersectsmap[] = {
SpatialIntersectsVM<Points, Line, false>,
SpatialIntersectsVM<Points, Region, false>,
SpatialIntersectsVM<Points, Line, true>,
SpatialIntersectsVM<Line, Line, false>,
SpatialIntersectsVM<Line, Region, false>,
SpatialIntersectsVM<Points, Region, true>,
SpatialIntersectsVM<Line, Region, true>,
SpatialIntersectsVM<Region, Region, false>
};
/*
1.1 Selection methods
1.1.1 SpatialSetOpSelect
used for set operations
*/
int SpatialSetOpSelect(ListExpr args)
{
string a1 = nl->SymbolValue(nl->First(args));
string a2 = nl->SymbolValue(nl->Second(args));
if (a1 == Point::BasicType()) {
if (a2 == Line::BasicType()) {
return 0;
}
if (a2 == Region::BasicType()) {
return 1;
}
return -1;
}
if (a1 == Points::BasicType()) {
if (a2 == Line::BasicType()) {
return 2;
}
if (a2 == Region::BasicType()) {
return 3;
}
return -1;
}
if (a1 == Line::BasicType()) {
if (a2 == Point::BasicType()) {
return 4;
}
if (a2 == Points::BasicType()) {
return 5;
}
if (a2 == Line::BasicType()) {
return 6;
}
if (a2 == Region::BasicType()) {
return 7;
}
return -1;
}
if (a1 == Region::BasicType()) {
if (a2 == Point::BasicType()) {
return 8;
}
if (a2 == Points::BasicType()) {
return 9;
}
if (a2 == Line::BasicType()) {
return 10;
}
if (a2 == Region::BasicType()) {
return 11;
}
return -1;
}
return -1;
}
enum SpatialType
{
stpoint,
stpoints,
stline,
stregion,
stbox,
sterror,
stsline
};
SpatialType SpatialTypeOfSymbol(ListExpr symbol)
{
if (nl->AtomType(symbol) == SymbolType) {
string s = nl->SymbolValue(symbol);
if (s == Point::BasicType()) {
return (stpoint);
}
if (s == Points::BasicType()) {
return (stpoints);
}
if (s == Line::BasicType()) {
return (stline);
}
if (s == Region::BasicType()) {
return (stregion);
}
if (s == Rectangle<2>::BasicType()) {
return (stbox);
}
if (s == SimpleLine::BasicType()) {
return (stsline);
}
}
return (sterror);
}
/*
1.1.1 SpatialSelectIntersects
used for intersects2 operator
*/
int SpatialSelectIntersects(ListExpr args)
{
ListExpr arg1 = nl->First(args);
ListExpr arg2 = nl->Second(args);
if (SpatialTypeOfSymbol(arg1) == stpoints
&& SpatialTypeOfSymbol(arg2) == stline) {
return 0;
}
if (SpatialTypeOfSymbol(arg1) == stpoints
&& SpatialTypeOfSymbol(arg2) == stregion) {
return 1;
}
if (SpatialTypeOfSymbol(arg1) == stline
&& SpatialTypeOfSymbol(arg2) == stpoints) {
return 2;
}
if (SpatialTypeOfSymbol(arg1) == stline
&& SpatialTypeOfSymbol(arg2) == stline) {
return 3;
}
if (SpatialTypeOfSymbol(arg1) == stline
&& SpatialTypeOfSymbol(arg2) == stregion) {
return 4;
}
if (SpatialTypeOfSymbol(arg1) == stregion
&& SpatialTypeOfSymbol(arg2) == stpoints) {
return 5;
}
if (SpatialTypeOfSymbol(arg1) == stregion
&& SpatialTypeOfSymbol(arg2) == stline) {
return 6;
}
if (SpatialTypeOfSymbol(arg1) == stregion
&& SpatialTypeOfSymbol(arg2) == stregion) {
return 7;
}
return -1; // This point should never be reached
}
/*
1.1 Type mapping
1.1.1 Trajectory2
*/
ListExpr MovingTypeMapSpatial(ListExpr args)
{
if (nl->ListLength(args) == 1) {
ListExpr arg1 = nl->First(args);
if (nl->IsEqual(arg1, MPoint::BasicType())) {
return nl->SymbolAtom(Line::BasicType());
}
}
return nl->SymbolAtom(Symbol::TYPEERROR());
}
/*
1.1.1 ToLine
*/
ListExpr ToLineTypeMap(ListExpr args)
{
if (nl->ListLength(args) == 1) {
ListExpr arg1 = nl->First(args);
if (nl->IsEqual(arg1, DLine::BasicType())) {
return nl->SymbolAtom(Line::BasicType());
}
}
return nl->SymbolAtom(Symbol::TYPEERROR());
}
/*
1.1.1 Union2
*/
ListExpr SpatialUnionTypeMap(ListExpr args)
{
if (nl->ListLength(args) != 2) {
return listutils::typeError("wrong number of arguments");
}
ListExpr arg1 = nl->First(args);
ListExpr arg2 = nl->Second(args);
if (!listutils::isSymbol(arg1)) {
return listutils::typeError("first arg is not a supported spatial type");
}
if (!listutils::isSymbol(arg2)) {
return listutils::typeError("second arg is not a supported spatial type");
}
string a1 = nl->SymbolValue(arg1);
string a2 = nl->SymbolValue(arg2);
if (a1 == Point::BasicType()) {
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Points::BasicType()) {
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Line::BasicType()) {
if (a2 == Point::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Points::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Region::BasicType()) {
if (a2 == Point::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
if (a2 == Points::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
return listutils::typeError("first arg is not a supported spatial type");
}
/*
1.1.1 Crossings2
*/
ListExpr SpatialCrossingsTM(ListExpr args)
{
ListExpr arg1, arg2;
if (nl->ListLength(args) == 2) {
arg1 = nl->First(args);
arg2 = nl->Second(args);
string a1 = nl->SymbolValue(arg1);
string a2 = nl->SymbolValue(arg2);
if (a1 == Line::BasicType() && a2 == Line::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
}
return listutils::typeError("line x line expected");
}
/*
1.1.1 Minus2
*/
ListExpr SpatialMinusTypeMap(ListExpr args)
{
if (nl->ListLength(args) != 2) {
return listutils::typeError("wrong number of arguments");
}
ListExpr arg1 = nl->First(args);
ListExpr arg2 = nl->Second(args);
if (!listutils::isSymbol(arg1)) {
return listutils::typeError("first arg is not a supported spatial type");
}
if (!listutils::isSymbol(arg2)) {
return listutils::typeError("second arg is not a supported spatial type");
}
string a1 = nl->SymbolValue(arg1);
string a2 = nl->SymbolValue(arg2);
if (a1 == Point::BasicType()) {
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Points::BasicType()) {
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Line::BasicType()) {
if (a2 == Point::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Points::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Region::BasicType()) {
if (a2 == Point::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
if (a2 == Points::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
return listutils::typeError("first arg is not a supported spatial type");
}
/*
1.1.1 Intersection2
*/
ListExpr SpatialIntersectionTypeMap(ListExpr args)
{
if (nl->ListLength(args) != 2) {
return listutils::typeError("wrong number of arguments");
}
ListExpr arg1 = nl->First(args);
ListExpr arg2 = nl->Second(args);
if (!listutils::isSymbol(arg1)) {
return listutils::typeError("first arg is not a supported spatial type");
}
if (!listutils::isSymbol(arg2)) {
return listutils::typeError("second arg is not a supported spatial type");
}
string a1 = nl->SymbolValue(arg1);
string a2 = nl->SymbolValue(arg2);
if (a1 == Point::BasicType()) {
if (a2 == Line::BasicType() || a2 == Region::BasicType())
return nl->SymbolAtom(Points::BasicType());
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Points::BasicType()) {
if (a2 == Line::BasicType() || a2 == Region::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Line::BasicType()) {
if (a2 == Point::BasicType() || a2 == Points::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
if (a2 == Line::BasicType() || a2 == Region::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
if (a1 == Region::BasicType()) {
if (a2 == Point::BasicType() || a2 == Points::BasicType()) {
return nl->SymbolAtom(Points::BasicType());
}
if (a2 == Line::BasicType()) {
return nl->SymbolAtom(Line::BasicType());
}
if (a2 == Region::BasicType()) {
return nl->SymbolAtom(Region::BasicType());
}
return listutils::typeError("second arg is not a supported spatial type");
}
return listutils::typeError("first arg not a supported spatial type");
}
/*
1.1.1 Intersects2
*/
ListExpr IntersectsTM(ListExpr args)
{
ListExpr arg1, arg2;
if (nl->ListLength(args) == 2) {
arg1 = nl->First(args);
arg2 = nl->Second(args);
SpatialType st1 = SpatialTypeOfSymbol(arg1);
SpatialType st2 = SpatialTypeOfSymbol(arg2);
if (st1 != stpoints || st2 != stpoints) {
if (((st1 == stpoints) || (st1 == stline) || (st1 == stregion)) &&
((st2 == stpoints) || (st2 == stline) || (st2 == stregion))) {
return nl->SymbolAtom(CcBool::BasicType());
}
}
}
return listutils::typeError(" t_1 x t_2 expected,"
" with t_1, t_2 in {points,line,region}");
}
/*
1.1 Definitions
*/
Operator temporaltrajectory2("trajectory2",
TemporalSpecTrajectory,
MPointTrajectory,
Operator::SimpleSelect,
MovingTypeMapSpatial);
Operator toline("toline",
ToLineSpec,
ToLine,
Operator::SimpleSelect,
ToLineTypeMap);
Operator spatialcrossings2("crossings",
SpatialSpecCrossings,
CrossingsLine,
Operator::SimpleSelect,
SpatialCrossingsTM);
Operator spatialintersection2("intersection",
SpatialIntersectionSpec,
12,
spatialintersectionVM,
SpatialSetOpSelect,
SpatialIntersectionTypeMap);
Operator spatialminus2("minus",
SpatialMinusSpec,
12,
spatialminusVM,
SpatialSetOpSelect,
SpatialMinusTypeMap);
Operator spatialunion2("union",
SpatialUnionSpec,
12,
spatialunionVM,
SpatialSetOpSelect,
SpatialUnionTypeMap);
Operator spatialintersects2("intersects",
SpatialSpecIntersects,
8,
spatialintersectsmap,
SpatialSelectIntersects,
IntersectsTM);
/*
1 Algebra definition
*/
RobustPlaneSweepAlgebra::RobustPlaneSweepAlgebra()
{
AddOperator(&temporaltrajectory2);
AddOperator(&toline);
AddOperator(&spatialintersection2);
AddOperator(&spatialminus2);
AddOperator(&spatialunion2);
AddOperator(&spatialcrossings2);
AddOperator(&spatialintersects2);
}
}
extern "C"
Algebra* InitializeRobustPlaneSweepAlgebra(
NestedList* nlRef,
QueryProcessor* qpRef)
{
// The C++ scope-operator :: must be used to qualify the full name
return new RobustPlaneSweep::RobustPlaneSweepAlgebra();
}
Reference in New Issue Copy Permalink