// Gets cell numbers of all polyHedra void Foam::readerDatabase::getPolyHedra() { const cellModel& tet = *(cellModeller::lookup("tet")); const cellModel& pyr = *(cellModeller::lookup("pyr")); const cellModel& prism = *(cellModeller::lookup("prism")); const cellModel& wedge = *(cellModeller::lookup("wedge")); const cellModel& tetWedge = *(cellModeller::lookup("tetWedge")); const cellModel& hex = *(cellModeller::lookup("hex")); DynamicList<label> polys(mesh().nCells()/100 + 1); const cellShapeList& cellShapes = mesh().cellShapes(); forAll(cellShapes, celli) { const cellShape& cellShape = cellShapes[celli]; const cellModel& cellModel = cellShape.model(); if ( (cellModel != tet) && (cellModel != pyr) && (cellModel != prism) && (cellModel != wedge) && (cellModel != tetWedge) && (cellModel != hex) ) { polys.append(celli); } } Info<< "Found " << polys.size() << " polyhedral cells " << endl; polys_.transfer(polys); }
void TestQgsDistanceArea::collections() { //test measuring for collections QgsDistanceArea myDa; myDa.setSourceAuthId( "EPSG:4030" ); myDa.setEllipsoidalMode( true ); myDa.setEllipsoid( "WGS84" ); //collection of lines, should be sum of line length QgsGeometry lines( QgsGeometryFactory::geomFromWkt( "GeometryCollection( LineString(0 36.53, 5.76 -48.16), LineString(0 25.54, 24.20 36.70) )" ) ); double result = myDa.measureLength( &lines ); QGSCOMPARENEAR( result, 12006159, 1 ); result = myDa.measureArea( &lines ); QVERIFY( qgsDoubleNear( result, 0 ) ); //collection of polygons QgsGeometry polys( QgsGeometryFactory::geomFromWkt( "GeometryCollection( Polygon((0 36.53, 5.76 -48.16, 0 25.54, 0 36.53)), Polygon((10 20, 15 20, 15 10, 10 20)) )" ) ); result = myDa.measureArea( &polys ); QGSCOMPARENEAR( result, 670434859475LL, 1 ); result = myDa.measureLength( &polys ); QVERIFY( qgsDoubleNear( result, 0 ) ); //mixed collection QgsGeometry mixed( QgsGeometryFactory::geomFromWkt( "GeometryCollection( LineString(0 36.53, 5.76 -48.16), LineString(0 25.54, 24.20 36.70), Polygon((0 36.53, 5.76 -48.16, 0 25.54, 0 36.53)), Polygon((10 20, 15 20, 15 10, 10 20)) )" ) ); //measure area specifically result = myDa.measureArea( &mixed ); QGSCOMPARENEAR( result, 670434859475LL, 1 ); //measure length result = myDa.measureLength( &mixed ); QGSCOMPARENEAR( result, 12006159, 1 ); }
vector<Poly> Clipping::getPolys(const CL::Polygons &cpolys, double z, double extrusionfactor) { uint count = cpolys.size(); vector<Poly> polys(count); for (uint i = 0 ; i<count; i++) polys[i] = getPoly(cpolys[i], z, extrusionfactor); return polys; }
void IsValidOp::checkValid(const MultiPolygon *g) { unsigned int ngeoms = g->getNumGeometries(); vector<const Polygon *>polys(ngeoms); for (unsigned int i=0; i<ngeoms; ++i) { const Polygon *p = (const Polygon *)g->getGeometryN(i); checkInvalidCoordinates(p); if (validErr != NULL) return; checkClosedRings(p); if (validErr != NULL) return; polys[i]=p; } GeometryGraph graph(0,g); checkTooFewPoints(&graph); if (validErr!=NULL) return; checkConsistentArea(&graph); if (validErr!=NULL) return; if (!isSelfTouchingRingFormingHoleValid) { checkNoSelfIntersectingRings(&graph); if (validErr!=NULL) return; } for(unsigned int i=0; i<ngeoms; ++i) { const Polygon *p=polys[i]; checkHolesInShell(p, &graph); if (validErr!=NULL) return; } for(unsigned int i=0; i<ngeoms; ++i) { const Polygon *p=polys[i]; checkHolesNotNested(p, &graph); if (validErr!=NULL) return; } checkShellsNotNested(g,&graph); if (validErr!=NULL) return; checkConnectedInteriors(graph); }
bool WireComputer::process( TriangleSet * triangleSet ) { GEOM_ASSERT(triangleSet); GeometryArrayPtr polys(new GeometryArray); for(Index3Array::const_iterator _it = triangleSet->getIndexList()->begin(); _it != triangleSet->getIndexList()->end(); _it++){ Point3ArrayPtr points(new Point3Array); for(Index3::const_iterator _i = _it->begin(); _i != _it->end(); _i++){ points->push_back(triangleSet->getPointList()->getAt(*_i)); } points->push_back(triangleSet->getPointList()->getAt(*(_it->begin()))); polys->push_back(GeometryPtr(new Polyline(points))); } if(polys->empty())__wire = GeometryPtr(); else if(polys->size() == 1)__wire = polys->getAt(0); else __wire = GeometryPtr(new Group(polys)); return true; }
GeneralPolygon::operator ClipperLib::Polygons() { ClipperLib::Polygons polys(_contours.size()); for(unsigned int c=0; c < _contours.size() ; ++c) { const Contour &contour = _contours[c]; ClipperLib::Polygon poly(contour.size()); for(unsigned int v=0; v < contour.size() ; ++v) { sf::Vector2f worldPos = _transformFromLocalToWorld(contour[v]); poly[v] = ClipperLib::IntPoint(worldPos.x * clipperScaleCoeficient, worldPos.y * clipperScaleCoeficient); } polys[c] = poly; } return polys; }
bool WireComputer::process( QuadSet * quadSet ) { GEOM_ASSERT(quadSet); // nothing to do as quadSet is already an ExplicitModel GeometryArrayPtr polys(new GeometryArray); for(Index4Array::const_iterator _it = quadSet->getIndexList()->begin(); _it != quadSet->getIndexList()->end(); _it++){ Point3ArrayPtr points(new Point3Array); for(Index4::const_iterator _i = _it->begin(); _i != _it->end(); _i++){ points->push_back(quadSet->getPointList()->getAt(*_i)); } points->push_back(quadSet->getPointList()->getAt(*(_it->begin()))); polys->push_back(GeometryPtr(new Polyline(points))); } if(polys->empty())__wire = GeometryPtr(); else if(polys->size() == 1)__wire = polys->getAt(0); else __wire = GeometryPtr(new Group(polys)); return true; }
bool WireComputer::process( AmapSymbol * amapSymbol ) { GEOM_ASSERT(amapSymbol); // nothing to do as amapSymbol has a cached representation of type of Mesh. GeometryArrayPtr polys(new GeometryArray); for(IndexArray::const_iterator _it = amapSymbol->getIndexList()->begin(); _it != amapSymbol->getIndexList()->end(); _it++){ Point3ArrayPtr points(new Point3Array); for(Index::const_iterator _i = _it->begin(); _i != _it->end(); _i++){ points->push_back(amapSymbol->getPointList()->getAt(*_i)); } points->push_back(amapSymbol->getPointList()->getAt(*(_it->begin()))); polys->push_back(GeometryPtr(new Polyline(points))); } if(polys->empty())__wire = GeometryPtr(); else if(polys->size() == 1)__wire = polys->getAt(0); else __wire = GeometryPtr(new Group(polys)); return true; }
bool SOctree::recursiveBuild(RadPrimList & inPolys, const RadPatchList & inLights, sBuildInfo & bi, const unsigned int depth) { // Per-node stats bi.totalNodes++; bi.totalDepth += depth; // User display if (!updateDisplay(bi, depth)) return false; // Conditions for being a leaf... bool leaf = false; assert(inPolys.size() || inLights.size()); if (depth >= bi.maxDepthLimiter) leaf = true; if (radius() <= bi.minRadiusLimiter) leaf = true; if (inPolys.size() <= bi.thresholdLimiter) leaf = true; // Am I a leaf? if (leaf) { // This _is_ a clipping octree, is it not? :) polys() = inPolys; { for (RadPrimList::node *i = polys().head(); i; i = i->next()) { RadPrim & p = i->data(); // Six sides to clip to for (unsigned int j = 0; j < 6; ++j) { // Origin & Center of this node-bounding plane geom::Point3 org = center() + planeCenterOffsets[j] * radius(); geom::Vector3 dir = -planeCenterOffsets[j]; // Build a plane that faces the interior of the node geom::Plane3 plane(org, dir); // Clip this polygon to the plane, keeping everything in the interior of the node RadPrim backSide; p.bisect(plane, backSide); } bi.processedSurfaceArea += p.calcArea(); } } // Build a BSP tree from this sucker { buildInfo.scenePolys = &polys(); buildInfo.quantizeResolution = bi.bspQuantizeResolution; buildInfo.leastDepthErrorBoundsPercent = bi.bspLeastDepthErrorBoundsPercent; //buildInfo.progressDialog = NULL; // Build the BSP if (!bsp().build(buildInfo)) return false; bi.totalPolys += buildInfo.totalPolys; } // Track lights bi.totalLights += inLights.size(); return true; } // Determine which node(s) each polygon intersects for (unsigned int i = 0; i < 8; ++i) { // Child dimensions float childRadius = radius() / 2.0f; geom::Point3 childCenter = center() + childCenterOffsets[i] * radius(); geom::Point3 cr(childRadius, childRadius, childRadius); // The list of polygons that intersect this child's AABB RadPrimList childPolys; childPolys.reserve(inPolys.size()); { RadPrimList::node * n = inPolys.head(); while(n) { if (n->data().intersectAABB(childCenter, cr)) { childPolys += n->data(); } n = n->next(); } // Remove the waste left over from what we originally reserved childPolys.compact(); } // The list of lights that intersect this child's AABB RadPatchList childLights; { geom::Point3 cMin = childCenter - childRadius; geom::Point3 cMax = childCenter + childRadius; for (RadPatchList::node * j = inLights.head(); j; j = j->next()) { const geom::Point3 & pos = j->data().origin(); if (pos.x() >= cMin.x() && pos.x() <= cMax.x() && pos.y() >= cMin.y() && pos.y() <= cMax.y() && pos.z() >= cMin.z() && pos.z() <= cMax.z()) { childLights += j->data(); } } } // If there weren't any polys or lights, don't recurse if (!childPolys.size() && !childLights.size()) { // No child goes here, stick in a placeholder children() += static_cast<SOctree *>(0); continue; } // Create a new child SOctree * child = &bi.octreeNodeReservoir.get(); child->center() = childCenter; child->radius() = childRadius; // Add this child to my array of children children() += child; // Recursively build this branch of the tree if (!child->recursiveBuild(childPolys, childLights, bi, depth + 1)) return false; } return true; }
// generate infill pattern as a vector of polygons ClipperLib::Polygons Infill::makeInfillPattern(InfillType type, const vector<Poly> tofillpolys, double infillDistance, double offsetDistance, double rotation) { this->type = type; //cerr << "have " << savedPatterns.size()<<" saved patterns " << endl; // look for saved pattern for this rotation Vector2d Min,Max; Min = layer->getMin(); Max = layer->getMax(); ClipperLib::Polygons cpolys; if (tofillpolys.size()==0) return cpolys; //omp_set_lock(&save_lock); //int tid = omp_get_thread_num( ); //cerr << "thread "<<tid << " looking for pattern " << endl; if (type != PolyInfill) { // can't save PolyInfill if (savedPatterns.size()>0){ //cerr << savedPatterns.size() << " patterns" << endl; while (rotation>2*M_PI) rotation -= 2*M_PI; while (rotation<0) rotation += 2*M_PI; this->angle= rotation; vector<uint> matches; for (vector<struct pattern>::iterator sIt=savedPatterns.begin(); sIt != savedPatterns.end(); sIt++){ //cerr << sIt->Min << sIt->Max <<endl; if (sIt->type == type && abs(sIt->distance-infillDistance) < 0.01 && abs(sIt->angle-rotation) < 0.01 ) { //cerr << name << " found saved pattern no " << sIt-savedPatterns.begin() << " with " << sIt->cpolys.size() <<" polys"<< endl << "type "<< sIt->type << sIt->Min << sIt->Max << endl; // is it too small for this layer? if (sIt->Min.x > Min.x || sIt->Min.y > Min.y || sIt->Max.x < Max.x || sIt->Max.y < Max.y) { matches.push_back(sIt-savedPatterns.begin()); //break; // there is no other match } else { //cerr <<"return "<< sIt->cpolys.size()<< endl; return sIt->cpolys; } } } sort(matches.rbegin(), matches.rend()); for (uint i=0; i<matches.size(); i++) { //cerr << i << " - " ; savedPatterns.erase(savedPatterns.begin()+matches[i]); } //cerr << endl; } } //omp_unset_lock(&save_lock); // none found - make new: bool zigzag = false; switch (type) { case SmallZigzagInfill: // small zigzag lines zigzag = true; //case ZigzagInfill: // long zigzag lines, make lines later case SupportInfill: // stripes, but leave them as polygons case RaftInfill: // stripes, but leave them as polygons case BridgeInfill: // stripes, make them to lines later case ParallelInfill: // stripes, make them to lines later { Vector2d center = (Min+Max)/2.; // make square that masks everything even when rotated Vector2d diag = Max-Min; double square = max(diag.x,diag.y); Vector2d sqdiag(square*2/3,square*2/3); Min=center-sqdiag; Max=center+sqdiag; //cerr << Min << "--"<<Max<< "::"<< center << endl; Poly poly(this->layer->getZ()); for (double x = Min.x; x < Max.x; x += 2*infillDistance) { poly.addVertex(Vector2d(x,Min.y)); if (zigzag){ for (double y = Min.y+infillDistance; y < Max.y; y += 2*infillDistance) { poly.addVertex(Vector2d(x,y)); poly.addVertex(Vector2d(x+infillDistance,y+infillDistance)); } for (double y = Max.y; y > Min.y; y -= 2*infillDistance) { poly.addVertex(Vector2d(x+infillDistance,y+infillDistance)); poly.addVertex(Vector2d(x+2*infillDistance,y)); } } else { poly.addVertex(Vector2d(x+infillDistance,Min.y)); poly.addVertex(Vector2d(x+infillDistance,Max.y)); poly.addVertex(Vector2d(x+2*infillDistance,Max.y)); } } poly.addVertex(Vector2d(Max.x,Min.y-infillDistance)); poly.addVertex(Vector2d(Min.x,Min.y-infillDistance)); poly.rotate(center,rotation); vector<Poly> polys; polys.push_back(poly); cpolys = Clipping::getClipperPolygons(polys); } break; case HilbertInfill: { Poly poly(this->layer->getZ()); Vector2d center = (Min+Max)/2.; Vector2d diag = Max-Min; double square = MAX(Max.x,Max.y); if (infillDistance<=0) break; int level = (int)ceil(log2(2*square/infillDistance)); if (level<0) break; //cerr << "level " << level; // start at 0,0 to get the same location for all layers poly.addVertex(Vector2d(0,0)); hilbert(level, 0, infillDistance, poly.vertices); vector<Poly> polys(1); polys[0] = poly; cpolys = Clipping::getClipperPolygons(polys); } break; case PolyInfill: // fill all polygons with their shrinked polys { vector< vector<Poly> > ipolys; // "shells" for (uint i=0;i<tofillpolys.size();i++){ double parea = Clipping::Area(tofillpolys[i]); // make first larger to get clip overlap double firstshrink=0.5*infillDistance; if (parea<0) firstshrink=-0.5*infillDistance; vector<Poly> shrinked = Clipping::getOffset(tofillpolys[i],firstshrink); vector<Poly> shrinked2 = Clipping::getOffset(shrinked,0.5*infillDistance); for (uint i=0;i<shrinked2.size();i++) shrinked2[i].cleanup(0.3*infillDistance); ipolys.push_back(shrinked2); //ipolys.insert(ipolys.end(),shrinked.begin(),shrinked.end()); double area = Clipping::Area(shrinked); //cerr << "shr " <<parea << " - " <<area<< " - " << " : " <<endl; //int shrcount =1; int lastnumpolys=0; while (shrinked.size()>0){ if (area*parea<0) break; //cerr << "shr " <<parea << " - " <<area<< " - " << shrcount << " : " <<endl; shrinked2 = Clipping::getOffset(shrinked,0.5*infillDistance); for (uint i=0;i<shrinked2.size();i++) shrinked2[i].cleanup(0.3*infillDistance); ipolys.push_back(shrinked2); //ipolys.insert(ipolys.end(),shrinked.begin(),shrinked.end()); lastnumpolys = shrinked.size(); shrinked = Clipping::getOffset(shrinked,-infillDistance); for (uint i=0;i<shrinked.size();i++) shrinked[i].cleanup(0.3*infillDistance); area = Clipping::Area(shrinked); //shrcount++; } // // remove last because they are too small // ipolys.erase(ipolys.end()-lastnumpolys,ipolys.end()); } vector<Poly> opolys; for (uint i=0;i<ipolys.size();i++){ opolys.insert(opolys.end(),ipolys[i].begin(),ipolys[i].end()); } cpolys = Clipping::getClipperPolygons(opolys); //cerr << "cpolys " << cpolys.size() << endl; } break; default: cerr << "infill type " << type << " unknown "<< endl; } // save //tid = omp_get_thread_num( ); //cerr << "thread "<<tid << " saving pattern " << endl; struct pattern newPattern; newPattern.type=type; newPattern.angle=rotation; newPattern.distance=infillDistance; newPattern.cpolys=cpolys; if (type != PolyInfill && type != ZigzagInfill) // can't save these { newPattern.Min=Min; newPattern.Max=Max; savedPatterns.push_back(newPattern); //cerr << "saved pattern " << endl; } return newPattern.cpolys; }
/* Function: controller ----------------------------------------- usage: controller(<input-file-stream>); Accepts an input filestream as only argument. Creates a vector of Poly(polynomial class) pointers. Also creates an iterator of the same type and proceeds to parse the input filestream based on relavent functionality. Controller will accept input of polynomials, as direct polynomial terms or as a mulitiple of 2 Polys. Controller will also act upon the appropriate polynomail with 2 commands show : displays the polynomial ex. 2x^2+5x+1 eval : evaluates the polynomail with the supplied argument */ void controller (std::ifstream& input){ std::vector<Poly*> polys(100); std::vector<Poly*>::iterator polyIt; /*set default value for each Poly* in polys to NULL */ for ( polyIt=polys.begin(); polyIt!=polys.end();polyIt++){ (*polyIt)=NULL; } /**************************************** * Build the full vector of Polynomials from the file ***********************************************/ try { std::string str; std::vector<std::string>data; while(std::getline(input, str, '\n')) { const char *cStr = str.c_str(); /* check for command or not */ if(isdigit(cStr[0])){ polyIt= polys.begin(); int polyPos=-1; try{ data = split(str, ' '); // splitting on whitespace std::cout << "length of data= " << data.size()<< std::endl; }catch(...){ std::cout << "\nExeption thrown splitting string"; std::cout<< "\nError Occured IN: "+str; } polyPos= atoi(data[0].c_str()); std::string op_string = data[1]; std::cout<< op_string << std::endl; char oper= data[1][0]; int count=0,coeff=0,exp=-1; Poly *add = new Poly(); /* Regular Polynomial building below. */ if (oper==':'){ for (unsigned i =2; i < data.size(); i++){ if (count==0){ coeff= atoi(data[i].c_str()); } else if( count==1){ exp= atoi(data[i].c_str()); } std::cout << "coeff =" << coeff << "expo= " << exp << std::endl; count++; if (count>=2){ add->push_term(coeff,exp); count=0; } } } /* Multiplication for 2 polynomials Below. */ else if (oper=='='){ int poly1= atoi(data[2].c_str()); int poly2= atoi(data[4].c_str()); if (polys[poly1]==NULL || polys[poly2]==NULL) throw "ERROR: INVALID POLY VECTOR INDEX"; add = ((*(polys[poly1]))) * (*(polys[poly2])); polys[polyPos]=add; } /*USE INDEX TO PLACE POLY INTO POSITION */ polys[polyPos]=add; } else { /* Command Section: Split strings then execute operations based on 2 possibilities: show and eval */ try{ data = split(str, ' '); // splitting on whitespace }catch(...){ std::cout << "\nExeption thrown splitting string"; std::cout << "\nError Occured IN: "+str; } /*variables for switching behavior */ std::string command= data[0]; /* */ enum com_Choice{show, eval} commands; int operand= atoi(data[1].c_str()); int value= atoi(data[2].c_str()); if (command == "eval"){ commands = eval; }else commands = show; switch (commands ) { case show: std::cout << "Poly["<<operand<<"]=" << (*polys[operand])<<std::endl; break; case eval: int result= (*polys[operand])(value ); std::cout << "Poly["<<operand<<"]("<<value<<")=" <<result<< std::endl; break; } } data.clear(); str.clear(); } } catch(...){ std::cout << "\nError Parsing input File:\n " << std::endl; } }