int db_CatValArray_get_value_di(dbCatValArray * cvarr, int cat, double *value)
{
int t;
int ctype = cvarr->ctype;
int ret;
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(cvarr, cat, &t);
if (ret != DB_OK)
return ret;
*value = (double)t;
return DB_OK;
}
if (ctype == DB_C_TYPE_DOUBLE) {
ret = db_CatValArray_get_value_double(cvarr, cat, value);
return ret;
}
return DB_FAILED;
}
/*-------------------------------------------------------------------------------------------*/
int cross_correlation(struct Map_info *Map, double passWE, double passNS)
/*
Map: Vector map from which cross-crorrelation will take values
passWE: spline step in West-East direction
passNS: spline step in North-South direction
RETURN:
TRUE on success
FALSE on failure
*/
{
int bilin = TRUE; /*booleans */
int nsplx, nsply, nparam_spl, ndata;
double *mean, *rms, *stdev;
/* double lambda[PARAM_LAMBDA] = { 0.0001, 0.001, 0.01, 0.1, 1.0, 10.0 }; */ /* Fixed values (by the moment) */
double lambda[PARAM_LAMBDA] = { 0.0001, 0.001, 0.005, 0.01, 0.02, 0.05 }; /* Fixed values (by the moment) */
/* a more exhaustive search:
#define PARAM_LAMBDA 11
double lambda[PARAM_LAMBDA] = { 0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0, 10.0 }; */
double *TN, *Q, *parVect; /* Interpolation and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
struct Point *observ;
struct Stats stat_vect;
/*struct line_pnts *points; */
/*struct line_cats *Cats; */
struct Cell_head region;
G_get_window(®ion);
extern int bspline_field;
extern char *bspline_column;
dbCatValArray cvarr;
G_debug(5,
"CrossCorrelation: Some tests using different lambda_i values will be done");
ndata = Vect_get_num_lines(Map);
if (ndata > NDATA_MAX)
G_warning(_("%d are too many points. "
"The cross validation would take too much time."), ndata);
/*points = Vect_new_line_struct (); */
/*Cats = Vect_new_cats_struct (); */
/* Current region is read and points recorded into observ */
observ = P_Read_Vector_Region_Map(Map, ®ion, &ndata, 1024, 1);
G_debug(5, "CrossCorrelation: %d points read in region. ", ndata);
G_verbose_message(_("%d points read in region"),
ndata);
if (ndata > 50)
G_warning(_("Maybe it takes too long. "
"It will depend on how many points you are considering."));
else
G_debug(5, "CrossCorrelation: It shouldn't take too long.");
if (ndata > 0) { /* If at least one point is in the region */
int i, j, lbd; /* lbd: lambda index */
int BW;
double mean_reg, *obs_mean;
int nrec, ctype = 0, verbosity;
struct field_info *Fi;
dbDriver *driver_cats;
mean = G_alloc_vector(PARAM_LAMBDA); /* Alloc as much mean, rms and stdev values as the total */
rms = G_alloc_vector(PARAM_LAMBDA); /* number of parameter used used for cross validation */
stdev = G_alloc_vector(PARAM_LAMBDA);
verbosity = G_verbose(); /* store for later reset */
/* Working with attributes */
if (bspline_field > 0) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(Map, bspline_field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
bspline_field);
driver_cats =
db_start_driver_open_database(Fi->driver, Fi->database);
G_debug(1, _("CrossCorrelation: driver=%s db=%s"), Fi->driver,
Fi->database);
if (driver_cats == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nrec =
db_select_CatValArray(driver_cats, Fi->table, Fi->key,
bspline_column, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("No records selected from table <%s> "),
Fi->table);
G_debug(1, "%d records selected from table",
nrec);
db_close_database_shutdown_driver(driver_cats);
}
/* Setting number of splines as a function of WE and SN spline steps */
nsplx = ceil((region.east - region.west) / passWE);
nsply = ceil((region.north - region.south) / passNS);
nparam_spl = nsplx * nsply; /* Total number of splines */
if (nparam_spl > 22900)
G_fatal_error(_("Too many splines (%d x %d). "
"Consider changing spline steps \"ew_step=\" \"ns_step=\"."),
nsplx, nsply);
BW = P_get_BandWidth(bilin, nsply);
/**/
/*Least Squares system */
N = G_alloc_matrix(nparam_spl, BW); /* Normal matrix */
TN = G_alloc_vector(nparam_spl); /* vector */
parVect = G_alloc_vector(nparam_spl); /* Parameters vector */
obsVect = G_alloc_matrix(ndata, 3); /* Observation vector */
Q = G_alloc_vector(ndata); /* "a priori" var-cov matrix */
obs_mean = G_alloc_vector(ndata);
stat_vect = alloc_Stats(ndata);
for (lbd = 0; lbd < PARAM_LAMBDA; lbd++) { /* For each lambda value */
G_message(_("Beginning cross validation with "
"lambda_i=%.4f ... (%d of %d)"), lambda[lbd],
lbd+1, PARAM_LAMBDA);
/*
How the cross correlation algorithm is done:
For each cycle, only the first ndata-1 "observ" elements are considered for the
interpolation. Within every interpolation mean is calculated to lowering edge
errors. The point left out will be used for an estimation. The error between the
estimation and the observation is recorded for further statistics.
At the end of the cycle, the last point, that is, the ndata-1 index, and the point
with j index are swapped.
*/
for (j = 0; j < ndata; j++) { /* Cross Correlation will use all ndata points */
double out_x, out_y, out_z; /* This point is left out */
for (i = 0; i < ndata; i++) { /* Each time, only the first ndata-1 points */
double dval; /* are considered in the interpolation */
/* Setting obsVect vector & Q matrix */
Q[i] = 1; /* Q=I */
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
if (bspline_field > 0) {
int cat, ival, ret;
/*type = Vect_read_line (Map, points, Cats, observ[i].lineID); */
/*if ( !(type & GV_POINTS ) ) continue; */
/*Vect_cat_get ( Cats, bspline_field, &cat ); */
cat = observ[i].cat;
if (cat < 0)
continue;
if (ctype == DB_C_TYPE_INT) {
ret =
db_CatValArray_get_value_int(&cvarr, cat,
&ival);
obsVect[i][2] = ival;
obs_mean[i] = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret =
db_CatValArray_get_value_double(&cvarr, cat,
&dval);
obsVect[i][2] = dval;
obs_mean[i] = dval;
}
if (ret != DB_OK) {
G_warning(_("No record for point (cat = %d)"),
cat);
continue;
}
}
else {
obsVect[i][2] = observ[i].coordZ;
obs_mean[i] = observ[i].coordZ;
}
} /* i index */
/* Mean calculation for every point less the last one */
mean_reg = calc_mean(obs_mean, ndata - 1);
for (i = 0; i < ndata; i++)
obsVect[i][2] -= mean_reg;
/* This is left out */
out_x = observ[ndata - 1].coordX;
out_y = observ[ndata - 1].coordY;
out_z = obsVect[ndata - 1][2];
if (bilin) { /* Bilinear interpolation */
normalDefBilin(N, TN, Q, obsVect, passWE, passNS, nsplx,
nsply, region.west, region.south,
ndata - 1, nparam_spl, BW);
nCorrectGrad(N, lambda[lbd], nsplx, nsply, passWE,
passNS);
}
else { /* Bicubic interpolation */
normalDefBicubic(N, TN, Q, obsVect, passWE, passNS, nsplx,
nsply, region.west, region.south,
ndata - 1, nparam_spl, BW);
nCorrectGrad(N, lambda[lbd], nsplx, nsply, passWE,
passNS);
}
/*
if (bilin) interpolation (&interp, P_BILINEAR);
else interpolation (&interp, P_BICUBIC);
*/
G_set_verbose(G_verbose_min());
G_math_solver_cholesky_sband(N, parVect, TN, nparam_spl, BW);
G_set_verbose(verbosity);
/* Estimation of j-point */
if (bilin)
stat_vect.estima[j] =
dataInterpolateBilin(out_x, out_y, passWE, passNS,
nsplx, nsply, region.west,
region.south, parVect);
else
stat_vect.estima[j] =
dataInterpolateBilin(out_x, out_y, passWE, passNS,
nsplx, nsply, region.west,
region.south, parVect);
/* Difference between estimated and observated i-point */
stat_vect.error[j] = out_z - stat_vect.estima[j];
G_debug(1, "CrossCorrelation: stat_vect.error[%d] = %lf", j,
stat_vect.error[j]);
/* Once the last value is left out, it is swapped with j-value */
observ = swap(observ, j, ndata - 1);
G_percent(j, ndata, 2);
}
mean[lbd] = calc_mean(stat_vect.error, stat_vect.n_points);
rms[lbd] =
calc_root_mean_square(stat_vect.error, stat_vect.n_points);
stdev[lbd] =
calc_standard_deviation(stat_vect.error, stat_vect.n_points);
G_message(_("Mean = %.5lf"), mean[lbd]);
G_message(_("Root Mean Square (RMS) = %.5lf"),
rms[lbd]);
G_message("---");
} /* ENDFOR each lambda value */
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_free_matrix(obsVect);
G_free_vector(parVect);
#ifdef nodef
/*TODO: if the minimum lambda is wanted, the function declaration must be changed */
/* At this moment, consider rms only */
rms_min = find_minimum(rms, &lbd_min);
stdev_min = find_minimum(stdev, &lbd_min);
/* Writing some output */
G_message(_("Different number of splines and lambda_i values have "
"been taken for the cross correlation"));
G_message(_("The minimum value for the test (rms=%lf) was "
"obtained with: lambda_i = %.3f"),
rms_min,
lambda[lbd_min]);
*lambda_min = lambda[lbd_min];
#endif
G_message(_("Table of results:"));
fprintf(stdout, _(" lambda | mean | rms |\n"));
for (lbd = 0; lbd < PARAM_LAMBDA; lbd++) {
fprintf(stdout, " %9.5f | %10.4f | %10.4f |\n", lambda[lbd],
mean[lbd], rms[lbd]);
}
G_free_vector(mean);
G_free_vector(rms);
} /* ENDIF (ndata > 0) */
else
G_warning(_("No point lies into the current region"));
G_free(observ);
return TRUE;
}
/*--------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variable declarations */
int nsply, nsplx, nrows, ncols, nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row, subregion_row, subregion_col;
int subregion = 0, nsubregions = 0;
int last_row, last_column, grid, bilin, ext, flag_auxiliar, cross; /* booleans */
double stepN, stepE, lambda, mean;
double N_extension, E_extension, edgeE, edgeN;
const char *mapset, *drv, *db, *vector, *map;
char table_name[GNAME_MAX], title[64];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int dim_vect, nparameters, BW;
int *lineVect; /* Vector restoring primitive's ID */
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
SEGMENT out_seg, mask_seg;
const char *out_file, *mask_file;
int out_fd, mask_fd;
double seg_size;
int seg_mb, segments_in_memory;
int have_mask;
/* Structs declarations */
int raster;
struct Map_info In, In_ext, Out;
struct History history;
struct GModule *module;
struct Option *in_opt, *in_ext_opt, *out_opt, *out_map_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *type_opt, *dfield_opt, *col_opt, *mask_opt,
*memory_opt, *solver, *error, *iter;
struct Flag *cross_corr_flag, *spline_step_flag;
struct Reg_dimens dims;
struct Cell_head elaboration_reg, original_reg;
struct bound_box general_box, overlap_box, original_box;
struct Point *observ;
struct line_cats *Cats;
dbCatValArray cvarr;
int with_z;
int nrec, ctype = 0;
struct field_info *Fi;
dbDriver *driver, *driver_cats;
/*----------------------------------------------------------------*/
/* Options declarations */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("surface"));
G_add_keyword(_("interpolation"));
G_add_keyword(_("LIDAR"));
module->description =
_("Performs bicubic or bilinear spline interpolation with Tykhonov regularization.");
cross_corr_flag = G_define_flag();
cross_corr_flag->key = 'c';
cross_corr_flag->description =
_("Find the best Tykhonov regularizing parameter using a \"leave-one-out\" cross validation method");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->label = _("Name of input vector point map");
dfield_opt = G_define_standard_option(G_OPT_V_FIELD);
dfield_opt->guisection = _("Settings");
col_opt = G_define_standard_option(G_OPT_DB_COLUMN);
col_opt->required = NO;
col_opt->label =
_("Name of the attribute column with values to be used for approximation");
col_opt->description = _("If not given and input is 3D vector map then z-coordinates are used.");
col_opt->guisection = _("Settings");
in_ext_opt = G_define_standard_option(G_OPT_V_INPUT);
in_ext_opt->key = "sparse_input";
in_ext_opt->required = NO;
in_ext_opt->label =
_("Name of input vector map with sparse points");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->required = NO;
out_opt->guisection = _("Outputs");
out_map_opt = G_define_standard_option(G_OPT_R_OUTPUT);
out_map_opt->key = "raster_output";
out_map_opt->required = NO;
out_map_opt->guisection = _("Outputs");
mask_opt = G_define_standard_option(G_OPT_R_INPUT);
mask_opt->key = "mask";
mask_opt->label = _("Raster map to use for masking (applies to raster output only)");
mask_opt->description = _("Only cells that are not NULL and not zero are interpolated");
mask_opt->required = NO;
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "4";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "4";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
type_opt = G_define_option();
type_opt->key = "method";
type_opt->description = _("Spline interpolation algorithm");
type_opt->type = TYPE_STRING;
type_opt->options = "bilinear,bicubic";
type_opt->answer = "bilinear";
type_opt->guisection = _("Settings");
G_asprintf((char **) &(type_opt->descriptions),
"bilinear;%s;bicubic;%s",
_("Bilinear interpolation"),
_("Bicubic interpolation"));
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda_i";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description = _("Tykhonov regularization parameter (affects smoothing)");
lambda_f_opt->answer = "0.01";
lambda_f_opt->guisection = _("Settings");
solver = N_define_standard_option(N_OPT_SOLVER_SYMM);
solver->options = "cholesky,cg";
solver->answer = "cholesky";
iter = N_define_standard_option(N_OPT_MAX_ITERATIONS);
error = N_define_standard_option(N_OPT_ITERATION_ERROR);
memory_opt = G_define_option();
memory_opt->key = "memory";
memory_opt->type = TYPE_INTEGER;
memory_opt->required = NO;
memory_opt->answer = "300";
memory_opt->label = _("Maximum memory to be used (in MB)");
memory_opt->description = _("Cache size for raster rows");
/*----------------------------------------------------------------*/
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
vector = out_opt->answer;
map = out_map_opt->answer;
if (vector && map)
G_fatal_error(_("Choose either vector or raster output, not both"));
if (!vector && !map && !cross_corr_flag->answer)
G_fatal_error(_("No raster or vector or cross-validation output"));
if (!strcmp(type_opt->answer, "linear"))
bilin = P_BILINEAR;
else
bilin = P_BICUBIC;
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
flag_auxiliar = FALSE;
drv = db_get_default_driver_name();
if (!drv) {
if (db_set_default_connection() != DB_OK)
G_fatal_error(_("Unable to set default DB connection"));
drv = db_get_default_driver_name();
}
db = db_get_default_database_name();
if (!db)
G_fatal_error(_("No default DB defined"));
/* Set auxiliary table's name */
if (vector) {
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
}
/* Something went wrong in a previous v.surf.bspline execution */
if (db_table_exists(drv, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(drv, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
drv);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliary table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
bspline_field = 0; /* assume 3D input */
bspline_column = col_opt->answer;
with_z = !bspline_column && Vect_is_3d(&In);
if (Vect_is_3d(&In)) {
if (!with_z)
G_verbose_message(_("Input is 3D: using attribute values instead of z-coordinates for approximation"));
else
G_verbose_message(_("Input is 3D: using z-coordinates for approximation"));
}
else { /* 2D */
if (!bspline_column)
G_fatal_error(_("Input vector map is 2D. Parameter <%s> required."), col_opt->key);
}
if (!with_z) {
bspline_field = Vect_get_field_number(&In, dfield_opt->answer);
}
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
fprintf(stdout, _("Estimated point density: %.4g"), dens);
fprintf(stdout, _("Estimated mean distance between points: %.4g"), dist);
}
else {
fprintf(stdout, _("No points in current region"));
}
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/*----------------------------------------------------------------*/
/* Cross-correlation begins */
if (cross_corr_flag->answer) {
G_debug(1, "CrossCorrelation()");
cross = cross_correlation(&In, stepE, stepN);
if (cross != TRUE)
G_fatal_error(_("Cross validation didn't finish correctly"));
else {
G_debug(1, "Cross validation finished correctly");
Vect_close(&In);
G_done_msg(_("Cross validation finished for ew_step = %f and ns_step = %f"), stepE, stepN);
exit(EXIT_SUCCESS);
}
}
/* Open input ext vector */
ext = FALSE;
if (in_ext_opt->answer) {
ext = TRUE;
G_message(_("Vector map <%s> of sparse points will be interpolated"),
in_ext_opt->answer);
if ((mapset = G_find_vector2(in_ext_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_ext_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In_ext, in_ext_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
}
/* Open output map */
/* vector output */
if (vector && !map) {
if (strcmp(drv, "dbf") == 0)
G_fatal_error(_("Sorry, the <%s> driver is not compatible with "
"the vector output of this module. "
"Try with raster output or another driver."), drv);
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
grid = FALSE;
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z))
G_fatal_error(_("Unable to create vector map <%s>"),
out_opt->answer);
/* Copy vector Head File */
if (ext == FALSE) {
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
}
else {
Vect_copy_head_data(&In_ext, &Out);
Vect_hist_copy(&In_ext, &Out);
}
Vect_hist_command(&Out);
G_verbose_message(_("Points in input vector map <%s> will be interpolated"),
vector);
}
/* read z values from attribute table */
if (bspline_field > 0) {
G_message(_("Reading values from attribute table..."));
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&In, bspline_field);
if (Fi == NULL)
G_fatal_error(_("Cannot read layer info"));
driver_cats = db_start_driver_open_database(Fi->driver, Fi->database);
/*G_debug (0, _("driver=%s db=%s"), Fi->driver, Fi->database); */
if (driver_cats == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver_cats);
nrec =
db_select_CatValArray(driver_cats, Fi->table, Fi->key,
col_opt->answer, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message(_("%d records selected from table"), nrec);
db_close_database_shutdown_driver(driver_cats);
}
/*----------------------------------------------------------------*/
/* Interpolation begins */
G_debug(1, "Interpolation()");
/* Open driver and database */
driver = db_start_driver_open_database(drv, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. "
"Run db.connect."), drv);
db_set_error_handler_driver(driver);
/* Create auxiliary table */
if (vector) {
if ((flag_auxiliar = P_Create_Aux4_Table(driver, table_name)) == FALSE) {
P_Drop_Aux_Table(driver, table_name);
G_fatal_error(_("Interpolation: Creating table: "
"It was impossible to create table <%s>."),
table_name);
}
/* db_create_index2(driver, table_name, "ID"); */
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(drv, db);
}
/* raster output */
raster = -1;
Rast_set_fp_type(DCELL_TYPE);
if (!vector && map) {
grid = TRUE;
raster = Rast_open_fp_new(out_map_opt->answer);
G_verbose_message(_("Cells for raster map <%s> will be interpolated"),
map);
}
/* Setting regions and boxes */
G_debug(1, "Interpolation: Setting regions and boxes");
G_get_window(&original_reg);
G_get_window(&elaboration_reg);
Vect_region_box(&original_reg, &original_box);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Alloc raster matrix */
have_mask = 0;
out_file = mask_file = NULL;
out_fd = mask_fd = -1;
if (grid == TRUE) {
int row;
DCELL *drastbuf;
seg_mb = atoi(memory_opt->answer);
if (seg_mb < 3)
G_fatal_error(_("Memory in MB must be >= 3"));
if (mask_opt->answer)
seg_size = sizeof(double) + sizeof(char);
else
seg_size = sizeof(double);
seg_size = (seg_size * SEGSIZE * SEGSIZE) / (1 << 20);
segments_in_memory = seg_mb / seg_size + 0.5;
G_debug(1, "%d %dx%d segments held in memory", segments_in_memory, SEGSIZE, SEGSIZE);
out_file = G_tempfile();
out_fd = creat(out_file, 0666);
if (Segment_format(out_fd, nrows, ncols, SEGSIZE, SEGSIZE, sizeof(double)) != 1)
G_fatal_error(_("Can not create temporary file"));
close(out_fd);
out_fd = open(out_file, 2);
if (Segment_init(&out_seg, out_fd, segments_in_memory) != 1)
G_fatal_error(_("Can not initialize temporary file"));
/* initialize output */
G_message(_("Initializing output..."));
drastbuf = Rast_allocate_buf(DCELL_TYPE);
Rast_set_d_null_value(drastbuf, ncols);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Segment_put_row(&out_seg, drastbuf, row);
}
G_percent(row, nrows, 2);
if (mask_opt->answer) {
int row, col, maskfd;
DCELL dval, *drastbuf;
char mask_val;
G_message(_("Load masking map"));
mask_file = G_tempfile();
mask_fd = creat(mask_file, 0666);
if (Segment_format(mask_fd, nrows, ncols, SEGSIZE, SEGSIZE, sizeof(char)) != 1)
G_fatal_error(_("Can not create temporary file"));
close(mask_fd);
mask_fd = open(mask_file, 2);
if (Segment_init(&mask_seg, mask_fd, segments_in_memory) != 1)
G_fatal_error(_("Can not initialize temporary file"));
maskfd = Rast_open_old(mask_opt->answer, "");
drastbuf = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_d_row(maskfd, drastbuf, row);
for (col = 0; col < ncols; col++) {
dval = drastbuf[col];
if (Rast_is_d_null_value(&dval) || dval == 0)
mask_val = 0;
else
mask_val = 1;
Segment_put(&mask_seg, &mask_val, row, col);
}
}
G_percent(row, nrows, 2);
G_free(drastbuf);
Rast_close(maskfd);
have_mask = 1;
}
}
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims); /* Set dim struct to zero */
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(bilin, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("Adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("Adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
/* Creating line and categories structs */
Cats = Vect_new_cats_struct();
Vect_cat_set(Cats, 1, 0);
subregion_row = 0;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each subregion row */
subregion_row++;
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
G_debug(1, "Interpolation: nsply = %d", nsply);
/*
if (nsply > NSPLY_MAX)
nsply = NSPLY_MAX;
*/
elaboration_reg.east = original_reg.west;
last_column = FALSE;
subregion_col = 0;
/* TODO: process each subregion using its own thread (via OpenMP or pthreads) */
/* I'm not sure about pthreads, but you can tell OpenMP to start all at the
same time and it will keep num_workers supplied with the next job as free
cpus become available */
while (last_column == FALSE) { /* For each subregion column */
int npoints = 0;
/* needed for sparse points interpolation */
int npoints_ext, *lineVect_ext = NULL;
double **obsVect_ext; /*, mean_ext = .0; */
struct Point *observ_ext;
subregion_col++;
subregion++;
if (nsubregions > 1)
G_message(_("Processing subregion %d of %d..."), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east -
elaboration_reg.west) / stepE) + 0.5;
G_debug(1, "Interpolation: nsplx = %d", nsplx);
/*
if (nsplx > NSPLX_MAX)
nsplx = NSPLX_MAX;
*/
G_debug(1, "Interpolation: (%d,%d): subregion bounds",
subregion_row, subregion_col);
G_debug(1, "Interpolation: \t\tNORTH:%.2f\t",
elaboration_reg.north);
G_debug(1, "Interpolation: WEST:%.2f\t\tEAST:%.2f",
elaboration_reg.west, elaboration_reg.east);
G_debug(1, "Interpolation: \t\tSOUTH:%.2f",
elaboration_reg.south);
#ifdef DEBUG_SUBREGIONS
fprintf(stdout, "B 5\n");
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.north);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.west, elaboration_reg.north);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.west, elaboration_reg.south);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.south);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.north);
fprintf(stdout, "C 1 1\n");
fprintf(stdout, " %.11g %.11g\n", (elaboration_reg.west + elaboration_reg.east) / 2,
(elaboration_reg.south + elaboration_reg.north) / 2);
fprintf(stdout, " 1 %d\n", subregion);
#endif
/* reading points in interpolation region */
dim_vect = nsplx * nsply;
observ_ext = NULL;
if (grid == FALSE && ext == TRUE) {
observ_ext =
P_Read_Vector_Region_Map(&In_ext,
&elaboration_reg,
&npoints_ext, dim_vect,
1);
}
else
npoints_ext = 1;
if (grid == TRUE && have_mask) {
/* any unmasked cells in general region ? */
mean = 0;
observ_ext =
P_Read_Raster_Region_masked(&mask_seg, &original_reg,
original_box, general_box,
&npoints_ext, dim_vect, mean);
}
observ = NULL;
if (npoints_ext > 0) {
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, bspline_field);
}
else
npoints = 1;
G_debug(1,
"Interpolation: (%d,%d): Number of points in <elaboration_box> is %d",
subregion_row, subregion_col, npoints);
if (npoints > 0)
G_verbose_message(_("%d points found in this subregion"), npoints);
/* only interpolate if there are any points in current subregion */
if (npoints > 0 && npoints_ext > 0) {
int i;
nparameters = nsplx * nsply;
BW = P_get_BandWidth(bilin, nsply);
/* Least Squares system */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Parameters vector */
obsVect = G_alloc_matrix(npoints, 3); /* Observation vector */
Q = G_alloc_vector(npoints); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints); /* */
for (i = 0; i < npoints; i++) { /* Setting obsVect vector & Q matrix */
double dval;
Q[i] = 1; /* Q=I */
lineVect[i] = observ[i].lineID;
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
/* read z coordinates from attribute table */
if (bspline_field > 0) {
int cat, ival, ret;
cat = observ[i].cat;
if (cat < 0)
continue;
if (ctype == DB_C_TYPE_INT) {
ret =
db_CatValArray_get_value_int(&cvarr, cat,
&ival);
obsVect[i][2] = ival;
observ[i].coordZ = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret =
db_CatValArray_get_value_double(&cvarr, cat,
&dval);
obsVect[i][2] = dval;
observ[i].coordZ = dval;
}
if (ret != DB_OK) {
G_warning(_("Interpolation: (%d,%d): No record for point (cat = %d)"),
subregion_row, subregion_col, cat);
continue;
}
}
/* use z coordinates of 3D vector */
else {
obsVect[i][2] = observ[i].coordZ;
}
}
/* Mean calculation for every point */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
G_debug(1, "Interpolation: (%d,%d): mean=%lf",
subregion_row, subregion_col, mean);
G_free(observ);
for (i = 0; i < npoints; i++)
obsVect[i][2] -= mean;
/* Bilinear interpolation */
if (bilin) {
G_debug(1,
"Interpolation: (%d,%d): Bilinear interpolation...",
subregion_row, subregion_col);
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints,
nparameters, BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
}
/* Bicubic interpolation */
else {
G_debug(1,
"Interpolation: (%d,%d): Bicubic interpolation...",
subregion_row, subregion_col);
normalDefBicubic(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints,
nparameters, BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
}
if(G_strncasecmp(solver->answer, "cg", 2) == 0)
G_math_solver_cg_sband(N, parVect, TN, nparameters, BW, atoi(iter->answer), atof(error->answer));
else
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
if (grid == TRUE) { /* GRID INTERPOLATION ==> INTERPOLATION INTO A RASTER */
G_debug(1, "Interpolation: (%d,%d): Regular_Points...",
subregion_row, subregion_col);
if (!have_mask) {
P_Regular_Points(&elaboration_reg, &original_reg, general_box,
overlap_box, &out_seg, parVect,
stepN, stepE, dims.overlap, mean,
nsplx, nsply, nrows, ncols, bilin);
}
else {
P_Sparse_Raster_Points(&out_seg,
&elaboration_reg, &original_reg,
general_box, overlap_box,
observ_ext, parVect,
stepE, stepN,
dims.overlap, nsplx, nsply,
npoints_ext, bilin, mean);
}
}
else { /* OBSERVATION POINTS INTERPOLATION */
if (ext == FALSE) {
G_debug(1, "Interpolation: (%d,%d): Sparse_Points...",
subregion_row, subregion_col);
P_Sparse_Points(&Out, &elaboration_reg, general_box,
overlap_box, obsVect, parVect,
lineVect, stepE, stepN,
dims.overlap, nsplx, nsply, npoints,
bilin, Cats, driver, mean,
table_name);
}
else { /* FLAG_EXT == TRUE */
/* done that earlier */
/*
int npoints_ext, *lineVect_ext = NULL;
double **obsVect_ext;
struct Point *observ_ext;
observ_ext =
P_Read_Vector_Region_Map(&In_ext,
&elaboration_reg,
&npoints_ext, dim_vect,
1);
*/
obsVect_ext = G_alloc_matrix(npoints_ext, 3); /* Observation vector_ext */
lineVect_ext = G_alloc_ivector(npoints_ext);
for (i = 0; i < npoints_ext; i++) { /* Setting obsVect_ext vector & Q matrix */
obsVect_ext[i][0] = observ_ext[i].coordX;
obsVect_ext[i][1] = observ_ext[i].coordY;
obsVect_ext[i][2] = observ_ext[i].coordZ - mean;
lineVect_ext[i] = observ_ext[i].lineID;
}
G_free(observ_ext);
G_debug(1, "Interpolation: (%d,%d): Sparse_Points...",
subregion_row, subregion_col);
P_Sparse_Points(&Out, &elaboration_reg, general_box,
overlap_box, obsVect_ext, parVect,
lineVect_ext, stepE, stepN,
dims.overlap, nsplx, nsply,
npoints_ext, bilin, Cats, driver,
mean, table_name);
G_free_matrix(obsVect_ext);
G_free_ivector(lineVect_ext);
} /* END FLAG_EXT == TRUE */
} /* END GRID == FALSE */
G_free_vector(parVect);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
}
else {
if (observ)
G_free(observ);
if (observ_ext)
G_free(observ_ext);
if (npoints == 0)
G_warning(_("No data within this subregion. "
"Consider increasing spline step values."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
G_verbose_message(_("Writing output..."));
/* Writing the output raster map */
if (grid == TRUE) {
int row, col;
DCELL *drastbuf, dval;
if (have_mask) {
Segment_release(&mask_seg); /* release memory */
close(mask_fd);
unlink(mask_file);
}
drastbuf = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col < ncols; col++) {
Segment_get(&out_seg, &dval, row, col);
drastbuf[col] = dval;
}
Rast_put_d_row(raster, drastbuf);
}
Rast_close(raster);
Segment_release(&out_seg); /* release memory */
close(out_fd);
unlink(out_file);
/* set map title */
sprintf(title, "%s interpolation with Tykhonov regularization",
type_opt->answer);
Rast_put_cell_title(out_map_opt->answer, title);
/* write map history */
Rast_short_history(out_map_opt->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(out_map_opt->answer, &history);
}
/* Writing to the output vector map the points from the overlapping zones */
else if (flag_auxiliar == TRUE) {
if (ext == FALSE)
P_Aux_to_Vector(&In, &Out, driver, table_name);
else
P_Aux_to_Vector(&In_ext, &Out, driver, table_name);
/* Drop auxiliary table */
G_debug(1, "%s: Dropping <%s>", argv[0], table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliary table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
if (ext != FALSE)
Vect_close(&In_ext);
if (vector)
Vect_close(&Out);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*END MAIN */
/*!
\brief transform 2d vector features to 3d
\param In input vector
\param Out output vector
\param type feature type to be transformed
\param height fixed height (used only if column is NULL)
\param field layer number
\param column attribute column used for height
*/
void trans2d(struct Map_info *In, struct Map_info *Out, int type,
double height, const char *field_name, const char *column)
{
int i, ltype, line, field;
int cat;
int ret, ctype;
struct line_pnts *Points;
struct line_cats *Cats;
dbCatValArray cvarr;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_CatValArray_init(&cvarr);
field = Vect_get_field_number(In, field_name);
if (column) {
struct field_info *Fi;
dbDriver *driver;
if (field == -1) {
G_warning(_("Invalid layer number %d, assuming 1"), field);
field = 1;
}
Fi = Vect_get_field(In, field);
if (!Fi) {
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_name);
}
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
db_set_error_handler_driver(driver);
/* column type must numeric */
ctype = db_column_Ctype(driver, Fi->table, column);
if (ctype == -1) {
G_fatal_error(_("Column <%s> not found in table <%s>"),
column, Fi->table);
}
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE) {
G_fatal_error(_("Column must be numeric"));
}
G_message(_("Fetching height from <%s> column..."), column);
db_select_CatValArray(driver, Fi->table, Fi->key,
column, NULL, &cvarr);
G_debug(3, "%d records selected", cvarr.n_values);
db_close_database_shutdown_driver(driver);
}
G_message(_("Transforming features..."));
line = 1;
while (1) {
ltype = Vect_read_next_line(In, Points, Cats);
if (ltype == -1) {
G_fatal_error(_("Unable to read vector map"));
}
if (ltype == -2) { /* EOF */
break;
}
G_progress(line, 1000);
if (!(ltype & type))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, &cat))
continue;
if (column) {
Vect_cat_get(Cats, field, &cat);
if (cat < 0) {
G_warning(_("Skipping feature without category"));
continue;
}
if (ctype == DB_C_TYPE_DOUBLE)
ret = db_CatValArray_get_value_double(&cvarr, cat, &height);
else { /* integer */
int height_i;
ret = db_CatValArray_get_value_int(&cvarr, cat, &height_i);
height = (double)height_i;
}
if (ret != DB_OK)
G_warning(_("Unable to get height for feature category %d"),
cat);
}
for (i = 0; i < Points->n_points; i++) {
Points->z[i] = height;
}
Vect_write_line(Out, ltype, Points, Cats);
line++;
}
G_progress(1, 1);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
}
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;
}
int read_points(const char *name, const char *field_name, const char *col, std::map<Point, Coord_type, K::Less_xy_2>& function_values,
std::vector<K::Point_2>& OutPoints)
{
int nrec, ctype = 0, npoints, field, with_z;
double x, y, z;
Point p;
struct Map_info Map;
struct field_info *Fi;
struct line_pnts *Points;
struct line_cats *Cats;
dbDriver *Driver;
dbCatValArray cvarr;
Vect_set_open_level(1); /* without topology */
if (Vect_open_old2(&Map, name, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), name);
field = Vect_get_field_number(&Map, field_name);
with_z = col == NULL && Vect_is_3d(&Map); /* read z-coordinates
only when column is
not defined */
if (!col) {
if (!with_z)
G_important_message(_("Input vector map <%s> is 2D - using categories to interpolate"),
Vect_get_full_name(&Map));
else
G_important_message(_("Input vector map <%s> is 3D - using z-coordinates to interpolate"),
Vect_get_full_name(&Map));
}
if (col) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %s"), field_name);
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, col, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message("One record selected from table %d records selected from table", nrec);
db_close_database_shutdown_driver(Driver);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* set constraints */
Vect_set_constraint_type(&Map, GV_POINTS);
if (field > 0)
Vect_set_constraint_field(&Map, field);
/* read points */
npoints = 0;
G_message(_("Reading points..."));
while(TRUE) {
double dval;
if (Vect_read_next_line(&Map, Points, Cats) < 0)
break;
G_progress(npoints, 1e3);
if (Points->n_points != 1) {
G_warning(_("Invalid point skipped"));
continue;
}
if (!with_z) {
int cat, ival, ret;
/* TODO: what to do with multiple cats */
Vect_cat_get(Cats, field, &cat);
if (cat < 0) /* skip features without category */
continue;
if (col) {
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &ival);
dval = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
}
if (ret != DB_OK) {
G_warning(_("No record for point (cat = %d)"), cat);
continue;
}
}
else {
dval = cat;
}
}
else
dval = Points->z[0];
x = Points->x[0];
y = Points->y[0];
p = Point(x,y);
OutPoints.push_back(p);
function_values.insert(std::make_pair(p, dval));
G_debug(3, "new point added: %f, %f, %f", x, y, dval);
npoints++;
}
G_progress(1, 1);
if (col)
db_CatValArray_free(&cvarr);
Vect_set_release_support(&Map);
Vect_close(&Map);
Vect_destroy_line_struct(Points);
G_debug(1, "read_points(): %d", npoints);
G_message("%d point loaded", npoints);
return npoints;
}
int do_areas(struct Map_info *Map, struct line_pnts *Points,
dbCatValArray * Cvarr, int ctype, int use,
double value, int value_type)
{
int i;
CELL cval, cat;
DCELL dval;
if (nareas <= 0)
return 0;
G_important_message(_("Reading areas..."));
for (i = 0; i < nareas; i++) {
/* Note: in old version (grass5.0) there was a check here if the current area
* is identical to previous one. I don't see any reason for this in topological vectors */
G_percent(i, nareas, 2);
cat = list[i].cat;
G_debug(3, "Area cat = %d", cat);
if (ISNULL(&cat)) { /* No centroid or no category */
set_cat(cat);
}
else {
if (use == USE_ATTR) {
if (ctype == DB_C_TYPE_INT) {
if ((db_CatValArray_get_value_int(Cvarr, cat, &cval)) !=
DB_OK) {
G_warning(_("No record for area (cat = %d)"), cat);
SETNULL(&cval);
}
set_cat(cval);
}
else if (ctype == DB_C_TYPE_DOUBLE) {
if ((db_CatValArray_get_value_double(Cvarr, cat, &dval))
!= DB_OK) {
G_warning(_("No record for area (cat = %d)"), cat);
SETDNULL(&dval);
}
set_dcat(dval);
}
else {
G_fatal_error(_("Unable to use column specified"));
}
}
else if (use == USE_CAT) {
set_cat(cat);
}
else {
if (value_type == CELL_TYPE)
set_cat((int)value);
else
set_dcat(value);
}
}
if (Vect_get_area_points(Map, list[i].index, Points) <= 0) {
G_warning(_("Get area %d failed"), list[i].index);
return -1;
}
G_plot_polygon(Points->x, Points->y, Points->n_points);
}
G_percent(1, 1, 1);
return nareas;
}
int main(int argc, char **argv)
{
int i, nsites, warn_once = 0;
int all;
long x, y;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *tests, *dfield, *layer;
} parm;
struct
{
struct Flag *q, *l, *region;
} flag;
double *w, *z;
struct Map_info Map;
int line, nlines, npoints;
int field;
struct line_pnts *Points;
struct line_cats *Cats;
struct bound_box box;
/* Attributes */
int nrecords;
int ctype;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("points"));
G_add_keyword(_("point pattern"));
module->description = _("Tests for normality for vector points.");
parm.input = G_define_standard_option(G_OPT_V_MAP);
parm.layer = G_define_standard_option(G_OPT_V_FIELD);
parm.tests = G_define_option();
parm.tests->key = "tests";
parm.tests->key_desc = "range";
parm.tests->type = TYPE_STRING;
parm.tests->multiple = YES;
parm.tests->required = YES;
parm.tests->label = _("Lists of tests (1-15)");
parm.tests->description = _("E.g. 1,3-8,13");
parm.dfield = G_define_standard_option(G_OPT_DB_COLUMN);
parm.dfield->required = YES;
flag.region = G_define_flag();
flag.region->key = 'r';
flag.region->description = _("Use only points in current region");
flag.l = G_define_flag();
flag.l->key = 'l';
flag.l->description = _("Lognormality instead of normality");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
all = flag.region->answer ? 0 : 1;
/* Open input */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, parm.input->answer, "", parm.layer->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), parm.input->answer);
field = Vect_get_field_number(&Map, parm.layer->answer);
/* Read attributes */
Fi = Vect_get_field(&Map, field);
if (Fi == NULL) {
G_fatal_error("Database connection not defined for layer %d", field);
}
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);
nrecords = db_select_CatValArray(Driver, Fi->table, Fi->key, parm.dfield->answer,
NULL, &cvarr);
G_debug(1, "nrecords = %d", nrecords);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Only numeric column type supported"));
if (nrecords < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message(_("%d records selected from table"), nrecords);
db_close_database_shutdown_driver(Driver);
/* Read points */
npoints = Vect_get_num_primitives(&Map, GV_POINT);
z = (double *)G_malloc(npoints * sizeof(double));
G_get_window(&window);
Vect_region_box(&window, &box);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(&Map);
nsites = 0;
for (line = 1; line <= nlines; line++) {
int type, cat, ret, cval;
double dval;
G_debug(3, "line = %d", line);
type = Vect_read_line(&Map, Points, Cats, line);
if (!(type & GV_POINT))
continue;
if (!all) {
if (!Vect_point_in_box(Points->x[0], Points->y[0], 0.0, &box))
continue;
}
Vect_cat_get(Cats, 1, &cat);
G_debug(3, "cat = %d", cat);
/* find actual value */
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &cval);
if (ret != DB_OK) {
G_warning(_("No record for cat %d"), cat);
continue;
}
dval = cval;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
if (ret != DB_OK) {
G_warning(_("No record for cat %d"), cat);
continue;
}
}
G_debug(3, "dval = %e", dval);
z[nsites] = dval;
nsites++;
}
G_verbose_message(_("Number of points: %d"), nsites);
if (nsites <= 0)
G_fatal_error(_("No points found"));
if (nsites < 4)
G_warning(_("Too small sample"));
if (flag.l->answer) {
warn_once = 0;
for (i = 0; i < nsites; ++i) {
if (z[i] > 1.0e-10)
z[i] = log10(z[i]);
else if (!warn_once) {
G_warning(_("Negative or very small point values set to -10.0"));
z[i] = -10.0;
warn_once = 1;
}
}
}
for (i = 0; parm.tests->answers[i]; i++)
if (!scan_cats(parm.tests->answers[i], &x, &y)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.tests->answers[i]; i++) {
scan_cats(parm.tests->answers[i], &x, &y);
while (x <= y)
switch (x++) {
case 1: /* moments */
fprintf(stdout, _("Moments \\sqrt{b_1} and b_2: "));
w = Cdhc_omnibus_moments(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 2: /* geary */
fprintf(stdout, _("Geary's a-statistic & an approx. normal: "));
w = Cdhc_geary_test(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 3: /* extreme deviates */
fprintf(stdout, _("Extreme normal deviates: "));
w = Cdhc_extreme(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 4: /* D'Agostino */
fprintf(stdout, _("D'Agostino's D & an approx. normal: "));
w = Cdhc_dagostino_d(z, nsites);
fprintf(stdout, "%g %g\n", w[0], w[1]);
break;
case 5: /* Kuiper */
fprintf(stdout,
_("Kuiper's V (regular & modified for normality): "));
w = Cdhc_kuipers_v(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 6: /* Watson */
fprintf(stdout,
_("Watson's U^2 (regular & modified for normality): "));
w = Cdhc_watson_u2(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 7: /* Durbin */
fprintf(stdout,
_("Durbin's Exact Test (modified Kolmogorov): "));
w = Cdhc_durbins_exact(z, nsites);
fprintf(stdout, "%g\n", w[0]);
break;
case 8: /* Anderson-Darling */
fprintf(stdout,
_("Anderson-Darling's A^2 (regular & modified for normality): "));
w = Cdhc_anderson_darling(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 9: /* Cramer-Von Mises */
fprintf(stdout,
_("Cramer-Von Mises W^2(regular & modified for normality): "));
w = Cdhc_cramer_von_mises(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 10: /* Kolmogorov-Smirnov */
fprintf(stdout,
_("Kolmogorov-Smirnov's D (regular & modified for normality): "));
w = Cdhc_kolmogorov_smirnov(z, nsites);
fprintf(stdout, "%g %g\n", w[1], w[0]);
break;
case 11: /* chi-square */
fprintf(stdout,
_("Chi-Square stat (equal probability classes) and d.f.: "));
w = Cdhc_chi_square(z, nsites);
fprintf(stdout, "%g %d\n", w[0], (int)w[1]);
break;
case 12: /* Shapiro-Wilk */
if (nsites > 50) {
G_warning(_("Shapiro-Wilk's W cannot be used for n > 50"));
if (nsites < 99)
G_message(_("Use Weisberg-Binghams's W''"));
}
else {
fprintf(stdout, _("Shapiro-Wilk W: "));
w = Cdhc_shapiro_wilk(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 13: /* Weisberg-Bingham */
if (nsites > 99 || nsites < 50)
G_warning(_("Weisberg-Bingham's W'' cannot be used for n < 50 or n > 99"));
else {
fprintf(stdout, _("Weisberg-Bingham's W'': "));
w = Cdhc_weisberg_bingham(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 14: /* Royston */
if (nsites > 2000)
G_warning(_("Royston only extended Shapiro-Wilk's W up to n = 2000"));
else {
fprintf(stdout, _("Shapiro-Wilk W'': "));
w = Cdhc_royston(z, nsites);
fprintf(stdout, "%g\n", w[0]);
}
break;
case 15: /* Kotz */
fprintf(stdout, _("Kotz' T'_f (Lognormality vs. Normality): "));
w = Cdhc_kotz_families(z, nsites);
fprintf(stdout, "%g\n", w[0]);
break;
default:
break;
}
}
exit(EXIT_SUCCESS);
}
