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

8579 lines
216 KiB
C++
Raw Blame History

/*
----
This file is part of SECONDO.
Copyright (C) 2009, University in Hagen, Faculty of Mathematics and
Computer Science, Database Systems for New Applications.
SECONDO is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
SECONDO is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
----
//paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}]
//paragraph [10] Footnote: [{\footnote{] [}}]
//[TOC] [\tableofcontents]
//[->] [$\to$]
[TOC]
0 Overview
1 Includes and defines
*/
#ifndef _AVL_Tree_CPP
#define _AVL_Tree_CPP
#include "AVL_Tree.h"
#include <cmath>
#include <vector>
#include <limits>
using namespace std;
namespace p2d {
bool p2d_debug = false;
/*
1 Class AVLTree
*/
/*
1.1 Constructor and destructor
*/
AVLTree::AVLTree() {
root = NULL;
}
AVLTree::~AVLTree() {
delete root;
}
/*
1.1 ~insert~
*/
void AVLTree::insert(AVLSegment* x, AVLSegment*& pred, AVLSegment*& suc) {
pred = NULL;
suc = NULL;
if (root == NULL) {
root = new AVLNode(x);
} else {
root = root->insert(x, pred, suc);
}
}
/*
1.1 ~removeGetNeighbor~
*/
void AVLTree::removeGetNeighbor(AVLSegment* x, AVLSegment*& pred,
AVLSegment*& suc) {
pred = NULL;
suc = NULL;
if (root != NULL) {
root = root->removeGetNeighbor(x, pred, suc);
}
}
/*
1.1 ~removeGetNeighbor2~
*/
void AVLTree::removeGetNeighbor2(AVLSegment* x, int gridXPos,
mpq_class& preciseXPos, AVLSegment*& pred, AVLSegment*& suc) {
pred = NULL;
suc = NULL;
if (root != NULL) {
root = root->removeGetNeighbor2(x, gridXPos, preciseXPos, pred, suc);
}
}
/*
1.1 ~removeInvalidSegment~
*/
void AVLTree::removeInvalidSegment(AVLSegment* x, int gridXPos,
mpq_class& preciseXPos) {
bool found = false;
if (root != NULL) {
root = root->removeInvalidSegment(x, gridXPos, preciseXPos, found);
assert(found);
}
}
/*
1.1 ~invertSegments~
*/
void AVLTree::invertSegments(vector<AVLSegment*>& v, int gridX, mpq_class& pX,
int gridY, mpq_class& pY, AVLSegment*& pred, size_t predIndex,
AVLSegment*& suc, size_t sucIndex) {
pred = NULL;
suc = NULL;
vector<AVLNode*> nodeVector;
bool found = false;
AVLNode* node = NULL;
AVLNode* lastNode = NULL;
AVLSegment* tempSeg1;
AVLSegment* tempSeg2;
for (size_t j = 0; j < v.size(); j++) {
if (j == predIndex) {
node = root->memberPlusNeighbor(v[j], found, gridX, pX, gridY, pY, pred,
true);
} else {
if (j == sucIndex) {
node = root->memberPlusNeighbor(v[j], found, gridX, pX, gridY, pY, suc,
false);
} else {
node = root->member(v[j], found, gridX, pX, gridY, pY);
}
}
if (found) {
if (j > 0 && lastNode->getElement()->isParallelTo(*(node->getElement()))) {
//2 segments, which run on the same line have
//to be in the same order after the inversion
//as before. Now they will be switched in the
//wrong order, and after the inversion they
//once again have the right order.
lastNode = nodeVector.back();
nodeVector.pop_back();
tempSeg1 = node->getElement();
tempSeg2 = lastNode->getElement();
node->setElement(&tempSeg2);
lastNode->setElement(&tempSeg1);
nodeVector.push_back(node);
nodeVector.push_back(lastNode);
} else {
nodeVector.push_back(node);
lastNode = node;
}
} else {
cerr << "Element not found." << endl;
cerr << "The tree:" << endl << endl;
root->inorder();
if (p2d_debug) {
cerr << "The following segments have to be inverted:" << endl;
size_t i = 0;
while (i < v.size()) {
v[i]->print();
i++;
}
}
cerr << "This segment could not be found: " << endl;
v[j]->print();
assert(false);
}
}
for (size_t k = 0; k < ((nodeVector.size()) / 2); k++) {
tempSeg1 = (nodeVector.at(k))->getElement();
tempSeg2 = nodeVector.at(nodeVector.size() - k - 1)->getElement();
nodeVector.at(k)->setElement(&tempSeg2);
nodeVector.at(nodeVector.size() - k - 1)->setElement(&tempSeg1);
}
}
/*
1.1 ~inorder~
*/
void AVLTree::inorder() {
if (root != NULL) {
root->inorder();
}
}
/*
2 Class AVLNode
*/
/*
1.1 Constructor and destructor
*/
AVLNode::AVLNode(AVLSegment* elem) :
elem(elem), left(NULL), right(NULL), height(0) {
}
AVLNode::AVLNode(const AVLNode& node) {
elem = node.elem;
if (node.left == NULL) {
left = NULL;
} else {
left = node.left;//new AVLNode(*node.left);
}
if (node.right == NULL) {
right = NULL;
} else {
right = node.right;//new AVLNode(*node.right);
}
height = node.height;
}
AVLNode::~AVLNode() {
/*
elem = NULL;
if (left){
delete left;
}
if (right){
delete right;
}
left = NULL;
right = NULL;
*/
}
/*
1.1 ~=~
*/
AVLNode& AVLNode::operator=(const AVLNode& node) {
elem = node.elem;
if (node.left == NULL) {
left = NULL;
} else {
left = node.left;//new AVLNode(*node.left);
}
if (node.right == NULL) {
right = NULL;
} else {
right = node.right;//new AVLNode(*node.right);
}
height = node.height;
return *this;
}
/*
1.1 ~memberPlusNeighbor~
*/
AVLNode* AVLNode::memberPlusNeighbor(AVLSegment* key, bool& result,
int gridXPos, mpq_class& preciseXPos, int gridYPos, mpq_class& preciseYPos,
AVLSegment*& neighbor, bool pred) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*key,
gridXPos);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosForMember(*key, gridXPos, preciseXPos,
gridYPos, preciseYPos);
}
if (cmpSegments == 0) {
result = true;
//search predecessor
if (pred && left != NULL) {
AVLNode* predNode = left;
while (predNode->right != NULL) {
predNode = predNode->right;
}
neighbor = &*(predNode->elem);
}
//search successor
if (!pred && right != NULL) {
AVLNode* sucNode = right;
while (sucNode->left != NULL) {
sucNode = sucNode->left;
}
neighbor = &*(sucNode->elem);
}
return this;
} else {
if (cmpSegments > 0) {
if (left == 0) {
result = false;
return 0;
} else {
if (!pred) {
neighbor = &*elem;
}
return left->memberPlusNeighbor(key, result, gridXPos, preciseXPos,
gridYPos, preciseYPos, neighbor, pred);
}
} else {
if (right == 0) {
result = false;
return 0;
} else {
if (pred) {
neighbor = &*elem;
}
return right->memberPlusNeighbor(key, result, gridXPos, preciseXPos,
gridYPos, preciseYPos, neighbor, pred);
}
}
}
}
/*
1.1 ~member~
*/
AVLNode* AVLNode::member(AVLSegment* key, bool& result, int gridXPos,
mpq_class& preciseXPos, int gridYPos, mpq_class& preciseYPos) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*key,
gridXPos);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosForMember(*key, gridXPos, preciseXPos,
gridYPos, preciseYPos);
}
if (cmpSegments == 0) {
result = true;
return this;
} else {
if (cmpSegments > 0) {
if (left == 0) {
result = false;
return 0;
} else {
return left->member(key, result, gridXPos, preciseXPos, gridYPos,
preciseYPos);
}
} else {
if (right == 0) {
result = false;
return 0;
} else {
return right->member(key, result, gridXPos, preciseXPos, gridYPos,
preciseYPos);
}
}
}
}
void AVLNode::setElement(AVLSegment** seg) {
elem = *seg;
}
/*
1.1 ~insert~
*/
AVLNode* AVLNode::insert(AVLSegment* x, AVLSegment*& pred, AVLSegment*& suc) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x,
x->getGridXL());
if (cmpSegments == 0) {
mpq_class preciseX = x->getPreciseXL();
cmpSegments = elem->compareInPosOrLeft(*x, x->getGridXL(), preciseX);
}
if (cmpSegments == 0) {
if (elem->getOwner() == first) {
elem->setSecondInsideAbove(x->getSecondInsideAbove());
} else {
elem->setFirstInsideAbove(x->getFirstInsideAbove());
}
elem->setConBelow(elem->getConBelow() + x->getConBelow());
elem->setConAbove(elem->getConAbove() + x->getConAbove());
assert((0 <= elem->getConBelow()) && (elem->getConBelow() <= 2));
assert((0 <= elem->getConAbove()) && (elem->getConAbove() <= 2));
elem->setOwner(both);
*x = *elem;
//search predecessor
if (left != NULL) {
AVLNode* predNode = left;
while (predNode->right != NULL) {
predNode = predNode->right;
}
pred = &*(predNode->elem);
}
//search successor
if (right != NULL) {
AVLNode* sucNode = right;
while (sucNode->left != NULL) {
sucNode = sucNode->left;
}
suc = &*(sucNode->elem);
}
return this;
} else {
if (cmpSegments > 0) {
suc = &*elem;
if (left == NULL) {
left = new AVLNode(x);
left->setHeight();
return this;
} else {
left = left->insert(x, pred, suc);
left->setHeight();
}
} else {
pred = &*elem;
if (right == NULL) {
right = new AVLNode(x);
right->setHeight();
return this;
} else {
right = right->insert(x, pred, suc);
right->setHeight();
}
}
}
setHeight();
if (balance() == -2) {
// the right son is out of balance
return counterClockwiseRotation();
}
if (balance() == 2) {
//the left son is out of balance
return clockwiseRotation();
}
return this;
}
/*
1.1 ~counterClockwiseRotation~
This function rebalances the tree
*/
AVLNode* AVLNode::counterClockwiseRotation() {
if (right->balance() != 1) {
//the right son of right is higher than his left son or has equal height
//a single rotation counterclockwise is necessary
AVLNode* t1 = right;
right = t1->left;
t1->left = new AVLNode(*this);
t1->left->setHeight();
t1->setHeight();
return t1;
} else {
//the left son of right is higher than his right son
// a double rotation counterclockwise is necessary
AVLNode *t1 = right;
AVLNode *t2 = t1->left;
t1->left = t2->right;
t2->right = t1;
right = t2->left;
t2->left = new AVLNode(*this);
(t2->left)->setHeight();
(t2->right)->setHeight();
t2->setHeight();
return t2;
}
}
/*
1.1 ~clockwiseRotation~
rebalances the tree
*/
AVLNode* AVLNode::clockwiseRotation() {
if (left->balance() != -1) {
//the left son of left is higher than his right son or has equal height
//a single rotation clockwise is necessary
AVLNode *t1 = left;
left = t1->right;
t1->right = new AVLNode(*this);
t1->right->setHeight();
t1->setHeight();
return t1;
} else {
//the right son of left is higher than his left son
// a double rotation clockwise is necessary
AVLNode *t1 = left;
AVLNode *t2 = t1->right;
t1->right = t2->left;
t2->left = t1;
left = t2->right;
t2->right = new AVLNode(*this);
(t2->left)->setHeight();
(t2->right)->setHeight();
t2->setHeight();
return t2;
}
}
/*
1.1 ~setHeight~
*/
void AVLNode::setHeight() {
if (left == NULL && right == NULL) {
height = 0;
} else {
if (left == NULL) {
height = right->getHeight() + 1;
} else {
if (right == NULL) {
height = left->getHeight() + 1;
} else {
if (left->getHeight() < right->getHeight()) {
height = right->getHeight() + 1;
} else {
height = left->getHeight() + 1;
}
}
}
}
}
/*
1.1 ~balance~
*/
int AVLNode::balance() {
int h1, h2;
if (left == NULL && right == NULL) {
return 0;
} else {
if (left == NULL) {
h1 = 0;
h2 = right->getHeight() + 1;
} else {
if (right == NULL) {
h2 = 0;
h1 = left->getHeight() + 1;
} else {
h1 = left->getHeight() + 1;
h2 = right->getHeight() + 1;
}
}
}
return h1 - h2;
}
/*
1.1 ~removeGetNeighbor~
*/
AVLNode* AVLNode::removeGetNeighbor(AVLSegment* x, AVLSegment*& pred,
AVLSegment*& suc) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x,
x->getGridXR());
if (cmpSegments == 0) {
mpq_class preciseX = x->getPreciseXR();
cmpSegments = elem->compareInPosOrRight(*x, x->getGridXR(), preciseX);
}
if (cmpSegments > 0) {
if (left == NULL) {
//Nothing to do
cerr << "Element not found:" << endl;
x->print();
cerr << "is not located on this path. "
<< "There might be an error in the compareInPos-function" << endl;
cerr << "The path ends at element:" << endl;
elem->print();
cerr << "and the searched element would lie in the left subtree." << endl;
assert(false);
return this;
} else {
suc = &*elem;
left = left->removeGetNeighbor(x, pred, suc);
}
setHeight();
if (right == NULL) {
return this;
}
if (balance() == -2) {
// the right son is higher than the left son
return counterClockwiseRotation();
}
if (balance() == 2) {
// the left son is higher than the right son
return clockwiseRotation();
}
return this;
} else if (cmpSegments < 0) {
if (right == NULL) {
// nothing to do
cerr << "Element not found:" << endl;
x->print();
cerr << "is not located on this path. "
<< "There might be an error in the compareInPos-function" << endl;
cerr << "The path ends at element:" << endl;
elem->print();
cerr << "and the searched element would lie in the right subtree." << endl;
assert(false);
return this;
} else {
pred = &*elem;
right = right->removeGetNeighbor(x, pred, suc);
}
setHeight();
if (left == NULL) {
return this;
}
if (balance() == -2) {
return counterClockwiseRotation();
}
if (balance() == 2) {
return clockwiseRotation();
}
return this;
} else {
//search predecessor
if (left != NULL) {
AVLNode* predNode = left;
while (predNode->right != NULL) {
predNode = predNode->right;
}
pred = &*(predNode->elem);
}
//search successor
if (right != NULL) {
AVLNode* sucNode = right;
while (sucNode->left != NULL) {
sucNode = sucNode->left;
}
suc = &*(sucNode->elem);
}
if (isLeaf()) {
delete this;
return NULL;
}
if (left == NULL) {
AVLNode *tr = right;
elem = NULL;
delete this;
return tr;
}
if (right == NULL) {
AVLNode *tl = left;
elem = NULL;
delete this;
return tl;
}
elem = right->deletemin(right);
if (right->elem == NULL) {
AVLNode* tmp = right;
right = right->right;
if (right != NULL) {
right->setHeight();
}
tmp->left = NULL;
tmp->right = NULL;
delete tmp;
}
setHeight();
if (balance() == -2) {
return counterClockwiseRotation();
}
if (balance() == 2) {
return clockwiseRotation();
}
return this;
}
}
/*
1.1 ~removeGetNeighbor2~
*/
AVLNode* AVLNode::removeGetNeighbor2(AVLSegment* x, int gridXPos,
mpq_class preciseXPos, AVLSegment*& pred, AVLSegment*& suc) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x, gridXPos);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosOrLeft(*x, gridXPos, preciseXPos);
}
if (cmpSegments > 0) {
if (left == NULL) {
//Nothing to do
cerr << "Element not found:" << endl;
x->print();
cerr << "is not located on this path. "
<< "There might be an error in the compareInPosBackward-function" << endl;
cerr << "The path ends at element:" << endl;
elem->print();
cerr << "and the searched element would lie in the left subtree." << endl;
assert(false);
return this;
} else {
suc = &*elem;
left = left->removeGetNeighbor2(x, gridXPos, preciseXPos, pred, suc);
}
setHeight();
if (right == NULL) {
return this;
}
if (balance() == -2) {
// the right son is higher than the left son
return counterClockwiseRotation();
}
if (balance() == 2) {
// the left son is higher than the right son
return clockwiseRotation();
}
return this;
} else if (cmpSegments < 0) {
if (right == NULL) {
// nothing to do
cerr << "Element not found:" << endl;
x->print();
cerr << "is not located on this path. "
<< "There might be an error in the compareInPosBackward-function" << endl;
cerr << "The path ends at element:" << endl;
elem->print();
cerr << "and the searched element would lie in the right subtree." << endl;
assert(false);
return this;
} else {
pred = &*elem;
right = right->removeGetNeighbor2(x, gridXPos, preciseXPos, pred, suc);
}
setHeight();
if (left == NULL) {
return this;
}
if (balance() == -2) {
return counterClockwiseRotation();
}
if (balance() == 2) {
return clockwiseRotation();
}
return this;
} else {
//search predecessor
if (left != NULL) {
AVLNode* predNode = left;
while (predNode->right != NULL) {
predNode = predNode->right;
}
pred = &*(predNode->elem);
}
//search successor
if (right != NULL) {
AVLNode* sucNode = right;
while (sucNode->left != NULL) {
sucNode = sucNode->left;
}
suc = &*(sucNode->elem);
}
if (isLeaf()) {
delete this;
return NULL;
}
if (left == NULL) {
AVLNode *tr = right;
elem = NULL;
delete this;
return tr;
}
if (right == NULL) {
AVLNode *tl = left;
elem = NULL;
delete this;
return tl;
}
elem = right->deletemin(right);
if (right->elem == NULL) {
AVLNode* tmp = right;
right = right->right;
if (right != NULL) {
right->setHeight();
}
tmp->left = NULL;
tmp->right = NULL;
delete tmp;
}
setHeight();
if (balance() == -2) {
return counterClockwiseRotation();
}
if (balance() == 2) {
return clockwiseRotation();
}
return this;
}
}
/*
1.1 ~removeInvalidSegment~
*/
AVLNode* AVLNode::removeInvalidSegment(AVLSegment* x, int gridXPos,
mpq_class preciseXPos, bool& found) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x, gridXPos);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosOrLeft(*x, gridXPos, preciseXPos);
}
if (cmpSegments > 0) {
if (left == NULL) {
//Nothing to do
cerr << "Element not found:" << endl;
x->print();
cerr << "is not located on this path. "
<< "There might be an error in the compareInPosBackward-function" << endl;
cerr << "The path ends at element:" << endl;
elem->print();
cerr << "and the searched element would lie in the left subtree." << endl;
assert(false);
return this;
} else {
left = left->removeInvalidSegment(x, gridXPos, preciseXPos, found);
}
setHeight();
if (right == NULL) {
return this;
}
if (balance() == -2) {
// the right son is higher than the left son
return counterClockwiseRotation();
}
if (balance() == 2) {
// the left son is higher than the right son
return clockwiseRotation();
}
return this;
} else if (cmpSegments < 0) {
if (right == NULL) {
// nothing to do
cerr << "Element not found:" << endl;
x->print();
cerr << "is not located on this path. "
<< "There might be an error in the compareInPosBackward-function" << endl;
cerr << "The path ends at element:" << endl;
elem->print();
cerr << "and the searched element would lie in the right subtree." << endl;
assert(false);
return this;
} else {
right = right->removeInvalidSegment(x, gridXPos, preciseXPos, found);
}
setHeight();
if (left == NULL) {
return this;
}
if (balance() == -2) {
return counterClockwiseRotation();
}
if (balance() == 2) {
return clockwiseRotation();
}
return this;
} else {
if (!elem->isValid()) {
// delete this
found = true;
if (isLeaf()) {
delete this;
return NULL;
}
if (left == NULL) {
AVLNode *tr = right;
elem = NULL;
delete this;
return tr;
}
if (right == NULL) {
AVLNode *tl = left;
elem = NULL;
delete this;
return tl;
}
elem = right->deletemin(right);
if (right->elem == NULL) {
AVLNode* tmp = right;
right = right->right;
if (right != NULL) {
right->setHeight();
}
tmp->left = NULL;
tmp->right = NULL;
delete tmp;
}
setHeight();
if (balance() == -2) {
return counterClockwiseRotation();
}
if (balance() == 2) {
return clockwiseRotation();
}
return this;
} else {
// ~this~ was inserted earlier then the invalid
// segment ~x~ ~x~ lay below ~this~
left = left->removeInvalidSegment(x, gridXPos, preciseXPos, found);
setHeight();
if (left == NULL) {
return this;
}
if (balance() == -2) {
// the right son is higher than the left son
return counterClockwiseRotation();
}
if (balance() == 2) {
// the left son is higher than the right son
return clockwiseRotation();
}
return this;
if (!found) {
right = right->removeInvalidSegment(x, gridXPos, preciseXPos, found);
setHeight();
if (right == NULL) {
return this;
}
if (balance() == -2) {
// the right son is higher than the left son
return counterClockwiseRotation();
}
if (balance() == 2) {
// the left son is higher than the right son
return clockwiseRotation();
}
return this;
}
}
}
}
/*
1.1 ~isLeaf~
*/
bool AVLNode::isLeaf() {
return (left == NULL && right == NULL);
}
/*
1.1 ~deletemin~
*/
AVLSegment* AVLNode::deletemin(AVLNode* node) {
AVLSegment* result = 0;
if (left == NULL) {
result = elem;
elem = 0;
} else {
result = left->deletemin(left);
if (left->elem == 0) {
left = left->right;
}
if (left != 0) {
left->setHeight();
}
setHeight();
if (balance() == -2) {
*node = *counterClockwiseRotation();
}
if (balance() == 2) {
*node = *clockwiseRotation();
}
}
return result;
}
/*
1.1 ~inorder~
*/
void AVLNode::inorder() {
if (left != 0) {
left->inorder();
}
cout << "aktueller Knoten:" << endl;
elem->print();
if (left != 0) {
cout << "left son: ";
left->elem->print();
} else {
cout << "left Son: 0" << endl << endl;
}
if (right != 0) {
cout << "right son: ";
right->elem->print();
} else {
cout << "right Son: 0" << endl << endl;
}
cout << endl << endl << endl;
if (right != 0) {
right->inorder();
}
}
/*
3 Class AVLSegment
*/
/*
1.1 Constructors and destructor
*/
AVLSegment::AVLSegment() :
flob(0), dbarray(0), originalData1(0), originalData2(0),
pxl(0), pyl(0), pxr(0), pyr(0),
valid(false), isNew(true), noOfChanges(0),
conAbove(0), conBelow(0) {
}
AVLSegment::AVLSegment(const Flob* preciseData, SegmentData* sd, Owner o) :
gridXL(sd->GetDomGridXCoord()), gridYL(sd->GetDomGridYCoord()), gridXR(
sd->GetSecGridXCoord()), gridYR(sd->GetSecGridYCoord()),
flob(preciseData), dbarray(0),
originalData1(sd), originalData2(0), pxl(0), pyl(0), pxr(0), pyr(0), owner(
o), valid(true), isNew(false), noOfChanges(0), firstInsideAbove(
o == first ? sd->GetInsideAbove() : 0), secondInsideAbove(
o == second ? sd->GetInsideAbove() : 0), conAbove(
sd->GetInsideAbove() ? 1 : 0), conBelow(sd->GetInsideAbove() ? 0 : 1) {
}
AVLSegment::AVLSegment(const Flob* preciseData, p2d::SegmentData* sd, Owner o,
mpq_class& scalefactor) :
gridXL(0), gridYL(0), gridXR(0), gridYR(0),
flob(0), dbarray(0), originalData1(0), originalData2(0),
pxl(0), pyl(0), pxr(0), pyr(0), owner(o),
valid(true), isNew(true), noOfChanges(0),
firstInsideAbove(o == first ? sd->GetInsideAbove() : 0),
secondInsideAbove(o == second ? sd->GetInsideAbove() : 0),
conAbove(sd->GetInsideAbove() ? 1 : 0),
conBelow(sd->GetInsideAbove() ? 0 : 1) {
p2d::prepareData(gridXL, pxl,
((sd->GetDomGridXCoord()+
sd->GetDomPreciseXCoord(*preciseData))*scalefactor));
p2d::prepareData(gridYL, pyl,
((sd->GetDomGridYCoord()+
sd->GetDomPreciseYCoord(*preciseData))*scalefactor));
p2d::prepareData(gridXR, pxr,
((sd->GetSecGridXCoord()+
sd->GetSecPreciseXCoord(*preciseData))*scalefactor));
p2d::prepareData(gridYR, pyr,
((sd->GetSecGridYCoord()+
sd->GetSecPreciseYCoord(*preciseData))*scalefactor));
}
AVLSegment::AVLSegment(const DbArray<unsigned int>* preciseData,
Reg2GridHalfSegment& gs, Reg2PrecHalfSegment* ps, Owner o) :
gridXL(gs.GetLeftPointX()), gridYL(gs.GetLeftPointY()), gridXR(
gs.GetRightPointX()), gridYR(gs.GetRightPointY()),
flob(0), dbarray(
preciseData), originalData1(0), originalData2(ps),
pxl(0), pyl(0), pxr(0), pyr(0),
owner(o), valid(true), isNew(false), noOfChanges(0), firstInsideAbove(
o == first ? gs.GetAttr().insideAbove : 0), secondInsideAbove(
o == second ? gs.GetAttr().insideAbove : 0), conAbove(
gs.attr.insideAbove ? 1 : 0), conBelow(gs.attr.insideAbove ? 0 : 1) {
}
AVLSegment::AVLSegment(const DbArray<unsigned int>* preciseData,
Reg2GridHalfSegment& gs, Reg2PrecHalfSegment& ps, Owner o,
mpq_class& scalefactor) :
gridXL(0), gridYL(0), gridXR(0), gridYR(0),
flob(0), dbarray(0), originalData1(0), originalData2(0),
pxl(0), pyl(0), pxr(0), pyr(0),
owner(o), valid(true), isNew(true), noOfChanges(0), firstInsideAbove(
o == first ? gs.GetAttr().insideAbove : 0), secondInsideAbove(
o == second ? gs.GetAttr().insideAbove : 0), conAbove(
gs.attr.insideAbove ? 1 : 0), conBelow(gs.attr.insideAbove ? 0 : 1) {
p2d::prepareData(gridXL, pxl,
((gs.GetLeftPointX()+ps.GetlPointx(preciseData))*scalefactor));
p2d::prepareData(gridYL, pyl,
((gs.GetLeftPointY()+ps.GetlPointy(preciseData))*scalefactor));
p2d::prepareData(gridXR, pxr,
((gs.GetRightPointX()+ps.GetrPointx(preciseData))*scalefactor));
p2d::prepareData(gridYR, pyr,
((gs.GetRightPointY()+ps.GetrPointy(preciseData))*scalefactor));
}
AVLSegment::AVLSegment(const AVLSegment& s) :
gridXL(s.getGridXL()), gridYL(s.getGridYL()), gridXR(s.getGridXR()), gridYR(
s.getGridYR()), flob(s.flob), dbarray(s.dbarray), originalData1(
s.originalData1), originalData2(s.originalData2),
pxl(s.pxl), pyl(s.pyl), pxr(s.pxr), pyr(s.pyr), owner(s.owner),
valid(s.isValid()), isNew(s.isNew), noOfChanges(s.noOfChanges),
firstInsideAbove(s.getFirstInsideAbove()), secondInsideAbove(
s.getSecondInsideAbove()), conAbove(s.conAbove), conBelow(s.conBelow) {
}
AVLSegment::AVLSegment(int gridX, mpq_class px, int gridY, mpq_class py) :
gridXL(gridX), gridYL(gridY), gridXR(gridX), gridYR(gridY), flob(0), dbarray(
0), originalData1(0), originalData2(0), pxl(px), pyl(py), pxr(px), pyr(py),
owner(none), valid(true), isNew(true), noOfChanges(0), firstInsideAbove(0),
secondInsideAbove(0), conAbove(0), conBelow(0) {
}
AVLSegment::AVLSegment(int gxl, int gyl, int gxr, int gyr, mpq_class xLeft,
mpq_class yLeft, mpq_class xRight, mpq_class yRight, Owner o) :
gridXL(gxl), gridYL(gyl), gridXR(gxr), gridYR(gyr), flob(0), dbarray(0),
originalData1(0), originalData2(0),
pxl(xLeft), pyl(yLeft), pxr(xRight), pyr(yRight),
owner(o), valid(true), isNew(true), noOfChanges(0),
firstInsideAbove(0), secondInsideAbove(0), conAbove(0), conBelow(0) {
}
AVLSegment::~AVLSegment() {
originalData1 = NULL;
originalData2 = NULL;
flob = NULL;
dbarray = NULL;
}
/*
1.1 ~set~
*/
void AVLSegment::set(mpq_class xl, mpq_class yl, mpq_class xr, mpq_class yr,
Owner o) {
prepareData(gridXL, pxl, xl);
prepareData(gridYL, pyl, yl);
prepareData(gridXR, pxr, xr);
prepareData(gridYR, pyr, yr);
owner = o;
isNew = true;
valid = true;
originalData1 = NULL;
originalData2 = NULL;
flob = NULL;
dbarray = NULL;
}
void AVLSegment::set(int gxl, int gyl, int gxr, int gyr, mpq_class xl,
mpq_class yl, mpq_class xr, mpq_class yr, Owner o) {
gridXL = gxl;
gridYL = gyl;
gridXR = gxr;
gridYR = gyr;
pxl = xl;
pyl = yl;
pxr = xr;
pyr = yr;
owner = o;
isNew = true;
valid = true;
originalData1 = NULL;
originalData2 = NULL;
flob = NULL;
dbarray = NULL;
}
/*
1.1 ~prepareData~
Extract the integer from ~value~.
*/
void AVLSegment::prepareData(int& resultGridX, mpq_class& resultPX,
mpq_class& value) {
mpz_class numerator = value.get_num();
mpz_class denominator = value.get_den();
mpz_class gridX = numerator / denominator;
if ((cmp(gridX, numeric_limits<int>::min())<0)
||(cmp(numeric_limits<int>::max(), gridX)<0)){
cerr <<"The grid-value "<<gridX
<<"don't fit in a variable of type int."<<endl;
assert(false);
}
resultGridX = (int) gridX.get_d();
int cmpValue = cmp(value, resultGridX);
if (cmpValue != 0) {
//value is not an integer
if (cmpValue < 0) {
//value is a rational number less 0
//the grid value is the next integer less than value
resultGridX--;
}
resultPX = value - resultGridX;
} else {
//value is an integer
resultPX = 0;
}
}
/*
1.1 ~getPrecise...~
*/
mpq_class AVLSegment::getPreciseXL() const {
if (isNew) {
return pxl;
} else {
if (originalData1) {
return originalData1->getPreciseLeftX(*flob);
} else {
return originalData2->GetlPointx(dbarray);
}
}
}
mpq_class AVLSegment::getPreciseYL() const {
if (isNew) {
return pyl;
} else {
if (originalData1) {
return originalData1->getPreciseLeftY(*flob);
} else {
return originalData2->GetlPointy(dbarray);
}
}
}
mpq_class AVLSegment::getPreciseXR() const {
if (isNew) {
return pxr;
} else {
if (originalData1) {
return originalData1->getPreciseRightX(*flob);
} else {
return originalData2->GetrPointx(dbarray);
}
}
}
mpq_class AVLSegment::getPreciseYR() const {
if (isNew) {
return pyr;
} else {
if (originalData1) {
return originalData1->getPreciseRightY(*flob);
} else {
return originalData2->GetrPointy(dbarray);
}
}
}
/*
1.1 ~getNumberOfChanges~
*/
int AVLSegment::getNumberOfChanges() const {
return noOfChanges;
}
/*
1.1 ~setNumberOfChanges~
*/
void AVLSegment::setNumberOfChanges(int i) {
noOfChanges = i;
}
/*
1.1 ~incrementNumberOfChanges~
*/
void AVLSegment::incrementNumberOfChanges() {
noOfChanges++;
}
/*
1.1 ~getFirstInsideAbove~
*/
bool AVLSegment::getFirstInsideAbove() const {
return firstInsideAbove;
}
/*
1.1 ~getSecondInsideAbove~
*/
bool AVLSegment::getSecondInsideAbove() const {
return secondInsideAbove;
}
/*
1.1 ~setFirstInsideAbove~
*/
void AVLSegment::setFirstInsideAbove(bool insideAbove) {
firstInsideAbove = insideAbove;
}
/*
1.1 ~setSecondInsideAbove~
*/
void AVLSegment::setSecondInsideAbove(bool insideAbove) {
secondInsideAbove = insideAbove;
}
/*
1.1 ~getConBelow~
*/
short int AVLSegment::getConBelow() {
return conBelow;
}
/*
1.1 ~getConAbove~
*/
short int AVLSegment::getConAbove() {
return conAbove;
}
/*
1.1 ~setConBelow~
*/
void AVLSegment::setConBelow(short int i) {
conBelow = i;
}
/*
1.1 ~setConAbove~
*/
void AVLSegment::setConAbove(short int i) {
conAbove = i;
}
/*
1.1 ~print~
*/
void AVLSegment::print() {
cout << "( " << getGridXL() << " " << getPreciseXL() << ", " << getGridYL()
<< " " << getPreciseYL() << ", " << getGridXR() << " " << getPreciseXR()
<< ", " << getGridYR() << " " << getPreciseYR() << " )" << endl << "owner: "
<< owner << endl << "conAbove: " << conAbove << endl << "conBelow: "
<< conBelow << endl << "valid: " << valid << endl
<< "firstInsideAbove: " << firstInsideAbove<<
endl<<"secondInsideAbove: " <<secondInsideAbove<<endl;
}
/*
1.1 test-functions
*/
/*
1.1.1 ~equal~
*/
bool AVLSegment::equal(AVLSegment& s) const {
if (getGridXL() != s.getGridXL() || getGridYL() != s.getGridYL()
|| getGridXR() != s.getGridXR() || getGridYR() != s.getGridYR()) {
return false;
}
if ((cmp(getPreciseXL(), s.getPreciseXL()) != 0)
|| (cmp(getPreciseYL(), s.getPreciseYL()) != 0)
|| (cmp(getPreciseXR(), s.getPreciseXR()) != 0)
|| (cmp(getPreciseYR(), s.getPreciseYR()) != 0)) {
return false;
}
return true;
}
/*
1.1.1 ~isPoint~
*/
bool AVLSegment::isPoint() const {
if (getGridXL() != getGridXR() || getGridYL() != getGridYR()) {
return false;
}
if ((cmp(getPreciseXL(), getPreciseXR()) != 0)
|| (cmp(getPreciseYL(), getPreciseYR()) != 0)) {
return false;
}
return true;
}
/*
1.1.1 ~isEndpoint~
*/
bool AVLSegment::isEndpoint(int gx, int gy, mpq_class px, mpq_class py) {
if (getGridXL() == gx && getGridYL() == gy) {
if (cmp(getPreciseXL(), px) == 0 && cmp(getPreciseYL(), py) == 0) {
return true;
}
}
if (getGridXR() == gx && getGridYR() == gy) {
if (cmp(getPreciseXR(), px) == 0 && cmp(getPreciseYR(), py) == 0) {
return true;
}
}
return false;
}
/*
1.1.1 ~startsAtPoint~
*/
bool AVLSegment::startsAtPoint(int gx, int gy, mpq_class px, mpq_class py) {
if (getGridXL() == gx && getGridYL() == gy) {
if (cmp(getPreciseXL(), px) == 0 && cmp(getPreciseYL(), py) == 0) {
return true;
}
}
return false;
}
/*
1.1.1 ~endsInPoint~
*/
bool AVLSegment::endsInPoint(int gx, int gy, mpq_class px, mpq_class py) {
if (getGridXR() == gx && getGridYR() == gy) {
if (cmp(getPreciseXR(), px) == 0 && cmp(getPreciseYR(), py) == 0) {
return true;
}
}
return false;
}
/*
1.1.1 ~isLeftOf~
*/
bool AVLSegment::isLeftOf(Event& event) {
if (getGridXR() < event.getGridX()) {
return true;
}
int cmpXR = cmp(getPreciseXR(), event.getPreciseX());
if ((getGridXR() == event.getGridX()) && (cmpXR < 0)) {
return true;
}
if ((getGridXR() > event.getGridX())
|| ((getGridXR() == event.getGridX()) && cmpXR > 0)) {
return false;
}
//equal x
if (getGridYR() < event.getGridY()) {
return true;
}
if (getGridYR() > event.getGridY()) {
return false;
}
int cmpYR = cmp(getPreciseYR(), event.getPreciseY());
if (cmpYR < 0) {
return true;
}
if (cmpYR > 0) {
return false;
}
//The right endpoint of the segment is equal to the eventpoint
//If the event is a left endpoint event or an intersection event,
//then the segment lay right of the event, otherwise not.
if (event.isRightEndpointEvent() || event.isIntersectionEvent()) {
return true;
} else {
return false;
}
}
/*
1.1.1 ~leftPointIsLeftOf~
*/
bool AVLSegment::leftPointIsLeftOf(Event& event) {
if (getGridXL() < event.getGridX()) {
return true;
}
int cmpXL = cmp(getPreciseXL(), event.getPreciseX());
if ((getGridXL() == event.getGridX()) && (cmpXL < 0)) {
return true;
}
if ((getGridXL() > event.getGridX())
|| ((getGridXL() == event.getGridX()) && cmpXL > 0)) {
return false;
}
//equal x
if (getGridYL() < event.getGridY()) {
return true;
}
if (getGridYL() > event.getGridY()) {
return false;
}
int cmpYL = cmp(getPreciseYL(), event.getPreciseY());
if (cmpYL < 0) {
return true;
}
if (cmpYL > 0) {
return false;
}
//The right endpoint of the segment is equal to the eventpoint
//If the event is a left endpoint event or an intersection event, then
//the segment lay right of the event, otherwise not.
if (event.isRightEndpointEvent()) {
return true;
} else {
return false;
}
}
/*
1.1.1 ~isRightPointOf~
*/
bool AVLSegment::isRightPointOf(AVLSegment& s) {
if (s.getGridXR() != getGridXL()) {
return false;
}
if (s.getGridYR() != getGridXL()) {
return false;
}
if (cmp(s.getPreciseXR(), getPreciseXL()) != 0) {
return false;
}
if (cmp(s.getPreciseYR(), getPreciseYL()) != 0) {
return false;
}
return true;
}
/*
1.1.1 ~isLeftPointOf~
*/
bool AVLSegment::isLeftPointOf(AVLSegment& s) {
if (s.getGridXL() != getGridXL()) {
return false;
}
if (s.getGridYL() != getGridYL()) {
return false;
}
if (cmp(s.getPreciseXL(), getPreciseXL()) != 0) {
return false;
}
if (cmp(s.getPreciseYL(), getPreciseYL()) != 0) {
return false;
}
return true;
}
/*
1.1.1 ~hasEqualLeftEndPointAs~
*/
bool AVLSegment::hasEqualLeftEndpointAs(AVLSegment& s) {
if (s.getGridXL() != getGridXL()) {
return false;
}
if (s.getGridYL() != getGridYL()) {
return false;
}
if (cmp(s.getPreciseXL(), getPreciseXL()) != 0) {
return false;
}
if (cmp(s.getPreciseYL(), getPreciseYL()) != 0) {
return false;
}
return true;
}
/*
1.1.1 ~isValid~
*/
bool AVLSegment::isValid() const {
return valid;
}
/*
1.1 ~changeValidity~
*/
void AVLSegment::changeValidity(bool v) {
valid = v;
}
/*
1.1 ~=~
*/
AVLSegment& AVLSegment::operator=(const AVLSegment& s) {
gridXL = s.getGridXL();
gridYL = s.getGridYL();
gridXR = s.getGridXR();
gridYR = s.getGridYR();
flob = s.flob;
dbarray = s.dbarray;
originalData1 = s.originalData1;
originalData2 = s.originalData2;
owner = s.getOwner();
valid = s.isValid();
isNew = s.isNew;
noOfChanges = s.getNumberOfChanges();
firstInsideAbove = s.firstInsideAbove;
secondInsideAbove = s.secondInsideAbove;
conAbove = s.conAbove;
conBelow = s.conBelow;
if (isNew) {
pxl = s.getPreciseXL();
pyl = s.getPreciseYL();
pxr = s.getPreciseXR();
pyr = s.getPreciseYR();
}
return *this;
}
/*
1.1 ~intervalIsVertical~
*/
bool AVLSegment::intervalIsVertical() {
return gridXL == gridXR;
}
/*
1.1 ~computeBeginOfIntersectionInterval~
*/
int AVLSegment::computeBeginOfIntersectionInterval(int pos) {
if (intervalIsVertical()) {
if (gridYL <= gridYR) {
return gridYL;
} else {
return gridYR;
}
} else {
if (((gridYR - gridYL) > 0 && (gridXR - gridXL) > 0)
|| ((gridYR - gridYL) < 0 && (gridXR - gridXL) < 0)) {
//positive slope
//mpq_class value = (((ppos * (gridYR - gridYL))
//+ (gridYL * (gridXR - pgridXL))
// - ((pgridXL + 1) * (gridYR - gridYL))) / (gridXR - pgridXL));
//if (cmp(value, numeric_limits<int>::max())>0){
// cerr<< "wert zu groß"<<endl;
// assert(false);
//}
long long yryl = gridYR - gridYL;
long long xrxl = gridXR - gridXL;
long long lPos = (long long) pos;
long long lGridXL = (long long) gridXL;
long long lGridYL = (long long) gridYL;
long long num = ((lPos * yryl) + (lGridYL * xrxl)
- ((lGridXL + 1) * yryl));
return ((int)(num/xrxl));
//return (((pos * (gridYR - gridYL)) + (gridYL * (gridXR - gridXL))
// - ((gridXL + 1) * (gridYR - gridYL))) / (gridXR - gridXL));
} else {
//mpq_class value = ((((ppos + 1) * (gridYR - gridYL))
//+ (gridYL * (gridXR - pgridXL))
// - (pgridXL * (gridYR - gridYL))) / (gridXR - pgridXL));
//if (cmp(value, numeric_limits<int>::max())>0){
// cerr<< "wert zu groß"<<endl;
// assert(false);
//}
long long yryl = gridYR - gridYL;
long long xrxl = gridXR - gridXL;
long long lPos = (long long) pos;
long long lGridXL = (long long) gridXL;
long long lGridYL = (long long) gridYL;
long long num = (((lPos + 1) * yryl) + (lGridYL * xrxl)
- (lGridXL * yryl));
return ((int)(num/xrxl));
//return ((((pos + 1) * (gridYR - gridYL)) + (gridYL * (gridXR - gridXL))
// - (gridXL * (gridYR - gridYL))) / (gridXR - gridXL));
}
}
}
/*
1.1 ~computeEndOfIntersectionInterval~
*/
int AVLSegment::computeEndOfIntersectionInterval(int pos) {
if (intervalIsVertical()) {
if (gridYL >= gridYR) {
return gridYL + 1;
} else {
return gridYR + 1;
}
} else {
//mpq_class pgridXL = gridXL;
//mpq_class ppos = pos;
if (((gridYR - gridYL) > 0 && (gridXR - gridXL) > 0)
|| ((gridYR - gridYL) < 0 && (gridXR - gridXL) < 0)) {
//positive slope
long long yryl = gridYR - gridYL;
long long xrxl = gridXR - gridXL;
long long lPos = (long long) pos;
long long lGridXL = (long long) gridXL;
long long lGridYL = (long long) gridYL;
long long num = (((lPos + 1) * yryl) + ((lGridYL + 1) * xrxl)
- ((lGridXL) * yryl));
return ((int)((num/(xrxl))+1));
} else {
long long yryl = gridYR - gridYL;
long long xrxl = gridXR - gridXL;
long long lPos = (long long) pos;
long long lGridXL = (long long) gridXL;
long long lGridYL = (long long) gridYL;
long long num = ((lPos * yryl) + ((lGridYL + 1) * xrxl)
- ((lGridXL + 1) * yryl));
return ((int)((num/xrxl)+1));
}
}
}
/*
1.1 ~compareIntersectionIntervallWithSweepline~
*/
int AVLSegment::compareIntersectionintervalWithSweepline(AVLSegment& s,
int gridXPos) {
assert(
(gridXL <= gridXPos && gridXPos <= gridXR && s.getGridXL() <= gridXPos
&& gridXPos <= s.getGridXR()));
int endInterval, beginIntervalOfS;
endInterval = computeEndOfIntersectionInterval(gridXPos);
beginIntervalOfS = s.computeBeginOfIntersectionInterval(gridXPos);
if (endInterval < beginIntervalOfS) {
// the interval of this segment in ~pos~ is below
// the interval of ~s~ in ~pos~. So the y-value of this in ~pos~
// is less than the y-value of ~s~ in ~pos~.
return -1;
}
int beginInterval, endIntervalOfS;
beginInterval = computeBeginOfIntersectionInterval(gridXPos);
endIntervalOfS = s.computeEndOfIntersectionInterval(gridXPos);
if (endIntervalOfS < beginInterval) {
// the interval of this segment in ~pos~ is above
// the interval of ~s~ in ~pos~. So the y-value of this in ~pos~
// is greater than the y-value of ~s~ in ~pos~.
return 1;
}
return 0;
}
/*
1.1 ~compareInPos~
*/
int AVLSegment::compareInPosOrRight(AVLSegment& s, int gridXPos,
mpq_class& preciseXPos) {
mpq_class thisY, sY;
mpq_class preciseXPosition = preciseXPos + gridXPos;
// compute the slope of both segments
bool thisIsNotVertical = false;
bool sIsNotVertical = false;
mpq_class thisSlope(0);
mpq_class sSlope(0);
mpq_class thisXL = getPreciseXL() + getGridXL();
mpq_class thisYL = getPreciseYL() + getGridYL();
mpq_class thisXR = getPreciseXR() + getGridXR();
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sXL = s.getPreciseXL() + s.getGridXL();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
mpq_class sXR = s.getPreciseXR() + s.getGridXR();
mpq_class sYR = s.getPreciseYR() + s.getGridYR();
if ((getGridXR() != getGridXL()) || (cmp(thisXR, thisXL) != 0)) {
thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
thisIsNotVertical = true;
}
if ((s.getGridXR() != s.getGridXL()) || (cmp(sXR, sXL) != 0)) {
sSlope = (sYR - sYL) / (sXR - sXL);
sIsNotVertical = true;
}
if (thisIsNotVertical && sIsNotVertical) {
mpq_class thisY = ((thisSlope * preciseXPosition) + thisYL
- (thisSlope * thisXL));
mpq_class sY = ((sSlope * preciseXPosition) + sYL - (sSlope * sXL));
int cmpYinPos = cmp(thisY, sY);
if (cmpYinPos != 0) {
return cmpYinPos;
} else {
//both segments intersect in ~pos~
if ((gridYL == gridYR) && (s.getGridYL() == s.getGridYR())
&& (cmp(getPreciseYL(), getPreciseYR()) == 0)
&& (cmp(s.getPreciseYL(), s.getPreciseYR()) == 0)) {
//both segments are horizontal, compare left points
//the left one is the smaller one
if (gridXL != s.getGridXL()) {
if (gridXL < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
int cmpXL = cmp(getPreciseXL(), s.getPreciseXL());
if (cmpXL != 0) {
return cmpXL;
}
//both left points are equal, compare right points,
//the left one is the smaller one
if (gridXR != s.getGridXR()) {
if (gridXR < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
return cmp(getPreciseXR(), s.getPreciseXR());
} else {
int cmpSlope = cmp(sSlope, thisSlope);
if (cmpSlope != 0) {
if (cmpSlope < 0) {
return 1;
} else {
return -1;
}
} else {
//both segments run on the same line
//the left one is smaller
if (getGridXL() != s.getGridXL()) {
if (getGridXL() < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
int cmpXL = cmp(thisXL, sXL);
if (cmpXL != 0) {
return cmpXL;
} else {
//both segments start in the same XL
if (getGridXR() != s.getGridXR()) {
if (getGridXR() < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
return cmp(thisXR, sXR);
}
}
}
}
}
else {
if (thisIsNotVertical) {
//~s~ is vertical
mpq_class thisY = ((thisSlope * sXL) + thisYL - (thisXL * thisSlope));
int cmpYinSXL1 = cmp(thisY, sYR);
if (cmpYinSXL1 <= 0) {
//~this~ runs below ~s~
return -1;
} else {
return 1;
}
}
if (sIsNotVertical) {
//~this~ is vertical
mpq_class sY = ((sSlope * thisXL) + sYL - (sXL * sSlope));
int cmpYinSXL2 = cmp(sY, thisYR);
if (cmpYinSXL2 <= 0) {
//~s~ runs below ~this~
return 1;
} else {
return -1;
}
}
if ((s.getGridYR() < this->getGridYL())
|| ((s.getGridYR() == this->getGridYL()) && (cmp(sYR, thisYL) < 0))) {
// this is above s
return 1;
} else {
if (getGridYR() < s.getGridYL()) {
return -1;
}
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
if ((getGridYR() == s.getGridYL()) && (cmp(thisYR, sYL) < 0)) {
// s above this
return -1;
}
if (getGridYL() != s.getGridYL()) {
if (getGridYL() < s.getGridYL()) {
return -1;
} else {
return 1;
}
}
int cmpYL = cmp(thisYL, sYL);
if (cmpYL != 0) {
return cmpYL;
} else {
if (getGridYR() != s.getGridYR()) {
if (getGridYR() < s.getGridYR()) {
return -1;
} else {
return 1;
}
}
int cmpYR = cmp(thisYR, sYR);
return cmpYR;
}
}
}
}
/*
1.1 ~compareInPosOrLeft~
*/
int AVLSegment::compareInPosOrLeft(AVLSegment& s, int gridXPos,
mpq_class& preciseXPos) {
mpq_class thisY, sY;
mpq_class preciseXPosition = preciseXPos + gridXPos;
// compute the slope of both segments
bool thisIsNotVertical = false;
bool sIsNotVertical = false;
mpq_class thisSlope(0);
mpq_class sSlope(0);
mpq_class thisXL = getPreciseXL() + getGridXL();
mpq_class thisYL = getPreciseYL() + getGridYL();
mpq_class thisXR = getPreciseXR() + getGridXR();
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sXL = s.getPreciseXL() + s.getGridXL();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
mpq_class sXR = s.getPreciseXR() + s.getGridXR();
mpq_class sYR = s.getPreciseYR() + s.getGridYR();
if ((getGridXR() != getGridXL()) || (cmp(thisXR, thisXL) != 0)) {
thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
thisIsNotVertical = true;
}
if ((s.getGridXR() != s.getGridXL()) || (cmp(sXR, sXL) != 0)) {
sSlope = (sYR - sYL) / (sXR - sXL);
sIsNotVertical = true;
}
if (thisIsNotVertical && sIsNotVertical) {
mpq_class thisY = ((thisSlope * preciseXPosition) + thisYL
- (thisSlope * thisXL));
mpq_class sY = ((sSlope * preciseXPosition) + sYL - (sSlope * sXL));
int cmpYinPos = cmp(thisY, sY);
if (cmpYinPos != 0) {
return cmpYinPos;
} else {
//both segments intersect in ~pos~
if ((gridYL == gridYR) && (s.getGridYL() == s.getGridYR())
&& (cmp(getPreciseYL(), getPreciseYR()) == 0)
&& (cmp(s.getPreciseYL(), s.getPreciseYR()) == 0)) {
//both segments are horizontal, compare left points
//the left one is the smaller one
if (gridXL != s.getGridXL()) {
if (gridXL < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
int cmpXL = cmp(getPreciseXL(), s.getPreciseXL());
if (cmpXL != 0) {
return cmpXL;
}
//both left points are equal, compare right points,
//the left one is the smaller one
if (gridXR != s.getGridXR()) {
if (gridXR < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
return cmp(getPreciseXR(), s.getPreciseXR());
} else {
int cmpSlope = cmp(sSlope, thisSlope);
if (cmpSlope != 0) {
return cmpSlope;
} else {
//both segments run on the same line
//the left one is smaller
if (getGridXL() != s.getGridXL()) {
if (getGridXL() < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
int cmpXL = cmp(thisXL, sXL);
if (cmpXL != 0) {
return cmpXL;
} else {
//both segments start in the same XL
if (getGridXR() != s.getGridXR()) {
if (getGridXR() < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
return cmp(thisXR, sXR);
}
}
}
}
}
else {
if (thisIsNotVertical) {
//~s~ is vertical
mpq_class thisY = ((thisSlope * sXL) + thisYL - (thisXL * thisSlope));
int cmpYinSXL1 = cmp(thisY, sYL);
if (cmpYinSXL1 < 0) {
//~this~ runs below ~s~
return -1;
} else {
return 1;
}
}
if (sIsNotVertical) {
//~this~ is vertical
mpq_class sY = ((sSlope * thisXL) + sYL - (sXL * sSlope));
int cmpYinSXL2 = cmp(sY, thisYL);
if (cmpYinSXL2 < 0) {
//~s~ runs below ~this~
return 1;
} else {
return -1;
}
}
// both are vertical
if ((s.getGridYR() < getGridYL())
|| ((s.getGridYR() == getGridYL()) && cmp(sYR, thisYL) < 0)) {
// this is above s
return 1;
} else {
if (getGridYR() < s.getGridYL()) {
return -1;
}
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
if ((getGridYR() == s.getGridYL()) && (cmp(thisYR, sYL) < 0)) {
// s above this
return -1;
}
if (getGridYL() != s.getGridYL()) {
if (getGridYL() < s.getGridYL()) {
return -1;
} else {
return 1;
}
}
int cmpYL = cmp(thisYL, sYL);
if (cmpYL != 0) {
return cmpYL;
} else {
if (getGridYR() != s.getGridYR()) {
if (getGridYR() < s.getGridYR()) {
return -1;
} else {
return 1;
}
}
return cmp(thisYR, sYR);
}
}
}
}
/*
1.1 ~compareInPosForMember~
*/
int AVLSegment::compareInPosForMember(AVLSegment& s, int gridXPos,
mpq_class& preciseXPos, int gridYPos, mpq_class& preciseYPos) {
mpq_class thisY, sY;
mpq_class preciseXPosition = preciseXPos + gridXPos;
// compute the slope of both segments
bool thisIsNotVertical = false;
bool sIsNotVertical = false;
mpq_class thisSlope(0);
mpq_class sSlope(0);
mpq_class thisXL = getPreciseXL() + getGridXL();
mpq_class thisYL = getPreciseYL() + getGridYL();
mpq_class thisXR = getPreciseXR() + getGridXR();
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sXL = s.getPreciseXL() + s.getGridXL();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
mpq_class sXR = s.getPreciseXR() + s.getGridXR();
mpq_class sYR = s.getPreciseYR() + s.getGridYR();
if ((getGridXR() != getGridXL()) || (cmp(thisXR, thisXL) != 0)) {
thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
thisIsNotVertical = true;
}
if ((s.getGridXR() != s.getGridXL()) || (cmp(sXR, sXL) != 0)) {
sSlope = (sYR - sYL) / (sXR - sXL);
sIsNotVertical = true;
}
if (thisIsNotVertical && sIsNotVertical) {
mpq_class thisY = ((thisSlope * preciseXPosition) + thisYL
- (thisSlope * thisXL));
mpq_class sY = ((sSlope * preciseXPosition) + sYL - (sSlope * sXL));
int cmpYinPos = cmp(thisY, sY);
if (cmpYinPos != 0) {
return cmpYinPos;
} else {
//both segments intersect in ~pos~
if ((gridYL == gridYR) && (s.getGridYL() == s.getGridYR())
&& (cmp(getPreciseYL(), getPreciseYR()) == 0)
&& (cmp(s.getPreciseYL(), s.getPreciseYR()) == 0)) {
//both segments are horizontal, compare left points
//the left one is the smaller one
if (gridXL != s.getGridXL()) {
if (gridXL < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
int cmpXL = cmp(getPreciseXL(), s.getPreciseXL());
if (cmpXL != 0) {
return cmpXL;
}
//both left points are equal, compare right points,
//the left one is the smaller one
if (gridXR != s.getGridXR()) {
if (gridXR < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
return cmp(getPreciseXR(), s.getPreciseXR());
} else {
int cmpSlope = cmp(sSlope, thisSlope);
if (cmpSlope != 0) {
return cmpSlope;
} else {
//both segments run on the same line
//the left one is smaller
if (getGridXL() != s.getGridXL()) {
if (getGridXL() < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
int cmpXL = cmp(thisXL, sXL);
if (cmpXL != 0) {
return cmpXL;
} else {
//both segments start in the same XL
if (getGridXR() != s.getGridXR()) {
if (getGridXR() < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
return cmp(thisXR, sXR);
}
}
}
}
}
else {
if (thisIsNotVertical) {
//~s~ is vertical
if ((this->getGridXL() == s.getGridXL())
&& (this->getGridYL() == s.getGridYL())
&& (cmp(this->getPreciseXL(), s.getPreciseXL()) == 0)
&& (cmp(this->getPreciseYL(), s.getPreciseYL()) == 0)
&& ((this->getGridYL() < gridYPos)
|| ((this->getGridYL() == gridYPos)
&& (cmp(this->getPreciseYL(), preciseYPos) < 0)))) {
//~this~ and ~s~ have been inverted before.
mpq_class thisY = ((thisSlope * sXL) + thisYL - (thisXL * thisSlope));
int cmpYinSXL1 = cmp(thisY, sYL);
if (cmpYinSXL1 < 0) {
//~this~ runs below ~s~
return 1;
} else {
return -1;
}
}
mpq_class thisY = ((thisSlope * sXL) + thisYL - (thisXL * thisSlope));
int cmpYinSXL1 = cmp(thisY, sYL);
if (cmpYinSXL1 < 0) {
//~this~ runs below ~s~
return -1;
} else {
return 1;
}
}
if (sIsNotVertical) {
//~this~ is vertical
if ((this->getGridXL() == s.getGridXL())
&& (this->getGridYL() == s.getGridYL())
&& (cmp(this->getPreciseXL(), s.getPreciseXL()) == 0)
&& (cmp(this->getPreciseYL(), s.getPreciseYL()) == 0)
&& ((this->getGridYL() < gridYPos)
|| ((this->getGridYL() == gridYPos)
&& (cmp(this->getPreciseYL(), preciseYPos) < 0)))) {
//~this~ and ~s~ have been inverted before.
mpq_class sY = ((sSlope * thisXL) + sYL - (sXL * sSlope));
int cmpYinSXL2 = cmp(sY, thisYL);
if (cmpYinSXL2 < 0) {
//~s~ runs below ~this~
return -1;
} else {
return 1;
}
}
mpq_class sY = ((sSlope * thisXL) + sYL - (sXL * sSlope));
int cmpYinSXL2 = cmp(sY, thisYL);
if (cmpYinSXL2 < 0) {
//~s~ runs below ~this~
return 1;
} else {
return -1;
}
}
// both are vertical
if ((s.getGridYR() < getGridYL())
|| ((s.getGridYR() == getGridYL()) && (cmp(sYR, thisYL) < 0))) {
// this is above s
return 1;
} else {
if (getGridYR() < s.getGridYL()) {
return -1;
}
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
if ((getGridYR() == s.getGridYL()) && (cmp(thisYR, sYL) < 0)) {
// s above this
return -1;
}
if (getGridYL() != s.getGridYL()) {
if (getGridYL() < s.getGridYL()) {
return -1;
} else {
return 1;
}
}
int cmpYL = cmp(thisYL, sYL);
if (cmpYL != 0) {
return cmpYL;
} else {
if (getGridYR() != s.getGridYR()) {
if (getGridYR() < s.getGridYR()) {
return -1;
} else {
return 1;
}
}
return cmp(thisYR, sYR);
}
}
}
}
/*
1.1 ~isVertical~
*/
bool AVLSegment::isVertical() const {
if (getGridXL() != getGridXR()) {
return false;
} else {
return (cmp(getPreciseXL(), getPreciseXR()) == 0);
}
}
/*
1.1 ~isParallelTo~
*/
bool AVLSegment::isParallelTo(const AVLSegment& s) const {
mpq_class thisXL = getPreciseXL() + getGridXL();
mpq_class thisXR = getPreciseXR() + getGridXR();
mpq_class sXL = s.getPreciseXL() + s.getGridXL();
mpq_class sXR = s.getPreciseXR() + s.getGridXR();
if ((getGridXL() == getGridXR()) && (cmp(thisXL, thisXR) == 0)) {
//this is vertical
if ((s.getGridXL() == s.getGridXR()) && (cmp(sXL, sXR) == 0)) {
//s is vertical
return true;
} else {
return false;
}
}
if ((s.getGridXL() == s.getGridXR()) && (cmp(sXL, sXR) == 0)) {
//s is vertical
return false;
}
mpq_class thisYL = getPreciseYL() + getGridYL();
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
mpq_class sYR = s.getPreciseYR() + s.getGridYR();
mpq_class thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
mpq_class sSlope = (sYR - sYL) / (sXR - sXL);
if (cmp(thisSlope, sSlope) == 0) {
return true;
}
return false;
}
/*
1.1 ~mightIntersect~
*/
bool AVLSegment::mightIntersect(AVLSegment& seg) {
BoundingSegments* thisBS = new BoundingSegments(gridXL, gridYL, gridXR,
gridYR);
BoundingSegments* segBS = new BoundingSegments(seg.getGridXL(),
seg.getGridYL(), seg.getGridXR(), seg.getGridYR());
bool result = thisBS->intersect(*segBS);
delete thisBS;
delete segBS;
return result;
}
/*
1.1 ~intersect~
*/
bool AVLSegment::intersect(AVLSegment& seg, AVLSegment& result) {
mpq_class thisXL = getPreciseXL() + getGridXL();
mpq_class thisYL = getPreciseYL() + getGridYL();
mpq_class thisXR = getPreciseXR() + getGridXR();
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class segXL = seg.getPreciseXL() + seg.getGridXL();
mpq_class segYL = seg.getPreciseYL() + seg.getGridYL();
mpq_class segXR = seg.getPreciseXR() + seg.getGridXR();
mpq_class segYR = seg.getPreciseYR() + seg.getGridYR();
if ((getGridXL() == getGridXR()) && (seg.getGridXL() == seg.getGridXR())
&& (cmp(thisXL, thisXR) == 0) && (cmp(segXL, segXR) == 0)) {
//both are vertical
if ((getGridXL() == seg.getGridXL()) && (cmp(thisXL, segXL) == 0)) {
//both segments run on one line
if ((seg.getGridYR() < getGridYL())
|| ((seg.getGridYR() == getGridYL()) && (cmp(segYR, thisYL) < 0))
|| (getGridYR() < seg.getGridYL())
|| ((getGridYR() == seg.getGridYL()) && (cmp(thisYR, segYL) < 0))) {
//this passes below or above ~seg~
return false;
} else {
//determine the endpoints
if ((getGridYL() < seg.getGridYL())
|| ((getGridYL() == seg.getGridYL()) && (cmp(thisYL, segYL) <= 0))) {
//overlapping segment starts in (segXL, segYL)
if ((seg.getGridYR() < getGridYR())
|| ((seg.getGridYR() == getGridYR()) && (cmp(segYR, thisYR) <= 0))) {
//overlapping segment ends in (segXL, segYR)
result.set(segXL, segYL, segXL, segYR, both);
return true;
} else {
//overlapping segment ends in (segXL, thisYR)
result.set(seg.getGridXL(), seg.getGridYL(),
seg.getGridXL(), getGridYR(),
seg.getPreciseXL(), seg.getPreciseYL(), seg.getPreciseXL(),
getPreciseYR(), both);
return true;
}
} else {
//overlapping segment starts in (thisXL, thisYL)
if ((seg.getGridYR() < getGridYR())
|| ((seg.getGridYR() == getGridYR()) && (cmp(segYR, thisYR) <= 0))) {
//overlapping segment ends in (segXL, segYR)
result.set(getGridXL(), getGridYL(), getGridXL(), seg.getGridYR(),
getPreciseXL(), getPreciseYL(), getPreciseXL(), seg.getPreciseYR(),
both);
return true;
} else {
//overlapping segment ends in (segXL, thisYR)
result.set(getGridXL(), getGridYL(), getGridXL(), getGridYR(),
getPreciseXL(), getPreciseYL(), getPreciseXL(), getPreciseYR(), both);
return true;
}
}
}
} else {
return false;
}
}
if ((getGridXL() == getGridXR()) && (cmp(thisXL, thisXR) == 0)) {
//this segments is vertical
if (((seg.getGridXL() < getGridXL())
|| ((seg.getGridXL() == getGridXL()) && (cmp(segXL, thisXL) <= 0)))
&& ((getGridXL() < seg.getGridXR())
|| ((getGridXL() == seg.getGridXR()) && (cmp(thisXL, segXR) <= 0)))) {
//this runs through segXL and segXR
mpq_class segSlope = (segYR - segYL) / (segXR - segXL);
mpq_class segB = segYL - segSlope * segXL;
mpq_class yValue = segSlope * thisXL + segB;
if ((cmp(thisYL, yValue) <= 0 && cmp(yValue, thisYR) <= 0)
|| (cmp(thisYR, yValue) <= 0 && cmp(yValue, thisYL) <= 0)) {
result.set(thisXL, yValue, thisXL, yValue, both);
return true;
} else {
return false;
}
} else {
//this runs more left/right than seg
return false;
}
}
if ((seg.getGridXL() == seg.getGridXR()) && (cmp(segXL, segXR) == 0)) {
//seg is vertical
if (((getGridXL() < seg.getGridXL())
|| ((getGridXL() == seg.getGridXL()) && (cmp(thisXL, segXL) <= 0)))
&& ((seg.getGridXL() < getGridXR())
|| ((seg.getGridXL() == getGridXR()) && (cmp(segXL, thisXR) <= 0)))) {
//seg runs through thisXL and thisXR
mpq_class thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
mpq_class thisB = thisYL - thisSlope * thisXL;
mpq_class yValue = thisSlope * segXL + thisB;
if ((cmp(segYL, yValue) <= 0 && cmp(yValue, segYR) <= 0)
|| (cmp(segYR, yValue) <= 0 && cmp(yValue, segYL) <= 0)) {
result.set(segXL, yValue, segXL, yValue, both);
return true;
} else {
return false;
}
} else {
//this runs more left/right than seg
return false;
}
}
mpq_class thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
mpq_class segSlope = (segYR - segYL) / (segXR - segXL);
mpq_class thisB = thisYL - thisSlope * thisXL;
mpq_class segB = segYL - segSlope * segXL;
if (cmp(thisSlope, segSlope) != 0) {
mpq_class xValue = (segB - thisB) / (thisSlope - segSlope);
if (cmp(segXL, xValue) <= 0 && cmp(xValue, segXR) <= 0
&& cmp(thisXL, xValue) <= 0 && cmp(xValue, thisXR) <= 0) {
mpq_class yValue = segSlope * xValue + segB;
yValue.canonicalize();
result.set(xValue, yValue, xValue, yValue, both);
return true;
} else {
return false;
}
} else {
// the segments are parallel
if (cmp(thisB, segB) == 0) {
//both segments runs on a line
if ((seg.getGridXR() < getGridXL()) || (getGridXR() < seg.getGridXL())
|| ((seg.getGridXR() == getGridXL()) && (cmp(segXR, thisXL) < 0))
|| ((getGridXR() == seg.getGridXL()) && (cmp(thisXR, segXL) < 0))) {
// seg runs more left/right than this
return false;
} else {
if ((getGridXL() < seg.getGridXL())
|| ((getGridXL() == seg.getGridXL()) && (cmp(thisXL, segXL) < 0))) {
if ((getGridXR() < seg.getGridXR())
|| ((getGridXR() == seg.getGridXR()) && (cmp(thisXR, segXR) < 0))) {
result.set(segXL, segYL, thisXR, thisYR, both);
return true;
} else {
result.set(segXL, segYL, segXR, segYR, both);
return true;
}
} else {
if ((getGridXR() < seg.getGridXR())
|| ((getGridXR() == seg.getGridXR()) && (cmp(thisXR, segXR) < 0))) {
result.set(thisXL, thisYL, thisXR, thisYR, both);
return true;
} else {
result.set(thisXL, thisYL, segXR, segYR, both);
return true;
}
}
}
} else {
return false;
}
}
assert(false);
return false;
}
/*
1 Class SimpleSegment and BoundingSegments
SimpleSegment and BoundingSegments are used in mightIntersect.
An object of type BoundingSegments contains the segments which
form the envelope of a real segment.
*/
/*
1.1 Constructors and destructor
*/
SimpleSegment::SimpleSegment(int gxl, int gyl, int gxr, int gyr, Position gp) :
xl(gxl), yl(gyl), xr(gxr), yr(gyr), p(gp) {
//cout <<"("<<xl<<", "<<yl<<")->("<<xr<<", "<<yr<<")"<<endl;
assert ((xl<xr)||((xl==xr)&&(yl<yr)));
}
BoundingSegments::BoundingSegments(int gxl, int gyl, int gxr, int gyr) {
//cout <<"gxl: "<<gxl<<endl;
//cout <<"gyl: "<<gyl<<endl;
//cout <<"gxr: "<<gxr<<endl;
//cout <<"gyr: "<<gyr<<endl;
if (gxl == gxr) {
//cout <<"vertikales Segment"<<endl;
//the segment is vertical
numSeg = 4;
createBoundingSegments(vertical, gxl, gyl, gxr, gyr);
} else {
if (gyl == gyr) {
//cout <<"horizontales Segment"<<endl;
//the segment is horizontal
numSeg = 4;
createBoundingSegments(horizontal, gxl, gyl, gxr, gyr);
} else {
//cout <<"schraeges Segment"<<endl;
int numerator = gyr - gyl;
int denumerator = gxr - gxl;
numSeg = 6;
if ((numerator > 0 && denumerator > 0)
|| (numerator < 0 && denumerator < 0)) {
//the segment has a positiv slope
//cout <<"positive slope"<<endl;
createBoundingSegments(positivSlope, gxl, gyl, gxr, gyr);
} else {
//the segment has a negativ slope
//cout <<"negative slope"<<endl;
createBoundingSegments(negativSlope, gxl, gyl, gxr, gyr);
}
}
}
}
BoundingSegments::~BoundingSegments() {
}
/*
1.1 ~createBoundingSegments~
*/
void BoundingSegments::createBoundingSegments(Slope s, int gxl, int gyl,
int gxr, int gyr) {
switch (s) {
case vertical: {
//cout <<"falsch"<<endl;
int y1 = gyl<gyr?gyl:gyr;
int y2 = gyl<gyr?gyr:gyl;
segments = new SimpleSegment[numSeg];
segments[0] = SimpleSegment(gxl, y1, gxr, y2 + 1, pLeft);
segments[1] = SimpleSegment(gxr, y2 + 1, gxr + 1, y2 + 1, top);
segments[2] = SimpleSegment(gxl + 1, y1, gxr + 1, y2 + 1, pRight);
segments[3] = SimpleSegment(gxl, y1, gxl + 1, y1, bottom);
break;
}
case horizontal: {
//cout <<"falsch"<<endl;
segments = new SimpleSegment[numSeg];
segments[0] = SimpleSegment(gxl, gyl, gxl, gyl + 1, pLeft);
segments[1] = SimpleSegment(gxl, gyl + 1, gxr + 1, gyr + 1, top);
segments[2] = SimpleSegment(gxr + 1, gyr, gxr + 1, gyr + 1, pRight);
segments[3] = SimpleSegment(gxl, gyl, gxr + 1, gyr, bottom);
break;
}
case positivSlope: {
//cout <<"richtig"<<endl;
segments = new SimpleSegment[numSeg];
segments[0] = SimpleSegment(gxl, gyl, gxl, gyl + 1, pLeft);
segments[1] = SimpleSegment(gxl, gyl + 1, gxr, gyr + 1, top);
segments[2] = SimpleSegment(gxr, gyr + 1, gxr + 1, gyr + 1, top);
segments[3] = SimpleSegment(gxr + 1, gyr, gxr + 1, gyr + 1, pRight);
segments[4] = SimpleSegment(gxl + 1, gyl, gxr + 1, gyr, bottom);
segments[5] = SimpleSegment(gxl, gyl, gxl + 1, gyl, bottom);
break;
}
case negativSlope: {
//cout <<"falsch"<<endl;
segments = new SimpleSegment[numSeg];
segments[0] = SimpleSegment(gxl, gyl, gxl, gyl + 1, pLeft);
segments[1] = SimpleSegment(gxl, gyl + 1, gxl + 1, gyl + 1, top);
segments[2] = SimpleSegment(gxl + 1, gyl + 1, gxr + 1, gyr + 1, top);
segments[3] = SimpleSegment(gxr + 1, gyr, gxr + 1, gyr + 1, pRight);
segments[4] = SimpleSegment(gxr, gyr, gxr + 1, gyr, bottom);
segments[5] = SimpleSegment(gxl, gyl, gxr, gyr, bottom);
break;
}
default: {
assert(false);
break;
}
}
}
/*
1.1 ~isVertical~
*/
bool BoundingSegments::isVertical(int i) {
assert(0 <= i && i < numSeg);
return (segments[i].getXR() == segments[i].getXL());
}
/*
1.1 ~isHorizontal~
*/
bool BoundingSegments::isHorizontal(int i) {
assert(0 <= i && i <= numSeg);
return (segments[i].getYR() == segments[i].getYL());
}
/*
1.1 ~isLeft~
*/
bool BoundingSegments::isLeft(int i) {
assert(0 <= i && i <= numSeg);
return (segments[i].getPosition() == pLeft);
}
/*
1.1 ~isRight~
*/
bool BoundingSegments::isRight(int i) {
assert(0 <= i && i <= numSeg);
return (segments[i].getPosition() == pRight);
}
/*
1.1 ~isTop~
*/
bool BoundingSegments::isTop(int i) {
assert(0 <= i && i <= numSeg);
return (segments[i].getPosition() == top);
}
/*
1.1 ~isBottom~
*/
bool BoundingSegments::isBottom(int i) {
assert(0 <= i && i <= numSeg);
return (segments[i].getPosition() == bottom);
}
/*
1.1 ~intersect~
long long tXL = segments[i].getXL();
long long tXR = segments[i].getXR();
long long tYL = segments[i].getYL();
long long tYR = segments[i].getYR();
long long bsXL = bs.segments[j].getXL();
long long bsXR = bs.segments[j].getXR();
long long bsYL = bs.segments[j].getYL();
long long bsYR = bs.segments[j].getYR();
if (isVertical(i)) {
vertical = segments[i];
second = bs.segments[j];
vXL = tXL;
vXR = tXR;
vYL = tYL;
vYR = tYR;
sXL = bsXL;
sXR = bsXR;
sYL = bsYL;
sYR = bsYR;
} else {
vertical = bs.segments[j];
second = segments[i];
vXL = bsXL;
vXR = bsXR;
vYL = bsYL;
vYR = bsYR;
sXL = tXL;
sXR = tXR;
sYL = tYL;
sYR = tYR;
}
*/
bool BoundingSegments::intersect(BoundingSegments& bs) {
int i = 0;
bool result = false;
while (i < numSeg && !result) {
int j = 0;
while (j < bs.numSeg && !result) {
long long tXL = segments[i].getXL();
long long tXR = segments[i].getXR();
long long tYL = segments[i].getYL();
long long tYR = segments[i].getYR();
long long bsXL = bs.segments[j].getXL();
long long bsXR = bs.segments[j].getXR();
long long bsYL = bs.segments[j].getYL();
long long bsYR = bs.segments[j].getYR();
long long thisNum = segments[i].getYR() - segments[i].getYL();
long long thisDenom = segments[i].getXR() - segments[i].getXL();
long long bsNum = bs.segments[j].getYR() - bs.segments[j].getYL();
long long bsDenom = bs.segments[j].getXR() - bs.segments[j].getXL();
if((thisDenom == 0) && (bsDenom == 0)) {
// both segments are vertical
if (((isRight(i) && bs.isRight(j)) || (isLeft(i) && isLeft(j)))
&& ((tXL == bsXL)
&& (!((tYR < bsYL)
||(tYL > bsYR))))) {
//If one segment is the left border of the real segment
//and one segment is the right border of the real segment,
//intersection of both is not relevant.
//An intersection is relevant if both are from the
//same side, both run through the same x-value and
//they overlap.
return true;
}
} else { //max. one segment is vertical
if ((thisDenom == 0) || (bsDenom == 0)) {
SimpleSegment vertical;
SimpleSegment second;
long long vXL, vYL, vYR;
long long sXL, sXR, sYL, sYR;
if (isVertical(i)) {
vertical = segments[i];
second = bs.segments[j];
vXL = tXL;
//vXR = tXR;
vYL = tYL;
vYR = tYR;
sXL = bsXL;
sXR = bsXR;
sYL = bsYL;
sYR = bsYR;
} else {
vertical = bs.segments[j];
second = segments[i];
vXL = bsXL;
//vXR = bsXR;
vYL = bsYL;
vYR = bsYR;
sXL = tXL;
sXR = tXR;
sYL = tYL;
sYR = tYR;
}
if ((sXL <= vXL) && (vXL <= sXR)) {
// the vertical segment lay between XL and XR
long long numerator = sYR - sYL;
long long denominator = sXR - sXL;
if (((numerator > 0) && (denominator > 0))
|| ((numerator < 0) && (denominator < 0))) {
/* second has a positive slope
* To prevent wrong values by using double we compute
* only with integers. If we have a function like
* f(x)=m*x+b, we take: m=numerator/denominator
* and b=second.getGridYL()-m*second.getGridXL().
* By avoiding double-values we get:
* y=(numerator*vertical.getGridXL()
* + (second.getGridYL()+1)*denominator
* - numerator*second.getGridXL()) / denominator.
* Then y is the grid-value. If yValue is in the
* interval formed by vertical, both segments might
* intersect.
*/
if (!((second.getPosition() == top && vertical.getPosition() == pRight
&& (vXL == sXL))
|| (second.getPosition() == bottom && vertical.getPosition() == pLeft
&&(vXL == sXR)))) {
long long yValueMin = ((numerator * vXL)
+ (sYL * denominator)
- (numerator * sXL))
/ denominator;
long long yValueMax = ((numerator * (vXL+1))
+ (sYL * denominator)
- (numerator * sXL))
/ denominator;
if (!((vYR < yValueMin) || (yValueMax < vYL))) {
return true;
}
}
} else {
if (((numerator > 0) && (denominator < 0))
|| ((numerator < 0) && (denominator > 0))) {
//second has a negativ slope
if (!((second.getPosition() == top && vertical.getPosition() == pLeft
&& vertical.getXL() == second.getXR())
|| (second.getPosition() == bottom
&& vertical.getPosition() == pRight
&& (vXL == sXL)))) {
long long yValueMin = ((numerator * (vXL+1))
+ (sYL * denominator)
- (numerator * sXL))
/ denominator;
long long yValueMax = ((numerator * vXL)
+ (sYL * denominator)
- (numerator * sXL))
/ denominator;
if (!((vYR < yValueMin) || (yValueMax < vYL))) {
return true;
}
}
} else { // second is horizontal
if ((sXL <= vXL)
&& (vXL <= sXR)
&& (vYL <= sYL)
&& (sYL <= vYR)) {
return true;
}
}
}
}
} else { //there is no vertical segment
if ((thisDenom * bsNum) == (thisNum * bsDenom)) {
//the segments are parallel
if ((isBottom(i) && bs.isBottom(j)) || (isTop(i) && bs.isTop(j))) {
//compare the intersection with the y-coordinate
//(~thisB~ and ~segB~). If they are equal, both
//segments run on the same line and intersect if they
//overlap
long long thisB =
(tYL * thisDenom) - (tXL * thisNum);
long long segB = (bsYL * bsDenom) - (bsXL * bsNum);
long long cmptB = thisB * bsDenom;
long long cmpsB = segB * thisDenom;
if (cmptB ==cmpsB) {
if (!((tXR <= bsXL) || (bsXR <= tXL))) {
return true;
}
}
}
} else { //the segements are not parallel or vertical
long long xNumerator = (thisDenom * bsDenom
* ((bsYL) - tYL))
+ (tXL * bsDenom * thisNum)
- (bsXL * thisDenom * bsNum);
long long xDenominator = ((thisNum * bsDenom) - (thisDenom * bsNum));
long long gridX = (xNumerator / xDenominator);
if ((tXL <= gridX) && (gridX <= tXR)
&& (bsXL <= gridX)
&& (gridX <= bsXR)) {
//the x-value of the intersection point lays in
//the x-interval of both segments
if (thisNum == 0) {
//this is a horizontal segment
if (((bsNum < 0) && (bsDenom < 0))
|| ((bsNum > 0) && (bsDenom > 0))) {
//the segment j of bs has a positiv slope
if ((!((segments[i].getPosition() == bottom)
&& (bs.segments[j].getPosition() == top)
&& (tXL == bsXR)))
&& (!((segments[i].getPosition() == top)
&& (bs.segments[j].getPosition() == bottom)
&& (tXR == bsXL)))) {
if ((bsYL <= tYL) && (tYL <= bsYR)) {
return true;
}
}
} else {
if ((!((segments[i].getPosition() == bottom)
&& (bs.segments[j].getPosition() == top)
&& (tXR == bsXL)))
&& (!((segments[i].getPosition() == top)
&& (bs.segments[j].getPosition() == bottom)
&& (tXL == bsXR)))) {
if (((bsYR <= tYL)) && (tYL <= bsYL)) {
return true;
}
}
}
} else {
if (bsNum == 0) {
if (((thisNum < 0) && (thisDenom < 0))
|| ((thisNum > 0) && (thisDenom > 0))) {
//the segment i of this has a positiv slope
if ((!((bs.segments[j].getPosition() == bottom)
&& (segments[i].getPosition() == top)
&& (bsXL == tXR)))
&& (!((bs.segments[j].getPosition() == top)
&& (segments[i].getPosition() == bottom)
&& (bsXR == tXL)))) {
if ((tYL <= bsYL) && (bsYL <= tYR)) {
return true;
}
}
} else {
if ((!((bs.segments[j].getPosition() == bottom)
&& (segments[i].getPosition() == top)
&& (bsXR == tXL)))
&& (!((bs.segments[j].getPosition() == top)
&& (segments[i].getPosition() == bottom)
&& (bsXL == tXR)))) {
if ((tYR <= bsYL) && (bsYL <= tYL)) {
return true;
}
}
}
} else {
//both segments are not horizontal
long long tyMin, tyMax, bsyMin, bsyMax;
if (((thisNum > 0) && ( thisDenom >0))
|| (( thisNum < 0)&&( thisDenom <0))){
//this has a positive slope
tyMin = ((thisNum * gridX)
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
tyMax = ((thisNum * (gridX+1))
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
} else {
//this has a negative slope
tyMin = ((thisNum * (gridX+1))
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
tyMax = ((thisNum * gridX)
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
}
if ((( bsNum >0)&&( thisDenom >0))
|| (( thisNum <0)&&( thisDenom <0))){
//this has a positive slope
bsyMin = ((thisNum * gridX)
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
bsyMax = ((thisNum * (gridX+1))
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
} else {
//this has a negative slope
bsyMin = ((thisNum * (gridX+1))
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
bsyMax = ((thisNum * gridX)
+ (tYL * thisDenom)
- (tXL * thisNum)) / thisDenom;
}
if (!(( tyMax < bsyMin)||( bsyMax < tyMin ))){
return true;
}
}
}
}
}
}
}
j++;
}
i++;
}
return result;
}
/*
1 Class Event
*/
/*
1.1 Constructors and destructor
*/
Event::Event(KindOfEvent k, AVLSegment* s) :
kind(k), gridX(k == leftEndpoint ? s->getGridXL() : s->getGridXR()), gridY(
k == leftEndpoint ? s->getGridYL() : s->getGridYR()), preciseX(
k == leftEndpoint ? s->getPreciseXL() : s->getPreciseXR()), preciseY(
k == leftEndpoint ? s->getPreciseYL() : s->getPreciseYR()),
seg(s), lSeg(0), gSeg(0), noOfChangesSeg(s->getNumberOfChanges()) {
}
Event::Event(KindOfEvent k, AVLSegment* s1, AVLSegment* s2) :
kind(k), gridX(s1->getGridXR()), gridY(s1->getGridYR()), preciseX(
s1->getPreciseXR()), preciseY(s1->getPreciseYR()),
seg(NULL), lSeg(s1), gSeg(s2),
noOfChangesSeg((s1->getNumberOfChanges() + s2->getNumberOfChanges())) {
}
Event::Event(KindOfEvent k, AVLSegment* s1, AVLSegment* s2, AVLSegment* s3) :
kind(k), gridX(s3->getGridXL()), gridY(s3->getGridYL()), preciseX(
s3->getPreciseXL()), preciseY(s3->getPreciseYL()),
seg(NULL), lSeg(s1), gSeg(s2),
noOfChangesSeg((s1->getNumberOfChanges() + s2->getNumberOfChanges())) {
}
Event::Event(const Event& e) :
kind(e.kind), gridX(e.gridX), gridY(e.gridY), preciseX(e.preciseX), preciseY(
e.preciseY), seg(e.seg), lSeg(e.lSeg), gSeg(e.gSeg), noOfChangesSeg(
e.getNoOfChanges()) {
}
Event::~Event() {
}
/*
1.1 ~getGridX~
*/
int Event::getGridX() const {
return gridX;
}
/*
1.1 ~getPreciseX~
*/
mpq_class Event::getPreciseX() const {
return preciseX;
}
/*
1.1 ~getGridY~
*/
int Event::getGridY() const {
return gridY;
}
/*
1.1 ~getPreciseX~
*/
mpq_class Event::getPreciseY() const {
return preciseY;
}
/*
1.1 ~getNoOfChanges~
*/
int Event::getNoOfChanges() const {
return noOfChangesSeg;
}
/*
1.1 ~=~
*/
Event& Event::operator=(const Event& e) {
kind = e.kind;
gridX = e.gridX;
gridY = e.gridY;
preciseX = e.preciseX;
preciseY = e.preciseY;
if (kind == intersectionPoint) {
seg = 0;
lSeg = e.lSeg;
gSeg = e.gSeg;
} else {
seg = e.seg;
lSeg = 0;
gSeg = 0;
}
noOfChangesSeg = e.noOfChangesSeg;
return *this;
}
/*
1.1 ~isValid~
An Event becomes invalid, if the associated segment(s) have been
changed between the time where the event is put in the
priority\_queue and the time where it has to be processed.
*/
bool Event::isValid() const {
if (this->isIntersectionEvent()) {
if (lSeg->isValid() && gSeg->isValid()) {
return true;
} else {
return false;
}
}
if (seg->isValid()) {
if (this->isRightEndpointEvent()) {
if (seg->getNumberOfChanges() == noOfChangesSeg) {
return true;
} else {
return false;
}
} else {
return true;
}
} else {
return false;
}
}
/*
1.1 ~isLeftEndpointEvent~
*/
bool Event::isLeftEndpointEvent() const {
return (kind == leftEndpoint);
}
/*
1.1 ~isRightEndpointEvent~
*/
bool Event::isRightEndpointEvent() const {
return (kind == rightEndpoint);
}
/*
1.1 ~isIntersectionEvent~
*/
bool Event::isIntersectionEvent() const {
if (kind == intersectionPoint) {
return true;
}
return false;
}
/*
1.1 ~getSegment~
*/
AVLSegment* Event::getSegment() const {
return seg;
}
/*
1.1 ~getLeftSegment~
*/
AVLSegment* Event::getLeftSegment() const {
return lSeg;
}
/*
1.1 ~getRightSegment~
*/
AVLSegment* Event::getRightSegment() const {
return gSeg;
}
/*
1.1 ~$>$~
*/
bool Event::operator>(const Event& e) const {
if (getGridX() != e.getGridX()) {
if (getGridX() > e.getGridX()) {
return true;
} else {
return false;
}
}
int cmpX = cmp(getPreciseX(), e.getPreciseX());
if (cmpX != 0) {
if (cmpX > 0) {
return true;
} else {
return false;
}
}
//equal x
if (getGridY() != e.getGridY()) {
if (getGridY() > e.getGridY()) {
return true;
} else {
return false;
}
}
int cmpY = cmp(getPreciseY(), e.getPreciseY());
if (cmpY != 0) {
if (cmpY > 0) {
return true;
} else {
return false;
}
}
//equal y
if (isRightEndpointEvent()) {
if (e.isRightEndpointEvent()) {
mpq_class p = getPreciseX();
return (seg->compareInPosOrLeft(*e.seg, getGridX(), p)) == 1;
} else {
return true;
}
}
if (isIntersectionEvent() && e.isLeftEndpointEvent()) {
return true;
}
if (isIntersectionEvent() && e.isIntersectionEvent()) {
mpq_class p = getPreciseX();
int cmpLSeg = lSeg->compareInPosOrLeft(*e.lSeg, getGridX(), p);
if (cmpLSeg != 0) {
if (cmpLSeg > 0) {
return true;
} else {
return false;
}
} else {
int cmpGSeg = gSeg->compareInPosOrLeft(*e.gSeg, getGridX(), p);
if (cmpGSeg > 0) {
return true;
} else {
return false;
}
}
}
if (isLeftEndpointEvent() && e.isLeftEndpointEvent()) {
mpq_class p = getPreciseX();
return (seg->compareInPosOrLeft(*e.seg, getGridX(), p)) == 1;
} else {
return false;
}
assert(false);
return false;
}
void Event::print() const {
if (!isValid()) {
cout << "invalid ";
}
switch (kind) {
case 0:
cout << "leftendpoint-event in (" << getGridX() << " " << getPreciseX()
<< ", " << getGridY() << " " << getPreciseY() << ")" << endl;
cout << "with segment: " << endl;
seg->print();
break;
case 1:
cout << "rightendpoint-event in (" << getGridX() << " " << getPreciseX()
<< ", " << getGridY() << " " << getPreciseY() << ")" << endl;
cout << "with segment: " << endl;
seg->print();
break;
case 2:
cout << "intersection-event in (" << getGridX() << " " << getPreciseX()
<< ", " << getGridY() << " " << getPreciseY() << ")" << endl;
cout << "with segments: " << endl;
lSeg->print();
gSeg->print();
break;
default:
assert(false);
}
}
/*
1 ~selectNext~
*/
template<class C1, class C2>
Owner selectNext(const C1& l1, int& pos1, const C2& l2, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event) {
Coordinate* values[3];
SegmentData* sd1 = new SegmentData();
SegmentData* sd2 = new SegmentData();
Event e1, e2;
Coordinate c0, c1, c2;
bool found = false;
int number = 0; // number of available values
while (pos1 < l1.Size() && !found) {
l1.get(pos1, *sd1);
if (sd1->IsLeftDomPoint()) {
c0.gx = l1.getLeftGridX(pos1);
c0.px = l1.getPreciseLeftX(pos1);
c0.gy = l1.getLeftGridY(pos1);
c0.py = l1.getPreciseLeftY(pos1);
values[0] = &c0;
number++;
found = true;
}
pos1++;
}
if (!found) {
values[0] = 0;
}
found = false;
while (pos2 < l2.Size() && !found) {
l2.get(pos2, *sd2);
if (sd2->IsLeftDomPoint()) {
c1.gx = l2.getLeftGridX(pos2);
c1.px = l2.getPreciseLeftX(pos2);
c1.gy = l2.getLeftGridY(pos2);
c1.py = l2.getPreciseLeftY(pos2);
values[1] = &c1;
number++;
found = true;
}
pos2++;
}
if (!found) {
values[1] = 0;
}
if (q.empty()) {
values[2] = 0;
} else {
e1 = q.top();
while (!e1.isValid()) {
q.pop();
e1 = q.top();
}
c2.gx = e1.getGridX();
c2.px = e1.getPreciseX();
c2.gy = e1.getGridY();
c2.py = e1.getPreciseY();
values[2] = &c2;
number++;
}
if (number == 0) {
// no halfsegments found
return none;
}
// search for the minimum.
int index = -1;
for (int i = 0; i < 3; i++) {
if (values[i]) {
if (index < 0 || (*values[index] > *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(l1.getPreciseCoordinates(), sd1, first);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
delete result1;
return first;
}
case 1: {
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(l2.getPreciseCoordinates(), sd2, second);
Event* result2 = new Event(leftEndpoint, seg2);
event = *result2;
delete result2;
return second;
}
case 2: {
if (values[0] != 0) {
pos1--;
}
if (values[1] != 0) {
pos2--;
}
if (q.empty()) {
} else {
q.pop();
}
event = e1;
if (e1.isIntersectionEvent()) {
return both;
} else {
return e1.getSegment()->getOwner();
}
}
default:
assert(false);
}
return none;
}
Owner selectNext(const Line2& l, int& pos1, const Line2& r, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event) {
return selectNext<Line2, Line2>(l, pos1, r, pos2, q, event);
}
template<class C1, class C2>
Owner selectNext(const C1& l1, int& pos1, const C2& l2, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event,
mpq_class& internalScalefactor) {
Coordinate* values[3];
SegmentData* sd1 = new SegmentData();
SegmentData* sd2 = new SegmentData();
Event e1, e2;
Coordinate c0, c1, c2;
bool found = false;
int number = 0; // number of available values
while (pos1 < l1.Size() && !found) {
l1.get(pos1, *sd1);
if (sd1->IsLeftDomPoint()) {
prepareData(c0.gx, c0.px,
((l1.getLeftGridX(pos1)+l1.getPreciseLeftX(pos1))*internalScalefactor));
prepareData(c0.gy, c0.py,
((l1.getLeftGridY(pos1)+l1.getPreciseLeftY(pos1))*internalScalefactor));
values[0] = &c0;
number++;
found = true;
}
pos1++;
}
if (!found) {
values[0] = 0;
}
found = false;
while (pos2 < l2.Size() && !found) {
l2.get(pos2, *sd2);
if (sd2->IsLeftDomPoint()) {
prepareData(c1.gx, c1.px,
((l2.getLeftGridX(pos2)+l2.getPreciseLeftX(pos2))*internalScalefactor));
prepareData(c1.gy, c1.py,
((l2.getLeftGridY(pos2)+l2.getPreciseLeftY(pos2))*internalScalefactor));
values[1] = &c1;
number++;
found = true;
}
pos2++;
}
if (!found) {
values[1] = 0;
}
if (q.empty()) {
values[2] = 0;
} else {
e1 = q.top();
while (!e1.isValid()) {
q.pop();
e1 = q.top();
}
prepareData(c2.gx, c2.px,
(e1.getGridX()+e1.getPreciseX()));
prepareData(c2.gy, c2.py,
(e1.getGridY()+e1.getPreciseY()));
values[2] = &c2;
number++;
}
if (number == 0) {
// no halfsegments found
return none;
}
// search for the minimum.
int index = -1;
for (int i = 0; i < 3; i++) {
if (values[i]) {
if (index < 0 || (*values[index] > *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(l1.getPreciseCoordinates(), sd1,
first, internalScalefactor);
//AVLSegment* seg1 = new AVLSegment(l1.getPreciseCoordinates(), sd1, first);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
delete result1;
return first;
}
case 1: {
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(l2.getPreciseCoordinates(), sd2,
second, internalScalefactor);
//AVLSegment* seg2 = new AVLSegment(l2.getPreciseCoordinates(), sd2, second);
Event* result2 = new Event(leftEndpoint, seg2);
event = *result2;
delete result2;
return second;
}
case 2: {
if (values[0] != 0) {
pos1--;
}
if (values[1] != 0) {
pos2--;
}
if (q.empty()) {
} else {
q.pop();
}
event = e1;
if (e1.isIntersectionEvent()) {
return both;
} else {
return e1.getSegment()->getOwner();
}
}
default:
assert(false);
}
return none;
}
Owner selectNext(const Line2& l, int& pos1, const Line2& r, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event,
mpq_class& internalScalefactor) {
return selectNext<Line2, Line2>(l, pos1, r, pos2, q, event,
internalScalefactor);
}
Owner selectNext(/*const*/Region2& r1, int& pos1,
/*const*/Region2& r2, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event) {
Coordinate* values[3];
Reg2GridHalfSegment gs1;
Reg2GridHalfSegment gs2;
Reg2PrecHalfSegment ps1;
Reg2PrecHalfSegment ps2;
Event e1, e2;
Coordinate c0, c1, c2;
bool found = false;
int number = 0; // number of available values
while (pos1 < r1.Size() && !found) {
r1.getgridCoordinates()->Get(pos1, gs1);
r1.getprecCoordinates()->Get(pos1, ps1);
if (gs1.IsLeftDomPoint()) {
c0.gx = gs1.GetLeftPointX();
c0.px = ps1.GetlPointx(r1.getpreciseCoordinates());
c0.gy = gs1.GetLeftPointY();
c0.py = ps1.GetlPointy(r1.getpreciseCoordinates());
values[0] = &c0;
number++;
found = true;
}
pos1++;
}
if (!found) {
values[0] = 0;
}
found = false;
while (pos2 < r2.Size() && !found) {
r2.getgridCoordinates()->Get(pos2, gs2);
r2.getprecCoordinates()->Get(pos2, ps2);
if (gs2.IsLeftDomPoint()) {
c1.gx = gs2.GetLeftPointX();
c1.px = ps2.GetlPointx(r2.getpreciseCoordinates());
c1.gy = gs2.GetLeftPointY();
c1.py = ps2.GetlPointy(r2.getpreciseCoordinates());
values[1] = &c1;
number++;
found = true;
}
pos2++;
}
if (!found) {
values[1] = 0;
}
if (q.empty()) {
values[2] = 0;
} else {
e1 = q.top();
while (!e1.isValid()) {
q.pop();
e1 = q.top();
}
c2.gx = e1.getGridX();
c2.px = e1.getPreciseX();
c2.gy = e1.getGridY();
c2.py = e1.getPreciseY();
values[2] = &c2;
number++;
}
if (number == 0) {
// no halfsegments found
return none;
}
// search for the minimum.
int index = -1;
for (int i = 0; i < 3; i++) {
if (values[i]) {
if (index < 0 || (*values[index] > *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(r1.getpreciseCoordinates(), gs1,
new Reg2PrecHalfSegment(ps1), first);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
delete result1;
return first;
}
case 1: {
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(r2.getpreciseCoordinates(), gs2,
new Reg2PrecHalfSegment(ps2), second);
Event* result2 = new Event(leftEndpoint, seg2);
event = *result2;
delete result2;
return second;
}
case 2: {
if (values[0] != 0) {
pos1--;
}
if (values[1] != 0) {
pos2--;
}
if (q.empty()) {
} else {
q.pop();
}
event = e1;
if (e1.isIntersectionEvent()) {
return both;
} else {
return e1.getSegment()->getOwner();
}
}
default:
assert(false);
}
return none;
}
Owner selectNext(/*const*/Region2& r1, int& pos1,
/*const*/Region2& r2, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event,
mpq_class& internalScalefactor) {
Coordinate* values[3];
Reg2GridHalfSegment gs1;
Reg2GridHalfSegment gs2;
Reg2PrecHalfSegment ps1;
Reg2PrecHalfSegment ps2;
Event e1, e2;
Coordinate c0, c1, c2;
bool found = false;
int number = 0; // number of available values
while (pos1 < r1.Size() && !found) {
r1.getgridCoordinates()->Get(pos1, gs1);
r1.getprecCoordinates()->Get(pos1, ps1);
if (gs1.IsLeftDomPoint()) {
//c0.gx = gs1.GetLeftPointX();
//c0.px = ps1.GetlPointx(r1.getpreciseCoordinates());
//c0.gy = gs1.GetLeftPointY();
//c0.py = ps1.GetlPointy(r1.getpreciseCoordinates());
prepareData(c0.gx, c0.px,
((gs1.GetLeftPointX()
+ps1.GetlPointx(r1.getpreciseCoordinates()))*internalScalefactor));
prepareData(c0.gy, c0.py,
((gs1.GetLeftPointY()
+ps1.GetlPointy(r1.getpreciseCoordinates()))*internalScalefactor));
values[0] = &c0;
number++;
found = true;
}
pos1++;
}
if (!found) {
values[0] = 0;
}
found = false;
while (pos2 < r2.Size() && !found) {
r2.getgridCoordinates()->Get(pos2, gs2);
r2.getprecCoordinates()->Get(pos2, ps2);
if (gs2.IsLeftDomPoint()) {
//c1.gx = gs2.GetLeftPointX();
//c1.px = ps2.GetlPointx(r2.getpreciseCoordinates());
//c1.gy = gs2.GetLeftPointY();
//c1.py = ps2.GetlPointy(r2.getpreciseCoordinates());
prepareData(c1.gx, c1.px,
((gs2.GetLeftPointX()
+ps2.GetlPointx(r2.getpreciseCoordinates()))*internalScalefactor));
prepareData(c1.gy, c1.py,
((gs2.GetLeftPointY()
+ps2.GetlPointy(r2.getpreciseCoordinates()))*internalScalefactor));
values[1] = &c1;
number++;
found = true;
}
pos2++;
}
if (!found) {
values[1] = 0;
}
if (q.empty()) {
values[2] = 0;
} else {
e1 = q.top();
while (!e1.isValid()) {
q.pop();
e1 = q.top();
}
//c2.gx = e1.getGridX();
//c2.px = e1.getPreciseX();
//c2.gy = e1.getGridY();
//c2.py = e1.getPreciseY();
prepareData(c2.gx, c2.px,
(e1.getGridX()+e1.getPreciseX()));
prepareData(c2.gy, c2.py,
(e1.getGridY()+e1.getPreciseY()));
values[2] = &c2;
number++;
}
if (number == 0) {
// no halfsegments found
return none;
}
// search for the minimum.
int index = -1;
for (int i = 0; i < 3; i++) {
if (values[i]) {
if (index < 0 || (*values[index] > *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(r1.getpreciseCoordinates(), gs1,
ps1, first, internalScalefactor);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
delete result1;
return first;
}
case 1: {
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(r2.getpreciseCoordinates(), gs2,
ps2, second, internalScalefactor);
Event* result2 = new Event(leftEndpoint, seg2);
event = *result2;
delete result2;
return second;
}
case 2: {
if (values[0] != 0) {
pos1--;
}
if (values[1] != 0) {
pos2--;
}
if (q.empty()) {
} else {
q.pop();
}
event = e1;
if (e1.isIntersectionEvent()) {
return both;
} else {
return e1.getSegment()->getOwner();
}
}
default:
assert(false);
}
return none;
}
Owner selectNext(const Line2& l, int& pos,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event) {
return selectNext<Line2>(l, pos, q, event);
}
template<class C>
Owner selectNext(const C& l, int& pos,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event) {
Coordinate* values[2];
Event e1;
Coordinate c0, c1;
SegmentData* sd1 = new SegmentData();
int number = 0; // number of available values
bool found = false;
values[0] = 0;
while (pos < l.Size() && !found) {
l.get(pos, *sd1);
if (sd1->IsLeftDomPoint()) {
c0.gx = l.getLeftGridX(pos);
c0.px = l.getPreciseLeftX(pos);
c0.gy = l.getLeftGridY(pos);
c0.py = l.getPreciseLeftY(pos);
values[0] = &c0;
number++;
found = true;
}
pos++;
}
if (q.empty()) {
values[1] = 0;
} else {
e1 = q.top();
c1.gx = e1.getGridX();
c1.px = e1.getPreciseX();
c1.gy = e1.getGridY();
c1.py = e1.getPreciseY();
values[1] = &c1;
number++;
}
if (number == 0) {
// no halfsegments found
return none;
}
// search for the minimum.
int index = -1;
for (int i = 0; i < 2; i++) {
if (values[i]) {
if (index < 0 || (*values[index] > *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
AVLSegment* result = new AVLSegment(l.getPreciseCoordinates(), sd1, first);
Event* res = new Event(leftEndpoint, result);
event = *res;
delete res;
return first;
}
case 1: {
pos--;
q.pop();
event = e1;
return first;
}
default: {
assert(false);
}
}
return none;
}
/*
1 ~mergeNeighbors~
*/
bool mergeNeighbors(AVLSegment* current, AVLSegment* neighbor) {
current->changeValidity(false);
if (neighbor->getGridXR() > current->getGridXR()
|| (neighbor->getGridXR() == current->getGridXR()
&& cmp(neighbor->getPreciseXR(), current->getPreciseXR()) > 0)
|| ((neighbor->getGridXR() == current->getGridXR())
&& (cmp(neighbor->getPreciseXR(), current->getPreciseXR()) == 0)
&& (neighbor->getGridYR() > current->getGridYR()))
|| ((neighbor->getGridXR() == current->getGridXR()
&& cmp(neighbor->getPreciseXR(), current->getPreciseXR()) == 0)
&& ((neighbor->getGridYR() == current->getGridYR())
&& cmp(neighbor->getPreciseYR(), current->getPreciseYR()) > 0))) {
//neighbor is longer -> nothing to do
return false;
} else {
AVLSegment* newNeighbor = new AVLSegment(neighbor->getGridXL(),
neighbor->getGridYL(), current->getGridXR(), current->getGridYR(),
neighbor->getPreciseXL(), neighbor->getPreciseYL(),
current->getPreciseXR(),
current->getPreciseYR(), neighbor->getOwner());
newNeighbor->setNumberOfChanges(neighbor->getNumberOfChanges() + 1);
*neighbor = *newNeighbor;
delete newNeighbor;
return true;
}
}
/*
1 ~splitNeighbors~
*/
void splitNeighbors(AVLSegment* current, AVLSegment* neighbor,
AVLSegment* overlappingSegment, AVLSegment* right) {
//r starts at the end of overlappingSegment. If neighbor is longer
//than current, r ends in the right endpoint of neighbor
AVLSegment* r;
if (neighbor->getGridXR() > current->getGridXR()
|| (neighbor->getGridXR() == current->getGridXR()
&& cmp(neighbor->getPreciseXR(), current->getPreciseXR()) > 0)
|| ((neighbor->getGridXR() == current->getGridXR())
&& (cmp(neighbor->getPreciseXR(), current->getPreciseXR()) == 0)
&& (neighbor->getGridYR() > current->getGridYR()))
|| ((neighbor->getGridXR() == current->getGridXR()
&& cmp(neighbor->getPreciseXR(), current->getPreciseXR()) == 0)
&& ((neighbor->getGridYR() == current->getGridYR())
&& cmp(neighbor->getPreciseYR(), current->getPreciseYR()) > 0))) {
//neighbor is longer
r = new AVLSegment(overlappingSegment->getGridXR(),
overlappingSegment->getGridYR(), neighbor->getGridXR(),
neighbor->getGridYR(), overlappingSegment->getPreciseXR(),
overlappingSegment->getPreciseYR(), neighbor->getPreciseXR(),
neighbor->getPreciseYR(), neighbor->getOwner());
r->setConAbove(neighbor->getConAbove());
r->setConBelow(neighbor->getConBelow());
r->setFirstInsideAbove(neighbor->getFirstInsideAbove());
r->setSecondInsideAbove(neighbor->getSecondInsideAbove());
} else {
r = new AVLSegment(overlappingSegment->getGridXR(),
overlappingSegment->getGridYR(), current->getGridXR(), current->getGridYR(),
overlappingSegment->getPreciseXR(), overlappingSegment->getPreciseYR(),
current->getPreciseXR(), current->getPreciseYR(), current->getOwner());
r->setConAbove(current->getConAbove());
r->setConBelow(current->getConBelow());
r->setFirstInsideAbove(current->getFirstInsideAbove());
r->setSecondInsideAbove(current->getSecondInsideAbove());
}
*right = *r;
delete r;
if (overlappingSegment->hasEqualLeftEndpointAs(*neighbor)) {
// the overlapping part starts at the left endpoint
// of ~neighbor~. ~neighbor~ is truncated to the
// length of the overlapping part and ~current~ is
// set to invalid, and will be removed later.
current->changeValidity(false);
AVLSegment newNeighbor(overlappingSegment->getGridXL(),
overlappingSegment->getGridYL(), overlappingSegment->getGridXR(),
overlappingSegment->getGridYR(), overlappingSegment->getPreciseXL(),
overlappingSegment->getPreciseYL(), overlappingSegment->getPreciseXR(),
overlappingSegment->getPreciseYR(), both);
if (neighbor->getOwner() == first) {
newNeighbor.setFirstInsideAbove(neighbor->getFirstInsideAbove());
newNeighbor.setSecondInsideAbove(current->getSecondInsideAbove());
newNeighbor.setConAbove(
neighbor->getFirstInsideAbove() + current->getSecondInsideAbove());
newNeighbor.setConBelow(
(!neighbor->getFirstInsideAbove()) + (!current->getSecondInsideAbove()));
} else {
newNeighbor.setFirstInsideAbove(current->getFirstInsideAbove());
newNeighbor.setSecondInsideAbove(neighbor->getSecondInsideAbove());
newNeighbor.setConAbove(
neighbor->getSecondInsideAbove() + current->getFirstInsideAbove());
newNeighbor.setConBelow(
(!neighbor->getSecondInsideAbove()) + (!current->getFirstInsideAbove()));
}
newNeighbor.setNumberOfChanges(neighbor->getNumberOfChanges() + 1);
*neighbor = newNeighbor;
} else {
AVLSegment newCurrent(overlappingSegment->getGridXL(),
overlappingSegment->getGridYL(), overlappingSegment->getGridXR(),
overlappingSegment->getGridYR(), overlappingSegment->getPreciseXL(),
overlappingSegment->getPreciseYL(), overlappingSegment->getPreciseXR(),
overlappingSegment->getPreciseYR(), both);
if (neighbor->getOwner() == first) {
newCurrent.setFirstInsideAbove(neighbor->getFirstInsideAbove());
newCurrent.setSecondInsideAbove(current->getSecondInsideAbove());
newCurrent.setConAbove(
neighbor->getFirstInsideAbove() + current->getSecondInsideAbove());
newCurrent.setConBelow(
(!neighbor->getFirstInsideAbove()) + (!current->getSecondInsideAbove()));
} else {
newCurrent.setFirstInsideAbove(current->getFirstInsideAbove());
newCurrent.setSecondInsideAbove(neighbor->getSecondInsideAbove());
newCurrent.setConAbove(
neighbor->getSecondInsideAbove() + current->getFirstInsideAbove());
newCurrent.setConBelow(
(!neighbor->getSecondInsideAbove()) + (!current->getFirstInsideAbove()));
}
*current = newCurrent;
AVLSegment newNeighbor(neighbor->getGridXL(), neighbor->getGridYL(),
overlappingSegment->getGridXL(), overlappingSegment->getGridYL(),
neighbor->getPreciseXL(), neighbor->getPreciseYL(),
overlappingSegment->getPreciseXL(), overlappingSegment->getPreciseYL(),
neighbor->getOwner());
newNeighbor.setConAbove(neighbor->getConAbove());
newNeighbor.setConBelow(neighbor->getConBelow());
if (neighbor->getOwner() == first) {
newNeighbor.setFirstInsideAbove(neighbor->getFirstInsideAbove());
newNeighbor.setSecondInsideAbove(current->getSecondInsideAbove());
} else {
newNeighbor.setFirstInsideAbove(current->getFirstInsideAbove());
newNeighbor.setSecondInsideAbove(neighbor->getSecondInsideAbove());
}
newNeighbor.setNumberOfChanges(neighbor->getNumberOfChanges() + 1);
*neighbor = newNeighbor;
}
}
/*
1 ~intersectionTestForRealminize~
*/
void intersectionTestForRealminize(AVLSegment* left, AVLSegment* right,
Event event, priority_queue<Event, vector<Event>, greater<Event> >& q,
bool leftIsSmaller) {
if (left->mightIntersect(*right)) {
AVLSegment* overlappingSegment = new AVLSegment();
if (left->intersect(*right, *overlappingSegment)) {
if (p2d_debug) {
cout << "s1: ";
left->print();
cout << "s2: ";
right->print();
cout << "Schnittpunkt :";
overlappingSegment->print();
}
if (overlappingSegment->isPoint()) {
if (!overlappingSegment->isLeftOf(event)
/*&& (!(overlappingSegment->isLeftPointOf(*left)
&& overlappingSegment->isRightPointOf(*right)))*/) {
if (leftIsSmaller) {
Event ie(intersectionPoint, left, right, overlappingSegment);
q.push(ie);
} else {
Event ie(intersectionPoint, right, left, overlappingSegment);
q.push(ie);
}
}
} else {
bool newNeighbor = mergeNeighbors(left, right);
if (newNeighbor) {
Event e(rightEndpoint, right);
q.push(e);
}
}
}
delete overlappingSegment;
}
}
/*
1 ~intersectionTestForSetOp~
*/
bool intersectionTestForSetOp(AVLSegment* s1, AVLSegment* s2, Event& event,
priority_queue<Event, vector<Event>, greater<Event> >& q,
bool leftIsSmaller) {
if (s1->mightIntersect(*s2)) {
AVLSegment* overlappingSegment = new AVLSegment();
if (s1->intersect(*s2, *overlappingSegment)) {
if (p2d_debug) {
cout << endl << endl << "s1: ";
s1->print();
cout << "s2: ";
s2->print();
cout << "Schnittpunkt :";
overlappingSegment->print();
cout << endl << endl;
}
if (overlappingSegment->isPoint()) {
if (!overlappingSegment->isLeftOf(event)) {
if (leftIsSmaller) {
Event ie(intersectionPoint, s1, s2, overlappingSegment);
q.push(ie);
} else {
Event ie(intersectionPoint, s2, s1, overlappingSegment);
q.push(ie);
}
}
} else {
AVLSegment* right = new AVLSegment();
splitNeighbors(s1, s2, overlappingSegment, right);
if (s1->getOwner() == both) {
Event e1(rightEndpoint, s1);
q.push(e1);
}
if (leftIsSmaller) {
Event ie2(intersectionPoint, s1, s2, overlappingSegment);
q.push(ie2);
} else {
Event ie2(intersectionPoint, s2, s1, overlappingSegment);
q.push(ie2);
}
Event e2(rightEndpoint, s2);
q.push(e2);
if (!right->isPoint()) {
Event e3(leftEndpoint, right);
q.push(e3);
} else {
delete right;
}
}
delete overlappingSegment;
return true;
}
delete overlappingSegment;
}
return false;
}
/*
1 ~collectSegmentsForInverting~
*/
void collectSegmentsForInverting(vector<AVLSegment*>& segmentVector,
Event& event, priority_queue<Event, vector<Event>, greater<Event> >& q,
size_t& predIndex, size_t& sucIndex, bool& inversionNecessary) {
mpq_class v = event.getPreciseX();
AVLSegment* seg = event.getLeftSegment();
AVLSegment* r = event.getRightSegment();
segmentVector.push_back(seg);
Event e = q.top();
while (e.isIntersectionEvent() && e.getGridX() == event.getGridX()
&& e.getGridY() == event.getGridY()
&& cmp(e.getPreciseX(), event.getPreciseX()) == 0
&& cmp(e.getPreciseY(), event.getPreciseY()) == 0) {
if (e.isValid()) {
if (seg->compareInPosOrLeft(*(e.getLeftSegment()), event.getGridX(), v)
< 0) {
if (segmentVector.back()->isParallelTo(*e.getLeftSegment())) {
if (segmentVector.size() == 1) {
predIndex = 1;
}
segmentVector.pop_back();
if ((segmentVector.size() == 0)
|| (segmentVector.size() > 0
&& !(segmentVector.back()->equal(*e.getLeftSegment())))) {
segmentVector.push_back(e.getLeftSegment());
}
segmentVector.push_back(seg);
r = e.getRightSegment();
} else {
inversionNecessary = true;
seg = e.getLeftSegment();
r = e.getRightSegment();
segmentVector.push_back(seg);
}
}
}
q.pop();
e = q.top();
}
if (segmentVector.back()->compareInPosOrLeft(*r, event.getGridX(), v) < 0) {
if (segmentVector.back()->isParallelTo(*r)) {
segmentVector.pop_back();
segmentVector.push_back(r);
segmentVector.push_back(seg);
sucIndex = segmentVector.size() - 2;
} else {
inversionNecessary = true;
segmentVector.push_back(r);
sucIndex = segmentVector.size() - 1;
}
}
}
/*
1 ~createNewSegments~
*/
void createNewSegments(AVLSegment& s, Line2& result, int& edgeno,
SetOperation op) {
switch (op) {
case union_op: {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
s.print();
}
result.addSegment(true, s.getGridXL(), s.getGridYL(), s.getGridXR(),
s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
s.getPreciseYR(), edgeno);
result.addSegment(false, s.getGridXL(), s.getGridYL(), s.getGridXR(),
s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
s.getPreciseYR(), edgeno);
edgeno++;
break;
}
case intersection_op: {
if (s.getOwner() == both) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
s.print();
}
result.addSegment(true, s.getGridXL(), s.getGridYL(), s.getGridXR(),
s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
s.getPreciseYR(), edgeno);
result.addSegment(false, s.getGridXL(), s.getGridYL(), s.getGridXR(),
s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
s.getPreciseYR(), edgeno);
edgeno++;
}
break;
}
case difference_op: {
if (s.getOwner() == first) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
s.print();
}
result.addSegment(true, s.getGridXL(), s.getGridYL(), s.getGridXR(),
s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
s.getPreciseYR(), edgeno);
result.addSegment(false, s.getGridXL(), s.getGridYL(), s.getGridXR(),
s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
s.getPreciseYR(), edgeno);
edgeno++;
}
break;
}
default: {
assert(false);
}
}
}
void createNewSegments(AVLSegment& s, Line2& result, int& edgeno,
SetOperation op, mpq_class& internalScalefactor) {
switch (op) {
case union_op: {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
s.print();
}
int gxl, gyl, gxr, gyr;
mpq_class pxl, pyl, pxr, pyr;
p2d::prepareData(gxl, pxl,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(gyl, pyl,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
p2d::prepareData(gxr, pxr,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(gyr, pyr,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
result.addSegment(true, gxl, gyl, gxr, gyr, pxl, pyl, pxr, pyr, edgeno);
result.addSegment(false, gxl, gyl, gxr, gyr, pxl, pyl, pxr, pyr, edgeno);
//result.addSegment(true, s.getGridXL(), s.getGridYL(), s.getGridXR(),
// s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
// s.getPreciseYR(), edgeno);
//result.addSegment(false, s.getGridXL(), s.getGridYL(), s.getGridXR(),
// s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
// s.getPreciseYR(), edgeno);
edgeno++;
break;
}
case intersection_op: {
if (s.getOwner() == both) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
s.print();
}
int gxl, gyl, gxr, gyr;
mpq_class pxl, pyl, pxr, pyr;
p2d::prepareData(gxl, pxl,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(gyl, pyl,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
p2d::prepareData(gxr, pxr,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(gyr, pyr,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
result.addSegment(true, gxl, gyl, gxr, gyr, pxl, pyl, pxr, pyr, edgeno);
result.addSegment(false, gxl, gyl, gxr, gyr, pxl, pyl, pxr, pyr, edgeno);
//result.addSegment(true, s.getGridXL(), s.getGridYL(), s.getGridXR(),
// s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
// s.getPreciseYR(), edgeno);
//result.addSegment(false, s.getGridXL(), s.getGridYL(), s.getGridXR(),
// s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
// s.getPreciseYR(), edgeno);
edgeno++;
}
break;
}
case difference_op: {
if (s.getOwner() == first) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
s.print();
}
int gxl, gyl, gxr, gyr;
mpq_class pxl, pyl, pxr, pyr;
p2d::prepareData(gxl, pxl,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(gyl, pyl,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
p2d::prepareData(gxr, pxr,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(gyr, pyr,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
result.addSegment(true, gxl, gyl, gxr, gyr, pxl, pyl, pxr, pyr, edgeno);
result.addSegment(false, gxl, gyl, gxr, gyr, pxl, pyl, pxr, pyr, edgeno);
//result.addSegment(true, s.getGridXL(), s.getGridYL(), s.getGridXR(),
// s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
// s.getPreciseYR(), edgeno);
//result.addSegment(false, s.getGridXL(), s.getGridYL(), s.getGridXR(),
// s.getGridYR(), s.getPreciseXL(), s.getPreciseYL(), s.getPreciseXR(),
// s.getPreciseYR(), edgeno);
edgeno++;
}
break;
}
default: {
assert(false);
}
}
}
/*
1 ~createNewSegments~
*/
void createNewSegments(vector<AVLSegment*>& segmentVector, Event& event,
Line2& result, int& edgeno, SetOperation op) {
for (size_t i = 0; i < segmentVector.size(); i++) {
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
bool isEndpoint = segmentVector.at(i)->isEndpoint(event.getGridX(),
event.getGridY(), px, py);
if (!isEndpoint
&& (op == union_op
|| (op == intersection_op && segmentVector.at(i)->getOwner() == both)
|| (op == difference_op && segmentVector.at(i)->getOwner() == first))) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
cout << segmentVector.at(i)->getGridXL() << " "
<< segmentVector.at(i)->getGridYL() << " " << event.getGridX() << " "
<< event.getGridY() << " " << segmentVector.at(i)->getPreciseXL() << " "
<< segmentVector.at(i)->getPreciseYL() << " " << event.getPreciseX()
<< " " << event.getPreciseY() << endl;
}
result.addSegment(true, segmentVector.at(i)->getGridXL(),
segmentVector.at(i)->getGridYL(), event.getGridX(), event.getGridY(),
segmentVector.at(i)->getPreciseXL(), segmentVector.at(i)->getPreciseYL(),
event.getPreciseX(), event.getPreciseY(), edgeno);
result.addSegment(false, segmentVector.at(i)->getGridXL(),
segmentVector.at(i)->getGridYL(), event.getGridX(), event.getGridY(),
segmentVector.at(i)->getPreciseXL(), segmentVector.at(i)->getPreciseYL(),
event.getPreciseX(), event.getPreciseY(), edgeno);
edgeno++;
AVLSegment* newLeft = new AVLSegment(event.getGridX(), event.getGridY(),
segmentVector.at(i)->getGridXR(), segmentVector.at(i)->getGridYR(),
event.getPreciseX(), event.getPreciseY(),
segmentVector.at(i)->getPreciseXR(), segmentVector.at(i)->getPreciseYR(),
segmentVector.at(i)->getOwner());
*(segmentVector.at(i)) = *newLeft;
}
}
}
/*
1 ~createNewSegments~
*/
void createNewSegments(vector<AVLSegment*>& segmentVector, Event& event,
Line2& result, int& edgeno, SetOperation op, mpq_class& internalScalefactor) {
for (size_t i = 0; i < segmentVector.size(); i++) {
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
bool isEndpoint = segmentVector.at(i)->isEndpoint(event.getGridX(),
event.getGridY(), px, py);
if (!isEndpoint
&& (op == union_op
|| (op == intersection_op && segmentVector.at(i)->getOwner() == both)
|| (op == difference_op && segmentVector.at(i)->getOwner() == first))) {
int gxl, gyl, gxr, gyr;
mpq_class pxl, pyl, pxr, pyr;
p2d::prepareData(gxl, pxl,
((segmentVector.at(i)->getGridXL()+
segmentVector.at(i)->getPreciseXL())/internalScalefactor));
p2d::prepareData(gyl, pyl,
((segmentVector.at(i)->getGridYL()+
segmentVector.at(i)->getPreciseYL())/internalScalefactor));
p2d::prepareData(gxr, pxr,
((event.getGridX()+
event.getPreciseX())/internalScalefactor));
p2d::prepareData(gyr, pyr,
((event.getGridY()+
event.getPreciseY())/internalScalefactor));
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
cout << gxl << " " << gyl << " " << gxr << " " << gyr
<< " " << pxl << " " << pyl << " " << pxr << " " << pyr << endl;
}
result.addSegment(true, gxl, gyl, gxr, gyr,
pxl, pyl, pxr, pyr, edgeno);
result.addSegment(false, gxl, gyl, gxr, gyr,
pxl, pyl, pxr, pyr, edgeno);
//result.addSegment(true, segmentVector.at(i)->getGridXL(),
// segmentVector.at(i)->getGridYL(), event.getGridX(), event.getGridY(),
// segmentVector.at(i)->getPreciseXL(), segmentVector.at(i)->getPreciseYL(),
// event.getPreciseX(), event.getPreciseY(), edgeno);
//result.addSegment(false, segmentVector.at(i)->getGridXL(),
// segmentVector.at(i)->getGridYL(), event.getGridX(), event.getGridY(),
// segmentVector.at(i)->getPreciseXL(), segmentVector.at(i)->getPreciseYL(),
// event.getPreciseX(), event.getPreciseY(), edgeno);
edgeno++;
AVLSegment* newLeft = new AVLSegment(event.getGridX(), event.getGridY(),
segmentVector.at(i)->getGridXR(), segmentVector.at(i)->getGridYR(),
event.getPreciseX(), event.getPreciseY(),
segmentVector.at(i)->getPreciseXR(), segmentVector.at(i)->getPreciseYR(),
segmentVector.at(i)->getOwner());
*(segmentVector.at(i)) = *newLeft;
}
}
}
/*
1 ~createNewSegments~
*/
void createNewSegments(vector<AVLSegment*>& segmentVector, Event& event,
AVLSegment* successor, Region2& result, int& edgeno,
int scalefactor, SetOperation op) {
size_t size = segmentVector.size();
AVLSegment* next = successor;
for (size_t i = 0; i < size; i++) {
AVLSegment* s = segmentVector.at(i);
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
bool startsAtEventpoint = s->startsAtPoint(event.getGridX(), event.getGridY(),
px, py);
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py);
if ((!startsAtEventpoint) && (!endsInEventpoint)) {
switch (op) {
case union_op: {
if ((s->getConAbove() == 0) || (s->getConBelow() == 0)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
s->getGridYL(), scalefactor);
Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
event.getPreciseY(), event.getGridY(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s->getConBelow() == 0);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case intersection_op: {
if (s->getConAbove() == 2 || s->getConBelow() == 2) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
s->getGridYL(), scalefactor);
Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
event.getPreciseY(), event.getGridY(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s->getConAbove() == 2);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case difference_op: {
switch (s->getOwner()) {
case first: {
if (s->getConAbove() + s->getConBelow() == 1) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
s->getGridYL(), scalefactor);
Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
event.getPreciseY(), event.getGridY(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s->getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case second: {
if ((s->getConAbove() == 1 && s->getConBelow() == 2)
|| (s->getConBelow() == 1 && s->getConAbove() == 2)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
s->getGridYL(), scalefactor);
Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
event.getPreciseY(), event.getGridY(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = !(s->getSecondInsideAbove());
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case both: {
if ((s->getConAbove() == 1) && (s->getConBelow() == 1)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
s->getGridYL(), scalefactor);
Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
event.getPreciseY(), event.getGridY(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s->getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
default:
assert(false);
} // switch (s->getOwner)
break;
} // case difference
default:
assert(false);
} //switch(op)
AVLSegment newS(event.getGridX(), event.getGridY(), s->getGridXR(),
s->getGridYR(), event.getPreciseX(), event.getPreciseY(),
s->getPreciseXR(), s->getPreciseYR(), s->getOwner());
newS.setConAbove(s->getConAbove());
newS.setConBelow(s->getConBelow());
newS.setFirstInsideAbove(s->getFirstInsideAbove());
newS.setSecondInsideAbove(s->getSecondInsideAbove());
*s = newS;
} // (!startsAtEventpoint) && (!endsInEventpoint)
if (!endsInEventpoint) {
if (s->getOwner() != both) {
if (!next) {
s->setConAbove(0);
} else {
s->setConAbove(next->getConBelow());
}
if ((s->getOwner() == first)) {
if (s->getFirstInsideAbove()) {
s->setConBelow(s->getConAbove() - 1);
} else {
s->setConBelow(s->getConAbove() + 1);
}
}
if (s->getOwner() == second) {
if (s->getSecondInsideAbove()) {
s->setConBelow(s->getConAbove() - 1);
} else {
s->setConBelow(s->getConAbove() + 1);
}
}
}
next = s;
assert((0 <= s->getConAbove()) && (s->getConAbove() <= 2));
assert((0 <= s->getConBelow()) && (s->getConBelow() <= 2));
}
} //end for
}
/*
1 ~setInsideAbove~
For buildRegion
*/
void setInsideAbove(vector<AVLSegment*>& segmentVector, Event& event,
AVLSegment* successor) {
size_t size = segmentVector.size();
AVLSegment* next = successor;
for (size_t i = 0; i < size; i++) {
AVLSegment* s = segmentVector.at(i);
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py);
if (!endsInEventpoint) {
if (s->getOwner() != both) {
if (!next) {
s->setFirstInsideAbove(false);
} else {
s->setFirstInsideAbove(!next->getFirstInsideAbove());
}
}
next = s;
}
} //end for
} // end setInsideAbove
/*
1 ~createNewSegments~
*/
void createNewSegments(vector<AVLSegment*>& segmentVector, Event& event,
AVLSegment* successor, Region2& result, int& edgeno, int scalefactor,
SetOperation op, mpq_class& internalScalefactor) {
size_t size = segmentVector.size();
AVLSegment* next = successor;
for (size_t i = 0; i < size; i++) {
AVLSegment* s = segmentVector.at(i);
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
bool startsAtEventpoint = s->startsAtPoint(event.getGridX(), event.getGridY(),
px, py);
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py);
if ((!startsAtEventpoint) && (!endsInEventpoint)) {
switch (op) {
case union_op: {
if ((s->getConAbove() == 0) || (s->getConBelow() == 0)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s->getConBelow() == 0);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case intersection_op: {
if (s->getConAbove() == 2 || s->getConBelow() == 2) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s->getConAbove() == 2);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case difference_op: {
switch (s->getOwner()) {
case first: {
if (s->getConAbove() + s->getConBelow() == 1) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s->getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case second: {
if ((s->getConAbove() == 1 && s->getConBelow() == 2)
|| (s->getConBelow() == 1 && s->getConAbove() == 2)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = !(s->getSecondInsideAbove());
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case both: {
if ((s->getConAbove() == 1) && (s->getConBelow() == 1)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s->print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s->getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
default:
assert(false);
} // switch (s->getOwner)
break;
} // case difference
default:
assert(false);
} //switch(op)
AVLSegment newS(event.getGridX(), event.getGridY(), s->getGridXR(),
s->getGridYR(), event.getPreciseX(), event.getPreciseY(),
s->getPreciseXR(), s->getPreciseYR(), s->getOwner());
newS.setConAbove(s->getConAbove());
newS.setConBelow(s->getConBelow());
newS.setFirstInsideAbove(s->getFirstInsideAbove());
newS.setSecondInsideAbove(s->getSecondInsideAbove());
*s = newS;
} // (!startsAtEventpoint) && (!endsInEventpoint)
if (!endsInEventpoint) {
if (s->getOwner() != both) {
if (!next) {
s->setConAbove(0);
} else {
s->setConAbove(next->getConBelow());
}
if ((s->getOwner() == first)) {
if (s->getFirstInsideAbove()) {
s->setConBelow(s->getConAbove() - 1);
} else {
s->setConBelow(s->getConAbove() + 1);
}
}
if (s->getOwner() == second) {
if (s->getSecondInsideAbove()) {
s->setConBelow(s->getConAbove() - 1);
} else {
s->setConBelow(s->getConAbove() + 1);
}
}
}
next = s;
assert((0 <= s->getConAbove()) && (s->getConAbove() <= 2));
assert((0 <= s->getConBelow()) && (s->getConBelow() <= 2));
}
} //end for
}
/*
1 ~checkSegments~
*/
void checkSegments(vector<AVLSegment*>& segmentVector, Event& event,
AVLSegment* successor, bool& result, RelationshipOperation op) {
size_t size = segmentVector.size();
AVLSegment* next = successor;
for (size_t i = 0; i < size; i++) {
AVLSegment* s = segmentVector.at(i);
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
bool startsAtEventpoint = s->startsAtPoint(event.getGridX(), event.getGridY(),
px, py);
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py);
if ((!startsAtEventpoint) && (!endsInEventpoint)) {
checkSegment(*s, result, op);
AVLSegment newS(event.getGridX(), event.getGridY(), s->getGridXR(),
s->getGridYR(), event.getPreciseX(), event.getPreciseY(),
s->getPreciseXR(), s->getPreciseYR(), s->getOwner());
newS.setConAbove(s->getConAbove());
newS.setConBelow(s->getConBelow());
newS.setFirstInsideAbove(s->getFirstInsideAbove());
newS.setSecondInsideAbove(s->getSecondInsideAbove());
*s = newS;
} // (!startsAtEventpoint) && (!endsInEventpoint)
if (!endsInEventpoint) {
if (s->getOwner() != both) {
if (!next) {
s->setConAbove(0);
} else {
s->setConAbove(next->getConBelow());
}
if ((s->getOwner() == first)) {
if (s->getFirstInsideAbove()) {
s->setConBelow(s->getConAbove() - 1);
} else {
s->setConBelow(s->getConAbove() + 1);
}
}
if (s->getOwner() == second) {
if (s->getSecondInsideAbove()) {
s->setConBelow(s->getConAbove() - 1);
} else {
s->setConBelow(s->getConAbove() + 1);
}
}
}
next = s;
assert((0 <= s->getConAbove()) && (s->getConAbove() <= 2));
assert((0 <= s->getConBelow()) && (s->getConBelow() <= 2));
}
}
}
/*
1 ~checkSegment~
*/
void checkSegment(AVLSegment& seg, bool& result, RelationshipOperation op) {
switch (op) {
case (intersects_op): {
if ((seg.getConAbove() == 2) || (seg.getConBelow() == 2)) {
if (p2d_debug) {
cout << "the regions intersect." << endl;
seg.print();
}
result = true;
}
break;
}
case overlaps_op: {
if ((seg.getConAbove() == 2) || (seg.getConBelow() == 2)) {
if (p2d_debug) {
cout << "the regions overlap." << endl;
seg.print();
}
result = true;
}
break;
} //case: overlaps_op
case inside_op: {
switch (seg.getOwner()) {
case first: {
if (seg.getConAbove() + seg.getConBelow() != 3) {
if (p2d_debug) {
cout << "r1 is not within r2-first" << endl;
seg.print();
}
result = false;
}
break;
}
case second: {
if ((seg.getConAbove() + seg.getConBelow()) != 1) {
if (p2d_debug) {
cout << "r1 is not within r2-second" << endl;
seg.print();
}
result = false;
}
break;
}
case both: {
if (!(((seg.getConAbove() == 2) && (seg.getConBelow() == 0))
|| ((seg.getConAbove() == 0) && (seg.getConBelow() == 2)))) {
if (p2d_debug) {
cout << "r1 is not within r2-both" << endl;
seg.print();
}
result = false;
}
break;
}
default:
assert(false);
} // switch (seg.getOwner)
break;
} // case:inside_op
default:
assert(false);
} //switch(op)
}
/*
1 ~createNewSegments~
*/
void createNewSegments(AVLSegment& s, Region2& result, int& edgeno,
int scalefactor, SetOperation op) {
switch (op) {
case union_op: {
if ((s.getConAbove() == 0) || (s.getConBelow() == 0)) {
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
s.getGridYL(), scalefactor);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s.getConBelow() == 0);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case intersection_op: {
if (s.getConAbove() == 2 || s.getConBelow() == 2) {
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
s.getGridYL(), scalefactor);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s.getConAbove() == 2);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case difference_op: {
switch (s.getOwner()) {
case first: {
if (s.getConAbove() + s.getConBelow() == 1) {
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
s.getGridYL(), scalefactor);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s.getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case second: {
if ((s.getConAbove() == 1 && s.getConBelow() == 2)
|| (s.getConBelow() == 1 && s.getConAbove() == 2)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s.print();
}
Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
s.getGridYL(), scalefactor);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = !(s.getSecondInsideAbove());
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case both: {
if ((s.getConAbove() == 1) && (s.getConBelow() == 1)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s.print();
}
Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
s.getGridYL(), scalefactor);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s.getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
default:
assert(false);
} // switch (s.getOwner)
break;
}
default: {
assert(false);
}
}
}
/*
1 ~createNewSegments~
for buildRegion
*/
void createNewSegments(Region2& result, AVLSegment& s,
int& edgeno, int scalefactor){
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
s.getGridYL(), scalefactor);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s.getFirstInsideAbove());
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
/*
1 ~createNewSegments~
*/
void createNewSegments(AVLSegment& s, Region2& result, int& edgeno,
int scalefactor, SetOperation op, mpq_class& internalScalefactor) {
switch (op) {
case union_op: {
if ((s.getConAbove() == 0) || (s.getConBelow() == 0)) {
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s.getConBelow() == 0);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case intersection_op: {
if (s.getConAbove() == 2 || s.getConBelow() == 2) {
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (s.getConAbove() == 2);
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case difference_op: {
switch (s.getOwner()) {
case first: {
if (s.getConAbove() + s.getConBelow() == 1) {
if (p2d_debug) {
cout << "neues Segment in Region einfuegen" << endl;
s.print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s.getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case second: {
if ((s.getConAbove() == 1 && s.getConBelow() == 2)
|| (s.getConBelow() == 1 && s.getConAbove() == 2)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s.print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = !(s.getSecondInsideAbove());
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
case both: {
if ((s.getConAbove() == 1) && (s.getConBelow() == 1)) {
if (p2d_debug) {
cout << "speichere Segment" << endl;
s.print();
}
int x, y;
mpq_class px, py;
prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = s.getFirstInsideAbove();
result += hs;
hs.SetLeftDomPoint(!hs.IsLeftDomPoint());
result += hs;
edgeno++;
}
break;
}
default:
assert(false);
} // switch (s.getOwner)
break;
}
default: {
assert(false);
}
}
}
/*
1 ~Realminize~
*/
void Realminize(const Line2& src, Line2& result, const bool forceThrow) {
result.Clear();
if (!src.IsDefined()) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (src.Size() <= 1) {
// empty line, nothing to realminize
return;
}
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos = 0;
AVLSegment* current = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
result.StartBulkLoad();
int edgeno = 0;
Event event;
while (selectNext(src, pos, q, event) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForRealminize(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForRealminize(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (event.isValid()) {
if (current->isValid()) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
current->print();
}
result.addSegment(true, current->getGridXL(), current->getGridYL(),
current->getGridXR(), current->getGridYR(), current->getPreciseXL(),
current->getPreciseYL(), current->getPreciseXR(),
current->getPreciseYR(), edgeno);
result.addSegment(false, current->getGridXL(), current->getGridYL(),
current->getGridXR(), current->getGridYR(), current->getPreciseXL(),
current->getPreciseYL(), current->getPreciseXR(),
current->getPreciseYR(), edgeno);
edgeno++;
}
mpq_class v1 = current->getPreciseXR();
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForRealminize(pred, suc, event, q, true);
}
}
}
else {
//intersection Event
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
//segmentVector stores all segments which intersect in the
//same event-point
vector<AVLSegment*> segmentVector;
AVLSegment* seg = event.getLeftSegment();
AVLSegment* r = event.getRightSegment();
segmentVector.push_back(seg);
Event e = q.top();
size_t predIndex = 0;
size_t sucIndex = 0;
//if there are only 2 intersecting segments,
//which are parallel (and the right endpoint of the first
//segment is the left endpoint of the second segment),
//the segments don't have to be inverted.
bool inversionNecessary = false;
while (e.isIntersectionEvent() && e.getGridX() == event.getGridX()
&& e.getGridY() == event.getGridY()
&& cmp(e.getPreciseX(), event.getPreciseX()) == 0
&& cmp(e.getPreciseY(), event.getPreciseY()) == 0) {
if (seg->compareInPosOrLeft(*(e.getLeftSegment()), event.getGridX(), v1)
< 0) {
if (seg->isParallelTo(*e.getLeftSegment())) {
if (segmentVector.size() == 1) {
predIndex = 1;
}
segmentVector.pop_back();
segmentVector.push_back(e.getLeftSegment());
segmentVector.push_back(seg);
} else {
inversionNecessary = true;
seg = e.getLeftSegment();
r = e.getRightSegment();
segmentVector.push_back(seg);
}
}
q.pop();
e = q.top();
}
if (segmentVector.back()->compareInPosOrLeft(*r, event.getGridX(), v1)
< 0) {
if (segmentVector.back()->isParallelTo(*r)) {
segmentVector.pop_back();
segmentVector.push_back(r);
segmentVector.push_back(seg);
sucIndex = segmentVector.size() - 2;
} else {
inversionNecessary = true;
segmentVector.push_back(r);
sucIndex = segmentVector.size() - 1;
}
}
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1, event.getGridY(),
v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for";
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForRealminize(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForRealminize(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
for (size_t i = 0; i < segmentVector.size(); i++) {
bool isEndpoint = segmentVector.at(i)->isEndpoint(event.getGridX(),
event.getGridY(), px, py);
if (!isEndpoint) {
if (p2d_debug) {
cout << "neues Segment in Line einfuegen" << endl;
cout << segmentVector.at(i)->getGridXL() << " "
<< segmentVector.at(i)->getGridYL() << " "
<< event.getGridX() << " "
<< event.getGridY() << " "
<< segmentVector.at(i)->getPreciseXL().get_d() << " "
<< segmentVector.at(i)->getPreciseYL().get_d() << " "
<< event.getPreciseX().get_d() << " "
<< event.getPreciseY().get_d()
<< endl;
}
result.addSegment(true, segmentVector.at(i)->getGridXL(),
segmentVector.at(i)->getGridYL(), event.getGridX(), event.getGridY(),
segmentVector.at(i)->getPreciseXL(),
segmentVector.at(i)->getPreciseYL(), event.getPreciseX(),
event.getPreciseY(), edgeno);
result.addSegment(false, segmentVector.at(i)->getGridXL(),
segmentVector.at(i)->getGridYL(), event.getGridX(), event.getGridY(),
segmentVector.at(i)->getPreciseXL(),
segmentVector.at(i)->getPreciseYL(), event.getPreciseX(),
event.getPreciseY(), edgeno);
edgeno++;
AVLSegment* newLeft = new AVLSegment(event.getGridX(),
event.getGridY(), segmentVector.at(i)->getGridXR(),
segmentVector.at(i)->getGridYR(), event.getPreciseX(),
event.getPreciseY(), segmentVector.at(i)->getPreciseXR(),
segmentVector.at(i)->getPreciseYR(), segmentVector.at(i)->getOwner());
*(segmentVector.at(i)) = *newLeft;
}
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad(false, false, false);
} // end Realminize
/*
1 ~BuildRegion~
*/
void BuildRegion(/*const*/Line2& line, Region2& result, int scalefactor) {
result.Clear();
if (!line.IsDefined() ) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (line.Size() == 0) {
return;
}
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
result.SetScaleFactor(scalefactor);
result.StartBulkLoad();
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
int edgeno = 0;
Event event;
while ((selectNext(line, pos1, q, event)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
createNewSegments(result, *current, edgeno, scalefactor);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
setInsideAbove(segmentVector, event, suc);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad();
} // buildRegion line2 [->] region2
/*
1 ~SetOp~
*/
void SetOp(const Line2& line1, const Line2& line2, Line2& result,
SetOperation op, const Geoid* geoid/*=0*/) {
result.Clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!line1.IsDefined() || !line2.IsDefined()
|| (geoid && !geoid->IsDefined())) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (line1.Size() == 0) {
switch (op) {
case union_op:
result = line2;
return;
case intersection_op:
return; // empty line
case difference_op:
return; // empty line
default:
assert(false);
}
}
if (line2.Size() == 0) {
switch (op) {
case union_op:
result = line1;
return;
case intersection_op:
return;
case difference_op:
result = line1;
return;
default:
assert(false);
}
}
if (!line1.BoundingBox().Intersects(line2.BoundingBox(), geoid)) {
switch (op) {
case union_op: {
result.StartBulkLoad();
int edgeno = 0;
int s = line1.Size();
SegmentData sd;
const Flob* flob = line1.getPreciseCoordinates();
for (int i = 0; i < s; i++) {
line1.get(i, sd);
if (sd.IsLeftDomPoint()) {
result.addSegment(true, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
result.addSegment(false, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
edgeno++;
}
}
s = line2.Size();
for (int i = 0; i < s; i++) {
line2.get(i, sd);
if (sd.IsLeftDomPoint()) {
result.addSegment(true, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
result.addSegment(false, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
edgeno++;
}
}
result.EndBulkLoad();
return;
}
case difference_op: {
result = line1;
return;
}
case intersection_op: {
return;
}
default:
assert(false);
}
}
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment nextHs;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
int edgeno = 0;
Event event;
result.StartBulkLoad();
while ((selectNext(line1, pos1, line2, pos2, q, event)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()) {
createNewSegments(*current, result, edgeno, op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test with" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test with" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, result, edgeno, op);
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad(true, false);
} // setop line2 x line2 [->] line2
/*
1 ~SetOp~
*/
void SetOpWithScaling(const Line2& line1, const Line2& line2, Line2& result,
SetOperation op, const Geoid* geoid/*=0*/) {
result.Clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!line1.IsDefined() || !line2.IsDefined()
|| (geoid && !geoid->IsDefined())) {
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (line1.Size() == 0) {
switch (op) {
case union_op:
result = line2;
return;
case intersection_op:
return; // empty line
case difference_op:
return; // empty line
default:
assert(false);
}
}
if (line2.Size() == 0) {
switch (op) {
case union_op:
result = line1;
return;
case intersection_op:
return;
case difference_op:
result = line1;
return;
default:
assert(false);
}
}
if (!line1.BoundingBox().Intersects(line2.BoundingBox(), geoid)) {
switch (op) {
case union_op: {
result.StartBulkLoad();
int edgeno = 0;
int s = line1.Size();
SegmentData sd;
const Flob* flob = line1.getPreciseCoordinates();
for (int i = 0; i < s; i++) {
line1.get(i, sd);
if (sd.IsLeftDomPoint()) {
result.addSegment(true, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
result.addSegment(false, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
edgeno++;
}
}
s = line2.Size();
for (int i = 0; i < s; i++) {
line2.get(i, sd);
if (sd.IsLeftDomPoint()) {
result.addSegment(true, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
result.addSegment(false, sd.getLeftX(), sd.getLeftY(), sd.getRightX(),
sd.getRightY(), sd.getPreciseLeftX(*flob), sd.getPreciseLeftY(*flob),
sd.getPreciseRightX(*flob), sd.getPreciseRightY(*flob), edgeno);
edgeno++;
}
}
result.EndBulkLoad();
return;
}
case difference_op: {
result = line1;
return;
}
case intersection_op: {
return;
}
default:
assert(false);
}
}
mpq_class internalScalefactor = computeScalefactor(line1, line2);
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment nextHs;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
int edgeno = 0;
Event event;
result.StartBulkLoad();
while ((selectNext(line1, pos1, line2, pos2, q,
event, internalScalefactor)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()) {
createNewSegments(*current, result, edgeno, op, internalScalefactor);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test with" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test with" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, result, edgeno, op,
internalScalefactor);
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad(true, false);
} // setopWithScaling line2 x line2 [->] line2
/*
1 ~intersects~
*/
bool intersects(const Line2& line1, const Line2& line2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!line1.IsDefined() || !line2.IsDefined()
|| (geoid && !geoid->IsDefined())) {
return false;
}
if (line1.Size() == 0) {
return false;
}
if (line2.Size() == 0) {
return false;
}
if (!line1.BoundingBox().Intersects(line2.BoundingBox(), geoid)) {
return false;
}
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current = NULL;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
Event event;
bool intersect = false;
while ((!intersect
&& (selectNext(line1, pos1, line2, pos2, q, event)) != none)) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
if (current->getOwner() == both) {
intersect = true;
}
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false)) {
if ((pred->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true)) {
if ((suc->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true)) {
if ((pred->getOwner() != suc->getOwner())||(pred->getOwner()==both)) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true)) {
if ((pred->getOwner() != suc->getOwner())||(pred->getOwner()==both)) {
intersect = true;
}
}
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true)) {
if ((pred->getOwner() != right->getOwner())||(pred->getOwner()==both)) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true)) {
if ((suc->getOwner() != left->getOwner())||(suc->getOwner()==both)) {
intersect = true;
}
}
}
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return intersect;
} // intersects line2 x line2 [->] bool
/*
1 ~intersects~
*/
bool intersectsWithScaling(const Line2& line1, const Line2& line2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!line1.IsDefined() || !line2.IsDefined()
|| (geoid && !geoid->IsDefined())) {
return false;
}
if (line1.Size() == 0) {
return false;
}
if (line2.Size() == 0) {
return false;
}
if (!line1.BoundingBox().Intersects(line2.BoundingBox(), geoid)) {
return false;
}
mpq_class internalScalefactor = computeScalefactor(line1, line2);
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current = NULL;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
Event event;
bool intersect = false;
while ((!intersect
&& (selectNext(line1, pos1, line2, pos2, q,
event, internalScalefactor)) != none)) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
if (current->getOwner() == both) {
intersect = true;
}
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false)) {
if ((pred->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true)) {
if ((suc->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
sss.inorder();
}
current = event.getSegment();
if (current->isValid()){
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true)) {
if ((pred->getOwner() != suc->getOwner())||(pred->getOwner()==both)) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true)) {
if ((pred->getOwner() != suc->getOwner())||(pred->getOwner()==both)) {
intersect = true;
}
}
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true)) {
if ((pred->getOwner() != right->getOwner())||(pred->getOwner()==both)) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true)) {
if ((suc->getOwner() != left->getOwner())||(suc->getOwner()==both)) {
intersect = true;
}
}
}
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return intersect;
} // intersectsWithScaling line2 x line2 [->] bool
/*
1 ~crossings~
*/
void crossings(const Line2& line1, const Line2& line2, Points2& result,
const Geoid* geoid/*=0*/) {
result.Clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!line1.IsDefined() || !line2.IsDefined()
|| (geoid && !geoid->IsDefined())) {
result.SetDefined(false);
return;
}
if (line1.Size() == 0) {
return;
}
if (line2.Size() == 0) {
return;
}
if (!line1.BoundingBox().Intersects(line2.BoundingBox(), geoid)) {
return;
}
result.StartBulkLoad();
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
Event event;
while (selectNext(line1, pos1, line2, pos2, q, event) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
mpq_class v1 = current->getPreciseXR();
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
bool hasSegOfArg1 = false;
bool hasSegOfArg2 = false;
size_t i = 0;
size_t size = segmentVector.size();
while (!(hasSegOfArg1 && hasSegOfArg2) && i < size) {
if (segmentVector.at(i)->getOwner() == first) {
hasSegOfArg1 = true;
}
if (segmentVector.at(i)->getOwner() == second) {
hasSegOfArg2 = true;
}
i++;
}
if (hasSegOfArg1 && hasSegOfArg2) {
Point2 p(true, event.getGridX(), event.getGridY(),
event.getPreciseX(), event.getPreciseY());
result.addPoint( p );
}
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1, event.getGridY(),
v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for";
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for";
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad();
} // crossings line2 x line2 [->] points2
/*
1 ~crossings~
*/
void crossingsWithScaling(const Line2& line1, const Line2& line2,
Points2& result, const Geoid* geoid/*=0*/) {
result.Clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!line1.IsDefined() || !line2.IsDefined()
|| (geoid && !geoid->IsDefined())) {
result.SetDefined(false);
return;
}
if (line1.Size() == 0) {
return;
}
if (line2.Size() == 0) {
return;
}
if (!line1.BoundingBox().Intersects(line2.BoundingBox(), geoid)) {
return;
}
result.StartBulkLoad();
mpq_class internalScalefactor = p2d::computeScalefactor(line1, line2);
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
Event event;
while (selectNext(line1, pos1, line2, pos2, q,
event, internalScalefactor) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
mpq_class v1 = current->getPreciseXR();
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
bool hasSegOfArg1 = false;
bool hasSegOfArg2 = false;
size_t i = 0;
size_t size = segmentVector.size();
while (!(hasSegOfArg1 && hasSegOfArg2) && i < size) {
if (segmentVector.at(i)->getOwner() == first) {
hasSegOfArg1 = true;
}
if (segmentVector.at(i)->getOwner() == second) {
hasSegOfArg2 = true;
}
i++;
}
if (hasSegOfArg1 && hasSegOfArg2) {
int gx, gy;
mpq_class px, py;
p2d::prepareData(gx, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
p2d::prepareData(gy, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Point2 p(true, gx, gy, px, py);
result.addPoint( p );
}
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1, event.getGridY(),
v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for";
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for";
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad();
} // crossingsWithScaling line2 x line2 [->] points2
/*
1 ~SetOp~
*/
void SetOp(/*const*/Region2& reg1, /*const*/Region2& reg2, Region2& result,
SetOperation op, const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
result.Clear();
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| (reg1.GetScaleFactor()!=reg2.GetScaleFactor())) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
result.SetDefined(false);
return;
}
result.SetDefined(true);
if (reg1.Size() == 0) {
switch (op) {
case union_op:
result = reg2;
return;
case intersection_op:
return; // empty region
case difference_op:
return; // empty region
default:
assert(false);
}
}
if (reg2.Size() == 0) {
switch (op) {
case union_op:
result = reg1;
return;
case intersection_op:
return;
case difference_op:
result = reg1;
return;
default:
assert(false);
}
}
result.SetScaleFactor(reg1.GetScaleFactor());
if (!reg1.BoundingBox().Intersects(reg2.BoundingBox(), geoid)) {
switch (op) {
case union_op: {
result.StartBulkLoad();
int edgeno = 0;
int s = reg1.Size();
Reg2GridHalfSegment gs;
Reg2PrecHalfSegment ps;
for (int i = 0; i < s; i++) {
reg1.getgridCoordinates()->Get(i, gs);
reg1.getprecCoordinates()->Get(i, ps);
if (gs.IsLeftDomPoint()) {
Reg2PrecisePoint p1(ps.GetlPointx(reg1.getpreciseCoordinates()),
gs.GetLeftPointX(), ps.GetlPointy(reg1.getpreciseCoordinates()),
gs.GetLeftPointY(), reg1.GetScaleFactor());
Reg2PrecisePoint p2(ps.GetrPointx(reg1.getpreciseCoordinates()),
gs.GetRightPointX(), ps.GetrPointy(reg1.getpreciseCoordinates()),
gs.GetRightPointY(), reg1.GetScaleFactor());
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (gs.attr.insideAbove);
result += hs;
hs.SetLeftDomPoint(false);
result += hs;
edgeno++;
}
}
s = reg2.Size();
for (int i = 0; i < s; i++) {
reg2.getgridCoordinates()->Get(i, gs);
reg2.getprecCoordinates()->Get(i, ps);
if (gs.IsLeftDomPoint()) {
Reg2PrecisePoint p1(ps.GetlPointx(reg2.getpreciseCoordinates()),
gs.GetLeftPointX(), ps.GetlPointy(reg2.getpreciseCoordinates()),
gs.GetLeftPointY(), reg1.GetScaleFactor());
Reg2PrecisePoint p2(ps.GetrPointx(reg2.getpreciseCoordinates()),
gs.GetRightPointX(), ps.GetrPointy(reg2.getpreciseCoordinates()),
gs.GetRightPointY(), reg1.GetScaleFactor());
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (gs.attr.insideAbove);
result += hs;
hs.SetLeftDomPoint(false);
result += hs;
edgeno++;
}
}
result.EndBulkLoad();
return;
}
case difference_op: {
result = reg1;
return;
}
case intersection_op: {
return;
}
default:
assert(false);
}
}
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
result.StartBulkLoad();
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
int edgeno = 0;
Event event;
result.StartBulkLoad();
while ((selectNext(reg1, pos1, reg2, pos2, q, event)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
createNewSegments(*current, result, edgeno, reg1.GetScaleFactor(), op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, suc, result, edgeno,
reg1.GetScaleFactor(), op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad();
} // setOP region2 x region2 [->] region2
/*
1 ~intersects~
*/
bool intersects(/*const*/Region2& reg1, /*const*/Region2& reg2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| (reg1.GetScaleFactor()!=reg2.GetScaleFactor())) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
return false;
}
if (reg1.Size() == 0) {
return false;
}
if (reg2.Size() == 0) {
return false;
}
if (!reg1.BoundingBox().Intersects(reg2.BoundingBox(), geoid)) {
return false;
}
assert(reg1.IsOrdered());
assert(reg2.IsOrdered());
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* right = NULL;
AVLSegment* left = NULL;
Event event;
bool intersect = false;
while (!intersect && (selectNext(reg1, pos1, reg2, pos2, q, event)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false)) {
if ((pred->getOwner() != current->getOwner())) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true)) {
if ((suc->getOwner() != current->getOwner())) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
checkSegment(*current, intersect, intersects_op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true)) {
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
if(intersectionTestForSetOp(pred, suc, event, q, true)){
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true)) {
if ((pred->getOwner() != right->getOwner())) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true)) {
if ((suc->getOwner() != left->getOwner())) {
intersect = true;
}
}
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, intersect, intersects_op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return intersect;
} // intersects region2 x region2 [->] bool
/*
1 ~overlaps~
*/
bool overlaps(/*const*/Region2& reg1, /*const*/Region2& reg2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| (reg1.GetScaleFactor()!=reg2.GetScaleFactor())) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
return false;
}
if (reg1.Size() == 0) {
return false;
}
if (reg2.Size() == 0) {
return false;
}
if (!reg1.BoundingBox().Intersects(reg2.BoundingBox(), geoid)) {
return false;
}
assert(reg1.IsOrdered());
assert(reg2.IsOrdered());
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* right = NULL;
AVLSegment* left = NULL;
Event event;
bool overlaps = false;
while (!overlaps && (selectNext(reg1, pos1, reg2, pos2, q, event)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
checkSegment(*current, overlaps, overlaps_op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, overlaps, overlaps_op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return overlaps;
} // overlaps region2 x region2 [->] bool
/*
1 ~inside~
*/
bool inside(/*const*/Region2& reg1, /*const*/Region2& reg2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| (reg1.GetScaleFactor()!=reg2.GetScaleFactor())) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
return false;
}
if (reg1.Size() == 0) {
return true;
}
if (reg2.Size() == 0) {
return false;
}
if (!reg2.BoundingBox().Contains(reg1.BoundingBox(), geoid)) {
return false;
}
assert(reg1.IsOrdered());
assert(reg2.IsOrdered());
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* right = NULL;
AVLSegment* left = NULL;
Event event;
bool inside = true;
while (inside && (selectNext(reg1, pos1, reg2, pos2, q, event)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
checkSegment(*current, inside, inside_op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, inside, inside_op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return inside;
} // inside region2 x region2 [->] bool
/*
1 ~SetOp~
*/
void SetOpWithScaling(/*const*/Region2& reg1, /*const*/Region2& reg2,
Region2& result, SetOperation op, const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
result.Clear();
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())) {
result.SetDefined(false);
return;
}
if (reg1.IsDefined() && reg2.IsDefined() &&
(reg1.GetScaleFactor()!=reg2.GetScaleFactor())){
cout <<"The regions have different scalefactors."<<endl;
result.SetDefined(false);
return;
}
result.SetScaleFactor(reg1.GetScaleFactor());
result.SetDefined(true);
if (reg1.Size() == 0) {
switch (op) {
case union_op:
result = reg2;
return;
case intersection_op:
return; // empty region
case difference_op:
return; // empty region
default:
assert(false);
}
}
if (reg2.Size() == 0) {
switch (op) {
case union_op:
result = reg1;
return;
case intersection_op:
return;
case difference_op:
result = reg1;
return;
default:
assert(false);
}
}
if (!reg1.BoundingBox().Intersects(reg2.BoundingBox(), geoid)) {
switch (op) {
case union_op: {
result.StartBulkLoad();
int edgeno = 0;
int s = reg1.Size();
Reg2GridHalfSegment gs;
Reg2PrecHalfSegment ps;
for (int i = 0; i < s; i++) {
reg1.getgridCoordinates()->Get(i, gs);
reg1.getprecCoordinates()->Get(i, ps);
if (gs.IsLeftDomPoint()) {
Reg2PrecisePoint p1(ps.GetlPointx(reg1.getpreciseCoordinates()),
gs.GetLeftPointX(), ps.GetlPointy(reg1.getpreciseCoordinates()),
gs.GetLeftPointY(), reg1.GetScaleFactor());
Reg2PrecisePoint p2(ps.GetrPointx(reg1.getpreciseCoordinates()),
gs.GetRightPointX(), ps.GetrPointy(reg1.getpreciseCoordinates()),
gs.GetRightPointY(), reg1.GetScaleFactor());
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (gs.attr.insideAbove);
result += hs;
hs.SetLeftDomPoint(false);
result += hs;
edgeno++;
}
}
s = reg2.Size();
for (int i = 0; i < s; i++) {
reg2.getgridCoordinates()->Get(i, gs);
reg2.getprecCoordinates()->Get(i, ps);
if (gs.IsLeftDomPoint()) {
Reg2PrecisePoint p1(ps.GetlPointx(reg2.getpreciseCoordinates()),
gs.GetLeftPointX(), ps.GetlPointy(reg2.getpreciseCoordinates()),
gs.GetLeftPointY(), reg1.GetScaleFactor());
Reg2PrecisePoint p2(ps.GetrPointx(reg2.getpreciseCoordinates()),
gs.GetRightPointX(), ps.GetrPointy(reg2.getpreciseCoordinates()),
gs.GetRightPointY(), reg1.GetScaleFactor());
Reg2PreciseHalfSegment hs = Reg2PreciseHalfSegment(true, p1, p2);
hs.attr.edgeno = edgeno;
hs.attr.insideAbove = (gs.attr.insideAbove);
result += hs;
hs.SetLeftDomPoint(false);
result += hs;
edgeno++;
}
}
result.EndBulkLoad();
return;
}
case difference_op: {
result = reg1;
return;
}
case intersection_op: {
return;
}
default:
assert(false);
}
}
mpq_class internalScalefactor = computeScalefactor(reg1, reg2);
//start plane sweep
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
result.StartBulkLoad();
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* left = NULL;
AVLSegment* right = NULL;
int edgeno = 0;
Event event;
result.StartBulkLoad();
while ((selectNext(reg1, pos1, reg2, pos2, q,
event, internalScalefactor)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
createNewSegments(*current, result, edgeno, reg1.GetScaleFactor(), op,
internalScalefactor);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, suc, result, edgeno,
reg1.GetScaleFactor(), op, internalScalefactor);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad();
} // setOPWithScalefactor region2 x region2 [->] region2
/*
1 ~intersects~
*/
bool intersectsWithScaling(/*const*/Region2& reg1, /*const*/Region2& reg2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| reg1.GetScaleFactor()!=reg2.GetScaleFactor()) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
return false;
}
if (reg1.Size() == 0) {
return false;
}
if (reg2.Size() == 0) {
return false;
}
if (!reg1.BoundingBox().Intersects(reg2.BoundingBox(), geoid)) {
return false;
}
assert(reg1.IsOrdered());
assert(reg2.IsOrdered());
mpq_class internalScalefactor = computeScalefactor(reg1, reg2);
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* right = NULL;
AVLSegment* left = NULL;
Event event;
bool intersect = false;
while (!intersect
&& (selectNext(reg1, pos1, reg2, pos2, q,
event, internalScalefactor)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false)) {
if ((pred->getOwner() != current->getOwner())) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true)) {
if ((suc->getOwner() != current->getOwner())) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
checkSegment(*current, intersect, intersects_op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true)) {
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
if(intersectionTestForSetOp(pred, suc, event, q, true)){
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true)) {
if ((pred->getOwner() != right->getOwner())) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true)) {
if ((suc->getOwner() != left->getOwner())) {
intersect = true;
}
}
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, intersect, intersects_op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return intersect;
} // intersectsWithScalefactor region2 x region2 [->] bool
/*
1 ~overlaps~
*/
bool overlapsWithScaling(/*const*/Region2& reg1, /*const*/Region2& reg2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| (reg1.GetScaleFactor()!=reg2.GetScaleFactor())) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
return false;
}
if (reg1.Size() == 0) {
return false;
}
if (reg2.Size() == 0) {
return false;
}
if (!reg1.BoundingBox().Intersects(reg2.BoundingBox(), geoid)) {
return false;
}
assert(reg1.IsOrdered());
assert(reg2.IsOrdered());
mpq_class internalScalefactor = computeScalefactor(reg1, reg2);
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* right = NULL;
AVLSegment* left = NULL;
Event event;
bool overlaps = false;
while (!overlaps
&& (selectNext(reg1, pos1, reg2, pos2, q,
event, internalScalefactor)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
checkSegment(*current, overlaps, overlaps_op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, overlaps, overlaps_op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return overlaps;
} // overlapsWithScalefactor region2 x region2 [->] bool
/*
1 ~inside~
*/
bool insideWithScaling(/*const*/Region2& reg1, /*const*/Region2& reg2,
const Geoid* geoid/*=0*/) {
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())
|| (reg1.GetScaleFactor()!=reg2.GetScaleFactor())) {
if (reg1.GetScaleFactor()!=reg2.GetScaleFactor()){
cout <<"The regions have different scalefactors."<<endl;
}
return false;
}
if (reg1.Size() == 0) {
return true;
}
if (reg2.Size() == 0) {
return false;
}
if (!reg2.BoundingBox().Contains(reg1.BoundingBox(), geoid)) {
return false;
}
cout <<"PS noetig"<<endl;
assert(reg1.IsOrdered());
assert(reg2.IsOrdered());
mpq_class internalScalefactor = computeScalefactor(reg1, reg2);
priority_queue<Event, vector<Event>, greater<Event> > q;
AVLTree sss;
int pos1 = 0;
int pos2 = 0;
AVLSegment* current;
AVLSegment* pred = NULL;
AVLSegment* suc = NULL;
AVLSegment* right = NULL;
AVLSegment* left = NULL;
Event event;
bool inside = true;
while (inside
&& (selectNext(reg1, pos1, reg2, pos2, q,
event, internalScalefactor)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
q.push(re);
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
checkSegment(*current, inside, inside_op);
sss.removeGetNeighbor(current, pred, suc);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true);
}
}
if (event.getNoOfChanges() == 0) {
//this is the last event with ~current~
delete current;
}
} else {
//intersection Event
if (event.isValid()) {
if (p2d_debug) {
event.print();
}
mpq_class v1 = event.getPreciseX();
mpq_class v2 = event.getPreciseY();
vector<AVLSegment*> segmentVector;
size_t predIndex = 0;
size_t sucIndex = 0;
bool inversionNecessary = false;
collectSegmentsForInverting(segmentVector, event, q, predIndex, sucIndex,
inversionNecessary);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, inside, inside_op);
} else {
AVLSegment* higherSeg = segmentVector.at(0);
AVLSegment* lowerSeg = segmentVector.at(1);
higherSeg->setConAbove(lowerSeg->getConAbove());
higherSeg->setConBelow(lowerSeg->getConBelow());
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return inside;
} // insideWithScalefactor region2 x region2 [->] bool
} //end of p2d
#endif /* AVL_TREE_CPP_*/
Reference in New Issue View Git Blame Copy Permalink