OGRBoolean OGRLineString::Equal( OGRGeometry * poOther ) { OGRLineString *poOLine = (OGRLineString *) poOther; if( poOther == this ) return TRUE; if( poOther->getGeometryType() != getGeometryType() ) return FALSE; // we should eventually test the SRS. if( getNumPoints() != poOLine->getNumPoints() ) return FALSE; for( int iPoint = 1; iPoint < getNumPoints(); iPoint++ ) { if( getX(iPoint) != poOLine->getX(iPoint) || getY(iPoint) != poOLine->getY(iPoint) || getZ(iPoint) != poOLine->getZ(iPoint) ) return FALSE; } return TRUE; }
Vector VariablesGrid::getLastVector( ) const { if ( getNumPoints( ) <= 0 ) return emptyVector; return getVector( getNumPoints( )-1 ); }
VariablesGrid VariablesGrid::getTimeSubGrid( double startTime, double endTime ) const { uint startIdx = getCeilIndex( startTime ); uint endIdx = getFloorIndex( endTime ); VariablesGrid newVariablesGrid; if ( ( isInInterval( startTime ) == BT_FALSE ) || ( isInInterval( endTime ) == BT_FALSE ) ) return newVariablesGrid; if ( ( startIdx >= getNumPoints( ) ) || ( endIdx >= getNumPoints( ) ) ) return newVariablesGrid; // if ( startIdx > endIdx ) // return newVariablesGrid; // add all matrices in interval (constant interpolation) if ( ( hasTime( startTime ) == BT_FALSE ) && ( startIdx > 0 ) ) newVariablesGrid.addMatrix( *(values[ startIdx-1 ]),startTime ); for( uint i=startIdx; i<=endIdx; ++i ) newVariablesGrid.addMatrix( *(values[i]),getTime( i ) ); if ( hasTime( endTime ) == BT_FALSE ) newVariablesGrid.addMatrix( *(values[ endIdx ]),endTime ); return newVariablesGrid; }
int calculateZHull(zhull_t *zh) { index_t fli=0; index_t pi; facet_t *f; list_t outsideset; int cnt=0; int maxit=getNumPoints(zh->pts); list_t horizon_fcts=emptyList(); list_t horizon_fcts_edges=emptyList(); list_t other_horizon_edges=emptyList(); list_t available_points=emptyList(); entry_t e; // if (maxit>MAXIT) // maxit=MAXIT; if (getNumPoints(zh->pts)!=0) { zhullInitialFacets(zh); //printZhull(zh); while(((getLength(zh->facets_with_insidepoints)>0) ||(getLength(zh->facets_with_outsidepoints)>0)) &&(cnt++<maxit)) { // printf("//////////////// ITERATION %d ///////\n",cnt); if (getLength(zh->facets_with_insidepoints)>0) { fli%=getLength(zh->facets_with_insidepoints); f=getFacetByIndex(zh->facets_with_insidepoints,fli); e=getEntry(f->insideset, 0); pi=entry_getIndex(&e); // printf("insidepoint\n"); // printList(zh->facets_with_insidepoints); } else { fli%=getLength(zh->facets_with_outsidepoints); f=getFacetByIndex(zh->facets_with_outsidepoints,fli); pi=f->farthest_outside_point; } // printf("point %d\n",pi); removeVisibleFacetsGetHorizonAndAvailablePoints(zh,pi,f, &horizon_fcts, &horizon_fcts_edges,&other_horizon_edges, &available_points); removeValueFromList(&available_points, entry_makeIndex(pi)); makePyramidFacetsToHorizon(zh,pi,horizon_fcts,horizon_fcts_edges, other_horizon_edges,available_points); // printZhull(zh); freeList(&horizon_fcts); freeList(&horizon_fcts_edges); freeList(&other_horizon_edges); freeList(&available_points); fli++; } // appendExteriorPoints(zh); } return cnt; }
void appendPoints(points_t *points, const float *x, const float *y, const float *z, const size_t num_points) { const size_t n=getNumPoints(*points); size_t i,j; reallocatePoints(points,getNumPoints(*points)+num_points); for (i=n,j=0; i<getNumPoints(*points); i++, j++) { points->v[i] = initVector(x[j],y[j],z[j]); } }
int OGRCircularString::IsFullCircle( double& cx, double& cy, double& square_R ) const { if( getNumPoints() == 3 && get_IsClosed() ) { const double x0 = getX(0); const double y0 = getY(0); const double x1 = getX(1); const double y1 = getY(1); cx = (x0 + x1) / 2; cy = (y0 + y1) / 2; square_R = (x1 - cx) * (x1 - cx) + (y1 - cy) * (y1 - cy); return TRUE; } // Full circle defined by 2 arcs? else if( getNumPoints() == 5 && get_IsClosed() ) { double R_1 = 0.0; double cx_1 = 0.0; double cy_1 = 0.0; double alpha0_1 = 0.0; double alpha1_1 = 0.0; double alpha2_1 = 0.0; double R_2 = 0.0; double cx_2 = 0.0; double cy_2 = 0.0; double alpha0_2 = 0.0; double alpha1_2 = 0.0; double alpha2_2 = 0.0; if( OGRGeometryFactory::GetCurveParmeters( getX(0), getY(0), getX(1), getY(1), getX(2), getY(2), R_1, cx_1, cy_1, alpha0_1, alpha1_1, alpha2_1) && OGRGeometryFactory::GetCurveParmeters( getX(2), getY(2), getX(3), getY(3), getX(4), getY(4), R_2, cx_2, cy_2, alpha0_2, alpha1_2, alpha2_2) && fabs(R_1-R_2) < 1e-10 && fabs(cx_1-cx_2) < 1e-10 && fabs(cy_1-cy_2) < 1e-10 && (alpha2_1 - alpha0_1) * (alpha2_2 - alpha0_2) > 0 ) { cx = cx_1; cy = cy_1; square_R = R_1 * R_1; return TRUE; } } return FALSE; }
VariablesGrid::operator DMatrix() const { DMatrix tmp(getNumPoints( ), getNumValues( ) + 1); for (uint run1 = 0; run1 < getNumPoints(); ++run1) { tmp(run1, 0) = getTime(run1); for (uint run2 = 0; run2 < getNumValues(); ++run2) tmp(run1, 1 + run2) = operator()(run1, run2); } return tmp; }
//! @cond Doxygen_Suppress double OGRCircularString::get_AreaOfCurveSegments() const { double dfArea = 0.0; for( int i = 0; i < getNumPoints() - 2; i += 2 ) { const double x0 = getX(i); const double y0 = getY(i); const double x1 = getX(i+1); const double y1 = getY(i+1); const double x2 = getX(i+2); const double y2 = getY(i+2); double R = 0.0; double cx = 0.0; double cy = 0.0; double alpha0 = 0.0; double alpha1 = 0.0; double alpha2 = 0.0; if( OGRGeometryFactory::GetCurveParmeters(x0, y0, x1, y1, x2, y2, R, cx, cy, alpha0, alpha1, alpha2)) { // Should be <= PI in absolute value. const double delta_alpha01 = alpha1 - alpha0; const double delta_alpha12 = alpha2 - alpha1; // Same. // http://en.wikipedia.org/wiki/Circular_segment dfArea += 0.5 * R * R * fabs( delta_alpha01 - sin(delta_alpha01) + delta_alpha12 - sin(delta_alpha12) ); } } return dfArea; }
double OGRCompoundCurve::get_Area() const { if( IsEmpty() || !get_IsClosed() ) return 0; // Optimization for convex rings. if( IsConvex() ) { // Compute area of shape without the circular segments. OGRPointIterator* poIter = getPointIterator(); OGRLineString oLS; oLS.setNumPoints( getNumPoints() ); OGRPoint p; for( int i = 0; poIter->getNextPoint(&p); i++ ) { oLS.setPoint( i, p.getX(), p.getY() ); } double dfArea = oLS.get_Area(); delete poIter; // Add the area of the spherical segments. dfArea += get_AreaOfCurveSegments(); return dfArea; } OGRLineString* poLS = CurveToLine(); double dfArea = poLS->get_Area(); delete poLS; return dfArea; }
boost::property_tree::ptree PointBuffer::toPTree() const { boost::property_tree::ptree tree; const Schema& schema = getSchema(); schema::index_by_index const& dimensions = schema.getDimensions().get<schema::index>(); const boost::uint32_t numPoints = getNumPoints(); for (boost::uint32_t pointIndex=0; pointIndex<numPoints; pointIndex++) { const std::string pointstring = boost::lexical_cast<std::string>(pointIndex) + "."; boost::uint32_t i = 0; for (i=0; i<dimensions.size(); i++) { const Dimension& dimension = dimensions[i]; boost::uint32_t const& size = dimension.getByteSize(); const std::string key = pointstring + dimension.getName(); std::string output = printDimension(dimension, pointIndex); tree.add(key, output); } } return tree; }
double RuleClenshawCurtis::eval( int level, int point, double x ) const{ double value = 1.0, d = nodes[point]; for( int j=0; j<getNumPoints(level); j++ ){ value *= ( j != point ) ? ( x - nodes[j] ) / ( d - nodes[j] ) : 1.0; } return value; }
boost::uint32_t Reader::processBuffer(PointBuffer& data, boost::uint64_t index) const { const Schema& schema = data.getSchema(); // how many are they asking for? boost::uint64_t numPointsWanted = data.getCapacity(); // we can only give them as many as we have left boost::uint64_t numPointsAvailable = getNumPoints() - index; if (numPointsAvailable < numPointsWanted) numPointsWanted = numPointsAvailable; schema::DimensionMap* d = m_buffer.getSchema().mapDimensions(data.getSchema()); data.setNumPoints(0); PointBuffer::copyLikeDimensions(m_buffer, data, *d, index, 0, numPointsWanted); data.setNumPoints(numPointsWanted); delete d; return numPointsWanted; }
CubatureControlVolume<SpT,PT,WT>:: CubatureControlVolume(const shards::CellTopology cellTopology) { // define primary cell topology with given one primaryCellTopo_ = cellTopology; // subcell is defined either hex or quad according to dimension switch (primaryCellTopo_.getDimension()) { case 2: subcvCellTopo_ = shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >()); break; case 3: subcvCellTopo_ = shards::CellTopology(shards::getCellTopologyData<shards::Hexahedron<8> >()); break; } // computation order is always one; degree_ = 1; // create subcell cubature points and weights and cache them const ordinal_type subcvDegree = 2; auto subcvCubature = DefaultCubatureFactory::create<SpT,PT,WT>(subcvCellTopo_, subcvDegree); const auto numSubcvPoints = subcvCubature->getNumPoints(); const auto subcvDim = subcvCubature->getDimension(); subcvCubaturePoints_ = Kokkos::DynRankView<PT,SpT>("CubatureControlVolume::subcvCubaturePoints_", numSubcvPoints, subcvDim); subcvCubatureWeights_ = Kokkos::DynRankView<WT,SpT>("CubatureControlVolume::subcvCubatureWeights_", numSubcvPoints); subcvCubature->getCubature(subcvCubaturePoints_, subcvCubatureWeights_); }
OGRBoolean OGRLinearRing::isPointOnRingBoundary(const OGRPoint* poPoint, int bTestEnvelope) const { if ( NULL == poPoint ) { CPLDebug( "OGR", "OGRLinearRing::isPointOnRingBoundary(const OGRPoint* poPoint) - passed point is NULL!" ); return 0; } const int iNumPoints = getNumPoints(); // Simple validation if ( iNumPoints < 4 ) return 0; const double dfTestX = poPoint->getX(); const double dfTestY = poPoint->getY(); // Fast test if point is inside extent of the ring if( bTestEnvelope ) { OGREnvelope extent; getEnvelope(&extent); if ( !( dfTestX >= extent.MinX && dfTestX <= extent.MaxX && dfTestY >= extent.MinY && dfTestY <= extent.MaxY ) ) { return 0; } } double prev_diff_x = getX(0) - dfTestX; double prev_diff_y = getY(0) - dfTestY; for ( int iPoint = 1; iPoint < iNumPoints; iPoint++ ) { const double x1 = getX(iPoint) - dfTestX; const double y1 = getY(iPoint) - dfTestY; const double x2 = prev_diff_x; const double y2 = prev_diff_y; /* If the point is on the segment, return immediatly */ /* FIXME? If the test point is not exactly identical to one of */ /* the vertices of the ring, but somewhere on a segment, there's */ /* little chance that we get 0. So that should be tested against some epsilon */ if ( x1 * y2 - x2 * y1 == 0 ) { /* If iPoint and iPointPrev are the same, go on */ if( !(x1 == x2 && y1 == y2) ) { return 1; } } prev_diff_x = x1; prev_diff_y = y1; } return 0; }
CoordinateSequence* Polygon::getCoordinates() const { if (isEmpty()) { return getFactory()->getCoordinateSequenceFactory()->create(); } vector<Coordinate> *cl = new vector<Coordinate>; // reserve space in the vector for all the polygon points cl->reserve(getNumPoints()); // Add shell points const CoordinateSequence* shellCoords=shell->getCoordinatesRO(); shellCoords->toVector(*cl); // Add holes points size_t nholes=holes->size(); for (size_t i=0; i<nholes; ++i) { const LinearRing* lr = dynamic_cast<const LinearRing *>((*holes)[i]); const CoordinateSequence* childCoords = lr->getCoordinatesRO(); childCoords->toVector(*cl); } return getFactory()->getCoordinateSequenceFactory()->create(cl); }
OGRBoolean OGRLinearRing::isPointInRing(const OGRPoint* poPoint, int bTestEnvelope) const { if ( NULL == poPoint ) { CPLDebug( "OGR", "OGRLinearRing::isPointInRing(const OGRPoint* poPoint) - passed point is NULL!" ); return 0; } const int iNumPoints = getNumPoints(); // Simple validation if ( iNumPoints < 4 ) return 0; const double dfTestX = poPoint->getX(); const double dfTestY = poPoint->getY(); // Fast test if point is inside extent of the ring if (bTestEnvelope) { OGREnvelope extent; getEnvelope(&extent); if ( !( dfTestX >= extent.MinX && dfTestX <= extent.MaxX && dfTestY >= extent.MinY && dfTestY <= extent.MaxY ) ) { return 0; } } // For every point p in ring, // test if ray starting from given point crosses segment (p - 1, p) int iNumCrossings = 0; for ( int iPoint = 1; iPoint < iNumPoints; iPoint++ ) { const int iPointPrev = iPoint - 1; const double x1 = getX(iPoint) - dfTestX; const double y1 = getY(iPoint) - dfTestY; const double x2 = getX(iPointPrev) - dfTestX; const double y2 = getY(iPointPrev) - dfTestY; if( ( ( y1 > 0 ) && ( y2 <= 0 ) ) || ( ( y2 > 0 ) && ( y1 <= 0 ) ) ) { // Check if ray intersects with segment of the ring const double dfIntersection = ( x1 * y2 - x2 * y1 ) / (y2 - y1); if ( 0.0 < dfIntersection ) { // Count intersections iNumCrossings++; } } } // If iNumCrossings number is even, given point is outside the ring, // when the crossings number is odd, the point is inside the ring. return ( ( iNumCrossings % 2 ) == 1 ? 1 : 0 ); }
vector_t getPoint(const points_t points, const index_t index) { if ((index>=0)&&(index<getNumPoints(points))) { return points.v[index]; } return initVector(0.0f,0.0f,0.0f); }
bool LineString::isClosed() const { if (isEmpty()) { return false; } return getCoordinateN(0).equals2D(getCoordinateN(getNumPoints()-1)); }
VariablesGrid VariablesGrid::getTimeSubGrid( uint startIdx, uint endIdx ) const { VariablesGrid newVariablesGrid; if ( ( startIdx >= getNumPoints( ) ) || ( endIdx >= getNumPoints( ) ) ) return newVariablesGrid; if ( startIdx > endIdx ) return newVariablesGrid; for( uint i=startIdx; i<=endIdx; ++i ) newVariablesGrid.addMatrix( *(values[i]),getTime( i ) ); return newVariablesGrid; }
Vector VariablesGrid::getVector( uint pointIdx ) const { if ( ( values == 0 ) || ( pointIdx >= getNumPoints() ) ) return emptyVector; return values[pointIdx]->getCol( 0 ); }
returnValue VariablesGrid::setAllVectors( const Vector& _values ) { for( uint i = 0; i < getNumPoints(); i++ ) ACADO_TRY( setVector( i,_values ) ); return SUCCESSFUL_RETURN; }
pdal::Bounds<double> PointBuffer::calculateBounds(bool is3d) const { pdal::Schema const& schema = getSchema(); pdal::Bounds<double> output; Dimension const& dimX = schema.getDimension("X"); Dimension const& dimY = schema.getDimension("Y"); Dimension const& dimZ = schema.getDimension("Z"); Vector<double> v; bool first = true; for (boost::uint32_t pointIndex=0; pointIndex<getNumPoints(); pointIndex++) { boost::int32_t xi = getField<boost::int32_t>(dimX, pointIndex); boost::int32_t yi = getField<boost::int32_t>(dimY, pointIndex); boost::int32_t zi = getField<boost::int32_t>(dimZ, pointIndex); double xd = dimX.applyScaling(xi); double yd = dimY.applyScaling(yi); if (is3d) { double zd = dimZ.applyScaling(zi); if (first) { output = pdal::Bounds<double>(xd, yd, zd, xd, yd, zd); first = false; v.add(xd); v.add(yd); v.add(zd); } v[0] = xd; v[1] = yd; v[2] = zd; output.grow(v); } else { if (first) { output = pdal::Bounds<double>(xd, yd, xd, yd); first = false; v.add(xd); v.add(yd); } v[0] = xd; v[1] = yd; output.grow(v); } } return output; }
void CubatureTensor<Scalar,ArrayPoint,ArrayWeight>::getCubature(ArrayPoint & cubPoints, ArrayWeight & cubWeights) const { int numCubPoints = getNumPoints(); int cubDim = getDimension(); // check size of cubPoints and cubWeights TEUCHOS_TEST_FOR_EXCEPTION( ( ( (int)cubPoints.size() < numCubPoints*cubDim ) || ( (int)cubWeights.size() < numCubPoints ) ), std::out_of_range, ">>> ERROR (CubatureTensor): Insufficient space allocated for cubature points or weights."); unsigned numCubs = cubatures_.size(); std::vector<unsigned> numLocPoints(numCubs); std::vector<unsigned> locDim(numCubs); std::vector< FieldContainer<Scalar> > points(numCubs); std::vector< FieldContainer<Scalar> > weights(numCubs); // extract required points and weights for (unsigned i=0; i<numCubs; i++) { numLocPoints[i] = cubatures_[i]->getNumPoints(); locDim[i] = cubatures_[i]->getDimension(); points[i].resize(numLocPoints[i], locDim[i]); weights[i].resize(numLocPoints[i]); // cubPoints and cubWeights are used here only for temporary data retrieval cubatures_[i]->getCubature(cubPoints, cubWeights); for (unsigned pt=0; pt<numLocPoints[i]; pt++) { for (unsigned d=0; d<locDim[i]; d++) { points[i](pt,d) = cubPoints(pt,d); weights[i](pt) = cubWeights(pt); } } } // reset all weights to 1.0 for (int i=0; i<numCubPoints; i++) { cubWeights(i) = (Scalar)1.0; } // fill tensor-product cubature int globDimCounter = 0; int shift = 1; for (unsigned i=0; i<numCubs; i++) { for (int j=0; j<numCubPoints; j++) { /* int itmp = ((j*shift) % numCubPoints) + (j / (numCubPoints/shift)); // equivalent, but numerically unstable */ int itmp = (j % (numCubPoints/shift))*shift + (j / (numCubPoints/shift)); for (unsigned k=0; k<locDim[i]; k++) { cubPoints(itmp , globDimCounter+k) = points[i](j % numLocPoints[i], k); } cubWeights( itmp ) *= weights[i](j % numLocPoints[i]); } shift *= numLocPoints[i]; globDimCounter += locDim[i]; } } // end getCubature
RuleGaussHermite::RuleGaussHermite( const int level, double walpha ) : max_level(level), tol(NUM_TOL), alpha(walpha), OneDRule(){ int total_points = 0; levels = new int[max_level+1]; levels[0] = 0; for( int l=0; l<max_level; l++ ){ levels[l+1] = levels[l] + getNumPoints(l); total_points += getNumPoints(l); } level_points = new int[total_points]; weights = new double[total_points]; int num_known_points = 0; double *known_x = new double[total_points]; double *x = 0, *w = 0; for( int l=0; l<max_level; l++ ){ int num_points = getNumPoints( l ); buildOneLevel( l, w, x ); for( int i=0; i<num_points; i++ ){ weights[ levels[l] + i ] = w[i]; int point = -1; for( int j=0; j<num_known_points; j++ ){ if ( fabs( x[i] - known_x[j] ) < tol ){ point = j; break; } } if ( point == - 1){ // new point found known_x[num_known_points] = x[i]; point = num_known_points; num_known_points++; } level_points[levels[l] + i] = point; } } nodes = new double[num_known_points]; tcopy( num_known_points, known_x, nodes ); delete[] known_x; delete[] x; delete[] w; }
Point* LineString::getEndPoint() const { if (isEmpty()) { return NULL; //return new Point(NULL,NULL); } return getPointN(getNumPoints() - 1); }
void svg::Polygon::print(std::ostream& os) { os <<"polygon "; for(unsigned int i = 0; i < getNumPoints(); ++i) { if (i > 0) os << ", "; os << getPointAt(i); } }
returnValue VariablesGrid::getSum( Vector& sum ) const { sum.setZero(); for( uint i=0; i<getNumPoints( ); ++i ) sum += getVector( i ); return SUCCESSFUL_RETURN; }
void BezierSpline::ReplacePoint(int index, GEOMETRY::geom::Coordinate &newpoint) { if(index<0 || index>=getNumPoints()) { return; } m_knots[index] = newpoint; OnPointChanged(); }
void countGeometry(OGRPolygon* poly, size_t &points, size_t &geom) { auto extRing = poly->getExteriorRing(); points += extRing->getNumPoints(); geom += poly->getNumInteriorRings() + 1; for (int i = 0; i < poly->getNumInteriorRings(); ++i) { points += poly->getInteriorRing(i)->getNumPoints(); } }
OGRLinearRing::OGRLinearRing( OGRLinearRing * poSrcRing ) { if( poSrcRing == NULL ) { CPLDebug( "OGR", "OGRLinearRing::OGRLinearRing(OGRLinearRing*poSrcRing) - passed in ring is NULL!" ); return; } setNumPoints( poSrcRing->getNumPoints() ); memcpy( paoPoints, poSrcRing->paoPoints, sizeof(OGRRawPoint) * getNumPoints() ); if( poSrcRing->padfZ ) { Make3D(); memcpy( padfZ, poSrcRing->padfZ, sizeof(double) * getNumPoints() ); } }