QGIS » QGIS Application

    lblPreview->setText( tr( "Expression is valid" ) );

static const QString OGC_NAMESPACE = "http://www.opengis.net/ogc";

  // get filter capability

  QDomNodeList fcap = capabilitiesDocument.elementsByTagNameNS( OGC_NAMESPACE, "Filter_Capabilities" );

  mCaps.canFilter = ( fcap.size() && fcap.at( 0 ).hasChildNodes() );

      void clear() { featureTypes.clear(); canFilter = false; }

      bool canFilter;  //provider advertises <Filter> capability

    mFeatureCount( /*0 [wbc 111225 incremental get*/ mFeatures.count() )

int QgsWFSData::getWFSData( const QSet<QString>* wfsFids )

  QgsDebugMsg( QString( "begin fetch: %1 cached features; %2 discard candidates" )

                        .arg( mFeatureCount ).arg( wfsFids ? wfsFids->size() : 0 ) );

  mWfsFids = wfsFids;

  QgsDebugMsg( QString( "end fetch: %1 features in cache" )

                        .arg( mFeatureCount ) );

  { //ignore duplicate features (e.g., protrude beyond previous extent)

    //[wbc111228 issue 4280: fetch un-cached features on demand]

    if ( mWfsFids && ! mCurrentFeatureId.isEmpty() && mWfsFids->contains( mCurrentFeatureId ) )

    {

      QgsDebugMsg( QString( "WFS FID %1 already fetched QGIS id %2" )

                            .arg( mCurrentFeatureId )

                            .arg( mIdMap.key ( mCurrentFeatureId ) ) );

    }

    else

      //MH090531: Check if all feature attributes are initialised, sometimes attribute values are missing.

      //We fill the not initialized ones with empty strings, otherwise the feature cannot be exported to shp later

      QgsAttributeMap currentFeatureAttributes = mCurrentFeature->attributeMap();

      QMap<QString, QPair<int, QgsField> >::const_iterator att_it = mThematicAttributes.constBegin();

      for ( ; att_it != mThematicAttributes.constEnd(); ++att_it )

        int attIndex = att_it.value().first;

        QgsAttributeMap::const_iterator findIt = currentFeatureAttributes.find( attIndex );

        if ( findIt == currentFeatureAttributes.constEnd() )

        {

          mCurrentFeature->addAttribute( attIndex, QVariant( "" ) );

        }

      mCurrentFeature->setGeometryAndOwnership( mCurrentWKB, mCurrentWKBSize );

      mFeatures.insert( mCurrentFeature->id(), mCurrentFeature );

      if ( !mCurrentFeatureId.isEmpty() )

      {

        mIdMap.insert( mCurrentFeature->id(), mCurrentFeatureId );

      }

      ++mFeatureCount;

    int getWFSData( const QSet<QString>* wfsFids = (QSet<QString>*) 0 );

    /**incremental get: optional list of FIDs to be ignored in WFS input stream*/

    const QSet<QString>* mWfsFids;

    mGeometryAttribute( 0 ),

    mInitUri(),

    mGetExtent(),

    mWfsFids( 0 ),

    mFilterCaps( 0 )

  //Local url or HTTP?  refactored from getFeature()

  //[wbc111228 issue 4280: fetch un-cached features on demand]

  //create mSourceCRS from url if possible; refactored from GetFeatureGET()

  //extracting geometry type before getFeature usually allows successful

  QString describeFeatureUri = uri;

  describeFeatureUri.replace( QString( "GetFeature" ), QString( "DescribeFeatureType" ) );

  if ( describeFeatureType( describeFeatureUri, mGeometryAttribute, mFields, mWKBType ) )

    QMessageBox::critical ( 0, tr( "DescribeFeatureType failed!" ),

                 tr( "Layer cannot be created from\n%1" ).arg( uri ) );

    mValid = false;

  //fetch features now or on first render?

  if ( mEncoding == QgsWFSProvider::FILE || ! uri.contains("BBOX") || mWKBType == QGis::WKBUnknown )

  { //now if (1) local URL, (2) "Cache All Features" option, or (3) WFS describeFeatureType does

    //not disclose a specific geometry type (e.g., TinyOWS reports "GeometryPropertyType")

    //retrieve all features in layer immediately

  } //otherwise: defer feature fetch until layer is first rendered

  else

  {

    mSpatialIndex = new QgsSpatialIndex();

  }

  //if we still do not know geometry type, user needs to change source select parameters

  if ( mWKBType == QGis::WKBUnknown )

  {

    QgsDebugMsg( QString( "Cannot obtain geometry type, URI=%1" ).arg( uri ) );

    QMessageBox::critical ( 0, tr( "Cannot obtain geometry type!" ),

                 tr( "This layer contains no geometry features in the current map canvas extent. "

                 "Reposition the map or check \"Cache All Features\" in the layer selection dialog." ) );

    mValid = false;

  }

  //[end mods for issue 4280]

  if ( mValid )

  { //record fetched extent per stand-alone BBOX (if any) in getFeature URI

    mGetExtent = getUriBBox();

  }

  else

  { //getFeature failed; clear getFeature fetch extent

    mGetExtent = QgsRectangle();

  }

  mFeatureCount = 0;

  mIdMap.clear();

  //first time through, initialize GetRenderedOnly logic

  //(layer object not available during ctor initialization)

  //[wbc111228 issue 4604: fetch rendered features only]

  //[issue 4280: fetch un-cached features on demand]

  if ( mEncoding == QgsWFSProvider::GET && mInitUri.isEmpty() )

  { //did user check "Cache All Features" in WFS layer source selection?

    if ( dataSourceUri().contains( "BBOX" ) )

    { //no: initialize incremental getFeature

      mGetRenderedOnly = initGetRenderedOnly( rect );

    }

    //getRenderedOnly manipulates dataSourceUri; save original URI

    mInitUri = dataSourceUri();

  }

  { //select all previously-retrieved features

  { //select features intersecting caller's extent (e.g., map canvas extent)

    { //"Cache All Features" was not selected for this layer; fetch features to be rendered

      //[issues 4604 + 4280]

      incrementalGet( rect );

                                         QgsFieldMap& fields, QGis::WkbType& geomType )

  //Local url or HTTP?

  if ( dataReader.getWFSData( mWfsFids ) != 0 )

  for ( QMap<QgsFeatureId, QgsFeature*>::iterator it = mFeatures.find( mFeatureCount ); it != mFeatures.end(); ++it )

    //QgsDebugMsg( "feature " + FID_TO_STRING(( *it )->id() ) );

  QNetworkRequest request( uri );

int QgsWFSProvider::describeFeatureTypeFile( const QString& uri, QString& geometryAttribute, QgsFieldMap& fields, QGis::WkbType& geomType)

  QgsDebugMsg( schemaDoc.toString() );

  //look for filter capabilities used by incremental get

  QDomElement e = capabilitiesDocument.elementsByTagNameNS( "http://www.opengis.net/ogc", "Filter_Capabilities" ).item(0).toElement();

  if ( ! e.tagName().isEmpty() )

    {

    mFilterCaps |= Filter;

    QDomNodeList o = e.elementsByTagNameNS( "http://www.opengis.net/ogc", "Logical_Operators" );

    if ( o.size() )

    {

      mFilterCaps |= LogicOps;

    }

    o = e.elementsByTagNameNS( "http://www.opengis.net/ogc", "BBOX" );

    if ( o.size() )

    {

      mFilterCaps |= BBox;

    }

  }

//[wbc111228 issue 4604: fetch rendered features only]

//[issue 4280: fetch un-cached features on demand]

  Q_UNUSED( rect );

    if ( ( mLayer = dynamic_cast<QgsVectorLayer*>( layersIt.value() ) ) )

    QgsDebugMsg( QString( "SHOULD NOT OCCUR: initialize() did not find layer for %1." )

                 .arg( dataSourceUri() ) );

    QMessageBox::critical ( 0, tr( "Non-Cached layer initialization failed!" ),

                 tr( "Incorrect operation may occur:\n%1" ).arg( dataSourceUri() ) );

  const QStringList geomTypes = ( QStringList ()

    //all GML v.2.1.3 _geometryProperty group members, except MultiGeometryPropertyType

    //sequence must exactly match enum Qgis::WkbType

    << ""  // unknown geometry, enum 0

    << "Point"

    << "LineString"

    << "Polygon"

    << "MultiPoint"

    << "MultiLineString"

    << "MultiPolygon" );

                       .arg( attName, propType ) );

    i = (int) QGis::WKBUnknown;

  }

  return (QGis::WkbType) i;

}

//if not caching whole layer, add features to the cache incrementally

//as pans and zooms expose new areas on the map canvas

//[wbc111228 issue 4280: fetch un-cached features on demand]

void QgsWFSProvider::incrementalGet( QgsRectangle rect )

{

 QgsDebugMsg( QString( "\nprevious get extent %1\n      select extent %2" ).arg( mGetExtent.toString(), rect.toString() ) );

 //has rendered extent expanded beyond last-retrieved WFS extent?

  //NB: compare overlap area instead of using "contains" function

  //    avoids double fetch due to rounding error on zoom-in/zoom-out sequences

  QgsRectangle olap( rect );

  olap = olap.intersect( &mGetExtent );

  //is there any overlap between current layer extent and new canvas?

  //and can WFS provider do ORed BBOX filters?

  if ( olap.isEmpty() || ( ( mFilterCaps & ( Filter | LogicOps | BBox ) ) !=  ( Filter | LogicOps | BBox ) ) )

  { //no, discard feature cache and do fresh fetch for new extent

    QgsDebugMsg( QString( "Layer %1 GetRenderedOnly: fetch replace" ).arg( mLayer->name() ) );

    //does original URI contain a user-specified filter?

    if ( mInitUri.contains( "&FILTER=" ) )

    { //yes, but FILTER & BBOX are mutually exclusive in WSF getFeature URL; merge BBOX into FILTER

      setDataSourceUri( makeFilteredUri( QList<QgsRectangle>() << rect ) );

    }

    else

    { //URI contains no FILTER; continue with stand-alone BBOX

      setDataSourceUri( setUriBBox( rect ) );

    }

    reloadData();

    if ( mValid )

    { //reloadData() cannot set mGetExtent for URI with filter

      mGetExtent = rect;

    }

  }

  else if ( ( ( rect.width() - olap.width() ) < 1e-6 )

            && ( ( rect.height() - olap.height() ) < 1e-6 ) )

  { //difference between canvas and layer extents is less than URL BBOX precision (6 decimal places)

    QgsDebugMsg( QString( "Layer %1 GetRenderedOnly: no fetch required" ).arg( mLayer->name() ) );

    return;

  else

  { //new canvas extent overlaps old extent: add features in new areas to existing layer

    //compute minimum expansion: at least 1/3 of desired extent in each direction that expands

    QgsRectangle newGetExt( mGetExtent );

    newGetExt.combineExtentWith( &rect );

    double minDeltaX = ( rect.xMaximum() - rect.xMinimum() ) / 3.;

    double minDeltaY = ( rect.yMaximum() - rect.yMinimum() ) / 3.;

    if ( rect.xMinimum() < mGetExtent.xMinimum() && rect.xMinimum() > ( mGetExtent.xMinimum() - minDeltaX) )

    {

      newGetExt.setXMinimum ( mGetExtent.xMinimum() - minDeltaX );

    }

    if ( rect.yMinimum() < mGetExtent.yMinimum() &&  rect.yMinimum() > ( mGetExtent.yMinimum() - minDeltaY) )

    {

      newGetExt.setYMinimum ( mGetExtent.yMinimum() - minDeltaY );

    }

    if ( rect.xMaximum() > mGetExtent.xMaximum() && rect.xMaximum() < ( mGetExtent.xMaximum() + minDeltaX) )

    {

      newGetExt.setXMaximum ( mGetExtent.xMaximum() + minDeltaX );

    }

    if ( rect.yMaximum() > mGetExtent.yMaximum() && rect.yMaximum() < ( mGetExtent.yMaximum() + minDeltaY) )

    {

      newGetExt.setYMaximum ( mGetExtent.yMaximum() + minDeltaY );

    }

    //calculate between 1 and 4 rectangles to be fetched around perimeter of existing layer extent

    QList<QgsRectangle> addArea;

    if ( newGetExt.xMinimum() < mGetExtent.xMinimum() )

    { //new area left of current extent

      addArea.append( QgsRectangle( newGetExt.xMinimum(), mGetExtent.yMinimum(), mGetExtent.xMinimum(), mGetExtent.yMaximum() ) );

    }

    if ( newGetExt.yMaximum() > mGetExtent.yMaximum() )

    { //new area above current extent

      addArea.append( QgsRectangle( newGetExt.xMinimum(), mGetExtent.yMaximum(), mGetExtent.xMaximum(), newGetExt.yMaximum() ) );

    }

    if ( newGetExt.xMaximum() > mGetExtent.xMaximum() )

    { //new area right of current extent

      addArea.append( QgsRectangle( mGetExtent.xMaximum(), mGetExtent.yMinimum(), newGetExt.xMaximum(), newGetExt.yMaximum() ) );

    }

    if ( newGetExt.yMinimum() < mGetExtent.yMinimum() )

    { //new area beneath current extent

      addArea.append( QgsRectangle( newGetExt.xMinimum(), newGetExt.yMinimum(), newGetExt.xMaximum(), mGetExtent.yMinimum() ) );

    }

    QgsDebugMsg( QString( "Layer %1 GetRenderedOnly: incremental fetch, %2 areas" ).arg( mLayer->name() ).arg( addArea.size() ) );

    //commented logic below allows duplicate FIDS to pass because some WFS

    //providers transmit features that do not strictly intersect the BBOX

    /*get WFS provider IDs of already-fetched features

    QList<QgsFeatureId> edgeFids;

    mWfsFids = new QSet<QString>;

    for ( int i = 0; i < addArea.size() ; ++i )

    { //identify features extending into each new area

      edgeFids.append( mSpatialIndex->intersects( addArea[i] ) );

    }

    while ( ! edgeFids.isEmpty() )

    { //collect known WFS provider FIDs of identified

      mWfsFids->insert( mIdMap.value( edgeFids.takeFirst() ) );

    }

    QgsDebugMsg( QString( "WFS FIDs to discard next fetch: %1" ).arg( mWfsFids->size() ) );*/

    //because of problem above, every known WFS FID is a discard candidate

    mWfsFids = new QSet<QString>( mIdMap.values().toSet() );

    //save current provider extent (getFeature calls to data reader overwrite mExtent)

    QgsRectangle saveMExtent( mExtent );

    //fetch features in new areas, discarding features already fetched

    setDataSourceUri ( makeFilteredUri( addArea ) );

    if ( getFeature( dataSourceUri() ) ) //QgsWFSData::endElement discards IDs in mWfsFids

    { //getFeature failed (timeout, abort); we no longer know the extent actually fetched

      mValid = false;               //layer is now invalid

      mGetExtent = QgsRectangle();  //getFeature extent is now unknown

    }

    else

    {

      mExtent.combineExtentWith ( &saveMExtent ); //sum of extents just received & previously cached

      mGetExtent = newGetExt;

    }

    delete mWfsFids;

    mWfsFids = 0;

    //save URI for possible later user refresh()

    setDataSourceUri ( setUriBBox ( rect ) );

  }

  QgsDebugMsg( QString( "features=%1; WSF FIDs=%2; unique WSF FIDs=%3" )

                        .arg( mFeatures.size() ).arg( mIdMap.size() )

                        .arg( mIdMap.values().toSet().size() ) );

}

//transform provider URI to express getFeatures BBOX as FILTER

QString QgsWFSProvider::makeFilteredUri( QList<QgsRectangle> addArea )

{

  //start with initial URI

  QString uri = mInitUri;

  //if the user specified a filter, get it

  QDomElement root;

  QDomNode n;

  QDomDocument filter = QDomDocument();

  QRegExp fre( "&FILTER=(.*)" );  // assumes &FILTER is last argument on URL

  //does the URI already contain a valid XML filter expression?

  if ( uri.contains( fre ) && filter.setContent( fre.cap(1) ) )

  { //yes, create insertion point to AND a BBOX filter

    root = filter.firstChild().toElement(); // <Filter> element

    QDomNode userFilter = root.removeChild( root.firstChild() );

    n = root.appendChild( filter.createElement( "And" ) );

    n.appendChild( userFilter );

    QgsDebugMsg( QString( "filter=%1" ).arg( filter.toString() ) );

  }

  else

  { //no, create new OGC XML Filter

    QDomElement root =  filter.createElement( "Filter" );

    n = filter.appendChild( root );

  }

  //define namespace for "Box" and "coordinates"

  root.setAttribute( "xmlns:gml", "http://www.opengis.net/gml" );

  //OR a new BBOX clause (ver. 1.0.0) for each new area

  if ( addArea.size() > 1 )

  {

    n = n.appendChild( filter.createElement( "Or" ) );

  }

  while ( ! addArea.isEmpty() )

  {

    QDomNode b = n.appendChild( filter.createElement( "BBOX" ) );

    QDomElement p = filter.createElement("PropertyName" );

    p.appendChild( filter.createTextNode( mGeometryAttribute ) );

    b.appendChild( p );

    //filter XML v. 1.0.0 -- accepted but ignored on some arcgis systems [wbc121130]

    QDomElement v = filter.createElement( "gml:Box" );

    v.setAttribute( "srsName", mSourceCRS.authid() );

    QDomNode e = b.appendChild( v );

    QDomNode c = e.appendChild( filter.createElement( "gml:coordinates" ) );

    QgsRectangle delta = addArea.takeFirst();

    c.appendChild( filter.createTextNode( QString( "%1,%2 %3,%4" )

                  .arg( delta.xMinimum(), 0, 'f').arg(delta.yMinimum(), 0, 'f')

                  .arg( delta.xMaximum(), 0, 'f').arg(delta.yMaximum(), 0, 'f') ) );

  }

  QgsDebugMsg( QString( "filter=%1" ).arg( filter.toString() ) );

  //get features contained in each new area

  uri.replace( QRegExp( "BBOX=.*" ), QString( "FILTER=%1" ).arg( filter.toString( -1 ) ) );

  return uri;

QString QgsWFSProvider::setUriBBox( QgsRectangle rect )

{

  QgsDebugMsg( QString( "layer %1 GetRenderedOnly: fetching extent %2" )

              .arg( mLayer->name(), rect.asWktCoordinates() ) );

  QString dsURI = mInitUri;

  dsURI = dsURI.replace( QRegExp( "BBOX=[^&]*" ),

                          QString( "BBOX=%1,%2,%3,%4" )

                          .arg( rect.xMinimum(), 0, 'f' )

                          .arg( rect.yMinimum(), 0, 'f' )

                          .arg( rect.xMaximum(), 0, 'f' )

                          .arg( rect.yMaximum(), 0, 'f' ) );

  return dsURI;

}

QgsRectangle QgsWFSProvider::getUriBBox()

{

  bool ok = true;

  QRegExp uriBBox( "&BBOX=(([-+.0-9]+,?){4})" );

  if ( dataSourceUri().contains( uriBBox ) )

  {

    QList<QString> coords = uriBBox.cap(1).split( "," );

    QList<double> coordd;

    while ( ok && ! coords.isEmpty() )

    {

      coordd.append( coords.takeFirst().toDouble( &ok ) );

    }

    if ( ok )

    {

      return QgsRectangle( coordd[0], coordd[1], coordd[2], coordd[3] );

    }

  }

  return QgsRectangle();

}

//[end issue 4280]

}

    /**WFS Filter capabilities of interest to data provider*/

    enum FilterCap

    {

      /** no filter capabilities advertised */

      NoFilter =          0,

      /** ogc:Filter_Capabilities advertised */

      Filter =            1,

      /** ogc:Logical_Operators advertised */

      LogicOps =     1 << 1,

      /** ogc:BBOX advertised */

      BBox =         1 << 2,

    };

    /**GetRenderedOnly option flag [wbc111228 issue 4604: fetch rendered features only]*/

    /**GetRenderedOnly initial URI*/

    QString mInitUri;

    /**incremental get: known FIDs [wbc111228 issue 4280: fetch un-cached features on demand]*/

    QSet<QString> *mWfsFids;

    /**WFS filter capabilities of interest to data provider*/

    int mFilterCaps;

    /**Initialize getRenderedOnly option*/

    /**Convert DescribeFeatureType schema geometry property type to WKBType*/

    /**Fetch features from WSF provider for canvas areas to be rendered*/

    void incrementalGet( QgsRectangle rect );

    /**convert URI BBOX into filter expression*/

    QString makeFilteredUri( QList<QgsRectangle> addArea );

    /**Update BBOX parameter in GetFeature URI*/

    QString setUriBBox ( QgsRectangle rect );

    /**Extract BBOX from dataSourceUri()*/

    QgsRectangle getUriBBox ();

  connect( treeWidget, SIGNAL( itemSelectionChanged() ), this, SLOT( setApplyButton() ) );

  treeWidget->resizeColumnToContents( 0 );

  treeWidget->sortItems( 0, Qt::AscendingOrder );

    if ( caps.featureTypes.count() == 1 )

    { //if only one item, select it; otherwise, user must select all desired items

      treeWidget->setCurrentItem( treeWidget->topLevelItem( 0 ) );

    }

    if ( ! caps.canFilter )

    { //if WFS provider does not advertise filter capability, delete "Filter" column

      treeWidget->setColumnCount(4);

    }

  }

}

//enable Apply button when one or more layers are selected

void QgsWFSSourceSelect::setApplyButton()

{

  if ( treeWidget->selectedItems().size() )

  {

    btnAdd->setEnabled( true );

  }

  else

  {

  //prepare canvas extent info [wbc111228 issue 4604: fetch rendered features only]

        QgsDebugMsg( QString("canvas transform: Canvas CRS=%1, Provider CRS=%2, BBOX=%3")

                             .arg(cCrs.authid(), pCrs.authid(), extent.asWktCoordinates() ) );

    //is "cache all features" checked?

    if ( ( *sIt )->checkState( 3 ) == Qt::Checked )

    void setApplyButton();

    <width>600</width>

    <height>450</height>

     <property name="baseSize">

      <size>

       <width>0</width>

       <height>0</height>

      </size>

     </property>

     <property name="textElideMode">

      <enum>Qt::ElideRight</enum>

     </property>

     <attribute name="headerCascadingSectionResizes">

      <bool>true</bool>

     </attribute>

     <attribute name="headerDefaultSectionSize">

      <number>80</number>

     </attribute>

     <attribute name="headerHighlightSections">

      <bool>true</bool>

     </attribute>

      <number>60</number>

     </attribute>

     <attribute name="headerStretchLastSection">

      <bool>true</bool>

     </attribute>

     <attribute name="headerCascadingSectionResizes">

      <bool>true</bool>

     </attribute>

     <attribute name="headerDefaultSectionSize">

      <number>80</number>

      <number>60</number>

     </attribute>

     <attribute name="headerHighlightSections">

      <bool>true</bool>

     </attribute>

     <attribute name="headerStretchLastSection">

      <bool>true</bool>

       <string>Cache All

      <property name="toolTip">

       <string extracomment="Retrieve all features from WFS repository when layer is created."/>

      </property>

      <property name="statusTip">

       <string extracomment="Caution: &lt;b&gt;slow&lt;/b&gt; layer creation from large remote WFS providers!"/>

      </property>

       <set>AlignLeft|AlignVCenter</set>

       <string>Filter (double click to enter)</string>