/**
* EXECUTE QUERY
*/
public function q_execMapQuery()
{
//--------------------------------
// Initialize tolerance to 0
//--------------------------------
$msLayers = array();
// query in specified groups only:
if (isset($_REQUEST['groups']) && $_REQUEST['groups']) {
$msLayers = getLayersByGroupOrLayerName($this->map, $_REQUEST['groups']);
// all groups:
} else {
for ($i = 0; $i < $this->map->numlayers; $i++) {
$msLayers[] = $this->map->getLayer($i);
}
}
foreach ($msLayers as $msLayer) {
// change tolerance only for buffer zone search.
if ($this->queryType == 'object') {
$msLayer->set('tolerance', 0);
}
}
// Modified by Thomas RAFFIN (SIRAP)
// to test (substitution)
// query by point
// Modified by Thomas RAFFIN (SIRAP)
// use layers with complex queries that are too long to select results
// cause maxscaledenom is not used...
$oldDatas = array();
for ($i = 0; $i < $this->map->numlayers; $i++) {
$qLayer = $this->map->getLayer($i);
$layerName = $qLayer->name;
if ($qLayer->getMetaData('PM_RESULT_DATASUBSTITION') != '') {
$oldDatas[$layerName] = $qLayer->data;
$qLayer->set('data', $qLayer->getMetaData('PM_RESULT_DATASUBSTITION'));
}
}
// few lines from incphp/query/query.php
// Patch from Alessandro Pasotti for fixing problems with result returned
$this->map->setSize($this->mapwidth, $this->mapheight);
// Set $this->map->extent to values of current map extent
// otherwise values of TOLERANCE in map file are not interpreted correctly
$this->map->setExtent($this->GEOEXT['minx'], $this->GEOEXT['miny'], $this->GEOEXT['maxx'], $this->GEOEXT['maxy']);
$this->map->preparequery();
if ($this->queryType == 'object') {
if (isset($_SESSION['pluginsConfig']['graphicalqueries']) && isset($_SESSION['pluginsConfig']['graphicalqueries']['bufferOnlyWithScale'])) {
$bufferOnlyWithScale = $_SESSION['pluginsConfig']['graphicalqueries']['bufferOnlyWithScale'] == 1;
} else {
$bufferOnlyWithScale = true;
}
if (!$bufferOnlyWithScale) {
// PMCommon::setGroups($this->map, $this->querygroups, $this->scale, 0, 1);
PMCommon::setGroups($this->map, $this->querygroups, 0, 0, 1);
}
// Search selected object
$jsonPMResult = $_SESSION['JSON_Results'];
// "[...]" ou "{...}"
$PMResult = json_decode($jsonPMResult);
// array ou class
if ($PMResult) {
$objUnion = false;
// List layer of selected object
$layersWithResult = $PMResult[0];
// be carreful : 0.000000001 is too small !!
$smallBuffer = 1.0E-8;
$mapProjStr = $this->map->getProjection();
if ($_SESSION['MS_VERSION'] < 6) {
$mapProjObj = ms_newprojectionobj($mapProjStr);
} else {
$mapProjObj = new projectionObj($mapProjStr);
}
// Loop on layers
$layerName = '';
foreach ($layersWithResult as $layerWithResult) {
$objUnionLayer = false;
// init layer to close the last open one
$layer = false;
$layerProjObj = false;
// Loop on layer objects
foreach ($layerWithResult->values as $selectedObject) {
// layer name
$currentLayerName = $selectedObject[0]->shplink[0];
if ($currentLayerName != $layerName) {
if ($layer) {
$layer->close();
}
$layerName = $currentLayerName;
$layer = $this->map->getLayerByName($layerName);
$layerProjObj = false;
$layerProjStr = $layer->getProjection();
if ($mapProjStr && $layerProjStr && $mapProjStr != $layerProjStr) {
if ($_SESSION['MS_VERSION'] < 6) {
$layerProjObj = ms_newprojectionobj($layerProjStr);
} else {
$layerProjObj = new projectionObj($layerProjStr);
}
}
$layer->open();
}
$shpIndex = $selectedObject[0]->shplink[1];
// Retrieve shape by its index.
$objShape = PMCommon::resultGetShape($_SESSION['MS_VERSION'], $layer, null, $shpIndex, -1);
// changed for compatibility with PG layers and MS >= 5.6
// reproject
if ($layerProjObj) {
$objShape->project($layerProjObj, $mapProjObj);
}
// Union of the shapes
if ($objUnionLayer) {
$objUnionLayer = $objShape->union($objUnionLayer);
} else {
$objUnionLayer = $objShape;
}
}
// End foreach : Loop of the layer
// close layer if exists
if ($layer) {
$layer->close();
}
if ($objUnionLayer) {
// Line : Buffer to convert Line or Point to Polygon
if ($objUnionLayer->type == MS_SHAPE_LINE && isset($_REQUEST['select_buffer']) && $_REQUEST['select_buffer'] > 0 || $objUnionLayer->type == MS_SHAPE_POINT) {
$objUnionLayer = $objUnionLayer->buffer($smallBuffer);
// if polygon -> the outline is removed to not select contiguous objects
} else {
if ($objUnionLayer->type == MS_SHAPE_POLYGON && !isset($_REQUEST['select_buffer'])) {
$objBoundary = $objUnionLayer->boundary();
$objBoundary = $objBoundary->buffer($smallBuffer);
$objUnionLayer = $objUnionLayer->difference($objBoundary);
}
}
}
if ($objUnionLayer) {
if ($objUnion) {
$objUnion = $objUnion->union($objUnionLayer);
} else {
$objUnion = $objUnionLayer;
}
}
// End if($objUnionLayer)
}
// End foreach : loop of layers
// Buffer -> Buffer zone
if (isset($_REQUEST['select_buffer'])) {
if ($objUnion) {
$objUnion = $objUnion->buffer($_REQUEST['select_buffer']);
unset($_REQUEST['select_buffer']);
}
}
if ($objUnion) {
// Query
@$this->map->queryByShape($objUnion);
}
}
// Query by point
} else {
if ($this->queryType == 'point') {
$tmpPoint = ms_newPointObj();
$tmpPoint->setXYZ($_REQUEST['select_pointX'], $_REQUEST['select_pointY'], 0);
if (isset($_REQUEST['select_buffer'])) {
@$this->map->queryByPoint($tmpPoint, MS_MULTIPLE, $_REQUEST['select_buffer']);
} else {
@$this->map->queryByPoint($tmpPoint, MS_MULTIPLE, -1);
}
PMCommon::freeMsObj($tmpPoint);
// query by Shape
} else {
if ($this->queryType == 'polygon') {
//'shape')
$poly = $_REQUEST['select_poly'];
$tmpLine = ms_newLineObj();
$tmpPoly = explode(',', $poly);
foreach ($tmpPoly as $point) {
$tmpTab = explode(' ', $point);
$tmpLine->addXY($tmpTab[0], $tmpTab[1]);
}
$objPoly = ms_newShapeObj(MS_SHAPE_POLYGON);
$objPoly->add($tmpLine);
// Buffer -> Buffer zone
if (isset($_REQUEST['select_buffer'])) {
$objPoly = $objPoly->buffer($_REQUEST['select_buffer']);
unset($_REQUEST['select_buffer']);
}
@$this->map->queryByShape($objPoly);
PMCommon::freeMsObj($tmpLine);
PMCommon::freeMsObj($objPoly);
// query by PolyLine
} else {
if ($this->queryType == 'line') {
$poly = $_REQUEST['select_line'];
$tmpLine = ms_newLineObj();
$tmpPoly = explode(',', $poly);
foreach ($tmpPoly as $point) {
$tmpTab = explode(' ', $point);
$tmpLine->addXY($tmpTab[0], $tmpTab[1]);
}
// Reduce the polygon to a polyline
for ($i = count($tmpPoly) - 1; $i >= 0; $i--) {
$tmpTab = explode(' ', $tmpPoly[$i]);
$tmpLine->addXY($tmpTab[0], $tmpTab[1]);
}
$objPoly = ms_newShapeObj(MS_SHAPE_POLYGON);
$objPoly->add($tmpLine);
// Buffer -> Buffer zone
if (isset($_REQUEST['select_buffer'])) {
$bufferLocal = $_REQUEST['select_buffer'];
if ($bufferLocal < 0) {
$bufferLocal = 0;
}
$objPoly = $objPoly->buffer($bufferLocal);
unset($_REQUEST['select_buffer']);
}
@$this->map->queryByShape($objPoly);
PMCommon::freeMsObj($tmpLine);
PMCommon::freeMsObj($objPoly);
// query by circle
} else {
if ($this->queryType == 'circle') {
$point = $_REQUEST['select_point'];
$radius = $_REQUEST['select_radius'];
$tmpPoint = ms_newPointObj();
$tmpTab = explode(' ', $point);
$tmpPoint->setXYZ($tmpTab[0], $tmpTab[1], 0);
if (isset($_REQUEST['select_buffer'])) {
@$this->map->queryByPoint($tmpPoint, MS_MULTIPLE, $radius + $_REQUEST['select_buffer']);
} else {
@$this->map->queryByPoint($tmpPoint, MS_MULTIPLE, $radius);
}
PMCommon::freeMsObj($tmpPoint);
}
}
}
}
}
// Modified by Thomas RAFFIN (SIRAP)
// use layers with complex queries that are too long to select results
// cause maxscaledenom is not used...
// reset data tag
foreach ($oldDatas as $qLayer => $oldData) {
$qLayer = $this->map->getLayerByName($qLayer);
$qLayer->set('data', $oldData);
}
}
/**
* highlight object :
* (from map.php : 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;
if ($_SESSION['MS_VERSION'] < 6) {
$mapProjObj = ms_newprojectionobj($mapProjStr);
$qLayerProjObj = ms_newprojectionobj($qLayerProjStr);
} else {
$mapProjObj = new projectionObj($mapProjStr);
$qLayerProjObj = new projectionObj($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'];
$indexesStr = implode(",", $shpindexes);
$idFilter = "({$uniqueField} IN ({$indexesStr}))";
$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);
}
}
}
}
private function activateLayers()
{
// unactivate all layers:
$numLayers = $this->internalMap->numlayers;
for ($iLayer = 0; $iLayer < $numLayers; $iLayer++) {
$layer = $this->internalMap->getLayer($iLayer);
$layer->set('status', MS_OFF);
}
// activate layers:
$layers = getLayersByGroupOrLayerName($this->internalMap, $this->groupNames);
foreach ($layers as $layer) {
$layer->set('status', MS_ON);
}
}
$doLabels = $_SESSION['sizeUpDownObj']['doLabels'];
$configLabelMinSize = $_SESSION['sizeUpDownObj']['configLabelMinSize'];
$msVersion = $_SESSION['MS_VERSION'];
// layers array to increase or decrease size
$layerArray = $_SESSION['sizeUpDownObj']['layers'];
foreach ($layerArray as $layerName => $multiplicator) {
if ($multiplicator != 0) {
// check number of application of the factor
if ($multiplicator > 0) {
$multiplicator = $multiplicator > $maxSizeUpIterator ? $maxSizeUpIterator : $multiplicator;
} else {
$multiplicator = $multiplicator < $minSizeDownIterator ? $minSizeDownIterator : $multiplicator;
}
$factmulti = $multiplicator > 0 ? abs($factor * $multiplicator) : 1 / abs($factor * $multiplicator);
// change size for each layer
$layers = getLayersByGroupOrLayerName($map, $layerName);
foreach ($layers as $layer) {
$numClassesObj = $layer->numclasses;
for ($iClass = 0; $iClass < $numClassesObj; $iClass++) {
$classObj = $layer->getClass($iClass);
$numStylesObj = $classObj->numstyles;
for ($iStyle = 0; $iStyle < $numStylesObj; $iStyle++) {
$styleObj = $classObj->getStyle($iStyle);
// size
$newStyleMinSize = abs($styleObj->minsize * $factmulti);
$sizeTmp = $newStyleMinSize < $styleDefaultMinSize ? $styleDefaultMinSize : $newStyleMinSize;
$styleObj->set('minsize', $sizeTmp);
$styleMinSize = $styleObj->minsize;
$newStyleSize = abs($styleObj->size * $factmulti);
$sizeTmp = $newStyleSize < $styleMinSize ? $styleMinSize : $newStyleSize;
$styleObj->set('size', $sizeTmp);
public static function calculateExtent($map, $groups, $applyMapExtentIfNull = false, $addBuffer = false)
{
$mapExtent = ms_newrectObj();
$layers = getLayersByGroupOrLayerName($map, $groups);
foreach ($layers as $layer) {
$layerExtent = false;
if ($layer) {
if ($layer->connectiontype == MS_POSTGIS || $layer->connectiontype == MS_ORACLESPATIAL) {
//get dns string containing : type of database, user name, password, host and database.
$dsn = PluginsMapUtils::getDSNConnection($layer);
if ($dsn) {
// code from mapserver mailing list (by Armin Burger):
// get table and filter :
$data = PluginsMapUtils::getQueryParamsFromDataString($layer, false, false);
$mapLayerFilter = $data['mapLayerFilter'];
$fromTable = $data['fromTable'];
$geomFld = $data['geomFld'];
$sql = 'SELECT ST_xmin(extent) AS minx, ST_ymin(extent) AS miny, ST_xmax(extent) AS maxx, ST_ymax(extent) AS maxy ';
$sql .= "FROM (SELECT St_Extent({$geomFld}) AS extent FROM {$fromTable} ";
$sql .= ($mapLayerFilter ? "WHERE {$mapLayerFilter}" : '') . ' ';
$sql .= ') AS bar';
$sql .= ' WHERE extent IS NOT NULL';
pm_logDebug(4, "calculateExtent - sql:{$sql}");
// DB:
require_once dirname(__FILE__) . '/easyMDB2.inc.php';
$edb = new Easy_MDB2();
$edb->setDSN($dsn);
$edb->start();
$qresultE = $edb->selectByQuery($sql, '');
$resValues = $qresultE['values'][0];
if ($resValues) {
$resIsValid = true;
foreach ($resValues as $val) {
if (!isset($val) || $val == 0 || $val == -1) {
$resIsValid = false;
break;
}
}
if ($resIsValid) {
$layerExtent = ms_newRectObj();
$layerExtent->setExtent($resValues['minx'], $resValues['miny'], $resValues['maxx'], $resValues['maxy']);
}
}
}
} else {
if ($layer->type != MS_LAYER_RASTER && ($layer->connectiontype == MS_SHAPEFILE || $layer->connectiontype == MS_TILED_SHAPEFILE || $layer->connectiontype == MS_OGR)) {
// SHP layer, OGR layer
$layerExtent = @$layer->getExtent();
}
}
if ($layerExtent) {
// change projection
$mapProjStr = $map->getProjection();
$layerProjStr = $layer->getProjection();
if ($mapProjStr && $layerProjStr && $mapProjStr != $layerProjStr) {
if ($_SESSION['MS_VERSION'] < 6) {
$mapProjObj = ms_newprojectionobj($mapProjStr);
$layerProjObj = ms_newprojectionobj($layerProjStr);
} else {
$mapProjObj = new projectionObj($mapProjStr);
$layerProjObj = new projectionObj($layerProjStr);
}
$layerExtent->project($layerProjObj, $mapProjObj);
}
// add buffer around freshly calculated extent
if ($addBuffer) {
$minx = $layerExtent->minx;
$miny = $layerExtent->miny;
$maxx = $layerExtent->maxx;
$maxy = $layerExtent->maxy;
$pointBuffer = isset($_SESSION['pointBuffer']) ? $_SESSION['pointBuffer'] : 50;
$shapeQueryBuffer = isset($_SESSION['shapeQueryBuffer']) ? $_SESSION['shapeQueryBuffer'] : 0.01;
$buf = 0;
if ($layer->type == MS_LAYER_POINT || $layer->type == MS_LAYER_ANNOTATION) {
$buf = $pointBuffer;
// set buffer depending on dimensions of your coordinate system
} else {
if (isset($shapeQueryBuffer) && $shapeQueryBuffer > 0) {
$buf = $shapeQueryBuffer * (($maxx - $minx + ($maxy - $miny)) / 2);
}
}
if ($buf > 0) {
$minx -= $buf;
$miny -= $buf;
$maxx += $buf;
$maxy += $buf;
$layerExtent->setExtent($minx, $miny, $maxx, $maxy);
}
}
if ($mapExtent->minx == -1 && $mapExtent->miny == -1 && $mapExtent->maxx == -1 && $mapExtent->maxy == -1) {
$minx = $layerExtent->minx;
$miny = $layerExtent->miny;
$maxx = $layerExtent->maxx;
$maxy = $layerExtent->maxy;
} else {
$minx = $layerExtent->minx < $mapExtent->minx ? $layerExtent->minx : $mapExtent->minx;
$miny = $layerExtent->miny < $mapExtent->miny ? $layerExtent->miny : $mapExtent->miny;
$maxx = $layerExtent->maxx > $mapExtent->maxx ? $layerExtent->maxx : $mapExtent->maxx;
$maxy = $layerExtent->maxy > $mapExtent->maxy ? $layerExtent->maxy : $mapExtent->maxy;
}
$mapExtent->setExtent($minx, $miny, $maxx, $maxy);
}
}
}
if ($mapExtent->minx == -1 || $mapExtent->miny == -1 || $mapExtent->maxx == -1 || $mapExtent->maxy == -1) {
$mapExtent = $map->extent;
if (!$applyMapExtentIfNull) {
$mapExtent->setExtent(0, 0, 1, 1);
}
}
return $mapExtent;
}
