qgsgrassprovider.cpp

一个非常好的GIS开源新版本

    return false;
  }
  Vect_set_category_index_update ( map->map );

  // Write history
  Vect_hist_command ( map->map );

#ifdef QGISDEBUG
  std::cerr << "Vector successfully reopened for update." << std::endl;
#endif

  map->update = true;
  map->valid = true;

  return true;
}

bool QgsGrassProvider::closeEdit ( bool newMap )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::closeEdit" << std::endl;
#endif

  if ( !isValid() )
    return false;

  /* Close map */
  GMAP *map = &(mMaps[mLayers[mLayerId].mapId]);

  if ( !(map->update) )
    return false;

  map->valid = false;
  map->version++;

  QgsGrass::setLocation ( (char *) map->gisdbase.ascii(), (char *) map->location.ascii() ); 

  // Set current mapset (mapset was previously checked by isGrassEditable() )
  // TODO: Should be done better / in other place ?
  // TODO: Is it necessary for build/close ?
  G__setenv( (char *)"MAPSET", (char *) map->mapset.ascii() );

  Vect_build_partial ( map->map, GV_BUILD_NONE, NULL);
  Vect_build ( map->map, stderr );

  // If a new map was created close the map and return
  if ( newMap )
  {
    std::cerr << "mLayers.size() = " << mLayers.size() << std::endl;
    map->update = false;
    // Map must be set as valid otherwise it is not closed and topo is not written
    map->valid = true;
    closeLayer( mLayerId );
    return true;
  }

  Vect_close ( map->map );

  map->update = false;

  if ( !reopenMap() ) return false;

  map->valid = true;

  return true;
}

bool QgsGrassProvider::reopenMap()
{
  GMAP *map = &(mMaps[mLayers[mLayerId].mapId]);

  QFileInfo di ( mGisdbase + "/" + mLocation + "/" + mMapset + "/vector/" + mMapName );
  map->lastModified = di.lastModified();

  di.setFile ( mGisdbase + "/" + mLocation + "/" + mMapset + "/vector/" + mMapset + "/dbln" );
  map->lastAttributesModified = di.lastModified();

  // Reopen vector
  QgsGrass::resetError(); // to "catch" error after Vect_open_old()
  Vect_set_open_level (2);

  Vect_open_old ( map->map, (char *) map->mapName.ascii(), (char *) map->mapset.ascii());

  if ( QgsGrass::getError() == QgsGrass::FATAL ) {
    std::cerr << "Cannot reopen GRASS vector: " << QgsGrass::getErrorMessage().toLocal8Bit().data() << std::endl;
    return false;
  }

#ifdef QGISDEBUG
  std::cerr << "GRASS map successfully reopened for reading." << std::endl;
#endif

  // Reload sources to layers
  for ( unsigned int i = 0; i <  mLayers.size(); i++) {
    // if ( !(mLayers[i].valid) ) continue; // ?

    if  ( mLayers[i].mapId == mLayers[mLayerId].mapId ) {
      loadLayerSourcesFromMap ( mLayers[i] );
    }
  }

  return true;
}

int QgsGrassProvider::numLines ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::numLines" << std::endl;
#endif

  return ( Vect_get_num_lines(mMap) );
}

int QgsGrassProvider::numNodes ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::numNodes" << std::endl;
#endif

  return ( Vect_get_num_nodes(mMap) );
}

int QgsGrassProvider::readLine ( struct line_pnts *Points, struct line_cats *Cats, int line )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::readLine" << std::endl;
#endif

  if ( Points )
    Vect_reset_line ( Points );

  if ( Cats )
    Vect_reset_cats ( Cats );

  if ( !Vect_line_alive(mMap, line) ) return -1;

  return ( Vect_read_line(mMap, Points, Cats, line) );
}

bool QgsGrassProvider::nodeCoor ( int node, double *x, double *y )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::nodeCoor" << std::endl;
#endif

  if ( !Vect_node_alive ( mMap, node) ) {
    *x = 0.0;
    *y = 0.0;
    return false;
  }

  Vect_get_node_coor ( mMap, node, x, y, NULL);
  return true;
}

bool QgsGrassProvider::lineNodes ( int line, int *node1, int *node2 )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::lineNodes" << std::endl;
#endif

  if ( !Vect_line_alive(mMap, line) ) {
    *node1 = 0;
    *node2 = 0;
    return false;
  }

  Vect_get_line_nodes ( mMap, line, node1, node2 );
  return true;
}

int QgsGrassProvider::writeLine ( int type, struct line_pnts *Points, struct line_cats *Cats )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::writeLine n_points = " << Points->n_points 
    << " n_cats = " << Cats->n_cats << std::endl;
#endif

  if ( !isEdited() )
    return -1;

  return ( (int) Vect_write_line(mMap,type,Points,Cats) );
}

int QgsGrassProvider::rewriteLine ( int line, int type, struct line_pnts *Points, struct line_cats *Cats )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::rewriteLine n_points = " << Points->n_points 
    << " n_cats = " << Cats->n_cats << std::endl;
#endif

  if ( !isEdited() )
    return -1;

  return ( Vect_rewrite_line(mMap,line,type,Points,Cats) );
}


int QgsGrassProvider::deleteLine ( int line )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::deleteLine" << std::endl;
#endif

  if ( !isEdited() )
    return -1;

  return ( Vect_delete_line(mMap,line) );
}

int QgsGrassProvider::findLine ( double x, double y, int type, double threshold )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::findLine" << std::endl;
#endif

  return ( Vect_find_line(mMap,x,y,0,type,threshold,0,0) );
}

int QgsGrassProvider::findNode ( double x, double y, double threshold )
{
  return ( Vect_find_node ( mMap, x, y, 0, threshold, 0 ) );
}

bool QgsGrassProvider::lineAreas ( int line, int *left, int *right )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::lineAreas" << std::endl;
#endif

  if ( !Vect_line_alive(mMap, line) ) {
    *left = 0;
    *right = 0;
    return false;
  }

  Vect_get_line_areas ( mMap, line, left, right );
  return true;
}

int QgsGrassProvider::centroidArea ( int centroid )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::centroidArea" << std::endl;
#endif

  if ( !Vect_line_alive(mMap, centroid) ) {
    return 0;
  }

  return ( Vect_get_centroid_area(mMap,centroid) );
}

int QgsGrassProvider::nodeNLines ( int node )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::nodeNLines" << std::endl;
#endif

  if ( !Vect_node_alive(mMap, node) ) {
    return 0;
  }

  return ( Vect_get_node_n_lines(mMap,node) );
}

int QgsGrassProvider::nodeLine ( int node, int idx )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::nodeLine" << std::endl;
#endif

  if ( !Vect_node_alive(mMap, node) ) {
    return 0;
  }

  return ( Vect_get_node_line(mMap,node,idx) );
}

int QgsGrassProvider::lineAlive ( int line )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::lineAlive" << std::endl;
#endif

  return ( Vect_line_alive(mMap, line) ) ;
}

int QgsGrassProvider::nodeAlive ( int node )
{
#if QGISDEBUG > 3
  std::cerr << "QgsGrassProvider::nodeAlive" << std::endl;
#endif

  return ( Vect_node_alive(mMap, node) ) ;
}

int QgsGrassProvider::numUpdatedLines ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::numUpdatedLines" << std::endl;
  std::cerr << "  numUpdatedLines = " << Vect_get_num_updated_lines(mMap) << std::endl;
#endif

  return ( Vect_get_num_updated_lines(mMap) ) ;
}

int QgsGrassProvider::numUpdatedNodes ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::numUpdatedNodes" << std::endl;
  std::cerr << "  numUpdatedNodes = " << Vect_get_num_updated_nodes(mMap) << std::endl;
#endif

  return ( Vect_get_num_updated_nodes(mMap) ) ;
}

int QgsGrassProvider::updatedLine ( int idx )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::updatedLine idx = " << idx << std::endl;
  std::cerr << "  updatedLine = " << Vect_get_updated_line( mMap, idx ) << std::endl;
#endif

  return ( Vect_get_updated_line( mMap, idx ) ) ;
}

int QgsGrassProvider::updatedNode ( int idx )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::updatedNode idx = " << idx << std::endl;
  std::cerr << "  updatedNode = " << Vect_get_updated_node( mMap, idx ) << std::endl;
#endif

  return ( Vect_get_updated_node( mMap, idx ) ) ;
}

// ------------------ Attributes -------------------------------------------------

QString *QgsGrassProvider::key ( int field )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::key() field = " << field << std::endl;
#endif

  QString *key = new QString();

  struct  field_info *fi = Vect_get_field( mMap, field); // should work also with field = 0

  if ( fi == NULL ) {
#ifdef QGISDEBUG
    std::cerr << "No field info -> no attributes" << std::endl;
#endif
    return key;
  }

  key->setAscii(fi->key);
  return key;
}

std::vector<QgsField> *QgsGrassProvider::columns ( int field )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::columns() field = " << field << std::endl;
#endif

  std::vector<QgsField> *col = new std::vector<QgsField>;

  struct  field_info *fi = Vect_get_field( mMap, field); // should work also with field = 0

  // Read attributes
  if ( fi == NULL ) {
#ifdef QGISDEBUG
    std::cerr << "No field info -> no attributes" << std::endl;
#endif
    return ( col );
  }

#ifdef QGISDEBUG
  std::cerr << "Field info found -> open database" << std::endl;
#endif
  QgsGrass::setMapset ( mGisdbase, mLocation, mMapset ); 
  dbDriver *driver = db_start_driver_open_database ( fi->driver, fi->database );

  if ( driver == NULL ) {
    std::cerr << "Cannot open database " << fi->database << " by driver " << fi->driver << std::endl;
    return ( col );
  }

#ifdef QGISDEBUG
  std::cerr << "Database opened -> describe table" << std::endl;
#endif

  dbString tableName;
  db_init_string ( &tableName );
  db_set_string ( &tableName, fi->table);

  dbTable *table;
  if(db_describe_table (driver, &tableName, &table) != DB_OK) {
    std::cerr << "Cannot describe table" << std::endl;
    return ( col );
  }

  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;
    }
    col->push_back ( QgsField( db_get_column_name (column), qtype, type, db_get_column_length(column), 0) );
  }

  db_close_database_shutdown_driver ( driver );

  return col;
}

QgsAttributeMap *QgsGrassProvider::attributes ( int field, int cat )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassProvider::attributes() field = " << field << " cat = " << cat << std::endl;
#endif

  QgsAttributeMap *att = new QgsAttributeMap;

  struct  field_info *fi = Vect_get_field( mMap, field); // should work also with field = 0

  // Read attributes
  if ( fi == NULL ) {
#ifdef QGISDEBUG
    std::cerr << "No field info -> no attributes" << std::endl;
#endif
    return att;
  }

#ifdef QGISDEBUG
  std::cerr << "Field info found -> open database" << std::endl;
#endif
  QgsGrass::setMapset ( mGisdbase, mLocation, mMapset ); 
  dbDriver *driver = db_start_driver_open_database ( fi->driver, fi->database );

  if ( driver == NULL ) {
    std::cerr << "Cannot open database " << fi->database << " by driver " << fi->driver << std::endl;
    return att;
  }

#ifdef QGISDEBUG
  std::cerr << "Database opened -> read attributes" << std::endl;
#endif

  dbString dbstr; 
  db_init_string (&dbstr);
  QString query;
  query.sprintf("select * from %s where %s = %d", fi->table, fi->key, cat );
  db_set_string (&dbstr, (char *)query.ascii());

#ifdef QGISDEBUG
  std::cerr << "SQL: " << db_get_string(&dbstr) << std::endl;