int Select(double *PartialX, double *PartialY, double *Interp,
int line_num, dbDriver * driver, char *tab_name)
{
int more;
char buf[1024];
dbString sql;
dbTable *table;
dbCursor cursor;
dbColumn *PartialX_col, *PartialY_col, *Interp_col;
dbValue *PartialX_value, *PartialY_value, *Interp_value;
db_init_string(&sql);
sprintf(buf,
"SELECT ID, Interp, X, Y FROM %s WHERE ID=%d",
tab_name, line_num);
db_append_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
return -1;
table = db_get_cursor_table(&cursor);
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
Interp_col = db_get_table_column(table, 1);
PartialX_col = db_get_table_column(table, 2);
PartialY_col = db_get_table_column(table, 3);
if (db_sqltype_to_Ctype(db_get_column_sqltype(Interp_col)) ==
DB_C_TYPE_DOUBLE)
Interp_value = db_get_column_value(Interp_col);
else
continue;
if (db_sqltype_to_Ctype(db_get_column_sqltype(PartialX_col)) ==
DB_C_TYPE_DOUBLE)
PartialX_value = db_get_column_value(PartialX_col);
else
continue;
if (db_sqltype_to_Ctype(db_get_column_sqltype(PartialY_col)) ==
DB_C_TYPE_DOUBLE)
PartialY_value = db_get_column_value(PartialY_col);
else
continue;
*Interp += db_get_value_double(Interp_value);
*PartialX += db_get_value_double(PartialX_value);
*PartialY += db_get_value_double(PartialY_value);
}
db_close_cursor(&cursor);
db_free_string(&sql);
return DB_OK;
}
/*!
\fn
\brief
\return
\param
*/
int
db_convert_Cstring_to_value(const char *Cstring, int sqltype, dbValue * value)
{
int i;
double d;
switch (db_sqltype_to_Ctype(sqltype)) {
case DB_C_TYPE_STRING:
return db_set_value_string(value, Cstring);
case DB_C_TYPE_INT:
i = 0;
sscanf(Cstring, "%d", &i);
db_set_value_int(value, i);
break;
case DB_C_TYPE_DOUBLE:
d = 0.0;
sscanf(Cstring, "%lf", &d);
db_set_value_double(value, d);
break;
case DB_C_TYPE_DATETIME:
return db_convert_Cstring_to_value_datetime(Cstring, sqltype, value);
default:
db_error("db_convert_Cstring_to_value(): unrecognized sqltype");
return DB_FAILED;
}
return DB_OK;
}
int sqltype_to_ogrtype(int sqltype)
{
int ctype, ogrtype;
ctype = db_sqltype_to_Ctype(sqltype);
switch(ctype) {
case DB_C_TYPE_INT:
ogrtype = OFTInteger;
break;
case DB_C_TYPE_DOUBLE:
ogrtype = OFTReal;
break;
case DB_C_TYPE_STRING:
ogrtype = OFTString;
break;
case DB_C_TYPE_DATETIME:
ogrtype = OFTString;
break;
default:
ogrtype = OFTString;
break;
}
return ogrtype;
}
bool OGRGRASSLayer::SetAttributes ( OGRFeature *poFeature, dbTable *table )
{
CPLDebug ( "GRASS", "OGRGRASSLayer::SetAttributes" );
for ( int i = 0; i < nFields; i++)
{
dbColumn *column = db_get_table_column ( table, i );
dbValue *value = db_get_column_value ( column );
int ctype = db_sqltype_to_Ctype ( db_get_column_sqltype(column) );
if ( !db_test_value_isnull(value) )
{
switch ( ctype ) {
case DB_C_TYPE_INT:
poFeature->SetField( i, db_get_value_int ( value ));
break;
case DB_C_TYPE_DOUBLE:
poFeature->SetField( i, db_get_value_double ( value ));
break;
case DB_C_TYPE_STRING:
poFeature->SetField( i, db_get_value_string ( value ));
break;
case DB_C_TYPE_DATETIME:
db_convert_column_value_to_string ( column, poDbString );
poFeature->SetField( i, db_get_string ( poDbString ));
break;
}
}
db_convert_column_value_to_string ( column, poDbString );
//CPLDebug ( "GRASS", "val = %s", db_get_string ( poDbString ));
}
return true;
}
/*!
\fn
\brief
\return
\param
*/
int
db_convert_value_to_string(dbValue * value, int sqltype, dbString * string)
{
char buf[64];
const char *bp = buf;
if (db_test_value_isnull(value)) {
*buf = 0;
}
else {
switch (db_sqltype_to_Ctype(sqltype)) {
case DB_C_TYPE_INT:
sprintf(buf, "%d", db_get_value_int(value));
break;
case DB_C_TYPE_DOUBLE:
sprintf(buf, "%.15g", db_get_value_double(value));
G_trim_decimal(buf);
break;
case DB_C_TYPE_STRING:
bp = db_get_value_string(value);
break;
case DB_C_TYPE_DATETIME:
return db_convert_value_datetime_into_string(value, sqltype,
string);
default:
db_error
("db_convert_value_into_string(): unrecongized sqltype-type");
return DB_FAILED;
}
}
return db_set_string(string, bp);
}
/*!
\brief Select pairs key/value to array, values are sorted by key (must be integer)
\param driver DB driver
\param tab table name
\param key key column name
\param col value column name
\param[out] cvarr dbCatValArray to store within
\return number of selected values
\return -1 on error
*/
int db_select_CatValArray(dbDriver * driver, const char *tab, const char *key,
const char *col, const char *where,
dbCatValArray * cvarr)
{
int i, type, more, nrows;
char buf[1024];
dbString stmt;
dbCursor cursor;
dbColumn *column;
dbValue *value;
dbTable *table;
G_debug(3, "db_select_CatValArray ()");
if (key == NULL || strlen(key) == 0) {
G_warning(_("Missing key column name"));
return -1;
}
if (col == NULL || strlen(col) == 0) {
G_warning(_("Missing column name"));
return -1;
}
db_init_string(&stmt);
sprintf(buf, "SELECT %s, %s FROM %s", key, col, tab);
db_set_string(&stmt, buf);
if (where != NULL && strlen(where) > 0) {
db_append_string(&stmt, " WHERE ");
db_append_string(&stmt, where);
}
G_debug(3, " SQL: %s", db_get_string(&stmt));
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
return (-1);
nrows = db_get_num_rows(&cursor);
G_debug(3, " %d rows selected", nrows);
if (nrows < 0) {
G_warning(_("Unable select records from table <%s>"), tab);
db_close_cursor(&cursor);
db_free_string(&stmt);
return -1;
}
db_CatValArray_alloc(cvarr, nrows);
table = db_get_cursor_table(&cursor);
/* Check if key column is integer */
column = db_get_table_column(table, 0);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
G_debug(3, " key type = %d", type);
if (type != DB_C_TYPE_INT) {
G_warning(_("Key column type is not integer"));
db_close_cursor(&cursor);
db_free_string(&stmt);
return -1;
}
column = db_get_table_column(table, 1);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
G_debug(3, " col type = %d", type);
/*
if ( type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE ) {
G_fatal_error ( "Column type not supported by db_select_to_array()" );
}
*/
cvarr->ctype = type;
/* fetch the data */
for (i = 0; i < nrows; i++) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
return (-1);
column = db_get_table_column(table, 0); /* first column */
value = db_get_column_value(column);
cvarr->value[i].cat = db_get_value_int(value);
column = db_get_table_column(table, 1);
value = db_get_column_value(column);
cvarr->value[i].isNull = value->isNull;
switch (type) {
case (DB_C_TYPE_INT):
if (value->isNull)
cvarr->value[i].val.i = 0;
else
cvarr->value[i].val.i = db_get_value_int(value);
break;
case (DB_C_TYPE_DOUBLE):
if (value->isNull)
cvarr->value[i].val.d = 0.0;
else
cvarr->value[i].val.d = db_get_value_double(value);
break;
case (DB_C_TYPE_STRING):
cvarr->value[i].val.s = (dbString *) malloc(sizeof(dbString));
db_init_string(cvarr->value[i].val.s);
if (!(value->isNull))
db_set_string(cvarr->value[i].val.s,
db_get_value_string(value));
break;
case (DB_C_TYPE_DATETIME):
cvarr->value[i].val.t =
(dbDateTime *) calloc(1, sizeof(dbDateTime));
if (!(value->isNull))
memcpy(cvarr->value[i].val.t, &(value->t),
sizeof(dbDateTime));
break;
default:
return (-1);
}
}
cvarr->n_values = nrows;
db_close_cursor(&cursor);
db_free_string(&stmt);
db_CatValArray_sort(cvarr);
return (nrows);
}
/*!
\brief Select array of ordered integers from table/column
\param driver DB driver
\param tab table name
\param col column name
\param where where statement
\param[out] pval array of ordered integer values
\return number of selected values
\return -1 on error
*/
int db_select_int(dbDriver * driver, const char *tab, const char *col,
const char *where, int **pval)
{
int type, more, alloc, count;
int *val;
char buf[1024];
const char *sval;
dbString stmt;
dbCursor cursor;
dbColumn *column;
dbValue *value;
dbTable *table;
G_debug(3, "db_select_int()");
if (col == NULL || strlen(col) == 0) {
G_warning(_("Missing column name"));
return -1;
}
/* allocate */
alloc = 1000;
val = (int *)G_malloc(alloc * sizeof(int));
if (where == NULL || strlen(where) == 0)
G_snprintf(buf, 1023, "SELECT %s FROM %s", col, tab);
else
G_snprintf(buf, 1023, "SELECT %s FROM %s WHERE %s", col, tab, where);
G_debug(3, " SQL: %s", buf);
db_init_string(&stmt);
db_append_string(&stmt, buf);
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
return (-1);
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
if (column == NULL) {
return -1;
}
value = db_get_column_value(column);
type = db_get_column_sqltype(column);
type = db_sqltype_to_Ctype(type);
/* fetch the data */
count = 0;
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
return (-1);
if (!more)
break;
if (count == alloc) {
alloc += 1000;
val = (int *)G_realloc(val, alloc * sizeof(int));
}
switch (type) {
case (DB_C_TYPE_INT):
val[count] = db_get_value_int(value);
break;
case (DB_C_TYPE_STRING):
sval = db_get_value_string(value);
val[count] = atoi(sval);
break;
case (DB_C_TYPE_DOUBLE):
val[count] = (int)db_get_value_double(value);
break;
default:
return (-1);
}
count++;
}
db_close_cursor(&cursor);
db_free_string(&stmt);
qsort((void *)val, count, sizeof(int), cmp);
*pval = val;
return (count);
}
int write_attributes(dbDriver *driver, int cat, const struct field_info *Fi,
OGRLayerH Ogr_layer, OGRFeatureH Ogr_feature)
{
int j, ogrfieldnum;
char buf[2000];
int ncol, sqltype, ctype, ogrtype, more;
const char *fidcol, *colname;
dbTable *table;
dbString dbstring;
dbColumn *column;
dbCursor cursor;
dbValue *value;
OGRFieldDefnH hFieldDefn;
G_debug(3, "write_attributes(): cat = %d", cat);
if (cat < 0) {
G_warning(_("Feature without category of layer %d"), Fi->number);
return 0;
}
db_init_string(&dbstring);
/* read & set attributes */
sprintf(buf, "SELECT * FROM %s WHERE %s = %d", Fi->table, Fi->key,
cat);
G_debug(4, "SQL: %s", buf);
db_set_string(&dbstring, buf);
/* select data */
if (db_open_select_cursor(driver, &dbstring, &cursor, DB_SEQUENTIAL) != DB_OK) {
G_fatal_error(_("Unable to select attributes for category %d"),
cat);
}
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
G_fatal_error(_("Unable to fetch data from table <%s>"),
Fi->table);
}
if (!more) {
G_warning(_("No database record for category %d, "
"no attributes will be written"),
cat);
return -1;
}
fidcol = OGR_L_GetFIDColumn(Ogr_layer);
table = db_get_cursor_table(&cursor);
ncol = db_get_table_number_of_columns(table);
for (j = 0; j < ncol; j++) {
column = db_get_table_column(table, j);
colname = db_get_column_name(column);
if (fidcol && *fidcol && strcmp(colname, fidcol) == 0) {
/* skip fid column */
continue;
}
value = db_get_column_value(column);
/* for debug only */
db_convert_column_value_to_string(column, &dbstring);
G_debug(2, "col %d : val = %s", j,
db_get_string(&dbstring));
sqltype = db_get_column_sqltype(column);
ctype = db_sqltype_to_Ctype(sqltype);
ogrtype = sqltype_to_ogrtype(sqltype);
G_debug(2, " colctype = %d", ctype);
ogrfieldnum = OGR_F_GetFieldIndex(Ogr_feature, colname);
if (ogrfieldnum < 0) {
/* create field if not exists */
hFieldDefn = OGR_Fld_Create(colname, ogrtype);
if (OGR_L_CreateField(Ogr_layer, hFieldDefn, TRUE) != OGRERR_NONE)
G_warning(_("Unable to create field <%s>"), colname);
ogrfieldnum = OGR_F_GetFieldIndex(Ogr_feature, colname);
}
/* Reset */
OGR_F_UnsetField(Ogr_feature, ogrfieldnum);
/* prevent writing NULL values */
if (!db_test_value_isnull(value)) {
switch (ctype) {
case DB_C_TYPE_INT:
OGR_F_SetFieldInteger(Ogr_feature, ogrfieldnum,
db_get_value_int(value));
break;
case DB_C_TYPE_DOUBLE:
OGR_F_SetFieldDouble(Ogr_feature, ogrfieldnum,
db_get_value_double(value));
break;
case DB_C_TYPE_STRING:
OGR_F_SetFieldString(Ogr_feature, ogrfieldnum,
db_get_value_string(value));
break;
case DB_C_TYPE_DATETIME:
db_convert_column_value_to_string(column,
&dbstring);
OGR_F_SetFieldString(Ogr_feature, ogrfieldnum,
db_get_string(&dbstring));
break;
}
}
}
db_close_cursor (&cursor);
db_free_string(&dbstring);
return 1;
}
QgsFields QgsGrassVectorLayer::fields()
{
QString dblnPath = mGrassObject.mapsetPath() + "/vector/" + mGrassObject.name() + "/dbln";
QgsDebugMsg( "dblnPath = " + dblnPath );
QFileInfo dblnFileInfo( dblnPath );
if ( !dblnFileInfo.exists() )
{
QgsDebugMsg( "dbln does not exist" );
mFields.clear();
mFieldsTimeStamp.setTime_t( 0 );
return mFields;
}
if ( dblnFileInfo.lastModified() > mFieldsTimeStamp && !mDriver.isEmpty()
&& !mDatabase.isEmpty() && !mTable.isEmpty() && !mKey.isEmpty() )
{
QgsDebugMsg( "reload fields" );
mError.clear();
mFields.clear();
mFieldsTimeStamp = dblnFileInfo.lastModified();
QgsDebugMsg( "open database " + mDatabase + " by driver " + mDriver );
QgsGrass::lock();
QgsGrass::setMapset( mGrassObject.gisdbase(), mGrassObject.location(), mGrassObject.mapset() );
dbDriver *driver = db_start_driver_open_database( mDriver.toUtf8().data(), mDatabase.toUtf8().data() );
if ( !driver )
{
mError = QObject::tr( "Cannot open database %1 by driver %2" ).arg( mDatabase, mDatabase );
QgsDebugMsg( mError );
}
else
{
QgsDebugMsg( "Database opened -> describe table " + mTable );
dbString tableName;
db_init_string( &tableName );
db_set_string( &tableName, mTable.toUtf8().data() );
dbTable *table;
if ( db_describe_table( driver, &tableName, &table ) != DB_OK )
{
mError = QObject::tr( "Cannot describe table %1" ).arg( mTable );
QgsDebugMsg( mError );
}
else
{
int nCols = db_get_table_number_of_columns( table );
for ( int c = 0; c < nCols; c++ )
{
dbColumn *column = db_get_table_column( table, c );
int ctype = db_sqltype_to_Ctype( db_get_column_sqltype( column ) );
QString type;
QVariant::Type qtype = QVariant::String; //default to string to prevent compiler warnings
switch ( ctype )
{
case DB_C_TYPE_INT:
type = "int";
qtype = QVariant::Int;
break;
case DB_C_TYPE_DOUBLE:
type = "double";
qtype = QVariant::Double;
break;
case DB_C_TYPE_STRING:
type = "string";
qtype = QVariant::String;
break;
case DB_C_TYPE_DATETIME:
type = "datetime";
qtype = QVariant::String;
break;
}
mFields.append( QgsField( db_get_column_name( column ), qtype, type, db_get_column_length( column ), 0 ) );
}
}
db_close_database_shutdown_driver( driver );
}
QgsGrass::unlock();
}
QgsDebugMsg( QString( "mFields.size() = %1" ).arg( mFields.size() ) );
return mFields;
}
void QgsGrassVectorMapLayer::load()
{
clear();
if ( !mMap )
{
return;
}
// Attributes are not loaded for topo layers in which case field == 0
if ( mField == 0 )
{
return;
}
QgsDebugMsg( QString( "cidxFieldIndex() = %1 cidxFieldNumCats() = %2" ).arg( cidxFieldIndex() ).arg( cidxFieldNumCats() ) );
mFieldInfo = Vect_get_field( mMap->map(), mField ); // should work also with field = 0
if ( !mFieldInfo )
{
QgsDebugMsg( "No field info -> no attribute table" );
}
else
{
QgsDebugMsg( "Field info found -> open database" );
QFileInfo di( mMap->grassObject().mapsetPath() + "/vector/" + mMap->grassObject().name() + "/dbln" );
mLastLoaded = di.lastModified();
QString error;
dbDriver *databaseDriver = openDriver( error );
if ( !databaseDriver || !error.isEmpty() )
{
QgsDebugMsg( error );
}
else
{
QgsDebugMsg( "Database opened -> open select cursor" );
QgsGrass::lock(); // not sure if lock is necessary
dbString dbstr;
db_init_string( &dbstr );
db_set_string( &dbstr, ( char * )"select * from " );
db_append_string( &dbstr, mFieldInfo->table );
QgsDebugMsg( QString( "SQL: %1" ).arg( db_get_string( &dbstr ) ) );
dbCursor databaseCursor;
if ( db_open_select_cursor( databaseDriver, &dbstr, &databaseCursor, DB_SCROLL ) != DB_OK )
{
db_close_database_shutdown_driver( databaseDriver );
QgsGrass::warning( "Cannot select attributes from table '" + QString( mFieldInfo->table ) + "'" );
}
else
{
#ifdef QGISDEBUG
int nRecords = db_get_num_rows( &databaseCursor );
QgsDebugMsg( QString( "Number of records: %1" ).arg( nRecords ) );
#endif
dbTable *databaseTable = db_get_cursor_table( &databaseCursor );
int nColumns = db_get_table_number_of_columns( databaseTable );
// Read columns' description
for ( int i = 0; i < nColumns; i++ )
{
QPair<double, double> minMax( DBL_MAX, -DBL_MAX );
dbColumn *column = db_get_table_column( databaseTable, i );
int ctype = db_sqltype_to_Ctype( db_get_column_sqltype( column ) );
QVariant::Type qtype = QVariant::String; //default to string
QgsDebugMsg( QString( "column = %1 ctype = %2" ).arg( db_get_column_name( column ) ).arg( ctype ) );
QString ctypeStr;
switch ( ctype )
{
case DB_C_TYPE_INT:
ctypeStr = QStringLiteral( "integer" );
qtype = QVariant::Int;
break;
case DB_C_TYPE_DOUBLE:
ctypeStr = QStringLiteral( "double" );
qtype = QVariant::Double;
break;
case DB_C_TYPE_STRING:
ctypeStr = QStringLiteral( "string" );
qtype = QVariant::String;
break;
case DB_C_TYPE_DATETIME:
ctypeStr = QStringLiteral( "datetime" );
qtype = QVariant::String;
break;
}
mTableFields.append( QgsField( db_get_column_name( column ), qtype, ctypeStr,
db_get_column_length( column ), db_get_column_precision( column ) ) );
mMinMax << minMax;
if ( G_strcasecmp( db_get_column_name( column ), mFieldInfo->key ) == 0 )
{
mKeyColumn = i;
}
}
if ( mKeyColumn < 0 )
{
mTableFields.clear();
QgsGrass::warning( QObject::tr( "Key column '%1' not found in the table '%2'" ).arg( mFieldInfo->key, mFieldInfo->table ) );
}
else
{
mHasTable = true;
// Read attributes to the memory
for ( ;; )
{
int more;
if ( db_fetch( &databaseCursor, DB_NEXT, &more ) != DB_OK )
{
QgsDebugMsg( "Cannot fetch DB record" );
break;
}
if ( !more )
{
break; // no more records
}
// Check cat value
dbColumn *column = db_get_table_column( databaseTable, mKeyColumn );
dbValue *value = db_get_column_value( column );
if ( db_test_value_isnull( value ) )
{
continue;
}
int cat = db_get_value_int( value );
if ( cat < 0 )
{
continue;
}
QList<QVariant> values;
for ( int i = 0; i < nColumns; i++ )
{
column = db_get_table_column( databaseTable, i );
int sqltype = db_get_column_sqltype( column );
int ctype = db_sqltype_to_Ctype( sqltype );
value = db_get_column_value( column );
db_convert_value_to_string( value, sqltype, &dbstr );
QgsDebugMsgLevel( QString( "column = %1 value = %2" ).arg( db_get_column_name( column ), db_get_string( &dbstr ) ), 3 );
QVariant variant;
if ( !db_test_value_isnull( value ) )
{
int iv;
double dv;
//layer.mAttributes[layer.nAttributes].values[i] = strdup( db_get_string( &dbstr ) );
switch ( ctype )
{
case DB_C_TYPE_INT:
iv = db_get_value_int( value );
variant = QVariant( iv );
mMinMax[i].first = std::min( mMinMax[i].first, ( double )iv );
mMinMax[i].second = std::min( mMinMax[i].second, ( double )iv );
break;
case DB_C_TYPE_DOUBLE:
dv = db_get_value_double( value );
variant = QVariant( dv );
mMinMax[i].first = std::min( mMinMax[i].first, dv );
mMinMax[i].second = std::min( mMinMax[i].second, dv );
break;
case DB_C_TYPE_STRING:
// Store as byte array so that codec may be used later
variant = QVariant( QByteArray( db_get_value_string( value ) ) );
break;
case DB_C_TYPE_DATETIME:
variant = QVariant( QByteArray( db_get_string( &dbstr ) ) );
break;
default:
variant = QVariant( QByteArray( db_get_string( &dbstr ) ) );
}
}
QgsDebugMsgLevel( QString( "column = %1 variant = %2" ).arg( db_get_column_name( column ), variant.toString() ), 3 );
values << variant;
}
mAttributes.insert( cat, values );
}
}
mValid = true;
db_close_cursor( &databaseCursor );
db_close_database_shutdown_driver( databaseDriver );
db_free_string( &dbstr );
QgsDebugMsg( QString( "mTableFields.size = %1" ).arg( mTableFields.size() ) );
QgsDebugMsg( QString( "number of attributes = %1" ).arg( mAttributes.size() ) );
}
QgsGrass::unlock();
}
}
// Add cat if no attribute fields exist (otherwise qgis crashes)
if ( mTableFields.size() == 0 )
{
mKeyColumn = 0;
mTableFields.append( QgsField( QStringLiteral( "cat" ), QVariant::Int, QStringLiteral( "integer" ) ) );
QPair<double, double> minMax( 0, 0 );
if ( cidxFieldIndex() >= 0 )
{
int ncats, cat, type, id;
ncats = Vect_cidx_get_num_cats_by_index( mMap->map(), cidxFieldIndex() );
if ( ncats > 0 )
{
Vect_cidx_get_cat_by_index( mMap->map(), cidxFieldIndex(), 0, &cat, &type, &id );
minMax.first = cat;
Vect_cidx_get_cat_by_index( mMap->map(), cidxFieldIndex(), ncats - 1, &cat, &type, &id );
minMax.second = cat;
}
}
mMinMax << minMax;
}
mFields = mTableFields;
mAttributeFields = mTableFields;
QgsDebugMsg( QString( "layer loaded mTableFields.size() = %1 mAttributes.size() = %2" ).arg( mTableFields.size() ).arg( mAttributes.size() ) );
mValid = true;
}
int query(struct Map_info *Map)
{
int i, j, idx, cat_no, nlines, type;
register int line_num;
struct line_pnts *Points;
struct line_cats *Cats;
struct field_info *Fi;
dbString stmt, value_string;
dbDriver *driver;
/* Initialize the Point struct */
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
G_message(_("Reading features..."));
/* Cycle through all lines and make a list of categories of 'qfield' for each category given by 'field' */
nlines = Vect_get_num_lines(Map);
for (line_num = 1; line_num <= nlines; line_num++) {
type = Vect_read_line(Map, Points, Cats, line_num);
if (!(type & options.type))
continue;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == options.field) {
cat_no = Cats->cat[i];
idx = find_cat(cat_no, 1);
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == options.qfield) { /* Add to list */
if (Values[idx].nqcats == Values[idx].aqcats) { /* Alloc space */
Values[idx].aqcats += 2;
Values[idx].qcat =
(int *)G_realloc(Values[idx].qcat,
Values[idx].aqcats *
sizeof(int));
}
Values[idx].qcat[Values[idx].nqcats] = Cats->cat[j];
Values[idx].nqcats++;
}
}
}
}
/* If there is no field cat add cat -1, values for cat -1 are reported at the end */
Vect_cat_get(Cats, options.field, &cat_no);
if (cat_no == -1) {
idx = find_cat(cat_no, 1);
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == options.qfield) { /* Add to list */
if (Values[idx].nqcats == Values[idx].aqcats) { /* Alloc space */
Values[idx].aqcats += 2;
Values[idx].qcat =
(int *)G_realloc(Values[idx].qcat,
Values[idx].aqcats *
sizeof(int));
}
Values[idx].qcat[Values[idx].nqcats] = Cats->cat[j];
Values[idx].nqcats++;
}
}
}
G_percent(line_num, nlines, 2);
}
db_init_string(&stmt);
db_init_string(&value_string);
if ((Fi = Vect_get_field(Map, options.qfield)) == NULL)
G_fatal_error(_("Database connection not defined for layer %d. Use v.db.connect first."),
options.qfield);
/* Open driver */
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);
/* Query the database for each category */
G_message(_("Querying database... "));
for (i = 0; i < vstat.rcat; i++) {
int j, ctype, nrows, more;
char buf[2000];
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
G_debug(3, "cat %d", Values[i].cat);
G_percent(i + 1, vstat.rcat, 1);
/* Skip if cat is zero and large number of query categories (many features without category).
* It would cause problems on server side and take long time. Postgres limit is 10000 */
/* TODO: verify because no category is encoded as cat = -1, not cat = zero */
if (Values[i].cat == 0 && Values[i].nqcats > 1000) {
G_warning(_("Query for category '0' (no category) was not executed because of too many "
"(%d) query categories. All later reported values for cat 0 are not valid."),
Values[i].nqcats);
continue;
}
if (Values[i].nqcats > 0) {
sprintf(buf, "SELECT %s FROM %s WHERE", options.qcol, Fi->table);
db_set_string(&stmt, buf);
for (j = 0; j < Values[i].nqcats; j++) {
G_debug(4, " qcat %d", Values[i].qcat[j]);
if (j > 0)
db_append_string(&stmt, " OR");
sprintf(buf, " %s = %d", Fi->key, Values[i].qcat[j]);
db_append_string(&stmt, buf);
}
G_debug(4, " SQL: '%s'", db_get_string(&stmt));
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL)
!= DB_OK)
G_fatal_error("Cannot open cursor: '%s'",
db_get_string(&stmt));
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
value = db_get_column_value(column);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
vstat.qtype = ctype;
nrows = db_get_num_rows(&cursor);
G_debug(4, " nrows = %d, columnt type = %d", nrows, ctype);
if (nrows != 1) {
if (nrows > 1) {
G_warning(_("Multiple query results, output value set to NULL (category [%d])"),
Values[i].cat);
}
Values[i].null = 1;
}
else {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
G_fatal_error(_("Unable to fetch record"));
db_convert_column_value_to_string(column, &stmt);
G_debug(4, " value = %s", db_get_string(&stmt));
if (db_test_value_isnull(value)) {
Values[i].null = 1;
}
else {
switch (ctype) {
case (DB_C_TYPE_INT):
Values[i].i1 = db_get_value_int(value);
break;
case (DB_C_TYPE_DOUBLE):
Values[i].d1 = db_get_value_double(value);
break;
case (DB_C_TYPE_STRING):
Values[i].str1 = G_store(db_get_value_string(value));
break;
case (DB_C_TYPE_DATETIME):
db_convert_column_value_to_string(column,
&value_string);
Values[i].str1 =
G_store(db_get_string(&value_string));
}
Values[i].null = 0;
}
}
db_close_cursor(&cursor);
}
else { /* no qcats -> upload NULL */
Values[i].null = 1;
}
}
db_close_database_shutdown_driver(driver);
return 0;
}
OGRGRASSLayer::OGRGRASSLayer( int layerIndex, struct Map_info * map )
{
CPLDebug ( "GRASS", "OGRGRASSLayer::OGRGRASSLayer layerIndex = %d", layerIndex );
iLayerIndex = layerIndex;
poMap = map;
poSRS = NULL;
iNextId = 0;
poPoints = Vect_new_line_struct();
poCats = Vect_new_cats_struct();
pszQuery = NULL;
paQueryMatch = NULL;
paSpatialMatch = NULL;
iLayer = Vect_cidx_get_field_number ( poMap, iLayerIndex);
CPLDebug ( "GRASS", "iLayer = %d", iLayer );
poLink = Vect_get_field ( poMap, iLayer ); // May be NULL if not defined
// Layer name
if ( poLink && poLink->name )
{
pszName = CPLStrdup( poLink->name );
}
else
{
char buf[20];
sprintf ( buf, "%d", iLayer );
pszName = CPLStrdup( buf );
}
// Because we don't represent centroids as any simple feature, we have to scan
// category index and create index of feature IDs pointing to category index
nTotalCount = Vect_cidx_get_type_count(poMap,iLayer, GV_POINT|GV_LINES|GV_AREA);
CPLDebug ( "GRASS", "nTotalCount = %d", nTotalCount );
paFeatureIndex = (int *) CPLMalloc ( nTotalCount * sizeof(int) );
int n = Vect_cidx_get_type_count(poMap,iLayer, GV_POINTS|GV_LINES|GV_AREA);
int cnt = 0;
for ( int i = 0; i < n; i++ )
{
int cat,type, id;
Vect_cidx_get_cat_by_index ( poMap, iLayerIndex, i, &cat, &type, &id );
if ( !( type & (GV_POINT|GV_LINES|GV_AREA) ) ) continue;
paFeatureIndex[cnt++] = i;
}
poFeatureDefn = new OGRFeatureDefn( pszName );
poFeatureDefn->Reference();
// Get type definition
int nTypes = Vect_cidx_get_num_types_by_index ( poMap, iLayerIndex );
int types = 0;
for ( int i = 0; i < nTypes; i++ ) {
int type, count;
Vect_cidx_get_type_count_by_index ( poMap, iLayerIndex, i, &type, &count);
if ( !(type & (GV_POINT|GV_LINES|GV_AREA) ) ) continue;
types |= type;
CPLDebug ( "GRASS", "type = %d types = %d", type, types );
}
OGRwkbGeometryType eGeomType = wkbUnknown;
if ( types == GV_LINE || types == GV_BOUNDARY || types == GV_LINES )
{
eGeomType = wkbLineString;
}
else if ( types == GV_POINT )
{
eGeomType = wkbPoint;
}
else if ( types == GV_AREA )
{
CPLDebug ( "GRASS", "set wkbPolygon" );
eGeomType = wkbPolygon;
}
if (Vect_is_3d(poMap))
poFeatureDefn->SetGeomType ( (OGRwkbGeometryType)(eGeomType | wkb25DBit) );
else
poFeatureDefn->SetGeomType ( eGeomType );
// Get attributes definition
poDbString = (dbString*) CPLMalloc ( sizeof(dbString) );
poCursor = (dbCursor*) CPLMalloc ( sizeof(dbCursor) );
bCursorOpened = FALSE;
poDriver = NULL;
bHaveAttributes = false;
db_init_string ( poDbString );
if ( poLink )
{
if ( StartDbDriver() )
{
db_set_string ( poDbString, poLink->table );
dbTable *table;
if ( db_describe_table ( poDriver, poDbString, &table) == DB_OK )
{
nFields = db_get_table_number_of_columns ( table );
iCatField = -1;
for ( int i = 0; i < nFields; i++)
{
dbColumn *column = db_get_table_column ( table, i );
int ctype = db_sqltype_to_Ctype ( db_get_column_sqltype(column) );
OGRFieldType ogrFtype = OFTInteger;
switch ( ctype ) {
case DB_C_TYPE_INT:
ogrFtype = OFTInteger;
break;
case DB_C_TYPE_DOUBLE:
ogrFtype = OFTReal;
break;
case DB_C_TYPE_STRING:
ogrFtype = OFTString;
break;
case DB_C_TYPE_DATETIME:
ogrFtype = OFTDateTime;
break;
}
CPLDebug ( "GRASS", "column = %s type = %d",
db_get_column_name(column), ctype );
OGRFieldDefn oField ( db_get_column_name(column), ogrFtype );
poFeatureDefn->AddFieldDefn( &oField );
if ( G_strcasecmp(db_get_column_name(column),poLink->key) == 0 )
{
iCatField = i;
}
}
if ( iCatField >= 0 )
{
bHaveAttributes = true;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot find key field" );
db_close_database_shutdown_driver ( poDriver );
poDriver = NULL;
}
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot describe table %s",
poLink->table );
}
db_close_database_shutdown_driver ( poDriver );
poDriver = NULL;
}
}
if ( !bHaveAttributes && iLayer > 0 ) // Because features in layer 0 have no cats
{
OGRFieldDefn oField("cat", OFTInteger);
poFeatureDefn->AddFieldDefn( &oField );
}
if ( getenv("GISBASE") ) // We have some projection info in GISBASE
{
struct Key_Value *projinfo, *projunits;
// Note: we dont have to reset GISDBASE and LOCATION_NAME because
// OGRGRASSLayer constructor is called from OGRGRASSDataSource::Open
// where those variables are set
projinfo = G_get_projinfo();
projunits = G_get_projunits();
char *srsWkt = GPJ_grass_to_wkt ( projinfo, projunits, 0, 0);
if ( srsWkt )
{
poSRS = new OGRSpatialReference ( srsWkt );
CPLFree ( srsWkt );
}
G_free_key_value(projinfo);
G_free_key_value(projunits);
}
}
struct Map_info *G_sites_open_old(const char *name, const char *mapset)
{
struct Map_info *Map;
struct field_info *fi;
int more, nrows, row, ncols, col, ndbl, nstr, adbl, astr, ctype;
SITE_ATT *sa;
dbDriver *driver;
dbString stmt;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
G_message(
_("Dev note: Adapted sites library used for vector points. "
"(module should be updated to GRASS 6 vector library)"));
Map = (struct Map_info *)G_malloc(sizeof(struct Map_info));
Vect_set_open_level(1);
Vect_open_old(Map, name, mapset);
G_debug(1, "Vector map opened");
/* Load attributes */
Map->site_att = NULL;
Map->n_site_att = 0;
Map->n_site_dbl = 0;
Map->n_site_str = 0;
fi = Vect_get_field(Map, 1);
if (fi == NULL) { /* not attribute table */
G_debug(1, "No attribute table");
return 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);
db_init_string(&stmt);
db_set_string(&stmt, "select * from ");
db_append_string(&stmt, fi->table);
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open select cursor: '%s'"),
db_get_string(&stmt));
nrows = db_get_num_rows(&cursor);
G_debug(1, "%d rows selected from vector attribute table", nrows);
Map->site_att = (SITE_ATT *) malloc(nrows * sizeof(SITE_ATT));
Map->n_site_att = nrows;
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
row = 0;
adbl = astr = 0;
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
G_fatal_error(_("Cannot fetch row"));
if (!more)
break;
/* Get number of each type */
if (row == 0) {
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (strcmp(db_get_column_name(column), fi->key) == 0)
continue;
switch (ctype) {
case DB_C_TYPE_INT:
case DB_C_TYPE_DOUBLE:
adbl++;
break;
case DB_C_TYPE_STRING:
case DB_C_TYPE_DATETIME:
astr++;
break;
}
}
Map->n_site_dbl = adbl;
Map->n_site_str = astr;
G_debug(1, "adbl = %d astr = %d", adbl, astr);
}
sa = &(Map->site_att[row]);
sa->dbl = (double *)malloc(adbl * sizeof(double));
sa->str = (char **)malloc(astr * sizeof(char *));
ndbl = nstr = 0;
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
value = db_get_column_value(column);
if (strcmp(db_get_column_name(column), fi->key) == 0) {
sa->cat = db_get_value_int(value);
}
else {
switch (ctype) {
case DB_C_TYPE_INT:
sa->dbl[ndbl] = db_get_value_int(value);
ndbl++;
break;
case DB_C_TYPE_DOUBLE:
sa->dbl[ndbl] = db_get_value_double(value);
ndbl++;
break;
case DB_C_TYPE_STRING:
sa->str[nstr] = G_store(db_get_value_string(value));
nstr++;
break;
case DB_C_TYPE_DATETIME:
sa->str[nstr] = ""; /* TODO */
nstr++;
break;
}
}
}
row++;
}
db_close_database_shutdown_driver(driver);
/* sort attributes */
qsort((void *)Map->site_att, Map->n_site_att, sizeof(SITE_ATT),
site_att_cmp);
return Map;
}
/*
Returns field names, types and indexes in double and string Map_info arrays
WARNING: user is responsible to free allocated memory, directly or calling G_sites_free_fields()
*/
int G_sites_get_fields(struct Map_info *Map, char ***cnames, int **ctypes,
int **ndx)
{
struct field_info *fi;
int nrows, row, ncols, col, ndbl, nstr, ctype;
const char *name;
dbDriver *driver;
dbString stmt;
dbCursor cursor;
dbTable *table;
dbColumn *column;
/*dbValue *value; */
/* warning: we are using "1" as cat field in Vect_get_field because G_sites_open_old
(in lib/sites/sites.c), that we use here to open sites, does the same and then
queries the db in the same way we do here.
Should it be not true in the future, maybe we'll have to change this by choosing
appropriate fields and multiple categories */
fi = (struct field_info *)Vect_get_field(Map, 1);
if (fi == NULL) { /* not attribute table */
G_debug(1, "No attribute table");
return -1;
}
driver = db_start_driver_open_database(fi->driver, fi->database);
if (driver == NULL)
G_fatal_error(_("Cannot open database %s by driver %s"), fi->database,
fi->driver);
db_init_string(&stmt);
db_set_string(&stmt, "select * from ");
db_append_string(&stmt, fi->table);
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Cannot select attributes"));
nrows = db_get_num_rows(&cursor);
G_debug(1, "%d rows selected from vector attribute table", nrows);
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
if (ncols <= 0)
return ncols;
row = 0;
/* Get number of each type */
ndbl = nstr = 0;
*cnames = (char **)malloc(ncols * sizeof(char *));
*ctypes = (int *)malloc(ncols * sizeof(int));
*ndx = (int *)malloc(ncols * sizeof(int));
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
name = db_get_column_name(column);
*(*cnames + col) = (char *)malloc(strlen(name) + 1);
strcpy(*(*cnames + col), db_get_column_name(column));
/* ctypes is 'c' for cat, 'd' for double, 's' for string */
if (strcmp(name, fi->key) == 0) {
*(*ctypes + col) = 'c';
*(*ndx + col) = -1;
}
else {
switch (ctype) {
case DB_C_TYPE_INT:
case DB_C_TYPE_DOUBLE:
*(*ctypes + col) = 'd';
*(*ndx + col) = ndbl;
ndbl++;
break;
case DB_C_TYPE_STRING:
case DB_C_TYPE_DATETIME:
*(*ctypes + col) = 's';
*(*ndx + col) = nstr;
nstr++;
break;
}
}
}
db_close_database_shutdown_driver(driver);
return ncols;
}
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;
}
/* Returns 0 - ok , 1 - error */
int
plot(int ctype, struct Map_info *Map, int type, int field,
char *columns, int ncols, char *sizecol, int size, double scale,
COLOR * ocolor, COLOR * colors, int y_center, double *max_reference,
int do3d)
{
int ltype, nlines, line, col, more, coltype, nselcols;
double x, y, csize, len;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
double *val;
char buf[2000];
struct field_info *Fi;
dbDriver *driver;
dbValue *value;
dbString sql;
dbCursor cursor;
dbTable *table;
dbColumn *column;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
Fi = Vect_get_field(Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
/* Open driver */
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fi->database,
Fi->driver);
return 1;
}
db_set_error_handler_driver(driver);
val = (double *)G_malloc((ncols + 1) * sizeof(double)); /* + 1 for sizecol */
Vect_rewind(Map);
nlines = Vect_get_num_lines(Map);
/* loop through each vector feature */
for (line = 1; line <= nlines; line++) {
G_debug(3, "line = %d", line);
ltype = Vect_read_line(Map, Points, Cats, line);
if (!(ltype & type))
continue;
Vect_cat_get(Cats, field, &cat);
if (cat < 0)
continue;
/* Select values from DB */
if (ctype == CTYPE_PIE && sizecol != NULL) {
sprintf(buf, "select %s, %s from %s where %s = %d", columns,
sizecol, Fi->table, Fi->key, cat);
nselcols = ncols + 1;
}
else {
sprintf(buf, "select %s from %s where %s = %d", columns,
Fi->table, Fi->key, cat);
nselcols = ncols;
}
db_set_string(&sql, buf);
G_debug(3, "SQL: %s", buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
buf);
return 1;
}
table = db_get_cursor_table(&cursor);
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK || !more)
continue;
for (col = 0; col < nselcols; col++) {
column = db_get_table_column(table, col);
value = db_get_column_value(column);
coltype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
switch (coltype) {
case DB_C_TYPE_INT:
val[col] = (double)db_get_value_int(value);
break;
case DB_C_TYPE_DOUBLE:
val[col] = db_get_value_double(value);
break;
default:
G_warning("Column type not supported (must be INT or FLOAT)");
return 1;
}
G_debug(4, " val[%d]: %f", col, val[col]);
}
db_close_cursor(&cursor);
/* Center of chart */
if (ltype & GV_LINES) { /* find center */
len = Vect_line_length(Points) / 2;
Vect_point_on_line(Points, len, &x, &y, NULL, NULL, NULL);
}
else {
x = Points->x[0];
y = Points->y[0];
}
if (ctype == CTYPE_PIE) {
if (sizecol != NULL) {
csize = val[ncols];
size = scale * csize;
}
pie(x, y, size, val, ncols, ocolor, colors, do3d);
}
else {
bar(x, y, size, scale, val, ncols, ocolor, colors, y_center,
max_reference, do3d);
}
}
db_close_database_shutdown_driver(driver);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
/*------------------------------------------------------------------------------------------------*/
void
P_Aux_to_Vector(struct Map_info *Map, struct Map_info *Out, dbDriver * driver,
char *tab_name)
{
int more, line_num, type, count = 0;
double coordX, coordY, coordZ;
struct line_pnts *point;
struct line_cats *cat;
dbTable *table;
dbColumn *column;
dbValue *value;
dbCursor cursor;
dbString sql;
char buf[1024];
point = Vect_new_line_struct();
cat = Vect_new_cats_struct();
db_init_string(&sql);
db_zero_string(&sql);
sprintf(buf, "select ID, X, Y, sum(Interp) from %s group by ID, X, Y",
tab_name);
db_append_string(&sql, buf);
db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL);
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
count++;
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (type == DB_C_TYPE_INT)
value = db_get_column_value(column);
else
continue;
line_num = db_get_value_int(value);
column = db_get_table_column(table, 1);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (type == DB_C_TYPE_DOUBLE)
value = db_get_column_value(column);
else
continue;
coordZ = db_get_value_double(value);
column = db_get_table_column(table, 2);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (type == DB_C_TYPE_DOUBLE)
value = db_get_column_value(column);
else
continue;
coordX = db_get_value_double(value);
column = db_get_table_column(table, 3);
type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (type == DB_C_TYPE_DOUBLE)
value = db_get_column_value(column);
else
continue;
coordY = db_get_value_double(value);
Vect_copy_xyz_to_pnts(point, &coordX, &coordY, &coordZ, 1);
Vect_reset_cats(cat);
Vect_cat_set(cat, 1, 1);
Vect_write_line(Out, GV_POINT, point, cat);
}
return;
}
int main(int argc, char *argv[])
{
int i, cat, with_z, more, ctype, nrows;
char buf[DB_SQL_MAX];
int count;
double coor[3];
int ncoor;
struct Option *driver_opt, *database_opt, *table_opt;
struct Option *xcol_opt, *ycol_opt, *zcol_opt, *keycol_opt, *where_opt,
*outvect;
struct Flag *same_table_flag;
struct GModule *module;
struct Map_info Map;
struct line_pnts *Points;
struct line_cats *Cats;
dbString sql;
dbDriver *driver;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
struct field_info *fi;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("import"));
G_add_keyword(_("database"));
G_add_keyword(_("points"));
module->description =
_("Creates new vector (points) map from database table containing coordinates.");
table_opt = G_define_standard_option(G_OPT_DB_TABLE);
table_opt->required = YES;
table_opt->description = _("Input table name");
driver_opt = G_define_standard_option(G_OPT_DB_DRIVER);
driver_opt->options = db_list_drivers();
driver_opt->answer = (char *)db_get_default_driver_name();
driver_opt->guisection = _("Input DB");
database_opt = G_define_standard_option(G_OPT_DB_DATABASE);
database_opt->answer = (char *)db_get_default_database_name();
database_opt->guisection = _("Input DB");
xcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
xcol_opt->key = "x";
xcol_opt->required = YES;
xcol_opt->description = _("Name of column containing x coordinate");
ycol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
ycol_opt->key = "y";
ycol_opt->required = YES;
ycol_opt->description = _("Name of column containing y coordinate");
zcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
zcol_opt->key = "z";
zcol_opt->description = _("Name of column containing z coordinate");
zcol_opt->guisection = _("3D output");
keycol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
keycol_opt->key = "key";
keycol_opt->required = NO;
keycol_opt->label = _("Name of column containing category number");
keycol_opt->description = _("Must refer to an integer column");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
outvect = G_define_standard_option(G_OPT_V_OUTPUT);
same_table_flag = G_define_flag();
same_table_flag->key = 't';
same_table_flag->description =
_("Use imported table as attribute table for new map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (zcol_opt->answer) {
with_z = WITH_Z;
ncoor = 3;
}
else {
with_z = WITHOUT_Z;
ncoor = 2;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
if (G_get_overwrite()) {
/* We don't want to delete the input table when overwriting the output
* vector. */
char name[GNAME_MAX], mapset[GMAPSET_MAX];
if (!G_name_is_fully_qualified(outvect->answer, name, mapset)) {
strcpy(name, outvect->answer);
strcpy(mapset, G_mapset());
}
Vect_set_open_level(1); /* no topo needed */
if (strcmp(mapset, G_mapset()) == 0 && G_find_vector2(name, mapset) &&
Vect_open_old(&Map, name, mapset) >= 0) {
int num_dblinks;
num_dblinks = Vect_get_num_dblinks(&Map);
for (i = 0; i < num_dblinks; i++) {
if ((fi = Vect_get_dblink(&Map, i)) != NULL &&
strcmp(fi->driver, driver_opt->answer) == 0 &&
strcmp(fi->database, database_opt->answer) == 0 &&
strcmp(fi->table, table_opt->answer) == 0)
G_fatal_error(_("Vector map <%s> cannot be overwritten "
"because input table <%s> is linked to "
"this map."),
outvect->answer, table_opt->answer);
}
Vect_close(&Map);
}
}
if (Vect_open_new(&Map, outvect->answer, with_z) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
outvect->answer);
Vect_set_error_handler_io(NULL, &Map);
Vect_hist_command(&Map);
fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE);
/* Open driver */
driver = db_start_driver_open_database(driver_opt->answer,
database_opt->answer);
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
}
db_set_error_handler_driver(driver);
/* check if target table already exists */
G_debug(3, "Output vector table <%s>, driver: <%s>, database: <%s>",
outvect->answer, db_get_default_driver_name(),
db_get_default_database_name());
if (!same_table_flag->answer &&
db_table_exists(db_get_default_driver_name(),
db_get_default_database_name(), outvect->answer) == 1)
G_fatal_error(_("Output vector map, table <%s> (driver: <%s>, database: <%s>) "
"already exists"), outvect->answer,
db_get_default_driver_name(),
db_get_default_database_name());
if (keycol_opt->answer) {
int coltype;
coltype = db_column_Ctype(driver, table_opt->answer, keycol_opt->answer);
if (coltype == -1)
G_fatal_error(_("Column <%s> not found in table <%s>"),
keycol_opt->answer, table_opt->answer);
if (coltype != DB_C_TYPE_INT)
G_fatal_error(_("Data type of key column must be integer"));
}
else {
if (same_table_flag->answer) {
G_fatal_error(_("Option <%s> must be specified when -%c flag is given"),
keycol_opt->key, same_table_flag->key);
}
if (strcmp(db_get_default_driver_name(), "sqlite") != 0)
G_fatal_error(_("Unable to define key column. This operation is not supported "
"by <%s> driver. You need to define <%s> option."),
fi->driver, keycol_opt->key);
}
/* Open select cursor */
sprintf(buf, "SELECT %s, %s", xcol_opt->answer, ycol_opt->answer);
db_set_string(&sql, buf);
if (with_z) {
sprintf(buf, ", %s", zcol_opt->answer);
db_append_string(&sql, buf);
}
if (keycol_opt->answer) {
sprintf(buf, ", %s", keycol_opt->answer);
db_append_string(&sql, buf);
}
sprintf(buf, " FROM %s", table_opt->answer);
db_append_string(&sql, buf);
if (where_opt->answer) {
sprintf(buf, " WHERE %s", where_opt->answer);
db_append_string(&sql, buf);
}
G_debug(2, "SQL: %s", db_get_string(&sql));
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK) {
G_fatal_error(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
}
table = db_get_cursor_table(&cursor);
nrows = db_get_num_rows(&cursor);
G_debug(2, "%d points selected", nrows);
count = cat = 0;
G_message(_("Writing features..."));
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
G_percent(count, nrows, 2);
/* key column */
if (keycol_opt->answer) {
column = db_get_table_column(table, with_z ? 3 : 2);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (ctype != DB_C_TYPE_INT)
G_fatal_error(_("Key column must be integer"));
value = db_get_column_value(column);
cat = db_get_value_int(value);
}
else {
cat++;
}
/* coordinates */
for (i = 0; i < ncoor; i++) {
column = db_get_table_column(table, i);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("x/y/z column must be integer or double"));
value = db_get_column_value(column);
if (ctype == DB_C_TYPE_INT)
coor[i] = (double)db_get_value_int(value);
else
coor[i] = db_get_value_double(value);
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, coor[0], coor[1], coor[2]);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Map, GV_POINT, Points, Cats);
count++;
}
G_percent(1, 1, 1);
/* close connection to input DB before copying attributes */
db_close_database_shutdown_driver(driver);
/* Copy table */
if (!same_table_flag->answer) {
G_message(_("Copying attributes..."));
if (DB_FAILED == db_copy_table_where(driver_opt->answer, database_opt->answer,
table_opt->answer,
fi->driver, fi->database, fi->table,
where_opt->answer)) { /* where can be NULL */
G_warning(_("Unable to copy table"));
}
else {
Vect_map_add_dblink(&Map, 1, NULL, fi->table,
keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN,
fi->database, fi->driver);
}
if (!keycol_opt->answer) {
/* TODO: implement for all DB drivers in generic way if
* possible */
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);
}
db_set_error_handler_driver(driver);
/* add key column */
sprintf(buf, "ALTER TABLE %s ADD COLUMN %s INTEGER",
fi->table, GV_KEY_COLUMN);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to add key column <%s>: "
"SERIAL type is not supported by <%s>"),
GV_KEY_COLUMN, fi->driver);
}
/* update key column */
sprintf(buf, "UPDATE %s SET %s = _ROWID_",
fi->table, GV_KEY_COLUMN);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Failed to update key column <%s>"),
GV_KEY_COLUMN);
}
}
}
else {
/* do not copy attributes, link original table */
Vect_map_add_dblink(&Map, 1, NULL, table_opt->answer,
keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN,
database_opt->answer, driver_opt->answer);
}
Vect_build(&Map);
Vect_close(&Map);
G_done_msg(_n("%d point written to vector map.",
"%d points written to vector map.",
count), count);
return (EXIT_SUCCESS);
}
/*--------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variables' declarations */
int row, nrows, col, ncols, MaxPoints;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
int last_row, last_column;
int nlines, nlines_first, line_num;
int more;
int clas, region = TRUE;
double Z_interp;
double Thres_j, Thres_d, ew_resol, ns_resol;
double minNS, minEW, maxNS, maxEW;
const char *mapset;
char buf[1024], table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int colorBordo, ripieno, conta, lungPunti, lungHull, xi, c1, c2;
double altPiano;
extern double **P, **cvxHull, **punti_bordo;
/* Struct declarations */
struct Cell_head elaboration_reg, original_reg;
struct element_grow **raster_matrix;
struct Map_info In, Out, First;
struct Option *in_opt, *out_opt, *first_opt, *Thres_j_opt, *Thres_d_opt;
struct GModule *module;
struct line_pnts *points, *points_first;
struct line_cats *Cats, *Cats_first;
struct field_info *field;
dbDriver *driver;
dbString sql;
dbTable *table;
dbCursor cursor;
/*------------------------------------------------------------------------------------------*/
/* Options' declaration */ ;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
module->description =
_("Building contour determination and Region Growing "
"algorithm for determining the building inside");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description =
_("Input vector (v.lidar.edgedetection output");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
first_opt = G_define_option();
first_opt->key = "first";
first_opt->type = TYPE_STRING;
first_opt->key_desc = "name";
first_opt->required = YES;
first_opt->gisprompt = "old,vector,vector";
first_opt->description = _("Name of the first pulse vector map");
Thres_j_opt = G_define_option();
Thres_j_opt->key = "tj";
Thres_j_opt->type = TYPE_DOUBLE;
Thres_j_opt->required = NO;
Thres_j_opt->description =
_("Threshold for cell object frequency in region growing");
Thres_j_opt->answer = "0.2";
Thres_d_opt = G_define_option();
Thres_d_opt->key = "td";
Thres_d_opt->type = TYPE_DOUBLE;
Thres_d_opt->required = NO;
Thres_d_opt->description =
_("Threshold for double pulse in region growing");
Thres_d_opt->answer = "0.6";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Thres_j = atof(Thres_j_opt->answer);
Thres_d = atof(Thres_d_opt->answer);
Thres_j += 1;
/* Open input vector */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
GV_FATAL_EXIT);
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
}
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(in_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_edge_Interpolation", xname);
}
else
sprintf(table_name, "%s_edge_Interpolation", in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (Vect_open_old(&In, in_opt->answer, mapset) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (Vect_open_old(&First, first_opt->answer, mapset) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), first_opt->answer);
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&In);
Vect_close(&First);
exit(EXIT_FAILURE);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Starting driver and open db for edgedetection interpolation table */
field = Vect_get_field(&In, F_INTERPOLATION);
/*if (field == NULL)
G_fatal_error (_("Cannot read field info")); */
driver = db_start_driver_open_database(field->driver, field->database);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
field->driver);
/* is this the right place to open the cursor ??? */
db_init_string(&sql);
db_zero_string(&sql);
sprintf(buf, "SELECT Interp,ID FROM %s", table_name);
G_debug(1, "buf: %s", buf);
db_append_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open table <%s>"), table_name);
count_obj = 1;
/* no topology, get number of lines in input vector */
nlines = 0;
points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_rewind(&In);
while (Vect_read_next_line(&In, points, Cats) > 0) {
nlines++;
}
Vect_rewind(&In);
/* no topology, get number of lines in first pulse input vector */
nlines_first = 0;
points_first = Vect_new_line_struct();
Cats_first = Vect_new_cats_struct();
Vect_rewind(&First);
while (Vect_read_next_line(&First, points_first, Cats_first) > 0) {
nlines_first++;
}
Vect_rewind(&First);
/* Setting regions and boxes */
G_debug(1, _("Setting regions and boxes"));
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
/* Fixing parameters of the elaboration region */
/*! The original_region will be divided into subregions */
ew_resol = original_reg.ew_res;
ns_resol = original_reg.ns_res;
/* calculate number of subregions */
nsubregion_col = ceil((original_reg.east - original_reg.west) / (LATO * ew_resol)) + 0.5;
nsubregion_row = ceil((original_reg.north - original_reg.south) / (LATO * ns_resol)) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
/* Subdividing and working with tiles */
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each strip of LATO rows */
elaboration_reg.north = elaboration_reg.south;
if (elaboration_reg.north > original_reg.north) /* First row */
elaboration_reg.north = original_reg.north;
elaboration_reg.south = elaboration_reg.north - LATO * ns_resol;
if (elaboration_reg.south <= original_reg.south) { /* Last row */
elaboration_reg.south = original_reg.south;
last_row = TRUE;
}
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each strip of LATO columns */
struct bound_box elaboration_box;
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
elaboration_reg.west = elaboration_reg.east;
if (elaboration_reg.west < original_reg.west) /* First column */
elaboration_reg.west = original_reg.west;
elaboration_reg.east = elaboration_reg.west + LATO * ew_resol;
if (elaboration_reg.east >= original_reg.east) { /* Last column */
elaboration_reg.east = original_reg.east;
last_column = TRUE;
}
/* Setting the active region */
elaboration_reg.ns_res = ns_resol;
elaboration_reg.ew_res = ew_resol;
nrows = (elaboration_reg.north - elaboration_reg.south) / ns_resol + 0.1;
ncols = (elaboration_reg.east - elaboration_reg.west) / ew_resol + 0.1;
elaboration_reg.rows = nrows;
elaboration_reg.cols = ncols;
G_debug(1, _("Rows = %d"), nrows);
G_debug(1, _("Columns = %d"), ncols);
raster_matrix = structMatrix(0, nrows, 0, ncols);
MaxPoints = nrows * ncols;
/* Initializing matrix */
for (row = 0; row <= nrows; row++) {
for (col = 0; col <= ncols; col++) {
raster_matrix[row][col].interp = 0;
raster_matrix[row][col].fi = 0;
raster_matrix[row][col].bordo = 0;
raster_matrix[row][col].dueImp = SINGLE_PULSE;
raster_matrix[row][col].orig = 0;
raster_matrix[row][col].fo = 0;
raster_matrix[row][col].clas = PRE_TERRAIN;
raster_matrix[row][col].fc = 0;
raster_matrix[row][col].obj = 0;
}
}
G_verbose_message(_("read points in input vector"));
Vect_region_box(&elaboration_reg, &elaboration_box);
line_num = 0;
Vect_rewind(&In);
while (Vect_read_next_line(&In, points, Cats) > 0) {
line_num++;
if ((Vect_point_in_box
(points->x[0], points->y[0], points->z[0],
&elaboration_box)) &&
((points->x[0] != elaboration_reg.west) ||
(points->x[0] == original_reg.west)) &&
((points->y[0] != elaboration_reg.north) ||
(points->y[0] == original_reg.north))) {
row =
(int)(Rast_northing_to_row
(points->y[0], &elaboration_reg));
col =
(int)(Rast_easting_to_col
(points->x[0], &elaboration_reg));
Z_interp = 0;
/* TODO: make sure the current db_fetch() usage works */
/* why not: */
/*
db_init_string(&sql);
sprintf(buf, "SELECT Interp,ID FROM %s WHERE ID=%d", table_name, line_num);
db_append_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open table <%s>"), table_name);
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
dbColumn *Z_Interp_col;
dbValue *Z_Interp_value;
table = db_get_cursor_table(&cursor);
Z_Interp_col = db_get_table_column(table, 1);
if (db_sqltype_to_Ctype(db_get_column_sqltype(Z_Interp_col)) ==
DB_C_TYPE_DOUBLE)
Z_Interp_value = db_get_column_value(Z_Interp_col);
else
continue;
Z_interp = db_get_value_double(Z_Interp_value);
break;
}
db_close_cursor(&cursor);
db_free_string(&sql);
*/
/* instead of */
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK ||
!more)
break;
dbColumn *Z_Interp_col, *ID_col;
dbValue *Z_Interp_value, *ID_value;
table = db_get_cursor_table(&cursor);
ID_col = db_get_table_column(table, 1);
if (db_sqltype_to_Ctype(db_get_column_sqltype(ID_col))
== DB_C_TYPE_INT)
ID_value = db_get_column_value(ID_col);
else
continue;
if (db_get_value_int(ID_value) == line_num) {
Z_Interp_col = db_get_table_column(table, 0);
if (db_sqltype_to_Ctype
(db_get_column_sqltype(Z_Interp_col)) ==
DB_C_TYPE_DOUBLE)
Z_Interp_value =
db_get_column_value(Z_Interp_col);
else
continue;
Z_interp = db_get_value_double(Z_Interp_value);
break;
}
}
raster_matrix[row][col].interp += Z_interp;
raster_matrix[row][col].fi++;
/*if (( clas = Vect_get_line_cat (&In, line_num, F_EDGE_DETECTION_CLASS) ) != UNKNOWN_EDGE) { */
if (Vect_cat_get(Cats, F_EDGE_DETECTION_CLASS, &clas)) {
raster_matrix[row][col].clas += clas;
raster_matrix[row][col].fc++;
}
raster_matrix[row][col].orig += points->z[0];
raster_matrix[row][col].fo++;
}
Vect_reset_cats(Cats);
Vect_reset_line(points);
}
for (row = 0; row <= nrows; row++) {
for (col = 0; col <= ncols; col++) {
if (raster_matrix[row][col].fc != 0) {
raster_matrix[row][col].clas--;
raster_matrix[row][col].
clas /= raster_matrix[row][col].fc;
}
if (raster_matrix[row][col].fi != 0)
raster_matrix[row][col].
interp /= raster_matrix[row][col].fi;
if (raster_matrix[row][col].fo != 0)
raster_matrix[row][col].
orig /= raster_matrix[row][col].fo;
}
}
/* DOUBLE IMPULSE */
Vect_rewind(&First);
while (Vect_read_next_line(&First, points_first, Cats_first) > 0) {
if ((Vect_point_in_box
(points_first->x[0], points_first->y[0],
points_first->z[0], &elaboration_box)) &&
((points->x[0] != elaboration_reg.west) ||
(points->x[0] == original_reg.west)) &&
((points->y[0] != elaboration_reg.north) ||
(points->y[0] == original_reg.north))) {
row =
(int)(Rast_northing_to_row
(points_first->y[0], &elaboration_reg));
col =
(int)(Rast_easting_to_col
(points_first->x[0], &elaboration_reg));
if (fabs
(points_first->z[0] - raster_matrix[row][col].orig) >=
Thres_d)
raster_matrix[row][col].dueImp = DOUBLE_PULSE;
}
Vect_reset_cats(Cats_first);
Vect_reset_line(points_first);
}
/* REGION GROWING */
if (region == TRUE) {
G_verbose_message(_("Region Growing"));
punti_bordo = G_alloc_matrix(MaxPoints, 3);
P = Pvector(0, MaxPoints);
colorBordo = 5;
ripieno = 6;
for (row = 0; row <= nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col <= ncols; col++) {
if ((raster_matrix[row][col].clas >= Thres_j) &&
(raster_matrix[row][col].clas < colorBordo)
&& (raster_matrix[row][col].fi != 0) &&
(raster_matrix[row][col].dueImp ==
SINGLE_PULSE)) {
/* Selecting a connected Object zone */
ripieno++;
if (ripieno > 10)
ripieno = 6;
/* Selecting points on a connected edge */
for (conta = 0; conta < MaxPoints; conta++) {
punti_bordo[conta][0] = 0;
punti_bordo[conta][1] = 0;
punti_bordo[conta][2] = 0;
P[conta] = punti_bordo[conta]; /* It only makes indexes to be equal, not coord values!! */
}
lungPunti = 0;
lungHull = 0;
regGrow8(elaboration_reg, raster_matrix,
punti_bordo, &lungPunti, row, col,
colorBordo, Thres_j, MaxPoints);
/* CONVEX-HULL COMPUTATION */
lungHull = ch2d(P, lungPunti);
cvxHull = G_alloc_matrix(lungHull, 3);
for (xi = 0; xi < lungHull; xi++) {
cvxHull[xi][0] = P[xi][0];
cvxHull[xi][1] = P[xi][1];
cvxHull[xi][2] = P[xi][2];
}
/* Computes the interpoling plane based only on Object points */
altPiano =
pianOriz(punti_bordo, lungPunti, &minNS,
&minEW, &maxNS, &maxEW,
raster_matrix, colorBordo);
for (c1 = minNS; c1 <= maxNS; c1++) {
for (c2 = minEW; c2 <= maxEW; c2++) {
if (checkHull(c1, c2, cvxHull, lungHull)
== 1) {
raster_matrix[c1][c2].obj = count_obj;
if ((raster_matrix[c1][c2].clas ==
PRE_TERRAIN)
&& (raster_matrix[c1][c2].orig >=
altPiano) && (lungHull > 3))
raster_matrix[c1][c2].clas =
ripieno;
}
}
}
G_free_matrix(cvxHull);
count_obj++;
}
}
}
G_free_matrix(punti_bordo);
free_Pvector(P, 0, MaxPoints);
}
/* WRITING THE OUTPUT VECTOR CATEGORIES */
Vect_rewind(&In);
while (Vect_read_next_line(&In, points, Cats) > 0) { /* Read every line for buffering points */
if ((Vect_point_in_box
(points->x[0], points->y[0], points->z[0],
&elaboration_box)) &&
((points->x[0] != elaboration_reg.west) ||
(points->x[0] == original_reg.west)) &&
((points->y[0] != elaboration_reg.north) ||
(points->y[0] == original_reg.north))) {
row =
(int)(Rast_northing_to_row
(points->y[0], &elaboration_reg));
col =
(int)(Rast_easting_to_col
(points->x[0], &elaboration_reg));
if (raster_matrix[row][col].clas == PRE_TERRAIN) {
if (raster_matrix[row][col].dueImp == SINGLE_PULSE)
Vect_cat_set(Cats, F_CLASSIFICATION,
TERRAIN_SINGLE);
else
Vect_cat_set(Cats, F_CLASSIFICATION,
TERRAIN_DOUBLE);
}
else {
if (raster_matrix[row][col].dueImp == SINGLE_PULSE)
Vect_cat_set(Cats, F_CLASSIFICATION,
OBJECT_SINGLE);
else
Vect_cat_set(Cats, F_CLASSIFICATION,
OBJECT_DOUBLE);
}
Vect_cat_set(Cats, F_COUNTER_OBJ,
raster_matrix[row][col].obj);
Vect_write_line(&Out, GV_POINT, points, Cats);
}
Vect_reset_cats(Cats);
Vect_reset_line(points);
}
free_structmatrix(raster_matrix, 0, nrows - 1, 0, ncols - 1);
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
Vect_close(&In);
Vect_close(&First);
Vect_close(&Out);
db_close_database_shutdown_driver(driver);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
