// Return true if the cut edge at loop[index] is preceded by cuts through // the edge end points. bool Foam::geomCellLooper::edgeEndsCut ( const labelList& loop, const label index ) const { label edgeI = getEdge(loop[index]); const edge& e = mesh().edges()[edgeI]; const label prevCut = loop[loop.rcIndex(index)]; const label nextCut = loop[loop.fcIndex(index)]; if (!isEdge(prevCut) && !isEdge(nextCut)) { // Cuts before and after are both vertices. Check if both // the edge endpoints label v0 = getVertex(prevCut); label v1 = getVertex(nextCut); if ( (v0 == e[0] && v1 == e[1]) || (v0 == e[1] && v1 == e[0]) ) { return true; } } return false; }
/** * Returns the inner segment configuration. * @return inner segment configuration */ unsigned int BOP_Segment::getConfig() { if (isUndefined(m_cfg1)) return m_cfg2; else if (isUndefined(m_cfg2)) return m_cfg1; else if (isVertex(m_cfg1)) { // v1 is vertex if (isVertex(m_cfg2)) { // v2 is vertex return createEdgeCfg(getEdgeBetween(getVertex(m_cfg1),getVertex(m_cfg2))); } else if (isEdge(m_cfg2)) { // v2 is edge if (isOnEdge(m_cfg1,getEdge(m_cfg2))) return m_cfg2; else return createInCfg(); //IN } else return createInCfg(); //IN } else if (isEdge(m_cfg1)) { // v1 is edge if (isVertex(m_cfg2)) { // v2 is vertex if (isOnEdge(m_cfg2,getEdge(m_cfg1))) return m_cfg1; else return createInCfg(); //IN } else if (isEdge(m_cfg2)) { // v2 is edge if (m_cfg1 == m_cfg2) return m_cfg1; else return createInCfg(); // IN } else return createInCfg(); // IN } else return createInCfg(); // IN }
void EdgeStrategy::onDataDenied ( const ndn::Data& data, const ndn::Interest& interest, ns3::Time& delay, const std::string& why ) { // if the denied data isn't leaving the network // then we just do the normal router stuff auto in_face = getFaceTable().get( data.getIncomingFaceId() ); auto out_face = getFaceTable().get( interest.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !out_face->isEdge(); if( coming_from_network == going_to_network ) { RouterStrategy::onDataDenied( data, interest, delay, why ); return; } if( going_to_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); RouterStrategy::onDataDenied( data, interest, delay, why ); return; } // if the data is denied then we add the // tag used to retrieve it to the negative // cache; however we only want to do this // when the data is leaving the internet // and going into the client network // and the data's access level > 0 BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::ENTRY_NETWORK ); if( data.getAccessLevel() > 0 ) { BOOST_ASSERT( interest.hasAuthTag() ); tracers::edge->bloom_insert ( interest.getAuthTag(), s_edge_bloom_delay ); delay += s_edge_bloom_delay; m_negative_cache.insert( interest.getAuthTag() ); } // do whatever a normal router would do RouterStrategy::onDataDenied( data, interest, delay, why ); }
void Graph::BFS(Vertex *w) { for(int i = 0; i < numVertices; i++) { marked[vertices[i]->num] = false; } marked[w->num] = true; queue<int> q; q.push(w->num); cout << "Breadth firts search starting from vertex "; cout << w->num << " : " << endl; while(!q.empty()) { int v = q.front(); q.pop(); cout << v << " "; for(int i = 0; i < numVertices; i++) { if(isEdge(vertices[v-1], vertices[i]) && !isMarked(vertices[i])) { q.push(vertices[i]->num); marked[vertices[i]->num] = true; } } } cout << endl; }
inline HexPoint HexPointUtil::rightEdge(HexPoint edge) { BenzeneAssert(isEdge(edge)); if (edge == NORTH) return WEST; if (edge == SOUTH) return EAST; if (edge == EAST) return NORTH; BenzeneAssert(edge == WEST); return SOUTH; }
void delEdge(int i, int j) { // Delete edge (i, j) if (isEdge(i,j)) { vertex[i]->remove(); numEdge--; } }
void EdgeStrategy::onDataSatisfied ( const ndn::Data& data, const ndn::Interest& interest, ns3::Time& delay ) { // if the satisfied data isn't leaving the network // then we just do the normal router stuff auto in_face = getFaceTable().get( data.getIncomingFaceId() ); auto out_face = getFaceTable().get( interest.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !out_face->isEdge(); if( coming_from_network == going_to_network ) { RouterStrategy::onDataSatisfied( data, interest, delay ); return; } if( going_to_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); RouterStrategy::onDataSatisfied( data, interest, delay ); return; } // if the data is satisfied then we add it to // the positive cache if it isn't marked with // the no recache flag and if its access level > 0 BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::ENTRY_NETWORK ); if( !data.getNoReCacheFlag() && data.getAccessLevel() > 0 ) { BOOST_ASSERT( interest.hasAuthTag() ); tracers::edge->bloom_insert ( interest.getAuthTag(), s_edge_bloom_delay ); delay += s_edge_bloom_delay; m_positive_cache.insert( interest.getAuthTag() ); } RouterStrategy::onDataSatisfied( data, interest, delay ); }
void Graph::newEdgeAt(int a, int aPos, int b, int bPos, int abData, int baData) { if (!isEdge(a,b)) { Node &na = node(a), &nb = node(b); na.addNeighbor(b, abData, aPos); if (!halfEdges()) nb.addNeighbor(a, baData, bPos); else ASSERT(baData < 0); } }
// when an edge is added/removed update the adjacency lists of the nodes involved void Graph::updateAdjacencyLists(Edge e) { if ( isEdge(e) ) { // already an edge so remove getNode(e.getFrom()).removeNeighbor(getNode(e.getTo())); if ( digraph ) getNode(e.getTo()).removeNeighbor(getNode(e.getFrom())); } else { // not an edge so add getNode(e.getFrom()).addNeighbor(getNode(e.getTo())); } }
int weight(int i, int j) { // Return weight of (i, j) Edge curr; if (isEdge(i, j)) { curr = vertex[i]->getValue(); return curr.weight(); } else return 0; }
/* ADD [DGraph] */ int DGraph::addEdge(int x, int y) { if (x > this->getNoOfVertices() || y > this->getNoOfVertices()) { return 0; } else if (isEdge(x, y)) { return -1; } this->inbounds[y].push_back(x); this->outbounds[x].push_back(y); return 1; }
// Get v’s next neighbor after w int next(int v, int w) { Edge it; if (isEdge(v, w)) { if ((vertex[v]->currPos()+1) < vertex[v]->length()) { vertex[v]->next(); it = vertex[v]->getValue(); return it.vertex(); } } return n(); // No neighbor }
bool EdgeStrategy::filterOutgoingData ( const nfd::Face& face, const ndn::Interest& interest, ndn::Data& data, ns3::Time& delay ) { auto in_face = getFaceTable().get( data.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !face.isEdge(); // if the data is coming from and leaving to // the same network then we don't need to do // anything special if( coming_from_network == going_to_network ) { return RouterStrategy::filterOutgoingData ( face, interest, data, delay ); } // if the data is coming into the network then // we just change its current network if( going_to_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::EXIT_NETWORK ); tracers::edge->data_entered( data ); data.setCurrentNetwork( ndn::RouteTracker::INTERNET_NETWORK ); return RouterStrategy::filterOutgoingData ( face, interest, data, delay ); } // if the data is leaving the network then we change // its current network if( coming_from_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); tracers::edge->data_left( data ); data.setCurrentNetwork( ndn::RouteTracker::ENTRY_NETWORK ); return RouterStrategy::filterOutgoingData ( face, interest, data, delay ); } // this should never happen BOOST_ASSERT( false ); return true; }
void Graph::generateNavGraph() { int l = map->getLength(); int h = map->getHeight(); int xExcess = l % proximity; int yExcess = h % proximity; if ( xExcess == 0 ) xExcess = proximity; if ( yExcess == 0 ) yExcess = proximity; cout << "Generating navGraph... xExcess=" << xExcess << ", yExcess=" << yExcess << ", proximity=" << proximity << endl; // create nodes Node * n; int index = 0; for( int x = xExcess/2; x < l; x += proximity ) { for( int y = yExcess/2; y < h; y += proximity ) { n = new Node(index, x, y); nodes.push_back(*n); index++; } } // this is only for a grid graph where cost of edges can only be sides of a square or diagonal of it. // also it assumes the grid base is parallel to x and y axis. in short this is a really specific code // not generic! double longedge = get_euclidian_distance(0, 0, proximity, proximity); double shortedge = get_euclidian_distance(0, 0, proximity, 0 ); // create edges vector<Node>::iterator iter; for( iter = nodes.begin(); iter != nodes.end(); iter++ ) { vector<Node> nbrs = getNeighbors(*iter); vector<Node>::iterator it; for( it = nbrs.begin(); it != nbrs.end(); it++ ) { Edge * e = new Edge( iter->getID(), it->getID() ) ; if ( iter->getX() == it->getX() || iter->getY() == it->getY() ) e->setCost(shortedge); else e->setCost(longedge); if ( !isEdge(*e) ) edges.push_back(*e); } } }
void FilterBase::apply(cv::InputArray _src, cv::OutputArray _dst, const int &ddepth){ int stype = _src.type(); int dcn = _src.channels(); int depth = CV_MAT_DEPTH(stype); if (0 <= ddepth) depth = ddepth; Mat src, dst; src = _src.getMat(); Size sz = src.size(); _dst.create(sz, CV_MAKETYPE(depth, dcn)); dst = _dst.getMat(); int imageWidth = src.rows; int imageHeight = src.cols; Mat srcChannels[3]; split(src, srcChannels); int margineWidth = kernel.cols / 2; int margineHeight = kernel.rows / 2; double kernelElemCount = (double)(kernel.cols * kernel.rows); for(int ch = 0; ch < dcn; ++ch){ for(int y = 0; y < imageHeight; ++y){ Vec3d *ptr = dst.ptr<Vec3d>(y); for(int x = 0; x < imageWidth; ++x){ if (isEdge(x, y, imageWidth, imageHeight, margineWidth, margineWidth)){ ptr[x][ch] = calcKernelOutputAtEdge(srcChannels[ch], kernel, x, y, imageWidth, imageHeight, margineWidth, margineHeight); }else{ ptr[x][ch] = calcKernelOutput(srcChannels[ch], kernel, x, y, margineWidth, margineHeight, kernelElemCount); } } } } }
bool Graph::DFS(Vertex *v, Vertex *w) { stack<int> s; for(int i = 0; i < numVertices; i++) { marked[vertices[i]->num] = false; } s.push(v->num); marked[v->num] = true; bool found = false; if(v->num == w->num) { cout << "Same starting and Ending Vertex" << endl; cout << w->num << endl; } cout << "Depth firts search starting from vertex "; cout << v->num << " : " << endl; while(!s.empty()) { int k = s.top(); s.pop(); if(k == w->num) { found = true; break; } cout << k << " "; for(int i = numVertices - 1; i >= 0; i--) { if(isEdge(vertices[k - 1], vertices[i]) && !isMarked(vertices[i])) { s.push(vertices[i]->num); marked[vertices[i]->num] = true; } } } cout << endl; return found; }
//fix up the point position,if the point is edge point void fix_PIXPOS(PIXPOS& pixel,int W,int H) { if(isEdge(pixel,W,H)) { pixel.bEdge = true; if(pixel.pix_X < 0) pixel.pix_X += W; if(pixel.pix_Y < 0) pixel.pix_Y += H; if(pixel.pix_X >= W) pixel.pix_X -= W; if(pixel.pix_Y >= H) pixel.pix_Y -= H; } else pixel.bEdge = false; }
int main(int argc, char* argv[]) { if (argc != 4) die(1); printf("going to get graph\n"); myGraph* graph = getGraph(argv[1]); printf("got graph\n"); int v1, v2 = -1; sscanf(argv[2], "%d", &v1); sscanf(argv[3], "%d", &v2); // check that we were given an actual edge if (!isEdge(graph, v1, v2)) die(1); checkWts(graph); int lastNNZ = -1; while(graph->nnz > 2) // note each edge is counted twice (forwards/backwards) { printf("graph->nnz: %d\n", graph->nnz); reduceGraph(&graph, v1, v2); if (lastNNZ == graph->nnz) { fprintf(stderr, "ERROR: reduceGraph failed to do anything!\n"); exit(2); } lastNNZ = graph->nnz; } printf("The effective resistence is: %lf\n", graph->wts[v1][0]); // assume all other edges gone, so it has to be first listing! freeGraph(graph); return 0; }
Bfs <TGraph> ::Bfs(TGraph _graph, bool (*isEdge)(typename TGraph::EdgeType*)) : graph(_graph) { int start = graph.s; dist.resize(graph.n, -1); prev.resize(graph.n, -1); dist[start] = 0; prev[start] = start; std::queue <int> q; q.push(start); while(!q.empty()) { int v = q.front(); q.pop(); for (int i = 0; i < graph.graph[v].size(); ++i) { if (isEdge(graph.graph[v][i])) { int to = graph.graph[v][i]->to; if (dist[to] == -1) { dist[to] = dist[v] + 1; prev[to] = v; q.push(to); } } } } }
// Set edge (i, j) to "weight" void setEdge(int i, int j, int weight) { Assert(weight>0, "May not set weight to 0"); Edge currEdge(j, weight); if (isEdge(i, j)) { // Edge already exists in graph vertex[i]->remove(); vertex[i]->insert(currEdge); } else { // Keep neighbors sorted by vertex index numEdge++; for (vertex[i]->moveToStart(); vertex[i]->currPos() < vertex[i]->length();vertex[i]->next()) { Edge temp = vertex[i]->getValue(); if (temp.vertex() > j) break; } vertex[i]->insert(currEdge); } }
void Foam::hexCellLooper::makeFace ( const labelList& loop, const scalarField& loopWeights, labelList& faceVerts, pointField& facePoints ) const { facePoints.setSize(loop.size()); faceVerts.setSize(loop.size()); forAll(loop, cutI) { label cut = loop[cutI]; if (isEdge(cut)) { label edgeI = getEdge(cut); const edge& e = mesh().edges()[edgeI]; const point& v0 = mesh().points()[e.start()]; const point& v1 = mesh().points()[e.end()]; facePoints[cutI] = loopWeights[cutI]*v1 + (1.0-loopWeights[cutI])*v0; } else { label vertI = getVertex(cut); facePoints[cutI] = mesh().points()[vertI]; } faceVerts[cutI] = cutI; }
Mat img_grad_mask(Mat grad_mag,Mat grad_x,Mat grad_y, Mat img_sym, double TH_G, double TH_P) // edge extraction { if (grad_mag.depth() != CV_64F) { cout << "the data type of the grad_mag is wrong!" << endl; exit(-1); } Mat mask; mask.create(grad_mag.rows, grad_mag.cols, CV_8U); // int i = 0, j = 0; bool flag_edge; for (i = 0; i < grad_mag.rows; i++) { for (j = 0; j < grad_mag.cols; j++) { mask.at<unsigned char>(i, j) = 0; if (grad_mag.at<double>(i, j) < TH_G) { continue; } flag_edge = isEdge(grad_mag, grad_x, grad_y, i, j); if (flag_edge) { double min_neighbor = min_8_neighbor(img_sym, i, j); double max_neighbor = max_8_neighbor(img_sym, i, j); double current_pixel = img_sym.at<uchar>(i, j); if ( ((current_pixel - max_neighbor) > TH_P) || ((current_pixel - min_neighbor) < -TH_P) ) { continue; } mask.at<unsigned char>(i, j) = 255; } } } return mask; }
PIXPOT Rbmp::get_pot(PIXPOS pixel) { PIXPOT ppot; memset(&ppot,0,sizeof(PIXPOT)); try { if(out_range_error(pixel)) throw 0; } catch(...) { printf("In get_pot, You set (x,y) is out Range!\n"); return ppot; } ppot.pot.pix_X = pixel.pix_X; ppot.pot.pix_Y = pixel.pix_Y; #ifdef ONLY ppot.pot.bEdge = isEdge(pixel,bmpWidth,bmpHeight); #else ppot.pot.bEdge = pixel.isEdge(pixel,bmpWidth,bmpHeight); #endif int lineByte = (bmpWidth * biBitCount + 31)/32*4; fseek(fp,bfOffBits + lineByte*(bmpHeight-pixel.pix_Y-1),0); //左上原点 // printf("坐标为(%d,%d)的像素\n",pixel.pix_X,pixel.pix_Y); BYTE8 *linedata = new BYTE8[lineByte];//一行像素的字节数(一个像素4个字节) // printf("lineByte:%d\n",lineByte); fread(linedata,lineByte,1,fp);//读取一行的所有数据 //fread(linedata,1,lineByte,fp);//读取一行的所有数据 int rgbsite; int tablesite; switch(biBitCount) { case 24://OK // printf("24位图\n"); rgbsite = pixel.pix_X*3; ppot.prgb.rgbBlue = linedata[rgbsite]; ppot.prgb.rgbGreen = linedata[rgbsite+1]; ppot.prgb.rgbRed = linedata[rgbsite+2]; break; case 8: // printf("8位图\n"); rgbsite= pixel.pix_X; tablesite = linedata[rgbsite]; //printf("%03d\n",linedata[k]); //printf("颜色表位置:%d\n",tablesite); ppot.prgb.rgbRed = pColorTable[tablesite].rgbRed; ppot.prgb.rgbGreen = pColorTable[tablesite].rgbGreen; ppot.prgb.rgbBlue = pColorTable[tablesite].rgbBlue; break; case 4: printf("4位图\n"); break; case 1: printf("1位图\n"); break; case 32: printf("32位图\n"); break; default: break; } // show_PIXPOT(pixpot); delete []linedata; return ppot; }
bool htd::Graph::isEdge(const std::vector<htd::vertex_t> & elements) const { return isEdge(htd::ConstCollection<htd::vertex_t>::getInstance(elements)); }
EyeCalibration::SegmentVector EyeCalibration::calculateConvexHull(CalibrationPointVector processingPoints) { // Edges SegmentVector segments; if (processingPoints.size() < 3) return segments; CalibrationPoint minX = processingPoints.at(0), minY = processingPoints.at(0), maxX = processingPoints.at(0), maxY = processingPoints.at(0); for (unsigned int i = 0; i < processingPoints.size(); i++) { CalibrationPoint point = processingPoints.at(i); osg::Vec3 ray = point.ray(); if (minX.x() > point.x()) minX = point; if (minY.y() > point.y()) minY = point; if (maxX.x() < point.x()) maxX = point; if (maxY.y() < point.y()) maxY = point; } // Get center int center_x = (maxX.x() - minX.x())/2; int center_y = (maxY.y() - minY.y())/2; // Ordered Point CalibrationPointVector orderedPoints(processingPoints); // Sort Points sort(orderedPoints, center_x, center_y); // Create segments for (unsigned int i = 0; i < orderedPoints.size(); i++) { CalibrationPoint from = orderedPoints.at(i); for (unsigned int k = 0; k < orderedPoints.size(); k++) { if (i == k) continue; CalibrationPoint to = orderedPoints.at(k); Segment segment(from, to); segments.push_back(segment); } } unsigned int i = 0; unsigned int j = 0; while ( i < segments.size() ) { //ProcessingPoints will be the points that are not in the current segment CalibrationPointVector processingPoints(orderedPoints); Segment segment = segments.at(i); //this loop prepares the ProcessingPoints list for each segment while ( j < processingPoints.size() ) { CalibrationPoint point = processingPoints.at(j); if((segment.x1() == point.x() && segment.y1() == point.y()) || (segment.x2() == point.x() && segment.y2() == point.y())) { //eliminating the points that are already in the current segment... //we don't need them processingPoints.erase(processingPoints.begin()+j); j = 0; } else { j++; } } //checking if the current segment is an edge or notBy calling isEdge function if( !isEdge(processingPoints, segments.at(i)) ) { segments.erase(segments.begin()+i); i = 0; } else { i++; } } return segments; }
bool HamPathVisitor::permutateAndValidate() { _coloredEdges.clear(); _edgeColors.clear(); const vector<Node*>& nodes = _graph->getNodes(); // keep on permutating until we get one without doubles do { _positions[_positions.size()-1]++; for ( unsigned i = _positions.size()-1; i > 0; i-- ) { // overflowing, reset last position if (_positions[i] >= static_cast<int>(_positions.size())) { int dif = _positions[i] - (_positions.size() -1); _positions[i-1] += dif; _positions[i] = 0; // start value } } // reached the end, graph has no hamiltonian path if (_positions[0] >= static_cast<int>(_positions.size())) { _finished = true; // reset the color vector<Node*> nodes = _graph->getNodes(); for (unsigned i = 0; i < nodes.size(); ++i) nodes[i]->setColor(_nodeColors[i]); for (unsigned i = 0; i < _coloredEdges.size(); ++i) _coloredEdges[i]->setColor(_edgeColors[i]); throw InvalidGraph("The graph does not contain an Hamiltonian path.", 1); } // set the new permutation and set it's color to orange because it's a candidate path for (unsigned i = 0; i < _positions.size(); ++i) { _permutation[i] = nodes[_positions[i]]; _permutation[i]->setColor(RGB::colorOrange()); } } while (doubles(_positions) ); // passed to isEdge Edge* edge; unsigned size = nodes.size(); // check if the permutation is a hamiltonian path // verification stage for (unsigned i = 0; i < size - 1; ++i) { // if (_path[i], _path[i+1]) is not an edge if ( !isEdge(_permutation[i], _permutation[i+1], &edge) ) return false; // if there is an edge, color it else { _drew = true; _edgeColors.push_back(edge->getColor()); edge->setColor(RGB::colorOrange()); _coloredEdges.push_back(edge); } } // if we get here, it was a hamiltonian path! return true; }
/*函数名称readIline()*/ bool Rbmp::readIline() { if(fp == NULL) return false; int lineByte; lineByte = (bmpWidth * biBitCount + 31)/32*4; printf("kkkkk:%d\n",lineByte); BYTE8 *linedata = new BYTE8[lineByte]; PIXPOT *lineppot = new PIXPOT[bmpWidth]; fseek(fp,bfOffBits,0); //左上原点 int k; int x = 0; int tablesite; for(int y = bmpHeight-1; y >= 0; y--)//左上为原点 // for(int i = 0; i < bmpHeight; i++)//左下为原点 { fread(linedata,1,lineByte,fp); for(k = 0;x < bmpWidth/*k < lineByte*/; k++) { printf("%03d ",linedata[k]); switch(biBitCount) { case 24://OK lineppot[x].prgb.rgbBlue = linedata[k]; lineppot[x].prgb.rgbGreen = linedata[++k]; lineppot[x].prgb.rgbRed = linedata[++k]; lineppot[x].pot.pix_X = x; lineppot[x].pot.pix_Y = y; if(isEdge(lineppot[x].pot,bmpWidth,bmpHeight)) lineppot[x].pot.bEdge = true; else lineppot[x].pot.bEdge = false; break; case 8: tablesite = linedata[k]; //printf("%03d\n",linedata[k]); //printf("颜色表位置:%d\n",tablesite); lineppot[x].prgb.rgbRed = pColorTable[tablesite].rgbRed; lineppot[x].prgb.rgbGreen = pColorTable[tablesite].rgbGreen; lineppot[x].prgb.rgbBlue = pColorTable[tablesite].rgbBlue; lineppot[x].pot.pix_X = x; lineppot[x].pot.pix_Y = y; if(isEdge(lineppot[x].pot,bmpWidth,bmpHeight)) lineppot[x].pot.bEdge = true; else lineppot[x].pot.bEdge = false; break; default: break; } #ifdef ONLY show_PIXPOT(lineppot[x]); #else lineppot[x].show_PIXPOT(); #endif printf("\n"); x++; } x = 0; cout << endl; } delete []linedata; delete []lineppot; return true; }
//----------------------------------------------------------------------------- void Myron::ProcessGlobIDs(){ //reset the globID buffer. for(int i=0;i<this->imageWidth*this->imageHeight;i++){ this->globIDs[i] = 0; } //erase the global globbox accum buffer. this->globBoxListCount = 0; this->globPixelListsCount = 0; //reset the working glob counter. int curGlobID = 0; //loop through all the pixels and call the recursive function on them for(int y=0;y<this->imageHeight;y++){ for(int x=0;x<this->imageWidth;x++){ int t =y*this->imageWidth+x; int r1 = isEdge(x,y); int r2 = (this->globIDs[t] == 0); int r3 = (this->globPixelList[t] == 255); if(r2 && r3 && r1 ){ curGlobID++; //found one. so find all the neighbors too. stackFriendlyRecursiveGlobFind(x,y,curGlobID); //now erase the globs below minDensity int logicaccum = 0; if(this->maxDensity_state>this->minDensity_state){//is max density NOT infinite? logicaccum = (this->thisGlobCount>this->maxDensity_state);//then also check for upper bound } if(this->thisGlobCount<this->minDensity_state||logicaccum){ //kill this glob for(int i=0;i<this->thisGlobCount;i++){ //turn that pixel black and erase its ID. this->globPixelList[this->thisGlobYs[i]*this->imageWidth+this->thisGlobXs[i]] = 0; this->globIDs [this->thisGlobYs[i]*this->imageWidth+this->thisGlobXs[i]] = 0; }//end for } else { //store the weirdly ordered pixel list for later use for(int i=0;i<this->thisGlobCount;i++){ this->globPixelLists[this->globPixelListsCount*3+0] = this->thisGlobXs[i]; this->globPixelLists[this->globPixelListsCount*3+1] = this->thisGlobYs[i]; //now record whether this is a head or a tail. if(i==0){ this->globPixelLists[this->globPixelListsCount*3+2] = 1; }else if(i==this->thisGlobCount-1){ this->globPixelLists[this->globPixelListsCount*3+2] = 2; }else{ this->globPixelLists[this->globPixelListsCount*3+2] = 0; } this->globPixelListsCount++; }//end for //do further analysis on it. //1. find the bounding box of it. int topmost = 10000000; int bottommost = -1000000; int leftmost = 10000000; int rightmost = -100000000; int i; for(i=0;i<this->thisGlobCount;i++){ if(this->thisGlobXs[i]<leftmost)leftmost=this->thisGlobXs[i]; if(this->thisGlobXs[i]>rightmost)rightmost=this->thisGlobXs[i]; if(this->thisGlobYs[i]<topmost)topmost=this->thisGlobYs[i]; if(this->thisGlobYs[i]>bottommost)bottommost=this->thisGlobYs[i]; } //store this data. this->globBoxList[this->globBoxListCount*4+0] = leftmost; this->globBoxList[this->globBoxListCount*4+1] = topmost; this->globBoxList[this->globBoxListCount*4+2] = rightmost; this->globBoxList[this->globBoxListCount*4+3] = bottommost; this->globBoxListCount++; }//end if }//end if }//end for }//end for int i; //calculate centerpoints for(i=0;i<this->globBoxListCount;i++){ this->globCenterPoints[i*2+0] = (this->globBoxList[i*4+0]+this->globBoxList[i*4+2])/2; this->globCenterPoints[i*2+1] = (this->globBoxList[i*4+1]+this->globBoxList[i*4+3])/2; } }
//----------------------------------------------------------------------------- void Myron::stackFriendlyRecursiveGlobFind(int x,int y, int curGlobID){ // i am proud of myself for writing this without using recursive function calling // because that was crashing on Mac OS X - the os having a (defaultly) small stack. // i bet linux is the same. // -josh this->thisGlobCount = 1; //clear the current glob data int stackCount = 1; //clear the parsing stack this->stackX[0] = x; this->stackY[0] = y; this->globIDs[y*this->imageWidth+x] = curGlobID; this->thisGlobXs[0] = x; this->thisGlobYs[0] = y; //i just added the stack's first item. //do all the neighbors of this guy to see if we can start a stack. int t; int xx; int yy; while(stackCount>0){ //pop one off. xx = this->stackX[stackCount-1]; yy = this->stackY[stackCount-1]; stackCount--; //then check the neighbors if they need to be dealt with later as well. //left if(xx-1>=0){ t = yy*this->imageWidth+(xx-1); if( this->globIDs[t] == 0 && this->globPixelList[t] == 255 && isEdge(xx,yy) ){ this->stackX[stackCount] = xx-1; this->stackY[stackCount] = yy; this->globIDs[t] = curGlobID; this->thisGlobXs[this->thisGlobCount] = xx-1; this->thisGlobYs[this->thisGlobCount] = yy; this->thisGlobCount++; stackCount++; } } //top if(yy-1>=0){ t = (yy-1)*this->imageWidth+(xx); if( this->globIDs[t] == 0 && this->globPixelList[t] == 255 && isEdge(xx,yy) ){ this->stackX[stackCount] = xx; this->stackY[stackCount] = yy-1; this->globIDs[t] = curGlobID; this->thisGlobXs[this->thisGlobCount] = xx; this->thisGlobYs[this->thisGlobCount] = yy-1; this->thisGlobCount++; stackCount++; } } //bottom if(yy+1<this->imageHeight){ t = (yy+1)*this->imageWidth+(xx); if( this->globIDs[t] == 0 && this->globPixelList[t] == 255 && isEdge(xx,yy) ){ this->stackX[stackCount] = xx; this->stackY[stackCount] = yy+1; this->globIDs[t] = curGlobID; this->thisGlobXs[this->thisGlobCount] = xx; this->thisGlobYs[this->thisGlobCount] = yy+1; this->thisGlobCount++; stackCount++; } } //right if(xx+1<this->imageWidth){ t = (yy)*this->imageWidth+(xx+1); if( this->globIDs[t] == 0 && this->globPixelList[t] == 255 && isEdge(xx,yy) ){ this->stackX[stackCount] = xx+1; this->stackY[stackCount] = yy; this->globIDs[t] = curGlobID; this->thisGlobXs[this->thisGlobCount] = xx+1; this->thisGlobYs[this->thisGlobCount] = yy; this->thisGlobCount++; stackCount++; } } } }
bool EdgeStrategy::filterOutgoingInterest ( const nfd::Face& face, ndn::Interest& interest, ns3::Time& delay ) { auto in_face = getFaceTable().get( interest.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !face.isEdge(); // if the interest coming from and going to // the same network then we don't need to do // anything special if( coming_from_network == going_to_network ) { return RouterStrategy::filterOutgoingInterest ( face, interest, delay ); } // if the interest is leaving the network then just change // current network if( coming_from_network ) { BOOST_ASSERT( interest.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); tracers::edge->interest_left( interest ); interest.setCurrentNetwork( ndn::RouteTracker::EXIT_NETWORK ); return RouterStrategy::filterOutgoingInterest ( face, interest, delay ); } // if the interest is entering the network then // we need to do some extra stuff BOOST_ASSERT( interest.getCurrentNetwork() == ndn::RouteTracker::ENTRY_NETWORK ); tracers::edge->interest_entered( interest ); interest.setCurrentNetwork( ndn::RouteTracker::INTERNET_NETWORK ); // if the interest doesn't have an auth tag, or its auth level // is 0 then we don't do any authentication if( !interest.hasAuthTag() || interest.getAuthTag().getAccessLevel() == 0 ) { return RouterStrategy::filterOutgoingInterest( face, interest, delay ); } const ndn::AuthTag& auth = interest.getAuthTag(); // if the auth tag provided by the interest is expired // then we can drop the interest if( auth.isExpired() ) { tracers::edge->blocked_interest ( interest, tracers::BlockedExpired ); onInterestDropped( interest, face, "Expired auth" ); return false; } // if the interest and auth tag have different prefixes // then we drop the interest if( !auth.getPrefix().isPrefixOf( interest.getName() ) ) { tracers::edge->blocked_interest ( interest, tracers::BlockedBadPrefix ); onInterestDropped( interest, face, "Mismatched prefix" ); return false; } // if the interest route hash doesn't match its auth tag // then we can drop it if( interest.getEntryRoute() != auth.getRouteHash() ) { tracers::edge->blocked_interest ( interest, tracers::BlockedBadRoute ); onInterestDropped( interest, face, "Bad route" ); return false; } // if the interest auth is in the positive auth cache then // we set its auth validity probability tracers::edge->bloom_lookup( auth, s_edge_bloom_delay ); delay += s_edge_bloom_delay; if( m_positive_cache.contains( auth ) ) { double fpp = m_positive_cache.getEffectiveFPP(); double prob = (double)1.0 - fpp; uint32_t iprob = prob*0xFFFFFFFF; interest.setAuthValidityProb( iprob ); } else { // if it's in the negative cache then we validate // its signature manually tracers::edge->bloom_lookup( auth, s_edge_bloom_delay ); delay += s_edge_bloom_delay; if( m_negative_cache.contains( auth ) ) { // we simulate verification delay by incrementing // the processing delay tracers::edge->sigverif( auth, s_edge_signature_delay ); delay += EdgeStrategy::s_edge_signature_delay; if( auth.getSignature().getValue().value_size() > 0 && auth.getSignature().getValue().value()[0] != 0 ) { // if signature is valid then set auth validity // and put auth into positive cache interest.setAuthValidityProb( 0xFFFFFFFF ); tracers::edge->auth_cached ( auth, tracers::CachedPositiveMoved ); m_positive_cache.insert( auth ); } else { // otherwise we drop the interest onInterestDropped( interest, face, "negative cache, manual validation failed" ); return false; } } else { // if the auth isn't in either cache then // we set validity probability to 0 interest.setAuthValidityProb( 0 ); } } return RouterStrategy::filterOutgoingInterest( face, interest, delay ); }