[andy/gpx.git] / src / libgpx / gpxreader.php

<?php
/**
 * gpxreader.php
 *
 * Copyright 2018 Andy Street <andy@street.me.uk>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 *
 */

namespace libgpx;

use \DateTimeImmutable;
use \XMLReader;

/**
 * Read GPX files.
 *
 * @author Andy Street <andy@street.me.uk>
 */
class GPXReader
{

  /**
   * Options used for XMLReader instances.
   */
  const XMLREADER_OPTIONS = LIBXML_NOERROR | LIBXML_NOWARNING;

  /**
   * Read GPX from a string.
   *
   * @param string $data The GPX XML data.
   * @return GPX The GPX data.
   * @throws MalformedGPXException If the GPX file is invalid.
   */
  public static function readString(string $data)
  {
    return self::read($data, true);
  }

  /**
   * Read GPX from a file.
   *
   * This function is an alias of `GPXReader::readURI()`.
   *
   * @param string $filename The name of the file containing GPX XML data.
   * @return GPX The GPX data.
   * @throws MalformedGPXException If the GPX file is invalid.
   */
  public static function readFile(string $filename)
  {
    return self::read($filename, false);
  }

  /**
   * Read GPX from a URI.
   *
   * @param string $uri The location of the file containing GPX XML data.
   * @return GPX The GPX data.
   * @throws MalformedGPXException If the GPX file is invalid.
   */
  public static function readURI(string $uri)
  {
    return self::read($uri, false);
  }

  /**
   * Read a GPX file.
   *
   * @param string $src The source of the GPX data.
   * @param boolean $fromString If true `src` is treated as a string containing
   *        the XML to parse otherwise it is treated as a URI to load data from.
   * @return GPX The loaded GPX data.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  public static function read(string $src, bool $fromString)
  {
    // Register stream wrapper
    if (!$fromString) {
      $wrappers = stream_get_wrappers();
      do {
        $wrapper = uniqid('libgpx-');
      } while (in_array($wrapper, $wrappers));
      if (!stream_wrapper_register($wrapper, '\libgpx\PeekStream'))
        throw new MalformedGPXException(
          'Unable to register stream.'
        );
    }
    try {
      // Load data from file
      $xml = new XMLReader();
      if ($fromString) {
        if (!@$xml->XML($src, null, self::XMLREADER_OPTIONS))
          throw new MalformedGPXException(
            'Unable to read XML string.'
          );
      } else {
        if (!@$xml->open($wrapper . '://' . $src, null, self::XMLREADER_OPTIONS))
          throw new MalformedGPXException(
            sprintf('Unable to read source “%s”', $src)
          );
      }

      // Namespace detection
      $namespace = self::detectRootNamespace(
        $fromString ? $src : PeekStream::peek($src)
      );
      switch ($namespace) {
        case libgpx::NAMESPACE_GPX_1_0:
          $xml->setSchema(__DIR__ . DIRECTORY_SEPARATOR . 'gpx-1-0.xsd');
          break;
        case libgpx::NAMESPACE_GPX_1_1:
          $xml->setSchema(__DIR__ . DIRECTORY_SEPARATOR . 'gpx-1-1.xsd');
          break;
        case null:
          throw new MalformedGPXException(
            'Supplied XML is not namespaced.'
          );
        default :
          throw new MalformedGPXException(
            sprintf('Unsupported namespace: %s', $namespace)
          );
      }

      // Read XML
      while ($valid = ($xml->read() && $xml->isValid())) {
        if ($xml->nodeType == XMLReader::ELEMENT) break;
      }
      if (!$valid)
        throw new MalformedGPXException(libxml_get_last_error()->message);
      $gpx = self::readGPX($xml);
    } finally {
      if (!$fromString) stream_wrapper_unregister($wrapper);
    }
    return $gpx;
  }

  /**
   * Detect the namespace of the XML root element.
   *
   * @param string $data The XML to extract namespace from.
   * @return string The namespace of the root element.
   * @throws MalformedGPXException If it was not possible to detect the namespace.
   */
  protected static function detectRootNamespace(string $data) {
    $xml = new XMLReader();
    $xml->XML($data, null, self::XMLREADER_OPTIONS);
    $namespace = false;
    while ($xml->read()) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        $namespace = $xml->namespaceURI;
        break;
      }
    }
    if ($namespace === false)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    $xml->close();
    return $namespace;
  }

  /**
   * Reads a gpx type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the gpx type.
   * @return GPX A GPX data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readGPX(XMLReader $xml)
  {
    $gpx = new GPX();
    $gpx->setCreator($xml->getAttribute('creator'));
    $ns = $xml->namespaceURI;
    $inMetadata = false;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        if ($xml->namespaceURI == $ns) {
          switch ($xml->localName) {
            case 'metadata':
              $inMetadata = true;
              break;
            case 'name':
              $gpx->setName($xml->readString());
              break;
            case 'desc':
              $gpx->setDesc($xml->readString());
              break;
            case 'author':
              if ($inMetadata) {
                $gpx->setAuthor(self::readPerson($xml));
              } else {
                $person = new Person();
                $person->setName($xml->readString());
                $gpx->setAuthor($person);
              }
              break;
            case 'email':
              $person = $gpx->getAuthor();
              if ($person !== null) $gpx->setAuthor($person = new Person());
              $person->setEmail($xml->readString());
              break;
            case 'copyright':
              $gpx->setCopyright(self::readCopyright($xml));
              break;
            case 'link':
              $gpx->getLinks()[] = self::readLink($xml);
              break;
            case 'url':
              $gpx->getLinks()[] = new Link($xml->readString());
              break;
            case 'urlname':
              $links = $gpx->getLinks();
              if (count($links) > 0)
                $links[0]->setText($xml->readString());
              break;
            case 'time':
              $gpx->setTime(new DateTimeImmutable($xml->readString()));
              break;
            case 'keywords':
              $keywords = $gpx->getKeywords();
              foreach (explode(',', $xml->readString()) as $keyword)
                $keywords[] = trim($keyword);
              break;
            case 'wpt':
              $gpx->getWaypoints()[] = self::readPoint($xml);
              break;
            case 'rte':
              $gpx->getRoutes()[] = self::readRoute($xml);
              break;
            case 'trk':
              $gpx->getTracks()[] = self::readTrack($xml);
              break;
            case 'extensions':
              $exts = (
                $inMetadata
                ? $gpx->getMetadataExtensions()
                : $gpx->getExtensions()
              );
              foreach (self::readExtensions($xml) as $ext) {
                $exts[] = $ext;
              }
              break;
          }
        } else {
          $gpx->getExtensions()[] = self::readExtension($xml);
        }
      } elseif (
        $xml->nodeType == XMLReader::END_ELEMENT
        && $xml->namespaceURI == $ns
      ) {
        switch ($xml->localName) {
          case 'metadata':
            $inMetadata = false;
            break;
          case 'gpx':
            break 2;
        }
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $gpx;
  }

  /**
   * Reads a rte type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the rte type.
   * @return Route A Route data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readRoute(XMLReader $xml)
  {
    $route = new Route();
    if ($xml->isEmptyElement) return $route;
    $ns = $xml->namespaceURI;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        if ($xml->namespaceURI == $ns) {
          switch ($xml->localName) {
            case 'name':
              $route->setName($xml->readString());
              break;
            case 'cmt':
              $route->setComment($xml->readString());
              break;
            case 'desc':
              $route->setDescription($xml->readString());
              break;
            case 'src':
              $route->setSource($xml->readString());
              break;
            case 'link':
              $route->getLinks()[] = self::readLink($xml);
              break;
            case 'url':
              $route->getLinks()[] = new Link($xml->readString());
              break;
            case 'urlname':
              $links = $route->getLinks();
              if (count($links) > 0)
                $links[0]->setText($xml->readString());
              break;
            case 'number':
              $route->setNumber($xml->readString());
              break;
            case 'type';
              $route->setType($xml->readString());
              break;
            case 'extensions':
              $exts = $route->getExtensions();
              foreach (self::readExtensions($xml) as $ext) {
                $exts[] = $ext;
              }
              break;
            case 'rtept':
              $route->getPoints()[] = self::readPoint($xml);
              break;
          }
        } else {
          $route->getExtensions()[] = self::readExtension($xml);
        }
      } elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->namespaceURI == $ns && $xml->localName == 'rte') break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $route;
  }

  /**
   * Reads a trk type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the trk type.
   * @return Track A Track data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readTrack(XMLReader $xml)
  {
    $track = new Track();
    $ns = $xml->namespaceURI;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        if ($xml->namespaceURI == $ns) {
          switch ($xml->localName) {
            case 'name':
              $track->setName($xml->readString());
              break;
            case 'cmt':
              $track->setComment($xml->readString());
              break;
            case 'desc':
              $track->setDescription($xml->readString());
              break;
            case 'src':
              $track->setSource($xml->readString());
              break;
            case 'link':
              $track->getLinks()[] = self::readLink($xml);
              break;
            case 'url':
              $track->getLinks()[] = new Link($xml->readString());
              break;
            case 'urlname':
              $links = $track->getLinks();
              if (count($links) > 0)
                $links[0]->setText($xml->readString());
              break;
            case 'number':
              $track->setNumber($xml->readString());
              break;
            case 'type';
              $track->setType($xml->readString());
              break;
            case 'extensions':
              $exts = $track->getExtensions();
              foreach (self::readExtensions($xml) as $ext) {
                $exts[] = $ext;
              }
              break;
            case 'trkseg':
              $track->getSegments()[] = self::readTrackSegment($xml);
              break;
          }
        } else {
          $track->getExtensions()[] = self::readExtension($xml);
        }
      } elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->namespaceURI == $ns && $xml->localName == 'trk') break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $track;
  }

  /**
   * Reads a trkseg type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the trkseg type.
   * @return TrackSegment A TrackSegment data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readTrackSegment(XMLReader $xml)
  {
    $segment = new TrackSegment();
    $ns = $xml->namespaceURI;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        if ($xml->namespaceURI == $ns) {
          switch ($xml->localName) {
            case 'trkpt':
              $segment->getPoints()[] = self::readPoint($xml);
              break;
            case 'extensions':
              $exts = $segment->getExtensions();
              foreach (self::readExtensions($xml) as $ext) {
                $exts[] = $ext;
              }
              break;
          }
        }
      } elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->namespaceURI == $ns && $xml->localName == 'trkseg') break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $segment;
  }

  /**
   * Reads a wpt type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the wpt type.
   * @return Point A Point data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readPoint(XMLReader $xml)
  {
    $point = new Point(
      $xml->getAttribute('lat'),
      $xml->getAttribute('lon')
    );
    if ($xml->isEmptyElement) return $point;
    $ns = $xml->namespaceURI;
    $name = $xml->localName;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        if ($xml->namespaceURI == $ns) {
          switch ($xml->localName) {
            case 'ele':
              $point->setEle($xml->readString());
              break;
            case 'time':
              $point->setTime(new DateTimeImmutable($xml->readString()));
              break;
            case 'magvar':
              $point->setMagvar($xml->readString());
              break;
            case 'geoidheight':
              $point->setGeoidHeight($xml->readString());
              break;
            case 'name':
              $point->setName($xml->readString());
              break;
            case 'cmt':
              $point->setComment($xml->readString());
              break;
            case 'desc':
              $point->setDescription($xml->readString());
              break;
            case 'src':
              $point->setSource($xml->readString());
              break;
            case 'link':
              $point->getLinks()[] = self::readLink($xml);
              break;
            case 'url':
              $point->getLinks()[] = new Link($xml->readString());
              break;
            case 'urlname':
              $links = $point->getLinks();
              if (count($links) > 0)
                $links[0]->setText($xml->readString());
              break;
            case 'sym':
              $point->setSymbol($xml->readString());
              break;
            case 'type':
              $point->setType($xml->readString());
              break;
            case 'fix':
              $point->setFix($xml->readString());
              break;
            case 'sat':
              $point->setSatellites($xml->readString());
              break;
            case 'hdop':
              $point->setHdop($xml->readString());
              break;
            case 'vdop':
              $point->setVdop($xml->readString());
              break;
            case 'pdop':
              $point->setPdop($xml->readString());
              break;
            case 'ageofdgpsdata':
              $point->setAgeOfDGPSData($xml->readString());
              break;
            case 'dgpsid':
              $point->setDGPSId($xml->readString());
              break;
            case 'extensions':
              $exts = $point->getExtensions();
              foreach (self::readExtensions($xml) as $ext) {
                $exts[] = $ext;
              }
              break;
          }
        } else {
          $point->getExtensions()[] = self::readExtension($xml);
        }
      } elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->namespaceURI == $ns && $xml->localName == $name) break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $point;
  }

  /**
   * Reads a person type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the person type.
   * @return Person A Person data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readPerson(XMLReader $xml)
  {
    $person = new Person();
    if ($xml->isEmptyElement) return $person;
    $name = $xml->localName;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        switch ($xml->localName) {
          case 'name':
            $person->setName($xml->readString());
            break;
          case 'email':
            $person->setEmail(
              $xml->getAttribute('id') . '@' . $xml->getAttribute('domain')
            );
            break;
          case 'link':
            $person->setLink(self::readLink($xml));
            break;
        }
      }  elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->localName == $name) break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $person;
  }

  /**
   * Reads a link type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the link type.
   * @return Link A Link data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readLink(XMLReader $xml)
  {
    $link = new Link($xml->getAttribute('href'));
    if ($xml->isEmptyElement) return $link;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        switch ($xml->localName) {
          case 'text':
            $link->setText($xml->readString());
            break;
          case 'type':
            $link->setType($xml->readString());
            break;
        }
      } elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->localName == 'link') break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $link;
  }

  /**
   * Reads a copyright type from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the copyright type.
   * @return Copyright A Copyright data structure.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readCopyright(XMLReader $xml)
  {
    $copyright = new Copyright($xml->getAttribute('author'));
    if ($xml->isEmptyElement) return $copyright;
    $name = $xml->localName;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::ELEMENT) {
        switch ($xml->localName) {
          case 'year':
            $copyright->setYear($xml->readString());
            break;
          case 'license':
            $copyright->setLicense($xml->readString());
            break;
        }
      }  elseif ($xml->nodeType == XMLReader::END_ELEMENT) {
        if ($xml->localName == $name) break;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $copyright;
  }

  /**
   * Reads an extensions type (GPX 1.1 only) from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the extensions type.
   * @return string[] An array of XML snippets describing the extensions.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readExtensions(XMLReader $xml)
  {
    $extensions = [];
    if (!$xml->isEmptyElement) {
      $xml->read();
      do {
        switch ($xml->nodeType) {
          case XMLReader::ELEMENT:
            $extensions[] = $xml->readOuterXML();
            break;
          case XMLReader::END_ELEMENT:
            break 2;
        }
      } while ($valid = ($xml->next() && $xml->isValid()));
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $extensions;
  }

  /**
   * Reads a extension (GPX 1.0 only) from an XML document.
   *
   * @param XMLReader $xml An XML document with the cursor positioned at the
   *        start of the extension element.
   * @return string An XML snippet describing the extension.
   * @throws MalformedGPXException If there was a problem parsing the XML.
   */
  protected static function readExtension(XMLReader $xml)
  {
    $extension = $xml->readOuterXML();
    $depth = 0;
    while ($valid = ($xml->read() && $xml->isValid())) {
      if ($xml->nodeType == XMLReader::END_ELEMENT && $depth-- == 0) {
        break;
      } elseif ($xml->nodeType == XMLReader::ELEMENT && !$xml->isEmptyElement) {
        $depth++;
      }
    }
    if (!$valid)
      throw new MalformedGPXException(libxml_get_last_error()->message);
    return $extension;
  }

}