Polygon.class.php in geoPHP 7

File

geoPHP/lib/geometry/Polygon.class.php

<?php

/**
 * Polygon: A polygon is a plane figure that is bounded by a closed path, 
 * composed of a finite sequence of straight line segments
 */
class Polygon extends Collection {
  protected $geom_type = 'Polygon';

  // The boundary of a polygin is it's outer ring
  public function boundary() {
    return $this
      ->exteriorRing();
  }
  public function area($exterior_only = FALSE, $signed = FALSE) {
    if ($this
      ->isEmpty()) {
      return 0;
    }
    if ($this
      ->geos() && $exterior_only == FALSE) {
      return $this
        ->geos()
        ->area();
    }
    $exterior_ring = $this->components[0];
    $pts = $exterior_ring
      ->getComponents();
    $c = count($pts);
    if ((int) $c == '0') {
      return NULL;
    }
    $a = '0';
    foreach ($pts as $k => $p) {
      $j = ($k + 1) % $c;
      $a = $a + $p
        ->getX() * $pts[$j]
        ->getY() - $p
        ->getY() * $pts[$j]
        ->getX();
    }
    if ($signed) {
      $area = $a / 2;
    }
    else {
      $area = abs($a / 2);
    }
    if ($exterior_only == TRUE) {
      return $area;
    }
    foreach ($this->components as $delta => $component) {
      if ($delta != 0) {
        $inner_poly = new Polygon(array(
          $component,
        ));
        $area -= $inner_poly
          ->area();
      }
    }
    return $area;
  }
  public function centroid() {
    if ($this
      ->isEmpty()) {
      return NULL;
    }
    if ($this
      ->geos()) {
      return geoPHP::geosToGeometry($this
        ->geos()
        ->centroid());
    }
    $exterior_ring = $this->components[0];
    $pts = $exterior_ring
      ->getComponents();
    $c = count($pts);
    if ((int) $c == '0') {
      return NULL;
    }
    $cn = array(
      'x' => '0',
      'y' => '0',
    );
    $a = $this
      ->area(TRUE, TRUE);

    // If this is a polygon with no area. Just return the first point.
    if ($a == 0) {
      return $this
        ->exteriorRing()
        ->pointN(1);
    }
    foreach ($pts as $k => $p) {
      $j = ($k + 1) % $c;
      $P = $p
        ->getX() * $pts[$j]
        ->getY() - $p
        ->getY() * $pts[$j]
        ->getX();
      $cn['x'] = $cn['x'] + ($p
        ->getX() + $pts[$j]
        ->getX()) * $P;
      $cn['y'] = $cn['y'] + ($p
        ->getY() + $pts[$j]
        ->getY()) * $P;
    }
    $cn['x'] = $cn['x'] / (6 * $a);
    $cn['y'] = $cn['y'] / (6 * $a);
    $centroid = new Point($cn['x'], $cn['y']);
    return $centroid;
  }

  /**
   * Find the outermost point from the centroid
   *
   * @returns Point The outermost point
   */
  public function outermostPoint() {
    $centroid = $this
      ->getCentroid();
    $max = array(
      'length' => 0,
      'point' => null,
    );
    foreach ($this
      ->getPoints() as $point) {
      $lineString = new LineString(array(
        $centroid,
        $point,
      ));
      if ($lineString
        ->length() > $max['length']) {
        $max['length'] = $lineString
          ->length();
        $max['point'] = $point;
      }
    }
    return $max['point'];
  }
  public function exteriorRing() {
    if ($this
      ->isEmpty()) {
      return new LineString();
    }
    return $this->components[0];
  }
  public function numInteriorRings() {
    if ($this
      ->isEmpty()) {
      return 0;
    }
    return $this
      ->numGeometries() - 1;
  }
  public function interiorRingN($n) {
    return $this
      ->geometryN($n + 1);
  }
  public function dimension() {
    if ($this
      ->isEmpty()) {
      return 0;
    }
    return 2;
  }
  public function isSimple() {
    if ($this
      ->geos()) {
      return $this
        ->geos()
        ->isSimple();
    }
    $segments = $this
      ->explode();
    foreach ($segments as $i => $segment) {
      foreach ($segments as $j => $check_segment) {
        if ($i != $j) {
          if ($segment
            ->lineSegmentIntersect($check_segment)) {
            return FALSE;
          }
        }
      }
    }
    return TRUE;
  }

  /**
   * For a given point, determine whether it's bounded by the given polygon.
   * Adapted from http://www.assemblysys.com/dataServices/php_pointinpolygon.php
   * @see http://en.wikipedia.org/wiki/Point%5Fin%5Fpolygon
   *
   * @param Point $point
   * @param boolean $pointOnBoundary - whether a boundary should be considered "in" or not
   * @param boolean $pointOnVertex - whether a vertex should be considered "in" or not
   * @return boolean
   */
  public function pointInPolygon($point, $pointOnBoundary = true, $pointOnVertex = true) {
    $vertices = $this
      ->getPoints();

    // Check if the point sits exactly on a vertex
    if ($this
      ->pointOnVertex($point, $vertices)) {
      return $pointOnVertex ? TRUE : FALSE;
    }

    // Check if the point is inside the polygon or on the boundary
    $intersections = 0;
    $vertices_count = count($vertices);
    for ($i = 1; $i < $vertices_count; $i++) {
      $vertex1 = $vertices[$i - 1];
      $vertex2 = $vertices[$i];
      if ($vertex1
        ->y() == $vertex2
        ->y() && $vertex1
        ->y() == $point
        ->y() && $point
        ->x() > min($vertex1
        ->x(), $vertex2
        ->x()) && $point
        ->x() < max($vertex1
        ->x(), $vertex2
        ->x())) {

        // Check if point is on an horizontal polygon boundary
        return $pointOnBoundary ? TRUE : FALSE;
      }
      if ($point
        ->y() > min($vertex1
        ->y(), $vertex2
        ->y()) && $point
        ->y() <= max($vertex1
        ->y(), $vertex2
        ->y()) && $point
        ->x() <= max($vertex1
        ->x(), $vertex2
        ->x()) && $vertex1
        ->y() != $vertex2
        ->y()) {
        $xinters = ($point
          ->y() - $vertex1
          ->y()) * ($vertex2
          ->x() - $vertex1
          ->x()) / ($vertex2
          ->y() - $vertex1
          ->y()) + $vertex1
          ->x();
        if ($xinters == $point
          ->x()) {

          // Check if point is on the polygon boundary (other than horizontal)
          return $pointOnBoundary ? TRUE : FALSE;
        }
        if ($vertex1
          ->x() == $vertex2
          ->x() || $point
          ->x() <= $xinters) {
          $intersections++;
        }
      }
    }

    // If the number of edges we passed through is even, then it's in the polygon.
    if ($intersections % 2 != 0) {
      return TRUE;
    }
    else {
      return FALSE;
    }
  }
  public function pointOnVertex($point) {
    foreach ($this
      ->getPoints() as $vertex) {
      if ($point
        ->equals($vertex)) {
        return true;
      }
    }
  }

  // Not valid for this geometry type
  // --------------------------------
  public function length() {
    return NULL;
  }

}

Classes

Name	Description
Polygon	Polygon: A polygon is a plane figure that is bounded by a closed path, composed of a finite sequence of straight line segments