qgswfsdata.cpp

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

    }

  QgsWFSData::parseMode theParseMode = mParseModeStack.top();
  if(theParseMode == QgsWFSData::attribute || theParseMode == QgsWFSData::coordinate)
  {
    mStringCash.append(QString::fromUtf8(chars, len));
  } 
}


int QgsWFSData::readEpsgFromAttribute(int& epsgNr, const XML_Char** attr) const
{
  int i = 0;
  while(attr[i] != NULL)
    {
      if(strcmp(attr[i], "srsName") == 0)
	{
	  QString epsgString(attr[i+1]);
	  QString epsgNrString;
	  if(epsgString.startsWith("http")) //e.g. geoserver: "http://www.opengis.net/gml/srs/epsg.xml#4326"
	    {
	      epsgNrString = epsgString.section("#", 1, 1);
	    }
	  else //e.g. umn mapserver: "EPSG:4326">
	    {
	      epsgNrString = epsgString.section(":", 1, 1);
	    }
	  bool conversionOk;
	  int eNr = epsgNrString.toInt(&conversionOk);
	  if(!conversionOk)
	    {
	      return 1;
	    }
	  epsgNr = eNr;
	  return 0;
	}
      ++i;
    }
  return 2;
}

QString QgsWFSData::readCsFromAttribute(const XML_Char** attr) const
{
  int i = 0;
  while(attr[i] != NULL)
    {
      if(strcmp(attr[i], "cs") == 0)
	{
	  return QString(attr[i+1]);
	}
      ++i;
    }
  return ",";
}

QString QgsWFSData::readTsFromAttribute(const XML_Char** attr) const
{
  int i = 0;
  while(attr[i] != NULL)
    {
      if(strcmp(attr[i], "ts") == 0)
	{
	  return QString(attr[i+1]);
	}
      ++i;
    }
  return " ";
}

int QgsWFSData::createBBoxFromCoordinateString(QgsRect* bb, const QString& coordString) const
{
  if(!bb)
    {
      return 1;
    }

  std::list<QgsPoint> points;
  //qWarning("string is: ");
  //qWarning(coordString.toLocal8Bit().data());
  if(pointsFromCoordinateString(points, coordString, mCoordinateSeparator, mTupleSeparator) != 0)
    {
      return 2;
    }
  if(points.size() < 2)
    {
      return 3;
    }
  
  std::list<QgsPoint>::const_iterator firstPointIt = points.begin();
  std::list<QgsPoint>::const_iterator secondPointIt = points.begin();
  ++secondPointIt;
  bb->set(*firstPointIt, *secondPointIt);
  return 0;
}

int QgsWFSData::pointsFromCoordinateString(std::list<QgsPoint>& points, const QString& coordString, const QString& cs, const QString& ts) const
{
  //tuples are separated by space, x/y by ','
  QStringList tuples = coordString.split(ts, QString::SkipEmptyParts);
  QStringList tuples_coordinates;
  double x, y;
  bool conversionSuccess;

  QStringList::const_iterator tupleIterator;
  for(tupleIterator = tuples.constBegin(); tupleIterator != tuples.constEnd(); ++tupleIterator)
    {
      tuples_coordinates = tupleIterator->split(cs, QString::SkipEmptyParts);
      if(tuples_coordinates.size() < 2)
	{
	  continue;
	}
      x = tuples_coordinates.at(0).toDouble(&conversionSuccess);
      if(!conversionSuccess)
	{
	  continue;
	}
      y = tuples_coordinates.at(1).toDouble(&conversionSuccess);
      if(!conversionSuccess)
	{
	  continue;
	}
      points.push_back(QgsPoint(x, y));
    }
  return 0;
}

int QgsWFSData::getPointWKB(unsigned char** wkb, int* size, const QgsPoint& point) const
{
  int wkbSize = 1 + sizeof(int) + 2 * sizeof(double);
  *size = wkbSize;
  *wkb = new unsigned char[wkbSize];
  QGis::WKBTYPE type = QGis::WKBPoint;
  double x = point.x();
  double y = point.y();
  int wkbPosition = 0; //current offset from wkb beginning (in bytes)

  memcpy(&(*wkb)[wkbPosition], &mEndian, 1);
  wkbPosition += 1;
  memcpy(&(*wkb)[wkbPosition], &type, sizeof(int));
  wkbPosition += sizeof(int);
  memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));
  wkbPosition += sizeof(double);
  memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));
  return 0;
}

int QgsWFSData::getLineWKB(unsigned char** wkb, int* size, const std::list<QgsPoint>& lineCoordinates) const
{
  int wkbSize = 1 + 2 * sizeof(int) + lineCoordinates.size() * 2* sizeof(double);
  *size = wkbSize;
  *wkb = new unsigned char[wkbSize];
  QGis::WKBTYPE 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], &mEndian, 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 QgsWFSData::getRingWKB(unsigned char** wkb, int* size, const std::list<QgsPoint>& ringCoordinates) const
{
  int wkbSize = sizeof(int) + ringCoordinates.size() * 2* sizeof(double);
  *size = wkbSize;
  *wkb = new unsigned char[wkbSize];
  int wkbPosition = 0; //current offset from wkb beginning (in bytes)
  double x, y;
  int nPoints = ringCoordinates.size();
  memcpy(&(*wkb)[wkbPosition], &nPoints, sizeof(int));
  wkbPosition += sizeof(int);

  std::list<QgsPoint>::const_iterator iter;
  for(iter = ringCoordinates.begin(); iter != ringCoordinates.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 QgsWFSData::createMultiLineFromFragments()
{
  mCurrentWKBSize = 0;
  mCurrentWKBSize += 1 + 2*sizeof(int);
  mCurrentWKBSize += totalWKBFragmentSize();
  
  mCurrentWKB = new unsigned char[mCurrentWKBSize];
  int pos = 0;
  QGis::WKBTYPE type = QGis::WKBMultiLineString;
  int numLines = mCurrentWKBFragments.begin()->size();
  //add endian
  memcpy(&(mCurrentWKB[pos]), &mEndian, 1);
  pos += 1;
  memcpy(&(mCurrentWKB[pos]), &type, sizeof(int));
  pos += sizeof(int);
  memcpy(&(mCurrentWKB[pos]), &numLines, sizeof(int));
  pos += sizeof(int);
  std::list<unsigned char*>::iterator wkbIt = mCurrentWKBFragments.begin()->begin();
  std::list<int>::iterator sizeIt = mCurrentWKBFragmentSizes.begin()->begin();
  
  //copy (and delete) all the wkb fragments
  for(; wkbIt != mCurrentWKBFragments.begin()->end(); ++wkbIt, ++sizeIt)
    {
      memcpy(&(mCurrentWKB[pos]), *wkbIt, *sizeIt);
      pos += *sizeIt;
      delete[] *wkbIt;
    }
  
  mCurrentWKBFragments.clear();
  mCurrentWKBFragmentSizes.clear();
  *mWkbType = QGis::WKBMultiLineString;
  return 0;
}

int QgsWFSData::createMultiPointFromFragments()
{
  mCurrentWKBSize = 0;
  mCurrentWKBSize += 1 + 2*sizeof(int);
  mCurrentWKBSize += totalWKBFragmentSize();
  
  int pos = 0;
  QGis::WKBTYPE type = QGis::WKBMultiPoint;
  int numPoints = mCurrentWKBFragments.begin()->size();
  
  memcpy(&(mCurrentWKB[pos]), &mEndian, 1);
  pos += 1;
  memcpy(&(mCurrentWKB[pos]), &type, sizeof(int));
  pos += sizeof(int);
  memcpy(&(mCurrentWKB[pos]), &numPoints, sizeof(int));
  pos += sizeof(int);

  std::list<unsigned char*>::iterator wkbIt = mCurrentWKBFragments.begin()->begin();
  std::list<int>::iterator sizeIt = mCurrentWKBFragmentSizes.begin()->begin();
  
  for(; wkbIt != mCurrentWKBFragments.begin()->end(); ++wkbIt, ++sizeIt)
    {
      memcpy(&(mCurrentWKB[pos]), *wkbIt, *sizeIt);
      pos += *sizeIt;
      delete[] *wkbIt;
    }

  mCurrentWKBFragments.clear();
  mCurrentWKBFragmentSizes.clear();
  *mWkbType = QGis::WKBMultiPoint;
  return 0;
}


int QgsWFSData::createPolygonFromFragments()
{
  mCurrentWKBSize = 0;
  mCurrentWKBSize += 1 + 2*sizeof(int);
  mCurrentWKBSize += totalWKBFragmentSize();

  mCurrentWKB = new unsigned char[mCurrentWKBSize];
  int pos = 0;
  QGis::WKBTYPE type = QGis::WKBPolygon;
  int numRings = mCurrentWKBFragments.begin()->size();
  memcpy(&(mCurrentWKB[pos]), &mEndian, 1);
  pos += 1;
  memcpy(&(mCurrentWKB[pos]), &type, sizeof(int));
  pos += sizeof(int);
  memcpy(&(mCurrentWKB[pos]), &numRings, sizeof(int));
  pos += sizeof(int);

  std::list<unsigned char*>::iterator wkbIt = mCurrentWKBFragments.begin()->begin();
  std::list<int>::iterator sizeIt = mCurrentWKBFragmentSizes.begin()->begin();
  for(;wkbIt != mCurrentWKBFragments.begin()->end(); ++wkbIt, ++sizeIt)
    {
      memcpy(&(mCurrentWKB[pos]), *wkbIt, *sizeIt);
      pos += *sizeIt;
      delete[] *wkbIt;
    }

  mCurrentWKBFragments.clear();
  mCurrentWKBFragmentSizes.clear();
  *mWkbType = QGis::WKBPolygon;
  return 0;
} 

int QgsWFSData::createMultiPolygonFromFragments()
{
  mCurrentWKBSize = 0;
  mCurrentWKBSize += 1 + 2*sizeof(int);
  mCurrentWKBSize += totalWKBFragmentSize();
  mCurrentWKBSize += mCurrentWKBFragments.size() * (1 + 2 * sizeof(int)); //fragments are just the rings
  
  mCurrentWKB = new unsigned char[mCurrentWKBSize];
  int pos = 0;
  QGis::WKBTYPE type = QGis::WKBMultiPolygon;
  QGis::WKBTYPE polygonType = QGis::WKBPolygon;
  int numPolys = mCurrentWKBFragments.size();
  int numRings;
  memcpy(&(mCurrentWKB[pos]), &mEndian, 1);
  pos += 1;
  memcpy(&(mCurrentWKB[pos]), &type, sizeof(int));
  pos += sizeof(int);
  memcpy(&(mCurrentWKB[pos]), &numPolys, sizeof(int));
  pos += sizeof(int);

  //have outer and inner iterators
  std::list<std::list<unsigned char*> >::iterator outerWkbIt;
  std::list<std::list<int> >::iterator outerSizeIt;
  std::list<unsigned char*>::iterator innerWkbIt;
  std::list<int>::iterator innerSizeIt;

  outerWkbIt = mCurrentWKBFragments.begin();
  outerSizeIt = mCurrentWKBFragmentSizes.begin();

  for(; outerWkbIt != mCurrentWKBFragments.end(); ++outerWkbIt, ++outerSizeIt)
    {
      //new polygon
      memcpy(&(mCurrentWKB[pos]), &mEndian, 1);
      pos += 1;
      memcpy(&(mCurrentWKB[pos]), &polygonType, sizeof(int));
      pos += sizeof(int);
      numRings = outerWkbIt->size();
      memcpy(&(mCurrentWKB[pos]), &numRings, sizeof(int));
      pos += sizeof(int);

      innerWkbIt = outerWkbIt->begin();
      innerSizeIt = outerSizeIt->begin();
      for(; innerWkbIt != outerWkbIt->end(); ++innerWkbIt, ++innerSizeIt)
	{
	  memcpy(&(mCurrentWKB[pos]), *innerWkbIt, *innerSizeIt);
	  pos += *innerSizeIt;
	  delete[] *innerWkbIt;
	}
    }

  mCurrentWKBFragments.clear();
  mCurrentWKBFragmentSizes.clear();
  *mWkbType = QGis::WKBMultiPolygon;
  return 0;
}

int QgsWFSData::totalWKBFragmentSize() const
{
  int result=0;
  for(std::list<std::list<int> >::const_iterator it = mCurrentWKBFragmentSizes.begin(); it != mCurrentWKBFragmentSizes.end(); ++it)
    {
      for(std::list<int>::const_iterator iter = it->begin(); iter != it->end(); ++iter)
	{
	  result += *iter;
	}
    }
  return result;
}