Ysurac / FlightAirMap

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

Indentation +90 added lines, -90 removed lines

@@ -30,55 +30,55 @@ 
    * @return Geometry|GeometryCollection
    */
   public function read($address, $return_type = 'point', $bounds = FALSE, $return_multiple = FALSE) {
-    if (is_array($address)) $address = join(',', $address);
+	if (is_array($address)) $address = join(',', $address);
     
-    if (gettype($bounds) == 'object') {
-      $bounds = $bounds->getBBox();
-    }
-    if (gettype($bounds) == 'array') {
-      $bounds_string = '&bounds='.$bounds['miny'].','.$bounds['minx'].'|'.$bounds['maxy'].','.$bounds['maxx'];
-    }
-    else {
-      $bounds_string = '';
-    }
+	if (gettype($bounds) == 'object') {
+	  $bounds = $bounds->getBBox();
+	}
+	if (gettype($bounds) == 'array') {
+	  $bounds_string = '&bounds='.$bounds['miny'].','.$bounds['minx'].'|'.$bounds['maxy'].','.$bounds['maxx'];
+	}
+	else {
+	  $bounds_string = '';
+	}
     
-    $url = "http://maps.googleapis.com/maps/api/geocode/json";
-    $url .= '?address='. urlencode($address);
-    $url .= $bounds_string;
-    $url .= '&sensor=false';
-    $this->result = json_decode(@file_get_contents($url));
+	$url = "http://maps.googleapis.com/maps/api/geocode/json";
+	$url .= '?address='. urlencode($address);
+	$url .= $bounds_string;
+	$url .= '&sensor=false';
+	$this->result = json_decode(@file_get_contents($url));
     
-    if ($this->result->status == 'OK') {
-      if ($return_multiple == FALSE) {
-        if ($return_type == 'point') {
-          return $this->getPoint();
-        }
-        if ($return_type == 'bounds' || $return_type == 'polygon') {
-          return $this->getPolygon();
-        }
-      }
-      if ($return_multiple == TRUE) {
-        if ($return_type == 'point') {
-          $points = array();
-          foreach ($this->result->results as $delta => $item) {
-            $points[] = $this->getPoint($delta);
-          }
-          return new MultiPoint($points);
-        }
-        if ($return_type == 'bounds' || $return_type == 'polygon') {
-          $polygons = array();
-          foreach ($this->result->results as $delta => $item) {
-            $polygons[] = $this->getPolygon($delta);
-          }
-          return new MultiPolygon($polygons);
-        }
-      }
-    }
-    else {
-      if ($this->result->status) throw new Exception('Error in Google Geocoder: '.$this->result->status);
-      else throw new Exception('Unknown error in Google Geocoder');
-      return FALSE;
-    }
+	if ($this->result->status == 'OK') {
+	  if ($return_multiple == FALSE) {
+		if ($return_type == 'point') {
+		  return $this->getPoint();
+		}
+		if ($return_type == 'bounds' || $return_type == 'polygon') {
+		  return $this->getPolygon();
+		}
+	  }
+	  if ($return_multiple == TRUE) {
+		if ($return_type == 'point') {
+		  $points = array();
+		  foreach ($this->result->results as $delta => $item) {
+			$points[] = $this->getPoint($delta);
+		  }
+		  return new MultiPoint($points);
+		}
+		if ($return_type == 'bounds' || $return_type == 'polygon') {
+		  $polygons = array();
+		  foreach ($this->result->results as $delta => $item) {
+			$polygons[] = $this->getPolygon($delta);
+		  }
+		  return new MultiPolygon($polygons);
+		}
+	  }
+	}
+	else {
+	  if ($this->result->status) throw new Exception('Error in Google Geocoder: '.$this->result->status);
+	  else throw new Exception('Unknown error in Google Geocoder');
+	  return FALSE;
+	}
   }
 
   /**
@@ -90,69 +90,69 @@ 
    * @return string Does a reverse geocode of the geometry
    */
   public function write(Geometry $geometry, $return_type = 'string') {
-    $centroid = $geometry->getCentroid();
-    $lat = $centroid->getY();
-    $lon = $centroid->getX();
+	$centroid = $geometry->getCentroid();
+	$lat = $centroid->getY();
+	$lon = $centroid->getX();
     
-    $url = "http://maps.googleapis.com/maps/api/geocode/json";
-    $url .= '?latlng='.$lat.','.$lon;
-    $url .= '&sensor=false';
-    $this->result = json_decode(@file_get_contents($url));
+	$url = "http://maps.googleapis.com/maps/api/geocode/json";
+	$url .= '?latlng='.$lat.','.$lon;
+	$url .= '&sensor=false';
+	$this->result = json_decode(@file_get_contents($url));
     
-    if ($this->result->status == 'OK') {
-      if ($return_type == 'string') {
-        return $this->result->results[0]->formatted_address;
-      }
-      if ($return_type == 'array') {
-        return $this->result->results[0]->address_components;
-      }
-    }
-    else {
-      if ($this->result->status) throw new Exception('Error in Google Reverse Geocoder: '.$this->result->status);
-      else throw new Exception('Unknown error in Google Reverse Geocoder');
-      return FALSE;
-    }
+	if ($this->result->status == 'OK') {
+	  if ($return_type == 'string') {
+		return $this->result->results[0]->formatted_address;
+	  }
+	  if ($return_type == 'array') {
+		return $this->result->results[0]->address_components;
+	  }
+	}
+	else {
+	  if ($this->result->status) throw new Exception('Error in Google Reverse Geocoder: '.$this->result->status);
+	  else throw new Exception('Unknown error in Google Reverse Geocoder');
+	  return FALSE;
+	}
   }
   
   private function getPoint($delta = 0) {
-    $lat = $this->result->results[$delta]->geometry->location->lat;
-    $lon = $this->result->results[$delta]->geometry->location->lng;
-    return new Point($lon, $lat);
+	$lat = $this->result->results[$delta]->geometry->location->lat;
+	$lon = $this->result->results[$delta]->geometry->location->lng;
+	return new Point($lon, $lat);
   }
 
   private function getPolygon($delta = 0) {
-    $points = array (
-      $this->getTopLeft($delta),
-      $this->getTopRight($delta),
-      $this->getBottomRight($delta),
-      $this->getBottomLeft($delta),
-      $this->getTopLeft($delta),
-    );
-    $outer_ring = new LineString($points);
-    return new Polygon(array($outer_ring));
+	$points = array (
+	  $this->getTopLeft($delta),
+	  $this->getTopRight($delta),
+	  $this->getBottomRight($delta),
+	  $this->getBottomLeft($delta),
+	  $this->getTopLeft($delta),
+	);
+	$outer_ring = new LineString($points);
+	return new Polygon(array($outer_ring));
   }
 
   private function getTopLeft($delta = 0) {
-    $lat = $this->result->results[$delta]->geometry->bounds->northeast->lat;
-    $lon = $this->result->results[$delta]->geometry->bounds->southwest->lng;
-    return new Point($lon, $lat);
+	$lat = $this->result->results[$delta]->geometry->bounds->northeast->lat;
+	$lon = $this->result->results[$delta]->geometry->bounds->southwest->lng;
+	return new Point($lon, $lat);
   }
 
   private function getTopRight($delta = 0) {
-    $lat = $this->result->results[$delta]->geometry->bounds->northeast->lat;
-    $lon = $this->result->results[$delta]->geometry->bounds->northeast->lng;
-    return new Point($lon, $lat);
+	$lat = $this->result->results[$delta]->geometry->bounds->northeast->lat;
+	$lon = $this->result->results[$delta]->geometry->bounds->northeast->lng;
+	return new Point($lon, $lat);
   }
   
   private function getBottomLeft($delta = 0) {
-    $lat = $this->result->results[$delta]->geometry->bounds->southwest->lat;
-    $lon = $this->result->results[$delta]->geometry->bounds->southwest->lng;
-     return new Point($lon, $lat);
+	$lat = $this->result->results[$delta]->geometry->bounds->southwest->lat;
+	$lon = $this->result->results[$delta]->geometry->bounds->southwest->lng;
+	 return new Point($lon, $lat);
   }
 
   private function getBottomRight($delta = 0) {
-    $lat = $this->result->results[$delta]->geometry->bounds->southwest->lat;
-    $lon = $this->result->results[$delta]->geometry->bounds->northeast->lng;
-    return new Point($lon, $lat);
+	$lat = $this->result->results[$delta]->geometry->bounds->southwest->lat;
+	$lon = $this->result->results[$delta]->geometry->bounds->northeast->lng;
+	return new Point($lon, $lat);
   }
 }

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

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

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

Indentation +103 added lines, -103 removed lines

@@ -23,7 +23,7 @@ 
    * @return Geometry|GeometryCollection

    */

   public function read($gpx) {

-    return $this->geomFromText($gpx);

+	return $this->geomFromText($gpx);

   }

 

   /**

@@ -34,147 +34,147 @@ 
    * @return string The GPX string representation of the input geometries

    */

   public function write(Geometry $geometry, $namespace = FALSE) {

-    if ($geometry->isEmpty()) return NULL;

-    if ($namespace) {

-      $this->namespace = $namespace;

-      $this->nss = $namespace.':';    

-    }

-    return '<'.$this->nss.'gpx creator="geoPHP" version="1.0">'.$this->geometryToGPX($geometry).'</'.$this->nss.'gpx>';

+	if ($geometry->isEmpty()) return NULL;

+	if ($namespace) {

+	  $this->namespace = $namespace;

+	  $this->nss = $namespace.':';    

+	}

+	return '<'.$this->nss.'gpx creator="geoPHP" version="1.0">'.$this->geometryToGPX($geometry).'</'.$this->nss.'gpx>';

   }

   

   public function geomFromText($text) {

-    // Change to lower-case and strip all CDATA

-    $text = strtolower($text);

-    $text = preg_replace('/<!\[cdata\[(.*?)\]\]>/s','',$text);

+	// Change to lower-case and strip all CDATA

+	$text = strtolower($text);

+	$text = preg_replace('/<!\[cdata\[(.*?)\]\]>/s','',$text);

     

-    // Load into DOMDocument

-    $xmlobj = new DOMDocument();

-    @$xmlobj->loadXML($text);

-    if ($xmlobj === false) {

-      throw new Exception("Invalid GPX: ". $text);

-    }

+	// Load into DOMDocument

+	$xmlobj = new DOMDocument();

+	@$xmlobj->loadXML($text);

+	if ($xmlobj === false) {

+	  throw new Exception("Invalid GPX: ". $text);

+	}

     

-    $this->xmlobj = $xmlobj;

-    try {

-      $geom = $this->geomFromXML();

-    } catch(InvalidText $e) {

-        throw new Exception("Cannot Read Geometry From GPX: ". $text);

-    } catch(Exception $e) {

-        throw $e;

-    }

+	$this->xmlobj = $xmlobj;

+	try {

+	  $geom = $this->geomFromXML();

+	} catch(InvalidText $e) {

+		throw new Exception("Cannot Read Geometry From GPX: ". $text);

+	} catch(Exception $e) {

+		throw $e;

+	}

 

-    return $geom;

+	return $geom;

   }

   

   protected function geomFromXML() {

-    $geometries = array();

-    $geometries = array_merge($geometries, $this->parseWaypoints());

-    $geometries = array_merge($geometries, $this->parseTracks());

-    $geometries = array_merge($geometries, $this->parseRoutes());

+	$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");

-    }

+	if (empty($geometries)) {

+	  throw new Exception("Invalid / Empty GPX");

+	}

     

-    return geoPHP::geometryReduce($geometries); 

+	return geoPHP::geometryReduce($geometries); 

   }

   

   protected function childElements($xml, $nodename = '') {

-    $children = array();

-    foreach ($xml->childNodes as $child) {

-      if ($child->nodeName == $nodename) {

-        $children[] = $child;

-      }

-    }

-    return $children;

+	$children = array();

+	foreach ($xml->childNodes as $child) {

+	  if ($child->nodeName == $nodename) {

+		$children[] = $child;

+	  }

+	}

+	return $children;

   }

   

   protected function parseWaypoints() {

-    $points = array();

-    $wpt_elements = $this->xmlobj->getElementsByTagName('wpt');

-    foreach ($wpt_elements as $wpt) {

-      $lat = $wpt->attributes->getNamedItem("lat")->nodeValue;

-      $lon = $wpt->attributes->getNamedItem("lon")->nodeValue;

-      $points[] = new Point($lon, $lat);

-    }

-    return $points;

+	$points = array();

+	$wpt_elements = $this->xmlobj->getElementsByTagName('wpt');

+	foreach ($wpt_elements as $wpt) {

+	  $lat = $wpt->attributes->getNamedItem("lat")->nodeValue;

+	  $lon = $wpt->attributes->getNamedItem("lon")->nodeValue;

+	  $points[] = new Point($lon, $lat);

+	}

+	return $points;

   }

   

   protected function parseTracks() {

-    $lines = array();

-    $trk_elements = $this->xmlobj->getElementsByTagName('trk');

-    foreach ($trk_elements as $trk) {

-      $components = array();

-      foreach ($this->childElements($trk, 'trkseg') as $trkseg) {

-        foreach ($this->childElements($trkseg, 'trkpt') as $trkpt) {

-          $lat = $trkpt->attributes->getNamedItem("lat")->nodeValue;

-          $lon = $trkpt->attributes->getNamedItem("lon")->nodeValue;

-          $components[] = new Point($lon, $lat);

-        }

-      }

-      if ($components) {$lines[] = new LineString($components);}

-    }

-    return $lines;

+	$lines = array();

+	$trk_elements = $this->xmlobj->getElementsByTagName('trk');

+	foreach ($trk_elements as $trk) {

+	  $components = array();

+	  foreach ($this->childElements($trk, 'trkseg') as $trkseg) {

+		foreach ($this->childElements($trkseg, 'trkpt') as $trkpt) {

+		  $lat = $trkpt->attributes->getNamedItem("lat")->nodeValue;

+		  $lon = $trkpt->attributes->getNamedItem("lon")->nodeValue;

+		  $components[] = new Point($lon, $lat);

+		}

+	  }

+	  if ($components) {$lines[] = new LineString($components);}

+	}

+	return $lines;

   }

   

   protected function parseRoutes() {

-    $lines = array();

-    $rte_elements = $this->xmlobj->getElementsByTagName('rte');

-    foreach ($rte_elements as $rte) {

-      $components = array();

-      foreach ($this->childElements($rte, 'rtept') as $rtept) {

-        $lat = $rtept->attributes->getNamedItem("lat")->nodeValue;

-        $lon = $rtept->attributes->getNamedItem("lon")->nodeValue;

-        $components[] = new Point($lon, $lat);

-      }

-      $lines[] = new LineString($components);

-    }

-    return $lines;

+	$lines = array();

+	$rte_elements = $this->xmlobj->getElementsByTagName('rte');

+	foreach ($rte_elements as $rte) {

+	  $components = array();

+	  foreach ($this->childElements($rte, 'rtept') as $rtept) {

+		$lat = $rtept->attributes->getNamedItem("lat")->nodeValue;

+		$lon = $rtept->attributes->getNamedItem("lon")->nodeValue;

+		$components[] = new Point($lon, $lat);

+	  }

+	  $lines[] = new LineString($components);

+	}

+	return $lines;

   }

   

   protected function geometryToGPX($geom) {

-    $type = strtolower($geom->getGeomType());

-    switch ($type) {

-      case 'point':

-        return $this->pointToGPX($geom);

-        break;

-      case 'linestring':

-        return $this->linestringToGPX($geom);

-        break;

-      case 'polygon':

-      case 'multipoint':

-      case 'multilinestring':

-      case 'multipolygon':

-      case 'geometrycollection':

-        return $this->collectionToGPX($geom);

-        break;

-    }

+	$type = strtolower($geom->getGeomType());

+	switch ($type) {

+	  case 'point':

+		return $this->pointToGPX($geom);

+		break;

+	  case 'linestring':

+		return $this->linestringToGPX($geom);

+		break;

+	  case 'polygon':

+	  case 'multipoint':

+	  case 'multilinestring':

+	  case 'multipolygon':

+	  case 'geometrycollection':

+		return $this->collectionToGPX($geom);

+		break;

+	}

   }

   

   private function pointToGPX($geom) {

-    return '<'.$this->nss.'wpt lat="'.$geom->getY().'" lon="'.$geom->getX().'" />';

+	return '<'.$this->nss.'wpt lat="'.$geom->getY().'" lon="'.$geom->getX().'" />';

   }

   

   private function linestringToGPX($geom) {

-    $gpx = '<'.$this->nss.'trk><'.$this->nss.'trkseg>';

+	$gpx = '<'.$this->nss.'trk><'.$this->nss.'trkseg>';

     

-    foreach ($geom->getComponents() as $comp) {

-      $gpx .= '<'.$this->nss.'trkpt lat="'.$comp->getY().'" lon="'.$comp->getX().'" />';

-    }

+	foreach ($geom->getComponents() as $comp) {

+	  $gpx .= '<'.$this->nss.'trkpt lat="'.$comp->getY().'" lon="'.$comp->getX().'" />';

+	}

     

-    $gpx .= '</'.$this->nss.'trkseg></'.$this->nss.'trk>';

+	$gpx .= '</'.$this->nss.'trkseg></'.$this->nss.'trk>';

     

-    return $gpx;

+	return $gpx;

   }

   

   public function collectionToGPX($geom) {

-    $gpx = '';

-    $components = $geom->getComponents();

-    foreach ($geom->getComponents() as $comp) {

-      $gpx .= $this->geometryToGPX($comp);

-    }

+	$gpx = '';

+	$components = $geom->getComponents();

+	foreach ($geom->getComponents() as $comp) {

+	  $gpx .= $this->geometryToGPX($comp);

+	}

     

-    return $gpx;

+	return $gpx;

   }

 

 }

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

Indentation +89 added lines, -89 removed lines

@@ -16,97 +16,97 @@ 
    * @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);
+	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);
   }
 
   private function objToGeom($obj) {
-    $type = $obj->type;
+	$type = $obj->type;
 
-    if ($type == 'GeometryCollection') {
-      return $this->objToGeometryCollection($obj);
-    }
-    $method = 'arrayTo' . $type;
-    return $this->$method($obj->coordinates);
+	if ($type == 'GeometryCollection') {
+	  return $this->objToGeometryCollection($obj);
+	}
+	$method = 'arrayTo' . $type;
+	return $this->$method($obj->coordinates);
   }
 
   private function arrayToPoint($array) {
-    return new Point($array[0], $array[1]);
+	return new Point($array[0], $array[1]);
   }
 
   private function arrayToLineString($array) {
-    $points = array();
-    foreach ($array as $comp_array) {
-      $points[] = $this->arrayToPoint($comp_array);
-    }
-    return new LineString($points);
+	$points = array();
+	foreach ($array as $comp_array) {
+	  $points[] = $this->arrayToPoint($comp_array);
+	}
+	return new LineString($points);
   }
 
   private function arrayToPolygon($array) {
-    $lines = array();
-    foreach ($array as $comp_array) {
-      $lines[] = $this->arrayToLineString($comp_array);
-    }
-    return new Polygon($lines);
+	$lines = array();
+	foreach ($array as $comp_array) {
+	  $lines[] = $this->arrayToLineString($comp_array);
+	}
+	return new Polygon($lines);
   }
 
   private function arrayToMultiPoint($array) {
-    $points = array();
-    foreach ($array as $comp_array) {
-      $points[] = $this->arrayToPoint($comp_array);
-    }
-    return new MultiPoint($points);
+	$points = array();
+	foreach ($array as $comp_array) {
+	  $points[] = $this->arrayToPoint($comp_array);
+	}
+	return new MultiPoint($points);
   }
 
   private function arrayToMultiLineString($array) {
-    $lines = array();
-    foreach ($array as $comp_array) {
-      $lines[] = $this->arrayToLineString($comp_array);
-    }
-    return new MultiLineString($lines);
+	$lines = array();
+	foreach ($array as $comp_array) {
+	  $lines[] = $this->arrayToLineString($comp_array);
+	}
+	return new MultiLineString($lines);
   }
 
   private function arrayToMultiPolygon($array) {
-    $polys = array();
-    foreach ($array as $comp_array) {
-      $polys[] = $this->arrayToPolygon($comp_array);
-    }
-    return new MultiPolygon($polys);
+	$polys = array();
+	foreach ($array as $comp_array) {
+	  $polys[] = $this->arrayToPolygon($comp_array);
+	}
+	return new MultiPolygon($polys);
   }
 
   private function objToGeometryCollection($obj) {
-    $geoms = array();
-    if (empty($obj->geometries)) {
-      throw new Exception('Invalid GeoJSON: GeometryCollection with no component geometries');
-    }
-    foreach ($obj->geometries as $comp_object) {
-      $geoms[] = $this->objToGeom($comp_object);
-    }
-    return new GeometryCollection($geoms);
+	$geoms = array();
+	if (empty($obj->geometries)) {
+	  throw new Exception('Invalid GeoJSON: GeometryCollection with no component geometries');
+	}
+	foreach ($obj->geometries as $comp_object) {
+	  $geoms[] = $this->objToGeom($comp_object);
+	}
+	return new GeometryCollection($geoms);
   }
 
   /**
@@ -118,32 +118,32 @@ 
    * @return string The GeoJSON string
    */
   public function write(Geometry $geometry, $return_array = FALSE) {
-    if ($return_array) {
-      return $this->getArray($geometry);
-    }
-    else {
-      return json_encode($this->getArray($geometry));
-    }
+	if ($return_array) {
+	  return $this->getArray($geometry);
+	}
+	else {
+	  return json_encode($this->getArray($geometry));
+	}
   }
 
   public function getArray($geometry) {
-    if ($geometry->getGeomType() == 'GeometryCollection') {
-      $component_array = array();
-      foreach ($geometry->components as $component) {
-        $component_array[] = array(
-          'type' => $component->geometryType(),
-          'coordinates' => $component->asArray(),
-        );
-      }
-      return array(
-        'type'=> 'GeometryCollection',
-        'geometries'=> $component_array,
-      );
-    }
-    else return array(
-      'type'=> $geometry->getGeomType(),
-      'coordinates'=> $geometry->asArray(),
-    );
+	if ($geometry->getGeomType() == 'GeometryCollection') {
+	  $component_array = array();
+	  foreach ($geometry->components as $component) {
+		$component_array[] = array(
+		  'type' => $component->geometryType(),
+		  'coordinates' => $component->asArray(),
+		);
+	  }
+	  return array(
+		'type'=> 'GeometryCollection',
+		'geometries'=> $component_array,
+	  );
+	}
+	else return array(
+	  'type'=> $geometry->getGeomType(),
+	  'coordinates'=> $geometry->asArray(),
+	);
   }
 }
 

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

Indentation +161 added lines, -161 removed lines

@@ -29,120 +29,120 @@ 
    * @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);

+	}

 

-    if (empty($wkb)) {

-      throw new Exception('Cannot read empty WKB geometry. Found ' . gettype($wkb));

-    }

+	if (empty($wkb)) {

+	  throw new Exception('Cannot read empty WKB geometry. Found ' . gettype($wkb));

+	}

 

-    $mem = fopen('php://memory', 'r+');

-    fwrite($mem, $wkb);

-    fseek($mem, 0);

+	$mem = fopen('php://memory', 'r+');

+	fwrite($mem, $wkb);

+	fseek($mem, 0);

 

-    $geometry = $this->getGeometry($mem);

-    fclose($mem);

-    return $geometry;

+	$geometry = $this->getGeometry($mem);

+	fclose($mem);

+	return $geometry;

   }

 

   function getGeometry(&$mem) {

-    $base_info = unpack("corder/ctype/cz/cm/cs", fread($mem, 5));

-    if ($base_info['order'] !== 1) {

-      throw new Exception('Only NDR (little endian) SKB format is supported at the moment');

-    }

-

-    if ($base_info['z']) {

-      $this->dimension++;

-      $this->z = TRUE;

-    }

-    if ($base_info['m']) {

-      $this->dimension++;

-      $this->m = TRUE;

-    }

-

-    // If there is SRID information, ignore it - use EWKB Adapter to get SRID support

-    if ($base_info['s']) {

-      fread($mem, 4);

-    }

-

-    switch ($base_info['type']) {

-      case 1:

-        return $this->getPoint($mem);

-      case 2:

-        return $this->getLinstring($mem);

-      case 3:

-        return $this->getPolygon($mem);

-      case 4:

-        return $this->getMulti($mem,'point');

-      case 5:

-        return $this->getMulti($mem,'line');

-      case 6:

-        return $this->getMulti($mem,'polygon');

-      case 7:

-        return $this->getMulti($mem,'geometry');

-    }

+	$base_info = unpack("corder/ctype/cz/cm/cs", fread($mem, 5));

+	if ($base_info['order'] !== 1) {

+	  throw new Exception('Only NDR (little endian) SKB format is supported at the moment');

+	}

+

+	if ($base_info['z']) {

+	  $this->dimension++;

+	  $this->z = TRUE;

+	}

+	if ($base_info['m']) {

+	  $this->dimension++;

+	  $this->m = TRUE;

+	}

+

+	// If there is SRID information, ignore it - use EWKB Adapter to get SRID support

+	if ($base_info['s']) {

+	  fread($mem, 4);

+	}

+

+	switch ($base_info['type']) {

+	  case 1:

+		return $this->getPoint($mem);

+	  case 2:

+		return $this->getLinstring($mem);

+	  case 3:

+		return $this->getPolygon($mem);

+	  case 4:

+		return $this->getMulti($mem,'point');

+	  case 5:

+		return $this->getMulti($mem,'line');

+	  case 6:

+		return $this->getMulti($mem,'polygon');

+	  case 7:

+		return $this->getMulti($mem,'geometry');

+	}

   }

 

   function getPoint(&$mem) {

-    $point_coords = unpack("d*", fread($mem,$this->dimension*8));

-    return new Point($point_coords[1],$point_coords[2]);

+	$point_coords = unpack("d*", fread($mem,$this->dimension*8));

+	return new Point($point_coords[1],$point_coords[2]);

   }

 

   function getLinstring(&$mem) {

-    // Get the number of points expected in this string out of the first 4 bytes

-    $line_length = unpack('L',fread($mem,4));

-

-    // Return an empty linestring if there is no line-length

-    if (!$line_length[1]) return new LineString();

-

-    // Read the nubmer of points x2 (each point is two coords) into decimal-floats

-    $line_coords = unpack('d*', fread($mem,$line_length[1]*$this->dimension*8));

-

-    // We have our coords, build up the linestring

-    $components = array();

-    $i = 1;

-    $num_coords = count($line_coords);

-    while ($i <= $num_coords) {

-      $components[] = new Point($line_coords[$i],$line_coords[$i+1]);

-      $i += 2;

-    }

-    return new LineString($components);

+	// Get the number of points expected in this string out of the first 4 bytes

+	$line_length = unpack('L',fread($mem,4));

+

+	// Return an empty linestring if there is no line-length

+	if (!$line_length[1]) return new LineString();

+

+	// Read the nubmer of points x2 (each point is two coords) into decimal-floats

+	$line_coords = unpack('d*', fread($mem,$line_length[1]*$this->dimension*8));

+

+	// We have our coords, build up the linestring

+	$components = array();

+	$i = 1;

+	$num_coords = count($line_coords);

+	while ($i <= $num_coords) {

+	  $components[] = new Point($line_coords[$i],$line_coords[$i+1]);

+	  $i += 2;

+	}

+	return new LineString($components);

   }

 

   function getPolygon(&$mem) {

-    // Get the number of linestring expected in this poly out of the first 4 bytes

-    $poly_length = unpack('L',fread($mem,4));

-

-    $components = array();

-    $i = 1;

-    while ($i <= $poly_length[1]) {

-      $components[] = $this->getLinstring($mem);

-      $i++;

-    }

-    return new Polygon($components);

+	// Get the number of linestring expected in this poly out of the first 4 bytes

+	$poly_length = unpack('L',fread($mem,4));

+

+	$components = array();

+	$i = 1;

+	while ($i <= $poly_length[1]) {

+	  $components[] = $this->getLinstring($mem);

+	  $i++;

+	}

+	return new Polygon($components);

   }

 

   function getMulti(&$mem, $type) {

-    // Get the number of items expected in this multi out of the first 4 bytes

-    $multi_length = unpack('L',fread($mem,4));

-

-    $components = array();

-    $i = 1;

-    while ($i <= $multi_length[1]) {

-      $components[] = $this->getGeometry($mem);

-      $i++;

-    }

-    switch ($type) {

-      case 'point':

-        return new MultiPoint($components);

-      case 'line':

-        return new MultiLineString($components);

-      case 'polygon':

-        return new MultiPolygon($components);

-      case 'geometry':

-        return new GeometryCollection($components);

-    }

+	// Get the number of items expected in this multi out of the first 4 bytes

+	$multi_length = unpack('L',fread($mem,4));

+

+	$components = array();

+	$i = 1;

+	while ($i <= $multi_length[1]) {

+	  $components[] = $this->getGeometry($mem);

+	  $i++;

+	}

+	switch ($type) {

+	  case 'point':

+		return new MultiPoint($components);

+	  case 'line':

+		return new MultiLineString($components);

+	  case 'polygon':

+		return new MultiPolygon($components);

+	  case 'geometry':

+		return new GeometryCollection($components);

+	}

   }

 

   /**

@@ -153,90 +153,90 @@ 
    * @return string The WKB 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);

-

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

-    }

+	// 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;

+	}

+

+	if ($write_as_hex) {

+	  $unpacked = unpack('H*',$wkb);

+	  return $unpacked[1];

+	}

+	else {

+	  return $wkb;

+	}

   }

 

   function writePoint($point) {

-    // Set the coords

-    $wkb = pack('dd',$point->x(), $point->y());

+	// Set the coords

+	$wkb = pack('dd',$point->x(), $point->y());

 

-    return $wkb;

+	return $wkb;

   }

 

   function writeLineString($line) {

-    // Set the number of points in this line

-    $wkb = pack('L',$line->numPoints());

+	// Set the number of points in this line

+	$wkb = pack('L',$line->numPoints());

 

-    // Set the coords

-    foreach ($line->getComponents() as $point) {

-      $wkb .= pack('dd',$point->x(), $point->y());

-    }

+	// Set the coords

+	foreach ($line->getComponents() as $point) {

+	  $wkb .= pack('dd',$point->x(), $point->y());

+	}

 

-    return $wkb;

+	return $wkb;

   }

 

   function writePolygon($poly) {

-    // Set the number of lines in this poly

-    $wkb = pack('L',$poly->numGeometries());

+	// Set the number of lines in this poly

+	$wkb = pack('L',$poly->numGeometries());

 

-    // Write the lines

-    foreach ($poly->getComponents() as $line) {

-      $wkb .= $this->writeLineString($line);

-    }

+	// Write the lines

+	foreach ($poly->getComponents() as $line) {

+	  $wkb .= $this->writeLineString($line);

+	}

 

-    return $wkb;

+	return $wkb;

   }

 

   function writeMulti($geometry) {

-    // Set the number of components

-    $wkb = pack('L',$geometry->numGeometries());

+	// Set the number of components

+	$wkb = pack('L',$geometry->numGeometries());

 

-    // Write the components

-    foreach ($geometry->getComponents() as $component) {

-      $wkb .= $this->write($component);

-    }

+	// Write the components

+	foreach ($geometry->getComponents() as $component) {

+	  $wkb .= $this->write($component);

+	}

 

-    return $wkb;

+	return $wkb;

   }

 

 }

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

Indentation +168 added lines, -168 removed lines

@@ -31,7 +31,7 @@ 
    * @return Geometry|GeometryCollection

    */

   public function read($kml) {

-    return $this->geomFromText($kml);

+	return $this->geomFromText($kml);

   }

 

   /**

@@ -42,218 +42,218 @@ 
    * @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);

+	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;

+	// 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);

+	$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;

+	$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);

-    return new Point($coordinates[0][0],$coordinates[0][1]);

+	$coordinates = $this->_extractCoordinates($xml);

+	return new Point($coordinates[0][0],$coordinates[0][1]);

   }

 

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

+	$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');

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

+	$components = array();

+

+	$outer_boundary_element_a = $this->childElements($xml, 'outerboundaryis');

+	$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);

+	$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;

+	$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;

-    }

+	$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) {

-    return '<'.$this->nss.'Point><'.$this->nss.'coordinates>'.$geom->getX().",".$geom->getY().'</'.$this->nss.'coordinates></'.$this->nss.'Point>';

+	return '<'.$this->nss.'Point><'.$this->nss.'coordinates>'.$geom->getX().",".$geom->getY().'</'.$this->nss.'coordinates></'.$this->nss.'Point>';

   }

 

   private function linestringToKML($geom, $type = FALSE) {

-    if (!$type) {

-      $type = $geom->getGeomType();

-    }

+	if (!$type) {

+	  $type = $geom->getGeomType();

+	}

 

-    $str = '<'.$this->nss . $type .'>';

+	$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++;

-      }

+	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.'coordinates>';

+	}

 

-    $str .= '</'. $this->nss . $type .'>';

+	$str .= '</'. $this->nss . $type .'>';

 

-    return $str;

+	return $str;

   }

 

   public function polygonToKML($geom) {

-    $components = $geom->getComponents();

-    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>';

+	$components = $geom->getComponents();

+	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>';

+	$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>';

   }

 

 }

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/Polygon.class.php

Indentation +117 added lines, -117 removed lines

@@ -9,70 +9,70 @@ 
   protected $geom_type = 'Polygon';
 
   public function area($exterior_only = FALSE, $signed = FALSE) {
-    if ($this->isEmpty()) return 0;
+	if ($this->isEmpty()) return 0;
     
-    if ($this->geos() && $exterior_only == FALSE) {
-      return $this->geos()->area();
-    }
+	if ($this->geos() && $exterior_only == FALSE) {
+	  return $this->geos()->area();
+	}
     
-    $exterior_ring = $this->components[0];
-    $pts = $exterior_ring->getComponents();
+	$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());
-    }
+	$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 ($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;
+	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->isEmpty()) return NULL;
     
-    if ($this->geos()) {
-      return geoPHP::geosToGeometry($this->geos()->centroid());
-    }
+	if ($this->geos()) {
+	  return geoPHP::geosToGeometry($this->geos()->centroid());
+	}
     
-    $exterior_ring = $this->components[0];
-    $pts = $exterior_ring->getComponents();
+	$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);
+	$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);
-    }
+	// 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;
-    }
+	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);
+	$cn['x'] = $cn['x'] / ( 6 * $a);
+	$cn['y'] = $cn['y'] / ( 6 * $a);
     
-    $centroid = new Point($cn['x'], $cn['y']);
-    return $centroid;
+	$centroid = new Point($cn['x'], $cn['y']);
+	return $centroid;
   }
 
 	/**
@@ -98,41 +98,41 @@ 
   }
 
   public function exteriorRing() {
-    if ($this->isEmpty()) return new LineString();
-    return $this->components[0];
+	if ($this->isEmpty()) return new LineString();
+	return $this->components[0];
   }
   
   public function numInteriorRings() {
-    if ($this->isEmpty()) return 0;
-    return $this->numGeometries()-1;
+	if ($this->isEmpty()) return 0;
+	return $this->numGeometries()-1;
   }
   
   public function interiorRingN($n) {
-    return $this->geometryN($n+1);
+	return $this->geometryN($n+1);
   }
   
   public function dimension() {
-    if ($this->isEmpty()) return 0;
-    return 2;
+	if ($this->isEmpty()) return 0;
+	return 2;
   }
 
   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;
   }
 
   /**
@@ -146,59 +146,59 @@ 
    * @return boolean
    */
   public function pointInPolygon($point, $pointOnBoundary = true, $pointOnVertex = true) {
-    $vertices = $this->getPoints();
+	$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 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);
+	// 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;
-    }
+	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;
-      }
-    }
+	foreach($this->getPoints() as $vertex) {
+	  if ($point->equals($vertex)) {
+		return true;
+	  }
+	}
   }