PG_RETURN_DATUM(result);
}
-/*
- TODO: continue working on adding PG_FREE_IF_COPY from HERE
-*/
-
/**
* See if two rasters intersect
*/
Datum RASTER_intersects(PG_FUNCTION_ARGS)
{
const int set_count = 2;
- rt_pgraster *pgrast;
+ rt_pgraster *pgrast[2];
+ int pgrastpos[2] = {-1, -1};
rt_raster rast[2] = {NULL};
uint32_t bandindex[2] = {0};
uint32_t hasbandindex[2] = {0};
for (i = 0, j = 0; i < set_count; i++) {
/* pgrast is null, return null */
if (PG_ARGISNULL(j)) {
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < i; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
- pgrast = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(j));
+ pgrast[i] = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(j));
+ pgrastpos[i] = j;
j++;
/* raster */
- rast[i] = rt_raster_deserialize(pgrast, FALSE);
+ rast[i] = rt_raster_deserialize(pgrast[i], FALSE);
if (!rast[i]) {
elog(ERROR, "RASTER_intersects: Could not deserialize the %s raster", i < 1 ? "first" : "second");
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k <= i; k++) {
+ if (k < i)
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
numBands = rt_raster_get_num_bands(rast[i]);
if (numBands < 1) {
elog(NOTICE, "The %s raster provided has no bands", i < 1 ? "first" : "second");
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ if (i > 0) i++;
+ for (k = 0; k < i; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
bandindex[i] = PG_GETARG_INT32(j);
if (bandindex[i] < 1 || bandindex[i] > numBands) {
elog(NOTICE, "Invalid band index (must use 1-based) for the %s raster. Returning NULL", i < 1 ? "first" : "second");
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ if (i > 0) i++;
+ for (k = 0; k < i; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
hasbandindex[i] = 1;
(!hasbandindex[0] && hasbandindex[1])
) {
elog(NOTICE, "Missing band index. Band indices must be provided for both rasters if any one is provided");
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
/* SRID must match */
if (rt_raster_get_srid(rast[0]) != rt_raster_get_srid(rast[1])) {
elog(ERROR, "The two rasters provided have different SRIDs");
- for (k = 0; k < set_count; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
if (rtn != 2) {
if (rtn != 1) {
- for (k = 0; k < set_count; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_BOOL(0);
}
/* band isn't specified */
else if (!hasbandindex[0]) {
- for (k = 0; k < set_count; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_BOOL(1);
}
}
rast[1], (hasbandindex[1] ? bandindex[1] - 1 : -1),
&intersects
);
- for (k = 0; k < set_count; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
if (!rtn) {
elog(ERROR, "RASTER_intersects: Unable to test for intersection on the two rasters");
Datum RASTER_sameAlignment(PG_FUNCTION_ARGS)
{
const int set_count = 2;
- rt_pgraster *pgrast;
+ rt_pgraster *pgrast[2];
+ int pgrastpos[2] = {-1, -1};
rt_raster rast[2] = {NULL};
uint32_t i;
for (i = 0, j = 0; i < set_count; i++) {
/* pgrast is null, return null */
if (PG_ARGISNULL(j)) {
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < i; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
- pgrast = (rt_pgraster *) PG_DETOAST_DATUM_SLICE(PG_GETARG_DATUM(j), 0, sizeof(struct rt_raster_serialized_t));
+ pgrast[i] = (rt_pgraster *) PG_DETOAST_DATUM_SLICE(PG_GETARG_DATUM(j), 0, sizeof(struct rt_raster_serialized_t));
+ pgrastpos[i] = j;
j++;
/* raster */
- rast[i] = rt_raster_deserialize(pgrast, TRUE);
+ rast[i] = rt_raster_deserialize(pgrast[i], TRUE);
if (!rast[i]) {
elog(ERROR, "RASTER_sameAlignment: Could not deserialize the %s raster", i < 1 ? "first" : "second");
- for (k = 0; k < i; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k <= i; k++) {
+ if (k < i)
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
}
}
if (err) {
- for (k = 0; k < set_count; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_BOOL(0);
}
rast[1],
&aligned
);
- for (k = 0; k < set_count; k++) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
if (!rtn) {
elog(ERROR, "RASTER_sameAlignment: Unable to test for alignment on the two rasters");
PG_RETURN_BOOL(aligned);
}
+/*
+ TODO: continue working on adding PG_FREE_IF_COPY from HERE
+*/
+
/**
* Two raster MapAlgebra
*/
Datum RASTER_mapAlgebra2(PG_FUNCTION_ARGS)
{
const int set_count = 2;
- rt_pgraster *pgrast;
+ rt_pgraster *pgrast[2];
+ int pgrastpos[2] = {-1, -1};
+ rt_pgraster *pgrtn;
rt_raster rast[2] = {NULL};
int _isempty[2] = {0};
uint32_t bandindex[2] = {0};
for (i = 0, j = 0; i < set_count; i++) {
if (!PG_ARGISNULL(j)) {
- pgrast = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(j));
+ pgrast[i] = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(j));
+ pgrastpos[i] = j;
j++;
/* raster */
- rast[i] = rt_raster_deserialize(pgrast, FALSE);
+ rast[i] = rt_raster_deserialize(pgrast[i], FALSE);
if (!rast[i]) {
elog(ERROR, "RASTER_mapAlgebra2: Could not deserialize the %s raster", i < 1 ? "first" : "second");
- for (k = 0; k < i; k++) {
- if (rast[k] != NULL) rt_raster_destroy(rast[k]);
+ for (k = 0; k <= i; k++) {
+ if (k < i && rast[k] != NULL)
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
}
PG_RETURN_NULL();
}
/* both rasters are NULL */
if (rast[0] == NULL && rast[1] == NULL) {
elog(NOTICE, "The two rasters provided are NULL. Returning NULL");
+ for (k = 0; k < set_count; k++) {
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
raster = rt_raster_new(0, 0);
if (raster == NULL) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to create empty raster");
- for (k = 0; k < i; k++) {
- if (rast[k] != NULL) rt_raster_destroy(rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (rast[k] != NULL)
+ rt_raster_destroy(rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
}
PG_RETURN_NULL();
}
rt_raster_set_scale(raster, 0, 0);
- pgrast = rt_raster_serialize(raster);
+ pgrtn = rt_raster_serialize(raster);
rt_raster_destroy(raster);
- if (!pgrast) PG_RETURN_NULL();
+ if (!pgrtn)
+ PG_RETURN_NULL();
- SET_VARSIZE(pgrast, pgrast->size);
- PG_RETURN_POINTER(pgrast);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/* replace the empty or NULL raster with one matching the other */
if (_rast[i] == NULL) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to create nodata raster");
rt_raster_destroy(_rast[j]);
+ for (k = 0; k < set_count; k++) {
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
rt_raster_set_srid(_rast[i], rt_raster_get_srid(_rast[j]));
/* SRID must match */
if (rt_raster_get_srid(_rast[0]) != rt_raster_get_srid(_rast[1])) {
elog(NOTICE, "The two rasters provided have different SRIDs. Returning NULL");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
/* same alignment */
if (!rt_raster_same_alignment(_rast[0], _rast[1], &aligned)) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to test for alignment on the two rasters");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
if (!aligned) {
elog(NOTICE, "The two rasters provided do not have the same alignment. Returning NULL");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
pixtype = rt_pixtype_index_from_name(pixtypename);
if (pixtype == PT_END ) {
elog(ERROR, "RASTER_mapAlgebra2: Invalid pixel type: %s", pixtypename);
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
}
);
if (!err) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to get output raster of correct extent");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
)
) {
elog(NOTICE, "The %s raster is NULL. Returning NULL", (i != 1 ? "FIRST" : "SECOND"));
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
(i != 1 ? "FIRST" : "SECOND"), bandindex[i]
);
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
- pgrast = rt_raster_serialize(raster);
+ pgrtn = rt_raster_serialize(raster);
rt_raster_destroy(raster);
- if (!pgrast) PG_RETURN_NULL();
+ if (!pgrtn) PG_RETURN_NULL();
- SET_VARSIZE(pgrast, pgrast->size);
- PG_RETURN_POINTER(pgrast);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
break;
case ET_UNION:
raster = rt_raster_new(0, 0);
if (raster == NULL) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to create no band raster");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
PG_RETURN_NULL();
}
+
rt_raster_set_scale(raster, 0, 0);
rt_raster_set_srid(raster, rt_raster_get_srid(_rast[0]));
}
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
- pgrast = rt_raster_serialize(raster);
+ pgrtn = rt_raster_serialize(raster);
rt_raster_destroy(raster);
- if (!pgrast) PG_RETURN_NULL();
+ if (!pgrtn) PG_RETURN_NULL();
- SET_VARSIZE(pgrast, pgrast->size);
- PG_RETURN_POINTER(pgrast);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
break;
}
) {
elog(NOTICE, "The two rasters provided do not have the respectively specified band indices. Returning no band raster of correct extent");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
- pgrast = rt_raster_serialize(raster);
+ pgrtn = rt_raster_serialize(raster);
rt_raster_destroy(raster);
- if (!pgrast) PG_RETURN_NULL();
+ if (!pgrtn) PG_RETURN_NULL();
- SET_VARSIZE(pgrast, pgrast->size);
- PG_RETURN_POINTER(pgrast);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/* get bands */
bandindex[i],
(i < 1 ? "FIRST" : "SECOND")
);
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
0
) < 0) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to add new band to output raster");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
band = rt_raster_get_band(raster, 0);
if (band == NULL) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to get newly added band of output raster");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
/* connect SPI */
if (SPI_connect() != SPI_OK_CONNECT) {
elog(ERROR, "RASTER_mapAlgebra2: Unable to connect to the SPI manager");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
*/
if (err) {
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
default:
elog(ERROR, "RASTER_mapAlgebra2: Invalid data type for expression or userfunction");
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
break;
SPI_finish();
}
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
for (k = 0; k < spi_count; k++) SPI_freeplan(spi_plan[k]);
SPI_finish();
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
SPI_finish();
}
- for (k = 0; k < set_count; k++) rt_raster_destroy(_rast[k]);
+ for (k = 0; k < set_count; k++) {
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
+ }
rt_raster_destroy(raster);
PG_RETURN_NULL();
}
for (k = 0; k < set_count; k++) {
- if (_rast[k] != NULL) rt_raster_destroy(_rast[k]);
+ if (_rast[k] != NULL)
+ rt_raster_destroy(_rast[k]);
+ PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
}
- pgrast = rt_raster_serialize(raster);
+ pgrtn = rt_raster_serialize(raster);
rt_raster_destroy(raster);
- if (!pgrast) PG_RETURN_NULL();
+ if (!pgrtn) PG_RETURN_NULL();
POSTGIS_RT_DEBUG(3, "Finished RASTER_mapAlgebra2");
- SET_VARSIZE(pgrast, pgrast->size);
- PG_RETURN_POINTER(pgrast);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/**
Datum RASTER_mapAlgebraFctNgb(PG_FUNCTION_ARGS)
{
rt_pgraster *pgraster = NULL;
+ rt_pgraster *pgrtn = NULL;
rt_raster raster = NULL;
rt_raster newrast = NULL;
rt_band band = NULL;
if (NULL == raster)
{
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not deserialize raster");
+ PG_FREE_IF_COPY(pgraster, 0);
PG_RETURN_NULL();
}
if ( NULL == newrast ) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not create a new raster. "
"Returning NULL");
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
PG_RETURN_NULL();
}
{
elog(NOTICE, "Raster is empty. Returning an empty raster");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraFctNgb: Getting raster band %d...", nband);
elog(NOTICE, "Raster does not have the required band. Returning a raster "
"without a band");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/* Get the raster band */
elog(NOTICE, "Could not get the required band. Returning a raster "
"without a band");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/*
elog(ERROR, "RASTER_mapAlgebraFctNgb: Invalid pixeltype. Returning NULL");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
elog(ERROR, "RASTER_mapAlgebraFctNgb: Required function is missing. Returning NULL");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
elog(ERROR, "RASTER_mapAlgebraFctNgb: Got invalid function object id. Returning NULL");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
elog(ERROR, "RASTER_mapAlgebraFctNgb: Function provided must return double precision not resultset. Returning NULL");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
elog(ERROR, "RASTER_mapAlgebraFctNgb: Function does not have three input parameters. Returning NULL");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
elog(ERROR, "RASTER_mapAlgebraFctNgb: Strict callback functions cannot have null parameters. Returning NULL");
rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
rt_raster_generate_new_band(newrast, newpixeltype,
newinitialvalue, TRUE, newnodatavalue, 0);
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
+
/* Serialize created raster */
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
- /* Free memory */
- rt_raster_destroy(raster);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
elog(NOTICE, "Could not modify band for new raster. Returning new "
"raster with the original band");
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
+
/* Serialize created raster */
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
- rt_raster_destroy(raster);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/* Get the width of the neighborhood */
elog(NOTICE, "Neighborhood width is NULL or <= 0. Returning new "
"raster with the original band");
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
+
/* Serialize created raster */
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
- rt_raster_destroy(raster);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
ngbwidth = PG_GETARG_INT32(3);
elog(NOTICE, "Neighborhood height is NULL or <= 0. Returning new "
"raster with the original band");
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
+
/* Serialize created raster */
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
- rt_raster_destroy(raster);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
ngbheight = PG_GETARG_INT32(4);
pfree(txtCallbackParam);
pfree(strFromText);
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
+
/* Serialize created raster */
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
elog(ERROR, "RASTER_mapAlgebraFctNgb: Could not serialize raster. "
"Returning NULL");
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
- rt_raster_destroy(raster);
- rt_raster_destroy(newrast);
-
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
}
else if (strcmp(strFromText, "NULL") == 0) {
pfree(strFromText);
pfree(txtCallbackParam);
+ rt_raster_destroy(raster);
+ PG_FREE_IF_COPY(pgraster, 0);
+
/* The newrast band has been modified */
POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraFctNgb: raster modified, serializing it.");
/* Serialize created raster */
- pgraster = rt_raster_serialize(newrast);
- if (NULL == pgraster) {
+ pgrtn = rt_raster_serialize(newrast);
+ rt_raster_destroy(newrast);
+ if (NULL == pgrtn) {
rt_raster_destroy(raster);
rt_raster_destroy(newrast);
PG_RETURN_NULL();
}
- SET_VARSIZE(pgraster, pgraster->size);
-
POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraFctNgb: raster serialized");
-
- rt_raster_destroy(raster);
- rt_raster_destroy(newrast);
-
POSTGIS_RT_DEBUG(4, "RASTER_mapAlgebraFctNgb: returning raster");
- PG_RETURN_POINTER(pgraster);
+ SET_VARSIZE(pgrtn, pgrtn->size);
+ PG_RETURN_POINTER(pgrtn);
}
/* ---------------------------------------------------------------- */
projects / postgis / commitdiff