coverage_window_calculation()

static Datum coverage_window_calculation ( PG_FUNCTION_ARGS  , int  mode  )

static

Definition at line 659 of file lwgeom_window.c.

{
        WindowObject winobj = PG_WINDOW_OBJECT();
        int64 curpos = WinGetCurrentPosition(winobj);
        int64 rowcount = WinGetPartitionRowCount(winobj);
        coverage_context *context = coverage_context_fetch(winobj, rowcount);
        GSERIALIZED* result;
        MemoryContext uppercontext = fcinfo->flinfo->fn_mcxt;
        MemoryContext oldcontext;
        const LWGEOM* subgeom;
 
        if (!context->isdone)
        {
                bool isnull;
                GEOSGeometry *output = NULL;
                GEOSGeometry *input = NULL;
                Datum d;
 
                if (!fcinfo->flinfo)
                        elog(ERROR, "%s: Could not find upper context", __func__);
 
                if (rowcount == 0)
                {
                        context->isdone = true;
                        context->isnull = true;
                        PG_RETURN_NULL();
                }
 
                initGEOS(lwpgnotice, lwgeom_geos_error);
 
                input = coverage_read_partition_into_collection(winobj, context);
                if (!input)
                        HANDLE_GEOS_ERROR("Failed to create collection");
 
                /* Run the correct GEOS function for the calling mode */
                if (mode == COVERAGE_SIMPLIFY)
                {
                        bool simplifyBoundary = true;
                        double tolerance = 0.0;
 
                        d = WinGetFuncArgCurrent(winobj, 1, &isnull);
                        if (!isnull) tolerance = DatumGetFloat8(d);
 
                        d = WinGetFuncArgCurrent(winobj, 2, &isnull);
                        if (!isnull) simplifyBoundary = DatumGetFloat8(d);
 
                        /* GEOSCoverageSimplifyVW is "preserveBoundary" so we invert simplifyBoundary */
                        output = GEOSCoverageSimplifyVW(input, tolerance, !simplifyBoundary);
                }
                else if (mode == COVERAGE_ISVALID)
                {
                        double tolerance = 0.0;
                        d = WinGetFuncArgCurrent(winobj, 1, &isnull);
                        if (!isnull) tolerance = DatumGetFloat8(d);
                        GEOSCoverageIsValid(input, tolerance, &output);
                }
 
#if POSTGIS_GEOS_VERSION >= 31400
 
                else if (mode == COVERAGE_CLEAN)
                {
                        double snappingDistance = 0.0;
                        double gapMaximumWidth = 0.0;
                        text *overlapMergeStrategyText;
                        int overlapMergeStrategy;
                        GEOSCoverageCleanParams *params = NULL;
 
                        d = WinGetFuncArgCurrent(winobj, 1, &isnull);
                        if (!isnull) gapMaximumWidth = DatumGetFloat8(d);
 
                        d = WinGetFuncArgCurrent(winobj, 2, &isnull);
                        if (!isnull) snappingDistance = DatumGetFloat8(d);
 
                        d = WinGetFuncArgCurrent(winobj, 3, &isnull);
                        if (!isnull)
                        {
                                overlapMergeStrategyText = DatumGetTextP(d);
                                overlapMergeStrategy = coverage_merge_strategy(text_to_cstring(overlapMergeStrategyText));
                        }
                        else
                        {
                                overlapMergeStrategy = 0; /* Default to MERGE_LONGEST_BORDER */
                        }
                        if (overlapMergeStrategy < 0)
                        {
                                HANDLE_GEOS_ERROR("Invalid OverlapMergeStrategy");
                        }
 
                        params = GEOSCoverageCleanParams_create();
                        GEOSCoverageCleanParams_setGapMaximumWidth(params, gapMaximumWidth);
                        GEOSCoverageCleanParams_setSnappingDistance(params, snappingDistance);
                        if (!GEOSCoverageCleanParams_setOverlapMergeStrategy(params, overlapMergeStrategy))
                        {
                                GEOSCoverageCleanParams_destroy(params);
                                HANDLE_GEOS_ERROR("Invalid OverlapMergeStrategy");
                        }
 
                        output = GEOSCoverageCleanWithParams(input, params);
                        GEOSCoverageCleanParams_destroy(params);
                }
#endif
                else
                {
                        elog(ERROR, "Unknown mode, never get here");
                }
 
                GEOSGeom_destroy(input);
 
                if (!output)
                {
                        HANDLE_GEOS_ERROR("Failed to process collection");
                }
 
                oldcontext = MemoryContextSwitchTo(uppercontext);
                context->geom = (LWCOLLECTION *) GEOS2LWGEOM(output, GEOSHasZ(output));
                MemoryContextSwitchTo(oldcontext);
                GEOSGeom_destroy(output);
 
                context->isdone = true;
        }
 
        /* Bomb out of any errors */
        if (context->isnull)
                PG_RETURN_NULL();
 
        /* Propagate the null entries */
        if (context->idx[curpos] < 0)
                PG_RETURN_NULL();
 
        /*
         * Geometry serialization is not const-safe! (we
         * calculate bounding boxes on demand) so we need
         * to make sure we have a persistent context when
         * we call the serialization, lest we create dangling
         * pointers in the object. It's possible we could
         * ignore them, skip the manual lwcollection_free
         * and let the aggcontext deletion take
         * care of the memory.
         */
        oldcontext = MemoryContextSwitchTo(uppercontext);
        subgeom = lwcollection_getsubgeom(context->geom, context->idx[curpos]);
        if (mode == COVERAGE_ISVALID && lwgeom_is_empty(subgeom))
        {
                result = NULL;
        }
        else
        {
                result = geometry_serialize((LWGEOM*)subgeom);
        }
        MemoryContextSwitchTo(oldcontext);
 
        /* When at the end of the partition, release the */
        /* simplified collection we have been reading. */
        if (curpos == rowcount - 1)
                lwcollection_free(context->geom);
 
        if (!result) PG_RETURN_NULL();
 
        PG_RETURN_POINTER(result);
 
}

References coverage_context_fetch(), COVERAGE_ISVALID, coverage_read_partition_into_collection(), COVERAGE_SIMPLIFY, coverage_context::geom, HANDLE_GEOS_ERROR, coverage_context::idx, coverage_context::isdone, coverage_context::isnull, lwcollection_free(), lwcollection_getsubgeom(), lwgeom_geos_error(), lwgeom_is_empty(), and result.

Referenced by ST_CoverageClean(), ST_CoverageInvalidEdges(), and ST_CoverageSimplify().

Here is the call graph for this function:

Here is the caller graph for this function: