PostGIS  3.0.6dev-r@@SVN_REVISION@@

◆ RASTER_reclass()

Datum RASTER_reclass ( PG_FUNCTION_ARGS  )

Definition at line 3500 of file rtpg_mapalgebra.c.

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

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, text_to_cstring(), and TRUE.

Here is the call graph for this function: