/*
* Creates a 2D (xy) linestring from a list of 2D points.
*
* Parameter first is a gaiaPointPtr to the first point in a linked list of points which define the linestring.
* All of the points in the list must be 2D (xy) points. There must be at least 2 points in the list.
*
* Returns a pointer to linestring containing all of the points in the list.
*/
static gaiaLinestringPtr
geoJSON_linestring_xy (struct geoJson_data *p_data, gaiaPointPtr first)
{
gaiaPointPtr p = first;
gaiaPointPtr p_n;
int points = 0;
int i = 0;
gaiaLinestringPtr linestring;
while (p != NULL)
{
p = p->Next;
points++;
}
linestring = gaiaAllocLinestring (points);
geoJsonMapDynAlloc (p_data, GEOJSON_DYN_LINESTRING, linestring);
p = first;
while (p != NULL)
{
gaiaSetPoint (linestring->Coords, i, p->X, p->Y);
p_n = p->Next;
geoJsonMapDynClean (p_data, p);
gaiaFreePoint (p);
p = p_n;
i++;
}
return linestring;
}
static void
add_linestring_to_geometry (struct gml_params *params,
gaiaDynamicLinePtr dyn_line)
{
/* adding a LINESTRING to current Geometry */
int iv = 0;
gaiaPointPtr pt;
gaiaLinestringPtr line;
if (params->geometry == NULL)
params->geometry = gaiaAllocGeomColl ();
pt = dyn_line->First;
while (pt)
{
/* counting how many POINTs are there */
iv++;
pt = pt->Next;
}
line = gaiaAddLinestringToGeomColl (params->geometry, iv);
iv = 0;
pt = dyn_line->First;
while (pt)
{
/* inserting any POINT into LINESTRING */
gaiaSetPoint (line->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
gaiaFreeDynamicLine (dyn_line);
}
static gaiaGeomCollPtr
gaiaGeoJsonGeometryFromLinestring (struct geoJson_data *p_data,
gaiaLinestringPtr line, int srid)
{
/* builds a GEOMETRY containing a LINESTRING */
gaiaGeomCollPtr geom = NULL;
gaiaLinestringPtr line2;
int iv;
double x;
double y;
geom = gaiaAllocGeomColl ();
geoJsonMapDynAlloc (p_data, GEOJSON_DYN_GEOMETRY, geom);
geom->DeclaredType = GAIA_LINESTRING;
geom->Srid = srid;
line2 = gaiaAddLinestringToGeomColl (geom, line->Points);
for (iv = 0; iv < line2->Points; iv++)
{
/* sets the POINTS for the exterior ring */
gaiaGetPoint (line->Coords, iv, &x, &y);
gaiaSetPoint (line2->Coords, iv, x, y);
}
geoJsonMapDynClean (p_data, line);
gaiaFreeLinestring (line);
return geom;
}
/*
* Creates a 2D (xy) ring in SpatiaLite
*
* first is a gaiaPointPtr to the first point in a linked list of points which define the polygon.
* All of the points given to the function are 2D (xy) points. There will be at least 4 points in the list.
*
* Returns the ring defined by the points given to the function.
*/
static gaiaRingPtr
geoJSON_ring_xy (struct geoJson_data *p_data, gaiaPointPtr first)
{
gaiaPointPtr p = first;
gaiaPointPtr p_n;
gaiaRingPtr ring = NULL;
int numpoints;
int index;
/* If no pointers are given, return. */
if (first == NULL)
return NULL;
/* Counts the number of points in the ring. */
numpoints = geoJSON_count_points (first);
if (numpoints < 4)
return NULL;
/* Creates and allocates a ring structure. */
ring = gaiaAllocRing (numpoints);
if (ring == NULL)
return NULL;
geoJsonMapDynAlloc (p_data, GEOJSON_DYN_RING, ring);
/* Adds every point into the ring structure. */
p = first;
for (index = 0; index < numpoints; index++)
{
gaiaSetPoint (ring->Coords, index, p->X, p->Y);
p_n = p->Next;
geoJsonMapDynClean (p_data, p);
gaiaFreePoint (p);
p = p_n;
}
return ring;
}
GAIAGEO_DECLARE void
gaiaSwapCoords (gaiaGeomCollPtr geom)
{
/* returns a geometry that is the old geometry with swapped x- and y-coordinates */
int ib;
int iv;
double x;
double y;
double z;
double m;
double sv;
gaiaPointPtr point;
gaiaPolygonPtr polyg;
gaiaLinestringPtr line;
gaiaRingPtr ring;
if (!geom)
return;
point = geom->FirstPoint;
while (point)
{
/* swapping POINTs */
sv = point->X;
point->X = point->Y;
point->Y = sv;
point = point->Next;
}
line = geom->FirstLinestring;
while (line)
{
/* swapping LINESTRINGs */
for (iv = 0; iv < line->Points; iv++)
{
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
sv = x;
x = y;
y = sv;
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (line->Coords, iv, x, y, z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (line->Coords, iv, x, y, m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (line->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (line->Coords, iv, x, y);
}
}
line = line->Next;
}
polyg = geom->FirstPolygon;
while (polyg)
{
/* swapping POLYGONs */
ring = polyg->Exterior;
for (iv = 0; iv < ring->Points; iv++)
{
/* shifting the EXTERIOR RING */
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
sv = x;
x = y;
y = sv;
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
for (ib = 0; ib < polyg->NumInteriors; ib++)
{
/* swapping the INTERIOR RINGs */
ring = polyg->Interiors + ib;
for (iv = 0; iv < ring->Points; iv++)
{
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
sv = x;
x = y;
y = sv;
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
}
polyg = polyg->Next;
}
gaiaMbrGeometry (geom);
}
GAIAGEO_DECLARE void
gaiaRotateCoords (gaiaGeomCollPtr geom, double angle)
{
/* returns a geometry that is the old geometry with required rotation applied to coordinates */
int ib;
int iv;
double x;
double y;
double z;
double m;
double nx;
double ny;
double rad = angle * 0.0174532925199432958;
double cosine = cos (rad);
double sine = sin (rad);
gaiaPointPtr point;
gaiaPolygonPtr polyg;
gaiaLinestringPtr line;
gaiaRingPtr ring;
if (!geom)
return;
point = geom->FirstPoint;
while (point)
{
/* shifting POINTs */
x = point->X;
y = point->Y;
point->X = (x * cosine) + (y * sine);
point->Y = (y * cosine) - (x * sine);
point = point->Next;
}
line = geom->FirstLinestring;
while (line)
{
/* rotating LINESTRINGs */
for (iv = 0; iv < line->Points; iv++)
{
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
nx = (x * cosine) + (y * sine);
ny = (y * cosine) - (x * sine);
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (line->Coords, iv, nx, ny, z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (line->Coords, iv, nx, ny, m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (line->Coords, iv, nx, ny, z, m);
}
else
{
gaiaSetPoint (line->Coords, iv, nx, ny);
}
}
line = line->Next;
}
polyg = geom->FirstPolygon;
while (polyg)
{
/* rotating POLYGONs */
ring = polyg->Exterior;
for (iv = 0; iv < ring->Points; iv++)
{
/* rotating the EXTERIOR RING */
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
nx = (x * cosine) + (y * sine);
ny = (y * cosine) - (x * sine);
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, nx, ny, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, nx, ny, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, nx, ny, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, nx, ny);
}
}
for (ib = 0; ib < polyg->NumInteriors; ib++)
{
/* rotating the INTERIOR RINGs */
ring = polyg->Interiors + ib;
for (iv = 0; iv < ring->Points; iv++)
{
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
nx = (x * cosine) + (y * sine);
ny = (y * cosine) - (x * sine);
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, nx, ny, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, nx, ny, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, nx, ny, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, nx, ny);
}
}
}
polyg = polyg->Next;
}
gaiaMbrGeometry (geom);
}
static void
auxGridSnapLinestring (gaiaLinestringPtr ln, gaiaGeomCollPtr result,
double origin_x, double origin_y, double origin_z,
double origin_m, double size_x, double size_y,
double size_z, double size_m)
{
/* snapping a Linestring to a regular Grid */
double x;
double y;
double z;
double m;
int has_z = 0;
int has_m = 0;
int iv;
gaiaDynamicLinePtr dyn;
gaiaPointPtr pt;
gaiaLinestringPtr lnx;
int count = 0;
if (ln == NULL || result == NULL)
return;
if (ln->DimensionModel == GAIA_XY_Z || ln->DimensionModel == GAIA_XY_Z_M)
has_z = 1;
if (ln->DimensionModel == GAIA_XY_M || ln->DimensionModel == GAIA_XY_Z_M)
has_m = 1;
dyn = gaiaAllocDynamicLine ();
for (iv = 0; iv < ln->Points; iv++)
{
/* snapping each Vertex to the given grid */
int to_be_inserted = 0;
z = 0.0;
m = 0.0;
if (has_z && has_m)
{
gaiaGetPointXYZM (ln->Coords, iv, &x, &y, &z, &m);
}
else if (has_z)
{
gaiaGetPointXYZ (ln->Coords, iv, &x, &y, &z);
}
else if (has_m)
{
gaiaGetPointXYM (ln->Coords, iv, &x, &y, &m);
}
else
{
gaiaGetPoint (ln->Coords, iv, &x, &y);
}
/* snapping coords to the given grid */
if (size_x > 0.0)
x = rint ((x - origin_x) / size_x) * size_x + origin_x;
if (size_y > 0.0)
y = rint ((y - origin_y) / size_y) * size_y + origin_y;
if (has_z && size_z > 0.0)
z = rint ((z - origin_z) / size_z) * size_z + origin_z;
if (has_m && size_m > 0.0)
m = rint ((m - origin_m) / size_m) * size_m + origin_m;
if (dyn->Last == NULL)
to_be_inserted = 1;
else
{
/* skipping repeated points */
pt = dyn->Last;
if (has_z && has_m)
{
if (pt->X == x && pt->Y == y && pt->Z == z && pt->M == m)
;
else
to_be_inserted = 1;
}
else if (has_z)
{
if (pt->X == x && pt->Y == y && pt->Z == z)
;
else
to_be_inserted = 1;
}
else if (has_m)
{
if (pt->X == x && pt->Y == y && pt->M == m)
;
else
to_be_inserted = 1;
}
else
{
if (pt->X == x && pt->Y == y)
;
else
to_be_inserted = 1;
}
}
if (to_be_inserted)
{
if (has_z && has_m)
gaiaAppendPointZMToDynamicLine (dyn, x, y, z, m);
else if (has_z)
gaiaAppendPointZToDynamicLine (dyn, x, y, z);
else if (has_m)
gaiaAppendPointMToDynamicLine (dyn, x, y, m);
else
gaiaAppendPointToDynamicLine (dyn, x, y);
}
}
/* checking for validity */
pt = dyn->First;
while (pt)
{
/* counting how many points are there */
count++;
pt = pt->Next;
}
if (count < 2)
{
/* skipping any collapsed line */
gaiaFreeDynamicLine (dyn);
return;
}
/* inserting into the result Geometry */
lnx = gaiaAddLinestringToGeomColl (result, count);
iv = 0;
pt = dyn->First;
while (pt)
{
/* copying points */
if (lnx->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (lnx->Coords, iv, pt->X, pt->Y, pt->Z);
}
else if (lnx->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (lnx->Coords, iv, pt->X, pt->Y, pt->M);
}
else if (lnx->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (lnx->Coords, iv, pt->X, pt->Y, pt->Z, pt->M);
}
else
{
gaiaSetPoint (lnx->Coords, iv, pt->X, pt->Y);
}
iv++;
pt = pt->Next;
}
gaiaFreeDynamicLine (dyn);
}
static int
kml_parse_linestring (struct kml_data *p_data, gaiaGeomCollPtr geom,
kmlNodePtr node, kmlNodePtr * next)
{
/* parsing a <LineString> */
gaiaGeomCollPtr ln;
gaiaGeomCollPtr last;
gaiaLinestringPtr new_ln;
gaiaPointPtr pt;
int iv;
int has_z = 1;
int points = 0;
gaiaDynamicLinePtr dyn = gaiaAllocDynamicLine ();
kmlMapDynAlloc (p_data, KML_DYN_DYNLINE, dyn);
if (strcmp (node->Tag, "coordinates") == 0)
{
/* parsing a KML <LineString> */
if (!kml_parse_coordinates (node->Coordinates, dyn, &has_z))
goto error;
node = node->Next;
if (node == NULL)
goto error;
if (strcmp (node->Tag, "coordinates") == 0)
;
else
goto error;
node = node->Next;
if (node == NULL)
goto error;
if (strcmp (node->Tag, "LineString") == 0)
;
else
goto error;
*next = node->Next;
}
/* ok, KML nodes match as expected */
points = kml_count_dyn_points (dyn);
if (points < 2)
goto error;
if (has_z)
{
ln = gaiaAllocGeomCollXYZ ();
kmlMapDynAlloc (p_data, KML_DYN_GEOM, ln);
new_ln = gaiaAddLinestringToGeomColl (ln, points);
pt = dyn->First;
iv = 0;
while (pt)
{
gaiaSetPointXYZ (new_ln->Coords, iv, pt->X, pt->Y, pt->Z);
iv++;
pt = pt->Next;
}
}
else
{
ln = gaiaAllocGeomColl ();
kmlMapDynAlloc (p_data, KML_DYN_GEOM, ln);
new_ln = gaiaAddLinestringToGeomColl (ln, points);
pt = dyn->First;
iv = 0;
while (pt)
{
gaiaSetPoint (new_ln->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
}
last = geom;
while (1)
{
/* searching the last Geometry within chain */
if (last->Next == NULL)
break;
last = last->Next;
}
last->Next = ln;
gaiaFreeDynamicLine (dyn);
return 1;
error:
gaiaFreeDynamicLine (dyn);
return 0;
}
static void
vbbox_read_row (VirtualBBoxCursorPtr cursor)
{
/* trying to read a row from the BoundingBox real-table */
struct splite_internal_cache *cache =
(struct splite_internal_cache *) cursor->pVtab->p_cache;
sqlite3_stmt *stmt;
int ret;
int ic;
int icx;
const char *text;
const unsigned char *blob;
int size;
sqlite3_int64 pk;
double minx;
double miny;
double maxx;
double maxy;
int srid;
char ok_minx = 'N';
char ok_miny = 'N';
char ok_maxx = 'N';
char ok_maxy = 'N';
char ok_srid = 'N';
stmt = cursor->stmt;
sqlite3_bind_int64 (stmt, 1, cursor->current_row);
ret = sqlite3_step (stmt);
if (ret == SQLITE_ROW)
{
pk = sqlite3_column_int64 (stmt, 0);
if (sqlite3_column_type (stmt, 1) == SQLITE_FLOAT)
{
minx = sqlite3_column_double (stmt, 1);
ok_minx = 'Y';
}
if (sqlite3_column_type (stmt, 2) == SQLITE_FLOAT)
{
miny = sqlite3_column_double (stmt, 2);
ok_miny = 'Y';
}
if (sqlite3_column_type (stmt, 3) == SQLITE_FLOAT)
{
maxx = sqlite3_column_double (stmt, 3);
ok_maxx = 'Y';
}
if (sqlite3_column_type (stmt, 4) == SQLITE_FLOAT)
{
maxy = sqlite3_column_double (stmt, 4);
ok_maxy = 'Y';
}
if (sqlite3_column_type (stmt, 5) == SQLITE_INTEGER)
{
srid = sqlite3_column_int (stmt, 5);
ok_srid = 'Y';
}
if (cursor->pVtab->BBoxGeom)
gaiaFreeGeomColl (cursor->pVtab->BBoxGeom);
cursor->pVtab->BBoxGeom = NULL;
if (ok_minx == 'Y' && ok_miny == 'Y' && ok_maxx == 'Y'
&& ok_maxy == 'Y')
{
gaiaGeomCollPtr geom = gaiaAllocGeomColl ();
gaiaPolygonPtr pg = gaiaAddPolygonToGeomColl (geom, 5, 0);
gaiaRingPtr rng = pg->Exterior;
gaiaSetPoint (rng->Coords, 0, minx, miny);
gaiaSetPoint (rng->Coords, 1, maxx, miny);
gaiaSetPoint (rng->Coords, 2, maxx, maxy);
gaiaSetPoint (rng->Coords, 3, minx, maxy);
gaiaSetPoint (rng->Coords, 4, minx, miny);
if (ok_srid == 'Y')
{
if (cursor->pVtab->ForceWGS84)
{
/* converting to WGS84 long-lat */
gaiaGeomCollPtr geom2 = NULL;
char *proj_from = NULL;
char *proj_to = NULL;
geom->Srid = srid;
getProjParams (cursor->pVtab->db, srid, &proj_from);
getProjParams (cursor->pVtab->db, 4326, &proj_to);
if (proj_to == NULL || proj_from == NULL)
geom2 = NULL;
else
#ifndef OMIT_PROJ /* including PROJ.4 */
if (cache != NULL)
geom2 =
gaiaTransform_r (cache, geom, proj_from,
proj_to);
else
geom2 =
gaiaTransform (geom, proj_from, proj_to);
#endif /* end including PROJ.4 */
geom2 = NULL;
if (geom2 != NULL)
geom2->Srid = 4326;
cursor->pVtab->BBoxGeom = geom2;
gaiaFreeGeomColl (geom);
if (proj_from)
free (proj_from);
if (proj_to)
free (proj_to);
}
else
{
geom->Srid = srid;
cursor->pVtab->BBoxGeom = geom;
}
}
else
{
geom->Srid = cursor->pVtab->Srid;
cursor->pVtab->BBoxGeom = geom;
}
}
icx = 5;
for (ic = 0; ic < cursor->pVtab->nColumns; ic++)
{
if (*(cursor->pVtab->Visible + ic) != 'Y')
continue;
icx++;
switch (sqlite3_column_type (stmt, icx))
{
case SQLITE_INTEGER:
value_set_int (*(cursor->pVtab->Value + ic),
sqlite3_column_int64 (stmt, icx));
break;
case SQLITE_FLOAT:
value_set_double (*(cursor->pVtab->Value + ic),
sqlite3_column_double (stmt, icx));
break;
case SQLITE_TEXT:
text = (char *) sqlite3_column_text (stmt, icx);
size = sqlite3_column_bytes (stmt, icx);
value_set_text (*(cursor->pVtab->Value + ic), text, size);
break;
case SQLITE_BLOB:
blob = sqlite3_column_blob (stmt, icx);
size = sqlite3_column_bytes (stmt, icx);
value_set_blob (*(cursor->pVtab->Value + ic), blob, size);
break;
case SQLITE_NULL:
default:
value_set_null (*(cursor->pVtab->Value + ic));
break;
};
}
}
else
{
/* an error occurred */
cursor->eof = 1;
return;
}
cursor->eof = 0;
cursor->current_row = pk;
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaMakeEllipse (double cx, double cy, double x_axis, double y_axis,
double step)
{
/* return a Linestring approximating an Ellipse */
gaiaDynamicLinePtr dyn;
double x;
double y;
double angle = 0.0;
int points = 0;
gaiaPointPtr pt;
gaiaGeomCollPtr geom;
gaiaLinestringPtr ln;
int iv = 0;
if (step < 0.0)
step *= -1.0;
if (step == 0.0)
step = 10.0;
if (step < 0.1)
step = 0.1;
if (step > 45.0)
step = 45.0;
if (x_axis < 0.0)
x_axis *= -1.0;
if (y_axis < 0.0)
y_axis *= -1.0;
dyn = gaiaAllocDynamicLine ();
while (angle < 360.0)
{
double rads = angle * .0174532925199432958;
x = cx + (x_axis * cos (rads));
y = cy + (y_axis * sin (rads));
gaiaAppendPointToDynamicLine (dyn, x, y);
angle += step;
}
/* closing the ellipse */
gaiaAppendPointToDynamicLine (dyn, dyn->First->X, dyn->First->Y);
pt = dyn->First;
while (pt)
{
/* counting how many points */
points++;
pt = pt->Next;
}
if (points == 0)
{
gaiaFreeDynamicLine (dyn);
return NULL;
}
geom = gaiaAllocGeomColl ();
ln = gaiaAddLinestringToGeomColl (geom, points);
pt = dyn->First;
while (pt)
{
/* setting Vertices */
gaiaSetPoint (ln->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
gaiaFreeDynamicLine (dyn);
return geom;
}
GAIAGEO_DECLARE void
gaiaShiftLongitude (gaiaGeomCollPtr geom)
{
/* returns a geometry that is the old geometry with negative longitudes shift by 360 */
int ib;
int iv;
double x;
double y;
double z;
double m;
gaiaPointPtr point;
gaiaPolygonPtr polyg;
gaiaLinestringPtr line;
gaiaRingPtr ring;
if (!geom)
return;
point = geom->FirstPoint;
while (point)
{
/* shifting POINTs */
if (point->X < 0)
{
point->X += 360.0;
}
point = point->Next;
}
line = geom->FirstLinestring;
while (line)
{
/* shifting LINESTRINGs */
for (iv = 0; iv < line->Points; iv++)
{
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
if (x < 0)
{
x += 360.0;
}
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (line->Coords, iv, x, y, z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (line->Coords, iv, x, y, m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (line->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (line->Coords, iv, x, y);
}
}
line = line->Next;
}
polyg = geom->FirstPolygon;
while (polyg)
{
/* shifting POLYGONs */
ring = polyg->Exterior;
for (iv = 0; iv < ring->Points; iv++)
{
/* shifting the EXTERIOR RING */
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
if (x < 0)
{
x += 360.0;
}
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
for (ib = 0; ib < polyg->NumInteriors; ib++)
{
/* shifting the INTERIOR RINGs */
ring = polyg->Interiors + ib;
for (iv = 0; iv < ring->Points; iv++)
{
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
if (x < 0)
{
x += 360.0;
}
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
}
polyg = polyg->Next;
}
gaiaMbrGeometry (geom);
}
static void
polygon_set_up (struct gml_params *params)
{
/* setting up the latest Polygon (if any) */
int iv;
int ib;
int interiors;
struct gml_rings_list *rg;
gaiaDynamicLinePtr dyn_line;
gaiaPointPtr pt;
gaiaPolygonPtr pg;
gaiaRingPtr ring;
if (params->polygon.exterior == NULL)
return;
if (params->geometry == NULL)
params->geometry = gaiaAllocGeomColl ();
/* preliminary recognition */
dyn_line = params->polygon.exterior;
iv = 0;
pt = dyn_line->First;
while (pt)
{
/* counting how many POINTs are into the Exterior Ring */
iv++;
pt = pt->Next;
}
interiors = 0;
rg = params->polygon.first;
while (rg)
{
/* counting how many Interior Rings are there */
interiors++;
rg = rg->next;
}
pg = gaiaAddPolygonToGeomColl (params->geometry, iv, interiors);
/* setting up the Exterior Ring */
ring = pg->Exterior;
iv = 0;
dyn_line = params->polygon.exterior;
pt = dyn_line->First;
while (pt)
{
/* inserting any POINT into the Exterior Ring */
gaiaSetPoint (ring->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
ib = 0;
rg = params->polygon.first;
while (rg)
{
/* setting up any Interior Ring */
dyn_line = params->polygon.exterior;
iv = 0;
pt = dyn_line->First;
while (pt)
{
/* counting how many POINTs are into the Interior Ring */
iv++;
pt = pt->Next;
}
ring = gaiaAddInteriorRing (pg, ib, iv);
iv = 0;
pt = dyn_line->First;
while (pt)
{
/* inserting any POINT into the Interior Ring */
gaiaSetPoint (ring->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
rg = rg->next;
ib++;
}
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaTriangularGrid (gaiaGeomCollPtr geom, double origin_x, double origin_y,
double size, int edges_only)
{
/* creating a regular grid [Triangular cells] */
double min_x;
double min_y;
double max_x;
double max_y;
double base_x;
double base_y;
double x1;
double y1;
double x2;
double y2;
double x3;
double y3;
double x4;
double y4;
int count = 0;
int odd_even = 0;
gaiaPolygonPtr pg;
gaiaRingPtr rng;
gaiaLinestringPtr ln;
gaiaGeomCollPtr result = NULL;
gaiaGeomCollPtr item = NULL;
if (size <= 0.0)
return NULL;
result = gaiaAllocGeomColl ();
result->Srid = geom->Srid;
get_grid_bbox (geom, &min_x, &min_y, &max_x, &max_y);
get_grid_base (min_x, min_y, origin_x, origin_y, size, &base_x, &base_y);
while (base_y < max_y)
{
/* looping on grid rows */
if (odd_even)
x1 = base_x - (size / 2.0);
else
x1 = base_x;
y1 = base_y;
x2 = x1 + size;
y2 = y1;
x3 = x1 + (size / 2.0);
y3 = y1 + (size * sin (3.14159265358979323846 / 3.0));
x4 = x3 + size;
y4 = y3;
while (x1 < max_x)
{
/* looping on grid columns */
item = gaiaAllocGeomColl ();
pg = gaiaAddPolygonToGeomColl (item, 4, 0);
rng = pg->Exterior;
gaiaSetPoint (rng->Coords, 0, x1, y1);
gaiaSetPoint (rng->Coords, 1, x2, y2);
gaiaSetPoint (rng->Coords, 2, x3, y3);
gaiaSetPoint (rng->Coords, 3, x1, y1);
gaiaMbrGeometry (item);
if (gaiaGeomCollIntersects (geom, item) == 1)
{
/* ok, inserting a valid cell [pointing upside] */
count++;
if (edges_only)
{
/* multilinestring */
ln = gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (ln->Coords, 0, x1, y1);
gaiaSetPoint (ln->Coords, 1, x2, y2);
ln = gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (ln->Coords, 0, x2, y2);
gaiaSetPoint (ln->Coords, 1, x3, y3);
ln = gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (ln->Coords, 0, x3, y3);
gaiaSetPoint (ln->Coords, 1, x1, y1);
}
else
{
/* polygon */
pg = gaiaAddPolygonToGeomColl (result, 4, 0);
rng = pg->Exterior;
gaiaSetPoint (rng->Coords, 0, x1, y1);
gaiaSetPoint (rng->Coords, 1, x2, y2);
gaiaSetPoint (rng->Coords, 2, x3, y3);
gaiaSetPoint (rng->Coords, 3, x1, y1);
}
}
gaiaFreeGeomColl (item);
item = gaiaAllocGeomColl ();
pg = gaiaAddPolygonToGeomColl (item, 4, 0);
rng = pg->Exterior;
gaiaSetPoint (rng->Coords, 0, x3, y3);
gaiaSetPoint (rng->Coords, 1, x2, y2);
gaiaSetPoint (rng->Coords, 2, x4, y4);
gaiaSetPoint (rng->Coords, 3, x3, y3);
gaiaMbrGeometry (item);
if (gaiaGeomCollIntersects (geom, item) == 1)
{
/* ok, inserting a valid cell [pointing downside] */
count++;
if (edges_only)
{
/* multilinestring */
ln = gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (ln->Coords, 0, x1, y1);
gaiaSetPoint (ln->Coords, 1, x2, y2);
ln = gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (ln->Coords, 0, x2, y2);
gaiaSetPoint (ln->Coords, 1, x3, y3);
ln = gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (ln->Coords, 0, x3, y3);
gaiaSetPoint (ln->Coords, 1, x1, y1);
}
else
{
/* polygon */
pg = gaiaAddPolygonToGeomColl (result, 4, 0);
rng = pg->Exterior;
gaiaSetPoint (rng->Coords, 0, x3, y3);
gaiaSetPoint (rng->Coords, 1, x2, y2);
gaiaSetPoint (rng->Coords, 2, x4, y4);
gaiaSetPoint (rng->Coords, 3, x3, y3);
}
}
gaiaFreeGeomColl (item);
x1 += size;
x2 += size;
x3 += size;
x4 += size;
}
base_y += (size * sin (3.14159265358979323846 / 3.0));
if (odd_even)
odd_even = 0;
else
odd_even = 1;
}
/* final check */
if (!count)
{
/* empty grid */
gaiaFreeGeomColl (result);
return NULL;
}
if (!edges_only)
{
result->DeclaredType = GAIA_MULTIPOLYGON;
return result;
}
item = result;
result = gaiaUnaryUnion (item);
gaiaFreeGeomColl (item);
result->Srid = geom->Srid;
result->DeclaredType = GAIA_LINESTRING;
return result;
}
static void
auxGridSnapPolygon (gaiaPolygonPtr pg, gaiaGeomCollPtr result, double origin_x,
double origin_y, double origin_z, double origin_m,
double size_x, double size_y, double size_z, double size_m)
{
/* snapping a Polygon to a regular Grid */
int ib;
int holes = 0;
int count;
int next_hole = 0;
int iv;
gaiaRingPtr rng;
gaiaPolygonPtr pgx;
gaiaPointPtr pt;
gaiaDynamicLinePtr rng_ext;
gaiaDynamicLinePtr dyn;
gaiaDynamicLinePtr *rng_ints = NULL;
if (pg == NULL || result == NULL)
return;
/* snapping the Exterior Ring */
rng = pg->Exterior;
rng_ext =
auxGridSnapRing (rng, origin_x, origin_y, origin_z, origin_m, size_x,
size_y, size_z, size_m);
if (rng_ext == NULL) /* skipping any collaped Polygon */
return;
if (pg->NumInteriors)
{
/* snapping any Interior Ring */
rng_ints = malloc (sizeof (gaiaRingPtr *) * pg->NumInteriors);
for (ib = 0; ib < pg->NumInteriors; ib++)
{
rng = pg->Interiors + ib;
*(rng_ints + ib) =
auxGridSnapRing (rng, origin_x, origin_y, origin_z,
origin_m, size_x, size_y, size_z, size_m);
if (*(rng_ints + ib) != NULL)
holes++;
}
}
/* inserting into the result Geometry */
pt = rng_ext->First;
count = 0;
while (pt)
{
/* counting how many points are in the Exterior Ring */
count++;
pt = pt->Next;
}
pgx = gaiaAddPolygonToGeomColl (result, count, holes);
rng = pgx->Exterior;
iv = 0;
pt = rng_ext->First;
while (pt)
{
/* copying Exterior Ring points */
if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (rng->Coords, iv, pt->X, pt->Y, pt->Z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (rng->Coords, iv, pt->X, pt->Y, pt->M);
}
else if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (rng->Coords, iv, pt->X, pt->Y, pt->Z, pt->M);
}
else
{
gaiaSetPoint (rng->Coords, iv, pt->X, pt->Y);
}
iv++;
pt = pt->Next;
}
if (holes > 0)
{
/* setting up any not-collapsed Hole */
for (ib = 0; ib < pg->NumInteriors; ib++)
{
if (*(rng_ints + ib) == NULL)
continue;
dyn = *(rng_ints + ib);
pt = dyn->First;
count = 0;
while (pt)
{
/* counting how many points are in the Exterior Ring */
count++;
pt = pt->Next;
}
rng = gaiaAddInteriorRing (pgx, next_hole++, count);
iv = 0;
pt = dyn->First;
while (pt)
{
/* copying Interior Ring points */
if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (rng->Coords, iv, pt->X, pt->Y,
pt->Z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (rng->Coords, iv, pt->X, pt->Y,
pt->M);
}
else if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (rng->Coords, iv, pt->X, pt->Y,
pt->Z, pt->M);
}
else
{
gaiaSetPoint (rng->Coords, iv, pt->X, pt->Y);
}
iv++;
pt = pt->Next;
}
}
}
/* memory clean-up */
gaiaFreeDynamicLine (rng_ext);
if (rng_ints)
{
for (ib = 0; ib < pg->NumInteriors; ib++)
{
dyn = *(rng_ints + ib);
if (dyn)
gaiaFreeDynamicLine (dyn);
}
free (rng_ints);
}
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaMakeEllipticArc (double cx,
double cy, double x_axis, double y_axis, double start,
double stop, double step)
{
/* return a Linestring approximating an Elliptic Arc */
gaiaDynamicLinePtr dyn;
double x;
double y;
double angle;
double rads;
int points = 0;
gaiaPointPtr pt;
gaiaGeomCollPtr geom;
gaiaLinestringPtr ln;
int iv = 0;
if (step < 0.0)
step *= -1.0;
if (step == 0.0)
step = 10.0;
if (step < 0.1)
step = 0.1;
if (step > 45.0)
step = 45.0;
if (x_axis < 0.0)
x_axis *= -1.0;
if (y_axis < 0.0)
y_axis *= -1.0;
/* normalizing Start/Stop angles */
while (start >= 360.0)
start -= 360.0;
while (start <= -720.0)
start += 360;
while (stop >= 360.0)
stop -= 360.0;
while (stop <= -720.0)
stop += 360;
if (start < 0.0)
start = 360.0 + start;
if (stop < 0.0)
stop = 360.0 + stop;
if (start > stop)
stop += 360.0;
dyn = gaiaAllocDynamicLine ();
angle = start;
while (angle < stop)
{
rads = angle * .0174532925199432958;
x = cx + (x_axis * cos (rads));
y = cy + (y_axis * sin (rads));
gaiaAppendPointToDynamicLine (dyn, x, y);
angle += step;
}
/* closing the arc */
rads = stop * .0174532925199432958;
x = cx + (x_axis * cos (rads));
y = cy + (y_axis * sin (rads));
if (x != dyn->Last->X || y != dyn->Last->Y)
gaiaAppendPointToDynamicLine (dyn, x, y);
pt = dyn->First;
while (pt)
{
/* counting how many points */
points++;
pt = pt->Next;
}
if (points == 0)
{
gaiaFreeDynamicLine (dyn);
return NULL;
}
geom = gaiaAllocGeomColl ();
ln = gaiaAddLinestringToGeomColl (geom, points);
pt = dyn->First;
while (pt)
{
/* setting Vertices */
gaiaSetPoint (ln->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
gaiaFreeDynamicLine (dyn);
return geom;
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaLinearize (gaiaGeomCollPtr geom, int force_multi)
{
/* attempts to rearrange a generic Geometry into a (multi)linestring */
int pts = 0;
int lns = 0;
gaiaGeomCollPtr result;
gaiaPointPtr pt;
gaiaLinestringPtr ln;
gaiaLinestringPtr new_ln;
gaiaPolygonPtr pg;
gaiaRingPtr rng;
int iv;
int ib;
double x;
double y;
double m;
double z;
if (!geom)
return NULL;
pt = geom->FirstPoint;
while (pt)
{
pts++;
pt = pt->Next;
}
ln = geom->FirstLinestring;
while (ln)
{
lns++;
ln = ln->Next;
}
if (pts || lns)
return NULL;
if (geom->DimensionModel == GAIA_XY_Z_M)
result = gaiaAllocGeomCollXYZM ();
else if (geom->DimensionModel == GAIA_XY_Z)
result = gaiaAllocGeomCollXYZ ();
else if (geom->DimensionModel == GAIA_XY_M)
result = gaiaAllocGeomCollXYM ();
else
result = gaiaAllocGeomColl ();
result->Srid = geom->Srid;
if (force_multi)
result->DeclaredType = GAIA_MULTILINESTRING;
pg = geom->FirstPolygon;
while (pg)
{
/* dissolving any POLYGON as simple LINESTRINGs (rings) */
rng = pg->Exterior;
new_ln = gaiaAddLinestringToGeomColl (result, rng->Points);
for (iv = 0; iv < rng->Points; iv++)
{
/* copying the EXTERIOR RING as LINESTRING */
if (geom->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
gaiaSetPointXYZM (new_ln->Coords, iv, x, y, z, m);
}
else if (geom->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
gaiaSetPointXYZ (new_ln->Coords, iv, x, y, z);
}
else if (geom->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
gaiaSetPointXYM (new_ln->Coords, iv, x, y, m);
}
else
{
gaiaGetPoint (rng->Coords, iv, &x, &y);
gaiaSetPoint (new_ln->Coords, iv, x, y);
}
}
for (ib = 0; ib < pg->NumInteriors; ib++)
{
rng = pg->Interiors + ib;
new_ln = gaiaAddLinestringToGeomColl (result, rng->Points);
for (iv = 0; iv < rng->Points; iv++)
{
/* copying an INTERIOR RING as LINESTRING */
if (geom->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
gaiaSetPointXYZM (new_ln->Coords, iv, x, y, z, m);
}
else if (geom->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
gaiaSetPointXYZ (new_ln->Coords, iv, x, y, z);
}
else if (geom->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
gaiaSetPointXYM (new_ln->Coords, iv, x, y, m);
}
else
{
gaiaGetPoint (rng->Coords, iv, &x, &y);
gaiaSetPoint (new_ln->Coords, iv, x, y);
}
}
}
pg = pg->Next;
}
if (result->FirstLinestring == NULL)
{
gaiaFreeGeomColl (result);
return NULL;
}
return result;
}
static gaiaGeomCollPtr
gaiaTransformCommon (projCtx handle, gaiaGeomCollPtr org, char *proj_from,
char *proj_to)
{
/* creates a new GEOMETRY reprojecting coordinates from the original one */
int ib;
int cnt;
int i;
double *xx;
double *yy;
double *zz;
double *mm = NULL;
double x;
double y;
double z = 0.0;
double m = 0.0;
int error = 0;
int from_angle;
int to_angle;
gaiaPointPtr pt;
gaiaLinestringPtr ln;
gaiaLinestringPtr dst_ln;
gaiaPolygonPtr pg;
gaiaPolygonPtr dst_pg;
gaiaRingPtr rng;
gaiaRingPtr dst_rng;
projPJ from_cs;
projPJ to_cs;
gaiaGeomCollPtr dst;
if (handle != NULL)
{
from_cs = pj_init_plus_ctx (handle, proj_from);
to_cs = pj_init_plus_ctx (handle, proj_to);
}
else
{
from_cs = pj_init_plus (proj_from);
to_cs = pj_init_plus (proj_to);
}
if (!from_cs)
{
if (to_cs)
pj_free (to_cs);
return NULL;
}
if (!to_cs)
{
pj_free (from_cs);
return NULL;
}
if (org->DimensionModel == GAIA_XY_Z)
dst = gaiaAllocGeomCollXYZ ();
else if (org->DimensionModel == GAIA_XY_M)
dst = gaiaAllocGeomCollXYM ();
else if (org->DimensionModel == GAIA_XY_Z_M)
dst = gaiaAllocGeomCollXYZM ();
else
dst = gaiaAllocGeomColl ();
/* setting up projection parameters */
from_angle = gaiaIsLongLat (proj_from);
to_angle = gaiaIsLongLat (proj_to);
cnt = 0;
pt = org->FirstPoint;
while (pt)
{
/* counting POINTs */
cnt++;
pt = pt->Next;
}
if (cnt)
{
/* reprojecting POINTs */
xx = malloc (sizeof (double) * cnt);
yy = malloc (sizeof (double) * cnt);
zz = malloc (sizeof (double) * cnt);
if (org->DimensionModel == GAIA_XY_M
|| org->DimensionModel == GAIA_XY_Z_M)
mm = malloc (sizeof (double) * cnt);
i = 0;
pt = org->FirstPoint;
while (pt)
{
/* inserting points to be converted in temporary arrays */
if (from_angle)
{
xx[i] = gaiaDegsToRads (pt->X);
yy[i] = gaiaDegsToRads (pt->Y);
}
else
{
xx[i] = pt->X;
yy[i] = pt->Y;
}
if (org->DimensionModel == GAIA_XY_Z
|| org->DimensionModel == GAIA_XY_Z_M)
zz[i] = pt->Z;
else
zz[i] = 0.0;
if (org->DimensionModel == GAIA_XY_M
|| org->DimensionModel == GAIA_XY_Z_M)
mm[i] = pt->M;
i++;
pt = pt->Next;
}
/* applying reprojection */
if (pj_transform (from_cs, to_cs, cnt, 0, xx, yy, zz) == 0)
{
/* inserting the reprojected POINTs in the new GEOMETRY */
for (i = 0; i < cnt; i++)
{
if (to_angle)
{
x = gaiaRadsToDegs (xx[i]);
y = gaiaRadsToDegs (yy[i]);
}
else
{
x = xx[i];
y = yy[i];
}
if (org->DimensionModel == GAIA_XY_Z
|| org->DimensionModel == GAIA_XY_Z_M)
z = zz[i];
else
z = 0.0;
if (org->DimensionModel == GAIA_XY_M
|| org->DimensionModel == GAIA_XY_Z_M)
m = mm[i];
else
m = 0.0;
if (dst->DimensionModel == GAIA_XY_Z)
gaiaAddPointToGeomCollXYZ (dst, x, y, z);
else if (dst->DimensionModel == GAIA_XY_M)
gaiaAddPointToGeomCollXYM (dst, x, y, m);
else if (dst->DimensionModel == GAIA_XY_Z_M)
gaiaAddPointToGeomCollXYZM (dst, x, y, z, m);
else
gaiaAddPointToGeomColl (dst, x, y);
}
}
else
error = 1;
free (xx);
free (yy);
free (zz);
if (org->DimensionModel == GAIA_XY_M
|| org->DimensionModel == GAIA_XY_Z_M)
free (mm);
}
if (error)
goto stop;
ln = org->FirstLinestring;
while (ln)
{
/* reprojecting LINESTRINGs */
cnt = ln->Points;
xx = malloc (sizeof (double) * cnt);
yy = malloc (sizeof (double) * cnt);
zz = malloc (sizeof (double) * cnt);
if (ln->DimensionModel == GAIA_XY_M
|| ln->DimensionModel == GAIA_XY_Z_M)
mm = malloc (sizeof (double) * cnt);
for (i = 0; i < cnt; i++)
{
/* inserting points to be converted in temporary arrays */
if (ln->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ln->Coords, i, &x, &y, &z);
}
else if (ln->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ln->Coords, i, &x, &y, &m);
}
else if (ln->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ln->Coords, i, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ln->Coords, i, &x, &y);
}
if (from_angle)
{
xx[i] = gaiaDegsToRads (x);
yy[i] = gaiaDegsToRads (y);
}
else
{
xx[i] = x;
yy[i] = y;
}
if (ln->DimensionModel == GAIA_XY_Z
|| ln->DimensionModel == GAIA_XY_Z_M)
zz[i] = z;
else
zz[i] = 0.0;
if (ln->DimensionModel == GAIA_XY_M
|| ln->DimensionModel == GAIA_XY_Z_M)
mm[i] = m;
}
/* applying reprojection */
if (pj_transform (from_cs, to_cs, cnt, 0, xx, yy, zz) == 0)
{
/* inserting the reprojected LINESTRING in the new GEOMETRY */
dst_ln = gaiaAddLinestringToGeomColl (dst, cnt);
for (i = 0; i < cnt; i++)
{
/* setting LINESTRING points */
if (to_angle)
{
x = gaiaRadsToDegs (xx[i]);
y = gaiaRadsToDegs (yy[i]);
}
else
{
x = xx[i];
y = yy[i];
}
if (ln->DimensionModel == GAIA_XY_Z
|| ln->DimensionModel == GAIA_XY_Z_M)
z = zz[i];
else
z = 0.0;
if (ln->DimensionModel == GAIA_XY_M
|| ln->DimensionModel == GAIA_XY_Z_M)
m = mm[i];
else
m = 0.0;
if (dst_ln->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (dst_ln->Coords, i, x, y, z);
}
else if (dst_ln->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (dst_ln->Coords, i, x, y, m);
}
else if (dst_ln->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (dst_ln->Coords, i, x, y, z, m);
}
else
{
gaiaSetPoint (dst_ln->Coords, i, x, y);
}
}
}
else
error = 1;
free (xx);
free (yy);
free (zz);
if (ln->DimensionModel == GAIA_XY_M
|| ln->DimensionModel == GAIA_XY_Z_M)
free (mm);
if (error)
goto stop;
ln = ln->Next;
}
pg = org->FirstPolygon;
while (pg)
{
/* reprojecting POLYGONs */
rng = pg->Exterior;
cnt = rng->Points;
dst_pg = gaiaAddPolygonToGeomColl (dst, cnt, pg->NumInteriors);
xx = malloc (sizeof (double) * cnt);
yy = malloc (sizeof (double) * cnt);
zz = malloc (sizeof (double) * cnt);
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
mm = malloc (sizeof (double) * cnt);
for (i = 0; i < cnt; i++)
{
/* inserting points to be converted in temporary arrays [EXTERIOR RING] */
if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, i, &x, &y, &z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, i, &x, &y, &m);
}
else if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, i, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (rng->Coords, i, &x, &y);
}
if (from_angle)
{
xx[i] = gaiaDegsToRads (x);
yy[i] = gaiaDegsToRads (y);
}
else
{
xx[i] = x;
yy[i] = y;
}
if (rng->DimensionModel == GAIA_XY_Z
|| rng->DimensionModel == GAIA_XY_Z_M)
zz[i] = z;
else
zz[i] = 0.0;
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
mm[i] = m;
}
/* applying reprojection */
if (pj_transform (from_cs, to_cs, cnt, 0, xx, yy, zz) == 0)
{
/* inserting the reprojected POLYGON in the new GEOMETRY */
dst_rng = dst_pg->Exterior;
for (i = 0; i < cnt; i++)
{
/* setting EXTERIOR RING points */
if (to_angle)
{
x = gaiaRadsToDegs (xx[i]);
y = gaiaRadsToDegs (yy[i]);
}
else
{
x = xx[i];
y = yy[i];
}
if (rng->DimensionModel == GAIA_XY_Z
|| rng->DimensionModel == GAIA_XY_Z_M)
z = zz[i];
else
z = 0.0;
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
m = mm[i];
else
m = 0.0;
if (dst_rng->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (dst_rng->Coords, i, x, y, z);
}
else if (dst_rng->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (dst_rng->Coords, i, x, y, m);
}
else if (dst_rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (dst_rng->Coords, i, x, y, z, m);
}
else
{
gaiaSetPoint (dst_rng->Coords, i, x, y);
}
}
}
else
error = 1;
free (xx);
free (yy);
free (zz);
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
free (mm);
if (error)
goto stop;
for (ib = 0; ib < pg->NumInteriors; ib++)
{
/* processing INTERIOR RINGS */
rng = pg->Interiors + ib;
cnt = rng->Points;
xx = malloc (sizeof (double) * cnt);
yy = malloc (sizeof (double) * cnt);
zz = malloc (sizeof (double) * cnt);
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
mm = malloc (sizeof (double) * cnt);
for (i = 0; i < cnt; i++)
{
/* inserting points to be converted in temporary arrays [INTERIOR RING] */
if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, i, &x, &y, &z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, i, &x, &y, &m);
}
else if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, i, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (rng->Coords, i, &x, &y);
}
if (from_angle)
{
xx[i] = gaiaDegsToRads (x);
yy[i] = gaiaDegsToRads (y);
}
else
{
xx[i] = x;
yy[i] = y;
}
if (rng->DimensionModel == GAIA_XY_Z
|| rng->DimensionModel == GAIA_XY_Z_M)
zz[i] = z;
else
zz[i] = 0.0;
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
mm[i] = m;
}
/* applying reprojection */
if (pj_transform (from_cs, to_cs, cnt, 0, xx, yy, zz) == 0)
{
/* inserting the reprojected POLYGON in the new GEOMETRY */
dst_rng = gaiaAddInteriorRing (dst_pg, ib, cnt);
for (i = 0; i < cnt; i++)
{
/* setting INTERIOR RING points */
if (to_angle)
{
x = gaiaRadsToDegs (xx[i]);
y = gaiaRadsToDegs (yy[i]);
}
else
{
x = xx[i];
y = yy[i];
}
if (rng->DimensionModel == GAIA_XY_Z
|| rng->DimensionModel == GAIA_XY_Z_M)
z = zz[i];
else
z = 0.0;
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
m = mm[i];
else
m = 0.0;
if (dst_rng->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (dst_rng->Coords, i, x, y, z);
}
else if (dst_rng->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (dst_rng->Coords, i, x, y, m);
}
else if (dst_rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (dst_rng->Coords, i, x, y, z,
m);
}
else
{
gaiaSetPoint (dst_rng->Coords, i, x, y);
}
}
}
else
error = 1;
free (xx);
free (yy);
free (zz);
if (rng->DimensionModel == GAIA_XY_M
|| rng->DimensionModel == GAIA_XY_Z_M)
free (mm);
if (error)
goto stop;
}
pg = pg->Next;
}
/* destroying the PROJ4 params */
stop:
pj_free (from_cs);
pj_free (to_cs);
if (error)
{
/* some error occurred */
gaiaPointPtr pP;
gaiaPointPtr pPn;
gaiaLinestringPtr pL;
gaiaLinestringPtr pLn;
gaiaPolygonPtr pA;
gaiaPolygonPtr pAn;
pP = dst->FirstPoint;
while (pP != NULL)
{
pPn = pP->Next;
gaiaFreePoint (pP);
pP = pPn;
}
pL = dst->FirstLinestring;
while (pL != NULL)
{
pLn = pL->Next;
gaiaFreeLinestring (pL);
pL = pLn;
}
pA = dst->FirstPolygon;
while (pA != NULL)
{
pAn = pA->Next;
gaiaFreePolygon (pA);
pA = pAn;
}
dst->FirstPoint = NULL;
dst->LastPoint = NULL;
dst->FirstLinestring = NULL;
dst->LastLinestring = NULL;
dst->FirstPolygon = NULL;
dst->LastPolygon = NULL;
}
if (dst)
{
gaiaMbrGeometry (dst);
dst->DeclaredType = org->DeclaredType;
}
return dst;
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaDissolveSegments (gaiaGeomCollPtr geom)
{
/* attempts to dissolve a Geometry into segments */
gaiaGeomCollPtr result;
gaiaPointPtr pt;
gaiaLinestringPtr ln;
gaiaLinestringPtr segment;
gaiaPolygonPtr pg;
gaiaRingPtr rng;
int iv;
int ib;
double x;
double y;
double z;
double m;
double x0;
double y0;
double z0;
double m0;
if (!geom)
return NULL;
if (geom->DimensionModel == GAIA_XY_Z_M)
result = gaiaAllocGeomCollXYZM ();
else if (geom->DimensionModel == GAIA_XY_Z)
result = gaiaAllocGeomCollXYZ ();
else if (geom->DimensionModel == GAIA_XY_M)
result = gaiaAllocGeomCollXYM ();
else
result = gaiaAllocGeomColl ();
pt = geom->FirstPoint;
while (pt)
{
if (geom->DimensionModel == GAIA_XY_Z_M)
gaiaAddPointToGeomCollXYZM (result, pt->X, pt->Y, pt->Z, pt->M);
else if (geom->DimensionModel == GAIA_XY_Z)
gaiaAddPointToGeomCollXYZ (result, pt->X, pt->Y, pt->Z);
else if (geom->DimensionModel == GAIA_XY_M)
gaiaAddPointToGeomCollXYM (result, pt->X, pt->Y, pt->M);
else
gaiaAddPointToGeomColl (result, pt->X, pt->Y);
pt = pt->Next;
}
ln = geom->FirstLinestring;
while (ln)
{
for (iv = 0; iv < ln->Points; iv++)
{
if (ln->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ln->Coords, iv, &x, &y, &z, &m);
}
else if (ln->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ln->Coords, iv, &x, &y, &z);
}
else if (ln->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ln->Coords, iv, &x, &y, &m);
}
else
{
gaiaGetPoint (ln->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (geom->DimensionModel == GAIA_XY_Z_M)
{
if (x != x0 || y != y0 || z != z0 || m != m0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPointXYZM (segment->Coords, 0, x0, y0,
z0, m0);
gaiaSetPointXYZM (segment->Coords, 1, x, y, z,
m);
}
}
else if (geom->DimensionModel == GAIA_XY_Z)
{
if (x != x0 || y != y0 || z != z0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPointXYZ (segment->Coords, 0, x0, y0,
z0);
gaiaSetPointXYZ (segment->Coords, 1, x, y, z);
}
}
else if (geom->DimensionModel == GAIA_XY_M)
{
if (x != x0 || y != y0 || m != m0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPointXYM (segment->Coords, 0, x0, y0,
m0);
gaiaSetPointXYM (segment->Coords, 1, x, y, m);
}
}
else
{
if (x != x0 || y != y0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (segment->Coords, 0, x0, y0);
gaiaSetPoint (segment->Coords, 1, x, y);
}
}
}
x0 = x;
y0 = y;
z0 = z;
m0 = m;
}
ln = ln->Next;
}
pg = geom->FirstPolygon;
while (pg)
{
rng = pg->Exterior;
for (iv = 0; iv < rng->Points; iv++)
{
/* exterior Ring */
if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
}
else if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
}
else
{
gaiaGetPoint (rng->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (geom->DimensionModel == GAIA_XY_Z_M)
{
if (x != x0 || y != y0 || z != z0 || m != m0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPointXYZM (segment->Coords, 0, x0, y0,
z0, m0);
gaiaSetPointXYZM (segment->Coords, 1, x, y, z,
m);
}
}
else if (geom->DimensionModel == GAIA_XY_Z)
{
if (x != x0 || y != y0 || z != z0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPointXYZ (segment->Coords, 0, x0, y0,
z0);
gaiaSetPointXYZ (segment->Coords, 1, x, y, z);
}
}
else if (geom->DimensionModel == GAIA_XY_M)
{
if (x != x0 || y != y0 || m != m0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPointXYM (segment->Coords, 0, x0, y0,
m0);
gaiaSetPointXYM (segment->Coords, 1, x, y, m);
}
}
else
{
if (x != x0 || y != y0)
{
segment =
gaiaAddLinestringToGeomColl (result, 2);
gaiaSetPoint (segment->Coords, 0, x0, y0);
gaiaSetPoint (segment->Coords, 1, x, y);
}
}
}
x0 = x;
y0 = y;
z0 = z;
m0 = m;
}
for (ib = 0; ib < pg->NumInteriors; ib++)
{
rng = pg->Interiors + ib;
for (iv = 0; iv < rng->Points; iv++)
{
/* interior Ring */
if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
}
else if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
}
else
{
gaiaGetPoint (rng->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (geom->DimensionModel == GAIA_XY_Z_M)
{
if (x != x0 || y != y0 || z != z0 || m != m0)
{
segment =
gaiaAddLinestringToGeomColl (result,
2);
gaiaSetPointXYZM (segment->Coords, 0,
x0, y0, z0, m0);
gaiaSetPointXYZM (segment->Coords, 1, x,
y, z, m);
}
}
else if (geom->DimensionModel == GAIA_XY_Z)
{
if (x != x0 || y != y0 || z != z0)
{
segment =
gaiaAddLinestringToGeomColl (result,
2);
gaiaSetPointXYZ (segment->Coords, 0, x0,
y0, z0);
gaiaSetPointXYZ (segment->Coords, 1, x,
y, z);
}
}
else if (geom->DimensionModel == GAIA_XY_M)
{
if (x != x0 || y != y0 || m != m0)
{
segment =
gaiaAddLinestringToGeomColl (result,
2);
gaiaSetPointXYM (segment->Coords, 0, x0,
y0, m0);
gaiaSetPointXYM (segment->Coords, 1, x,
y, m);
}
}
else
{
if (x != x0 || y != y0)
{
segment =
gaiaAddLinestringToGeomColl (result,
2);
gaiaSetPoint (segment->Coords, 0, x0,
y0);
gaiaSetPoint (segment->Coords, 1, x, y);
}
}
}
x0 = x;
y0 = y;
z0 = z;
m0 = m;
}
}
pg = pg->Next;
}
result->Srid = geom->Srid;
return result;
}
GAIAGEO_DECLARE void
gaiaNormalizeLonLat (gaiaGeomCollPtr geom)
{
/* returns a geometry that is the old geometry with all latitudes shifted
into the range -90 to 90, and all longitudes shifted into the range -180 to
180.
*/
int ib;
int iv;
double x;
double y;
double z;
double m;
gaiaPointPtr point;
gaiaPolygonPtr polyg;
gaiaLinestringPtr line;
gaiaRingPtr ring;
if (!geom)
return;
point = geom->FirstPoint;
while (point)
{
normalizePoint (&(point->X), &(point->Y));
point = point->Next;
}
line = geom->FirstLinestring;
while (line)
{
/* shifting LINESTRINGs */
for (iv = 0; iv < line->Points; iv++)
{
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
normalizePoint (&x, &y);
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (line->Coords, iv, x, y, z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (line->Coords, iv, x, y, m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (line->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (line->Coords, iv, x, y);
}
}
line = line->Next;
}
polyg = geom->FirstPolygon;
while (polyg)
{
/* shifting POLYGONs */
ring = polyg->Exterior;
for (iv = 0; iv < ring->Points; iv++)
{
/* shifting the EXTERIOR RING */
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
normalizePoint (&x, &y);
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
for (ib = 0; ib < polyg->NumInteriors; ib++)
{
/* shifting the INTERIOR RINGs */
ring = polyg->Interiors + ib;
for (iv = 0; iv < ring->Points; iv++)
{
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
normalizePoint (&x, &y);
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
}
polyg = polyg->Next;
}
gaiaMbrGeometry (geom);
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaExtractLinestringsFromGeomColl (gaiaGeomCollPtr geom)
{
/* extracts any LINESTRING from a GeometryCollection */
gaiaGeomCollPtr result;
gaiaLinestringPtr ln;
gaiaLinestringPtr new_ln;
int lns = 0;
int iv;
double x;
double y;
double z;
double m;
if (!geom)
return NULL;
ln = geom->FirstLinestring;
while (ln)
{
lns++;
ln = ln->Next;
}
if (!lns)
return NULL;
if (geom->DimensionModel == GAIA_XY_Z_M)
result = gaiaAllocGeomCollXYZM ();
else if (geom->DimensionModel == GAIA_XY_Z)
result = gaiaAllocGeomCollXYZ ();
else if (geom->DimensionModel == GAIA_XY_M)
result = gaiaAllocGeomCollXYM ();
else
result = gaiaAllocGeomColl ();
ln = geom->FirstLinestring;
while (ln)
{
new_ln = gaiaAddLinestringToGeomColl (result, ln->Points);
for (iv = 0; iv < ln->Points; iv++)
{
if (ln->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ln->Coords, iv, &x, &y, &z, &m);
gaiaSetPointXYZM (new_ln->Coords, iv, x, y, z, m);
}
else if (ln->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ln->Coords, iv, &x, &y, &z);
gaiaSetPointXYZ (new_ln->Coords, iv, x, y, z);
}
else if (ln->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ln->Coords, iv, &x, &y, &m);
gaiaSetPointXYM (new_ln->Coords, iv, x, y, m);
}
else
{
gaiaGetPoint (ln->Coords, iv, &x, &y);
gaiaSetPoint (new_ln->Coords, iv, x, y);
}
}
ln = ln->Next;
}
result->Srid = geom->Srid;
result->DeclaredType = GAIA_MULTILINESTRING;
return result;
}
GAIAGEO_DECLARE void
gaiaScaleCoords (gaiaGeomCollPtr geom, double scale_x, double scale_y)
{
/* returns a geometry that is the old geometry with required scaling applied to coordinates */
int ib;
int iv;
double x;
double y;
double z;
double m;
gaiaPointPtr point;
gaiaPolygonPtr polyg;
gaiaLinestringPtr line;
gaiaRingPtr ring;
if (!geom)
return;
point = geom->FirstPoint;
while (point)
{
/* scaling POINTs */
point->X *= scale_x;
point->Y *= scale_y;
point = point->Next;
}
line = geom->FirstLinestring;
while (line)
{
/* scaling LINESTRINGs */
for (iv = 0; iv < line->Points; iv++)
{
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
x *= scale_x;
y *= scale_y;
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (line->Coords, iv, x, y, z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (line->Coords, iv, x, y, m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (line->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (line->Coords, iv, x, y);
}
}
line = line->Next;
}
polyg = geom->FirstPolygon;
while (polyg)
{
/* scaling POLYGONs */
ring = polyg->Exterior;
for (iv = 0; iv < ring->Points; iv++)
{
/* scaling the EXTERIOR RING */
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
x *= scale_x;
y *= scale_y;
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
for (ib = 0; ib < polyg->NumInteriors; ib++)
{
/* scaling the INTERIOR RINGs */
ring = polyg->Interiors + ib;
for (iv = 0; iv < ring->Points; iv++)
{
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (ring->Coords, iv, &x, &y, &z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (ring->Coords, iv, &x, &y, &m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (ring->Coords, iv, &x, &y);
}
x *= scale_x;
y *= scale_y;
if (ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (ring->Coords, iv, x, y, z);
}
else if (ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (ring->Coords, iv, x, y, m);
}
else if (ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ring->Coords, iv, x, y, z, m);
}
else
{
gaiaSetPoint (ring->Coords, iv, x, y);
}
}
}
polyg = polyg->Next;
}
gaiaMbrGeometry (geom);
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaExtractPolygonsFromGeomColl (gaiaGeomCollPtr geom)
{
/* extracts any POLYGON from a GeometryCollection */
gaiaGeomCollPtr result;
gaiaPolygonPtr pg;
gaiaPolygonPtr new_pg;
gaiaRingPtr rng;
gaiaRingPtr new_rng;
int pgs = 0;
int iv;
int ib;
double x;
double y;
double z;
double m;
if (!geom)
return NULL;
pg = geom->FirstPolygon;
while (pg)
{
pgs++;
pg = pg->Next;
}
if (!pgs)
return NULL;
if (geom->DimensionModel == GAIA_XY_Z_M)
result = gaiaAllocGeomCollXYZM ();
else if (geom->DimensionModel == GAIA_XY_Z)
result = gaiaAllocGeomCollXYZ ();
else if (geom->DimensionModel == GAIA_XY_M)
result = gaiaAllocGeomCollXYM ();
else
result = gaiaAllocGeomColl ();
pg = geom->FirstPolygon;
while (pg)
{
rng = pg->Exterior;
new_pg =
gaiaAddPolygonToGeomColl (result, rng->Points, pg->NumInteriors);
new_rng = new_pg->Exterior;
for (iv = 0; iv < rng->Points; iv++)
{
if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
gaiaSetPointXYZM (new_rng->Coords, iv, x, y, z, m);
}
else if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
gaiaSetPointXYZ (new_rng->Coords, iv, x, y, z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
gaiaSetPointXYM (new_rng->Coords, iv, x, y, m);
}
else
{
gaiaGetPoint (rng->Coords, iv, &x, &y);
gaiaSetPoint (new_rng->Coords, iv, x, y);
}
}
for (ib = 0; ib < pg->NumInteriors; ib++)
{
rng = pg->Interiors + ib;
new_rng = gaiaAddInteriorRing (new_pg, ib, rng->Points);
for (iv = 0; iv < rng->Points; iv++)
{
if (rng->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (rng->Coords, iv, &x, &y, &z, &m);
gaiaSetPointXYZM (new_rng->Coords, iv, x, y, z, m);
}
else if (rng->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (rng->Coords, iv, &x, &y, &z);
gaiaSetPointXYZ (new_rng->Coords, iv, x, y, z);
}
else if (rng->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (rng->Coords, iv, &x, &y, &m);
gaiaSetPointXYM (new_rng->Coords, iv, x, y, m);
}
else
{
gaiaGetPoint (rng->Coords, iv, &x, &y);
gaiaSetPoint (new_rng->Coords, iv, x, y);
}
}
}
pg = pg->Next;
}
result->Srid = geom->Srid;
result->DeclaredType = GAIA_MULTIPOLYGON;
return result;
}
int main (int argc, char *argv[])
{
int result;
int returnValue = 0;
gaiaRingPtr interior;
/* Common setup */
gaiaLinestringPtr linestr1 = gaiaAllocLinestring(0);
gaiaLinestringPtr linestr2 = gaiaAllocLinestring(0);
gaiaPolygonPtr poly1 = gaiaAllocPolygon(0, 0);
gaiaPolygonPtr poly2 = gaiaAllocPolygon(0, 0);
/* Tests start here */
/* zero length linestring */
result = gaiaLinestringEquals(linestr1, linestr2);
if (result != 1) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -1;
goto exit;
}
/* non-matching linestring lengths */
gaiaFreeLinestring (linestr1);
gaiaFreeLinestring (linestr2);
linestr1 = gaiaAllocLinestring(2);
linestr2 = gaiaAllocLinestring(3);
gaiaSetPoint(linestr1->Coords, 0, 1, 3); /* line1, first point */
gaiaSetPoint(linestr1->Coords, 1, 2, 4); /* line1, second point */
gaiaSetPoint(linestr2->Coords, 0, 4, -2); /* line2, first point */
gaiaSetPoint(linestr2->Coords, 1, 1, 5); /* line2, second point */
gaiaSetPoint(linestr2->Coords, 2, 3, 4); /* line2, third point */
result = gaiaLinestringEquals(linestr1, linestr2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -2;
goto exit;
}
/* identical lines */
gaiaFreeLinestring (linestr2);
linestr2 = gaiaCloneLinestring(linestr1);
result = gaiaLinestringEquals(linestr1, linestr2);
if (result != 1) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -3;
goto exit;
}
/* not quite identical lines */
gaiaSetPoint(linestr2->Coords, 1, 2, -4);
result = gaiaLinestringEquals(linestr1, linestr2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -4;
goto exit;
}
/* zero length polygon */
result = gaiaPolygonEquals(poly1, poly2);
if (result != 1) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -5;
goto exit;
}
/* matching polygons */
gaiaFreePolygon (poly1);
gaiaFreePolygon (poly2);
poly1 = gaiaAllocPolygon(5, 0);
gaiaSetPoint(poly1->Exterior->Coords, 0, 0, 0);
gaiaSetPoint(poly1->Exterior->Coords, 1, 10, 0);
gaiaSetPoint(poly1->Exterior->Coords, 2, 10, 10);
gaiaSetPoint(poly1->Exterior->Coords, 3, 0, 10);
gaiaSetPoint(poly1->Exterior->Coords, 4, 0, 0);
poly2 = gaiaClonePolygon(poly1);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 1) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -6;
goto exit;
}
/* not quite matching polygons */
gaiaSetPoint(poly2->Exterior->Coords, 2, 10, -10);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -7;
goto exit;
}
/* polygons with different numbers of interiors */
gaiaFreePolygon (poly2);
poly2 = gaiaAllocPolygon(5, 1);
gaiaSetPoint(poly2->Exterior->Coords, 0, 0, 0);
gaiaSetPoint(poly2->Exterior->Coords, 1, 10, 0);
gaiaSetPoint(poly2->Exterior->Coords, 2, 10, 10);
gaiaSetPoint(poly2->Exterior->Coords, 3, 0, 10);
gaiaSetPoint(poly2->Exterior->Coords, 4, 0, 0);
interior = gaiaAddInteriorRing(poly2, 0, 4);
gaiaSetPoint(interior->Coords, 0, 1, 1);
gaiaSetPoint(interior->Coords, 1, 3, 2);
gaiaSetPoint(interior->Coords, 2, 3, 1);
gaiaSetPoint(interior->Coords, 3, 1, 1);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -8;
goto exit;
}
/* same exteriors and interiors */
gaiaFreePolygon (poly1);
poly1 = gaiaClonePolygon(poly2);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 1) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -9;
goto exit;
}
/* slightly different interiors */
gaiaSetPoint(interior->Coords, 2, 3, 3);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -10;
goto exit;
}
/* different number of exterior points */
gaiaFreePolygon(poly2);
poly2 = gaiaAllocPolygon(4, 1);
gaiaSetPoint(poly2->Exterior->Coords, 0, 0, 0);
gaiaSetPoint(poly2->Exterior->Coords, 1, 10, 0);
gaiaSetPoint(poly2->Exterior->Coords, 2, 10, 10);
gaiaSetPoint(poly2->Exterior->Coords, 3, 0, 0);
interior = gaiaAddInteriorRing(poly2, 0, 4);
gaiaSetPoint(interior->Coords, 0, 1, 1);
gaiaSetPoint(interior->Coords, 1, 3, 2);
gaiaSetPoint(interior->Coords, 2, 3, 1);
gaiaSetPoint(interior->Coords, 3, 1, 1);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -11;
goto exit;
}
/* same exterior points, but different number of points on first interior */
gaiaFreePolygon (poly2);
poly2 = gaiaAllocPolygon(5, 1);
gaiaSetPoint(poly2->Exterior->Coords, 0, 0, 0);
gaiaSetPoint(poly2->Exterior->Coords, 1, 10, 0);
gaiaSetPoint(poly2->Exterior->Coords, 2, 10, 10);
gaiaSetPoint(poly2->Exterior->Coords, 3, 0, 10);
gaiaSetPoint(poly2->Exterior->Coords, 4, 0, 0);
interior = gaiaAddInteriorRing(poly2, 0, 5);
gaiaSetPoint(interior->Coords, 0, 1, 1);
gaiaSetPoint(interior->Coords, 1, 3, 2);
gaiaSetPoint(interior->Coords, 2, 3, 3);
gaiaSetPoint(interior->Coords, 3, 1, 3);
gaiaSetPoint(interior->Coords, 4, 1, 1);
result = gaiaPolygonEquals(poly1, poly2);
if (result != 0) {
fprintf(stderr, "bad result at %s:%i: %i\n", __FILE__, __LINE__, result);
returnValue = -12;
goto exit;
}
/* Cleanup and exit */
exit:
gaiaFreeLinestring (linestr1);
gaiaFreeLinestring (linestr2);
gaiaFreePolygon (poly1);
gaiaFreePolygon (poly2);
return returnValue;
}
GAIAGEO_DECLARE gaiaGeomCollPtr
gaiaSanitize (gaiaGeomCollPtr geom)
{
/*
/ sanitizes a GEOMETRYCOLLECTION:
/ - repeated vertices are omitted
/ - ring closure is enforced anyway
*/
int iv;
int ib;
double x = 0.0;
double y = 0.0;
double z = 0.0;
double m = 0.0;
double last_x = 0.0;
double last_y = 0.0;
double last_z = 0.0;
int points;
gaiaPointPtr point;
gaiaLinestringPtr line;
gaiaLinestringPtr new_line;
gaiaPolygonPtr polyg;
gaiaPolygonPtr new_polyg;
gaiaGeomCollPtr new_geom;
gaiaRingPtr i_ring;
gaiaRingPtr o_ring;
if (!geom)
return NULL;
if (geom->DimensionModel == GAIA_XY_Z)
new_geom = gaiaAllocGeomCollXYZ ();
else if (geom->DimensionModel == GAIA_XY_M)
new_geom = gaiaAllocGeomCollXYM ();
else if (geom->DimensionModel == GAIA_XY_Z_M)
new_geom = gaiaAllocGeomCollXYZM ();
else
new_geom = gaiaAllocGeomColl ();
new_geom->Srid = geom->Srid;
new_geom->DeclaredType = geom->DeclaredType;
point = geom->FirstPoint;
while (point)
{
/* copying POINTs */
gaiaAddPointToGeomCollXYZM (new_geom, point->X, point->Y, point->Z,
point->M);
point = point->Next;
}
line = geom->FirstLinestring;
while (line)
{
/* sanitizing LINESTRINGs */
points = 0;
for (iv = 0; iv < line->Points; iv++)
{
/* PASS I - checking points */
z = 0.0;
m = 0.0;
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (last_x == x && last_y == y && last_z == z)
;
else
points++;
}
else
points++;
last_x = x;
last_y = y;
last_z = z;
}
if (points < 2)
{
/* illegal LINESTRING - copying the original one */
new_line = gaiaAddLinestringToGeomColl (new_geom, line->Points);
gaiaCopyLinestringCoords (new_line, line);
}
else
{
/* valid LINESTRING - sanitizing */
new_line = gaiaAddLinestringToGeomColl (new_geom, points);
points = 0;
for (iv = 0; iv < line->Points; iv++)
{
/* PASS II - inserting points */
z = 0.0;
m = 0.0;
if (line->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (line->Coords, iv, &x, &y, &z);
}
else if (line->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (line->Coords, iv, &x, &y, &m);
}
else if (line->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (line->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (line->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (last_x == x && last_y == y && last_z == z)
;
else
{
if (new_line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (new_line->Coords,
points, x, y, z);
}
else if (new_line->DimensionModel ==
GAIA_XY_M)
{
gaiaSetPointXYM (new_line->Coords,
points, x, y, m);
}
else if (new_line->DimensionModel ==
GAIA_XY_Z_M)
{
gaiaSetPointXYZM (new_line->Coords,
points, x, y, z, m);
}
else
{
gaiaSetPoint (new_line->Coords, points,
x, y);
}
points++;
}
}
else
{
if (new_line->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (new_line->Coords, points, x,
y, z);
}
else if (new_line->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (new_line->Coords, points, x,
y, m);
}
else if (new_line->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (new_line->Coords, points, x,
y, z, m);
}
else
{
gaiaSetPoint (new_line->Coords, points, x, y);
}
points++;
}
last_x = x;
last_y = y;
last_z = z;
}
}
line = line->Next;
}
polyg = geom->FirstPolygon;
while (polyg)
{
/* copying POLYGONs */
i_ring = polyg->Exterior;
/* sanitizing EXTERIOR RING */
points = 0;
for (iv = 0; iv < i_ring->Points; iv++)
{
/* PASS I - checking points */
z = 0.0;
m = 0.0;
if (i_ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (i_ring->Coords, iv, &x, &y, &z);
}
else if (i_ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (i_ring->Coords, iv, &x, &y, &m);
}
else if (i_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (i_ring->Coords, iv, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (i_ring->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (last_x == x && last_y == y && last_z == z)
;
else
points++;
}
else
points++;
last_x = x;
last_y = y;
last_z = z;
}
if (last_x == x && last_y == y && last_z == z)
;
else
{
/* forcing RING closure */
points++;
}
if (points < 4)
{
/* illegal RING - copying the original one */
new_polyg =
gaiaAddPolygonToGeomColl (new_geom, i_ring->Points,
polyg->NumInteriors);
o_ring = new_polyg->Exterior;
gaiaCopyRingCoords (o_ring, i_ring);
}
else
{
/* valid RING - sanitizing */
new_polyg =
gaiaAddPolygonToGeomColl (new_geom, points,
polyg->NumInteriors);
o_ring = new_polyg->Exterior;
points = 0;
for (iv = 0; iv < i_ring->Points; iv++)
{
/* PASS II - inserting points */
z = 0.0;
m = 0.0;
if (i_ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (i_ring->Coords, iv, &x, &y, &z);
}
else if (i_ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (i_ring->Coords, iv, &x, &y, &m);
}
else if (i_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (i_ring->Coords, iv, &x, &y, &z,
&m);
}
else
{
gaiaGetPoint (i_ring->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (last_x == x && last_y == y && last_z == z)
;
else
{
if (o_ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (o_ring->Coords, points,
x, y, z);
}
else if (o_ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (o_ring->Coords, points,
x, y, m);
}
else if (o_ring->DimensionModel ==
GAIA_XY_Z_M)
{
gaiaSetPointXYZM (o_ring->Coords,
points, x, y, z, m);
}
else
{
gaiaSetPoint (o_ring->Coords, points, x,
y);
}
points++;
}
}
else
{
if (o_ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (o_ring->Coords, points, x,
y, z);
}
else if (o_ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (o_ring->Coords, points, x,
y, m);
}
else if (o_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (o_ring->Coords, points, x,
y, z, m);
}
else
{
gaiaSetPoint (o_ring->Coords, points, x, y);
}
points++;
}
last_x = x;
last_y = y;
last_z = z;
}
}
/* PASS III - forcing RING closure */
z = 0.0;
m = 0.0;
if (i_ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (i_ring->Coords, 0, &x, &y, &z);
}
else if (i_ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (i_ring->Coords, 0, &x, &y, &m);
}
else if (i_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (i_ring->Coords, 0, &x, &y, &z, &m);
}
else
{
gaiaGetPoint (i_ring->Coords, 0, &x, &y);
}
points = o_ring->Points - 1;
if (o_ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (o_ring->Coords, points, x, y, z);
}
else if (o_ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (o_ring->Coords, points, x, y, m);
}
else if (o_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (o_ring->Coords, points, x, y, z, m);
}
else
{
gaiaSetPoint (o_ring->Coords, points, x, y);
}
for (ib = 0; ib < new_polyg->NumInteriors; ib++)
{
/* copying each INTERIOR RING [if any] */
i_ring = polyg->Interiors + ib;
/* sanitizing an INTERIOR RING */
points = 0;
for (iv = 0; iv < i_ring->Points; iv++)
{
/* PASS I - checking points */
z = 0.0;
m = 0.0;
if (i_ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (i_ring->Coords, iv, &x, &y, &z);
}
else if (i_ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (i_ring->Coords, iv, &x, &y, &m);
}
else if (i_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (i_ring->Coords, iv, &x, &y, &z,
&m);
}
else
{
gaiaGetPoint (i_ring->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (last_x == x && last_y == y && last_z == z)
;
else
points++;
}
else
points++;
last_x = x;
last_y = y;
last_z = z;
}
if (last_x == x && last_y == y && last_z == z)
;
else
{
/* forcing RING closure */
points++;
}
if (points < 4)
{
/* illegal RING - copying the original one */
o_ring =
gaiaAddInteriorRing (new_polyg, ib, i_ring->Points);
gaiaCopyRingCoords (o_ring, i_ring);
}
else
{
/* valid RING - sanitizing */
o_ring = gaiaAddInteriorRing (new_polyg, ib, points);
points = 0;
for (iv = 0; iv < i_ring->Points; iv++)
{
/* PASS II - inserting points */
z = 0.0;
m = 0.0;
if (i_ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (i_ring->Coords, iv, &x, &y,
&z);
}
else if (i_ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (i_ring->Coords, iv, &x, &y,
&m);
}
else if (i_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (i_ring->Coords, iv, &x, &y,
&z, &m);
}
else
{
gaiaGetPoint (i_ring->Coords, iv, &x, &y);
}
if (iv > 0)
{
if (last_x == x && last_y == y && last_z == z)
;
else
{
if (o_ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (o_ring->Coords,
points, x, y, z);
}
else if (o_ring->DimensionModel ==
GAIA_XY_M)
{
gaiaSetPointXYM (o_ring->Coords,
points, x, y, m);
}
else if (o_ring->DimensionModel ==
GAIA_XY_Z_M)
{
gaiaSetPointXYZM (o_ring->Coords,
points, x, y, z,
m);
}
else
{
gaiaSetPoint (o_ring->Coords,
points, x, y);
}
points++;
}
}
else
{
if (o_ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (o_ring->Coords, points,
x, y, z);
}
else if (o_ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (o_ring->Coords, points,
x, y, m);
}
else if (o_ring->DimensionModel ==
GAIA_XY_Z_M)
{
gaiaSetPointXYZM (o_ring->Coords,
points, x, y, z, m);
}
else
{
gaiaSetPoint (o_ring->Coords, points, x,
y);
}
points++;
}
last_x = x;
last_y = y;
last_z = z;
}
/* PASS III - forcing RING closure */
z = 0.0;
m = 0.0;
if (i_ring->DimensionModel == GAIA_XY_Z)
{
gaiaGetPointXYZ (i_ring->Coords, 0, &x, &y, &z);
}
else if (i_ring->DimensionModel == GAIA_XY_M)
{
gaiaGetPointXYM (i_ring->Coords, 0, &x, &y, &m);
}
else if (i_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaGetPointXYZM (i_ring->Coords, 0, &x, &y, &z,
&m);
}
else
{
gaiaGetPoint (i_ring->Coords, 0, &x, &y);
}
points = o_ring->Points - 1;
if (o_ring->DimensionModel == GAIA_XY_Z)
{
gaiaSetPointXYZ (o_ring->Coords, points, x, y, z);
}
else if (o_ring->DimensionModel == GAIA_XY_M)
{
gaiaSetPointXYM (o_ring->Coords, points, x, y, m);
}
else if (o_ring->DimensionModel == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (o_ring->Coords, points, x, y, z,
m);
}
else
{
gaiaSetPoint (o_ring->Coords, points, x, y);
}
}
}
polyg = polyg->Next;
}
return new_geom;
}
static int
kml_parse_polygon (struct kml_data *p_data, gaiaGeomCollPtr geom,
kmlNodePtr node, kmlNodePtr * next_n)
{
/* parsing a <Polygon> */
int interior;
int has_z;
int inners;
int outers;
int points;
int iv;
int ib = 0;
gaiaGeomCollPtr pg;
gaiaGeomCollPtr last_g;
gaiaPolygonPtr new_pg;
gaiaRingPtr ring;
gaiaDynamicLinePtr dyn;
gaiaPointPtr pt;
gaiaDynamicLinePtr exterior_ring;
kmlNodePtr next;
kmlDynamicRingPtr dyn_rng;
kmlDynamicPolygonPtr dyn_pg = kml_alloc_dyn_polygon (p_data);
kmlNodePtr n = node;
while (n)
{
/* looping on rings */
if (strcmp (n->Tag, "Polygon") == 0)
{
*next_n = n->Next;
break;
}
dyn = kml_parse_ring (n, &interior, &has_z, &next);
if (dyn == NULL)
goto error;
if (kml_count_dyn_points (dyn) < 4)
{
/* cannot be a valid ring */
goto error;
}
/* checking if the ring is closed */
if (has_z)
{
if (dyn->First->X == dyn->Last->X
&& dyn->First->Y == dyn->Last->Y
&& dyn->First->Z == dyn->Last->Z)
;
else
goto error;
}
else
{
if (dyn->First->X == dyn->Last->X
&& dyn->First->Y == dyn->Last->Y)
;
else
goto error;
}
kml_add_polygon_ring (dyn_pg, dyn, interior, has_z);
n = next;
}
/* ok, KML nodes match as expected */
inners = 0;
outers = 0;
has_z = 1;
dyn_rng = dyn_pg->first;
while (dyn_rng)
{
/* verifying the rings collection */
if (dyn_rng->has_z == 0)
has_z = 0;
if (dyn_rng->interior)
inners++;
else
{
outers++;
points = kml_count_dyn_points (dyn_rng->ring);
exterior_ring = dyn_rng->ring;
}
dyn_rng = dyn_rng->next;
}
if (outers != 1) /* no exterior ring declared */
goto error;
if (has_z)
{
pg = gaiaAllocGeomCollXYZ ();
kmlMapDynAlloc (p_data, KML_DYN_GEOM, pg);
new_pg = gaiaAddPolygonToGeomColl (pg, points, inners);
/* initializing the EXTERIOR RING */
ring = new_pg->Exterior;
pt = exterior_ring->First;
iv = 0;
while (pt)
{
gaiaSetPointXYZ (ring->Coords, iv, pt->X, pt->Y, pt->Z);
iv++;
pt = pt->Next;
}
dyn_rng = dyn_pg->first;
while (dyn_rng)
{
/* initializing any INTERIOR RING */
if (dyn_rng->interior == 0)
{
dyn_rng = dyn_rng->next;
continue;
}
points = kml_count_dyn_points (dyn_rng->ring);
ring = gaiaAddInteriorRing (new_pg, ib, points);
ib++;
pt = dyn_rng->ring->First;
iv = 0;
while (pt)
{
gaiaSetPointXYZ (ring->Coords, iv, pt->X, pt->Y, pt->Z);
iv++;
pt = pt->Next;
}
dyn_rng = dyn_rng->next;
}
}
else
{
pg = gaiaAllocGeomColl ();
kmlMapDynAlloc (p_data, KML_DYN_GEOM, pg);
new_pg = gaiaAddPolygonToGeomColl (pg, points, inners);
/* initializing the EXTERIOR RING */
ring = new_pg->Exterior;
pt = exterior_ring->First;
iv = 0;
while (pt)
{
gaiaSetPoint (ring->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
dyn_rng = dyn_pg->first;
while (dyn_rng)
{
/* initializing any INTERIOR RING */
if (dyn_rng->interior == 0)
{
dyn_rng = dyn_rng->next;
continue;
}
points = kml_count_dyn_points (dyn_rng->ring);
ring = gaiaAddInteriorRing (new_pg, ib, points);
ib++;
pt = dyn_rng->ring->First;
iv = 0;
while (pt)
{
gaiaSetPoint (ring->Coords, iv, pt->X, pt->Y);
iv++;
pt = pt->Next;
}
dyn_rng = dyn_rng->next;
}
}
last_g = geom;
while (1)
{
/* searching the last Geometry within chain */
if (last_g->Next == NULL)
break;
last_g = last_g->Next;
}
last_g->Next = pg;
kml_free_dyn_polygon (dyn_pg);
return 1;
error:
kml_free_dyn_polygon (dyn_pg);
return 0;
}
static gaiaGeomCollPtr
fromGeosGeometry (const GEOSGeometry * geos, const int dimension_model)
{
/* converting a GEOS Geometry into a GAIA Geometry */
int type;
int itemType;
unsigned int dims;
int iv;
int ib;
int it;
int sub_it;
int nItems;
int nSubItems;
int holes;
unsigned int points;
double x;
double y;
double z;
const GEOSCoordSequence *cs;
const GEOSGeometry *geos_ring;
const GEOSGeometry *geos_item;
const GEOSGeometry *geos_sub_item;
gaiaGeomCollPtr gaia = NULL;
gaiaLinestringPtr ln;
gaiaPolygonPtr pg;
gaiaRingPtr rng;
if (!geos)
return NULL;
type = GEOSGeomTypeId (geos);
switch (type)
{
case GEOS_POINT:
if (dimension_model == GAIA_XY_Z)
gaia = gaiaAllocGeomCollXYZ ();
else if (dimension_model == GAIA_XY_M)
gaia = gaiaAllocGeomCollXYM ();
else if (dimension_model == GAIA_XY_Z_M)
gaia = gaiaAllocGeomCollXYZM ();
else
gaia = gaiaAllocGeomColl ();
gaia->DeclaredType = GAIA_POINT;
gaia->Srid = GEOSGetSRID (geos);
cs = GEOSGeom_getCoordSeq (geos);
GEOSCoordSeq_getDimensions (cs, &dims);
if (dims == 3)
{
GEOSCoordSeq_getX (cs, 0, &x);
GEOSCoordSeq_getY (cs, 0, &y);
GEOSCoordSeq_getZ (cs, 0, &z);
}
else
{
GEOSCoordSeq_getX (cs, 0, &x);
GEOSCoordSeq_getY (cs, 0, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
gaiaAddPointToGeomCollXYZ (gaia, x, y, z);
else if (dimension_model == GAIA_XY_M)
gaiaAddPointToGeomCollXYM (gaia, x, y, 0.0);
else if (dimension_model == GAIA_XY_Z_M)
gaiaAddPointToGeomCollXYZM (gaia, x, y, z, 0.0);
else
gaiaAddPointToGeomColl (gaia, x, y);
break;
case GEOS_LINESTRING:
if (dimension_model == GAIA_XY_Z)
gaia = gaiaAllocGeomCollXYZ ();
else if (dimension_model == GAIA_XY_M)
gaia = gaiaAllocGeomCollXYM ();
else if (dimension_model == GAIA_XY_Z_M)
gaia = gaiaAllocGeomCollXYZM ();
else
gaia = gaiaAllocGeomColl ();
gaia->DeclaredType = GAIA_LINESTRING;
gaia->Srid = GEOSGetSRID (geos);
cs = GEOSGeom_getCoordSeq (geos);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
ln = gaiaAddLinestringToGeomColl (gaia, points);
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (ln->Coords, iv, x, y, z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (ln->Coords, iv, x, y, 0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ln->Coords, iv, x, y, z, 0.0);
}
else
{
gaiaSetPoint (ln->Coords, iv, x, y);
}
}
break;
case GEOS_POLYGON:
if (dimension_model == GAIA_XY_Z)
gaia = gaiaAllocGeomCollXYZ ();
else if (dimension_model == GAIA_XY_M)
gaia = gaiaAllocGeomCollXYM ();
else if (dimension_model == GAIA_XY_Z_M)
gaia = gaiaAllocGeomCollXYZM ();
else
gaia = gaiaAllocGeomColl ();
gaia->DeclaredType = GAIA_POLYGON;
gaia->Srid = GEOSGetSRID (geos);
/* exterior ring */
holes = GEOSGetNumInteriorRings (geos);
geos_ring = GEOSGetExteriorRing (geos);
cs = GEOSGeom_getCoordSeq (geos_ring);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
pg = gaiaAddPolygonToGeomColl (gaia, points, holes);
rng = pg->Exterior;
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (rng->Coords, iv, x, y, z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (rng->Coords, iv, x, y, 0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (rng->Coords, iv, x, y, z, 0.0);
}
else
{
gaiaSetPoint (rng->Coords, iv, x, y);
}
}
for (ib = 0; ib < holes; ib++)
{
/* interior rings */
geos_ring = GEOSGetInteriorRingN (geos, ib);
cs = GEOSGeom_getCoordSeq (geos_ring);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
rng = gaiaAddInteriorRing (pg, ib, points);
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (rng->Coords, iv, x, y, z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (rng->Coords, iv, x, y, 0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (rng->Coords, iv, x, y, z, 0.0);
}
else
{
gaiaSetPoint (rng->Coords, iv, x, y);
}
}
}
break;
case GEOS_MULTIPOINT:
case GEOS_MULTILINESTRING:
case GEOS_MULTIPOLYGON:
case GEOS_GEOMETRYCOLLECTION:
if (dimension_model == GAIA_XY_Z)
gaia = gaiaAllocGeomCollXYZ ();
else if (dimension_model == GAIA_XY_M)
gaia = gaiaAllocGeomCollXYM ();
else if (dimension_model == GAIA_XY_Z_M)
gaia = gaiaAllocGeomCollXYZM ();
else
gaia = gaiaAllocGeomColl ();
if (type == GEOS_MULTIPOINT)
gaia->DeclaredType = GAIA_MULTIPOINT;
else if (type == GEOS_MULTILINESTRING)
gaia->DeclaredType = GAIA_MULTILINESTRING;
else if (type == GEOS_MULTIPOLYGON)
gaia->DeclaredType = GAIA_MULTIPOLYGON;
else
gaia->DeclaredType = GAIA_GEOMETRYCOLLECTION;
gaia->Srid = GEOSGetSRID (geos);
nItems = GEOSGetNumGeometries (geos);
for (it = 0; it < nItems; it++)
{
/* looping on elementaty geometries */
geos_item = GEOSGetGeometryN (geos, it);
itemType = GEOSGeomTypeId (geos_item);
switch (itemType)
{
case GEOS_POINT:
cs = GEOSGeom_getCoordSeq (geos_item);
GEOSCoordSeq_getDimensions (cs, &dims);
if (dims == 3)
{
GEOSCoordSeq_getX (cs, 0, &x);
GEOSCoordSeq_getY (cs, 0, &y);
GEOSCoordSeq_getZ (cs, 0, &z);
}
else
{
GEOSCoordSeq_getX (cs, 0, &x);
GEOSCoordSeq_getY (cs, 0, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
gaiaAddPointToGeomCollXYZ (gaia, x, y, z);
else if (dimension_model == GAIA_XY_M)
gaiaAddPointToGeomCollXYM (gaia, x, y, 0.0);
else if (dimension_model == GAIA_XY_Z_M)
gaiaAddPointToGeomCollXYZM (gaia, x, y, z, 0.0);
else
gaiaAddPointToGeomColl (gaia, x, y);
break;
case GEOS_LINESTRING:
cs = GEOSGeom_getCoordSeq (geos_item);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
ln = gaiaAddLinestringToGeomColl (gaia, points);
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (ln->Coords, iv, x, y, z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (ln->Coords, iv, x, y, 0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ln->Coords, iv, x, y, z,
0.0);
}
else
{
gaiaSetPoint (ln->Coords, iv, x, y);
}
}
break;
case GEOS_MULTILINESTRING:
nSubItems = GEOSGetNumGeometries (geos_item);
for (sub_it = 0; sub_it < nSubItems; sub_it++)
{
/* looping on elementaty geometries */
geos_sub_item =
GEOSGetGeometryN (geos_item, sub_it);
cs = GEOSGeom_getCoordSeq (geos_sub_item);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
ln = gaiaAddLinestringToGeomColl (gaia, points);
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (ln->Coords, iv, x, y,
z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (ln->Coords, iv, x, y,
0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (ln->Coords, iv, x, y,
z, 0.0);
}
else
{
gaiaSetPoint (ln->Coords, iv, x, y);
}
}
}
break;
case GEOS_POLYGON:
/* exterior ring */
holes = GEOSGetNumInteriorRings (geos_item);
geos_ring = GEOSGetExteriorRing (geos_item);
cs = GEOSGeom_getCoordSeq (geos_ring);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
pg = gaiaAddPolygonToGeomColl (gaia, points, holes);
rng = pg->Exterior;
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (rng->Coords, iv, x, y, z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (rng->Coords, iv, x, y, 0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (rng->Coords, iv, x, y, z,
0.0);
}
else
{
gaiaSetPoint (rng->Coords, iv, x, y);
}
}
for (ib = 0; ib < holes; ib++)
{
/* interior rings */
geos_ring = GEOSGetInteriorRingN (geos_item, ib);
cs = GEOSGeom_getCoordSeq (geos_ring);
GEOSCoordSeq_getDimensions (cs, &dims);
GEOSCoordSeq_getSize (cs, &points);
rng = gaiaAddInteriorRing (pg, ib, points);
for (iv = 0; iv < (int) points; iv++)
{
if (dims == 3)
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
GEOSCoordSeq_getZ (cs, iv, &z);
}
else
{
GEOSCoordSeq_getX (cs, iv, &x);
GEOSCoordSeq_getY (cs, iv, &y);
z = 0.0;
}
if (dimension_model == GAIA_XY_Z)
{
gaiaSetPointXYZ (rng->Coords, iv, x, y,
z);
}
else if (dimension_model == GAIA_XY_M)
{
gaiaSetPointXYM (rng->Coords, iv, x, y,
0.0);
}
else if (dimension_model == GAIA_XY_Z_M)
{
gaiaSetPointXYZM (rng->Coords, iv, x, y,
z, 0.0);
}
else
{
gaiaSetPoint (rng->Coords, iv, x, y);
}
}
}
break;
};
}
break;
};
return gaia;
}
