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);
}
}
}
}
