Node* Node::predecessor() {//Poprzednik Node *p = this; if (this->left != NULL) return(maximal(p->left)); throw std::exception("Wezel nie posiada poprzednika."); };
void FastHessian::compute() { // For each octave, only the filter sizes not already used for // smaller scales are added. This means that the (up to) four // interval layers for each octave will be at different points of // the response map. This mapping gives those indexes, corresponding // to the buildup in buildResponseMap(). // // (Taken from the openSURF code). static const int filter_map [OCTAVES][INTERVALS] = {{0,1,2,3}, {1,3,4,5}, {3,5,6,7}, {5,7,8,9}, {7,9,10,11}}; // start by clearing out any existing interest points and building // the Hessian response map. m_ipoints.clear(); buildResponseMap(); // Compute maxima by comparing points to the level above and below // them. The SURF article is quite vague on whether or not // comparison is made between different octaves. The SIFT article // does not mention this either. However, the opencv and the // opensurf implementations seem to agree that comparison is only // done within octaves, so this is the approach we take here. ResponseLayer *b,*m,*t; int o,i,x,y; // Loop through all octaves, and for octave, select m_interval-2 // sets of top/middle/bottom. This does in practice mean that only 3 // or 4 intervals pr octave make sense. for(o = 0; o < m_octaves; o++) { for(i = 0; i < m_intervals-2; i++) { b = m_layers.at(filter_map[o][i]); m = m_layers.at(filter_map[o][i+1]); t = m_layers.at(filter_map[o][i+2]); // Loop at the scale of the top-most (most sparse) layer for(y = 0; y < t->height(); y++) { for(x = 0; x < t->width(); x++) { Point pt(x,y); if(maximal(pt, b, m, t)) addPoint(pt, b, m, t); } } } } }
int main(int argc, char* argv[]) { if ( argc != 4 ) { cout << "Usage: CMOrderedTreeMiner support input_file output_file" << endl; exit (1); } int support; istringstream iss(argv[1]); iss >> support; if(!iss) { cerr << "invalid argument, not an integer value" << endl; exit (1); } vector<int> frequency(1000,0); //assuming the max frequent tree size is 1000 vector<int> checked(1000,0); vector<int> closed(1000,0); vector<int> maximal(1000,0); currentPatternTree.initialSize(); time_t start_time; time_t stop_time; /****************************************************************** step1: read in the database, and find the MIN_VERTEX and MAX_VERTEX ******************************************************************/ string inputFile = argv[2]; string outputFile = argv[3]; ofstream outFile(outputFile.c_str()); if(!outFile) { cerr << "cannot open OUTPUT file!" << endl; exit(1); } ifstream inFile(inputFile.c_str()); if(!inFile) { cerr << "cannot open INPUT file!" << endl; exit(1); } vector<TextTree> database; int myTid = 0; while ( !inFile.eof() ) { TextTree tt; inFile >> tt; if ( !inFile.eof() ) { tt.tid = myTid++; for ( short i = 0; i < tt.vNumber; i++ ) { if ( tt.vLabel[i] < MIN_VERTEX ) MIN_VERTEX = tt.vLabel[i]; if ( tt.vLabel[i] > MAX_VERTEX ) MAX_VERTEX = tt.vLabel[i]; } database.push_back(tt); } } inFile.close(); /****************************************************************** step2.1: scan the database once, find frequent node labels ******************************************************************/ vector<bool> isFrequent(MAX_VERTEX - MIN_VERTEX + 1, false); map<short,int> count; map<short,int>::iterator pos; start_time = time(0); for ( int i = 0; i < database.size(); i++ ) { vector<bool> isVisited(MAX_VERTEX - MIN_VERTEX + 1, false); for ( short j = 0; j < database[i].vNumber; j++ ) { short temp = database[i].vLabel[j] - MIN_VERTEX; if ( !isVisited[temp] ) { isVisited[temp] = true; pos = count.find(temp); if ( pos != count.end() ) count[temp]++; else count.insert(make_pair(temp, 1)); } } } for ( int i = 0; i < isFrequent.size(); i++ ) { if ( count[i] >= support ) isFrequent[i] = true; } /****************************************************************** step2.2: scan the database another time, to get occurrenceList for all frequent nodes ******************************************************************/ map<short,OccLongList> occLongList; map<short,OccLongList>::iterator pos2; vector<short> dummy; for ( int i = 0; i < database.size(); i++ ) { for ( short j = 0; j < database[i].vNumber; j++ ) { if ( isFrequent[database[i].vLabel[j] - MIN_VERTEX] == true ) { occLongList[database[i].vLabel[j] - MIN_VERTEX].insert(i,dummy,j); } } } /****************************************************************** step2.3: explore each frequent item ******************************************************************/ for ( pos2 = occLongList.begin(); pos2 != occLongList.end(); ++pos2 ) { if ( pos2->second.mySupport >= support ) { currentPatternTree.addRightmost(pos2->first + MIN_VERTEX,0); pos2->second.explore(isFrequent,database,support,checked,closed,maximal); currentPatternTree.deleteRightmost(); } } stop_time = time(0); /****************************************************************** step2.4: output the results ******************************************************************/ for ( short j = 0; j < 1000; j++ ) { if ( checked[j] > 0 ) { outFile << "number of checked " << j << " trees: " << checked[j] << endl; } } outFile << endl << "************************" << endl; for ( short j = 0; j < 1000; j++ ) { if ( closed[j] > 0 ) { outFile << "number of closed " << j << " trees: " << closed[j] << endl; } } outFile << endl << "************************" << endl; for ( short j = 0; j < 1000; j++ ) { if ( maximal[j] > 0 ) { outFile << "number of maximal " << j << " trees: " << maximal[j] << endl; } } outFile << endl; outFile << "Total Running Time: " << difftime(stop_time, start_time) << endl; outFile.close(); return 0; }
/* create mesh from a vector of nodes, element list in format => * {nuber of nodes, node0, node1, ..., material}, {REPEAT}, ..., 0 (end of list); and surface colors in format => * global surface, {number of nodes, node0, node1, ..., surface}, {REPEAT}, ..., 0 (end of list); */ MESH_DATA* MESH_Create (REAL (*nodes) [3], int *elements, int *surfaces) { int maximal_node, minimal_node, elements_count, faces_count, temp, *eleptr, n; REAL (*node) [3]; MEM *elemem, facmem, mapmem; ELEMENT *ele, *enx, *elist; FACE *fac, *cac, *gac, *flist; MAP *faces, *smap; MESH_DATA *msh; maximal_node = 0; minimal_node = INT_MAX; elements_count = 0; faces_count = 0; /* create mesh storage */ ERRMEM (msh = static_cast<MESH_DATA*>(MEM_CALLOC (sizeof (MESH_DATA)))); elemem = &msh->elemem; /* calculate elements */ for (eleptr = elements; eleptr [0]; eleptr += (eleptr [0]+2)) elements_count ++; MEM_Init (elemem, sizeof (ELEMENT), elements_count); MEM_Init (&facmem, sizeof (FACE), MEMCHUNK); MEM_Init (&mapmem, sizeof (MAP), MEMCHUNK); MEM_Init (&msh->mapmem, sizeof (MAP), MIN (elements_count, MEMCHUNK)); elist = NULL; flist = NULL; faces = NULL; /* create elements list & face adjacency map */ for (eleptr = elements; eleptr [0]; eleptr += (eleptr [0]+2)) { ASSERT ( eleptr [0] == 4 || /* tetrahedron */ eleptr [0] == 5 || /* pyramid */ eleptr [0] == 6 || /* wedge */ eleptr [0] == 8, /* hexahedron */ "ERROR: unsupported element type"); ele = create_element (elemem, eleptr); flist = create_faces (&facmem, &mapmem, &faces, ele, flist); ele->next = elist; elist = ele; /* node number extrema */ temp = maximal (eleptr); if (temp > maximal_node) maximal_node = temp; temp = minimal (eleptr); if (temp < minimal_node) minimal_node = temp; } /* calculate faces */ for (fac = flist; fac; fac = fac->next) if (fac->ele) faces_count ++; /* alocate additional storage */ MEM_Init (&msh->facmem, sizeof (FACE), faces_count); msh->nodes_count = (maximal_node - minimal_node + 1); ERRMEM (msh->nodes = static_cast<REAL(*)[3]>(malloc (sizeof (REAL [3]) * (msh->nodes_count)))); msh->surfeles_count = msh->bulkeles_count = 0; msh->surfeles = msh->bulkeles = NULL; /* set up elements */ for (ele = elist; ele; ele = enx) { enx = ele->next; if (minimal_node > 0) /* impose 0-based indexing */ { for (temp = 0; temp < ele->type; temp ++) ele->nodes [temp] -= minimal_node; } ele->prev = NULL; if (ele->neighs < neighs (ele->type)) /* surface element */ { msh->surfeles_count ++; ele->next = msh->surfeles; if (msh->surfeles) msh->surfeles->prev = ele; msh->surfeles = ele; } else /* bulk element */ { msh->bulkeles_count ++; ele->next = msh->bulkeles; if (msh->bulkeles) msh->bulkeles->prev = ele; msh->bulkeles = ele; } } /* create surfaces map => skip first element of 'surfaces' == the global surface kind */ for (eleptr = (surfaces + 1), smap = NULL, temp = 0; eleptr [0]; eleptr += (eleptr [0]+2), temp ++) { fac = static_cast<FACE*>(MEM_Alloc (&facmem)); ASSERT ( eleptr [0] == 3 || /* triangle */ eleptr [0] == 4, /* quad */ "ERROR: unsupported face type"); fac->type = eleptr [0]; for (n = 0; n < eleptr [0]; n ++) fac->nodes [n] = eleptr [n+1]; sort (fac->nodes, fac->nodes+fac->type-1); fac->color = eleptr [eleptr [0] + 1]; MAP_Insert (&mapmem, &smap, fac, /* map by the type/nodes key */ fac, face_compare); } /* set up nodes */ for (temp = minimal_node, node = msh->nodes; temp <= maximal_node; temp ++, node ++) { COPY (nodes [temp], *node); } /* set up faces */ for (fac = flist; fac; fac = fac->next) { if (fac->ele) /* see (***) */ { ele = fac->ele; cac = static_cast<FACE*>(MEM_Alloc (&msh->facmem)); setup_face (ele, fac->index, cac, 0); /* setup face nodes without sorting them */ cac->index = fac->index; cac->ele = fac->ele; setup_normal (msh->nodes, cac); /* calculate outer spatial normal */ cac->next = ele->faces; /* append element face list */ ele->faces = cac; /* set the mapped surface kind if possible => otherwise the global one */ gac = static_cast<FACE*>(MAP_Find (smap, fac, face_compare)); cac->color = (gac ? gac->color : surfaces [0]); } } /* create mesh face list */ for (ele = msh->surfeles; ele; ele = ele->next) { for (fac = ele->faces; fac; fac = fac->next) { fac->n = msh->faces; msh->faces = fac; } } /* clean up */ MEM_Release (&facmem); MEM_Release (&mapmem); return msh; }