int main(int argc, char *argv[])
{
struct GModule *module;
struct _options options;
struct _flags flags;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("output"));
G_add_keyword(_("external"));
module->description =
_("Defines vector output format utilizing OGR library.");
OGRRegisterAll();
parse_args(argc, argv, &options, &flags);
if (flags.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
if (flags.r->answer) {
G_remove("", "OGR");
exit(EXIT_SUCCESS);
}
if (options.format->answer)
check_format(options.format->answer);
if (options.dsn->answer)
make_link(options.dsn->answer,
options.format->answer, options.opts->answers);
if (flags.p->answer || flags.g->answer) {
print_status(flags.g->answer ? 1 : 0);
}
exit(EXIT_SUCCESS);
}
void filter_holes(Gfile * out)
{
int row, col, nrows, ncols;
void *arast, *brast, *crast;
int i, pixel[9], cold, warm, shadow, nulo, lim;
Gfile tmp;
nrows = Rast_window_rows();
ncols = Rast_window_cols();
if (nrows < 3 || ncols < 3)
return;
/* Open to read */
if ((out->fd = Rast_open_old(out->name, "")) < 0)
G_fatal_error(_("Unable to open raster map <%s>"), out->name);
arast = Rast_allocate_buf(CELL_TYPE);
brast = Rast_allocate_buf(CELL_TYPE);
crast = Rast_allocate_buf(CELL_TYPE);
/* Open to write */
sprintf(tmp.name, "_%d.BBB", getpid());
tmp.rast = Rast_allocate_buf(CELL_TYPE);
if ((tmp.fd = Rast_open_new(tmp.name, CELL_TYPE)) < 0)
G_fatal_error(_("Unable to create raster map <%s>"), tmp.name);
G_important_message(_("Filling small holes in clouds..."));
/* Se puede acelerar creandolos nulos y luego arast = brast
brast = crast y cargando crast solamente
G_set_f_null_value(cell[2], ncols);
*/
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
/* Read row values */
if (row != 0) {
Rast_get_c_row(out->fd, arast, row - 1);
}
Rast_get_c_row(out->fd, brast, row);
if (row != (nrows - 1)) {
Rast_get_c_row(out->fd, crast, row + 1);
}
/* Analysis of all pixels */
for (col = 0; col < ncols; col++) {
pixel[0] = pval(brast, col);
if (pixel[0] == 0) {
if (row == 0) {
pixel[1] = -1;
pixel[2] = -1;
pixel[3] = -1;
if (col == 0) {
pixel[4] = -1;
pixel[5] = pval(brast, col + 1);
pixel[6] = -1;
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else if (col != (ncols - 1)) {
pixel[4] = pval(brast, col - 1);
pixel[5] = pval(brast, col + 1);
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else {
pixel[4] = pval(brast, col - 1);
pixel[5] = -1;
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = -1;
}
}
else if (row != (nrows - 1)) {
if (col == 0) {
pixel[1] = -1;
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = -1;
pixel[5] = pval(brast, col + 1);
pixel[6] = -1;
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else if (col != (ncols - 1)) {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = pval(brast, col - 1);
pixel[5] = pval(brast, col + 1);
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = -1;
pixel[4] = pval(brast, col - 1);
pixel[5] = -1;
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = -1;
}
}
else {
pixel[6] = -1;
pixel[7] = -1;
pixel[8] = -1;
if (col == 0) {
pixel[1] = -1;
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = -1;
pixel[5] = pval(brast, col + 1);
}
else if (col != (ncols - 1)) {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = pval(brast, col - 1);
pixel[5] = pval(brast, col + 1);
}
else {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = -1;
pixel[4] = pval(brast, col - 1);
pixel[5] = -1;
}
}
cold = warm = shadow = nulo = 0;
for (i = 1; i < 9; i++) {
switch (pixel[i]) {
case IS_COLD_CLOUD:
cold++;
break;
case IS_WARM_CLOUD:
warm++;
break;
case IS_SHADOW:
shadow++;
break;
default:
nulo++;
break;
}
}
lim = (int)(cold + warm + shadow + nulo) / 2;
/* Entra pixel[0] = 0 */
if (nulo < lim) {
if (shadow >= (cold + warm))
pixel[0] = IS_SHADOW;
else
pixel[0] =
(warm > cold) ? IS_WARM_CLOUD : IS_COLD_CLOUD;
}
}
if (pixel[0] != 0) {
((CELL *) tmp.rast)[col] = pixel[0];
}
else {
Rast_set_c_null_value((CELL *) tmp.rast + col, 1);
}
}
Rast_put_row(tmp.fd, tmp.rast, CELL_TYPE);
}
G_percent(1, 1, 1);
G_free(arast);
G_free(brast);
G_free(crast);
Rast_close(out->fd);
G_free(tmp.rast);
Rast_close(tmp.fd);
G_remove("cats", out->name);
G_remove("cell", out->name);
G_remove("cellhd", out->name);
G_remove("cell_misc", out->name);
G_remove("hist", out->name);
G_rename("cats", tmp.name, out->name);
G_rename("cell", tmp.name, out->name);
G_rename("cellhd", tmp.name, out->name);
G_rename("cell_misc", tmp.name, out->name);
G_rename("hist", tmp.name, out->name);
return;
}
void make_link(const char *dsn_opt,
const char *format,
char *option_str, char **options)
{
int use_ogr;
char *filename, *dsn;
FILE *fp;
struct Key_Value *key_val;
key_val = G_create_key_value();
/* check for weird options */
if (G_strncasecmp(dsn_opt, "PG:", 3) == 0 &&
strcmp(format, "PostgreSQL") != 0)
G_warning(_("Data source starts with \"PG:\" prefix, expecting \"PostgreSQL\" "
"format (\"%s\" given)"), format);
/* use OGR ? */
use_ogr = is_ogr(format);
if (use_ogr) {
filename = "OGR";
G_remove("", "PG");
}
else {
filename = "PG";
G_remove("", "OGR");
}
/* be friendly, ignored 'PG:' prefix for GRASS-PostGIS data driver */
if (!use_ogr && strcmp(format, "PostgreSQL") == 0 &&
G_strncasecmp(dsn_opt, "PG:", 3) == 0) {
int i, length;
length = strlen(dsn_opt);
dsn = (char *) G_malloc(length - 3);
for (i = 3; i < length; i++)
dsn[i-3] = dsn_opt[i];
dsn[length-3] = '\0';
}
else {
dsn = G_store(dsn_opt);
}
/* parse options for PG data format */
if (options && *options && !use_ogr) {
int i;
char *key, *value;
i = 0;
while (options[i]) {
if (parse_option_pg(options[i++], &key, &value) != 0)
continue;
G_set_key_value(key, value, key_val);
}
}
/* datasource section */
if (dsn) {
if (use_ogr)
G_set_key_value("dsn", dsn, key_val);
else
G_set_key_value("conninfo", dsn, key_val);
}
if (use_ogr) { /* OGR */
if (format)
G_set_key_value("format", format, key_val);
if (option_str)
G_set_key_value("options", option_str, key_val);
}
else { /* PG */
G_set_key_value("format", "PostgreSQL", key_val);
}
/* save file - OGR or PG */
fp = G_fopen_new("", filename);
if (!fp)
G_fatal_error(_("Unable to create settings file"));
if (G_fwrite_key_value(fp, key_val) < 0)
G_fatal_error(_("Error writing settings file"));
fclose(fp);
if (use_ogr)
G_verbose_message(_("Switched to OGR format (%s)"),
G_find_key_value("format", key_val));
else
G_verbose_message(_("Switched to PostGIS format"));
G_free_key_value(key_val);
}
int test_large_file(int depths, int rows, int cols, int tile_size)
{
int sum = 0;
int x, y, z, count;
DCELL value;
G_message("Testing DCELL put function for large files");
RASTER3D_Region region;
RASTER3D_Map *map = NULL;
/* We need to set up a specific region for the new raster3d map.
* First we safe the default region. */
Rast3d_get_window(®ion);
region.bottom = -365.5;
region.top = 365.5;
region.south = -90;
region.north = 90;
region.west = -180;
region.east = 180;
region.rows = rows;
region.cols = cols;
region.depths = depths;
Rast3d_adjust_region(®ion);
G_message("Creating 3D raster map");
map = Rast3d_open_new_opt_tile_size("test_put_get_value_dcell_large",
RASTER3D_USE_CACHE_XY, ®ion, DCELL_TYPE, tile_size);
/* The window is the same as the map region ... of course */
Rast3d_set_window_map(map, ®ion);
/*Write -1 first to see if the tile handling works correctly */
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Put the counter as cell value */
value = -1;
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
}
}
}
G_percent(1, 1, 1);
G_message("Rewriting the values");
/* Now write the values to be evaluated */
count = 1;
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Put the counter as cell value */
value = count;
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
count++;
}
}
}
G_percent(1, 1, 1);
G_message("Verifying 3D raster map");
count = 1;
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Check the counter as cell value */
Rast3d_get_value(map, x, y, z, &value, DCELL_TYPE);
if(fabs(value - (double)(count) > EPSILON)) {
G_message("At: z %i y %i x %i -- value %.14lf != %.14lf\n",
z, y, x, value, (double)(count));
sum++;
}
count++;
}
}
}
G_percent(1, 1, 1);
Rast3d_close(map);
G_remove("grid3", "test_put_get_value_dcell_large");
return sum;
}
int test_large_file_sparse_random(int depths, int rows, int cols, int tile_size)
{
int sum = 0;
int x, y, z, i;
DCELL value, random_value;
DCELL *random_value_vector = G_calloc(RAND_VALUE_VECTOR_SIZE, sizeof(DCELL));
G_message("Testing DCELL put function for large files filled with sparse random values");
RASTER3D_Region region;
RASTER3D_Map *map = NULL;
/* We need to set up a specific region for the new raster3d map.
* First we safe the default region. */
Rast3d_get_window(®ion);
region.bottom = -365.5;
region.top = 365.5;
region.south = -90;
region.north = 90;
region.west = -180;
region.east = 180;
region.rows = rows;
region.cols = cols;
region.depths = depths;
Rast3d_adjust_region(®ion);
G_message("Creating 3D raster map filled with sparse random values");
map = Rast3d_open_new_opt_tile_size("test_put_get_value_dcell_large_sparse_random",
RASTER3D_USE_CACHE_XY, ®ion, DCELL_TYPE, tile_size);
/* The window is the same as the map region ... of course */
Rast3d_set_window_map(map, ®ion);
srand(1);
/* We fill the random value vector */
for(i = 0; i < RAND_VALUE_VECTOR_SIZE; i++) {
/* Put the counter as cell value */
value = (DCELL)rand();
value /= RAND_MAX;
if(value <= 0.7)
value = 0.0;
else if(value <= 0.8)
value = 1.0;
else if(value <= 0.9)
value = 2.0;
else if(value <= 1.0)
value = 3.0;
else
value = 4.0;
random_value_vector[i] = value;
}
i = 0;
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Put the counter as cell value */
value = random_value_vector[i];
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
i++;
if(i == RAND_VALUE_VECTOR_SIZE)
i = 0;
}
}
}
G_percent(1, 1, 1);
/* Write everything to the disk */
Rast3d_flush_all_tiles(map);
Rast3d_close(map);
G_message("Verifying 3D raster map filled with sparse random values");
map = Rast3d_open_cell_old("test_put_get_value_dcell_large_sparse_random",
G_mapset(), ®ion, DCELL_TYPE, RASTER3D_USE_CACHE_XY);
i = 0;
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Check the counter as cell value */
Rast3d_get_value(map, x, y, z, &value, DCELL_TYPE);
if(fabs(value - random_value_vector[i]) > EPSILON) {
G_message("At: z %i y %i x %i -- value %.14lf != %.14lf\n",
z, y, x, value, random_value);
sum++;
}
i++;
if(i == RAND_VALUE_VECTOR_SIZE)
i = 0;
}
}
}
G_percent(1, 1, 1);
Rast3d_close(map);
G_free(random_value_vector);
G_remove("grid3", "test_put_get_value_dcell_large_sparse_random");
return sum;
}
int test_large_file_zeros(int depths, int rows, int cols, int tile_size)
{
int sum = 0;
int x, y, z;
DCELL value;
G_message("Testing DCELL put function for large files filled with zeros");
RASTER3D_Region region;
RASTER3D_Map *map = NULL;
/* We need to set up a specific region for the new raster3d map.
* First we safe the default region. */
Rast3d_get_window(®ion);
region.bottom = -365.5;
region.top = 365.5;
region.south = -90;
region.north = 90;
region.west = -180;
region.east = 180;
region.rows = rows;
region.cols = cols;
region.depths = depths;
Rast3d_adjust_region(®ion);
G_message("Creating 3D raster map filled with zeros");
map = Rast3d_open_new_opt_tile_size("test_put_get_value_dcell_large_zeros",
RASTER3D_USE_CACHE_XY, ®ion, DCELL_TYPE, tile_size);
/* The window is the same as the map region ... of course */
Rast3d_set_window_map(map, ®ion);
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Put the counter as cell value */
value = 0.0;
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
}
}
}
G_percent(1, 1, 1);
/* Write everything to the disk */
Rast3d_flush_all_tiles(map);
Rast3d_close(map);
G_message("Verifying 3D raster map filled with zeros");
map = Rast3d_open_cell_old("test_put_get_value_dcell_large_zeros",
G_mapset(), ®ion, DCELL_TYPE, RASTER3D_USE_CACHE_XY);
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Check the counter as cell value */
Rast3d_get_value(map, x, y, z, &value, DCELL_TYPE);
if(value > EPSILON) {
G_message("At: z %i y %i x %i -- value %.14lf != 0.0\n",
z, y, x, value);
sum++;
}
}
}
}
G_percent(1, 1, 1);
Rast3d_close(map);
G_remove("grid3", "test_put_get_value_dcell_large_zeros");
return sum;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct _options options;
struct _flags flags;
char * format;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("output"));
G_add_keyword(_("external"));
G_add_keyword("OGR");
G_add_keyword("PostGIS");
module->description = _("Defines vector output format.");
#ifdef HAVE_OGR
OGRRegisterAll();
#endif
parse_args(argc, argv, &options, &flags);
if (flags.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
if (flags.r->answer) {
if (G_remove("", "OGR") == 1) {
G_verbose_message(_("Switched from OGR to native format"));
}
else {
if (G_remove("", "PG") == 1)
G_verbose_message(_("Switched from PostGIS to native format"));
}
G_message(_("Current output format for vectors: %s"), "GRASS");
exit(EXIT_SUCCESS);
}
format = NULL;
if (options.format->answer) {
format = G_store(options.format->answer);
check_format(format);
}
if (options.dsn->answer) {
make_link(options.dsn->answer, format,
options.opts->answer, options.opts->answers);
}
else if (options.input->answer) {
read_status_file(options.input);
}
if (flags.p->answer || flags.g->answer) {
print_status(flags.g->answer ? TRUE : FALSE);
}
if (options.output->answer) {
save_status_file(options.output);
}
if (options.dsn->answer || options.input->answer)
G_message(_("Current output format for vectors: %s"), format);
exit(EXIT_SUCCESS);
}
