/*!
\brief Load raster map as integer map
Calling function must have already allocated space in buff for
struct BM of wind->rows & wind->cols.
This routine simply loads the map into the bitmap by repetitve calls
to get_map_row. Any value other than 0 in the map will set the bitmap.
(may want to change later to allow specific value to set)
Changed to use null.
\param wind current window
\param map_name raster map name
\param[out] buff data buffer
\returns 1 on success
\return -1 on failure
*/
int Gs_loadmap_as_bitmap(struct Cell_head *wind, const char *map_name,
struct BM *buff)
{
FILEDESC cellfile;
const char *map_set;
char *nullflags;
int *tmp_buf;
int row, col;
G_debug(3, "Gs_loadmap_as_bitmap");
map_set = G_find_cell2(map_name, "");
if (!map_set) {
G_warning(_("Raster map <%s> not found"), map_name);
return -1;
}
if ((cellfile = G_open_cell_old(map_name, map_set)) == -1) {
G_fatal_error(_("Unable to open raster map <%s>"), map_name);
}
tmp_buf = (int *)G_malloc(wind->cols * sizeof(int)); /* G_fatal_error */
if (!tmp_buf) {
return -1;
}
nullflags = G_allocate_null_buf();
if (!nullflags) {
G_fatal_error(_("Unable to allocate memory for a null buffer"));
}
G_message(_("Loading raster map <%s>..."),
G_fully_qualified_name(map_name, map_set));
for (row = 0; row < wind->rows; row++) {
G_get_null_value_row(cellfile, nullflags, row);
for (col = 0; col < wind->cols; col++) {
if (nullflags[col]) {
/* no data */
BM_set(buff, col, row, 1);
}
else {
BM_set(buff, col, row, 0);
}
}
}
G_close_cell(cellfile);
G_free(tmp_buf);
G_free(nullflags);
return (1);
}
/*!
\brief Load raster map as integer map
Calling function must have already allocated space in buff for
struct BM of wind->rows & wind->cols.
This routine simply loads the map into the bitmap by repetitve calls
to get_map_row. Any value other than 0 in the map will set the bitmap.
(may want to change later to allow specific value to set)
Changed to use null.
\param wind current window
\param map_name raster map name
\param[out] buff data buffer
\returns 1 on success
\return -1 on failure
*/
int Gs_loadmap_as_bitmap(struct Cell_head *wind, const char *map_name,
struct BM *buff)
{
FILEDESC cellfile;
const char *map_set;
int *tmp_buf;
int row, col;
G_debug(3, "Gs_loadmap_as_bitmap");
map_set = G_find_raster2(map_name, "");
if (!map_set) {
G_warning(_("Raster map <%s> not found"), map_name);
return -1;
}
cellfile = Rast_open_old(map_name, map_set);
tmp_buf = (int *)G_malloc(wind->cols * sizeof(int)); /* G_fatal_error */
if (!tmp_buf) {
return -1;
}
G_message(_("Loading raster map <%s>..."),
G_fully_qualified_name(map_name, map_set));
for (row = 0; row < wind->rows; row++) {
Rast_get_c_row(cellfile, tmp_buf, row);
for (col = 0; col < wind->cols; col++) {
if (Rast_is_c_null_value(&tmp_buf[col])) {
/* no data */
BM_set(buff, col, row, 1);
}
else {
BM_set(buff, col, row, 0);
}
}
}
Rast_close(cellfile);
G_free(tmp_buf);
return (1);
}
/*!
\brief Load raster map as floating point map
Calling function must have already allocated space in buff for
wind->rows * wind->cols floats.
This routine simply loads the map into a 2d array by repetitve calls
to get_f_raster_row.
\param wind current window
\param map_name raster map name
\param[out] buff data buffer
\param[out] nullmap null map buffer
\param[out] has_null indicates if raster map contains null-data
\return 1 on success
\return 0 on failure
*/
int Gs_loadmap_as_float(struct Cell_head *wind, const char *map_name,
float *buff, struct BM *nullmap, int *has_null)
{
FILEDESC cellfile;
const char *map_set;
char *nullflags;
int offset, row, col;
G_debug(3, "Gs_loadmap_as_float(): name=%s", map_name);
map_set = G_find_cell2(map_name, "");
if (!map_set) {
G_warning(_("Raster map <%s> not found"), map_name);
return 0;
}
*has_null = 0;
nullflags = G_allocate_null_buf(); /* G_fatal_error */
if (!nullflags) {
G_fatal_error(_("Unable to allocate memory for a null buffer"));
}
if ((cellfile = G_open_cell_old(map_name, map_set)) == -1) {
G_fatal_error(_("Unable to open raster map <%s>"), map_name);
}
G_message(_("Loading raster map <%s>..."),
G_fully_qualified_name(map_name, map_set));
for (row = 0; row < wind->rows; row++) {
offset = row * wind->cols;
G_get_f_raster_row(cellfile, &(buff[offset]), row);
G_get_null_value_row(cellfile, nullflags, row);
G_percent(row, wind->rows, 2);
for (col = 0; col < wind->cols; col++) {
if (nullflags[col] || G_is_f_null_value(buff + offset + col)) {
*has_null = 1;
BM_set(nullmap, col, row, 1);
}
/* set nm */
}
}
G_percent(1, 1, 1);
G_debug(4, " has_null=%d", *has_null);
G_close_cell(cellfile);
G_free(nullflags);
return (1);
}
/*!
\brief Load raster map as floating point map
Calling function must have already allocated space in buff for
wind->rows * wind->cols floats.
This routine simply loads the map into a 2d array by repetitve calls
to get_f_raster_row.
\param wind current window
\param map_name raster map name
\param[out] buff data buffer
\param[out] nullmap null map buffer
\param[out] has_null indicates if raster map contains null-data
\return 1 on success
\return 0 on failure
*/
int Gs_loadmap_as_float(struct Cell_head *wind, const char *map_name,
float *buff, struct BM *nullmap, int *has_null)
{
FILEDESC cellfile;
const char *map_set;
int offset, row, col;
G_debug(3, "Gs_loadmap_as_float(): name=%s", map_name);
map_set = G_find_raster2(map_name, "");
if (!map_set) {
G_warning(_("Raster map <%s> not found"), map_name);
return 0;
}
*has_null = 0;
cellfile = Rast_open_old(map_name, map_set);
G_message(_("Loading raster map <%s>..."),
G_fully_qualified_name(map_name, map_set));
for (row = 0; row < wind->rows; row++) {
offset = row * wind->cols;
Rast_get_f_row(cellfile, &(buff[offset]), row);
G_percent(row, wind->rows, 2);
for (col = 0; col < wind->cols; col++) {
if (Rast_is_f_null_value(buff + offset + col)) {
*has_null = 1;
BM_set(nullmap, col, row, 1);
}
/* set nm */
}
}
G_percent(1, 1, 1);
G_debug(4, " has_null=%d", *has_null);
Rast_close(cellfile);
return (1);
}
int INPUT(struct Map_info *In, char *column, char *scol, char *wheresql)
{
struct quadruple *point;
double x, y, z, w, nz = 0., sm;
double c1, c2, c3, c4, c5, c6, nsg;
int i, j, k = 0, a, irev, cfmask;
int ddisk = 0;
double deltx, delty, deltz;
int first_time = 1;
CELL *cellmask;
const char *mapsetm;
char buf[500];
int cat, intval;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr, sarray;
int nrec, nrec1, ctype, sctype;
struct line_pnts *Points;
struct line_cats *Cats;
OUTRANGE = 0;
NPOINT = 0;
dmin = dmin * dmin;
/* Read attributes */
db_CatValArray_init(&cvarr);
if (scol != NULL)
db_CatValArray_init(&sarray);
Fi = Vect_get_field(In, 1);
if (Fi == NULL)
G_fatal_error(_("Unable to get layer info for vector map"));
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key, column, wheresql,
&cvarr);
ctype = cvarr.ctype;
G_debug(3, "nrec = %d", nrec);
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type of wcolumn is not supported (must be integer or double)"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_message("%d records selected from table", nrec);
if (scol != NULL) {
nrec1 =
db_select_CatValArray(Driver, Fi->table, Fi->key, scol, wheresql,
&sarray);
sctype = cvarr.ctype;
if (sctype == -1)
G_fatal_error(_("Cannot read column type of smooth column"));
if (sctype == DB_C_TYPE_DATETIME)
G_fatal_error
(_("Column type of smooth column (datetime) is not supported"));
if (sctype != DB_C_TYPE_INT && sctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type of smooth column is not supported (must be integer or double)"));
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_rewind(In);
while (1) {
int ival, type, ret;
if (-1 == (type = Vect_read_next_line(In, Points, Cats)))
G_fatal_error(_("Unable to read vector map"));
if (type == -2)
break; /* EOF */
if (!(type & GV_POINTS))
continue;
Vect_cat_get(Cats, 1, &cat);
if (cat < 0) {
G_warning(_("Point without category"));
continue;
}
x = Points->x[0];
y = Points->y[0];
z = Points->z[0];
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &ival);
w = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&cvarr, cat, &w);
}
if (ret != DB_OK) {
if (wheresql != NULL)
/* G_message(_("Database record for cat %d not used due to SQL statement")); */
/* do nothing in this case to not confuse user. Or implement second cat list */
;
else
G_warning(_("No record for category %d in table <%s>"), cat,
Fi->table);
continue;
}
if (rsm == -1 && scol != NULL) {
if (sctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&sarray, cat, &intval);
sm = intval;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&sarray, cat, &sm);
}
}
G_debug(3, "%f %f %f %f", x, y, z, w);
k++;
w = w * wmult;
z = z * zmult;
c1 = x - ((struct octdata *)(root->data))->x_orig;
c2 = ((struct octdata *)(root->data))->x_orig +
((struct octdata *)(root->data))->n_cols * ew_res - x;
c3 = y - ((struct octdata *)(root->data))->y_orig;
c4 = ((struct octdata *)(root->data))->y_orig +
((struct octdata *)(root->data))->n_rows * ns_res - y;
c5 = z - ((struct octdata *)(root->data))->z_orig;
c6 = ((struct octdata *)(root->data))->z_orig +
((struct octdata *)(root->data))->n_levs * tb_res - z;
if (!
((c1 >= 0) && (c2 >= 0) && (c3 >= 0) && (c4 >= 0) && (c5 >= 0) &&
(c6 >= 0))) {
if (!OUTRANGE) {
G_warning(_("Some points outside of region -- will ignore..."));
}
OUTRANGE++;
}
else {
if (!(point = point_new(x, y, z, w, sm))) {
clean();
G_fatal_error(_("Cannot allocate memory for point"));
}
a = OT_insert_oct(point, root);
if (a == 0) {
NPOINT++;
}
if (a < 0) {
G_warning(_("Can't insert %lf,%lf,%lf,%lf,%lf a=%d"), x, y, z,
w, sm, a);
return -1;
}
if (first_time) {
first_time = 0;
xmin = x;
ymin = y;
zmin = z;
wmin = w;
xmax = x;
ymax = y;
zmax = z;
wmax = w;
}
xmin = amin1(xmin, x);
ymin = amin1(ymin, y);
zmin = amin1(zmin, z);
wmin = amin1(wmin, w);
xmax = amax1(xmax, x);
ymax = amax1(ymax, y);
zmax = amax1(zmax, z);
wmax = amax1(wmax, w);
}
} /* while */
db_CatValArray_free(&cvarr);
c1 = xmin - ((struct octdata *)(root->data))->x_orig;
c2 = ((struct octdata *)(root->data))->x_orig +
((struct octdata *)(root->data))->n_cols * ew_res - xmax;
c3 = ymin - ((struct octdata *)(root->data))->y_orig;
c4 = ((struct octdata *)(root->data))->y_orig +
((struct octdata *)(root->data))->n_rows * ns_res - ymax;
c5 = zmin - ((struct octdata *)(root->data))->z_orig;
c6 = ((struct octdata *)(root->data))->z_orig +
((struct octdata *)(root->data))->n_levs * tb_res - zmax;
if ((c1 > 5 * ew_res) || (c2 > 5 * ew_res) ||
(c3 > 5 * ns_res) || (c4 > 5 * ns_res) ||
(c5 > 5 * tb_res) || (c6 > 5 * tb_res)) {
static int once = 0;
if (!once) {
once = 1;
G_warning(_("Strip exists with insufficient data"));
}
}
nz = wmin;
totsegm = translate_oct(root, ((struct octdata *)(root->data))->x_orig,
((struct octdata *)(root->data))->y_orig,
((struct octdata *)(root->data))->z_orig, nz);
if (!totsegm) {
clean();
G_fatal_error(_("Zero segments!"));
}
((struct octdata *)(root->data))->x_orig = 0;
((struct octdata *)(root->data))->y_orig = 0;
((struct octdata *)(root->data))->z_orig = 0; /* was commented out */
if (outz != NULL)
ddisk += disk;
if (gradient != NULL)
ddisk += disk;
if (aspect1 != NULL)
ddisk += disk;
if (ncurv != NULL)
ddisk += disk;
if (gcurv != NULL)
ddisk += disk;
if (mcurv != NULL)
ddisk += disk;
G_message
("Processing all selected output files will require %d bytes of disk space for temp files",
ddisk);
/*
fprintf(stderr,"xmin=%lf,xmax=%lf,ymin=%lf,ymax=%lf,zmin=%lf,zmax=%lf,wmin=%lf,wmax=%lf\n",xmin,xmax,ymin,ymax,zmin,zmax,wmin,wmax);
*/
fprintf(stderr, "\n");
if (OUTRANGE > 0)
G_warning
(_("There are points outside specified 2D/3D region--ignored %d points (total points: %d)"),
OUTRANGE, k);
if (NPOINT > 0)
G_warning
(_("Points are more dense than specified 'DMIN'--ignored %d points (remain %d)"),
NPOINT, k - NPOINT);
NPOINT = k - NPOINT - NPT - OUTRANGE;
if (NPOINT < KMIN) {
if (NPOINT != 0) {
G_warning
(_("%d points given for interpolation (after thinning) is less than given NPMIN=%d"),
NPOINT, KMIN);
KMIN = NPOINT;
}
else {
fprintf(stderr, "ERROR: zero points in the given region!\n");
return -1;
}
}
if (NPOINT > KMAXPOINTS && KMIN <= KMAX) {
fprintf(stderr,
"ERROR: segmentation parameters set to invalid values: npmin = %d, segmax = %d \n",
KMIN, KMAX);
fprintf(stderr,
"for smooth connection of segments, npmin > segmax (see manual) \n");
return -1;
}
if (NPOINT < KMAXPOINTS && KMAX != KMAXPOINTS)
G_warning
(_("There is less than %d points for interpolation, no segmentation is necessary, to run the program faster, set segmax=%d (see manual)"),
KMAXPOINTS, KMAXPOINTS);
deltx = xmax - xmin;
delty = ymax - ymin;
deltz = zmax - zmin;
nsg = (double)NPOINT / (double)KMIN;
dnorm = deltx * delty * deltz / nsg;
nsg = 3.0;
nsg = 1. / nsg;
dnorm = pow(dnorm, nsg);
/* DEBUG
if (fd4 != NULL)
fprintf (fd4, "deltx,delty %f %f \n", deltx, delty);
*/
nsizc = current_region.cols; /* ((int)(deltx/ew_res))+1; */
nsizr = current_region.rows; /* ((int)(delty/ns_res))+1; */
NPT = k;
x0utm = 0.;
y0utm = 0.;
z0utm = 0.;
/** create a bitmap mask from given raster map **/
if (maskmap != NULL) {
mapsetm = G_find_raster2(maskmap, "");
if (!mapsetm) {
clean();
G_fatal_error(_("Mask raster map [%s] not found"), maskmap);
}
bitmask = BM_create(nsizc, nsizr);
cellmask = Rast_allocate_c_buf();
cfmask = Rast_open_old(maskmap, mapsetm);
for (i = 0; i < nsizr; i++) {
irev = nsizr - i - 1;
Rast_get_c_row(cfmask, cellmask, i);
for (j = 0; j < nsizc; j++) {
if ((cellmask[j] == 0) || Rast_is_c_null_value(&cellmask[j]))
BM_set(bitmask, j, irev, 0);
else
BM_set(bitmask, j, irev, 1);
}
}
G_message(_("Bitmap mask created"));
}
return 1;
}
/*!
\brief Load raster map as integer map
Calling function must have already allocated space in buff for
wind->rows * wind->cols unsigned chars.
This routine simply loads the map into a 2d array by repetitve calls
to get_map_row.
Since signs of chars can be tricky, we only load positive chars
between 0-255.
\todo fn body Gs_loadmap_as_float()
\param wind current window
\param map_name raster map name
\param[out] buff data buffer
\param[out] nullmap null map buffer
\param[out] has_null indicates if raster map contains null-data
\return 1 on success
\return -1 on failure
\return -2 if read ok, but 1 or more values
were too large (small) to fit into an unsigned char.
(in which case the max (min) char is used)
*/
int Gs_loadmap_as_char(struct Cell_head *wind, const char *map_name,
unsigned char *buff, struct BM *nullmap, int *has_null)
{
FILEDESC cellfile;
const char *map_set;
int *ti, *tmp_buf;
int offset, row, col, val, max_char, overflow, charsize, bitplace;
unsigned char *tc;
G_debug(3, "Gs_loadmap_as_char");
overflow = 0;
charsize = 8 * sizeof(unsigned char);
/* 0 bits for sign! */
max_char = 1;
for (bitplace = 0; bitplace < charsize; ++bitplace) {
max_char *= 2;
}
max_char -= 1;
map_set = G_find_raster2(map_name, "");
if (!map_set) {
G_warning(_("Raster map <%s> not found"), map_name);
return -1;
}
*has_null = 0;
cellfile = Rast_open_old(map_name, map_set);
tmp_buf = (int *)G_malloc(wind->cols * sizeof(int)); /* G_fatal_error */
if (!tmp_buf) {
return -1;
}
G_message(_("Loading raster map <%s>..."),
G_fully_qualified_name(map_name, map_set));
for (row = 0; row < wind->rows; row++) {
offset = row * wind->cols;
Rast_get_c_row(cellfile, tmp_buf, row);
tc = (unsigned char *)&(buff[offset]);
ti = tmp_buf;
G_percent(row, wind->rows, 2);
for (col = 0; col < wind->cols; col++) {
if (Rast_is_c_null_value(&tmp_buf[col])) {
*has_null = 1;
BM_set(nullmap, col, row, 1);
}
else {
val = *ti;
if (val > max_char) {
overflow = 1;
*tc = (unsigned char)max_char;
}
else if (val < 0) {
overflow = 1;
*tc = 0;
}
else {
*tc = (unsigned char)val;
}
}
ti++;
tc++;
}
}
G_percent(1, 1, 1);
Rast_close(cellfile);
G_free(tmp_buf);
return (overflow ? -2 : 1);
}
/*!
\brief Load raster map as integer map
Calling function must have already allocated space in buff for
wind->rows * wind->cols shorts.
This routine simply loads the map into a 2d array by repetitve calls
to get_map_row.
\param wind current window
\param map_name raster map name
\param[out] buff data buffer
\param[out] nullmap null map buffer
\param[out] has_null indicates if raster map contains null-data
\return 1 on success
\return -1 on failure,
\return -2 if read ok, but 1 or more values were too large (small)
to fit into a short (in which case the max (min) short is used)
*/
int Gs_loadmap_as_short(struct Cell_head *wind, const char *map_name,
short *buff, struct BM *nullmap, int *has_null)
{
FILEDESC cellfile;
const char *map_set;
int *ti, *tmp_buf;
int offset, row, col, val, max_short, overflow, shortsize, bitplace;
short *ts;
G_debug(3, "Gs_loadmap_as_short");
overflow = 0;
shortsize = 8 * sizeof(short);
/* 1 bit for sign */
/* same as 2 << (shortsize-1) */
for (max_short = bitplace = 1; bitplace < shortsize; ++bitplace) {
max_short *= 2;
}
max_short -= 1;
map_set = G_find_raster2(map_name, "");
if (!map_set) {
G_warning(_("Raster map <%s> not found"), map_name);
return -1;
}
*has_null = 0;
cellfile = Rast_open_old(map_name, map_set);
tmp_buf = (int *)G_malloc(wind->cols * sizeof(int)); /* G_fatal_error */
if (!tmp_buf) {
return -1;
}
G_message(_("Loading raster map <%s>..."),
G_fully_qualified_name(map_name, map_set));
for (row = 0; row < wind->rows; row++) {
offset = row * wind->cols;
Rast_get_c_row(cellfile, tmp_buf, row);
G_percent(row, wind->rows, 2);
ts = &(buff[offset]);
ti = tmp_buf;
for (col = 0; col < wind->cols; col++) {
if (Rast_is_c_null_value(&tmp_buf[col])) {
*has_null = 1;
BM_set(nullmap, col, row, 1);
}
else {
val = *ti;
if (abs(val) > max_short) {
overflow = 1;
/* assign floor/ceiling value?
*/
*ts = (short)(max_short * val / abs(val));
}
else {
*ts = (short)val;
}
}
ti++;
ts++;
}
}
G_percent(1, 1, 1);
Rast_close(cellfile);
G_free(tmp_buf);
return (overflow ? -2 : 1);
}
