gpsdata.cpp

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

/***************************************************************************
      gpsdata.cpp  -  Data structures for GPS data
                             -------------------
    begin                : 2004-04-14
    copyright            : (C) 2004 by Lars Luthman
    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 <limits>
#include <stdexcept>
#include <cstring>

#include <QFile>
#include <QTextStream>
#include <QObject>
#include <QSet>

#include "gpsdata.h"
#include <qgslogger.h>

#define OUTPUT_PRECISION 12

QString GPSObject::xmlify(const QString& str) {
  QString tmp = str;
  tmp.replace("&", "&amp;");
  tmp.replace("<", "&lt;");
  tmp.replace(">", "&gt;");
  tmp.replace("\"", "&quot;");
  tmp.replace("\'", "&apos;");
  return tmp;
}


void GPSObject::writeXML(QTextStream& stream) {
  if (!name.isEmpty())
    stream<<"<name>"<<xmlify(name)<<"</name>\n";
  if (!cmt.isEmpty())
    stream<<"<cmt>"<<xmlify(cmt)<<"</cmt>\n";
  if (!desc.isEmpty())
    stream<<"<desc>"<<xmlify(desc)<<"</desc>\n";
  if (!src.isEmpty())
    stream<<"<src>"<<xmlify(src)<<"</src>\n";
  if (!url.isEmpty())
    stream<<"<url>"<<xmlify(url)<<"</url>\n";
  if (!urlname.isEmpty())
    stream<<"<urlname>"<<xmlify(urlname)<<"</urlname>\n";
}


GPSPoint::GPSPoint() {
  ele = -std::numeric_limits<double>::max();
}


void GPSPoint::writeXML(QTextStream& stream) {
  GPSObject::writeXML(stream);
  if (ele != -std::numeric_limits<double>::max())
    stream<<"<ele>"<<ele<<"</ele>\n";
  if (!sym.isEmpty())
    stream<<"<sym>"<<xmlify(sym)<<"</sym>\n";
}


GPSExtended::GPSExtended()
  : xMin(std::numeric_limits<double>::max()),
    xMax(-std::numeric_limits<double>::max()),
    yMin(std::numeric_limits<double>::max()),
    yMax(-std::numeric_limits<double>::max()),
    number(std::numeric_limits<int>::max()) {
  
}


void GPSExtended::writeXML(QTextStream& stream) {
  GPSObject::writeXML(stream);
  if (number != std::numeric_limits<int>::max())
    stream<<"<number>"<<number<<"</number>\n";
}


void Waypoint::writeXML(QTextStream& stream) {
  stream << "<wpt lat=\"" << QString::number(lat, 'f', OUTPUT_PRECISION) <<
    "\" lon=\"" << QString::number(lon, 'f', OUTPUT_PRECISION) << "\">\n";
  GPSPoint::writeXML(stream);
  stream<<"</wpt>\n";
}


void Route::writeXML(QTextStream& stream) {
  stream<<"<rte>\n";
  GPSExtended::writeXML(stream);
  for (unsigned int i = 0; i < points.size(); ++i) {
    stream<<"<rtept lat=\""<< QString::number(points[i].lat, 'f', OUTPUT_PRECISION)
	  <<"\" lon=\"" << QString::number(points[i].lon, 'f', OUTPUT_PRECISION) <<"\">\n";
    points[i].writeXML(stream);
    stream<<"</rtept>\n";
  }
  stream<<"</rte>\n";
}


void Track::writeXML(QTextStream& stream) {
  stream<<"<trk>\n";
  GPSExtended::writeXML(stream);
  for (unsigned int i = 0; i < segments.size(); ++i) {
    stream<<"<trkseg>\n";
    for (unsigned int j = 0; j < segments[i].points.size(); ++j) {
      stream<<"<trkpt lat=\"" <<
        QString::number(segments[i].points[j].lat, 'f', OUTPUT_PRECISION) <<
        "\" lon=\""<< QString::number(segments[i].points[j].lon, 'f', OUTPUT_PRECISION) <<
        "\">\n";
      segments[i].points[j].writeXML(stream);
      stream<<"</trkpt>\n";
    }
    stream<<"</trkseg>\n";
  }
  stream<<"</trk>\n";
}


GPSData::GPSData() {
  xMin = std::numeric_limits<double>::max();
  xMax = -std::numeric_limits<double>::max();
  yMin = std::numeric_limits<double>::max();
  yMax = -std::numeric_limits<double>::max();
  nextWaypoint = 0;
  nextRoute = 0;
  nextTrack = 0;
}


QgsRect GPSData::getExtent() const {
  return QgsRect(xMin, yMin, xMax, yMax);
}

void GPSData::setNoDataExtent() {
  if (getNumberOfWaypoints() + getNumberOfRoutes() + getNumberOfTracks() == 0)
  {
    xMin = -1.0;
    xMax =  1.0;
    yMin = -1.0;
    yMax =  1.0;
  }
}

int GPSData::getNumberOfWaypoints() const {
  return waypoints.size();
}


int GPSData::getNumberOfRoutes() const {
  return routes.size();
}


int GPSData::getNumberOfTracks() const {
  return tracks.size();
}


GPSData::WaypointIterator GPSData::waypointsBegin() {
  return waypoints.begin();
}


GPSData::RouteIterator GPSData::routesBegin() {
  return routes.begin();
}


GPSData::TrackIterator GPSData::tracksBegin() {
  return tracks.begin();
}


GPSData::WaypointIterator GPSData::waypointsEnd() {
  return waypoints.end();
}


GPSData::RouteIterator GPSData::routesEnd() {
  return routes.end();
}


GPSData::TrackIterator GPSData::tracksEnd() {
  return tracks.end();
}


GPSData::WaypointIterator GPSData::addWaypoint(double lat, double lon, 
                 QString name, double ele) {
  Waypoint wpt;
  wpt.lat = lat;
  wpt.lon = lon;
  wpt.name = name;
  wpt.ele = ele;
  return addWaypoint(wpt);
}


GPSData::WaypointIterator GPSData::addWaypoint(const Waypoint& wpt) {
  xMax = xMax > wpt.lon ? xMax : wpt.lon;
  xMin = xMin < wpt.lon ? xMin : wpt.lon;
  yMax = yMax > wpt.lat ? yMax : wpt.lat;
  yMin = yMin < wpt.lat ? yMin : wpt.lat;
  WaypointIterator iter = waypoints.insert(waypoints.end(), wpt);
  iter->id = nextWaypoint++;
  return iter;
}


GPSData::RouteIterator GPSData::addRoute(QString name) {
  Route rte;
  rte.name = name;
  return addRoute(rte);
}


GPSData::RouteIterator GPSData::addRoute(const Route& rte) {
  xMax = xMax > rte.xMax ? xMax : rte.xMax;
  xMin = xMin < rte.xMin ? xMin : rte.xMin;
  yMax = yMax > rte.yMax ? yMax : rte.yMax;
  yMin = yMin < rte.yMin ? yMin : rte.yMin;
  RouteIterator iter = routes.insert(routes.end(), rte);
  iter->id = nextRoute++;
  return iter;
}


GPSData::TrackIterator GPSData::addTrack(QString name) {
  Track trk;
  trk.name = name;
  return addTrack(trk);
}
  

GPSData::TrackIterator GPSData::addTrack(const Track& trk) {
  xMax = xMax > trk.xMax ? xMax : trk.xMax;
  xMin = xMin < trk.xMin ? xMin : trk.xMin;
  yMax = yMax > trk.yMax ? yMax : trk.yMax;
  yMin = yMin < trk.yMin ? yMin : trk.yMin;
  TrackIterator iter = tracks.insert(tracks.end(), trk);
  iter->id = nextTrack++;
  return iter;
}


void GPSData::removeWaypoints(const QgsFeatureIds & ids) {
  QList<int> ids2 = ids.toList();
  qSort(ids2);
  QList<int>::const_iterator iter = ids2.begin();
  WaypointIterator wIter;
  for (wIter = waypoints.begin(); 
       wIter != waypoints.end() && iter != ids2.end(); ) {
    WaypointIterator tmpIter = wIter;
    ++tmpIter;
    if (wIter->id == *iter) {
      waypoints.erase(wIter);
      ++iter;
    }
    wIter = tmpIter;
  }
}
  

void GPSData::removeRoutes(const QgsFeatureIds & ids) {
  QList<int> ids2 = ids.toList();
  qSort(ids2);
  QList<int>::const_iterator iter = ids2.begin();
  RouteIterator rIter;
  for (rIter = routes.begin(); rIter != routes.end() && iter != ids2.end(); ) {
    RouteIterator tmpIter = rIter;
    ++tmpIter;
    if (rIter->id == *iter) {
      routes.erase(rIter);
      ++iter;
    }
    rIter = tmpIter;
  }  
}
  

void GPSData::removeTracks(const QgsFeatureIds & ids) {
  QList<int> ids2 = ids.toList();
  qSort(ids2);
  QList<int>::const_iterator iter = ids2.begin();
  TrackIterator tIter;
  for (tIter = tracks.begin(); tIter != tracks.end() && iter != ids2.end(); ) {
    TrackIterator tmpIter = tIter;
    ++tmpIter;
    if (tIter->id == *iter) {
      tracks.erase(tIter);
      ++iter;
    }
    tIter = tmpIter;
  }  
}


void GPSData::writeXML(QTextStream& stream) {
  stream.setEncoding(QTextStream::UnicodeUTF8);
  stream<<"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
  <<"<gpx version=\"1.0\" creator=\"Quantum GIS\">\n";
  for (WaypointIterator wIter = waypoints.begin(); 
       wIter != waypoints.end(); ++wIter)
    wIter->writeXML(stream);
  for (RouteIterator rIter = routes.begin(); rIter != routes.end(); ++rIter)
    rIter->writeXML(stream);
  for (TrackIterator tIter = tracks.begin(); tIter != tracks.end(); ++tIter)