qgsgrassmapcalc.cpp

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

    struct Cell_head window;

    QStringList mm = obj->value().split("@");
    if ( mm.size() < 1 ) continue;

    QString map = mm.at(0);
    QString mapset = QgsGrass::getDefaultMapset();
    if  ( mm.size() > 1 ) mapset = mm.at(1);

    if ( !QgsGrass::mapRegion ( QgsGrass::Raster,
      QgsGrass::getDefaultGisdbase(),
      QgsGrass::getDefaultLocation(), mapset, map,
      &window ) )
    {
      QMessageBox::warning( 0, tr("Warning"), tr("Cannot check region "
        "of map ") + obj->value() );
      continue;
    }

    if ( G_window_overlap ( &currentWindow ,
      window.north, window.south, window.east, window.west) == 0 )
    {
      list.append ( obj->value() );
    }
  }
  return list;
}

bool QgsGrassMapcalc::inputRegion ( struct Cell_head *window, bool all )
{
#ifdef QGISDEBUG
  std::cerr << "gsGrassMapcalc::inputRegion" << std::endl;
#endif

  if  ( !QgsGrass::region ( QgsGrass::getDefaultGisdbase(),
    QgsGrass::getDefaultLocation(),
    QgsGrass::getDefaultMapset(), window ) )
  {
    QMessageBox::warning( 0, tr("Warning"), tr("Cannot get current region" ));
    return false;
  }

  Q3CanvasItemList l = mCanvas->allItems();

  int count = 0;
  for ( Q3CanvasItemList::Iterator it=l.fromLast(); it!=l.end(); --it) 
  {
    if (! (*it)->isActive() ) continue;

    if ( typeid (**it) != typeid (QgsGrassMapcalcObject) ) continue;

    QgsGrassMapcalcObject *obj = 
      dynamic_cast <QgsGrassMapcalcObject *> (*it);

    if ( obj->type() != QgsGrassMapcalcObject::Map ) continue;

    struct Cell_head mapWindow;

    QStringList mm = obj->value().split("@");
    if ( mm.size() < 1 ) continue;

    QString map = mm.at(0);
    QString mapset = QgsGrass::getDefaultMapset();
    if  ( mm.size() > 1 ) mapset = mm.at(1);

    if ( !QgsGrass::mapRegion ( QgsGrass::Raster,
      QgsGrass::getDefaultGisdbase(),
      QgsGrass::getDefaultLocation(), mapset, map,
      &mapWindow ) )
    {
      QMessageBox::warning( 0, tr("Warning"), tr("Cannot get region "
        "of map ") + obj->value() );
      return false;
    }

    // TODO: best way to set resolution ?
    if ( count == 0)
    {
      QgsGrass::copyRegionExtent ( &mapWindow, window );
      QgsGrass::copyRegionResolution ( &mapWindow, window );
    }
    else
    {
      QgsGrass::extendRegion ( &mapWindow, window );
    }
    count++;
  }

  return true;
}

QStringList QgsGrassMapcalc::output ( int type )
{
#ifdef QGISDEBUG
  std::cerr << "gsGrassMapcalc::output" << std::endl;
#endif
  QStringList list;
  if ( type == QgsGrassModuleOption::Raster ) 
  {
    list.append ( mOutputLineEdit->text() );
  }
  return list;
}

QgsGrassMapcalc::~QgsGrassMapcalc()
{
}

void QgsGrassMapcalc::showOptions( int tool )
{
  std::cerr << "QgsGrassMapcalc::showOptions() tool = " << tool << std::endl;

  // Hide widgets
  mMapComboBox->hide();
  mConstantLineEdit->hide();
  mFunctionComboBox->hide();

  switch ( tool )
  {
  case AddMap:
    mMapComboBox->show();
    break;

  case AddConstant:
    mConstantLineEdit->show();
    break;

  case AddFunction:
    mFunctionComboBox->show();
    break;
  }
}

void QgsGrassMapcalc::setOption()
{
  std::cerr << "QgsGrassMapcalc::setOption()" << std::endl;

  if ( mTool != Select ) return;
  if ( !mObject ) return;

  switch ( mObject->type() )
  {
  case QgsGrassMapcalcObject::Map :
    {
      bool found = false;
      for ( unsigned int i = 0 ; i < mMaps.size(); i++ ) 
      { 
        if ( mMapComboBox->text(i) == mObject->label()
          && mMaps[i] == mObject->value() )
        {
          mMapComboBox->setCurrentItem ( i ) ;
          found = true;
        }
      }
      if ( !found ) 
      {
        mMaps.push_back ( mObject->value() );
        mMapComboBox->insertItem ( mObject->label() );
        mMapComboBox->setCurrentItem ( mMapComboBox->count()-1 );
      }
      break;
    }

  case QgsGrassMapcalcObject::Constant :
    mConstantLineEdit->setText ( mObject->value() ); 
    break;

  case QgsGrassMapcalcObject::Function :
    for ( unsigned int i = 0; i < mFunctions.size(); i++ ) 
    {
      if ( mFunctions[i].name() != mObject->function().name() ) continue;
      if ( mFunctions[i].inputCount() != mObject->function().inputCount() ) continue;

      mFunctionComboBox->setCurrentItem ( i );
      break;
    }
    // TODO: if not found

    break;
  }

}

void QgsGrassMapcalc::setTool( int tool )
{
  // Clear old
  if ( mTool == Select ) 
  {
    if ( mObject ) mObject->setSelected ( false );
    if ( mConnector ) mConnector->setSelected ( false );
  }
  else 
  {
    if ( mObject ) delete mObject;
    if ( mConnector ) delete mConnector;
    mCanvas->update();
  }
  mObject = 0;
  mConnector = 0;

  mTool = tool;
  mToolStep = 0;

  mView->viewport()->setMouseTracking ( false );

  switch ( mTool )
  {
  case AddMap:
    mObject = new QgsGrassMapcalcObject(QgsGrassMapcalcObject::Map);
    mObject->setId ( nextId() );

    // TODO check if there are maps
    mObject->setValue ( mMaps[mMapComboBox->currentItem()],
      mMapComboBox->currentText() );

    mObject->setCanvas(mCanvas);
    mObject->Q3CanvasRectangle::show();
    mActionAddMap->setOn(true);
    mView->viewport()->setMouseTracking ( true );
    mView->setCursor ( QCursor(Qt::SizeAllCursor) ); 
    break;

  case AddConstant:
    mObject = new QgsGrassMapcalcObject(QgsGrassMapcalcObject::Constant);
    mObject->setId ( nextId() );
    mObject->setValue ( mConstantLineEdit->text() );
    mObject->setCanvas(mCanvas);
    mObject->Q3CanvasRectangle::show();
    mActionAddConstant->setOn(true);
    mView->viewport()->setMouseTracking ( true );
    mView->setCursor ( QCursor(Qt::SizeAllCursor) ); 
    break;

  case AddFunction:
    mObject = new QgsGrassMapcalcObject(QgsGrassMapcalcObject::Function);
    mObject->setId ( nextId() );
    //mObject->setValue ( mFunctionComboBox->currentText() );
    mObject->setFunction ( mFunctions[ mFunctionComboBox->currentItem() ] );
    mObject->setCanvas(mCanvas);
    mObject->Q3CanvasRectangle::show();
    mActionAddFunction->setOn(true);
    mView->viewport()->setMouseTracking ( true );
    mView->setCursor ( QCursor(Qt::SizeAllCursor) ); 
    break;

  case AddConnector:
    mConnector = new QgsGrassMapcalcConnector ( mCanvas );
    mConnector->setId ( nextId() );
    mConnector->setCanvas(mCanvas);
    mConnector->Q3CanvasLine::show();
    mActionAddConnection->setOn(true);
    mView->setCursor ( QCursor(Qt::CrossCursor) ); 
    break;
  }

  showOptions(mTool);
  setToolActionsOff(); 
  mActionDeleteItem->setEnabled( false );
  mCanvas->update();
}

void QgsGrassMapcalc::addMap()
{
  updateMaps();
  if ( mMaps.size() == 0 )
  {
    QMessageBox::warning( 0, tr("Warning"), tr("No GRASS raster maps"
      " currently in QGIS" ));

    setTool ( AddConstant);
    return;
  }

  setTool(AddMap);
}

void QgsGrassMapcalc::addConstant()
{
  setTool(AddConstant);
}

void QgsGrassMapcalc::addFunction()
{
  setTool(AddFunction);
}

void QgsGrassMapcalc::addConnection()
{
  setTool(AddConnector);
}

void QgsGrassMapcalc::selectItem()
{
  setTool(Select);
  mActionSelectItem->setOn(true);
  mView->setCursor ( QCursor(Qt::ArrowCursor) ); 
}

void QgsGrassMapcalc::deleteItem()
{
  if ( mConnector )
  {
    delete mConnector;
    mConnector = 0;
  }
  if ( mObject && mObject->type() != QgsGrassMapcalcObject::Output )
  {
    delete mObject;
    mObject = 0;
  }
  mActionDeleteItem->setEnabled(false);
  mCanvas->update();
}

void QgsGrassMapcalc::keyPressEvent ( QKeyEvent * e )
{
  if ( e->key() == Qt::Key_Delete ) 
  {
    deleteItem();
  }
}

void QgsGrassMapcalc::setToolActionsOff()
{
  mActionAddMap->setOn(false);
  mActionAddConstant->setOn(false);
  mActionAddFunction->setOn(false);
  mActionAddConnection->setOn(false);
  mActionSelectItem->setOn(false);
  mActionDeleteItem->setOn(false);
}

void QgsGrassMapcalc::updateMaps()
{
  // TODO: this copy and paste from QgsGrassModuleInput, do it better
#ifdef QGISDEBUG
  std::cerr << "QgsGrassMapcalc::updateMaps" << std::endl;
#endif
  QString current = mMapComboBox->currentText ();
  mMapComboBox->clear();
  mMaps.resize(0);

  QgsMapCanvas *canvas = mIface->getMapCanvas();

  int nlayers = canvas->layerCount();
  std::cerr << "nlayers = " << nlayers << std::endl;
  for ( int i = 0; i < nlayers; i++ ) {
    QgsMapLayer *layer = canvas->getZpos(i);

    if ( layer->type() != QgsMapLayer::RASTER ) continue;

    // Check if it is GRASS raster
    QString source = QDir::cleanDirPath ( layer->source() ); 

    // Note: QDir::cleanPath is using '/' also on Windows
    //QChar sep = QDir::separator();
    QChar sep = '/';

    if ( source.contains( "cellhd" ) == 0 ) continue;

    // Most probably GRASS layer, check GISBASE and LOCATION
    QStringList split = QStringList::split ( sep, source );

    if ( split.size() < 4 ) continue;

    QString map = split.last();
    split.pop_back(); // map
    if ( split.last() != "cellhd" ) continue;
    split.pop_back(); // cellhd

    QString mapset = split.last();
    split.pop_back(); // mapset

    //QDir locDir ( sep + split.join ( QString(sep) ) ) ;
    //QString loc = locDir.canonicalPath();

    QString loc =  source.remove ( QRegExp("/[^/]+/[^/]+/[^/]+$") );
    loc = QDir(loc).canonicalPath();

    QDir curlocDir ( QgsGrass::getDefaultGisdbase() + sep + QgsGrass::getDefaultLocation() );
    QString curloc = curlocDir.canonicalPath();

    if ( loc != curloc ) continue;

    //if ( mUpdate && mapset != QgsGrass::getDefaultMapset() ) continue;

    mMapComboBox->insertItem( layer->name() );
    if ( layer->name() == current ) mMapComboBox->setCurrentText ( current );
    mMaps.push_back ( map + "@" + mapset );
  }
}

void QgsGrassMapcalc::mapChanged()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassMapcalc::mapChanged" << std::endl;
#endif

  if ( (mTool != AddMap && mTool != Select)  || !mObject ) return;
  if ( mObject->type() != QgsGrassMapcalcObject::Map ) return;

  mObject->setValue ( mMaps[mMapComboBox->currentItem()],
    mMapComboBox->currentText() );
  mObject->resetSize();
  mCanvas->update();
}

void QgsGrassMapcalc::constantChanged()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassMapcalc::constantChanged" << std::endl;
#endif

  if ( (mTool != AddConstant && mTool != Select) || !mObject ) return;
  if ( mObject->type() != QgsGrassMapcalcObject::Constant ) return;

  mObject->setValue ( mConstantLineEdit->text() );
  mObject->resetSize();
  mCanvas->update();
}

void QgsGrassMapcalc::functionChanged()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassMapcalc::functionChanged" << std::endl;
#endif

  if ( (mTool != AddFunction && mTool != Select) || !mObject ) return;
  if ( mObject->type() != QgsGrassMapcalcObject::Function ) return;

  mObject->setFunction ( mFunctions[ mFunctionComboBox->currentItem() ] );
  mObject->resetSize();
  mCanvas->update();
}

void QgsGrassMapcalc::limit( QPoint *point)
{
  if ( point->x() < 0 ) point->setX(0);
  if ( point->y() < 0 ) point->setY(0);
  if ( point->x() > mCanvas->width() ) point->setX(mCanvas->width());
  if ( point->y() > mCanvas->height() ) point->setY(mCanvas->height());
}

void QgsGrassMapcalc::resizeCanvas( int width, int height )
{
  mCanvas->resize ( width, height );
  mPaper->setSize ( width, height );
  mCanvas->update();
}

void QgsGrassMapcalc::growCanvas(int left, int right, int top, int bottom)
{
  std::cerr << "QgsGrassMapcalc::growCanvas()" << std::endl;
  std::cerr << "left = " << left << " right = " << right
    << " top = " << top << " bottom = " << bottom << std::endl;

  int width = mCanvas->width() + left + right;
  int height = mCanvas->height() + top + bottom;
  resizeCanvas( width, height );

  Q3CanvasItemList l = mCanvas->allItems();

  for ( Q3CanvasItemList::Iterator it=l.fromLast(); it!=l.end(); --it) 
  {
    if (! (*it)->isActive() ) continue;

    if ( typeid (**it) == typeid (QgsGrassMapcalcObject) )
    {
      QgsGrassMapcalcObject *obj = 
        dynamic_cast <QgsGrassMapcalcObject *> (*it);

      QPoint p = obj->center();
      obj->setCenter ( p.x()+left, p.y()+top );
    } 
    else if ( typeid (**it) == typeid (QgsGrassMapcalcConnector) )
    {
      QgsGrassMapcalcConnector *con = 
        dynamic_cast <QgsGrassMapcalcConnector *> (*it);

      for ( int i = 0; i < 2; i++ )
      {
        QPoint p = con->point(i);
        p.setX ( p.x()+left );
        p.setY ( p.y()+top );
        con->setPoint ( i,  p );
      }
    }
  }

  mCanvas->update();
}

void QgsGrassMapcalc::autoGrow()
{
  std::cerr << "QgsGrassMapcalc::autoGrow()" << std::endl;

  int thresh = 15;

  int left = 0;
  int right = mCanvas->width();
  int top = 0;
  int bottom = mCanvas->height();
  std::cerr << "left = " << left << " right = " << right
    << " top = " << top << " bottom = " << bottom << std::endl;

  Q3CanvasItemList l = mCanvas->allItems();

  for ( Q3CanvasItemList::Iterator it=l.fromLast(); it!=l.end(); --it) 
  {
    if (! (*it)->isActive() ) continue;

    // Exclude current
    if ( (mTool != Select) && (*it == mObject || *it == mConnector) ) 
      continue;

    QRect r = (*it)->boundingRect(); 

    std::cerr << "r.left = " << r.left() << " r.right = " << r.right()
      << " r.top = " << r.top() << " bottom = " << r.bottom () << std::endl;

    if ( r.left() - thresh < left )     left   = r.left() - thresh;
    if ( r.right() + thresh > right )   right  = r.right() + thresh;
    if ( r.top() - thresh < top )       top    = r.top() - thresh;
    if ( r.bottom() + thresh > bottom ) bottom = r.bottom() + thresh;

    std::cerr << "left = " << left << " right = " << right
      << " top = " << top << " bottom = " << bottom << std::endl;
  }
  left = -left;
  right = right - mCanvas->width();
  top = -top;
  bottom = bottom - mCanvas->height();

  growCanvas ( left, right, top, bottom );
}

void QgsGrassMapcalc::saveAs()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassMapcalc::saveAs()" << std::endl;
#endif

  // Check/create 'mapcalc' directory in current mapset
  QString ms = QgsGrass::getDefaultGisdbase() + "/" 
    + QgsGrass::getDefaultLocation() + "/"