Initial import.

vendor/phayes/geophp/lib/adapters/KML.class.php

@@ -0,0 +1,272 @@
+<?php
+/*
+ * Copyright (c) Patrick Hayes
+ * Copyright (c) 2010-2011, Arnaud Renevier
+ *
+ * This code is open-source and licenced under the Modified BSD License.
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * PHP Geometry/KML encoder/decoder
+ *
+ * Mainly inspired/adapted from OpenLayers( http://www.openlayers.org )
+ *   Openlayers/format/WKT.js
+ *
+ * @package    sfMapFishPlugin
+ * @subpackage GeoJSON
+ * @author     Camptocamp <info@camptocamp.com>
+ */
+class KML extends GeoAdapter
+{
+  private $namespace = FALSE;
+  private $nss = ''; // Name-space string. eg 'georss:'
+
+  /**
+   * Read KML string into geometry objects
+   *
+   * @param string $kml A KML string
+   *
+   * @return Geometry|GeometryCollection
+   */
+  public function read($kml) {
+    return $this->geomFromText($kml);
+  }
+
+  /**
+   * Serialize geometries into a KML string.
+   *
+   * @param Geometry $geometry
+   *
+   * @return string The KML string representation of the input geometries
+   */
+  public function write(Geometry $geometry, $namespace = FALSE) {
+    if ($namespace) {
+      $this->namespace = $namespace;
+      $this->nss = $namespace.':';
+    }
+    return $this->geometryToKML($geometry);
+  }
+
+  public function geomFromText($text) {
+    // Change to lower-case and strip all CDATA
+    $text = mb_strtolower($text, mb_detect_encoding($text));
+    $text = preg_replace('/<!\[cdata\[(.*?)\]\]>/s','',$text);
+
+    // Load into DOMDocument
+    $xmlobj = new DOMDocument();
+    @$xmlobj->loadXML($text);
+    if ($xmlobj === false) {
+      throw new Exception("Invalid KML: ". $text);
+    }
+
+    $this->xmlobj = $xmlobj;
+    try {
+      $geom = $this->geomFromXML();
+    } catch(InvalidText $e) {
+        throw new Exception("Cannot Read Geometry From KML: ". $text);
+    } catch(Exception $e) {
+        throw $e;
+    }
+
+    return $geom;
+  }
+
+  protected function geomFromXML() {
+    $geometries = array();
+    $geom_types = geoPHP::geometryList();
+    $placemark_elements = $this->xmlobj->getElementsByTagName('placemark');
+    if ($placemark_elements->length) {
+      foreach ($placemark_elements as $placemark) {
+        foreach ($placemark->childNodes as $child) {
+          // Node names are all the same, except for MultiGeometry, which maps to GeometryCollection
+          $node_name = $child->nodeName == 'multigeometry' ? 'geometrycollection' : $child->nodeName;
+          if (array_key_exists($node_name, $geom_types)) {
+            $function = 'parse'.$geom_types[$node_name];
+            $geometries[] = $this->$function($child);
+          }
+        }
+      }
+    }
+    else {
+      // The document does not have a placemark, try to create a valid geometry from the root element
+      $node_name = $this->xmlobj->documentElement->nodeName == 'multigeometry' ? 'geometrycollection' : $this->xmlobj->documentElement->nodeName;
+      if (array_key_exists($node_name, $geom_types)) {
+        $function = 'parse'.$geom_types[$node_name];
+        $geometries[] = $this->$function($this->xmlobj->documentElement);
+      }
+    }
+    return geoPHP::geometryReduce($geometries);
+  }
+
+  protected function childElements($xml, $nodename = '') {
+    $children = array();
+    if ($xml->childNodes) {
+      foreach ($xml->childNodes as $child) {
+        if ($child->nodeName == $nodename) {
+          $children[] = $child;
+        }
+      }
+    }
+    return $children;
+  }
+
+  protected function parsePoint($xml) {
+    $coordinates = $this->_extractCoordinates($xml);
+    if (!empty($coordinates)) {
+      return new Point($coordinates[0][0],$coordinates[0][1]);
+    }
+    else {
+      return new Point();
+    }
+  }
+
+  protected function parseLineString($xml) {
+    $coordinates = $this->_extractCoordinates($xml);
+    $point_array = array();
+    foreach ($coordinates as $set) {
+      $point_array[] = new Point($set[0],$set[1]);
+    }
+    return new LineString($point_array);
+  }
+
+  protected function parsePolygon($xml) {
+    $components = array();
+
+    $outer_boundary_element_a = $this->childElements($xml, 'outerboundaryis');
+    if (empty($outer_boundary_element_a)) {
+      return new Polygon(); // It's an empty polygon
+    }
+    $outer_boundary_element = $outer_boundary_element_a[0];
+    $outer_ring_element_a = $this->childElements($outer_boundary_element, 'linearring');
+    $outer_ring_element = $outer_ring_element_a[0];
+    $components[] = $this->parseLineString($outer_ring_element);
+
+    if (count($components) != 1) {
+      throw new Exception("Invalid KML");
+    }
+
+    $inner_boundary_element_a = $this->childElements($xml, 'innerboundaryis');
+    if (count($inner_boundary_element_a)) {
+      foreach ($inner_boundary_element_a as $inner_boundary_element) {
+        foreach ($this->childElements($inner_boundary_element, 'linearring') as $inner_ring_element) {
+          $components[] = $this->parseLineString($inner_ring_element);
+        }
+      }
+    }
+
+    return new Polygon($components);
+  }
+
+  protected function parseGeometryCollection($xml) {
+    $components = array();
+    $geom_types = geoPHP::geometryList();
+    foreach ($xml->childNodes as $child) {
+      $nodeName = ($child->nodeName == 'linearring') ? 'linestring' : $child->nodeName;
+      if (array_key_exists($nodeName, $geom_types)) {
+        $function = 'parse'.$geom_types[$nodeName];
+        $components[] = $this->$function($child);
+      }
+    }
+    return new GeometryCollection($components);
+  }
+
+  protected function _extractCoordinates($xml) {
+    $coord_elements = $this->childElements($xml, 'coordinates');
+    $coordinates = array();
+    if (count($coord_elements)) {
+      $coord_sets = explode(' ', preg_replace('/[\r\n]+/', ' ', $coord_elements[0]->nodeValue));
+      foreach ($coord_sets as $set_string) {
+        $set_string = trim($set_string);
+        if ($set_string) {
+          $set_array = explode(',',$set_string);
+          if (count($set_array) >= 2) {
+            $coordinates[] = $set_array;
+          }
+        }
+      }
+    }
+
+    return $coordinates;
+  }
+
+  private function geometryToKML($geom) {
+    $type = strtolower($geom->getGeomType());
+    switch ($type) {
+      case 'point':
+        return $this->pointToKML($geom);
+        break;
+      case 'linestring':
+        return $this->linestringToKML($geom);
+        break;
+      case 'polygon':
+        return $this->polygonToKML($geom);
+        break;
+      case 'multipoint':
+      case 'multilinestring':
+      case 'multipolygon':
+      case 'geometrycollection':
+        return $this->collectionToKML($geom);
+        break;
+    }
+  }
+
+  private function pointToKML($geom) {
+    $out = '<'.$this->nss.'Point>';
+    if (!$geom->isEmpty()) {
+      $out .= '<'.$this->nss.'coordinates>'.$geom->getX().",".$geom->getY().'</'.$this->nss.'coordinates>';
+    }
+    $out .= '</'.$this->nss.'Point>';
+    return $out;
+  }
+
+  private function linestringToKML($geom, $type = FALSE) {
+    if (!$type) {
+      $type = $geom->getGeomType();
+    }
+
+    $str = '<'.$this->nss . $type .'>';
+
+    if (!$geom->isEmpty()) {
+      $str .= '<'.$this->nss.'coordinates>';
+      $i=0;
+      foreach ($geom->getComponents() as $comp) {
+        if ($i != 0) $str .= ' ';
+        $str .= $comp->getX() .','. $comp->getY();
+        $i++;
+      }
+
+      $str .= '</'.$this->nss.'coordinates>';
+    }
+
+    $str .= '</'. $this->nss . $type .'>';
+
+    return $str;
+  }
+
+  public function polygonToKML($geom) {
+    $components = $geom->getComponents();
+    $str = '';
+    if (!empty($components)) {
+      $str = '<'.$this->nss.'outerBoundaryIs>' . $this->linestringToKML($components[0], 'LinearRing') . '</'.$this->nss.'outerBoundaryIs>';
+      foreach (array_slice($components, 1) as $comp) {
+        $str .= '<'.$this->nss.'innerBoundaryIs>' . $this->linestringToKML($comp) . '</'.$this->nss.'innerBoundaryIs>';
+      }
+    }
+
+    return '<'.$this->nss.'Polygon>'. $str .'</'.$this->nss.'Polygon>';
+  }
+
+  public function collectionToKML($geom) {
+    $components = $geom->getComponents();
+    $str = '<'.$this->nss.'MultiGeometry>';
+    foreach ($geom->getComponents() as $comp) {
+      $sub_adapter = new KML();
+      $str .= $sub_adapter->write($comp);
+    }
+
+    return $str .'</'.$this->nss.'MultiGeometry>';
+  }
+
+}