BASKER_INLINE int Basker<Int, Entry,Exe_Space>::match_ordering(int option) { //printf("match_order called\n"); /* ---- Tests -------- INT_1DARRAY mperm; MALLOC_INT_1DARRAY(mperm, A.nrow); mc64(2,mperm); INT_1DARRAY mperm2; MALLOC_INT_1DARRAY(mperm2, A.nrow); mwm(A,mperm2); return 0; */ Int job = 2; //5 is the default for SuperLU_DIST //INT_1DARRAY mperm = order_match_array; MALLOC_INT_1DARRAY(order_match_array, A.nrow); //MALLOC_INT_1DARRAY(mperm, A.nrow); mwm(A,order_match_array); //mc64(job,order_match_array); //mc64(job,mperm); match_flag = BASKER_TRUE; #ifdef BASKER_DEBUG_ORDER printf("Matching Perm \n"); for(Int i = 0; i < A.nrow; i++) { printf("%d, \n", order_match_array(i)); //printf("%d, \n", mperm[i]); } printf("\n"); #endif //We want to test what the match ordering does if //have explicit zeros #ifdef BASKER_DEBUG_ORDER FILE *fp; fp = fopen("match_order.txt", "w"); for(Int i = 0; i < A.nrow; i++) { fprintf(fp, "%d \n", order_match_array(i)); } fclose(fp); #endif permute_row(A,order_match_array); //permute_row(A,mperm); //May have to call row_idx sort return 0; }//end match_ordering()
void IMFT<Ptr>::twoFrameCorresponding(vector<ListGraph::Node> vecUFrame, vector<ListGraph::Node> vecVFrame) { if(m_isDebug) printf("2-Frame Corresponding : # F1 - %d, # F2 - %d\n", vecUFrame.size(), vecVFrame.size()); // make graph, weight map ListGraph g; ListGraph::NodeMap<V> gNodeMap(g); ListGraph::EdgeMap<double> gEdgeMap(g); // make nodes of UFrame : save node id of UFrame for(int i=0;i<vecUFrame.size();i++){ ListGraph::Node n = g.addNode(); V v; v.id = m_g.id(vecUFrame.at(i)); v.ptr = (*m_gNodeMap)[vecUFrame.at(i)].ptr; v.nFrame = 1; gNodeMap[n] = v; } // make nodes of VFrame : save node id of VFrame for(int i=0;i<vecVFrame.size();i++){ ListGraph::Node n = g.addNode(); V v; v.id = m_g.id(vecVFrame.at(i)); v.ptr = (*m_gNodeMap)[vecVFrame.at(i)].ptr; v.nFrame = 2; gNodeMap[n] = v; // connection for(ListGraph::NodeIt pn(g); pn != INVALID; ++pn){ if(gNodeMap[pn].nFrame != v.nFrame){ double weight = gain(gNodeMap[pn], v); gEdgeMap[g.addEdge(pn,n)] = weight; // ListGraph::Edge e = g.addEdge(pn,n); // gEdgeMap[e] = weight; // gNodeMap[m_g.u(e)].edgeID = g.id(e); // gNodeMap[m_g.v(e)].edgeID = g.id(e); } } } // maximum weighted matching MaxWeightedMatching<ListGraph, ListGraph::EdgeMap<double> > mwm(g, gEdgeMap); mwm.run(); int wsum = mwm.matchingWeight(); if(m_isDebug) printf("2-Frame Max = %d\n", wsum); // make edges of original graph using original nodes' ids for(ListGraph::EdgeIt e(g); e != INVALID; ++e){ if(mwm.matching(e)){ int origUId = gNodeMap[g.u(e)].id; int origVId = gNodeMap[g.v(e)].id; ListGraph::Node newU, newV; newU = m_g.nodeFromId(origUId); newV = m_g.nodeFromId(origVId); if(m_isDebug) printf("2-Frame Connection %d, %d nodes\n", origUId, origVId); double weight = gain((*m_gNodeMap)[newU], (*m_gNodeMap)[newV]); ListGraph::Edge e = m_g.addEdge(newU,newV); (*m_gEdgeMap)[e] = weight; (*m_gNodeMap)[m_g.u(e)].edgeID = m_g.id(e); (*m_gNodeMap)[m_g.v(e)].edgeID = m_g.id(e); // if u가 track이 없으면, track 생성하고, v도 track에 집어 넣음. // u가 track이 있으면, v를 그 track에 집어 넣음. if(cnt > m_nWindow){ int vId = m_g.id(m_g.u(e))-1; if(!(*m_gNodeMap)[m_g.nodeFromId(vId)].isTrack){ // generate a track of vId m_cntTrack ++; Track track; track.setNum(m_cntTrack); track.putNode((*m_gNodeMap)[m_g.nodeFromId(vId)].ptr, vId, (*m_gNodeMap)[m_g.nodeFromId(vId)].nFrame); (*m_gNodeMap)[m_g.nodeFromId(vId)].isTrack = 1; (*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack = m_cntTrack; if(m_isDebug) printf("Generate new track # %d of node %d\n", m_cntTrack, vId); // add v(e) to the track track.putNode((*m_gNodeMap)[m_g.v(e)].ptr, m_g.id(m_g.v(e)), (*m_gNodeMap)[m_g.v(e)].nFrame); (*m_gNodeMap)[m_g.v(e)].isTrack = 1; (*m_gNodeMap)[m_g.v(e)].nTrack = m_cntTrack; m_tracks.push_back(track); } else{ // add v(e) to the track for(int i=0;i<m_tracks.size();i++){ if(m_tracks.at(i).num() == (*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack){ m_tracks.at(i).putNode((*m_gNodeMap)[m_g.v(e)].ptr, m_g.id(m_g.v(e)), (*m_gNodeMap)[m_g.v(e)].nFrame); (*m_gNodeMap)[m_g.v(e)].nTrack = (*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack; (*m_gNodeMap)[m_g.v(e)].isTrack = 1; if(m_isDebug) printf("put node %d to the track %d\n", m_g.id(m_g.v(e)), (*m_gNodeMap)[m_g.v(e)].nTrack); break; } } } } } } }
void IMFT<Ptr>::backtracking() { if(m_isDebug) printf("Backtracking\n"); // backtracking for frame 1-2 corresponding for(ListGraph::NodeIt n(m_g); n != INVALID; ++n){ if((*m_gNodeMap)[n].nFrame == 1 && !(*m_gNodeMap)[n].isIn && (*m_gNodeMap)[n].edgeID >= 0){ // erase initial edges if(m_isDebug) printf("erase edge # %d\n", (*m_gNodeMap)[n].edgeID); ListGraph::Edge e; e = m_g.edgeFromId((*m_gNodeMap)[n].edgeID); ListGraph::Node v = m_g.v(e); (*m_gNodeMap)[n].edgeID = -1; (*m_gNodeMap)[v].edgeID = -1; if(m_isDebug) printf("node initialization %d\n", m_g.id(v)); m_g.erase(e); // make extension edges from initial edges // connection to previous nodes for(ListGraph::NodeIt np(m_g); np != INVALID; ++np){ if((*m_gNodeMap)[np].nFrame != 1 && (*m_gNodeMap)[np].isIn && (*m_gNodeMap)[np].edgeID < 0){ double weight = gain((*m_gNodeMap)[np], (*m_gNodeMap)[n]); ListGraph::Edge e = m_g.addEdge(n,np); (*m_gEdgeMap)[e] = weight; (*m_gNodeMap)[m_g.u(e)].edgeID = m_g.id(e); (*m_gNodeMap)[m_g.v(e)].edgeID = m_g.id(e); } } } } confirmDGraph(); // maximum weighted matching MaxWeightedMatching<ListGraph, ListGraph::EdgeMap<double> > mwm(m_g, *m_gEdgeMap); mwm.run(); int wsum = mwm.matchingWeight(); if(m_isDebug) printf("Max = %d\n", wsum); // make maximum path cover C /* for all edges // if it is not matched, delete edges, if it was old edge -> save oldEdge // if it is matched, liking edge to nodes : save edge id to the connedted nodes // find correction edges : matching edges having a node of old edges */ for(ListGraph::EdgeIt e(m_g); e != INVALID; ++e){ if(mwm.matching(e)){ if(m_isDebug) printf("Edge of Maximum Path Cover : %d\n", m_g.id(e)); (*m_gNodeMap)[m_g.u(e)].edgeID = m_g.id(e); (*m_gNodeMap)[m_g.v(e)].edgeID = m_g.id(e); } else{ (*m_gNodeMap)[m_g.v(e)].edgeID = -1; m_g.erase(e); } } confirmDGraph(); // save old edges m_vecOldEdge.clear(); for(ListGraph::EdgeIt e(m_g); e != INVALID; ++e){ m_vecOldEdge.push_back(m_g.id(e)); } }
void IMFT<Ptr>::tracking() { // maximum weighted matching MaxWeightedMatching<ListGraph, ListGraph::EdgeMap<double> > mwm(m_g, *m_gEdgeMap); mwm.run(); double wsum = mwm.matchingWeight(); if(m_isDebug) printf("Max = %d\n", wsum); m_wsum = wsum; // make maximum path cover C /* for all edges // if it is not matched, delete edges, if it was old edge -> save oldEdge // if it is matched, liking edge to nodes : save edge id to the connedted nodes // find correction edges : matching edges having a node of old edges */ vector<ListGraph::Edge> vecCorEdge, vecDelOldEdge; for(ListGraph::EdgeIt e(m_g); e != INVALID; ++e){ if(mwm.matching(e)){ if(m_isDebug) printf("Edge of Maximum Path Cover : %d\n", m_g.id(e)); (*m_gNodeMap)[m_g.u(e)].edgeID = m_g.id(e); (*m_gNodeMap)[m_g.v(e)].edgeID = m_g.id(e); // track extension ListGraph::Node nodeT = m_g.nodeFromId(m_g.id(m_g.u(e))-1); if((*m_gNodeMap)[m_g.v(e)].nFrame == cnt){ if((*m_gNodeMap)[nodeT].isTrack){ for(int i=0;i<m_tracks.size();i++){ if(m_tracks.at(i).num() == (*m_gNodeMap)[nodeT].nTrack){ m_tracks.at(i).putNode((*m_gNodeMap)[m_g.v(e)].ptr, m_g.id(m_g.v(e)), (*m_gNodeMap)[m_g.v(e)].nFrame); (*m_gNodeMap)[m_g.v(e)].nTrack = (*m_gNodeMap)[nodeT].nTrack; (*m_gNodeMap)[m_g.v(e)].isTrack = 1; if(m_isDebug) printf("At cnt %d, put node %d of frame %d to the track %d\n", cnt, m_g.id(m_g.v(e)), (*m_gNodeMap)[m_g.v(e)].nFrame, (*m_gNodeMap)[m_g.v(e)].nTrack); break; } } } else{ // make new track if(cnt > m_nWindow){ m_cntTrack ++; Track track; track.setNum(m_cntTrack); track.putNode((*m_gNodeMap)[nodeT].ptr, m_g.id(nodeT), (*m_gNodeMap)[nodeT].nFrame); (*m_gNodeMap)[nodeT].isTrack = 1; (*m_gNodeMap)[nodeT].nTrack = m_cntTrack; if(m_isDebug) printf("Generate new track # %d of node %d\n", m_cntTrack, m_g.id(nodeT)); // add v(e) to the track track.putNode((*m_gNodeMap)[m_g.v(e)].ptr, m_g.id(m_g.v(e)), (*m_gNodeMap)[m_g.v(e)].nFrame); (*m_gNodeMap)[m_g.v(e)].isTrack = 1; (*m_gNodeMap)[m_g.v(e)].nTrack = m_cntTrack; m_tracks.push_back(track); } } } } else{ for(int i=0;i<m_vecOldEdge.size();i++){ if(m_g.id(e) == m_vecOldEdge.at(i)) { // edges deleted by correction edge vecDelOldEdge.push_back(e); (*m_gNodeMap)[m_g.v(e)].edgeID = -1; break; } } m_g.erase(e); } } // false hypothesis /* for all correction edges // find false hypothesis : edges having a directed path from an edge replaced by a correction edge // : find a previous track having an edge replaced by a correction edge // : false hypotheses = edges of tracks // delete all false hypotheses */ for(int i=0;i<vecDelOldEdge.size();i++){ ListGraph::Edge delEdge = vecDelOldEdge.at(i); if(m_isDebug) printf("At cnt %d, edge %d is an old edge deleted by a correction edge\n",cnt, m_g.id(delEdge)); // delete false hypotheses int vId = m_g.id(m_g.v(delEdge)); if(m_isDebug) printf("delete node %d from the track %d\n", vId ,(*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack); if(eraseNodeinTrack((*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack, vId)){ (*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack = 0; (*m_gNodeMap)[m_g.nodeFromId(vId)].isTrack = 0; } ListGraph::Node uNode = m_g.nodeFromId(vId+1); int fhId = (*m_gNodeMap)[uNode].edgeID; while(fhId != -1){ if(m_isDebug) printf("False Hypothsis %d is deleted\n", fhId); ListGraph::Edge fhEdge = m_g.edgeFromId(fhId); (*m_gNodeMap)[m_g.u(fhEdge)].edgeID = -2; // check for a node connected with a deleted edge (*m_gNodeMap)[m_g.v(fhEdge)].edgeID = -2; // check for a node connected with a deleted edge vId = m_g.id(m_g.v(fhEdge)); if(m_isDebug) printf("At cnt %d, delete node %d(frame %d) from the track %d\n", cnt, vId, (*m_gNodeMap)[m_g.nodeFromId(vId)].nFrame, (*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack); if(eraseNodeinTrack((*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack, vId)){ (*m_gNodeMap)[m_g.nodeFromId(vId)].nTrack = 0; (*m_gNodeMap)[m_g.nodeFromId(vId)].isTrack = 0; } uNode = m_g.nodeFromId(vId+1); fhId = (*m_gNodeMap)[uNode].edgeID; m_g.erase(fhEdge); } } // new edges /* if cnt < m_nWindow : for i=1 to cnt if cnt <= m_nWindow : for i=cnt-m_nWindow+1 to cnt // make two frame correspondance Vi ~ Vi+1 */ vector<ListGraph::Node> vecUFrame, vecVFrame; if(cnt < m_nWindow){ for(int i=1; i<cnt; i++){ vecUFrame.clear(); vecVFrame.clear(); // 2-frame corresponding for(ListGraph::NodeIt n(m_g); n != INVALID; ++n){ // if((*m_gNodeMap)[n].nFrame > i+1) break; if((*m_gNodeMap)[n].nFrame == i && !(*m_gNodeMap)[n].isIn && (*m_gNodeMap)[n].edgeID == -2) vecUFrame.push_back(n); if((*m_gNodeMap)[n].nFrame == i+1 && (*m_gNodeMap)[n].isIn && (*m_gNodeMap)[n].edgeID == -2) vecVFrame.push_back(n); } if(vecUFrame.size() != 0 && vecVFrame.size() != 0){ if(m_isDebug) printf("2-Frame Corresponding of %d and %d\n", i, i+1); twoFrameCorresponding(vecUFrame, vecVFrame); } } } else{ for(int i=cnt-m_nWindow+1; i<cnt; i++){ vecUFrame.clear(); vecVFrame.clear(); // 2-frame corresponding for(ListGraph::NodeIt n(m_g); n != INVALID; ++n){ // if((*m_gNodeMap)[n].nFrame > i+1) break; if((*m_gNodeMap)[n].nFrame == i && !(*m_gNodeMap)[n].isIn && (*m_gNodeMap)[n].edgeID == -2) vecUFrame.push_back(n); if((*m_gNodeMap)[n].nFrame == i+1 && (*m_gNodeMap)[n].isIn && (*m_gNodeMap)[n].edgeID == -2) vecVFrame.push_back(n); } if(vecUFrame.size() != 0 && vecVFrame.size() != 0){ if(m_isDebug) printf("2-Frame Corresponding of %d and %d\n", i, i+1); twoFrameCorresponding(vecUFrame, vecVFrame); } } } }