int dotest ()
{
int v,p;
double *d;
time_t tbegin, tput, tget;
alloc_vars();
qhashtbl_t *tbl = qhashtbl(range);
/* Put all data values with path/var into hashtable */
printf("============== PUT DATA INTO HASHTABLE ============\n");
time (&tbegin);
for (p=0; p<npaths; p++) {
for (v=0; v<nvars; v++) {
tbl->put2(tbl, varpaths[p], varnames[v], &data[p*nvars+v]);
}
}
time (&tput);
tput = tput - tbegin;
/* Get each element and check value */
printf("============== GET DATA FROM HASHTABLE ============\n");
time (&tbegin);
for (p=npaths-1; p>=0; p--) {
for (v=nvars-1; v>=0; v--) {
d = tbl->get2(tbl, varpaths[p], varnames[v]);
if (d == NULL) {
printf ("ERROR: stored value for p=%d,v=%d not found in hash table\n",
p, v);
return 1;
} else if (*d != data[p*nvars+v]) {
printf ("ERROR: for p=%d,v=%d, found value = %lf in hash table != "
"what was put in = %lf\n",
p, v, *d, data[p*nvars+v]);
return 2;
}
}
}
time (&tget);
tget = tget - tbegin;
printf("Timing: put %d elements in %ld seconds, got them back in %ld seconds\n",
npaths*nvars, (long)tput, (long)tget);
/* Print hashtable */
printf("============== PRINT HASHTABLE ============\n");
tbl->debug(tbl,NULL,0);
/* Free hashtable */
tbl->free(tbl);
free_vars();
return 0;
}
int main (int argc, char ** argv)
{
int err, step ;
int do_write = 1;
int do_read = 1;
int m = 0;
char write_method[16];
MPI_Init (&argc, &argv);
MPI_Comm_rank (comm, &rank);
MPI_Comm_size (comm, &size);
if (argc > 1) {
m = strtol (argv[1], NULL, 10);
if (errno) { printf("Invalid 1st argument %s\n", argv[1]); Usage(); return 1;}
}
if (argc > 2) {
if (argv[2][0] == 'w' || argv[2][0] == 'W') {
do_read = 0;
} else if (argv[2][0] == 'r' || argv[2][0] == 'R') {
do_write = 0;
} else {
printE ("Invalid command line argument %s. Allowed ones:\n"
" w: do write only\n"
" r: do read only\n", argv[2]);
MPI_Finalize ();
return 1;
}
}
if (m==0) {
read_method = ADIOS_READ_METHOD_BP;
strcpy(write_method,"MPI");
} else {
read_method = ADIOS_READ_METHOD_DATASPACES;
strcpy(write_method,"DATASPACES");
}
log ("Writing: %s method=%s\n"
"Reading: %s method=%d\n",
(do_write ? "yes" : "no"), write_method,
(do_read ? "yes" : "no"), read_method);
alloc_vars();
if (do_write) {
adios_init_noxml (comm);
adios_allocate_buffer (ADIOS_BUFFER_ALLOC_NOW, 10);
}
if (do_read) {
err = adios_read_init_method(read_method, comm, "verbose=2");
if (err) {
printE ("%s\n", adios_errmsg());
}
}
if (do_write) {
adios_declare_group (&m_adios_group, "selections", "iter", adios_flag_yes);
adios_select_method (m_adios_group, write_method, "verbose=2", "");
define_vars();
for (step=0; step<NSTEPS; step++) {
if (!err) {
set_vars (step);
err = write_file (step);
sleep(1);
}
}
adios_free_group (m_adios_group);
}
if (!err && do_read)
err = read_points ();
//if (!err && do_read)
// err = read_writerblocks ();
if (do_read) {
adios_read_finalize_method (read_method);
}
fini_vars();
if (do_write) {
adios_finalize (rank);
}
MPI_Finalize ();
return err;
}
int main (int argc, char ** argv)
{
int err,i,M;
int iconnect;
MPI_Init (&argc, &argv);
MPI_Comm_rank (wcomm, &wrank);
MPI_Comm_size (wcomm, &wsize);
if (argc < 2) { Usage(); return 1; }
errno = 0;
M = strtol (argv[1], NULL, 10);
if (errno || M < 1 || M > wsize) {
printE("Invalid 1st argument %s\n", argv[1]); Usage(); return 1;
}
iconnect = (wrank >= wsize-M); // connect to server from ranks N-M, N-M+1, ..., N
MPI_Comm_split (wcomm, iconnect, wrank+M-wsize, &subcomm);
MPI_Comm_rank (subcomm, &subrank);
MPI_Comm_size (subcomm, &subsize);
if (iconnect) {
if (subsize != M) {
printE ("Something wrong with communicator split: N=%d, M=%d, splitted size=%d\n",
wsize, M, subsize);
return 2;
}
log ("connect as subrank %d\n", subrank);
}
alloc_vars();
adios_read_init_method(ADIOS_READ_METHOD_DATASPACES, subcomm, "verbose=4");
adios_init_noxml (subcomm);
adios_allocate_buffer (ADIOS_BUFFER_ALLOC_NOW, 1);
if (iconnect)
{
adios_declare_group (&m_adios_group, "connect", "iter", adios_flag_yes);
adios_select_method (m_adios_group, "DATASPACES", "verbose=4", "");
adios_define_var (m_adios_group, "ldim1", "", adios_integer, 0, 0, 0);
adios_define_var (m_adios_group, "gdim1", "", adios_integer, 0, 0, 0);
adios_define_var (m_adios_group, "offs1", "", adios_integer, 0, 0, 0);
adios_define_var (m_adios_group, "a1", "", adios_integer,
"ldim1", "gdim1", "offs1");
for (i=0; i<NSTEPS; i++) {
if (!err) {
set_vars (i);
err = write_file (i);
}
}
}
log ("done with work, sync with others...\n");
MPI_Barrier (wcomm);
log ("call adios_finalize...\n");
adios_finalize (wrank);
log ("call adios_read_finalize_method...\n");
adios_read_finalize_method (ADIOS_READ_METHOD_DATASPACES);
fini_vars();
MPI_Finalize ();
return err;
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd;
char *name, *result;
char **mapname;
FCELL **fbuf;
int n_measures, n_outputs, *measure_idx;
int nrows, ncols;
int row, col, first_row, last_row, first_col, last_col;
int i, j;
CELL **data; /* Data structure containing image */
DCELL *dcell_row;
struct FPRange range;
DCELL min, max, inscale;
FCELL measure; /* Containing measure done */
int dist, size; /* dist = value of distance, size = s. of moving window */
int offset;
int have_px, have_py, have_sentr, have_pxpys, have_pxpyd;
int infd, *outfd;
RASTER_MAP_TYPE data_type, out_data_type;
struct GModule *module;
struct Option *opt_input, *opt_output, *opt_size, *opt_dist, *opt_measure;
struct Flag *flag_ind, *flag_all;
struct History history;
char p[1024];
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
G_add_keyword(_("texture"));
module->description =
_("Generate images with textural features from a raster map.");
module->overwrite = 1;
/* Define the different options */
opt_input = G_define_standard_option(G_OPT_R_INPUT);
opt_output = G_define_standard_option(G_OPT_R_BASENAME_OUTPUT);
opt_size = G_define_option();
opt_size->key = "size";
opt_size->key_desc = "value";
opt_size->type = TYPE_INTEGER;
opt_size->required = NO;
opt_size->description = _("The size of moving window (odd and >= 3)");
opt_size->answer = "3";
/* Textural character is in direct relation of the spatial size of the texture primitives. */
opt_dist = G_define_option();
opt_dist->key = "distance";
opt_dist->key_desc = "value";
opt_dist->type = TYPE_INTEGER;
opt_dist->required = NO;
opt_dist->description = _("The distance between two samples (>= 1)");
opt_dist->answer = "1";
for (i = 0; menu[i].name; i++) {
if (i)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[i].name);
}
opt_measure = G_define_option();
opt_measure->key = "method";
opt_measure->type = TYPE_STRING;
opt_measure->required = NO;
opt_measure->multiple = YES;
opt_measure->options = p;
opt_measure->description = _("Textural measurement method");
flag_ind = G_define_flag();
flag_ind->key = 's';
flag_ind->description = _("Separate output for each angle (0, 45, 90, 135)");
flag_all = G_define_flag();
flag_all->key = 'a';
flag_all->description = _("Calculate all textural measurements");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = opt_input->answer;
result = opt_output->answer;
size = atoi(opt_size->answer);
if (size <= 0)
G_fatal_error(_("Size of the moving window must be > 0"));
if (size % 2 != 1)
G_fatal_error(_("Size of the moving window must be odd"));
dist = atoi(opt_dist->answer);
if (dist <= 0)
G_fatal_error(_("The distance between two samples must be > 0"));
n_measures = 0;
if (flag_all->answer) {
for (i = 0; menu[i].name; i++) {
menu[i].useme = 1;
}
n_measures = i;
}
else {
for (i = 0; opt_measure->answers[i]; i++) {
if (opt_measure->answers[i]) {
const char *measure_name = opt_measure->answers[i];
int n = find_measure(measure_name);
menu[n].useme = 1;
n_measures++;
}
}
}
if (!n_measures)
G_fatal_error(_("Nothing to compute. Use at least one textural measure."));
measure_idx = G_malloc(n_measures * sizeof(int));
j = 0;
for (i = 0; menu[i].name; i++) {
if (menu[i].useme == 1) {
measure_idx[j] = menu[i].idx;
j++;
}
}
/* variables needed */
if (menu[2].useme || menu[11].useme || menu[12].useme)
have_px = 1;
else
have_px = 0;
if (menu[11].useme || menu[12].useme)
have_py = 1;
else
have_py = 0;
if (menu[6].useme || menu[7].useme)
have_sentr = 1;
else
have_sentr = 0;
if (menu[5].useme || menu[6].useme || menu[7].useme)
have_pxpys = 1;
else
have_pxpys = 0;
if (menu[9].useme || menu[10].useme)
have_pxpyd = 1;
else
have_pxpyd = 0;
infd = Rast_open_old(name, "");
/* determine the inputmap type (CELL/FCELL/DCELL) */
data_type = Rast_get_map_type(infd);
Rast_get_cellhd(name, "", &cellhd);
out_data_type = FCELL_TYPE;
/* Allocate output buffers, use FCELL data_type */
n_outputs = n_measures;
if (flag_ind->answer) {
n_outputs = n_measures * 4;
}
fbuf = G_malloc(n_outputs * sizeof(FCELL *));
mapname = G_malloc(n_outputs * sizeof(char *));
for (i = 0; i < n_outputs; i++) {
mapname[i] = G_malloc(GNAME_MAX * sizeof(char));
fbuf[i] = Rast_allocate_buf(out_data_type);
}
/* open output maps */
outfd = G_malloc(n_outputs * sizeof(int));
for (i = 0; i < n_measures; i++) {
if (flag_ind->answer) {
for (j = 0; j < 4; j++) {
sprintf(mapname[i * 4 + j], "%s%s_%d", result,
menu[measure_idx[i]].suffix, j * 45);
outfd[i * 4 + j] = Rast_open_new(mapname[i * 4 + j], out_data_type);
}
}
else {
sprintf(mapname[i], "%s%s", result,
menu[measure_idx[i]].suffix);
outfd[i] = Rast_open_new(mapname[i], out_data_type);
}
}
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Load raster map. */
/* allocate the space for one row of cell map data *A* */
dcell_row = Rast_allocate_d_buf();
/* Allocate appropriate memory for the structure containing the image */
data = (int **)G_malloc(nrows * sizeof(int *));
for (i = 0; i < nrows; i++) {
data[i] = (int *)G_malloc(ncols * sizeof(int));
}
/* read input range */
Rast_init_fp_range(&range);
Rast_read_fp_range(name, "", &range);
Rast_get_fp_range_min_max(&range, &min, &max);
inscale = 0;
if (min < 0 || max > 255) {
inscale = 255. / (max - min);
}
/* input has 0 - 1 range */
else if (max <= 1.) {
inscale = 255. / (max - min);
}
/* Read in cell map values */
/* TODO: use r.proj cache */
G_important_message(_("Reading raster map..."));
for (j = 0; j < nrows; j++) {
Rast_get_row(infd, dcell_row, j, DCELL_TYPE);
for (i = 0; i < ncols; i++) {
if (Rast_is_d_null_value(&(dcell_row[i])))
data[j][i] = -1;
else if (inscale) {
data[j][i] = (CELL)((dcell_row[i] - min) * inscale);
}
else
data[j][i] = (CELL)dcell_row[i];
}
}
/* close input cell map and release the row buffer */
Rast_close(infd);
G_free(dcell_row);
/* Now raster map is loaded to memory. */
/* *************************************************************************************************
*
* Compute of the matrix S.G.L.D. (Spatial Gray-Level Dependence Matrices) or co-occurrence matrix.
* The image is analized for piece, every piece is naming moving window (s.w.). The s.w. must be
* square with number of size's samples odd, that because we want the sample at the center of matrix.
*
***************************************************************************************************/
offset = size / 2;
first_row = first_col = offset;
last_row = nrows - offset;
last_col = ncols - offset;
Rast_set_f_null_value(fbuf[0], ncols);
for (row = 0; row < first_row; row++) {
for (i = 0; i < n_outputs; i++) {
Rast_put_row(outfd[i], fbuf[0], out_data_type);
}
}
if (n_measures > 1)
G_message(n_("Calculating %d texture measure",
"Calculating %d texture measures", n_measures), n_measures);
else
G_message(_("Calculating %s"), menu[measure_idx[0]].desc);
alloc_vars(size, dist);
for (row = first_row; row < last_row; row++) {
G_percent(row, nrows, 2);
for (i = 0; i < n_outputs; i++)
Rast_set_f_null_value(fbuf[i], ncols);
/*process the data */
for (col = first_col; col < last_col; col++) {
if (!set_vars(data, row, col, size, offset, dist)) {
for (i = 0; i < n_outputs; i++)
Rast_set_f_null_value(&(fbuf[i][col]), 1);
continue;
}
/* for all angles (0, 45, 90, 135) */
for (i = 0; i < 4; i++) {
set_angle_vars(i, have_px, have_py, have_sentr, have_pxpys, have_pxpyd);
/* for all requested textural measures */
for (j = 0; j < n_measures; j++) {
measure = (FCELL) h_measure(measure_idx[j]);
if (flag_ind->answer) {
/* output for each angle separately */
fbuf[j * 4 + i][col] = measure;
}
else {
/* use average over all angles for each measure */
if (i == 0)
fbuf[j][col] = measure;
else if (i < 3)
fbuf[j][col] += measure;
else
fbuf[j][col] = (fbuf[j][col] + measure) / 4.0;
}
}
}
}
for (i = 0; i < n_outputs; i++) {
Rast_put_row(outfd[i], fbuf[i], out_data_type);
}
}
Rast_set_f_null_value(fbuf[0], ncols);
for (row = last_row; row < nrows; row++) {
for (i = 0; i < n_outputs; i++) {
Rast_put_row(outfd[i], fbuf[0], out_data_type);
}
}
G_percent(nrows, nrows, 1);
for (i = 0; i < n_outputs; i++) {
Rast_close(outfd[i]);
Rast_short_history(mapname[i], "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname[i], &history);
G_free(fbuf[i]);
}
G_free(fbuf);
G_free(data);
exit(EXIT_SUCCESS);
}
