PostGIS  3.1.6dev-r@@SVN_REVISION@@

◆ RASTER_mapAlgebraExpr()

Datum RASTER_mapAlgebraExpr ( PG_FUNCTION_ARGS  )

Create a new empty raster with having the same georeference as the provided raster

If this new raster is empty (width = 0 OR height = 0) then there is nothing to compute and we return it right now

Check if the raster has the required band. Otherwise, return a raster without band

We set the initial value of the future band to nodata value. If nodata value is null, then the raster will be initialized to rt_band_get_min_value but all the values should be recomputed anyway

Set the new pixeltype

Optimization: If a nodataval is provided, use it for newinitialvalue. Then, we can initialize the raster with this value and skip the computation of nodata values one by one in the main computing loop

Optimization: If the raster is only filled with nodata values return right now a raster filled with the newinitialvalue TODO: Call rt_band_check_isnodata instead?

Optimization: If expression resume to 'RAST' and hasnodataval is zero, we can just return the band from the original raster

Optimization: If expression resume to a constant (it does not contain [rast)

Compute the new value, set it and we will return after creating the new raster

Create the raster receiving all the computed values. Initialize it to the new initial value

Optimization: If expression is NULL, or all the pixels could be set in one step, return the initialized raster now

We compute a value only for the withdata value pixel since the nodata value has already been set by the first optimization

Definition at line 4480 of file rtpg_mapalgebra.c.

4481 {
4482  rt_pgraster *pgraster = NULL;
4483  rt_pgraster *pgrtn = NULL;
4484  rt_raster raster = NULL;
4485  rt_raster newrast = NULL;
4486  rt_band band = NULL;
4487  rt_band newband = NULL;
4488  int x, y, nband, width, height;
4489  double r;
4490  double newnodatavalue = 0.0;
4491  double newinitialvalue = 0.0;
4492  double newval = 0.0;
4493  char *newexpr = NULL;
4494  char *initexpr = NULL;
4495  char *expression = NULL;
4496  int hasnodataval = 0;
4497  double nodataval = 0.;
4498  rt_pixtype newpixeltype;
4499  int skipcomputation = 0;
4500  int len = 0;
4501  const int argkwcount = 3;
4502  enum KEYWORDS { kVAL=0, kX=1, kY=2 };
4503  char *argkw[] = {"[rast]", "[rast.x]", "[rast.y]"};
4504  Oid argkwtypes[] = { FLOAT8OID, INT4OID, INT4OID };
4505  int argcount = 0;
4506  Oid argtype[] = { FLOAT8OID, INT4OID, INT4OID };
4507  uint8_t argpos[3] = {0};
4508  char place[12];
4509  int idx = 0;
4510  int ret = -1;
4511  TupleDesc tupdesc;
4512  SPIPlanPtr spi_plan = NULL;
4513  SPITupleTable * tuptable = NULL;
4514  HeapTuple tuple;
4515  char * strFromText = NULL;
4516  Datum *values = NULL;
4517  Datum datum = (Datum)NULL;
4518  char *nulls = NULL;
4519  bool isnull = FALSE;
4520  int i = 0;
4521  int j = 0;
4522 
4523  POSTGIS_RT_DEBUG(2, "RASTER_mapAlgebraExpr: Starting...");
4524 
4525  /* Check raster */
4526  if (PG_ARGISNULL(0)) {
4527  elog(NOTICE, "Raster is NULL. Returning NULL");
4528  PG_RETURN_NULL();
4529  }
4530 
4531 
4532  /* Deserialize raster */
4533  pgraster = (rt_pgraster *)PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
4534  raster = rt_raster_deserialize(pgraster, FALSE);
4535  if (NULL == raster) {
4536  PG_FREE_IF_COPY(pgraster, 0);
4537  elog(ERROR, "RASTER_mapAlgebraExpr: Could not deserialize raster");
4538  PG_RETURN_NULL();
4539  }
4540 
4541  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: Getting arguments...");
4542 
4543  if (PG_ARGISNULL(1))
4544  nband = 1;
4545  else
4546  nband = PG_GETARG_INT32(1);
4547 
4548  if (nband < 1)
4549  nband = 1;
4550 
4551 
4552  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: Creating new empty raster...");
4553 
4558  width = rt_raster_get_width(raster);
4559  height = rt_raster_get_height(raster);
4560 
4561  newrast = rt_raster_new(width, height);
4562 
4563  if ( NULL == newrast ) {
4564  PG_FREE_IF_COPY(pgraster, 0);
4565  elog(ERROR, "RASTER_mapAlgebraExpr: Could not create a new raster");
4566  PG_RETURN_NULL();
4567  }
4568 
4569  rt_raster_set_scale(newrast,
4572 
4573  rt_raster_set_offsets(newrast,
4576 
4577  rt_raster_set_skews(newrast,
4580 
4582 
4583 
4588  if (rt_raster_is_empty(newrast))
4589  {
4590  elog(NOTICE, "Raster is empty. Returning an empty raster");
4592  PG_FREE_IF_COPY(pgraster, 0);
4593 
4594  pgrtn = rt_raster_serialize(newrast);
4595  rt_raster_destroy(newrast);
4596  if (NULL == pgrtn) {
4597 
4598  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4599  PG_RETURN_NULL();
4600  }
4601 
4602  SET_VARSIZE(pgrtn, pgrtn->size);
4603  PG_RETURN_POINTER(pgrtn);
4604  }
4605 
4606 
4607  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: Getting raster band %d...", nband);
4608 
4613  if (!rt_raster_has_band(raster, nband - 1)) {
4614  elog(NOTICE, "Raster does not have the required band. Returning a raster "
4615  "without a band");
4617  PG_FREE_IF_COPY(pgraster, 0);
4618 
4619  pgrtn = rt_raster_serialize(newrast);
4620  rt_raster_destroy(newrast);
4621  if (NULL == pgrtn) {
4622  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4623  PG_RETURN_NULL();
4624  }
4625 
4626  SET_VARSIZE(pgrtn, pgrtn->size);
4627  PG_RETURN_POINTER(pgrtn);
4628  }
4629 
4630  /* Get the raster band */
4632  if ( NULL == band ) {
4633  elog(NOTICE, "Could not get the required band. Returning a raster "
4634  "without a band");
4636  PG_FREE_IF_COPY(pgraster, 0);
4637 
4638  pgrtn = rt_raster_serialize(newrast);
4639  rt_raster_destroy(newrast);
4640  if (NULL == pgrtn) {
4641  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4642  PG_RETURN_NULL();
4643  }
4644 
4645  SET_VARSIZE(pgrtn, pgrtn->size);
4646  PG_RETURN_POINTER(pgrtn);
4647  }
4648 
4649  /*
4650  * Get NODATA value
4651  */
4652  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: Getting NODATA value for band...");
4653 
4655  rt_band_get_nodata(band, &newnodatavalue);
4656  }
4657 
4658  else {
4659  newnodatavalue = rt_band_get_min_value(band);
4660  }
4661 
4662  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: NODATA value for band: = %f",
4663  newnodatavalue);
4664 
4670  newinitialvalue = newnodatavalue;
4671 
4675  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: Setting pixeltype...");
4676 
4677  if (PG_ARGISNULL(2)) {
4678  newpixeltype = rt_band_get_pixtype(band);
4679  }
4680 
4681  else {
4682  strFromText = text_to_cstring(PG_GETARG_TEXT_P(2));
4683  newpixeltype = rt_pixtype_index_from_name(strFromText);
4684  pfree(strFromText);
4685  if (newpixeltype == PT_END)
4686  newpixeltype = rt_band_get_pixtype(band);
4687  }
4688 
4689  if (newpixeltype == PT_END) {
4690  PG_FREE_IF_COPY(pgraster, 0);
4691  elog(ERROR, "RASTER_mapAlgebraExpr: Invalid pixeltype");
4692  PG_RETURN_NULL();
4693  }
4694 
4695  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: Pixeltype set to %s",
4696  rt_pixtype_name(newpixeltype));
4697 
4698 
4699  /* Construct expression for raster values */
4700  if (!PG_ARGISNULL(3)) {
4701  expression = text_to_cstring(PG_GETARG_TEXT_P(3));
4702  len = strlen("SELECT (") + strlen(expression) + strlen(")::double precision");
4703  initexpr = (char *)palloc(len + 1);
4704 
4705  memcpy(initexpr, "SELECT (", strlen("SELECT ("));
4706  memcpy(initexpr + strlen("SELECT ("), expression, strlen(expression));
4707  memcpy(initexpr + strlen("SELECT (") + strlen(expression), ")::double precision", strlen(")::double precision"));
4708  initexpr[len] = '\0';
4709 
4710  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: Expression is %s", initexpr);
4711 
4712  /* We don't need this memory */
4713  /*
4714  pfree(expression);
4715  expression = NULL;
4716  */
4717  }
4718 
4719 
4720 
4726  if (!PG_ARGISNULL(4)) {
4727  hasnodataval = 1;
4728  nodataval = PG_GETARG_FLOAT8(4);
4729  newinitialvalue = nodataval;
4730 
4731  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: new initial value = %f",
4732  newinitialvalue);
4733  }
4734  else
4735  hasnodataval = 0;
4736 
4737 
4738 
4745 
4746  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: Band is a nodata band, returning "
4747  "a raster filled with nodata");
4748 
4749  ret = rt_raster_generate_new_band(newrast, newpixeltype,
4750  newinitialvalue, TRUE, newnodatavalue, 0);
4751 
4752  /* Free memory */
4753  if (initexpr)
4754  pfree(initexpr);
4756  PG_FREE_IF_COPY(pgraster, 0);
4757 
4758  /* Serialize created raster */
4759  pgrtn = rt_raster_serialize(newrast);
4760  rt_raster_destroy(newrast);
4761  if (NULL == pgrtn) {
4762  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4763  PG_RETURN_NULL();
4764  }
4765 
4766  SET_VARSIZE(pgrtn, pgrtn->size);
4767  PG_RETURN_POINTER(pgrtn);
4768  }
4769 
4770 
4775  if (initexpr != NULL && ( !strcmp(initexpr, "SELECT [rast]") || !strcmp(initexpr, "SELECT [rast.val]") ) && !hasnodataval) {
4776 
4777  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: Expression resumes to RAST. "
4778  "Returning raster with band %d from original raster", nband);
4779 
4780  POSTGIS_RT_DEBUGF(4, "RASTER_mapAlgebraExpr: New raster has %d bands",
4781  rt_raster_get_num_bands(newrast));
4782 
4783  rt_raster_copy_band(newrast, raster, nband - 1, 0);
4784 
4785  POSTGIS_RT_DEBUGF(4, "RASTER_mapAlgebraExpr: New raster now has %d bands",
4786  rt_raster_get_num_bands(newrast));
4787 
4788  pfree(initexpr);
4790  PG_FREE_IF_COPY(pgraster, 0);
4791 
4792  /* Serialize created raster */
4793  pgrtn = rt_raster_serialize(newrast);
4794  rt_raster_destroy(newrast);
4795  if (NULL == pgrtn) {
4796  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4797  PG_RETURN_NULL();
4798  }
4799 
4800  SET_VARSIZE(pgrtn, pgrtn->size);
4801  PG_RETURN_POINTER(pgrtn);
4802  }
4803 
4808  if (initexpr != NULL && strstr(initexpr, "[rast") == NULL) {
4809  ret = SPI_connect();
4810  if (ret != SPI_OK_CONNECT) {
4811  PG_FREE_IF_COPY(pgraster, 0);
4812  elog(ERROR, "RASTER_mapAlgebraExpr: Could not connect to the SPI manager");
4813  PG_RETURN_NULL();
4814  };
4815 
4816  /* Execute the expresion into newval */
4817  ret = SPI_execute(initexpr, FALSE, 0);
4818 
4819  if (ret != SPI_OK_SELECT || SPI_tuptable == NULL || SPI_processed != 1) {
4820 
4821  /* Free memory allocated out of the current context */
4822  if (SPI_tuptable)
4823  SPI_freetuptable(tuptable);
4824  PG_FREE_IF_COPY(pgraster, 0);
4825 
4826  SPI_finish();
4827  elog(ERROR, "RASTER_mapAlgebraExpr: Invalid construction for expression");
4828  PG_RETURN_NULL();
4829  }
4830 
4831  tupdesc = SPI_tuptable->tupdesc;
4832  tuptable = SPI_tuptable;
4833 
4834  tuple = tuptable->vals[0];
4835  newexpr = SPI_getvalue(tuple, tupdesc, 1);
4836  if ( ! newexpr ) {
4837  POSTGIS_RT_DEBUG(3, "Constant expression evaluated to NULL, keeping initvalue");
4838  newval = newinitialvalue;
4839  } else {
4840  newval = atof(newexpr);
4841  }
4842 
4843  SPI_freetuptable(tuptable);
4844 
4845  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: New raster value = %f",
4846  newval);
4847 
4848  SPI_finish();
4849 
4850  skipcomputation = 1;
4851 
4856  if (!hasnodataval) {
4857  newinitialvalue = newval;
4858  skipcomputation = 2;
4859  }
4860 
4861  /* Return the new raster as it will be before computing pixel by pixel */
4862  else if (FLT_NEQ(newval, newinitialvalue)) {
4863  skipcomputation = 2;
4864  }
4865  }
4866 
4871  ret = rt_raster_generate_new_band(newrast, newpixeltype,
4872  newinitialvalue, TRUE, newnodatavalue, 0);
4873 
4878  /*if (initexpr == NULL || skipcomputation == 2) {*/
4879  if (expression == NULL || skipcomputation == 2) {
4880 
4881  /* Free memory */
4882  if (initexpr)
4883  pfree(initexpr);
4885  PG_FREE_IF_COPY(pgraster, 0);
4886 
4887  /* Serialize created raster */
4888  pgrtn = rt_raster_serialize(newrast);
4889  rt_raster_destroy(newrast);
4890  if (NULL == pgrtn) {
4891  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4892  PG_RETURN_NULL();
4893  }
4894 
4895  SET_VARSIZE(pgrtn, pgrtn->size);
4896  PG_RETURN_POINTER(pgrtn);
4897  }
4898 
4899  RASTER_DEBUG(3, "RASTER_mapAlgebraExpr: Creating new raster band...");
4900 
4901  /* Get the new raster band */
4902  newband = rt_raster_get_band(newrast, 0);
4903  if ( NULL == newband ) {
4904  elog(NOTICE, "Could not modify band for new raster. Returning new "
4905  "raster with the original band");
4906 
4907  if (initexpr)
4908  pfree(initexpr);
4910  PG_FREE_IF_COPY(pgraster, 0);
4911 
4912  /* Serialize created raster */
4913  pgrtn = rt_raster_serialize(newrast);
4914  rt_raster_destroy(newrast);
4915  if (NULL == pgrtn) {
4916  elog(ERROR, "RASTER_mapAlgebraExpr: Could not serialize raster");
4917  PG_RETURN_NULL();
4918  }
4919 
4920  SET_VARSIZE(pgrtn, pgrtn->size);
4921  PG_RETURN_POINTER(pgrtn);
4922  }
4923 
4924  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: Main computing loop (%d x %d)",
4925  width, height);
4926 
4927  if (initexpr != NULL) {
4928  /* Convert [rast.val] to [rast] */
4929  newexpr = rtpg_strreplace(initexpr, "[rast.val]", "[rast]", NULL);
4930  pfree(initexpr); initexpr=newexpr;
4931 
4932  sprintf(place,"$1");
4933  for (i = 0, j = 1; i < argkwcount; i++) {
4934  len = 0;
4935  newexpr = rtpg_strreplace(initexpr, argkw[i], place, &len);
4936  pfree(initexpr); initexpr=newexpr;
4937  if (len > 0) {
4938  argtype[argcount] = argkwtypes[i];
4939  argcount++;
4940  argpos[i] = j++;
4941 
4942  sprintf(place, "$%d", j);
4943  }
4944  else {
4945  argpos[i] = 0;
4946  }
4947  }
4948 
4949  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: initexpr = %s", initexpr);
4950 
4951  /* define values */
4952  values = (Datum *) palloc(sizeof(Datum) * argcount);
4953  if (values == NULL) {
4954 
4955  SPI_finish();
4956 
4958  PG_FREE_IF_COPY(pgraster, 0);
4959  rt_raster_destroy(newrast);
4960 
4961  elog(ERROR, "RASTER_mapAlgebraExpr: Could not allocate memory for value parameters of prepared statement");
4962  PG_RETURN_NULL();
4963  }
4964 
4965  /* define nulls */
4966  nulls = (char *)palloc(argcount);
4967  if (nulls == NULL) {
4968 
4969  SPI_finish();
4970 
4972  PG_FREE_IF_COPY(pgraster, 0);
4973  rt_raster_destroy(newrast);
4974 
4975  elog(ERROR, "RASTER_mapAlgebraExpr: Could not allocate memory for null parameters of prepared statement");
4976  PG_RETURN_NULL();
4977  }
4978 
4979  /* Connect to SPI and prepare the expression */
4980  ret = SPI_connect();
4981  if (ret != SPI_OK_CONNECT) {
4982 
4983  if (initexpr)
4984  pfree(initexpr);
4986  PG_FREE_IF_COPY(pgraster, 0);
4987  rt_raster_destroy(newrast);
4988 
4989  elog(ERROR, "RASTER_mapAlgebraExpr: Could not connect to the SPI manager");
4990  PG_RETURN_NULL();
4991  };
4992 
4993  /* Type of all arguments is FLOAT8OID */
4994  spi_plan = SPI_prepare(initexpr, argcount, argtype);
4995 
4996  if (spi_plan == NULL) {
4997 
4999  PG_FREE_IF_COPY(pgraster, 0);
5000  rt_raster_destroy(newrast);
5001 
5002  SPI_finish();
5003 
5004  pfree(initexpr);
5005 
5006  elog(ERROR, "RASTER_mapAlgebraExpr: Could not prepare expression");
5007  PG_RETURN_NULL();
5008  }
5009  }
5010 
5011  for (x = 0; x < width; x++) {
5012  for(y = 0; y < height; y++) {
5013  ret = rt_band_get_pixel(band, x, y, &r, NULL);
5014 
5019  if (ret == ES_NONE && FLT_NEQ(r, newnodatavalue)) {
5020  if (skipcomputation == 0) {
5021  if (initexpr != NULL) {
5022  /* Reset the null arg flags. */
5023  memset(nulls, 'n', argcount);
5024 
5025  for (i = 0; i < argkwcount; i++) {
5026  idx = argpos[i];
5027  if (idx < 1) continue;
5028  idx--;
5029 
5030  if (i == kX ) {
5031  /* x is 0 based index, but SQL expects 1 based index */
5032  values[idx] = Int32GetDatum(x+1);
5033  nulls[idx] = ' ';
5034  }
5035  else if (i == kY) {
5036  /* y is 0 based index, but SQL expects 1 based index */
5037  values[idx] = Int32GetDatum(y+1);
5038  nulls[idx] = ' ';
5039  }
5040  else if (i == kVAL ) {
5041  values[idx] = Float8GetDatum(r);
5042  nulls[idx] = ' ';
5043  }
5044 
5045  }
5046 
5047  ret = SPI_execute_plan(spi_plan, values, nulls, FALSE, 0);
5048  if (ret != SPI_OK_SELECT || SPI_tuptable == NULL ||
5049  SPI_processed != 1) {
5050  if (SPI_tuptable)
5051  SPI_freetuptable(tuptable);
5052 
5053  SPI_freeplan(spi_plan);
5054  SPI_finish();
5055 
5056  pfree(values);
5057  pfree(nulls);
5058  pfree(initexpr);
5059 
5061  PG_FREE_IF_COPY(pgraster, 0);
5062  rt_raster_destroy(newrast);
5063 
5064  elog(ERROR, "RASTER_mapAlgebraExpr: Error executing prepared plan");
5065 
5066  PG_RETURN_NULL();
5067  }
5068 
5069  tupdesc = SPI_tuptable->tupdesc;
5070  tuptable = SPI_tuptable;
5071 
5072  tuple = tuptable->vals[0];
5073  datum = SPI_getbinval(tuple, tupdesc, 1, &isnull);
5074  if ( SPI_result == SPI_ERROR_NOATTRIBUTE ) {
5075  POSTGIS_RT_DEBUGF(3, "Expression for pixel %d,%d (value %g) errored, skip setting", x+1,y+1,r);
5076  newval = newinitialvalue;
5077  }
5078  else if ( isnull ) {
5079  POSTGIS_RT_DEBUGF(3, "Expression for pixel %d,%d (value %g) evaluated to NULL, skip setting", x+1,y+1,r);
5080  newval = newinitialvalue;
5081  } else {
5082  newval = DatumGetFloat8(datum);
5083  }
5084 
5085  SPI_freetuptable(tuptable);
5086  }
5087 
5088  else
5089  newval = newinitialvalue;
5090 
5091  POSTGIS_RT_DEBUGF(3, "RASTER_mapAlgebraExpr: new value = %f",
5092  newval);
5093  }
5094 
5095 
5096  rt_band_set_pixel(newband, x, y, newval, NULL);
5097  }
5098 
5099  }
5100  }
5101 
5102  if (initexpr != NULL) {
5103  SPI_freeplan(spi_plan);
5104  SPI_finish();
5105 
5106  pfree(values);
5107  pfree(nulls);
5108  pfree(initexpr);
5109  }
5110  else {
5111  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: no SPI cleanup");
5112  }
5113 
5114 
5115  /* The newrast band has been modified */
5116 
5117  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: raster modified, serializing it.");
5118  /* Serialize created raster */
5119 
5121  PG_FREE_IF_COPY(pgraster, 0);
5122 
5123  pgrtn = rt_raster_serialize(newrast);
5124  rt_raster_destroy(newrast);
5125  if (NULL == pgrtn)
5126  PG_RETURN_NULL();
5127 
5128  SET_VARSIZE(pgrtn, pgrtn->size);
5129 
5130  POSTGIS_RT_DEBUG(3, "RASTER_mapAlgebraExpr: raster serialized");
5131 
5132 
5133  POSTGIS_RT_DEBUG(4, "RASTER_mapAlgebraExpr: returning raster");
5134 
5135 
5136  PG_RETURN_POINTER(pgrtn);
5137 }
char * r
Definition: cu_in_wkt.c:24
#define TRUE
Definition: dbfopen.c:73
#define FALSE
Definition: dbfopen.c:72
#define FLT_NEQ(x, y)
Definition: librtcore.h:2234
#define RASTER_DEBUG(level, msg)
Definition: librtcore.h:295
int32_t rt_raster_get_srid(rt_raster raster)
Get raster's SRID.
Definition: rt_raster.c:356
double rt_raster_get_x_skew(rt_raster raster)
Get skew about the X axis.
Definition: rt_raster.c:181
double rt_raster_get_x_offset(rt_raster raster)
Get raster x offset, in projection units.
Definition: rt_raster.c:213
int rt_raster_generate_new_band(rt_raster raster, rt_pixtype pixtype, double initialvalue, uint32_t hasnodata, double nodatavalue, int index)
Generate a new inline band and add it to a raster.
Definition: rt_raster.c:485
void rt_raster_set_scale(rt_raster raster, double scaleX, double scaleY)
Set scale in projection units.
Definition: rt_raster.c:137
int rt_band_get_hasnodata_flag(rt_band band)
Get hasnodata flag value.
Definition: rt_band.c:674
rt_pixtype rt_pixtype_index_from_name(const char *pixname)
Definition: rt_pixel.c:80
rt_errorstate rt_band_get_pixel(rt_band band, int x, int y, double *value, int *nodata)
Get pixel value.
Definition: rt_band.c:1221
void rt_raster_destroy(rt_raster raster)
Release memory associated to a raster.
Definition: rt_raster.c:82
rt_pixtype
Definition: librtcore.h:185
@ PT_END
Definition: librtcore.h:197
void rt_raster_set_skews(rt_raster raster, double skewX, double skewY)
Set skews about the X and Y axis.
Definition: rt_raster.c:168
int rt_band_get_isnodata_flag(rt_band band)
Get isnodata flag value.
Definition: rt_band.c:714
rt_raster rt_raster_new(uint32_t width, uint32_t height)
Construct a raster with given dimensions.
Definition: rt_raster.c:48
int rt_raster_has_band(rt_raster raster, int nband)
Return TRUE if the raster has a band of this number.
Definition: rt_raster.c:1342
void * rt_raster_serialize(rt_raster raster)
Return this raster in serialized form.
Definition: rt_serialize.c:521
double rt_raster_get_x_scale(rt_raster raster)
Get scale X in projection units.
Definition: rt_raster.c:150
double rt_band_get_min_value(rt_band band)
Returns the minimal possible value for the band according to the pixel type.
Definition: rt_band.c:1745
rt_errorstate rt_band_set_pixel(rt_band band, int x, int y, double val, int *converted)
Set single pixel's value.
Definition: rt_band.c:974
@ ES_NONE
Definition: librtcore.h:180
uint16_t rt_raster_get_num_bands(rt_raster raster)
Definition: rt_raster.c:372
uint16_t rt_raster_get_height(rt_raster raster)
Definition: rt_raster.c:129
void rt_raster_set_srid(rt_raster raster, int32_t srid)
Set raster's SRID.
Definition: rt_raster.c:363
rt_errorstate rt_band_get_nodata(rt_band band, double *nodata)
Get NODATA value.
Definition: rt_band.c:1730
rt_pixtype rt_band_get_pixtype(rt_band band)
Return pixeltype of this band.
Definition: rt_band.c:631
const char * rt_pixtype_name(rt_pixtype pixtype)
Definition: rt_pixel.c:110
uint16_t rt_raster_get_width(rt_raster raster)
Definition: rt_raster.c:121
int rt_raster_copy_band(rt_raster torast, rt_raster fromrast, int fromindex, int toindex)
Copy one band from one raster to another.
Definition: rt_raster.c:1365
double rt_raster_get_y_scale(rt_raster raster)
Get scale Y in projection units.
Definition: rt_raster.c:159
double rt_raster_get_y_skew(rt_raster raster)
Get skew about the Y axis.
Definition: rt_raster.c:190
void rt_raster_set_offsets(rt_raster raster, double x, double y)
Set insertion points in projection units.
Definition: rt_raster.c:199
rt_raster rt_raster_deserialize(void *serialized, int header_only)
Return a raster from a serialized form.
Definition: rt_serialize.c:725
double rt_raster_get_y_offset(rt_raster raster)
Get raster y offset, in projection units.
Definition: rt_raster.c:222
int rt_raster_is_empty(rt_raster raster)
Return TRUE if the raster is empty.
Definition: rt_raster.c:1329
rt_band rt_raster_get_band(rt_raster raster, int bandNum)
Return Nth band, or NULL if unavailable.
Definition: rt_raster.c:381
band
Definition: ovdump.py:58
nband
Definition: pixval.py:53
raster
Be careful!! Zeros function's input parameter can be a (height x width) array, not (width x height): ...
Definition: rtrowdump.py:121
char * rtpg_strreplace(const char *str, const char *oldstr, const char *newstr, int *count)
Definition: rtpg_internal.c:55
#define POSTGIS_RT_DEBUG(level, msg)
Definition: rtpostgis.h:61
#define POSTGIS_RT_DEBUGF(level, msg,...)
Definition: rtpostgis.h:65
Struct definitions.
Definition: librtcore.h:2251

References ovdump::band, ES_NONE, FALSE, FLT_NEQ, pixval::nband, POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, PT_END, r, rtrowdump::raster, RASTER_DEBUG, rt_band_get_hasnodata_flag(), rt_band_get_isnodata_flag(), rt_band_get_min_value(), rt_band_get_nodata(), rt_band_get_pixel(), rt_band_get_pixtype(), rt_band_set_pixel(), rt_pixtype_index_from_name(), rt_pixtype_name(), rt_raster_copy_band(), rt_raster_deserialize(), rt_raster_destroy(), rt_raster_generate_new_band(), rt_raster_get_band(), rt_raster_get_height(), rt_raster_get_num_bands(), rt_raster_get_srid(), rt_raster_get_width(), rt_raster_get_x_offset(), rt_raster_get_x_scale(), rt_raster_get_x_skew(), rt_raster_get_y_offset(), rt_raster_get_y_scale(), rt_raster_get_y_skew(), rt_raster_has_band(), rt_raster_is_empty(), rt_raster_new(), rt_raster_serialize(), rt_raster_set_offsets(), rt_raster_set_scale(), rt_raster_set_skews(), rt_raster_set_srid(), rtpg_strreplace(), rt_raster_serialized_t::size, TRUE, pixval::x, and pixval::y.

Here is the call graph for this function: