rt_band_get_value_count()

rt_valuecount rt_band_get_value_count	(	rt_band	band,
		int	exclude_nodata_value,
		double *	search_values,
		uint32_t	search_values_count,
		double	roundto,
		uint32_t *	rtn_total,
		uint32_t *	rtn_count
	)

Count the number of times provided value(s) occur in the band.

Parameters

band	: the band to query for minimum and maximum pixel values
exclude_nodata_value	: if non-zero, ignore nodata values
search_values	: array of values to count
search_values_count	: the number of search values
roundto	: the decimal place to round the values to
rtn_total	: the number of pixels examined in the band
rtn_count	: the number of value counts being returned

Returns

the number of times the provide value(s) occur or NULL

Definition at line 1609 of file rt_statistics.c.

  {
        rt_valuecount vcnts = NULL;
        rt_pixtype pixtype = PT_END;
        uint8_t *data = NULL;
        double nodata = 0;
 
        int scale = 0;
        int doround = 0;
        double tmpd = 0;
        uint32_t i = 0;
 
        uint32_t x = 0;
        uint32_t y = 0;
        int rtn;
        double pxlval;
        int isnodata = 0;
        double rpxlval;
        uint32_t total = 0;
        uint32_t vcnts_count = 0;
        uint32_t new_valuecount = 0;
 
#if POSTGIS_DEBUG_LEVEL > 0
        clock_t start, stop;
        double elapsed = 0;
#endif
 
        RASTER_DEBUG(3, "starting");
#if POSTGIS_DEBUG_LEVEL > 0
        start = clock();
#endif
 
        assert(NULL != band);
        assert(NULL != rtn_count);
 
        data = rt_band_get_data(band);
        if (data == NULL) {
                rterror("rt_band_get_summary_stats: Cannot get band data");
                return NULL;
        }
 
        pixtype = band->pixtype;
 
        if (rt_band_get_hasnodata_flag(band)) {
                rt_band_get_nodata(band, &nodata);
                RASTER_DEBUGF(3, "hasnodata, nodataval = 1, %f", nodata);
        }
        else {
                exclude_nodata_value = 0;
                RASTER_DEBUG(3, "hasnodata, nodataval = 0, 0");
        }
 
        RASTER_DEBUGF(3, "exclude_nodata_value = %d", exclude_nodata_value);
 
        /* process roundto */
        if (roundto < 0 || FLT_EQ(roundto, 0.0)) {
                roundto = 0;
                scale = 0;
        }
        /* tenths, hundredths, thousandths, etc */
        else if (roundto < 1) {
        switch (pixtype) {
                        /* integer band types don't have digits after the decimal place */
                        case PT_1BB:
                        case PT_2BUI:
                        case PT_4BUI:
                        case PT_8BSI:
                        case PT_8BUI:
                        case PT_16BSI:
                        case PT_16BUI:
                        case PT_32BSI:
                        case PT_32BUI:
                                roundto = 0;
                                break;
                        /* floating points, check the rounding */
                        case PT_16BF:
                        case PT_32BF:
                        case PT_64BF:
                                for (scale = 0; scale <= 20; scale++)
                                {
                                        tmpd = roundto * pow(10, scale);
                                        if (FLT_EQ((tmpd - ((int)tmpd)), 0.0))
                                                break;
                                }
                                break;
                        case PT_END:
                                break;
                }
        }
        /* ones, tens, hundreds, etc */
        else {
                for (scale = 0; scale >= -20; scale--) {
                        tmpd = roundto * pow(10, scale);
                        if (tmpd < 1 || FLT_EQ(tmpd, 1.0)) {
                                if (scale == 0) doround = 1;
                                break;
                        }
                }
        }
 
        if (scale != 0 || doround)
                doround = 1;
        else
                doround = 0;
        RASTER_DEBUGF(3, "scale = %d", scale);
        RASTER_DEBUGF(3, "doround = %d", doround);
 
        /* process search_values */
        if (search_values_count > 0 && NULL != search_values) {
                vcnts = (rt_valuecount) rtalloc(sizeof(struct rt_valuecount_t) * search_values_count);
                if (NULL == vcnts) {
                        rterror("rt_band_get_count_of_values: Could not allocate memory for value counts");
                        *rtn_count = 0;
                        return NULL;
                }
 
                for (i = 0; i < search_values_count; i++) {
                        vcnts[i].count = 0;
                        vcnts[i].percent = 0;
                        if (!doround)
                                vcnts[i].value = search_values[i];
                        else
                                vcnts[i].value = ROUND(search_values[i], scale);
                }
                vcnts_count = i;
        }
        else
                search_values_count = 0;
        RASTER_DEBUGF(3, "search_values_count = %d", search_values_count);
 
        /* entire band is nodata */
        if (rt_band_get_isnodata_flag(band) != FALSE) {
                if (exclude_nodata_value) {
                        rtwarn("All pixels of band have the NODATA value");
                        return NULL;
                }
                else {
                        if (search_values_count > 0) {
                                /* check for nodata match */
                                for (i = 0; i < search_values_count; i++) {
                                        if (!doround)
                                                tmpd = nodata;
                                        else
                                                tmpd = ROUND(nodata, scale);
 
                                        if (FLT_NEQ(tmpd, vcnts[i].value))
                                                continue;
 
                                        vcnts[i].count = band->width * band->height;
                                        if (NULL != rtn_total) *rtn_total = vcnts[i].count;
                                        vcnts->percent = 1.0;
                                }
 
                                *rtn_count = vcnts_count;
                        }
                        /* no defined search values */
                        else {
                                vcnts = (rt_valuecount) rtalloc(sizeof(struct rt_valuecount_t));
                                if (NULL == vcnts) {
                                        rterror("rt_band_get_count_of_values: Could not allocate memory for value counts");
                                        *rtn_count = 0;
                                        return NULL;
                                }
 
                                vcnts->value = nodata;
                                vcnts->count = band->width * band->height;
                                if (NULL != rtn_total) *rtn_total = vcnts[i].count;
                                vcnts->percent = 1.0;
 
                                *rtn_count = 1;
                        }
 
                        return vcnts;
                }
        }
 
        for (x = 0; x < band->width; x++) {
                for (y = 0; y < band->height; y++) {
                        rtn = rt_band_get_pixel(band, x, y, &pxlval, &isnodata);
 
                        /* error getting value, continue */
                        if (rtn != ES_NONE)
                                continue;
 
                        if (!exclude_nodata_value || (exclude_nodata_value && !isnodata)) {
                                total++;
                                if (doround) {
                                        rpxlval = ROUND(pxlval, scale);
                                }
                                else
                                        rpxlval = pxlval;
                                RASTER_DEBUGF(5, "(pxlval, rpxlval) => (%0.6f, %0.6f)", pxlval, rpxlval);
 
                                new_valuecount = 1;
                                /* search for match in existing valuecounts */
                                for (i = 0; i < vcnts_count; i++) {
                                        /* match found */
                                        if (FLT_EQ(vcnts[i].value, rpxlval)) {
                                                vcnts[i].count++;
                                                new_valuecount = 0;
                                                RASTER_DEBUGF(5, "(value, count) => (%0.6f, %d)", vcnts[i].value, vcnts[i].count);
                                                break;
                                        }
                                }
 
                                /*
                                        don't add new valuecount either because
                                                - no need for new one
                                                - user-defined search values
                                */
                                if (!new_valuecount || search_values_count > 0) continue;
 
                                /* add new valuecount */
                                vcnts = rtrealloc(vcnts, sizeof(struct rt_valuecount_t) * (vcnts_count + 1));
                                if (NULL == vcnts) {
                                        rterror("rt_band_get_count_of_values: Could not allocate memory for value counts");
                                        *rtn_count = 0;
                                        return NULL;
                                }
 
                                vcnts[vcnts_count].value = rpxlval;
                                vcnts[vcnts_count].count = 1;
                                vcnts[vcnts_count].percent = 0;
                                RASTER_DEBUGF(5, "(value, count) => (%0.6f, %d)", vcnts[vcnts_count].value, vcnts[vcnts_count].count);
                                vcnts_count++;
                        }
                }
        }
 
#if POSTGIS_DEBUG_LEVEL > 0
        stop = clock();
        elapsed = ((double) (stop - start)) / CLOCKS_PER_SEC;
        RASTER_DEBUGF(3, "elapsed time = %0.4f", elapsed);
#endif
 
        for (i = 0; i < vcnts_count; i++) {
                vcnts[i].percent = (double) vcnts[i].count / total;
                RASTER_DEBUGF(5, "(value, count) => (%0.6f, %d)", vcnts[i].value, vcnts[i].count);
        }
 
        RASTER_DEBUG(3, "done");
        if (NULL != rtn_total) *rtn_total = total;
        *rtn_count = vcnts_count;
        return vcnts;
}

References quantile_llist_element::count, rt_valuecount_t::count, ES_NONE, FALSE, FLT_EQ, FLT_NEQ, rt_valuecount_t::percent, PT_16BF, PT_16BSI, PT_16BUI, PT_1BB, PT_2BUI, PT_32BF, PT_32BSI, PT_32BUI, PT_4BUI, PT_64BF, PT_8BSI, PT_8BUI, PT_END, RASTER_DEBUG, RASTER_DEBUGF, ROUND, rt_band_get_data(), rt_band_get_hasnodata_flag(), rt_band_get_isnodata_flag(), rt_band_get_nodata(), rt_band_get_pixel(), rtalloc(), rterror(), rtrealloc(), rtwarn(), quantile_llist_element::value, and rt_valuecount_t::value.

Referenced by RASTER_valueCount(), RASTER_valueCountCoverage(), and test_band_value_count().

Here is the call graph for this function:

Here is the caller graph for this function: