RASTER_GDALWarp()

Datum RASTER_GDALWarp

(

PG_FUNCTION_ARGS

)

Definition at line 451 of file rtpg_gdal.c.

References clamp_srid(), FALSE, FLT_NEQ, POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, rtpixdump::rast, rtrowdump::raster, rt_raster_deserialize(), rt_raster_destroy(), rt_raster_gdal_warp(), rt_raster_get_srid(), rt_raster_serialize(), rt_raster_set_srid(), rt_util_gdal_resample_alg(), rtpg_getSR(), rtpg_strtoupper(), rtpg_trim(), rt_raster_serialized_t::size, and SRID_UNKNOWN.

Referenced by RASTER_getGDALDrivers().

{
        rt_pgraster *pgraster = NULL;
        rt_pgraster *pgrast = NULL;
        rt_raster raster = NULL;
        rt_raster rast = NULL;

        text *algtext = NULL;
        char *algchar = NULL;
        GDALResampleAlg alg = GRA_NearestNeighbour;
        double max_err = 0.125;

        int src_srid = SRID_UNKNOWN;
        char *src_srs = NULL;
        int dst_srid = SRID_UNKNOWN;
        char *dst_srs = NULL;
        int no_srid = 0;

        double scale[2] = {0};
        double *scale_x = NULL;
        double *scale_y = NULL;

        double gridw[2] = {0};
        double *grid_xw = NULL;
        double *grid_yw = NULL;

        double skew[2] = {0};
        double *skew_x = NULL;
        double *skew_y = NULL;

        int dim[2] = {0};
        int *dim_x = NULL;
        int *dim_y = NULL;

        POSTGIS_RT_DEBUG(3, "RASTER_GDALWarp: Starting");

        /* pgraster is null, return null */
        if (PG_ARGISNULL(0))
                PG_RETURN_NULL();
        pgraster = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));

        /* raster */
        raster = rt_raster_deserialize(pgraster, FALSE);
        if (!raster) {
                PG_FREE_IF_COPY(pgraster, 0);
                elog(ERROR, "RASTER_GDALWarp: Could not deserialize raster");
                PG_RETURN_NULL();
        }

        /* resampling algorithm */
        if (!PG_ARGISNULL(1)) {
                algtext = PG_GETARG_TEXT_P(1);
                algchar = rtpg_trim(rtpg_strtoupper(text_to_cstring(algtext)));
                alg = rt_util_gdal_resample_alg(algchar);
        }
        POSTGIS_RT_DEBUGF(4, "Resampling algorithm: %d", alg);

        /* max error */
        if (!PG_ARGISNULL(2)) {
                max_err = PG_GETARG_FLOAT8(2);
                if (max_err < 0.) max_err = 0.;
        }
        POSTGIS_RT_DEBUGF(4, "max_err: %f", max_err);

        /* source SRID */
        src_srid = clamp_srid(rt_raster_get_srid(raster));
        POSTGIS_RT_DEBUGF(4, "source SRID: %d", src_srid);

        /* target SRID */
        if (!PG_ARGISNULL(3)) {
                dst_srid = clamp_srid(PG_GETARG_INT32(3));
                if (dst_srid == SRID_UNKNOWN) {
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        elog(ERROR, "RASTER_GDALWarp: %d is an invalid target SRID", dst_srid);
                        PG_RETURN_NULL();
                }
        }
        else
                dst_srid = src_srid;
        POSTGIS_RT_DEBUGF(4, "destination SRID: %d", dst_srid);

        /* target SRID != src SRID, error */
        if (src_srid == SRID_UNKNOWN && dst_srid != src_srid) {
                rt_raster_destroy(raster);
                PG_FREE_IF_COPY(pgraster, 0);
                elog(ERROR, "RASTER_GDALWarp: Input raster has unknown (%d) SRID", src_srid);
                PG_RETURN_NULL();
        }
        /* target SRID == src SRID, no reprojection */
        else if (dst_srid == src_srid) {
                no_srid = 1;
        }

        /* scale x */
        if (!PG_ARGISNULL(4)) {
                scale[0] = PG_GETARG_FLOAT8(4);
                if (FLT_NEQ(scale[0], 0)) scale_x = &scale[0];
        }

        /* scale y */
        if (!PG_ARGISNULL(5)) {
                scale[1] = PG_GETARG_FLOAT8(5);
                if (FLT_NEQ(scale[1], 0)) scale_y = &scale[1];
        }

        /* grid alignment x */
        if (!PG_ARGISNULL(6)) {
                gridw[0] = PG_GETARG_FLOAT8(6);
                grid_xw = &gridw[0];
        }

        /* grid alignment y */
        if (!PG_ARGISNULL(7)) {
                gridw[1] = PG_GETARG_FLOAT8(7);
                grid_yw = &gridw[1];
        }

        /* skew x */
        if (!PG_ARGISNULL(8)) {
                skew[0] = PG_GETARG_FLOAT8(8);
                if (FLT_NEQ(skew[0], 0)) skew_x = &skew[0];
        }

        /* skew y */
        if (!PG_ARGISNULL(9)) {
                skew[1] = PG_GETARG_FLOAT8(9);
                if (FLT_NEQ(skew[1], 0)) skew_y = &skew[1];
        }

        /* width */
        if (!PG_ARGISNULL(10)) {
                dim[0] = PG_GETARG_INT32(10);
                if (dim[0] < 0) dim[0] = 0;
                if (dim[0] > 0) dim_x = &dim[0];
        }

        /* height */
        if (!PG_ARGISNULL(11)) {
                dim[1] = PG_GETARG_INT32(11);
                if (dim[1] < 0) dim[1] = 0;
                if (dim[1] > 0) dim_y = &dim[1];
        }

        /* check that at least something is to be done */
        if (
                (dst_srid == SRID_UNKNOWN) &&
                (scale_x == NULL) && (scale_y == NULL) &&
                (grid_xw == NULL) && (grid_yw == NULL) &&
                (skew_x == NULL) && (skew_y == NULL) &&
                (dim_x == NULL) && (dim_y == NULL)
        ) {
                elog(NOTICE, "No resampling parameters provided.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
        /* both values of alignment must be provided if any one is provided */
        else if (
                (grid_xw != NULL && grid_yw == NULL) ||
                (grid_xw == NULL && grid_yw != NULL)
        ) {
                elog(NOTICE, "Values must be provided for both X and Y when specifying the alignment.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
        /* both values of scale must be provided if any one is provided */
        else if (
                (scale_x != NULL && scale_y == NULL) ||
                (scale_x == NULL && scale_y != NULL)
        ) {
                elog(NOTICE, "Values must be provided for both X and Y when specifying the scale.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }
        /* scale and width/height provided */
        else if (
                (scale_x != NULL || scale_y != NULL) &&
                (dim_x != NULL || dim_y != NULL)
        ) {
                elog(NOTICE, "Scale X/Y and width/height are mutually exclusive.  Only provide one.  Returning original raster");
                rt_raster_destroy(raster);
                PG_RETURN_POINTER(pgraster);
        }

        /* get srses from srids */
        if (!no_srid) {
                /* source srs */
                src_srs = rtpg_getSR(src_srid);
                if (NULL == src_srs) {
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        elog(ERROR, "RASTER_GDALWarp: Input raster has unknown SRID (%d)", src_srid);
                        PG_RETURN_NULL();
                }
                POSTGIS_RT_DEBUGF(4, "src srs: %s", src_srs);

                dst_srs = rtpg_getSR(dst_srid);
                if (NULL == dst_srs) {
                        if (!no_srid) pfree(src_srs);
                        rt_raster_destroy(raster);
                        PG_FREE_IF_COPY(pgraster, 0);
                        elog(ERROR, "RASTER_GDALWarp: Target SRID (%d) is unknown", dst_srid);
                        PG_RETURN_NULL();
                }
                POSTGIS_RT_DEBUGF(4, "dst srs: %s", dst_srs);
        }

        rast = rt_raster_gdal_warp(
                raster,
                src_srs, dst_srs,
                scale_x, scale_y,
                dim_x, dim_y,
                NULL, NULL,
                grid_xw, grid_yw,
                skew_x, skew_y,
                alg, max_err);
        rt_raster_destroy(raster);
        PG_FREE_IF_COPY(pgraster, 0);
        if (!no_srid) {
                pfree(src_srs);
                pfree(dst_srs);
        }
        if (!rast) {
                elog(ERROR, "RASTER_band: Could not create transformed raster");
                PG_RETURN_NULL();
        }

        /* add target SRID */
        rt_raster_set_srid(rast, dst_srid);

        pgrast = rt_raster_serialize(rast);
        rt_raster_destroy(rast);

        if (NULL == pgrast) PG_RETURN_NULL();

        POSTGIS_RT_DEBUG(3, "RASTER_GDALWarp: done");

        SET_VARSIZE(pgrast, pgrast->size);
        PG_RETURN_POINTER(pgrast);
}

Here is the call graph for this function:

Here is the caller graph for this function: