Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
align pointer and reference in sip files batch 2
  • Loading branch information
3nids committed May 1, 2017
1 parent 699580d commit 7b60d89
Show file tree
Hide file tree
Showing 260 changed files with 2,649 additions and 2,649 deletions.
22 changes: 11 additions & 11 deletions python/analysis/interpolation/Bezier3D.sip
Expand Up @@ -8,35 +8,35 @@ class Bezier3D : ParametricLine
/** Default constructor*/
Bezier3D();
/** Constructor, par is a pointer to the parent, controlpoly a controlpolygon*/
Bezier3D( ParametricLine* par, QVector<Point3D*>* controlpoly );
Bezier3D( ParametricLine *par, QVector<Point3D*> *controlpoly );
/** Destructor*/
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 );
virtual void calcFirstDer( float t, Vector3D *v );
/** Calculates the second derivative and assigns it to v*/
virtual void calcSecDer( float t, Vector3D* v );
virtual void calcSecDer( float t, Vector3D *v );
//virtual Point3D calcPoint(float t);
/** Calculates the point on the curve and assigns it to p*/
virtual void calcPoint( float t, Point3D* p );
virtual void calcPoint( float t, Point3D *p );
/** Changes the order of control points*/
virtual void changeDirection();
//virtual void draw(QPainter* p);
//virtual bool intersects(ParametricLine* pal);
//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*/
virtual void remove( int i );
/** Returns a control point*/
virtual const Point3D* getControlPoint( int number ) const;
virtual const Point3D *getControlPoint( int number ) const;
/** Returns a pointer to the control polygon*/
virtual const QVector<Point3D*>* getControlPoly() const;
virtual const QVector<Point3D*> *getControlPoly() const;
/** Returns the degree of the curve*/
virtual int getDegree() const;
/** Returns the parent*/
virtual ParametricLine* getParent() const;
virtual ParametricLine *getParent() const;
/** Sets the parent*/
virtual void setParent( ParametricLine* par );
virtual void setParent( ParametricLine *par );
/** Sets the control polygon*/
virtual void setControlPoly( QVector<Point3D*>* cp );
virtual void setControlPoly( QVector<Point3D*> *cp );

};
8 changes: 4 additions & 4 deletions python/analysis/interpolation/CloughTocherInterpolator.sip
Expand Up @@ -13,12 +13,12 @@ class CloughTocherInterpolator : TriangleInterpolator
/** Standard constructor*/
CloughTocherInterpolator();
/** Constructor with a pointer to the triangulation as argument*/
CloughTocherInterpolator( NormVecDecorator* tin );
CloughTocherInterpolator( NormVecDecorator *tin );
/** Destructor*/
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 );
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, Point3D* result );
virtual void setTriangulation( NormVecDecorator* tin );
virtual bool calcPoint( double x, double y, Point3D *result );
virtual void setTriangulation( NormVecDecorator *tin );
};
34 changes: 17 additions & 17 deletions python/analysis/interpolation/DualEdgeTriangulation.sip
Expand Up @@ -5,31 +5,31 @@ class DualEdgeTriangulation: Triangulation
%End
public:
DualEdgeTriangulation();
DualEdgeTriangulation( int nop, Triangulation* decorator );
DualEdgeTriangulation( int nop, Triangulation *decorator );
virtual ~DualEdgeTriangulation();
void setDecorator( Triangulation* d );
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 );
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( Point3D* p /Transfer/);
int addPoint( Point3D *p /Transfer/);
/** Performs a consistency check, remove this later*/
virtual void performConsistencyTest();
/** Calculates the normal at a point on the surface*/
virtual bool calcNormal( double x, double y, Vector3D* result );
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, Point3D* result );
virtual bool calcPoint( double x, double y, Point3D *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;
//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*/
virtual Point3D* getPoint( unsigned int i ) const;
virtual Point3D *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, Point3D* p1, int* n1 /Out/, Point3D* p2 /Out/, int* n2 /Out/, Point3D* p3 /Out/, int* n3 /Out/ );
bool getTriangle( double x, double y, Point3D *p1, int *n1 /Out/, Point3D *p2 /Out/, int *n2 /Out/, Point3D *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, Point3D* p1 /Out/, Point3D* p2 /Out/, Point3D* p3 /Out/ );
bool getTriangle( double x, double y, Point3D *p1 /Out/, Point3D *p2 /Out/, Point3D *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 );
QList<int> *getSurroundingTriangles( int pointno );
/** Returns the largest x-coordinate value of the bounding box*/
virtual double getXMax() const;
/** Returns the smallest x-coordinate value of the bounding box*/
Expand All @@ -49,7 +49,7 @@ class DualEdgeTriangulation: Triangulation
/** Sets the color of the breaklines*/
virtual void setBreakEdgeColor( int r, int g, int b );
/** Sets an interpolator object*/
void setTriangleInterpolator( TriangleInterpolator* interpolator );
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)*/
Expand All @@ -63,10 +63,10 @@ class DualEdgeTriangulation: Triangulation
/** Swaps the edge which is closest to the point with x and y coordinates (if this is possible)*/
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*/
virtual QList<int>* getPointsAroundEdge( double x, double y );
virtual QList<int> *getPointsAroundEdge( double x, double y );
/** Saves the triangulation as a (line) shapefile
@return true in case of success*/
virtual bool saveAsShapefile( const QString& fileName ) const;
virtual bool saveAsShapefile( const QString &fileName ) const;

protected:
/** Inserts an edge and makes sure, everything is ok with the storage of the edge. The number of the HalfEdge is returned*/
Expand All @@ -80,7 +80,7 @@ class DualEdgeTriangulation: Triangulation
/** Returns the number of an edge which points to the point with number 'point' or -1 if there is an error*/
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*/
int baseEdgeOfTriangle( Point3D* point );
int baseEdgeOfTriangle( Point3D *point );
/** Checks, if 'edge' has to be swapped because of the empty circle criterion. If so, doSwap(...) is called.*/
bool checkSwap( unsigned int edge, unsigned int recursiveDeep );
/** Swaps 'edge' and test recursively for other swaps (delaunay criterion)*/
Expand All @@ -90,7 +90,7 @@ class DualEdgeTriangulation: Triangulation
/** Returns true, if it is possible to swap an edge, otherwise false(concave quad or edge on (or outside) the convex hull)*/
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*/
void triangulatePolygon( QList<int>* poly, QList<int>* free, int mainedge );
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*/
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*/
Expand All @@ -100,5 +100,5 @@ class DualEdgeTriangulation: Triangulation
/** Returns true, if a half edge is on the convex hull and false otherwise*/
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*/
void evaluateInfluenceRegion( Point3D* point, int edge, QSet<int> &set );
void evaluateInfluenceRegion( Point3D *point, int edge, QSet<int> &set );
};
14 changes: 7 additions & 7 deletions python/analysis/interpolation/LinTriangleInterpolator.sip
Expand Up @@ -7,22 +7,22 @@ class LinTriangleInterpolator : TriangleInterpolator
/** Default constructor*/
LinTriangleInterpolator();
/** Constructor with reference to a DualEdgeTriangulation object*/
LinTriangleInterpolator( DualEdgeTriangulation* tin );
LinTriangleInterpolator( DualEdgeTriangulation *tin );
/** Destructor*/
virtual ~LinTriangleInterpolator();
/** Calculates the normal vector and assigns it to vec*/
virtual bool calcNormVec( double x, double y, Vector3D* result );
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, Point3D* result );
virtual bool calcPoint( double x, double y, Point3D *result );
/** Returns a pointer to the current Triangulation object*/
virtual DualEdgeTriangulation* getTriangulation() const;
virtual DualEdgeTriangulation *getTriangulation() const;
/** Sets a Triangulation*/
virtual void setTriangulation( DualEdgeTriangulation* tin );
virtual void setTriangulation( DualEdgeTriangulation *tin );


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 );
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 calcFirstDerY( double x, double y, Vector3D *result );
};
4 changes: 2 additions & 2 deletions python/analysis/interpolation/Line3D.sip
Expand Up @@ -9,11 +9,11 @@ class Line3D /NoDefaultCtors/
/** Returns true, if the Line contains no Point3D, otherwise false*/
bool empty() const;
/** Inserts a node behind the current position and sets the current position to this new node*/
void insertPoint( Point3D* p );
void insertPoint( Point3D *p );
/** Removes the point behind the current position*/
void removePoint();
/** Gets the point at the current position*/
Point3D* getPoint() const;
Point3D *getPoint() const;
/** Returns the current position*/
unsigned int getCurrent() const;
/** Returns the size of the line (the numbero of inserted Nodes without 'head' and 'z'*/
Expand Down
12 changes: 6 additions & 6 deletions python/analysis/interpolation/Node.sip
Expand Up @@ -6,15 +6,15 @@ class Node

public:
Node();
Node( const Node& n );
Node( const Node &n );
~Node();
// Node& operator=( const Node& n );
// Node &operator=( const Node &n );
/** Returns a pointer to the next element in the linked list*/
Node* getNext() const;
Node *getNext() const;
/** Returns a pointer to the Point3D object associated with the node*/
Point3D* getPoint() const;
Point3D *getPoint() const;
/** Sets the pointer to the next node*/
void setNext( Node* n );
void setNext( Node *n );
/** Sets a new pointer to an associated Point3D object*/
void setPoint( Point3D* p );
void setPoint( Point3D *p );
};
22 changes: 11 additions & 11 deletions python/analysis/interpolation/NormVecDecorator.sip
Expand Up @@ -8,39 +8,39 @@ class NormVecDecorator : TriDecorator
//! 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();
NormVecDecorator( Triangulation* tin );
NormVecDecorator( Triangulation *tin );
virtual ~NormVecDecorator();
/** Adds a point to the triangulation*/
int addPoint( Point3D* p );
int addPoint( Point3D *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 );
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 );
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, Point3D* result );
bool calcPoint( double x, double y, Point3D *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 void eliminateHorizontalTriangles();
/** Estimates the first derivative a point. Return true in case of succes and false otherwise*/
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*/
bool estimateFirstDerivatives( QProgressDialog* d = 0 );
bool estimateFirstDerivatives( QProgressDialog *d = 0 );
/** Returns a pointer to the normal vector for the point with the number n*/
Vector3D* getNormal( int n ) const;
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, Point3D* p1 /Out/, Vector3D* v1 /Out/, Point3D* p2 /Out/, Vector3D* v2 /Out/, Point3D* p3 /Out/, Vector3D* v3 /Out/ );
bool getTriangle( double x, double y, Point3D *p1 /Out/, Vector3D *v1 /Out/, Point3D *p2 /Out/, Vector3D *v2 /Out/, Point3D *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, Point3D* p1 /Out/, int* ptn1 /Out/, Vector3D* v1 /Out/, PointState* state1 /Out/, Point3D* p2 /Out/, int* ptn2 /Out/, Vector3D* v2 /Out/, PointState* state2 /Out/, Point3D* p3 /Out/, int* ptn3 /Out/, Vector3D* v3 /Out/, PointState* state3 /Out/);
//bool getTriangle( double x, double y, Point3D* p1 /Out/, int* ptn1 /Out/, Vector3D* v1 /Out/, PointState* state1 /Out/, Point3D* p2 /Out/, int *ptn2 /Out/, Vector3D *v2 /Out/, PointState *state2 /Out/, Point3D *p3 /Out/, int *ptn3 /Out/, Vector3D *v3 /Out/, PointState *state3 /Out/);
/** Returns the state of the point with the number 'pointno'*/
PointState getState( int pointno ) const;
/** Sets an interpolator*/
void setTriangleInterpolator( TriangleInterpolator* inter );
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)*/
virtual bool swapEdge( double x, double y );
/** Saves the triangulation as a (line) shapefile
@return true in case of success*/
virtual bool saveAsShapefile( const QString& fileName ) const;
virtual bool saveAsShapefile( const QString &fileName ) const;

protected:
/** Sets the state (BreakLine, Normal, EndPoint) of a point*/
Expand Down

2 comments on commit 7b60d89

@3nids
Copy link
Member Author

@3nids 3nids commented on 7b60d89 May 1, 2017

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@m-kuhn seems the macos test is still failing on timeout
https://travis-ci.org/qgis/QGIS/jobs/227671702

@m-kuhn
Copy link
Member

@m-kuhn m-kuhn commented on 7b60d89 May 1, 2017

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That's expected. At least we got a message now (although it could be a bit nicer)

Please sign in to comment.