PICFLAGS="$lt_prog_compiler_pic"
AC_SUBST([PICFLAGS])
+AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-math-errno], [_cv_nomatherrno], [-fno-math-errno], [], [CFLAGS="$CFLAGS -fno-math-errno"], [])
+AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-signed-zeros], [_cv_nosignedzeros], [-fno-signed-zeros], [], [CFLAGS="$CFLAGS -fno-signed-zeros"], [])
+
dnl
dnl For GCC enable additional warning flags -Wall and -Wmissing-prototypes (using macro included with libtool)
dnl
extern LWCOLLECTION *lwgeom_as_lwcollection(const LWGEOM *lwgeom);
extern LWPOLY *lwgeom_as_lwpoly(const LWGEOM *lwgeom);
extern LWLINE *lwgeom_as_lwline(const LWGEOM *lwgeom);
-extern LWPOINT *lwgeom_as_lwpoint(const LWGEOM *lwgeom);
+
extern LWCIRCSTRING *lwgeom_as_lwcircstring(const LWGEOM *lwgeom);
extern LWCURVEPOLY *lwgeom_as_lwcurvepoly(const LWGEOM *lwgeom);
extern LWCOMPOUND *lwgeom_as_lwcompound(const LWGEOM *lwgeom);
*/
extern int getPoint2d_p(const POINTARRAY *pa, uint32_t n, POINT2D *point);
-/**
-* Returns a POINT2D pointer into the POINTARRAY serialized_ptlist,
-* suitable for reading from. This is very high performance
-* and declared const because you aren't allowed to muck with the
-* values, only read them.
-*/
-extern const POINT2D* getPoint2d_cp(const POINTARRAY *pa, uint32_t n);
-
/**
* Returns a POINT3DZ pointer into the POINTARRAY serialized_ptlist,
* suitable for reading from. This is very high performance
*/
extern void ptarray_set_point4d(POINTARRAY *pa, uint32_t n, const POINT4D *p4d);
-/*
- * get a pointer to nth point of a POINTARRAY
- * You'll need to cast it to appropriate dimensioned point.
- * Note that if you cast to a higher dimensional point you'll
- * possibly corrupt the POINTARRAY.
- *
- * WARNING: Don't cast this to a POINT !
- * it would not be reliable due to memory alignment constraints
- */
-extern uint8_t *getPoint_internal(const POINTARRAY *pa, uint32_t n);
-
-/*
- * size of point represeneted in the POINTARRAY
- * 16 for 2d, 24 for 3d, 32 for 4d
- */
-extern size_t ptarray_point_size(const POINTARRAY *pa);
-
-
/**
* Construct an empty pointarray, allocating storage and setting
* the npoints, but not filling in any information. Should be used in conjunction
/* general utilities 2D */
extern double distance2d_pt_pt(const POINT2D *p1, const POINT2D *p2);
-
-inline static double
-distance2d_sqr_pt_pt(const POINT2D *p1, const POINT2D *p2)
-{
- double hside = p2->x - p1->x;
- double vside = p2->y - p1->y;
-
- return hside * hside + vside * vside;
-}
-
extern double distance2d_pt_seg(const POINT2D *p, const POINT2D *A, const POINT2D *B);
extern double distance2d_sqr_pt_seg(const POINT2D *p, const POINT2D *A, const POINT2D *B);
extern LWGEOM* lwgeom_closest_line(const LWGEOM *lw1, const LWGEOM *lw2);
*/
extern int lwgeom_has_srid(const LWGEOM *geom);
-/**
-* Return true or false depending on whether a geometry is an "empty"
-* geometry (no vertices members)
-*/
-extern int lwgeom_is_empty(const LWGEOM *geom);
-
/**
* Return true or false depending on whether a geometry is a linear
* feature that closes on itself.
*/
extern int32_t lwgeom_get_srid(const LWGEOM *geom);
-/**
-* Return LWTYPE number
-*/
-extern uint32_t lwgeom_get_type(const LWGEOM *geom);
-
/**
* Return #LW_TRUE if geometry has Z ordinates
*/
*/
int * lwgeom_cluster_2d_kmeans(const LWGEOM **geoms, uint32_t ngeoms, uint32_t k);
+#include "lwinline.h"
+
#endif /* !defined _LIBLWGEOM_H */
return ptarray_is_closed_2d(curve->points);
}
-int lwcircstring_is_empty(const LWCIRCSTRING *circ)
-{
- if ( !circ->points || circ->points->npoints < 1 )
- return LW_TRUE;
- return LW_FALSE;
-}
-
double lwcircstring_length(const LWCIRCSTRING *circ)
{
return lwcircstring_length_2d(circ);
return colout;
}
-int lwcollection_is_empty(const LWCOLLECTION *col)
-{
- uint32_t i;
- if ( (col->ngeoms == 0) || (!col->geoms) )
- return LW_TRUE;
- for( i = 0; i < col->ngeoms; i++ )
- {
- if ( ! lwgeom_is_empty(col->geoms[i]) ) return LW_FALSE;
- }
- return LW_TRUE;
-}
-
uint32_t lwcollection_count_vertices(LWCOLLECTION *col)
{
}
}
-LWPOINT *
-lwgeom_as_lwpoint(const LWGEOM *lwgeom)
-{
- if ( lwgeom == NULL ) return NULL;
- if ( lwgeom->type == POINTTYPE )
- return (LWPOINT *)lwgeom;
- else return NULL;
-}
-
LWLINE *
lwgeom_as_lwline(const LWGEOM *lwgeom)
{
return geom->srid;
}
-uint32_t
-lwgeom_get_type(const LWGEOM *geom)
-{
- if ( ! geom ) return 0;
- return geom->type;
-}
-
int
lwgeom_has_z(const LWGEOM *geom)
{
return result;
}
-int lwgeom_is_empty(const LWGEOM *geom)
-{
- int result = LW_FALSE;
- LWDEBUGF(4, "lwgeom_is_empty: got type %s",
- lwtype_name(geom->type));
-
- switch (geom->type)
- {
- case POINTTYPE:
- return lwpoint_is_empty((LWPOINT*)geom);
- break;
- case LINETYPE:
- return lwline_is_empty((LWLINE*)geom);
- break;
- case CIRCSTRINGTYPE:
- return lwcircstring_is_empty((LWCIRCSTRING*)geom);
- break;
- case POLYGONTYPE:
- return lwpoly_is_empty((LWPOLY*)geom);
- break;
- case TRIANGLETYPE:
- return lwtriangle_is_empty((LWTRIANGLE*)geom);
- break;
- case MULTIPOINTTYPE:
- case MULTILINETYPE:
- case MULTIPOLYGONTYPE:
- case COMPOUNDTYPE:
- case CURVEPOLYTYPE:
- case MULTICURVETYPE:
- case MULTISURFACETYPE:
- case POLYHEDRALSURFACETYPE:
- case TINTYPE:
- case COLLECTIONTYPE:
- return lwcollection_is_empty((LWCOLLECTION *)geom);
- break;
- default:
- lwerror("lwgeom_is_empty: unsupported input geometry type: %s",
- lwtype_name(geom->type));
- break;
- }
- return result;
-}
-
int lwgeom_has_srid(const LWGEOM *geom)
{
if ( geom->srid != SRID_UNKNOWN )
return 1;
}
-/**
-* Returns a pointer into the POINTARRAY serialized_ptlist,
-* suitable for reading from. This is very high performance
-* and declared const because you aren't allowed to muck with the
-* values, only read them.
-*/
-const POINT2D*
-getPoint2d_cp(const POINTARRAY *pa, uint32_t n)
-{
- if ( ! pa ) return 0;
-
- if ( n>=pa->npoints )
- {
- lwerror("getPoint2d_cp: point offset out of range");
- return 0; /*error */
- }
-
- return (const POINT2D*)getPoint_internal(pa, n);
-}
-
const POINT3DZ*
getPoint3dz_cp(const POINTARRAY *pa, uint32_t n)
{
--- /dev/null
+/**********************************************************************
+ *
+ * PostGIS - Spatial Types for PostgreSQL
+ * http://postgis.net
+ *
+ * PostGIS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * PostGIS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PostGIS. If not, see <http://www.gnu.org/licenses/>.
+ *
+ **********************************************************************
+ *
+ * Copyright 2018 Darafei Praliaskouski <me@komzpa.net>
+ * Copyright 2017-2018 Daniel Baston <dbaston@gmail.com>
+ * Copyright 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright 2011 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright 2007-2008 Mark Cave-Ayland
+ * Copyright 2001-2006 Refractions Research Inc.
+ *
+ **********************************************************************/
+
+#if PARANOIA_LEVEL > 0
+#include <assert.h>
+#endif
+
+inline static double
+distance2d_sqr_pt_pt(const POINT2D *p1, const POINT2D *p2)
+{
+ double hside = p2->x - p1->x;
+ double vside = p2->y - p1->y;
+
+ return hside * hside + vside * vside;
+}
+
+/*
+ * Size of point represeneted in the POINTARRAY
+ * 16 for 2d, 24 for 3d, 32 for 4d
+ */
+static inline size_t
+ptarray_point_size(const POINTARRAY *pa)
+{
+ return sizeof(double) * FLAGS_NDIMS(pa->flags);
+}
+
+/*
+ * Get a pointer to Nth point of a POINTARRAY
+ * You'll need to cast it to appropriate dimensioned point.
+ * Note that if you cast to a higher dimensional point you'll
+ * possibly corrupt the POINTARRAY.
+ *
+ * Casting to returned pointer to POINT2D* should be safe,
+ * as gserialized format always keeps the POINTARRAY pointer
+ * aligned to double boundary.
+ *
+ * WARNING: Don't cast this to a POINT!
+ * it would not be reliable due to memory alignment constraints
+ */
+static inline uint8_t *
+getPoint_internal(const POINTARRAY *pa, uint32_t n)
+{
+ size_t size;
+ uint8_t *ptr;
+
+#if PARANOIA_LEVEL > 0
+ assert(pa);
+ assert(n <= pa->npoints);
+ assert(n < pa->maxpoints);
+#endif
+
+ size = ptarray_point_size(pa);
+ ptr = pa->serialized_pointlist + size * n;
+
+ return ptr;
+}
+
+/**
+ * Returns a POINT2D pointer into the POINTARRAY serialized_ptlist,
+ * suitable for reading from. This is very high performance
+ * and declared const because you aren't allowed to muck with the
+ * values, only read them.
+ */
+static inline const POINT2D *
+getPoint2d_cp(const POINTARRAY *pa, uint32_t n)
+{
+ if (!pa)
+ return 0;
+
+ return (const POINT2D *)getPoint_internal(pa, n);
+}
+
+static inline LWPOINT *
+lwgeom_as_lwpoint(const LWGEOM *lwgeom)
+{
+ if (!lwgeom)
+ return NULL;
+ if (lwgeom->type == POINTTYPE)
+ return (LWPOINT *)lwgeom;
+ else
+ return NULL;
+}
+
+/**
+ * Return LWTYPE number
+ */
+static inline uint32_t
+lwgeom_get_type(const LWGEOM *geom)
+{
+ if (!geom)
+ return 0;
+ return geom->type;
+}
+
+static inline int
+lwpoint_is_empty(const LWPOINT *point)
+{
+ if (!point->point || point->point->npoints < 1)
+ return LW_TRUE;
+ return LW_FALSE;
+}
+
+static inline int
+lwline_is_empty(const LWLINE *line)
+{
+ if (!line->points || line->points->npoints < 1)
+ return LW_TRUE;
+ return LW_FALSE;
+}
+
+static inline int
+lwcircstring_is_empty(const LWCIRCSTRING *circ)
+{
+ if (!circ->points || circ->points->npoints < 1)
+ return LW_TRUE;
+ return LW_FALSE;
+}
+
+static inline int
+lwpoly_is_empty(const LWPOLY *poly)
+{
+ if ((poly->nrings < 1) || (!poly->rings) || (!poly->rings[0]) || (poly->rings[0]->npoints < 1))
+ return LW_TRUE;
+ return LW_FALSE;
+}
+
+static inline int
+lwtriangle_is_empty(const LWTRIANGLE *triangle)
+{
+ if (!triangle->points || triangle->points->npoints < 1)
+ return LW_TRUE;
+ return LW_FALSE;
+}
+
+static inline int lwgeom_is_empty(const LWGEOM *geom);
+
+static inline int
+lwcollection_is_empty(const LWCOLLECTION *col)
+{
+ uint32_t i;
+ if ((col->ngeoms == 0) || (!col->geoms))
+ return LW_TRUE;
+ for (i = 0; i < col->ngeoms; i++)
+ {
+ if (!lwgeom_is_empty(col->geoms[i]))
+ return LW_FALSE;
+ }
+ return LW_TRUE;
+}
+
+/**
+ * Return true or false depending on whether a geometry is an "empty"
+ * geometry (no vertices members)
+ */
+static inline int
+lwgeom_is_empty(const LWGEOM *geom)
+{
+ switch (geom->type)
+ {
+ case POINTTYPE:
+ return lwpoint_is_empty((LWPOINT *)geom);
+ break;
+ case LINETYPE:
+ return lwline_is_empty((LWLINE *)geom);
+ break;
+ case CIRCSTRINGTYPE:
+ return lwcircstring_is_empty((LWCIRCSTRING *)geom);
+ break;
+ case POLYGONTYPE:
+ return lwpoly_is_empty((LWPOLY *)geom);
+ break;
+ case TRIANGLETYPE:
+ return lwtriangle_is_empty((LWTRIANGLE *)geom);
+ break;
+ case MULTIPOINTTYPE:
+ case MULTILINETYPE:
+ case MULTIPOLYGONTYPE:
+ case COMPOUNDTYPE:
+ case CURVEPOLYTYPE:
+ case MULTICURVETYPE:
+ case MULTISURFACETYPE:
+ case POLYHEDRALSURFACETYPE:
+ case TINTYPE:
+ case COLLECTIONTYPE:
+ return lwcollection_is_empty((LWCOLLECTION *)geom);
+ break;
+ default:
+ return LW_FALSE;
+ break;
+ }
+}
*
*------------------------------------------------------------------------*/
-#include <float.h>
-#include <math.h>
-
#include "liblwgeom_internal.h"
/*
uint32_t p1 = 0, p2 = 0;
uint32_t i, j;
uint32_t duplicate_count = 1; /* a point is a duplicate of itself */
- double max_dst = -1;
+ double max_dst = -1, current_distance;
double dst_p1, dst_p2;
/* k=0, k=1: "clustering" is just input validation */
dst_p2 = distance2d_sqr_pt_pt(objs[i], objs[p2]);
if ((dst_p1 > max_dst) || (dst_p2 > max_dst))
{
- max_dst = fmax(dst_p1, dst_p2);
if (dst_p1 > dst_p2)
+ {
+ max_dst = dst_p1;
p2 = i;
+ }
else
+ {
+ max_dst = dst_p2;
p1 = i;
+ }
}
if ((dst_p1 == 0) || (dst_p2 == 0)) duplicate_count++;
}
if (distances[j] < 0) continue;
/* update minimal distance with previosuly accepted cluster */
- distances[j] = fmin(distance2d_sqr_pt_pt(objs[j], centers[i - 1]), distances[j]);
+ current_distance = distance2d_sqr_pt_pt(objs[j], centers[i - 1]);
+ if (current_distance < distances[j])
+ distances[j] = current_distance;
/* greedily take a point that's farthest from any of accepted clusters */
if (distances[j] > max_distance)
return lineout;
}
-int lwline_is_empty(const LWLINE *line)
-{
- if ( !line->points || line->points->npoints < 1 )
- return LW_TRUE;
- return LW_FALSE;
-}
-
-
uint32_t lwline_count_vertices(LWLINE *line)
{
assert(line);
return pointout;
}
-int lwpoint_is_empty(const LWPOINT *point)
-{
- if ( ! point->point || point->point->npoints < 1 )
- return LW_TRUE;
- return LW_FALSE;
-}
-
-
return polyout;
}
-int lwpoly_is_empty(const LWPOLY *poly)
-{
- if ( (poly->nrings < 1) || (!poly->rings) || (!poly->rings[0]) || (poly->rings[0]->npoints < 1) )
- return LW_TRUE;
- return LW_FALSE;
-}
-
uint32_t lwpoly_count_vertices(LWPOLY *poly)
{
uint32_t i = 0;
return ret;
}
-int lwtriangle_is_empty(const LWTRIANGLE *triangle)
-{
- if ( !triangle->points || triangle->points->npoints < 1 )
- return LW_TRUE;
- return LW_FALSE;
-}
-
/**
* Find the area of the outer ring
*/
va_end(ap);
}
-
-
const char*
lwtype_name(uint8_t type)
{
return FLAGS_GET_M(pa->flags);
}
-/*
- * Size of point represeneted in the POINTARRAY
- * 16 for 2d, 24 for 3d, 32 for 4d
- */
-inline size_t
-ptarray_point_size(const POINTARRAY *pa)
-{
- LWDEBUGF(5, "ptarray_point_size: FLAGS_NDIMS(pa->flags)=%x",FLAGS_NDIMS(pa->flags));
-
- return sizeof(double)*FLAGS_NDIMS(pa->flags);
-}
-
POINTARRAY*
ptarray_construct(char hasz, char hasm, uint32_t npoints)
{
}
-/*
- * Get a pointer to nth point of a POINTARRAY.
- *
- * Casting to returned pointer to POINT2D* should be safe,
- * as gserialized format always keeps the POINTARRAY pointer
- * aligned to double boundary.
- */
-uint8_t *
-getPoint_internal(const POINTARRAY *pa, uint32_t n)
-{
- size_t size;
- uint8_t *ptr;
-
-#if PARANOIA_LEVEL > 0
- if ( pa == NULL )
- {
- lwerror("%s [%d] got NULL pointarray", __FILE__, __LINE__);
- return NULL;
- }
-
- LWDEBUGF(5, "(n=%d, pa.npoints=%d, pa.maxpoints=%d)",n,pa->npoints,pa->maxpoints);
-
- if ( ( n > pa->npoints ) ||
- ( n >= pa->maxpoints ) )
- {
- lwerror("%s [%d] called outside of ptarray range (n=%d, pa.npoints=%d, pa.maxpoints=%d)", __FILE__, __LINE__, n, pa->npoints, pa->maxpoints);
- return NULL; /*error */
- }
-#endif
-
- size = ptarray_point_size(pa);
-
- ptr = pa->serialized_pointlist + size * n;
- if ( FLAGS_NDIMS(pa->flags) == 2)
- {
- LWDEBUGF(5, "point = %g %g", *((double*)(ptr)), *((double*)(ptr+8)));
- }
- else if ( FLAGS_NDIMS(pa->flags) == 3)
- {
- LWDEBUGF(5, "point = %g %g %g", *((double*)(ptr)), *((double*)(ptr+8)), *((double*)(ptr+16)));
- }
- else if ( FLAGS_NDIMS(pa->flags) == 4)
- {
- LWDEBUGF(5, "point = %g %g %g %g", *((double*)(ptr)), *((double*)(ptr+8)), *((double*)(ptr+16)), *((double*)(ptr+24)));
- }
-
- return ptr;
-}
-
/**
* Affine transform a pointarray.
*
**********************************************************************/
-
-
#include "liblwgeom_internal.h"
#include "stringbuffer.h"
s->str_end = s->str_start;
}
-/**
-* If necessary, expand the stringbuffer_t internal buffer to accommodate the
-* specified additional size.
-*/
-static inline void
-stringbuffer_makeroom(stringbuffer_t *s, size_t size_to_add)
-{
- size_t current_size = (s->str_end - s->str_start);
- size_t capacity = s->capacity;
- size_t required_size = current_size + size_to_add;
-
- while (capacity < required_size)
- capacity *= 2;
-
- if ( capacity > s->capacity )
- {
- s->str_start = lwrealloc(s->str_start, capacity);
- s->capacity = capacity;
- s->str_end = s->str_start + current_size;
- }
-}
-
/**
* Return the last character in the buffer.
*/
return *(s->str_end - 1);
}
-/**
-* Append the specified string to the stringbuffer_t.
-*/
-void
-stringbuffer_append(stringbuffer_t *s, const char *a)
-{
- int alen = strlen(a); /* Length of string to append */
- int alen0 = alen + 1; /* Length including null terminator */
- stringbuffer_makeroom(s, alen0);
- memcpy(s->str_end, a, alen0);
- s->str_end += alen;
-}
/**
* Returns a reference to the internal string being managed by
#ifndef _STRINGBUFFER_H
#define _STRINGBUFFER_H 1
+#include "liblwgeom_internal.h"
+
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
extern void stringbuffer_clear(stringbuffer_t *sb);
void stringbuffer_set(stringbuffer_t *sb, const char *s);
void stringbuffer_copy(stringbuffer_t *sb, stringbuffer_t *src);
-extern void stringbuffer_append(stringbuffer_t *sb, const char *s);
extern int stringbuffer_aprintf(stringbuffer_t *sb, const char *fmt, ...);
extern const char *stringbuffer_getstring(stringbuffer_t *sb);
extern char *stringbuffer_getstringcopy(stringbuffer_t *sb);
extern int stringbuffer_trim_trailing_white(stringbuffer_t *s);
extern int stringbuffer_trim_trailing_zeroes(stringbuffer_t *s);
+/**
+ * If necessary, expand the stringbuffer_t internal buffer to accommodate the
+ * specified additional size.
+ */
+static inline void
+stringbuffer_makeroom(stringbuffer_t *s, size_t size_to_add)
+{
+ size_t current_size = (s->str_end - s->str_start);
+ size_t capacity = s->capacity;
+ size_t required_size = current_size + size_to_add;
+
+ while (capacity < required_size)
+ capacity *= 2;
+
+ if (capacity > s->capacity)
+ {
+ s->str_start = lwrealloc(s->str_start, capacity);
+ s->capacity = capacity;
+ s->str_end = s->str_start + current_size;
+ }
+}
+/**
+ * Append the specified string to the stringbuffer_t.
+ */
+inline static void
+stringbuffer_append(stringbuffer_t *s, const char *a)
+{
+ int alen = strlen(a); /* Length of string to append */
+ int alen0 = alen + 1; /* Length including null terminator */
+ stringbuffer_makeroom(s, alen0);
+ memcpy(s->str_end, a, alen0);
+ s->str_end += alen;
+}
#endif /* _STRINGBUFFER_H */
projects / postgis / commitdiff