| New file |
|---|
| 0,0 → 1,641 |
|---|
| <?php |
| /** |
| * Author : Julien Moquet |
| * |
| * Inspired by Proj4js from Mike Adair madairATdmsolutions.ca |
| * and Richard Greenwood rich@greenwoodmap.com |
| * License: LGPL as per: http://www.gnu.org/copyleft/lesser.html |
| */ |
| class Proj4phpProj { |
| |
| /** |
| * Property: readyToUse |
| * Flag to indicate if initialization is complete for $this Proj object |
| */ |
| public $readyToUse = false; |
| |
| /** |
| * Property: title |
| * The title to describe the projection |
| */ |
| public $title = null; |
| |
| /** |
| * Property: projName |
| * The projection class for $this projection, e.g. lcc (lambert conformal conic, |
| * or merc for mercator). These are exactly equivalent to their Proj4 |
| * counterparts. |
| */ |
| public $projName = null; |
| |
| /** |
| * Property: projection |
| * The projection object for $this projection. */ |
| public $projection = null; |
| |
| /** |
| * Property: units |
| * The units of the projection. Values include 'm' and 'degrees' |
| */ |
| public $units = null; |
| |
| /** |
| * Property: datum |
| * The datum specified for the projection |
| */ |
| public $datum = null; |
| |
| /** |
| * Property: x0 |
| * The x coordinate origin |
| */ |
| public $x0 = 0; |
| |
| /** |
| * Property: y0 |
| * The y coordinate origin |
| */ |
| public $y0 = 0; |
| |
| /** |
| * Property: localCS |
| * Flag to indicate if the projection is a local one in which no transforms |
| * are required. |
| */ |
| public $localCS = false; |
| |
| /** |
| * |
| * @var type |
| */ |
| protected $wktRE = '/^(\w+)\[(.*)\]$/'; |
| |
| /** |
| * Constructor: initialize |
| * Constructor for Proj4php::Proj objects |
| * |
| * Parameters: |
| * $srsCode - a code for map projection definition parameters. These are usually |
| * (but not always) EPSG codes. |
| */ |
| public function __construct( $srsCode ) { |
| |
| $this->srsCodeInput = $srsCode; |
| |
| //check to see if $this is a WKT string |
| if( (strpos( $srsCode, 'GEOGCS' ) !== false) || |
| (strpos( $srsCode, 'GEOCCS' ) !== false) || |
| (strpos( $srsCode, 'PROJCS' ) !== false) || |
| (strpos( $srsCode, 'LOCAL_CS' ) !== false) ) { |
| $this->parseWKT( $srsCode ); |
| $this->deriveConstants(); |
| $this->loadProjCode( $this->projName ); |
| return; |
| } |
| |
| // DGR 2008-08-03 : support urn and url |
| if( strpos( $srsCode, 'urn:' ) === 0 ) { |
| //urn:ORIGINATOR:def:crs:CODESPACE:VERSION:ID |
| $urn = explode( ':', $srsCode ); |
| if( ($urn[1] == 'ogc' || $urn[1] == 'x-ogc') && |
| ($urn[2] == 'def') && |
| ($urn[3] == 'crs') ) { |
| $srsCode = $urn[4] . ':' . $urn[strlen( $urn ) - 1]; |
| } |
| } else if( strpos( $srsCode, 'http://' ) === 0 ) { |
| //url#ID |
| $url = explode( '#', $srsCode ); |
| if( preg_match( "/epsg.org/", $url[0] ) ) { |
| // http://www.epsg.org/# |
| $srsCode = 'EPSG:' . $url[1]; |
| } else if( preg_match( "/RIG.xml/", $url[0] ) ) { |
| //http://librairies.ign.fr/geoportail/resources/RIG.xml# |
| //http://interop.ign.fr/registers/ign/RIG.xml# |
| $srsCode = 'IGNF:' . $url[1]; |
| } |
| } |
| $this->srsCode = strtoupper( $srsCode ); |
| if( strpos( $this->srsCode, "EPSG" ) === 0 ) { |
| $this->srsCode = $this->srsCode; |
| $this->srsAuth = 'epsg'; |
| $this->srsProjNumber = substr( $this->srsCode, 5 ); |
| // DGR 2007-11-20 : authority IGNF |
| } else if( strpos( $this->srsCode, "IGNF" ) === 0 ) { |
| $this->srsCode = $this->srsCode; |
| $this->srsAuth = 'IGNF'; |
| $this->srsProjNumber = substr( $this->srsCode, 5 ); |
| // DGR 2008-06-19 : pseudo-authority CRS for WMS |
| } else if( strpos( $this->srsCode, "CRS" ) === 0 ) { |
| $this->srsCode = $this->srsCode; |
| $this->srsAuth = 'CRS'; |
| $this->srsProjNumber = substr( $this->srsCode, 4 ); |
| } else { |
| $this->srsAuth = ''; |
| $this->srsProjNumber = $this->srsCode; |
| } |
| $this->loadProjDefinition(); |
| } |
| |
| /** |
| * Function: loadProjDefinition |
| * Loads the coordinate system initialization string if required. |
| * Note that dynamic loading happens asynchronously so an application must |
| * wait for the readyToUse property is set to true. |
| * To prevent dynamic loading, include the defs through a script tag in |
| * your application. |
| * |
| */ |
| public function loadProjDefinition() { |
| |
| //check in memory |
| if( array_key_exists( $this->srsCode, Proj4php::$defs ) ) { |
| $this->defsLoaded(); |
| return; |
| } |
| //else check for def on the server |
| $filename = dirname( __FILE__ ) . '/defs/' . strtoupper( $this->srsAuth ) . $this->srsProjNumber . '.php'; |
| |
| try { |
| Proj4php::loadScript( $filename ); |
| $this->defsLoaded(); // succes |
| |
| } catch ( Exception $e ) { |
| $this->loadFromService(); // fail |
| } |
| } |
| |
| /** |
| * Function: loadFromService |
| * Creates the REST URL for loading the definition from a web service and |
| * loads it. |
| * |
| * |
| * DO IT AGAIN. : SHOULD PHP CODE BE GET BY WEBSERVICES ? |
| */ |
| public function loadFromService() { |
| |
| //else load from web service |
| $url = Proj4php::$defsLookupService . '/' . $this->srsAuth . '/' . $this->srsProjNumber . '/proj4/'; |
| try { |
| Proj4php::$defs[strtoupper($this->srsAuth) . ":" . $this->srsProjNumber] = Proj4php::loadScript( $url ); |
| } catch ( Exception $e ) { |
| $this->defsFailed(); |
| } |
| } |
| |
| /** |
| * Function: defsLoaded |
| * Continues the Proj object initilization once the def file is loaded |
| * |
| */ |
| public function defsLoaded() { |
| |
| $this->parseDefs(); |
| $this->loadProjCode( $this->projName ); |
| } |
| |
| /** |
| * Function: checkDefsLoaded |
| * $this is the loadCheck method to see if the def object exists |
| * |
| */ |
| public function checkDefsLoaded() { |
| return isset(Proj4php::$defs[$this->srsCode]) && !empty(Proj4php::$defs[$this->srsCode]); |
| } |
| |
| /** |
| * Function: defsFailed |
| * Report an error in loading the defs file, but continue on using WGS84 |
| * |
| */ |
| public function defsFailed() { |
| Proj4php::reportError( 'failed to load projection definition for: ' . $this->srsCode ); |
| Proj4php::$defs[$this->srsCode] = Proj4php::$defs['WGS84']; //set it to something so it can at least continue |
| $this->defsLoaded(); |
| } |
| |
| /** |
| * Function: loadProjCode |
| * Loads projection class code dynamically if required. |
| * Projection code may be included either through a script tag or in |
| * a built version of proj4php |
| * |
| * An exception occurs if the projection is not found. |
| */ |
| public function loadProjCode( $projName ) { |
| |
| if( array_key_exists( $projName, Proj4php::$proj ) ) { |
| $this->initTransforms(); |
| return; |
| } |
| //the filename for the projection code |
| $filename = dirname( __FILE__ ) . '/projCode/' . $projName . '.php'; |
| |
| try { |
| Proj4php::loadScript( $filename ); |
| $this->loadProjCodeSuccess( $projName ); |
| |
| } catch ( Exception $e ) { |
| $this->loadProjCodeFailure( $projName ); |
| } |
| } |
| |
| /** |
| * Function: loadProjCodeSuccess |
| * Loads any proj dependencies or continue on to final initialization. |
| * |
| */ |
| public function loadProjCodeSuccess( $projName ) { |
| |
| if( isset(Proj4php::$proj[$projName]->dependsOn) && !empty(Proj4php::$proj[$projName]->dependsOn)) { |
| $this->loadProjCode( Proj4php::$proj[$projName]->dependsOn ); |
| } else { |
| $this->initTransforms(); |
| } |
| } |
| |
| /** |
| * Function: defsFailed |
| * Report an error in loading the proj file. Initialization of the Proj |
| * object has failed and the readyToUse flag will never be set. |
| * |
| */ |
| public function loadProjCodeFailure( $projName ) { |
| Proj4php::reportError( "failed to find projection file for: " . $projName ); |
| //TBD initialize with identity transforms so proj will still work? |
| } |
| |
| /** |
| * Function: checkCodeLoaded |
| * $this is the loadCheck method to see if the projection code is loaded |
| * |
| */ |
| public function checkCodeLoaded( $projName ) { |
| |
| return isset(Proj4php::$proj[$projName]) && !empty(Proj4php::$proj[$projName]); |
| } |
| |
| /** |
| * Function: initTransforms |
| * Finalize the initialization of the Proj object |
| * |
| */ |
| public function initTransforms() { |
| |
| $this->projection = clone(Proj4php::$proj[$this->projName]); |
| Proj4php::extend( $this->projection, $this ); |
| $this->init(); |
| |
| // initiate depending class |
| if( false !== ($dependsOn = isset($this->projection->dependsOn) && !empty($this->projection->dependsOn) ? $this->projection->dependsOn : false) ) { |
| Proj4php::extend( Proj4php::$proj[$dependsOn], $this->projection) && |
| Proj4php::$proj[$dependsOn]->init() && |
| Proj4php::extend( $this->projection, Proj4php::$proj[$dependsOn] ); |
| } |
| |
| $this->readyToUse = true; |
| } |
| |
| /** |
| * |
| */ |
| public function init() { |
| $this->projection->init(); |
| } |
| |
| /** |
| * |
| * @param type $pt |
| * @return type |
| */ |
| public function forward( $pt ) { |
| return $this->projection->forward( $pt ); |
| } |
| |
| /** |
| * |
| * @param type $pt |
| * @return type |
| */ |
| public function inverse( $pt ) { |
| return $this->projection->inverse( $pt ); |
| } |
| |
| /** |
| * Function: parseWKT |
| * Parses a WKT string to get initialization parameters |
| * |
| */ |
| public function parseWKT( $wkt ) { |
| |
| if( false === ($match = preg_match( $this->wktRE, $wkt, $wktMatch )) ) |
| return; |
| |
| $wktObject = $wktMatch[1]; |
| $wktContent = $wktMatch[2]; |
| $wktTemp = explode( ",", $wktContent ); |
| |
| $wktName = (strtoupper($wktObject) == "TOWGS84") ? "TOWGS84" : array_shift( $wktTemp ); |
| $wktName = preg_replace( '/^\"/', "", $wktName ); |
| $wktName = preg_replace( '/\"$/', "", $wktName ); |
| |
| /* |
| $wktContent = implode(",",$wktTemp); |
| $wktArray = explode("],",$wktContent); |
| for ($i=0; i<sizeof($wktArray)-1; ++$i) { |
| $wktArray[$i] .= "]"; |
| } |
| */ |
| |
| $wktArray = array(); |
| $bkCount = 0; |
| $obj = ""; |
| |
| foreach( $wktTemp as $token ) { |
| |
| $bkCount = substr_count($token, "[") - substr_count($token, "]"); |
| |
| // ??? |
| $obj .= $token; |
| if( $bkCount === 0 ) { |
| array_push( $wktArray, $obj ); |
| $obj = ""; |
| } else { |
| $obj .= ","; |
| } |
| } |
| |
| //do something based on the type of the wktObject being parsed |
| //add in variations in the spelling as required |
| switch( $wktObject ) { |
| case 'LOCAL_CS': |
| $this->projName = 'identity'; |
| $this->localCS = true; |
| $this->srsCode = $wktName; |
| break; |
| case 'GEOGCS': |
| $this->projName = 'longlat'; |
| $this->geocsCode = $wktName; |
| if( !$this->srsCode ) |
| $this->srsCode = $wktName; |
| break; |
| case 'PROJCS': |
| $$this->srsCode = $wktName; |
| break; |
| case 'GEOCCS': |
| break; |
| case 'PROJECTION': |
| $this->projName = Proj4php::$wktProjections[$wktName]; |
| break; |
| case 'DATUM': |
| $this->datumName = $wktName; |
| break; |
| case 'LOCAL_DATUM': |
| $this->datumCode = 'none'; |
| break; |
| case 'SPHEROID': |
| $this->ellps = $wktName; |
| $this->a = floatval( array_shift( $wktArray ) ); |
| $this->rf = floatval( array_shift( $wktArray ) ); |
| break; |
| case 'PRIMEM': |
| $this->from_greenwich = floatval( array_shift( $wktArray ) ); //to radians? |
| break; |
| case 'UNIT': |
| $this->units = $wktName; |
| $this->unitsPerMeter = floatval( array_shift( $wktArray ) ); |
| break; |
| case 'PARAMETER': |
| $name = strtolower( $wktName ); |
| $value = floatval( array_shift( $wktArray ) ); |
| //there may be many variations on the wktName values, add in case |
| //statements as required |
| switch( $name ) { |
| case 'false_easting': |
| $this->x0 = $value; |
| break; |
| case 'false_northing': |
| $this->y0 = $value; |
| break; |
| case 'scale_factor': |
| $this->k0 = $value; |
| break; |
| case 'central_meridian': |
| $this->long0 = $value * Proj4php::$common->D2R; |
| break; |
| case 'latitude_of_origin': |
| $this->lat0 = $value * Proj4php::$common->D2R; |
| break; |
| case 'more_here': |
| break; |
| default: |
| break; |
| } |
| break; |
| case 'TOWGS84': |
| $this->datum_params = $wktArray; |
| break; |
| //DGR 2010-11-12: AXIS |
| case 'AXIS': |
| $name = strtolower( $wktName ); |
| $value = array_shift( $wktArray ); |
| switch( $value ) { |
| case 'EAST' : $value = 'e'; |
| break; |
| case 'WEST' : $value = 'w'; |
| break; |
| case 'NORTH': $value = 'n'; |
| break; |
| case 'SOUTH': $value = 's'; |
| break; |
| case 'UP' : $value = 'u'; |
| break; |
| case 'DOWN' : $value = 'd'; |
| break; |
| case 'OTHER': |
| default : $value = ' '; |
| break; //FIXME |
| } |
| if( !$this->axis ) { |
| $this->axis = "enu"; |
| } |
| switch( $name ) { |
| case 'X': $this->axis = $value . substr( $this->axis, 1, 2 ); |
| break; |
| case 'Y': $this->axis = substr( $this->axis, 0, 1 ) . $value . substr( $this->axis, 2, 1 ); |
| break; |
| case 'Z': $this->axis = substr( $this->axis, 0, 2 ) . $value; |
| break; |
| default : break; |
| } |
| case 'MORE_HERE': |
| break; |
| default: |
| break; |
| } |
| |
| foreach( $wktArray as $wktArrayContent ) |
| $this->parseWKT( $wktArrayContent ); |
| } |
| |
| /** |
| * Function: parseDefs |
| * Parses the PROJ.4 initialization string and sets the associated properties. |
| * |
| */ |
| public function parseDefs() { |
| |
| $this->defData = Proj4php::$defs[$this->srsCode]; |
| #$paramName; |
| #$paramVal; |
| if( !$this->defData ) { |
| return; |
| } |
| $paramArray = explode( "+", $this->defData ); |
| for( $prop = 0; $prop < sizeof( $paramArray ); $prop++ ) { |
| if( strlen( $paramArray[$prop] ) == 0 ) |
| continue; |
| $property = explode( "=", $paramArray[$prop] ); |
| $paramName = strtolower( $property[0] ); |
| if( sizeof( $property ) >= 2 ) { |
| $paramVal = $property[1]; |
| } |
| |
| switch( trim( $paramName ) ) { // trim out spaces |
| case "": break; // throw away nameless parameter |
| case "title": $this->title = $paramVal; |
| break; |
| case "proj": $this->projName = trim( $paramVal ); |
| break; |
| case "units": $this->units = trim( $paramVal ); |
| break; |
| case "datum": $this->datumCode = trim( $paramVal ); |
| break; |
| case "nadgrids": $this->nagrids = trim( $paramVal ); |
| break; |
| case "ellps": $this->ellps = trim( $paramVal ); |
| break; |
| case "a": $this->a = floatval( $paramVal ); |
| break; // semi-major radius |
| case "b": $this->b = floatval( $paramVal ); |
| break; // semi-minor radius |
| // DGR 2007-11-20 |
| case "rf": $this->rf = floatval( paramVal ); |
| break; // inverse flattening rf= a/(a-b) |
| case "lat_0": $this->lat0 = $paramVal * Proj4php::$common->D2R; |
| break; // phi0, central latitude |
| case "lat_1": $this->lat1 = $paramVal * Proj4php::$common->D2R; |
| break; //standard parallel 1 |
| case "lat_2": $this->lat2 = $paramVal * Proj4php::$common->D2R; |
| break; //standard parallel 2 |
| case "lat_ts": $this->lat_ts = $paramVal * Proj4php::$common->D2R; |
| break; // used in merc and eqc |
| case "lon_0": $this->long0 = $paramVal * Proj4php::$common->D2R; |
| break; // lam0, central longitude |
| case "alpha": $this->alpha = floatval( $paramVal ) * Proj4php::$common->D2R; |
| break; //for somerc projection |
| case "lonc": $this->longc = paramVal * Proj4php::$common->D2R; |
| break; //for somerc projection |
| case "x_0": $this->x0 = floatval( $paramVal ); |
| break; // false easting |
| case "y_0": $this->y0 = floatval( $paramVal ); |
| break; // false northing |
| case "k_0": $this->k0 = floatval( $paramVal ); |
| break; // projection scale factor |
| case "k": $this->k0 = floatval( $paramVal ); |
| break; // both forms returned |
| case "r_a": $this->R_A = true; |
| break; // sphere--area of ellipsoid |
| case "zone": $this->zone = intval( $paramVal, 10 ); |
| break; // UTM Zone |
| case "south": $this->utmSouth = true; |
| break; // UTM north/south |
| case "towgs84": $this->datum_params = explode( ",", $paramVal ); |
| break; |
| case "to_meter": $this->to_meter = floatval( $paramVal ); |
| break; // cartesian scaling |
| case "from_greenwich": $this->from_greenwich = $paramVal * Proj4php::$common->D2R; |
| break; |
| // DGR 2008-07-09 : if pm is not a well-known prime meridian take |
| // the value instead of 0.0, then convert to radians |
| case "pm": $paramVal = trim( $paramVal ); |
| $this->from_greenwich = Proj4php::$primeMeridian[$paramVal] ? Proj4php::$primeMeridian[$paramVal] : floatval( $paramVal ); |
| $this->from_greenwich *= Proj4php::$common->D2R; |
| break; |
| // DGR 2010-11-12: axis |
| case "axis": $paramVal = trim( $paramVal ); |
| $legalAxis = "ewnsud"; |
| if( strlen( paramVal ) == 3 && |
| strpos( $legalAxis, substr( $paramVal, 0, 1 ) ) !== false && |
| strpos( $legalAxis, substr( $paramVal, 1, 1 ) ) !== false && |
| strpos( $legalAxis, substr( $paramVal, 2, 1 ) ) !== false ) { |
| $this->axis = $paramVal; |
| } //FIXME: be silent ? |
| break; |
| case "no_defs": break; |
| default: //alert("Unrecognized parameter: " . paramName); |
| } // switch() |
| } // for paramArray |
| $this->deriveConstants(); |
| } |
| |
| /** |
| * Function: deriveConstants |
| * Sets several derived constant values and initialization of datum and ellipse parameters. |
| * |
| */ |
| public function deriveConstants() { |
| |
| if( isset( $this->nagrids ) && $this->nagrids == '@null' ) |
| $this->datumCode = 'none'; |
| |
| if( isset( $this->datumCode ) && $this->datumCode != 'none' ) { |
| |
| $datumDef = Proj4php::$datum[$this->datumCode]; |
| |
| if( is_array($datumDef ) ) { |
| $this->datum_params = array_key_exists( 'towgs84', $datumDef ) ? explode( ',', $datumDef['towgs84'] ) : null; |
| $this->ellps = $datumDef['ellipse']; |
| $this->datumName = array_key_exists( 'datumName', $datumDef ) ? $datumDef['datumName'] : $this->datumCode; |
| } |
| } |
| if( !isset( $this->a ) ) { // do we have an ellipsoid? |
| if( !isset( $this->ellps ) || strlen( $this->ellps ) == 0 || !array_key_exists( $this->ellps, Proj4php::$ellipsoid ) ) |
| $ellipse = Proj4php::$ellipsoid['WGS84']; |
| else { |
| $ellipse = Proj4php::$ellipsoid[$this->ellps]; |
| } |
| |
| Proj4php::extend( $this, $ellipse ); |
| } |
| |
| if( isset( $this->rf ) && !isset( $this->b ) ) |
| $this->b = (1.0 - 1.0 / $this->rf) * $this->a; |
| |
| if ( (isset($this->rf) && $this->rf === 0) || abs($this->a - $this->b) < Proj4php::$common->EPSLN) { |
| $this->sphere = true; |
| $this->b = $this->a; |
| } |
| $this->a2 = $this->a * $this->a; // used in geocentric |
| $this->b2 = $this->b * $this->b; // used in geocentric |
| $this->es = ($this->a2 - $this->b2) / $this->a2; // e ^ 2 |
| $this->e = sqrt( $this->es ); // eccentricity |
| if( isset( $this->R_A ) ) { |
| $this->a *= 1. - $this->es * (Proj4php::$common->SIXTH + $this->es * (Proj4php::$common->RA4 + $this->es * Proj4php::$common->RA6)); |
| $this->a2 = $this->a * $this->a; |
| $this->b2 = $this->b * $this->b; |
| $this->es = 0.0; |
| } |
| $this->ep2 = ($this->a2 - $this->b2) / $this->b2; // used in geocentric |
| if( !isset( $this->k0 ) ) |
| $this->k0 = 1.0; //default value |
| |
| //DGR 2010-11-12: axis |
| if( !isset( $this->axis ) ) { |
| $this->axis = "enu"; |
| } |
| |
| $this->datum = new Proj4phpDatum( $this ); |
| } |
| |
| } |