bool QgsLineString::deleteVertex( QgsVertexId position )
{
if ( position.vertex >= mX.size() || position.vertex < 0 )
{
return false;
}
mX.remove( position.vertex );
mY.remove( position.vertex );
if ( is3D() )
{
mZ.remove( position.vertex );
}
if ( isMeasure() )
{
mM.remove( position.vertex );
}
if ( numPoints() == 1 )
{
clear();
}
clearCache(); //set bounding box invalid
return true;
}
int QgsCurve::vertexNumberFromVertexId( QgsVertexId id ) const
{
if ( id.part != 0 || id.ring != 0 )
return -1;
if ( id.vertex < 0 || id.vertex >= numPoints() )
return -1;
return id.vertex;
}
QgsPointV2 QgsLineStringV2::startPoint() const
{
if ( numPoints() < 1 )
{
return QgsPointV2();
}
return pointN( 0 );
}
void QgsCompoundCurve::close()
{
if ( numPoints() < 1 || isClosed() )
{
return;
}
addVertex( startPoint() );
}
void QgsLineStringV2::close()
{
if ( numPoints() < 1 || isClosed() )
{
return;
}
addVertex( startPoint() );
}
int main() {
srand(time(0));
while (breakCond != 1) {
printMenu();
selection();
switch(selector) {
case 1:
printf("Would you like, 1)Addition or 2)Multiplication?\n");
scanf("%d", &arithSelect);
if (arithSelect != 1 && arithSelect != 2) {
printf("You have made an invalid choice. Please start again.\n");
scanf("%d", &arithSelect);
};
arithCollect();
avgTime = arithGame(maxValue, quant, arithSelect);
score = score + numPoints(avgTime);
break;
case 2:
printf("Enter the maximum number for the game:\n");
scanf("%d", &maxValue);
avgTime = guessGame(maxValue);
score = score + numPoints(avgTime);
case 3:
printf("Your score is %d.\n", score);
break;
case 4:
printf("Thank you for playing!\n");
breakCond = 1;
break;
default:
printf("This is an invalid value, please make a valid selection:\n");
selection();
break;
};
};
};
void QgsLineStringV2::sumUpArea( double& sum ) const
{
int maxIndex = numPoints() - 1;
for ( int i = 0; i < maxIndex; ++i )
{
sum += 0.5 * ( mCoords[i].x() * mCoords[i+1].y() - mCoords[i].y() * mCoords[i+1].x() );
}
}
QgsPointV2 QgsCircularString::startPoint() const
{
if ( numPoints() < 1 )
{
return QgsPointV2();
}
return pointN( 0 );
}
void BvhTriangleSystem::integrate(float dt)
{
masssystem::integrateAllAnchored((float3 *)deviceX(),
(float3 *)deviceV(),
(float3 *)deviceVa(),
dt,
numPoints());
CudaBase::CheckCudaError("triangle system integrate");
}
void QgsCircularString::points( QgsPointSequence &pts ) const
{
pts.clear();
int nPts = numPoints();
for ( int i = 0; i < nPts; ++i )
{
pts.push_back( pointN( i ) );
}
}
void QgsLineStringV2::points( QList<QgsPointV2>& pts ) const
{
pts.clear();
int nPoints = numPoints();
for ( int i = 0; i < nPoints; ++i )
{
pts.push_back( pointN( i ) );
}
}
void QgsLineString::sumUpArea( double &sum ) const
{
int maxIndex = numPoints() - 1;
for ( int i = 0; i < maxIndex; ++i )
{
sum += 0.5 * ( mX.at( i ) * mY.at( i + 1 ) - mY.at( i ) * mX.at( i + 1 ) );
}
}
std::string ATetrahedronMesh::verbosestr() const
{
std::stringstream sst;
sst<<" tetrahedron mesh nv "<<numPoints()
<<"\n ntetra "<<numTetrahedrons()
<<"\n volume "<<volume()
<<"\n";
return sst.str();
}
void BvhTetrahedronSystem::update()
{
masssystem::useAnchoredVelocity((float3 *)deviceV(),
(float3 *)deviceVa(),
(uint *)deviceAnchor(),
numPoints());
formTetrahedronAabbs();
CudaLinearBvh::update();
}
//curve interface
double QgsCircularString::length() const
{
int nPoints = numPoints();
double length = 0;
for ( int i = 0; i < ( nPoints - 2 ) ; i += 2 )
{
length += QgsGeometryUtils::circleLength( mX[i], mY[i], mX[i + 1], mY[i + 1], mX[i + 2], mY[i + 2] );
}
return length;
}
bool QgsLineStringV2::pointAt( int i, QgsPointV2& vertex, QgsVertexId::VertexType& type ) const
{
if ( i >= numPoints() )
{
return false;
}
vertex = pointN( i );
type = QgsVertexId::SegmentVertex;
return true;
}
bool QgsLineStringV2::pointAt( int node, QgsPointV2& point, QgsVertexId::VertexType& type ) const
{
if ( node < 0 || node >= numPoints() )
{
return false;
}
point = pointN( node );
type = QgsVertexId::SegmentVertex;
return true;
}
bool QgsCircularString::pointAt( int node, QgsPointV2 &point, QgsVertexId::VertexType &type ) const
{
if ( node >= numPoints() )
{
return false;
}
point = pointN( node );
type = ( node % 2 == 0 ) ? QgsVertexId::SegmentVertex : QgsVertexId::CurveVertex;
return true;
}
double QgsLineString::vertexAngle( QgsVertexId vertex ) const
{
if ( mX.count() < 2 )
{
//undefined
return 0.0;
}
if ( vertex.vertex == 0 || vertex.vertex >= ( numPoints() - 1 ) )
{
if ( isClosed() )
{
double previousX = mX.at( numPoints() - 2 );
double previousY = mY.at( numPoints() - 2 );
double currentX = mX.at( 0 );
double currentY = mY.at( 0 );
double afterX = mX.at( 1 );
double afterY = mY.at( 1 );
return QgsGeometryUtils::averageAngle( previousX, previousY, currentX, currentY, afterX, afterY );
}
else if ( vertex.vertex == 0 )
{
return QgsGeometryUtils::lineAngle( mX.at( 0 ), mY.at( 0 ), mX.at( 1 ), mY.at( 1 ) );
}
else
{
int a = numPoints() - 2;
int b = numPoints() - 1;
return QgsGeometryUtils::lineAngle( mX.at( a ), mY.at( a ), mX.at( b ), mY.at( b ) );
}
}
else
{
double previousX = mX.at( vertex.vertex - 1 );
double previousY = mY.at( vertex.vertex - 1 );
double currentX = mX.at( vertex.vertex );
double currentY = mY.at( vertex.vertex );
double afterX = mX.at( vertex.vertex + 1 );
double afterY = mY.at( vertex.vertex + 1 );
return QgsGeometryUtils::averageAngle( previousX, previousY, currentX, currentY, afterX, afterY );
}
}
void QgsLineStringV2::sumUpArea( double& sum ) const
{
int maxIndex = numPoints() - 1;
if ( maxIndex == 1 )
return; //no area, just a single line
for ( int i = 0; i < maxIndex; ++i )
{
sum += 0.5 * ( mX.at( i ) * mY.at( i + 1 ) - mY.at( i ) * mX.at( i + 1 ) );
}
}
void QgsLineStringV2::transform( const QTransform& t )
{
int nPoints = numPoints();
for ( int i = 0; i < nPoints; ++i )
{
qreal x, y;
t.map( mX.at( i ), mY.at( i ), &x, &y );
mX[i] = x; mY[i] = y;
}
mBoundingBox = QgsRectangle();
}
QPolygonF QgsCurve::asQPolygonF() const
{
const int nb = numPoints();
QPolygonF points;
points.reserve( nb );
for ( int i = 0; i < nb; ++i )
{
points << QPointF( xAt( i ), yAt( i ) );
}
return points;
}
double QgsCircularString::vertexAngle( QgsVertexId vId ) const
{
if ( numPoints() < 3 )
{
//undefined
return 0.0;
}
int before = vId.vertex - 1;
int vertex = vId.vertex;
int after = vId.vertex + 1;
if ( vId.vertex % 2 != 0 ) // a curve vertex
{
if ( vId.vertex >= 1 && vId.vertex < numPoints() - 1 )
{
return QgsGeometryUtils::circleTangentDirection( QgsPoint( mX[vertex], mY[vertex] ), QgsPoint( mX[before], mY[before] ),
QgsPoint( mX[vertex], mY[vertex] ), QgsPoint( mX[after], mY[after] ) );
}
}
else //a point vertex
{
if ( vId.vertex == 0 )
{
return QgsGeometryUtils::circleTangentDirection( QgsPoint( mX[0], mY[0] ), QgsPoint( mX[0], mY[0] ),
QgsPoint( mX[1], mY[1] ), QgsPoint( mX[2], mY[2] ) );
}
if ( vId.vertex >= numPoints() - 1 )
{
int a = numPoints() - 3;
int b = numPoints() - 2;
int c = numPoints() - 1;
return QgsGeometryUtils::circleTangentDirection( QgsPoint( mX[c], mY[c] ), QgsPoint( mX[a], mY[a] ),
QgsPoint( mX[b], mY[b] ), QgsPoint( mX[c], mY[c] ) );
}
else
{
if ( vId.vertex + 2 > numPoints() - 1 )
{
return 0.0;
}
int vertex1 = vId.vertex - 2;
int vertex2 = vId.vertex - 1;
int vertex3 = vId.vertex;
double angle1 = QgsGeometryUtils::circleTangentDirection( QgsPoint( mX[vertex3], mY[vertex3] ),
QgsPoint( mX[vertex1], mY[vertex1] ), QgsPoint( mX[vertex2], mY[vertex2] ), QgsPoint( mX[vertex3], mY[vertex3] ) );
int vertex4 = vId.vertex + 1;
int vertex5 = vId.vertex + 2;
double angle2 = QgsGeometryUtils::circleTangentDirection( QgsPoint( mX[vertex3], mY[vertex3] ),
QgsPoint( mX[vertex3], mY[vertex3] ), QgsPoint( mX[vertex4], mY[vertex4] ), QgsPoint( mX[vertex5], mY[vertex5] ) );
return QgsGeometryUtils::averageAngle( angle1, angle2 );
}
}
return 0.0;
}
void QgsLineString::transform( const QTransform &t )
{
int nPoints = numPoints();
for ( int i = 0; i < nPoints; ++i )
{
qreal x, y;
t.map( mX.at( i ), mY.at( i ), &x, &y );
mX[i] = x;
mY[i] = y;
}
clearCache();
}
bool QgsCurve::isClosed() const
{
if ( numPoints() == 0 )
return false;
//don't consider M-coordinates when testing closedness
QgsPointV2 start = startPoint();
QgsPointV2 end = endPoint();
return ( qgsDoubleNear( start.x(), end.x(), 1E-8 ) &&
qgsDoubleNear( start.y(), end.y(), 1E-8 ) &&
qgsDoubleNear( start.z(), end.z(), 1E-8 ) );
}
/*
================
idPointListInterface::selectPoint
================
*/
int idPointListInterface::selectPoint(int index, bool single) {
if (index >= 0 && index < numPoints()) {
if (single) {
deselectAll();
} else {
if (isPointSelected(index) >= 0) {
selectedPoints.Remove(index);
}
}
return selectedPoints.Append(index);
}
return -1;
}
void QgsCircularStringV2::transform( const QTransform& t )
{
clearCache();
int nPoints = numPoints();
for ( int i = 0; i < nPoints; ++i )
{
qreal x, y;
t.map( mX.at( i ), mY.at( i ), &x, &y );
mX[i] = x;
mY[i] = y;
}
}
void Spline::calcSpline()
{
const int np=numPoints();
double *u = new double[np];
if (natural)
{
mPoints[0].y2 = u[0] = 0.0;
}
else
{
mPoints[0].y2 = -0.5;
u[0] =
(3.0/(mPoints[1].x-mPoints[0].x))*((mPoints[1].y-mPoints[0].y)
/ (mPoints[1].x-mPoints[0].x)-yp1);
}
double sig,p,qn,un;
for (int i=1; i<=np-2; i++)
{
sig=(mPoints[i].x-mPoints[i-1].x) / (mPoints[i+1].x-mPoints[i-1].x);
p = sig*mPoints[i-1].y2+2.0;
mPoints[i].y2 = (sig-1.0)/p;
u[i] =
(mPoints[i+1].y - mPoints[i].y) / (mPoints[i+1].x-mPoints[i].x)
- (mPoints[i].y - mPoints[i-1].y) / (mPoints[i].x - mPoints[i-1].x);
u[i] = (6.0*u[i] / (mPoints[i+1].x - mPoints[i-1].x) - sig *u[i-1])/p;
}
if (natural)
{
qn = un = 0.0;
}
else
{
qn = 0.5;
un =
(3.0 / (mPoints[np-1].x - mPoints[np-2].x))
* (ypn - (mPoints[np-1].y - mPoints[np-2].y)
/ (mPoints[np-1].x - mPoints[np-2].x));
}
mPoints[np-1].y2 = (un - qn * u[np-2]) / (qn*mPoints[np-2].y2 +1.0 );
for (int i=np-2; i>=0; i--)
{
mPoints[i].y2 = mPoints[i].y2 * mPoints[i+1].y2+u[i];
}
mRecalc = false;
delete [] u;
}
QgsLineString *QgsCircularString::curveToLine( double tolerance, SegmentationToleranceType toleranceType ) const
{
QgsLineString *line = new QgsLineString();
QgsPointSequence points;
int nPoints = numPoints();
for ( int i = 0; i < ( nPoints - 2 ) ; i += 2 )
{
segmentize( pointN( i ), pointN( i + 1 ), pointN( i + 2 ), points, tolerance, toleranceType );
}
line->setPoints( points );
return line;
}
Coordinate GObject::center() const {
Coordinate r(0, 0, 0);
int n = numPoints();
for(auto &p : _coordinates){
r.x += p.x;
r.y += p.y;
r.z += p.z;
}
r.x /= n;
r.y /= n;
r.z /= n;
return r;
}
