sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-04-17 00:04:02 -04:00
Code Issues Packages Projects Releases Wiki Activity

sipify analysis interpolation (#4757)

Browse Source
This commit is contained in:
Denis Rouzaud 2017-06-22 20:25:19 +02:00 committed by GitHub
parent 46596914e1
commit e40f92cc1b
35 changed files with 1254 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
python/analysis/interpolation/Bezier3D.sip
View File

@ -1,42 +1,97 @@
class Bezier3D : ParametricLine
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Bezier3D.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class Bezier3D: ParametricLine
{
%TypeHeaderCode
#include <Bezier3D.h>
%Docstring
Class Bezier3D represents a bezier curve, represented by control points. Parameter t is running from 0 to 1. The class is capable to calculate the curve point and the first two derivatives belonging to t.*
%End
%TypeHeaderCode
#include "Bezier3D.h"
%End
protected:
public:
/** Default constructor*/
Bezier3D();
/** Constructor, par is a pointer to the parent, controlpoly a controlpolygon*/
Bezier3D( ParametricLine *par, QVector<QgsPoint*> *controlpoly );
/** Destructor*/
%Docstring
Default constructor
%End
Bezier3D( ParametricLine *par, QVector<QgsPoint *> *controlpoly );
%Docstring
Constructor, par is a pointer to the parent, controlpoly a controlpolygon
%End
virtual ~Bezier3D();
/** Do not use this method, since a Bezier curve does not consist of other curves*/
virtual void add( ParametricLine *pl );
/** Calculates the first derivative and assigns it to v*/
virtual void calcFirstDer( float t, Vector3D *v );
/** Calculates the second derivative and assigns it to v*/
virtual void calcSecDer( float t, Vector3D *v );
//virtual QgsPoint calcPoint(float t);
/** Calculates the point on the curve and assigns it to p*/
virtual void calcPoint( float t, QgsPoint *p );
/** Changes the order of control points*/
virtual void add( ParametricLine *pl /Transfer/ );
%Docstring
Do not use this method, since a Bezier curve does not consist of other curves
%End
virtual void calcFirstDer( float t, Vector3D *v /Out/ );
%Docstring
Calculates the first derivative and assigns it to v
%End
virtual void calcSecDer( float t, Vector3D *v /Out/ );
%Docstring
Calculates the second derivative and assigns it to v
%End
virtual void calcPoint( float t, QgsPoint *p /Out/ );
%Docstring
Calculates the point on the curve and assigns it to p
%End
virtual void changeDirection();
//virtual void draw(QPainter *p);
//virtual bool intersects(ParametricLine *pal);
/** Do not use this method, since a Bezier curve does not consist of other curves*/
%Docstring
Changes the order of control points
%End
virtual void remove( int i );
/** Returns a control point*/
%Docstring
Do not use this method, since a Bezier curve does not consist of other curves
%End
virtual const QgsPoint *getControlPoint( int number ) const;
/** Returns a pointer to the control polygon*/
virtual const QVector<QgsPoint*> *getControlPoly() const;
/** Returns the degree of the curve*/
%Docstring
Returns a control point
:rtype: QgsPoint
%End
virtual const QVector<QgsPoint *> *getControlPoly() const;
%Docstring
Returns a pointer to the control polygon
:rtype: list of QgsPoint
%End
virtual int getDegree() const;
/** Returns the parent*/
%Docstring
Returns the degree of the curve
:rtype: int
%End
virtual ParametricLine *getParent() const;
/** Sets the parent*/
%Docstring
Returns the parent
:rtype: ParametricLine
%End
virtual void setParent( ParametricLine *par );
/** Sets the control polygon*/
virtual void setControlPoly( QVector<QgsPoint*> *cp );
%Docstring
Sets the parent
%End
virtual void setControlPoly( QVector<QgsPoint *> *cp );
%Docstring
Sets the control polygon
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Bezier3D.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

61
python/analysis/interpolation/CloughTocherInterpolator.sip
View File

@ -1,24 +1,65 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/CloughTocherInterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class CloughTocherInterpolator : TriangleInterpolator
{
%Docstring
This is an implementation of a Clough-Tocher interpolator based on a triangular tessellation. The derivatives orthogonal to the boundary curves are interpolated linearly along a triangle edge.*
%End
%TypeHeaderCode
#include <CloughTocherInterpolator.h>
#include "CloughTocherInterpolator.h"
%End
protected:
/** Finds out, in which triangle the point with the coordinates x and y is*/
void init( double x, double y );
/** Calculates the Bernsteinpolynomials to calculate the Beziertriangle. 'n' is three in the cubical case, 'i', 'j', 'k' are the indices of the controllpoint and 'u', 'v', 'w' are the barycentric coordinates of the point*/
%Docstring
Finds out, in which triangle the point with the coordinates x and y is
%End
double calcBernsteinPoly( int n, int i, int j, int k, double u, double v, double w );
%Docstring
Calculates the Bernsteinpolynomials to calculate the Beziertriangle. 'n' is three in the cubical case, 'i', 'j', 'k' are the indices of the controllpoint and 'u', 'v', 'w' are the barycentric coordinates of the point
:rtype: float
%End
public:
/** Standard constructor*/
CloughTocherInterpolator();
/** Constructor with a pointer to the triangulation as argument*/
%Docstring
Standard constructor
%End
CloughTocherInterpolator( NormVecDecorator *tin );
/** Destructor*/
%Docstring
Constructor with a pointer to the triangulation as argument
%End
virtual ~CloughTocherInterpolator();
/** Calculates the normal vector and assigns it to vec (not implemented at the moment)*/
virtual bool calcNormVec( double x, double y, Vector3D *result );
/** Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point*/
virtual bool calcPoint( double x, double y, QgsPoint *result );
virtual bool calcNormVec( double x, double y, Vector3D *result /Out/ );
%Docstring
Calculates the normal vector and assigns it to vec (not implemented at the moment)
:rtype: bool
%End
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ );
%Docstring
Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point
:rtype: bool
%End
virtual void setTriangulation( NormVecDecorator *tin );
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/CloughTocherInterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

256
python/analysis/interpolation/DualEdgeTriangulation.sip
View File

@ -1,104 +1,234 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/DualEdgeTriangulation.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class DualEdgeTriangulation: Triangulation
{
%Docstring
DualEdgeTriangulation is an implementation of a triangulation class based on the dual edge data structure*
%End
%TypeHeaderCode
#include <DualEdgeTriangulation.h>
#include "DualEdgeTriangulation.h"
%End
public:
DualEdgeTriangulation();
DualEdgeTriangulation( int nop, Triangulation *decorator );
virtual ~DualEdgeTriangulation();
void setDecorator( Triangulation *d );
/** Adds a line (e.g. a break-, structure- or an isoline) to the triangulation. The class takes ownership of the line object and its points*/
void addLine( Line3D *line /Transfer/, bool breakline );
/** Adds a point to the triangulation and returns the number of this point in case of success or -100 in case of failure*/
int addPoint( QgsPoint *p /Transfer/);
/** Performs a consistency check, remove this later*/
virtual void addLine( Line3D *line /Transfer/, bool breakline );
%Docstring
Adds a line (e.g. a break-, structure- or an isoline) to the triangulation. The class takes ownership of the line object and its points
%End
virtual int addPoint( QgsPoint *p /Transfer/ );
%Docstring
Adds a point to the triangulation and returns the number of this point in case of success or -100 in case of failure
:rtype: int
%End
virtual void performConsistencyTest();
/** Calculates the normal at a point on the surface*/
virtual bool calcNormal( double x, double y, Vector3D *result );
/** Calculates x-, y and z-value of the point on the surface*/
virtual bool calcPoint( double x, double y, QgsPoint *result );
/** Draws the points, edges and the forced lines*/
//virtual void draw(QPainter *p, double xlowleft, double ylowleft, double xupright, double yupright, double width, double height) const;
/** Returns a pointer to the point with number i*/
%Docstring
Performs a consistency check, remove this later
%End
virtual bool calcNormal( double x, double y, Vector3D *result /Out/ );
%Docstring
Calculates the normal at a point on the surface
:rtype: bool
%End
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ );
%Docstring
Calculates x-, y and z-value of the point on the surface
:rtype: bool
%End
virtual QgsPoint *getPoint( unsigned int i ) const;
/** Returns the number of the point opposite to the triangle points p1, p2 (which have to be on a halfedge)*/
int getOppositePoint( int p1, int p2 );
/** Finds out, in which triangle the point with coordinates x and y is and assigns the numbers of the vertices to 'n1', 'n2' and 'n3' and the vertices to 'p1', 'p2' and 'p3'*/
bool getTriangle( double x, double y, QgsPoint *p1, int *n1 /Out/, QgsPoint *p2 /Out/, int *n2 /Out/, QgsPoint *p3 /Out/, int *n3 /Out/ );
/** Finds out, in which triangle the point with coordinates x and y is and assigns addresses to the points at the vertices to 'p1', 'p2' and 'p3*/
bool getTriangle( double x, double y, QgsPoint *p1 /Out/, QgsPoint *p2 /Out/, QgsPoint *p3 /Out/ );
/** Returns a pointer to a value list with the information of the triangles surrounding (counterclockwise) a point. Four integer values describe a triangle, the first three are the number of the half edges of the triangle and the fourth is -10, if the third (and most counterclockwise) edge is a breakline, and -20 otherwise. The value list has to be deleted by the code which called the method*/
QList<int> *getSurroundingTriangles( int pointno );
/** Returns the largest x-coordinate value of the bounding box*/
%Docstring
Returns a pointer to the point with number i
:rtype: QgsPoint
%End
virtual int getOppositePoint( int p1, int p2 );
%Docstring
Returns the number of the point opposite to the triangle points p1, p2 (which have to be on a halfedge)
:rtype: int
%End
virtual bool getTriangle( double x, double y, QgsPoint *p1 /Out/, int *n1 /Out/, QgsPoint *p2 /Out/, int *n2 /Out/, QgsPoint *p3 /Out/, int *n3 /Out/ ) /PyName=getTriangleVertices/;
%Docstring
Finds out, in which triangle the point with coordinates x and y is and assigns the numbers of the vertices to 'n1', 'n2' and 'n3' and the vertices to 'p1', 'p2' and 'p3'
:rtype: bool
%End
virtual bool getTriangle( double x, double y, QgsPoint *p1 /Out/, QgsPoint *p2 /Out/, QgsPoint *p3 /Out/ );
%Docstring
Finds out, in which triangle the point with coordinates x and y is and assigns addresses to the points at the vertices to 'p1', 'p2' and 'p3
:rtype: bool
%End
virtual QList<int> *getSurroundingTriangles( int pointno );
%Docstring
Returns a pointer to a value list with the information of the triangles surrounding (counterclockwise) a point. Four integer values describe a triangle, the first three are the number of the half edges of the triangle and the fourth is -10, if the third (and most counterclockwise) edge is a breakline, and -20 otherwise. The value list has to be deleted by the code which called the method
:rtype: list of int
%End
virtual double getXMax() const;
/** Returns the smallest x-coordinate value of the bounding box*/
%Docstring
Returns the largest x-coordinate value of the bounding box
:rtype: float
%End
virtual double getXMin() const;
/** Returns the largest y-coordinate value of the bounding box*/
%Docstring
Returns the smallest x-coordinate value of the bounding box
:rtype: float
%End
virtual double getYMax() const;
/** Returns the smallest x-coordinate value of the bounding box*/
%Docstring
Returns the largest y-coordinate value of the bounding box
:rtype: float
%End
virtual double getYMin() const;
/** Returns the number of points*/
%Docstring
Returns the smallest x-coordinate value of the bounding box
:rtype: float
%End
virtual int getNumberOfPoints() const;
/** Sets the behavior of the triangulation in case of crossing forced lines*/
%Docstring
Returns the number of points
:rtype: int
%End
virtual void setForcedCrossBehavior( Triangulation::ForcedCrossBehavior b );
/** Sets the color of the normal edges*/
%Docstring
Sets the behavior of the triangulation in case of crossing forced lines
%End
virtual void setEdgeColor( int r, int g, int b );
/** Sets the color of the forced edges*/
%Docstring
Sets the color of the normal edges
%End
virtual void setForcedEdgeColor( int r, int g, int b );
/** Sets the color of the breaklines*/
%Docstring
Sets the color of the forced edges
%End
virtual void setBreakEdgeColor( int r, int g, int b );
/** Sets an interpolator object*/
void setTriangleInterpolator( TriangleInterpolator *interpolator );
/** Eliminates the horizontal triangles by swapping or by insertion of new points*/
void eliminateHorizontalTriangles();
/** Adds points to make the triangles better shaped (algorithm of ruppert)*/
%Docstring
Sets the color of the breaklines
%End
virtual void setTriangleInterpolator( TriangleInterpolator *interpolator );
%Docstring
Sets an interpolator object
%End
virtual void eliminateHorizontalTriangles();
%Docstring
Eliminates the horizontal triangles by swapping or by insertion of new points
%End
virtual void ruppertRefinement();
/** Returns true, if the point with coordinates x and y is inside the convex hull and false otherwise*/
bool pointInside( double x, double y );
/** Reads the dual edge structure of a taff file*/
//bool readFromTAFF(QString fileName);
/** Saves the dual edge structure to a taff file*/
//bool saveToTAFF(QString fileName) const;
/** Swaps the edge which is closest to the point with x and y coordinates (if this is possible)*/
%Docstring
Adds points to make the triangles better shaped (algorithm of ruppert)
%End
virtual bool pointInside( double x, double y );
%Docstring
Returns true, if the point with coordinates x and y is inside the convex hull and false otherwise
:rtype: bool
%End
virtual bool swapEdge( double x, double y );
/** Returns a value list with the numbers of the four points, which would be affected by an edge swap. This function is e.g. needed by NormVecDecorator to know the points, for which the normals have to be recalculated. The returned ValueList has to be deleted by the code which calls the method*/
%Docstring
Swaps the edge which is closest to the point with x and y coordinates (if this is possible)
:rtype: bool
%End
virtual QList<int> *getPointsAroundEdge( double x, double y );
/** Saves the triangulation as a (line) shapefile
@return true in case of success*/
%Docstring
Returns a value list with the numbers of the four points, which would be affected by an edge swap. This function is e.g. needed by NormVecDecorator to know the points, for which the normals have to be recalculated. The returned ValueList has to be deleted by the code which calls the method
:rtype: list of int
%End
virtual bool saveAsShapefile( const QString &fileName ) const;
%Docstring
Saves the triangulation as a (line) shapefile
:return: true in case of success*
:rtype: bool
%End
protected:
/** Inserts an edge and makes sure, everything is ok with the storage of the edge. The number of the HalfEdge is returned*/
unsigned int insertEdge( int dual, int next, int point, bool mbreak, bool forced );
/** Inserts a forced segment between the points with the numbers p1 and p2 into the triangulation and returns the number of a HalfEdge belonging to this forced edge or -100 in case of failure*/
%Docstring
Inserts an edge and makes sure, everything is ok with the storage of the edge. The number of the HalfEdge is returned
%End
int insertForcedSegment( int p1, int p2, bool breakline );
/** Threshold for the leftOfTest to handle numerical instabilities*/
//const static double leftOfTresh=0.00001;
/** Security to prevent endless loops in 'baseEdgeOfTriangle'. It there are more iteration then this number, the point will not be inserted*/
//const static int nBaseOfRuns;
/** Returns the number of an edge which points to the point with number 'point' or -1 if there is an error*/
%Docstring
Inserts a forced segment between the points with the numbers p1 and p2 into the triangulation and returns the number of a HalfEdge belonging to this forced edge or -100 in case of failure
:rtype: int
%End
int baseEdgeOfPoint( int point );
/** Returns the number of a HalfEdge from a triangle in which 'point' is in. If the number -10 is returned, this means, that 'point' is outside the convex hull. If -5 is returned, then numerical problems with the leftOfTest occurred (and the value of the possible edge is stored in the variable 'mUnstableEdge'. -20 means, that the inserted point is exactly on an edge (the number is stored in the variable 'mEdgeWithPoint'). -25 means, that the point is already in the triangulation (the number of the point is stored in the member 'mTwiceInsPoint'. If -100 is returned, this means that something else went wrong*/
%Docstring
Returns the number of an edge which points to the point with number 'point' or -1 if there is an error
:rtype: int
%End
int baseEdgeOfTriangle( QgsPoint *point );
/** Checks, if 'edge' has to be swapped because of the empty circle criterion. If so, doSwap(...) is called.*/
%Docstring
Returns the number of a HalfEdge from a triangle in which 'point' is in. If the number -10 is returned, this means, that 'point' is outside the convex hull. If -5 is returned, then numerical problems with the leftOfTest occurred (and the value of the possible edge is stored in the variable 'mUnstableEdge'. -20 means, that the inserted point is exactly on an edge (the number is stored in the variable 'mEdgeWithPoint'). -25 means, that the point is already in the triangulation (the number of the point is stored in the member 'mTwiceInsPoint'. If -100 is returned, this means that something else went wrong
:rtype: int
%End
bool checkSwap( unsigned int edge, unsigned int recursiveDeep );
/** Swaps 'edge' and test recursively for other swaps (delaunay criterion)*/
%Docstring
Checks, if 'edge' has to be swapped because of the empty circle criterion. If so, doSwap(...) is called.
:rtype: bool
%End
void doSwap( unsigned int edge, unsigned int recursiveDeep );
/** Swaps 'edge' and does no recursive testing*/
%Docstring
Swaps 'edge' and test recursively for other swaps (delaunay criterion)
%End
void doOnlySwap( unsigned int edge );
/** Returns true, if it is possible to swap an edge, otherwise false(concave quad or edge on (or outside) the convex hull)*/
%Docstring
Swaps 'edge' and does no recursiv testing
%End
bool swapPossible( unsigned int edge );
/** Divides a polygon in a triangle and two polygons and calls itself recursively for these two polygons. 'poly' is a pointer to a list with the numbers of the edges of the polygon, 'free' is a pointer to a list of free halfedges, and 'mainedge' is the number of the edge, towards which the new triangle is inserted. Mainedge has to be the same as poly->begin(), otherwise the recursion does not work*/
%Docstring
Returns true, if it is possible to swap an edge, otherwise false(concave quad or edge on (or outside) the convex hull)
:rtype: bool
%End
void triangulatePolygon( QList<int> *poly, QList<int> *free, int mainedge );
/** Tests, if the bounding box of the halfedge with index i intersects the specified bounding box. The main purpose for this method is the drawing of the triangulation*/
%Docstring
Divides a polygon in a triangle and two polygons and calls itself recursively for these two polygons. 'poly' is a pointer to a list with the numbers of the edges of the polygon, 'free' is a pointer to a list of free halfedges, and 'mainedge' is the number of the edge, towards which the new triangle is inserted. Mainedge has to be the same as poly->begin(), otherwise the recursion does not work
%End
bool halfEdgeBBoxTest( int edge, double xlowleft, double ylowleft, double xupright, double yupright ) const;
/** Calculates the minimum angle, which would be present, if the specified halfedge would be swapped*/
%Docstring
Tests, if the bounding box of the halfedge with index i intersects the specified bounding box. The main purpose for this method is the drawing of the triangulation
:rtype: bool
%End
double swapMinAngle( int edge ) const;
/** Inserts a new point on the halfedge with number 'edge'. The position can have a value from 0 to 1 (e.g. 0.5 would be in the middle). The return value is the number of the new inserted point. tin is the triangulation, which should be used to calculate the elevation of the inserted point*/
%Docstring
Calculates the minimum angle, which would be present, if the specified halfedge would be swapped
:rtype: float
%End
int splitHalfEdge( int edge, float position );
/** Returns true, if a half edge is on the convex hull and false otherwise*/
%Docstring
Inserts a new point on the halfedge with number 'edge'. The position can have a value from 0 to 1 (e.g. 0.5 would be in the middle). The return value is the number of the new inserted point. tin is the triangulation, which should be used to calculate the elevation of the inserted point
:rtype: int
%End
bool edgeOnConvexHull( int edge );
/** Function needed for the ruppert algorithm. Tests, if point is in the circle through both endpoints of edge and the endpoint of edge->dual->next->point. If so, the function calls itself recursively for edge->next and edge->next->next. Stops, if it finds a forced edge or a convex hull edge*/
%Docstring
Returns true, if a half edge is on the convex hull and false otherwise
:rtype: bool
%End
void evaluateInfluenceRegion( QgsPoint *point, int edge, QSet<int> &set );
%Docstring
Function needed for the ruppert algorithm. Tests, if point is in the circle through both endpoints of edge and the endpoint of edge->dual->next->point. If so, the function calls itself recursively for edge->next and edge->next->next. Stops, if it finds a forced edge or a convex hull edge
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/DualEdgeTriangulation.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

75
python/analysis/interpolation/HalfEdge.sip
View File

@ -1,32 +1,81 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/HalfEdge.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class HalfEdge
{
%TypeHeaderCode
#include <HalfEdge.h>
#include "HalfEdge.h"
%End
protected:
public:
/** Default constructor. Values for mDual, mNext, mPoint are set to -10 which means that they are undefined*/
HalfEdge();
%Docstring
Default constructor. Values for mDual, mNext, mPoint are set to -10 which means that they are undefined
%End
HalfEdge( int dual, int next, int point, bool mbreak, bool forced );
~HalfEdge();
/** Returns the number of the dual HalfEdge*/
int getDual() const;
/** Returns the number of the next HalfEdge*/
%Docstring
Returns the number of the dual HalfEdge
:rtype: int
%End
int getNext() const;
/** Returns the number of the point at which this HalfEdge points*/
%Docstring
Returns the number of the next HalfEdge
:rtype: int
%End
int getPoint() const;
/** Returns, whether the HalfEdge belongs to a break line or not*/
%Docstring
Returns the number of the point at which this HalfEdge points
:rtype: int
%End
bool getBreak() const;
/** Returns, whether the HalfEdge belongs to a constrained edge or not*/
%Docstring
Returns, whether the HalfEdge belongs to a break line or not
:rtype: bool
%End
bool getForced() const;
/** Sets the number of the dual HalfEdge*/
%Docstring
Returns, whether the HalfEdge belongs to a constrained edge or not
:rtype: bool
%End
void setDual( int d );
/** Sets the number of the next HalfEdge*/
%Docstring
Sets the number of the dual HalfEdge
%End
void setNext( int n );
/** Sets the number of point at which this HalfEdge points*/
%Docstring
Sets the number of the next HalfEdge
%End
void setPoint( int p );
/** Sets the break flag*/
%Docstring
Sets the number of point at which this HalfEdge points
%End
void setBreak( bool b );
/** Sets the forced flag*/
%Docstring
Sets the break flag
%End
void setForced( bool f );
%Docstring
Sets the forced flag
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/HalfEdge.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

78
python/analysis/interpolation/LinTriangleInterpolator.sip
View File

@ -1,28 +1,78 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/LinTriangleInterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class LinTriangleInterpolator : TriangleInterpolator
{
%Docstring
LinTriangleInterpolator is a class which interpolates linearly on a triangulation*
%End
%TypeHeaderCode
#include <LinTriangleInterpolator.h>
#include "LinTriangleInterpolator.h"
%End
public:
/** Default constructor*/
LinTriangleInterpolator();
/** Constructor with reference to a DualEdgeTriangulation object*/
%Docstring
Default constructor
%End
LinTriangleInterpolator( DualEdgeTriangulation *tin );
/** Destructor*/
%Docstring
Constructor with reference to a DualEdgeTriangulation object
%End
virtual ~LinTriangleInterpolator();
/** Calculates the normal vector and assigns it to vec*/
virtual bool calcNormVec( double x, double y, Vector3D *result );
/** Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point*/
virtual bool calcPoint( double x, double y, QgsPoint *result );
/** Returns a pointer to the current Triangulation object*/
virtual bool calcNormVec( double x, double y, Vector3D *result /Out/ );
%Docstring
Calculates the normal vector and assigns it to vec
:rtype: bool
%End
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ );
%Docstring
Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point
:rtype: bool
%End
virtual DualEdgeTriangulation *getTriangulation() const;
/** Sets a Triangulation*/
%Docstring
Returns a pointer to the current Triangulation object
:rtype: DualEdgeTriangulation
%End
virtual void setTriangulation( DualEdgeTriangulation *tin );
%Docstring
Sets a Triangulation
%End
protected:
/** Calculates the first derivative with respect to x for a linear surface and assigns it to vec*/
virtual bool calcFirstDerX( double x, double y, Vector3D *result );
/** Calculates the first derivative with respect to y for a linear surface and assigns it to vec*/
virtual bool calcFirstDerY( double x, double y, Vector3D *result );
virtual bool calcFirstDerX( double x, double y, Vector3D *result /Out/ );
%Docstring
Calculates the first derivative with respect to x for a linear surface and assigns it to vec
:rtype: bool
%End
virtual bool calcFirstDerY( double x, double y, Vector3D *result /Out/ );
%Docstring
Calculates the first derivative with respect to y for a linear surface and assigns it to vec
:rtype: bool
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/LinTriangleInterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

70
python/analysis/interpolation/Line3D.sip
View File

@ -1,25 +1,75 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Line3D.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class Line3D /NoDefaultCtors/
{
%TypeHeaderCode
#include <Line3D.h>
%Docstring
This class represents a line. It is implemented as a single directed linked list of nodes (with related QgsPoint objects). Attention: the points inserted in a line are not deleted from Line3D*
%End
%TypeHeaderCode
#include "Line3D.h"
%End
private:
Line3D( const Line3D & ) ;
private:
Line3D &operator=( const Line3D & ) ;
%Docstring
:rtype: Line3D
%End
protected:
public:
Line3D();
~Line3D();
/** Returns true, if the Line contains no QgsPoint, otherwise false*/
bool empty() const;
/** Inserts a node behind the current position and sets the current position to this new node*/
%Docstring
Returns true, if the Line contains no QgsPoint, otherwise false
:rtype: bool
%End
void insertPoint( QgsPoint *p );
/** Removes the point behind the current position*/
%Docstring
Inserts a node behind the current position and sets the current position to this new node
%End
void removePoint();
/** Gets the point at the current position*/
%Docstring
Removes the point behind the current position
%End
QgsPoint *getPoint() const;
/** Returns the current position*/
%Docstring
Gets the point at the current position
:rtype: QgsPoint
%End
unsigned int getCurrent() const;
/** Returns the size of the line (the numbero of inserted Nodes without 'head' and 'z'*/
%Docstring
Returns the current position
%End
unsigned int getSize() const;
/** Sets the current Node to head*/
%Docstring
Returns the size of the line (the numbero of inserted Nodes without 'head' and 'z'
%End
void goToBegin();
/** Goes to the next Node*/
%Docstring
Sets the current Node to head
%End
void goToNext();
%Docstring
Goes to the next Node
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Line3D.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

46
python/analysis/interpolation/Node.sip
View File

@ -1,20 +1,52 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Node.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class Node
{
%TypeHeaderCode
#include <Node.h>
%Docstring
Node is a class used by Line3D. It represents a node in the single directed linked list. Associated QgsPoint objects are deleted when the node is deleted.*
%End
%TypeHeaderCode
#include "Node.h"
%End
protected:
public:
Node();
Node( const Node &n );
~Node();
// Node &operator=( const Node &n );
/** Returns a pointer to the next element in the linked list*/
Node *getNext() const;
/** Returns a pointer to the QgsPoint object associated with the node*/
%Docstring
Returns a pointer to the next element in the linked list
:rtype: Node
%End
QgsPoint *getPoint() const;
/** Sets the pointer to the next node*/
%Docstring
Returns a pointer to the QgsPoint object associated with the node
:rtype: QgsPoint
%End
void setNext( Node *n );
/** Sets a new pointer to an associated QgsPoint object*/
%Docstring
Sets the pointer to the next node
%End
void setPoint( QgsPoint *p );
%Docstring
Sets a new pointer to an associated QgsPoint object
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Node.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

129
python/analysis/interpolation/NormVecDecorator.sip
View File

@ -1,48 +1,119 @@
class NormVecDecorator : TriDecorator
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/NormVecDecorator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class NormVecDecorator: TriDecorator
{
%TypeHeaderCode
#include <NormVecDecorator.h>
%Docstring
Decorator class which adds the functionality of estimating normals at the data points*
%End
%TypeHeaderCode
#include "NormVecDecorator.h"
%End
public:
//! Enumeration for the state of a point. Normal means, that the point is not on a BreakLine, BreakLine means that the point is on a breakline (but not an end point of it) and EndPoint means, that it is an endpoint of a breakline
enum PointState {Normal, BreakLine, EndPoint};
NormVecDecorator();
%Docstring
Enumeration for the state of a point. Normal means, that the point is not on a BreakLine, BreakLine means that the point is on a breakline (but not an end point of it) and EndPoint means, that it is an endpoint of a breakline.
%End
NormVecDecorator( Triangulation *tin );
virtual ~NormVecDecorator();
/** Adds a point to the triangulation*/
int addPoint( QgsPoint *p );
/** Calculates the normal at a point on the surface and assigns it to 'result'. Returns true in case of success and false in case of failure*/
bool calcNormal( double x, double y, Vector3D *result );
/** Calculates the normal of a triangle-point for the point with coordinates x and y. This is needed, if a point is on a break line and there is no unique normal stored in 'mNormVec'. Returns false, it something went wrong and true otherwise*/
bool calcNormalForPoint( double x, double y, int point, Vector3D *result );
/** Calculates x-, y and z-value of the point on the surface and assigns it to 'result'. Returns true in case of success and flase in case of failure*/
bool calcPoint( double x, double y, QgsPoint *result );
/** Eliminates the horizontal triangles by swapping or by insertion of new points. If alreadyestimated is true, a re-estimation of the normals will be done*/
virtual int addPoint( QgsPoint *p );
%Docstring
Adds a point to the triangulation
:rtype: int
%End
virtual bool calcNormal( double x, double y, Vector3D *result /Out/ );
%Docstring
Calculates the normal at a point on the surface and assigns it to 'result'. Returns true in case of success and false in case of failure
:rtype: bool
%End
bool calcNormalForPoint( double x, double y, int point, Vector3D *result /Out/ );
%Docstring
Calculates the normal of a triangle-point for the point with coordinates x and y. This is needed, if a point is on a break line and there is no unique normal stored in 'mNormVec'. Returns false, it something went wrong and true otherwise
:rtype: bool
%End
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ );
%Docstring
Calculates x-, y and z-value of the point on the surface and assigns it to 'result'. Returns true in case of success and flase in case of failure
:rtype: bool
%End
virtual void eliminateHorizontalTriangles();
/** Estimates the first derivative a point. Return true in case of succes and false otherwise*/
%Docstring
Eliminates the horizontal triangles by swapping or by insertion of new points. If alreadyestimated is true, a re-estimation of the normals will be done
%End
bool estimateFirstDerivative( int pointno );
/** This method adds the functionality of estimating normals at the data points. Return true in the case of success and false otherwise*/
%Docstring
Estimates the first derivative a point. Return true in case of succes and false otherwise
:rtype: bool
%End
bool estimateFirstDerivatives( QProgressDialog *d = 0 );
/** Returns a pointer to the normal vector for the point with the number n*/
%Docstring
This method adds the functionality of estimating normals at the data points. Return true in the case of success and false otherwise
:rtype: bool
%End
Vector3D *getNormal( int n ) const;
/** Finds out, in which triangle a point with coordinates x and y is and assigns the triangle points to p1, p2, p3 and the estimated normals to v1, v2, v3. The vectors are normally taken from 'mNormVec', except if p1, p2 or p3 is a point on a breakline. In this case, the normal is calculated on-the-fly. Returns false, if something went wrong and true otherwise*/
bool getTriangle( double x, double y, QgsPoint *p1 /Out/, Vector3D *v1 /Out/, QgsPoint *p2 /Out/, Vector3D *v2 /Out/, QgsPoint *p3 /Out/, Vector3D *v3 /Out/ );
/** This function behaves similar to the one above. Additionally, the numbers of the points are returned (ptn1, ptn2, ptn3) as well as the PointStates of the triangle points (state1, state2, state3)
* @note not available in Python bindings
*/
//bool getTriangle( double x, double y, QgsPoint *p1 /Out/, int *ptn1 /Out/, Vector3D *v1 /Out/, PointState *state1 /Out/, QgsPoint *p2 /Out/, int *ptn2 /Out/, Vector3D *v2 /Out/, PointState *state2 /Out/, QgsPoint *p3 /Out/, int *ptn3 /Out/, Vector3D *v3 /Out/, PointState *state3 /Out/);
/** Returns the state of the point with the number 'pointno'*/
%Docstring
Returns a pointer to the normal vector for the point with the number n
:rtype: Vector3D
%End
bool getTriangle( double x, double y, QgsPoint *p1 /Out/, Vector3D *v1 /Out/, QgsPoint *p2 /Out/, Vector3D *v2 /Out/, QgsPoint *p3 /Out/, Vector3D *v3 /Out/ ) /PyName=getTriangleVertices/;
%Docstring
Finds out, in which triangle a point with coordinates x and y is and assigns the triangle points to p1, p2, p3 and the estimated normals to v1, v2, v3. The vectors are normally taken from 'mNormVec', except if p1, p2 or p3 is a point on a breakline. In this case, the normal is calculated on-the-fly. Returns false, if something went wrong and true otherwise
:rtype: bool
%End
bool getTriangle( double x, double y, QgsPoint *p1 /Out/, int *ptn1 /Out/, Vector3D *v1 /Out/, PointState *state1 /Out/, QgsPoint *p2 /Out/, int *ptn2 /Out/, Vector3D *v2 /Out/, PointState *state2 /Out/, QgsPoint *p3 /Out/, int *ptn3 /Out/, Vector3D *v3 /Out/, PointState *state3 /Out/ );
%Docstring
This function behaves similar to the one above. Additionally, the numbers of the points are returned (ptn1, ptn2, ptn3) as well as the PointStates of the triangle points (state1, state2, state3)
:rtype: bool
%End
PointState getState( int pointno ) const;
/** Sets an interpolator*/
void setTriangleInterpolator( TriangleInterpolator *inter );
/** Swaps the edge which is closest to the point with x and y coordinates (if this is possible) and forces recalculation of the concerned normals (if alreadyestimated is true)*/
%Docstring
Returns the state of the point with the number 'pointno'
:rtype: PointState
%End
virtual void setTriangleInterpolator( TriangleInterpolator *inter );
%Docstring
Sets an interpolator
%End
virtual bool swapEdge( double x, double y );
/** Saves the triangulation as a (line) shapefile
@return true in case of success*/
%Docstring
Swaps the edge which is closest to the point with x and y coordinates (if this is possible) and forces recalculation of the concerned normals (if alreadyestimated is true)
:rtype: bool
%End
virtual bool saveAsShapefile( const QString &fileName ) const;
%Docstring
Saves the triangulation as a (line) shapefile
:return: true in case of success*
:rtype: bool
%End
protected:
/** Sets the state (BreakLine, Normal, EndPoint) of a point*/
void setState( int pointno, PointState s );
%Docstring
Sets the state (BreakLine, Normal, EndPoint) of a point
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/NormVecDecorator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

79
python/analysis/interpolation/ParametricLine.sip
View File

@ -1,29 +1,76 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/ParametricLine.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class ParametricLine
{
%TypeHeaderCode
#include <ParametricLine.h>
%Docstring
ParametricLine is an Interface for parametric lines. It is possible, that a parametric line is composed of several parametric
lines (see the composite pattern in Gamma et al. 'Design Patterns'). Do not build instances of it since it is an abstract class.*
%End
%TypeHeaderCode
#include "ParametricLine.h"
%End
protected:
public:
/** Default constructor*/
ParametricLine();
/** Constructor, par is a pointer to the parent object, controlpoly the controlpolygon
*/
ParametricLine( ParametricLine *par /Transfer/, QVector<QgsPoint*> *controlpoly );
/** Destructor*/
%Docstring
Default constructor
%End
ParametricLine( ParametricLine *par /Transfer/, QVector<QgsPoint *> *controlpoly );
%Docstring
Constructor, par is a pointer to the parent object, controlpoly the controlpolygon
%End
virtual ~ParametricLine();
virtual void add( ParametricLine *pl ) = 0;
virtual void calcFirstDer( float t, Vector3D *v ) = 0;
virtual void calcSecDer( float t, Vector3D *v ) = 0;
//virtual QgsPoint calcPoint(float t);
virtual void calcPoint( float t, QgsPoint* ) = 0;
virtual void add( ParametricLine *pl /Transfer/ ) = 0;
virtual void calcFirstDer( float t, Vector3D *v /Out/ ) = 0;
virtual void calcSecDer( float t, Vector3D *v /Out/ ) = 0;
virtual void calcPoint( float t, QgsPoint *p /Out/ ) = 0;
virtual void changeDirection() = 0;
//virtual void draw(QPainter *p);
virtual const QgsPoint *getControlPoint( int number ) const = 0;
virtual const QVector<QgsPoint*> *getControlPoly() const = 0;
%Docstring
:rtype: QgsPoint
%End
virtual const QVector<QgsPoint *> *getControlPoly() const = 0;
%Docstring
:rtype: list of QgsPoint
%End
virtual int getDegree() const = 0;
%Docstring
:rtype: int
%End
virtual ParametricLine *getParent() const = 0;
//virtual bool intersects(ParametricLine *pal);
%Docstring
:rtype: ParametricLine
%End
virtual void remove( int i ) = 0;
virtual void setControlPoly( QVector<QgsPoint*> *cp ) = 0;
virtual void setControlPoly( QVector<QgsPoint *> *cp ) = 0;
virtual void setParent( ParametricLine *paral ) = 0;
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/ParametricLine.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

46
python/analysis/interpolation/TriDecorator.sip
View File

@ -1,26 +1,45 @@
/** Decorator class for Triangulations (s. Decorator pattern in Gamma et al.)*/
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/TriDecorator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class TriDecorator : Triangulation
{
%TypeHeaderCode
#include <TriDecorator.h>
%Docstring
Decorator class for Triangulations (s. Decorator pattern in Gamma et al.)*
%End
%TypeHeaderCode
#include "TriDecorator.h"
%End
public:
TriDecorator();
explicit TriDecorator( Triangulation *t );
virtual ~TriDecorator();
virtual void addLine( Line3D *line, bool breakline );
virtual int addPoint( QgsPoint *p );
/** Adds an association to a triangulation*/
virtual void addTriangulation( Triangulation *t );
/** Performs a consistency check, remove this later*/
%Docstring
Adds an association to a triangulation
%End
virtual void performConsistencyTest();
virtual bool calcNormal( double x, double y, Vector3D *result );
virtual bool calcPoint( double x, double y, QgsPoint *result );
%Docstring
Performs a consistency check, remove this later
%End
virtual bool calcNormal( double x, double y, Vector3D *result /Out/ );
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ );
virtual QgsPoint *getPoint( unsigned int i ) const;
virtual int getNumberOfPoints() const;
bool getTriangle( double x, double y, QgsPoint *p1, int *n1 /Out/, QgsPoint *p2 /Out/, int *n2 /Out/, QgsPoint *p3 /Out/, int *n3 /Out/ );
bool getTriangle( double x, double y, QgsPoint *p1 /Out/, QgsPoint *p2 /Out/, QgsPoint *p3 /Out/ );
virtual bool getTriangle( double x, double y, QgsPoint *p1 /Out/, int *n1 /Out/, QgsPoint *p2 /Out/, int *n2 /Out/, QgsPoint *p3 /Out/, int *n3 /Out/ ) /PyName=getTriangleVertices/;
virtual bool getTriangle( double x, double y, QgsPoint *p1 /Out/, QgsPoint *p2 /Out/, QgsPoint *p3 /Out/ );
virtual int getOppositePoint( int p1, int p2 );
virtual QList<int> *getSurroundingTriangles( int pointno );
virtual double getXMax() const;
@ -37,5 +56,14 @@ class TriDecorator : Triangulation
virtual bool pointInside( double x, double y );
virtual bool swapEdge( double x, double y );
virtual QList<int> *getPointsAroundEdge( double x, double y );
protected:
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/TriDecorator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

47
python/analysis/interpolation/TriangleInterpolator.sip
View File

@ -1,12 +1,49 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/TriangleInterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class TriangleInterpolator
{
%Docstring
This is an interface for interpolator classes for triangulations*
%End
%TypeHeaderCode
#include <TriangleInterpolator.h>
#include "TriangleInterpolator.h"
%End
public:
virtual ~TriangleInterpolator();
/** Calculates the normal vector and assigns it to vec*/
virtual bool calcNormVec( double x, double y, Vector3D *result ) = 0;
/** Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point*/
virtual bool calcPoint( double x, double y, QgsPoint *result ) = 0;
virtual bool calcNormVec( double x, double y, Vector3D *result /Out/ ) = 0;
%Docstring
Calculates the normal vector and assigns it to vec
:rtype: bool
%End
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ ) = 0;
%Docstring
Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point
:rtype: bool
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/TriangleInterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

219
python/analysis/interpolation/Triangulation.sip
View File

@ -1,119 +1,202 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Triangulation.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class Triangulation
{
%TypeHeaderCode
#include <Triangulation.h>
%Docstring
Interface for Triangulation classes*
%End
%TypeHeaderCode
#include "Triangulation.h"
%End
public:
//! Enumeration describing the behavior, if two forced lines cross.
enum ForcedCrossBehavior
{
SnappingTypeVertex, //!< the second inserted forced line is snapped to the closest vertice of the first inserted forced line.
DeleteFirst, //!< the status of the first inserted forced line is reset to that of a normal edge (so that the second inserted forced line remain and the first not)
SnappingTypeVertex,
DeleteFirst,
InsertVertex
};
virtual ~Triangulation();
/**
* Adds a line (e.g. a break-, structure- or an isoline) to the triangulation.
* The class takes ownership of the line object and its points
*/
virtual void addLine( Line3D *line /Transfer/, bool breakline ) = 0;
%Docstring
Adds a line (e.g. a break-, structure- or an isoline) to the triangulation.
The class takes ownership of the line object and its points
%End
/**
* Adds a point to the triangulation
* Ownership is transferred to this class
*/
virtual int addPoint( QgsPoint *p ) = 0;
%Docstring
Adds a point to the triangulation
Ownership is transferred to this class
:rtype: int
%End
/**
* Calculates the normal at a point on the surface and assigns it to 'result'.
* @return true in case of success and false in case of failure
*/
virtual bool calcNormal( double x, double y, Vector3D *result ) = 0;
virtual bool calcNormal( double x, double y, Vector3D *result /Out/ ) = 0;
%Docstring
Calculates the normal at a point on the surface and assigns it to 'result'.
:return: true in case of success and false in case of failure
:rtype: bool
%End
/** Performs a consistency check, remove this later*/
virtual void performConsistencyTest() = 0;
%Docstring
Performs a consistency check, remove this later
%End
/**
* Calculates x-, y and z-value of the point on the surface and assigns it to 'result'.
* Returns true in case of success and flase in case of failure
*/
virtual bool calcPoint( double x, double y, QgsPoint *result ) = 0;
virtual bool calcPoint( double x, double y, QgsPoint *result /Out/ ) = 0;
%Docstring
Calculates x-, y and z-value of the point on the surface and assigns it to 'result'.
Returns true in case of success and flase in case of failure
:rtype: bool
%End
/** Returns a pointer to the point with number i. Any virtual points must have the number -1*/
virtual QgsPoint *getPoint( unsigned int i ) const = 0;
%Docstring
Returns a pointer to the point with number i. Any virtual points must have the number -1
:rtype: QgsPoint
%End
/** Finds out in which triangle the point with coordinates x and y is and
* assigns the numbers of the vertices to 'n1', 'n2' and 'n3' and the vertices to 'p1', 'p2' and 'p3'
*/
virtual bool getTriangle( double x, double y, QgsPoint *p1, int *n1 /Out/, QgsPoint *p2 /Out/, int *n2 /Out/, QgsPoint *p3 /Out/, int *n3 /Out/ ) = 0;
virtual bool getTriangle( double x, double y, QgsPoint *p1 /Out/, int *n1 /Out/, QgsPoint *p2 /Out/, int *n2 /Out/, QgsPoint *p3 /Out/, int *n3 /Out/ ) = 0 /PyName=getTriangleVertices/;
%Docstring
Finds out in which triangle the point with coordinates x and y is and
assigns the numbers of the vertices to 'n1', 'n2' and 'n3' and the vertices to 'p1', 'p2' and 'p3'
:rtype: bool
%End
/** Finds out, in which triangle the point with coordinates x and y is and assigns the points at the vertices to 'p1', 'p2' and 'p3*/
virtual bool getTriangle( double x, double y, QgsPoint *p1 /Out/, QgsPoint *p2 /Out/, QgsPoint *p3 /Out/ ) = 0;
%Docstring
Finds out, in which triangle the point with coordinates x and y is and assigns the points at the vertices to 'p1', 'p2' and 'p3
:rtype: bool
%End
/** Returns the number of the point opposite to the triangle points p1, p2 (which have to be on a halfedge)*/
virtual int getOppositePoint( int p1, int p2 ) = 0;
%Docstring
Returns the number of the point opposite to the triangle points p1, p2 (which have to be on a halfedge)
:rtype: int
%End
/** Returns the largest x-coordinate value of the bounding box*/
virtual double getXMax() const = 0;
%Docstring
Returns the largest x-coordinate value of the bounding box
:rtype: float
%End
/** Returns the smallest x-coordinate value of the bounding box*/
virtual double getXMin() const = 0;
%Docstring
Returns the smallest x-coordinate value of the bounding box
:rtype: float
%End
/** Returns the largest y-coordinate value of the bounding box*/
virtual double getYMax() const = 0;
%Docstring
Returns the largest y-coordinate value of the bounding box
:rtype: float
%End
/** Returns the smallest x-coordinate value of the bounding box*/
virtual double getYMin() const = 0;
%Docstring
Returns the smallest x-coordinate value of the bounding box
:rtype: float
%End
/** Returns the number of points*/
virtual int getNumberOfPoints() const = 0;
%Docstring
Returns the number of points
:rtype: int
%End
/**
* Returns a pointer to a value list with the information of the triangles surrounding (counterclockwise) a point.
* Four integer values describe a triangle, the first three are the number of the half edges of the triangle
* and the fourth is -10, if the third (and most counterclockwise) edge is a breakline, and -20 otherwise.
* The value list has to be deleted by the code which called the method.
* Any virtual point needs to have the number -1
*/
virtual QList<int> *getSurroundingTriangles( int pointno ) = 0;
%Docstring
Returns a pointer to a value list with the information of the triangles surrounding (counterclockwise) a point.
Four integer values describe a triangle, the first three are the number of the half edges of the triangle
and the fourth is -10, if the third (and most counterclockwise) edge is a breakline, and -20 otherwise.
The value list has to be deleted by the code which called the method.
Any virtual point needs to have the number -1
:rtype: list of int
%End
/** Returns a value list with the numbers of the four points, which would be affected by an edge swap.
* This function is e.g. needed by NormVecDecorator to know the points,
* for which the normals have to be recalculated.
* The list has to be deleted by the code which calls this method
*/
virtual QList<int> *getPointsAroundEdge( double x, double y ) = 0;
%Docstring
Returns a value list with the numbers of the four points, which would be affected by an edge swap.
This function is e.g. needed by NormVecDecorator to know the points,
for which the normals have to be recalculated.
The list has to be deleted by the code which calls this method
:rtype: list of int
%End
/** Draws the points, edges and the forced lines*/
//virtual void draw(QPainter *p, double xlowleft, double ylowleft, double xupright, double yupright, double width, double height) const=0;
/** Sets the behavior of the triangulation in case of crossing forced lines*/
virtual void setForcedCrossBehavior( Triangulation::ForcedCrossBehavior b ) = 0;
/** Sets the color of the normal edges*/
%Docstring
Sets the behavior of the triangulation in case of crossing forced lines
%End
virtual void setEdgeColor( int r, int g, int b ) = 0;
/** Sets the color of the forced edges*/
%Docstring
Sets the color of the normal edges
%End
virtual void setForcedEdgeColor( int r, int g, int b ) = 0;
/** Sets the color of the breaklines*/
%Docstring
Sets the color of the forced edges
%End
virtual void setBreakEdgeColor( int r, int g, int b ) = 0;
/** Sets an interpolator object*/
%Docstring
Sets the color of the breaklines
%End
virtual void setTriangleInterpolator( TriangleInterpolator *interpolator ) = 0;
/** Eliminates the horizontal triangles by swapping*/
%Docstring
Sets an interpolator object
%End
virtual void eliminateHorizontalTriangles() = 0;
/** Adds points to make the triangles better shaped (algorithm of ruppert)*/
%Docstring
Eliminates the horizontal triangles by swapping
%End
virtual void ruppertRefinement() = 0;
/** Returns true, if the point with coordinates x and y is inside the convex hull and false otherwise*/
%Docstring
Adds points to make the triangles better shaped (algorithm of ruppert)
%End
virtual bool pointInside( double x, double y ) = 0;
/** Reads the content of a taff-file*/
//virtual bool readFromTAFF(QString fileName)=0;
/** Saves the content to a taff file*/
//virtual bool saveToTAFF(QString fileName) const=0;
/** Swaps the edge which is closest to the point with x and y coordinates (if this is possible)*/
%Docstring
Returns true, if the point with coordinates x and y is inside the convex hull and false otherwise
:rtype: bool
%End
virtual bool swapEdge( double x, double y ) = 0;
/** Saves the triangulation as a (line) shapefile
@return true in case of success*/
%Docstring
Swaps the edge which is closest to the point with x and y coordinates (if this is possible)
:rtype: bool
%End
virtual bool saveAsShapefile( const QString &fileName ) const = 0;
%Docstring
Saves the triangulation as a (line) shapefile
:return: true in case of success
:rtype: bool
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Triangulation.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

87
python/analysis/interpolation/Vector3D.sip
View File

@ -1,35 +1,88 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Vector3D.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class Vector3D
{
%TypeHeaderCode
#include <Vector3D.h>
%Docstring
Class Vector3D represents a 3D-Vector, capable to store x-,y- and
z-coordinates in double values. In fact, the class is the same as QgsPoint.
The name 'vector' makes it easier to understand the programs.
%End
%TypeHeaderCode
#include "Vector3D.h"
%End
protected:
public:
/** Constructor taking the three components as arguments*/
Vector3D( double x, double y, double z );
/** Default constructor*/
%Docstring
Constructor taking the three components as arguments
%End
Vector3D();
/** Copy constructor*/
Vector3D( const Vector3D &v );
/** Destructor*/
~Vector3D();
// Vector3D &operator=( const Vector3D &v );
%Docstring
Default constructor
%End
bool operator==( const Vector3D &v ) const;
bool operator!=( const Vector3D &v ) const;
/** Returns the x-component of the vector*/
%Docstring
:rtype: bool
%End
double getX() const;
/** Returns the y-component of the vector*/
%Docstring
Returns the x-component of the vector
:rtype: float
%End
double getY() const;
/** Returns the z-component of the vector*/
%Docstring
Returns the y-component of the vector
:rtype: float
%End
double getZ() const;
/** Returns the length of the vector*/
%Docstring
Returns the z-component of the vector
:rtype: float
%End
double getLength() const;
/** Sets the x-component of the vector*/
%Docstring
Returns the length of the vector
:rtype: float
%End
void setX( double x );
/** Sets the y-component of the vector*/
%Docstring
Sets the x-component of the vector
%End
void setY( double y );
/** Sets the z-component of the vector*/
%Docstring
Sets the y-component of the vector
%End
void setZ( double z );
/** Standardises the vector*/
%Docstring
Sets the z-component of the vector
%End
void standardise();
%Docstring
Standardises the vector
%End
private:
Vector3D( const Vector3D &v );
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/Vector3D.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

36
python/analysis/interpolation/qgsgridfilewriter.sip
View File

@ -1,15 +1,39 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgsgridfilewriter.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class QgsGridFileWriter
{
%TypeHeaderCode
#include <qgsgridfilewriter.h>
%End
%TypeHeaderCode
#include "qgsgridfilewriter.h"
%End
public:
QgsGridFileWriter( QgsInterpolator *i, const QString &outputPath, const QgsRectangle &extent, int nCols, int nRows, double cellSizeX, double cellSizeY );
/** Writes the grid file.
@param showProgressDialog shows a dialog with the possibility to cancel
@return 0 in case of success*/
int writeFile( bool showProgressDialog = false );
%Docstring
Writes the grid file.
\param showProgressDialog shows a dialog with the possibility to cancel
:return: 0 in case of success*
:rtype: int
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgsgridfilewriter.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

40
python/analysis/interpolation/qgsidwinterpolator.sip
View File

@ -1,18 +1,42 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgsidwinterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class QgsIDWInterpolator: QgsInterpolator
{
%TypeHeaderCode
#include <qgsidwinterpolator.h>
#include "qgsidwinterpolator.h"
%End
public:
QgsIDWInterpolator( const QList<QgsInterpolator::LayerData> &layerData );
~QgsIDWInterpolator();
/** Calculates interpolation value for map coordinates x, y
@param x x-coordinate (in map units)
@param y y-coordinate (in map units)
@param result out: interpolation result
@return 0 in case of success*/
int interpolatePoint( double x, double y, double &result );
virtual int interpolatePoint( double x, double y, double &result );
%Docstring
Calculates interpolation value for map coordinates x, y
\param x x-coordinate (in map units)
\param y y-coordinate (in map units)
\param result out: interpolation result
:return: 0 in case of success*
:rtype: int
%End
void setDistanceCoefficient( double p );
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgsidwinterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

68
python/analysis/interpolation/qgsinterpolator.sip
View File

@ -1,14 +1,34 @@
/** Interface class for interpolations. Interpolators take
the vertices of a vector layer as base data. The z-Value
can be an attribute or the z-coordinates in case of 25D types*/
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgsinterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
struct vertexData
{
double x;
double y;
double z;
};
class QgsInterpolator
{
%Docstring
Interface class for interpolations. Interpolators take
the vertices of a vector layer as base data. The z-Value
can be an attribute or the z-coordinates in case of 25D types*
%End
%TypeHeaderCode
#include "qgsinterpolator.h"
%End
public:
/** Describes the type of input data*/
enum InputType
{
POINTS,
@ -16,7 +36,6 @@ class QgsInterpolator
BREAK_LINES
};
/** A layer together with the information about interpolation attribute / z-coordinate interpolation and the type (point, structure line, breakline)*/
struct LayerData
{
QgsVectorLayer *vectorLayer;
@ -29,19 +48,36 @@ class QgsInterpolator
virtual ~QgsInterpolator();
/** Calculates interpolation value for map coordinates x, y
@param x x-coordinate (in map units)
@param y y-coordinate (in map units)
@param result out: interpolation result
@return 0 in case of success*/
virtual int interpolatePoint( double x, double y, double &result ) = 0;
%Docstring
Calculates interpolation value for map coordinates x, y
\param x x-coordinate (in map units)
\param y y-coordinate (in map units)
\param result out: interpolation result
:return: 0 in case of success*
:rtype: int
%End
// @note not available in python bindings
// const QList<LayerData> &layerData() const;
protected:
/** Caches the vertex and value data from the provider. All the vertex data
will be held in virtual memory
@return 0 in case of success*/
int cacheBaseData();
%Docstring
Caches the vertex and value data from the provider. All the vertex data
will be held in virtual memory
:return: 0 in case of success*
:rtype: int
%End
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgsinterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

44
python/analysis/interpolation/qgstininterpolator.sip
View File

@ -1,10 +1,25 @@
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgstininterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/
class QgsTINInterpolator: QgsInterpolator
{
%Docstring
Interpolation in a triangular irregular network*
%End
%TypeHeaderCode
#include <qgstininterpolator.h>
#include "qgstininterpolator.h"
%End
public:
//describes the type of interpolation
enum TINInterpolation
{
Linear,
@ -13,13 +28,26 @@ class QgsTINInterpolator: QgsInterpolator
QgsTINInterpolator( const QList<QgsInterpolator::LayerData> &inputData, TINInterpolation interpolation = Linear, bool showProgressDialog = false );
~QgsTINInterpolator();
/** Calculates interpolation value for map coordinates x, y
@param x x-coordinate (in map units)
@param y y-coordinate (in map units)
@param result out: interpolation result
@return 0 in case of success*/
int interpolatePoint( double x, double y, double &result );
virtual int interpolatePoint( double x, double y, double &result );
%Docstring
Calculates interpolation value for map coordinates x, y
\param x x-coordinate (in map units)
\param y y-coordinate (in map units)
\param result out: interpolation result
:return: 0 in case of success*
:rtype: int
%End
void setExportTriangulationToFile( bool e );
void setTriangulationFilePath( const QString &filepath );
};
/************************************************************************
* This file has been generated automatically from *
* *
* src/analysis/interpolation/qgstininterpolator.h *
* *
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
************************************************************************/

17
python/auto_sip.blacklist
View File

@ -1,22 +1,5 @@
core/conversions.sip
core/qgsexception.sip
analysis/interpolation/Bezier3D.sip
analysis/interpolation/CloughTocherInterpolator.sip
analysis/interpolation/DualEdgeTriangulation.sip
analysis/interpolation/HalfEdge.sip
analysis/interpolation/LinTriangleInterpolator.sip
analysis/interpolation/Line3D.sip
analysis/interpolation/Node.sip
analysis/interpolation/NormVecDecorator.sip
analysis/interpolation/ParametricLine.sip
analysis/interpolation/TriangleInterpolator.sip
analysis/interpolation/Triangulation.sip
analysis/interpolation/TriDecorator.sip
analysis/interpolation/Vector3D.sip
analysis/interpolation/qgsgridfilewriter.sip
analysis/interpolation/qgsinterpolator.sip
analysis/interpolation/qgsidwinterpolator.sip
analysis/interpolation/qgstininterpolator.sip
server/qgsserverfilter.sip
server/qgsserverinterface.sip
server/qgsaccesscontrolfilter.sip

12
src/analysis/interpolation/Bezier3D.h
View File

@ -35,14 +35,14 @@ class ANALYSIS_EXPORT Bezier3D: public ParametricLine
virtual ~Bezier3D();
//! Do not use this method, since a Bezier curve does not consist of other curves
virtual void add( ParametricLine *pl ) override;
virtual void add( ParametricLine *pl SIP_TRANSFER ) override;
//! Calculates the first derivative and assigns it to v
virtual void calcFirstDer( float t, Vector3D *v ) override;
virtual void calcFirstDer( float t, Vector3D *v SIP_OUT ) override;
//! Calculates the second derivative and assigns it to v
virtual void calcSecDer( float t, Vector3D *v ) override;
virtual void calcSecDer( float t, Vector3D *v SIP_OUT ) override;
//virtual QgsPoint calcPoint(float t);
//! Calculates the point on the curve and assigns it to p
virtual void calcPoint( float t, QgsPoint *p ) override;
virtual void calcPoint( float t, QgsPoint *p SIP_OUT ) override;
//! Changes the order of control points
virtual void changeDirection() override;
//virtual void draw(QPainter* p);
@ -64,6 +64,8 @@ class ANALYSIS_EXPORT Bezier3D: public ParametricLine
};
#ifndef SIP_RUN
//-----------------------------------------------constructors, destructor and assignment operator------------------------------
inline Bezier3D::Bezier3D() : ParametricLine()//default constructor
@ -130,3 +132,5 @@ inline void Bezier3D::setControlPoly( QVector<QgsPoint *> *cp )
#endif
#endif

4
src/analysis/interpolation/CloughTocherInterpolator.h
View File

@ -84,9 +84,9 @@ class ANALYSIS_EXPORT CloughTocherInterpolator : public TriangleInterpolator
CloughTocherInterpolator( NormVecDecorator *tin );
virtual ~CloughTocherInterpolator();
//! Calculates the normal vector and assigns it to vec (not implemented at the moment)
virtual bool calcNormVec( double x, double y, Vector3D *result ) override;
virtual bool calcNormVec( double x, double y, Vector3D *result SIP_OUT ) override;
//! Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point
virtual bool calcPoint( double x, double y, QgsPoint *result ) override;
virtual bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) override;
virtual void setTriangulation( NormVecDecorator *tin );
};

12
src/analysis/interpolation/DualEdgeTriangulation.h
View File

@ -46,13 +46,13 @@ class ANALYSIS_EXPORT DualEdgeTriangulation: public Triangulation
//! Adds a line (e.g. a break-, structure- or an isoline) to the triangulation. The class takes ownership of the line object and its points
void addLine( Line3D *line SIP_TRANSFER, bool breakline ) override;
//! Adds a point to the triangulation and returns the number of this point in case of success or -100 in case of failure
int addPoint( QgsPoint *p ) override;
int addPoint( QgsPoint *p SIP_TRANSFER ) override;
//! Performs a consistency check, remove this later
virtual void performConsistencyTest() override;
//! Calculates the normal at a point on the surface
virtual bool calcNormal( double x, double y, Vector3D *result ) override;
virtual bool calcNormal( double x, double y, Vector3D *result SIP_OUT ) override;
//! Calculates x-, y and z-value of the point on the surface
virtual bool calcPoint( double x, double y, QgsPoint *result ) override;
virtual bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) override;
//! Draws the points, edges and the forced lines
//virtual void draw(QPainter* p, double xlowleft, double ylowleft, double xupright, double yupright, double width, double height) const;
//! Returns a pointer to the point with number i
@ -60,8 +60,7 @@ class ANALYSIS_EXPORT DualEdgeTriangulation: public Triangulation
//! Returns the number of the point opposite to the triangle points p1, p2 (which have to be on a halfedge)
int getOppositePoint( int p1, int p2 ) override;
//! Finds out, in which triangle the point with coordinates x and y is and assigns the numbers of the vertices to 'n1', 'n2' and 'n3' and the vertices to 'p1', 'p2' and 'p3'
//! \note not available in Python bindings
virtual bool getTriangle( double x, double y, QgsPoint *p1, int *n1, QgsPoint *p2, int *n2, QgsPoint *p3, int *n3 ) override SIP_SKIP;
virtual bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, int *n1 SIP_OUT, QgsPoint *p2 SIP_OUT, int *n2 SIP_OUT, QgsPoint *p3 SIP_OUT, int *n3 SIP_OUT ) SIP_PYNAME( getTriangleVertices ) override;
//! Finds out, in which triangle the point with coordinates x and y is and assigns addresses to the points at the vertices to 'p1', 'p2' and 'p3
virtual bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, QgsPoint *p2 SIP_OUT, QgsPoint *p3 SIP_OUT ) override;
//! Returns a pointer to a value list with the information of the triangles surrounding (counterclockwise) a point. Four integer values describe a triangle, the first three are the number of the half edges of the triangle and the fourth is -10, if the third (and most counterclockwise) edge is a breakline, and -20 otherwise. The value list has to be deleted by the code which called the method
@ -178,6 +177,8 @@ class ANALYSIS_EXPORT DualEdgeTriangulation: public Triangulation
void evaluateInfluenceRegion( QgsPoint *point, int edge, QSet<int> &set );
};
#ifndef SIP_RUN
inline DualEdgeTriangulation::DualEdgeTriangulation()
: xMax( 0 )
, xMin( 0 )
@ -245,6 +246,7 @@ inline bool DualEdgeTriangulation::halfEdgeBBoxTest( int edge, double xlowleft,
}
#endif
#endif

5
src/analysis/interpolation/HalfEdge.h
View File

@ -63,6 +63,9 @@ class ANALYSIS_EXPORT HalfEdge
void setForced( bool f );
};
#ifndef SIP_RUN
inline HalfEdge::HalfEdge(): mDual( -10 ), mNext( -10 ), mPoint( -10 ), mBreak( false ), mForced( false )
{
@ -124,3 +127,5 @@ inline void HalfEdge::setForced( bool f )
}
#endif
#endif

11
src/analysis/interpolation/LinTriangleInterpolator.h
View File

@ -32,9 +32,9 @@ class ANALYSIS_EXPORT LinTriangleInterpolator : public TriangleInterpolator
LinTriangleInterpolator( DualEdgeTriangulation *tin );
virtual ~LinTriangleInterpolator();
//! Calculates the normal vector and assigns it to vec
virtual bool calcNormVec( double x, double y, Vector3D *result ) override;
virtual bool calcNormVec( double x, double y, Vector3D *result SIP_OUT ) override;
//! Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point
virtual bool calcPoint( double x, double y, QgsPoint *result ) override;
virtual bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) override;
//! Returns a pointer to the current Triangulation object
virtual DualEdgeTriangulation *getTriangulation() const;
//! Sets a Triangulation
@ -44,11 +44,13 @@ class ANALYSIS_EXPORT LinTriangleInterpolator : public TriangleInterpolator
protected:
DualEdgeTriangulation *mTIN = nullptr;
//! Calculates the first derivative with respect to x for a linear surface and assigns it to vec
virtual bool calcFirstDerX( double x, double y, Vector3D *result );
virtual bool calcFirstDerX( double x, double y, Vector3D *result SIP_OUT );
//! Calculates the first derivative with respect to y for a linear surface and assigns it to vec
virtual bool calcFirstDerY( double x, double y, Vector3D *result );
virtual bool calcFirstDerY( double x, double y, Vector3D *result SIP_OUT );
};
#ifndef SIP_RUN
inline LinTriangleInterpolator::LinTriangleInterpolator()
: mTIN( nullptr )
{
@ -76,6 +78,7 @@ inline void LinTriangleInterpolator::setTriangulation( DualEdgeTriangulation *ti
}
#endif
#endif

10
src/analysis/interpolation/Line3D.h
View File

@ -19,16 +19,17 @@
#include "Node.h"
#include "qgis_analysis.h"
#include "qgis_sip.h"
/** \ingroup analysis
* This class represents a line. It is implemented as a single directed linked list of nodes (with related QgsPoint objects). Attention: the points inserted in a line are not deleted from Line3D*/
class ANALYSIS_EXPORT Line3D
class ANALYSIS_EXPORT Line3D SIP_NODEFAULTCTORS
{
private:
//! Copy constructor, declared private to not use it
Line3D( const Line3D & );
Line3D( const Line3D & ) SIP_FORCE;
//! Assignment operator, declared private to not use it
Line3D &operator=( const Line3D & );
Line3D &operator=( const Line3D & ) SIP_FORCE;
protected:
Node *head = nullptr;
Node *z = nullptr;
@ -57,6 +58,8 @@ class ANALYSIS_EXPORT Line3D
void goToNext();
};
#ifndef SIP_RUN
inline Line3D::Line3D( const Line3D & )
{
@ -83,3 +86,4 @@ inline unsigned int Line3D::getSize() const
}
#endif
#endif

4
src/analysis/interpolation/Node.h
View File

@ -44,6 +44,9 @@ class ANALYSIS_EXPORT Node
void setPoint( QgsPoint *p );
};
#ifndef SIP_RUN
inline Node::Node()
: mPoint( nullptr )
, mNext( nullptr )
@ -77,3 +80,4 @@ inline void Node::setPoint( QgsPoint *p )
}
#endif
#endif

19
src/analysis/interpolation/NormVecDecorator.h
View File

@ -40,11 +40,11 @@ class ANALYSIS_EXPORT NormVecDecorator: public TriDecorator
//! Adds a point to the triangulation
int addPoint( QgsPoint *p ) override;
//! Calculates the normal at a point on the surface and assigns it to 'result'. Returns true in case of success and false in case of failure
bool calcNormal( double x, double y, Vector3D *result ) override;
bool calcNormal( double x, double y, Vector3D *result SIP_OUT ) override;
//! Calculates the normal of a triangle-point for the point with coordinates x and y. This is needed, if a point is on a break line and there is no unique normal stored in 'mNormVec'. Returns false, it something went wrong and true otherwise
bool calcNormalForPoint( double x, double y, int point, Vector3D *result );
bool calcNormalForPoint( double x, double y, int point, Vector3D *result SIP_OUT );
//! Calculates x-, y and z-value of the point on the surface and assigns it to 'result'. Returns true in case of success and flase in case of failure
bool calcPoint( double x, double y, QgsPoint *result ) override;
bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) override;
//! Eliminates the horizontal triangles by swapping or by insertion of new points. If alreadyestimated is true, a re-estimation of the normals will be done
virtual void eliminateHorizontalTriangles() override;
//! Estimates the first derivative a point. Return true in case of succes and false otherwise
@ -54,12 +54,9 @@ class ANALYSIS_EXPORT NormVecDecorator: public TriDecorator
//! Returns a pointer to the normal vector for the point with the number n
Vector3D *getNormal( int n ) const;
//! Finds out, in which triangle a point with coordinates x and y is and assigns the triangle points to p1, p2, p3 and the estimated normals to v1, v2, v3. The vectors are normally taken from 'mNormVec', except if p1, p2 or p3 is a point on a breakline. In this case, the normal is calculated on-the-fly. Returns false, if something went wrong and true otherwise
bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, Vector3D *v1 SIP_OUT, QgsPoint *p2 SIP_OUT, Vector3D *v2 SIP_OUT, QgsPoint *p3 SIP_OUT, Vector3D *v3 SIP_OUT );
/** This function behaves similar to the one above. Additionally, the numbers of the points are returned (ptn1, ptn2, ptn3) as well as the PointStates of the triangle points (state1, state2, state3)
* \note not available in Python bindings
*/
bool getTriangle( double x, double y, QgsPoint *p1, int *ptn1, Vector3D *v1, PointState *state1, QgsPoint *p2, int *ptn2, Vector3D *v2, PointState *state2, QgsPoint *p3, int *ptn3, Vector3D *v3, PointState *state3 ) SIP_SKIP;
bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, Vector3D *v1 SIP_OUT, QgsPoint *p2 SIP_OUT, Vector3D *v2 SIP_OUT, QgsPoint *p3 SIP_OUT, Vector3D *v3 SIP_OUT ) SIP_PYNAME( getTriangleVertices );
//! This function behaves similar to the one above. Additionally, the numbers of the points are returned (ptn1, ptn2, ptn3) as well as the PointStates of the triangle points (state1, state2, state3)
bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, int *ptn1 SIP_OUT, Vector3D *v1 SIP_OUT, PointState *state1 SIP_OUT, QgsPoint *p2 SIP_OUT, int *ptn2 SIP_OUT, Vector3D *v2 SIP_OUT, PointState *state2 SIP_OUT, QgsPoint *p3 SIP_OUT, int *ptn3 SIP_OUT, Vector3D *v3 SIP_OUT, PointState *state3 SIP_OUT );
//! Returns the state of the point with the number 'pointno'
PointState getState( int pointno ) const;
//! Sets an interpolator
@ -85,6 +82,8 @@ class ANALYSIS_EXPORT NormVecDecorator: public TriDecorator
void setState( int pointno, PointState s );
};
#ifndef SIP_RUN
inline NormVecDecorator::NormVecDecorator(): TriDecorator(), mInterpolator( nullptr ), mNormVec( new QVector<Vector3D*>( DEFAULT_STORAGE_FOR_NORMALS ) ), mPointState( new QVector<PointState>( DEFAULT_STORAGE_FOR_NORMALS ) )
{
alreadyestimated = false;
@ -114,3 +113,5 @@ inline Vector3D *NormVecDecorator::getNormal( int n ) const
}
#endif
#endif

15
src/analysis/interpolation/ParametricLine.h
View File

@ -20,6 +20,7 @@
#include "qgspoint.h"
#include <QVector>
#include "qgis_analysis.h"
#include "qgis_sip.h"
class Vector3D;
@ -41,13 +42,13 @@ class ANALYSIS_EXPORT ParametricLine
/** Constructor, par is a pointer to the parent object, controlpoly the controlpolygon
*/
ParametricLine( ParametricLine *par, QVector<QgsPoint *> *controlpoly );
ParametricLine( ParametricLine *par SIP_TRANSFER, QVector<QgsPoint *> *controlpoly );
virtual ~ParametricLine();
virtual void add( ParametricLine *pl ) = 0;
virtual void calcFirstDer( float t, Vector3D *v ) = 0;
virtual void calcSecDer( float t, Vector3D *v ) = 0;
virtual void add( ParametricLine *pl SIP_TRANSFER ) = 0;
virtual void calcFirstDer( float t, Vector3D *v SIP_OUT ) = 0;
virtual void calcSecDer( float t, Vector3D *v SIP_OUT ) = 0;
//virtual QgsPoint calcPoint(float t);
virtual void calcPoint( float t, QgsPoint * ) = 0;
virtual void calcPoint( float t, QgsPoint *p SIP_OUT ) = 0;
virtual void changeDirection() = 0;
//virtual void draw(QPainter* p);
virtual const QgsPoint *getControlPoint( int number ) const = 0;
@ -60,6 +61,8 @@ class ANALYSIS_EXPORT ParametricLine
virtual void setParent( ParametricLine *paral ) = 0;
};
#ifndef SIP_RUN
//-----------------------------------------constructors and destructor----------------------
inline ParametricLine::ParametricLine()
@ -85,6 +88,8 @@ inline ParametricLine::~ParametricLine()
#endif
#endif

9
src/analysis/interpolation/TriDecorator.h
View File

@ -35,11 +35,11 @@ class ANALYSIS_EXPORT TriDecorator : public Triangulation
virtual void addTriangulation( Triangulation *t );
//! Performs a consistency check, remove this later
virtual void performConsistencyTest() override;
virtual bool calcNormal( double x, double y, Vector3D *result ) override;
virtual bool calcPoint( double x, double y, QgsPoint *result ) override;
virtual bool calcNormal( double x, double y, Vector3D *result SIP_OUT ) override;
virtual bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) override;
virtual QgsPoint *getPoint( unsigned int i ) const override;
virtual int getNumberOfPoints() const override;
bool getTriangle( double x, double y, QgsPoint *p1, int *n1 SIP_OUT, QgsPoint *p2 SIP_OUT, int *n2 SIP_OUT, QgsPoint *p3 SIP_OUT, int *n3 SIP_OUT ) override;
bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, int *n1 SIP_OUT, QgsPoint *p2 SIP_OUT, int *n2 SIP_OUT, QgsPoint *p3 SIP_OUT, int *n3 SIP_OUT ) SIP_PYNAME( getTriangleVertices ) override;
bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, QgsPoint *p2 SIP_OUT, QgsPoint *p3 SIP_OUT ) override;
virtual int getOppositePoint( int p1, int p2 ) override;
virtual QList<int> *getSurroundingTriangles( int pointno ) override;
@ -62,6 +62,8 @@ class ANALYSIS_EXPORT TriDecorator : public Triangulation
Triangulation *mTIN = nullptr;
};
#ifndef SIP_RUN
inline TriDecorator::TriDecorator(): mTIN( nullptr )
{
@ -83,4 +85,5 @@ inline void TriDecorator::addTriangulation( Triangulation *t )
}
#endif
#endif

4
src/analysis/interpolation/TriangleInterpolator.h
View File

@ -28,9 +28,9 @@ class ANALYSIS_EXPORT TriangleInterpolator
public:
virtual ~TriangleInterpolator() = default;
//! Calculates the normal vector and assigns it to vec
virtual bool calcNormVec( double x, double y, Vector3D *result ) = 0;
virtual bool calcNormVec( double x, double y, Vector3D *result SIP_OUT ) = 0;
//! Performs a linear interpolation in a triangle and assigns the x-,y- and z-coordinates to point
virtual bool calcPoint( double x, double y, QgsPoint *result ) = 0;
virtual bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) = 0;
};
#endif

9
src/analysis/interpolation/Triangulation.h
View File

@ -55,7 +55,7 @@ class ANALYSIS_EXPORT Triangulation
* Calculates the normal at a point on the surface and assigns it to 'result'.
* \returns true in case of success and false in case of failure
*/
virtual bool calcNormal( double x, double y, Vector3D *result ) = 0;
virtual bool calcNormal( double x, double y, Vector3D *result SIP_OUT ) = 0;
//! Performs a consistency check, remove this later
virtual void performConsistencyTest() = 0;
@ -64,7 +64,7 @@ class ANALYSIS_EXPORT Triangulation
* Calculates x-, y and z-value of the point on the surface and assigns it to 'result'.
* Returns true in case of success and flase in case of failure
*/
virtual bool calcPoint( double x, double y, QgsPoint *result ) = 0;
virtual bool calcPoint( double x, double y, QgsPoint *result SIP_OUT ) = 0;
//! Returns a pointer to the point with number i. Any virtual points must have the number -1
virtual QgsPoint *getPoint( unsigned int i ) const = 0;
@ -72,7 +72,7 @@ class ANALYSIS_EXPORT Triangulation
/** Finds out in which triangle the point with coordinates x and y is and
* assigns the numbers of the vertices to 'n1', 'n2' and 'n3' and the vertices to 'p1', 'p2' and 'p3'
*/
virtual bool getTriangle( double x, double y, QgsPoint *p1, int *n1 SIP_OUT, QgsPoint *p2 SIP_OUT, int *n2 SIP_OUT, QgsPoint *p3 SIP_OUT, int *n3 SIP_OUT ) = 0;
virtual bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, int *n1 SIP_OUT, QgsPoint *p2 SIP_OUT, int *n2 SIP_OUT, QgsPoint *p3 SIP_OUT, int *n3 SIP_OUT ) = 0 SIP_PYNAME( getTriangleVertices );
//! Finds out, in which triangle the point with coordinates x and y is and assigns the points at the vertices to 'p1', 'p2' and 'p3
virtual bool getTriangle( double x, double y, QgsPoint *p1 SIP_OUT, QgsPoint *p2 SIP_OUT, QgsPoint *p3 SIP_OUT ) = 0;
@ -154,9 +154,10 @@ class ANALYSIS_EXPORT Triangulation
virtual bool saveAsShapefile( const QString &fileName ) const = 0;
};
#ifndef SIP_RUN
inline Triangulation::~Triangulation()
{
}
#endif
#endif

8
src/analysis/interpolation/Vector3D.h
View File

@ -60,8 +60,15 @@ class ANALYSIS_EXPORT Vector3D
void setZ( double z );
//! Standardises the vector
void standardise();
private:
#ifdef SIP_RUN
Vector3D( const Vector3D &v );
#endif
};
#ifndef SIP_RUN
//------------------------------------------constructors------------------------------------
inline Vector3D::Vector3D( double x, double y, double z )
@ -113,3 +120,4 @@ inline void Vector3D::setZ( double z )
}
#endif
#endif

2
src/analysis/interpolation/qgsidwinterpolator.h
View File

@ -27,7 +27,7 @@
class ANALYSIS_EXPORT QgsIDWInterpolator: public QgsInterpolator
{
public:
QgsIDWInterpolator( const QList<LayerData> &layerData );
QgsIDWInterpolator( const QList<QgsInterpolator::LayerData> &layerData );
/** Calculates interpolation value for map coordinates x, y
\param x x-coordinate (in map units)

4
src/analysis/interpolation/qgsinterpolator.h
View File

@ -53,10 +53,10 @@ class ANALYSIS_EXPORT QgsInterpolator
QgsVectorLayer *vectorLayer = nullptr;
bool zCoordInterpolation;
int interpolationAttribute;
InputType mInputType;
QgsInterpolator::InputType mInputType;
};
QgsInterpolator( const QList<LayerData> &layerData );
QgsInterpolator( const QList<QgsInterpolator::LayerData> &layerData );
virtual ~QgsInterpolator() = default;

2
src/analysis/interpolation/qgstininterpolator.h
View File

@ -37,7 +37,7 @@ class ANALYSIS_EXPORT QgsTINInterpolator: public QgsInterpolator
Linear,
CloughTocher
};
QgsTINInterpolator( const QList<LayerData> &inputData, TINInterpolation interpolation = Linear, bool showProgressDialog = false );
QgsTINInterpolator( const QList<QgsInterpolator::LayerData> &inputData, TINInterpolation interpolation = Linear, bool showProgressDialog = false );
~QgsTINInterpolator();
/** Calculates interpolation value for map coordinates x, y

8
tests/code_layout/acceptable_missing_doc.py
View File

@ -256,7 +256,7 @@ ACCEPTABLE_MISSING_DOCS = {
"QgsSymbolRenderContext": ["renderContext() const ", "setMapUnitScale(const QgsMapUnitScale &scale)", "renderContext()", "outputUnit() const ", "outputLineWidth(double width) const ", "outputPixelSize(double size) const ", "selected() const ", "setRenderHints(int hints)", "QgsSymbolRenderContext(QgsRenderContext &c, QgsSymbol::OutputUnit u, qreal alpha=1.0, bool selected=false, int renderHints=0, const QgsFeature *f=nullptr, const QgsFields *fields=nullptr, const QgsMapUnitScale &mapUnitScale=QgsMapUnitScale())", "setSelected(bool selected)", "setOutputUnit(QgsSymbol::OutputUnit u)", "setFeature(const QgsFeature *f)", "renderHints() const ", "mapUnitScale() const "],
"QgsIdentifyMenu": ["MenuLevel", "execWithSingleResult()", "allowMultipleReturn()", "resultsIfExternalAction()", "showFeatureActions()", "maxFeatureDisplay()", "maxLayerDisplay()"],
"QgsPointLocator_VisitorNearestEdge": ["QgsPointLocator_VisitorNearestEdge(QgsPointLocator *pl, QgsPointLocator::Match &m, const QgsPointXY &srcPoint, QgsPointLocator::MatchFilter *filter=nullptr)"],
"ParametricLine": ["getControlPoint(int number) const =0", "getDegree() const =0", "calcPoint(float t, QgsPoint *)=0", "calcFirstDer(float t, Vector3D *v)=0", "remove(int i)=0", "setParent(ParametricLine *paral)=0", "calcSecDer(float t, Vector3D *v)=0", "getParent() const =0", "changeDirection()=0", "add(ParametricLine *pl)=0", "getControlPoly() const =0", "setControlPoly(QVector< QgsPoint * > *cp)=0"],
"ParametricLine": ["getControlPoint(int number) const =0", "getDegree() const =0", "calcPoint(float t, QgsPoint *p)=0", "calcFirstDer(float t, Vector3D *v)=0", "remove(int i)=0", "setParent(ParametricLine *paral)=0", "calcSecDer(float t, Vector3D *v)=0", "getParent() const =0", "changeDirection()=0", "add(ParametricLine *pl)=0", "getControlPoly() const =0", "setControlPoly(QVector< QgsPoint * > *cp)=0"],
"QgsComposerAttributeTable": ["QgsComposerAttributeTable(QgsComposition *composition)"],
"QgisInterface": ["helpToolBar()=0", "actionToggleFullScreen()=0", "newLayerMenu()=0", "actionNodeTool()=0", "actionCopyFeatures()=0", "actionNewProject()=0", "actionNewVectorLayer()=0", "actionCancelEdits()=0", "actionSplitParts()=0", "actionShowComposerManager()=0", "actionHelpContents()=0", "actionOpenFieldCalculator()=0", "actionSaveProjectAs()=0", "actionLayerProperties()=0", "helpMenu()=0", "actionSimplifyFeature()=0", "actionAddAllToOverview()=0", "databaseMenu()=0", "actionCheckQgisVersion()=0", "actionSaveProject()=0", "actionCancelAllEdits()=0", "layerTreeView()=0", "advancedDigitizeToolBar()=0", "actionAbout()=0", "webMenu()=0", "actionDuplicateLayer()=0", "actionShowPythonDialog()=0", "vectorToolBar()=0", "actionPasteFeatures()=0", "actionPrintComposer()=0", "actionSplitFeatures()=0", "actionPluginListSeparator()=0", "pluginManagerInterface()=0", "actionRemoveAllFromOverview()=0", "digitizeToolBar()=0", "actionSaveActiveLayerEdits()=0", "firstRightStandardMenu()=0", "projectMenu()=0", "actionProjectProperties()=0", "actionCopyLayerStyle()=0", "actionAllEdits()=0", "actionAddOgrLayer()=0", "actionDeleteRing()=0", "actionAddWmsLayer()=0", "settingsMenu()=0", "actionAddRing()=0", "fileToolBar()=0", "editMenu()=0", "pluginMenu()=0", "mapNavToolToolBar()=0", "vectorMenu()=0", "actionCutFeatures()=0", "actionSaveMapAsImage()=0", "actionMoveFeature()=0", "windowMenu()=0", "actionShowSelectedLayers()=0", "actionDeleteSelected()=0", "actionOptions()=0", "layerToolBar()=0", "actionDeletePart()=0", "actionAddPgLayer()=0", "databaseToolBar()=0", "actionRollbackAllEdits()=0", "actionShowAllLayers()=0", "viewMenu()=0", "actionRollbackEdits()=0", "actionSaveAllEdits()=0", "actionPasteLayerStyle()=0", "actionQgisHomePage()=0", "attributesToolBar()=0", "actionExit()=0", "rasterToolBar()=0", "actionHideAllLayers()=0", "actionAddToOverview()=0", "layerMenu()=0", "actionToggleEditing()=0", "actionLayerSaveAs()=0", "actionManagePlugins()=0", "actionCustomProjection()=0", "rasterMenu()=0", "actionAddPart()=0", "pluginToolBar()=0", "actionRemoveLayer()=0", "actionOpenTable()=0", "actionSaveEdits()=0", "actionOpenProject()=0", "webToolBar()=0", "actionAddFeature()=0", "actionHideSelectedLayers()=0", "actionAddRasterLayer()=0"],
"QgsCollapsibleGroupBoxBasic": ["QgsCollapsibleGroupBoxBasic(const QString &title, QWidget *parent=nullptr)", "checkToggled(bool ckd)", "QgsCollapsibleGroupBoxBasic(QWidget *parent=nullptr)", "init()", "clearModifiers()", "titleRect() const ", "checkClicked(bool ckd)", "updateStyle()", "toggleCollapsed()"],
@ -539,7 +539,7 @@ ACCEPTABLE_MISSING_DOCS = {
"QgsOWSSourceSelect": ["addWMSListRow(const QDomElement &item, int row)", "connectionsChanged()", "addRasterLayer(const QString &rasterLayerPath, const QString &baseName, const QString &providerKey)", "searchFinished()", "enableLayersForCrs(QTreeWidgetItem *item)", "addWMSListItem(const QDomElement &el, int row, int column)"],
"QgsSmartGroupCondition": ["removed(int)", "QgsSmartGroupCondition(int id, QWidget *parent=nullptr)", "destruct()"],
"QgsDataDefinedSizeDialog": ["QgsDataDefinedSizeDialog(const QList< QgsSymbol * > &symbolList, QgsVectorLayer *layer)"],
"QgsIDWInterpolator": ["QgsIDWInterpolator(const QList< LayerData > &layerData)", "setDistanceCoefficient(double p)"],
"QgsIDWInterpolator": ["QgsIDWInterpolator(const QList< QgsInterpolator::LayerData > &layerData)", "setDistanceCoefficient(double p)"],
"QgsRasterHistogram": ["None"],
"QgsDial": ["setSingleStep(const QVariant &step)", "variantValue() const ", "valueChanged(int)", "setMinimum(const QVariant &min)", "valueChanged(const QVariant &)", "setValue(const QVariant &value)", "setMaximum(const QVariant &max)", "QgsDial(QWidget *parent=nullptr)"],
"QgsExpressionItem": ["QgsExpressionItem(const QString &label, const QString &expressionText, const QString &helpText, QgsExpressionItem::ItemType itemType=ExpressionNode)", "QgsExpressionItem(const QString &label, const QString &expressionText, QgsExpressionItem::ItemType itemType=ExpressionNode)", "ItemType", "getExpressionText() const "],
@ -666,7 +666,7 @@ ACCEPTABLE_MISSING_DOCS = {
"QgsGeometryCache": ["cachedGeometries()", "cachedGeometriesRect()", "setCachedGeometriesRect(const QgsRectangle &extent)"],
"QgsAuthCertInfo": ["QgsAuthCertInfo(const QSslCertificate &cert, bool manageCertTrust=false, QWidget *parent=0, const QList< QSslCertificate > &connectionCAs=QList< QSslCertificate >())", "trustCacheRebuilt()"],
"QgsExpressionBuilderWidget": ["loadRecent(const QString &key)", "QgsExpressionBuilderWidget(QWidget *parent)", "isExpressionValid()", "saveToRecent(const QString &key)", "loadFieldNames(const QgsFields &fields)", "showEvent(QShowEvent *e)"],
"QgsTINInterpolator": ["setExportTriangulationToFile(bool e)", "TINInterpolation", "setTriangulationFilePath(const QString &filepath)", "QgsTINInterpolator(const QList< LayerData > &inputData, TINInterpolation interpolation=Linear, bool showProgressDialog=false)"],
"QgsTINInterpolator": ["setExportTriangulationToFile(bool e)", "TINInterpolation", "setTriangulationFilePath(const QString &filepath)", "QgsTINInterpolator(const QList< QgsInterpolator::LayerData > &inputData, TINInterpolation interpolation=Linear, bool showProgressDialog=false)"],
"QgsMapLayerProxyModel": ["Filter", "exceptedLayerList()", "filters() const "],
"QgsCompoundCurve": ["QgsCompoundCurve(const QgsCompoundCurve &curve)"],
"QgisPlugin": ["QgisPlugin(QString const &name=\"\", QString const &description=\"\", QString const &category=\"\", QString const &version=\"\", PLUGINTYPE const &type=MAPLAYER)", "name()"],
@ -675,7 +675,7 @@ ACCEPTABLE_MISSING_DOCS = {
"QgsGlowEffect": ["QgsGlowEffect(const QgsGlowEffect &other)"],
"Node": ["Node(const Node &n)"],
"QgsSymbolLevelItem": ["layer()", "QgsSymbolLevelItem(QgsSymbol *symbol, int layer)", "symbol()"],
"QgsInterpolator": ["QgsInterpolator(const QList< LayerData > &layerData)"],
"QgsInterpolator": ["QgsInterpolator(const QList< QgsInterpolator::LayerData > &layerData)"],
"QgsComposerFrame": ["QgsComposerFrame(QgsComposition *c, QgsComposerMultiFrame *mf, qreal x, qreal y, qreal width, qreal height)"],
"QgsComposerArrow": ["MarkerMode"],
"QgsAttributeAction": ["operator[](int idx)", "setDefaultAction(int actionNumber)", "size() const ", "at(int idx)"],