Ysurac / FlightAirMap

require/libs/geoPHP/lib/adapters/EWKB.class.php

Indentation +62 added lines, -62 removed lines

@@ -13,33 +13,33 @@ 
    * @return Geometry
    */
   public function read($wkb, $is_hex_string = FALSE) {
-    if ($is_hex_string) {
-      $wkb = pack('H*',$wkb);
-    }
+	if ($is_hex_string) {
+	  $wkb = pack('H*',$wkb);
+	}
     
-    // Open the wkb up in memory so we can examine the SRID
-    $mem = fopen('php://memory', 'r+');
-    fwrite($mem, $wkb);
-    fseek($mem, 0);
-    $base_info = unpack("corder/ctype/cz/cm/cs", fread($mem, 5));
-    if ($base_info['s']) {
-      $srid = current(unpack("Lsrid", fread($mem, 4)));
-    }
-    else {
-      $srid = NULL;
-    }
-    fclose($mem);
+	// Open the wkb up in memory so we can examine the SRID
+	$mem = fopen('php://memory', 'r+');
+	fwrite($mem, $wkb);
+	fseek($mem, 0);
+	$base_info = unpack("corder/ctype/cz/cm/cs", fread($mem, 5));
+	if ($base_info['s']) {
+	  $srid = current(unpack("Lsrid", fread($mem, 4)));
+	}
+	else {
+	  $srid = NULL;
+	}
+	fclose($mem);
     
-    // Run the wkb through the normal WKB reader to get the geometry
-    $wkb_reader = new WKB();
-    $geom = $wkb_reader->read($wkb);
+	// Run the wkb through the normal WKB reader to get the geometry
+	$wkb_reader = new WKB();
+	$geom = $wkb_reader->read($wkb);
     
-    // If there is an SRID, add it to the geometry
-    if ($srid) {
-      $geom->setSRID($srid);
-    }
+	// If there is an SRID, add it to the geometry
+	if ($srid) {
+	  $geom->setSRID($srid);
+	}
     
-    return $geom;
+	return $geom;
   }
   
   /**
@@ -50,47 +50,47 @@ 
    * @return string The Extended-WKB binary string representation of the input geometries
    */
   public function write(Geometry $geometry, $write_as_hex = FALSE) {
-    // We always write into NDR (little endian)
-    $wkb = pack('c',1);
+	// We always write into NDR (little endian)
+	$wkb = pack('c',1);
     
-    switch ($geometry->getGeomType()) {
-      case 'Point';
-        $wkb .= pack('L',1);
-        $wkb .= $this->writePoint($geometry);
-        break;
-      case 'LineString';
-        $wkb .= pack('L',2);
-        $wkb .= $this->writeLineString($geometry);
-        break;
-      case 'Polygon';
-        $wkb .= pack('L',3);
-        $wkb .= $this->writePolygon($geometry);
-        break;
-      case 'MultiPoint';
-        $wkb .= pack('L',4);
-        $wkb .= $this->writeMulti($geometry);
-        break;
-      case 'MultiLineString';
-        $wkb .= pack('L',5);
-        $wkb .= $this->writeMulti($geometry);
-        break;
-      case 'MultiPolygon';
-        $wkb .= pack('L',6);
-        $wkb .= $this->writeMulti($geometry);
-        break;
-      case 'GeometryCollection';
-        $wkb .= pack('L',7);
-        $wkb .= $this->writeMulti($geometry);
-        break;
-    }
+	switch ($geometry->getGeomType()) {
+	  case 'Point';
+		$wkb .= pack('L',1);
+		$wkb .= $this->writePoint($geometry);
+		break;
+	  case 'LineString';
+		$wkb .= pack('L',2);
+		$wkb .= $this->writeLineString($geometry);
+		break;
+	  case 'Polygon';
+		$wkb .= pack('L',3);
+		$wkb .= $this->writePolygon($geometry);
+		break;
+	  case 'MultiPoint';
+		$wkb .= pack('L',4);
+		$wkb .= $this->writeMulti($geometry);
+		break;
+	  case 'MultiLineString';
+		$wkb .= pack('L',5);
+		$wkb .= $this->writeMulti($geometry);
+		break;
+	  case 'MultiPolygon';
+		$wkb .= pack('L',6);
+		$wkb .= $this->writeMulti($geometry);
+		break;
+	  case 'GeometryCollection';
+		$wkb .= pack('L',7);
+		$wkb .= $this->writeMulti($geometry);
+		break;
+	}
     
-    if ($write_as_hex) {
-      $unpacked = unpack('H*',$wkb);
-      return $unpacked[1];
-    }
-    else {
-      return $wkb;
-    }
+	if ($write_as_hex) {
+	  $unpacked = unpack('H*',$wkb);
+	  return $unpacked[1];
+	}
+	else {
+	  return $wkb;
+	}
   }
 
 }

Spacing +10 added lines, -10 removed lines

@@ -14,7 +14,7 @@ 
    */
   public function read($wkb, $is_hex_string = FALSE) {
     if ($is_hex_string) {
-      $wkb = pack('H*',$wkb);
+      $wkb = pack('H*', $wkb);
     }
     
     // Open the wkb up in memory so we can examine the SRID
@@ -51,41 +51,41 @@ 
    */
   public function write(Geometry $geometry, $write_as_hex = FALSE) {
     // We always write into NDR (little endian)
-    $wkb = pack('c',1);
+    $wkb = pack('c', 1);
     
     switch ($geometry->getGeomType()) {
       case 'Point';
-        $wkb .= pack('L',1);
+        $wkb .= pack('L', 1);
         $wkb .= $this->writePoint($geometry);
         break;
       case 'LineString';
-        $wkb .= pack('L',2);
+        $wkb .= pack('L', 2);
         $wkb .= $this->writeLineString($geometry);
         break;
       case 'Polygon';
-        $wkb .= pack('L',3);
+        $wkb .= pack('L', 3);
         $wkb .= $this->writePolygon($geometry);
         break;
       case 'MultiPoint';
-        $wkb .= pack('L',4);
+        $wkb .= pack('L', 4);
         $wkb .= $this->writeMulti($geometry);
         break;
       case 'MultiLineString';
-        $wkb .= pack('L',5);
+        $wkb .= pack('L', 5);
         $wkb .= $this->writeMulti($geometry);
         break;
       case 'MultiPolygon';
-        $wkb .= pack('L',6);
+        $wkb .= pack('L', 6);
         $wkb .= $this->writeMulti($geometry);
         break;
       case 'GeometryCollection';
-        $wkb .= pack('L',7);
+        $wkb .= pack('L', 7);
         $wkb .= $this->writeMulti($geometry);
         break;
     }
     
     if ($write_as_hex) {
-      $unpacked = unpack('H*',$wkb);
+      $unpacked = unpack('H*', $wkb);
       return $unpacked[1];
     }
     else {

Braces +2 added lines, -4 removed lines

@@ -24,8 +24,7 @@ 
     $base_info = unpack("corder/ctype/cz/cm/cs", fread($mem, 5));
     if ($base_info['s']) {
       $srid = current(unpack("Lsrid", fread($mem, 4)));
-    }
-    else {
+    } else {
       $srid = NULL;
     }
     fclose($mem);
@@ -87,8 +86,7 @@ 
     if ($write_as_hex) {
       $unpacked = unpack('H*',$wkb);
       return $unpacked[1];
-    }
-    else {
+    } else {
       return $wkb;
     }
   }

require/libs/geoPHP/lib/adapters/GeoHash.class.php

Indentation +118 added lines, -118 removed lines

@@ -16,21 +16,21 @@ 
    * @see GeoAdapter::read()
    */
   public function read($hash, $as_grid = FALSE) {
-    $ll = $this->decode($hash);
-    if (!$as_grid) {
-      return new Point($ll['medlon'], $ll['medlat']);
-    }
-    else {
-      return new Polygon(array(
-        new LineString(array(
-          new Point($ll['minlon'], $ll['maxlat']),
-          new Point($ll['maxlon'], $ll['maxlat']),
-          new Point($ll['maxlon'], $ll['minlat']),
-          new Point($ll['minlon'], $ll['minlat']),
-          new Point($ll['minlon'], $ll['maxlat']),
-        ))
-      ));
-    }
+	$ll = $this->decode($hash);
+	if (!$as_grid) {
+	  return new Point($ll['medlon'], $ll['medlat']);
+	}
+	else {
+	  return new Polygon(array(
+		new LineString(array(
+		  new Point($ll['minlon'], $ll['maxlat']),
+		  new Point($ll['maxlon'], $ll['maxlat']),
+		  new Point($ll['maxlon'], $ll['minlat']),
+		  new Point($ll['minlon'], $ll['minlat']),
+		  new Point($ll['minlon'], $ll['maxlat']),
+		))
+	  ));
+	}
   }
 
   /**
@@ -40,32 +40,32 @@ 
    * @see GeoAdapter::write()
    */
   public function write(Geometry $geometry, $precision = NULL){
-    if ($geometry->isEmpty()) return '';
+	if ($geometry->isEmpty()) return '';
 
-    if($geometry->geometryType() === 'Point'){
-      return $this->encodePoint($geometry, $precision);
-    }
-    else {
-      // The geohash is the hash grid ID that fits the envelope
-      $envelope = $geometry->envelope();
-      $geohashes = array();
-      $geohash = '';
-      foreach ($envelope->getPoints() as $point) {
-        $geohashes[] = $this->encodePoint($point, 0.0000001);
-      }
-      $i = 0;
-      while ($i < strlen($geohashes[0])) {
-        $char = $geohashes[0][$i];
-        foreach ($geohashes as $hash) {
-          if ($hash[$i] != $char) {
-            return $geohash;
-          }
-        }
-        $geohash .= $char;
-        $i++;
-      }
-      return $geohash;
-    }
+	if($geometry->geometryType() === 'Point'){
+	  return $this->encodePoint($geometry, $precision);
+	}
+	else {
+	  // The geohash is the hash grid ID that fits the envelope
+	  $envelope = $geometry->envelope();
+	  $geohashes = array();
+	  $geohash = '';
+	  foreach ($envelope->getPoints() as $point) {
+		$geohashes[] = $this->encodePoint($point, 0.0000001);
+	  }
+	  $i = 0;
+	  while ($i < strlen($geohashes[0])) {
+		$char = $geohashes[0][$i];
+		foreach ($geohashes as $hash) {
+		  if ($hash[$i] != $char) {
+			return $geohash;
+		  }
+		}
+		$geohash .= $char;
+		$i++;
+	  }
+	  return $geohash;
+	}
   }
 
   /**
@@ -75,51 +75,51 @@ 
    * @see https://github.com/asonge/php-geohash/issues/1
    */
   private function encodePoint($point, $precision = NULL){
-    if ($precision === NULL) {
-      $lap = strlen($point->y())-strpos($point->y(),".");
-      $lop = strlen($point->x())-strpos($point->x(),".");
-      $precision = pow(10,-max($lap-1,$lop-1,0))/2;
-    }
+	if ($precision === NULL) {
+	  $lap = strlen($point->y())-strpos($point->y(),".");
+	  $lop = strlen($point->x())-strpos($point->x(),".");
+	  $precision = pow(10,-max($lap-1,$lop-1,0))/2;
+	}
 
-    $minlat =  -90;
-    $maxlat =   90;
-    $minlon = -180;
-    $maxlon =  180;
-    $latE   =   90;
-    $lonE   =  180;
-    $i = 0;
-    $error = 180;
-    $hash='';
-    while($error>=$precision) {
-      $chr = 0;
-      for($b=4;$b>=0;--$b) {
-        if((1&$b) == (1&$i)) {
-          // even char, even bit OR odd char, odd bit...a lon
-          $next = ($minlon+$maxlon)/2;
-          if($point->x()>$next) {
-            $chr |= pow(2,$b);
-            $minlon = $next;
-          } else {
-            $maxlon = $next;
-          }
-          $lonE /= 2;
-        } else {
-          // odd char, even bit OR even char, odd bit...a lat
-          $next = ($minlat+$maxlat)/2;
-          if($point->y()>$next) {
-            $chr |= pow(2,$b);
-            $minlat = $next;
-          } else {
-            $maxlat = $next;
-          }
-          $latE /= 2;
-        }
-      }
-      $hash .= $this->table[$chr];
-      $i++;
-      $error = min($latE,$lonE);
-    }
-    return $hash;
+	$minlat =  -90;
+	$maxlat =   90;
+	$minlon = -180;
+	$maxlon =  180;
+	$latE   =   90;
+	$lonE   =  180;
+	$i = 0;
+	$error = 180;
+	$hash='';
+	while($error>=$precision) {
+	  $chr = 0;
+	  for($b=4;$b>=0;--$b) {
+		if((1&$b) == (1&$i)) {
+		  // even char, even bit OR odd char, odd bit...a lon
+		  $next = ($minlon+$maxlon)/2;
+		  if($point->x()>$next) {
+			$chr |= pow(2,$b);
+			$minlon = $next;
+		  } else {
+			$maxlon = $next;
+		  }
+		  $lonE /= 2;
+		} else {
+		  // odd char, even bit OR even char, odd bit...a lat
+		  $next = ($minlat+$maxlat)/2;
+		  if($point->y()>$next) {
+			$chr |= pow(2,$b);
+			$minlat = $next;
+		  } else {
+			$maxlat = $next;
+		  }
+		  $latE /= 2;
+		}
+	  }
+	  $hash .= $this->table[$chr];
+	  $i++;
+	  $error = min($latE,$lonE);
+	}
+	return $hash;
   }
 
   /**
@@ -128,39 +128,39 @@ 
    * @see https://github.com/asonge/php-geohash/issues/1
    */
   private function decode($hash){
-    $ll = array();
-    $minlat =  -90;
-    $maxlat =   90;
-    $minlon = -180;
-    $maxlon =  180;
-    $latE   =   90;
-    $lonE   =  180;
-    for($i=0,$c=strlen($hash);$i<$c;$i++) {
-      $v = strpos($this->table,$hash[$i]);
-      if(1&$i) {
-        if(16&$v)$minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(8&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(4&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(2&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(1&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        $latE /= 8;
-        $lonE /= 4;
-      } else {
-        if(16&$v)$minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(8&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(4&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(2&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(1&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        $latE /= 4;
-        $lonE /= 8;
-      }
-    }
-    $ll['minlat'] = $minlat;
-    $ll['minlon'] = $minlon;
-    $ll['maxlat'] = $maxlat;
-    $ll['maxlon'] = $maxlon;
-    $ll['medlat'] = round(($minlat+$maxlat)/2, max(1, -round(log10($latE)))-1);
-    $ll['medlon'] = round(($minlon+$maxlon)/2, max(1, -round(log10($lonE)))-1);
-    return $ll;
+	$ll = array();
+	$minlat =  -90;
+	$maxlat =   90;
+	$minlon = -180;
+	$maxlon =  180;
+	$latE   =   90;
+	$lonE   =  180;
+	for($i=0,$c=strlen($hash);$i<$c;$i++) {
+	  $v = strpos($this->table,$hash[$i]);
+	  if(1&$i) {
+		if(16&$v)$minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+		if(8&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+		if(4&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+		if(2&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+		if(1&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+		$latE /= 8;
+		$lonE /= 4;
+	  } else {
+		if(16&$v)$minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+		if(8&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+		if(4&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+		if(2&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+		if(1&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+		$latE /= 4;
+		$lonE /= 8;
+	  }
+	}
+	$ll['minlat'] = $minlat;
+	$ll['minlon'] = $minlon;
+	$ll['maxlat'] = $maxlat;
+	$ll['maxlon'] = $maxlon;
+	$ll['medlat'] = round(($minlat+$maxlat)/2, max(1, -round(log10($latE)))-1);
+	$ll['medlon'] = round(($minlon+$maxlon)/2, max(1, -round(log10($lonE)))-1);
+	return $ll;
   }
 }

Spacing +44 added lines, -44 removed lines

@@ -6,7 +6,7 @@ 
  * @see http://en.wikipedia.org/wiki/Geohash
  *
  */
-class GeoHash extends GeoAdapter{
+class GeoHash extends GeoAdapter {
   private $table = "0123456789bcdefghjkmnpqrstuvwxyz";
 
   /**
@@ -39,10 +39,10 @@ 
    * @param Point $geometry
    * @see GeoAdapter::write()
    */
-  public function write(Geometry $geometry, $precision = NULL){
+  public function write(Geometry $geometry, $precision = NULL) {
     if ($geometry->isEmpty()) return '';
 
-    if($geometry->geometryType() === 'Point'){
+    if ($geometry->geometryType() === 'Point') {
       return $this->encodePoint($geometry, $precision);
     }
     else {
@@ -74,30 +74,30 @@ 
    * @author algorithm based on code by Alexander Songe <a@songe.me>
    * @see https://github.com/asonge/php-geohash/issues/1
    */
-  private function encodePoint($point, $precision = NULL){
+  private function encodePoint($point, $precision = NULL) {
     if ($precision === NULL) {
-      $lap = strlen($point->y())-strpos($point->y(),".");
-      $lop = strlen($point->x())-strpos($point->x(),".");
-      $precision = pow(10,-max($lap-1,$lop-1,0))/2;
+      $lap = strlen($point->y()) - strpos($point->y(), ".");
+      $lop = strlen($point->x()) - strpos($point->x(), ".");
+      $precision = pow(10, -max($lap - 1, $lop - 1, 0))/2;
     }
 
-    $minlat =  -90;
-    $maxlat =   90;
+    $minlat = -90;
+    $maxlat = 90;
     $minlon = -180;
-    $maxlon =  180;
-    $latE   =   90;
-    $lonE   =  180;
+    $maxlon = 180;
+    $latE   = 90;
+    $lonE   = 180;
     $i = 0;
     $error = 180;
-    $hash='';
-    while($error>=$precision) {
+    $hash = '';
+    while ($error >= $precision) {
       $chr = 0;
-      for($b=4;$b>=0;--$b) {
-        if((1&$b) == (1&$i)) {
+      for ($b = 4; $b >= 0; --$b) {
+        if ((1&$b) == (1&$i)) {
           // even char, even bit OR odd char, odd bit...a lon
-          $next = ($minlon+$maxlon)/2;
-          if($point->x()>$next) {
-            $chr |= pow(2,$b);
+          $next = ($minlon + $maxlon)/2;
+          if ($point->x() > $next) {
+            $chr |= pow(2, $b);
             $minlon = $next;
           } else {
             $maxlon = $next;
@@ -105,9 +105,9 @@ 
           $lonE /= 2;
         } else {
           // odd char, even bit OR even char, odd bit...a lat
-          $next = ($minlat+$maxlat)/2;
-          if($point->y()>$next) {
-            $chr |= pow(2,$b);
+          $next = ($minlat + $maxlat)/2;
+          if ($point->y() > $next) {
+            $chr |= pow(2, $b);
             $minlat = $next;
           } else {
             $maxlat = $next;
@@ -117,7 +117,7 @@ 
       }
       $hash .= $this->table[$chr];
       $i++;
-      $error = min($latE,$lonE);
+      $error = min($latE, $lonE);
     }
     return $hash;
   }
@@ -127,30 +127,30 @@ 
    * @author algorithm based on code by Alexander Songe <a@songe.me>
    * @see https://github.com/asonge/php-geohash/issues/1
    */
-  private function decode($hash){
+  private function decode($hash) {
     $ll = array();
-    $minlat =  -90;
-    $maxlat =   90;
+    $minlat = -90;
+    $maxlat = 90;
     $minlon = -180;
-    $maxlon =  180;
-    $latE   =   90;
-    $lonE   =  180;
-    for($i=0,$c=strlen($hash);$i<$c;$i++) {
-      $v = strpos($this->table,$hash[$i]);
-      if(1&$i) {
-        if(16&$v)$minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(8&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(4&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(2&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(1&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+    $maxlon = 180;
+    $latE   = 90;
+    $lonE   = 180;
+    for ($i = 0, $c = strlen($hash); $i < $c; $i++) {
+      $v = strpos($this->table, $hash[$i]);
+      if (1&$i) {
+        if (16&$v)$minlat = ($minlat + $maxlat)/2; else $maxlat = ($minlat + $maxlat)/2;
+        if (8&$v) $minlon = ($minlon + $maxlon)/2; else $maxlon = ($minlon + $maxlon)/2;
+        if (4&$v) $minlat = ($minlat + $maxlat)/2; else $maxlat = ($minlat + $maxlat)/2;
+        if (2&$v) $minlon = ($minlon + $maxlon)/2; else $maxlon = ($minlon + $maxlon)/2;
+        if (1&$v) $minlat = ($minlat + $maxlat)/2; else $maxlat = ($minlat + $maxlat)/2;
         $latE /= 8;
         $lonE /= 4;
       } else {
-        if(16&$v)$minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(8&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(4&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(2&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(1&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+        if (16&$v)$minlon = ($minlon + $maxlon)/2; else $maxlon = ($minlon + $maxlon)/2;
+        if (8&$v) $minlat = ($minlat + $maxlat)/2; else $maxlat = ($minlat + $maxlat)/2;
+        if (4&$v) $minlon = ($minlon + $maxlon)/2; else $maxlon = ($minlon + $maxlon)/2;
+        if (2&$v) $minlat = ($minlat + $maxlat)/2; else $maxlat = ($minlat + $maxlat)/2;
+        if (1&$v) $minlon = ($minlon + $maxlon)/2; else $maxlon = ($minlon + $maxlon)/2;
         $latE /= 4;
         $lonE /= 8;
       }
@@ -159,8 +159,8 @@ 
     $ll['minlon'] = $minlon;
     $ll['maxlat'] = $maxlat;
     $ll['maxlon'] = $maxlon;
-    $ll['medlat'] = round(($minlat+$maxlat)/2, max(1, -round(log10($latE)))-1);
-    $ll['medlon'] = round(($minlon+$maxlon)/2, max(1, -round(log10($lonE)))-1);
+    $ll['medlat'] = round(($minlat + $maxlat)/2, max(1, -round(log10($latE))) - 1);
+    $ll['medlon'] = round(($minlon + $maxlon)/2, max(1, -round(log10($lonE))) - 1);
     return $ll;
   }
 }

Braces +55 added lines, -15 removed lines

@@ -19,8 +19,7 @@ 
     $ll = $this->decode($hash);
     if (!$as_grid) {
       return new Point($ll['medlon'], $ll['medlat']);
-    }
-    else {
+    } else {
       return new Polygon(array(
         new LineString(array(
           new Point($ll['minlon'], $ll['maxlat']),
@@ -40,12 +39,13 @@ 
    * @see GeoAdapter::write()
    */
   public function write(Geometry $geometry, $precision = NULL){
-    if ($geometry->isEmpty()) return '';
+    if ($geometry->isEmpty()) {
+    	return '';
+    }
 
     if($geometry->geometryType() === 'Point'){
       return $this->encodePoint($geometry, $precision);
-    }
-    else {
+    } else {
       // The geohash is the hash grid ID that fits the envelope
       $envelope = $geometry->envelope();
       $geohashes = array();
@@ -138,19 +138,59 @@ 
     for($i=0,$c=strlen($hash);$i<$c;$i++) {
       $v = strpos($this->table,$hash[$i]);
       if(1&$i) {
-        if(16&$v)$minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(8&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(4&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(2&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(1&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
+        if(16&$v) {
+        	$minlat = ($minlat+$maxlat)/2;
+        } else {
+        	$maxlat = ($minlat+$maxlat)/2;
+        }
+        if(8&$v) {
+        	$minlon = ($minlon+$maxlon)/2;
+        } else {
+        	$maxlon = ($minlon+$maxlon)/2;
+        }
+        if(4&$v) {
+        	$minlat = ($minlat+$maxlat)/2;
+        } else {
+        	$maxlat = ($minlat+$maxlat)/2;
+        }
+        if(2&$v) {
+        	$minlon = ($minlon+$maxlon)/2;
+        } else {
+        	$maxlon = ($minlon+$maxlon)/2;
+        }
+        if(1&$v) {
+        	$minlat = ($minlat+$maxlat)/2;
+        } else {
+        	$maxlat = ($minlat+$maxlat)/2;
+        }
         $latE /= 8;
         $lonE /= 4;
       } else {
-        if(16&$v)$minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(8&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(4&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
-        if(2&$v) $minlat = ($minlat+$maxlat)/2; else $maxlat = ($minlat+$maxlat)/2;
-        if(1&$v) $minlon = ($minlon+$maxlon)/2; else $maxlon = ($minlon+$maxlon)/2;
+        if(16&$v) {
+        	$minlon = ($minlon+$maxlon)/2;
+        } else {
+        	$maxlon = ($minlon+$maxlon)/2;
+        }
+        if(8&$v) {
+        	$minlat = ($minlat+$maxlat)/2;
+        } else {
+        	$maxlat = ($minlat+$maxlat)/2;
+        }
+        if(4&$v) {
+        	$minlon = ($minlon+$maxlon)/2;
+        } else {
+        	$maxlon = ($minlon+$maxlon)/2;
+        }
+        if(2&$v) {
+        	$minlat = ($minlat+$maxlat)/2;
+        } else {
+        	$maxlat = ($minlat+$maxlat)/2;
+        }
+        if(1&$v) {
+        	$minlon = ($minlon+$maxlon)/2;
+        } else {
+        	$maxlon = ($minlon+$maxlon)/2;
+        }
         $latE /= 4;
         $lonE /= 8;
       }

require/libs/geoPHP/lib/geometry/GeometryCollection.class.php

Indentation +8 added lines, -8 removed lines

@@ -12,14 +12,14 @@
   // MultiPoint or a LineString, since they share the same structure (collection
   // of points). So we need to call out the type explicitly. 
   public function asArray() {
-    $array = array();
-    foreach ($this->components as $component) {
-      $array[] = array(
-        'type' => $component->geometryType(),
-        'components' => $component->asArray(),
-      );
-    }
-    return $array;
+	$array = array();
+	foreach ($this->components as $component) {
+	  $array[] = array(
+		'type' => $component->geometryType(),
+		'components' => $component->asArray(),
+	  );
+	}
+	return $array;
   }
   
   // Not valid for this geomettry

require/libs/geoPHP/lib/geometry/Point.class.php

Indentation +50 added lines, -50 removed lines

@@ -18,31 +18,31 @@ 
    * @param numeric $z The z coordinate (or altitude) - optional
    */
   public function __construct($x, $y, $z = NULL) {
-    // Basic validation on x and y
-    if (!is_numeric($x) || !is_numeric($y)) {
-      throw new Exception("Cannot construct Point. x and y should be numeric");
-    }
-
-    // Check to see if this is a 3D point
-    if ($z !== NULL) {
-      if (!is_numeric($z)) {
-       throw new Exception("Cannot construct Point. z should be numeric");
-      }
-      $this->dimention = 3;
-    }
-
-    // Convert to floatval in case they are passed in as a string or integer etc.
-    $x = floatval($x);
-    $y = floatval($y);
-    $z = floatval($z);
-
-    // Add poitional elements
-    if ($this->dimention == 2) {
-      $this->coords = array($x, $y);
-    }
-    if ($this->dimention == 3) {
-      $this->coords = array($x, $y, $z);
-    }
+	// Basic validation on x and y
+	if (!is_numeric($x) || !is_numeric($y)) {
+	  throw new Exception("Cannot construct Point. x and y should be numeric");
+	}
+
+	// Check to see if this is a 3D point
+	if ($z !== NULL) {
+	  if (!is_numeric($z)) {
+	   throw new Exception("Cannot construct Point. z should be numeric");
+	  }
+	  $this->dimention = 3;
+	}
+
+	// Convert to floatval in case they are passed in as a string or integer etc.
+	$x = floatval($x);
+	$y = floatval($y);
+	$z = floatval($z);
+
+	// Add poitional elements
+	if ($this->dimention == 2) {
+	  $this->coords = array($x, $y);
+	}
+	if ($this->dimention == 3) {
+	  $this->coords = array($x, $y, $z);
+	}
   }
 
   /**
@@ -51,7 +51,7 @@ 
    * @return float The X coordinate
    */
   public function x() {
-    return $this->coords[0];
+	return $this->coords[0];
   }
 
   /**
@@ -60,7 +60,7 @@ 
    * @return float The Y coordinate
    */
   public function y() {
-    return $this->coords[1];
+	return $this->coords[1];
   }
 
   /**
@@ -69,73 +69,73 @@ 
    * @return float The Z coordinate or NULL is not a 3D point
    */
   public function z() {
-    if ($this->dimention == 3) {
-      return $this->coords[2];
-    }
-    else return NULL;
+	if ($this->dimention == 3) {
+	  return $this->coords[2];
+	}
+	else return NULL;
   }
 
   // A point's centroid is itself
   public function centroid() {
-    return $this;
+	return $this;
   }
 
   public function getBBox() {
-    return array(
-      'maxy' => $this->getY(),
-      'miny' => $this->getY(),
-      'maxx' => $this->getX(),
-      'minx' => $this->getX(),
-    );
+	return array(
+	  'maxy' => $this->getY(),
+	  'miny' => $this->getY(),
+	  'maxx' => $this->getX(),
+	  'minx' => $this->getX(),
+	);
   }
 
   public function asArray($assoc = FALSE) {
-    return $this->coords;
+	return $this->coords;
   }
 
   public function area() {
-    return 0;
+	return 0;
   }
 
   public function length() {
-    return 0;
+	return 0;
   }
 
   public function greatCircleLength() {
-    return 0;
+	return 0;
   }
 
   public function haversineLength() {
-    return 0;
+	return 0;
   }
 
   // The boundary of a point is itself
   public function boundary() {
-    return $this;
+	return $this;
   }
 
   public function dimension() {
-    return 0;
+	return 0;
   }
 
   public function isEmpty() {
-    return FALSE;
+	return FALSE;
   }
 
   public function numPoints() {
-    return 1;
+	return 1;
   }
 
   public function getPoints() {
-    return array($this);
+	return array($this);
   }
 
   public function equals($geometry) {
-    return ($this->x() == $geometry->x() && $this->y() == $geometry->y());
+	return ($this->x() == $geometry->x() && $this->y() == $geometry->y());
   }
 
   public function isSimple() {
-    return TRUE;
+	return TRUE;
   }
 
   // Not valid for this geometry type

Spacing +11 added lines, -11 removed lines

@@ -139,17 +139,17 @@
   }
 
   // Not valid for this geometry type
-  public function numGeometries()    { return NULL; }
-  public function geometryN($n)      { return NULL; }
-  public function startPoint()       { return NULL; }
-  public function endPoint()         { return NULL; }
-  public function isRing()           { return NULL; }
-  public function isClosed()         { return NULL; }
-  public function pointN($n)         { return NULL; }
-  public function exteriorRing()     { return NULL; }
+  public function numGeometries() { return NULL; }
+  public function geometryN($n) { return NULL; }
+  public function startPoint() { return NULL; }
+  public function endPoint() { return NULL; }
+  public function isRing() { return NULL; }
+  public function isClosed() { return NULL; }
+  public function pointN($n) { return NULL; }
+  public function exteriorRing() { return NULL; }
   public function numInteriorRings() { return NULL; }
-  public function interiorRingN($n)  { return NULL; }
-  public function pointOnSurface()   { return NULL; }
-  public function explode()          { return NULL; }
+  public function interiorRingN($n) { return NULL; }
+  public function pointOnSurface() { return NULL; }
+  public function explode() { return NULL; }
 }
 

Braces +2 added lines, -1 removed lines

@@ -71,8 +71,9 @@
   public function z() {
     if ($this->dimention == 3) {
       return $this->coords[2];
+    } else {
+    	return NULL;
     }
-    else return NULL;
   }
 
   // A point's centroid is itself

require/libs/geoPHP/lib/geometry/MultiPoint.class.php

Indentation +2 added lines, -2 removed lines

@@ -7,11 +7,11 @@
   protected $geom_type = 'MultiPoint';
   
   public function numPoints() {
-    return $this->numGeometries();
+	return $this->numGeometries();
   }
   
   public function isSimple() {
-    return TRUE;
+	return TRUE;
   }
   
   // Not valid for this geometry type

require/libs/geoPHP/lib/geometry/MultiLineString.class.php

Indentation +6 added lines, -6 removed lines

@@ -8,12 +8,12 @@
 
   // MultiLineString is closed if all it's components are closed
   public function isClosed() {
-    foreach ($this->components as $line) {
-      if (!$line->isClosed()) {
-        return FALSE;
-      }
-    }
-    return TRUE;
+	foreach ($this->components as $line) {
+	  if (!$line->isClosed()) {
+		return FALSE;
+	  }
+	}
+	return TRUE;
   }
 
 }

require/libs/geoPHP/lib/geometry/Collection.class.php

Indentation +188 added lines, -188 removed lines

@@ -18,17 +18,17 @@ 
    * @param array $components array of geometries
    */
   public function __construct($components = array()) {
-    if (!is_array($components)) {
-      throw new Exception("Component geometries must be passed as an array");
-    }
-    foreach ($components as $component) {
-      if ($component instanceof Geometry) {
-        $this->components[] = $component;
-      }
-      else {
-        throw new Exception("Cannot create a collection with non-geometries");
-      }
-    }
+	if (!is_array($components)) {
+	  throw new Exception("Component geometries must be passed as an array");
+	}
+	foreach ($components as $component) {
+	  if ($component instanceof Geometry) {
+		$this->components[] = $component;
+	  }
+	  else {
+		throw new Exception("Cannot create a collection with non-geometries");
+	  }
+	}
   }
 
   /**
@@ -37,244 +37,244 @@ 
    * @return array
    */
   public function getComponents() {
-    return $this->components;
+	return $this->components;
   }
 
   public function centroid() {
-    if ($this->isEmpty()) return NULL;
+	if ($this->isEmpty()) return NULL;
 
-    if ($this->geos()) {
-      $geos_centroid = $this->geos()->centroid();
-      if ($geos_centroid->typeName() == 'Point') {
-        return geoPHP::geosToGeometry($this->geos()->centroid());
-      }
-    }
+	if ($this->geos()) {
+	  $geos_centroid = $this->geos()->centroid();
+	  if ($geos_centroid->typeName() == 'Point') {
+		return geoPHP::geosToGeometry($this->geos()->centroid());
+	  }
+	}
 
-    // As a rough estimate, we say that the centroid of a colletion is the centroid of it's envelope
-    // @@TODO: Make this the centroid of the convexHull
-    // Note: Outside of polygons, geometryCollections and the trivial case of points, there is no standard on what a "centroid" is
-    $centroid = $this->envelope()->centroid();
+	// As a rough estimate, we say that the centroid of a colletion is the centroid of it's envelope
+	// @@TODO: Make this the centroid of the convexHull
+	// Note: Outside of polygons, geometryCollections and the trivial case of points, there is no standard on what a "centroid" is
+	$centroid = $this->envelope()->centroid();
 
-    return $centroid;
+	return $centroid;
   }
 
   public function getBBox() {
-    if ($this->isEmpty()) return NULL;
-
-    if ($this->geos()) {
-      $envelope = $this->geos()->envelope();
-      if ($envelope->typeName() == 'Point') {
-        return geoPHP::geosToGeometry($envelope)->getBBOX();
-      }
-
-      $geos_ring = $envelope->exteriorRing();
-      return array(
-        'maxy' => $geos_ring->pointN(3)->getY(),
-        'miny' => $geos_ring->pointN(1)->getY(),
-        'maxx' => $geos_ring->pointN(1)->getX(),
-        'minx' => $geos_ring->pointN(3)->getX(),
-      );
-    }
-
-    // Go through each component and get the max and min x and y
-    $i = 0;
-    foreach ($this->components as $component) {
-      $component_bbox = $component->getBBox();
-
-      // On the first run through, set the bbox to the component bbox
-      if ($i == 0) {
-        $maxx = $component_bbox['maxx'];
-        $maxy = $component_bbox['maxy'];
-        $minx = $component_bbox['minx'];
-        $miny = $component_bbox['miny'];
-      }
-
-      // Do a check and replace on each boundary, slowly growing the bbox
-      $maxx = $component_bbox['maxx'] > $maxx ? $component_bbox['maxx'] : $maxx;
-      $maxy = $component_bbox['maxy'] > $maxy ? $component_bbox['maxy'] : $maxy;
-      $minx = $component_bbox['minx'] < $minx ? $component_bbox['minx'] : $minx;
-      $miny = $component_bbox['miny'] < $miny ? $component_bbox['miny'] : $miny;
-      $i++;
-    }
-
-    return array(
-      'maxy' => $maxy,
-      'miny' => $miny,
-      'maxx' => $maxx,
-      'minx' => $minx,
-    );
+	if ($this->isEmpty()) return NULL;
+
+	if ($this->geos()) {
+	  $envelope = $this->geos()->envelope();
+	  if ($envelope->typeName() == 'Point') {
+		return geoPHP::geosToGeometry($envelope)->getBBOX();
+	  }
+
+	  $geos_ring = $envelope->exteriorRing();
+	  return array(
+		'maxy' => $geos_ring->pointN(3)->getY(),
+		'miny' => $geos_ring->pointN(1)->getY(),
+		'maxx' => $geos_ring->pointN(1)->getX(),
+		'minx' => $geos_ring->pointN(3)->getX(),
+	  );
+	}
+
+	// Go through each component and get the max and min x and y
+	$i = 0;
+	foreach ($this->components as $component) {
+	  $component_bbox = $component->getBBox();
+
+	  // On the first run through, set the bbox to the component bbox
+	  if ($i == 0) {
+		$maxx = $component_bbox['maxx'];
+		$maxy = $component_bbox['maxy'];
+		$minx = $component_bbox['minx'];
+		$miny = $component_bbox['miny'];
+	  }
+
+	  // Do a check and replace on each boundary, slowly growing the bbox
+	  $maxx = $component_bbox['maxx'] > $maxx ? $component_bbox['maxx'] : $maxx;
+	  $maxy = $component_bbox['maxy'] > $maxy ? $component_bbox['maxy'] : $maxy;
+	  $minx = $component_bbox['minx'] < $minx ? $component_bbox['minx'] : $minx;
+	  $miny = $component_bbox['miny'] < $miny ? $component_bbox['miny'] : $miny;
+	  $i++;
+	}
+
+	return array(
+	  'maxy' => $maxy,
+	  'miny' => $miny,
+	  'maxx' => $maxx,
+	  'minx' => $minx,
+	);
   }
 
   public function asArray() {
-    $array = array();
-    foreach ($this->components as $component) {
-      $array[] = $component->asArray();
-    }
-    return $array;
+	$array = array();
+	foreach ($this->components as $component) {
+	  $array[] = $component->asArray();
+	}
+	return $array;
   }
 
   public function area() {
-    if ($this->geos()) {
-      return $this->geos()->area();
-    }
-
-    $area = 0;
-    foreach ($this->components as $component) {
-      $area += $component->area();
-    }
-    return $area;
+	if ($this->geos()) {
+	  return $this->geos()->area();
+	}
+
+	$area = 0;
+	foreach ($this->components as $component) {
+	  $area += $component->area();
+	}
+	return $area;
   }
 
   // By default, the boundary of a collection is the boundary of it's components
   public function boundary() {
-    if ($this->isEmpty()) return new LineString();
+	if ($this->isEmpty()) return new LineString();
 
-    if ($this->geos()) {
-      return $this->geos()->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);
+	$components_boundaries = array();
+	foreach ($this->components as $component) {
+	  $components_boundaries[] = $component->boundary();
+	}
+	return geoPHP::geometryReduce($components_boundaries);
   }
 
   public function numGeometries() {
-    return count($this->components);
+	return count($this->components);
   }
 
   // Note that the standard is 1 based indexing
   public function geometryN($n) {
-    $n = intval($n);
-    if (array_key_exists($n-1, $this->components)) {
-      return $this->components[$n-1];
-    }
-    else {
-      return NULL;
-    }
+	$n = intval($n);
+	if (array_key_exists($n-1, $this->components)) {
+	  return $this->components[$n-1];
+	}
+	else {
+	  return NULL;
+	}
   }
 
   public function length() {
-    $length = 0;
-    foreach ($this->components as $delta => $component) {
-      $length += $component->length();
-    }
-    return $length;
+	$length = 0;
+	foreach ($this->components as $delta => $component) {
+	  $length += $component->length();
+	}
+	return $length;
   }
 
   public function greatCircleLength($radius = 6378137) {
-    $length = 0;
-    foreach ($this->components as $component) {
-      $length += $component->greatCircleLength($radius);
-    }
-    return $length;
+	$length = 0;
+	foreach ($this->components as $component) {
+	  $length += $component->greatCircleLength($radius);
+	}
+	return $length;
   }
 
   public function haversineLength() {
-    $length = 0;
-    foreach ($this->components as $component) {
-      $length += $component->haversineLength();
-    }
-    return $length;
+	$length = 0;
+	foreach ($this->components as $component) {
+	  $length += $component->haversineLength();
+	}
+	return $length;
   }
 
   public function dimension() {
-    $dimension = 0;
-    foreach ($this->components as $component) {
-      if ($component->dimension() > $dimension) {
-        $dimension = $component->dimension();
-      }
-    }
-    return $dimension;
+	$dimension = 0;
+	foreach ($this->components as $component) {
+	  if ($component->dimension() > $dimension) {
+		$dimension = $component->dimension();
+	  }
+	}
+	return $dimension;
   }
 
   // A collection is empty if it has no components OR all it's components are empty
   public function isEmpty() {
-    if (!count($this->components)) {
-      return TRUE;
-    }
-    else {
-      foreach ($this->components as $component) {
-        if (!$component->isEmpty()) return FALSE;
-      }
-      return TRUE;
-    }
+	if (!count($this->components)) {
+	  return TRUE;
+	}
+	else {
+	  foreach ($this->components as $component) {
+		if (!$component->isEmpty()) return FALSE;
+	  }
+	  return TRUE;
+	}
   }
 
   public function numPoints() {
-    $num = 0;
-    foreach ($this->components as $component) {
-      $num += $component->numPoints();
-    }
-    return $num;
+	$num = 0;
+	foreach ($this->components as $component) {
+	  $num += $component->numPoints();
+	}
+	return $num;
   }
 
   public function getPoints() {
-    $points = array();
-    foreach ($this->components as $component) {
-      $points = array_merge($points, $component->getPoints());
-    }
-    return $points;
+	$points = array();
+	foreach ($this->components as $component) {
+	  $points = array_merge($points, $component->getPoints());
+	}
+	return $points;
   }
 
   public function equals($geometry) {
-    if ($this->geos()) {
-      return $this->geos()->equals($geometry->geos());
-    }
-
-    // To test for equality we check to make sure that there is a matching point
-    // in the other geometry for every point in this geometry.
-    // This is slightly more strict than the standard, which
-    // uses Within(A,B) = true and Within(B,A) = true
-    // @@TODO: Eventually we could fix this by using some sort of simplification
-    // method that strips redundant vertices (that are all in a row)
-
-    $this_points = $this->getPoints();
-    $other_points = $geometry->getPoints();
-
-    // First do a check to make sure they have the same number of vertices
-    if (count($this_points) != count($other_points)) {
-      return FALSE;
-    }
-
-    foreach ($this_points as $point) {
-      $found_match = FALSE;
-      foreach ($other_points as $key => $test_point) {
-        if ($point->equals($test_point)) {
-          $found_match = TRUE;
-          unset($other_points[$key]);
-          break;
-        }
-      }
-      if (!$found_match) {
-        return FALSE;
-      }
-    }
-
-    // All points match, return TRUE
-    return TRUE;
+	if ($this->geos()) {
+	  return $this->geos()->equals($geometry->geos());
+	}
+
+	// To test for equality we check to make sure that there is a matching point
+	// in the other geometry for every point in this geometry.
+	// This is slightly more strict than the standard, which
+	// uses Within(A,B) = true and Within(B,A) = true
+	// @@TODO: Eventually we could fix this by using some sort of simplification
+	// method that strips redundant vertices (that are all in a row)
+
+	$this_points = $this->getPoints();
+	$other_points = $geometry->getPoints();
+
+	// First do a check to make sure they have the same number of vertices
+	if (count($this_points) != count($other_points)) {
+	  return FALSE;
+	}
+
+	foreach ($this_points as $point) {
+	  $found_match = FALSE;
+	  foreach ($other_points as $key => $test_point) {
+		if ($point->equals($test_point)) {
+		  $found_match = TRUE;
+		  unset($other_points[$key]);
+		  break;
+		}
+	  }
+	  if (!$found_match) {
+		return FALSE;
+	  }
+	}
+
+	// All points match, return TRUE
+	return TRUE;
   }
 
   public function isSimple() {
-    if ($this->geos()) {
-      return $this->geos()->isSimple();
-    }
+	if ($this->geos()) {
+	  return $this->geos()->isSimple();
+	}
 
-    // A collection is simple if all it's components are simple
-    foreach ($this->components as $component) {
-      if (!$component->isSimple()) return FALSE;
-    }
+	// A collection is simple if all it's components are simple
+	foreach ($this->components as $component) {
+	  if (!$component->isSimple()) return FALSE;
+	}
 
-    return TRUE;
+	return TRUE;
   }
 
   public function explode() {
-    $parts = array();
-    foreach ($this->components as $component) {
-      $parts = array_merge($parts, $component->explode());
-    }
-    return $parts;
+	$parts = array();
+	foreach ($this->components as $component) {
+	  $parts = array_merge($parts, $component->explode());
+	}
+	return $parts;
   }
 
   // Not valid for this geometry type

Spacing +12 added lines, -12 removed lines

@@ -147,8 +147,8 @@ 
   // Note that the standard is 1 based indexing
   public function geometryN($n) {
     $n = intval($n);
-    if (array_key_exists($n-1, $this->components)) {
-      return $this->components[$n-1];
+    if (array_key_exists($n - 1, $this->components)) {
+      return $this->components[$n - 1];
     }
     else {
       return NULL;
@@ -279,16 +279,16 @@ 
 
   // Not valid for this geometry type
   // --------------------------------
-  public function x()                { return NULL; }
-  public function y()                { return NULL; }
-  public function startPoint()       { return NULL; }
-  public function endPoint()         { return NULL; }
-  public function isRing()           { return NULL; }
-  public function isClosed()         { return NULL; }
-  public function pointN($n)         { return NULL; }
-  public function exteriorRing()     { return NULL; }
+  public function x() { return NULL; }
+  public function y() { return NULL; }
+  public function startPoint() { return NULL; }
+  public function endPoint() { return NULL; }
+  public function isRing() { return NULL; }
+  public function isClosed() { return NULL; }
+  public function pointN($n) { return NULL; }
+  public function exteriorRing() { return NULL; }
   public function numInteriorRings() { return NULL; }
-  public function interiorRingN($n)  { return NULL; }
-  public function pointOnSurface()   { return NULL; }
+  public function interiorRingN($n) { return NULL; }
+  public function pointOnSurface() { return NULL; }
 }
 

Braces +18 added lines, -11 removed lines

@@ -24,8 +24,7 @@ 
     foreach ($components as $component) {
       if ($component instanceof Geometry) {
         $this->components[] = $component;
-      }
-      else {
+      } else {
         throw new Exception("Cannot create a collection with non-geometries");
       }
     }
@@ -41,7 +40,9 @@ 
   }
 
   public function centroid() {
-    if ($this->isEmpty()) return NULL;
+    if ($this->isEmpty()) {
+    	return NULL;
+    }
 
     if ($this->geos()) {
       $geos_centroid = $this->geos()->centroid();
@@ -59,7 +60,9 @@ 
   }
 
   public function getBBox() {
-    if ($this->isEmpty()) return NULL;
+    if ($this->isEmpty()) {
+    	return NULL;
+    }
 
     if ($this->geos()) {
       $envelope = $this->geos()->envelope();
@@ -127,7 +130,9 @@ 
 
   // By default, the boundary of a collection is the boundary of it's components
   public function boundary() {
-    if ($this->isEmpty()) return new LineString();
+    if ($this->isEmpty()) {
+    	return new LineString();
+    }
 
     if ($this->geos()) {
       return $this->geos()->boundary();
@@ -149,8 +154,7 @@ 
     $n = intval($n);
     if (array_key_exists($n-1, $this->components)) {
       return $this->components[$n-1];
-    }
-    else {
+    } else {
       return NULL;
     }
   }
@@ -193,10 +197,11 @@ 
   public function isEmpty() {
     if (!count($this->components)) {
       return TRUE;
-    }
-    else {
+    } else {
       foreach ($this->components as $component) {
-        if (!$component->isEmpty()) return FALSE;
+        if (!$component->isEmpty()) {
+        	return FALSE;
+        }
       }
       return TRUE;
     }
@@ -263,7 +268,9 @@ 
 
     // A collection is simple if all it's components are simple
     foreach ($this->components as $component) {
-      if (!$component->isSimple()) return FALSE;
+      if (!$component->isSimple()) {
+      	return FALSE;
+      }
     }
 
     return TRUE;

require/libs/geoPHP/lib/geometry/LineString.class.php

Indentation +116 added lines, -116 removed lines

@@ -19,173 +19,173 @@
       throw new Exception("Cannot construct a LineString with a single point");
     }
 */
-    // Call the Collection constructor to build the LineString
-    parent::__construct($points);
+	// Call the Collection constructor to build the LineString
+	parent::__construct($points);
   }
 
   // The boundary of a linestring is itself
   public function boundary() {
-    return $this;
+	return $this;
   }
 
   public function startPoint() {
-    return $this->pointN(1);
+	return $this->pointN(1);
   }
 
   public function endPoint() {
-    $last_n = $this->numPoints();
-    return $this->pointN($last_n);
+	$last_n = $this->numPoints();
+	return $this->pointN($last_n);
   }
 
   public function isClosed() {
-    return ($this->startPoint()->equals($this->endPoint()));
+	return ($this->startPoint()->equals($this->endPoint()));
   }
 
   public function isRing() {
-    return ($this->isClosed() && $this->isSimple());
+	return ($this->isClosed() && $this->isSimple());
   }
 
   public function numPoints() {
-    return $this->numGeometries();
+	return $this->numGeometries();
   }
 
   public function pointN($n) {
-    return $this->geometryN($n);
+	return $this->geometryN($n);
   }
 
   public function dimension() {
-    if ($this->isEmpty()) return 0;
-    return 1;
+	if ($this->isEmpty()) return 0;
+	return 1;
   }
 
   public function area() {
-    return 0;
+	return 0;
   }
 
   public function length() {
-    if ($this->geos()) {
-      return $this->geos()->length();
-    }
-    $length = 0;
-    foreach ($this->getPoints() as $delta => $point) {
-      $previous_point = $this->geometryN($delta);
-      if ($previous_point) {
-        $length += sqrt(pow(($previous_point->getX() - $point->getX()), 2) + pow(($previous_point->getY()- $point->getY()), 2));
-      }
-    }
-    return $length;
+	if ($this->geos()) {
+	  return $this->geos()->length();
+	}
+	$length = 0;
+	foreach ($this->getPoints() as $delta => $point) {
+	  $previous_point = $this->geometryN($delta);
+	  if ($previous_point) {
+		$length += sqrt(pow(($previous_point->getX() - $point->getX()), 2) + pow(($previous_point->getY()- $point->getY()), 2));
+	  }
+	}
+	return $length;
   }
 
   public function greatCircleLength($radius = 6378137) {
-    $length = 0;
-    $points = $this->getPoints();
-    for($i=0; $i<$this->numPoints()-1; $i++) {
-      $point = $points[$i];
-      $next_point = $points[$i+1];
-      if (!is_object($next_point)) {continue;}
-      // Great circle method
-      $lat1 = deg2rad($point->getY());
-      $lat2 = deg2rad($next_point->getY());
-      $lon1 = deg2rad($point->getX());
-      $lon2 = deg2rad($next_point->getX());
-      $dlon = $lon2 - $lon1;
-      $length +=
-        $radius *
-          atan2(
-            sqrt(
-              pow(cos($lat2) * sin($dlon), 2) +
-                pow(cos($lat1) * sin($lat2) - sin($lat1) * cos($lat2) * cos($dlon), 2)
-            )
-            ,
-            sin($lat1) * sin($lat2) +
-              cos($lat1) * cos($lat2) * cos($dlon)
-          );
-    }
-    // Returns length in meters.
-    return $length;
+	$length = 0;
+	$points = $this->getPoints();
+	for($i=0; $i<$this->numPoints()-1; $i++) {
+	  $point = $points[$i];
+	  $next_point = $points[$i+1];
+	  if (!is_object($next_point)) {continue;}
+	  // Great circle method
+	  $lat1 = deg2rad($point->getY());
+	  $lat2 = deg2rad($next_point->getY());
+	  $lon1 = deg2rad($point->getX());
+	  $lon2 = deg2rad($next_point->getX());
+	  $dlon = $lon2 - $lon1;
+	  $length +=
+		$radius *
+		  atan2(
+			sqrt(
+			  pow(cos($lat2) * sin($dlon), 2) +
+				pow(cos($lat1) * sin($lat2) - sin($lat1) * cos($lat2) * cos($dlon), 2)
+			)
+			,
+			sin($lat1) * sin($lat2) +
+			  cos($lat1) * cos($lat2) * cos($dlon)
+		  );
+	}
+	// Returns length in meters.
+	return $length;
   }
 
   public function haversineLength() {
-    $degrees = 0;
-    $points = $this->getPoints();
-    for($i=0; $i<$this->numPoints()-1; $i++) {
-      $point = $points[$i];
-      $next_point = $points[$i+1];
-      if (!is_object($next_point)) {continue;}
-      $degree = rad2deg(
-        acos(
-          sin(deg2rad($point->getY())) * sin(deg2rad($next_point->getY())) +
-            cos(deg2rad($point->getY())) * cos(deg2rad($next_point->getY())) *
-              cos(deg2rad(abs($point->getX() - $next_point->getX())))
-        )
-      );
-      $degrees += $degree;
-    }
-    // Returns degrees
-    return $degrees;
+	$degrees = 0;
+	$points = $this->getPoints();
+	for($i=0; $i<$this->numPoints()-1; $i++) {
+	  $point = $points[$i];
+	  $next_point = $points[$i+1];
+	  if (!is_object($next_point)) {continue;}
+	  $degree = rad2deg(
+		acos(
+		  sin(deg2rad($point->getY())) * sin(deg2rad($next_point->getY())) +
+			cos(deg2rad($point->getY())) * cos(deg2rad($next_point->getY())) *
+			  cos(deg2rad(abs($point->getX() - $next_point->getX())))
+		)
+	  );
+	  $degrees += $degree;
+	}
+	// Returns degrees
+	return $degrees;
   }
 
   public function explode() {
-    $parts = array();
-    $points = $this->getPoints();
+	$parts = array();
+	$points = $this->getPoints();
 
-    foreach ($points as $i => $point) {
-      if (isset($points[$i+1])) {
-        $parts[] = new LineString(array($point, $points[$i+1]));
-      }
-    }
-    return $parts;
+	foreach ($points as $i => $point) {
+	  if (isset($points[$i+1])) {
+		$parts[] = new LineString(array($point, $points[$i+1]));
+	  }
+	}
+	return $parts;
   }
 
   public function isSimple() {
-    if ($this->geos()) {
-      return $this->geos()->isSimple();
-    }
+	if ($this->geos()) {
+	  return $this->geos()->isSimple();
+	}
 
-    $segments = $this->explode();
+	$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;
+	foreach ($segments as $i => $segment) {
+	  foreach ($segments as $j => $check_segment) {
+		if ($i != $j) {
+		  if ($segment->lineSegmentIntersect($check_segment)) {
+			return FALSE;
+		  }
+		}
+	  }
+	}
+	return TRUE;
   }
 
   // Utility function to check if any line sigments intersect
   // Derived from http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
   public function lineSegmentIntersect($segment) {
-    $p0_x = $this->startPoint()->x();
-    $p0_y = $this->startPoint()->y();
-    $p1_x = $this->endPoint()->x();
-    $p1_y = $this->endPoint()->y();
-    $p2_x = $segment->startPoint()->x();
-    $p2_y = $segment->startPoint()->y();
-    $p3_x = $segment->endPoint()->x();
-    $p3_y = $segment->endPoint()->y();
-
-    $s1_x = $p1_x - $p0_x;     $s1_y = $p1_y - $p0_y;
-    $s2_x = $p3_x - $p2_x;     $s2_y = $p3_y - $p2_y;
-
-    $fps = (-$s2_x * $s1_y) + ($s1_x * $s2_y);
-    $fpt = (-$s2_x * $s1_y) + ($s1_x * $s2_y);
-
-    if ($fps == 0 || $fpt == 0) {
-      return FALSE;
-    }
-
-    $s = (-$s1_y * ($p0_x - $p2_x) + $s1_x * ($p0_y - $p2_y)) / $fps;
-    $t = ( $s2_x * ($p0_y - $p2_y) - $s2_y * ($p0_x - $p2_x)) / $fpt;
-
-    if ($s > 0 && $s < 1 && $t > 0 && $t < 1) {
-      // Collision detected
-      return TRUE;
-    }
-    return FALSE;
+	$p0_x = $this->startPoint()->x();
+	$p0_y = $this->startPoint()->y();
+	$p1_x = $this->endPoint()->x();
+	$p1_y = $this->endPoint()->y();
+	$p2_x = $segment->startPoint()->x();
+	$p2_y = $segment->startPoint()->y();
+	$p3_x = $segment->endPoint()->x();
+	$p3_y = $segment->endPoint()->y();
+
+	$s1_x = $p1_x - $p0_x;     $s1_y = $p1_y - $p0_y;
+	$s2_x = $p3_x - $p2_x;     $s2_y = $p3_y - $p2_y;
+
+	$fps = (-$s2_x * $s1_y) + ($s1_x * $s2_y);
+	$fpt = (-$s2_x * $s1_y) + ($s1_x * $s2_y);
+
+	if ($fps == 0 || $fpt == 0) {
+	  return FALSE;
+	}
+
+	$s = (-$s1_y * ($p0_x - $p2_x) + $s1_x * ($p0_y - $p2_y)) / $fps;
+	$t = ( $s2_x * ($p0_y - $p2_y) - $s2_y * ($p0_x - $p2_x)) / $fpt;
+
+	if ($s > 0 && $s < 1 && $t > 0 && $t < 1) {
+	  // Collision detected
+	  return TRUE;
+	}
+	return FALSE;
   }
 }
 

Spacing +22 added lines, -22 removed lines

@@ -70,7 +70,7 @@ 
     foreach ($this->getPoints() as $delta => $point) {
       $previous_point = $this->geometryN($delta);
       if ($previous_point) {
-        $length += sqrt(pow(($previous_point->getX() - $point->getX()), 2) + pow(($previous_point->getY()- $point->getY()), 2));
+        $length += sqrt(pow(($previous_point->getX() - $point->getX()), 2) + pow(($previous_point->getY() - $point->getY()), 2));
       }
     }
     return $length;
@@ -79,10 +79,10 @@ 
   public function greatCircleLength($radius = 6378137) {
     $length = 0;
     $points = $this->getPoints();
-    for($i=0; $i<$this->numPoints()-1; $i++) {
+    for ($i = 0; $i < $this->numPoints() - 1; $i++) {
       $point = $points[$i];
-      $next_point = $points[$i+1];
-      if (!is_object($next_point)) {continue;}
+      $next_point = $points[$i + 1];
+      if (!is_object($next_point)) {continue; }
       // Great circle method
       $lat1 = deg2rad($point->getY());
       $lat2 = deg2rad($next_point->getY());
@@ -90,15 +90,15 @@ 
       $lon2 = deg2rad($next_point->getX());
       $dlon = $lon2 - $lon1;
       $length +=
-        $radius *
+        $radius*
           atan2(
             sqrt(
-              pow(cos($lat2) * sin($dlon), 2) +
-                pow(cos($lat1) * sin($lat2) - sin($lat1) * cos($lat2) * cos($dlon), 2)
+              pow(cos($lat2)*sin($dlon), 2) +
+                pow(cos($lat1)*sin($lat2) - sin($lat1)*cos($lat2)*cos($dlon), 2)
             )
             ,
-            sin($lat1) * sin($lat2) +
-              cos($lat1) * cos($lat2) * cos($dlon)
+            sin($lat1)*sin($lat2) +
+              cos($lat1)*cos($lat2)*cos($dlon)
           );
     }
     // Returns length in meters.
@@ -108,14 +108,14 @@ 
   public function haversineLength() {
     $degrees = 0;
     $points = $this->getPoints();
-    for($i=0; $i<$this->numPoints()-1; $i++) {
+    for ($i = 0; $i < $this->numPoints() - 1; $i++) {
       $point = $points[$i];
-      $next_point = $points[$i+1];
-      if (!is_object($next_point)) {continue;}
+      $next_point = $points[$i + 1];
+      if (!is_object($next_point)) {continue; }
       $degree = rad2deg(
         acos(
-          sin(deg2rad($point->getY())) * sin(deg2rad($next_point->getY())) +
-            cos(deg2rad($point->getY())) * cos(deg2rad($next_point->getY())) *
+          sin(deg2rad($point->getY()))*sin(deg2rad($next_point->getY())) +
+            cos(deg2rad($point->getY()))*cos(deg2rad($next_point->getY()))*
               cos(deg2rad(abs($point->getX() - $next_point->getX())))
         )
       );
@@ -130,8 +130,8 @@ 
     $points = $this->getPoints();
 
     foreach ($points as $i => $point) {
-      if (isset($points[$i+1])) {
-        $parts[] = new LineString(array($point, $points[$i+1]));
+      if (isset($points[$i + 1])) {
+        $parts[] = new LineString(array($point, $points[$i + 1]));
       }
     }
     return $parts;
@@ -168,18 +168,18 @@ 
     $p3_x = $segment->endPoint()->x();
     $p3_y = $segment->endPoint()->y();
 
-    $s1_x = $p1_x - $p0_x;     $s1_y = $p1_y - $p0_y;
-    $s2_x = $p3_x - $p2_x;     $s2_y = $p3_y - $p2_y;
+    $s1_x = $p1_x - $p0_x; $s1_y = $p1_y - $p0_y;
+    $s2_x = $p3_x - $p2_x; $s2_y = $p3_y - $p2_y;
 
-    $fps = (-$s2_x * $s1_y) + ($s1_x * $s2_y);
-    $fpt = (-$s2_x * $s1_y) + ($s1_x * $s2_y);
+    $fps = (-$s2_x*$s1_y) + ($s1_x*$s2_y);
+    $fpt = (-$s2_x*$s1_y) + ($s1_x*$s2_y);
 
     if ($fps == 0 || $fpt == 0) {
       return FALSE;
     }
 
-    $s = (-$s1_y * ($p0_x - $p2_x) + $s1_x * ($p0_y - $p2_y)) / $fps;
-    $t = ( $s2_x * ($p0_y - $p2_y) - $s2_y * ($p0_x - $p2_x)) / $fpt;
+    $s = (-$s1_y*($p0_x - $p2_x) + $s1_x*($p0_y - $p2_y))/$fps;
+    $t = ($s2_x*($p0_y - $p2_y) - $s2_y*($p0_x - $p2_x))/$fpt;
 
     if ($s > 0 && $s < 1 && $t > 0 && $t < 1) {
       // Collision detected

Braces +3 added lines, -1 removed lines

@@ -54,7 +54,9 @@
   }
 
   public function dimension() {
-    if ($this->isEmpty()) return 0;
+    if ($this->isEmpty()) {
+    	return 0;
+    }
     return 1;
   }
 

require/libs/geoPHP/lib/geometry/Geometry.class.php

Indentation +146 added lines, -146 removed lines

@@ -46,38 +46,38 @@ 
   // Public: Standard -- Common to all geometries
   // --------------------------------------------
   public function SRID() {
-    return $this->srid;
+	return $this->srid;
   }
 
   public function setSRID($srid) {
-    if ($this->geos()) {
-      $this->geos()->setSRID($srid);
-    }
-    $this->srid = $srid;
+	if ($this->geos()) {
+	  $this->geos()->setSRID($srid);
+	}
+	$this->srid = $srid;
   }
 
   public function envelope() {
-    if ($this->isEmpty()) return new Polygon();
+	if ($this->isEmpty()) return new Polygon();
 
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->envelope());
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->envelope());
+	}
 
-    $bbox = $this->getBBox();
-    $points = array (
-      new Point($bbox['maxx'],$bbox['miny']),
-      new Point($bbox['maxx'],$bbox['maxy']),
-      new Point($bbox['minx'],$bbox['maxy']),
-      new Point($bbox['minx'],$bbox['miny']),
-      new Point($bbox['maxx'],$bbox['miny']),
-    );
+	$bbox = $this->getBBox();
+	$points = array (
+	  new Point($bbox['maxx'],$bbox['miny']),
+	  new Point($bbox['maxx'],$bbox['maxy']),
+	  new Point($bbox['minx'],$bbox['maxy']),
+	  new Point($bbox['minx'],$bbox['miny']),
+	  new Point($bbox['maxx'],$bbox['miny']),
+	);
 
-    $outer_boundary = new LineString($points);
-    return new Polygon(array($outer_boundary));
+	$outer_boundary = new LineString($points);
+	return new Polygon(array($outer_boundary));
   }
 
   public function geometryType() {
-    return $this->geom_type;
+	return $this->geom_type;
   }
 
   // Public: Non-Standard -- Common to all geometries
@@ -85,263 +85,263 @@ 
 
   // $this->out($format, $other_args);
   public function out() {
-    $args = func_get_args();
+	$args = func_get_args();
 
-    $format = array_shift($args);
-    $type_map = geoPHP::getAdapterMap();
-    $processor_type = $type_map[$format];
-    $processor = new $processor_type();
+	$format = array_shift($args);
+	$type_map = geoPHP::getAdapterMap();
+	$processor_type = $type_map[$format];
+	$processor = new $processor_type();
 
-    array_unshift($args, $this);
-    $result = call_user_func_array(array($processor, 'write'), $args);
+	array_unshift($args, $this);
+	$result = call_user_func_array(array($processor, 'write'), $args);
 
-    return $result;
+	return $result;
   }
 
 
   // Public: Aliases
   // ---------------
   public function getCentroid() {
-    return $this->centroid();
+	return $this->centroid();
   }
 
   public function getArea() {
-    return $this->area();
+	return $this->area();
   }
 
   public function getX() {
-    return $this->x();
+	return $this->x();
   }
 
   public function getY() {
-    return $this->y();
+	return $this->y();
   }
 
   public function getGeos() {
-    return $this->geos();
+	return $this->geos();
   }
 
   public function getGeomType() {
-    return $this->geometryType();
+	return $this->geometryType();
   }
 
   public function getSRID() {
-    return $this->SRID();
+	return $this->SRID();
   }
 
   public function asText() {
-    return $this->out('wkt');
+	return $this->out('wkt');
   }
 
   public function asBinary() {
-    return $this->out('wkb');
+	return $this->out('wkb');
   }
 
   // Public: GEOS Only Functions
   // ---------------------------
   public function geos() {
-    // If it's already been set, just return it
-    if ($this->geos && geoPHP::geosInstalled()) {
-      return $this->geos;
-    }
-    // It hasn't been set yet, generate it
-    if (geoPHP::geosInstalled()) {
-      $reader = new GEOSWKBReader();
-      $this->geos = $reader->readHEX($this->out('wkb',TRUE));
-    }
-    else {
-      $this->geos = FALSE;
-    }
-    return $this->geos;
+	// If it's already been set, just return it
+	if ($this->geos && geoPHP::geosInstalled()) {
+	  return $this->geos;
+	}
+	// It hasn't been set yet, generate it
+	if (geoPHP::geosInstalled()) {
+	  $reader = new GEOSWKBReader();
+	  $this->geos = $reader->readHEX($this->out('wkb',TRUE));
+	}
+	else {
+	  $this->geos = FALSE;
+	}
+	return $this->geos;
   }
 
   public function setGeos($geos) {
-    $this->geos = $geos;
+	$this->geos = $geos;
   }
 
   public function pointOnSurface() {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->pointOnSurface());
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->pointOnSurface());
+	}
   }
 
   public function equalsExact(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->equalsExact($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->equalsExact($geometry->geos());
+	}
   }
 
   public function relate(Geometry $geometry, $pattern = NULL) {
-    if ($this->geos()) {
-      if ($pattern) {
-        return $this->geos()->relate($geometry->geos(), $pattern);
-      }
-      else {
-        return $this->geos()->relate($geometry->geos());
-      }
-    }
+	if ($this->geos()) {
+	  if ($pattern) {
+		return $this->geos()->relate($geometry->geos(), $pattern);
+	  }
+	  else {
+		return $this->geos()->relate($geometry->geos());
+	  }
+	}
   }
 
   public function checkValidity() {
-    if ($this->geos()) {
-      return $this->geos()->checkValidity();
-    }
+	if ($this->geos()) {
+	  return $this->geos()->checkValidity();
+	}
   }
 
   public function buffer($distance) {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->buffer($distance));
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->buffer($distance));
+	}
   }
 
   public function intersection(Geometry $geometry) {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->intersection($geometry->geos()));
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->intersection($geometry->geos()));
+	}
   }
 
   public function convexHull() {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->convexHull());
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->convexHull());
+	}
   }
 
   public function difference(Geometry $geometry) {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->difference($geometry->geos()));
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->difference($geometry->geos()));
+	}
   }
 
   public function symDifference(Geometry $geometry) {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->symDifference($geometry->geos()));
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->symDifference($geometry->geos()));
+	}
   }
 
   // Can pass in a geometry or an array of geometries
   public function union(Geometry $geometry) {
-    if ($this->geos()) {
-      if (is_array($geometry)) {
-        $geom = $this->geos();
-        foreach ($geometry as $item) {
-          $geom = $geom->union($item->geos());
-        }
-        return geoPHP::geosToGeometry($geom);
-      }
-      else {
-        return geoPHP::geosToGeometry($this->geos()->union($geometry->geos()));
-      }
-    }
+	if ($this->geos()) {
+	  if (is_array($geometry)) {
+		$geom = $this->geos();
+		foreach ($geometry as $item) {
+		  $geom = $geom->union($item->geos());
+		}
+		return geoPHP::geosToGeometry($geom);
+	  }
+	  else {
+		return geoPHP::geosToGeometry($this->geos()->union($geometry->geos()));
+	  }
+	}
   }
 
   public function simplify($tolerance, $preserveTopology = FALSE) {
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->simplify($tolerance, $preserveTopology));
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->simplify($tolerance, $preserveTopology));
+	}
   }
 
   public function disjoint(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->disjoint($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->disjoint($geometry->geos());
+	}
   }
 
   public function touches(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->touches($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->touches($geometry->geos());
+	}
   }
 
   public function intersects(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->intersects($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->intersects($geometry->geos());
+	}
   }
 
   public function crosses(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->crosses($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->crosses($geometry->geos());
+	}
   }
 
   public function within(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->within($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->within($geometry->geos());
+	}
   }
 
   public function contains(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->contains($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->contains($geometry->geos());
+	}
   }
 
   public function overlaps(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->overlaps($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->overlaps($geometry->geos());
+	}
   }
 
   public function covers(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->covers($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->covers($geometry->geos());
+	}
   }
 
   public function coveredBy(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->coveredBy($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->coveredBy($geometry->geos());
+	}
   }
 
   public function distance(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->distance($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->distance($geometry->geos());
+	}
   }
 
   public function hausdorffDistance(Geometry $geometry) {
-    if ($this->geos()) {
-      return $this->geos()->hausdorffDistance($geometry->geos());
-    }
+	if ($this->geos()) {
+	  return $this->geos()->hausdorffDistance($geometry->geos());
+	}
   }
 
   public function project(Geometry $point, $normalized = NULL) {
-    if ($this->geos()) {
-      return $this->geos()->project($point->geos(), $normalized);
-    }
+	if ($this->geos()) {
+	  return $this->geos()->project($point->geos(), $normalized);
+	}
   }
 
   // Public - Placeholders
   // ---------------------
   public function hasZ() {
-    // geoPHP does not support Z values at the moment
-    return FALSE;
+	// geoPHP does not support Z values at the moment
+	return FALSE;
   }
 
   public function is3D() {
-    // geoPHP does not support 3D geometries at the moment
-    return FALSE;
+	// geoPHP does not support 3D geometries at the moment
+	return FALSE;
   }
 
   public function isMeasured() {
-    // geoPHP does not yet support M values
-    return FALSE;
+	// geoPHP does not yet support M values
+	return FALSE;
   }
 
   public function coordinateDimension() {
-    // geoPHP only supports 2-dimentional space
-    return 2;
+	// geoPHP only supports 2-dimentional space
+	return 2;
   }
 
   public function z() {
-    // geoPHP only supports 2-dimentional space
-    return NULL;
+	// geoPHP only supports 2-dimentional space
+	return NULL;
   }
 
   public function m() {
-    // geoPHP only supports 2-dimentional space
-    return NULL;
+	// geoPHP only supports 2-dimentional space
+	return NULL;
   }
 
 }

Spacing +9 added lines, -9 removed lines

@@ -21,8 +21,8 @@ 
   abstract public function geometryN($n);
   abstract public function startPoint();
   abstract public function endPoint();
-  abstract public function isRing();            // Mssing dependancy
-  abstract public function isClosed();          // Missing dependancy
+  abstract public function isRing(); // Mssing dependancy
+  abstract public function isClosed(); // Missing dependancy
   abstract public function numPoints();
   abstract public function pointN($n);
   abstract public function exteriorRing();
@@ -64,12 +64,12 @@ 
     }
 
     $bbox = $this->getBBox();
-    $points = array (
-      new Point($bbox['maxx'],$bbox['miny']),
-      new Point($bbox['maxx'],$bbox['maxy']),
-      new Point($bbox['minx'],$bbox['maxy']),
-      new Point($bbox['minx'],$bbox['miny']),
-      new Point($bbox['maxx'],$bbox['miny']),
+    $points = array(
+      new Point($bbox['maxx'], $bbox['miny']),
+      new Point($bbox['maxx'], $bbox['maxy']),
+      new Point($bbox['minx'], $bbox['maxy']),
+      new Point($bbox['minx'], $bbox['miny']),
+      new Point($bbox['maxx'], $bbox['miny']),
     );
 
     $outer_boundary = new LineString($points);
@@ -147,7 +147,7 @@ 
     // It hasn't been set yet, generate it
     if (geoPHP::geosInstalled()) {
       $reader = new GEOSWKBReader();
-      $this->geos = $reader->readHEX($this->out('wkb',TRUE));
+      $this->geos = $reader->readHEX($this->out('wkb', TRUE));
     }
     else {
       $this->geos = FALSE;

Braces +6 added lines, -7 removed lines

@@ -57,7 +57,9 @@ 
   }
 
   public function envelope() {
-    if ($this->isEmpty()) return new Polygon();
+    if ($this->isEmpty()) {
+    	return new Polygon();
+    }
 
     if ($this->geos()) {
       return geoPHP::geosToGeometry($this->geos()->envelope());
@@ -148,8 +150,7 @@ 
     if (geoPHP::geosInstalled()) {
       $reader = new GEOSWKBReader();
       $this->geos = $reader->readHEX($this->out('wkb',TRUE));
-    }
-    else {
+    } else {
       $this->geos = FALSE;
     }
     return $this->geos;
@@ -175,8 +176,7 @@ 
     if ($this->geos()) {
       if ($pattern) {
         return $this->geos()->relate($geometry->geos(), $pattern);
-      }
-      else {
+      } else {
         return $this->geos()->relate($geometry->geos());
       }
     }
@@ -227,8 +227,7 @@ 
           $geom = $geom->union($item->geos());
         }
         return geoPHP::geosToGeometry($geom);
-      }
-      else {
+      } else {
         return geoPHP::geosToGeometry($this->geos()->union($geometry->geos()));
       }
     }