openlayers/examples/kamap.txt

   1 <?php
   2 /*
   3
   4 This is a PHP file to be used as a backend for a ka-Map layer. It requires
   5 PHP with Mapscript and libgd modules installed. The top of the file
   6 is a configuration section: please edit the variables in this configuration
   7 section to meet your needs, then rename this file to tile.php or something
   8 similar and put it in a web accessible directory. More information
   9 on the OpenLayers ka-Map layer is available from:
  10
  11   http://trac.openlayers.org/wiki/OpenLayers.Layer.KaMap
  12
  13 */
  14 /**********************************************************************
  15  *
  16  * $Id: tile.php,v 1.33 2006/02/07 03:19:55 pspencer Exp $
  17  *
  18  * purpose: a simple phpmapscript-based tile renderer that implements
  19  *          rudimentary caching for reasonable efficiency.  Note the
  20  *          cache never shrinks in this version so your disk could
  21  *          easily fill up!
  22  *
  23  * author: Paul Spencer (pspencer@dmsolutions.ca)
  24  *
  25  * modifications by Daniel Morissette (dmorissette@dmsolutions.ca)
  26  *
  27  * Modified by Christopher Schmidt for OpenLayers redistribution.
  28  *
  29  **********************************************************************
  30  *
  31  * Copyright (c) 2005, DM Solutions Group Inc.
  32  *
  33  * Permission is hereby granted, free of charge, to any person obtaining a
  34  * copy of this software and associated documentation files (the "Software"),
  35  * to deal in the Software without restriction, including without limitation
  36  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  37  * and/or sell copies of the Software, and to permit persons to whom the
  38  * Software is furnished to do so, subject to the following conditions:
  39  *
  40  * The above copyright notice and this permission notice shall be included
  41  * in all copies or substantial portions of the Software.
  42  *
  43  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  44  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  45  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  46  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  47  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  48  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  49  * DEALINGS IN THE SOFTWARE.
  50  *
  51  **********************************************************************/
  52
  53
  54 /******************************************************************************
  55  * basic system configuration
  56  *
  57  * kaMap! uses PHP/MapScript and the PHP GD extension to
  58  * render tiles, and uses PHP/MapScript to generate initialization parameters
  59  * a legend, and a keymap from the selected map file.
  60  *
  61  * Make sure to set the correct module names for your PHP extensions.
  62  *
  63  * WINDOWS USERS: you will likely need to use php_gd2.dll instead of php_gd.dll
  64  */
  65 $szPHPMapScriptModule = 'php_mapscript.'.PHP_SHLIB_SUFFIX;
  66 $szPHPGDModule = 'php_gd.'.PHP_SHLIB_SUFFIX;
  67
  68 /******************************************************************************
  69  * tile generation parameters
  70  *
  71  * kaMap! generates tiles to load in the client application by first rendering
  72  * larger areas from the map file and then slicing them up into smaller tiles.
  73  * This approach reduces the overhead of loading PHP/MapScript and PHP GD and
  74  * drawing the map file.  These larger areas are referred to as metaTiles in
  75  * the code.  You can set the size of both the small tiles and the metaTiles
  76  * here.  A reasonable size for the small tiles seems to be 200 pixels square.
  77  * Smaller tiles seem to cause problems in client browsers by causing too many
  78  * images to be created and thus slowing performance of live dragging.  Larger
  79  * tiles take longer to download to the client and are inefficient.
  80  *
  81  * The number of smaller tiles that form a metaTile can also be configured.
  82  * This parameter allows tuning of the tile generator to ensure optimal
  83  * performance and for label placement.  MapServer will produce labels only
  84  * within a rendered area.  If the area is too small then features may be
  85  * labelled multiple times.  If the area is too large, it may exceed MapServer,s
  86  * maximum map size (by default 2000x2000) or be too resource-intensive on the
  87  * server, ultimately reducing performance.
  88  */
  89 $tileWidth = 256;
  90 $tileHeight = 256;
  91 $metaWidth = 5;
  92 $metaHeight = 5;
  93 /* $metaBuffer = Buffer size in pixels to add around metatiles to avoid
  94  * rendering issues along the edge of the map image
  95  */
  96 $metaBuffer = 10;
  97
  98 /******************************************************************************
  99  * in-image debugging information - tile location, outlines etc.
 100  * to use this, you need to remove images from your cache first.  This also
 101  * affects the meta tiles - if debug is on, they are not deleted.
 102  */
 103 $bDebug = false;
 104
 105 /******************************************************************************
 106  * aszMapFiles - an array of map files available to the application.  How this
 107  * is used is determined by the application.  Each map file is entered into
 108  * this array as a key->value pair.
 109  *
 110  * The key is the name to be used by the tile caching system to store cached
 111  * tiles within the base cache directory.  This key should be a single word
 112  * that uniquely identifies the map.
 113  *
 114  * The value associated with each key is an array of three values.  The first
 115  * value is a human-readable name to be presented to the user (should the
 116  * application choose to do so) and the second value is the path to the map
 117  * file.  It is assumed that the map file is fully configured for use with
 118  * MapServer/MapScript as no error checking or setting of values is done.  The
 119  * third value is an array of scale values for zooming.
 120  */
 121
 122 $aszMapFiles = array(
 123   "world"   => array( "World", "/path/to/your/mapfile",
 124                array( 10000  ), # in openlayers, the scale array doesn't matter.
 125                "PNG24")
 126
 127 /* Add more elements to this array to offer multiple mapfiles */
 128
 129 );
 130
 131 /******************************************************************************
 132  * figure out which map file to use and set up the necessary variables for
 133  * the rest of the code to use.  This does need to be done on every page load
 134  * unfortunately.
 135  *
 136  * szMap should be set to the default map file to use but can change if
 137  * this script is called with map=<mapname>.
 138  */
 139 $szMap = 'world';
 140
 141 /******************************************************************************
 142  * kaMap! caching
 143  *
 144  * this is the directory within which kaMap! will create its tile cache.  The
 145  * directory does NOT have to be web-accessible, but it must be writable by the
 146  * web-server-user and allow creation of both directories AND files.
 147  *
 148  * the tile caching system will create a separate subdirectory within the base
 149  * cache directory for each map file.  Within the cache directory for each map
 150  * file, directories will be created for each group of layers.  Within the group
 151  * directories, directories will be created at each of the configured scales
 152  * for the application (see mapfile configuration above.)
 153  */
 154 $szBaseCacheDir =  "/var/cache/kamap/";
 155
 156 /*****  END OF CONFIGURABLE STUFF - unless you know what you are doing   *****/
 157 /*****                                                                   *****/
 158 /*****                                                                   *****/
 159 /*****                                                                   *****/
 160 /*****  END OF CONFIGURABLE STUFF - unless you know what you are doing   *****/
 161
 162 if (isset($_REQUEST['map']) && isset($aszMapFiles[$_REQUEST['map']]))
 163 {
 164     $szMap = $_REQUEST['map'];
 165 }
 166
 167 $szMapCacheDir = $szBaseCacheDir.$szMap."/";
 168 $szMapName = $aszMapFiles[$szMap][0];
 169 $szMapFile = $aszMapFiles[$szMap][1];
 170 $anScales = $aszMapFiles[$szMap][2];
 171 setOutputFormat($aszMapFiles[$szMap][3]);
 172 /******************************************************************************
 173  * output format of the map and resulting tiles
 174  *
 175  * The output format used with MapServer can greatly affect appearance and
 176  * performance.  It is recommended to use an 8 bit format such as PNG
 177  *
 178  * NOTE: the tile caching code in tile.php is not configurable here.  It
 179  * currently assumes that it is outputting 8bit PNG files.  If you change to
 180  * PNG24 here then you will need to update tile.php to use the gd function
 181  * imagecreatetruecolor.  If you change the output format to jpeg then
 182  * you would need to change imagepng() to imagejpeg().  A nice enhancement
 183  * would be to make that fully configurable from here.
 184  */
 185 function setOutputFormat($szFormat)
 186 {
 187     switch($szFormat) {
 188         case "PNG24":
 189             $GLOBALS['szMapImageFormat'] = 'PNG24'; //mapscript format name
 190             $GLOBALS['szMapImageCreateFunction'] = "imagecreatefrompng"; // appropriate GD function
 191             $GLOBALS['szImageExtension'] = '.png'; //file extension
 192             $GLOBALS['szImageCreateFunction'] = "imagecreatetruecolor"; //or imagecreatetruecolor if PNG24 ...
 193             $GLOBALS['szImageOutputFunction'] = "imagepng"; //or imagegif, imagejpeg ...
 194             $GLOBALS['szImageHeader'] = 'image/png'; //the content-type of the image
 195             break;
 196         case "GIF":
 197             $GLOBALS['szMapImageFormat'] = 'GIF'; //mapscript format name
 198             $GLOBALS['szMapImageCreateFunction'] = "imagecreatefromgif"; // appropriate GD function
 199             $GLOBALS['szImageExtension'] = '.gif'; //file extension
 200             $GLOBALS['szImageCreateFunction'] = "imagecreate"; //or imagecreatetruecolor if PNG24 ...
 201             $GLOBALS['szImageOutputFunction'] = "imagegif"; //or imagegif, imagejpeg ...
 202             $GLOBALS['szImageHeader'] = 'image/gif'; //the content-type of the image
 203             break;
 204         case "JPEG":
 205             $GLOBALS['szMapImageFormat'] = 'JPEG'; //mapscript format name
 206             $GLOBALS['szMapImageCreateFunction'] = "imagecreatefromjpeg"; // appropriate GD function
 207             $GLOBALS['szImageExtension'] = '.jpg'; //file extension
 208             $GLOBALS['szImageCreateFunction'] = "imagecreatetruecolor"; //or imagecreatetruecolor if PNG24 ...
 209             $GLOBALS['szImageOutputFunction'] = "imagejpeg"; //or imagegif, imagejpeg ...
 210             $GLOBALS['szImageHeader'] = 'image/jpeg'; //the content-type of the image
 211             break;
 212         case "PNG":
 213             $GLOBALS['szMapImageFormat'] = 'PNG'; //mapscript format name
 214             $GLOBALS['szMapImageCreateFunction'] = "imagecreatefrompng"; // appropriate GD function
 215             $GLOBALS['szImageExtension'] = '.png'; //file extension
 216             $GLOBALS['szImageCreateFunction'] = "imagecreate"; //or imagecreatetruecolor if PNG24 ...
 217             $GLOBALS['szImageOutputFunction'] = "imagepng"; //or imagegif, imagejpeg ...
 218             $GLOBALS['szImageHeader'] = 'image/png'; //the content-type of the image
 219             break;
 220         case "DITHERED":
 221         case "PNG8":
 222             $GLOBALS['szMapImageFormat'] = 'dithered';
 223             $GLOBALS['szMapImageCreateFunction'] = "imagecreatefrompng";
 224             $GLOBALS['szImageExtension'] = '.png';
 225             $GLOBALS['szImageCreateFunction'] = "imagecreate";
 226             $GLOBALS['szImageOutputFunction'] = "imagepng";
 227             $GLOBALS['szImageHeader'] = 'image/png';
 228             break;
 229     }
 230 }
 231
 232 /**
 233  * create all directories in a directory tree - found on the php web site
 234  * under the mkdir function ...
 235  */
 236 function makeDirs($strPath, $mode = 0775)
 237 {
 238    return is_dir($strPath) or ( makeDirs(dirname($strPath), $mode) and mkdir($strPath, $mode) );
 239 }
 240
 241 /**
 242  * This function replaces all special characters in the given string.
 243  *
 244  * @param szString string - The string to convert.
 245  *
 246  * @return string converted
 247  */
 248 function normalizeString($szString)
 249 {
 250     // Normalize string by replacing all special characters
 251     // e.g.    "http://my.host.com/cgi-bin/mywms?"
 252     // becomes "http___my_host_com_cgi_bin_mywms_"
 253     return preg_replace("/(\W)/", "_", $szString);
 254 }
 255
 256 /* bug 1253 - root permissions required to delete cached files */
 257 $orig_umask = umask(0);
 258
 259 /* create the main cache directory if necessary */
 260 if (!@is_dir($szMapCacheDir))
 261     makeDirs($szMapCacheDir);
 262
 263 /* get the various request parameters
 264  * also need to make sure inputs are clean, especially those used to
 265  * build paths and filenames
 266  */
 267  /*
 268  * the tile renderer accepts several parameters and returns a tile image from
 269  * the cache, creating the tile only if necessary.
 270  *
 271  * all requests include the pixel location of the request at a certain scale
 272  * and this script figures out the geographic location of the tile from the
 273  * scale assuming that 0,0 in pixels is 0,0 in geographic units
 274  *
 275  * Request parameters are:
 276  *
 277  * map: the name of the map to use.  This is handled by config.php.
 278  *
 279  * t: top pixel position
 280  * l: left pixel position
 281  * s: scale
 282  * g: (optional) comma-delimited list of group names to draw
 283  * layers: (optional) comma-delimited list of layers to draw
 284  * force: optional.  If set, force redraw of the meta tile.  This was added to
 285  *        help with invalid images sometimes being generated.
 286  * tileid: (optional) can be used instead of t+l to specify the tile coord.,
 287  *         useful in regenerating the cache
 288  */
 289
 290 $top = isset( $_REQUEST['t'] ) ? intval($_REQUEST['t']) : 0;
 291 $left = isset( $_REQUEST['l'] ) ? intval($_REQUEST['l']) : 0;
 292 $scale = isset( $_REQUEST['s'] ) ? $_REQUEST['s'] : $anScales[0];
 293 $bForce = isset($_REQUEST['force'])? true : false;
 294 $groups = isset( $_REQUEST['g'] ) ? $_REQUEST['g'] : "";
 295 $layers = isset( $_REQUEST['layers'] ) ? $_REQUEST['layers'] : "";
 296
 297 // dynamic imageformat ----------------------------------------------
 298 //use the function in config.php to set the output format
 299 if (isset($_REQUEST['i']))
 300    setOutputFormat( $_REQUEST['i'] );
 301 //----------------------------------------------------------------
 302
 303 /* tileid=t#####l#### can be used instead of t+l parameters. Useful in
 304  * regenerating the cache for instance.
 305  */
 306 if (isset( $_REQUEST['tileid']) &&
 307     preg_match("/t(-?\d+)l(-?\d+)/", $_REQUEST['tileid'], $aMatch) )
 308 {
 309     $top = intval($aMatch[1]);
 310     $left = intval($aMatch[2]);
 311 }
 312
 313 /* Calculate the metatile's top-left corner coordinates.
 314  * Include the $metaBuffer around the metatile to account for various
 315  * rendering issues happening around the edge of a map
 316  */
 317 $metaLeft = floor( ($left)/($tileWidth*$metaWidth) ) * $tileWidth * $metaWidth;
 318 $metaTop = floor( ($top)/($tileHeight*$metaHeight) ) * $tileHeight *$metaHeight;
 319 $szMetaTileId = "t".$metaTop."l".$metaLeft;
 320 $metaLeft -= $metaBuffer;
 321 $metaTop -= $metaBuffer;
 322
 323 /* caching is done by scale value, then groups and layers and finally metatile
 324  * and tile id. Create a new directory if necessary
 325  */
 326 $szGroupDir = $groups != "" ? normalizeString($groups) : "def";
 327 $szLayerDir = $layers != "" ? normalizeString($layers) : "def";
 328
 329 $szCacheDir = $szMapCacheDir."/".$scale."/".$szGroupDir."/".$szLayerDir."/".$szMetaTileId;
 330 if (!@is_dir($szCacheDir))
 331     makeDirs($szCacheDir);
 332
 333 /* resolve cache hit - clear the os stat cache if necessary */
 334 $szTileId = "t".$top."l".$left;
 335 $szCacheFile = $szCacheDir."/".$szTileId.$szImageExtension;
 336 clearstatcache();
 337
 338 $szMetaDir = $szCacheDir."/meta";
 339 if (!@is_Dir($szMetaDir))
 340     makeDirs($szMetaDir);
 341
 342 /* simple locking in case there are several requests for the same meta
 343    tile at the same time - only draw it once to help with performance */
 344 $szLockFile = $szMetaDir."/lock_".$metaTop."_".$metaLeft;
 345 $fpLockFile = fopen($szLockFile, "a+");
 346 clearstatcache();
 347 if (!file_exists($szCacheFile) || $bForce)
 348 {
 349     flock($fpLockFile, LOCK_EX);
 350     fwrite($fpLockFile, ".");
 351
 352     //check once more to see if the cache file was created while waiting for
 353     //the lock
 354     clearstatcache();
 355     if (!file_exists($szCacheFile) || $bForce)
 356     {
 357         if (!extension_loaded('MapScript'))
 358         {
 359             dl( $szPHPMapScriptModule );
 360         }
 361         if (!extension_loaded('gd'))
 362         {
 363             dl( $szPHPGDModule);
 364         }
 365
 366         if (!@is_Dir($szMetaDir))
 367             makeDirs($szMetaDir);
 368
 369         $oMap = ms_newMapObj($szMapFile);
 370
 371         /* Metatile width/height include 2x the metaBuffer value */
 372         $oMap->set('width', $tileWidth * $metaWidth + 2*$metaBuffer);
 373         $oMap->set('height', $tileHeight * $metaHeight + 2*$metaBuffer);
 374
 375         /* Tell MapServer to not render labels inside the metaBuffer area
 376          * (new in 4.6)
 377          * TODO: Until MapServer bugs 1353/1355 are resolved, we need to
 378          * pass a negative value for "labelcache_map_edge_buffer"
 379          */
 380         $oMap->setMetadata("labelcache_map_edge_buffer", -$metaBuffer);
 381
 382         $inchesPerUnit = array(1, 12, 63360.0, 39.3701, 39370.1, 4374754);
 383         $geoWidth = $scale/($oMap->resolution*$inchesPerUnit[$oMap->units]);
 384         $geoHeight = $scale/($oMap->resolution*$inchesPerUnit[$oMap->units]);
 385
 386         /* draw the metatile */
 387         $minx = $metaLeft * $geoWidth;
 388         $maxx = $minx + $geoWidth * $oMap->width;
 389         $maxy = -1 * $metaTop * $geoHeight;
 390         $miny = $maxy - $geoHeight * $oMap->height;
 391
 392         $nLayers = $oMap->numlayers;
 393         $oMap->setExtent($minx,$miny,$maxx,$maxy);
 394         $oMap->selectOutputFormat( $szMapImageFormat );
 395         $aszLayers = array();
 396         if ($groups || $layers)
 397         {
 398             /* Draw only specified layers instead of default from mapfile*/
 399             if ($layers)
 400             {
 401                 $aszLayers = explode(",", $layers);
 402             }
 403
 404             if ($groups)
 405             {
 406                 $aszGroups = explode(",", $groups);
 407             }
 408
 409             for($i=0;$i<$nLayers;$i++)
 410             {
 411                 $oLayer = $oMap->getLayer($i);
 412                 if (($aszGroups && in_array($oLayer->group,$aszGroups)) ||
 413                     ($aszLayers && in_array($oLayer->name,$aszLayers)) ||
 414                     ($aszGroups && $oLayer->group == '' &&
 415                      in_array( "__base__", $aszGroups)))
 416                 {
 417                     $oLayer->set("status", MS_ON );
 418                 }
 419                 else
 420                 {
 421                     $oLayer->set("status", MS_OFF );
 422                 }
 423             }
 424             //need transparency if groups or layers are used
 425             $oMap->outputformat->set("transparent", MS_ON );
 426         }
 427         else
 428         {
 429             $oMap->outputformat->set("transparent", MS_OFF );
 430         }
 431
 432
 433         $szMetaImg = $szMetaDir."/t".$metaTop."l".$metaLeft.$szImageExtension;
 434         $oImg = $oMap->draw();
 435         $oImg->saveImage($szMetaImg);
 436         $oImg->free();
 437         eval("\$oGDImg = ".$szMapImageCreateFunction."('".$szMetaImg."');");
 438         if ($bDebug)
 439         {
 440             $blue = imagecolorallocate($oGDImg, 0, 0, 255);
 441             imagerectangle($oGDImg, 0, 0, $tileWidth * $metaWidth - 1, $tileHeight * $metaHeight - 1, $blue );
 442         }
 443         for($i=0;$i<$metaWidth;$i++)
 444         {
 445             for ($j=0;$j<$metaHeight;$j++)
 446             {
 447                 eval("\$oTile = ".$szImageCreateFunction."( ".$tileWidth.",".$tileHeight." );");
 448                 // Allocate BG color for the tile (in case the metatile has transparent BG)
 449                 $nTransparent = imagecolorallocate($oTile, $oMap->imagecolor->red, $oMap->imagecolor->green, $oMap->imagecolor->blue);
 450                 //if ($oMap->outputformat->transparent == MS_ON)
 451                 //{
 452                     imagecolortransparent( $oTile,$nTransparent);
 453                 //}
 454                 $tileTop = $j*$tileHeight + $metaBuffer;
 455                 $tileLeft = $i*$tileWidth + $metaBuffer;
 456                 imagecopy( $oTile, $oGDImg, 0, 0, $tileLeft, $tileTop, $tileWidth, $tileHeight );
 457                 /* debugging stuff */
 458                 if ($bDebug)
 459                 {
 460                     $black = imagecolorallocate($oTile, 1, 1, 1);
 461                     $green = imagecolorallocate($oTile, 0, 128, 0 );
 462                     $red = imagecolorallocate($oTile, 255, 0, 0);
 463                     imagerectangle( $oTile, 1, 1, $tileWidth-2, $tileHeight-2, $green );
 464                     imageline( $oTile, 0, $tileHeight/2, $tileWidth-1, $tileHeight/2, $red);
 465                     imageline( $oTile, $tileWidth/2, 0, $tileWidth/2, $tileHeight-1, $red);
 466                     imagestring ( $oTile, 3, 10, 10, ($metaLeft+$tileLeft)." x ".($metaTop+$tileTop), $black );
 467                     imagestring ( $oTile, 3, 10, 30, ($minx+$i*$geoWidth)." x ".($maxy - $j*$geoHeight), $black );
 468                 }
 469                 $szTileImg = $szCacheDir."/t".($metaTop+$tileTop)."l".($metaLeft+$tileLeft).$szImageExtension;
 470                 eval("$szImageOutputFunction( \$oTile, '".$szTileImg."' );");
 471                 imagedestroy($oTile);
 472                 $oTile = null;
 473             }
 474         }
 475         if ($oGDImg != null)
 476         {
 477             imagedestroy($oGDImg);
 478             $oGDImg = null;
 479         }
 480         if (!$bDebug)
 481         {
 482             unlink( $szMetaImg );
 483         }
 484     }
 485     //release the exclusive lock
 486     flock($fpLockFile, LOCK_UN );
 487 }
 488
 489 //acquire shared lock for reading to prevent a problem that could occur
 490 //if a tile exists but is only partially generated.
 491 flock($fpLockFile, LOCK_SH);
 492
 493 $h = fopen($szCacheFile, "r");
 494 header("Content-Type: ".$szImageHeader);
 495 header("Content-Length: " . filesize($szCacheFile));
 496 header("Expires: " . date( "D, d M Y H:i:s GMT", time() + 31536000 ));
 497 header("Cache-Control: max-age=31536000, must-revalidate" );
 498 fpassthru($h);
 499 fclose($h);
 500
 501 //release lock
 502 fclose($fpLockFile);
 503
 504 /* bug 1253 - root permissions required to delete cached files */
 505 umask($orig_umask);
 506
 507 exit;
 508 ?>