794 lines
24 KiB
C++
794 lines
24 KiB
C++
|
/*
|
||
|
|
|
||
|
|
see Lines.h for documentation
|
||
|
|
|
||
|
|
\tableofcontents
|
||
|
|
|
||
|
|
*/
|
||
|
|
#include "RegionInterpolator.h"
|
||
|
|
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
namespace RegionInterpol
|
||
|
|
{
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Constructors and Destructor
|
||
|
|
|
||
|
|
*/
|
||
|
|
Match :: Match (RegionForInterpolation *src, RegionForInterpolation *trgt,
|
||
|
|
string nam,string dscrpton)
|
||
|
|
{
|
||
|
|
description = dscrpton;
|
||
|
|
name = nam;
|
||
|
|
source = src;
|
||
|
|
target = trgt;
|
||
|
|
vector <vector <LineWA*> > tmp;
|
||
|
|
tmp.resize (source->getNrOfFaces() + target->getNrOfFaces());
|
||
|
|
for(int i = 0; i<source->getNrOfFaces(); i++)
|
||
|
|
{
|
||
|
|
vector<LineWA> tmpline = source->getFace(i)->getCycle()->getOutLine();;
|
||
|
|
tmp[i].resize(tmpline.size());
|
||
|
|
for(unsigned int j = 0; j < tmpline.size(); j++)
|
||
|
|
{
|
||
|
|
tmp[i][j] = new LineWA(&tmpline[j]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for(int i = 0; i < target->getNrOfFaces(); i++)
|
||
|
|
{
|
||
|
|
vector<LineWA> tmpline = target->getFace(i)->getCycle()->getOutLine();;
|
||
|
|
tmp[i + source->getNrOfFaces()].resize(tmpline.size());
|
||
|
|
for(unsigned int j = 0; j < tmpline.size(); j++)
|
||
|
|
{
|
||
|
|
tmp[i + source->getNrOfFaces()][j] = new LineWA(&tmpline[j]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
greatestDist = Utils::getMaxDistance(tmp);
|
||
|
|
LineWA* del;
|
||
|
|
for(vector <vector <LineWA*> >::iterator it1= tmp.begin(); it1!=
|
||
|
|
tmp.end(); ++it1)
|
||
|
|
{
|
||
|
|
for(vector<LineWA*>::iterator it2= (*it1).begin(); it2 !=
|
||
|
|
(*it1).end(); ++it2)
|
||
|
|
{
|
||
|
|
del= (*it2);
|
||
|
|
delete del;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Get functions
|
||
|
|
|
||
|
|
1.1 getName()
|
||
|
|
|
||
|
|
*/
|
||
|
|
string Match :: getName()
|
||
|
|
{
|
||
|
|
return(name);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getDescription()
|
||
|
|
|
||
|
|
*/
|
||
|
|
string Match :: getDescription()
|
||
|
|
{
|
||
|
|
return(description);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getAreaRating()
|
||
|
|
|
||
|
|
*/
|
||
|
|
double Match :: getAreaRating()
|
||
|
|
{
|
||
|
|
return(Arearating);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getOverlapRating()
|
||
|
|
|
||
|
|
*/
|
||
|
|
double Match :: getOverlapRating()
|
||
|
|
{
|
||
|
|
return(Ovelaprating);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getHausdorffRating()
|
||
|
|
|
||
|
|
*/
|
||
|
|
double Match :: getHausdorffRating()
|
||
|
|
{
|
||
|
|
return(Hausdorffrating);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getLinarRating()
|
||
|
|
|
||
|
|
*/
|
||
|
|
double Match :: getLinarRating()
|
||
|
|
{
|
||
|
|
return(linearRating);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getRating()
|
||
|
|
|
||
|
|
*/
|
||
|
|
double Match::getRating(double AreaWeight, double OverlapWeigth,
|
||
|
|
double HausdorffWeight, double LinearWeigth)
|
||
|
|
{
|
||
|
|
return(Arearating * AreaWeight + Ovelaprating * OverlapWeigth +
|
||
|
|
linearRating * LinearWeigth + Hausdorffrating * HausdorffWeight);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getSource()
|
||
|
|
|
||
|
|
*/
|
||
|
|
RegionForInterpolation *Match :: getSource()
|
||
|
|
{
|
||
|
|
return(source);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getTarget()
|
||
|
|
|
||
|
|
*/
|
||
|
|
RegionForInterpolation *Match :: getTarget()
|
||
|
|
{
|
||
|
|
return(target);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Match::setSource(RegionForInterpolation *arg)
|
||
|
|
{
|
||
|
|
source= arg;
|
||
|
|
}
|
||
|
|
void Match::setTarget(RegionForInterpolation *arg)
|
||
|
|
{
|
||
|
|
target= arg;
|
||
|
|
}
|
||
|
|
void Match::nullify()
|
||
|
|
{
|
||
|
|
source=0;
|
||
|
|
target=0;
|
||
|
|
for(map<int, SingleMatch*>::iterator it= maps.begin(); it!=
|
||
|
|
maps.end(); ++it)
|
||
|
|
(*it).second=0;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getMatches()
|
||
|
|
|
||
|
|
*/
|
||
|
|
vector<RegionTreeNode*> Match :: getMatches(RegionTreeNode *source)
|
||
|
|
{
|
||
|
|
int sourceHash = findIndex(source);
|
||
|
|
vector <RegionTreeNode*> res;
|
||
|
|
if(maps.find(sourceHash) == maps.end())
|
||
|
|
{
|
||
|
|
return(res);
|
||
|
|
}
|
||
|
|
SingleMatch* tmp = maps[sourceHash];
|
||
|
|
tmp->removeNulls();
|
||
|
|
for(int i = 0; i < tmp->getNrTargets(); i++)
|
||
|
|
{
|
||
|
|
res.push_back(tmp->getTargetAt(i));
|
||
|
|
}
|
||
|
|
return(res);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getMaps()
|
||
|
|
|
||
|
|
*/
|
||
|
|
map<int, SingleMatch*> Match :: getMaps()
|
||
|
|
{
|
||
|
|
return(maps);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 getTargetChildren()
|
||
|
|
|
||
|
|
*/
|
||
|
|
vector<ConvexHullTreeNode*> Match :: getTargetChildren(RegionTreeNode *source)
|
||
|
|
{
|
||
|
|
vector<RegionTreeNode*> tmp = getMatches(source);
|
||
|
|
vector<ConvexHullTreeNode*> res;
|
||
|
|
for(unsigned int i = 0; i < tmp.size(); i++)
|
||
|
|
{
|
||
|
|
if(dynamic_cast <Face*> (tmp[i]))
|
||
|
|
{
|
||
|
|
Face* tmpFace = (Face*) tmp[i];
|
||
|
|
vector <ConvexHullTreeNode*> tmpCHTN =
|
||
|
|
tmpFace->getCycle()->getChildren();
|
||
|
|
for(unsigned int j = 0; j < tmpCHTN.size(); j++)
|
||
|
|
{
|
||
|
|
res.push_back(tmpCHTN.at(j));
|
||
|
|
}
|
||
|
|
|
||
|
|
for(int j = 0; j < tmpFace->getNrOfHoles(); j++)
|
||
|
|
{
|
||
|
|
res.push_back(tmpFace->getHole(j));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(dynamic_cast <ConvexHullTreeNode*> (tmp[i]))
|
||
|
|
{
|
||
|
|
ConvexHullTreeNode* tmpCHTN = (ConvexHullTreeNode*)tmp[i];
|
||
|
|
vector<ConvexHullTreeNode*> tmpChildren = tmpCHTN->getChildren();
|
||
|
|
for(unsigned int j = 0 ; j< tmpChildren.size(); j++)
|
||
|
|
{
|
||
|
|
res.push_back(tmpChildren.at(j));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return(res);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Set functions
|
||
|
|
|
||
|
|
1.1 addMatch()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: addMatch(RegionTreeNode *source, RegionTreeNode *target)
|
||
|
|
{
|
||
|
|
int sourceHash = findIndex(source);
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<< "addMatch: "<< source->hashCode()<< " " << target->hashCode()<< endl;
|
||
|
|
#endif
|
||
|
|
if(maps.find(sourceHash) == maps.end())
|
||
|
|
{
|
||
|
|
SingleMatch *tmp = new SingleMatch(source,target);
|
||
|
|
maps.insert(map<int, SingleMatch*> :: value_type(sourceHash, tmp));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(maps[sourceHash]->getSource()->equals(source))
|
||
|
|
{
|
||
|
|
maps[sourceHash]->addTarget(target);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "echtes Problem" << endl;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 addName()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: addName(string newName)
|
||
|
|
{
|
||
|
|
name += '\n' + newName;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 removeMatches()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: removeMatches(RegionTreeNode *toDelete)
|
||
|
|
{
|
||
|
|
if(toDelete != NULL)
|
||
|
|
{
|
||
|
|
removeSingleMatch(toDelete);
|
||
|
|
if(dynamic_cast <ConvexHullTreeNode*> (toDelete))
|
||
|
|
{
|
||
|
|
vector <ConvexHullTreeNode*> children = ((ConvexHullTreeNode*)
|
||
|
|
toDelete)->getChildren();
|
||
|
|
for(unsigned int i = 0; i < children.size(); i++)
|
||
|
|
{
|
||
|
|
removeMatches(children.at(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(dynamic_cast <Face*> (toDelete))
|
||
|
|
{
|
||
|
|
Face* deleteFace=( (Face*) toDelete);
|
||
|
|
removeMatches(deleteFace->getCycle());
|
||
|
|
for(int i = 0; i<deleteFace->getNrOfHoles(); i++)
|
||
|
|
{
|
||
|
|
removeMatches(deleteFace->getHole(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(dynamic_cast <Region*> (toDelete))
|
||
|
|
{
|
||
|
|
RegionForInterpolation* deleteRegion = ((RegionForInterpolation*)
|
||
|
|
toDelete);
|
||
|
|
for(int i = 0; i < deleteRegion->getNrOfFaces(); i++)
|
||
|
|
{
|
||
|
|
removeMatches(deleteRegion->getFace(i));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Public Methods
|
||
|
|
|
||
|
|
1.1 finalize()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: finalize()
|
||
|
|
{
|
||
|
|
map <int, SingleMatch*> :: iterator iter = maps.begin();
|
||
|
|
while(iter != maps.end())
|
||
|
|
{
|
||
|
|
SingleMatch *tmp = (*iter).second;
|
||
|
|
tmp->removeNulls();
|
||
|
|
iter++;
|
||
|
|
if(tmp->getNrTargets() == 1 &&
|
||
|
|
dynamic_cast <ConvexHullTreeNode*> (tmp->getTargetAt(0)))
|
||
|
|
//1 to 1 Match of ConvexHullTrees search and delete huge rotatings
|
||
|
|
{
|
||
|
|
ConvexHullTreeNode *stmp = (ConvexHullTreeNode*) tmp->getSource();
|
||
|
|
ConvexHullTreeNode *ttmp=(ConvexHullTreeNode*) tmp->getTargetAt(0);
|
||
|
|
|
||
|
|
if( (dynamic_cast <ConvexHullTreeNode*> (stmp->getParentNode())) &&
|
||
|
|
(dynamic_cast <ConvexHullTreeNode*> (ttmp->getParentNode())) )
|
||
|
|
{
|
||
|
|
ConvexHullTreeNode *parentS = ((ConvexHullTreeNode*)
|
||
|
|
stmp->getParentNode());
|
||
|
|
ConvexHullTreeNode *parentT = ((ConvexHullTreeNode*)
|
||
|
|
ttmp->getParentNode());
|
||
|
|
vector<LineWA*> linesS = parentS->getLineForChild(stmp);
|
||
|
|
vector<LineWA*> linesT = parentT->getLineForChild(ttmp);
|
||
|
|
if(linesS.size() == 2 && linesT.size() == 2)
|
||
|
|
{
|
||
|
|
vector<LineWA> *linesNeiS = new vector <LineWA> (4);
|
||
|
|
vector<LineWA> *linesNeiT = new vector <LineWA> (4);
|
||
|
|
linesNeiS->at(1) = linesS[0];
|
||
|
|
linesNeiS->at(2) = linesS[1];
|
||
|
|
linesNeiT->at(1) = linesT[0];
|
||
|
|
linesNeiT->at(2) = linesT[1];
|
||
|
|
vector <LineWA> parentSLL = parentS->getOutLine();
|
||
|
|
vector <LineWA> parentTLL = parentT->getOutLine();
|
||
|
|
for(unsigned int i = 0; i < parentSLL.size(); i++)
|
||
|
|
{
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << parentSLL[i] << " vs. " << *linesS[0] << endl;
|
||
|
|
cout << parentSLL[(i + 1) % parentSLL.size()] <<
|
||
|
|
" vs. " << linesS[1] << endl;
|
||
|
|
#endif
|
||
|
|
if(parentSLL[i].equals(linesS[0]) &&
|
||
|
|
parentSLL[(i+1)%parentSLL.size()].equals(linesS[1]))
|
||
|
|
{
|
||
|
|
linesNeiS->at(0) = parentSLL[(i-1+parentSLL.size())%
|
||
|
|
parentSLL.size()];
|
||
|
|
linesNeiS->at(3)=parentSLL[(i+2)%parentSLL.size()];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for(unsigned int i = 0; i < parentTLL.size(); i++)
|
||
|
|
{
|
||
|
|
if(parentTLL[i].equals(linesT[0]) && parentTLL[ (i+1) %
|
||
|
|
parentTLL.size()] .equals(linesT[1]))
|
||
|
|
{
|
||
|
|
linesNeiT->at(0)=parentTLL[(i-1+parentTLL.size()) %
|
||
|
|
parentTLL.size()];
|
||
|
|
linesNeiT->at(3)=parentTLL[(i+2)%parentTLL.size()];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Utils :: computeLineAngles(linesNeiS);
|
||
|
|
Utils :: computeLineAngles(linesNeiT);
|
||
|
|
double angleT = linesNeiT->at(1).getAngle();
|
||
|
|
double angleS = linesNeiS->at(1).getAngle();
|
||
|
|
if(linesNeiS->at(0).getAngle()>linesNeiS->at(1).getAngle())
|
||
|
|
{
|
||
|
|
linesNeiS->at(1).setAngle
|
||
|
|
(linesNeiS->at(1).getAngle() + 2 * M_PI);
|
||
|
|
}
|
||
|
|
if(linesNeiS->at(1).getAngle()>linesNeiS->at(2).getAngle())
|
||
|
|
{
|
||
|
|
linesNeiS->at(2).setAngle
|
||
|
|
(linesNeiS->at(2).getAngle() + 2 * M_PI);
|
||
|
|
}
|
||
|
|
if(linesNeiT->at(0).getAngle()>linesNeiT->at(1).getAngle())
|
||
|
|
{
|
||
|
|
linesNeiT->at(1).setAngle
|
||
|
|
(linesNeiT->at(1).getAngle() + 2 * M_PI);
|
||
|
|
}
|
||
|
|
if(linesNeiT->at(1).getAngle()>linesNeiT->at(2).getAngle())
|
||
|
|
{
|
||
|
|
linesNeiT->at(2).setAngle
|
||
|
|
(linesNeiT->at(2).getAngle() + 2 * M_PI);
|
||
|
|
}
|
||
|
|
if( (angleS<linesNeiT->at(0).getAngle() ||
|
||
|
|
angleS > linesNeiT->at(2).getAngle() ) &&
|
||
|
|
(angleS + 2 * M_PI < linesNeiT->at(0).getAngle() ||
|
||
|
|
angleS + 2 * M_PI > linesNeiT->at(2).getAngle() ) )
|
||
|
|
{
|
||
|
|
tmp->removeTargets();
|
||
|
|
}
|
||
|
|
if( (angleT < linesNeiS->at(0).getAngle() ||
|
||
|
|
angleT > linesNeiS->at(2).getAngle() ) &&
|
||
|
|
(angleT + 2 * M_PI < linesNeiS->at(0).getAngle() ||
|
||
|
|
angleT + 2 * M_PI > linesNeiS->at(2).getAngle() ) )
|
||
|
|
{
|
||
|
|
tmp->removeTargets();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(tmp!=NULL&&tmp->getNrTargets()>1)
|
||
|
|
//1 to N Match
|
||
|
|
{
|
||
|
|
if(dynamic_cast<Face*>(tmp->getSource()))
|
||
|
|
//1 to N Match of Faces try to split them
|
||
|
|
{
|
||
|
|
Face *sou = (Face*) tmp->getSource();
|
||
|
|
Face *t1 = (Face*) tmp->getTargetAt(0);
|
||
|
|
Face *t2 = (Face*) tmp->getTargetAt(1);
|
||
|
|
RegionForInterpolation *parentsou = sou->getParent();
|
||
|
|
removeMatches(sou);
|
||
|
|
removeMatches(t1);
|
||
|
|
removeMatches(t2);
|
||
|
|
vector<Face*> *newSources = parentsou->splitOnLine(sou->
|
||
|
|
getCycle()->getSplitLine(t1->getCycle() , t2->getCycle()));
|
||
|
|
if( newSources->size() == 2 &&
|
||
|
|
newSources->at(0) != NULL &&
|
||
|
|
newSources->at(1) != NULL)
|
||
|
|
{
|
||
|
|
vector<Face*> *oldtargets = new vector<Face*> (2);
|
||
|
|
oldtargets->at(0) = t1;
|
||
|
|
oldtargets->at(1) = t2;
|
||
|
|
vector<Face*> new1;
|
||
|
|
vector<Face*> new2;
|
||
|
|
vector<Face*> old1;
|
||
|
|
vector<Face*> old2;
|
||
|
|
new1.push_back(newSources->at(0));
|
||
|
|
new2.push_back(newSources->at(1));
|
||
|
|
old1.push_back(getBestMatch(newSources->at(0), oldtargets));
|
||
|
|
old2.push_back(getBestMatch(newSources->at(1), oldtargets));
|
||
|
|
matchFaces(&new1, &old1);
|
||
|
|
matchFaces(&new2, &old2);
|
||
|
|
for(int i = 2; i< tmp->getNrTargets(); i++)
|
||
|
|
{
|
||
|
|
vector<Face*> tmpTar;
|
||
|
|
tmpTar.push_back(( (Face*) tmp->getTargetAt(i)));
|
||
|
|
vector<Face*> tmpSour;
|
||
|
|
tmpSour.push_back(getBestMatch(tmpTar[0], newSources));
|
||
|
|
matchFaces(&tmpSour, &tmpTar);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
//Split failed match each face with best matched
|
||
|
|
{
|
||
|
|
vector<Face*> tmpSour;
|
||
|
|
tmpSour.push_back(sou);
|
||
|
|
vector<Face*> tmpTar;
|
||
|
|
vector<Face*> tmpTar2;
|
||
|
|
for(int i = 0; i < tmp->getNrTargets(); i++)
|
||
|
|
{
|
||
|
|
tmpTar.push_back( (Face*) tmp->getTargetAt(i));
|
||
|
|
}
|
||
|
|
tmpTar2.push_back(getBestMatch(sou, &tmpTar));
|
||
|
|
matchFaces(&tmpSour, &tmpTar2);
|
||
|
|
}
|
||
|
|
iter =maps.begin();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if(dynamic_cast<ConvexHullTreeNode*>(tmp->getSource()))
|
||
|
|
{
|
||
|
|
vector<ConvexHullTreeNode*> tmpSour;
|
||
|
|
tmpSour.push_back( (ConvexHullTreeNode*) tmp->getSource());
|
||
|
|
removeMatches((ConvexHullTreeNode*) tmp->getSource());
|
||
|
|
vector<ConvexHullTreeNode*> tmpTar;
|
||
|
|
vector<ConvexHullTreeNode*> tmpTar2;
|
||
|
|
for(int i = 0; i < tmp->getNrTargets(); i++)
|
||
|
|
{
|
||
|
|
tmpTar.push_back( (ConvexHullTreeNode*) tmp->getTargetAt(i));
|
||
|
|
}
|
||
|
|
tmpTar2.push_back(getBestMatch( (ConvexHullTreeNode*)
|
||
|
|
tmp->getSource(), &tmpTar));
|
||
|
|
matchCHTNs(tmpSour, tmpTar2);
|
||
|
|
iter = maps.begin();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Operators
|
||
|
|
|
||
|
|
1.1 $<<$
|
||
|
|
|
||
|
|
*/
|
||
|
|
ostream& operator << (ostream& s, Match *match)
|
||
|
|
{
|
||
|
|
s << match->getName() << endl
|
||
|
|
<< match->getDescription() << " Ratings: " <<endl
|
||
|
|
<< "AR: " << match->getAreaRating() << " OR: " << match->getOverlapRating()
|
||
|
|
<< " HR: " << match->getHausdorffRating() << " LR: "
|
||
|
|
<< match->getLinarRating() << endl;
|
||
|
|
#ifdef DEMATCH
|
||
|
|
map <int, SingleMatch*> :: iterator iter = match->maps.begin();
|
||
|
|
while(iter != match->maps.end())
|
||
|
|
{
|
||
|
|
s << "Key" << (*iter).first;
|
||
|
|
s << (*(*iter).second);
|
||
|
|
iter++;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Protected Methods
|
||
|
|
|
||
|
|
1.1 generateRatings()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: generateRatings()
|
||
|
|
{
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<"gr"<<endl;;
|
||
|
|
cout<<this<<endl;
|
||
|
|
cout<<*source;
|
||
|
|
cout<<*target;
|
||
|
|
#endif
|
||
|
|
Hausdorffrating = 0.0;
|
||
|
|
Ovelaprating = 0.0;
|
||
|
|
Arearating = 0.0;
|
||
|
|
linearRating = 0;
|
||
|
|
NrOfRatings = 0;
|
||
|
|
for(int i = 0; i < source->getNrOfFaces(); i++)
|
||
|
|
{
|
||
|
|
vector<RegionTreeNode*> tmp = getMatches(source->getFace(i));
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << tmp.size() << endl;
|
||
|
|
#endif
|
||
|
|
if(tmp.size() == 0)
|
||
|
|
{
|
||
|
|
Hausdorffrating += Utils::getDiameter(Utils :: convertCHLine2LineWA
|
||
|
|
(source->getFace(i)->getCycle()->getLines()));
|
||
|
|
Ovelaprating += 0.0;
|
||
|
|
Arearating += 0.0;
|
||
|
|
linearRating += 0.5;
|
||
|
|
NrOfRatings++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
rateFace(source->getFace(i), tmp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for(int i = 0; i<target->getNrOfFaces(); i++)
|
||
|
|
{
|
||
|
|
vector<RegionTreeNode*> tmp = getMatches(target->getFace(i));
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<tmp.size()<<endl;
|
||
|
|
#endif
|
||
|
|
if(tmp.size() == 0)
|
||
|
|
{
|
||
|
|
Hausdorffrating += Utils::getDiameter(Utils :: convertCHLine2LineWA
|
||
|
|
(target->getFace(i)->getCycle()->getLines()));
|
||
|
|
Ovelaprating += 0.0;
|
||
|
|
Arearating += 0.0;
|
||
|
|
linearRating += 0.5;
|
||
|
|
NrOfRatings++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
rateFace(target->getFace(i),tmp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<"gr2"<<endl;
|
||
|
|
cout<<source->getNrOfFaces()<<" "<<target->getNrOfFaces()<<endl;
|
||
|
|
cout<<"gr2"<<NrOfRatings<<" "<<greatestDist<<endl;;
|
||
|
|
#endif
|
||
|
|
Arearating = Arearating / NrOfRatings;
|
||
|
|
Ovelaprating = Ovelaprating / NrOfRatings;
|
||
|
|
Hausdorffrating = 1 - Hausdorffrating / NrOfRatings / greatestDist;
|
||
|
|
linearRating = linearRating / NrOfRatings;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 rateFace()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: rateFace(Face *source, vector<RegionTreeNode*> targets)
|
||
|
|
{
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<"grF"<<endl;
|
||
|
|
#endif
|
||
|
|
double sourceArea = abs(Utils :: getArea(source->getCycle()->getLines()));
|
||
|
|
double targetArea = 0.0;
|
||
|
|
double sumOverlaps = 0.0;
|
||
|
|
double HausdorffTmp = 0.0;
|
||
|
|
vector<CHLine> sourcel = source->getCycle()->getLines();
|
||
|
|
for(unsigned int i = 0; i < targets.size(); i++)
|
||
|
|
{
|
||
|
|
vector<CHLine> targetl = ( (Face*) targets[i])->getCycle()->getLines();
|
||
|
|
if(Utils :: getHausdorfDistance(source->getCycle()->getLines(),
|
||
|
|
((Face*) targets[i])->getCycle()->getLines()) > HausdorffTmp)
|
||
|
|
{
|
||
|
|
HausdorffTmp = Utils :: getHausdorfDistance(sourcel, targetl);
|
||
|
|
}
|
||
|
|
targetArea += abs(Utils :: getArea(targetl));
|
||
|
|
sumOverlaps += Utils :: getOverlap(&sourcel, &targetl);
|
||
|
|
}
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<"grF1 "<<sourceArea<<" "<<targetArea<<endl;
|
||
|
|
#endif
|
||
|
|
NrOfRatings++;
|
||
|
|
Arearating += min(sourceArea, targetArea) / max(sourceArea, targetArea);
|
||
|
|
Ovelaprating += sumOverlaps / sourceArea;
|
||
|
|
Hausdorffrating += HausdorffTmp / targets.size();
|
||
|
|
linearRating += 1.0 / targets.size();
|
||
|
|
vector <ConvexHullTreeNode*> children;
|
||
|
|
children = source->getCycle()->getChildren();
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<"grF2"<<endl;
|
||
|
|
#endif
|
||
|
|
for(unsigned int i = 0; i<children.size(); i++)
|
||
|
|
{
|
||
|
|
vector <RegionTreeNode*> tmp = getMatches(children.at(i));
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "CHTN :" << children.at(i)->hashCode() << " hat "
|
||
|
|
<< tmp.size() << " Matches" << endl;
|
||
|
|
#endif
|
||
|
|
if(tmp.size() == 0)
|
||
|
|
{
|
||
|
|
Hausdorffrating += Utils :: getDiameter(sourcel);
|
||
|
|
Ovelaprating += 0.0;
|
||
|
|
Arearating += 0.0;
|
||
|
|
linearRating += 0.5;
|
||
|
|
NrOfRatings++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
rateCHTN(children.at(i),tmp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "GRFace oH AR: " << Arearating << " HR: " << Hausdorffrating
|
||
|
|
<< " lR: " << linearRating << " Nr: " << NrOfRatings<<endl;
|
||
|
|
#endif
|
||
|
|
for(int i = 0; i<source->getNrOfHoles(); i++)
|
||
|
|
{
|
||
|
|
vector <RegionTreeNode*> tmp = getMatches(source->getHole(i));
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "Hole :" << source->getHole(i)->hashCode()
|
||
|
|
<< " hat " << tmp.size() << " Matches" << endl;
|
||
|
|
#endif
|
||
|
|
if(tmp.size() == 0)
|
||
|
|
{
|
||
|
|
Hausdorffrating += Utils :: getDiameter
|
||
|
|
(Utils :: convertCHLine2LineWA(sourcel));
|
||
|
|
Ovelaprating += 0.0;
|
||
|
|
Arearating += 0.0;
|
||
|
|
linearRating += 0.5;
|
||
|
|
NrOfRatings++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
rateCHTN(source->getHole(i),tmp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "GRFace AR: " << Arearating << " HR: " << Hausdorffrating
|
||
|
|
<< " lR: " << linearRating << " Nr: " << NrOfRatings << endl;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 rateCHTN()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match::rateCHTN(ConvexHullTreeNode *source,vector<RegionTreeNode*> targets)
|
||
|
|
{
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout<<"grCHTN"<<endl;
|
||
|
|
cout << "GRCHTN AR: " << Arearating << " HR: " << Hausdorffrating
|
||
|
|
<< " lR: " << linearRating << " Nr: " << NrOfRatings << endl;
|
||
|
|
cout<<*source;
|
||
|
|
//cout<<targets[0];
|
||
|
|
cout<<targets.size()<<endl;;
|
||
|
|
//cout<<source->getLines().size()<<endl;
|
||
|
|
//cout<<((ConvexHullTreeNode*)targets[0])->getLines().size();
|
||
|
|
#endif
|
||
|
|
double sourceArea = abs(Utils :: getArea(source->getLines()));
|
||
|
|
double targetArea = 0.0;
|
||
|
|
double sumOverlaps = 0.0;
|
||
|
|
double HausdorffTmp = 0.0;
|
||
|
|
for(unsigned int i = 0;i < targets.size(); i++)
|
||
|
|
{
|
||
|
|
if(Utils :: getHausdorfDistance(source->getLines(),
|
||
|
|
((ConvexHullTreeNode*) targets[i])->getLines()) > HausdorffTmp)
|
||
|
|
{
|
||
|
|
HausdorffTmp = Utils :: getHausdorfDistance(source->getLines(),
|
||
|
|
((ConvexHullTreeNode*) targets[i])->getLines());
|
||
|
|
}
|
||
|
|
targetArea += abs(Utils :: getArea(((ConvexHullTreeNode*)
|
||
|
|
targets[i])->getLines()));
|
||
|
|
vector<CHLine> sourcel = source->getLines();
|
||
|
|
vector<CHLine> targetl =((ConvexHullTreeNode*) targets[i])->getLines();
|
||
|
|
sumOverlaps += Utils :: getOverlap(&sourcel, &targetl);
|
||
|
|
}
|
||
|
|
NrOfRatings++;
|
||
|
|
Arearating += min(sourceArea, targetArea) / max(sourceArea, targetArea);
|
||
|
|
Ovelaprating += sumOverlaps / (sourceArea + targetArea);
|
||
|
|
Hausdorffrating += HausdorffTmp / targets.size();
|
||
|
|
linearRating += 1.0 / targets.size();
|
||
|
|
vector<ConvexHullTreeNode*> children = source->getChildren();
|
||
|
|
for(unsigned int i = 0; i<children.size(); i++)
|
||
|
|
{
|
||
|
|
vector<RegionTreeNode*> tmp = getMatches(children.at(i));
|
||
|
|
if(tmp.size() == 0)
|
||
|
|
{
|
||
|
|
Hausdorffrating += Utils :: getDiameter
|
||
|
|
(Utils :: convertCHLine2LineWA(source->getLines()));
|
||
|
|
Ovelaprating += 0.0;
|
||
|
|
Arearating += 0.0;
|
||
|
|
linearRating += 0.5;
|
||
|
|
NrOfRatings++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
rateCHTN(children.at(i), tmp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "GRCHTN AR: " << Arearating << " HR: " << Hausdorffrating
|
||
|
|
<< " lR: " << linearRating << " Nr: " << NrOfRatings << endl;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1 Private Methods
|
||
|
|
|
||
|
|
1.1 findIndex()
|
||
|
|
|
||
|
|
*/
|
||
|
|
int Match :: findIndex(RegionTreeNode *source)
|
||
|
|
{
|
||
|
|
int sourceHash = source->hashCode();
|
||
|
|
while(maps.find(sourceHash) != maps.end() &&
|
||
|
|
!maps[sourceHash]->getSource()->equals(source))
|
||
|
|
{
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "Konflikt zwischen " << maps.size() << " " << sourceHash << endl;
|
||
|
|
#endif
|
||
|
|
sourceHash++;
|
||
|
|
}
|
||
|
|
#ifdef DEMATCH
|
||
|
|
cout << "<geloest " << maps.size() << " " << sourceHash << endl;
|
||
|
|
#endif
|
||
|
|
return(sourceHash);
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
|
||
|
|
1.1 removeSingleMatch()
|
||
|
|
|
||
|
|
*/
|
||
|
|
void Match :: removeSingleMatch(RegionTreeNode *toDelete)
|
||
|
|
{
|
||
|
|
if(toDelete!=NULL)
|
||
|
|
{
|
||
|
|
int sourceHash = findIndex(toDelete);
|
||
|
|
delete maps.find(sourceHash)->second;
|
||
|
|
maps.erase(sourceHash);
|
||
|
|
map<int,SingleMatch*> :: iterator iter = maps.begin();
|
||
|
|
while(iter != maps.end())
|
||
|
|
{
|
||
|
|
SingleMatch *tmp = (*iter).second;
|
||
|
|
for(int i = 0; i < tmp->getNrTargets(); i++)
|
||
|
|
{
|
||
|
|
if(toDelete->equals(tmp->getTargetAt(i)))
|
||
|
|
tmp->removeTarget(i);
|
||
|
|
}
|
||
|
|
iter++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|