qgsgrassmodel.cpp

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

/*******************************************************************
                              qgsgrasstree.cpp
                             -------------------
    begin                : February, 2006
    copyright            : (C) 2006 by Radim Blazek
    email                : [e-mail]
********************************************************************/
/********************************************************************
 This program is free software; you can redistribute it and/or modify  
 it under the terms of the GNU General Public License as published by 
 the Free Software Foundation; either version 2 of the License, or     
 (at your option) any later version.                                   
*******************************************************************/
#include <iostream>
#include <vector>
#include <map>

#include <QApplication>
#include <QStyle>
#include <qdir.h>
#include <qfile.h>
#include <qsettings.h>
#include <qstringlist.h>
#include <qmessagebox.h>
#include <qpainter.h>
#include <qpixmap.h>
#include <qnamespace.h>
#include <qevent.h>
#include <qsize.h>
#include <qicon.h>
#include <QTreeWidgetItem>
#include <QModelIndex>
#include <QVariant>
#include <QRegExp>

#include "qgis.h"
#include "qgsapplication.h"
#include "qgslogger.h"

extern "C" {
#include <grass/gis.h>
#include <grass/Vect.h>
}

#include "../../src/providers/grass/qgsgrass.h"
#include "../../src/providers/grass/qgsgrassprovider.h"
#include "qgsgrassmodel.h"
#include "qgsgrassselect.h"

/* 
 * Internal data structure starts (at present) with LOCATION
 * as top level element, that is root but it does not appear 
 * in the tree view. First elements shown in the view are mapsets
 */

class QgsGrassModelItem
{
public:
  QgsGrassModelItem(QgsGrassModelItem *parent, int row, QString name,
    QString path, int type);
  QgsGrassModelItem();
  ~QgsGrassModelItem();

  // Copy mGisbase, mLocation, mMapset, mMap, mLayer
  void copyNames ( QgsGrassModelItem *item);

  void populate();
  bool populated() { return mPopulated; }

  int type() { return mType; }

  // Map URI
  QString uri();

  QgsGrassModelItem *child ( int i );
  QgsGrassModelItem *mParent;
  QVariant data (int role = Qt::DisplayRole);
  QString name();
  QString info();
  QString htmlTableRow ( QString s1, QString s2 );
  QString htmlTableRow ( QStringList  list );

  int mType;

  QString mGisbase;
  QString mLocation;
  QString mMapset;
  QString mMap;
  QString mLayer;

  QVector<QgsGrassModelItem*> mChildren;
  bool mPopulated;

  QgsGrassModel *mModel;
};

QgsGrassModelItem::QgsGrassModelItem()
    :mParent(0),mType(QgsGrassModel::None),mPopulated(false)
{
}

QgsGrassModelItem::~QgsGrassModelItem() 
{ 
  for (int i = 0; i < mChildren.size();i++) 
  {
    delete mChildren[i];
  }
  mChildren.clear(); 
}

void QgsGrassModelItem::copyNames ( QgsGrassModelItem *item  ) 
{ 
  mModel = item->mModel;
  mGisbase = item->mGisbase;
  mLocation = item->mLocation;
  mMapset = item->mMapset;
  mMap = item->mMap;
  mLayer = item->mLayer;
}

QVariant QgsGrassModelItem::data (int role) 
{ 
  if (role != Qt::DisplayRole) return QVariant();

  return name();
}

QString QgsGrassModelItem::info() 
{ 
  QString tblStart = "<table border=1 cellspacing=1 cellpadding=1>";
  switch ( mType ) 
  {
  case QgsGrassModel::Location:
    return QObject::tr("Location: ","Metadata in GRASS Browser") + mLocation; 
    break;
  case QgsGrassModel::Mapset:
    return QObject::tr("Location: ","Metadata in GRASS Browser") + mLocation + QObject::tr("<br>Mapset: ","Metadata in GRASS Browser") + mMapset; 
    break;
  case QgsGrassModel::Vectors:
  case QgsGrassModel::Rasters:
    return QObject::tr("Location: ") + mLocation + QObject::tr("<br>Mapset: ") + mMapset; 
    break;
  case QgsGrassModel::Raster:
    {
      QString str = tblStart;
      str += htmlTableRow(QObject::tr("<b>Raster</b>"), "<b>" + mMap + "</b>" );

      struct Cell_head head;
      int rasterType = -1;
      QgsGrass::setLocation( mGisbase, mLocation );

      if( G_get_cellhd( mMap.toLocal8Bit().data(), 
        mMapset.toLocal8Bit().data(), &head) != 0 ) 
      {
        str += "<tr><td colspan=2>" + QObject::tr("Cannot open raster header") + "</td></tr>";
      }
      else
      {
        str += htmlTableRow ( QObject::tr("Rows"), QString::number(head.rows));
        str += htmlTableRow ( QObject::tr("Columns"), QString::number(head.cols) );
        str += htmlTableRow ( QObject::tr("N-S resolution"), QString::number(head.ns_res) );
        str += htmlTableRow ( QObject::tr("E-W resolution"), QString::number(head.ew_res) );
        str += htmlTableRow ( QObject::tr("North"), QString::number(head.north) );
        str += htmlTableRow ( QObject::tr("South"), QString::number(head.south) );
        str += htmlTableRow ( QObject::tr("East"), QString::number(head.east) );
        str += htmlTableRow ( QObject::tr("West"), QString::number(head.west) );

        rasterType = G_raster_map_type( mMap.toLocal8Bit().data(),
          mMapset.toLocal8Bit().data() );

        QString format;
        if( rasterType == CELL_TYPE ) 
        {
          format = "integer (" + QString::number(head.format);
          format += head.format==0 ? " byte)" : "bytes)";
        }
        else if( rasterType == FCELL_TYPE ) 
        {
          format += "floating point (4 bytes)";
        }
        else if( rasterType == DCELL_TYPE )
        {
          format += "floating point (8 bytes)";
        }
        else
        {
          format += "unknown";
        }
        str += htmlTableRow ( QObject::tr("Format"), format );
      }

      // Range of values
      struct FPRange range;
      if ( G_read_fp_range( mMap.toLocal8Bit().data(),
        mMapset.toLocal8Bit().data(), &range ) != -1 )
      {
        double min, max;
        G_get_fp_range_min_max( &range, &min, &max );

        str += htmlTableRow ( QObject::tr("Minimum value"), QString::number(min));
        str += htmlTableRow ( QObject::tr("Maximum value"), QString::number(max));
      }

      // History
      struct History hist;
      if ( G_read_history( mMap.toLocal8Bit().data(),
        mMapset.toLocal8Bit().data(), &hist) >= 0 )
      {
        if ( QString(hist.datsrc_1).length() > 0 
          || QString(hist.datsrc_2).length() > 0 )
        {
          str += htmlTableRow ( QObject::tr("Data source"), QString(hist.datsrc_1) + " " 
            + QString(hist.datsrc_2) );
        }
        if ( QString(hist.keywrd).length() > 0 ) 
        { 
          str += htmlTableRow ( QObject::tr("Data description"), QString(hist.keywrd) );
        }
        if ( hist.edlinecnt > 0 ) 
        {
          QString h;
          for (int i = 0; i < hist.edlinecnt; i++)
          {
            h += QString(hist.edhist[i]) + "<br>";
          }
          str += htmlTableRow ( QObject::tr("Comments"), h);
        }
      }

      // Categories
      if ( rasterType == CELL_TYPE ) 
      {
        struct Categories Cats;
        int ret = G_read_cats( mMap.toLocal8Bit().data(),
          mMapset.toLocal8Bit().data(), &Cats);

        if ( ret == 0 )
        {
          if ( Cats.ncats > 0 )
          {
            str += "<tr><td colspan=2>" + QObject::tr("Categories") + "</td></tr>";
            for ( int i = 0; i < Cats.ncats; i++) 
            {
              str += htmlTableRow ( 
                QString::number((int)Cats.q.table[i].dLow),
                QString(Cats.labels[i]));
            }
          }
          G_free_cats(&Cats);
        }
      }
      str += "</table>";

      return str; 
    }
    break;

  case QgsGrassModel::Vector:
    {
      QString str = tblStart;
      str += htmlTableRow(QObject::tr("<b>Vector</b>"), "<b>" + mMap + "</b>" );

      QgsGrass::setLocation( mGisbase, mLocation );

      struct Map_info Map;
      int level = Vect_open_old_head ( &Map, mMap.toLocal8Bit().data(), 
        mMapset.toLocal8Bit().data());

      if ( level >= 2 ) 
      {
        int is3d = Vect_is_3d (&Map);

        // Number of elements
        str += htmlTableRow ( QObject::tr("Points"), QString::number(Vect_get_num_primitives(&Map, GV_POINT)) );
        str += htmlTableRow ( QObject::tr("Lines"), QString::number(Vect_get_num_primitives(&Map, GV_LINE)) );
        str += htmlTableRow ( QObject::tr("Boundaries"), QString::number(Vect_get_num_primitives(&Map, GV_BOUNDARY)) );
        str += htmlTableRow ( QObject::tr("Centroids"), QString::number(Vect_get_num_primitives(&Map, GV_CENTROID)) );
        if ( is3d ) 
        {
          str += htmlTableRow ( QObject::tr("Faces"), QString::number( Vect_get_num_primitives(&Map, GV_FACE) ) );
          str += htmlTableRow ( QObject::tr("Kernels"), QString::number( Vect_get_num_primitives(&Map, GV_KERNEL) ) );
        }

        str += htmlTableRow ( QObject::tr("Areas"), QString::number(Vect_get_num_areas(&Map)) );
        str += htmlTableRow ( QObject::tr("Islands"), QString::number( Vect_get_num_islands(&Map) ) );


        // Box and dimension
        BOUND_BOX box;
        char buffer[100];

        Vect_get_map_box (&Map, &box );

        QgsGrass::setMapset( mGisbase, mLocation, mMapset );
        struct Cell_head window;
        G_get_window (&window);
        int proj = window.proj;

        G_format_northing (box.N, buffer, proj);
        str += htmlTableRow ( QObject::tr("North"), QString(buffer) );
        G_format_northing (box.S, buffer, proj);
        str += htmlTableRow ( QObject::tr("South"), QString(buffer) );
        G_format_easting (box.E, buffer, proj );
        str += htmlTableRow ( QObject::tr("East"), QString(buffer) );
        G_format_easting (box.W, buffer, proj );
        str += htmlTableRow ( QObject::tr("West"), QString(buffer) );
        if ( is3d ) 
        {
          str += htmlTableRow ( QObject::tr("Top"), QString::number(box.T) );
          str += htmlTableRow ( QObject::tr("Bottom"), QString::number(box.B) );
        }

        str += htmlTableRow ( "3D", is3d ? QObject::tr("yes") : QObject::tr("no") );

        str += "</table>";

        // History
        Vect_hist_rewind ( &Map );
        char hbuffer[1001];
        str += "<p>"+ QObject::tr("History<br>");
        QRegExp rx ( "^-+$" );
        while ( Vect_hist_read ( hbuffer, 1000, &Map ) != NULL ) {
          QString row = QString(hbuffer);
          if ( rx.search ( row ) != -1 ) 
          { 
            str += "<hr>";
          }
          else
          {
            str += row + "<br>";
          }
        }
      }
      else 
      {
        str += "</table>";
      }

      Vect_close (&Map);
      return str;
    }
    break;

  case QgsGrassModel::VectorLayer:
    {
      QString str = tblStart;
      str += htmlTableRow(QObject::tr("<b>Vector</b>"), "<b>" + mMap + "</b>" );
      str += htmlTableRow(QObject::tr("<b>Layer</b>"), "<b>" + mLayer + "</b>" );

      QgsGrass::setLocation( mGisbase, mLocation );

      struct Map_info Map;
      int level = Vect_open_old_head ( &Map, mMap.toLocal8Bit().data(), 
        mMapset.toLocal8Bit().data());

      if ( level >= 2 ) 
      {
        struct field_info *fi;

        int field = QgsGrassProvider::grassLayer(mLayer);
        if ( field != -1 ) 
        {
          // Number of features
          int type = QgsGrassProvider::grassLayerType(mLayer);
          if (type != -1 )
          {
            str += htmlTableRow( QObject::tr("Features"), 
              QString::number(Vect_cidx_get_type_count(&Map, field, type)) );
          }

          fi = Vect_get_field ( &Map, field);

          // Database link
          if ( fi ) 
          {
            str += htmlTableRow(QObject::tr("Driver"), QString(fi->driver) );
            str += htmlTableRow(QObject::tr("Database"), QString(fi->database) );
            str += htmlTableRow(QObject::tr("Table"), QString(fi->table) );
            str += htmlTableRow(QObject::tr("Key column"), QString(fi->key) );
          }
        }
      }            
      str += "</table>";

      Vect_close (&Map);
      return str;
    }
    break;
  }
  return QString();
}

QString QgsGrassModelItem::htmlTableRow ( QString s1, QString s2 )
{ 
  QStringList sl (s1);
  sl.append (s2);
  return htmlTableRow (sl);
}

QString QgsGrassModelItem::htmlTableRow ( QStringList list )
{ 
  QString s = "<tr>";
  for ( int i = 0; i < list.size(); i++ )
  {
    s.append ( "<td>" + list.at(i) + "</td>" );
  }
  s.append ( "</tr>" );
  return s;
}

QString QgsGrassModelItem::name() 
{ 
  switch ( mType ) 
  {
  case QgsGrassModel::Location:
    return mLocation; 
    break;
  case QgsGrassModel::Mapset:
    return mMapset;
    break;
  case QgsGrassModel::Vectors:
    return "vector";
    break;
  case QgsGrassModel::Rasters:
    return "raster";
    break;
  case QgsGrassModel::Regions:
    return "region";
    break;
  case QgsGrassModel::Vector:
  case QgsGrassModel::Raster:
  case QgsGrassModel::Region:
    return mMap;
    break;
  case QgsGrassModel::VectorLayer:
    return mLayer; 
    break;
  }
  return QString();
}

QString QgsGrassModelItem::uri () 
{ 
  switch ( mType ) 
  {
  case QgsGrassModel::VectorLayer:
    return mGisbase + "/" + mLocation + "/" + mMapset + "/" 
      + mMap + "/" + mLayer;
    break;
  case QgsGrassModel::Raster:
    return mGisbase + "/" + mLocation + "/" + mMapset + "/cellhd/" + mMap;
    break;
  }
  return QString();
}

QgsGrassModelItem *QgsGrassModelItem::child ( int i ) 
{
  Q_ASSERT(i >= 0 );
  Q_ASSERT(i < mChildren.size());
  //return &(mChildren[i]);
  return mChildren[i];
}

void QgsGrassModelItem::populate()
{
  QgsDebugMsg("called.");

  if ( mPopulated ) return;

  mModel->refreshItem(this);
}

/*********************** MODEL ***********************/