[geos-commits] [SCM] GEOS branch master updated. 8a9600bb2e617c788fdcdad8eb9e9045925bbd23
git at osgeo.org
git at osgeo.org
Thu Aug 30 15:15:54 PDT 2018
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GEOS".
The branch, master has been updated
via 8a9600bb2e617c788fdcdad8eb9e9045925bbd23 (commit)
via e7adbc55a20633064d3af49f2662b17e5ca02e47 (commit)
from 5ecabd64e27eacf528b5a9344d9a03384484bca9 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 8a9600bb2e617c788fdcdad8eb9e9045925bbd23
Merge: 5ecabd6 e7adbc5
Author: cvvergara <vicky at georepublic.de>
Date: Thu Aug 30 15:15:54 2018 -0700
Merge branch 'fix-shadow' of cvvergara/geos into master
commit e7adbc55a20633064d3af49f2662b17e5ca02e47
Author: cvvergara <vicky at georepublic.de>
Date: Fri Aug 3 11:56:51 2018 -0500
fix shadow problems (Closes #857)
adding -Wshadow to compilation (on cmake)
This is a combination of 16 commits.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3dad493..772d688 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -140,7 +140,7 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
"Forcing IEEE 754 using flag -ffloat-store - ${GEOS_ENABLE_FLOATSTORE}")
# Warnings specification
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -fno-implicit-inline-templates -Wconversion -pedantic -W -Wunused -Wuninitialized -Wextra -Wdouble-promotion")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -fno-implicit-inline-templates -Wconversion -pedantic -W -Wunused -Wuninitialized -Wextra -Wdouble-promotion -Wshadow")
# Turn on Position Independent Code generation for GEOS C shared library
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -Wall -Wconversion -pedantic -Wmissing-prototypes -W -Wunused -Wuninitialized -Wextra -Wdouble-promotion")
diff --git a/include/geos/algorithm/RayCrossingCounter.h b/include/geos/algorithm/RayCrossingCounter.h
index f1d0e0b..9891f37 100644
--- a/include/geos/algorithm/RayCrossingCounter.h
+++ b/include/geos/algorithm/RayCrossingCounter.h
@@ -109,8 +109,8 @@ public:
const geom::Coordinate& p2,
const geom::Coordinate& q);
- RayCrossingCounter(const geom::Coordinate& point)
- : point( point),
+ RayCrossingCounter(const geom::Coordinate& p_point)
+ : point( p_point),
crossingCount( 0),
isPointOnSegment( false)
{ }
diff --git a/include/geos/algorithm/distance/DiscreteFrechetDistance.h b/include/geos/algorithm/distance/DiscreteFrechetDistance.h
index bc7eb14..ba7b30b 100644
--- a/include/geos/algorithm/distance/DiscreteFrechetDistance.h
+++ b/include/geos/algorithm/distance/DiscreteFrechetDistance.h
@@ -113,11 +113,11 @@ public:
static double distance(const geom::Geometry& g0,
const geom::Geometry& g1, double densifyFrac);
- DiscreteFrechetDistance(const geom::Geometry& g0,
- const geom::Geometry& g1)
+ DiscreteFrechetDistance(const geom::Geometry& p_g0,
+ const geom::Geometry& p_g1)
:
- g0(g0),
- g1(g1),
+ g0(p_g0),
+ g1(p_g1),
ptDist(),
densifyFrac(0.0)
{}
diff --git a/include/geos/algorithm/distance/DiscreteHausdorffDistance.h b/include/geos/algorithm/distance/DiscreteHausdorffDistance.h
index 72fbdd1..77d8535 100644
--- a/include/geos/algorithm/distance/DiscreteHausdorffDistance.h
+++ b/include/geos/algorithm/distance/DiscreteHausdorffDistance.h
@@ -107,11 +107,11 @@ public:
static double distance(const geom::Geometry& g0,
const geom::Geometry& g1, double densifyFrac);
- DiscreteHausdorffDistance(const geom::Geometry& g0,
- const geom::Geometry& g1)
+ DiscreteHausdorffDistance(const geom::Geometry& p_g0,
+ const geom::Geometry& p_g1)
:
- g0(g0),
- g1(g1),
+ g0(p_g0),
+ g1(p_g1),
ptDist(),
densifyFrac(0.0)
{}
@@ -155,9 +155,9 @@ public:
class MaxPointDistanceFilter : public geom::CoordinateFilter
{
public:
- MaxPointDistanceFilter(const geom::Geometry& geom)
+ MaxPointDistanceFilter(const geom::Geometry& p_geom)
:
- geom(geom)
+ geom(p_geom)
{}
void filter_ro(const geom::Coordinate* pt) override
@@ -190,9 +190,9 @@ public:
public:
MaxDensifiedByFractionDistanceFilter(
- const geom::Geometry& geom, double fraction)
+ const geom::Geometry& p_geom, double fraction)
:
- geom(geom),
+ geom(p_geom),
numSubSegs( std::size_t(util::round(1.0/fraction)) )
{
}
@@ -221,11 +221,11 @@ public:
private:
- void compute(const geom::Geometry& g0,
- const geom::Geometry& g1)
+ void compute(const geom::Geometry& p_g0,
+ const geom::Geometry& p_g1)
{
- computeOrientedDistance(g0, g1, ptDist);
- computeOrientedDistance(g1, g0, ptDist);
+ computeOrientedDistance(p_g0, p_g1, ptDist);
+ computeOrientedDistance(p_g1, p_g0, ptDist);
}
void computeOrientedDistance(const geom::Geometry& discreteGeom,
diff --git a/include/geos/algorithm/locate/IndexedPointInAreaLocator.h b/include/geos/algorithm/locate/IndexedPointInAreaLocator.h
index b0e44d2..369b042 100644
--- a/include/geos/algorithm/locate/IndexedPointInAreaLocator.h
+++ b/include/geos/algorithm/locate/IndexedPointInAreaLocator.h
@@ -80,8 +80,8 @@ private:
algorithm::RayCrossingCounter * counter;
public:
- SegmentVisitor( algorithm::RayCrossingCounter * counter)
- : counter( counter)
+ SegmentVisitor( algorithm::RayCrossingCounter * p_counter)
+ : counter( p_counter)
{ }
~SegmentVisitor() override
diff --git a/include/geos/algorithm/locate/SimplePointInAreaLocator.h b/include/geos/algorithm/locate/SimplePointInAreaLocator.h
index c9f0f89..f1f40f3 100644
--- a/include/geos/algorithm/locate/SimplePointInAreaLocator.h
+++ b/include/geos/algorithm/locate/SimplePointInAreaLocator.h
@@ -55,8 +55,8 @@ public:
static bool containsPointInPolygon(const geom::Coordinate& p,
const geom::Polygon *poly);
- SimplePointInAreaLocator( const geom::Geometry * g)
- : g( g)
+ SimplePointInAreaLocator( const geom::Geometry * p_g)
+ : g( p_g)
{ }
int locate( const geom::Coordinate * p) override
diff --git a/include/geos/geom/prep/AbstractPreparedPolygonContains.h b/include/geos/geom/prep/AbstractPreparedPolygonContains.h
index 6bd4e90..3106ca4 100644
--- a/include/geos/geom/prep/AbstractPreparedPolygonContains.h
+++ b/include/geos/geom/prep/AbstractPreparedPolygonContains.h
@@ -109,20 +109,20 @@ protected:
virtual bool fullTopologicalPredicate( const geom::Geometry * geom) =0;
public:
- AbstractPreparedPolygonContains( const PreparedPolygon * const prepPoly)
- : PreparedPolygonPredicate( prepPoly),
+ AbstractPreparedPolygonContains( const PreparedPolygon * const p_prepPoly)
+ : PreparedPolygonPredicate( p_prepPoly),
hasSegmentIntersection( false),
hasProperIntersection( false),
hasNonProperIntersection( false),
requireSomePointInInterior(true)
{ }
- AbstractPreparedPolygonContains( const PreparedPolygon * const prepPoly, bool requireSomePointInInterior)
- : PreparedPolygonPredicate( prepPoly),
+ AbstractPreparedPolygonContains( const PreparedPolygon * const p_prepPoly, bool p_requireSomePointInInterior)
+ : PreparedPolygonPredicate( p_prepPoly),
hasSegmentIntersection( false),
hasProperIntersection( false),
hasNonProperIntersection( false),
- requireSomePointInInterior(requireSomePointInInterior)
+ requireSomePointInInterior(p_requireSomePointInInterior)
{ }
~AbstractPreparedPolygonContains() override
diff --git a/include/geos/geom/prep/PreparedPolygonPredicate.h b/include/geos/geom/prep/PreparedPolygonPredicate.h
index adb5f89..f340930 100644
--- a/include/geos/geom/prep/PreparedPolygonPredicate.h
+++ b/include/geos/geom/prep/PreparedPolygonPredicate.h
@@ -128,8 +128,8 @@ public:
*
* @param prepPoly the PreparedPolygon to evaluate
*/
- PreparedPolygonPredicate( const PreparedPolygon * const prepPoly)
- : prepPoly( prepPoly)
+ PreparedPolygonPredicate( const PreparedPolygon * const p_prepPoly)
+ : prepPoly( p_prepPoly)
{ }
virtual ~PreparedPolygonPredicate()
diff --git a/include/geos/geom/util/GeometryExtracter.h b/include/geos/geom/util/GeometryExtracter.h
index 94b6eb4..1cd33c9 100644
--- a/include/geos/geom/util/GeometryExtracter.h
+++ b/include/geos/geom/util/GeometryExtracter.h
@@ -48,15 +48,15 @@ public:
template <class ComponentType, class TargetContainer>
static void extract(const Geometry& geom, TargetContainer& lst)
{
- if ( const ComponentType* c = dynamic_cast<const ComponentType*>(&geom) )
+ if ( const ComponentType* p_c = dynamic_cast<const ComponentType*>(&geom) )
{
- lst.push_back(c);
+ lst.push_back(p_c);
}
- else if ( const GeometryCollection* c =
+ else if ( const GeometryCollection* p_c1 =
dynamic_cast<const GeometryCollection*>(&geom) )
{
GeometryExtracter::Extracter<ComponentType, TargetContainer> extracter(lst);
- c->apply_ro(&extracter);
+ p_c1->apply_ro(&extracter);
}
}
diff --git a/include/geos/index/intervalrtree/IntervalRTreeLeafNode.h b/include/geos/index/intervalrtree/IntervalRTreeLeafNode.h
index 683404e..b190377 100644
--- a/include/geos/index/intervalrtree/IntervalRTreeLeafNode.h
+++ b/include/geos/index/intervalrtree/IntervalRTreeLeafNode.h
@@ -42,9 +42,9 @@ protected:
public:
/// @param item externally owned
- IntervalRTreeLeafNode( double min, double max, void * item)
- : IntervalRTreeNode( min, max),
- item( item)
+ IntervalRTreeLeafNode( double p_min, double p_max, void * p_item)
+ : IntervalRTreeNode( p_min, p_max),
+ item( p_item)
{ }
~IntervalRTreeLeafNode() override
diff --git a/include/geos/index/intervalrtree/IntervalRTreeNode.h b/include/geos/index/intervalrtree/IntervalRTreeNode.h
index 82b7d69..0d4870e 100644
--- a/include/geos/index/intervalrtree/IntervalRTreeNode.h
+++ b/include/geos/index/intervalrtree/IntervalRTreeNode.h
@@ -55,9 +55,9 @@ public:
max( DoubleNegInfinity )
{ }
- IntervalRTreeNode( double min, double max)
- : min( min ),
- max( max )
+ IntervalRTreeNode( double p_min, double p_max)
+ : min( p_min ),
+ max( p_max )
{ }
virtual ~IntervalRTreeNode()
diff --git a/include/geos/linearref/LocationIndexedLine.h b/include/geos/linearref/LocationIndexedLine.h
index 7aef969..95ed1dd 100644
--- a/include/geos/linearref/LocationIndexedLine.h
+++ b/include/geos/linearref/LocationIndexedLine.h
@@ -57,8 +57,8 @@ public:
*
* @param linearGeom the linear geometry to reference along
*/
- LocationIndexedLine(const geom::Geometry *linearGeom)
- : linearGeom(linearGeom)
+ LocationIndexedLine(const geom::Geometry *p_linearGeom)
+ : linearGeom(p_linearGeom)
{
checkGeometryType();
}
diff --git a/include/geos/noding/MCIndexSegmentSetMutualIntersector.h b/include/geos/noding/MCIndexSegmentSetMutualIntersector.h
index 07329af..0b36d27 100644
--- a/include/geos/noding/MCIndexSegmentSetMutualIntersector.h
+++ b/include/geos/noding/MCIndexSegmentSetMutualIntersector.h
@@ -88,8 +88,8 @@ public:
SegmentOverlapAction& operator=(const SegmentOverlapAction& rhs) = delete;
public:
- SegmentOverlapAction(SegmentIntersector & si) :
- index::chain::MonotoneChainOverlapAction(), si(si)
+ SegmentOverlapAction(SegmentIntersector & p_si) :
+ index::chain::MonotoneChainOverlapAction(), si(p_si)
{}
void overlap(index::chain::MonotoneChain& mc1, std::size_t start1,
diff --git a/include/geos/noding/OrientedCoordinateArray.h b/include/geos/noding/OrientedCoordinateArray.h
index d8061aa..4a4dd78 100644
--- a/include/geos/noding/OrientedCoordinateArray.h
+++ b/include/geos/noding/OrientedCoordinateArray.h
@@ -53,10 +53,10 @@ public:
*
* @param pts the coordinates to orient
*/
- OrientedCoordinateArray(const geom::CoordinateSequence& pts)
+ OrientedCoordinateArray(const geom::CoordinateSequence& p_pts)
:
- pts(&pts),
- orientationVar(orientation(pts))
+ pts(&p_pts),
+ orientationVar(orientation(p_pts))
{
}
diff --git a/include/geos/noding/SegmentIntersectionDetector.h b/include/geos/noding/SegmentIntersectionDetector.h
index 6905193..8b7eab8 100644
--- a/include/geos/noding/SegmentIntersectionDetector.h
+++ b/include/geos/noding/SegmentIntersectionDetector.h
@@ -58,9 +58,9 @@ private:
protected:
public:
- SegmentIntersectionDetector( LineIntersector * li)
+ SegmentIntersectionDetector( LineIntersector * p_li)
:
- li( li),
+ li( p_li),
findProper(false),
findAllTypes(false),
_hasIntersection(false),
@@ -77,14 +77,14 @@ public:
}
- void setFindProper( bool findProper)
+ void setFindProper( bool p_findProper)
{
- this->findProper = findProper;
+ this->findProper = p_findProper;
}
- void setFindAllIntersectionTypes( bool findAllTypes)
+ void setFindAllIntersectionTypes( bool p_findAllTypes)
{
- this->findAllTypes = findAllTypes;
+ this->findAllTypes = p_findAllTypes;
}
/**
diff --git a/include/geos/triangulate/DelaunayTriangulationBuilder.h b/include/geos/triangulate/DelaunayTriangulationBuilder.h
index cbc6444..6b887cc 100644
--- a/include/geos/triangulate/DelaunayTriangulationBuilder.h
+++ b/include/geos/triangulate/DelaunayTriangulationBuilder.h
@@ -107,9 +107,9 @@ public:
*
* @param tolerance the tolerance distance to use
*/
- inline void setTolerance(double tolerance)
+ inline void setTolerance(double p_tolerance)
{
- this->tolerance = tolerance;
+ this->tolerance = p_tolerance;
}
private:
diff --git a/include/geos/triangulate/quadedge/QuadEdge.h b/include/geos/triangulate/quadedge/QuadEdge.h
index c005f81..7515b6a 100644
--- a/include/geos/triangulate/quadedge/QuadEdge.h
+++ b/include/geos/triangulate/quadedge/QuadEdge.h
@@ -171,8 +171,8 @@ public:
*
* @param nextEdge edge
*/
- inline void setNext(QuadEdge *next) {
- this->next = next;
+ inline void setNext(QuadEdge *p_next) {
+ this->next = p_next;
}
/***************************************************************************
diff --git a/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h b/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
index c738ac7..e37f43b 100644
--- a/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
+++ b/include/geos/triangulate/quadedge/QuadEdgeSubdivision.h
@@ -159,8 +159,8 @@ public:
* @param locator
* a QuadEdgeLocator
*/
- inline void setLocator(std::unique_ptr<QuadEdgeLocator> locator) {
- this->locator = std::move(locator);
+ inline void setLocator(std::unique_ptr<QuadEdgeLocator> p_locator) {
+ this->locator = std::move(p_locator);
}
/**
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e477ed4..157eb51 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -6,7 +6,7 @@
#
# This is free software; you can redistribute and/or modify it under
# the terms of the GNU Lesser General Public Licence as published
-# by the Free Software Foundation.
+# by the Free Software Foundation.
# See the COPYING file for more information.
#
#################################################################################
@@ -26,14 +26,14 @@ if(GEOS_ENABLE_MACOSX_FRAMEWORK)
add_library(GEOS SHARED ${geos_SOURCES} ${geos_c_SOURCES})
- math(EXPR CVERSION "${VERSION_MAJOR} + 1")
- # VERSION = current version, SOVERSION = compatibility version
+ math(EXPR CVERSION "${VERSION_MAJOR} + 1")
+ # VERSION = current version, SOVERSION = compatibility version
set_target_properties(GEOS
PROPERTIES
CLEAN_DIRECT_OUTPUT 1
FRAMEWORK 1
- VERSION "${CVERSION}.${VERSION_MINOR}.${VERSION_PATCH}"
- SOVERSION ${CVERSION}
+ VERSION "${CVERSION}.${VERSION_MINOR}.${VERSION_PATCH}"
+ SOVERSION ${CVERSION}
FRAMEWORK_VERSION ${VERSION_MAJOR}
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}"
diff --git a/src/algorithm/ConvexHull.cpp b/src/algorithm/ConvexHull.cpp
index 568c386..636cce8 100644
--- a/src/algorithm/ConvexHull.cpp
+++ b/src/algorithm/ConvexHull.cpp
@@ -118,37 +118,37 @@ ConvexHull::toCoordinateSequence(Coordinate::ConstVect &cv)
/* private */
void
-ConvexHull::computeOctPts(const Coordinate::ConstVect &inputPts,
+ConvexHull::computeOctPts(const Coordinate::ConstVect &p_inputPts,
Coordinate::ConstVect &pts)
{
// Initialize all slots with first input coordinate
- pts = Coordinate::ConstVect(8, inputPts[0]);
+ pts = Coordinate::ConstVect(8, p_inputPts[0]);
- for (size_t i=1, n=inputPts.size(); i<n; ++i)
+ for (size_t i=1, n=p_inputPts.size(); i<n; ++i)
{
- if (inputPts[i]->x < pts[0]->x) {
- pts[0] = inputPts[i];
+ if (p_inputPts[i]->x < pts[0]->x) {
+ pts[0] = p_inputPts[i];
}
- if (inputPts[i]->x - inputPts[i]->y < pts[1]->x - pts[1]->y) {
- pts[1] = inputPts[i];
+ if (p_inputPts[i]->x - p_inputPts[i]->y < pts[1]->x - pts[1]->y) {
+ pts[1] = p_inputPts[i];
}
- if (inputPts[i]->y > pts[2]->y) {
- pts[2] = inputPts[i];
+ if (p_inputPts[i]->y > pts[2]->y) {
+ pts[2] = p_inputPts[i];
}
- if (inputPts[i]->x + inputPts[i]->y > pts[3]->x + pts[3]->y) {
- pts[3] = inputPts[i];
+ if (p_inputPts[i]->x + p_inputPts[i]->y > pts[3]->x + pts[3]->y) {
+ pts[3] = p_inputPts[i];
}
- if (inputPts[i]->x > pts[4]->x) {
- pts[4] = inputPts[i];
+ if (p_inputPts[i]->x > pts[4]->x) {
+ pts[4] = p_inputPts[i];
}
- if (inputPts[i]->x - inputPts[i]->y > pts[5]->x - pts[5]->y) {
- pts[5] = inputPts[i];
+ if (p_inputPts[i]->x - p_inputPts[i]->y > pts[5]->x - pts[5]->y) {
+ pts[5] = p_inputPts[i];
}
- if (inputPts[i]->y < pts[6]->y) {
- pts[6] = inputPts[i];
+ if (p_inputPts[i]->y < pts[6]->y) {
+ pts[6] = p_inputPts[i];
}
- if (inputPts[i]->x + inputPts[i]->y < pts[7]->x + pts[7]->y) {
- pts[7] = inputPts[i];
+ if (p_inputPts[i]->x + p_inputPts[i]->y < pts[7]->x + pts[7]->y) {
+ pts[7] = p_inputPts[i];
}
}
@@ -157,10 +157,10 @@ ConvexHull::computeOctPts(const Coordinate::ConstVect &inputPts,
/* private */
bool
-ConvexHull::computeOctRing(const Coordinate::ConstVect &inputPts,
+ConvexHull::computeOctRing(const Coordinate::ConstVect &p_inputPts,
Coordinate::ConstVect &dest)
{
- computeOctPts(inputPts, dest);
+ computeOctPts(p_inputPts, dest);
// Remove consecutive equal Coordinates
// unique() returns an iterator to the end of the resulting
diff --git a/src/algorithm/PointLocator.cpp b/src/algorithm/PointLocator.cpp
index 2249280..448dd85 100644
--- a/src/algorithm/PointLocator.cpp
+++ b/src/algorithm/PointLocator.cpp
@@ -86,8 +86,8 @@ PointLocator::computeLocation(const Coordinate& p, const Geometry *geom)
{
for(std::size_t i=0, n=mpo->getNumGeometries(); i<n; ++i)
{
- const Polygon *po=dynamic_cast<const Polygon *>(mpo->getGeometryN(i));
- updateLocationInfo(locate(p, po));
+ const Polygon *p_po=dynamic_cast<const Polygon *>(mpo->getGeometryN(i));
+ updateLocationInfo(locate(p, p_po));
}
}
else if (const GeometryCollection *col=dynamic_cast<const GeometryCollection *>(geom))
diff --git a/src/algorithm/distance/DiscreteFrechetDistance.cpp b/src/algorithm/distance/DiscreteFrechetDistance.cpp
index 0399a60..f194336 100644
--- a/src/algorithm/distance/DiscreteFrechetDistance.cpp
+++ b/src/algorithm/distance/DiscreteFrechetDistance.cpp
@@ -86,12 +86,12 @@ DiscreteFrechetDistance::getSegementAt(const CoordinateSequence& seq, size_t ind
PointPairDistance&
DiscreteFrechetDistance::getFrecheDistance(std::vector< std::vector<PointPairDistance> >& ca, size_t i, size_t j, const CoordinateSequence& p, const CoordinateSequence& q)
{
- PointPairDistance ptDist;
+ PointPairDistance p_ptDist;
if (! ca[i][j].getIsNull())
{
return ca[i][j];
}
- ptDist.initialize(getSegementAt(p, i), getSegementAt(q, j));
+ p_ptDist.initialize(getSegementAt(p, i), getSegementAt(q, j));
if (i == 0 && j == 0)
{
ca[i][j] = ptDist;
@@ -99,12 +99,12 @@ DiscreteFrechetDistance::getFrecheDistance(std::vector< std::vector<PointPairDis
else if (i > 0 && j == 0)
{
PointPairDistance nextDist = getFrecheDistance(ca,i-1,0,p,q);
- ca[i][j] = (nextDist.getDistance() > ptDist.getDistance()) ? nextDist : ptDist;
+ ca[i][j] = (nextDist.getDistance() > p_ptDist.getDistance()) ? nextDist : p_ptDist;
}
else if (i == 0 && j > 0)
{
PointPairDistance nextDist = getFrecheDistance(ca,0,j-1,p,q);
- ca[i][j] = (nextDist.getDistance() > ptDist.getDistance()) ? nextDist : ptDist;
+ ca[i][j] = (nextDist.getDistance() > p_ptDist.getDistance()) ? nextDist : p_ptDist;
}
else
{
@@ -113,7 +113,7 @@ DiscreteFrechetDistance::getFrecheDistance(std::vector< std::vector<PointPairDis
d3 = getFrecheDistance(ca,i,j-1,p,q);
PointPairDistance& minDist = (d1.getDistance() < d2.getDistance()) ? d1 : d2;
if (d3.getDistance() < minDist.getDistance()) minDist = d3;
- ca[i][j] = (minDist.getDistance() > ptDist.getDistance()) ? minDist : ptDist;
+ ca[i][j] = (minDist.getDistance() > p_ptDist.getDistance()) ? minDist : p_ptDist;
}
return ca[i][j];
diff --git a/src/algorithm/distance/DiscreteHausdorffDistance.cpp b/src/algorithm/distance/DiscreteHausdorffDistance.cpp
index 16ac558..7e8fc3b 100644
--- a/src/algorithm/distance/DiscreteHausdorffDistance.cpp
+++ b/src/algorithm/distance/DiscreteHausdorffDistance.cpp
@@ -87,11 +87,11 @@ void
DiscreteHausdorffDistance::computeOrientedDistance(
const geom::Geometry& discreteGeom,
const geom::Geometry& geom,
- PointPairDistance& ptDist)
+ PointPairDistance& p_ptDist)
{
MaxPointDistanceFilter distFilter(geom);
discreteGeom.apply_ro(&distFilter);
- ptDist.setMaximum(distFilter.getMaxPointDistance());
+ p_ptDist.setMaximum(distFilter.getMaxPointDistance());
if (densifyFrac > 0)
{
diff --git a/src/geom/GeometryCollection.cpp b/src/geom/GeometryCollection.cpp
index 9240608..3ead8fa 100644
--- a/src/geom/GeometryCollection.cpp
+++ b/src/geom/GeometryCollection.cpp
@@ -253,12 +253,12 @@ GeometryCollection::normalize()
Envelope::Ptr
GeometryCollection::computeEnvelopeInternal() const
{
- Envelope::Ptr envelope(new Envelope());
+ Envelope::Ptr p_envelope(new Envelope());
for (size_t i=0; i<geometries->size(); i++) {
const Envelope *env=(*geometries)[i]->getEnvelopeInternal();
- envelope->expandToInclude(env);
+ p_envelope->expandToInclude(env);
}
- return envelope;
+ return p_envelope;
}
int
diff --git a/src/geom/LineString.cpp b/src/geom/LineString.cpp
index 244fd5d..14bc1c1 100644
--- a/src/geom/LineString.cpp
+++ b/src/geom/LineString.cpp
@@ -269,11 +269,11 @@ LineString::computeEnvelopeInternal() const
double maxy = c.y;
std::size_t npts=points->getSize();
for (std::size_t i=1; i<npts; i++) {
- const Coordinate &c=points->getAt(i);
- minx = minx < c.x ? minx : c.x;
- maxx = maxx > c.x ? maxx : c.x;
- miny = miny < c.y ? miny : c.y;
- maxy = maxy > c.y ? maxy : c.y;
+ const Coordinate &c1=points->getAt(i);
+ minx = minx < c1.x ? minx : c1.x;
+ maxx = maxx > c1.x ? maxx : c1.x;
+ miny = miny < c1.y ? miny : c1.y;
+ maxy = maxy > c1.y ? maxy : c1.y;
}
// caller expects a newly allocated Envelope.
diff --git a/src/geom/prep/PreparedPolygonContains.cpp b/src/geom/prep/PreparedPolygonContains.cpp
index 86f8760..89f8c08 100644
--- a/src/geom/prep/PreparedPolygonContains.cpp
+++ b/src/geom/prep/PreparedPolygonContains.cpp
@@ -28,8 +28,8 @@ namespace prep { // geos.geom.prep
//
// public:
//
-PreparedPolygonContains::PreparedPolygonContains(const PreparedPolygon * const prepPoly)
- : AbstractPreparedPolygonContains( prepPoly)
+PreparedPolygonContains::PreparedPolygonContains(const PreparedPolygon * const p_prepPoly)
+ : AbstractPreparedPolygonContains( p_prepPoly)
{
}
diff --git a/src/geom/util/GeometryTransformer.cpp b/src/geom/util/GeometryTransformer.cpp
index 94b079c..47e3dbc 100644
--- a/src/geom/util/GeometryTransformer.cpp
+++ b/src/geom/util/GeometryTransformer.cpp
@@ -278,11 +278,11 @@ GeometryTransformer::transformPolygon(
vector<Geometry*>* holes = new vector<Geometry*>();
for (size_t i = 0, n = geom->getNumInteriorRing(); i<n; i++)
{
- const LinearRing* lr = dynamic_cast<const LinearRing*>(
+ const LinearRing* p_lr = dynamic_cast<const LinearRing*>(
geom->getInteriorRingN(i));
- assert(lr);
+ assert(p_lr);
- Geometry::Ptr hole(transformLinearRing(lr, geom));
+ Geometry::Ptr hole(transformLinearRing(p_lr, geom));
if ( hole.get() == nullptr || hole->isEmpty() ) {
continue;
@@ -301,9 +301,9 @@ GeometryTransformer::transformPolygon(
if ( isAllValidLinearRings)
{
Geometry* sh = shell.release();
- LinearRing* lr = dynamic_cast<LinearRing*>(sh);
- assert(lr);
- return Geometry::Ptr(factory->createPolygon(lr, holes));
+ LinearRing* p_lr = dynamic_cast<LinearRing*>(sh);
+ assert(p_lr);
+ return Geometry::Ptr(factory->createPolygon(p_lr, holes));
}
else
{
diff --git a/src/geomgraph/EdgeEndStar.cpp b/src/geomgraph/EdgeEndStar.cpp
index 3310cbc..f10e391 100644
--- a/src/geomgraph/EdgeEndStar.cpp
+++ b/src/geomgraph/EdgeEndStar.cpp
@@ -269,7 +269,7 @@ EdgeEndStar::propagateSideLabels(int geomIndex)
EdgeEndStar::iterator it;
// initialize loc to location of last L side (if any)
- for (EdgeEndStar::iterator it=beginIt; it!=endIt; ++it)
+ for (it=beginIt; it!=endIt; ++it)
{
EdgeEnd *e=*it;
assert(e);
diff --git a/src/geomgraph/EdgeRing.cpp b/src/geomgraph/EdgeRing.cpp
index a4ec1c4..17127b1 100644
--- a/src/geomgraph/EdgeRing.cpp
+++ b/src/geomgraph/EdgeRing.cpp
@@ -176,7 +176,7 @@ EdgeRing::addHole(EdgeRing *edgeRing)
/*public*/
Polygon*
-EdgeRing::toPolygon(const GeometryFactory* geometryFactory)
+EdgeRing::toPolygon(const GeometryFactory* p_geometryFactory)
{
testInvariant();
@@ -193,7 +193,7 @@ EdgeRing::toPolygon(const GeometryFactory* geometryFactory)
// wants a LinearRing
//
LinearRing *shellLR=new LinearRing(*(getLinearRing()));
- return geometryFactory->createPolygon(shellLR, holeLR);
+ return p_geometryFactory->createPolygon(shellLR, holeLR);
}
/*public*/
diff --git a/src/geomgraph/GeometryGraph.cpp b/src/geomgraph/GeometryGraph.cpp
index dafe6ee..b838919 100644
--- a/src/geomgraph/GeometryGraph.cpp
+++ b/src/geomgraph/GeometryGraph.cpp
@@ -184,20 +184,20 @@ GeometryGraph::add(const Geometry *g)
useBoundaryDeterminationRule = false;
- if ( const Polygon* x = dynamic_cast<const Polygon*>(g) )
- addPolygon(x);
+ if ( const Polygon* x1 = dynamic_cast<const Polygon*>(g) )
+ addPolygon(x1);
// LineString also handles LinearRings
- else if ( const LineString* x = dynamic_cast<const LineString*>(g) )
- addLineString(x);
+ else if ( const LineString* x2 = dynamic_cast<const LineString*>(g) )
+ addLineString(x2);
- else if ( const Point* x = dynamic_cast<const Point*>(g) )
- addPoint(x);
+ else if ( const Point* x3 = dynamic_cast<const Point*>(g) )
+ addPoint(x3);
- else if ( const GeometryCollection* x =
+ else if ( const GeometryCollection* x4 =
dynamic_cast<const GeometryCollection*>(g) )
{
- addCollection(x);
+ addCollection(x4);
}
else {
@@ -437,7 +437,7 @@ GeometryGraph::computeEdgeIntersections(GeometryGraph *g,
}
void
-GeometryGraph::insertPoint(int argIndex, const Coordinate& coord,
+GeometryGraph::insertPoint(int p_argIndex, const Coordinate& coord,
int onLocation)
{
#if GEOS_DEBUG > 1
@@ -447,11 +447,11 @@ GeometryGraph::insertPoint(int argIndex, const Coordinate& coord,
Label& lbl = n->getLabel();
if ( lbl.isNull() )
{
- n->setLabel(argIndex, onLocation);
+ n->setLabel(p_argIndex, onLocation);
}
else
{
- lbl.setLocation(argIndex, onLocation);
+ lbl.setLocation(p_argIndex, onLocation);
}
}
@@ -462,7 +462,7 @@ GeometryGraph::insertPoint(int argIndex, const Coordinate& coord,
* iff if it is in the boundaries of an odd number of Geometries
*/
void
-GeometryGraph::insertBoundaryPoint(int argIndex, const Coordinate& coord)
+GeometryGraph::insertBoundaryPoint(int p_argIndex, const Coordinate& coord)
{
Node *n=nodes->addNode(coord);
// nodes always have labels
@@ -472,31 +472,31 @@ GeometryGraph::insertBoundaryPoint(int argIndex, const Coordinate& coord)
int boundaryCount=1;
// determine the current location for the point (if any)
- int loc = lbl.getLocation(argIndex,Position::ON);
+ int loc = lbl.getLocation(p_argIndex,Position::ON);
if (loc==Location::BOUNDARY) boundaryCount++;
// determine the boundary status of the point according to the
// Boundary Determination Rule
int newLoc = determineBoundary(boundaryNodeRule, boundaryCount);
- lbl.setLocation(argIndex,newLoc);
+ lbl.setLocation(p_argIndex,newLoc);
}
/*private*/
void
-GeometryGraph::addSelfIntersectionNodes(int argIndex)
+GeometryGraph::addSelfIntersectionNodes(int p_argIndex)
{
for (vector<Edge*>::iterator i=edges->begin(), endIt=edges->end();
i!=endIt; ++i)
{
Edge *e=*i;
- int eLoc = e->getLabel().getLocation(argIndex);
+ int eLoc = e->getLabel().getLocation(p_argIndex);
EdgeIntersectionList &eiL = e->eiList;
for (EdgeIntersectionList::iterator
eiIt=eiL.begin(), eiEnd=eiL.end();
eiIt!=eiEnd; ++eiIt)
{
EdgeIntersection *ei=*eiIt;
- addSelfIntersectionNode(argIndex, ei->coord, eLoc);
+ addSelfIntersectionNode(p_argIndex, ei->coord, eLoc);
GEOS_CHECK_FOR_INTERRUPTS();
}
}
@@ -504,18 +504,18 @@ GeometryGraph::addSelfIntersectionNodes(int argIndex)
/*private*/
void
-GeometryGraph::addSelfIntersectionNode(int argIndex,
+GeometryGraph::addSelfIntersectionNode(int p_argIndex,
const Coordinate& coord, int loc)
{
// if this node is already a boundary node, don't change it
- if (isBoundaryNode(argIndex,coord)) return;
+ if (isBoundaryNode(p_argIndex,coord)) return;
if (loc==Location::BOUNDARY && useBoundaryDeterminationRule)
{
- insertBoundaryPoint(argIndex,coord);
+ insertBoundaryPoint(p_argIndex,coord);
}
else
{
- insertPoint(argIndex,coord,loc);
+ insertPoint(p_argIndex,coord,loc);
}
}
diff --git a/src/geomgraph/index/SegmentIntersector.cpp b/src/geomgraph/index/SegmentIntersector.cpp
index 0e49b5f..630cf80 100644
--- a/src/geomgraph/index/SegmentIntersector.cpp
+++ b/src/geomgraph/index/SegmentIntersector.cpp
@@ -213,7 +213,7 @@ SegmentIntersector::addIntersections(Edge *e0, size_t segIndex0, Edge *e1, size_
/*private*/
bool
-SegmentIntersector::isBoundaryPoint(LineIntersector *li,
+SegmentIntersector::isBoundaryPoint(LineIntersector *p_li,
vector<Node*> *tstBdyNodes)
{
if ( ! tstBdyNodes ) return false;
@@ -221,7 +221,7 @@ SegmentIntersector::isBoundaryPoint(LineIntersector *li,
for(vector<Node*>::iterator i=tstBdyNodes->begin();i<tstBdyNodes->end();i++) {
Node *node=*i;
const Coordinate& pt=node->getCoordinate();
- if (li->isIntersection(pt)) return true;
+ if (p_li->isIntersection(pt)) return true;
}
return false;
}
@@ -229,11 +229,11 @@ SegmentIntersector::isBoundaryPoint(LineIntersector *li,
/*private*/
bool
-SegmentIntersector::isBoundaryPoint(LineIntersector *li,
+SegmentIntersector::isBoundaryPoint(LineIntersector *p_li,
vector<vector<Node*>*>& tstBdyNodes)
{
- if (isBoundaryPoint(li, tstBdyNodes[0])) return true;
- if (isBoundaryPoint(li, tstBdyNodes[1])) return true;
+ if (isBoundaryPoint(p_li, tstBdyNodes[0])) return true;
+ if (isBoundaryPoint(p_li, tstBdyNodes[1])) return true;
return false;
}
diff --git a/src/index/bintree/Key.cpp b/src/index/bintree/Key.cpp
index 96dca54..27d3a5d 100644
--- a/src/index/bintree/Key.cpp
+++ b/src/index/bintree/Key.cpp
@@ -83,12 +83,12 @@ Key::computeKey(Interval *itemInterval)
}
void
-Key::computeInterval(int level, Interval *itemInterval)
+Key::computeInterval(int p_level, Interval *itemInterval)
{
using geos::index::quadtree::DoubleBits;
- double size=DoubleBits::powerOf2(level);
- //double size = pow2.power(level);
+ double size=DoubleBits::powerOf2(p_level);
+ //double size = pow2.power(p_level);
pt=std::floor(itemInterval->getMin()/size)*size;
interval->init(pt,pt+size);
}
diff --git a/src/index/quadtree/Key.cpp b/src/index/quadtree/Key.cpp
index 5bb0447..f20e2c8 100644
--- a/src/index/quadtree/Key.cpp
+++ b/src/index/quadtree/Key.cpp
@@ -115,9 +115,9 @@ Key::computeKey(const Envelope& itemEnv)
}
void
-Key::computeKey(int level, const Envelope& itemEnv)
+Key::computeKey(int p_level, const Envelope& itemEnv)
{
- double quadSize=DoubleBits::powerOf2(level);
+ double quadSize=DoubleBits::powerOf2(p_level);
//double quadSize=pow2.power(level);
pt.x = std::floor(itemEnv.getMinX()/quadSize)*quadSize;
pt.y = std::floor(itemEnv.getMinY()/quadSize)*quadSize;
diff --git a/src/index/strtree/BoundablePair.cpp b/src/index/strtree/BoundablePair.cpp
index 8a0c21c..4ec0b7b 100644
--- a/src/index/strtree/BoundablePair.cpp
+++ b/src/index/strtree/BoundablePair.cpp
@@ -25,10 +25,10 @@ namespace geos {
namespace index {
namespace strtree {
-BoundablePair::BoundablePair(const Boundable* boundable1, const Boundable* boundable2, ItemDistance* itemDistance) :
- boundable1(boundable1),
- boundable2(boundable2),
- itemDistance(itemDistance)
+BoundablePair::BoundablePair(const Boundable* p_boundable1, const Boundable* p_boundable2, ItemDistance* p_itemDistance) :
+ boundable1(p_boundable1),
+ boundable2(p_boundable2),
+ itemDistance(p_itemDistance)
{
mDistance = distance();
}
diff --git a/src/index/strtree/SIRtree.cpp b/src/index/strtree/SIRtree.cpp
index 3ba538f..4c8452f 100644
--- a/src/index/strtree/SIRtree.cpp
+++ b/src/index/strtree/SIRtree.cpp
@@ -73,8 +73,8 @@ SIRtree::SIRtree():
}
/*public*/
-SIRtree::SIRtree(size_t nodeCapacity):
- AbstractSTRtree(nodeCapacity),
+SIRtree::SIRtree(size_t p_nodeCapacity):
+ AbstractSTRtree(p_nodeCapacity),
intersectsOp(new SIRIntersectsOp())
{
}
@@ -86,9 +86,9 @@ SIRtree::~SIRtree() {
class SIRAbstractNode: public AbstractNode {
public:
- SIRAbstractNode(int level, size_t capacity)
+ SIRAbstractNode(int p_level, size_t capacity)
:
- AbstractNode(level, capacity)
+ AbstractNode(p_level, capacity)
{}
~SIRAbstractNode() override
@@ -100,18 +100,18 @@ protected:
void* computeBounds() const override
{
- Interval* bounds=nullptr;
+ Interval* p_bounds=nullptr;
const BoundableList& b = *getChildBoundables();
for(unsigned int i=0; i<b.size(); ++i)
{
const Boundable* childBoundable=b[i];
- if (bounds==nullptr) {
- bounds=new Interval(*((Interval*)childBoundable->getBounds()));
+ if (p_bounds==nullptr) {
+ p_bounds=new Interval(*((Interval*)childBoundable->getBounds()));
} else {
- bounds->expandToInclude((Interval*)childBoundable->getBounds());
+ p_bounds->expandToInclude((Interval*)childBoundable->getBounds());
}
}
- return bounds;
+ return p_bounds;
}
};
diff --git a/src/index/strtree/STRtree.cpp b/src/index/strtree/STRtree.cpp
index 59d808c..80644b6 100644
--- a/src/index/strtree/STRtree.cpp
+++ b/src/index/strtree/STRtree.cpp
@@ -90,7 +90,7 @@ static bool yComparator(Boundable *a, Boundable *b)
}
/*public*/
-STRtree::STRtree(size_t nodeCapacity): AbstractSTRtree(nodeCapacity)
+STRtree::STRtree(size_t p_nodeCapacity): AbstractSTRtree(p_nodeCapacity)
{
}
@@ -277,9 +277,9 @@ std::pair<const void*, const void*> STRtree::nearestNeighbour(BoundablePair* ini
class STRAbstractNode: public AbstractNode{
public:
- STRAbstractNode(int level, size_t capacity)
+ STRAbstractNode(int p_level, size_t capacity)
:
- AbstractNode(level, capacity)
+ AbstractNode(p_level, capacity)
{}
~STRAbstractNode() override
@@ -291,7 +291,7 @@ protected:
void* computeBounds() const override
{
- Envelope* bounds=nullptr;
+ Envelope* p_bounds=nullptr;
const BoundableList& b = *getChildBoundables();
if ( b.empty() ) return nullptr;
@@ -299,13 +299,13 @@ protected:
BoundableList::const_iterator i=b.begin();
BoundableList::const_iterator e=b.end();
- bounds=new Envelope(* static_cast<const Envelope*>((*i)->getBounds()) );
+ p_bounds=new Envelope(* static_cast<const Envelope*>((*i)->getBounds()) );
for(; i!=e; ++i)
{
const Boundable* childBoundable=*i;
- bounds->expandToInclude((Envelope*)childBoundable->getBounds());
+ p_bounds->expandToInclude((Envelope*)childBoundable->getBounds());
}
- return bounds;
+ return p_bounds;
}
};
diff --git a/src/io/WKTWriter.cpp b/src/io/WKTWriter.cpp
index a5cf1b0..7880e11 100644
--- a/src/io/WKTWriter.cpp
+++ b/src/io/WKTWriter.cpp
@@ -168,61 +168,61 @@ void WKTWriter::writeFormatted(const Geometry *geometry, Writer *writer) {
}
void
-WKTWriter::writeFormatted(const Geometry *geometry, bool isFormatted,
+WKTWriter::writeFormatted(const Geometry *geometry, bool p_isFormatted,
Writer *writer)
{
CLocalizer clocale;
- this->isFormatted=isFormatted;
+ this->isFormatted=p_isFormatted;
decimalPlaces = roundingPrecision == -1 ? geometry->getPrecisionModel()->getMaximumSignificantDigits() : roundingPrecision;
appendGeometryTaggedText(geometry, 0, writer);
}
void
-WKTWriter::appendGeometryTaggedText(const Geometry *geometry, int level,
+WKTWriter::appendGeometryTaggedText(const Geometry *geometry, int p_level,
Writer *writer)
{
outputDimension = std::min( defaultOutputDimension,
geometry->getCoordinateDimension() );
- indent(level, writer);
+ indent(p_level, writer);
if ( const Point* point = dynamic_cast<const Point*>(geometry) )
{
- appendPointTaggedText(point->getCoordinate(),level,writer);
+ appendPointTaggedText(point->getCoordinate(),p_level,writer);
}
else if ( const LinearRing* lr =
dynamic_cast<const LinearRing*>(geometry) )
{
- appendLinearRingTaggedText(lr, level, writer);
+ appendLinearRingTaggedText(lr, p_level, writer);
}
else if ( const LineString* ls =
dynamic_cast<const LineString*>(geometry) )
{
- appendLineStringTaggedText(ls, level, writer);
+ appendLineStringTaggedText(ls, p_level, writer);
}
- else if ( const Polygon* x =
+ else if ( const Polygon* x1 =
dynamic_cast<const Polygon*>(geometry) )
{
- appendPolygonTaggedText(x, level, writer);
+ appendPolygonTaggedText(x1, p_level, writer);
}
- else if ( const MultiPoint* x =
+ else if ( const MultiPoint* x2 =
dynamic_cast<const MultiPoint*>(geometry) )
{
- appendMultiPointTaggedText(x, level, writer);
+ appendMultiPointTaggedText(x2, p_level, writer);
}
- else if ( const MultiLineString* x =
+ else if ( const MultiLineString* x3 =
dynamic_cast<const MultiLineString*>(geometry) )
{
- appendMultiLineStringTaggedText(x, level, writer);
+ appendMultiLineStringTaggedText(x3, p_level, writer);
}
- else if ( const MultiPolygon* x =
+ else if ( const MultiPolygon* x4 =
dynamic_cast<const MultiPolygon*>(geometry) )
{
- appendMultiPolygonTaggedText(x, level, writer);
+ appendMultiPolygonTaggedText(x4, p_level, writer);
}
- else if ( const GeometryCollection* x =
+ else if ( const GeometryCollection* x5 =
dynamic_cast<const GeometryCollection*>(geometry) )
{
- appendGeometryCollectionTaggedText(x, level, writer);
+ appendGeometryCollectionTaggedText(x5, p_level, writer);
}
else
{
@@ -232,25 +232,25 @@ WKTWriter::appendGeometryTaggedText(const Geometry *geometry, int level,
/*protected*/
void
-WKTWriter::appendPointTaggedText(const Coordinate* coordinate, int level,
+WKTWriter::appendPointTaggedText(const Coordinate* coordinate, int p_level,
Writer *writer)
{
writer->write("POINT ");
if( outputDimension == 3 && !old3D && coordinate != nullptr )
writer->write( "Z " );
- appendPointText(coordinate, level, writer);
+ appendPointText(coordinate, p_level, writer);
}
void
-WKTWriter::appendLineStringTaggedText(const LineString *lineString, int level,
+WKTWriter::appendLineStringTaggedText(const LineString *lineString, int p_level,
Writer *writer)
{
writer->write("LINESTRING ");
if( outputDimension == 3 && !old3D && !lineString->isEmpty() )
writer->write( "Z " );
- appendLineStringText(lineString, level, false, writer);
+ appendLineStringText(lineString, p_level, false, writer);
}
/*
@@ -260,46 +260,46 @@ WKTWriter::appendLineStringTaggedText(const LineString *lineString, int level,
* @param linearRing the <code>LinearRing</code> to process
* @param writer the output writer to append to
*/
-void WKTWriter::appendLinearRingTaggedText(const LinearRing* linearRing, int level, Writer *writer) {
+void WKTWriter::appendLinearRingTaggedText(const LinearRing* linearRing, int p_level, Writer *writer) {
writer->write("LINEARRING ");
if( outputDimension == 3 && !old3D && !linearRing->isEmpty() )
writer->write( "Z " );
- appendLineStringText((LineString*)linearRing, level, false, writer);
+ appendLineStringText((LineString*)linearRing, p_level, false, writer);
}
-void WKTWriter::appendPolygonTaggedText(const Polygon *polygon, int level, Writer *writer) {
+void WKTWriter::appendPolygonTaggedText(const Polygon *polygon, int p_level, Writer *writer) {
writer->write("POLYGON ");
if( outputDimension == 3 && !old3D && !polygon->isEmpty())
writer->write( "Z " );
- appendPolygonText(polygon, level, false, writer);
+ appendPolygonText(polygon, p_level, false, writer);
}
-void WKTWriter::appendMultiPointTaggedText(const MultiPoint *multipoint, int level, Writer *writer) {
+void WKTWriter::appendMultiPointTaggedText(const MultiPoint *multipoint, int p_level, Writer *writer) {
writer->write("MULTIPOINT ");
if( outputDimension == 3 && !old3D && !multipoint->isEmpty() )
writer->write( "Z " );
- appendMultiPointText(multipoint, level, writer);
+ appendMultiPointText(multipoint, p_level, writer);
}
-void WKTWriter::appendMultiLineStringTaggedText(const MultiLineString *multiLineString, int level,Writer *writer) {
+void WKTWriter::appendMultiLineStringTaggedText(const MultiLineString *multiLineString, int p_level,Writer *writer) {
writer->write("MULTILINESTRING ");
if( outputDimension == 3 && !old3D && !multiLineString->isEmpty() )
writer->write( "Z " );
- appendMultiLineStringText(multiLineString, level, false, writer);
+ appendMultiLineStringText(multiLineString, p_level, false, writer);
}
-void WKTWriter::appendMultiPolygonTaggedText(const MultiPolygon *multiPolygon, int level, Writer *writer) {
+void WKTWriter::appendMultiPolygonTaggedText(const MultiPolygon *multiPolygon, int p_level, Writer *writer) {
writer->write("MULTIPOLYGON ");
if( outputDimension == 3 && !old3D && !multiPolygon->isEmpty() )
writer->write( "Z " );
- appendMultiPolygonText(multiPolygon, level, writer);
+ appendMultiPolygonText(multiPolygon, p_level, writer);
}
-void WKTWriter::appendGeometryCollectionTaggedText(const GeometryCollection *geometryCollection, int level,Writer *writer) {
+void WKTWriter::appendGeometryCollectionTaggedText(const GeometryCollection *geometryCollection, int p_level,Writer *writer) {
writer->write("GEOMETRYCOLLECTION ");
if( outputDimension == 3 && !old3D && !geometryCollection->isEmpty() )
writer->write( "Z " );
- appendGeometryCollectionText(geometryCollection, level, writer);
+ appendGeometryCollectionText(geometryCollection, p_level, writer);
}
void
@@ -346,19 +346,19 @@ WKTWriter::writeNumber(double d) {
}
void
-WKTWriter::appendLineStringText(const LineString *lineString, int level,
+WKTWriter::appendLineStringText(const LineString *lineString, int p_level,
bool doIndent, Writer *writer)
{
if (lineString->isEmpty()) {
writer->write("EMPTY");
} else {
- if (doIndent) indent(level, writer);
+ if (doIndent) indent(p_level, writer);
writer->write("(");
for(size_t i=0, n=lineString->getNumPoints(); i<n; ++i)
{
if (i>0) {
writer->write(", ");
- if (i%10==0) indent(level + 2, writer);
+ if (i%10==0) indent(p_level + 2, writer);
}
appendCoordinate(&(lineString->getCoordinateN(i)), writer);
}
@@ -407,12 +407,12 @@ WKTWriter::appendMultiPointText(const MultiPoint *multiPoint,
}
}
-void WKTWriter::appendMultiLineStringText(const MultiLineString *multiLineString, int level, bool indentFirst,
+void WKTWriter::appendMultiLineStringText(const MultiLineString *multiLineString, int p_level, bool indentFirst,
Writer *writer) {
if (multiLineString->isEmpty()) {
writer->write("EMPTY");
} else {
- int level2=level;
+ int level2=p_level;
bool doIndent=indentFirst;
writer->write("(");
for (size_t i = 0, n = multiLineString->getNumGeometries();
@@ -420,7 +420,7 @@ void WKTWriter::appendMultiLineStringText(const MultiLineString *multiLineString
{
if (i>0) {
writer->write(", ");
- level2=level+1;
+ level2=p_level+1;
doIndent=true;
}
const LineString* ls = dynamic_cast<const LineString *>(
@@ -432,11 +432,11 @@ void WKTWriter::appendMultiLineStringText(const MultiLineString *multiLineString
}
}
-void WKTWriter::appendMultiPolygonText(const MultiPolygon *multiPolygon, int level, Writer *writer) {
+void WKTWriter::appendMultiPolygonText(const MultiPolygon *multiPolygon, int p_level, Writer *writer) {
if (multiPolygon->isEmpty()) {
writer->write("EMPTY");
} else {
- int level2=level;
+ int level2=p_level;
bool doIndent=false;
writer->write("(");
for (size_t i = 0, n = multiPolygon->getNumGeometries();
@@ -444,7 +444,7 @@ void WKTWriter::appendMultiPolygonText(const MultiPolygon *multiPolygon, int lev
{
if (i>0) {
writer->write(", ");
- level2=level+1;
+ level2=p_level+1;
doIndent=true;
}
const Polygon *p = dynamic_cast<const Polygon *>(
@@ -459,20 +459,20 @@ void WKTWriter::appendMultiPolygonText(const MultiPolygon *multiPolygon, int lev
void
WKTWriter::appendGeometryCollectionText(
const GeometryCollection *geometryCollection,
- int level,
+ int p_level,
Writer *writer)
{
if (geometryCollection->isEmpty()) {
writer->write("EMPTY");
} else {
- int level2=level;
+ int level2=p_level;
writer->write("(");
for (size_t i = 0, n = geometryCollection->getNumGeometries();
i < n; ++i)
{
if (i>0) {
writer->write(", ");
- level2=level+1;
+ level2=p_level+1;
}
appendGeometryTaggedText(geometryCollection->getGeometryN(i),level2,writer);
}
@@ -480,10 +480,10 @@ WKTWriter::appendGeometryCollectionText(
}
}
-void WKTWriter::indent(int level, Writer *writer) {
- if (!isFormatted || level<=0) return;
+void WKTWriter::indent(int p_level, Writer *writer) {
+ if (!isFormatted || p_level<=0) return;
writer->write("\n");
- writer->write(string(INDENT * level, ' '));
+ writer->write(string(INDENT * p_level, ' '));
}
} // namespace geos.io
diff --git a/src/linearref/ExtractLineByLocation.cpp b/src/linearref/ExtractLineByLocation.cpp
index 11ec0e0..6acc12b 100644
--- a/src/linearref/ExtractLineByLocation.cpp
+++ b/src/linearref/ExtractLineByLocation.cpp
@@ -47,8 +47,8 @@ Geometry *ExtractLineByLocation::extract(const Geometry *line, const LinearLocat
return ls.extract(start, end);
}
-ExtractLineByLocation::ExtractLineByLocation(const Geometry *line) :
- line(line) {}
+ExtractLineByLocation::ExtractLineByLocation(const Geometry *p_line) :
+ line(p_line) {}
Geometry *ExtractLineByLocation::extract(const LinearLocation& start, const LinearLocation& end)
diff --git a/src/linearref/LengthIndexOfPoint.cpp b/src/linearref/LengthIndexOfPoint.cpp
index cdfd9df..f7698d9 100644
--- a/src/linearref/LengthIndexOfPoint.cpp
+++ b/src/linearref/LengthIndexOfPoint.cpp
@@ -47,8 +47,8 @@ double LengthIndexOfPoint::indexOfAfter(const Geometry *linearGeom, const Coordi
return locater.indexOfAfter(inputPt, minIndex);
}
-LengthIndexOfPoint::LengthIndexOfPoint(const Geometry *linearGeom):
- linearGeom(linearGeom) {}
+LengthIndexOfPoint::LengthIndexOfPoint(const Geometry *p_linearGeom):
+ linearGeom(p_linearGeom) {}
double LengthIndexOfPoint::indexOf(const Coordinate& inputPt) const
{
diff --git a/src/linearref/LengthIndexedLine.cpp b/src/linearref/LengthIndexedLine.cpp
index 7986a65..4265b12 100644
--- a/src/linearref/LengthIndexedLine.cpp
+++ b/src/linearref/LengthIndexedLine.cpp
@@ -35,8 +35,8 @@ namespace geos
namespace linearref // geos.linearref
{
-LengthIndexedLine::LengthIndexedLine(const Geometry* linearGeom) :
- linearGeom(linearGeom) {}
+LengthIndexedLine::LengthIndexedLine(const Geometry* p_linearGeom) :
+ linearGeom(p_linearGeom) {}
Coordinate LengthIndexedLine::extractPoint(double index) const
{
diff --git a/src/linearref/LengthLocationMap.cpp b/src/linearref/LengthLocationMap.cpp
index c60fafe..0e60071 100644
--- a/src/linearref/LengthLocationMap.cpp
+++ b/src/linearref/LengthLocationMap.cpp
@@ -41,8 +41,8 @@ double LengthLocationMap::getLength(const Geometry* linearGeom, const LinearLoca
}
-LengthLocationMap::LengthLocationMap(const Geometry* linearGeom) :
- linearGeom(linearGeom) {}
+LengthLocationMap::LengthLocationMap(const Geometry* p_linearGeom) :
+ linearGeom(p_linearGeom) {}
LinearLocation
LengthLocationMap::getLocation(double length) const
diff --git a/src/linearref/LinearGeometryBuilder.cpp b/src/linearref/LinearGeometryBuilder.cpp
index bc88c6e..f05ada8 100644
--- a/src/linearref/LinearGeometryBuilder.cpp
+++ b/src/linearref/LinearGeometryBuilder.cpp
@@ -41,24 +41,24 @@ namespace linearref // geos.linearref
{
/* public */
-LinearGeometryBuilder::LinearGeometryBuilder(const GeometryFactory* geomFact) :
- geomFact(geomFact),
+LinearGeometryBuilder::LinearGeometryBuilder(const GeometryFactory* p_geomFact) :
+ geomFact(p_geomFact),
ignoreInvalidLines(false),
fixInvalidLines(false),
coordList(nullptr) {}
/* public */
void
-LinearGeometryBuilder::setIgnoreInvalidLines(bool ignoreInvalidLines)
+LinearGeometryBuilder::setIgnoreInvalidLines(bool p_ignoreInvalidLines)
{
- this->ignoreInvalidLines = ignoreInvalidLines;
+ this->ignoreInvalidLines = p_ignoreInvalidLines;
}
/* public */
void
-LinearGeometryBuilder::setFixInvalidLines(bool fixInvalidLines)
+LinearGeometryBuilder::setFixInvalidLines(bool p_fixInvalidLines)
{
- this->fixInvalidLines = fixInvalidLines;
+ this->fixInvalidLines = p_fixInvalidLines;
}
/* public */
diff --git a/src/linearref/LinearIterator.cpp b/src/linearref/LinearIterator.cpp
index a1cd0b4..60783e9 100644
--- a/src/linearref/LinearIterator.cpp
+++ b/src/linearref/LinearIterator.cpp
@@ -38,30 +38,30 @@ size_t LinearIterator::segmentEndVertexIndex(const LinearLocation& loc)
return loc.getSegmentIndex();
}
-LinearIterator::LinearIterator(const Geometry* linear) :
+LinearIterator::LinearIterator(const Geometry* p_linear) :
vertexIndex(0),
componentIndex(0),
- linear(linear),
- numLines(linear->getNumGeometries())
+ linear(p_linear),
+ numLines(p_linear->getNumGeometries())
{
loadCurrentLine();
}
-LinearIterator::LinearIterator(const Geometry* linear, const LinearLocation& start):
+LinearIterator::LinearIterator(const Geometry* p_linear, const LinearLocation& start):
vertexIndex(segmentEndVertexIndex(start)),
componentIndex(start.getComponentIndex()),
- linear(linear),
- numLines(linear->getNumGeometries())
+ linear(p_linear),
+ numLines(p_linear->getNumGeometries())
{
loadCurrentLine();
}
-LinearIterator::LinearIterator(const Geometry* linear, size_t componentIndex, size_t vertexIndex) :
- vertexIndex(vertexIndex),
- componentIndex(componentIndex),
- linear(linear),
- numLines(linear->getNumGeometries())
+LinearIterator::LinearIterator(const Geometry* p_linear, size_t p_componentIndex, size_t p_vertexIndex) :
+ vertexIndex(p_vertexIndex),
+ componentIndex(p_componentIndex),
+ linear(p_linear),
+ numLines(p_linear->getNumGeometries())
{
loadCurrentLine();
}
diff --git a/src/linearref/LinearLocation.cpp b/src/linearref/LinearLocation.cpp
index 16bd4b3..b413b76 100644
--- a/src/linearref/LinearLocation.cpp
+++ b/src/linearref/LinearLocation.cpp
@@ -56,22 +56,22 @@ LinearLocation::pointAlongSegmentByFraction(const Coordinate& p0, const Coordina
}
/* public */
-LinearLocation::LinearLocation(size_t segmentIndex,
- double segmentFraction)
+LinearLocation::LinearLocation(size_t p_segmentIndex,
+ double p_segmentFraction)
:
componentIndex(0),
- segmentIndex(segmentIndex),
- segmentFraction(segmentFraction)
+ segmentIndex(p_segmentIndex),
+ segmentFraction(p_segmentFraction)
{}
/* public */
-LinearLocation::LinearLocation(size_t componentIndex,
- size_t segmentIndex, double segmentFraction)
+LinearLocation::LinearLocation(size_t p_componentIndex,
+ size_t p_segmentIndex, double p_segmentFraction)
:
- componentIndex(componentIndex),
- segmentIndex(segmentIndex),
- segmentFraction(segmentFraction)
+ componentIndex(p_componentIndex),
+ segmentIndex(p_segmentIndex),
+ segmentFraction(p_segmentFraction)
{
normalize();
}
diff --git a/src/linearref/LocationIndexOfLine.cpp b/src/linearref/LocationIndexOfLine.cpp
index 7b00513..f438e1e 100644
--- a/src/linearref/LocationIndexOfLine.cpp
+++ b/src/linearref/LocationIndexOfLine.cpp
@@ -41,8 +41,8 @@ LocationIndexOfLine::indicesOf(const Geometry* linearGeom,
return locater.indicesOf(subLine);
}
-LocationIndexOfLine::LocationIndexOfLine(const Geometry* linearGeom) :
- linearGeom(linearGeom) {}
+LocationIndexOfLine::LocationIndexOfLine(const Geometry* p_linearGeom) :
+ linearGeom(p_linearGeom) {}
/* public */
LinearLocation*
diff --git a/src/linearref/LocationIndexOfPoint.cpp b/src/linearref/LocationIndexOfPoint.cpp
index bed28d5..860d4b6 100644
--- a/src/linearref/LocationIndexOfPoint.cpp
+++ b/src/linearref/LocationIndexOfPoint.cpp
@@ -91,8 +91,8 @@ LinearLocation LocationIndexOfPoint::indexOfAfter(const Geometry *linearGeom, co
return locater.indexOfAfter(inputPt, minIndex);
}
-LocationIndexOfPoint::LocationIndexOfPoint(const Geometry *linearGeom) :
- linearGeom(linearGeom)
+LocationIndexOfPoint::LocationIndexOfPoint(const Geometry *p_linearGeom) :
+ linearGeom(p_linearGeom)
{}
LinearLocation LocationIndexOfPoint::indexOf(const Coordinate& inputPt) const
diff --git a/src/noding/GeometryNoder.cpp b/src/noding/GeometryNoder.cpp
index ac1b43c..7abc845 100644
--- a/src/noding/GeometryNoder.cpp
+++ b/src/noding/GeometryNoder.cpp
@@ -119,20 +119,20 @@ GeometryNoder::toGeometry(SegmentString::NonConstVect& nodedEdges)
std::unique_ptr<geom::Geometry>
GeometryNoder::getNoded()
{
- SegmentString::NonConstVect lineList;
- extractSegmentStrings(argGeom, lineList);
+ SegmentString::NonConstVect p_lineList;
+ extractSegmentStrings(argGeom, p_lineList);
- Noder& noder = getNoder();
+ Noder& p_noder = getNoder();
SegmentString::NonConstVect* nodedEdges = nullptr;
try {
- noder.computeNodes( &lineList );
- nodedEdges = noder.getNodedSubstrings();
+ p_noder.computeNodes( &p_lineList );
+ nodedEdges = p_noder.getNodedSubstrings();
}
catch (const std::exception& ex)
{
- for (size_t i=0, n=lineList.size(); i<n; ++i)
- delete lineList[i];
+ for (size_t i=0, n=p_lineList.size(); i<n; ++i)
+ delete p_lineList[i];
throw;
}
diff --git a/src/noding/NodingValidator.cpp b/src/noding/NodingValidator.cpp
index 906294d..5741725 100644
--- a/src/noding/NodingValidator.cpp
+++ b/src/noding/NodingValidator.cpp
@@ -162,10 +162,10 @@ NodingValidator::checkEndPtVertexIntersections() const
/* private */
void
NodingValidator::checkEndPtVertexIntersections(const Coordinate& testPt,
- const SegmentString::NonConstVect& segStrings) const
+ const SegmentString::NonConstVect& p_segStrings) const
{
for (SegmentString::NonConstVect::const_iterator
- it = segStrings.begin(), itEnd = segStrings.end();
+ it = p_segStrings.begin(), itEnd = p_segStrings.end();
it != itEnd;
++it)
{
diff --git a/src/noding/snapround/HotPixel.cpp b/src/noding/snapround/HotPixel.cpp
index bc7156d..2ee9af0 100644
--- a/src/noding/snapround/HotPixel.cpp
+++ b/src/noding/snapround/HotPixel.cpp
@@ -71,13 +71,13 @@ HotPixel::getSafeEnvelope() const
/*private*/
void
-HotPixel::initCorners(const Coordinate& pt)
+HotPixel::initCorners(const Coordinate& p_pt)
{
double tolerance = 0.5;
- minx = pt.x - tolerance;
- maxx = pt.x + tolerance;
- miny = pt.y - tolerance;
- maxy = pt.y + tolerance;
+ minx = p_pt.x - tolerance;
+ maxx = p_pt.x + tolerance;
+ miny = p_pt.y - tolerance;
+ maxy = p_pt.y + tolerance;
corner.resize(4);
corner[0] = Coordinate(maxx, maxy);
diff --git a/src/noding/snapround/SimpleSnapRounder.cpp b/src/noding/snapround/SimpleSnapRounder.cpp
index ba3ff60..658f32b 100644
--- a/src/noding/snapround/SimpleSnapRounder.cpp
+++ b/src/noding/snapround/SimpleSnapRounder.cpp
@@ -196,12 +196,12 @@ SimpleSnapRounder::computeVertexSnaps(const SegmentString::NonConstVect& edges)
/*private*/
void
SimpleSnapRounder::snapRound(SegmentString::NonConstVect* segStrings,
- LineIntersector& li)
+ LineIntersector& p_li)
{
assert(segStrings);
vector<Coordinate> intersections;
- findInteriorIntersections(*segStrings, li, intersections);
+ findInteriorIntersections(*segStrings, p_li, intersections);
computeSnaps(*segStrings, intersections);
computeVertexSnaps(*segStrings);
}
@@ -210,9 +210,9 @@ SimpleSnapRounder::snapRound(SegmentString::NonConstVect* segStrings,
void
SimpleSnapRounder::findInteriorIntersections(
SegmentString::NonConstVect& segStrings,
- LineIntersector& li, vector<Coordinate>& ret)
+ LineIntersector& p_li, vector<Coordinate>& ret)
{
- IntersectionFinderAdder intFinderAdder(li, ret);
+ IntersectionFinderAdder intFinderAdder(p_li, ret);
MCIndexNoder noder;
noder.setSegmentIntersector(&intFinderAdder);
noder.computeNodes(&segStrings);
diff --git a/src/operation/IsSimpleOp.cpp b/src/operation/IsSimpleOp.cpp
index 520f751..c279636 100644
--- a/src/operation/IsSimpleOp.cpp
+++ b/src/operation/IsSimpleOp.cpp
@@ -124,16 +124,16 @@ IsSimpleOp::isSimple()
/*public*/
bool
-IsSimpleOp::isSimple(const LineString *geom)
+IsSimpleOp::isSimple(const LineString *p_geom)
{
- return isSimpleLinearGeometry(geom);
+ return isSimpleLinearGeometry(p_geom);
}
/*public*/
bool
-IsSimpleOp::isSimple(const MultiLineString *geom)
+IsSimpleOp::isSimple(const MultiLineString *p_geom)
{
- return isSimpleLinearGeometry(geom);
+ return isSimpleLinearGeometry(p_geom);
}
/*public*/
@@ -166,10 +166,10 @@ IsSimpleOp::isSimpleMultiPoint(const MultiPoint& mp)
}
bool
-IsSimpleOp::isSimpleLinearGeometry(const Geometry *geom)
+IsSimpleOp::isSimpleLinearGeometry(const Geometry *p_geom)
{
- if (geom->isEmpty()) return true;
- GeometryGraph graph(0,geom);
+ if (p_geom->isEmpty()) return true;
+ GeometryGraph graph(0,p_geom);
LineIntersector li;
std::unique_ptr<SegmentIntersector> si (graph.computeSelfNodes(&li,true));
diff --git a/src/operation/buffer/BufferInputLineSimplifier.cpp b/src/operation/buffer/BufferInputLineSimplifier.cpp
index 6b9d147..1276a14 100644
--- a/src/operation/buffer/BufferInputLineSimplifier.cpp
+++ b/src/operation/buffer/BufferInputLineSimplifier.cpp
@@ -138,19 +138,19 @@ BufferInputLineSimplifier::collapseLine() const
/* private */
bool
BufferInputLineSimplifier::isDeletable(size_t i0, size_t i1, size_t i2,
- double distanceTol) const
+ double p_distanceTol) const
{
const Coordinate& p0 = inputLine[i0];
const Coordinate& p1 = inputLine[i1];
const Coordinate& p2 = inputLine[i2];
if (! isConcave(p0, p1, p2)) return false;
- if (! isShallow(p0, p1, p2, distanceTol)) return false;
+ if (! isShallow(p0, p1, p2, p_distanceTol)) return false;
// MD - don't use this heuristic - it's too restricting
// if (p0.distance(p2) > distanceTol) return false;
- return isShallowSampled(p0, p1, i0, i2, distanceTol);
+ return isShallowSampled(p0, p1, i0, i2, p_distanceTol);
}
/* private */
@@ -158,7 +158,7 @@ bool
BufferInputLineSimplifier::isShallowConcavity(const geom::Coordinate& p0,
const geom::Coordinate& p1,
const geom::Coordinate& p2,
- double distanceTol) const
+ double p_distanceTol) const
{
int orientation = CGAlgorithms::computeOrientation(p0, p1, p2);
bool isAngleToSimplify = (orientation == angleOrientation);
@@ -166,7 +166,7 @@ BufferInputLineSimplifier::isShallowConcavity(const geom::Coordinate& p0,
return false;
double dist = CGAlgorithms::distancePointLine(p1, p0, p2);
- return dist < distanceTol;
+ return dist < p_distanceTol;
}
/* private */
@@ -174,14 +174,14 @@ bool
BufferInputLineSimplifier::isShallowSampled(const geom::Coordinate& p0,
const geom::Coordinate& p2,
size_t i0, size_t i2,
- double distanceTol) const
+ double p_distanceTol) const
{
// check every n'th point to see if it is within tolerance
auto inc = (i2 - i0) / NUM_PTS_TO_CHECK;
if (inc <= 0) inc = 1;
for (size_t i = i0; i < i2; i += inc) {
- if (! isShallow(p0, p2, inputLine[i], distanceTol))
+ if (! isShallow(p0, p2, inputLine[i], p_distanceTol))
return false;
}
return true;
@@ -192,10 +192,10 @@ bool
BufferInputLineSimplifier::isShallow(const geom::Coordinate& p0,
const geom::Coordinate& p1,
const geom::Coordinate& p2,
- double distanceTol) const
+ double p_distanceTol) const
{
double dist = CGAlgorithms::distancePointLine(p1, p0, p2);
- return dist < distanceTol;
+ return dist < p_distanceTol;
}
/* private */
diff --git a/src/operation/buffer/BufferParameters.cpp b/src/operation/buffer/BufferParameters.cpp
index c519a05..d9b1bee 100644
--- a/src/operation/buffer/BufferParameters.cpp
+++ b/src/operation/buffer/BufferParameters.cpp
@@ -45,7 +45,7 @@ BufferParameters::BufferParameters()
{}
// public
-BufferParameters::BufferParameters(int quadrantSegments)
+BufferParameters::BufferParameters(int p_quadrantSegments)
:
quadrantSegments(DEFAULT_QUADRANT_SEGMENTS),
endCapStyle(CAP_ROUND),
@@ -53,12 +53,12 @@ BufferParameters::BufferParameters(int quadrantSegments)
mitreLimit(DEFAULT_MITRE_LIMIT),
_isSingleSided(false)
{
- setQuadrantSegments(quadrantSegments);
+ setQuadrantSegments(p_quadrantSegments);
}
// public
-BufferParameters::BufferParameters(int quadrantSegments,
- EndCapStyle endCapStyle)
+BufferParameters::BufferParameters(int p_quadrantSegments,
+ EndCapStyle p_endCapStyle)
:
quadrantSegments(DEFAULT_QUADRANT_SEGMENTS),
endCapStyle(CAP_ROUND),
@@ -66,15 +66,15 @@ BufferParameters::BufferParameters(int quadrantSegments,
mitreLimit(DEFAULT_MITRE_LIMIT),
_isSingleSided(false)
{
- setQuadrantSegments(quadrantSegments);
- setEndCapStyle(endCapStyle);
+ setQuadrantSegments(p_quadrantSegments);
+ setEndCapStyle(p_endCapStyle);
}
// public
-BufferParameters::BufferParameters(int quadrantSegments,
- EndCapStyle endCapStyle,
- JoinStyle joinStyle,
- double mitreLimit)
+BufferParameters::BufferParameters(int p_quadrantSegments,
+ EndCapStyle p_endCapStyle,
+ JoinStyle p_joinStyle,
+ double p_mitreLimit)
:
quadrantSegments(DEFAULT_QUADRANT_SEGMENTS),
endCapStyle(CAP_ROUND),
@@ -82,10 +82,10 @@ BufferParameters::BufferParameters(int quadrantSegments,
mitreLimit(DEFAULT_MITRE_LIMIT),
_isSingleSided(false)
{
- setQuadrantSegments(quadrantSegments);
- setEndCapStyle(endCapStyle);
- setJoinStyle(joinStyle);
- setMitreLimit(mitreLimit);
+ setQuadrantSegments(p_quadrantSegments);
+ setEndCapStyle(p_endCapStyle);
+ setJoinStyle(p_joinStyle);
+ setMitreLimit(p_mitreLimit);
}
// public
diff --git a/src/operation/buffer/OffsetCurveBuilder.cpp b/src/operation/buffer/OffsetCurveBuilder.cpp
index a9cd15f..54b48ba 100644
--- a/src/operation/buffer/OffsetCurveBuilder.cpp
+++ b/src/operation/buffer/OffsetCurveBuilder.cpp
@@ -104,11 +104,11 @@ OffsetCurveBuilder::computePointCurve(const Coordinate& pt,
/*public*/
void
OffsetCurveBuilder::getSingleSidedLineCurve(const CoordinateSequence* inputPts,
- double distance, vector<CoordinateSequence*>& lineList, bool leftSide,
+ double p_distance, vector<CoordinateSequence*>& lineList, bool leftSide,
bool rightSide)
{
// A zero or negative width buffer of a line/point is empty.
- if ( distance <= 0.0 ) return ;
+ if ( p_distance <= 0.0 ) return ;
if ( inputPts->getSize() < 2 )
{
@@ -116,9 +116,9 @@ OffsetCurveBuilder::getSingleSidedLineCurve(const CoordinateSequence* inputPts,
return ;
}
- double distTol = simplifyTolerance(distance);
+ double distTol = simplifyTolerance(p_distance);
- std::unique_ptr<OffsetSegmentGenerator> segGen = getSegGen(distance);
+ std::unique_ptr<OffsetSegmentGenerator> segGen = getSegGen(p_distance);
if ( leftSide ) {
//--------- compute points for left side of line
diff --git a/src/operation/buffer/OffsetSegmentGenerator.cpp b/src/operation/buffer/OffsetSegmentGenerator.cpp
index b67e177..12afdac 100644
--- a/src/operation/buffer/OffsetSegmentGenerator.cpp
+++ b/src/operation/buffer/OffsetSegmentGenerator.cpp
@@ -173,17 +173,17 @@ OffsetSegmentGenerator::addNextSegment(const Coordinate &p, bool addStartPoint)
/*private*/
void
-OffsetSegmentGenerator::computeOffsetSegment(const LineSegment& seg, int side,
- double distance, LineSegment& offset)
+OffsetSegmentGenerator::computeOffsetSegment(const LineSegment& seg, int p_side,
+ double p_distance, LineSegment& offset)
{
- int sideSign = side == Position::LEFT ? 1 : -1;
+ int sideSign = p_side == Position::LEFT ? 1 : -1;
double dx = seg.p1.x - seg.p0.x;
double dy = seg.p1.y - seg.p0.y;
double len = sqrt(dx * dx + dy * dy);
// u is the vector that is the length of the offset,
// in the direction of the segment
- double ux = sideSign * distance * dx / len;
- double uy = sideSign * distance * dy / len;
+ double ux = sideSign * p_distance * dx / len;
+ double uy = sideSign * p_distance * dy / len;
offset.p0.x = seg.p0.x - uy;
offset.p0.y = seg.p0.y + ux;
offset.p1.x = seg.p1.x - uy;
@@ -294,23 +294,23 @@ OffsetSegmentGenerator::addFillet(const Coordinate &p, double startAngle,
/*private*/
void
-OffsetSegmentGenerator::createCircle(const Coordinate &p, double distance)
+OffsetSegmentGenerator::createCircle(const Coordinate &p, double p_distance)
{
// add start point
- Coordinate pt(p.x + distance, p.y);
+ Coordinate pt(p.x + p_distance, p.y);
segList.addPt(pt);
- addFillet(p, 0.0, 2.0*PI, -1, distance);
+ addFillet(p, 0.0, 2.0*PI, -1, p_distance);
segList.closeRing();
}
/*private*/
void
-OffsetSegmentGenerator::createSquare(const Coordinate &p, double distance)
+OffsetSegmentGenerator::createSquare(const Coordinate &p, double p_distance)
{
- segList.addPt(Coordinate(p.x+distance, p.y+distance));
- segList.addPt(Coordinate(p.x+distance, p.y-distance));
- segList.addPt(Coordinate(p.x-distance, p.y-distance));
- segList.addPt(Coordinate(p.x-distance, p.y+distance));
+ segList.addPt(Coordinate(p.x+p_distance, p.y+p_distance));
+ segList.addPt(Coordinate(p.x+p_distance, p.y-p_distance));
+ segList.addPt(Coordinate(p.x-p_distance, p.y-p_distance));
+ segList.addPt(Coordinate(p.x-p_distance, p.y+p_distance));
segList.closeRing();
}
@@ -481,9 +481,9 @@ OffsetSegmentGenerator::addInsideTurn(int orientation, bool addStartPoint)
/* private */
void
OffsetSegmentGenerator::addMitreJoin(const geom::Coordinate& p,
- const geom::LineSegment& offset0,
- const geom::LineSegment& offset1,
- double distance)
+ const geom::LineSegment& p_offset0,
+ const geom::LineSegment& p_offset1,
+ double p_distance)
{
bool isMitreWithinLimit = true;
Coordinate intPt;
@@ -497,12 +497,12 @@ OffsetSegmentGenerator::addMitreJoin(const geom::Coordinate& p,
*/
try
{
- HCoordinate::intersection(offset0.p0, offset0.p1,
- offset1.p0, offset1.p1,
+ HCoordinate::intersection(p_offset0.p0, p_offset0.p1,
+ p_offset1.p0, p_offset1.p1,
intPt);
- double mitreRatio = distance <= 0.0 ? 1.0
- : intPt.distance(p) / fabs(distance);
+ double mitreRatio = p_distance <= 0.0 ? 1.0
+ : intPt.distance(p) / fabs(p_distance);
if (mitreRatio > bufParams.getMitreLimit())
isMitreWithinLimit = false;
@@ -521,7 +521,7 @@ OffsetSegmentGenerator::addMitreJoin(const geom::Coordinate& p,
}
else
{
- addLimitedMitreJoin(offset0, offset1, distance,
+ addLimitedMitreJoin(p_offset0, p_offset1, p_distance,
bufParams.getMitreLimit());
//addBevelJoin(offset0, offset1);
}
@@ -530,12 +530,12 @@ OffsetSegmentGenerator::addMitreJoin(const geom::Coordinate& p,
/* private */
void
OffsetSegmentGenerator::addLimitedMitreJoin(
- const geom::LineSegment& offset0,
- const geom::LineSegment& offset1,
- double distance, double mitreLimit)
+ const geom::LineSegment& p_offset0,
+ const geom::LineSegment& p_offset1,
+ double p_distance, double p_mitreLimit)
{
- ::geos::ignore_unused_variable_warning(offset0);
- ::geos::ignore_unused_variable_warning(offset1);
+ ::geos::ignore_unused_variable_warning(p_offset0);
+ ::geos::ignore_unused_variable_warning(p_offset1);
const Coordinate& basePt = seg0.p1;
@@ -553,11 +553,11 @@ OffsetSegmentGenerator::addLimitedMitreJoin(
double mitreMidAng = Angle::normalize(midAng + PI);
// the miterLimit determines the distance to the mitre bevel
- double mitreDist = mitreLimit * distance;
+ double mitreDist = p_mitreLimit * p_distance;
// the bevel delta is the difference between the buffer distance
// and half of the length of the bevel segment
double bevelDelta = mitreDist * fabs(sin(angDiffHalf));
- double bevelHalfLen = distance - bevelDelta;
+ double bevelHalfLen = p_distance - bevelDelta;
// compute the midpoint of the bevel segment
double bevelMidX = basePt.x + mitreDist * cos(mitreMidAng);
@@ -588,11 +588,11 @@ OffsetSegmentGenerator::addLimitedMitreJoin(
/* private */
void
-OffsetSegmentGenerator::addBevelJoin( const geom::LineSegment& offset0,
- const geom::LineSegment& offset1)
+OffsetSegmentGenerator::addBevelJoin( const geom::LineSegment& p_offset0,
+ const geom::LineSegment& p_offset1)
{
- segList.addPt(offset0.p1);
- segList.addPt(offset1.p0);
+ segList.addPt(p_offset0.p1);
+ segList.addPt(p_offset1.p0);
}
} // namespace geos.operation.buffer
diff --git a/src/operation/distance/FacetSequence.cpp b/src/operation/distance/FacetSequence.cpp
index 12fbd7e..72501d9 100644
--- a/src/operation/distance/FacetSequence.cpp
+++ b/src/operation/distance/FacetSequence.cpp
@@ -23,10 +23,10 @@ using namespace geos::geom;
using namespace geos::operation::distance;
using namespace geos::algorithm;
-FacetSequence::FacetSequence(const CoordinateSequence* pts, size_t start, size_t end) :
- pts(pts),
- start(start),
- end(end) {
+FacetSequence::FacetSequence(const CoordinateSequence* p_pts, size_t p_start, size_t p_end) :
+ pts(p_pts),
+ start(p_start),
+ end(p_end) {
computeEnvelope();
}
diff --git a/src/operation/intersection/RectangleIntersection.cpp b/src/operation/intersection/RectangleIntersection.cpp
index aba0408..df4e8f4 100644
--- a/src/operation/intersection/RectangleIntersection.cpp
+++ b/src/operation/intersection/RectangleIntersection.cpp
@@ -644,20 +644,20 @@ RectangleIntersection::clip_geom(const geom::Geometry * g,
const Rectangle & rect,
bool keep_polygons)
{
- if ( const Point* p = dynamic_cast<const geom::Point *>(g) )
- return clip_point(p, parts, rect);
- else if ( const MultiPoint* p = dynamic_cast<const geom::MultiPoint *>(g) )
- return clip_multipoint(p, parts, rect);
- else if ( const LineString* p = dynamic_cast<const geom::LineString *>(g) )
- return clip_linestring(p, parts, rect);
- else if ( const MultiLineString* p = dynamic_cast<const geom::MultiLineString *>(g) )
- return clip_multilinestring(p, parts, rect);
- else if ( const Polygon* p = dynamic_cast<const geom::Polygon *>(g) )
- return clip_polygon(p, parts, rect, keep_polygons);
- else if ( const MultiPolygon* p = dynamic_cast<const geom::MultiPolygon *>(g) )
- return clip_multipolygon(p, parts, rect, keep_polygons);
- else if ( const GeometryCollection* p = dynamic_cast<const geom::GeometryCollection *>(g) )
- return clip_geometrycollection(p, parts, rect, keep_polygons);
+ if ( const Point* p1 = dynamic_cast<const geom::Point *>(g) )
+ return clip_point(p1, parts, rect);
+ else if ( const MultiPoint* p2 = dynamic_cast<const geom::MultiPoint *>(g) )
+ return clip_multipoint(p2, parts, rect);
+ else if ( const LineString* p3 = dynamic_cast<const geom::LineString *>(g) )
+ return clip_linestring(p3, parts, rect);
+ else if ( const MultiLineString* p4 = dynamic_cast<const geom::MultiLineString *>(g) )
+ return clip_multilinestring(p4, parts, rect);
+ else if ( const Polygon* p5 = dynamic_cast<const geom::Polygon *>(g) )
+ return clip_polygon(p5, parts, rect, keep_polygons);
+ else if ( const MultiPolygon* p6 = dynamic_cast<const geom::MultiPolygon *>(g) )
+ return clip_multipolygon(p6, parts, rect, keep_polygons);
+ else if ( const GeometryCollection* p7 = dynamic_cast<const geom::GeometryCollection *>(g) )
+ return clip_geometrycollection(p7, parts, rect, keep_polygons);
else {
throw util::UnsupportedOperationException("Encountered an unknown geometry component when clipping polygons");
}
diff --git a/src/operation/intersection/RectangleIntersectionBuilder.cpp b/src/operation/intersection/RectangleIntersectionBuilder.cpp
index 777b246..a83ab0b 100644
--- a/src/operation/intersection/RectangleIntersectionBuilder.cpp
+++ b/src/operation/intersection/RectangleIntersectionBuilder.cpp
@@ -475,9 +475,9 @@ RectangleIntersectionBuilder::reconnectPolygons(const Rectangle & rect)
using geos::algorithm::CGAlgorithms;
geom::Coordinate c;
hole->getCoordinatesRO()->getAt(0, c);
- for (ShellAndHolesList::iterator i=exterior.begin(), e=exterior.end(); i!=e; ++i)
+ for (ShellAndHolesList::iterator p_i=exterior.begin(), p_e=exterior.end(); p_i!=p_e; ++p_i)
{
- ShellAndHoles &p = *i;
+ ShellAndHoles &p = *p_i;
const CoordinateSequence *shell_cs = p.first->getCoordinatesRO();
if( CGAlgorithms::isPointInRing(c, shell_cs) )
{
diff --git a/src/operation/linemerge/LineSequencer.cpp b/src/operation/linemerge/LineSequencer.cpp
index 5bd9407..6ec3415 100644
--- a/src/operation/linemerge/LineSequencer.cpp
+++ b/src/operation/linemerge/LineSequencer.cpp
@@ -108,11 +108,11 @@ LineSequencer::isSequenced(const Geometry* geom)
/* private */
bool
-LineSequencer::hasSequence(planargraph::Subgraph& graph)
+LineSequencer::hasSequence(planargraph::Subgraph& p_graph)
{
int oddDegreeCount = 0;
for (planargraph::NodeMap::container::const_iterator
- it=graph.nodeBegin(), endIt=graph.nodeEnd();
+ it=p_graph.nodeBegin(), endIt=p_graph.nodeEnd();
it!=endIt;
++it)
{
@@ -333,16 +333,16 @@ LineSequencer::addReverseSubpath(const planargraph::DirectedEdge *de,
/*private*/
planargraph::DirectedEdge::NonConstList*
-LineSequencer::findSequence(planargraph::Subgraph& graph)
+LineSequencer::findSequence(planargraph::Subgraph& p_graph)
{
using planargraph::DirectedEdge;
using planargraph::Node;
using planargraph::GraphComponent;
- GraphComponent::setVisited(graph.edgeBegin(),
- graph.edgeEnd(), false);
+ GraphComponent::setVisited(p_graph.edgeBegin(),
+ p_graph.edgeEnd(), false);
- const Node* startNode = findLowestDegreeNode(graph);
+ const Node* startNode = findLowestDegreeNode(p_graph);
const DirectedEdge *startDE = *(startNode->getOutEdges()->begin());
const DirectedEdge *startDESym = startDE->getSym();
diff --git a/src/operation/overlay/ElevationMatrix.cpp b/src/operation/overlay/ElevationMatrix.cpp
index 0ef4d3a..a5445ad 100644
--- a/src/operation/overlay/ElevationMatrix.cpp
+++ b/src/operation/overlay/ElevationMatrix.cpp
@@ -63,12 +63,12 @@ ElevationMatrixFilter::filter_rw(Coordinate *c) const
// already has a Z value, nothing to do
if ( ! ISNAN(c->z) ) return;
- double avgElevation = em.getAvgElevation();
+ double p_avgElevation = em.getAvgElevation();
try {
const ElevationMatrixCell &emc = em.getCell(*c);
c->z = emc.getAvg();
- if ( ISNAN(c->z) ) c->z = avgElevation;
+ if ( ISNAN(c->z) ) c->z = p_avgElevation;
#if GEOS_DEBUG
cerr<<" z set to "<<c->z<<endl;
#endif
diff --git a/src/operation/overlay/MaximalEdgeRing.cpp b/src/operation/overlay/MaximalEdgeRing.cpp
index d7d3c4a..e978c57 100644
--- a/src/operation/overlay/MaximalEdgeRing.cpp
+++ b/src/operation/overlay/MaximalEdgeRing.cpp
@@ -47,10 +47,10 @@ namespace overlay { // geos.operation.overlay
/*public*/
// CGAlgorithms obsoleted
MaximalEdgeRing::MaximalEdgeRing(DirectedEdge *start,
- const GeometryFactory *geometryFactory)
+ const GeometryFactory *p_geometryFactory)
// throw(const TopologyException &)
:
- EdgeRing(start, geometryFactory)
+ EdgeRing(start, p_geometryFactory)
{
computePoints(start);
computeRing();
diff --git a/src/operation/overlay/MinimalEdgeRing.cpp b/src/operation/overlay/MinimalEdgeRing.cpp
index c2af8ad..197433f 100644
--- a/src/operation/overlay/MinimalEdgeRing.cpp
+++ b/src/operation/overlay/MinimalEdgeRing.cpp
@@ -37,9 +37,9 @@ namespace operation { // geos.operation
namespace overlay { // geos.operation.overlay
MinimalEdgeRing::MinimalEdgeRing(geomgraph::DirectedEdge *start,
- const geom::GeometryFactory *geometryFactory)
+ const geom::GeometryFactory *p_geometryFactory)
:
- geomgraph::EdgeRing(start, geometryFactory)
+ geomgraph::EdgeRing(start, p_geometryFactory)
{
computePoints(start);
computeRing();
diff --git a/src/operation/overlay/OverlayOp.cpp b/src/operation/overlay/OverlayOp.cpp
index 86f49ba..1677858 100644
--- a/src/operation/overlay/OverlayOp.cpp
+++ b/src/operation/overlay/OverlayOp.cpp
@@ -514,13 +514,13 @@ OverlayOp::mergeZ(Node *n, const LineString *line) const
{
const CoordinateSequence *pts = line->getCoordinatesRO();
const Coordinate &p = n->getCoordinate();
- LineIntersector li;
+ LineIntersector p_li;
for(size_t i=1, size=pts->size(); i<size; ++i)
{
const Coordinate &p0=pts->getAt(i-1);
const Coordinate &p1=pts->getAt(i);
- li.computeIntersection(p, p0, p1);
- if (li.hasIntersection())
+ p_li.computeIntersection(p, p0, p1);
+ if (p_li.hasIntersection())
{
if ( p == p0 )
{
diff --git a/src/operation/overlay/PolygonBuilder.cpp b/src/operation/overlay/PolygonBuilder.cpp
index 8bb1bfb..87ce0b8 100644
--- a/src/operation/overlay/PolygonBuilder.cpp
+++ b/src/operation/overlay/PolygonBuilder.cpp
@@ -162,8 +162,8 @@ PolygonBuilder::buildMaximalEdgeRings(const vector<DirectedEdge*> *dirEdges,
}
catch (util::GEOSException&)
{ // cleanup if that happens (see stmlf-cases-20061020.xml)
- for(size_t i=oldSize, n=maxEdgeRings.size(); i<n; i++)
- delete maxEdgeRings[i];
+ for(size_t p_i=oldSize, p_n=maxEdgeRings.size(); p_i<p_n; p_i++)
+ delete maxEdgeRings[p_i];
//cerr << "Exception! " << e.what() << endl;
throw;
}
diff --git a/src/operation/overlay/snap/SnapOverlayOp.cpp b/src/operation/overlay/snap/SnapOverlayOp.cpp
index 3b09324..302bd3f 100644
--- a/src/operation/overlay/snap/SnapOverlayOp.cpp
+++ b/src/operation/overlay/snap/SnapOverlayOp.cpp
@@ -83,16 +83,16 @@ SnapOverlayOp::snap(geom::GeomPtrPair& snapGeom)
/* private */
void
-SnapOverlayOp::removeCommonBits(const geom::Geometry& geom0,
- const geom::Geometry& geom1,
+SnapOverlayOp::removeCommonBits(const geom::Geometry& p_geom0,
+ const geom::Geometry& p_geom1,
geom::GeomPtrPair& remGeom)
{
cbr.reset(new precision::CommonBitsRemover());
- cbr->add(&geom0);
- cbr->add(&geom1);
+ cbr->add(&p_geom0);
+ cbr->add(&p_geom1);
- remGeom.first.reset( cbr->removeCommonBits(geom0.clone()) );
- remGeom.second.reset( cbr->removeCommonBits(geom1.clone()) );
+ remGeom.first.reset( cbr->removeCommonBits(p_geom0.clone()) );
+ remGeom.second.reset( cbr->removeCommonBits(p_geom1.clone()) );
}
/*private*/
diff --git a/src/operation/relate/RelateNode.cpp b/src/operation/relate/RelateNode.cpp
index 0f295f5..56d8d6f 100644
--- a/src/operation/relate/RelateNode.cpp
+++ b/src/operation/relate/RelateNode.cpp
@@ -32,8 +32,8 @@ namespace geos {
namespace operation { // geos.operation
namespace relate { // geos.operation.relate
-RelateNode::RelateNode(const Coordinate& coord, EdgeEndStar *edges):
- Node(coord,edges)
+RelateNode::RelateNode(const Coordinate& p_coord, EdgeEndStar *p_edges):
+ Node(p_coord,p_edges)
{}
RelateNode::~RelateNode()
diff --git a/src/operation/valid/IsValidOp.cpp b/src/operation/valid/IsValidOp.cpp
index c8d8165..60e296a 100644
--- a/src/operation/valid/IsValidOp.cpp
+++ b/src/operation/valid/IsValidOp.cpp
@@ -132,21 +132,21 @@ IsValidOp::checkValid(const Geometry *g)
// empty geometries are always valid!
if (g->isEmpty()) return;
- if ( const Point* x = dynamic_cast<const Point*>(g) )
- checkValid(x);
+ if ( const Point* x1 = dynamic_cast<const Point*>(g) )
+ checkValid(x1);
// LineString also handles LinearRings, so we check LinearRing first
- else if ( const LinearRing* x = dynamic_cast<const LinearRing*>(g) )
- checkValid(x);
- else if ( const LineString* x = dynamic_cast<const LineString*>(g) )
- checkValid(x);
- else if ( const Polygon* x = dynamic_cast<const Polygon*>(g) )
- checkValid(x);
- else if ( const MultiPolygon* x = dynamic_cast<const MultiPolygon*>(g) )
- checkValid(x);
- else if ( const GeometryCollection* x =
+ else if ( const LinearRing* x2 = dynamic_cast<const LinearRing*>(g) )
+ checkValid(x2);
+ else if ( const LineString* x3 = dynamic_cast<const LineString*>(g) )
+ checkValid(x3);
+ else if ( const Polygon* x4 = dynamic_cast<const Polygon*>(g) )
+ checkValid(x4);
+ else if ( const MultiPolygon* x5 = dynamic_cast<const MultiPolygon*>(g) )
+ checkValid(x5);
+ else if ( const GeometryCollection* x6 =
dynamic_cast<const GeometryCollection*>(g) )
{
- checkValid(x);
+ checkValid(x6);
}
else throw util::UnsupportedOperationException();
}
diff --git a/src/precision/GeometryPrecisionReducer.cpp b/src/precision/GeometryPrecisionReducer.cpp
index a5923ee..6af8ac8 100644
--- a/src/precision/GeometryPrecisionReducer.cpp
+++ b/src/precision/GeometryPrecisionReducer.cpp
@@ -132,12 +132,12 @@ GeometryFactory::Ptr
GeometryPrecisionReducer::createFactory( const GeometryFactory& oldGF,
const PrecisionModel& newPM )
{
- GeometryFactory::Ptr newFactory(
+ GeometryFactory::Ptr p_newFactory(
GeometryFactory::create(&newPM,
oldGF.getSRID(),
const_cast<CoordinateSequenceFactory*>(oldGF.getCoordinateSequenceFactory()))
);
- return newFactory;
+ return p_newFactory;
}
} // namespace geos.precision
diff --git a/src/simplify/TaggedLineSegment.cpp b/src/simplify/TaggedLineSegment.cpp
index 343d09e..142eeef 100644
--- a/src/simplify/TaggedLineSegment.cpp
+++ b/src/simplify/TaggedLineSegment.cpp
@@ -31,21 +31,21 @@
namespace geos {
namespace simplify { // geos::simplify
-TaggedLineSegment::TaggedLineSegment(const geom::Coordinate& p0,
- const geom::Coordinate& p1,
+TaggedLineSegment::TaggedLineSegment(const geom::Coordinate& p_p0,
+ const geom::Coordinate& p_p1,
const geom::Geometry* nParent,
size_t nIndex)
:
- LineSegment(p0, p1),
+ LineSegment(p_p0, p_p1),
parent(nParent),
index(nIndex)
{
}
-TaggedLineSegment::TaggedLineSegment(const geom::Coordinate& p0,
- const geom::Coordinate& p1)
+TaggedLineSegment::TaggedLineSegment(const geom::Coordinate& p_p0,
+ const geom::Coordinate& p_p1)
:
- LineSegment(p0, p1),
+ LineSegment(p_p0, p_p1),
parent(nullptr),
index(0)
{
diff --git a/src/simplify/TaggedLineStringSimplifier.cpp b/src/simplify/TaggedLineStringSimplifier.cpp
index 24ce036..29320e9 100644
--- a/src/simplify/TaggedLineStringSimplifier.cpp
+++ b/src/simplify/TaggedLineStringSimplifier.cpp
@@ -293,16 +293,16 @@ TaggedLineStringSimplifier::isInLineSection(
/*private*/
void
-TaggedLineStringSimplifier::remove(const TaggedLineString* line,
+TaggedLineStringSimplifier::remove(const TaggedLineString* p_line,
std::size_t start,
std::size_t end)
{
- assert(end <= line->getSegments().size() );
+ assert(end <= p_line->getSegments().size() );
assert(start < end); // I'm not sure this should always be true
for (std::size_t i = start; i < end; i++)
{
- const TaggedLineSegment* seg = line->getSegment(i);
+ const TaggedLineSegment* seg = p_line->getSegment(i);
inputIndex->remove(seg);
}
}
diff --git a/src/triangulate/IncrementalDelaunayTriangulator.cpp b/src/triangulate/IncrementalDelaunayTriangulator.cpp
index 58d4291..26c3139 100644
--- a/src/triangulate/IncrementalDelaunayTriangulator.cpp
+++ b/src/triangulate/IncrementalDelaunayTriangulator.cpp
@@ -28,8 +28,8 @@ namespace triangulate { //geos.triangulate
using namespace quadedge;
IncrementalDelaunayTriangulator::IncrementalDelaunayTriangulator(
- QuadEdgeSubdivision *subdiv) :
- subdiv(subdiv), isUsingTolerance(subdiv->getTolerance() > 0.0)
+ QuadEdgeSubdivision *p_subdiv) :
+ subdiv(p_subdiv), isUsingTolerance(p_subdiv->getTolerance() > 0.0)
{
}
diff --git a/src/triangulate/quadedge/LastFoundQuadEdgeLocator.cpp b/src/triangulate/quadedge/LastFoundQuadEdgeLocator.cpp
index 33e7830..241439b 100644
--- a/src/triangulate/quadedge/LastFoundQuadEdgeLocator.cpp
+++ b/src/triangulate/quadedge/LastFoundQuadEdgeLocator.cpp
@@ -23,8 +23,8 @@ namespace geos {
namespace triangulate { //geos.triangulate
namespace quadedge { //geos.triangulate.quadedge
-LastFoundQuadEdgeLocator::LastFoundQuadEdgeLocator(QuadEdgeSubdivision *subdiv) :
- subdiv(subdiv), lastEdge(nullptr)
+LastFoundQuadEdgeLocator::LastFoundQuadEdgeLocator(QuadEdgeSubdivision *p_subdiv) :
+ subdiv(p_subdiv), lastEdge(nullptr)
{
}
diff --git a/src/triangulate/quadedge/QuadEdge.cpp b/src/triangulate/quadedge/QuadEdge.cpp
index b5f1ece..d19dd61 100644
--- a/src/triangulate/quadedge/QuadEdge.cpp
+++ b/src/triangulate/quadedge/QuadEdge.cpp
@@ -126,9 +126,9 @@ QuadEdge::getPrimary() const
}
void
-QuadEdge::setData(void* data)
+QuadEdge::setData(void* p_data)
{
- this->data = data;
+ this->data = p_data;
}
void*
diff --git a/src/triangulate/quadedge/QuadEdgeSubdivision.cpp b/src/triangulate/quadedge/QuadEdgeSubdivision.cpp
index bed1152..53a4711 100644
--- a/src/triangulate/quadedge/QuadEdgeSubdivision.cpp
+++ b/src/triangulate/quadedge/QuadEdgeSubdivision.cpp
@@ -61,8 +61,8 @@ QuadEdgeSubdivision::getTriangleEdges(const QuadEdge &startQE,
}
}
-QuadEdgeSubdivision::QuadEdgeSubdivision(const geom::Envelope &env, double tolerance) :
- tolerance(tolerance),
+QuadEdgeSubdivision::QuadEdgeSubdivision(const geom::Envelope &env, double p_tolerance) :
+ tolerance(p_tolerance),
locator(new LastFoundQuadEdgeLocator(this))
{
edgeCoincidenceTolerance = tolerance / EDGE_COINCIDENCE_TOL_FACTOR;
@@ -379,7 +379,7 @@ private:
CoordinateArraySequenceFactory coordSeqFact;
public:
- TriangleCoordinatesVisitor(QuadEdgeSubdivision::TriList *triCoords): triCoords(triCoords)
+ TriangleCoordinatesVisitor(QuadEdgeSubdivision::TriList *p_triCoords): triCoords(p_triCoords)
{
}
@@ -436,10 +436,10 @@ QuadEdgeSubdivision::visitTriangles(TriangleVisitor *triVisitor, bool includeFra
QuadEdge *edge = edgeStack.top();
edgeStack.pop();
if (visitedEdges.find(edge) == visitedEdges.end()) {
- QuadEdge **triEdges = fetchTriangleToVisit(edge, edgeStack,
+ QuadEdge **p_triEdges = fetchTriangleToVisit(edge, edgeStack,
includeFrame, visitedEdges);
- if (triEdges != nullptr)
- triVisitor->visit(triEdges);
+ if (p_triEdges != nullptr)
+ triVisitor->visit(p_triEdges);
}
}
}
@@ -447,11 +447,11 @@ QuadEdgeSubdivision::visitTriangles(TriangleVisitor *triVisitor, bool includeFra
std::unique_ptr<geom::MultiLineString>
QuadEdgeSubdivision::getEdges(const geom::GeometryFactory& geomFact)
{
- std::unique_ptr<QuadEdgeList> quadEdges(getPrimaryEdges(false));
- std::vector<Geometry *> edges(quadEdges->size());
+ std::unique_ptr<QuadEdgeList> p_quadEdges(getPrimaryEdges(false));
+ std::vector<Geometry *> edges(p_quadEdges->size());
const CoordinateSequenceFactory *coordSeqFact = geomFact.getCoordinateSequenceFactory();
int i = 0;
- for (QuadEdgeSubdivision::QuadEdgeList::iterator it = quadEdges->begin(); it != quadEdges->end(); ++it)
+ for (QuadEdgeSubdivision::QuadEdgeList::iterator it = p_quadEdges->begin(); it != p_quadEdges->end(); ++it)
{
QuadEdge *qe = *it;
CoordinateSequence *coordSeq = coordSeqFact->create((std::vector<geom::Coordinate>*)nullptr);;
diff --git a/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp b/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp
index c09b6ef..2b54a2e 100644
--- a/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp
+++ b/tests/perf/operation/predicate/RectangleIntersectsPerfTest.cpp
@@ -58,8 +58,8 @@ public:
* algorithm, and provides a more realistic test.
*/
using geos::precision::SimpleGeometryPrecisionReducer;
- PrecisionModel pm(size/10);
- SimpleGeometryPrecisionReducer reducer(&pm);
+ PrecisionModel p_pm(size/10);
+ SimpleGeometryPrecisionReducer reducer(&p_pm);
Geometry::Ptr sinePolyCrinkly ( reducer.reduce(sinePoly.get()) );
sinePoly.reset();
diff --git a/tests/unit/algorithm/MinimumDiameterTest.cpp b/tests/unit/algorithm/MinimumDiameterTest.cpp
index a38df9e..d05470c 100644
--- a/tests/unit/algorithm/MinimumDiameterTest.cpp
+++ b/tests/unit/algorithm/MinimumDiameterTest.cpp
@@ -63,10 +63,10 @@ namespace tut
template<>
void object::test<1>()
{
- GeomPtr geom(reader.read("POLYGON ((0 0, 0 20, 20 20, 20 0, 0 0))"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("POLYGON ((0 0, 0 20, 20 20, 20 0, 0 0))"));
+ ensure(nullptr != p_geom.get());
- geos::algorithm::MinimumDiameter m(geom.get());
+ geos::algorithm::MinimumDiameter m(p_geom.get());
GeomPtr minRect( m.getMinimumRectangle() );
ensure(nullptr != minRect.get());
@@ -81,10 +81,10 @@ namespace tut
template<>
void object::test<2>()
{
- GeomPtr geom(reader.read("POLYGON ((0 5, 5 10, 10 5, 5 0, 0 5))"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("POLYGON ((0 5, 5 10, 10 5, 5 0, 0 5))"));
+ ensure(nullptr != p_geom.get());
- geos::algorithm::MinimumDiameter m(geom.get());
+ geos::algorithm::MinimumDiameter m(p_geom.get());
GeomPtr minRect( m.getMinimumRectangle() );
ensure(nullptr != minRect.get());
@@ -99,10 +99,10 @@ namespace tut
template<>
void object::test<3>()
{
- GeomPtr geom(reader.read("POLYGON EMPTY"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("POLYGON EMPTY"));
+ ensure(nullptr != p_geom.get());
- geos::algorithm::MinimumDiameter m(geom.get());
+ geos::algorithm::MinimumDiameter m(p_geom.get());
GeomPtr minRect( m.getMinimumRectangle() );
ensure(nullptr != minRect.get());
@@ -117,10 +117,10 @@ namespace tut
template<>
void object::test<4>()
{
- GeomPtr geom(reader.read("Point(1 2)"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("Point(1 2)"));
+ ensure(nullptr != p_geom.get());
- geos::algorithm::MinimumDiameter m(geom.get());
+ geos::algorithm::MinimumDiameter m(p_geom.get());
GeomPtr minRect( m.getMinimumRectangle() );
ensure(nullptr != minRect.get());
@@ -135,10 +135,10 @@ namespace tut
template<>
void object::test<5>()
{
- GeomPtr geom(reader.read("LineString(1 2, 2 4)"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("LineString(1 2, 2 4)"));
+ ensure(nullptr != p_geom.get());
- geos::algorithm::MinimumDiameter m(geom.get());
+ geos::algorithm::MinimumDiameter m(p_geom.get());
GeomPtr minRect( m.getMinimumRectangle() );
ensure(nullptr != minRect.get());
@@ -153,10 +153,10 @@ namespace tut
template<>
void object::test<6>()
{
- GeomPtr geom(reader.read("POINT (0 240)"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("POINT (0 240)"));
+ ensure(nullptr != p_geom.get());
- GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( geom.get() ) );
+ GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( p_geom.get() ) );
ensure(nullptr != minDiameter.get());
GeomPtr expectedGeom(reader.read("LineString (0 240, 0 240)"));
@@ -170,10 +170,10 @@ namespace tut
template<>
void object::test<7>()
{
- GeomPtr geom(reader.read("LINESTRING (0 240, 220 240)"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("LINESTRING (0 240, 220 240)"));
+ ensure(nullptr != p_geom.get());
- GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( geom.get() ) );
+ GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( p_geom.get() ) );
ensure(nullptr != minDiameter.get());
GeomPtr expectedGeom(reader.read("LINESTRING (0 240, 0 240)"));
@@ -187,10 +187,10 @@ namespace tut
template<>
void object::test<8>()
{
- GeomPtr geom(reader.read("POLYGON ((0 240, 220 240, 220 0, 0 0, 0 240))"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("POLYGON ((0 240, 220 240, 220 0, 0 0, 0 240))"));
+ ensure(nullptr != p_geom.get());
- GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( geom.get() ) );
+ GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( p_geom.get() ) );
ensure(nullptr != minDiameter.get());
GeomPtr expectedGeom(reader.read("LINESTRING (0 0, 220 0)"));
@@ -204,10 +204,10 @@ namespace tut
template<>
void object::test<9>()
{
- GeomPtr geom(reader.read("POLYGON ((0 240, 160 140, 220 0, 0 0, 0 240))"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("POLYGON ((0 240, 160 140, 220 0, 0 0, 0 240))"));
+ ensure(nullptr != p_geom.get());
- GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( geom.get() ) );
+ GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( p_geom.get() ) );
ensure(nullptr != minDiameter.get());
GeomPtr expectedGeom(reader.read("LINESTRING (185.86206896551724 79.65517241379311, 0 0)"));
@@ -221,10 +221,10 @@ namespace tut
template<>
void object::test<10>()
{
- GeomPtr geom(reader.read("LINESTRING ( 39 119, 162 197, 135 70, 95 35, 33 66, 111 82, 97 131, 48 160, -4 182, 57 195, 94 202, 90 174, 75 134, 47 114, 0 100, 59 81, 123 60, 136 43, 163 75, 145 114, 93 136, 92 159, 105 175 )"));
- ensure(nullptr != geom.get());
+ GeomPtr p_geom(reader.read("LINESTRING ( 39 119, 162 197, 135 70, 95 35, 33 66, 111 82, 97 131, 48 160, -4 182, 57 195, 94 202, 90 174, 75 134, 47 114, 0 100, 59 81, 123 60, 136 43, 163 75, 145 114, 93 136, 92 159, 105 175 )"));
+ ensure(nullptr != p_geom.get());
- GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( geom.get() ) );
+ GeomPtr minDiameter( geos::algorithm::MinimumDiameter::getMinimumDiameter( p_geom.get() ) );
ensure(nullptr != minDiameter.get());
GeomPtr expectedGeom(reader.read("LINESTRING (64.46262341325811 196.41184767277855, 95 35)"));
diff --git a/tests/unit/algorithm/RobustLineIntersectorTest.cpp b/tests/unit/algorithm/RobustLineIntersectorTest.cpp
index bcdb065..40fe1a7 100644
--- a/tests/unit/algorithm/RobustLineIntersectorTest.cpp
+++ b/tests/unit/algorithm/RobustLineIntersectorTest.cpp
@@ -58,7 +58,6 @@ namespace tut
template<>
void object::test<1>()
{
- LineIntersector i;
Coordinate p1(10, 10);
Coordinate p2(20, 20);
Coordinate q1(20, 10);
@@ -78,7 +77,6 @@ namespace tut
template<>
void object::test<2>()
{
- LineIntersector i;
Coordinate p1(10, 10);
Coordinate p2(20, 10);
Coordinate q1(22, 10);
@@ -96,7 +94,6 @@ namespace tut
template<>
void object::test<3>()
{
- LineIntersector i;
Coordinate p1(10, 10);
Coordinate p2(20, 10);
Coordinate q1(20, 10);
@@ -114,7 +111,6 @@ namespace tut
template<>
void object::test<4>()
{
- LineIntersector i;
Coordinate p1(10, 10);
Coordinate p2(20, 10);
Coordinate q1(15, 10);
@@ -132,7 +128,6 @@ namespace tut
template<>
void object::test<5>()
{
- LineIntersector i;
Coordinate p1(10, 10);
Coordinate p2(20, 10);
Coordinate q1(10, 10);
diff --git a/tests/unit/capi/GEOSSTRtreeTest.cpp b/tests/unit/capi/GEOSSTRtreeTest.cpp
index 72989c5..66d4ced 100644
--- a/tests/unit/capi/GEOSSTRtreeTest.cpp
+++ b/tests/unit/capi/GEOSSTRtreeTest.cpp
@@ -11,7 +11,7 @@
#include <cmath>
struct INTPOINT {
- INTPOINT(int x, int y) : x(x), y(y) {}
+ INTPOINT(int p_x, int p_y) : x(p_x), y(p_y) {}
int x;
int y;
};
diff --git a/tests/unit/geom/GeometryComponentFilterTest.cpp b/tests/unit/geom/GeometryComponentFilterTest.cpp
index 6eed1eb..74a87b3 100644
--- a/tests/unit/geom/GeometryComponentFilterTest.cpp
+++ b/tests/unit/geom/GeometryComponentFilterTest.cpp
@@ -53,8 +53,8 @@ void object::test<1>()
{
GeometryRefArray& lineal;
GeometryRefArray& nonlineal;
- GeometryComponentSplitter(GeometryRefArray& lineal, GeometryRefArray& nonlineal)
- : lineal(lineal), nonlineal(nonlineal)
+ GeometryComponentSplitter(GeometryRefArray& p_lineal, GeometryRefArray& p_nonlineal)
+ : lineal(p_lineal), nonlineal(p_nonlineal)
{
ensure(lineal.empty());
ensure(nonlineal.empty());
diff --git a/tests/unit/geom/GeometryFilterTest.cpp b/tests/unit/geom/GeometryFilterTest.cpp
index b18683b..5f29260 100644
--- a/tests/unit/geom/GeometryFilterTest.cpp
+++ b/tests/unit/geom/GeometryFilterTest.cpp
@@ -53,8 +53,8 @@ void object::test<1>()
{
GeometryRefArray& lineal;
GeometryRefArray& nonlineal;
- GeometrySplitter(GeometryRefArray& lineal, GeometryRefArray& nonlineal)
- : lineal(lineal), nonlineal(nonlineal)
+ GeometrySplitter(GeometryRefArray& p_lineal, GeometryRefArray& p_nonlineal)
+ : lineal(p_lineal), nonlineal(p_nonlineal)
{
ensure(lineal.empty());
ensure(nonlineal.empty());
diff --git a/tests/unit/io/WKTReaderTest.cpp b/tests/unit/io/WKTReaderTest.cpp
index eabc61a..da307a3 100644
--- a/tests/unit/io/WKTReaderTest.cpp
+++ b/tests/unit/io/WKTReaderTest.cpp
@@ -149,9 +149,9 @@ namespace tut
// use FLOATING model
namespace ggm = geos::geom;
namespace gio = geos::io;
- ggm::PrecisionModel pm(ggm::PrecisionModel::FLOATING);
- ggm::GeometryFactory::Ptr gf = ggm::GeometryFactory::create(&pm);
- gio::WKTReader wktReader(gf.get());
+ ggm::PrecisionModel p_pm(ggm::PrecisionModel::FLOATING);
+ ggm::GeometryFactory::Ptr p_gf = ggm::GeometryFactory::create(&p_pm);
+ gio::WKTReader wktReader(p_gf.get());
const std::string str = " POINT (0 0) ";
geom.reset(wktReader.read(str)); //HERE IT FAILS
diff --git a/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp b/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp
index e790fdf..21bea52 100644
--- a/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp
+++ b/tests/unit/operation/overlay/validate/OverlayResultValidatorTest.cpp
@@ -58,15 +58,15 @@ namespace tut
{
std::string wkt0("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g0(wktreader.read(wkt0));
+ GeomPtr p_g0(wktreader.read(wkt0));
std::string wkt1("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g1(wktreader.read(wkt1));
+ GeomPtr p_g1(wktreader.read(wkt1));
std::string wktres("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr gres(wktreader.read(wkt1));
+ GeomPtr p_gres(wktreader.read(wkt1));
- OverlayResultValidator validator(*g0, *g1, *gres);
+ OverlayResultValidator validator(*p_g0, *p_g1, *p_gres);
ensure( validator.isValid(OverlayOp::opUNION) );
}
@@ -77,15 +77,15 @@ namespace tut
{
std::string wkt0("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g0(wktreader.read(wkt0));
+ GeomPtr p_g0(wktreader.read(wkt0));
std::string wkt1("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g1(wktreader.read(wkt1));
+ GeomPtr p_g1(wktreader.read(wkt1));
std::string wktres("POLYGON((0 0, 10.001 0, 10 10, 0 10, 0 0))");
- GeomPtr gres(wktreader.read(wktres));
+ GeomPtr p_gres(wktreader.read(wktres));
- OverlayResultValidator validator(*g0, *g1, *gres);
+ OverlayResultValidator validator(*p_g0, *p_g1, *p_gres);
ensure (! validator.isValid(OverlayOp::opUNION) );
}
@@ -96,15 +96,15 @@ namespace tut
{
std::string wkt0("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g0(wktreader.read(wkt0));
+ GeomPtr p_g0(wktreader.read(wkt0));
std::string wkt1("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g1(wktreader.read(wkt1));
+ GeomPtr p_g1(wktreader.read(wkt1));
std::string wktres("POLYGON((0 0, 9.999 0, 10 10, 0 10, 0 0))");
- GeomPtr gres(wktreader.read(wktres));
+ GeomPtr p_gres(wktreader.read(wktres));
- OverlayResultValidator validator(*g0, *g1, *gres);
+ OverlayResultValidator validator(*p_g0, *p_g1, *p_gres);
ensure (! validator.isValid(OverlayOp::opUNION) );
}
@@ -116,15 +116,15 @@ namespace tut
{
std::string wkt0("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g0(wktreader.read(wkt0));
+ GeomPtr p_g0(wktreader.read(wkt0));
std::string wkt1("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g1(wktreader.read(wkt1));
+ GeomPtr p_g1(wktreader.read(wkt1));
std::string wktres("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0),(5 5, 5 6, 6 6, 5 5))");
- GeomPtr gres(wktreader.read(wktres));
+ GeomPtr p_gres(wktreader.read(wktres));
- OverlayResultValidator validator(*g0, *g1, *gres);
+ OverlayResultValidator validator(*p_g0, *p_g1, *p_gres);
ensure (! validator.isValid(OverlayOp::opUNION) );
}
@@ -136,16 +136,16 @@ namespace tut
{
std::string wkt0("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))");
- GeomPtr g0(wktreader.read(wkt0));
+ GeomPtr p_g0(wktreader.read(wkt0));
std::string wkt1("POLYGON((5 0, 1500 0, 1500 10, 5 10, 5 0))");
- GeomPtr g1(wktreader.read(wkt1));
+ GeomPtr p_g1(wktreader.read(wkt1));
// small shift
std::string wktres("POLYGON((0 0, 750 0.0001, 150 0, 150 10, 0 10, 0 0))");
- GeomPtr gres(wktreader.read(wktres));
+ GeomPtr p_gres(wktreader.read(wktres));
- OverlayResultValidator validator(*g0, *g1, *gres);
+ OverlayResultValidator validator(*p_g0, *p_g1, *p_gres);
ensure (! validator.isValid(OverlayOp::opUNION) );
}
@@ -156,15 +156,15 @@ namespace tut
{
std::string wkt0("POLYGON ((20.0 40.0, 20.0 200.0, 180.0 200.0, 180.0 120.0, 140.0 120.0, 180.0 119.0, 180.0 40.0, 20.0 40.0), (140.0 160.0, 80.0 120.0, 140.0 80.0, 140.0 160.0))");
- GeomPtr g0(wktreader.read(wkt0));
+ GeomPtr p_g0(wktreader.read(wkt0));
std::string wkt1("POLYGON ((200.0 160.0, 150.0 160.0, 150.0 80.0, 200.0 80.0, 200.0 160.0))");
- GeomPtr g1(wktreader.read(wkt1));
+ GeomPtr p_g1(wktreader.read(wkt1));
std::string wktres("MULTIPOLYGON (((20.0 40.0, 20.0 200.0, 180.0 200.0, 180.0 160.0, 150.0 160.0, 150.0 120.0, 150.0 80.0, 180.0 80.0, 180.0 40.0, 20.0 40.0), (80.0 120.0, 140.0 80.0, 140.0 120.0, 140.0 160.0, 80.0 120.0)), ((150.0 120.0, 180.0 120.0, 180.0 160.0, 200.0 160.0, 200.0 80.0, 180.0 80.0, 180.0 119.0, 150.0 120.0)))");
- GeomPtr gres(wktreader.read(wktres));
+ GeomPtr p_gres(wktreader.read(wktres));
- OverlayResultValidator validator(*g0, *g1, *gres);
+ OverlayResultValidator validator(*p_g0, *p_g1, *p_gres);
ensure ( ! validator.isValid(OverlayOp::opSYMDIFFERENCE) );
}
diff --git a/tests/unit/operation/union/CascadedPolygonUnionTest.cpp b/tests/unit/operation/union/CascadedPolygonUnionTest.cpp
index de3a55a..c95b728 100644
--- a/tests/unit/operation/union/CascadedPolygonUnionTest.cpp
+++ b/tests/unit/operation/union/CascadedPolygonUnionTest.cpp
@@ -71,7 +71,7 @@ namespace tut
return CascadedPolygonUnion::Union(geoms);
}
- void test_runner(test_cascadedpolygonuniontest_data& t,
+ void p_test_runner(test_cascadedpolygonuniontest_data& t,
std::vector<geos::geom::Polygon*>* geoms)
{
std::unique_ptr<geos::geom::Geometry> union1(unionIterated(geoms));
@@ -117,7 +117,7 @@ namespace tut
g.push_back(geom);
}
- test_runner(*this, &g);
+ p_test_runner(*this, &g);
for_each(g.begin(), g.end(), delete_geometry);
}
diff --git a/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp b/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp
index 9be23a6..2bf63e7 100644
--- a/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp
+++ b/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp
@@ -300,7 +300,7 @@ namespace tut
struct Multiplier : public CoordinateSequenceFilter
{
double f;
- Multiplier(double f) : f(f) {}
+ Multiplier(double p_f) : f(p_f) {}
void filter_rw(CoordinateSequence& seq, std::size_t i) override
{
seq.setOrdinate(i, CoordinateSequence::X, seq[i].x * f);
diff --git a/tests/unit/tut/tut_result.hpp b/tests/unit/tut/tut_result.hpp
index 078f257..9d1eb1c 100644
--- a/tests/unit/tut/tut_result.hpp
+++ b/tests/unit/tut/tut_result.hpp
@@ -144,13 +144,13 @@ struct test_result : public test_result_posix
*/
test_result(const std::string& grp,int pos,
const std::string& test_name, result_type res,
- const std::exception& ex)
+ const std::exception& p_ex)
: group(grp),
test(pos),
name(test_name),
result(res),
- message(ex.what()),
- exception_typeid(type_name(ex))
+ message(p_ex.what()),
+ exception_typeid(type_name(p_ex))
{
}
diff --git a/tests/xmltester/XMLTester.cpp b/tests/xmltester/XMLTester.cpp
index 8ffba8b..ec31bc1 100644
--- a/tests/xmltester/XMLTester.cpp
+++ b/tests/xmltester/XMLTester.cpp
@@ -782,11 +782,11 @@ XMLTester::parseTest(const TiXmlNode* node)
const TiXmlNode* resnode = opnode->FirstChild();
if ( ! resnode )
{
- std::stringstream tmp;
- tmp << "op of test " << testCount
+ std::stringstream p_tmp;
+ p_tmp << "op of test " << testCount
<< " of case " << caseCount
<< " has no expected result child";
- throw(runtime_error(tmp.str()));
+ throw(runtime_error(p_tmp.str()));
}
opRes = resnode->Value();
@@ -845,12 +845,12 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="isvalid")
{
- geom::Geometry *gT=gA;
+ geom::Geometry *p_gT=gA;
if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) {
- gT=gB;
+ p_gT=gB;
}
- if (gT->isValid()) actual_result="true";
+ if (p_gT->isValid()) actual_result="true";
else actual_result="false";
if (actual_result==opRes) success=1;
@@ -1030,13 +1030,13 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="getboundary")
{
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomPtr gRealRes(gT->getBoundary());
+ GeomPtr gRealRes(p_gT->getBoundary());
gRealRes->normalize();
if (gRes->compareTo(gRealRes.get())==0) success=1;
@@ -1050,13 +1050,13 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="getcentroid")
{
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomPtr gRealRes(gT->getCentroid());
+ GeomPtr gRealRes(p_gT->getCentroid());
if ( gRealRes.get() ) gRealRes->normalize();
else gRealRes.reset(factory->createPoint());
@@ -1073,10 +1073,10 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="issimple")
{
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
- if (gT->isSimple()) actual_result="true";
+ if (p_gT->isSimple()) actual_result="true";
else actual_result="false";
if (actual_result==opRes) success=1;
@@ -1085,13 +1085,13 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="convexhull")
{
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomPtr gRealRes(gT->convexHull());
+ GeomPtr gRealRes(p_gT->convexHull());
gRealRes->normalize();
if (gRes->compareTo(gRealRes.get())==0) success=1;
@@ -1107,8 +1107,8 @@ XMLTester::parseTest(const TiXmlNode* node)
{
using namespace operation::buffer;
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
@@ -1124,7 +1124,7 @@ XMLTester::parseTest(const TiXmlNode* node)
}
- BufferOp op(gT, params);
+ BufferOp op(p_gT, params);
gRealRes.reset(op.getResultGeometry(dist));
profile.stop();
@@ -1144,8 +1144,8 @@ XMLTester::parseTest(const TiXmlNode* node)
{
using namespace operation::buffer;
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
@@ -1169,7 +1169,7 @@ XMLTester::parseTest(const TiXmlNode* node)
BufferBuilder bufBuilder( params ) ;
gRealRes.reset( bufBuilder.bufferLineSingleSided(
- gT, dist, leftSide ) ) ;
+ p_gT, dist, leftSide ) ) ;
profile.stop();
gRealRes->normalize();
@@ -1189,8 +1189,8 @@ XMLTester::parseTest(const TiXmlNode* node)
{
using namespace operation::buffer;
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
@@ -1207,7 +1207,7 @@ XMLTester::parseTest(const TiXmlNode* node)
params.setQuadrantSegments(std::atoi(opArg3.c_str()));
}
- BufferOp op(gT, params);
+ BufferOp op(p_gT, params);
gRealRes.reset(op.getResultGeometry(dist));
profile.stop();
@@ -1226,13 +1226,13 @@ XMLTester::parseTest(const TiXmlNode* node)
else if (opName=="getinteriorpoint")
{
- geom::Geometry *gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ geom::Geometry *p_gT=gA;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
GeomPtr gRes(parseGeometry(opRes, "expected"));
gRes->normalize();
- GeomPtr gRealRes(gT->getInteriorPoint());
+ GeomPtr gRealRes(p_gT->getInteriorPoint());
if ( gRealRes.get() ) gRealRes->normalize();
else gRealRes.reset(factory->createPoint());
@@ -1292,12 +1292,12 @@ XMLTester::parseTest(const TiXmlNode* node)
GeomPtr gRes(wktreader->read(opRes));
gRes->normalize();
- geom::Geometry *gT=gA;
+ geom::Geometry *p_gT=gA;
- if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) gT=gB;
+ if ( ( opArg1 == "B" || opArg1 == "b" ) && gB ) p_gT=gB;
LineMerger merger;
- merger.add(gT);
+ merger.add(p_gT);
std::unique_ptr< std::vector<geom::LineString *> > lines ( merger.getMergedLineStrings() );
std::vector<geom::Geometry *>*newgeoms = new std::vector<geom::Geometry *>(lines->begin(),
lines->end());
@@ -1453,9 +1453,9 @@ XMLTester::parseTest(const TiXmlNode* node)
success = 1 && validOut;
}
- std::stringstream tmp;
- tmp << maxdiffop << ": " << maxdiff;
- actual_result=tmp.str();
+ std::stringstream p_tmp;
+ p_tmp << maxdiffop << ": " << maxdiff;
+ actual_result=p_tmp.str();
expected_result=opRes;
}
@@ -1519,24 +1519,24 @@ XMLTester::parseTest(const TiXmlNode* node)
}
void
-XMLTester::runPredicates(const geom::Geometry *gA, const geom::Geometry *gB)
+XMLTester::runPredicates(const geom::Geometry *p_gA, const geom::Geometry *p_gB)
{
- std::cout << "\t Equals:\tAB=" << (gA->equals(gB)?"T":"F") << ", BA=" << (gB->equals(gA)?"T":"F") << std::endl;
- std::cout << "\t Disjoint:\tAB=" << (gA->disjoint(gB)?"T":"F") << ", BA=" << (gB->disjoint(gA)?"T":"F") << std::endl;
- std::cout << "\tIntersects:\tAB=" << (gA->intersects(gB)?"T":"F") << ", BA=" << (gB->intersects(gA)?"T":"F") << std::endl;
- std::cout << "\t Touches:\tAB=" << (gA->touches(gB)?"T":"F") << ", BA=" << (gB->touches(gA)?"T":"F") << std::endl;
- std::cout << "\t Crosses:\tAB=" << (gA->crosses(gB)?"T":"F") << ", BA=" << (gB->crosses(gA)?"T":"F") << std::endl;
- std::cout << "\t Within:\tAB=" << (gA->within(gB)?"T":"F") << ", BA=" << (gB->within(gA)?"T":"F") << std::endl;
- std::cout << "\t Contains:\tAB=" << (gA->contains(gB)?"T":"F") << ", BA=" << (gB->contains(gA)?"T":"F") << std::endl;
- std::cout << "\t Overlaps:\tAB=" << (gA->overlaps(gB)?"T":"F") << ", BA=" << (gB->overlaps(gA)?"T":"F") << std::endl;
-
- std::cout << "\t Prepared Disjoint:\tAB=" << (prepare(gA)->disjoint(gB)?"T":"F") << ", BA=" << (prepare(gB)->disjoint(gA)?"T":"F") << std::endl;
- std::cout << "\tPrepared Intersects:\tAB=" << (prepare(gA)->intersects(gB)?"T":"F") << ", BA=" << (prepare(gB)->intersects(gA)?"T":"F") << std::endl;
- std::cout << "\t Prepared Touches:\tAB=" << (prepare(gA)->touches(gB)?"T":"F") << ", BA=" << (prepare(gB)->touches(gA)?"T":"F") << std::endl;
- std::cout << "\t Prepared Crosses:\tAB=" << (prepare(gA)->crosses(gB)?"T":"F") << ", BA=" << (prepare(gB)->crosses(gA)?"T":"F") << std::endl;
- std::cout << "\t Prepared Within:\tAB=" << (prepare(gA)->within(gB)?"T":"F") << ", BA=" << (prepare(gB)->within(gA)?"T":"F") << std::endl;
- std::cout << "\t Prepared Contains:\tAB=" << (prepare(gA)->contains(gB)?"T":"F") << ", BA=" << (prepare(gB)->contains(gA)?"T":"F") << std::endl;
- std::cout << "\t Prepared Overlaps:\tAB=" << (prepare(gA)->overlaps(gB)?"T":"F") << ", BA=" << (prepare(gB)->overlaps(gA)?"T":"F") << std::endl;
+ std::cout << "\t Equals:\tAB=" << (p_gA->equals(p_gB)?"T":"F") << ", BA=" << (p_gB->equals(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Disjoint:\tAB=" << (p_gA->disjoint(p_gB)?"T":"F") << ", BA=" << (p_gB->disjoint(p_gA)?"T":"F") << std::endl;
+ std::cout << "\tIntersects:\tAB=" << (p_gA->intersects(p_gB)?"T":"F") << ", BA=" << (p_gB->intersects(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Touches:\tAB=" << (p_gA->touches(p_gB)?"T":"F") << ", BA=" << (p_gB->touches(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Crosses:\tAB=" << (p_gA->crosses(p_gB)?"T":"F") << ", BA=" << (p_gB->crosses(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Within:\tAB=" << (p_gA->within(p_gB)?"T":"F") << ", BA=" << (p_gB->within(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Contains:\tAB=" << (p_gA->contains(p_gB)?"T":"F") << ", BA=" << (p_gB->contains(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Overlaps:\tAB=" << (p_gA->overlaps(p_gB)?"T":"F") << ", BA=" << (p_gB->overlaps(p_gA)?"T":"F") << std::endl;
+
+ std::cout << "\t Prepared Disjoint:\tAB=" << (prepare(p_gA)->disjoint(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->disjoint(p_gA)?"T":"F") << std::endl;
+ std::cout << "\tPrepared Intersects:\tAB=" << (prepare(p_gA)->intersects(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->intersects(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Prepared Touches:\tAB=" << (prepare(p_gA)->touches(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->touches(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Prepared Crosses:\tAB=" << (prepare(p_gA)->crosses(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->crosses(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Prepared Within:\tAB=" << (prepare(p_gA)->within(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->within(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Prepared Contains:\tAB=" << (prepare(p_gA)->contains(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->contains(p_gA)?"T":"F") << std::endl;
+ std::cout << "\t Prepared Overlaps:\tAB=" << (prepare(p_gA)->overlaps(p_gB)?"T":"F") << ", BA=" << (prepare(p_gB)->overlaps(p_gA)?"T":"F") << std::endl;
}
XMLTester::~XMLTester()
-----------------------------------------------------------------------
Summary of changes:
CMakeLists.txt | 2 +-
include/geos/algorithm/RayCrossingCounter.h | 4 +-
.../algorithm/distance/DiscreteFrechetDistance.h | 8 +-
.../algorithm/distance/DiscreteHausdorffDistance.h | 24 ++---
.../algorithm/locate/IndexedPointInAreaLocator.h | 4 +-
.../algorithm/locate/SimplePointInAreaLocator.h | 4 +-
.../geom/prep/AbstractPreparedPolygonContains.h | 10 +-
include/geos/geom/prep/PreparedPolygonPredicate.h | 4 +-
include/geos/geom/util/GeometryExtracter.h | 8 +-
.../index/intervalrtree/IntervalRTreeLeafNode.h | 6 +-
.../geos/index/intervalrtree/IntervalRTreeNode.h | 6 +-
include/geos/linearref/LocationIndexedLine.h | 4 +-
.../noding/MCIndexSegmentSetMutualIntersector.h | 4 +-
include/geos/noding/OrientedCoordinateArray.h | 6 +-
include/geos/noding/SegmentIntersectionDetector.h | 12 +--
.../triangulate/DelaunayTriangulationBuilder.h | 4 +-
include/geos/triangulate/quadedge/QuadEdge.h | 4 +-
.../triangulate/quadedge/QuadEdgeSubdivision.h | 4 +-
src/CMakeLists.txt | 10 +-
src/algorithm/ConvexHull.cpp | 42 ++++----
src/algorithm/PointLocator.cpp | 4 +-
src/algorithm/distance/DiscreteFrechetDistance.cpp | 10 +-
.../distance/DiscreteHausdorffDistance.cpp | 4 +-
src/geom/GeometryCollection.cpp | 6 +-
src/geom/LineString.cpp | 10 +-
src/geom/prep/PreparedPolygonContains.cpp | 4 +-
src/geom/util/GeometryTransformer.cpp | 12 +--
src/geomgraph/EdgeEndStar.cpp | 2 +-
src/geomgraph/EdgeRing.cpp | 4 +-
src/geomgraph/GeometryGraph.cpp | 42 ++++----
src/geomgraph/index/SegmentIntersector.cpp | 10 +-
src/index/bintree/Key.cpp | 6 +-
src/index/quadtree/Key.cpp | 4 +-
src/index/strtree/BoundablePair.cpp | 8 +-
src/index/strtree/SIRtree.cpp | 18 ++--
src/index/strtree/STRtree.cpp | 14 +--
src/io/WKTWriter.cpp | 96 +++++++++----------
src/linearref/ExtractLineByLocation.cpp | 4 +-
src/linearref/LengthIndexOfPoint.cpp | 4 +-
src/linearref/LengthIndexedLine.cpp | 4 +-
src/linearref/LengthLocationMap.cpp | 4 +-
src/linearref/LinearGeometryBuilder.cpp | 12 +--
src/linearref/LinearIterator.cpp | 22 ++---
src/linearref/LinearLocation.cpp | 18 ++--
src/linearref/LocationIndexOfLine.cpp | 4 +-
src/linearref/LocationIndexOfPoint.cpp | 4 +-
src/noding/GeometryNoder.cpp | 14 +--
src/noding/NodingValidator.cpp | 4 +-
src/noding/snapround/HotPixel.cpp | 10 +-
src/noding/snapround/SimpleSnapRounder.cpp | 8 +-
src/operation/IsSimpleOp.cpp | 14 +--
src/operation/buffer/BufferInputLineSimplifier.cpp | 18 ++--
src/operation/buffer/BufferParameters.cpp | 28 +++---
src/operation/buffer/OffsetCurveBuilder.cpp | 8 +-
src/operation/buffer/OffsetSegmentGenerator.cpp | 64 ++++++-------
src/operation/distance/FacetSequence.cpp | 8 +-
.../intersection/RectangleIntersection.cpp | 28 +++---
.../intersection/RectangleIntersectionBuilder.cpp | 4 +-
src/operation/linemerge/LineSequencer.cpp | 12 +--
src/operation/overlay/ElevationMatrix.cpp | 4 +-
src/operation/overlay/MaximalEdgeRing.cpp | 4 +-
src/operation/overlay/MinimalEdgeRing.cpp | 4 +-
src/operation/overlay/OverlayOp.cpp | 6 +-
src/operation/overlay/PolygonBuilder.cpp | 4 +-
src/operation/overlay/snap/SnapOverlayOp.cpp | 12 +--
src/operation/relate/RelateNode.cpp | 4 +-
src/operation/valid/IsValidOp.cpp | 24 ++---
src/precision/GeometryPrecisionReducer.cpp | 4 +-
src/simplify/TaggedLineSegment.cpp | 12 +--
src/simplify/TaggedLineStringSimplifier.cpp | 6 +-
.../IncrementalDelaunayTriangulator.cpp | 4 +-
.../quadedge/LastFoundQuadEdgeLocator.cpp | 4 +-
src/triangulate/quadedge/QuadEdge.cpp | 4 +-
src/triangulate/quadedge/QuadEdgeSubdivision.cpp | 18 ++--
.../predicate/RectangleIntersectsPerfTest.cpp | 4 +-
tests/unit/algorithm/MinimumDiameterTest.cpp | 60 ++++++------
tests/unit/algorithm/RobustLineIntersectorTest.cpp | 5 -
tests/unit/capi/GEOSSTRtreeTest.cpp | 2 +-
tests/unit/geom/GeometryComponentFilterTest.cpp | 4 +-
tests/unit/geom/GeometryFilterTest.cpp | 4 +-
tests/unit/io/WKTReaderTest.cpp | 6 +-
.../validate/OverlayResultValidatorTest.cpp | 48 +++++-----
.../operation/union/CascadedPolygonUnionTest.cpp | 4 +-
.../unit/simplify/DouglasPeuckerSimplifierTest.cpp | 2 +-
tests/unit/tut/tut_result.hpp | 6 +-
tests/xmltester/XMLTester.cpp | 106 ++++++++++-----------
86 files changed, 540 insertions(+), 545 deletions(-)
hooks/post-receive
--
GEOS
More information about the geos-commits
mailing list