//------------------------------------------------------------------------------
// scanline() -- select the scanline and setup the AET
//------------------------------------------------------------------------------
void Scanline::scanline(const int y)
{
// reset some values
curPoly = nullptr;
curX = 0.0f;
curY = static_cast<double>(y);
refAET = 0;
nAPT = 0;
// Purge old edges from the AET
for (int i = nAET-1; i >= 0; i--) {
if (curY > aet[i]->uv[1]) {
for (unsigned int j = i; j < nAET-1; j++) {
aet[j] = aet[j+1];
}
nAET--;
}
}
// Move new edges from ET and put into the AET
while (refET < nET && curY >= et[refET]->lv[1]) {
aet[nAET++] = et[refET++];
}
// Update x positions and normals of edges in the AET
for (unsigned int i = 0; i < nAET; i++) {
double dist = curY - aet[i]->lv[1];
aet[i]->x = static_cast<double>(aet[i]->lv[0]) + aet[i]->slope*dist;
aet[i]->cn = aet[i]->lvn + aet[i]->nslope * dist;
}
// Sort the AET
sortEdges(aet, nAET, 0);
}
void kruskal()
{
NODE *u, *v;
SET *uSet, *vSet;
for( ADJ_LIST *header = adjListBeg; header != NULL; header = header->down)
{
u = header->node;
makeSet(u);
}
sortEdges();
for( int i = 0; i < edgeCount; i++ )
{
uSet = findSet(edgeList[i].node1);
vSet = findSet(edgeList[i].node2);
if( uSet != vSet )
{
cout << "Taking edge : " << edgeList[i].node1->id << "--" << edgeList[i].node2->id << ":" << edgeList[i].weight << endl;
UNION(uSet, vSet);
changeEdgeColor(&edgeList[i], GREEN);
sleep(1);
changeNodeColor(edgeList[i].node1, GREEN);
usleep(500000);
changeNodeColor(edgeList[i].node2, GREEN);
sleep(1);
}
}
}
//------------------------------------------------------------------------------
// reset() -- reset the scanline alg but keep the polygon and edge tables
//------------------------------------------------------------------------------
void Scanline::reset()
{
refET = 0;
nAET = 0;
refAET = 0;
nAPT = 0;
curY = 0.0f;
curPoly = nullptr;
if (nET > 0) sortEdges(et,nET,1);
}
typedef struct Set {
}
int main (int argc, char const * argv[]) {
inputGraph();
sortEdges();
printGraph();
return 0;
}
void TreeOptimizer2::initializeOptimization(){
// compute the size of the preconditioning matrix
int sz=maxIndex()+1;
DEBUG(1) << "Size= " << sz << endl;
M.resize(sz);
DEBUG(1) << "allocating M(" << sz << ")" << endl;
iteration=1;
// sorting edges
if (sortedEdges!=0){
delete sortedEdges;
sortedEdges=0;
}
sortedEdges=sortEdges();
}
// Find a minimum spanning tree of wg using Kruskal's algorithm and
// return it in mstree.
void kruskal(Wgraph& wg, Wgraph& mstree) {
edge e, e1; vertex u,v,cu,cv; weight w;
class Partition vsets(wg.n());
edge *elist = new edge[wg.m()+1];
int i = 1;
for (e = wg.first(); e != 0; e = wg.next(e)) elist[i++] = e;
sortEdges(elist,wg);
for (e1 = 1; e1 <= wg.m(); e1++) {
e = elist[e1];
u = wg.left(e); v = wg.right(e); w = wg.weight(e);
cu = vsets.find(u); cv = vsets.find(v);
if (cu != cv) {
vsets.link(cu,cv);
e = mstree.join(u,v); mstree.setWeight(e,w);
}
}
}
/**
* kruskal 最小生成树算法
*/
void kruskal(MGraph G)
{
// 获取图中所有的边
Edge* edges = getEdges(G);
// 对边按权值进行排序(edges是经过排序后的边的数组)
sortEdges(edges, G.edgeNum);
int vends[MAX] = {0};
Edge kruskal[MAX];
int index = 0;
/*
* 在不形成环路的前提下，将边从小到大拿出来，直到生成一个树
*/
for(int i = 0; i < G.edgeNum; i++)
{
int edgeStart = getPosition(G, edges[i].start);
int edgeEnd = getPosition(G, edges[i].end);
// 获取edgeStart和edgeEnd在已有的最小生成树中的终点
int m = getEnd(vends, edgeStart);
int n = getEnd(vends, edgeEnd);
// 如果m!=n，意味着"边i"与"已经添加到最小生成树中的顶点"没有形成环路
if(m != n)
{
vends[m] = n;
kruskal[index++] = edges[i];
}
}
free(edges);
// 统计并打印"kruskal最小生成树"的信息
int length = 0;
for(int i = 0; i < index; i++)
length += kruskal[i].weight;
printf("length = %d \n", length);
for(int i = 0; i < index; i++)
{
printf("(%c, %c) ", kruskal[i].start, kruskal[i].end);
}
printf("\n");
}
void kruskal(Wgraph& wg, UiList& mstree) {
// Find a minimum spanning tree of wg using Kruskal's algorithm and
// return it in mstree. This version returns a list of the edges using
// the edge numbers in wg, rather than a separate Wgraph data structure.
edge e, e1; vertex u,v,cu,cv; weight w;
Partition vsets(wg.n());
edge *elist = new edge[wg.m()+1];
int i = 1;
for (e = wg.first(); e != 0; e = wg.next(e)) elist[i++] = e;
sortEdges(elist,wg);
for (e1 = wg.first(); e1 != 0; e1 = wg.next(e1)) {
e = elist[e1];
u = wg.left(e); v = wg.right(e); w = wg.weight(e);
cu = vsets.find(u); cv = vsets.find(v);
if (cu != cv) {
vsets.link(cu,cv); mstree.addLast(e);
}
}
}
void TreeOptimizer3::initializeOptimization(EdgeCompareMode mode){
edgeCompareMode=mode;
// compute the size of the preconditioning matrix
int sz=maxIndex()+1;
DEBUG(1) << "Size= " << sz << endl;
M.resize(sz);
DEBUG(1) << "allocating M(" << sz << ")" << endl;
iteration=1;
// sorting edges
if (sortedEdges!=0){
delete sortedEdges;
sortedEdges=0;
}
sortedEdges=sortEdges();
mpl=maxPathLength();
rotGain=1.;
trasGain=1.;
}
/* Continuous model synthesis main function
*/
bool continuousModelSynthesis2D(vector<Edge*> &edges, vector<Vertex*> &vertices,
CMSModel &input, Grid &grid)
{
for( std::vector<Vertex*>::iterator vertex_itr = vertices.begin();
vertex_itr != vertices.end(); vertex_itr++)
sortEdges(*vertex_itr);
int *relativeCounters;
std::vector<VertexStateEdges> sourceValidStates;
std::vector<VertexState> validStates;
relativeCounters = new int[vertices.size()];
for(unsigned int i = 0; i < vertices.size(); i++)
relativeCounters[i] = 0;
generateValid(sourceValidStates, input, grid);
generateStates( vertices, sourceValidStates, validStates, relativeCounters);
//srand(time(NULL)); done already;
while(validStates.size() > 0)
{
sort(validStates.begin(), validStates.end());
std::vector<VertexState>::iterator itr = validStates.begin();
if(*((*itr).relativesCounter) > 1)
{
int size = validStates.size();
//int randomstate = rand()%(validStates.size());
//Sanity check, validStates should be smaller than relativesCounter
if( *((*itr).relativesCounter) > (int)validStates.size())
exit(9001);
int randomstate = rand() % *((*itr).relativesCounter);
itr += randomstate;
}
else
{
int i = 0;
i++;
}
//(*((*itr).relativesCounter))--;
VertexState state = (*itr);
validStates.erase(itr);
for(int i = 0; i < 4; i++)
{
if(state.dependentedges[i] != NULL)
{
constrainEdge(state.dependentedges[i],
state.edgeinfo.dependentstates[i].leftFace,
state.edgeinfo.dependentstates[i].rightFace, validStates);
}
}
}
bool result = true;
for(unsigned int i = 0; i < vertices.size(); i++)
{
std::cout << relativeCounters[i];
if( relativeCounters[i] == 0)
{
result = false;
}
}
std::cout << std::endl;
delete relativeCounters;
return result;
}
/* Continuous model synthesis main function
*/
bool continuousModelSynthesis(vector<Edge*> &edges, vector<Vertex*> &vertices,
CMSModel3D &input, Grid &grid)
{
Utils::Timer timer;
cout << endl << "---Continuous Model Synthesis Progress---" << std::endl;
unsigned int seed = (unsigned int)time(NULL);
std::cout<< "Changing seed..." << seed << std::endl;
srand(seed);
if(firstrun)
{
for( std::vector<Vertex*>::iterator vertex_itr = vertices.begin();
vertex_itr != vertices.end(); vertex_itr++)
{
sortEdges(*vertex_itr);
}
//firstrun = false;
}
PotentialVertex *currentVertex;
std::vector<PotentialVertex*> unassignedVertices;
std::vector<PotentialVertex*>::iterator unassignedItr;
PotentialVertexState selectedState;
if(firstrun)
{
cout << "Generating states..." << endl;
timer.start();
bruteForceGenerate(unassignedVertices, input, grid);
timer.stop();
timer.printSeconds();
firstrun = false;
}
else
{
while(history.selectedVertexList.size() > 0)
{
vector<vector<PotentialVertexState>*>::iterator listitr;
vector<PotentialVertexState>::iterator stateitr;
listitr = history.constrainedVertexList.back().begin();
stateitr = history.removedStatesList.back().begin();
while( listitr != history.constrainedVertexList.back().end() && stateitr != history.removedStatesList.back().end() )
{
(*listitr)->push_back(*stateitr);
listitr++;
stateitr++;
}
history.constrainedVertexList.pop_back();
history.removedStatesList.pop_back();
unassignedVertices.push_back(history.selectedVertexList.back());
unassignedVertices.back()->states.push_back(history.selectedState.back());
history.selectedVertexList.pop_back();
history.selectedState.pop_back();
}
}
cout << "Assigning states..." << endl;
timer.start();
while(unassignedVertices.size() > 0)
{
//std::cout << "Assignments Remaining: " << unassignedVertices.size() << std::endl;
sort(unassignedVertices.begin(), unassignedVertices.end(), sortVertex);
if( (*unassignedVertices.begin())->states.size() == 0)
{
//unassignedVertices.erase(unassignedVertices.begin());
//continue;
//backtrack
//std::cout << "BACKTRACK: " << unassignedVertices.size() << std::endl;
vector<vector<PotentialVertexState>*>::iterator listitr;
vector<PotentialVertexState>::iterator stateitr;
listitr = history.constrainedVertexList.back().begin();
stateitr = history.removedStatesList.back().begin();
while( listitr != history.constrainedVertexList.back().end() && stateitr != history.removedStatesList.back().end() )
{
(*listitr)->push_back(*stateitr);
listitr++;
stateitr++;
}
history.constrainedVertexList.pop_back();
history.removedStatesList.pop_back();
if(history.constrainedVertexList.size() == 0 || history.removedStatesList.size() == 0)
{
std::cout << "!!!" << std::endl;
break;
}
history.constrainedVertexList.back().push_back(&(history.selectedVertexList.back()->states));
history.removedStatesList.back().push_back(history.selectedState.back());
unassignedVertices.push_back(history.selectedVertexList.back());
history.selectedVertexList.pop_back();
history.selectedState.pop_back();
continue;
}
unassignedItr = unassignedVertices.begin();
currentVertex = *(unassignedItr);
unassignedVertices.erase(unassignedItr);
selectedState = currentVertex->getAndRemoveRandomState();
history.selectedVertexList.push_back(currentVertex);
history.selectedState.push_back(selectedState);
history.constrainedVertexList.push_back(vector<vector<PotentialVertexState>*>());
history.removedStatesList.push_back(vector<PotentialVertexState>());
for(int i = 0; i < NUM_VOLUMES; i++)
{
if(currentVertex->volumes[i] != NULL)
{
constrainVolume(currentVertex->volumes[i], selectedState.volumes[i], unassignedVertices, history);
}
}
}
for(std::vector<PotentialVertex*>::iterator itr = unassignedVertices.begin(); itr != unassignedVertices.end(); itr++)
{
delete (*itr);
}
timer.stop();
timer.printSeconds();
return true;
}
