File "groupsAndLayers.phtml"
Full path: /www/map/mapserver-extensions/pmapper-4.2.0/plugins/common/groupsAndLayers.phtml
File size: 13.9 KiB (14235 bytes)
MIME-type: text/x-php
Charset: utf-8
<?php
/******************************************************************************
*
* Purpose: Common functions used in plugins
* Author: Thomas Raffin, SIRAP
*
******************************************************************************
*
* Copyright (c) 2007 SIRAP
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. See the COPYING file.
*
* The software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with p.mapper; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
******************************************************************************/
/**
* Return an array of layers, depending of the name of a layer or a group
* It is possible to pass an array in parameter
*/
function getLayersByGroupOrLayerName($map, $groupOrLayer) {
$mapLayers = Array();
if ($map) {
if (is_array($groupOrLayer)) {
$manyGroupOrLayer = $groupOrLayer;
} else {
$manyGroupOrLayer = explode(",", $groupOrLayer);
}
foreach($manyGroupOrLayer as $oneGroupOrLayer) {
$oneGroupOrLayer = trim($oneGroupOrLayer);
if ($oneGroupOrLayer) {
// If we are searching a group (not a layer) :
$mapLayersIndexes = $map->getLayersIndexByGroup($oneGroupOrLayer);
if ($mapLayersIndexes) {
foreach ($mapLayersIndexes as $iLayerIndex) {
$mapLayer = $map->getLayer($iLayerIndex);
if ($mapLayer) {
$mapLayers[] = $mapLayer;
}
}
} else {
$mapLayer = @$map->getLayerByName($oneGroupOrLayer);
if ($mapLayer) {
$mapLayers[] = $mapLayer;
}
}
}
}
}
return $mapLayers;
}
/**
* highlight object :
* (from map.phtml : PMAP::pmap_addResultLayer)
*/
function addResultLayer($map, $reslayer, $shpindexes, $shptileindexes=-1) {
// $qLayer = $map->getLayerByName($reslayer);
$qLayers = getLayersByGroupOrLayerName($map, $reslayer);
if ($qLayers) {
$qLayer = $qLayers[0];
if ($qLayer) {
$qlayType = $qLayer->type;
$layNum = count($map->getAllLayerNames());
// Test if layer has the same projection as map
$mapProjStr = $map->getProjection();
$qLayerProjStr = $qLayer->getProjection();
$changeLayProj = false;
if ($mapProjStr && $qLayerProjStr && $mapProjStr != $qLayerProjStr) {
$changeLayProj = true;
$mapProjObj = ms_newprojectionobj($mapProjStr);
$qLayerProjObj = ms_newprojectionobj($qLayerProjStr);
}
// New result layer
if ($_SESSION['PM_TPL_MAP_FILE']) {
// load from template map file
$hlDynLayer = 0;
$hlMap = ms_newMapObj($_SESSION['PM_TPL_MAP_FILE']);
$hlMapLayer = $hlMap->getLayerByName("highlight_$qlayType");
$newResLayer = ms_newLayerObj($map, $hlMapLayer);
} else {
// create dynamically
$hlDynLayer = 1;
$newResLayer = ms_newLayerObj($map);
$newResLayer->set("name", "reslayer");
if ($qlayType == 0) {
$newResLayer->set("type", 0); // Point for point layer
} elseif ($qlayType == 1 || $qlayType == 2) {
$newResLayer->set("type", 1); // Line for line && polygon layers
}
##$newResLayer->set("type", $qlayType); // Take always same layer type as layer itself
}
// Add selected shape to new layer
//# when layer is an event theme
if ($qLayer->getMetaData("XYLAYER_PROPERTIES") != "") {
foreach ($shpindexes as $cStr) {
$cList = preg_split('/@/', $cStr);
$xcoord = $cList[0];
$ycoord = $cList[1];
$resLine = ms_newLineObj(); // needed to use a line because only a line can be added to a shapeObj
$resLine->addXY($xcoord, $ycoord);
$resShape = ms_newShapeObj(1);
$resShape->add($resLine);
$newResLayer->addFeature($resShape);
}
//# specific for PG layers <==== required for MS >= 5.6 !!!
} elseif ($qLayer->connectiontype == 6) {
$newResLayer->set("connection", $qLayer->connection);
if (method_exists($newResLayer, "setConnectionType")) {
$newResLayer->setConnectionType($qLayer->connectiontype);
} else {
$newResLayer->set("connectiontype", $qLayer->connectiontype);
}
$data = $qLayer->data;
// use layers with complex queries that are too long to select results
// cause maxscaledenom is not used...
if ($qLayer->getMetaData("PM_RESULT_DATASUBSTITION") != "") {
$data = $qLayer->getMetaData("PM_RESULT_DATASUBSTITION");
}
$newResLayer->set("data", $data);
if ($qLayerProjStr) $newResLayer->setProjection($qLayerProjStr);
$glList = PMCommon::returnGroupGlayer($reslayer);
$glayer = $glList[1];
$layerDbProperties = $glayer->getLayerDbProperties();
$uniqueField = $layerDbProperties['unique_field'];
$idFilter = $uniqueField . ' IN (' . (implode(",", $shpindexes)) . ')';
$newResLayer->setFilter($idFilter);
//# 'normal' layers
} else {
// Add selected shape to new layer
// use layers with complex queries that are too long to select results
// cause maxscaledenom is not used...
$olddata = false;
if ($qLayer->getMetaData("PM_RESULT_DATASUBSTITION") != "") {
$olddata = $qLayer->data;
$qLayer->set("data", $qLayer->getMetaData("PM_RESULT_DATASUBSTITION"));
}
$msVersion = $_SESSION['MS_VERSION'];
$qLayer->open();
foreach ($shpindexes as $resShpIdx) {
if (preg_match("/@/", $resShpIdx)) {
$idxList = explode("@", $resShpIdx);
$resTileShpIdx = $idxList[0];
$resShpIdx = $idxList[1];
} else {
$resTileShpIdx = $shptileindexes;
}
$resShape = PMCommon::resultGetShape($msVersion, $qLayer, null, $resShpIdx, $resTileShpIdx);
// Change projection to map projection if necessary
if ($changeLayProj) {
// If error appears here for Postgis layers, then DATA is not defined properly as:
// "the_geom from (select the_geom, oid, xyz from layer) AS new USING UNIQUE oid USING SRID=4258"
$resShape->project($qLayerProjObj, $mapProjObj);
}
$newResLayer->addFeature($resShape);
}
$qLayer->close();
// use layers with complex queries that are too long to select results
// cause maxscaledenom is not used...
// reset data tag
if ($olddata) {
$qLayer->set('data', $olddata);
}
}
$newResLayer->set("status", MS_ON);
$newResLayerIdx = $newResLayer->index;
if ($hlDynLayer) {
// SELECTION COLOR
$iniClrStr = trim($_SESSION["highlightColor"]);
$iniClrList = preg_split('/[\s,]+/', $iniClrStr);
$iniClr0 = $iniClrList[0];
$iniClr1 = $iniClrList[1];
$iniClr2 = $iniClrList[2];
// CREATE NEW CLASS
$resClass = ms_newClassObj($newResLayer);
$clStyle = ms_newStyleObj($resClass);
$clStyle->color->setRGB($iniClr0, $iniClr1, $iniClr2);
$clStyle->set("symbolname", "circle");
$symSize = ($qlayType < 1 ? 10 : 5);
$clStyle->set("size", $symSize);
}
// Move layer to top (is it working???)
//$layOrder = $map->getLayersDrawingOrder();
while ($newResLayerIdx < ($layNum-1)) {
$map->moveLayerUp($newResLayerIdx);
}
}
}
}
/**
* Return groups available in array
*/
function getAvailableGroups($map, $onlyChecked, $onlyNonRasters, $onlyVisibleAtScale, $onlyQueryable = true, $onlyInCategories = false) {
// only checked groups :
if ($onlyChecked) {
$groupsStep1 = $_SESSION["groups"];
} else {
$groupsStep1 = $_SESSION["allGroups"];
}
$groupsStep2 = Array();
$scale = $_SESSION["geo_scale"];
$grouplist = $_SESSION["grouplist"];
foreach ($grouplist as $grp){
if (in_array($grp->getGroupName(), $groupsStep1, TRUE)) {
$glayerList = $grp->getLayers();
foreach ($glayerList as $glayer) {
$mapLayer = $map->getLayer($glayer->getLayerIdx());
$groupOk = true;
// no raster layers / groups :
if ($groupOk && $onlyNonRasters) {
if ($mapLayer->type >= 3) {
$groupOk = false;
}
}
// only visible layers / groups depending on scale :
if ($groupOk && $onlyVisibleAtScale) {
if (PMCommon::checkScale($map, $mapLayer, $scale) <> 1) {
$groupOk = false;
}
}
if ($groupOk && $onlyQueryable) {
$hasTemplate = 0;
if ($mapLayer->template) {
$hasTemplate = 1;
}
if (!$hasTemplate) {
$numclasses = $mapLayer->numclasses;
for ($cl=0; $cl < $numclasses; $cl++) {
$class = $mapLayer->getClass($cl);
$classTemplate = $class->template;
if ($class->template) {
$hasTemplate = 1;
break;
}
}
}
$groupOk = $hasTemplate;
}
if ($groupOk) {
$groupsStep2[] = $grp;
break;
}
}
}
}
// only layers in categories
$groupsStep3 = Array();
if ($onlyInCategories) {
// get Categories
require_once($_SESSION['PM_INCPHP'] . "/layerview.phtml");
$layerView = new LayerView($map, false, false);
$categoryList = $layerView->getCategoryList();
if (count($categoryList) > 0) {
foreach ($categoryList as $cat) {
$catGrps = $cat['groups'];
$categoriesGroups = Array();
foreach ($catGrps as $catGrp) {
if ($catGrp) {
$catGrpName = $catGrp['name'];
foreach ($groupsStep2 as $grp) {
$grpName = $grp->getGroupName();
if ($catGrpName === $grpName) {
$groupsStep3[] = $grp;
}
}
}
}
}
}
} else {
$groupsStep3 = $groupsStep2;
}
return $groupsStep3;
}
/**
* Return the layer list with opacity to use
*
* $retVal = (in INI configuration file) defining the name of the paremeter to read
*
* return an array of "name => opacity"
*/
function getConfigLayersAndOpacities($ini, $paramName) {
$retVal = Array();
if ($paramName) {
$list = isset($ini[$paramName]) ? $ini[$paramName] : "";
if ($list) {
$layersAndOpacities = explode(",", $list);
if ($layersAndOpacities) {
foreach ($layersAndOpacities as $layerAndOpacity) {
$arrayTmp = explode(":", $layerAndOpacity);
if ($arrayTmp[0]) {
$retVal[$arrayTmp[0]] = $arrayTmp[1] ? (integer) $arrayTmp[1] : "map";
}
}
}
}
}
return $retVal;
}
/**
* Return name and header fields for the pmapper layer specified
*
* The result array contain:
* - string lists (use valuesToUseTxt and valuesToShowTxt keys)
* - arrays (use valuesToUse and valuesToShow keys)
*/
function getAttributsRealAndReadNames($layerName) {
$retVal = array();
$valuesToUse = array();
$valuesToShow = array();
if (strlen($layerName) > 0) {
$grouplist = $_SESSION['grouplist'];
if ($grouplist) {
$group = false;
if (array_key_exists($layerName, $grouplist)) {
$group = $grouplist[$layerName];
} else {
$found = false;
foreach ($grouplist as $grp) {
if ($grp && is_a($grp, 'GROUP')) {
$glayerList = $grp->getLayers();
foreach ($glayerList as $glayer) {
if ($glayer->getLayerName() == $layerName) {
$group = $grp;
$found = true;
break;
}
}
if ($found) {
break;
}
}
}
}
if ($group && is_a($group, 'GROUP')) {
$valuesToShow = $group->getResHeaders();
$layers = $group->getLayers();
if ($layers) {
$firstLayer = $layers[0];
if ($firstLayer) {
$valuesToUse = $firstLayer->getResFields();
}
}
}
}
}
$valuesToUseTxt = implode(',', $valuesToUse);
$valuesToShowTxt = implode(',', $valuesToShow);
$retVal["valuesToUseTxt"] = $valuesToUseTxt;
$retVal["valuesToShowTxt"] = $valuesToShowTxt;
$retVal["valuesToUse"] = $valuesToUse;
$retVal["valuesToShow"] = $valuesToShow;
return $retVal;
}
/*
* change SESSION['grouplist']:
*/
function updateGroupList($map) {
// get original opacities:
// this require should be done before session_start!!!
//require_once($_SESSION['PM_INCPHP'] . '/group.phtml');
$grouplist = $_SESSION['grouplist'];
$opacities = array();
foreach ($grouplist as $grp) {
$glayerList = $grp->getLayers();
foreach ($glayerList as $glayer) {
$opacities[$glayer->getLayerName()] = $glayer->getOpacity();
}
}
// change SESSION['grouplist']:
require_once($_SESSION['PM_INCPHP'] . '/initgroups.phtml');
$iG = new Init_groups($map, $_SESSION['allGroups'], $_SESSION['gLanguage'], true);
$iG->createGroupList();
//restore opacity:
$grouplist = $_SESSION['grouplist'];
foreach ($grouplist as $grp) {
$glayerList = $grp->getLayers();
foreach ($glayerList as $glayer) {
$name = $glayer->getLayerName();
if (isset($opacities[$name])) {
$opacity = $opacities[$name];
$glayer->setOpacity($opacity);
}
}
}
}
?>