PostGIS  3.7.0dev-r@@SVN_REVISION@@

◆ RASTER_reclass()

Datum RASTER_reclass ( PG_FUNCTION_ARGS  )

Definition at line 3466 of file rtpg_mapalgebra.c.

3466  {
3467  rt_pgraster *pgraster = NULL;
3468  rt_pgraster *pgrtn = NULL;
3469  rt_raster raster = NULL;
3470  rt_band band = NULL;
3471  rt_band newband = NULL;
3472  uint32_t numBands = 0;
3473 
3474  ArrayType *array;
3475  Oid etype;
3476  Datum *e;
3477  bool *nulls;
3478  int16 typlen;
3479  bool typbyval;
3480  char typalign;
3481  int n = 0;
3482 
3483  int i = 0;
3484  int j = 0;
3485  int k = 0;
3486 
3487  uint32_t a = 0;
3488  uint32_t b = 0;
3489  uint32_t c = 0;
3490 
3491  rt_reclassexpr *exprset = NULL;
3492  HeapTupleHeader tup;
3493  bool isnull;
3494  Datum tupv;
3495  uint32_t nband = 0;
3496  char *expr = NULL;
3497  text *exprtext = NULL;
3498  double val = 0;
3499  char *junk = NULL;
3500  int inc_val = 0;
3501  int exc_val = 0;
3502  char *pixeltype = NULL;
3503  text *pixeltypetext = NULL;
3504  rt_pixtype pixtype = PT_END;
3505  double nodataval = 0;
3506  bool hasnodata = FALSE;
3507 
3508  char **comma_set = NULL;
3509  uint32_t comma_n = 0;
3510  char **colon_set = NULL;
3511  uint32_t colon_n = 0;
3512  char **dash_set = NULL;
3513  uint32_t dash_n = 0;
3514 
3515  POSTGIS_RT_DEBUG(3, "RASTER_reclass: Starting");
3516 
3517  /* pgraster is null, return null */
3518  if (PG_ARGISNULL(0))
3519  PG_RETURN_NULL();
3520  pgraster = (rt_pgraster *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
3521 
3522  /* raster */
3523  raster = rt_raster_deserialize(pgraster, FALSE);
3524  if (!raster) {
3525  PG_FREE_IF_COPY(pgraster, 0);
3526  elog(ERROR, "RASTER_reclass: Could not deserialize raster");
3527  PG_RETURN_NULL();
3528  }
3529  numBands = rt_raster_get_num_bands(raster);
3530  POSTGIS_RT_DEBUGF(3, "RASTER_reclass: %d possible bands to be reclassified", numBands);
3531 
3532  /* process set of reclassarg */
3533  POSTGIS_RT_DEBUG(3, "RASTER_reclass: Processing Arg 1 (reclassargset)");
3534  array = PG_GETARG_ARRAYTYPE_P(1);
3535  etype = ARR_ELEMTYPE(array);
3536  get_typlenbyvalalign(etype, &typlen, &typbyval, &typalign);
3537 
3538  deconstruct_array(array, etype, typlen, typbyval, typalign, &e,
3539  &nulls, &n);
3540 
3541  if (!n) {
3542  elog(NOTICE, "Invalid argument for reclassargset. Returning original raster");
3543 
3544  pgrtn = rt_raster_serialize(raster);
3545  rt_raster_destroy(raster);
3546  PG_FREE_IF_COPY(pgraster, 0);
3547  if (!pgrtn)
3548  PG_RETURN_NULL();
3549 
3550  SET_VARSIZE(pgrtn, pgrtn->size);
3551  PG_RETURN_POINTER(pgrtn);
3552  }
3553 
3554  /*
3555  process each element of reclassarg
3556  each element is the index of the band to process, the set
3557  of reclass ranges and the output band's pixeltype
3558  */
3559  for (i = 0; i < n; i++) {
3560  if (nulls[i]) continue;
3561 
3562  /* each element is a tuple */
3563  tup = (HeapTupleHeader) DatumGetPointer(e[i]);
3564  if (NULL == tup) {
3565  elog(NOTICE, "Invalid argument for reclassargset. Returning original raster");
3566 
3567  pgrtn = rt_raster_serialize(raster);
3568  rt_raster_destroy(raster);
3569  PG_FREE_IF_COPY(pgraster, 0);
3570  if (!pgrtn)
3571  PG_RETURN_NULL();
3572 
3573  SET_VARSIZE(pgrtn, pgrtn->size);
3574  PG_RETURN_POINTER(pgrtn);
3575  }
3576 
3577  /* band index (1-based) */
3578  tupv = GetAttributeByName(tup, "nband", &isnull);
3579  if (isnull) {
3580  elog(NOTICE, "Invalid argument for reclassargset. Missing value of nband for reclassarg of index %d . Returning original raster", i);
3581 
3582  pgrtn = rt_raster_serialize(raster);
3583  rt_raster_destroy(raster);
3584  PG_FREE_IF_COPY(pgraster, 0);
3585  if (!pgrtn)
3586  PG_RETURN_NULL();
3587 
3588  SET_VARSIZE(pgrtn, pgrtn->size);
3589  PG_RETURN_POINTER(pgrtn);
3590  }
3591  nband = DatumGetInt32(tupv);
3592  POSTGIS_RT_DEBUGF(3, "RASTER_reclass: expression for band %d", nband);
3593 
3594  /* valid band index? */
3595  if (nband < 1 || nband > numBands) {
3596  elog(NOTICE, "Invalid argument for reclassargset. Invalid band index (must use 1-based) for reclassarg of index %d . Returning original raster", i);
3597 
3598  pgrtn = rt_raster_serialize(raster);
3599  rt_raster_destroy(raster);
3600  PG_FREE_IF_COPY(pgraster, 0);
3601  if (!pgrtn)
3602  PG_RETURN_NULL();
3603 
3604  SET_VARSIZE(pgrtn, pgrtn->size);
3605  PG_RETURN_POINTER(pgrtn);
3606  }
3607 
3608  /* reclass expr */
3609  tupv = GetAttributeByName(tup, "reclassexpr", &isnull);
3610  if (isnull) {
3611  elog(NOTICE, "Invalid argument for reclassargset. Missing value of reclassexpr for reclassarg of index %d . Returning original raster", i);
3612 
3613  pgrtn = rt_raster_serialize(raster);
3614  rt_raster_destroy(raster);
3615  PG_FREE_IF_COPY(pgraster, 0);
3616  if (!pgrtn)
3617  PG_RETURN_NULL();
3618 
3619  SET_VARSIZE(pgrtn, pgrtn->size);
3620  PG_RETURN_POINTER(pgrtn);
3621  }
3622  exprtext = (text *) DatumGetPointer(tupv);
3623  if (NULL == exprtext) {
3624  elog(NOTICE, "Invalid argument for reclassargset. Missing value of reclassexpr for reclassarg of index %d . Returning original raster", i);
3625 
3626  pgrtn = rt_raster_serialize(raster);
3627  rt_raster_destroy(raster);
3628  PG_FREE_IF_COPY(pgraster, 0);
3629  if (!pgrtn)
3630  PG_RETURN_NULL();
3631 
3632  SET_VARSIZE(pgrtn, pgrtn->size);
3633  PG_RETURN_POINTER(pgrtn);
3634  }
3635  expr = text_to_cstring(exprtext);
3636  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: expr (raw) %s", expr);
3637  expr = rtpg_removespaces(expr);
3638  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: expr (clean) %s", expr);
3639 
3640  /* split string to its components */
3641  /* comma (,) separating rangesets */
3642  comma_set = rtpg_strsplit(expr, ",", &comma_n);
3643  if (comma_n < 1) {
3644  elog(NOTICE, "Invalid argument for reclassargset. Invalid expression of reclassexpr for reclassarg of index %d . Returning original raster", i);
3645 
3646  pgrtn = rt_raster_serialize(raster);
3647  rt_raster_destroy(raster);
3648  PG_FREE_IF_COPY(pgraster, 0);
3649  if (!pgrtn)
3650  PG_RETURN_NULL();
3651 
3652  SET_VARSIZE(pgrtn, pgrtn->size);
3653  PG_RETURN_POINTER(pgrtn);
3654  }
3655 
3656  /* set of reclass expressions */
3657  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: %d possible expressions", comma_n);
3658  exprset = palloc(comma_n * sizeof(rt_reclassexpr));
3659 
3660  for (a = 0, j = 0; a < comma_n; a++) {
3661  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: map %s", comma_set[a]);
3662 
3663  /* colon (:) separating range "src" and "dst" */
3664  colon_set = rtpg_strsplit(comma_set[a], ":", &colon_n);
3665  if (colon_n != 2) {
3666  elog(NOTICE, "Invalid argument for reclassargset. Invalid expression of reclassexpr for reclassarg of index %d . Returning original raster", i);
3667  for (k = 0; k < j; k++) pfree(exprset[k]);
3668  pfree(exprset);
3669 
3670  pgrtn = rt_raster_serialize(raster);
3671  rt_raster_destroy(raster);
3672  PG_FREE_IF_COPY(pgraster, 0);
3673  if (!pgrtn)
3674  PG_RETURN_NULL();
3675 
3676  SET_VARSIZE(pgrtn, pgrtn->size);
3677  PG_RETURN_POINTER(pgrtn);
3678  }
3679 
3680  /* allocate mem for reclass expression */
3681  exprset[j] = palloc(sizeof(struct rt_reclassexpr_t));
3682 
3683  for (b = 0; b < colon_n; b++) {
3684  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: range %s", colon_set[b]);
3685 
3686  /* dash (-) separating "min" and "max" */
3687  dash_set = rtpg_strsplit(colon_set[b], "-", &dash_n);
3688  if (dash_n < 1 || dash_n > 3) {
3689  elog(NOTICE, "Invalid argument for reclassargset. Invalid expression of reclassexpr for reclassarg of index %d . Returning original raster", i);
3690  for (k = 0; k < j; k++) pfree(exprset[k]);
3691  pfree(exprset);
3692 
3693  pgrtn = rt_raster_serialize(raster);
3694  rt_raster_destroy(raster);
3695  PG_FREE_IF_COPY(pgraster, 0);
3696  if (!pgrtn)
3697  PG_RETURN_NULL();
3698 
3699  SET_VARSIZE(pgrtn, pgrtn->size);
3700  PG_RETURN_POINTER(pgrtn);
3701  }
3702 
3703  for (c = 0; c < dash_n; c++) {
3704  /* need to handle: (-9999-100 -> "(", "9999", "100" */
3705  if (
3706  c < 1 &&
3707  strlen(dash_set[c]) == 1 && (
3708  strchr(dash_set[c], '(') != NULL ||
3709  strchr(dash_set[c], '[') != NULL ||
3710  strchr(dash_set[c], ')') != NULL ||
3711  strchr(dash_set[c], ']') != NULL
3712  )
3713  ) {
3714  uint32_t dash_it;
3715  junk = palloc(sizeof(char) * (strlen(dash_set[c + 1]) + 2));
3716  if (NULL == junk) {
3717  for (k = 0; k <= j; k++) pfree(exprset[k]);
3718  pfree(exprset);
3719  rt_raster_destroy(raster);
3720  PG_FREE_IF_COPY(pgraster, 0);
3721 
3722  elog(ERROR, "RASTER_reclass: Could not allocate memory");
3723  PG_RETURN_NULL();
3724  }
3725 
3726  sprintf(junk, "%s%s", dash_set[c], dash_set[c + 1]);
3727  c++;
3728  dash_set[c] = repalloc(dash_set[c], sizeof(char) * (strlen(junk) + 1));
3729  strcpy(dash_set[c], junk);
3730  pfree(junk);
3731 
3732  /* rebuild dash_set */
3733  for (dash_it = 1; dash_it < dash_n; dash_it++) {
3734  dash_set[dash_it - 1] = repalloc(dash_set[dash_it - 1], (strlen(dash_set[dash_it]) + 1) * sizeof(char));
3735  strcpy(dash_set[dash_it - 1], dash_set[dash_it]);
3736  }
3737  dash_n--;
3738  c--;
3739  pfree(dash_set[dash_n]);
3740  dash_set = repalloc(dash_set, sizeof(char *) * dash_n);
3741  }
3742 
3743  /* there shouldn't be more than two in dash_n */
3744  if (c < 1 && dash_n > 2) {
3745  elog(NOTICE, "Invalid argument for reclassargset. Invalid expression of reclassexpr for reclassarg of index %d . Returning original raster", i);
3746  for (k = 0; k < j; k++) pfree(exprset[k]);
3747  pfree(exprset);
3748 
3749  pgrtn = rt_raster_serialize(raster);
3750  rt_raster_destroy(raster);
3751  PG_FREE_IF_COPY(pgraster, 0);
3752  if (!pgrtn)
3753  PG_RETURN_NULL();
3754 
3755  SET_VARSIZE(pgrtn, pgrtn->size);
3756  PG_RETURN_POINTER(pgrtn);
3757  }
3758 
3759  /* check interval flags */
3760  exc_val = 0;
3761  inc_val = 1;
3762  /* range */
3763  if (dash_n != 1) {
3764  /* min */
3765  if (c < 1) {
3766  if (
3767  strchr(dash_set[c], ')') != NULL ||
3768  strchr(dash_set[c], ']') != NULL
3769  ) {
3770  exc_val = 1;
3771  inc_val = 1;
3772  }
3773  else if (strchr(dash_set[c], '(') != NULL){
3774  inc_val = 0;
3775  }
3776  else {
3777  inc_val = 1;
3778  }
3779  }
3780  /* max */
3781  else {
3782  if (
3783  strrchr(dash_set[c], '(') != NULL ||
3784  strrchr(dash_set[c], '[') != NULL
3785  ) {
3786  exc_val = 1;
3787  inc_val = 0;
3788  }
3789  else if (strrchr(dash_set[c], ']') != NULL) {
3790  inc_val = 1;
3791  }
3792  else {
3793  inc_val = 0;
3794  }
3795  }
3796  }
3797  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: exc_val %d inc_val %d", exc_val, inc_val);
3798 
3799  /* remove interval flags */
3800  dash_set[c] = rtpg_chartrim(dash_set[c], "()[]");
3801  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: min/max (char) %s", dash_set[c]);
3802 
3803  /* value from string to double */
3804  errno = 0;
3805  val = strtod(dash_set[c], &junk);
3806  if (errno != 0 || dash_set[c] == junk) {
3807  elog(NOTICE, "Invalid argument for reclassargset. Invalid expression of reclassexpr for reclassarg of index %d . Returning original raster", i);
3808  for (k = 0; k < j; k++) pfree(exprset[k]);
3809  pfree(exprset);
3810 
3811  pgrtn = rt_raster_serialize(raster);
3812  rt_raster_destroy(raster);
3813  PG_FREE_IF_COPY(pgraster, 0);
3814  if (!pgrtn)
3815  PG_RETURN_NULL();
3816 
3817  SET_VARSIZE(pgrtn, pgrtn->size);
3818  PG_RETURN_POINTER(pgrtn);
3819  }
3820  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: min/max (double) %f", val);
3821 
3822  /* strsplit removes dash (a.k.a. negative sign), compare now to restore */
3823  if (c < 1)
3824  junk = strstr(colon_set[b], dash_set[c]);
3825  else
3826  junk = rtpg_strrstr(colon_set[b], dash_set[c]);
3827  POSTGIS_RT_DEBUGF(
3828  4,
3829  "(colon_set[%d], dash_set[%d], junk) = (%s, %s, %s)",
3830  b, c, colon_set[b], dash_set[c], junk
3831  );
3832  /* not beginning of string */
3833  if (junk != colon_set[b]) {
3834  /* prior is a dash */
3835  if (*(junk - 1) == '-') {
3836  /* prior is beginning of string or prior - 1 char is dash, negative number */
3837  if (
3838  ((junk - 1) == colon_set[b]) ||
3839  (*(junk - 2) == '-') ||
3840  (*(junk - 2) == '[') ||
3841  (*(junk - 2) == '(')
3842  ) {
3843  val *= -1.;
3844  }
3845  }
3846  }
3847  POSTGIS_RT_DEBUGF(4, "RASTER_reclass: min/max (double) %f", val);
3848 
3849  /* src */
3850  if (b < 1) {
3851  /* singular value */
3852  if (dash_n == 1) {
3853  exprset[j]->src.exc_min = exprset[j]->src.exc_max = exc_val;
3854  exprset[j]->src.inc_min = exprset[j]->src.inc_max = inc_val;
3855  exprset[j]->src.min = exprset[j]->src.max = val;
3856  }
3857  /* min */
3858  else if (c < 1) {
3859  exprset[j]->src.exc_min = exc_val;
3860  exprset[j]->src.inc_min = inc_val;
3861  exprset[j]->src.min = val;
3862  }
3863  /* max */
3864  else {
3865  exprset[j]->src.exc_max = exc_val;
3866  exprset[j]->src.inc_max = inc_val;
3867  exprset[j]->src.max = val;
3868  }
3869  }
3870  /* dst */
3871  else {
3872  /* singular value */
3873  if (dash_n == 1)
3874  exprset[j]->dst.min = exprset[j]->dst.max = val;
3875  /* min */
3876  else if (c < 1)
3877  exprset[j]->dst.min = val;
3878  /* max */
3879  else
3880  exprset[j]->dst.max = val;
3881  }
3882  }
3883  pfree(dash_set);
3884  }
3885  pfree(colon_set);
3886 
3887  POSTGIS_RT_DEBUGF(3, "RASTER_reclass: or: %f - %f nr: %f - %f"
3888  , exprset[j]->src.min
3889  , exprset[j]->src.max
3890  , exprset[j]->dst.min
3891  , exprset[j]->dst.max
3892  );
3893  j++;
3894  }
3895  pfree(comma_set);
3896 
3897  /* pixel type */
3898  tupv = GetAttributeByName(tup, "pixeltype", &isnull);
3899  if (isnull) {
3900  elog(NOTICE, "Invalid argument for reclassargset. Missing value of pixeltype for reclassarg of index %d . Returning original raster", i);
3901 
3902  pgrtn = rt_raster_serialize(raster);
3903  rt_raster_destroy(raster);
3904  PG_FREE_IF_COPY(pgraster, 0);
3905  if (!pgrtn)
3906  PG_RETURN_NULL();
3907 
3908  SET_VARSIZE(pgrtn, pgrtn->size);
3909  PG_RETURN_POINTER(pgrtn);
3910  }
3911  pixeltypetext = (text *) DatumGetPointer(tupv);
3912  if (NULL == pixeltypetext) {
3913  elog(NOTICE, "Invalid argument for reclassargset. Missing value of pixeltype for reclassarg of index %d . Returning original raster", i);
3914 
3915  pgrtn = rt_raster_serialize(raster);
3916  rt_raster_destroy(raster);
3917  PG_FREE_IF_COPY(pgraster, 0);
3918  if (!pgrtn)
3919  PG_RETURN_NULL();
3920 
3921  SET_VARSIZE(pgrtn, pgrtn->size);
3922  PG_RETURN_POINTER(pgrtn);
3923  }
3924  pixeltype = text_to_cstring(pixeltypetext);
3925  POSTGIS_RT_DEBUGF(3, "RASTER_reclass: pixeltype %s", pixeltype);
3926  pixtype = rt_pixtype_index_from_name(pixeltype);
3927 
3928  /* nodata */
3929  tupv = GetAttributeByName(tup, "nodataval", &isnull);
3930  if (isnull) {
3931  nodataval = 0;
3932  hasnodata = FALSE;
3933  }
3934  else {
3935  nodataval = DatumGetFloat8(tupv);
3936  hasnodata = TRUE;
3937  }
3938  POSTGIS_RT_DEBUGF(3, "RASTER_reclass: nodataval %f", nodataval);
3939  POSTGIS_RT_DEBUGF(3, "RASTER_reclass: hasnodata %d", hasnodata);
3940 
3941  /* do reclass */
3942  band = rt_raster_get_band(raster, nband - 1);
3943  if (!band) {
3944  elog(NOTICE, "Could not find raster band of index %d. Returning original raster", nband);
3945  for (k = 0; k < j; k++) pfree(exprset[k]);
3946  pfree(exprset);
3947 
3948  pgrtn = rt_raster_serialize(raster);
3949  rt_raster_destroy(raster);
3950  PG_FREE_IF_COPY(pgraster, 0);
3951  if (!pgrtn)
3952  PG_RETURN_NULL();
3953 
3954  SET_VARSIZE(pgrtn, pgrtn->size);
3955  PG_RETURN_POINTER(pgrtn);
3956  }
3957  newband = rt_band_reclass(band, pixtype, hasnodata, nodataval, exprset, j);
3958  if (!newband) {
3959  for (k = 0; k < j; k++) pfree(exprset[k]);
3960  pfree(exprset);
3961 
3962  rt_raster_destroy(raster);
3963  PG_FREE_IF_COPY(pgraster, 0);
3964 
3965  elog(ERROR, "RASTER_reclass: Could not reclassify raster band of index %d", nband);
3966  PG_RETURN_NULL();
3967  }
3968 
3969  /* replace old band with new band */
3970  if (rt_raster_replace_band(raster, newband, nband - 1) == NULL) {
3971  for (k = 0; k < j; k++) pfree(exprset[k]);
3972  pfree(exprset);
3973 
3974  rt_band_destroy(newband);
3975  rt_raster_destroy(raster);
3976  PG_FREE_IF_COPY(pgraster, 0);
3977 
3978  elog(ERROR, "RASTER_reclass: Could not replace raster band of index %d with reclassified band", nband);
3979  PG_RETURN_NULL();
3980  }
3981 
3982  /* old band is in the variable band */
3983  rt_band_destroy(band);
3984 
3985  /* free exprset */
3986  for (k = 0; k < j; k++) pfree(exprset[k]);
3987  pfree(exprset);
3988  }
3989 
3990  pgrtn = rt_raster_serialize(raster);
3991  rt_raster_destroy(raster);
3992  PG_FREE_IF_COPY(pgraster, 0);
3993  if (!pgrtn)
3994  PG_RETURN_NULL();
3995 
3996  POSTGIS_RT_DEBUG(3, "RASTER_reclass: Finished");
3997 
3998  SET_VARSIZE(pgrtn, pgrtn->size);
3999  PG_RETURN_POINTER(pgrtn);
4000 }
TRUE
#define TRUE
Definition: dbfopen.c:73
FALSE
#define FALSE
Definition: dbfopen.c:72
rt_band_reclass
rt_band rt_band_reclass(rt_band srcband, rt_pixtype pixtype, uint32_t hasnodata, double nodataval, rt_reclassexpr *exprset, int exprcount)
Returns new band with values reclassified.
Definition: rt_mapalgebra.c:69
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
rt_raster_serialize
void * rt_raster_serialize(rt_raster raster)
Return this raster in serialized form.
Definition: rt_serialize.c:521
rt_raster_replace_band
rt_band rt_raster_replace_band(rt_raster raster, rt_band band, int index)
Replace band at provided index with new band.
Definition: rt_raster.c:1404
rt_band_destroy
void rt_band_destroy(rt_band band)
Destroy a raster band.
Definition: rt_band.c:491
rt_raster_get_num_bands
uint16_t rt_raster_get_num_bands(rt_raster raster)
Definition: rt_raster.c:376
rt_raster_deserialize
rt_raster rt_raster_deserialize(void *serialized, int header_only)
Return a raster from a serialized form.
Definition: rt_serialize.c:725
rt_raster_get_band
rt_band rt_raster_get_band(rt_raster raster, int bandNum)
Return Nth band, or NULL if unavailable.
Definition: rt_raster.c:385
ovdump.band
band
Definition: ovdump.py:58
pixval.nband
nband
Definition: pixval.py:54
rtrowdump.raster
raster
Be careful!! Zeros function's input parameter can be a (height x width) array, not (width x height): ...
Definition: rtrowdump.py:121
rtpg_removespaces
char * rtpg_removespaces(char *str)
Definition: rtpg_internal.c:207
rtpg_chartrim
char * rtpg_chartrim(const char *input, char *remove)
Definition: rtpg_internal.c:110
rtpg_strrstr
char * rtpg_strrstr(const char *s1, const char *s2)
Definition: rtpg_internal.c:265
rtpg_strsplit
char ** rtpg_strsplit(const char *str, const char *delimiter, uint32_t *n)
Definition: rtpg_internal.c:142
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
rt_band_t
Definition: librtcore.h:2503
rt_raster_serialized_t::size
uint32_t size
Definition: librtcore.h:2442
rt_raster_serialized_t
Struct definitions.
Definition: librtcore.h:2440
rt_raster_t
Definition: librtcore.h:2474
rt_reclassexpr_t::rt_reclassrange::min
double min
Definition: librtcore.h:2622
rt_reclassexpr_t::rt_reclassrange::inc_min
int inc_min
Definition: librtcore.h:2624
rt_reclassexpr_t::rt_reclassrange::exc_max
int exc_max
Definition: librtcore.h:2627
rt_reclassexpr_t::rt_reclassrange::exc_min
int exc_min
Definition: librtcore.h:2626
rt_reclassexpr_t::rt_reclassrange::max
double max
Definition: librtcore.h:2623
rt_reclassexpr_t::rt_reclassrange::inc_max
int inc_max
Definition: librtcore.h:2625
rt_reclassexpr_t::src
struct rt_reclassexpr_t::rt_reclassrange src
rt_reclassexpr_t::dst
struct rt_reclassexpr_t::rt_reclassrange dst
rt_reclassexpr_t
Definition: librtcore.h:2620

References ovdump::band, rt_reclassexpr_t::dst, rt_reclassexpr_t::rt_reclassrange::exc_max, rt_reclassexpr_t::rt_reclassrange::exc_min, FALSE, rt_reclassexpr_t::rt_reclassrange::inc_max, rt_reclassexpr_t::rt_reclassrange::inc_min, rt_reclassexpr_t::rt_reclassrange::max, rt_reclassexpr_t::rt_reclassrange::min, pixval::nband, POSTGIS_RT_DEBUG, POSTGIS_RT_DEBUGF, PT_END, rtrowdump::raster, rt_band_destroy(), rt_band_reclass(), rt_pixtype_index_from_name(), rt_raster_deserialize(), rt_raster_destroy(), rt_raster_get_band(), rt_raster_get_num_bands(), rt_raster_replace_band(), rt_raster_serialize(), rtpg_chartrim(), rtpg_removespaces(), rtpg_strrstr(), rtpg_strsplit(), rt_raster_serialized_t::size, rt_reclassexpr_t::src, and TRUE.

Here is the call graph for this function: