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() );
}
}
