std::deque<const Coords*> LcpFinder::leastCostPath(int algorithm) { if (this->startPoint == 0) { std::cout << "No startpoint set in finder. Is the startpoint inside any polygon?\n" << std::endl; exit(1); } for (int i = 0; i<this->polygons.size(); i++) { this->triangulate(i); } int targetsFound = 0; this->startPoint->setToStart(0); /* bool (*compareFunction)(const Coords*, const Coords*); if (algorithm == 0) { compareFunction = &compDijkstra; } else if (algorithm == 1) { compareFunction = &compAstar; } cmpr comparator{compareFunction}; */ //MinHeap<const Coords*, cmpr> minheap(comparator); //MinHeap<const Coords*, cmpr> minheap(comparator); boost::heap::fibonacci_heap<const Coords*, boost::heap::compare < Coords::cmpr>> minheap; this->startPoint->handle = minheap.push(this->startPoint); int handled = 0; int old = 0; int total = this->coordmap.size(); int percent = total / 100; while (!minheap.empty()) { if (handled - old > percent) { int percentage = handled * 100 / total; old = handled; std::cout << "\rSearching..." << percentage << "% done"; fflush(stdout); } handled++; const Coords* node = minheap.top(); //std::cout<<node->toString()<<std::endl; if (node == 0) { std::cout << "current node = 0\n"; exit(2); } if (node->flag == 1) { targetsFound++; if (targetsFound == this->numOfTargets) { std::cout << "break\n"; break; } } minheap.pop(); nSet neighbours = findNeighbours(node); for (std::pair<const Coords*, double> p : neighbours) { const Coords* n = p.first; if (n == 0) { std::cout << "neighbour is 0\n"; exit(2); } double d = p.second; if (n->getToStart() < 0) { // node has not yet been inserted into minheap n->setToStart(d); //n->setToEnd(this->toClosestEnd(n)); n->setPred(node); n->handle = minheap.push(n); } else if (n->getToStart() > d) { n->setToStart(d); n->setPred(node); minheap.increase(n->handle); //minheap.decrease(n); //reorders minheap after changing priority of n } } } std::deque<const Coords*> res{}; for (std::pair<int, std::forward_list < const Coords*>> polygon : this->targetPoints) { for (const Coords* ep : polygon.second) { if (ep == 0) { std::cout << "EP == 0\n"; continue; } if (ep == this->startPoint) { continue; } res.push_back(ep); } } return res; }
MStatus BCIViz::compute( const MPlug& plug, MDataBlock& block ) { if( plug == outValue ) { MStatus status; MDagPath path; MDagPath::getAPathTo(thisMObject(), path); MMatrix worldInverseSpace = path.inclusiveMatrixInverse(); MDataHandle inputdata = block.inputValue(ainput, &status); if(status) { const MMatrix drvSpace = inputdata.asMatrix(); fDriverPos.x = drvSpace(3, 0); fDriverPos.y = drvSpace(3, 1); fDriverPos.z = drvSpace(3, 2); fDriverPos *= worldInverseSpace; } fTargetPositions.clear(); MArrayDataHandle htarget = block.inputArrayValue( atargets ); unsigned numTarget = htarget.elementCount(); fTargetPositions.setLength(numTarget); for(unsigned i = 0; i<numTarget; i++) { MDataHandle tgtdata = htarget.inputValue(&status); if(status) { const MMatrix tgtSpace = tgtdata.asMatrix(); MPoint tgtPos(tgtSpace(3,0), tgtSpace(3,1), tgtSpace(3,2)); tgtPos *= worldInverseSpace; MVector disp = tgtPos; disp.normalize(); tgtPos = disp; fTargetPositions[i] = tgtPos; } htarget.next(); } m_hitTriangle = 0; neighbourId[0] = 0; neighbourId[1] = 1; neighbourId[2] = 2; if(!checkTarget()) { MGlobal::displayWarning("convex hull must have no less than 4 targes."); return MS::kSuccess; } if(!checkFirstFour(fTargetPositions)) { MGlobal::displayWarning("first 4 targes cannot sit on the same plane."); return MS::kSuccess; } if(!constructHull()) { MGlobal::displayWarning("convex hull failed on construction."); return MS::kSuccess; } findNeighbours(); calculateWeight(); MArrayDataHandle outputHandle = block.outputArrayValue( outValue ); int numWeight = fTargetPositions.length(); m_resultWeights.setLength(numWeight); for(int i=0; i < numWeight; i++) m_resultWeights[i] = 0.0; m_resultWeights[neighbourId[0]] = fAlpha; m_resultWeights[neighbourId[1]] = fBeta; m_resultWeights[neighbourId[2]] = fGamma; MArrayDataBuilder builder(outValue, numWeight, &status); for(int i=0; i < numWeight; i++) { MDataHandle outWeightHandle = builder.addElement(i); outWeightHandle.set( m_resultWeights[i] ); //MGlobal::displayInfo(MString("wei ") + i + " " + weights[i]); } outputHandle.set(builder); outputHandle.setAllClean(); } return MS::kSuccess; }
/*-----------------------------------------------------------*/ int haloExchange(int benchmarkType){ int dataSizeIter; /* find the ranks of the left and right neighbour */ findNeighbours(); /* initialise repsToDo to defaultReps */ repsToDo = defaultReps; /* Start loop over data sizes */ dataSizeIter = minDataSize; /* Initialise dataSizeIter */ MPI_Barrier(comm); while (dataSizeIter <= maxDataSize){ /* set sizeofBuffer */ sizeofBuffer = dataSizeIter * numThreads; /*Allocate space for the main data arrays */ allocateHaloexchangeData(sizeofBuffer); /* perform benchmark warm-up */ if (benchmarkType == MASTERONLY){ masteronlyHaloexchange(warmUpIters, dataSizeIter); } else if (benchmarkType == FUNNELLED){ funnelledHaloexchange(warmUpIters, dataSizeIter); } else if (benchmarkType == MULTIPLE){ multipleHaloexchange(warmUpIters, dataSizeIter); } GASPI(barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); /* Each process performs a verification test */ testHaloexchange(sizeofBuffer, dataSizeIter); MPI_Barrier(comm); /*Initialise the benchmark */ benchComplete = FALSE; /*Execute benchmark until target time is reached */ while (benchComplete != TRUE){ /*Start timer */ GASPI(barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); startTime = MPI_Wtime(); /*Execute benchmarkType for repsToDo repetitions*/ if (benchmarkType == MASTERONLY){ masteronlyHaloexchange(repsToDo, dataSizeIter); } else if (benchmarkType == FUNNELLED){ funnelledHaloexchange(repsToDo, dataSizeIter); } else if (benchmarkType == MULTIPLE){ multipleHaloexchange(repsToDo, dataSizeIter); } /*Stop timer */ GASPI(barrier(GASPI_GROUP_ALL, GASPI_BLOCK)); finishTime = MPI_Wtime(); totalTime = finishTime - startTime; MPI_Barrier(comm); /* Test if target time is reached with the number of reps */ if (myMPIRank==0){ benchComplete = repTimeCheck(totalTime, repsToDo); } /* Ensure all procs have the same value of benchComplete */ /* and repsToDo */ MPI_Bcast(&benchComplete, 1, MPI_INT, 0, comm); MPI_Bcast(&repsToDo, 1, MPI_INT, 0, comm); } /* Master process sets benchmark results */ if (myMPIRank == 0 ){ setReportParams(dataSizeIter, repsToDo, totalTime); printReport(); } /* Free allocated data */ freeHaloexchangeData(); /* Double dataSize and loop again */ dataSizeIter = dataSizeIter * 2; } return 0; }
void RegionGrowingHSV::findPointNeighbours () { // convert point cloud type to vtkPolyData vtkPolyData* m_polydata = vtkPolyData::New(); int convertnum = mesh2vtk(m_polymesh,m_polydata); if( num_pts!=convertnum ) return; pcl::search::Search <pcl::PointXYZRGB>::Ptr tree = boost::shared_ptr<pcl::search::Search<pcl::PointXYZRGB> > (new pcl::search::KdTree<pcl::PointXYZRGB>); pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>()); pcl::fromROSMsg(m_polymesh.cloud,*cloud); tree->setInputCloud(cloud); std::vector<float> nearestDis; std::vector<int> neighbours; point_neighbours_.clear(); neighbours_for_possi_.clear(); point_neighbours_.resize (num_pts, neighbours); neighbours_for_possi_.resize(num_pts,neighbours); for (int i_point = 0; i_point < num_pts; i_point++) { std::vector<bool> is_neighbour(num_pts,false); std::vector<int> seed_initial; std::vector<int> seed; seed_initial.push_back(i_point); int time = 0; neighbours.clear (); while( !seed_initial.empty() && time<searchDis_ ) { while( !seed_initial.empty() ) // 将seed_initial中的种子点copy到seed中 { seed.swap(seed_initial); seed_initial.clear(); } while(!seed.empty()) { int current_seed = seed[0]; seed.erase(seed.begin()); is_neighbour[current_seed] = true; findNeighbours(current_seed,seed_initial,neighbours,is_neighbour,m_polydata); } time++; if(time==1) { if(neighbours.size()<3) { neighbours.clear(); nearestDis.clear(); tree->nearestKSearch(cloud->points[i_point],10,neighbours,nearestDis); } point_neighbours_[i_point] = neighbours; } } //std::cout<<"size neighbours of the "<<i_point<<"'s point is "<<neighbours.size()<<std::endl; if(neighbours.size()<3) { neighbours.clear(); nearestDis.clear(); tree->nearestKSearch(cloud->points[i_point],10,neighbours,nearestDis); } neighbours_for_possi_[i_point].swap (neighbours); } std::cout<<"find point neighbours end..."<<std::endl; }