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

7731 lines
198 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]
[TOC]
0 Overview
This file contains same classes and operators as
the file AVL\_Tree.cpp. Only the struct ~TestStruct~ is new.
It is added to some methods to check
how often decisions could be made without using the precise data of type
mpq\_class.
To save some space the comments are reduced to a minimum. For more information
see file AVL\_Tree.cpp
1 Includes and defines
*/
#ifndef TESTAVLTREE_CPP
#define TESTAVLTREE_CPP
#include "TestAVLTree.h"
#include <cmath>
#include <vector>
using namespace std;
namespace p2d_test {
mpq_class vNoCmpGrid = 0;
mpq_class vNoCmpPrecise = 0;
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,
TestStruct& t) {
pred = NULL;
suc = NULL;
if (root == NULL) {
root = new AVLNode(x);
} else {
root = root->insert(x, pred, suc, t);
}
}
/*
1.1 ~remove~
*/
void AVLTree::removeGetNeighbor(AVLSegment* x, AVLSegment*& pred,
AVLSegment*& suc, TestStruct& t) {
pred = NULL;
suc = NULL;
if (root != NULL) {
root = root->removeGetNeighbor(x, pred, suc, t);
}
}
void AVLTree::removeGetNeighbor2(AVLSegment* x, int gridXPos,
mpq_class& preciseXPos, AVLSegment*& pred, AVLSegment*& suc, TestStruct& t) {
pred = NULL;
suc = NULL;
if (root != NULL) {
root = root->removeGetNeighbor2(x, gridXPos, preciseXPos, pred, suc, t);
}
}
void AVLTree::removeInvalidSegment(AVLSegment* x, int gridXPos,
mpq_class& preciseXPos, TestStruct& t) {
bool found = false;
if (root != NULL) {
root = root->removeInvalidSegment(x, gridXPos, preciseXPos, found, t);
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, TestStruct& t) {
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, t);
} else {
if (j == sucIndex) {
node = root->memberPlusNeighbor(v[j], found, gridX, pX, gridY, pY, suc,
false, t);
} else {
node = root->member(v[j], found, gridX, pX, gridY, pY, t);
}
}
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();
}
}
/*
1 Class AVLNode
*/
/*
1.1 ConTestStructor 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 = new AVLNode(*node.left);
}
if (node.right == NULL) {
right = NULL;
} else {
right = new AVLNode(*node.right);
}
height = node.height;
}
AVLNode::~AVLNode() {
}
/*
1.1 ~=~
*/
AVLNode& AVLNode::operator=(const AVLNode& node) {
elem = node.elem;
if (node.left == NULL) {
left = NULL;
} else {
left = new AVLNode(*node.left);
}
if (node.right == NULL) {
right = NULL;
} else {
right = new AVLNode(*node.right);
}
height = node.height;
return *this;
}
/*
1.1 ~member~
*/
AVLNode* AVLNode::memberPlusNeighbor(AVLSegment* key, bool& result,
int gridXPos, mpq_class& preciseXPos, int gridYPos, mpq_class& preciseYPos,
AVLSegment*& neighbor, bool pred, TestStruct& t) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*key,
gridXPos, t);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosForMember(*key, gridXPos, preciseXPos,
gridYPos, preciseYPos, t);
}
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, t);
}
} else {
if (right == 0) {
result = false;
return 0;
} else {
if (pred) {
neighbor = &*elem;
}
return right->memberPlusNeighbor(key, result, gridXPos, preciseXPos,
gridYPos, preciseYPos, neighbor, pred, t);
}
}
}
}
AVLNode* AVLNode::member(AVLSegment* key, bool& result, int gridXPos,
mpq_class& preciseXPos, int gridYPos, mpq_class& preciseYPos, TestStruct& t) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*key,
gridXPos, t);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosForMember(*key, gridXPos, preciseXPos,
gridYPos, preciseYPos, t);
}
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, t);
}
} else {
if (right == 0) {
result = false;
return 0;
} else {
return right->member(key, result, gridXPos, preciseXPos, gridYPos,
preciseYPos, t);
}
}
}
}
/*
1.1 ~getElement~ and ~setElement~
*/
void AVLNode::setElement(AVLSegment** seg) {
elem = *seg;
}
/*
1.1 ~insert~
*/
AVLNode* AVLNode::insert(AVLSegment* x, AVLSegment*& pred, AVLSegment*& suc,
TestStruct& t) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x,
x->getGridXL(), t);
if (cmpSegments == 0) {
mpq_class preciseX = x->getPreciseXL();
cmpSegments = elem->compareInPosOrLeft(*x, x->getGridXL(), preciseX, t);
}
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, t);
left->setHeight();
}
} else {
pred = &*elem;
if (right == NULL) {
right = new AVLNode(x);
right->setHeight();
return this;
} else {
right = right->insert(x, pred, suc, t);
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~ and ~clockwiseRotation~
*/
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;
}
}
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 ~remove~
*/
AVLNode* AVLNode::removeGetNeighbor(AVLSegment* x, AVLSegment*& pred,
AVLSegment*& suc, TestStruct& t) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x,
x->getGridXR(), t);
if (cmpSegments == 0) {
mpq_class preciseX = x->getPreciseXR();
cmpSegments = elem->compareInPosOrRight(*x, x->getGridXR(), preciseX, t);
}
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();
assert(false);
return this;
} else {
suc = &*elem;
left = left->removeGetNeighbor(x, pred, suc, t);
}
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();
assert(false);
return this;
} else {
pred = &*elem;
right = right->removeGetNeighbor(x, pred, suc, t);
}
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;
}
}
AVLNode* AVLNode::removeGetNeighbor2(AVLSegment* x, int gridXPos,
mpq_class preciseXPos, AVLSegment*& pred, AVLSegment*& suc, TestStruct& t) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x, gridXPos,
t);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosOrLeft(*x, gridXPos, preciseXPos, t);
}
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();
assert(false);
return this;
} else {
suc = &*elem;
left = left->removeGetNeighbor2(x, gridXPos, preciseXPos, pred, suc, t);
}
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();
assert(false);
return this;
} else {
pred = &*elem;
right = right->removeGetNeighbor2(x, gridXPos, preciseXPos, pred, suc, t);
}
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;
}
}
AVLNode* AVLNode::removeInvalidSegment(AVLSegment* x, int gridXPos,
mpq_class preciseXPos, bool& found, TestStruct& t) {
int cmpSegments = elem->compareIntersectionintervalWithSweepline(*x, gridXPos,
t);
if (cmpSegments == 0) {
cmpSegments = elem->compareInPosOrLeft(*x, gridXPos, preciseXPos, t);
}
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();
assert(false);
return this;
} else {
left = left->removeInvalidSegment(x, gridXPos, preciseXPos, found, t);
}
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();
assert(false);
return this;
} else {
right = right->removeInvalidSegment(x, gridXPos, preciseXPos, found, t);
}
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, t);
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, t);
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();
}
}
/*
1 Class AVLSegment
*/
/*
1.1 ConTestStructors 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, p2d::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& internalScalefactor) :
gridXL(0), gridYL(0), gridXR(0), gridYR(0),
flob(), dbarray(0), originalData1(), 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))*internalScalefactor));
p2d::prepareData(gridYL, pyl,
((sd->GetDomGridYCoord()+
sd->GetDomPreciseYCoord(*preciseData))*internalScalefactor));
p2d::prepareData(gridXR, pxr,
((sd->GetSecGridXCoord()+
sd->GetSecPreciseXCoord(*preciseData))*internalScalefactor));
p2d::prepareData(gridYR, pyr,
((sd->GetSecGridYCoord()+
sd->GetSecPreciseYCoord(*preciseData))*internalScalefactor));
}
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& internalScalefactor) :
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))*internalScalefactor));
p2d::prepareData(gridYL, pyl,
((gs.GetLeftPointY()+ps.GetlPointy(preciseData))*internalScalefactor));
p2d::prepareData(gridXR, pxr,
((gs.GetRightPointX()+ps.GetrPointx(preciseData))*internalScalefactor));
p2d::prepareData(gridYR, pyr,
((gs.GetRightPointY()+ps.GetrPointy(preciseData))*internalScalefactor));
}
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, TestStruct& t) {
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, TestStruct& t) {
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~
*/
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;
}
/*
1.1 ~equal~
*/
bool AVLSegment::equal(AVLSegment& s, TestStruct& t) const {
t.noCmpGrid++;
if (getGridXL() != s.getGridXL() || getGridYL() != s.getGridYL()
|| getGridXR() != s.getGridXR() || getGridYR() != s.getGridYR()) {
//t aktualisieren
if (getGridXL() == s.getGridXL()) {
t.noCmpGrid++;
if (getGridYL() == s.getGridYL()) {
t.noCmpGrid++;
if (getGridXR() == s.getGridXR()) {
t.noCmpGrid++;
}
}
}
return false;
}
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 3;
t.noCmpPrecise++;
if ((cmp(getPreciseXL(), s.getPreciseXL()) != 0)
|| (cmp(getPreciseYL(), s.getPreciseYL()) != 0)
|| (cmp(getPreciseXR(), s.getPreciseXR()) != 0)
|| (cmp(getPreciseYR(), s.getPreciseYR()) != 0)) {
//t akualisieren
if (cmp(getPreciseXL(), s.getPreciseXL()) == 0) {
t.noCmpPrecise++;
if (cmp(getPreciseYL(), s.getPreciseYL()) == 0) {
t.noCmpPrecise++;
if (cmp(getPreciseXR(), s.getPreciseXR()) == 0) {
t.noCmpPrecise++;
}
}
}
return false;
}
//t aktualisieren
t.noCmpPrecise = t.noCmpPrecise + 3;
return true;
}
/*
1.1 ~isPoint~
*/
bool AVLSegment::isPoint(TestStruct& t) const {
t.noCmpGrid++;
if (getGridXL() != getGridXR() || getGridYL() != getGridYR()) {
if (getGridXL() == getGridXR()) {
t.noCmpGrid++;
}
return false;
}
t.noCmpGrid++;
t.noCmpPrecise++;
if ((cmp(getPreciseXL(), getPreciseXR()) != 0)
|| (cmp(getPreciseYL(), getPreciseYR()) != 0)) {
if (cmp(getPreciseXL(), getPreciseXR()) == 0) {
t.noCmpPrecise++;
}
return false;
}
t.noCmpPrecise++;
return true;
}
/*
1.1 ~isEndpoint~
*/
bool AVLSegment::isEndpoint(int gx, int gy, mpq_class px, mpq_class py,
TestStruct& t) {
t.noCmpGrid++;
if ((getGridXL() == gx) && (getGridYL() == gy)) {
//t aktualisieren
t.noCmpGrid++;
t.noCmpPrecise++;
if ((cmp(getPreciseXL(), px) == 0) && (cmp(getPreciseYL(), py) == 0)) {
//t aktualisieren
t.noCmpPrecise++;
return true;
}
//t aktualisieren
if (cmp(getPreciseXL(), px) == 0) {
t.noCmpPrecise++;
}
}
//t aktualisieren
if (getGridXL() == gx) {
t.noCmpGrid++;
}
t.noCmpGrid++;
if ((getGridXR() == gx) && (getGridYR() == gy)) {
t.noCmpGrid++;
t.noCmpPrecise++;
if ((cmp(getPreciseXR(), px) == 0) && (cmp(getPreciseYR(), py) == 0)) {
t.noCmpPrecise++;
return true;
}
if (cmp(getPreciseXR(), px) == 0) {
t.noCmpPrecise++;
}
}
if (getGridXR() == gx) {
t.noCmpGrid++;
}
return false;
}
/*
1.1 ~startsAtPoint~
*/
bool AVLSegment::startsAtPoint(int gx, int gy, mpq_class px, mpq_class py,
TestStruct& t) {
t.noCmpGrid++;
if (getGridXL() == gx && getGridYL() == gy) {
t.noCmpGrid++;
t.noCmpPrecise++;
if (cmp(getPreciseXL(), px) == 0 && cmp(getPreciseYL(), py) == 0) {
t.noCmpPrecise++;
return true;
}
if (cmp(getPreciseXL(), px) == 0) {
t.noCmpPrecise++;
}
}
if (getGridXL() == gx) {
t.noCmpGrid++;
}
return false;
}
/*
1.1 ~endsInPoint~
*/
bool AVLSegment::endsInPoint(int gx, int gy, mpq_class px, mpq_class py,
TestStruct& t) {
t.noCmpGrid++;
if (getGridXR() == gx && getGridYR() == gy) {
t.noCmpGrid++;
t.noCmpPrecise++;
if (cmp(getPreciseXR(), px) == 0 && cmp(getPreciseYR(), py) == 0) {
t.noCmpPrecise++;
return true;
}
if (cmp(getPreciseXR(), px) == 0) {
t.noCmpPrecise++;
}
}
if (getGridXR() == gx) {
t.noCmpGrid++;
}
return false;
}
/*
1.1 ~isLeftOf~
*/
bool AVLSegment::isLeftOf(Event& event, TestStruct& t) {
t.noCmpGrid++;
if (getGridXR() < event.getGridX()) {
return true;
}
int cmpXR = cmp(getPreciseXR(), event.getPreciseX());
t.noCmpGrid++;
if ((getGridXR() == event.getGridX()) && (cmpXR < 0)) {
t.noCmpPrecise++;
return true;
}
if (getGridXR() == event.getGridX()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((getGridXR() > event.getGridX())
|| ((getGridXR() == event.getGridX()) && cmpXR > 0)) {
if (getGridXR() == event.getGridX()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
return false;
}
if (getGridXR() == event.getGridX()) {
t.noCmpGrid++;
t.noCmpPrecise++;
} else {
if (getGridXR() < event.getGridX()) {
t.noCmpGrid++;
}
}
//equal x
t.noCmpGrid++;
if (getGridYR() < event.getGridY()) {
return true;
}
t.noCmpGrid++;
if (getGridYR() > event.getGridY()) {
return false;
}
int cmpYR = cmp(getPreciseYR(), event.getPreciseY());
t.noCmpPrecise++;
if (cmpYR < 0) {
return true;
}
t.noCmpPrecise++;
if (cmpYR > 0) {
return false;
}
//The right endpoint of the segment is equal to the eventpoint
//If the event is a leftendpoint 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 ~leftPointIsLeftOf~
*/
bool AVLSegment::leftPointIsLeftOf(Event& event, TestStruct& t) {
t.noCmpGrid++;
if (getGridXL() < event.getGridX()) {
return true;
}
int cmpXL = cmp(getPreciseXL(), event.getPreciseX());
t.noCmpGrid++;
if ((getGridXL() == event.getGridX()) && (cmpXL < 0)) {
t.noCmpPrecise++;
return true;
}
if (getGridXL() == event.getGridX()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((getGridXL() > event.getGridX())
|| ((getGridXL() == event.getGridX()) && cmpXL > 0)) {
if (getGridXL() == event.getGridX()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
return false;
}
if (getGridXL() == event.getGridX()) {
t.noCmpGrid++;
t.noCmpPrecise++;
} else {
if (getGridXL() < event.getGridX()) {
t.noCmpGrid++;
}
}
//equal x
t.noCmpGrid++;
if (getGridYL() < event.getGridY()) {
return true;
}
t.noCmpGrid++;
if (getGridYL() > event.getGridY()) {
return false;
}
int cmpYL = cmp(getPreciseYL(), event.getPreciseY());
t.noCmpPrecise++;
if (cmpYL < 0) {
return true;
}
t.noCmpPrecise++;
if (cmpYL > 0) {
return false;
}
//The right endpoint of the segment is equal to the eventpoint
//If the event is a leftendpoint 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 ~isRightPointOf~
*/
bool AVLSegment::isRightPointOf(AVLSegment& s, TestStruct& t) {
t.noCmpGrid++;
if (s.getGridXR() != getGridXL()) {
return false;
}
t.noCmpGrid++;
if (s.getGridYR() != getGridXL()) {
return false;
}
t.noCmpPrecise++;
if (cmp(s.getPreciseXR(), getPreciseXL()) != 0) {
return false;
}
t.noCmpPrecise++;
if (cmp(s.getPreciseYR(), getPreciseYL()) != 0) {
return false;
}
return true;
}
/*
1.1 ~isLeftPointOf~
*/
bool AVLSegment::isLeftPointOf(AVLSegment& s, TestStruct& t) {
t.noCmpGrid++;
if (s.getGridXL() != getGridXL()) {
return false;
}
t.noCmpGrid++;
if (s.getGridYL() != getGridYL()) {
return false;
}
t.noCmpPrecise++;
if (cmp(s.getPreciseXL(), getPreciseXL()) != 0) {
return false;
}
t.noCmpPrecise++;
if (cmp(s.getPreciseYL(), getPreciseYL()) != 0) {
return false;
}
return true;
}
/*
1.1 ~hasEqualLeftEndpointAs~
*/
bool AVLSegment::hasEqualLeftEndpointAs(AVLSegment& s, TestStruct& t) {
t.noCmpGrid++;
if (s.getGridXL() != getGridXL()) {
return false;
}
t.noCmpGrid++;
if (s.getGridYL() != getGridYL()) {
return false;
}
t.noCmpPrecise++;
if (cmp(s.getPreciseXL(), getPreciseXL()) != 0) {
return false;
}
t.noCmpPrecise++;
if (cmp(s.getPreciseYL(), getPreciseYL()) != 0) {
return false;
}
return true;
}
/*
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 {
mpz_class pgridXL = gridXL;
mpz_class ppos = pos;
if (((gridYR - gridYL) > 0 && (gridXR - gridXL) > 0)
|| ((gridYR - gridYL) < 0 && (gridXR - gridXL) < 0)) {
//positive slope
mpz_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 num = ((pos * yryl) + (gridYL * xrxl)
- ((gridXL + 1) * yryl));
int v = (int)(num/xrxl);
if (cmp(value, v)!=0){
cerr << "Fehler in computeBeginOfIntersectionInterval1"<<value <<" "<<v
<<endl;
assert(false);
}
return (int)(num/xrxl);
//return (((pos * (gridYR - gridYL)) + (gridYL * (gridXR - gridXL))
// - ((gridXL + 1) * (gridYR - gridYL))) / (gridXR - gridXL));
} else {
mpz_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 num = (((pos + 1) * yryl) + (gridYL * xrxl)
- (gridXL * yryl));
int v = (int)(num/xrxl);
if (cmp(value, v)!=0){
cerr << "Fehler in computeBeginOfIntersectionInterval2"<<value <<" "<<v
<<endl;
assert(false);
}
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 {
mpz_class pgridXL = gridXL;
mpz_class ppos = pos;
if (((gridYR - gridYL) > 0 && (gridXR - gridXL) > 0)
|| ((gridYR - gridYL) < 0 && (gridXR - gridXL) < 0)) {
//positive slope
mpz_class value = ((((ppos + 1) * (gridYR - gridYL))
+ ((gridYL + 1) * (gridXR-pgridXL))
- ((pgridXL) * (gridYR - gridYL))) / (gridXR - pgridXL)) + 1;
//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 num = (((pos + 1) * yryl) + ((gridYL + 1) * xrxl)
- ((gridXL) * yryl));
int v = (int)((num/(xrxl))+1);
if (cmp(value,v)!=0){
cerr <<" Fehler in computeEndOfIntersectionInterval1"<<value <<" "<<v
<<endl;
assert(false);
}
return (int)((num/(xrxl))+1);
//return ((((pos + 1) * (gridYR - gridYL)) + ((gridYL + 1) * (gridXR-gridXL))
// - ((gridXL) * (gridYR - gridYL))) / (gridXR - gridXL)) + 1;
} else {
mpz_class value = (((ppos * (gridYR - gridYL))
+ ((gridYL + 1) * (gridXR - pgridXL))
- ((pgridXL + 1) * (gridYR - gridYL))) / (gridXR - pgridXL)) + 1;
//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 num = ((pos * yryl) + ((gridYL + 1) * xrxl)
- ((gridXL + 1) * yryl));
int v = (int)((num/(xrxl))+1);
if (cmp(value,v)!=0){
cerr <<" Fehler in computeEndOfIntersectionInterval2"<<value <<" "<<v
<<endl;
assert(false);
}
return (int)((num/xrxl)+1);
//return (((pos * (gridYR - gridYL)) + ((gridYL + 1) * (gridXR - gridXL))
// - ((gridXL + 1) * (gridYR - gridYL))) / (gridXR - gridXL)) + 1;
}
}
}
/*
1.1 ~compareIntersectionIntervalWithSweepline~
*/
int AVLSegment::compareIntersectionintervalWithSweepline(AVLSegment& s,
int gridXPos, TestStruct& t) {
t.noCallCmpIntersectionIntervall++;
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 ~compareInPosOrRight~
*/
int AVLSegment::compareInPosOrRight(AVLSegment& s, int gridXPos,
mpq_class& preciseXPos, TestStruct& t) {
t.noCallCmpWithPreciseData++;
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();
t.noCmpGrid++;
if ((getGridXR() != getGridXL()) || (cmp(thisXR, thisXL) != 0)) {
if (getGridXR() == getGridXL()) {
t.noCmpPrecise++;
}
thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
thisIsNotVertical = true;
}
t.noCmpGrid++;
if ((s.getGridXR() != s.getGridXL()) || (cmp(sXR, sXL) != 0)) {
if (s.getGridXR() == s.getGridXL()) {
t.noCmpPrecise++;
}
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
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 2;
t.noCmpPrecise = t.noCmpPrecise + 2;
t.noCmpGrid++;
if (gridXL != s.getGridXL()) {
t.noCmpGrid++;
if (gridXL < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
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
t.noCmpGrid++;
if (gridXR != s.getGridXR()) {
t.noCmpGrid++;
if (gridXR < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
return cmp(getPreciseXR(), s.getPreciseXR());
} else {
//t aktualisieren
if (gridYL != gridYR) {
t.noCmpGrid++;
} else {
if (s.getGridYL() != s.getGridYR()) {
t.noCmpGrid = t.noCmpGrid + 2;
} else {
if (cmp(getPreciseYL(), getPreciseYR()) != 0) {
t.noCmpGrid = t.noCmpGrid + 2;
t.noCmpPrecise++;
} else {
t.noCmpGrid = t.noCmpGrid + 2;
t.noCmpPrecise = t.noCmpPrecise + 2;
}
}
}
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
t.noCmpGrid++;
if (getGridXL() != s.getGridXL()) {
t.noCmpGrid++;
if (getGridXL() < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpXL = cmp(thisXL, sXL);
if (cmpXL != 0) {
return cmpXL;
} else {
//both segments start in the same XL
t.noCmpGrid++;
if (getGridXR() != s.getGridXR()) {
t.noCmpGrid++;
if (getGridXR() < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
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;
}
}
// both are vertical
t.noCmpGrid++;
if ((s.getGridYR() < this->getGridYL())
|| ((s.getGridYR() == this->getGridYL()) && (cmp(sYR, thisYL) < 0))) {
if (s.getGridYR() == this->getGridYL()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
// this is above s
return 1;
} else {
//t aktualisieren
t.noCmpGrid++;
if (s.getGridYR() == this->getGridYL()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if (getGridYR() < s.getGridYL()) {
return -1;
}
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
t.noCmpGrid++;
if ((getGridYR() == s.getGridYL()) && (cmp(thisYR, sYL) < 0)) {
// s above this
t.noCmpPrecise++;
return -1;
}
//t aktualisieren
if (getGridYR() == s.getGridYL()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if (getGridYL() != s.getGridYL()) {
t.noCmpGrid++;
if (getGridYL() < s.getGridYL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpYL = cmp(thisYL, sYL);
if (cmpYL != 0) {
return cmpYL;
} else {
t.noCmpGrid++;
if (getGridYR() != s.getGridYR()) {
t.noCmpGrid++;
if (getGridYR() < s.getGridYR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpYR = cmp(thisYR, sYR);
return cmpYR;
}
}
}
}
/*
1.1 ~compareInPosOrLeft~
*/
int AVLSegment::compareInPosOrLeft(AVLSegment& s, int gridXPos,
mpq_class& preciseXPos, TestStruct& t) {
t.noCallCmpWithPreciseData++;
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();
t.noCmpGrid++;
if ((getGridXR() != getGridXL()) || (cmp(thisXR, thisXL) != 0)) {
if (getGridXR() == getGridXL()) {
t.noCmpPrecise++;
}
thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
thisIsNotVertical = true;
}
t.noCmpGrid++;
if ((s.getGridXR() != s.getGridXL()) || (cmp(sXR, sXL) != 0)) {
if (s.getGridXR() != s.getGridXL()) {
t.noCmpPrecise++;
}
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
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 2;
t.noCmpPrecise = t.noCmpPrecise + 2;
t.noCmpGrid++;
if (gridXL != s.getGridXL()) {
t.noCmpGrid++;
if (gridXL < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
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
t.noCmpGrid++;
if (gridXR != s.getGridXR()) {
t.noCmpGrid++;
if (gridXR < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
return cmp(getPreciseXR(), s.getPreciseXR());
} else {
//t aktualisieren
t.noCmpGrid++;
if (gridYL == gridYR) {
t.noCmpGrid++;
if (s.getGridYL() == s.getGridYR()) {
t.noCmpPrecise++;
if (cmp(getPreciseYL(), getPreciseYR()) == 0) {
t.noCmpPrecise++;
}
}
}
int cmpSlope = cmp(sSlope, thisSlope);
if (cmpSlope != 0) {
return cmpSlope;
} else {
//both segments run on the same line
//the left one is smaller
t.noCmpGrid++;
if (getGridXL() != s.getGridXL()) {
t.noCmpGrid++;
if (getGridXL() < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpXL = cmp(thisXL, sXL);
if (cmpXL != 0) {
return cmpXL;
} else {
//both segments start in the same XL
t.noCmpGrid++;
if (getGridXR() != s.getGridXR()) {
t.noCmpGrid++;
if (getGridXR() < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
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
t.noCmpGrid++;
if ((s.getGridYR() < getGridYL())
|| ((s.getGridYR() == getGridYL()) && cmp(sYR, thisYL) < 0)) {
// this is above s
//t aktualisieren
if (s.getGridYR() == getGridYL()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
return 1;
} else {
//t aktualisieren
if (s.getGridYR() > getGridYL()) {
t.noCmpGrid++;
} else {
t.noCmpGrid++;
t.noCmpPrecise++;
}
t.noCmpGrid++;
if (getGridYR() < s.getGridYL()) {
return -1;
}
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
t.noCmpGrid++;
if ((getGridYR() == s.getGridYL()) && (cmp(thisYR, sYL) < 0)) {
// s above this
//t aktualisieren
t.noCmpPrecise++;
return -1;
}
//t aktualisieren
if (getGridYR() == s.getGridYL()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if (getGridYL() != s.getGridYL()) {
t.noCmpGrid++;
if (getGridYL() < s.getGridYL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpYL = cmp(thisYL, sYL);
if (cmpYL != 0) {
return cmpYL;
} else {
t.noCmpGrid++;
if (getGridYR() != s.getGridYR()) {
t.noCmpGrid++;
if (getGridYR() < s.getGridYR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
return cmp(thisYR, sYR);
}
}
}
}
/*
1.1 ~compareInPosForMember~
*/
int AVLSegment::compareInPosForMember(AVLSegment& s, int gridXPos,
mpq_class& preciseXPos, int gridYPos, mpq_class& preciseYPos, TestStruct& t){
t.noCallCmpWithPreciseData++;
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();
t.noCmpGrid++;
if ((getGridXR() != getGridXL()) || (cmp(thisXR, thisXL) != 0)) {
if (getGridXR() == getGridXL()) {
t.noCmpPrecise++;
}
thisSlope = (thisYR - thisYL) / (thisXR - thisXL);
thisIsNotVertical = true;
}
t.noCmpGrid++;
if ((s.getGridXR() != s.getGridXL()) || (cmp(sXR, sXL) != 0)) {
if (s.getGridXR() == s.getGridXL()) {
t.noCmpPrecise++;
}
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
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 2;
t.noCmpPrecise = t.noCmpPrecise + 2;
t.noCmpGrid++;
if (gridXL != s.getGridXL()) {
t.noCmpGrid++;
if (gridXL < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
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
t.noCmpGrid++;
if (gridXR != s.getGridXR()) {
t.noCmpGrid++;
if (gridXR < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
return cmp(getPreciseXR(), s.getPreciseXR());
} else {
//t aktualisieren
t.noCmpGrid++;
if (gridYL == gridYR) {
t.noCmpGrid++;
if (s.getGridYL() == s.getGridYR()) {
t.noCmpPrecise++;
if (cmp(getPreciseYL(), getPreciseYR()) == 0) {
t.noCmpPrecise++;
}
}
}
int cmpSlope = cmp(sSlope, thisSlope);
if (cmpSlope != 0) {
return cmpSlope;
} else {
//both segments run on the same line
//the left one is smaller
t.noCmpGrid++;
if (getGridXL() != s.getGridXL()) {
t.noCmpGrid++;
if (getGridXL() < s.getGridXL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpXL = cmp(thisXL, sXL);
if (cmpXL != 0) {
return cmpXL;
} else {
//both segments start in the same XL
t.noCmpGrid++;
if (getGridXR() != s.getGridXR()) {
t.noCmpGrid++;
if (getGridXR() < s.getGridXR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
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.
//t aktualisieren
if (this->getGridYL() < gridYPos) {
t.noCmpGrid = t.noCmpGrid + 3;
t.noCmpPrecise = t.noCmpPrecise + 2;
} else {
t.noCmpGrid = t.noCmpGrid + 4;
t.noCmpPrecise = t.noCmpPrecise + 3;
}
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;
}
}
//t aktualisieren
t.noCmpGrid++;
if (this->getGridXL() == s.getGridXL()) {
t.noCmpGrid++;
if (this->getGridYL() == s.getGridYL()) {
t.noCmpPrecise++;
if (cmp(this->getPreciseXL(), s.getPreciseXL()) == 0) {
t.noCmpPrecise++;
if (cmp(this->getPreciseYL(), s.getPreciseYL()) == 0) {
t.noCmpGrid++;
if (this->getGridYL() == gridYPos) {
t.noCmpGrid++;
t.noCmpPrecise++;
} else {
if ((this->getGridYL() > gridYPos)) {
t.noCmpGrid++;
}
}
}
}
}
}
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.
//t aktualisieren
if (this->getGridYL() < gridYPos) {
t.noCmpGrid = t.noCmpGrid + 3;
t.noCmpPrecise = t.noCmpPrecise + 2;
} else {
t.noCmpGrid = t.noCmpGrid + 4;
t.noCmpPrecise = t.noCmpPrecise + 3;
}
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;
}
}
//t aktualisieren
t.noCmpGrid++;
if (this->getGridXL() == s.getGridXL()) {
t.noCmpGrid++;
if (this->getGridYL() == s.getGridYL()) {
t.noCmpGrid++;
if (cmp(this->getPreciseXL(), s.getPreciseXL()) == 0) {
t.noCmpPrecise++;
if (cmp(this->getPreciseYL(), s.getPreciseYL()) == 0) {
t.noCmpGrid++;
if (this->getGridYL() == gridYPos) {
t.noCmpGrid++;
t.noCmpPrecise++;
} else {
if (this->getGridYL() > gridYPos) {
t.noCmpGrid++;
}
}
}
}
}
}
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
t.noCmpGrid++;
if ((s.getGridYR() < getGridYL())
|| ((s.getGridYR() == getGridYL()) && (cmp(sYR, thisYL) < 0))) {
//t aktualisieren
if (s.getGridYR() == getGridYL()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
// this is above s
return 1;
} else {
//t aktualisieren
if (s.getGridYR() == getGridYL()) {
t.noCmpGrid++;
t.noCmpPrecise++;
} else {
if (s.getGridYR() > getGridYL()) {
t.noCmpGrid++;
}
}
t.noCmpGrid++;
if (getGridYR() < s.getGridYL()) {
return -1;
}
mpq_class thisYR = getPreciseYR() + getGridYR();
mpq_class sYL = s.getPreciseYL() + s.getGridYL();
t.noCmpGrid++;
if ((getGridYR() == s.getGridYL()) && (cmp(thisYR, sYL) < 0)) {
// s above this
//t aktualisieren
t.noCmpPrecise++;
return -1;
}
//t aktualisieren
if (getGridYR() == s.getGridYL()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if (getGridYL() != s.getGridYL()) {
t.noCmpGrid++;
if (getGridYL() < s.getGridYL()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
int cmpYL = cmp(thisYL, sYL);
if (cmpYL != 0) {
return cmpYL;
} else {
t.noCmpGrid++;
if (getGridYR() != s.getGridYR()) {
t.noCmpGrid++;
if (getGridYR() < s.getGridYR()) {
return -1;
} else {
return 1;
}
}
t.noCmpPrecise++;
return cmp(thisYR, sYR);
}
}
}
}
/*
1.1 ~isVertical~
*/
bool AVLSegment::isVertical(TestStruct& t) const {
t.noCmpGrid++;
if (getGridXL() != getGridXR()) {
return false;
} else {
t.noCmpPrecise++;
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 (cmp(thisXL, thisXR) == 0) {
//this is vertical
if (cmp(sXL, sXR) == 0) {
//s is vertical
return true;
} else {
return false;
}
}
if (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, TestStruct& t) {
t.noCallMightIntersect++;
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, TestStruct& t) {
t.noCallIntersect++;
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();
t.noCmpGrid++;
if ((getGridXL() == getGridXR()) && (seg.getGridXL() == seg.getGridXR())
&& (cmp(thisXL, thisXR) == 0) && (cmp(segXL, segXR) == 0)) {
//both are vertical
t.noCmpGrid++;
t.noCmpPrecise = t.noCmpPrecise + 2;
t.noCmpGrid++;
if ((getGridXL() == seg.getGridXL()) && (cmp(thisXL, segXL) == 0)) {
//both segments run on one line
t.noCmpPrecise++;
t.noCmpGrid++;
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~
//t aktualisieren
if (seg.getGridYR() >= getGridYL()) {
t.noCmpGrid++;
if (seg.getGridYR() == getGridYL()) {
t.noCmpPrecise++;
if (cmp(segYR, thisYL) >= 0) {
t.noCmpGrid++;
if (getGridYR() >= seg.getGridYL()) {
t.noCmpGrid++;
if (getGridYR() == seg.getGridYL()) {
t.noCmpPrecise++;
}
}
}
} else {
t.noCmpGrid++;
if (getGridYR() >= seg.getGridYL()) {
t.noCmpGrid++;
if (getGridYR() == seg.getGridYL()) {
t.noCmpPrecise++;
}
}
}
}
return false;
} else {
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 3;
if (seg.getGridYR() == getGridYL()) {
t.noCmpPrecise++;
}
if (getGridYR() == seg.getGridYL()) {
t.noCmpPrecise++;
}
//determine the endpoints
t.noCmpGrid++;
if ((getGridYL() < seg.getGridYL())
|| ((getGridYL() == seg.getGridYL()) && (cmp(thisYL, segYL) <= 0))) {
//overlapping segment starts in (segXL, segYL)
//t aktualisieren
if (getGridYL() == seg.getGridYL()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((seg.getGridYR() < getGridYR())
|| ((seg.getGridYR() == getGridYR()) && (cmp(segYR, thisYR) <= 0))) {
if (seg.getGridYR() == getGridYR()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
//overlapping segment ends in (segXL, segYR)
result.set(segXL, segYL, segXL, segYR, both, t);
return true;
} else {
//overlapping segment ends in (segXL, thisYR)
//t aktualisieren
t.noCmpGrid++;
if (seg.getGridYR() == getGridYR()) {
t.noCmpPrecise++;
}
result.set(seg.getGridXL(), seg.getGridYL(), seg.getGridXL(), getGridYR(),
seg.getPreciseXL(), seg.getPreciseYL(), seg.getPreciseXL(),
getPreciseYR(), both, t);
return true;
}
} else {
//t aktualisieren
t.noCmpGrid++;
if (getGridYL() == seg.getGridYL()) {
t.noCmpPrecise++;
}
//overlapping segment starts in (thisXL, thisYL)
t.noCmpGrid++;
if ((seg.getGridYR() < getGridYR())
|| ((seg.getGridYR() == getGridYR()) && (cmp(segYR, thisYR) <= 0))) {
//overlapping segment ends in (segXL, segYR)
//t aktualisieren
if (seg.getGridYR() == getGridYR()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
result.set(getGridXL(), getGridYL(), getGridXL(), seg.getGridYR(),
getPreciseXL(), getPreciseYL(), getPreciseXL(), seg.getPreciseYR(),
both, t);
return true;
} else {
//overlapping segment ends in (segXL, thisYR)
//t aktualisieren
t.noCmpGrid++;
if (seg.getGridYR() == getGridYR()) {
t.noCmpPrecise++;
}
result.set(getGridXL(), getGridYL(), getGridXL(), getGridYR(),
getPreciseXL(), getPreciseYL(), getPreciseXL(), getPreciseYR(), both,
t);
return true;
}
}
}
} else {
//t aktualisieren
if (getGridXL() == seg.getGridXL()) {
t.noCmpPrecise++;
}
return false;
}
}
//t aktualisieren
if (getGridXL() == getGridXR()) {
t.noCmpGrid++;
if (seg.getGridXL() == seg.getGridXR()) {
t.noCmpPrecise++;
if (cmp(thisXL, thisXR) == 0) {
t.noCmpPrecise++;
}
}
}
t.noCmpGrid++;
if ((getGridXL() == getGridXR()) && (cmp(thisXL, thisXR) == 0)) {
//this segments is vertical
t.noCmpPrecise++;
t.noCmpGrid++;
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
if (seg.getGridXL() >= getGridXL()) {
t.noCmpGrid++;
if ((seg.getGridXL() == getGridXL())) {
t.noCmpPrecise++;
if (cmp(segXL, thisXL) > 0) {
t.noCmpGrid++;
if (getGridXL() >= seg.getGridXR()) {
t.noCmpGrid++;
if (getGridXL() == seg.getGridXR()) {
t.noCmpPrecise++;
}
}
}
} else {
t.noCmpGrid++;
if (getGridXL() >= seg.getGridXR()) {
t.noCmpGrid++;
if (getGridXL() == seg.getGridXR()) {
t.noCmpPrecise++;
}
}
}
}
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, t);
return true;
} else {
return false;
}
} else {
//this runs more left/right than seg
return false;
}
}
//t aktualisieren
if (getGridXL() == getGridXR()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((seg.getGridXL() == seg.getGridXR()) && (cmp(segXL, segXR) == 0)) {
//seg is vertical
t.noCmpPrecise++;
t.noCmpGrid++;
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
//t aktualisieren
if (getGridXL() >= seg.getGridXL()) {
t.noCmpGrid++;
if (getGridXL() == seg.getGridXL()) {
t.noCmpPrecise++;
if (cmp(thisXL, segXL) <= 0) {
t.noCmpGrid++;
if (seg.getGridXL() >= getGridXR()) {
t.noCmpGrid++;
if (seg.getGridXL() == getGridXR()) {
t.noCmpPrecise++;
}
}
}
}
} else {
t.noCmpGrid++;
if (seg.getGridXL() >= getGridXR()) {
t.noCmpGrid++;
if (seg.getGridXL() == getGridXR()) {
t.noCmpPrecise++;
}
}
}
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, t);
return true;
} else {
return false;
}
} else {
//this runs more left/right than seg
//t aktualisieren
if (getGridXL() >= seg.getGridXL()) {
t.noCmpGrid++;
if (getGridXL() == seg.getGridXL()) {
t.noCmpPrecise++;
if (cmp(thisXL, segXL) <= 0) {
t.noCmpGrid++;
if (seg.getGridXL() >= getGridXR()) {
t.noCmpGrid++;
if (seg.getGridXL() == getGridXR()) {
t.noCmpPrecise++;
}
}
}
}
} else {
t.noCmpGrid++;
if (seg.getGridXL() >= getGridXR()) {
t.noCmpGrid++;
if (seg.getGridXL() == getGridXR()) {
t.noCmpPrecise++;
}
}
}
return false;
}
}
//t aktualisieren
if (seg.getGridXL() == seg.getGridXR()) {
t.noCmpPrecise++;
}
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, t);
return true;
} else {
return false;
}
} else {
// the segments are parallel
if (cmp(thisB, segB) == 0) {
//both segments runs on a line
t.noCmpGrid++;
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
//t aktualisieren
if (seg.getGridXR() >= getGridXL()) {
t.noCmpGrid++;
if (getGridXR() >= seg.getGridXL()) {
t.noCmpGrid++;
if (seg.getGridXR() == getGridXL()) {
t.noCmpPrecise++;
if (cmp(segXR, thisXL) >= 0) {
t.noCmpGrid++;
if (getGridXR() == seg.getGridXL()) {
t.noCmpPrecise++;
}
}
} else {
t.noCmpGrid++;
if (getGridXR() == seg.getGridXL()) {
t.noCmpPrecise++;
}
}
}
}
return false;
} else {
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 3;
if (seg.getGridXR() == getGridXL()) {
t.noCmpPrecise++;
}
if (getGridXR() == seg.getGridXL()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((getGridXL() < seg.getGridXL())
|| ((getGridXL() == seg.getGridXL()) && (cmp(thisXL, segXL) < 0))) {
//t aktualisieren
if (getGridXL() == seg.getGridXL()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((getGridXR() < seg.getGridXR())
|| ((getGridXR() == seg.getGridXR()) && (cmp(thisXR, segXR) < 0))) {
//t aktualisieren
if (getGridXR() == seg.getGridXR()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
result.set(segXL, segYL, thisXR, thisYR, both, t);
return true;
} else {
//t aktualisieren
t.noCmpGrid++;
if (getGridXR() == seg.getGridXR()) {
t.noCmpPrecise++;
}
result.set(segXL, segYL, segXR, segYR, both, t);
return true;
}
} else {
//t aktualisieren
t.noCmpGrid++;
if (getGridXL() == seg.getGridXL()) {
t.noCmpPrecise++;
}
t.noCmpGrid++;
if ((getGridXR() < seg.getGridXR())
|| ((getGridXR() == seg.getGridXR()) && (cmp(thisXR, segXR) < 0))) {
//t aktualisieren
if (getGridXR() == seg.getGridXR()) {
t.noCmpGrid++;
t.noCmpPrecise++;
}
result.set(thisXL, thisYL, thisXR, thisYR, both, t);
return true;
} else {
//t aktualisieren
t.noCmpGrid++;
if (getGridXR() == seg.getGridXR()) {
t.noCmpPrecise++;
}
result.set(thisXL, thisYL, segXR, segYR, both, t);
return true;
}
}
}
} else {
return false;
}
}
assert(false);
return false;
}
/*
1 Class SimpleSegment and BoundingSegments
*/
SimpleSegment::SimpleSegment(int gxl, int gyl, int gxr, int gyr, Position gp) :
xl(gxl), yl(gyl), xr(gxr), yr(gyr), p(gp) {
}
BoundingSegments::BoundingSegments(int gxl, int gyl, int gxr, int gyr) {
if (gxl == gxr) {
//the segment is vertical
numSeg = 4;
createBoundingSegments(vertical, gxl, gyl, gxr, gyr);
} else {
if (gyl == gyr) {
//the segment is horizontal
numSeg = 4;
createBoundingSegments(horizontal, gxl, gyl, gxr, gyr);
} else {
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
createBoundingSegments(positivSlope, gxl, gyl, gxr, gyr);
} else {
//the segment has a negativ slope
createBoundingSegments(negativSlope, gxl, gyl, gxr, gyr);
}
}
}
}
BoundingSegments::~BoundingSegments() {
}
void BoundingSegments::createBoundingSegments(Slope s, int gxl, int gyl,
int gxr, int gyr) {
switch (s) {
case vertical: {
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: {
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: {
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: {
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~
*/
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 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)))
&& ((segments[i].getXL() == bs.segments[j].getXL())
&& !(segments[i].getYR() <= bs.segments[j].getYL()
|| segments[i].getYL() >= bs.segments[j].getYR()))) {
//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;
if (isVertical(i)) {
vertical = segments[i];
second = bs.segments[j];
} else {
vertical = bs.segments[j];
second = segments[i];
}
if (second.getXL() <= vertical.getXL()
&& vertical.getXL() <= second.getXR()) {
// the vertical segment lay between XL and XR
long long numerator = second.getYR() - second.getYL();
long long denominator = second.getXR() - second.getXL();
if ((numerator > 0 && denominator > 0)
|| (numerator < 0 && denominator < 0)) {
/* second has a positiv 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/denumerator
* and b=second.getGridYL()-m*second.getGridXL().
* By avoiding double-values we get:
* y=(numerator*vertical.getGridXL()
* + (second.getGridYL()+1)*denumerator
* - numerator*second.getGridXL()) / denumerator.
* 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
&& vertical.getXL() == second.getXL())
|| (second.getPosition() == bottom && vertical.getPosition() == pLeft
&& vertical.getXL() == second.getXR()))) {
long long yValue = (numerator * vertical.getXL()
+ second.getYL() * denominator - numerator * second.getXL())
/ denominator;
//mpz_class pValue = (((int)(numerator)) * vertical.getXL()
// + second.getYL() * ((int)(denominator)) - ((int)(numerator))
//* second.getXL())
// / ((int)(denominator));
//if ((cmp(pValue, numeric_limits<int>::min())<0)
// ||(cmp(numeric_limits<int>::max(), pValue)<0)){
// cerr <<"The grid-value "<<pValue
// <<"don't fit in a variable of type int."<<endl;
// return true;
//}
//if ((cmp(pValue, ((int)yValue))!=0)){
// cerr <<"mightIntersect1 "<<pValue
// <<"is not equal "<<yValue<<endl;
// assert(false);
//}
//int yValue = (int) pValue.get_d();
if (((vertical.getYL() <= yValue && yValue < vertical.getYR())
|| (vertical.getYR() <= yValue && yValue <= vertical.getYL()))
&& !(second.getPosition() == top && vertical.getPosition() == pLeft
&& vertical.getXL() == second.getXR()
&& yValue == vertical.getYL())) {
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
&& vertical.getXL() == second.getXL()))) {
long long yValue = (numerator * vertical.getXL()
+ second.getYL() * denominator - numerator * second.getXL())
/ denominator;
//mpz_class pYValue = (((int)(numerator)) * vertical.getXL()
// + second.getYL() * ((int)(denominator))
//- ((int)(numerator)) * second.getXL())
// / ((int)(denominator));
//if ((cmp(pYValue, numeric_limits<int>::min())<0)
// ||(cmp(numeric_limits<int>::max(), pYValue)<0)){
// cerr <<"The grid-value "<<pYValue
// <<"don't fit in a variable of type int."<<endl;
// return true;
//}
//if ((cmp(pYValue, ((int)yValue))!=0)){
// cerr <<"mightIntersect2 "<<pYValue
// <<"is not equal "<<yValue<<endl;
// assert(false);
//}
//int yValue = (int) pYValue.get_d();
if (((vertical.getYL() <= yValue && yValue <= vertical.getYR())
|| (vertical.getYR() <= yValue && yValue <= vertical.getYL()))
&& !(second.getPosition() == top && vertical.getPosition() == pRight
&& vertical.getXL() == second.getXL()
&& yValue == vertical.getYL())) {
return true;
}
}
} else { // second is horizonal
if (vertical.getPosition() == pLeft) {
if (second.getXL() <= vertical.getXL()
&& vertical.getXL() < second.getXR()
&& vertical.getYL() < second.getYL()
&& second.getYL() < vertical.getYR()) {
return true;
}
} else { //vertical is right
if (second.getXL() < vertical.getXL()
&& vertical.getXL() <= second.getXR()
&& vertical.getYL() < second.getYL()
&& second.getYL() < vertical.getYR()) {
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 = segments[i].getYL() * thisDenom
- segments[i].getXL() * thisNum;
long long segB = bs.segments[j].getYL() * thisDenom
- bs.segments[j].getXL() * thisNum;
//mpz_class pValue1 = segments[i].getYL() * ((int)(thisDenom))
// - segments[i].getXL() * ((int)(thisNum));
//if ((cmp(pValue1, ((int)thisB))!=0)){
// cerr <<"mightIntersect3 "<<pValue1
// <<"is not equal "<<thisB<<endl;
// assert(false);
//}
//mpz_class pValue2 = bs.segments[j].getYL() * ((int)(thisDenom))
// - bs.segments[j].getXL() * ((int)(thisNum));
//if ((cmp(pValue2, ((int)segB))!=0)){
// cerr <<"mightIntersect4 "<<pValue2
// <<"is not equal "<<segB<<endl;
// assert(false);
//}
if (thisB == segB) {
if (!(segments[i].getXR() <= bs.segments[j].getXL()
|| bs.segments[j].getXR() <= segments[i].getXL())) {
return true;
}
}
}
} else { //the segements are not parallel or vertical
long long xNumerator = (thisDenom * bsDenom
* (bs.segments[j].getYL() - segments[i].getYL()))
+ (segments[i].getXL() * bsDenom * thisNum)
- (bs.segments[j].getXL() * thisDenom * bsNum);
long long xDenominator = (thisNum * bsDenom - thisDenom * bsNum);
long long gridX = xNumerator / xDenominator;
//mpz_class pXNumerator = (((int)(thisDenom)) * ((int)(bsDenom))
// * (bs.segments[j].getYL() - segments[i].getYL()))
// + (segments[i].getXL() * ((int)(bsDenom)) * ((int)(thisNum)))
// - (bs.segments[j].getXL() * ((int)(thisDenom)) * ((int)(bsNum)));
//mpz_class pXDenominator = (((int)(thisNum))
//* ((int)(bsDenom)) - ((int)(thisDenom)) * ((int)(bsNum)));
//mpz_class pGridX = pXNumerator / pXDenominator;
//if ((cmp(pGridX, numeric_limits<int>::min())<0)
// ||(cmp(numeric_limits<int>::max(), pGridX)<0)){
// cerr <<"The grid-value "<<pGridX
// <<"don't fit in a variable of type int."<<endl;
// return true;
//}
//int gridX = (int) pGridX.get_d();
//if ((cmp(pGridX, ((int)gridX))!=0)){
// cerr <<"mightIntersect5 "<<pGridX
// <<"is not equal "<<gridX<<endl;
// assert(false);
//}
if ((segments[i].getXL() <= gridX && gridX < segments[i].getXR())
&& (bs.segments[j].getXL() <= gridX
&& gridX < bs.segments[j].getXR())) {
//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
&& segments[i].getXL() == bs.segments[j].getXR())
&& !(segments[i].getPosition() == top
&& bs.segments[j].getPosition() == bottom
&& segments[i].getXR() == bs.segments[j].getXL())) {
if (bs.segments[j].getYL() <= segments[i].getYL()
&& segments[i].getYL() <= bs.segments[j].getYR()) {
return true;
}
}
} else {
if (!(segments[i].getPosition() == bottom
&& bs.segments[j].getPosition() == top
&& segments[i].getXR() == bs.segments[j].getXL())
&& !(segments[i].getPosition() == top
&& bs.segments[j].getPosition() == bottom
&& segments[i].getXL() == bs.segments[j].getXR())) {
if (bs.segments[j].getYR() <= segments[i].getYL()
&& segments[i].getYL() <= bs.segments[j].getYL()) {
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
&& bs.segments[j].getXL() == segments[i].getXR())
&& !(bs.segments[j].getPosition() == top
&& segments[i].getPosition() == bottom
&& bs.segments[j].getXR() == segments[i].getXL())) {
if (segments[i].getYL() <= bs.segments[j].getYL()
&& bs.segments[j].getYL() <= segments[i].getYR()) {
return true;
}
}
} else {
if ((!(bs.segments[j].getPosition() == bottom
&& segments[i].getPosition() == top
&& bs.segments[j].getXR() == segments[i].getXL()))
&& (!(bs.segments[j].getPosition() == top
&& segments[i].getPosition() == bottom
&& bs.segments[j].getXL() == segments[i].getXR()))) {
if (segments[i].getYR() <= bs.segments[j].getYL()
&& bs.segments[j].getYL() <= segments[i].getYL()) {
return true;
}
}
}
} else {
//both segments are not horizontal
long long gridY = ((thisNum * gridX)
+ (segments[i].getYL() * thisDenom)
- (segments[i].getXL() * thisNum)) / thisDenom;
//mpz_class pGridY = ((((int)(thisNum)) * pGridX)
// + (segments[i].getYL() * ((int)(thisDenom)))
// - (segments[i].getXL() * ((int)(thisNum)))) / ((int)(thisDenom));
//if ((cmp(pGridY, numeric_limits<int>::min())<0)
// ||(cmp(numeric_limits<int>::max(), pGridY)<0)){
// cerr <<"The grid-value "<<pGridY
// <<"don't fit in a variable of type int."<<endl;
// return true;
//}
//int gridY = (int) pGridY.get_d();
//if (cmp(pGridY,((int)gridY))!=0){
// cerr<<"mightIntersect6"<<pGridY <<" "<<gridY<<endl;
// assert(false);
//}
int thisYMin = min(segments[i].getYL(), segments[i].getYR());
int thisYMax = max(segments[i].getYL(), segments[i].getYR());
int bsYMin = min(bs.segments[j].getYL(), bs.segments[j].getYR());
int bsYMax = max(bs.segments[j].getYL(), bs.segments[j].getYR());
if ((thisYMin <= gridY && gridY <= thisYMax)
&& (bsYMin <= gridY && gridY <= bsYMax)) {
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~
*/
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 {
vNoCmpGrid++;
if (getGridX() != e.getGridX()) {
vNoCmpGrid++;
if (getGridX() > e.getGridX()) {
return true;
} else {
return false;
}
}
vNoCmpPrecise++;
int cmpX = cmp(getPreciseX(), e.getPreciseX());
if (cmpX != 0) {
if (cmpX > 0) {
return true;
} else {
return false;
}
}
//equal x
vNoCmpGrid++;
if (getGridY() != e.getGridY()) {
vNoCmpGrid++;
if (getGridY() > e.getGridY()) {
return true;
} else {
return false;
}
}
vNoCmpPrecise++;
int cmpY = cmp(getPreciseY(), e.getPreciseY());
if (cmpY != 0) {
if (cmpY > 0) {
return true;
} else {
return false;
}
}
//equal y
TestStruct t;
t.clear();
if (isRightEndpointEvent()) {
if (e.isRightEndpointEvent()) {
mpq_class p = getPreciseX();
bool c = (seg->compareInPosOrLeft(*e.seg, getGridX(), p, t)) == 1;
vNoCmpGrid = vNoCmpGrid + t.noCmpGrid;
vNoCmpPrecise = vNoCmpPrecise + t.noCmpPrecise;
return c;
} 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, t);
if (cmpLSeg != 0) {
vNoCmpGrid = vNoCmpGrid + t.noCmpGrid;
vNoCmpPrecise = vNoCmpPrecise + t.noCmpPrecise;
if (cmpLSeg > 0) {
return true;
} else {
return false;
}
} else {
int cmpGSeg = gSeg->compareInPosOrLeft(*e.gSeg, getGridX(), p, t);
vNoCmpGrid = vNoCmpGrid + t.noCmpGrid;
vNoCmpPrecise = vNoCmpPrecise + t.noCmpPrecise;
if (cmpGSeg > 0) {
return true;
} else {
return false;
}
}
}
if (isLeftEndpointEvent() && e.isLeftEndpointEvent()) {
mpq_class p = getPreciseX();
bool c = (seg->compareInPosOrLeft(*e.seg, getGridX(), p, t)) == 1;
vNoCmpGrid = vNoCmpGrid + t.noCmpGrid;
vNoCmpPrecise = vNoCmpPrecise + t.noCmpPrecise;
return c;
} 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,
TestStruct& t) {
Coordinate* values[3];
p2d::SegmentData* sd1 = new p2d::SegmentData();
p2d::SegmentData* sd2 = new p2d::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])->greaterThan(*values[i], t))) {
//> *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;
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;
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 p2d::Line2& l, int& pos1, const p2d::Line2& r, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event,
TestStruct& t) {
return selectNext<p2d::Line2, p2d::Line2>(l, pos1, r, pos2, q, event, t);
}
/*
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,
mpq_class& scalefactor, TestStruct& t) {
Coordinate* values[3];
p2d::SegmentData* sd1 = new p2d::SegmentData();
p2d::SegmentData* sd2 = new p2d::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()) {
p2d::prepareData(c0.gx, c0.px,
((l1.getLeftGridX(pos1)+l1.getPreciseLeftX(pos1))*scalefactor));
p2d::prepareData(c0.gy, c0.py,
((l1.getLeftGridY(pos1)+l1.getPreciseLeftY(pos1))*scalefactor));
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()) {
p2d::prepareData(c1.gx, c1.px,
((l2.getLeftGridX(pos2)+l2.getPreciseLeftX(pos2))*scalefactor));
p2d::prepareData(c1.gy, c1.py,
((l2.getLeftGridY(pos2)+l2.getPreciseLeftY(pos2))*scalefactor));
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])->greaterThan(*values[i], t))) {
//> *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(l1.getPreciseCoordinates(), sd1,
first, scalefactor);
//AVLSegment* seg1 = new AVLSegment(l1.getPreciseCoordinates(), sd1, first);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
return first;
}
case 1: {
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(l2.getPreciseCoordinates(), sd2,
second, scalefactor);
//AVLSegment* seg2 = new AVLSegment(l2.getPreciseCoordinates(), sd2, second);
Event* result2 = new Event(leftEndpoint, seg2);
event = *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 p2d::Line2& l, int& pos1, const p2d::Line2& r, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event,
mpq_class& scalefactor, TestStruct& t) {
return selectNext<p2d::Line2, p2d::Line2>(l, pos1, r, pos2, q, event,
scalefactor, t);
}
Owner selectNext(/*const*/Region2& r1, int& pos1,
/*const*/Region2& r2, int& pos2,
priority_queue<Event, vector<Event>, greater<Event> >& q, Event& event,
TestStruct& t) {
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]->greaterThan(*values[i], t))) {
//> *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
t.noSegmentsIn++;
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(r1.getpreciseCoordinates(), gs1,
new Reg2PrecHalfSegment(ps1), first);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
return first;
}
case 1: {
t.noSegmentsIn++;
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(r2.getpreciseCoordinates(), gs2,
new Reg2PrecHalfSegment(ps2), second);
Event* result2 = new Event(leftEndpoint, seg2);
event = *result2;
return second;
}
case 2: {
if (e1.isLeftEndpointEvent()){
t.noSegmentsIn++;
}
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& scalefactor, TestStruct& t) {
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()) {
p2d::prepareData(c0.gx, c0.px,
((gs1.GetLeftPointX()
+ps1.GetlPointx(r1.getpreciseCoordinates()))*scalefactor));
p2d::prepareData(c0.gy, c0.py,
((gs1.GetLeftPointY()
+ps1.GetlPointy(r1.getpreciseCoordinates()))*scalefactor));
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()) {
p2d::prepareData(c1.gx, c1.px,
((gs2.GetLeftPointX()
+ps2.GetlPointx(r2.getpreciseCoordinates()))*scalefactor));
p2d::prepareData(c1.gy, c1.py,
((gs2.GetLeftPointY()
+ps2.GetlPointy(r2.getpreciseCoordinates()))*scalefactor));
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]->greaterThan(*values[i], t))) {
//> *values[i])) {
index = i;
}
}
}
switch (index) {
case 0: {
t.noSegmentsIn++;
if (values[1] != 0) {
pos2--;
}
AVLSegment* seg1 = new AVLSegment(r1.getpreciseCoordinates(), gs1,
ps1, first, scalefactor);
Event* result1 = new Event(leftEndpoint, seg1);
event = *result1;
return first;
}
case 1: {
t.noSegmentsIn++;
if (values[0] != 0) {
pos1--;
}
AVLSegment* seg2 = new AVLSegment(r2.getpreciseCoordinates(), gs2,
ps2, second, scalefactor);
Event* result2 = new Event(leftEndpoint, seg2);
event = *result2;
return second;
}
case 2: {
if (e1.isLeftEndpointEvent()){
t.noSegmentsIn++;
}
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;
}
/*
1 ~splitNeighbors~
*/
void splitNeighbors(AVLSegment* current, AVLSegment* neighbor,
AVLSegment* overlappingSegment, AVLSegment* right, TestStruct& t) {
//r starts at he end of overlappingSegment. If neighbor is longer
//than current, r ends in the right endpoint of neighbor
AVLSegment* r;
t.noCmpGrid++;
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
//t aktualisieren
if (neighbor->getGridXR() > current->getGridXR()) {
} else {
if (neighbor->getGridXR() == current->getGridXR()
&& cmp(neighbor->getPreciseXR(), current->getPreciseXR()) > 0) {
t.noCmpGrid++;
t.noCmpPrecise++;
} else {
if ((neighbor->getGridXR() == current->getGridXR())
&& (cmp(neighbor->getPreciseXR(), current->getPreciseXR()) == 0)
&& (neighbor->getGridYR() > current->getGridYR())) {
t.noCmpGrid = t.noCmpGrid + 3;
t.noCmpPrecise = t.noCmpPrecise + 2;
} else {
t.noCmpGrid = t.noCmpGrid + 5;
t.noCmpPrecise = t.noCmpPrecise + 4;
}
}
}
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 {
//t aktualisieren
t.noCmpGrid = t.noCmpGrid + 3;
if (neighbor->getGridXR() == current->getGridXR()) {
t.noCmpPrecise = t.noCmpPrecise + 3;
if (cmp(neighbor->getPreciseXR(), current->getPreciseXR()) == 0) {
t.noCmpGrid = t.noCmpGrid + 2;
if (neighbor->getGridYR() == current->getGridYR()) {
t.noCmpPrecise++;
}
}
}
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, t)) {
// 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 ~intersectionForSetOp~
*/
bool intersectionTestForSetOp(AVLSegment* s1, AVLSegment* s2, Event& event,
priority_queue<Event, vector<Event>, greater<Event> >& q, bool leftIsSmaller,
TestStruct& t) {
if (s1->mightIntersect(*s2, t)) {
AVLSegment* overlappingSegment = new AVLSegment();
if (s1->intersect(*s2, *overlappingSegment, t)) {
if (p2d_debug) {
cout << endl << endl << "s1: ";
s1->print();
cout << "s2: ";
s2->print();
cout << "Schnittpunkt :";
overlappingSegment->print();
cout << endl << endl;
}
if (overlappingSegment->isPoint(t)) {
if (!overlappingSegment->isLeftOf(event, t)) {
if (leftIsSmaller) {
Event ie(intersectionPoint, s1, s2, overlappingSegment);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(ie);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
} else {
Event ie(intersectionPoint, s2, s1, overlappingSegment);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(ie);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
}
} else {
AVLSegment* right = new AVLSegment();
splitNeighbors(s1, s2, overlappingSegment, right, t);
if (s1->getOwner() == both) {
Event e1(rightEndpoint, s1);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(e1);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
if (leftIsSmaller) {
Event ie2(intersectionPoint, s1, s2, overlappingSegment);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(ie2);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
} else {
Event ie2(intersectionPoint, s2, s1, overlappingSegment);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(ie2);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
Event e2(rightEndpoint, s2);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(e2);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
if (!right->isPoint(t)) {
Event e3(leftEndpoint, right);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(e3);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
} 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,
TestStruct& t) {
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) {
t.noCmpGrid = t.noCmpGrid + 2;
t.noCmpPrecise = t.noCmpPrecise + 2;
if (e.isValid()) {
if (seg->compareInPosOrLeft(*(e.getLeftSegment()), event.getGridX(), v, t)
< 0) {
t.noCallCmpWithPreciseData--;
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(), t)))) {
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);
}
} else {
t.noCallCmpWithPreciseData--;
}
}
q.pop();
e = q.top();
}
//t aktualisieren
if (e.isIntersectionEvent()) {
t.noCmpGrid++;
if (e.getGridX() == event.getGridX()) {
t.noCmpGrid++;
if (e.getGridY() == event.getGridY()) {
t.noCmpPrecise++;
if (cmp(e.getPreciseX(), event.getPreciseX()) == 0) {
t.noCmpPrecise++;
}
}
}
}
if (segmentVector.back()->compareInPosOrLeft(*r, event.getGridX(), v, t) < 0) {
t.noCallCmpWithPreciseData--;
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;
}
} else {
t.noCallCmpWithPreciseData--;
}
}
/*
1 ~createNewSegments~
*/
void createNewSegments(AVLSegment& s, p2d::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, p2d::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,
p2d::Line2& result, int& edgeno, SetOperation op, TestStruct& t) {
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, t);
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;
}
}
}
void createNewSegments(vector<AVLSegment*>& segmentVector, Event& event,
p2d::Line2& result, int& edgeno, SetOperation op,
mpq_class& internalScalefactor, TestStruct& t) {
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, t);
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, TestStruct& t) {
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, t);
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py, t);
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
} //end intersects region x region -> bool
/*
1 ~createNewSegments~
*/
void createNewSegments(vector<AVLSegment*>& segmentVector, Event& event,
AVLSegment* successor, Region2& result, int& edgeno, int scalefactor,
SetOperation op, mpq_class& internalScalefactor, TestStruct& t) {
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, t);
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py, t);
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;
p2d::prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
//Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
// s->getGridYL(), 0);
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
p2d::prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
// event.getPreciseY(), event.getGridY(), 0);
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;
p2d::prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s->getPreciseXL(), s->getGridXL(), s->getPreciseYL(),
// s->getGridYL(), 0);
p2d::prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
p2d::prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
// event.getPreciseY(), event.getGridY(), 0);
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;
p2d::prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
p2d::prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s->getPreciseXL(),
//s->getGridXL(), s->getPreciseYL(),
// s->getGridYL(), 0);
//Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
// event.getPreciseY(), event.getGridY(), 0);
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;
p2d::prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
p2d::prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s->getPreciseXL(),
//s->getGridXL(), s->getPreciseYL(),
// s->getGridYL(), 0);
//Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
// event.getPreciseY(), event.getGridY(), 0);
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;
p2d::prepareData(x, px,
((s->getGridXL()+s->getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s->getGridYL()+s->getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((event.getGridX()+event.getPreciseX())/internalScalefactor));
p2d::prepareData(y, py,
((event.getGridY()+event.getPreciseY())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s->getPreciseXL(),
//s->getGridXL(), s->getPreciseYL(),
// s->getGridYL(), 0);
//Reg2PrecisePoint p2(event.getPreciseX(), event.getGridX(),
// event.getPreciseY(), event.getGridY(), 0);
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
} //end intersects region x region -> bool
/*
1 ~checkSegments~
*/
void checkSegments(vector<AVLSegment*>& segmentVector, Event& event,
AVLSegment* successor, bool& result, RelationshipOperation op,
TestStruct& t) {
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, t);
bool endsInEventpoint = s->endsInPoint(event.getGridX(), event.getGridY(), px,
py, t);
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" << endl;
seg.print();
}
result = false;
}
break;
}
case second: {
if ((seg.getConAbove() + seg.getConBelow()) != 1) {
if (p2d_debug) {
cout << "r1 is not within r2" << 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" << 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(), 0);
Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
s.getGridYR(), 0);
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);
}
}
}
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;
p2d::prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
// s.getGridYL(), 0);
//Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
// s.getGridYR(), 0);
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;
p2d::prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
// s.getGridYL(), 0);
//Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
// s.getGridYR(), 0);
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;
p2d::prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
// s.getGridYL(), 0);
//Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
// s.getGridYR(), 0);
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;
p2d::prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
// s.getGridYL(), 0);
//Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
// s.getGridYR(), 0);
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;
p2d::prepareData(x, px,
((s.getGridXL()+s.getPreciseXL())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYL()+s.getPreciseYL())/internalScalefactor));
Reg2PrecisePoint p1(px, x, py, y, scalefactor);
p2d::prepareData(x, px,
((s.getGridXR()+s.getPreciseXR())/internalScalefactor));
p2d::prepareData(y, py,
((s.getGridYR()+s.getPreciseYR())/internalScalefactor));
Reg2PrecisePoint p2(px, x, py, y, scalefactor);
//Reg2PrecisePoint p1(s.getPreciseXL(), s.getGridXL(), s.getPreciseYL(),
// s.getGridYL(), 0);
//Reg2PrecisePoint p2(s.getPreciseXR(), s.getGridXR(), s.getPreciseYR(),
// s.getGridYR(), 0);
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 ~SetOp~ for ~Line2~
*/
void SetOp(const p2d::Line2& line1, const p2d::Line2& line2, p2d::Line2& result,
SetOperation op, TestStruct& t, const Geoid* geoid/*=0*/) {
t.clear();
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();
p2d::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, t)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false, t);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true, t);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} 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, t);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
}
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection- with" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true, t);
}
if (p2d_debug && suc) {
cout << "intersection- with" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true, t);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, result, edgeno, op, t);
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad(true, false);
} // setop line2 x line2 -> line2
/*
1 ~intersects~
*/
bool intersects(const p2d::Line2& line1, const p2d::Line2& line2, TestStruct& t,
const Geoid* geoid/*=0*/) {
t.clear();
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, t)) != none)) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
if (current->getOwner() == both) {
intersect = true;
}
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false, t)) {
if ((pred->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true, t)) {
if ((suc->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
sss.removeGetNeighbor(current, pred, suc, t);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true, t)) {
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true, t)) {
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection- for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true, t)) {
if (pred->getOwner() != right->getOwner()) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection- for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true, t)) {
if (suc->getOwner() != left->getOwner()) {
intersect = true;
}
}
}
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return intersect;
} // intersects line2 x line2 -> bool
/*
1 ~SetOp~ for ~Line2~
*/
void SetOpWithScaling(const p2d::Line2& line1, const p2d::Line2& line2,
p2d::Line2& result,
SetOperation op, TestStruct& t, const Geoid* geoid/*=0*/) {
t.clear();
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();
p2d::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 = p2d::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, t)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false, t);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true, t);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} 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, t);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
}
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection- with" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true, t);
}
if (p2d_debug && suc) {
cout << "intersection- with" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true, t);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, result, edgeno,
op, internalScalefactor, t);
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
result.EndBulkLoad(true, false);
} // setopWithScaling line2 x line2 -> line2
/*
1 ~intersects~
*/
bool intersectsWithScaling(const p2d::Line2& line1, const p2d::Line2& line2,
TestStruct& t,
const Geoid* geoid/*=0*/) {
t.clear();
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 = p2d::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, t)) != none)) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
if (current->getOwner() == both) {
intersect = true;
}
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false, t)) {
if ((pred->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true, t)) {
if ((suc->getOwner() != current->getOwner())
|| (current->getOwner() == both)) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} else {
if (event.isRightEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
if (current->isValid()){
sss.removeGetNeighbor(current, pred, suc, t);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true, t)) {
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true, t)) {
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection- for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true, t)) {
if (pred->getOwner() != right->getOwner()) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection- for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true, t)) {
if (suc->getOwner() != left->getOwner()) {
intersect = true;
}
}
}
}
}
}
}
if (p2d_debug) {
cout << "the tree:" << endl;
sss.inorder();
}
}
return intersect;
} // intersectsWithScaling line2 x line2 -> bool
/*
1 ~SetOp~ for ~Region2~
*/
void SetOp(/*const*/Region2& reg1, /*const*/Region2& reg2, Region2& result,
SetOperation op, TestStruct& t, const Geoid* geoid/*=0*/) {
t.clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
result.Clear();
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())) {
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, t)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false, t);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true, t);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} 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, t);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
}
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true, t);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true, t);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, suc, result, edgeno,
reg1.GetScaleFactor(), op, t);
} 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, TestStruct& t,
const Geoid* geoid/*=0*/) {
t.clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())) {
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, t)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false, t)) {
if ((pred->getOwner() != current->getOwner())) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true, t)) {
if ((suc->getOwner() != current->getOwner())) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} 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, t);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true, t)) {
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
if(intersectionTestForSetOp(pred, suc, event, q, true, t)){
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection- for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true, t)) {
if ((pred->getOwner() != right->getOwner())) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection- for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true, t)) {
if ((suc->getOwner() != left->getOwner())) {
intersect = true;
}
}
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, intersect, intersects_op, t);
} 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 ~SetOp~ for ~Region2~
*/
void SetOpWithScaling(/*const*/Region2& reg1, /*const*/Region2& reg2,
Region2& result,
SetOperation op, TestStruct& t, const Geoid* geoid/*=0*/) {
t.clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
result.Clear();
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())) {
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);
}
}
mpq_class internalScalefactor = p2d::computeScalefactor(reg1, reg2);
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, t)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
mpq_class v = current->getPreciseXL();
if (pred) {
intersectionTestForSetOp(current, pred, event, q, false, t);
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
intersectionTestForSetOp(current, suc, event, q, true, t);
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} 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, t);
current->changeValidity(false);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
intersectionTestForSetOp(pred, suc, event, q, true, t);
}
}
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection-test for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
intersectionTestForSetOp(pred, right, event, q, true, t);
}
if (p2d_debug && suc) {
cout << "intersection-test for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
intersectionTestForSetOp(left, suc, event, q, true, t);
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
createNewSegments(segmentVector, event, suc, result, edgeno,
reg1.GetScaleFactor(), op, internalScalefactor, t);
} 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();
} // setOPWithScaling region2 x region2 -> region2
/*
1 ~intersects~
*/
bool intersectsWithScaling(/*const*/Region2& reg1, /*const*/Region2& reg2,
TestStruct& t, const Geoid* geoid/*=0*/) {
t.clear();
if (geoid) {
cerr << ": Spherical geometry not implemented." << endl;
assert(false);
}
if (!reg1.IsDefined() || !reg2.IsDefined() || (geoid && !geoid->IsDefined())) {
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 = p2d::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, t)) != none) {
if (event.isLeftEndpointEvent()) {
if (p2d_debug) {
event.print();
}
current = event.getSegment();
sss.insert(current, pred, suc, t);
mpq_class v = current->getPreciseXL();
if (pred) {
if (intersectionTestForSetOp(current, pred, event, q, false, t)) {
if ((pred->getOwner() != current->getOwner())) {
intersect = true;
}
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
} else {
if (suc) {
if (intersectionTestForSetOp(current, suc, event, q, true, t)) {
if ((suc->getOwner() != current->getOwner())) {
intersect = true;
}
}
if (!current->isValid()) {
sss.removeInvalidSegment(current, event.getGridX(), v, t);
}
}
}
if (current->isValid() && !(current->getOwner() == both)) {
Event re(rightEndpoint, current);
vNoCmpGrid = 0;
vNoCmpPrecise = 0;
q.push(re);
t.noCmpGrid = t.noCmpGrid + vNoCmpGrid;
t.noCmpPrecise = t.noCmpPrecise + vNoCmpPrecise;
}
} 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, t);
current->changeValidity(false);
if (pred && suc) {
if (intersectionTestForSetOp(pred, suc, event, q, true, t)) {
if ((pred->getOwner() != suc->getOwner())) {
intersect = true;
}
}
}
} else {
mpq_class v1 = event.getPreciseX();
sss.removeGetNeighbor2(current, event.getGridX(), v1, pred, suc, t);
if (pred && suc) {
if(intersectionTestForSetOp(pred, suc, event, q, true, t)){
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, t);
if (inversionNecessary) {
left = segmentVector.at(0);
right = segmentVector.back();
sss.invertSegments(segmentVector, event.getGridX(), v1,
event.getGridY(), v2, pred, predIndex, suc, sucIndex, t);
if (p2d_debug && pred) {
cout << "intersection- for" << endl;
right->print();
cout << " and " << endl;
pred->print();
}
if (pred) {
if (intersectionTestForSetOp(pred, right, event, q, true, t)) {
if ((pred->getOwner() != right->getOwner())) {
intersect = true;
}
}
}
if (p2d_debug && suc) {
cout << "intersection- for" << endl;
left->print();
cout << " and " << endl;
suc->print();
}
if (suc) {
if (intersectionTestForSetOp(left, suc, event, q, true, t)) {
if ((suc->getOwner() != left->getOwner())) {
intersect = true;
}
}
}
mpq_class px = event.getPreciseX();
mpq_class py = event.getPreciseY();
checkSegments(segmentVector, event, suc, intersect, intersects_op, t);
} 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;
} // intersectsWithScaling region2 x region2 -> bool
} //end of p2d_
#endif /* TESTAVLTREE_CPP_*/
Reference in New Issue View Git Blame Copy Permalink