LCOV - code coverage report
Current view: top level - geom/lib - libgeom.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 59 63 93.7 %
Date: 2020-06-29 20:00:14 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2020 MonetDB B.V.
       7             :  */
       8             : 
       9             : /*
      10             :  * @f libgeom
      11             :  * @a Niels Nes
      12             :  *
      13             :  * @* The simple geom library
      14             :  */
      15             : 
      16             : #include "monetdb_config.h"
      17             : #include "libgeom.h"
      18             : 
      19             : #include <math.h>
      20             : 
      21             : static void __attribute__((__format__(__printf__, 1, 2)))
      22          57 : geomerror(_In_z_ _Printf_format_string_ const char *fmt, ...)
      23             : {
      24          57 :         va_list va;
      25          57 :         char err[256];
      26          57 :         va_start(va, fmt);
      27          57 :         vsnprintf(err, sizeof(err), fmt, va);
      28          57 :         GDKtracer_log(__FILE__, __func__, __LINE__, M_CRITICAL,
      29             :                       GDK, NULL, "%s", err);
      30          57 :         va_end(va);
      31          57 : }
      32             : 
      33             : void
      34         252 : libgeom_init(void)
      35             : {
      36         252 :         initGEOS((GEOSMessageHandler) geomerror, (GEOSMessageHandler) geomerror);
      37         252 :         GEOS_setWKBByteOrder(1);        /* NDR (little endian) */
      38         252 :         printf("# MonetDB/GIS module loaded\n");
      39         252 :         fflush(stdout);         /* make merovingian see this *now* */
      40         252 : }
      41             : 
      42             : void
      43         250 : libgeom_exit(void)
      44             : {
      45         250 :         finishGEOS();
      46         250 : }
      47             : 
      48             : bool
      49        6645 : is_wkb_nil(const wkb *w)
      50             : {
      51        6645 :         if (!w || w->len == ~0)
      52          92 :                 return 1;
      53             :         return 0;
      54             : }
      55             : 
      56             : 
      57             : /* Function getMbrGeos
      58             :  * Creates an mbr holding the lower left and upper right coordinates
      59             :  * of a GEOSGeom.
      60             :  */
      61             : /*
      62             : int
      63             : getMbrGeos(mbr *res, const GEOSGeom geosGeometry)
      64             : {
      65             :         GEOSGeom envelope;
      66             :         //int coordinatesNum  = 0;
      67             :         double xmin = 0, ymin = 0, xmax = 0, ymax = 0;
      68             : 
      69             :         if (!geosGeometry || (envelope = GEOSEnvelope(geosGeometry)) == NULL)
      70             :                 return 0;
      71             : 
      72             :         // get the number of coordinates the geometry has
      73             :         //coordinatesNum = GEOSGeom_getCoordinateDimension(geosGeometry);
      74             : 
      75             :         if (GEOSGeomTypeId(envelope) == GEOS_POINT) {
      76             : #if GEOS_CAPI_VERSION_MAJOR >= 1 && GEOS_CAPI_VERSION_MINOR >= 3
      77             :                 const GEOSCoordSequence *coords = GEOSGeom_getCoordSeq(envelope);
      78             : #else
      79             :                 const GEOSCoordSeq coords = GEOSGeom_getCoordSeq(envelope);
      80             : #endif
      81             :                 GEOSCoordSeq_getX(coords, 0, &xmin);
      82             :                 GEOSCoordSeq_getY(coords, 0, &ymin);
      83             :                 assert(GDK_flt_min <= xmin && xmin <= GDK_flt_max);
      84             :                 assert(GDK_flt_min <= ymin && ymin <= GDK_flt_max);
      85             :                 res->xmin = (float) xmin;
      86             :                 res->ymin = (float) ymin;
      87             :                 res->xmax = (float) xmin;
      88             :                 res->ymax = (float) ymin;
      89             :         } else {                // GEOSGeomTypeId(envelope) == GEOS_POLYGON
      90             : #if GEOS_CAPI_VERSION_MAJOR >= 1 && GEOS_CAPI_VERSION_MINOR >= 3
      91             :                 const GEOSGeometry *ring = GEOSGetExteriorRing(envelope);
      92             : #else
      93             :                 const GEOSGeom ring = GEOSGetExteriorRing(envelope);
      94             : #endif
      95             :                 if (ring) {
      96             : #if GEOS_CAPI_VERSION_MAJOR >= 1 && GEOS_CAPI_VERSION_MINOR >= 3
      97             :                         const GEOSCoordSequence *coords = GEOSGeom_getCoordSeq(ring);
      98             : #else
      99             :                         const GEOSCoordSeq coords = GEOSGeom_getCoordSeq(ring);
     100             : #endif
     101             :                         GEOSCoordSeq_getX(coords, 0, &xmin);
     102             :                         GEOSCoordSeq_getY(coords, 0, &ymin);
     103             :                         GEOSCoordSeq_getX(coords, 2, &xmax);
     104             :                         GEOSCoordSeq_getY(coords, 2, &ymax);
     105             :                         assert(GDK_flt_min <= xmin && xmin <= GDK_flt_max);
     106             :                         assert(GDK_flt_min <= ymin && ymin <= GDK_flt_max);
     107             :                         assert(GDK_flt_min <= xmax && xmax <= GDK_flt_max);
     108             :                         assert(GDK_flt_min <= ymax && ymax <= GDK_flt_max);
     109             :                         res->xmin = (float) xmin;
     110             :                         res->ymin = (float) ymin;
     111             :                         res->xmax = (float) xmax;
     112             :                         res->ymax = (float) ymax;
     113             :                 }
     114             :         }
     115             :         GEOSGeom_destroy(envelope);
     116             :         return 1;
     117             : }
     118             : */
     119             : 
     120             : GEOSGeom
     121        3042 : wkb2geos(const wkb *geomWKB)
     122             : {
     123        3042 :         GEOSGeom geosGeometry;
     124             : 
     125        3042 :         if (is_wkb_nil(geomWKB))
     126             :                 return NULL;
     127             : 
     128        3042 :         geosGeometry = GEOSGeomFromWKB_buf((unsigned char *) geomWKB->data, geomWKB->len);
     129             : 
     130        3046 :         if (geosGeometry != NULL)
     131        3046 :                 GEOSSetSRID(geosGeometry, geomWKB->srid);
     132             : 
     133             :         return geosGeometry;
     134             : }
     135             : 
     136             : /* Function getMbrGeom
     137             :  * A wrapper for getMbrGeos on a geom_geometry.
     138             :  */
     139             : /*
     140             : int
     141             : getMbrGeom(mbr *res, wkb *geom)
     142             : {
     143             :         GEOSGeom geosGeometry = wkb2geos(geom);
     144             : 
     145             :         if (geosGeometry) {
     146             :                 int r = getMbrGeos(res, geosGeometry);
     147             :                 GEOSGeom_destroy(geosGeometry);
     148             :                 return r;
     149             :         }
     150             :         return 0;
     151             : }
     152             : */
     153             : 
     154             : const char *
     155         180 : geom_type2str(int t, int flag)
     156             : {
     157         180 :         if (flag == 0) {
     158         126 :                 switch (t) {
     159             :                 //case wkbGeometry:
     160             :                 //      return "GEOMETRY";
     161          23 :                 case wkbPoint_mdb:
     162          23 :                         return "POINT";
     163          21 :                 case wkbLineString_mdb:
     164          21 :                         return "LINESTRING";
     165           0 :                 case wkbLinearRing_mdb:
     166           0 :                         return "LINEARRING";
     167          15 :                 case wkbPolygon_mdb:
     168          15 :                         return "POLYGON";
     169          15 :                 case wkbMultiPoint_mdb:
     170          15 :                         return "MULTIPOINT";
     171          22 :                 case wkbMultiLineString_mdb:
     172          22 :                         return "MULTILINESTRING";
     173          20 :                 case wkbMultiPolygon_mdb:
     174          20 :                         return "MULTIPOLYGON";
     175          10 :                 case wkbGeometryCollection_mdb:
     176          10 :                         return "GEOMETRYCOLLECTION";
     177             :                 }
     178          54 :         } else if (flag == 1) {
     179          54 :                 switch (t) {
     180             :                 //case wkbGeometry:
     181             :                 //      return "ST_Geometry";
     182           5 :                 case wkbPoint_mdb:
     183           5 :                         return "ST_Point";
     184          11 :                 case wkbLineString_mdb:
     185          11 :                         return "ST_LineString";
     186           0 :                 case wkbLinearRing_mdb:
     187           0 :                         return "ST_LinearRing";
     188           6 :                 case wkbPolygon_mdb:
     189           6 :                         return "ST_Polygon";
     190           5 :                 case wkbMultiPoint_mdb:
     191           5 :                         return "ST_MultiPoint";
     192          11 :                 case wkbMultiLineString_mdb:
     193          11 :                         return "ST_MultiLinestring";
     194           8 :                 case wkbMultiPolygon_mdb:
     195           8 :                         return "ST_MultiPolygon";
     196           8 :                 case wkbGeometryCollection_mdb:
     197           8 :                         return "ST_GeometryCollection";
     198             :                 }
     199             :         }
     200             :         return "UKNOWN";
     201             : }
     202             : 
     203             : 
     204             : /*
     205             : str
     206             : geomerty_2_geometry(wkb *res, wkb **geom, int *columnType, int *columnSRID, int *valueSRID)
     207             : {
     208             : 
     209             :         //char* geomStr;
     210             :         //size_t len = 0;
     211             :         //fprintf(stderr, "geometry_2_geometry\n");
     212             :         //wkbTOSTR(&geomStr, &len, *geom);
     213             :         if (*geom != NULL)
     214             :                 fprintf(stderr, "type:%d - wkbTOSTR cannot be seen at this point\n", *columnType);
     215             : 
     216             :         if (res == NULL)
     217             :                 fprintf(stderr, "-> ");
     218             : 
     219             :         fprintf(stderr, "%d vs %d\n", *columnSRID, *valueSRID);
     220             :         return "0";
     221             : }
     222             : */

Generated by: LCOV version 1.14