mapmanager/mapmanager.php

Go to the documentation of this file.

<?

require_once('map.php');

// CLICK TYPES
define ('MM_CLICK_MAIN', 1);
define ('MM_CLICK_REF', 2);

// ZOOM TYPES
define('MM_ZOOM_NONE', 0);
define('MM_ZOOM_IN', 1);
define('MM_ZOOM_OUT', 2);
define('MM_ZOOM_PAN', 3);
define('MM_ZOOM_SCALE', 4);
define('MM_ZOOM_EXTENT', 5);

function imagePointToMapPoint($image_point, $map_extent, $image_width, $image_height) 
{
    if (!$image_point)
        trigger_error('A point object must be specified', E_USER_ERROR);

    //Calculate the X coordinate
    $geo_x_diff = $map_extent->maxx - $map_extent->minx; // Get the difference between the geographical coordinates
    $x_ratio = $geo_x_diff / $image_width; // Get the ratio of the geographic coordinates to the image size
    $geo_x_delta = $image_point->x * $x_ratio; // Scale the clicked pixel to the geographic scale
    $geo_x = $map_extent->minx + $geo_x_delta; // Place this in the context of the map by adding it to the minimum extent

    //Calculate the Y coordinate
    $geo_y_diff = $map_extent->maxy - $map_extent->miny;
    $y_ratio = $geo_y_diff / $image_height;
    $pix_y_delta = $image_height - $image_point->y; // Everything is the same as for the X coordinate, except that here you have to compensate for image coordinates being upper left instead of lower right (as on a map)
    $geo_y_delta = $pix_y_delta * $y_ratio;
    $geo_y = $map_extent->miny + $geo_y_delta;

    $map_point = ms_newPointObj();
    $map_point->setXY($geo_x, $geo_y);
            
    return $map_point;
}


function mapPointToImagePoint($map_point, $map_extent, $image_width, $image_height) 
{
    if (!$map_point)
        trigger_error('A point object must be specified', E_USER_ERROR);
    
    //Calculate the X coordinate
    $geo_x_diff = $map_extent->maxx - $map_extent->minx;// Get the difference between the geographical coordinates
    $x_ratio = $geo_x_diff / $image_width; // Get the ratio of the geographic coordinates to the image size
    $geo_x_image_diff = $map_point->x - $map_extent->minx; // get the distance of the coordinate from the x minimum
    $pix_x = round($geo_x_image_diff / $x_ratio); // Scale the geographic coordinate to the image scale in pixels

    //Calculate the Y coordinate
    $geo_y_diff = $map_extent->maxy - $map_extent->miny;
    $y_ratio = $geo_y_diff / $image_height;
    $geo_y_image_diff = $map_point->y - $map_extent->miny;
    $pix_y_delta = $geo_y_image_diff / $y_ratio;
    $pix_y = round($image_height - $pix_y_delta); // Everything is the same as for the X coordinate, except that here you have to compensate for image coordinates being upper left instead of lower right (as on a map)

    $image_point = ms_newPointObj();
    $image_point->setXY($pix_x, $pix_y);
            
    return $image_point;
}

function rectToString($rect)
{
    return $rect->minx.' '.$rect->miny.' '.$rect->maxx.' '.$rect->maxy;
}

function stringToRect($string) 
{
    $extents = explode(' ', $string);
    $rect = ms_newRectObj();
    $rect->setextent($extents[0], $extents[1], $extents[2], $extents[3]);
    return $rect;
}


function pointToString($point)
{
    return $point->x.' '.$point->y.' '.$point->m;
}

function stringToPoint($string) 
{
    $contents = explode(' ', $string);
    $point = ms_newPointObj();
    $point->setXY($contents[0], $contents[1], $contents[2]);
    return $point;
}

class MapManager extends Map
{
    // SERIALISED VARS

    var $max_extent;
    var $zoom_level;
    var $layer_renderers;
    var $zoom_type;
    var $zoom_scale;
    var $zoom_extent;

    // NON SERIALISED VARS

    var $map_click;
    var $click_type;

    function MapManager($map_file, $new_map_path = null)
        {
            $this->Map($map_file, $new_map_path);
            $this->setMaxExtent($this->get('extent'));
            $this->setZoomLevel(1);
            $this->preparequery();
            $this->layer_renderers = array();
            $this->setZoomType(MM_ZOOM_PAN);
        }

    // ACCESSORS

    function getClickType() 
        {
            return $this->click_type;
        }
    
    function setZoomType($zoom_type) 
        {
            $this->zoom_type = $zoom_type;
        }

    function getZoomType() 
        {
            return $this->zoom_type;
        }

    function setZoomScale($zoom_scale) 
        {
            $this->zoom_scale = $zoom_scale;
        }

    function getZoomScale() 
        {
            return $this->zoom_scale;
        }

    function setZoomExtent($zoom_extent) 
        {
            $this->zoom_extent = $zoom_extent;
        }

    function getZoomExtent() 
        {
            return $this->zoom_extent;
        }
    
    function getMapClick($as_map_coords = true) 
        {
            if (!$this->map_click)
                return null;
            
            if ($as_map_coords)
                return $this->map_click;

            return $this->mapPointToImagePoint($this->map_click);
        }    
    
    function setMapClick($map_click, $click_type) 
        {            
            $this->map_click = $map_click;
            $this->click_type = $click_type;
        }

    function setZoomLevel($zoom_level)
        {
            if (!is_numeric($zoom_level))
                trigger_error('The zoom level must be a numeric value: '.$zoom_level, E_USER_ERROR);

            if (is_float($zoom_level / 1))    // check to see if it's an integer
                trigger_error('The zoom level must be an integer value', E_USER_ERROR);
            
            $this->zoom_level = $zoom_level;
        }

    function getZoomLevel() 
        {
            return $this->zoom_level;
        }
    
    function getMaxExtent() 
        {
            return $this->max_extent;
        }

    function setMaxExtent($extent) 
        {
            $this->max_extent = $extent;
        }    

    // LAYER RELATED METHODS

    function layerExists($layer_name) 
        {
            if ($layer = $this->getLayerByName($layer_name))
                return true;
            return false;
        }

    function layerIsOn($layer_name) 
        {
            if (!$layer = $this->getLayerByName($layer_name))
                return false;

            if ($layer->status == MS_ON)
                return true;

            return false;
        }

    function turnLayerOn($layer_name, $toggle_group = false) 
        {
            if (!$this->layerExists($layer_name))
                trigger_error("The layer '$layer_name' does not exist", E_USER_ERROR);

            $layer = $this->getLayerByName($layer_name);            
            if ($toggle_group and $this->isGroupLayer($layer_name)) {
                $this->turnGroupOn($layer->group);
            } else {
                $layer->set('status', MS_ON);
            }
        }

    function turnLayerOff($layer_name, $toggle_group = false) 
        {
            if (!$this->layerExists($layer_name))
                trigger_error("The layer '$layer_name' does not exist", E_USER_ERROR);

            $layer = $this->getLayerByName($layer_name);
            if ($toggle_group and $this->isGroupLayer($layer_name)) {
                $this->turnGroupOff($layer->group);
            } else {
                $layer->set('status', MS_OFF);
            }
        }

    function isGroupLayer($layer_name) 
        {
            if (!$this->layerExists($layer_name))
                return false;

            $layer = $this->getLayerByName($layer_name);
            return (strlen($layer->group) > 0) ? true : false;
        }

    function groupExists($group_name) 
        {
            return in_array($group_name, $this->getAllGroupNames());
        }
    
    function turnGroupOff($group_name) 
        {
            if (!$this->groupExists($group_name))
                trigger_error("The group '$group_name' does not exist", E_USER_ERROR);

            foreach ($this->getLayersIndexByGroup($group_name) as $index) 
                {
                    $layer = $this->getLayer($index);
                    $layer->set('status', MS_OFF);
                }
        }

    function turnGroupOn($group_name) 
        {
            if (!$this->groupExists($group_name))
                trigger_error("The group '$group_name' does not exist", E_USER_ERROR);

            foreach ($this->getLayersIndexByGroup($group_name) as $index) 
                {
                    $layer = $this->getLayer($index);
                    $layer->set('status', MS_ON);
                }
        }
    
    function layerIsQueryable($layer_name) 
        {
            $layer = $this->getLayerByName($layer_name);
            if (!$layer)
                return false;

            if ($layer->template)
                return true;

            for ($i = 0; $i < $layer->numclasses; $i++) {
                $class = $layer->getClass($i);
                if ($class->template)
                    return true;
            }
            
            return false;
        }

    function layerIsSelectable($layer_name) 
        {
            if (!$layer = $this->getLayerByName($layer_name))
                return false;

            $selectable = $layer->getMetaData('SELECTABLE');

            if (strtoupper($selectable) == 'ON')
                return true;
            
            return false;
        }

    function setLayerSelectable($layer_name, $selectable) 
        {
            if (!$layer = $this->getLayerByName($layer_name))
                trigger_error("the layer '$layer_name' does not exist", E_USER_ERROR);

            if ($selectable)
                $layer->setMetaData('SELECTABLE', 'ON');
            else
                $layer->removeMetaData('SELECTABLE');
        }

    function getSelectableLayerNames() 
        {
            $layer_names = array();
            foreach ($this->getAllLayerNames() as $layer_name) 
                {
                    if ($this->layerIsSelectable($layer_name))
                        $layer_names[] = $layer_name;
                }
            return $layer_names;
        }
    
    function setLayerRenderer($layer_name, $renderer) 
        {
            if (!$this->layerExists($layer_name))
                trigger_error("the layer '$layer_name' does not exist", E_USER_ERROR);

            if (!is_callable($renderer))
                trigger_error("The callback function to render the layer '$layer_name' is not valid", E_USER_ERROR);

            $this->layer_renderers[$layer_name] = $renderer;
        }

    function getLayerRenderer($layer_name) 
        {
            if (!$this->layerRendererExists($layer_name))
                trigger_error("no renderer is associated with layer '$layer_name'", E_USER_ERROR);

            return $this->layer_renderers[$layer_name];
        }

    function removeLayerRenderer($layer_name) 
        {
            if (!$this->layerRendererExists($layer_name))
                trigger_error("no renderer to remove for layer '$layer_name'", E_USER_ERROR);

            unset($this->layer_renderers[$layer_name]);
        }
    
    function layerRendererExists($layer_name) 
        {
            return isset($this->layer_renderers[$layer_name]);
        }

    // UTILITY METHODS

    function imagePointToMapPoint($image_point) 
        {
            $extent =& $this->get('extent');
            $height = $this->get('height');
            $width = $this->get('width');
            
            return imagePointToMapPoint($image_point, $extent, $width, $height);
        }

    function mapPointToImagePoint($map_point) 
        {
            $extent =& $this->get('extent');
            $height = $this->get('height');
            $width = $this->get('width');
            
            return mapPointToImagePoint($map_point, $extent, $width, $height);
        }
    
    function imagePointToRefMapPoint($image_point) 
        {
            $reference =& $this->get('reference');

            $extent = $reference->extent;
            $height = $reference->height;
            $width = $reference->width;
            
            return imagePointToMapPoint($image_point, $extent, $width, $height);
        }

    function refMapPointToImagePoint($map_point) 
        {
            $reference =& $this->get('reference');

            $extent = $reference->extent;
            $height = $reference->height;
            $width = $reference->width;
            
            return mapPointToImagePoint($map_point, $extent, $width, $height);
        }


    // TESTS
    
    function zoomedToMinScale() 
        {
            $web =& $this->get('web');

            $minscale = $web->minscale;

            if ($minscale == -1)
                return false;
            
            $scale = $this->get('scale');

            if ($scale != -1 and $scale <= $minscale)
                return true;
            
            return false;
        }
    
    function zoomedToMaxScale() 
        {
            $web =& $this->get('web');

            $maxscale = $web->maxscale;

            if ($maxscale == -1)
                return false;
            
            $scale = $this->get('scale');

            if ($scale != -1 and $scale >= $maxscale)
                return true;
            
            return false;
        }

    function zoomedToMaxExtent() 
        {
            $max_extent = $this->getMaxExtent();
            $extent =& $this->get('extent');

            if (($extent->minx <= $max_extent->minx) and
                ($extent->miny <= $max_extent->miny) and
                ($extent->maxx >= $max_extent->maxx) and
                ($extent->maxy >= $max_extent->maxy)) {
                return true;
            }

            return false;
        }
    

    // ZOOM METHODS

    function zoom() 
        {
            $zoom_type = $this->getZoomType();

            switch($zoom_type) {
            case MM_ZOOM_NONE:
                return false;
            case MM_ZOOM_IN:
                $this->zoomInToMapClick();
                break;
            case MM_ZOOM_OUT:
                $this->zoomOutToMapClick();
                break;
            case MM_ZOOM_PAN:
                $this->panToMapClick();
                break;
            case MM_ZOOM_SCALE:
                if (!$zoom_scale = $this->getZoomScale())
                    trigger_error('No zoom scale has been set', E_USER_ERROR);                
                $this->zoomToScale($zoom_scale);
                break;
            case MM_ZOOM_EXTENT:
                if (!$zoom_extent = $this->getZoomExtent())
                    trigger_error('No zoom extent has been set', E_USER_ERROR);
                $this->zoomToExtent($zoom_extent);
                break;
            default:
                trigger_error('Unknown zoom type', E_USER_ERROR);
            }

            return true;
        }

    function zoomToExtent($extent) 
        {
            $width = $this->get('width');
            $height = $this->get('height');
            $pixel_extent = ms_newRectObj();
            $pixel_extent->setextent(0, $height, $width, 0);
            $max_extent = $this->getMaxExtent();

            $this->preparequery();
            $this->zoomrectangle($pixel_extent, $width, $height, $extent, $max_extent);
        }

    function zoomToScale($scale) 
        {
            $width = $this->get('width');
            $height = $this->get('height');
            $pixel_pos = ms_newPointObj();
            $x = round($width / 2);
            $y = round($height / 2);
            $pixel_pos->setXY($x, $y);
            $extent =& $this->get('extent');
            $max_extent = $this->getMaxExtent();

            $this->zoomscale($scale, $pixel_pos, $width, $height, $extent, $max_extent);
        }

    function zoomToPoint($map_point, $zoom_level) 
        {
            // check to ensure the zoom request is valid
            if (($zoom_level == 1) and $this->zoomedToMaxExtent()) // trying to pan at maximum extent
                return;
            elseif (($zoom_level > 1) and $this->zoomedToMinScale()) // trying to zoom in further than the minimum scale
                return;
            elseif (($zoom_level < 1) and ($this->zoomedToMaxScale() or $this->zoomedToMaxExtent()))    // trying to zoom out further than allowed
                return;

            $image_point = $this->mapPointToImagePoint($map_point);
            
            $width = $this->get('width');
            $height = $this->get('height');
            $extent =& $this->get('extent');
            $max_extent = $this->getMaxExtent();
            
            $this->zoompoint($zoom_level, $image_point, $width, $height, $extent, $max_extent);
        }

    function panToPoint($map_point) 
        {
            $this->zoomToPoint($map_point, 1);
        }

    function zoomInToPoint($map_point) 
        {
            $zoom_level = $this->getZoomLevel();
            $this->zoomToPoint($map_point, $zoom_level);
        }

    function zoomOutToPoint($map_point) 
        {
            $zoom_level = $this->getZoomLevel();
            $this->zoomToPoint($map_point, -$zoom_level);
        }

    function zoomOutToMapClick() 
        {
            $map_click = $this->getMapClick();

            if (!$map_click)
                return false;

            $this->zoomOutToPoint($map_click);
            return true;
        }

    function panToMapClick() 
        {
            $map_click = $this->getMapClick();

            if (!$map_click)
                return false;

            $this->panToPoint($map_click);
            return true;
        }
    
    function zoomInToMapClick() 
        {
            $map_click = $this->getMapClick();

            if (!$map_click)
                return false;
            
            $this->zoomInToPoint($map_click);
            return true;
        }
    
    // OVERRIDDEN METHODS
    
    function draw() 
        {
            $imageObj = $this->prepareImage();
            
            $postlabelcache = array();

            foreach ($this->getlayersdrawingorder() as $index) 
                {
                    $layer = $this->getLayer($index);

                    if ($layer->postlabelcache != MS_TRUE)
                        $this->drawLayer($layer, $imageObj);
                    else
                        $postlabelcache[] = $layer;
                }

            $legend =& $this->get('legend');
            if ($legend->status == MS_EMBED)
                $this->embedlegend($imageObj);

            $scalebar =& $this->get('scalebar');
            if ($scalebar->status == MS_EMBED) 
                $this->embedScalebar($imageObj);

            $this->drawLabelCache($imageObj);

            foreach ($postlabelcache as $layer)
                {
                    $this->drawLayer($layer, $imageObj);
                }
            
            return $imageObj;
        }

    function drawLayer($layer, &$imageObj) 
        {
            if ($layer->status == MS_OFF)
                return;
            
            if (!$this->layerRendererExists($layer->name)) {
                if (!$this->layerIsQueryable($layer->name)) {
                    $layer->draw($imageObj);
                } else {
                    $layer->drawQuery($imageObj);
                }
            } else {
                $callback = $this->getLayerRenderer($layer->name);
                call_user_func($callback, $imageObj);
            }
        }

    /***************************************************
     * Serialisation INTERFACE
     ***************************************************/
    
    function __wakeup() 
        {
            parent::__wakeup();

            if ($this->max_extent)
                $this->setMaxExtent(stringToRect($this->max_extent));

            if ($this->zoom_extent)
                $this->setZoomExtent(stringToRect($this->zoom_extent));
            
            // zoom to exactly the same place in order to properly initialise the map object (i.e. scale property)
            $this->zoomToExtent($this->get('extent'));
        }
    
    function __sleep() 
        {
            $sleep_vars = parent::__sleep();

            if ($max_extent = $this->getMaxExtent())
                $this->max_extent = rectToString($max_extent);

            if ($zoom_extent = $this->getZoomExtent())
                $this->zoom_extent = rectToString($zoom_extent);
            
            array_push($sleep_vars, 'max_extent', 'zoom_level', 'layer_renderers', 'zoom_type', 'zoom_scale', 'zoom_extent');
            return $sleep_vars;
        }
}

?>

---