/**
* 使用分离轴法检查矩形是否相交
*/
bool Range::collideRange(const Range& range) const
{
CCPoint one[4]={CCPointZero};
one[0].x=tr.x-tl.x;
one[0].y=tr.y-tl.y;
one[1].x=br.x-tr.x;
one[1].y=br.y-tr.y;
one[2].x=bl.x-br.x;
one[2].y=bl.y-br.y;
one[3].x=tl.x-bl.x;
one[3].y=tl.y-bl.y;
CCPoint other[4]={CCPointZero};
other[0].x=range.tr.x-range.tl.x;
other[0].y=range.tr.y-range.tl.y;
other[1].x=range.br.x-range.tr.x;
other[1].y=range.br.y-range.tr.y;
other[2].x=range.bl.x-range.br.x;
other[2].y=range.bl.y-range.br.y;
other[3].x=range.tl.x-range.bl.x;
other[3].y=range.tl.y-range.bl.y;
//检查以自己的边的轴的投影是否重合
if (!checkEdge(tl,tr,*this,range)) {
return false;
}
if (!checkEdge(tr,br,*this,range)) {
return false;
}
if (!checkEdge(br,bl,*this,range)) {
return false;
}
if (!checkEdge(bl,tl,*this,range)) {
return false;
}
//检查以对方的边的轴的投影是否重合
if (!checkEdge(range.tl,range.tr,*this,range)) {
return false;
}
if (!checkEdge(range.tr,range.br,*this,range)) {
return false;
}
if (!checkEdge(range.br,range.bl,*this,range)) {
return false;
}
if (!checkEdge(range.bl,range.tl,*this,range)) {
return false;
}
return true;
}
SplitResult BaseUkkonen::testAndSplit(Node* node, int begin, int end, string symbol)
{
if (end <= begin)
{
if ( ( node->edges.find(symbol) == node->edges.end() ) && (node != dummy) )
return make_pair(false, node);
else
return make_pair(true, node);
}
else
{
Node* current = checkEdge(node, parser->getWord(begin));
string temp = parser->getWord(current->begin + end - begin);
if (symbol == temp)
{
return make_pair(true, node);
}
Node* newNode = new Node(node);
current->parent = newNode;
link(node, current->begin, current->begin + end - begin, newNode);
link(newNode, current->begin + end - begin, current->end, current);
return make_pair(false, newNode);
}
}
bool Model::checkEdge(Vertex base, Vertex start, Vertex begin, Vertex last,
std::map<unsigned int, bool> checked)
{
// Get a vertex that is both a neighbor of base and start and different than last
for (auto it = start.neighbors.begin(); it != start.neighbors.end(); ++it)
{
// If the neighbors neighbor is the beginning but not the one we just came from
// then there is a way of circling base through their neighbors
if(*it == begin.id && *it != last.id)
return false;
// If the neighbor has already been used don't use it again
if(checked[*it])
continue;
for (auto it2 = base.neighbors.begin(); it2 != base.neighbors.end(); ++it2)
{
if (*it == *it2)
{
// Found a match
checked[*it] = true;
// Check the next vertex
bool isEdge = checkEdge(base, m_vertices[*it], begin, start, checked);
// If checkEdge returns true there might still be a different "path" to prove
// that it's no edge, thus we continue iterating
if (!isEdge)
return false;
}
}
}
// If we get here the algorithm has not found a proper way
return true;
}
bool Model::checkEdge(Vertex base, Vertex start)
{
std::map<unsigned int, bool> checked;
for(auto neighbor : base.neighbors)
checked[neighbor] = false;
checked[start.id] = true;
return checkEdge(base, start, start, start, checked);
}
std::string operator ()(const std::string &s)
{
std::size_t curr = start;
for(std::string::size_type i = 0; i < s.size(); ++i)
{
if(!checkEdge(curr, s[i]))
return MakeString() << "0" << "\n" << i << "\n" << GET_STR(curr);
curr = M[curr][s[i]];
}
return MakeString() << (S.count(curr) ? "1" : "0") << "\n" << s.size() << "\n" << GET_STR(curr);
}
ActivePoint BaseUkkonen::canonize(Node* node, int begin, int end)
{
if (end <= begin)
{
return make_pair(node, begin);
}
else
{
Node* current = checkEdge(node, parser->getWord(begin));
while (end - begin >= current->end - current->begin)
{
begin += current->end - current->begin;
node = current;
if ( end > begin)
{
current = checkEdge(node, parser->getWord(begin));
}
}
return make_pair(node, begin);
}
}
void Ball::update(sf::Time& dt){
checkEdge();
if(_atTop){
_atTop = false;
_yVel = -_yVel;
}
if(_atSide){
_atSide = false;
_xVel = -_xVel;
}
float deltaX = dt.asSeconds() * _xVel;
float deltaY = dt.asSeconds() * _yVel;
_ball.move(deltaX, deltaY);
//Accelerate the ball
if(abs(_xVel) < 500){
if(_xVel >= 0){
_xVel += dt.asSeconds() * _accel;
}
if(_xVel < 0){
_xVel -= dt.asSeconds() * _accel;
}
if(_yVel >= 0){
_yVel += dt.asSeconds() * _accel;
}
if(_yVel < 0){
_yVel -= dt.asSeconds() * _accel;
}
}
}
void VoronoiShatter::getVDFormDT(){
//VD's vertex: DT's tetra, center of the sphere
//VD's edge: 2 VD's vertex with the same DT's face
//VD's face: tetra which share DT's edge
//VD's poly: share DT's vertex
std::cerr<<"START!!!!!!!!!!!!!!11: "<< std::endl;
int counter = 0;
int currentKey = 0;
int flag = 0;
int first_vertex_flag = 0;
int previousTetraKey = 0;
int nextTetraKey = 0;
int firstTetraKey = 0;
int nowVertexId = 0;
bool still_has_edge=true;
Tetrahedron t;
//VoronoiShatter voronoiShatter;
//TetraMap pool = voronoiShatter.getPool();
TetraMap pool = tetraPool;
TetraMapItr itr = pool.begin();
for( ; itr!=pool.end(); itr++){
// get tetrahedront
t = itr->second;
// put all verteces to set, not include big tetra's vertecies
if( t.v1 != bigTetra .v1 && t.v1 != bigTetra .v2 && t.v1 !=bigTetra .v3 && t.v1 != bigTetra .v4)
vertexSet.insert(t.v1);
if( t.v2 != bigTetra .v1 && t.v2 != bigTetra .v2 && t.v2 !=bigTetra .v3 && t.v2 != bigTetra .v4)
vertexSet.insert(t.v2);
if( t.v3 != bigTetra .v1 && t.v3 != bigTetra .v2 && t.v3 !=bigTetra .v3 && t.v3 != bigTetra .v4)
vertexSet.insert(t.v3);
if( t.v4 != bigTetra .v1 && t.v4 != bigTetra .v2 && t.v4 !=bigTetra .v3 && t.v4 != bigTetra .v4)
vertexSet.insert(t.v4);
}
Tetrahedron originalTetra;
while( !vertexSet.empty() )
{
first_vertex_flag = 0;
// not sure
// choose one vertex p
checkVertex = vertexSet.begin();
// if no tetra contains p
if( getTetra(checkVertex->incidentTetra, originalTetra) ==false){
vertexSet.erase(checkVertex);
continue;
}
// tetra contains p
inSetEdge e1;
inSetEdge e2;
inSetEdge e3;
// push the edge to stack
if(*checkVertex == originalTetra.v1){
std::cerr<<"AAA: "<< std::endl;
e1.startVertex = originalTetra.v1;
e1.endVertex = originalTetra.v2;
e1.key = originalTetra.key;
e2.startVertex = originalTetra.v1;
e2.endVertex = originalTetra.v3;
e2.key = originalTetra.key;
e3.startVertex = originalTetra.v1;
e3.endVertex = originalTetra.v4;
e3.key = originalTetra.key;
edgeSet.insert(e1);
edgeSet.insert(e2);
edgeSet.insert(e3);
}
else if(*checkVertex == originalTetra.v2){
std::cerr<<"BBB: "<< std::endl;
e1.startVertex = originalTetra.v2;
e1.endVertex = originalTetra.v1;
e1.key = originalTetra.key;
e2.startVertex = originalTetra.v2;
e2.endVertex = originalTetra.v3;
e2.key = originalTetra.key;
e3.startVertex = originalTetra.v2;
e3.endVertex = originalTetra.v4;
e3.key = originalTetra.key;
edgeSet.insert(e1);
edgeSet.insert(e2);
edgeSet.insert(e3);
}
else if(*checkVertex == originalTetra.v3){
std::cerr<<"CCC: "<< std::endl;
e1.startVertex = originalTetra.v3;
e1.endVertex = originalTetra.v1;
e1.key = originalTetra.key;
e2.startVertex = originalTetra.v3;
e2.endVertex = originalTetra.v2;
e2.key = originalTetra.key;
e3.startVertex = originalTetra.v3;
e3.endVertex = originalTetra.v4;
e3.key = originalTetra.key;
edgeSet.insert(e1);
edgeSet.insert(e2);
edgeSet.insert(e3);
}
else if(*checkVertex == originalTetra.v4){
std::cerr<<"DDD: "<< std::endl;
e1.startVertex = originalTetra.v4;
e1.endVertex = originalTetra.v1;
e1.key = originalTetra.key;
std::cerr<<"DDD - e1.key: "<<e1.key<< std::endl;
e2.startVertex = originalTetra.v4;
e2.endVertex = originalTetra.v2;
e2.key = originalTetra.key;
std::cerr<<"DDD - e2.key: "<<e2.key<< std::endl;
e3.startVertex = originalTetra.v4;
e3.endVertex = originalTetra.v3;
e3.key = originalTetra.key;
std::cerr<<"DDD - e3.key: "<<e3.key<< std::endl;
edgeSet.insert(e1);
edgeSet.insert(e2);
edgeSet.insert(e3);
}
int vdEdgeTag = 0;
int vdFaceTag = 0;
VDfaceIndex.push_back(0);
VDpolyIndex.push_back(0);
// choose first edge
// currentEdgeItr = edgeSet.begin();
bool hasNeighbor =true;
still_has_edge = true;
flag=0;
inSetEdge usedEdge;
int cou=0;
while( still_has_edge==true )
// for( currentEdgeItr; currentEdgeItr!=edgeSet.end(); currentEdgeItr++ ) //while haven't choosen the last edge
// for( ; currentEdgeItr!=edgeSet.end(); currentEdgeItr++ ) //while haven't choosen the last edge
{
// if(still_has_edge==false)
// break;
//choose one edge, from first to compare used set
if(flag==0 || flag==3 ){
currentEdgeItr = edgeSet.begin();
usedEdge.startVertex = currentEdgeItr->startVertex;
usedEdge.endVertex = currentEdgeItr->endVertex;
usedEdge.key = currentEdgeItr->key;
}
if(flag!=1 && flag!=4)
{
if(usedEdgeSet.size()!=edgeSet.size()-1)
{
while( usedEdgeSet.count(usedEdge)!=0 )
{
currentEdgeItr++;
usedEdge.startVertex = currentEdgeItr->startVertex;
usedEdge.endVertex = currentEdgeItr->endVertex;
usedEdge.key = currentEdgeItr->key;
}
}
else
{
usedEdge.startVertex = currentEdgeItr->startVertex;
usedEdge.endVertex = currentEdgeItr->endVertex;
usedEdge.key = currentEdgeItr->key;
flag=4;
cou=0;
previousTetraKey = 0;
nextTetraKey = 0;
firstTetraKey = 0;
// find the edge from which tetra
currentKey = currentEdgeItr->key;
first_vertex_flag = 0;
firstTetraKey = currentEdgeItr->key;
}
}
usedEdgeSet.insert(usedEdge);
std::cerr<<"setEdgeSize: "<< edgeSet.size()<<std::endl;
// choose one edge E
// inSetEdge currentEdge;
// currentEdge = edgeSet.top();
hasNeighbor = true;
if(flag!=1 && flag!=4){
previousTetraKey = 0;
nextTetraKey = 0;
firstTetraKey = 0;
// find the edge from which tetra
currentKey = currentEdgeItr->key;
// first_vertex_flag = 0;
firstTetraKey = currentEdgeItr->key;
}
Tetrahedron currentTetra;
while( hasNeighbor )
{
counter++;
std::cerr<<"counter: "<< counter<<std::endl;
std::cerr<<"currentKey - StartAAA: "<< currentKey<<std::endl;
// get current tetra
if( !getTetra( currentKey, currentTetra) ){
//continue;
break;
}
std::cerr<<"currentKey - StartBBB: "<< currentKey<<std::endl;
// tetra contains p
inSetEdge ed1;
inSetEdge ed2;
inSetEdge ed3;
// push the edge to stack
if(*checkVertex == currentTetra.v1)
{
std::cerr<<"EEE: "<< std::endl;
ed1.startVertex = currentTetra.v1;
ed1.endVertex = currentTetra.v2;
// findEdge = edgeSet.find(ed1);
if( edgeSet.count(ed1) == 0 )
{
ed1.key =currentTetra.key;
edgeSet.insert(ed1);
}
ed2.startVertex = currentTetra.v1;
ed2.endVertex = currentTetra.v3;
// findEdge = edgeSet.find(ed2);
if( edgeSet.count(ed2) == 0 )
{
ed2.key = currentTetra.key;
edgeSet.insert(ed2);
}
ed3.startVertex = currentTetra.v1;
ed3.endVertex = currentTetra.v4;
// findEdge = edgeSet.find(ed3);
if( edgeSet.count(ed3) == 0 )
{
ed3.key = currentTetra.key;
edgeSet.insert(ed3);
}
}
if(*checkVertex == currentTetra.v2)
{
std::cerr<<"FFF: "<< std::endl;
ed1.startVertex = currentTetra.v2;
ed1.endVertex = currentTetra.v1;
// findEdge = edgeSet.find(ed1);
if( edgeSet.count(ed1) == 0 )
{
ed1.key =currentTetra.key;
edgeSet.insert(ed1);
}
ed2.startVertex = currentTetra.v2;
ed2.endVertex = currentTetra.v3;
// findEdge = edgeSet.find(ed2);
if( edgeSet.count(ed2) == 0 )
{
ed2.key = currentTetra.key;
edgeSet.insert(ed2);
}
ed3.startVertex = currentTetra.v2;
ed3.endVertex = currentTetra.v4;
// findEdge = edgeSet.find(ed3);
if( edgeSet.count(ed3) == 0 )
{
ed3.key = currentTetra.key;
edgeSet.insert(ed3);
}
}
if(*checkVertex == currentTetra.v3)
{
std::cerr<<"GGG: "<< std::endl;
ed1.startVertex = currentTetra.v3;
ed1.endVertex = currentTetra.v1;
// findEdge = edgeSet.find(ed1);
if( edgeSet.count(ed1) == 0 )
{
ed1.key =currentTetra.key;
edgeSet.insert(ed1);
}
ed2.startVertex = currentTetra.v3;
ed2.endVertex = currentTetra.v2;
// findEdge = edgeSet.find(ed2);
if( edgeSet.count(ed2) == 0 )
{
ed2.key = currentTetra.key;
edgeSet.insert(ed2);
}
ed3.startVertex = currentTetra.v3;
ed3.endVertex = currentTetra.v4;
// findEdge = edgeSet.find(ed3);
if( edgeSet.count(ed3) == 0 )
{
ed3.key = currentTetra.key;
edgeSet.insert(ed3);
}
}
if(*checkVertex == currentTetra.v4)
{
std::cerr<<"HHH: "<< std::endl;
ed1.startVertex = currentTetra.v4;
ed1.endVertex = currentTetra.v1;
// findEdge = edgeSet.find(ed1);
if( edgeSet.count(ed1) == 0 )
{
ed1.key =currentTetra.key;
edgeSet.insert(ed1);
std::cerr<<"HHH - ED1: "<<ed1.key<< std::endl;
}
ed2.startVertex = currentTetra.v4;
ed2.endVertex = currentTetra.v2;
// findEdge = edgeSet.find(ed2);
if( edgeSet.count(ed2) == 0 )
{
ed2.key = currentTetra.key;
edgeSet.insert(ed2);
std::cerr<<"HHH - ED2: "<<ed2.key<< std::endl;
}
ed3.startVertex = currentTetra.v4;
ed3.endVertex = currentTetra.v3;
// findEdge = edgeSet.find(ed3);
if( edgeSet.count(ed3) == 0 )
{
ed3.key = currentTetra.key;
edgeSet.insert(ed3);
std::cerr<<"HHH - ED3: "<<ed3.key<< std::endl;
}
}
// find VD's vertex vp of currentTetra
Vertex vp;
vp = findSphereCenter( currentTetra );
// end of finding VD's vertex vp of currentTetra
std::cerr<<"Vertex: "<<std::endl;
// put vp into VDvertex
VDvertex.push_back(vp);
// end of putting vp into VDvertex
if(first_vertex_flag==0)
{
nowVertexId = VDvertex.size()-1;
}
if(flag==1 || (flag==4&&cou!=0)){
// recode the VDedge
if(VDvertex.size()>1)
{
Edge vdEdge;
vdEdge.startVertexId = VDvertex.size() - 2;
vdEdge.endVertexId = VDvertex.size() - 1;
VDedge.push_back( vdEdge );
std::cerr<<"Edge "<<std::endl;
// end record the VDedge
}
}
// save now's tetra for preious
// choose neighbor tetra which contain edge e
Tetrahedron t1, t2, t3, t4;
if( getTetra(currentTetra.neighbour1, t1) == false )
{
// std::cerr<<"no neighborRRR"<<std::endl;
}
if( getTetra(currentTetra.neighbour2, t2) == false )
{
// std::cerr<<"no neighbor2"<<std::endl;
}
if( getTetra(currentTetra.neighbour3, t3) == false )
{
// std::cerr<<"no neighbor3"<<std::endl;
}
if( getTetra(currentTetra.neighbour4, t4) == false )
{
// std::cerr<<"no neighbor4"<<std::endl;
}
// if tetra contains edge, and it is not the first tetra
if ( checkEdge(t1, currentEdgeItr->startVertex, currentEdgeItr->endVertex)==true
&& t1.key != previousTetraKey
&& t1.key != firstTetraKey
){
previousTetraKey = currentTetra.key;
currentKey = t1.key;
std::cerr<<"t1: "<<t1.key<<std::endl;
std::cerr<<"currentKey - End - t1: "<< currentKey<<std::endl;
first_vertex_flag = 1;
if(flag==4)
{
flag=4;
cou=1;
}
else
flag=1;
break;
}
else if (checkEdge(t2, currentEdgeItr->startVertex, currentEdgeItr->endVertex) ==true
&& t2.key != previousTetraKey
&& t2.key != firstTetraKey
){
previousTetraKey = currentTetra.key;
currentKey = t2.key;
std::cerr<<"t2: "<<t2.key<<std::endl;
std::cerr<<"currentKey - End - t2: "<< currentKey<<std::endl;
first_vertex_flag = 1;
if(flag==4)
{
flag=4;
cou=1;
}
else
flag=1;
break;
}
else if (checkEdge(t3, currentEdgeItr->startVertex, currentEdgeItr->endVertex) ==true
&& t3.key != previousTetraKey
&& t3.key != firstTetraKey
){
previousTetraKey = currentTetra.key;
currentKey = t3.key;
std::cerr<<"t3: "<<t3.key<<std::endl;
std::cerr<<"currentKey - End - t3: "<< currentKey<<std::endl;
std::cerr<<"previoueKey - End "<< previousTetraKey<<std::endl;
first_vertex_flag = 1;
if(flag==4)
{
flag=4;
cou=1;
}
else
flag=1;
break;
}
else if ( checkEdge(t4, currentEdgeItr->startVertex, currentEdgeItr->endVertex) ==true
&& t4.key != previousTetraKey
&& t4.key != firstTetraKey
){
previousTetraKey = currentTetra.key;
currentKey = t4.key;
std::cerr<<"t4: "<<t4.key<<std::endl;
std::cerr<<"currentKey - End - t4: "<< currentKey<<std::endl;
first_vertex_flag = 1;
if(flag==4)
{
flag=4;
cou=1;
}
else
flag=1;
break;
}
else{
hasNeighbor = false;
std::cerr<<"hereherehere"<<std::endl;
if(flag==4)
still_has_edge=false;
flag = 2;
//break;
}
}// end while of find neighbor
if(flag==2 )
{
// first vertex and last vertex
Edge vdEdge;
vdEdge.startVertexId = VDvertex.size() - 1;
vdEdge.endVertexId = nowVertexId;
VDedge.push_back( vdEdge );
first_vertex_flag = 0;
std::cerr<<"First and Last Vertex"<<std::endl;
}
if(flag==2 )
{
// this is a VDface
for(int i=vdEdgeTag; i<VDedge.size(); i++)
{
VDface.push_back( i );
std::cerr<<"Face: "<<VDedge.size()<<std::endl;
}
vdEdgeTag = VDedge.size();
// if(vdEdgeTag!=0)
VDfaceIndex.push_back( vdEdgeTag);
// end of VDface
flag = 3;
}
std::cerr<<"still_has_edge: "<<still_has_edge<<std::endl;
}//end while edge set
//this is a VDpoly
/* for(int i=vdFaceTag; i<VDface.size(); i++)
{
VDpoly.push_back( i );
std::cerr<<"Poly"<<std::endl;
}
*/
vdFaceTag = VDfaceIndex.size();
// if(vdFaceTag!=0)
VDpolyIndex.push_back( vdFaceTag-1 );
//end if VDpoly
// erase the vertex
vertexSet.erase( checkVertex );
usedEdgeSet.clear();
edgeSet.clear();
flag=0;
}//end while of vertex stk
std::cerr<<"v1x: "<<VDvertex.at(0).point.x<<std::endl;
std::cerr<<"v1x: "<<VDvertex.at(0).point.y<<std::endl;
std::cerr<<"v1x: "<<VDvertex.at(0).point.z<<std::endl;
std::cerr<<"v2x: "<<VDvertex.at(1).point.x<<std::endl;
std::cerr<<"v2x: "<<VDvertex.at(1).point.y<<std::endl;
std::cerr<<"v2x: "<<VDvertex.at(1).point.z<<std::endl;
std::cerr<<"v3x: "<<VDvertex.at(2).point.x<<std::endl;
std::cerr<<"v3x: "<<VDvertex.at(2).point.y<<std::endl;
std::cerr<<"v3x: "<<VDvertex.at(2).point.z<<std::endl;
std::cerr<<"v4x: "<<VDvertex.at(3).point.x<<std::endl;
std::cerr<<"v4x: "<<VDvertex.at(3).point.y<<std::endl;
std::cerr<<"v4x: "<<VDvertex.at(3).point.z<<std::endl;
std::cerr<<"v5x: "<<VDvertex.at(4).point.x<<std::endl;
std::cerr<<"v5x: "<<VDvertex.at(4).point.y<<std::endl;
std::cerr<<"v5x: "<<VDvertex.at(4).point.z<<std::endl;
std::cerr<<"v6x: "<<VDvertex.at(5).point.x<<std::endl;
std::cerr<<"v6x: "<<VDvertex.at(5).point.y<<std::endl;
std::cerr<<"v6x: "<<VDvertex.at(5).point.z<<std::endl;
std::cerr<<"v7x: "<<VDvertex.at(6).point.x<<std::endl;
std::cerr<<"v7x: "<<VDvertex.at(6).point.y<<std::endl;
std::cerr<<"v7x: "<<VDvertex.at(6).point.z<<std::endl;
std::cerr<<"v8x: "<<VDvertex.at(7).point.x<<std::endl;
std::cerr<<"v8x: "<<VDvertex.at(7).point.y<<std::endl;
std::cerr<<"v8x: "<<VDvertex.at(7).point.z<<std::endl;
std::cerr<<"v9x: "<<VDvertex.at(8).point.x<<std::endl;
std::cerr<<"v9x: "<<VDvertex.at(8).point.y<<std::endl;
std::cerr<<"v9x: "<<VDvertex.at(8).point.z<<std::endl;
std::cerr<<"v10x: "<<VDvertex.at(9).point.x<<std::endl;
std::cerr<<"v10x: "<<VDvertex.at(9).point.y<<std::endl;
std::cerr<<"v10x: "<<VDvertex.at(9).point.z<<std::endl;
std::cerr<<"v11x: "<<VDvertex.at(10).point.x<<std::endl;
std::cerr<<"v11x: "<<VDvertex.at(10).point.y<<std::endl;
std::cerr<<"v11x: "<<VDvertex.at(10).point.z<<std::endl;
std::cerr<<"v12x: "<<VDvertex.at(11).point.x<<std::endl;
std::cerr<<"v12x: "<<VDvertex.at(11).point.y<<std::endl;
std::cerr<<"v12x: "<<VDvertex.at(11).point.z<<std::endl;
std::cerr<<"e1: "<<VDedge.at(0).startVertexId<<std::endl;
std::cerr<<"e1: "<<VDedge.at(0).endVertexId<<std::endl;
std::cerr<<"e2: "<<VDedge.at(1).startVertexId<<std::endl;
std::cerr<<"e2: "<<VDedge.at(1).endVertexId<<std::endl;
std::cerr<<"e3: "<<VDedge.at(2).startVertexId<<std::endl;
std::cerr<<"e3: "<<VDedge.at(2).endVertexId<<std::endl;
std::cerr<<"e4: "<<VDedge.at(3).startVertexId<<std::endl;
std::cerr<<"e4: "<<VDedge.at(3).endVertexId<<std::endl;
std::cerr<<"e5: "<<VDedge.at(4).startVertexId<<std::endl;
std::cerr<<"e5: "<<VDedge.at(4).endVertexId<<std::endl;
std::cerr<<"e6: "<<VDedge.at(5).startVertexId<<std::endl;
std::cerr<<"e6: "<<VDedge.at(5).endVertexId<<std::endl;
std::cerr<<"face1 "<<VDfaceIndex.at(0)<<std::endl;
std::cerr<<"face2: "<<VDfaceIndex.at(1)<<std::endl;
std::cerr<<"face3: "<<VDfaceIndex.at(2)<<std::endl;
std::cerr<<"face4: "<<VDfaceIndex.at(3)<<std::endl;
std::cerr<<"face5: "<<VDfaceIndex.at(4)<<std::endl;
std::cerr<<"poly1 "<<VDpolyIndex.at(0)<<std::endl;
std::cerr<<"poly2: "<<VDpolyIndex.at(1)<<std::endl;
return;
}
/*trySwapPieces
* compute the score the puzzle WOULD have, if swap occured
* p:puzzle
* i, j: pieces to be swap
* returns: new total score with the swap
*
*/
int trySwapPieces(puzzle p,int **cur_sol,int score, int i, int j, int *wrongs, int *wsize_ptr){
//newscores=oldscores-computeLocalScore(....,cur_sol, i)-computeLocalScore(.....,cur_sol, j)
//.... +computeLocalScore(...., swapped_sol, i)+computeLocalScore(....,swapped_sol, j);
int rot, tmp, old_i, old_j, old_rot_i, old_rot_j, k, maxi=0, maxj=0, max_rot_i, max_rot_j, found, w, skip=0;
int scoreold=score;
//store actual pieces and rotations:
old_i=cur_sol[i][0];
old_j=cur_sol[j][0];
old_rot_i=cur_sol[i][1];
old_rot_j=cur_sol[j][1];
score-=computeLocalScore(p, cur_sol, cur_sol[i][0], i, cur_sol[i][1]);
score-=computeLocalScore(p, cur_sol, cur_sol[j][0], j, cur_sol[j][1]);
if(isNeighbor(p, i, j)){
/* try rotating the two pieces in place */
score+=checkEdge(p, cur_sol, i, j); // score for common edge was removed twice, so re-add once
for(cur_sol[i][1]=0;cur_sol[i][1]<4;cur_sol[i][1]++){ //rotate i
for(cur_sol[j][1]=0;cur_sol[j][1]<4;cur_sol[j][1]++){ //rotate j
k=computeLocalScore(p, cur_sol, old_i, i, cur_sol[i][1]); //score from i
tmp=computeLocalScore(p, cur_sol, old_j, j, cur_sol[j][1]); //score from j
if(tmp+k>maxi+maxj){
maxi=k;
maxj=tmp;
max_rot_i=cur_sol[i][1];
max_rot_j=cur_sol[j][1];
}
}
}
score+=maxi+maxj; // this adds one point for each "good" edge, so the common edge has double score
//update solution
cur_sol[i][1]=max_rot_i;
cur_sol[j][1]=max_rot_j;
score-=checkEdge(p, cur_sol, i, j); //score for common edge has been added twice, then subtract once
if (score>scoreold){
skip=1; //-> don't try swapping; maybe next time...
} else {
//restore
cur_sol[i][1]=old_rot_i;
cur_sol[j][1]=old_rot_j;
score-=maxi+maxj;
}
if(!skip){
/* swap the pieces (if leads to better score) */
cur_sol[i][0]=old_j; //move j-->i
cur_sol[j][0]=old_i; //move i-->j
for(cur_sol[i][1]=0;cur_sol[i][1]<4;cur_sol[i][1]++){ //rotate i
for(cur_sol[j][1]=0;cur_sol[j][1]<4;cur_sol[j][1]++){ //rotate j
k=computeLocalScore(p, cur_sol, old_j, i, cur_sol[i][1]); //score from i
tmp=computeLocalScore(p, cur_sol, old_i, j, cur_sol[j][1]); //score from j
if(tmp+k>maxi+maxj){
maxi=k;
maxj=tmp;
max_rot_i=cur_sol[i][1];
max_rot_j=cur_sol[j][1];
}
}
}
score+=maxi+maxj; // this adds one point for each "good" edge, so the common edge has double score
score-=checkEdge(p, cur_sol, i, j); //score for common edge has been added twice, then subtract once
if (score>scoreold){
//update solution
cur_sol[i][1]=max_rot_i;
cur_sol[j][1]=max_rot_j;
} else {
//restore old values:
cur_sol[i][0]=old_i;
cur_sol[i][1]=old_rot_i;
cur_sol[j][0]=old_j;
cur_sol[j][1]=old_rot_j;
score=scoreold;
}
}
} else {
for(rot=0;rot<4;rot++){
tmp=computeLocalScore(p, cur_sol, old_i, j, rot);
if(tmp>maxi){
maxi=tmp;
max_rot_i=rot;
}
}
score+=maxi;
maxj=0;
for(rot=0;rot<4;rot++){
tmp=computeLocalScore(p, cur_sol, old_j, i, rot);
if(tmp>maxj){
maxj=tmp;
max_rot_j=rot;
}
}
score+=maxj;
if(score>scoreold){
cur_sol[j][0]=old_i;
cur_sol[j][1]=max_rot_i;
cur_sol[i][0]=old_j;
cur_sol[i][1]=max_rot_j;
}else{
return(scoreold);
}
}
/* update wrongs vector */
#ifdef WRONGS
if(maxi==MAX_LOCAL_SCORE){
removeWrong(p, cur_sol, wrongs, wsize_ptr, i);
}
// update neighbors of i
updateWrongs(p, cur_sol, wrongs, wsize_ptr, i);
if(maxj==MAX_LOCAL_SCORE){
removeWrong(p, cur_sol, wrongs, wsize_ptr, i);
}
// update neighbors of j
updateWrongs(p, cur_sol, wrongs, wsize_ptr, i);
#endif
return(score);
}
void Model::analyzeMesh()
{
// Clear any previous results
m_vertices.clear();
m_vertexTree.clear();
m_baseIndex2ModelIndex.clear();
// Add all vertices
for (unsigned int i = 0; i < m_pMesh->getVertices().size(); i++)
{
auto vertex = m_pMesh->getVertices()[i];
auto normal = m_pMesh->getNormals()[i];
// Check if there already is a vertex with the same coordinates
auto dbglCoords = dbgl::Vec3d(vertex.x(), vertex.y(), vertex.z());
auto pVertId = m_vertexTree.getSimilar(dbglCoords, 0.0001);
if(pVertId != nullptr)
{
// Average normals
m_vertices[*pVertId].normal += Eigen::Vector3d(normal.x(), normal.y(), normal.z());
// Add base vertex id
m_vertices[*pVertId].baseVertices.insert(i);
// Create a list base index -> this index
m_baseIndex2ModelIndex.push_back(*pVertId);
}
else
{
Vertex vert;
vert.id = m_vertices.size();
vert.coords = Eigen::Vector3d(vertex.x(), vertex.y(), vertex.z());
vert.normal = Eigen::Vector3d(normal.x(), normal.y(), normal.z());
vert.baseVertices.insert(i);
m_vertices.push_back(vert);
m_vertexTree.insert(dbglCoords, vert.id);
// Create a list base index -> this index
m_baseIndex2ModelIndex.push_back(vert.id);
}
}
// Normalize all normals
for(auto& vert : m_vertices)
vert.normal.normalize();
// Balance the tree for maximum performance
m_vertexTree.balance();
// Compute neighbors
for (unsigned int i = 0; i < m_pMesh->getIndices().size(); i += 3)
{
m_vertices[m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 0]]].neighbors.insert(
m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 1]]);
m_vertices[m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 0]]].neighbors.insert(
m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 2]]);
m_vertices[m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 1]]].neighbors.insert(
m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 0]]);
m_vertices[m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 1]]].neighbors.insert(
m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 2]]);
m_vertices[m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 2]]].neighbors.insert(
m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 0]]);
m_vertices[m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 2]]].neighbors.insert(
m_baseIndex2ModelIndex[m_pMesh->getIndices()[i + 1]]);
}
// Compute edge vertices
for (unsigned int i = 0; i < m_vertices.size(); i++)
{
if (m_vertices[i].neighbors.empty())
continue;
bool isEdge = false;
for(auto it = m_vertices[i].neighbors.begin(); it != m_vertices[i].neighbors.end(); ++it)
{
// Usually this should finish on first iteration. Only due to bad luck it might need more.
auto start = m_vertices[*it];
isEdge = checkEdge(m_vertices[i], start);
if(!isEdge)
break;
}
m_vertices[i].isEdge = isEdge;
}
}
