rt_pixel_set_to_array()

rt_errorstate rt_pixel_set_to_array	(	rt_pixel	npixel,
		int	count,
		rt_mask	mask,
		int	x,
		int	y,
		uint16_t	distancex,
		uint16_t	distancey,
		double ***	value,
		int ***	nodata,
		int *	dimx,
		int *	dimy
	)

Definition at line 286 of file rt_pixel.c.

References genraster::count, rt_mask_t::dimx, rt_mask_t::dimy, ES_ERROR, ES_NONE, FLT_EQ, rt_mask_t::nodata, RASTER_DEBUGF, rtalloc(), rtdealloc(), rterror(), rt_pixel_t::value, rt_mask_t::values, rt_mask_t::weighted, rt_pixel_t::x, and rt_pixel_t::y.

Referenced by RASTER_neighborhood(), rt_raster_iterator(), test_band_get_nearest_pixel(), and test_pixel_set_to_array().

  {
        uint32_t i;
        uint32_t j;
        uint32_t dim[2] = {0};
        double **values = NULL;
        int **nodatas = NULL;
        int zero[2] = {0};
        int _x;
        int _y;

        assert(npixel != NULL && count > 0);
        assert(value != NULL);
        assert(nodata != NULL);

        /* dimensions */
        dim[0] = distancex * 2 + 1;
        dim[1] = distancey * 2 + 1;
        RASTER_DEBUGF(4, "dimensions = %d x %d", dim[0], dim[1]);

        /* make sure that the dimx and dimy match mask */
        if (mask != NULL) {
          if (dim[0] != mask->dimx || dim[1] != mask->dimy) {
            rterror("rt_pixel_set_array: mask dimensions %d x %d do not match given dims %d x %d", mask->dimx, mask->dimy,  dim[0],  dim[1]);
            return ES_ERROR;
          }

          if (mask->values == NULL || mask->nodata == NULL) {
            rterror("rt_pixel_set_array: Invalid mask");
            return ES_ERROR;
          }

        }

        /* establish 2D arrays (Y axis) */
        values = rtalloc(sizeof(double *) * dim[1]);
        nodatas = rtalloc(sizeof(int *) * dim[1]);

        if (values == NULL || nodatas == NULL) {
                rterror("rt_pixel_set_to_array: Could not allocate memory for 2D array");
                return ES_ERROR;
        }

        /* initialize X axis */
        for (i = 0; i < dim[1]; i++) {
                values[i] = rtalloc(sizeof(double) * dim[0]);
                nodatas[i] = rtalloc(sizeof(int) * dim[0]);

                if (values[i] == NULL || nodatas[i] == NULL) {
                        rterror("rt_pixel_set_to_array: Could not allocate memory for dimension of 2D array");

                        if (values[i] == NULL) {
                                for (j = 0; j < i; j++) {
                                        rtdealloc(values[j]);
                                        rtdealloc(nodatas[j]);
                                }
                        }
                        else {
                                for (j = 0; j <= i; j++) {
                                        rtdealloc(values[j]);
                                        if (j < i)
                                                rtdealloc(nodatas[j]);
                                }
                        }

                        rtdealloc(values);
                        rtdealloc(nodatas);

                        return ES_ERROR;
                }

                /* set values to 0 */
                memset(values[i], 0, sizeof(double) * dim[0]);

                /* set nodatas to 1 */
                for (j = 0; j < dim[0]; j++)
                        nodatas[i][j] = 1;
        }

        /* get 0,0 of grid */
        zero[0] = x - distancex;
        zero[1] = y - distancey;

        /* populate 2D arrays */
        for (i = 0; i < count; i++) {
                if (npixel[i].nodata)
                        continue;

                _x = npixel[i].x - zero[0];
                _y = npixel[i].y - zero[1];

                RASTER_DEBUGF(4, "absolute x,y: %d x %d", npixel[i].x, npixel[i].y);
                RASTER_DEBUGF(4, "relative x,y: %d x %d", _x, _y);

                /* no mask */
                if (mask == NULL) {
                        values[_y][_x] = npixel[i].value;
                        nodatas[_y][_x] = 0;
                }
                /* mask */
                else {
                        /* unweighted (boolean) mask */
                        if (mask->weighted == 0) {
                                /* pixel is set to zero or nodata */
                                if (FLT_EQ(mask->values[_y][_x],0) || mask->nodata[_y][_x] == 1) {
                                        values[_y][_x] = 0;
                                        nodatas[_y][_x] = 1;
                                }
                                /* use pixel */
                                else {
                                        values[_y][_x] = npixel[i].value;
                                        nodatas[_y][_x] = 0;
                                }
                        }
                        /* weighted mask */
                        else {
                                /* nodata */
                                if(mask->nodata[_y][_x] == 1) {
                                        values[_y][_x] = 0;
                                        nodatas[_y][_x] = 1;
                                }
                                /* apply weight to pixel value */
                                else {
                                        values[_y][_x] = npixel[i].value * mask->values[_y][_x];
                                        nodatas[_y][_x] = 0;
                                }
                        }
                }

                RASTER_DEBUGF(4, "(x, y, nodata, value) = (%d, %d, %d, %f)", _x, _y, nodatas[_y][_x], values[_y][_x]);
        }

        *value = &(*values);
        *nodata = &(*nodatas);
        if (dimx != NULL)
                *dimx = dim[0];
        if (dimy != NULL)
                *dimy = dim[1];

        return ES_NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function: