qgswfsprovider.cpp

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

  for(std::vector<std::list<QgsPoint> >::const_iterator it = ringCoordinates.begin(); it != ringCoordinates.end(); ++it)
    {
      nPointsInRing = it->size(); 
      memcpy(&(*wkb)[wkbPosition], &nPointsInRing, sizeof(int));
      wkbPosition += sizeof(int);
      //iterate through the string list converting the strings to x-/y- doubles
      std::list<QgsPoint>::const_iterator iter;
      for(iter = it->begin(); iter != it->end(); ++iter)
	{
	  x = iter->x();
	  y = iter->y();
	  //qWarning("currentCoordinate: " + QString::number(x) + " // " + QString::number(y));
	  memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));
	  wkbPosition += sizeof(double);
	  memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));
	  wkbPosition += sizeof(double);
	}
    }
  return 0;
}

int QgsWFSProvider::getWkbFromGML2LineString(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const
{
  QDomNodeList coordinatesList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "coordinates");
  if(coordinatesList.size() < 1)
    {
      return 1;
    }
  QDomElement coordinatesElement = coordinatesList.at(0).toElement();
  std::list<QgsPoint> lineCoordinates;
  if(readGML2Coordinates(lineCoordinates, coordinatesElement) != 0)
    {
      return 2;
    }

  char e = QgsApplication::endian();
  int size = 1 + 2 * sizeof(int) + lineCoordinates.size() * 2* sizeof(double);
  *wkb = new unsigned char[size];
  *wkbSize = size;
  *type = QGis::WKBLineString;
  int wkbPosition = 0; //current offset from wkb beginning (in bytes)
  double x, y;
  int nPoints = lineCoordinates.size();
  
  //fill the contents into *wkb
  memcpy(&(*wkb)[wkbPosition], &e, 1);
  wkbPosition += 1;
  memcpy(&(*wkb)[wkbPosition], type, sizeof(int));
  wkbPosition += sizeof(int);
  memcpy(&(*wkb)[wkbPosition], &nPoints, sizeof(int));
  wkbPosition += sizeof(int);
  
  std::list<QgsPoint>::const_iterator iter;
  for(iter = lineCoordinates.begin(); iter != lineCoordinates.end(); ++iter)
    {
      x = iter->x();
      y = iter->y();
      memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));
      wkbPosition += sizeof(double);
      memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));
      wkbPosition += sizeof(double);
    }
  return 0;
}

int QgsWFSProvider::getWkbFromGML2MultiPoint(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const
{
  std::list<QgsPoint> pointList;
  std::list<QgsPoint> currentPoint;
  QDomNodeList pointMemberList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "pointMember");
  if(pointMemberList.size() < 1)
    {
      return 1;
    }
  QDomNodeList pointNodeList;
  QDomNodeList coordinatesList;
  for(int i = 0; i < pointMemberList.size(); ++i)
    {
      //<Point> element
      pointNodeList = pointMemberList.at(i).toElement().elementsByTagNameNS(GML_NAMESPACE, "Point");
      if(pointNodeList.size() < 1)
	{
	  continue;
	}
      //<coordinates> element
      coordinatesList = pointNodeList.at(0).toElement().elementsByTagNameNS(GML_NAMESPACE, "coordinates");
      if(coordinatesList.size() < 1)
	{
	  continue;
	}
      currentPoint.clear();
      if(readGML2Coordinates(currentPoint, coordinatesList.at(0).toElement()) != 0)
	{
	  continue;
	}
      if(currentPoint.size() < 1)
	{
	  continue;
	}
      pointList.push_back((*currentPoint.begin()));
    }

  //calculate the required wkb size
  int size = 1 + 2 * sizeof(int) + pointList.size() * (2 * sizeof(double) + 1 + sizeof(int));
  *wkb = new unsigned char[size];
  *wkbSize = size;
  *type = QGis::WKBMultiPoint;

  //fill the wkb content
  char e = QgsApplication::endian();
  int wkbPosition = 0; //current offset from wkb beginning (in bytes)
  int nPoints = pointList.size(); //number of points
  double x, y;
  memcpy(&(*wkb)[wkbPosition], &e, 1);
  wkbPosition += 1;
  memcpy(&(*wkb)[wkbPosition], type, sizeof(int));
  wkbPosition += sizeof(int);
  memcpy(&(*wkb)[wkbPosition], &nPoints, sizeof(int));
  wkbPosition += sizeof(int);
  for(std::list<QgsPoint>::const_iterator it = pointList.begin(); it != pointList.end(); ++it)
    {
      memcpy(&(*wkb)[wkbPosition], &e, 1);
      wkbPosition += 1;
      memcpy(&(*wkb)[wkbPosition], type, sizeof(int));
      wkbPosition += sizeof(int);
      x = it->x();
      memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));
      wkbPosition += sizeof(double);
      y = it->y();
      memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));
      wkbPosition += sizeof(double);
    }
  return 0;
}

int QgsWFSProvider::getWkbFromGML2MultiLineString(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const
{
  //geoserver has
  //<gml:MultiLineString>
  //<gml:lineStringMember>
  //<gml:LineString>
  
  //mapserver has directly
  //<gml:MultiLineString
  //<gml:LineString

  std::list<std::list<QgsPoint> > lineCoordinates; //first list: lines, second list: points of one line
  QDomElement currentLineStringElement;
  QDomNodeList currentCoordList;

  QDomNodeList lineStringMemberList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "lineStringMember");
  if(lineStringMemberList.size() > 0) //geoserver
    {
      for(int i = 0; i < lineStringMemberList.size(); ++i)
	{
	  QDomNodeList lineStringNodeList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "LineString");
	  if(lineStringNodeList.size() < 1)
	    {
	      return 1;
	    }
	  currentLineStringElement = lineStringNodeList.at(0).toElement();
	  currentCoordList = currentLineStringElement.elementsByTagNameNS(GML_NAMESPACE, "coordinates");
	  if(currentCoordList.size() < 1)
	    {
	      return 2;
	    }
	  std::list<QgsPoint> currentPointList;
	  if(readGML2Coordinates(currentPointList, currentCoordList.at(0).toElement()) != 0)
	    {
	      return 3;
	    }
	  lineCoordinates.push_back(currentPointList);
	}
    }
  else
    {
      QDomNodeList lineStringList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "LineString");
      if(lineStringList.size() > 0) //mapserver
	{
	  for(int i = 0; i < lineStringList.size(); ++i)
	    {
	      currentLineStringElement = lineStringList.at(i).toElement();
	      currentCoordList = currentLineStringElement.elementsByTagNameNS(GML_NAMESPACE, "coordinates");
	      if(currentCoordList.size() < 1)
		{
		  return 4;
		}
	      std::list<QgsPoint> currentPointList;
	      if(readGML2Coordinates(currentPointList, currentCoordList.at(0).toElement()) != 0)
		{
		  return 5;
		}
	      lineCoordinates.push_back(currentPointList);
	    }
	}
      else
	{
	  return 6;
	}
    }


  //calculate the required wkb size
  int size = (lineCoordinates.size() + 1) * (1 + 2 * sizeof(int));
  for(std::list<std::list<QgsPoint> >::const_iterator it = lineCoordinates.begin(); it != lineCoordinates.end(); ++it)
    {
      size += it->size() * 2 * sizeof(double);
    }
  *wkb = new unsigned char[size];
  *wkbSize = size;
  *type = QGis::WKBMultiLineString;
  
  //fill the wkb content
  char e = QgsApplication::endian();
  int wkbPosition = 0; //current offset from wkb beginning (in bytes)
  int nLines = lineCoordinates.size();
  int nPoints; //number of points in a line
  double x, y;
  memcpy(&(*wkb)[wkbPosition], &e, 1);
  wkbPosition += 1;
  memcpy(&(*wkb)[wkbPosition], type, sizeof(int));
  wkbPosition += sizeof(int);
  memcpy(&(*wkb)[wkbPosition], &nLines, sizeof(int));
  wkbPosition += sizeof(int);
  for(std::list<std::list<QgsPoint> >::const_iterator it = lineCoordinates.begin(); it != lineCoordinates.end(); ++it)
    {
      memcpy(&(*wkb)[wkbPosition], &e, 1);
      wkbPosition += 1;
      memcpy(&(*wkb)[wkbPosition], type, sizeof(int));
      wkbPosition += sizeof(int);
      nPoints = it->size();
      memcpy(&(*wkb)[wkbPosition], &nPoints, sizeof(int));
      wkbPosition += sizeof(int);
      for(std::list<QgsPoint>::const_iterator iter = it->begin(); iter != it->end(); ++iter)
	{
	  x = iter->x();
	  //qWarning("x is: " + QString::number(x));
	  y = iter->y();
	  //qWarning("y is: " + QString::number(y));
	  memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));
	  wkbPosition += sizeof(double);
	  memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));
	  wkbPosition += sizeof(double);
	}
    }
  return 0;  
}

int QgsWFSProvider::getWkbFromGML2MultiPolygon(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const
{
  //first list: different polygons, second list: different rings, third list: different points
  std::list<std::list<std::list<QgsPoint> > > multiPolygonPoints;
  QDomElement currentPolygonMemberElement;
  QDomNodeList polygonList;
  QDomElement currentPolygonElement;
  QDomNodeList outerBoundaryList;
  QDomElement currentOuterBoundaryElement;
  QDomElement currentInnerBoundaryElement;
  QDomNodeList innerBoundaryList;
  QDomNodeList linearRingNodeList;
  QDomElement currentLinearRingElement;
  QDomNodeList currentCoordinateList;

  QDomNodeList polygonMemberList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "polygonMember");
  for(int i = 0; i < polygonMemberList.size(); ++i)
    {
      std::list<std::list<QgsPoint> > currentPolygonList;
      currentPolygonMemberElement = polygonMemberList.at(i).toElement();
      polygonList = currentPolygonMemberElement.elementsByTagNameNS(GML_NAMESPACE, "Polygon");
      if(polygonList.size() < 1)
	{
	  continue;
	}
      currentPolygonElement = polygonList.at(0).toElement();
      
      //find exterior ring
      outerBoundaryList = currentPolygonElement.elementsByTagNameNS(GML_NAMESPACE, "outerBoundaryIs");
      if(outerBoundaryList.size() < 1)
	{
	  continue;
	}
      
      currentOuterBoundaryElement = outerBoundaryList.at(0).toElement();
      std::list<QgsPoint> ringCoordinates;
     
      linearRingNodeList = currentOuterBoundaryElement.elementsByTagNameNS(GML_NAMESPACE, "LinearRing");
      if(linearRingNodeList.size() < 1)
	{
	  continue;
	}
      currentLinearRingElement = linearRingNodeList.at(0).toElement();
      currentCoordinateList = currentLinearRingElement.elementsByTagNameNS(GML_NAMESPACE, "coordinates");
      if(currentCoordinateList.size() < 1)
	{
	  continue;
	}
      if(readGML2Coordinates(ringCoordinates, currentCoordinateList.at(0).toElement()) != 0)
	{
	  continue;
	}
      currentPolygonList.push_back(ringCoordinates);

      //find interior rings
      QDomNodeList innerBoundaryList = currentPolygonElement.elementsByTagNameNS(GML_NAMESPACE, "innerBoundaryIs");
      for(int j = 0; j < innerBoundaryList.size(); ++j)
	{
	  std::list<QgsPoint> ringCoordinates;
	  currentInnerBoundaryElement = innerBoundaryList.at(j).toElement();
	  linearRingNodeList = currentInnerBoundaryElement.elementsByTagNameNS(GML_NAMESPACE, "LinearRing");
	  if(linearRingNodeList.size() < 1)
	    {
	      continue;
	    }
	  currentLinearRingElement = linearRingNodeList.at(0).toElement(); 
	  currentCoordinateList = currentLinearRingElement.elementsByTagNameNS(GML_NAMESPACE, "coordinates");
	  if(currentCoordinateList.size() < 1)
	    {
	      continue;
	    }
	  if(readGML2Coordinates(ringCoordinates, currentCoordinateList.at(0).toElement()) != 0)
	    {
	      continue;
	    } 
	  currentPolygonList.push_back(ringCoordinates);
	}
      multiPolygonPoints.push_back(currentPolygonList);
    }
  
  int size = 1 + 2 * sizeof(int);
  //calculate the wkb size
  for(std::list<std::list<std::list<QgsPoint> > >::const_iterator it = multiPolygonPoints.begin(); it != multiPolygonPoints.end(); ++it)
    {
      size += 1 + 2 * sizeof(int);
      for(std::list<std::list<QgsPoint> >::const_iterator iter = it->begin(); iter != it->end(); ++iter)
	{
	  size += sizeof(int) + 2 * iter->size() * sizeof(double);
	}
    }
  *wkb = new unsigned char[size];
  *wkbSize = size;
  *type = QGis::WKBMultiPolygon;
  int polygonType = QGis::WKBPolygon;
  char e = QgsApplication::endian();
  int wkbPosition = 0; //current offset from wkb beginning (in bytes)
  double x, y;
  int nPolygons = multiPolygonPoints.size();
  int nRings;
  int nPointsInRing;
  
  //fill the contents into *wkb
  memcpy(&(*wkb)[wkbPosition], &e, 1);
  wkbPosition += 1;
  memcpy(&(*wkb)[wkbPosition], type, sizeof(int));
  wkbPosition += sizeof(int);
  memcpy(&(*wkb)[wkbPosition], &nPolygons, sizeof(int));
  wkbPosition += sizeof(int);
  
  for(std::list<std::list<std::list<QgsPoint> > >::const_iterator it = multiPolygonPoints.begin(); it != multiPolygonPoints.end(); ++it)
    {
      memcpy(&(*wkb)[wkbPosition], &e, 1);
      wkbPosition += 1;
      memcpy(&(*wkb)[wkbPosition], &polygonType, sizeof(int));
      wkbPosition += sizeof(int);
      nRings = it->size();
      memcpy(&(*wkb)[wkbPosition], &nRings, sizeof(int));
      wkbPosition += sizeof(int);
      for(std::list<std::list<QgsPoint> >::const_iterator iter = it->begin(); iter != it->end(); ++iter)
	{
	  nPointsInRing = iter->size();
	  memcpy(&(*wkb)[wkbPosition], &nPointsInRing, sizeof(int));
	  wkbPosition += sizeof(int);
	  for(std::list<QgsPoint>::const_iterator iterator = iter->begin(); iterator != iter->end(); ++iterator)
	    {
	      x = iterator->x();
	      y = iterator->y();
	      memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));
	      wkbPosition += sizeof(double);
	      memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));
	      wkbPosition += sizeof(double);
	    }
	}
    }
  return 0;
}

int QgsWFSProvider::readGML2Coordinates(std::list<QgsPoint>& coords, const QDomElement elem) const
{
  QString coordSeparator = ",";
  QString tupelSeparator = " ";
  //"decimal" has to be "."

  coords.clear();

  if(elem.hasAttribute("cs"))
    {
      coordSeparator = elem.attribute("cs");
    }
  if(elem.hasAttribute("ts"))
    {
      tupelSeparator = elem.attribute("ts");
    }

  QStringList tupels = elem.text().split(tupelSeparator, QString::SkipEmptyParts);
  QStringList tupel_coords;
  double x, y;
  bool conversionSuccess;

  QStringList::const_iterator it;
  for(it = tupels.constBegin(); it != tupels.constEnd(); ++it)
    {
      tupel_coords = (*it).split(coordSeparator, QString::SkipEmptyParts);
      if(tupel_coords.size() < 2)
	{
	  continue;
	}
      x = tupel_coords.at(0).toDouble(&conversionSuccess);
      if(!conversionSuccess)
	{
	  return 1;
	}
      y = tupel_coords.at(1).toDouble(&conversionSuccess);
      if(!conversionSuccess)
	{
	  return 1;
	}
      coords.push_back(QgsPoint(x, y));
    }
  return 0;
}

void QgsWFSProvider::handleWFSProgressMessage(int done, int total)
{
  QString totalString;
  if(total == 0)
    {
      totalString = tr("unknown");
    }
  else
    {
      totalString = QString::number(total);
    }
  QString message(tr("received %1 bytes from %2").arg(QString::number(done)).arg(totalString));
  emit dataReadProgressMessage(message);
}


QString QgsWFSProvider::name() const
{
  return TEXT_PROVIDER_KEY;
}

QString QgsWFSProvider::description() const
{
  return TEXT_PROVIDER_DESCRIPTION;
}


QGISEXTERN QgsWFSProvider* classFactory(const QString *uri)
{
  return new QgsWFSProvider(*uri);
}

QGISEXTERN QString providerKey()
{
    return TEXT_PROVIDER_KEY;
}

QGISEXTERN QString description()
{
    return TEXT_PROVIDER_DESCRIPTION;
}

QGISEXTERN bool isProvider()
{
  return true;
}