PHP geoPHP::geometryReduce方法代码示例

 /**
  * Converts an stdClass object into a Geometry based on its 'type' property
  * Converts an stdClass object into a Geometry, based on its 'type' property
  *
  * @param stdClass $obj Object resulting from json decoding a GeoJSON string
  *
  * @return object Object from class eometry
  */
 private static function toInstance($obj)
 {
     if (is_null($obj)) {
         return null;
     }
     if (!isset($obj->type)) {
         self::checkType($obj);
     }
     if ($obj->type == 'Feature') {
         $instance = self::toGeomInstance($obj->geometry);
     } else {
         if ($obj->type == 'FeatureCollection') {
             $geometries = array();
             foreach ($obj->features as $feature) {
                 $geometries[] = self::toGeomInstance($feature->geometry);
             }
             // Get a geometryCollection or MultiGeometry out of the the provided geometries
             $instance = geoPHP::geometryReduce($geometries);
         } else {
             // It's a geometry
             $instance = self::toGeomInstance($obj);
         }
     }
     return $instance;
 }

 protected function geomFromXML()
 {
     $geometries = array();
     $geometries = array_merge($geometries, $this->parseWaypoints());
     $geometries = array_merge($geometries, $this->parseTracks());
     $geometries = array_merge($geometries, $this->parseRoutes());
     if (empty($geometries)) {
         throw new Exception("Invalid / Empty GPX");
     }
     return geoPHP::geometryReduce($geometries);
 }

 /**
  * Given an object or a string, return a Geometry
  *
  * @param mixed $input The GeoJSON string or object
  *
  * @return object Geometry
  */
 public function read($input)
 {
     if (is_string($input)) {
         $input = json_decode($input);
     }
     if (!is_object($input)) {
         throw new Exception('Invalid JSON');
     }
     if (!is_string($input->type)) {
         throw new Exception('Invalid JSON');
     }
     // Check to see if it's a FeatureCollection
     if ($input->type == 'FeatureCollection') {
         $geoms = array();
         foreach ($input->features as $feature) {
             $geoms[] = $this->read($feature);
         }
         return geoPHP::geometryReduce($geoms);
     }
     // Check to see if it's a Feature
     if ($input->type == 'Feature') {
         return $this->read($input->geometry);
     }
     // It's a geometry - process it
     return $this->objToGeom($input);
 }

/**
 * Convert KML -> WKT.
 *
 * @param string $wkt The coverage.
 * @return string|null The WKT.
 */
function nl_kml2wkt($kml)
{
    $wkt = null;
    // Is the input valid KML?
    if (geoPHP::detectFormat($kml) == 'kml') {
        $geo = geoPHP::load($kml);
        $wkt = geoPHP::geometryReduce($geo)->out('wkt');
    }
    return $wkt;
}

 protected function geomFromXML()
 {
     $geometries = array();
     $geometries = array_merge($geometries, $this->parsePoints());
     $geometries = array_merge($geometries, $this->parseLines());
     $geometries = array_merge($geometries, $this->parsePolygons());
     $geometries = array_merge($geometries, $this->parseBoxes());
     $geometries = array_merge($geometries, $this->parseCircles());
     if (empty($geometries)) {
         throw new Exception("Invalid / Empty GeoRSS");
     }
     return geoPHP::geometryReduce($geometries);
 }

 /**
  * Convert an object into a GeoPHP Geometry object.
  *
  * The following rules will dictate the conversion:
  *  - Multi-value geofields of different types will be reduced to a
  *    GEOMETRYCOLLECTION.
  *  - Multi-value geofields of the same 'simple type' (POINT, LINESTRING or
  *    POLYGON) will be reduced to the MULTI* equivalent.
  *  - GEOMETRYCOLLECTION's containing multiple values of only one 'simple type'
  *    will be reduced to the MULTI* equvalent.
  *  - GEOMETRYCOLLECTION's or MULTI* values containing only one geometry will be
  *    reduced to that geometery.
  *
  * @param Traversable $object
  *    An object that represents a geometry or a (traversable) collection of
  *    such objects.
  *
  * @param Callable $to_geom
  *    A callback that takes your object and returns a GeoPHP Geometry object.
  *
  * @return
  *    A GeoPHP Geometry object representing the $object value
  *    converted according to the above rules.
  */
 protected function createGeoPHPGeometry($object, $to_geom = NULL)
 {
     geophp_load();
     if (empty($object)) {
         return NULL;
     }
     if (!$to_geom) {
         $to_geom = function ($wkt) {
             return \geoPHP::load($wkt, 'wkt');
         };
     }
     // TODO: This reflection sucks.
     if (is_array($object) || $object instanceof \Traversable && $object instanceof \Countable && $object instanceof \ArrayAccess) {
         foreach ($object as $delta => $value) {
             $geometry = $this->createGeoPHPGeometry($value, $to_geom);
             if ($geometry) {
                 $geom[] = $geometry;
             }
         }
     } else {
         $geom = $to_geom($object);
     }
     return \geoPHP::geometryReduce($geom);
 }

 /**
  *
  */
 protected function geometry()
 {
     if (!$this->processed || $reset) {
         $this->process();
     }
     geophp_load();
     return \geoPHP::geometryReduce(array_map(function ($feature) {
         // TODO: GeoPHP cannot parse an array-based representation of a GeoJSON
         //       object. We have to encode the array then parse the JSON string.
         $json = json_encode($feature->geometry);
         return \geoPHP::load($json, 'json');
     }, $this->features));
 }

 static function geometryReduce($geometry)
 {
     // If it's an array of one, then just parse the one
     if (is_array($geometry)) {
         if (count($geometry) == 1) {
             return geoPHP::geometryReduce($geometry[0]);
         }
     }
     // If the geometry cannot even theoretically be reduced more, then pass it back
     if (gettype($geometry) == 'object') {
         $passbacks = array('Point', 'LineString', 'Polygon');
         if (in_array($geometry->geometryType(), $passbacks)) {
             return $geometry;
         }
     }
     // If it is a mutlti-geometry, check to see if it just has one member
     // If it does, then pass the member, if not, then just pass back the geometry
     if (gettype($geometry) == 'object') {
         $simple_collections = array('MultiPoint', 'MultiLineString', 'MultiPolygon');
         if (in_array(get_class($geometry), $passbacks)) {
             $components = $geometry->getComponents();
             if (count($components) == 1) {
                 return $components[0];
             } else {
                 return $geometry;
             }
         }
     }
     // So now we either have an array of geometries, a GeometryCollection, or an array of GeometryCollections
     if (!is_array($geometry)) {
         $geometry = array($geometry);
     }
     $geometries = array();
     $geom_types = array();
     $collections = array('MultiPoint', 'MultiLineString', 'MultiPolygon', 'GeometryCollection');
     foreach ($geometry as $item) {
         if (in_array(get_class($item), $collections)) {
             foreach ($item->getComponents() as $component) {
                 $geometries[] = $component;
                 $geom_types[] = $component->geometryType();
             }
         } else {
             $geometries[] = $item;
             $geom_types[] = $item->geometryType();
         }
     }
     $geom_types = array_unique($geom_types);
     if (count($geom_types) == 1) {
         if (count($geometries) == 1) {
             return $geometries[0];
         } else {
             $class = 'Multi' . $geom_types[0];
             return new $class($geometries);
         }
     } else {
         return new GeometryCollection($geometries);
     }
 }

 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);
 }

 public function boundary()
 {
     if ($this->geos()) {
         return $this->geos()->boundary();
     }
     $components_boundaries = array();
     foreach ($this->components as $component) {
         $components_boundaries[] = $component->boundary();
     }
     return geoPHP::geometryReduce($components_boundaries);
 }