Changeset 5516

Timestamp:

04/09/10 06:34:35 (2 years ago)

Author:

jorgearevalo

Message:

SQL function ST_DumpAsPolygons created, under conditional compilation. It still
has errors. So, it's NOT SAFE to use it. Default version returning NULL if don't
specify --enable-development option in configure script created. Related ticket: #297

Location:

spike/wktraster

Files:

• rt_core/rt_api.c (modified) (9 diffs)
• rt_core/rt_api.h (modified) (1 diff)
• rt_pg/rt_pg.c (modified) (2 diffs)
• rt_pg/rtpostgis.sql.in.c (modified) (4 diffs)
• test/core/testapi.c (modified) (1 diff)

spike/wktraster/rt_core/rt_api.c

@@ -1313 +1313 @@
     int srid;
     double val;
-    char * wktPol;
+    char * wktGeom;
 };
 
@@ -1319 +1319 @@
 #ifdef ENABLE_DEVELOPMENT
 rt_wktgeomval
-rt_raster_as_wktpolygon(rt_context ctx, rt_raster raster, int nband)
+rt_raster_dump_as_wktpolygons(rt_context ctx, rt_raster raster, int nband)
 {
     char szDataPointer[50];
@@ -1405 +1405 @@
     memdataset = GDALCreate(GDALGetDriverByName("MEM"),
                                    "",rt_band_get_width(ctx, band), 
-                                   rt_band_get_height(ctx, band), 0, GDT_Byte,
-                                   NULL);
+                                   rt_band_get_height(ctx, band), 0, 
+                                   GDT_Byte, NULL);
 
     if (NULL == memdataset)
@@ -1596 +1596 @@
 
         /**
-         * The field was stored as int, but we can use this function because
-         * uses "atof" to transform the string representation of the number
-         * into a double. We shouldn't have problems
+         * The field was stored as int, but we can use this function 
+         * because uses "atof" to transform the string representation of 
+         * the number into a double. We shouldn't have problems
          **/
         dValueToCompare = OGR_F_GetFieldAsDouble(hFeature, iPixVal);
@@ -1607 +1607 @@
          * the associated polygon is discarded
          **/
-       dEpsilon = fabs(dValueToCompare - dBandNoData);
-       if (dEpsilon > FLT_EPSILON)
+        dEpsilon = fabs(dValueToCompare - dBandNoData);
+        if (dEpsilon > FLT_EPSILON)
             nValidPols--;
     }
@@ -1630 +1630 @@
         dEpsilon = fabs(dValueToCompare - dBandNoData);
 
-        // Valid polygon
+        /* Valid polygon */
         if (dEpsilon > FLT_EPSILON)
         {
@@ -1636 +1636 @@
             OGR_G_ExportToWkt(hGeom, &pszSrcText);
             
-            // Fill rt_wktgeomval structure
+            /* Fill rt_wktgeomval structure */
             pols[nCont].val = OGR_F_GetFieldAsInteger(hFeature, iPixVal); 
             pols[nCont].srid = rt_raster_get_srid(ctx, raster);
-            pols[nCont].wktPol = (char *)ctx->alloc(strlen(pszSrcText) 
+            pols[nCont].wktGeom = (char *)ctx->alloc(strlen(pszSrcText) 
                     * sizeof(char));
-            strcpy(pols[nCont].wktPol, pszSrcText);            
-
-#ifdef POSTGIS_RASTER_API_DEBUG
-            ctx->info("Feature %d, WKT Polygon: %s", j, pols[nCont].wktPol);
+            strcpy(pols[nCont].wktGeom, pszSrcText);            
+
+#ifdef POSTGIS_RASTER_API_DEBUG
+            ctx->info("Feature %d, WKT Polygon: %s", j, pols[nCont].wktGeom);
             ctx->info("Feature %d, value: %d", j, (int)(pols[nCont].val));
             ctx->info("Feature %d, srid: %d", j, pols[nCont].srid);
@@ -1666 +1666 @@
 
 rt_wktgeomval
-rt_raster_as_wktpolygon(rt_context ctx, rt_raster raster, int nband)
+rt_raster_dump_as_wktpolygons(rt_context ctx, rt_raster raster, int nband)
 {
     /**
@@ -1676 +1676 @@
 }
 
-#endif // ENABLE_DEVELOPMENT
+#endif /* ENABLE_DEVELOPMENT */
 
 

spike/wktraster/rt_core/rt_api.h

@@ -542 +542 @@
  */
 rt_wktgeomval
-rt_raster_as_wktpolygon(rt_context ctx, rt_raster raster, int nband);
+rt_raster_dump_as_wktpolygons(rt_context ctx, rt_raster raster, int nband);
 
 /**

spike/wktraster/rt_pg/rt_pg.c

@@ -88 +88 @@
 Datum RASTER_to_LWGEOM(PG_FUNCTION_ARGS);
 Datum RASTER_to_BOX2DFLOAT4(PG_FUNCTION_ARGS);
+Datum RASTER_dumpAsWKTPolygons(PG_FUNCTION_ARGS);
 
 /* Get all the properties of a raster */
@@ -517 +518 @@
     PG_RETURN_POINTER(bbox);
 }
+
+
+
+
+/**
+ * Needed for sizeof
+ */
+struct rt_wktgeomval_t {
+    int srid;
+    double val;
+    char * wktGeom;
+};
+
+
+/**
+ * Need this to store the set of structs and a index to know
+ * which struct should I get in each call
+ */
+
+struct rt_wktgeomval_ind_t {
+    rt_wktgeomval geomval;
+    int index;
+};
+
+typedef struct rt_wktgeomval_ind_t* rt_wktgeomval_ind;
+
+ 
+#ifdef ENABLE_DEVELOPMENT
+
+
+/**
+ * Returns a set of "geomval" value, one for each group of pixel sharing the same value for the provided band.
+ */
+PG_FUNCTION_INFO_V1(RASTER_asWKTPolygon);
+Datum RASTER_dumpAsWKTPolygons(PG_FUNCTION_ARGS)
+{
+    rt_pgraster *pgraster;
+    rt_raster raster;
+    rt_context ctx = get_rt_context(fcinfo);
+    FuncCallContext *funcctx;
+    int call_cntr;
+    int max_calls;
+    TupleDesc tupdesc;
+    AttInMetadata *attinmeta;
+    int nband;
+    rt_wktgeomval geomval;
+    rt_wktgeomval_ind geomval_ind;
+
+
+    /**
+     * Check input parameters
+     */
+    if ( PG_NARGS() < 1 || PG_NARGS() > 2 )
+    {
+        ereport(errcode(ERRCODE_TOO_MANY_ARGUMENTS), 
+                (errmsg("RASTER_dumpAsWKTPolygons requires 1 or 2 args")));
+        PG_RETURN_NULL();
+    }
+
+    /**
+     * Stuff donde only in the first call of the function
+     */
+    if (SRF_IS_FIRSTCALL())
+    {
+        MemoryContext oldcontext;
+
+        /* Create a function context for cross-call persistence */
+        funcctx = SRF_FIRSTCALL_INIT();
+
+        /* switch to memory context appropriate for multiple function 
+           calls */
+        oldcontext = 
+            MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
+       
+        /* Get raster context. We change to a valid memory context
+         * (fcinfo->flinfo->fn_mcxt) to create a new rt_context. So, all
+         * the memory operations performed in rt_api core function called
+         * will be based on palloc. See palloc advantages at PostgreSQL
+         * source, in src/backend/utils/mmgr/README
+         */
+        ctx = get_rt_context(fcinfo);
+
+        /* Get input arguments */
+        pgraster = (rt_pgraster *)PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
+        raster = rt_raster_deserialize(ctx, pgraster);
+        if ( ! raster ) 
+        {
+            ereport(errcode(ERRCODE_OUT_OF_MEMORY), 
+                    (errmsg("Could not deserialize raster")));
+            PG_RETURN_NULL();
+        }
+
+        if (PG_NARGS() == 2)
+            nband = PG_GETARG_UINT32(1);
+        else
+            nband = 1; /* By default, first band */
+
+        /* Polygonize raster */
+        geomval = rt_raster_dump_as_wktpolygons(ctx, raster, nband);
+        /**
+         * Not needed to check geomval. It was allocated by the new
+         * rt_context, that uses palloc. It never returns NULL
+         */
+       
+        /**
+         * Total number of tuples to be return
+         * xxx jorgearevalo: Check if this works...
+         */
+        funcctx->max_calls = 
+            sizeof(geomval) / sizeof(rt_wktgeomval);
+
+        /** 
+         * Store needed information
+         */
+        geomval_ind = (rt_wktgeomval_ind *)palloc(1*sizeof(rt_wktgeomval));
+        if ( ! geomval_ind)
+        {
+            ereport(errcode(ERRCODE_OUT_OF_MEMORY), 
+                    (errmsg("Out of memory")));
+            PG_RETURN_NULL();
+        }
+        geomval_ind->geomval = geomval;
+        geomval_ind->index = 0;
+        funcctx->user_fctx = geomval_ind;
+
+        /* Build a tuple descriptor for our result type */
+        if (get_call_result_type(fcinfo, NULL, &tupdesc) != 
+                TYPEFUNC_COMPOSITE)
+        {
+            ereport(ERROR,
+                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+                     errmsg("Function returning record called in context "
+                            "that cannot accept type record")));
+        }
+
+
+        /* Generate attribute metadata needed later to produce tuples
+           for raw C strings */
+        attinmeta = TupleDescGetAttInMetadata(tupdesc);
+        funcctx->attinmeta = attinmeta;
+
+        MemoryContextSwitchTo(oldcontext);
+    }
+
+    /* Stuff done on every call of the function */
+    funcctx = SRF_PERCALL_SETUP();
+    call_cntr = funcctx->call_cntr;
+    max_calls = funcctx->max_calls;
+    attinmeta = funcctx->attinmeta;
+    geomval_ind = funcctx->user_fctx;
+
+    /* If there is more left to send... */
+    if (call_cntr < max_calls)
+    {
+        char ** values;
+        HeapTuple tuple;
+        Datum result;
+
+        /**
+         * Prepare a values array for building the returned tuple.
+         * This should be an array of C strings which will be processed
+         * later by the type input functions
+         */
+        values = (char **)palloc(3 * sizeof(char *));
+        values[0] = (char *)palloc(sizeof(int) * sizeof(char));
+        values[1] = (char *)palloc(
+                strlen(geomval_ind->geomval[geomval_ind->index].wktGeom) * sizeof(char));
+        values[2] = (char *)palloc(sizeof(double) * sizeof(char));
+
+        snprintf(values[0], sizeof(int), "%d",
+                geomval_ind->geomval[geomval_ind->index].srid);
+        snprintf(values[1], 
+                strlen(geomval_ind->geomval[geomval_ind->index].wktGeom),
+                "%s", geomval_ind->geomval[geomval_ind->index].wktGeom);
+        snprintf(values[2], sizeof(double), "%f",
+                geomval_ind->geomval[geomval_ind->index].val);
+        
+        /* Build a tuple */
+        tuple = BuildTupleFromCStrings(attinmeta, values);
+
+        /* Make the tuple into a datum */
+        result = HeapTupleGetDatum(tuple);
+
+        /* Increment index */
+        geomval_ind->index++;
+
+        /* Clean up. Not really necessary */
+        pfree(values[0]);
+        pfree(values[1]);
+        pfree(values[2]);
+        pfree(values);
+
+        SRF_RETURN_NEXT(funcctx, result);
+    }
+
+    /* No more left */
+    else
+    {
+        /* Free geomval memory? */
+
+        SRF_RETURN_DONE(funcctx);
+    }
+
+}
+
+#else
+PG_FUNCTION_INFO_V1(RASTER_asWKTPolygon);
+Datum RASTER_dumpAsWKTPolygons(PG_FUNCTION_ARGS)
+{
+    /**
+     * This function is under development and may have an
+     * unexpected behaviour. If you want to use it, pass
+     * '--enable-development' option to configure script
+     */
+
+    /* xxx jorgearevalo: The ereport call causes an error when a query is 
+     * executed: 'errstart was not called'. I suppose is an initialization
+     * issue. Investigate it.
+     */
+
+    /*
+    ereport(errcode(ERRCODE_WARNING),
+            (errmsg("This function is under development and may have an "
+                    "unexpected behaviour. If you want  to use it, pass "
+                    "--enable-development option to configure script")));
+    */      
+    PG_RETURN_NULL();
+}
+#endif
+
 
 /**

spike/wktraster/rt_pg/rtpostgis.sql.in.c

@@ -55 +55 @@
 );
 
+CREATE TYPE geomval AS (
+    geom geometry,
+    val double precision,
+    srid int
+);
+
+CREATE TYPE wktgeomval AS (
+    wktgeom text,
+    val double precision,
+    srid int 
+);
+
 ------------------------------------------------------------------------------
 --  FUNCTIONS
@@ -82 +94 @@
     RETURNS BOX2D
     AS 'MODULE_PATHNAME','RASTER_to_BOX2DFLOAT4'
+    LANGUAGE 'C' _IMMUTABLE_STRICT;
+
+CREATEFUNCTION DumpAsWKTPolygons(raster, int DEFAULT 1)
+    RETURNS SETOF wktgeomval
+    AS 'MODULE_PATHNAME','RASTER_dumpAsWKTPolygons'
     LANGUAGE 'C' _IMMUTABLE_STRICT;
 
@@ -232 +249 @@
 $$
 LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (isstrict);
+
 
 CREATEFUNCTION st_setgeoreference(raster, text)
@@ -348 +366 @@
     AS 'MODULE_PATHNAME', 'RASTER_makeEmpty'
     LANGUAGE 'C' IMMUTABLE; -- a new lib will require a new session
+
+    
+CREATEFUNCTION st_dumpaspolygons(raster) 
+    RETURNS SETOF geomval
+    AS 'select st_geomfromtext(wktgeomval.wktgeom), wktgeomval.val,
+    wktgeomval.srid from dumpaswktpolygons($1, 1) as wktgeomval'
+    LANGUAGE 'SQL' _IMMUTABLE_STRICT;
+
+CREATEFUNCTION st_dumpaspolygons(raster, int) 
+    RETURNS SETOF geomval
+    AS 'select st_geomfromtext(wktgeomval.wktgeom), wktgeomval.val,
+    wktgeomval.srid from dumpaswktpolygons($1, $2) as wktgeomval'
+    LANGUAGE 'SQL' _IMMUTABLE_STRICT;
+
 
 ------------------------------------------------------------------------------

spike/wktraster/test/core/testapi.c

@@ -1066 +1066 @@
             int srid;
             double val;
-            char * wktPol;
+            char * wktGeom;
         };
 
         typedef struct rt_wktgeomval_t* rt_wktgeomval;
         
-        rt_wktgeomval gv = rt_raster_as_wktpolygon(ctx, rt, 1);
+        rt_wktgeomval gv = rt_raster_dump_as_wktpolygons(ctx, rt, 1);
 
         CHECK_EQUALS(gv[0].val, 1);
-        CHECK(!strcmp(gv[0].wktPol,"POLYGON ((3 1,3 2,2 2,2 3,1 3,1 6,2 6,2 7,3 7,3 8,5 8,5 6,3 6,3 3,4 3,5 3,5 1,3 1))"));
+        CHECK(!strcmp(gv[0].wktGeom,"POLYGON ((3 1,3 2,2 2,2 3,1 3,1 6,2 6,2 7,3 7,3 8,5 8,5 6,3 6,3 3,4 3,5 3,5 1,3 1))"));
 
         CHECK_EQUALS(gv[1].val, 2);
-        CHECK(!strcmp(gv[1].wktPol,"POLYGON ((5 1,5 3,6 3,6 6,5 6,5 8,6 8,6 7,7 7,7 6,8 6,8 3,7 3,7 2,6 2,6 1,5 1))"));      
+        CHECK(!strcmp(gv[1].wktGeom,"POLYGON ((5 1,5 3,6 3,6 6,5 6,5 8,6 8,6 7,7 7,7 6,8 6,8 3,7 3,7 2,6 2,6 1,5 1))"));      
         
         rt_raster_destroy(ctx, rt);