PostGIS  3.4.0dev-r@@SVN_REVISION@@

◆ RASTER_asRaster()

Datum RASTER_asRaster ( PG_FUNCTION_ARGS  )

Definition at line 1045 of file rtpg_geometry.c.

1046 {
1047  GSERIALIZED *gser = NULL;
1048 
1049  LWGEOM *geom = NULL;
1050  rt_raster rast = NULL;
1051  rt_pgraster *pgrast = NULL;
1052 
1053  lwvarlena_t *wkb;
1054  unsigned char variant = WKB_SFSQL;
1055 
1056  double scale[2] = {0};
1057  double *scale_x = NULL;
1058  double *scale_y = NULL;
1059 
1060  int dim[2] = {0};
1061  int *dim_x = NULL;
1062  int *dim_y = NULL;
1063 
1064  ArrayType *array;
1065  Oid etype;
1066  Datum *e;
1067  bool *nulls;
1068  int16 typlen;
1069  bool typbyval;
1070  char typalign;
1071  int n = 0;
1072  int i = 0;
1073  int j = 0;
1074  int haserr = 0;
1075 
1076  text *pixeltypetext = NULL;
1077  char *pixeltype = NULL;
1078  rt_pixtype pixtype = PT_END;
1079  rt_pixtype *pixtypes = NULL;
1080  uint32_t pixtypes_len = 0;
1081 
1082  double *values = NULL;
1083  uint32_t values_len = 0;
1084 
1085  uint8_t *hasnodatas = NULL;
1086  double *nodatavals = NULL;
1087  uint32_t nodatavals_len = 0;
1088 
1089  double ulw[2] = {0};
1090  double *ul_xw = NULL;
1091  double *ul_yw = NULL;
1092 
1093  double gridw[2] = {0};
1094  double *grid_xw = NULL;
1095  double *grid_yw = NULL;
1096 
1097  double skew[2] = {0};
1098  double *skew_x = NULL;
1099  double *skew_y = NULL;
1100 
1101  char **options = NULL;
1102  int options_len = 0;
1103 
1104  uint32_t num_bands = 0;
1105 
1106  int32_t srid = SRID_UNKNOWN;
1107  char *srs = NULL;
1108 
1109  POSTGIS_RT_DEBUG(3, "RASTER_asRaster: Starting");
1110 
1111  /* based upon LWGEOM_asBinary function in postgis/lwgeom_ogc.c */
1112 
1113  /* Get the geometry */
1114  if (PG_ARGISNULL(0))
1115  PG_RETURN_NULL();
1116 
1117  gser = PG_GETARG_GSERIALIZED_P(0);
1118  geom = lwgeom_from_gserialized(gser);
1119 
1120  /* Get a 2D version of the geometry if necessary */
1121  if (lwgeom_ndims(geom) > 2) {
1122  LWGEOM *geom2d = lwgeom_force_2d(geom);
1123  lwgeom_free(geom);
1124  geom = geom2d;
1125  }
1126 
1127  /* empty geometry, return empty raster */
1128  if (lwgeom_is_empty(geom)) {
1129  POSTGIS_RT_DEBUG(3, "Input geometry is empty. Returning empty raster");
1130  lwgeom_free(geom);
1131  PG_FREE_IF_COPY(gser, 0);
1132 
1133  rast = rt_raster_new(0, 0);
1134  if (rast == NULL)
1135  PG_RETURN_NULL();
1136 
1137  pgrast = rt_raster_serialize(rast);
1138  rt_raster_destroy(rast);
1139 
1140  if (NULL == pgrast)
1141  PG_RETURN_NULL();
1142 
1143  SET_VARSIZE(pgrast, pgrast->size);
1144  PG_RETURN_POINTER(pgrast);
1145  }
1146 
1147  /* scale x */
1148  if (!PG_ARGISNULL(1)) {
1149  scale[0] = PG_GETARG_FLOAT8(1);
1150  if (FLT_NEQ(scale[0], 0.0))
1151  scale_x = &scale[0];
1152  }
1153 
1154  /* scale y */
1155  if (!PG_ARGISNULL(2)) {
1156  scale[1] = PG_GETARG_FLOAT8(2);
1157  if (FLT_NEQ(scale[1], 0.0))
1158  scale_y = &scale[1];
1159  }
1160  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: scale (x, y) = %f, %f", scale[0], scale[1]);
1161 
1162  /* width */
1163  if (!PG_ARGISNULL(3)) {
1164  dim[0] = PG_GETARG_INT32(3);
1165  if (dim[0] < 0) dim[0] = 0;
1166  if (dim[0] != 0) dim_x = &dim[0];
1167  }
1168 
1169  /* height */
1170  if (!PG_ARGISNULL(4)) {
1171  dim[1] = PG_GETARG_INT32(4);
1172  if (dim[1] < 0) dim[1] = 0;
1173  if (dim[1] != 0) dim_y = &dim[1];
1174  }
1175  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: dim (x, y) = %d, %d", dim[0], dim[1]);
1176 
1177  /* pixeltype */
1178  if (!PG_ARGISNULL(5)) {
1179  array = PG_GETARG_ARRAYTYPE_P(5);
1180  etype = ARR_ELEMTYPE(array);
1181  get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);
1182 
1183  switch (etype) {
1184  case TEXTOID:
1185  break;
1186  default:
1187 
1188  lwgeom_free(geom);
1189  PG_FREE_IF_COPY(gser, 0);
1190 
1191  elog(ERROR, "RASTER_asRaster: Invalid data type for pixeltype");
1192  PG_RETURN_NULL();
1193  break;
1194  }
1195 
1196  deconstruct_array(array, etype, typlen, typbyval, typalign, &e,
1197  &nulls, &n);
1198 
1199  if (n) {
1200  pixtypes = (rt_pixtype *) palloc(sizeof(rt_pixtype) * n);
1201  /* clean each pixeltype */
1202  for (i = 0, j = 0; i < n; i++) {
1203  if (nulls[i]) {
1204  pixtypes[j++] = PT_64BF;
1205  continue;
1206  }
1207 
1208  pixeltype = NULL;
1209  switch (etype) {
1210  case TEXTOID:
1211  pixeltypetext = (text *) DatumGetPointer(e[i]);
1212  if (NULL == pixeltypetext) break;
1213  pixeltype = text_to_cstring(pixeltypetext);
1214 
1215  /* trim string */
1216  pixeltype = rtpg_trim(pixeltype);
1217  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: pixeltype is '%s'", pixeltype);
1218  break;
1219  }
1220 
1221  if (strlen(pixeltype)) {
1222  pixtype = rt_pixtype_index_from_name(pixeltype);
1223  if (pixtype == PT_END) {
1224 
1225  pfree(pixtypes);
1226 
1227  lwgeom_free(geom);
1228  PG_FREE_IF_COPY(gser, 0);
1229 
1230  elog(ERROR, "RASTER_asRaster: Invalid pixel type provided: %s", pixeltype);
1231  PG_RETURN_NULL();
1232  }
1233 
1234  pixtypes[j] = pixtype;
1235  j++;
1236  }
1237  }
1238 
1239  if (j > 0) {
1240  /* trim allocation */
1241  pixtypes = repalloc(pixtypes, j * sizeof(rt_pixtype));
1242  pixtypes_len = j;
1243  }
1244  else {
1245  pfree(pixtypes);
1246  pixtypes = NULL;
1247  pixtypes_len = 0;
1248  }
1249  }
1250  }
1251 #if POSTGIS_DEBUG_LEVEL > 0
1252  for (uint32_t u = 0; u < pixtypes_len; u++)
1253  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: pixtypes[%u] = %u", i, pixtypes[i]);
1254 #endif
1255 
1256  /* value */
1257  if (!PG_ARGISNULL(6)) {
1258  array = PG_GETARG_ARRAYTYPE_P(6);
1259  etype = ARR_ELEMTYPE(array);
1260  get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);
1261 
1262  switch (etype) {
1263  case FLOAT4OID:
1264  case FLOAT8OID:
1265  break;
1266  default:
1267 
1268  if (pixtypes_len) pfree(pixtypes);
1269 
1270  lwgeom_free(geom);
1271  PG_FREE_IF_COPY(gser, 0);
1272 
1273  elog(ERROR, "RASTER_asRaster: Invalid data type for value");
1274  PG_RETURN_NULL();
1275  break;
1276  }
1277 
1278  deconstruct_array(array, etype, typlen, typbyval, typalign, &e,
1279  &nulls, &n);
1280 
1281  if (n) {
1282  values = (double *) palloc(sizeof(double) * n);
1283  for (i = 0, j = 0; i < n; i++) {
1284  if (nulls[i]) {
1285  values[j++] = 1;
1286  continue;
1287  }
1288 
1289  switch (etype) {
1290  case FLOAT4OID:
1291  values[j] = (double) DatumGetFloat4(e[i]);
1292  break;
1293  case FLOAT8OID:
1294  values[j] = (double) DatumGetFloat8(e[i]);
1295  break;
1296  }
1297  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: values[%d] = %f", j, values[j]);
1298 
1299  j++;
1300  }
1301 
1302  if (j > 0) {
1303  /* trim allocation */
1304  values = repalloc(values, j * sizeof(double));
1305  values_len = j;
1306  }
1307  else {
1308  pfree(values);
1309  values = NULL;
1310  values_len = 0;
1311  }
1312  }
1313  }
1314 #if POSTGIS_DEBUG_LEVEL > 0
1315  for (uint32_t u = 0; u < values_len; u++)
1316  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: values[%u] = %f", i, values[i]);
1317 #endif
1318 
1319  /* nodataval */
1320  if (!PG_ARGISNULL(7)) {
1321  array = PG_GETARG_ARRAYTYPE_P(7);
1322  etype = ARR_ELEMTYPE(array);
1323  get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);
1324 
1325  switch (etype) {
1326  case FLOAT4OID:
1327  case FLOAT8OID:
1328  break;
1329  default:
1330 
1331  if (pixtypes_len) pfree(pixtypes);
1332  if (values_len) pfree(values);
1333 
1334  lwgeom_free(geom);
1335  PG_FREE_IF_COPY(gser, 0);
1336 
1337  elog(ERROR, "RASTER_asRaster: Invalid data type for nodataval");
1338  PG_RETURN_NULL();
1339  break;
1340  }
1341 
1342  deconstruct_array(array, etype, typlen, typbyval, typalign, &e,
1343  &nulls, &n);
1344 
1345  if (n) {
1346  nodatavals = (double *) palloc(sizeof(double) * n);
1347  hasnodatas = (uint8_t *) palloc(sizeof(uint8_t) * n);
1348  for (i = 0, j = 0; i < n; i++) {
1349  if (nulls[i]) {
1350  hasnodatas[j] = 0;
1351  nodatavals[j] = 0;
1352  j++;
1353  continue;
1354  }
1355 
1356  hasnodatas[j] = 1;
1357  switch (etype) {
1358  case FLOAT4OID:
1359  nodatavals[j] = (double) DatumGetFloat4(e[i]);
1360  break;
1361  case FLOAT8OID:
1362  nodatavals[j] = (double) DatumGetFloat8(e[i]);
1363  break;
1364  }
1365  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: hasnodatas[%d] = %d", j, hasnodatas[j]);
1366  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: nodatavals[%d] = %f", j, nodatavals[j]);
1367 
1368  j++;
1369  }
1370 
1371  if (j > 0) {
1372  /* trim allocation */
1373  nodatavals = repalloc(nodatavals, j * sizeof(double));
1374  hasnodatas = repalloc(hasnodatas, j * sizeof(uint8_t));
1375  nodatavals_len = j;
1376  }
1377  else {
1378  pfree(nodatavals);
1379  pfree(hasnodatas);
1380  nodatavals = NULL;
1381  hasnodatas = NULL;
1382  nodatavals_len = 0;
1383  }
1384  }
1385  }
1386 #if POSTGIS_DEBUG_LEVEL > 0
1387  for (uint32_t u = 0; u < nodatavals_len; u++)
1388  {
1389  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: hasnodatas[%u] = %d", u, hasnodatas[u]);
1390  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: nodatavals[%u] = %f", u, nodatavals[u]);
1391  }
1392 #endif
1393 
1394  /* upperleftx */
1395  if (!PG_ARGISNULL(8)) {
1396  ulw[0] = PG_GETARG_FLOAT8(8);
1397  ul_xw = &ulw[0];
1398  }
1399 
1400  /* upperlefty */
1401  if (!PG_ARGISNULL(9)) {
1402  ulw[1] = PG_GETARG_FLOAT8(9);
1403  ul_yw = &ulw[1];
1404  }
1405  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: upperleft (x, y) = %f, %f", ulw[0], ulw[1]);
1406 
1407  /* gridx */
1408  if (!PG_ARGISNULL(10)) {
1409  gridw[0] = PG_GETARG_FLOAT8(10);
1410  grid_xw = &gridw[0];
1411  }
1412 
1413  /* gridy */
1414  if (!PG_ARGISNULL(11)) {
1415  gridw[1] = PG_GETARG_FLOAT8(11);
1416  grid_yw = &gridw[1];
1417  }
1418  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: grid (x, y) = %f, %f", gridw[0], gridw[1]);
1419 
1420  /* check dependent variables */
1421  haserr = 0;
1422  do {
1423  /* only part of scale provided */
1424  if (
1425  (scale_x == NULL && scale_y != NULL) ||
1426  (scale_x != NULL && scale_y == NULL)
1427  ) {
1428  elog(NOTICE, "Values must be provided for both X and Y of scale if one is specified");
1429  haserr = 1;
1430  break;
1431  }
1432 
1433  /* only part of dimension provided */
1434  if (
1435  (dim_x == NULL && dim_y != NULL) ||
1436  (dim_x != NULL && dim_y == NULL)
1437  ) {
1438  elog(NOTICE, "Values must be provided for both width and height if one is specified");
1439  haserr = 1;
1440  break;
1441  }
1442 
1443  /* scale and dimension provided */
1444  if (
1445  (scale_x != NULL && scale_y != NULL) &&
1446  (dim_x != NULL && dim_y != NULL)
1447  ) {
1448  elog(NOTICE, "Values provided for X and Y of scale and width and height. Using the width and height");
1449  scale_x = NULL;
1450  scale_y = NULL;
1451  break;
1452  }
1453 
1454  /* neither scale or dimension provided */
1455  if (
1456  (scale_x == NULL && scale_y == NULL) &&
1457  (dim_x == NULL && dim_y == NULL)
1458  ) {
1459  elog(NOTICE, "Values must be provided for X and Y of scale or width and height");
1460  haserr = 1;
1461  break;
1462  }
1463 
1464  /* only part of upper-left provided */
1465  if (
1466  (ul_xw == NULL && ul_yw != NULL) ||
1467  (ul_xw != NULL && ul_yw == NULL)
1468  ) {
1469  elog(NOTICE, "Values must be provided for both X and Y when specifying the upper-left corner");
1470  haserr = 1;
1471  break;
1472  }
1473 
1474  /* only part of alignment provided */
1475  if (
1476  (grid_xw == NULL && grid_yw != NULL) ||
1477  (grid_xw != NULL && grid_yw == NULL)
1478  ) {
1479  elog(NOTICE, "Values must be provided for both X and Y when specifying the alignment");
1480  haserr = 1;
1481  break;
1482  }
1483 
1484  /* upper-left and alignment provided */
1485  if (
1486  (ul_xw != NULL && ul_yw != NULL) &&
1487  (grid_xw != NULL && grid_yw != NULL)
1488  ) {
1489  elog(NOTICE, "Values provided for both X and Y of upper-left corner and alignment. Using the values of upper-left corner");
1490  grid_xw = NULL;
1491  grid_yw = NULL;
1492  break;
1493  }
1494  }
1495  while (0);
1496 
1497  if (haserr) {
1498  if (pixtypes_len) pfree(pixtypes);
1499  if (values_len) pfree(values);
1500  if (nodatavals_len) {
1501  pfree(nodatavals);
1502  pfree(hasnodatas);
1503  }
1504 
1505  lwgeom_free(geom);
1506  PG_FREE_IF_COPY(gser, 0);
1507 
1508  PG_RETURN_NULL();
1509  }
1510 
1511  /* skewx */
1512  if (!PG_ARGISNULL(12)) {
1513  skew[0] = PG_GETARG_FLOAT8(12);
1514  if (FLT_NEQ(skew[0], 0.0))
1515  skew_x = &skew[0];
1516  }
1517 
1518  /* skewy */
1519  if (!PG_ARGISNULL(13)) {
1520  skew[1] = PG_GETARG_FLOAT8(13);
1521  if (FLT_NEQ(skew[1], 0.0))
1522  skew_y = &skew[1];
1523  }
1524  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: skew (x, y) = %f, %f", skew[0], skew[1]);
1525 
1526  /* all touched */
1527  if (!PG_ARGISNULL(14) && PG_GETARG_BOOL(14) == TRUE) {
1528  if (options_len == 0) {
1529  options_len = 1;
1530  options = (char **) palloc(sizeof(char *) * options_len);
1531  }
1532  else {
1533  options_len++;
1534  options = (char **) repalloc(options, sizeof(char *) * options_len);
1535  }
1536 
1537  options[options_len - 1] = palloc(sizeof(char*) * (strlen("ALL_TOUCHED=TRUE") + 1));
1538  strcpy(options[options_len - 1], "ALL_TOUCHED=TRUE");
1539  }
1540 
1541  if (options_len) {
1542  options_len++;
1543  options = (char **) repalloc(options, sizeof(char *) * options_len);
1544  options[options_len - 1] = NULL;
1545  }
1546 
1547  /* get geometry's srid */
1548  srid = gserialized_get_srid(gser);
1549 
1550  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: srid = %d", srid);
1551  if (clamp_srid(srid) != SRID_UNKNOWN) {
1552  srs = rtpg_getSR(srid);
1553  if (NULL == srs) {
1554 
1555  if (pixtypes_len) pfree(pixtypes);
1556  if (values_len) pfree(values);
1557  if (nodatavals_len) {
1558  pfree(hasnodatas);
1559  pfree(nodatavals);
1560  }
1561  if (options_len) pfree(options);
1562 
1563  lwgeom_free(geom);
1564  PG_FREE_IF_COPY(gser, 0);
1565 
1566  elog(ERROR, "RASTER_asRaster: Could not find srtext for SRID (%d)", srid);
1567  PG_RETURN_NULL();
1568  }
1569  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: srs is %s", srs);
1570  }
1571  else
1572  srs = NULL;
1573 
1574  /* determine number of bands */
1575  /* MIN macro is from GDAL's cpl_port.h */
1576  num_bands = MIN(pixtypes_len, values_len);
1577  num_bands = MIN(num_bands, nodatavals_len);
1578  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: pixtypes_len = %d", pixtypes_len);
1579  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: values_len = %d", values_len);
1580  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: nodatavals_len = %d", nodatavals_len);
1581  POSTGIS_RT_DEBUGF(3, "RASTER_asRaster: num_bands = %d", num_bands);
1582 
1583  /* warn of imbalanced number of band elements */
1584  if (!(
1585  (pixtypes_len == values_len) &&
1586  (values_len == nodatavals_len)
1587  )) {
1588  elog(
1589  NOTICE,
1590  "Imbalanced number of values provided for pixeltype (%d), value (%d) and nodataval (%d). Using the first %d values of each parameter",
1591  pixtypes_len,
1592  values_len,
1593  nodatavals_len,
1594  num_bands
1595  );
1596  }
1597 
1598  /* get wkb of geometry */
1599  POSTGIS_RT_DEBUG(3, "RASTER_asRaster: getting wkb of geometry");
1600  wkb = lwgeom_to_wkb_varlena(geom, variant);
1601  lwgeom_free(geom);
1602  PG_FREE_IF_COPY(gser, 0);
1603 
1604  /* rasterize geometry */
1605  POSTGIS_RT_DEBUG(3, "RASTER_asRaster: rasterizing geometry");
1606  /* use nodatavals for the init parameter */
1607  rast = rt_raster_gdal_rasterize((unsigned char *)wkb->data,
1608  LWSIZE_GET(wkb->size) - LWVARHDRSZ,
1609  srs,
1610  num_bands,
1611  pixtypes,
1612  nodatavals,
1613  values,
1614  nodatavals,
1615  hasnodatas,
1616  dim_x,
1617  dim_y,
1618  scale_x,
1619  scale_y,
1620  ul_xw,
1621  ul_yw,
1622  grid_xw,
1623  grid_yw,
1624  skew_x,
1625  skew_y,
1626  options);
1627 
1628  if (pixtypes_len) pfree(pixtypes);
1629  if (values_len) pfree(values);
1630  if (nodatavals_len) {
1631  pfree(hasnodatas);
1632  pfree(nodatavals);
1633  }
1634  if (options_len) pfree(options);
1635 
1636  if (!rast) {
1637  elog(ERROR, "RASTER_asRaster: Could not rasterize geometry");
1638  PG_RETURN_NULL();
1639  }
1640 
1641  /* add target srid */
1642  rt_raster_set_srid(rast, srid);
1643 
1644  pgrast = rt_raster_serialize(rast);
1645  rt_raster_destroy(rast);
1646 
1647  if (NULL == pgrast) PG_RETURN_NULL();
1648 
1649  POSTGIS_RT_DEBUG(3, "RASTER_asRaster: done");
1650 
1651  SET_VARSIZE(pgrast, pgrast->size);
1652  PG_RETURN_POINTER(pgrast);
1653 }
variant
static uint8_t variant
Definition: cu_in_twkb.c:26
TRUE
#define TRUE
Definition: dbfopen.c:73
gserialized_get_srid
int32_t gserialized_get_srid(const GSERIALIZED *g)
Extract the SRID from the serialized form (it is packed into three bytes so this is a handy function)...
Definition: gserialized.c:126
lwgeom_from_gserialized
LWGEOM * lwgeom_from_gserialized(const GSERIALIZED *g)
Allocate a new LWGEOM from a GSERIALIZED.
Definition: gserialized.c:239
lwgeom_ndims
int lwgeom_ndims(const LWGEOM *geom)
Return the number of dimensions (2, 3, 4) in a geometry.
Definition: lwgeom.c:955
LWVARHDRSZ
#define LWVARHDRSZ
Definition: liblwgeom.h:311
lwgeom_free
void lwgeom_free(LWGEOM *geom)
Definition: lwgeom.c:1155
LWSIZE_GET
#define LWSIZE_GET(varsize)
Macro for reading the size from the GSERIALIZED size attribute.
Definition: liblwgeom.h:324
SRID_UNKNOWN
#define SRID_UNKNOWN
Unknown SRID value.
Definition: liblwgeom.h:215
lwgeom_to_wkb_varlena
lwvarlena_t * lwgeom_to_wkb_varlena(const LWGEOM *geom, uint8_t variant)
Definition: lwout_wkb.c:851
WKB_SFSQL
#define WKB_SFSQL
Definition: liblwgeom.h:2176
clamp_srid
int32_t clamp_srid(int32_t srid)
Return a valid SRID from an arbitrary integer Raises a notice if what comes out is different from wha...
Definition: lwutil.c:333
lwgeom_force_2d
LWGEOM * lwgeom_force_2d(const LWGEOM *geom)
Strip out the Z/M components of an LWGEOM.
Definition: lwgeom.c:793
FLT_NEQ
#define FLT_NEQ(x, y)
Definition: librtcore.h:2386
rt_pixtype_index_from_name
rt_pixtype rt_pixtype_index_from_name(const char *pixname)
Definition: rt_pixel.c:80
rt_raster_destroy
void rt_raster_destroy(rt_raster raster)
Release memory associated to a raster.
Definition: rt_raster.c:86
rt_pixtype
rt_pixtype
Definition: librtcore.h:187
PT_END
@ PT_END
Definition: librtcore.h:199
PT_64BF
@ PT_64BF
Definition: librtcore.h:198
rt_raster_new
rt_raster rt_raster_new(uint32_t width, uint32_t height)
Construct a raster with given dimensions.
Definition: rt_raster.c:52
rt_raster_serialize
void * rt_raster_serialize(rt_raster raster)
Return this raster in serialized form.
Definition: rt_serialize.c:521
rt_raster_gdal_rasterize
rt_raster rt_raster_gdal_rasterize(const unsigned char *wkb, uint32_t wkb_len, const char *srs, uint32_t num_bands, rt_pixtype *pixtype, double *init, double *value, double *nodata, uint8_t *hasnodata, int *width, int *height, double *scale_x, double *scale_y, double *ul_xw, double *ul_yw, double *grid_xw, double *grid_yw, double *skew_x, double *skew_y, char **options)
Return a raster of the provided geometry.
Definition: rt_raster.c:2618
rt_raster_set_srid
void rt_raster_set_srid(rt_raster raster, int32_t srid)
Set raster's SRID.
Definition: rt_raster.c:367
lwgeom_is_empty
static int lwgeom_is_empty(const LWGEOM *geom)
Return true or false depending on whether a geometry is an "empty" geometry (no vertices members)
Definition: lwinline.h:203
rtpg_getSR
char * rtpg_getSR(int32_t srid)
Definition: rtpg_internal.c:282
rtpg_trim
char * rtpg_trim(const char *input)
Definition: rtpg_internal.c:226
POSTGIS_RT_DEBUG
#define POSTGIS_RT_DEBUG(level, msg)
Definition: rtpostgis.h:65
POSTGIS_RT_DEBUGF
#define POSTGIS_RT_DEBUGF(level, msg,...)
Definition: rtpostgis.h:69
MIN
#define MIN(a, b)
Definition: shpopen.c:64
lwvarlena_t::size
uint32_t size
Definition: liblwgeom.h:307
lwvarlena_t::data
char data[]
Definition: liblwgeom.h:308
lwvarlena_t
Definition: liblwgeom.h:306
rt_raster_serialized_t::size
uint32_t size
Definition: librtcore.h:2405
rt_raster_serialized_t
Struct definitions.
Definition: librtcore.h:2403
rt_raster_t
Definition: librtcore.h:2437

References clamp_srid(), lwvarlena_t::data, FLT_NEQ, gserialized_get_srid(), lwgeom_force_2d(), lwgeom_free(), lwgeom_from_gserialized(), lwgeom_is_empty(), lwgeom_ndims(), lwgeom_to_wkb_varlena(), LWSIZE_GET, LWVARHDRSZ, MIN, POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, PT_64BF, PT_END, rtpixdump::rast, rt_pixtype_index_from_name(), rt_raster_destroy(), rt_raster_gdal_rasterize(), rt_raster_new(), rt_raster_serialize(), rt_raster_set_srid(), rtpg_getSR(), rtpg_trim(), lwvarlena_t::size, rt_raster_serialized_t::size, rt_raster_serialized_t::srid, SRID_UNKNOWN, TRUE, variant, and WKB_SFSQL.

Here is the call graph for this function: