header('Last-Modified: ' . gmdate('D, d M Y H:i:s', $lastModified).' GMT');

<?php
/**
 * Polygon Clipping
 * @author Andrew Brampton me <at> bramp <dot> net
 * @url http://bramp.net/blog/2011/11/php-polygon-clipper-using-the-sutherland-hodgman-algorithm/
 *
 * Based on the Sutherland-Hodgman algorithm (1974).
 * http://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm
 *
 * This approache assumes four clip edges (the bounding box).
 * The original algorithm iterated though each clip edge, and then each point. Instead
 * we iterate each point, and then clip edge. This reduces the memory usage. TODO Measure if that is useful!
 *
 * Usage:
 *   require('clip.class.php');
 * 
 *   // Create a cliper with bounds defined by the points (x1, y1)-(x2,y2);
 *   $clip = new SutherlandHodgman($x1, $y1, $x2, $y2);
 * 
 *   // Create array of 2 tuple coordinates
 *   $points = { {x1, y1}, {x2, y2} ... {xN, yN} }'
 *
 *   // Clip! The resulting array will only have points within the bounds
 *   $points = $clip->clip($points);
 *
 */

abstract class Edge {

	var $bound;

	function __construct($bound) {
		$this->bound = $bound;
	}

	/**
	 * Is point $p inside the bounds. Techinically is it on the inside
	 * of the infinite edge defined by $bound
	 *
	 * @param point $p
	 */
	abstract function inside($p);

	/**
	 * Finds the intersection with the bounds, on the line p1-p2
	 *
	 * @param point $p1 The point inside the bounds
	 * @param point $p2 The point outside the bounds
	 */
	abstract function intersect($p1, $p2);
}

abstract class HorzEdge extends Edge {

	/**
	 * Returns the point at which the line $p1-$p2 hits the horz boundary
	 *
	 * @param point $p1
	 * @param point $p2
	 *
	 * @return point
	 */
	function intersect($p1, $p2) {
		$dY = $p2[1] - $p1[1];

		if ($dY == 0)
			return array($p1[0], $this->bound);

		$dX = $p2[0] - $p1[0];
		$dY2 = ($this->bound - $p1[1]);

		return array(($dY2 / $dY) * $dX + $p1[0], $this->bound);
	}
}

abstract class VertEdge extends Edge {

	/**
	* Returns the point at which the line $p1-$p2 hits the vertical boundary
	*
	* @param point $p1
	* @param point $p2
	*
	* @return point
	*/
	function intersect($p1, $p2) {
		$dX = $p2[0] - $p1[0];

		if ($dX == 0)
			return array($this->bound, $p1[1]);

		$dY = $p2[1] - $p1[1];
		$dX2 = ($this->bound - $p1[0]);

		return array($this->bound, ($dX2 / $dX) * $dY + $p1[1]);
	}
}

function intersect($p1, $p2) {
	$dX = $p2[0] - $p1[0];
	$dY = $p2[1] - $p1[1];
}

class RightEdge extends VertEdge {
	function inside($p) {
		return $p[0] < $this->bound; //X
	}
}

class LeftEdge extends VertEdge {
	function inside($p) {
		return $p[0] >= $this->bound; //X
	}
}

class TopEdge extends HorzEdge {
	function inside($p) {
		return $p[1] >= $this->bound; //Y
	}
}

class BottomEdge extends HorzEdge {
	function inside($p) {
		return $p[1] < $this->bound; //Y
	}
}

function check_point($p, $msg) {
	if ($p[0] < -180 || $p[0] > 180 || $p[1] < -90 || $p[1] > 90) {
		var_dump($p);
		var_dump(debug_backtrace());
		die("Something went wrong! $msg");
	}
}

class SutherlandHodgman {

	var $edges;

	/**
	 * Construct with the bounds of the clipped area
	 *
	 * @param unknown_type $x1
	 * @param unknown_type $y1
	 * @param unknown_type $x2
	 * @param unknown_type $y2
	 */
	function __construct($x1, $y1, $x2, $y2) {
		assert($x1 < $x2);
		assert($y1 < $y2);

		$this->edges = array(
			new RightEdge($x2),
			new TopEdge($y1),
			new LeftEdge($x1),
			new BottomEdge($y2)
		);
	}

	/**
	 * Clip the array of (x,y) coords to the bounds
	 * specified in the constructor
	 *
	 * @param array $points
	 */
	function clip($points) {

		if (count($points) < 3)
			throw "Clip requires a polygon of three points or more";

		foreach ($this->edges as $edge) {
			$output = array();

			if (empty($points))
				return $points;

			$previous = $points[0];
			$previousInside = $edge->inside($previous);

			// Add the first onto the end so it eventually gets processed
			$points_count = count($points);
			if ($points[$points_count - 1] !== $points[0]) {
				$points[] = $points[0];
				$points_count++;
			}

			for ($i = 1; $i < $points_count; $i++) {
				$point = $points[$i];

				assert(is_array($point));
				assert(count($point) == 2);

				$inside = $edge->inside($point);

				if ($inside) {
					if (!$previousInside) {
						assert(!$edge->inside($previous));
						$output[] = $edge->intersect($point, $previous);
					}

					$output[] = $point;

				} else if ($previousInside) {
					assert($edge->inside($previous));
					$output[] = $edge->intersect($previous, $point);
				}

				$previous = $point;
				$previousInside = $inside;
			}

			$points = $output;
		}

		return $output;
	}
}

mkdir php
cd php
apt-get source php5
cd php5-*
debuild -us -uc -j4

# start our own mysql server for the tests
/bin/sh debian/setup-mysql.sh 1029 /home/bramp/vendor/php/php5-5.3.8.0/mysql_db
mysqladmin: connect to server at 'localhost' failed
error: 'Access denied for user 'root'@'localhost' (using password: YES)'
make: *** [test-results.txt] Error 1
dpkg-buildpackage: error: debian/rules build gave error exit status 2
debuild: fatal error at line 1348:
dpkg-buildpackage -rfakeroot -D -us -uc -j8 failed

-- debian/setup-mysql.sh.org	2011-11-21 21:57:07.244481175 -0500
+++ debian/setup-mysql.sh	2011-11-21 21:40:39.384455880 -0500
@@ -16,7 +16,7 @@
 
 socket=$datadir/mysql.sock
 # Commands:
-mysqladmin="mysqladmin -u root -P $port -h localhost --socket=$socket"
+mysqladmin="mysqladmin --no-defaults -u root -P $port -h localhost --socket=$socket"
 mysqld="/usr/sbin/mysqld --no-defaults --bind-address=localhost --port=$port --socket=$socket --datadir=$datadir"
 
 # Main code #

sudo mv /etc/php5/conf.d /etc/php5/conf.d.tmp

try {
  // Create files
  // Do something with the files
} finally {
  // Delete files - This code will run no matter what exceptions or errors occur while creating the files.
}

class UnlinkMe {
	var $filename;

	function __construct($filename) {
		$this->filename = $filename;
	}

	function __destruct() {
		unlink($this->filename);
	}
}

// To use:
function doSomething() {
  $unlinkme = new UnlinkMe('/tmp/filename'):

  // Do some work with the files

  return;
}

PHP Fatal error:  Uncaught exception 'PDOException' with message 'SQLSTATE[HY000]: General error: 2053 ' in /home/bramp/my.php:29
Stack trace:
#0 /home/bramp/my.php(29): PDOStatement->fetch(2)

...
$sql = 'SELECT TRIGGER_NAME, TRIGGER_GROUP, JOB_NAME FROM QRTZ_TRIGGERS';
$sth = $dbh->prepare($sql) or die('Failed to prepare SELECT TRIGGER query');
while ($row = $sth->fetch(PDO::FETCH_ASSOC)) {
...

$sth->execute();

<?php
$username = '1234';
$realm    = 'asterisk';
$password = 'PASSWORD';
$uri      = 'sip:1.2.3.4';
$nonce    = 'abcdef01';

$str1 = md5("$username:$realm:$password");
$str2 = md5("REGISTER:$uri");

echo md5("$str1:$nonce:$str2");
?>;

foreach (domain)
   for (i =0; i<3;i++)
      foreach (server)
         query(server, domain)

<?php
// Converts OS Easting/Northing to Lat/Long
// by bramp
	
function Marc($bf0, $n, $PHI0, $PHI) {
	/*
	Compute meridional arc.
	Input: - 
	 ellipsoid semi major axis multiplied by central meridian scale factor (bf0) in meters; 
	 n (computed from a, b and f0); 
	 lat of false origin (PHI0) 
	 initial or final latitude of point (PHI) IN RADIANS.
	*/

	$n2 = pow($n, 2);
	$n3 = pow($n, 3);

	$ans  = ((1 + $n + ((5 / 4) * ($n2)) + ((5 / 4) * $n3)) * ($PHI - $PHI0));
	$ans -= (((3 * $n) + (3 * $n2) + ((21 / 8 ) * $n3)) * (sin($PHI - $PHI0)) * (cos($PHI + $PHI0)));
	$ans += ((((15 / 8 ) * $n2) + ((15 / 8 ) * $n3)) * (sin(2 * ($PHI - $PHI0))) * (cos(2 * ($PHI + $PHI0))));
	$ans -= (((35 / 24) * $n3) * (sin(3 * ($PHI - $PHI0))) * (cos(3 * ($PHI + $PHI0))));

	return $bf0 * $ans;
}
	
function initialLat($North, $n0, $afo, $PHI0, $n, $bfo) {
	/*
	Compute initial value for Latitude (PHI) IN RADIANS.
	Input: - _
	northing of point (North) and northing of false origin (n0) in meters; 
	semi major axis multiplied by central meridian scale factor (af0) in meters; 
	latitude of false origin (PHI0) IN RADIANS;
	n (computed from a, b and f0) 
	ellipsoid semi major axis multiplied by central meridian scale factor (bf0) in meters.
	*/
	
	//First PHI value (PHI1)
	$PHI1 = (($North - $n0) / $afo) + $PHI0;

	//Calculate M
	$M = Marc($bfo, $n, $PHI0, $PHI1);

	//Calculate new PHI value (PHI2)
	$PHI2 = (($North - $n0 - $M) / $afo) + $PHI1;
	
	//Iterate to get final value for InitialLat
	while ( abs($North - $n0 - $M) > 0.00001 ) {
		$PHI2 = (($North - $n0 - $M) / $afo) + $PHI1;
		$M = Marc($bfo, $n, $PHI0, $PHI2);
		$PHI1 = $PHI2;
	}
	
	return $PHI2;
}

function E_N_to_Lat_Long($East, $North) {
	
	$a  = 6377563.396; // Semi-major axis, a
	$b  = 6356256.910; //Semi-minor axis, b
	$e0 = 400000.000; //True origin Easting, E0	
	$n0 = -100000.000; //True origin Northing, N0	
	$f0 = 0.999601271700; //Central Meridan Scale, F0
	
	$PHI0 = 49.0; // True origin latitude, j0
	$LAM0 = -2.0; // True origin longitude, l0
	
	//Convert angle measures to radians
	$RadPHI0 = $PHI0 * (M_PI / 180);
	$RadLAM0 = $LAM0 * (M_PI / 180);

	//Compute af0, bf0, e squared (e2), n and Et
	$af0 = $a * $f0;
	$bf0 = $b * $f0;
	$e2 = ($af0*$af0 - $bf0*$bf0 ) / ($af0*$af0);
	$n = ($af0 - $bf0) / ($af0 + $bf0);
	$Et = $East - $e0;

	//Compute initial value for latitude (PHI) in radians
	$PHId = InitialLat($North, $n0, $af0, $RadPHI0, $n, $bf0);

	$sinPHId2 = pow(sin($PHId),  2);
	$cosPHId  = pow(cos($PHId), -1);
	
	$tanPHId  = tan($PHId);
	$tanPHId2 = pow($tanPHId, 2);
	$tanPHId4 = pow($tanPHId, 4);
	$tanPHId6 = pow($tanPHId, 6);

	//Compute nu, rho and eta2 using value for PHId
	$nu = $af0 / (sqrt(1 - ($e2 * $sinPHId2)));
	$rho = ($nu * (1 - $e2)) / (1 - $e2 * $sinPHId2);
	$eta2 = ($nu / $rho) - 1;
	
	//Compute Longitude
	$X    = $cosPHId / $nu;
	$XI   = $cosPHId / (   6 * pow($nu, 3)) * (($nu / $rho)         +  2 * $tanPHId2);
	$XII  = $cosPHId / ( 120 * pow($nu, 5)) * (5  + 28 * $tanPHId2  + 24 * $tanPHId4);
	$XIIA = $cosPHId / (5040 * pow($nu, 7)) * (61 + 662 * $tanPHId2 + 1320 * $tanPHId4 + 720 * $tanPHId6);

	$VII  = $tanPHId / (  2 * $rho * $nu);
	$VIII = $tanPHId / ( 24 * $rho * pow($nu, 3)) * ( 5 +  3 * $tanPHId2 + $eta2 - 9 * $eta2 * $tanPHId2 );
	$IX   = $tanPHId / (720 * $rho * pow($nu, 5)) * (61 + 90 * $tanPHId2 + 45 * $tanPHId4 );

	$long = (180 / M_PI) * ($RadLAM0 + ($Et * $X) - pow($Et,3) * $XI + pow($Et,5) * $XII - pow($Et,7) * $XIIA);
	$lat  = (180 / M_PI) * ($PHId - (pow($Et,2) * $VII) + (pow($Et, 4) * $VIII) - (pow($Et, 6) * $IX));
	
	return array($lat, $long);
}
?>;

$e = 349000;
$n = 461000;

print_r( E_N_to_Lat_Long( $e, $n) );