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

Generated by: LCOV version 1.14