/*!
\brief Fetches list of DB column names and types of vector map attribute table
\param Map vector map
\param field layer number
\return list of column(s) types on success
\retutn NULL on error
*/
const char *Vect_get_column_names_types(struct Map_info *Map, int field)
{
int num_dblinks, ncols, col;
struct field_info *fi;
dbDriver *driver = NULL;
dbHandle handle;
dbString table_name;
dbTable *table;
char buf[2000], temp_buf[2000];
num_dblinks = Vect_get_num_dblinks(Map);
if (num_dblinks <= 0)
return (NULL);
G_debug(3,
"Displaying column types for database connection of layer %d:",
field);
if ((fi = Vect_get_field(Map, field)) == NULL)
return (NULL);
driver = db_start_driver(fi->driver);
if (driver == NULL)
return (NULL);
db_init_handle(&handle);
db_set_handle(&handle, fi->database, NULL);
if (db_open_database(driver, &handle) != DB_OK)
return (NULL);
db_init_string(&table_name);
db_set_string(&table_name, fi->table);
if (db_describe_table(driver, &table_name, &table) != DB_OK)
return (NULL);
ncols = db_get_table_number_of_columns(table);
sprintf(buf, " ");
for (col = 0; col < ncols; col++) {
if (col == 0)
sprintf(buf, "%s(%s)",
db_get_column_name(db_get_table_column(table, col)),
db_sqltype_name(db_get_column_sqltype
(db_get_table_column(table, col))));
else {
sprintf(temp_buf, ",%s(%s)",
db_get_column_name(db_get_table_column(table, col)),
db_sqltype_name(db_get_column_sqltype
(db_get_table_column(table, col))));
strcat(buf, temp_buf);
}
}
G_debug(3, "%s", buf);
db_close_database(driver);
db_shutdown_driver(driver);
return G_store(G_chop(buf));
}
void print_columns(const struct Map_info *Map, const char *input_opt, const char *field_opt)
{
int num_dblinks, col, ncols;
struct field_info *fi;
dbDriver *driver = NULL;
dbHandle handle;
dbString table_name;
dbTable *table;
num_dblinks = Vect_get_num_dblinks(Map);
if (num_dblinks <= 0) {
G_fatal_error(_("Database connection for map <%s> is not defined in DB file"),
input_opt);
}
G_message(_("Displaying column types/names for database connection of layer <%s>:"),
field_opt);
if ((fi = Vect_get_field2(Map, field_opt)) == NULL)
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_opt);
driver = db_start_driver(fi->driver);
if (driver == NULL)
G_fatal_error(_("Unable to open driver <%s>"),
fi->driver);
db_init_handle(&handle);
db_set_handle(&handle, fi->database, NULL);
if (db_open_database(driver, &handle) != DB_OK)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
db_init_string(&table_name);
db_set_string(&table_name, fi->table);
if (db_describe_table(driver, &table_name, &table) != DB_OK)
G_fatal_error(_("Unable to describe table <%s>"),
fi->table);
ncols = db_get_table_number_of_columns(table);
for (col = 0; col < ncols; col++)
fprintf(stdout, "%s|%s\n",
db_sqltype_name(db_get_column_sqltype
(db_get_table_column
(table, col))),
db_get_column_name(db_get_table_column
(table, col)));
db_close_database(driver);
db_shutdown_driver(driver);
}
int db__copy_table(const char *from_drvname, const char *from_dbname,
const char *from_tblname, const char *to_drvname,
const char *to_dbname, const char *to_tblname,
const char *where, const char *select, const char *selcol,
int *ivals, int nvals)
{
int col, ncols, sqltype, ctype, more, selcol_found;
char buf[1000];
int *ivalues;
dbHandle from_handle, to_handle;
dbString tblname, sql;
dbString value_string;
dbString *tblnames;
dbTable *table, *out_table;
dbCursor cursor;
dbColumn *column;
dbValue *value;
const char *colname;
dbDriver *from_driver, *to_driver;
int count, i;
G_debug(3, "db_copy_table():\n from driver = %s, db = %s, table = %s\n"
" to driver = %s, db = %s, table = %s, where = %s, select = %s",
from_drvname, from_dbname, from_tblname, to_drvname, to_dbname,
to_tblname, where, select);
db_init_handle(&from_handle);
db_init_handle(&to_handle);
db_init_string(&tblname);
db_init_string(&sql);
db_init_string(&value_string);
/* Make a copy of input values and sort it */
if (ivals) {
ivalues = (int *)G_malloc(nvals * sizeof(int));
memcpy(ivalues, ivals, nvals * sizeof(int));
qsort((void *)ivalues, nvals, sizeof(int), cmp);
}
/* Open input driver and database */
from_driver = db_start_driver(from_drvname);
if (from_driver == NULL) {
G_warning(_("Unable to start driver <%s>"), from_drvname);
return DB_FAILED;
}
db_set_handle(&from_handle, from_dbname, NULL);
if (db_open_database(from_driver, &from_handle) != DB_OK) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
from_dbname, from_drvname);
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
/* Open output driver and database */
if (strcmp(from_drvname, to_drvname) == 0
&& strcmp(from_dbname, to_dbname) == 0) {
G_debug(3, "Use the same driver");
to_driver = from_driver;
}
else {
to_driver = db_start_driver(to_drvname);
if (to_driver == NULL) {
G_warning(_("Unable to start driver <%s>"), to_drvname);
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
db_set_handle(&to_handle, to_dbname, NULL);
if (db_open_database(to_driver, &to_handle) != DB_OK) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
to_dbname, to_drvname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
}
db_begin_transaction(to_driver);
/* Because in SQLite3 an opened cursor is no more valid
if 'schema' is modified (create table), we have to open
cursor twice */
/* test if the table exists */
if (db_list_tables(to_driver, &tblnames, &count, 0) != DB_OK) {
G_warning(_("Unable to get list tables in database <%s>"),
to_dbname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver)
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
for (i = 0; i < count; i++) {
const char *tblname = db_get_string(&tblnames[i]);
if (strcmp(to_tblname, tblname) == 0) {
G_warning(_("Table <%s> already exists in database <%s>"),
to_tblname, to_dbname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver)
db_close_database_shutdown_driver(from_driver);
return DB_FAILED;
}
}
/* Create new table */
/* Open cursor for data structure */
if (select) {
db_set_string(&sql, select);
/* TODO!: cannot use this because it will not work if a query
* ends with 'group by' for example */
/*
tmp = strdup ( select );
G_tolcase ( tmp );
if ( !strstr( tmp,"where") )
{
db_append_string ( &sql, " where 0 = 1");
}
else
{
db_append_string ( &sql, " and 0 = 1");
}
free (tmp);
*/
}
else {
db_set_string(&sql, "select * from ");
db_append_string(&sql, from_tblname);
db_append_string(&sql, " where 0 = 1"); /* to get no data */
}
G_debug(3, db_get_string(&sql));
if (db_open_select_cursor(from_driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
G_debug(3, "Select cursor opened");
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
G_debug(3, "ncols = %d", ncols);
out_table = db_alloc_table(ncols);
db_set_table_name(out_table, to_tblname);
selcol_found = 0;
for (col = 0; col < ncols; col++) {
dbColumn *out_column;
column = db_get_table_column(table, col);
colname = db_get_column_name(column);
sqltype = db_get_column_sqltype(column);
ctype = db_sqltype_to_Ctype(sqltype);
G_debug(3, "%s (%s)", colname, db_sqltype_name(sqltype));
out_column = db_get_table_column(out_table, col);
if (selcol && G_strcasecmp(colname, selcol) == 0) {
if (ctype != DB_C_TYPE_INT)
G_fatal_error(_("Column <%s> is not integer"),
colname);
selcol_found = 1;
}
db_set_column_name(out_column, db_get_column_name(column));
db_set_column_description(out_column,
db_get_column_description(column));
db_set_column_sqltype(out_column, db_get_column_sqltype(column));
db_set_column_length(out_column, db_get_column_length(column));
db_set_column_precision(out_column, db_get_column_precision(column));
db_set_column_scale(out_column, db_get_column_scale(column));
}
db_close_cursor(&cursor);
if (selcol && !selcol_found)
G_fatal_error(_("Column <%s> not found"), selcol);
if (db_create_table(to_driver, out_table) != DB_OK) {
G_warning(_("Unable to create table <%s>"),
to_tblname);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
/* Open cursor with data */
if (select) {
db_set_string(&sql, select);
}
else {
db_set_string(&sql, "select * from ");
db_append_string(&sql, from_tblname);
if (where) {
db_append_string(&sql, " where ");
db_append_string(&sql, where);
}
}
G_debug(3, db_get_string(&sql));
if (db_open_select_cursor(from_driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
G_debug(3, "Select cursor opened");
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
G_debug(3, "ncols = %d", ncols);
/* Copy all rows */
while (1) {
int select;
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
G_warning(_("Unable to fetch data from table <%s>"),
from_tblname);
db_close_cursor(&cursor);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
if (!more)
break;
sprintf(buf, "insert into %s values ( ", to_tblname);
db_set_string(&sql, buf);
select = 1;
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
colname = db_get_column_name(column);
sqltype = db_get_column_sqltype(column);
ctype = db_sqltype_to_Ctype(sqltype);
value = db_get_column_value(column);
if (selcol && G_strcasecmp(colname, selcol) == 0) {
if (db_test_value_isnull(value))
continue;
if (!bsearch(&(value->i), ivalues, nvals, sizeof(int), cmp)) {
select = 0;
break;
}
}
if (col > 0)
db_append_string(&sql, ", ");
db_convert_value_to_string(value, sqltype, &value_string);
switch (ctype) {
case DB_C_TYPE_STRING:
case DB_C_TYPE_DATETIME:
if (db_test_value_isnull(value)) {
db_append_string(&sql, "null");
}
else {
db_double_quote_string(&value_string);
db_append_string(&sql, "'");
db_append_string(&sql, db_get_string(&value_string));
db_append_string(&sql, "'");
}
break;
case DB_C_TYPE_INT:
case DB_C_TYPE_DOUBLE:
if (db_test_value_isnull(value)) {
db_append_string(&sql, "null");
}
else {
db_append_string(&sql, db_get_string(&value_string));
}
break;
default:
G_warning(_("Unknown column type (column <%s>)"),
colname);
db_close_cursor(&cursor);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
}
if (!select)
continue;
db_append_string(&sql, ")");
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(to_driver, &sql) != DB_OK) {
G_warning("Unable to insert new record: '%s'",
db_get_string(&sql));
db_close_cursor(&cursor);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_FAILED;
}
}
if (selcol)
G_free(ivalues);
G_debug(3, "Table copy OK");
db_close_cursor(&cursor);
db_commit_transaction(to_driver);
db_close_database_shutdown_driver(to_driver);
if (from_driver != to_driver) {
db_close_database_shutdown_driver(from_driver);
}
return DB_OK;
}
int db__driver_create_table(dbTable * table)
{
int col, ncols;
dbColumn *column;
const char *colname;
int sqltype;
char buf[500];
dbString sql;
/* dbConnection conn_par; */
G_debug(3, "db__driver_create_table()");
init_error();
db_init_string(&sql);
db_set_string(&sql, "CREATE TABLE ");
db_append_string(&sql, db_get_table_name(table));
db_append_string(&sql, " ( ");
ncols = db_get_table_number_of_columns(table);
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
colname = db_get_column_name(column);
sqltype = db_get_column_sqltype(column);
G_debug(3, "%s (%s)", colname, db_sqltype_name(sqltype));
if (col > 0)
db_append_string(&sql, ", ");
db_append_string(&sql, colname);
db_append_string(&sql, " ");
switch (sqltype) {
case DB_SQL_TYPE_SMALLINT:
db_append_string(&sql, "SMALLINT");
break;
case DB_SQL_TYPE_INTEGER:
db_append_string(&sql, "INT");
break;
case DB_SQL_TYPE_REAL:
db_append_string(&sql, "FLOAT");
break;
/* TODO: better numeric types */
case DB_SQL_TYPE_DOUBLE_PRECISION:
case DB_SQL_TYPE_DECIMAL:
case DB_SQL_TYPE_NUMERIC:
case DB_SQL_TYPE_INTERVAL:
db_append_string(&sql, "DOUBLE");
break;
/* GRASS does not distinguish TIMESTAMP and DATETIME */
/*
case DB_SQL_TYPE_DATETIME|DB_DATETIME_MASK:
db_append_string ( &sql, "DATETIME");
break;
*/
case DB_SQL_TYPE_TIMESTAMP:
/* db_append_string ( &sql, "TIMESTAMP"); */
db_append_string(&sql, "DATETIME");
break;
case DB_SQL_TYPE_DATE:
db_append_string(&sql, "DATE");
break;
case DB_SQL_TYPE_TIME:
db_append_string(&sql, "TIME");
break;
case DB_SQL_TYPE_CHARACTER:
sprintf(buf, "VARCHAR(%d)", db_get_column_length(column));
db_append_string(&sql, buf);
break;
case DB_SQL_TYPE_TEXT:
db_append_string(&sql, "TEXT");
break;
default:
G_warning("Unknown column type (%s)", colname);
return DB_FAILED;
}
}
db_append_string(&sql, " )");
G_debug(3, " SQL: %s", db_get_string(&sql));
if (mysql_query(connection, db_get_string(&sql)) != 0) {
append_error("Cannot create table:\n");
append_error(db_get_string(&sql));
append_error("\n");
append_error(mysql_error(connection));
report_error();
db_free_string(&sql);
return DB_FAILED;
}
/* Grant privileges */
/*
* 1) MySQL does not support user groups but it is possible
* to specify list of users.
* 2) Only root can grant privileges.
*/
/*
db_get_connection(&conn_par);
if ( conn_par.group )
{
db_set_string ( &sql, "GRANT SELECT ON on " );
db_append_string ( &sql, db_get_table_name ( table ) );
db_append_string ( &sql, " TO " );
db_append_string ( &sql, conn_par.group );
G_debug (3, " SQL: %s", db_get_string(&sql) );
if ( mysql_query ( connection, db_get_string(&sql) ) != 0 )
{
G_warning ( "Cannot grant select on table: \n%s\n%s",
db_get_string(&sql), mysql_error(connection) );
}
}
*/
db_free_string(&sql);
return DB_OK;
}
int db__driver_create_table(dbTable * table)
{
int col, ncols;
dbColumn *column;
const char *colname;
int sqltype;
char buf[500];
PGresult *res;
dbString sql;
dbConnection connection;
G_debug(3, "db__driver_create_table()");
init_error();
db_init_string(&sql);
/* db_table_to_sql ( table, &sql ); */
db_set_string(&sql, "create table ");
db_append_string(&sql, db_get_table_name(table));
db_append_string(&sql, " ( ");
ncols = db_get_table_number_of_columns(table);
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
colname = db_get_column_name(column);
sqltype = db_get_column_sqltype(column);
G_debug(3, "%s (%s)", colname, db_sqltype_name(sqltype));
if (col > 0)
db_append_string(&sql, ", ");
db_append_string(&sql, colname);
db_append_string(&sql, " ");
switch (sqltype) {
case DB_SQL_TYPE_CHARACTER:
sprintf(buf, "varchar(%d)", db_get_column_length(column));
db_append_string(&sql, buf);
break;
case DB_SQL_TYPE_TEXT:
db_append_string(&sql, "text");
break;
case DB_SQL_TYPE_SMALLINT:
db_append_string(&sql, "smallint");
break;
case DB_SQL_TYPE_INTEGER:
db_append_string(&sql, "integer");
break;
case DB_SQL_TYPE_REAL:
db_append_string(&sql, "real");
break;
/* TODO: better numeric types */
case DB_SQL_TYPE_DOUBLE_PRECISION:
case DB_SQL_TYPE_DECIMAL:
case DB_SQL_TYPE_NUMERIC:
case DB_SQL_TYPE_INTERVAL:
db_append_string(&sql, "double precision");
break;
case DB_SQL_TYPE_DATE:
db_append_string(&sql, "date");
break;
case DB_SQL_TYPE_TIME:
db_append_string(&sql, "time");
break;
case DB_SQL_TYPE_TIMESTAMP:
db_append_string(&sql, "timestamp");
break;
default:
G_warning("Unknown column type (%s)", colname);
return DB_FAILED;
}
}
db_append_string(&sql, " )");
G_debug(3, " SQL: %s", db_get_string(&sql));
res = PQexec(pg_conn, db_get_string(&sql));
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK) {
append_error("Cannot create table:\n");
append_error(db_get_string(&sql));
append_error("\n");
append_error(PQerrorMessage(pg_conn));
report_error();
PQclear(res);
db_free_string(&sql);
return DB_FAILED;
}
PQclear(res);
/* Grant privileges */
db_get_connection(&connection);
db_set_string(&sql, "grant select on ");
db_append_string(&sql, db_get_table_name(table));
db_append_string(&sql, " to public");
if (connection.group) {
db_append_string(&sql, ", group ");
db_append_string(&sql, connection.group);
}
G_debug(3, " SQL: %s", db_get_string(&sql));
res = PQexec(pg_conn, db_get_string(&sql));
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK) {
append_error("Cannot grant select on table:\n");
append_error(db_get_string(&sql));
append_error("\n");
append_error(PQerrorMessage(pg_conn));
report_error();
PQclear(res);
db_free_string(&sql);
return DB_FAILED;
}
PQclear(res);
db_free_string(&sql);
return DB_OK;
}
int vect_to_rast(const char *vector_map, const char *raster_map, const char *field_name,
const char *column, int cache_mb, int use, double value,
int value_type, const char *rgbcolumn, const char *labelcolumn,
int ftype, char *where, char *cats, int dense)
{
struct Map_info Map;
struct line_pnts *Points;
int i, field;
struct cat_list *cat_list = NULL;
int fd; /* for raster map */
int nareas, nlines; /* number of converted features */
int nareas_all, nplines_all; /* number of all areas, points/lines */
int stat;
int format;
int pass, npasses;
/* Attributes */
int nrec;
int ctype = 0;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
int is_fp = 0;
nareas = 0;
G_verbose_message(_("Loading data..."));
Vect_set_open_level(2);
if (Vect_open_old2(&Map, vector_map, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), vector_map);
field = Vect_get_field_number(&Map, field_name);
if (field > 0)
cat_list = Vect_cats_set_constraint(&Map, field, where, cats);
if ((use == USE_Z) && !(Vect_is_3d(&Map)))
G_fatal_error(_("Vector map <%s> is not 3D"),
Vect_get_full_name(&Map));
switch (use) {
case USE_ATTR:
db_CatValArray_init(&cvarr);
if (!(Fi = Vect_get_field(&Map, field)))
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_name);
if ((Driver =
db_start_driver_open_database(Fi->driver, Fi->database)) == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(Driver);
/* Note do not check if the column exists in the table because it may be expression */
if ((nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key, column, NULL,
&cvarr)) == -1)
G_fatal_error(_("Column <%s> not found"), column);
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 (%s) not supported (did you mean 'labelcolumn'?)"),
db_sqltype_name(ctype));
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);
for (i = 0; i < cvarr.n_values; i++) {
if (ctype == DB_C_TYPE_INT) {
G_debug(3, "cat = %d val = %d", cvarr.value[i].cat,
cvarr.value[i].val.i);
}
else if (ctype == DB_C_TYPE_DOUBLE) {
G_debug(3, "cat = %d val = %f", cvarr.value[i].cat,
cvarr.value[i].val.d);
}
}
switch (ctype) {
case DB_C_TYPE_INT:
format = CELL_TYPE;
break;
case DB_C_TYPE_DOUBLE:
format = DCELL_TYPE;
break;
default:
G_fatal_error(_("Unable to use column <%s>"), column);
break;
}
break;
case USE_CAT:
format = CELL_TYPE;
break;
case USE_VAL:
format = value_type;
break;
case USE_Z:
format = DCELL_TYPE;
is_fp = 1;
break;
case USE_D:
format = DCELL_TYPE;
break;
default:
G_fatal_error(_("Unknown use type: %d"), use);
}
fd = Rast_open_new(raster_map, format);
Points = Vect_new_line_struct();
if (use != USE_Z && use != USE_D && (ftype & GV_AREA)) {
if ((nareas = sort_areas(&Map, Points, field, cat_list)) == 0)
G_warning(_("No areas selected from vector map <%s>"),
vector_map);
G_debug(1, "%d areas sorted", nareas);
}
if (nareas > 0 && dense) {
G_warning(_("Area conversion and line densification are mutually exclusive, disabling line densification."));
dense = 0;
}
nlines = Vect_get_num_primitives(&Map, ftype);
nplines_all = nlines;
npasses = begin_rasterization(cache_mb, format, dense);
pass = 0;
nareas_all = Vect_get_num_areas(&Map);
do {
pass++;
if (npasses > 1)
G_message(_("Pass %d of %d:"), pass, npasses);
stat = 0;
if ((use != USE_Z && use != USE_D) && nareas) {
if (do_areas
(&Map, Points, &cvarr, ctype, use, value,
value_type) < 0) {
G_warning(_("Problem processing areas from vector map <%s>, continuing..."),
vector_map);
stat = -1;
break;
}
}
if (nlines) {
if ((nlines =
do_lines(&Map, Points, &cvarr, ctype, field, cat_list,
use, value, value_type, ftype,
&nplines_all, dense)) < 0) {
G_warning(_("Problem processing lines from vector map <%s>, continuing..."),
vector_map);
stat = -1;
break;
}
}
G_important_message(_("Writing raster map..."));
stat = output_raster(fd);
} while (stat == 0);
G_suppress_warnings(0);
/* stat: 0 == repeat; 1 == done; -1 == error; */
Vect_destroy_line_struct(Points);
if (stat < 0) {
Rast_unopen(fd);
return 1;
}
Vect_close(&Map);
G_verbose_message(_("Creating support files for raster map..."));
Rast_close(fd);
update_hist(raster_map, vector_map, Map.head.orig_scale);
/* colors */
if (rgbcolumn) {
if (use != USE_ATTR && use != USE_CAT) {
G_warning(_("Color can be updated from database only if use=attr"));
update_colors(raster_map);
}
else {
update_dbcolors(raster_map, vector_map, field, rgbcolumn, is_fp,
column);
}
}
else if (use == USE_D)
update_fcolors(raster_map);
else
update_colors(raster_map);
update_cats(raster_map);
/* labels */
update_labels(raster_map, vector_map, field, labelcolumn, use, value,
column);
#if 0
/* maximum possible numer of areas: number of centroids
* actual number of areas, currently unknown:
* number of areas with centroid that are within cat constraint
* and overlap with current region */
if (nareas_all > 0)
G_message(_("Converted areas: %d of %d"), nareas,
Vect_get_num_primitives(&Map, GV_CENTROID));
/* maximum possible numer of lines: number of GV_LINE + GV_POINT
* actual number of lines, currently unknown:
* number of lines are within cat constraint
* and overlap with current region */
if (nlines > 0 && nplines_all > 0)
G_message(_("Converted points/lines: %d of %d"), nlines, nplines_all);
#endif
return 0;
}
