Example #1
0
 private function url_createLayer()
 {
     if (!is_file($_SESSION['PM_TPL_MAP_FILE'])) {
         error_log("P.MAPPER ERROR: cannot find template map. Check INI settings for 'tplMapFile'");
         return false;
     }
     $tplMap = ms_newMapObj($_SESSION['PM_TPL_MAP_FILE']);
     $poiLayer = $tplMap->getLayerByName("poi");
     $txtLayer = ms_newLayerObj($this->map, $poiLayer);
     $txtLayer->set("name", "url_txtlayer");
     $txtLayer->set("type", 0);
     $txtLayer->set("status", MS_ON);
     $url_points = $_SESSION['url_points'];
     foreach ($url_points as $upnt) {
         // Create line, add xp point, create shape and add line and text, add shape to layer
         //$pointList = explode(",", $f);
         $px = $upnt[0];
         $py = $upnt[1];
         $txt = $upnt[2];
         $newLine = ms_newLineObj();
         $newLine->addXY($px, $py);
         $newShape = ms_newShapeObj(0);
         $newShape->add($newLine);
         $newShape->set("text", $txt);
         $txtLayer->addFeature($newShape);
     }
 }
Example #2
0
function addPoint($row, $lon, $lat, $name)
{
    global $shpFile, $dbfFile;
    // Create the shape
    $shp = ms_newShapeObj(MS_SHAPE_POINT);
    $pt = ms_newPointobj();
    $pt->setXY($lon, $lat, 0);
    $line = ms_newLineObj();
    $line->add($pt);
    $shp->add($line);
    $shpFile->addShape($shp);
    dbase_add_record($dbfFile, array($row["station"], $name, $row["years"], $row["cvalid"], $row["high"], $row["low"], $row["precip"], $row["max_precip"], $row["max_precip_yr"], $row["max_high"], $row["max_low"], $row["min_high"], $row["min_low"], $row["max_high_yr"], $row["max_low_yr"], $row["min_high_yr"], $row["min_low_yr"]));
}
Example #3
0
 function adicionaTemaGeoRSS($servico, $dir_tmp, $locaplic, $canal)
 {
     $xml = simplexml_load_file($servico);
     $conta = 0;
     foreach ($xml->channel as $c) {
         if ($conta == $canal) {
             $canal = $c;
         }
     }
     $nos = $canal->item;
     //verifica se o canal faz referencia a elementos externos
     //se sim, usa todos os elementos do xml no lugar do canal
     foreach ($canal->items as $t) {
         foreach ($t->xpath('rdf:Seq') as $x) {
             foreach ($x->xpath('rdf:li') as $z) {
                 $nos = $xml->item;
             }
         }
     }
     $resultado = array();
     $tipog = "";
     foreach ($nos as $item) {
         $env = array();
         //define o tipo
         if ($item->xpath('geo:lat')) {
             $tipog = "geo";
         }
         if ($item->xpath('georss:point')) {
             $tipog = "georsspoint";
         }
         if ($item->xpath('georss:where')) {
             $tipog = "envelope";
         }
         if ($tipog == "envelope") {
             foreach ($item->xpath('georss:where') as $w) {
                 foreach ($w->xpath('gml:Envelope') as $e) {
                     //$lc = $e->xpath('gml:lowerCorner');
                     $lc = (string) $e->children('gml', TRUE)->lowerCorner;
                     //$uc = $e->xpath('gml:upperCorner');
                     $uc = (string) $e->children('gml', TRUE)->upperCorner;
                     $lc = explode(" ", $lc);
                     $uc = explode(" ", $uc);
                     if (is_numeric($lc[0])) {
                         $ymin = $lc[0];
                         $ymax = $uc[0];
                         $xmin = $lc[1];
                         $xmax = $uc[1];
                         if ($ymin != "") {
                             $env = array($xmin, $ymin, $xmax, $ymax);
                         }
                     }
                 }
             }
         }
         if ($tipog == "geo") {
             if ($item->xpath('geo:lon')) {
                 $x = (string) $item->children('geo', TRUE)->lon;
             } else {
                 $x = (string) $item->children('geo', TRUE)->long;
             }
             //$y = $item->xpath('geo:lat');
             $y = (string) $item->children('geo', TRUE)->lat;
             $env = array($y, $x);
         }
         if ($tipog == "georsspoint") {
             //$temp = $item->xpath('georss:point');
             $temp = (string) $item->children('georss', TRUE)->point;
             $env = explode(" ", $temp);
         }
         if (count($env) > 0) {
             $resultado[] = array(ixml($item, "title"), ixml($item, "link"), ixml($item, "description"), ixml($item, "category"), $env);
         }
     }
     //cria o shapefile com os dados
     if (count($resultado) > 0) {
         //para manipular dbf
         include_once dirname(__FILE__) . "/../pacotes/phpxbase/api_conversion.php";
         $diretorio = dirname($this->arquivo);
         $tipol = MS_SHP_POLYGON;
         if ($tipog == "georsspoint") {
             $tipol = MS_SHP_POINT;
         }
         if ($tipog == "geo") {
             $tipol = MS_SHP_POINT;
         }
         $novonomelayer = nomeRandomico(10) . "georss";
         $nomeshp = $diretorio . "/" . $novonomelayer;
         $novoshpf = ms_newShapefileObj($nomeshp, $tipol);
         $def[] = array("TITULO", "C", "254");
         $def[] = array("LINK", "C", "254");
         $def[] = array("DESC", "C", "254");
         $def[] = array("CATEGORIA", "C", "254");
         if (!function_exists(dbase_create)) {
             $db = xbase_create($nomeshp . ".dbf", $def);
             xbase_close($db);
         } else {
             $db = dbase_create($nomeshp . ".dbf", $def);
             dbase_close($db);
         }
         //acrescenta os pontos no novo shapefile
         $dbname = $nomeshp . ".dbf";
         $db = xbase_open($dbname, 2);
         $reg = array();
         $novoshpf = ms_newShapefileObj($nomeshp . ".shp", -2);
         //acrescenta os shapes
         foreach ($resultado as $r) {
             $pts = $r[4];
             if ($tipol == MS_SHP_POLYGON) {
                 $shp = ms_newShapeObj(MS_SHP_POLYGON);
                 $linha = ms_newLineObj();
                 $linha->addXY($pts[0], $pts[3]);
                 $linha->addXY($pts[2], $pts[3]);
                 $linha->addXY($pts[2], $pts[1]);
                 $linha->addXY($pts[0], $pts[1]);
                 $linha->addXY($pts[0], $pts[3]);
             } else {
                 $shp = ms_newShapeObj(MS_SHP_POINT);
                 $linha = ms_newLineObj();
                 $linha->addXY($pts[1], $pts[0]);
             }
             $shp->add($linha);
             $novoshpf->addShape($shp);
             $reg = array($r[0], $r[1], $r[2], $r[3]);
             xbase_add_record($db, $reg);
             $reg = array();
         }
         xbase_close($db);
         if ($tipog == "georsspoint" || $tipog == "geo") {
             $tipol = MS_LAYER_POINT;
         } else {
             $tipol = MS_LAYER_POLYGON;
         }
         $layer = criaLayer($this->mapa, $tipol, MS_DEFAULT, "GeoRSS", "SIM");
         $layer->set("data", $nomeshp . ".shp");
         $layer->set("name", basename($nomeshp));
         $layer->setmetadata("DOWNLOAD", "sim");
         $layer->setmetadata("TEMALOCAL", "SIM");
         //evita problemas no modo tile
         if ($this->v > 5) {
             $layer->setprocessing("LABEL_NO_CLIP=True");
             $layer->setprocessing("POLYLINE_NO_CLIP=True");
         }
         if ($tipol == MS_LAYER_POLYGON) {
             $classe = $layer->getclass(0);
             $estilo = $classe->getstyle(0);
             $estilo->set("symbolname", "p4");
             $estilo->set("size", 5);
             $cor = $estilo->color;
             $cor->setrgb(255, 0, 0);
             $coro = $estilo->outlinecolor;
             $coro->setrgb(255, 0, 0);
         }
         //$layer->set("transparency",50);
         $layer->setmetadata("nomeoriginal", basename($nomeshp));
         //echo $tipol;
         return "ok";
     }
     return "erro";
 }
Example #4
0
    $e_style2 = ms_newStyleObj($e_class2);
    $e_style2->color->setRGB(200, 160, 100);
    $e_style2->set("size", 7);
    $e_style2->set("symbolname", 'circle');
    $e_track = ms_newLayerObj($e_map);
    $e_track->set('name', 'temptrack');
    $e_track->set('status', MS_ON);
    $e_track->set('type', MS_LAYER_LINE);
    $e_track->addFeature($e_shape);
    $e_class = ms_newClassObj($e_track);
    $e_style = ms_newStyleObj($e_class);
    $e_style->color->setRGB(255, 255, 20);
    $e_style->set("size", 3);
    $e_style->set("symbolname", 'circle');
    $e_shapestart = ms_newShapeObj(MS_SHAPE_POINT);
    $e_line = ms_newLineObj();
    list($px, $py) = split(' ', $_SESSION['track'][0]);
    $e_line->addXY($px, $py);
    $e_shapestart->add($e_line);
    $e_track3 = ms_newLayerObj($e_map);
    $e_track3->set('name', 'temptrackstart');
    $e_track3->set('status', MS_ON);
    $e_track3->set('type', MS_LAYER_POINT);
    $e_track3->addFeature($e_shapestart);
    $e_class3 = ms_newClassObj($e_track3);
    $e_style3 = ms_newStyleObj($e_class3);
    $e_style3->set("symbolname", 'flag2');
}
$e_image = $e_map->draw();
$image = $e_image->saveWebImage();
$e_ref = $e_map->drawreferencemap();
Example #5
0
 /**
  * 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);
     }
 }
Example #6
0
function inserePoligonosUrl()
{
    global $tamanhosimbolo, $simbolo, $corsimbolo, $poligonos, $nometemapoligonos, $dir_tmp, $imgdir, $tmpfname, $locaplic;
    include_once "pacotes/phpxbase/api_conversion.php";
    if (!isset($nometemapoligonos)) {
        $nometemapoligonos = "Poligonos";
    }
    if ($nometemapoligonos == "") {
        $nometemapoligonos = "Poligonos";
    }
    //
    //cria o shape file
    //
    $tipol = MS_SHP_POLYGON;
    $nomeshp = $dir_tmp . "/" . $imgdir . "/poligonosins";
    // cria o dbf
    $def = array();
    $items = array("COORD");
    foreach ($items as $ni) {
        $def[] = array($ni, "C", "254");
    }
    if (!function_exists(dbase_create)) {
        xbase_create($nomeshp . ".dbf", $def);
    } else {
        dbase_create($nomeshp . ".dbf", $def);
    }
    $dbname = $nomeshp . ".dbf";
    $db = xbase_open($dbname, 2);
    $novoshpf = ms_newShapefileObj($nomeshp, $tipol);
    $linhas = explode(",", trim($poligonos));
    $pontosLinhas = array();
    //guarda os pontos de cada linha em arrays
    foreach ($linhas as $l) {
        $tempPTs = explode(" ", trim($l));
        $temp = array();
        foreach ($tempPTs as $p) {
            if (is_numeric($p)) {
                $temp[] = $p;
            }
        }
        $pontosLinhas[] = $temp;
    }
    foreach ($pontosLinhas as $ptsl) {
        $linhas = $ptsl;
        $shape = ms_newShapeObj($tipol);
        $linha = ms_newLineObj();
        $reg = array();
        $reg[] = "";
        for ($ci = 0; $ci < count($linhas); $ci = $ci + 2) {
            $linha->addXY($linhas[$ci], $linhas[$ci + 1]);
        }
        $shape->add($linha);
        $novoshpf->addShape($shape);
        xbase_add_record($db, $reg);
    }
    $novoshpf->free();
    xbase_close($db);
    //adiciona o layer
    $mapa = ms_newMapObj($tmpfname);
    $layer = ms_newLayerObj($mapa);
    $layer->set("name", "linhains");
    $layer->set("data", $nomeshp . ".shp");
    $layer->setmetadata("DOWNLOAD", "sim");
    $layer->setmetadata("temalocal", "sim");
    $layer->setmetadata("tema", $nometemapoligonos);
    $layer->setmetadata("classe", "sim");
    $layer->setmetadata("ATLAS", "nao");
    $layer->set("type", MS_LAYER_POLYGON);
    $layer->set("opacity", "50");
    $layer->set("status", MS_DEFAULT);
    $classe = ms_newClassObj($layer);
    $classe->set("name", " ");
    $estilo = ms_newStyleObj($classe);
    $cor = $estilo->color;
    if (!isset($corsimbolo)) {
        $corsimbolo = "255,0,0";
    }
    $corsimbolo = str_replace(" ", ",", $corsimbolo);
    $corsimbolo = explode(",", $corsimbolo);
    $cor->setRGB($corsimbolo[0], $corsimbolo[1], $corsimbolo[2]);
    $salvo = $mapa->save($tmpfname);
    erroCriacao();
}
Example #7
0
 function selecaoPT($xy, $tipo, $tolerancia)
 {
     if ($tipo == "novo") {
         $this->selecaoLimpa();
         $tipo = "adiciona";
     }
     if ($tipo == "limpa") {
         return $this->selecaoLimpa();
     }
     if ($tipo == "inverte") {
         return $this->selecaoInverte();
     }
     if (!$this->layer) {
         return "erro";
     }
     $shp_atual = array();
     if ($this->qyfileTema != "" && file_exists($this->qyfileTema)) {
         $shp_atual = $this->unserializeQ($this->qyfileTema);
     }
     $shpi = array();
     $c = explode(" ", $xy);
     $pt = ms_newPointObj();
     $pt->setXY($c[0], $c[1]);
     if ($tolerancia == 0) {
         $this->layer->set("tolerance", 0);
         $this->layer->set("toleranceunits", 6);
         if ($this->layer->type == MS_LAYER_POINT || $this->layer->type == MS_LAYER_LINE) {
             $this->layer->set("tolerance", 5);
             $ident = @$this->layer->queryByPoint($pt, 1, 0);
         } else {
             $ident = @$this->layer->queryByPoint($pt, 1, 0);
         }
     } else {
         error_reporting(0);
         $projInObj = ms_newprojectionobj("proj=longlat,ellps=WGS84,datum=WGS84,no_defs");
         $projOutObj = ms_newprojectionobj("proj=poly,ellps=GRS67,lat_0=0,lon_0=" . $pt->x . ",x_0=5000000,y_0=10000000");
         $poPoint = ms_newpointobj();
         $poPoint->setXY($pt->x, $pt->y);
         //$dd1 = ms_newpointobj();
         //$dd1->setXY($rect->minx, $rect->miny);
         $poPoint->project($projInObj, $projOutObj);
         $dd2 = ms_newpointobj();
         $dd2->setXY($poPoint->x + $tolerancia, $poPoint->y);
         $dd2->project($projOutObj, $projInObj);
         $d = $pt->distanceToPoint($dd2);
         if ($d < 0) {
             $d = $d * -1;
         }
         //calcula a distancia 29100
         //gera o buffer
         $s = ms_newShapeObj(MS_SHAPE_POINT);
         $linha = ms_newLineObj();
         $linha->add($pt);
         $s->add($linha);
         $buffer = $s->buffer($d);
         $ident = @$this->layer->queryByShape($buffer);
     }
     if ($ident != 1) {
         $res_count = $this->layer->getNumresults();
         $shpi = array();
         for ($i = 0; $i < $res_count; ++$i) {
             $result = $this->layer->getResult($i);
             $shpi[] = $result->shapeindex;
         }
     }
     if ($tipo == "adiciona") {
         return $this->selecaoAdiciona($shpi, $shp_atual);
     }
     if ($tipo == "retira") {
         return $this->selecaoRetira($shpi, $shp_atual);
     }
 }
Example #8
0
function calculaAreaPixel($map_file, $celsize)
{
    $mapa = ms_newMapObj($map_file);
    $rect = $mapa->extent;
    $projInObj = ms_newprojectionobj("proj=longlat,ellps=WGS84,datum=WGS84,no_defs");
    $projOutObj = ms_newprojectionobj("proj=poly,ellps=GRS67,lat_0=0,lon_0=" . $rect->minx . ",x_0=5000000,y_0=10000000");
    $y = $rect->maxy - ($rect->maxy - $rect->miny) / 2;
    $x = $rect->maxx - ($rect->maxx - $rect->minx) / 2;
    $shape = ms_newShapeObj(MS_SHAPE_POLYGON);
    $linha = ms_newLineObj();
    $linha->addXY($x, $y);
    $linha->addXY($x + $celsize, $y);
    $linha->addXY($x + $celsize, $y - $celsize);
    $linha->addXY($x, $y - $celsize);
    $linha->addXY($x, $y);
    $shape->add($linha);
    $shape->project($projInObj, $projOutObj);
    $s = $shape->towkt();
    $shape = ms_shapeObjFromWkt($s);
    $area = $shape->getArea();
    return $area;
}
Example #9
0
 $oLabelObj2->set("size", 7);
 $oLabelObj2->set("type", MS_TRUETYPE);
 $oLabelObj2->set("font", "arial");
 $oLabelObj2->color->setRGB(0, 0, 0);
 $oLabelObj2->outlinecolor->setRGB(255, 255, 255);
 $oMapClass2 = ms_newClassObj($oLayerPoints2);
 $oMapClass2->addLabel($oLabelObj2);
 //auteur et logo
 if ($printLogo && isset($_GET['printNomAuteur'])) {
     $auteurNom = $_GET['printNomAuteur'];
     $oLayerPoints3 = ms_newLayerObj($oMap);
     $oLayerPoints3->set("name", "Title");
     $oLayerPoints3->set("type", MS_LAYER_ANNOTATION);
     $oLayerPoints3->set("status", MS_DEFAULT);
     $oLayerPoints3->set("transform", MS_FALSE);
     $oCoordList3 = ms_newLineObj();
     $oPointShape3 = ms_newShapeObj(MS_SHAPE_POINT);
     $oCoordList3->addXY($nMapWidth - $heightMaxLogo - 5, $nMapHeight - 5);
     $oPointShape3->add($oCoordList3);
     $oPointShape3->set("text", $auteurNom);
     $oLayerPoints3->addFeature($oPointShape3);
     $oLabelObj3 = new labelObj();
     $oLabelObj3->set("position", MS_CL);
     $oLabelObj3->set("size", 7);
     $oLabelObj3->set("type", MS_TRUETYPE);
     $oLabelObj3->set("font", "arial");
     $oLabelObj3->set("align", MS_ALIGN_LEFT);
     $oLabelObj3->color->setRGB(0, 0, 0);
     $oLabelObj3->outlinecolor->setRGB(255, 255, 255);
     $oMapClass3 = ms_newClassObj($oLayerPoints3);
     $oMapClass3->addLabel($oLabelObj3);
Example #10
0
 function gradeDeHex($dd, $px, $py, $locaplic, $nptx, $npty, $proj = false)
 {
     set_time_limit(180);
     // http://gmc.yoyogames.com/index.php?showtopic=336183
     $hh = sin(deg2rad(30)) * $dd;
     $rr = cos(deg2rad(30)) * $dd;
     // para manipular dbf
     if ($this->dbaseExiste == false) {
         include_once dirname(__FILE__) . "/../pacotes/phpxbase/api_conversion.php";
     }
     $nomegrade = nomeRandomico();
     $nomeshp = $this->diretorio . "/" . $nomegrade;
     // pega a extens&atilde;o geogr&aacute;fica do mapa
     $this->mapa->preparequery();
     $r = $this->mapa->extent;
     $ext = ms_newRectObj();
     $ext->setextent($r->minx, $r->miny, $r->maxx, $r->maxy);
     if ($proj == true) {
         // caso precise projetar
         $projInObj = ms_newprojectionobj("proj=latlong,a=6378137,b=6378137");
         $projOutObj = ms_newprojectionobj("proj=merc,a=6378137,b=6378137,lat_ts=0.0,lon_0=0.0,x_0=0.0,y_0=0,k=1.0,units=m");
         $ext->project($projInObj, $projOutObj);
         $pt = ms_newpointobj();
         $pt->setXY($px, $py);
         $pt->project($projInObj, $projOutObj);
         $px = $pt->x;
         $py = $pt->y;
     }
     $fx = $ext->maxx;
     $fy = $ext->miny;
     // calcula a dist&acirc;ncia entre os pontos em dd se nao tiver sido especificada ou for 0
     $distx = $fx - $px;
     $disty = $fy - $py;
     if ($distx < 0) {
         $distx = $distx * -1;
     }
     if ($disty < 0) {
         $disty = $disty * -1;
     }
     if ($nptx == "") {
         $nptx = round($distx / $dd, 0);
     }
     if ($npty == "") {
         $npty = round($disty / $dd, 0);
     }
     // cria o shapefile
     $novoshpf = ms_newShapefileObj($nomeshp, MS_SHP_POLYGON);
     $def = array();
     $def[] = array("id", "C", "20");
     if ($this->dbaseExiste == false) {
         $db = xbase_create($nomeshp . ".dbf", $def);
         xbase_close($db);
     } else {
         $db = dbase_create($nomeshp . ".dbf", $def);
         dbase_close($db);
     }
     // acrescenta os pontos no novo shapefile
     $dbname = $nomeshp . ".dbf";
     if ($this->dbaseExiste == false) {
         $db = xbase_open($dbname, 2);
     } else {
         $db = dbase_open($dbname, 2);
     }
     $reg = array();
     $w = $this->mapa->width;
     $h = $this->mapa->height;
     $valorcoluna = $px;
     $par = false;
     for ($coluna = 0; $coluna < $nptx; $coluna++) {
         $x = $valorcoluna;
         $valorlinha = $py;
         if ($par == true) {
             $valorlinha = $valorlinha - $rr;
             $par = false;
         } else {
             // $y = $y + $hh;
             $par = true;
         }
         for ($linha = 0; $linha < $npty; $linha++) {
             $y = $valorlinha;
             $valorlinha = $valorlinha - 2 * $rr;
             $poPoint1 = ms_newpointobj();
             $poPoint2 = ms_newpointobj();
             $poPoint3 = ms_newpointobj();
             $poPoint4 = ms_newpointobj();
             $poPoint5 = ms_newpointobj();
             $poPoint6 = ms_newpointobj();
             // Point 0: $x, $y
             // Point 1: x + s, y
             // Point 2: x + s + h, y + r
             // Point 3: x + s, y + r + r
             // Point 4: x, y + r + r
             // Point 5: x - h, y + r
             $poPoint1->setXY($x, $y);
             $poPoint2->setXY($x + $dd, $y);
             $poPoint3->setXY($x + $dd + $hh, $y - $rr);
             $poPoint4->setXY($x + $dd, $y - $rr - $rr);
             $poPoint5->setXY($x, $y - $rr - $rr);
             $poPoint6->setXY($x - $hh, $y - $rr);
             if ($proj == true) {
                 $poPoint1->project($projOutObj, $projInObj);
                 $poPoint2->project($projOutObj, $projInObj);
                 $poPoint3->project($projOutObj, $projInObj);
                 $poPoint4->project($projOutObj, $projInObj);
                 $poPoint5->project($projOutObj, $projInObj);
                 $poPoint6->project($projOutObj, $projInObj);
             }
             $linhas = ms_newLineObj();
             $linhas->add($poPoint1);
             $linhas->add($poPoint2);
             $linhas->add($poPoint3);
             $linhas->add($poPoint4);
             $linhas->add($poPoint5);
             $linhas->add($poPoint6);
             $linhas->add($poPoint1);
             $shapen = ms_newShapeObj(MS_SHP_POLYGON);
             $shapen->add($linhas);
             $novoshpf->addShape($shapen);
             $reg[] = $linha . "-" . $coluna;
             if ($this->dbaseExiste == false) {
                 xbase_add_record($db, $reg);
             } else {
                 dbase_add_record($db, $reg);
             }
             $reg = array();
         }
         $valorcoluna = $valorcoluna + $dd + $hh;
     }
     if ($this->dbaseExiste == false) {
         xbase_close($db);
     } else {
         dbase_close($db);
     }
     // adiciona o novo tema no mapa
     $novolayer = criaLayer($this->mapa, MS_LAYER_POLYGON, MS_DEFAULT, "Grade (" . $nomegrade . ")", $metaClasse = "SIM");
     $novolayer->set("data", $nomeshp . ".shp");
     $novolayer->setmetadata("DOWNLOAD", "SIM");
     $novolayer->setmetadata("TEMALOCAL", "SIM");
     $novolayer->set("opacity", "50");
     if (file_exists($this->qyfile)) {
         unlink($this->qyfile);
     }
     return "ok";
 }
Example #11
0
function updatePolDBFRecord($szFileName, $aszPointProperties, $nId = -1, $aPuntos)
{
    $dbfFile = dbase_open($szFileName . '.dbf', 2);
    $nCount = dbase_numrecords($dbfFile);
    $nMaxID = $nCount + 1;
    $aszPointProperties[0] = $nMaxID;
    // add the record to the dbase file if the array is populated
    if (count($aszPointProperties) > 0) {
        $shpFile = ms_newShapeFileObj($szFileName, -2);
        $oShp = ms_newShapeObj(MS_SHP_LINE);
        $oLine = ms_newLineObj();
        //$oLine->addXY($aPuntos[0], $aPuntos[1]);
        //$oLine->addXY($aPuntos[2], $aPuntos[3]);
        $nPoints = count($aPuntos);
        for ($i = 0; $i < $nPoints; $i++) {
            if (fmod($i, 2) == 0) {
                //$aX = $aPuntos[$i];
            } else {
                $j = $i - 1;
                //$aPuntos[$i];
                $oLine->addXY($aPuntos[$j], $aPuntos[$i]);
            }
        }
        $oShp->add($oLine);
        $oLine->free();
        $shpFile->addShape($oShp);
        $aszPointProperties[2] = $oShp->getLength();
        $aszPointProperties[3] = $oShp->getArea();
        dbase_add_record($dbfFile, array_values($aszPointProperties));
    }
    $oShp->free();
    $shpFile->free();
    // close the dbf
    dbase_close($dbfFile);
    // return success
    return true;
    // end updatePolDBFRecord() function
}
Example #12
0
File: map.php Project: sukma279/GIS
 /**
  * FOR ZOOM TO SELECTED.
  * Adds a new layer to the map for highlighting feature
  */
 private function pmap_addResultLayer($reslayer, $shpindexes)
 {
     if (isset($_SESSION["resulttilelayers"])) {
         $resulttilelayers = $_SESSION["resulttilelayers"];
         $resulttilelayer = $resulttilelayers[$reslayer];
     } else {
         $resulttilelayers = null;
         $resulttilelayer = null;
     }
     $qLayer = $this->map->getLayerByName($reslayer);
     $qlayType = $qLayer->type;
     $layNum = count($this->map->getAllLayerNames());
     // Test if layer has the same projection as map
     $mapProjStr = $this->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}");
         $hlMapLayer->set("name", "pmapper_reslayer");
         $newResLayer = ms_newLayerObj($this->map, $hlMapLayer);
     } else {
         // create dynamically
         $hlDynLayer = 1;
         $newResLayer = ms_newLayerObj($this->map);
         $newResLayer->set("name", "pmapper_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
         // Modified by Thomas RAFFIN (SIRAP)
         // 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"));
         }
         $qLayer->open();
         foreach ($shpindexes as $resShpIdx) {
             if (preg_match("/@/", $resShpIdx)) {
                 $idxList = explode("@", $resShpIdx);
                 $resTileShpIdx = $idxList[0];
                 $resShpIdx = $idxList[1];
             } else {
                 $resTileShpIdx = $resulttilelayer[$resShpIdx];
             }
             $resShape = PMCommon::resultGetShape($this->msVersion, $qLayer, null, $resShpIdx, $resTileShpIdx);
             // changed for compatibility with PG layers and MS >= 5.6
             // 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"
                 if ($resShape) {
                     $resShape->project($qLayerProjObj, $mapProjObj);
                 }
             }
             if ($resShape) {
                 $newResLayer->addFeature($resShape);
             }
         }
         $qLayer->close();
         // 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
         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???)
     while ($newResLayerIdx < $layNum - 1) {
         $this->map->moveLayerUp($newResLayerIdx);
     }
 }
Example #13
0
 function shpPT2shp($locaplic, $para)
 {
     if (!$this->layer) {
         return "erro";
     }
     $this->layer->set("template", "none.htm");
     $diretorio = dirname($this->arquivo);
     $tipol = MS_SHP_ARC;
     $tipos = MS_SHAPE_LINE;
     if ($para == "poligono") {
         $tipol = MS_SHP_POLYGON;
         $tipos = MS_SHAPE_POLYGON;
     }
     $novonomelayer = nomeRandomico();
     $nomeshp = $diretorio . "/" . $novonomelayer;
     $items = pegaItens($this->layer);
     // cria o dbf
     $def = array();
     foreach ($items as $ni) {
         $temp = strtoupper($ni);
         $def[] = array($temp, "C", "254");
     }
     //para manipular dbf
     if ($this->dbaseExiste == false) {
         include_once dirname(__FILE__) . "/../pacotes/phpxbase/api_conversion.php";
         $db = xbase_create($nomeshp . ".dbf", $def);
     } else {
         $db = dbase_create($nomeshp . ".dbf", $def);
     }
     $dbname = $nomeshp . ".dbf";
     $reg = array();
     $novoshpf = ms_newShapefileObj($nomeshp . ".shp", $tipol);
     $this->layer->open();
     $prjMapa = $this->mapa->getProjection();
     $prjTema = $this->layer->getProjection();
     $ret = $this->mapa->extent;
     if ($prjTema != "" && $prjMapa != $prjTema) {
         $projOutObj = ms_newprojectionobj($prjTema);
         $projInObj = ms_newprojectionobj($prjMapa);
         $ret->project($projInObj, $projOutObj);
     }
     $this->layer->whichShapes($ret);
     $linha = ms_newLineObj();
     $pponto = "";
     $pontos = array();
     while ($shape = $this->layer->nextShape()) {
         $lin = $shape->line(0);
         $pt = $lin->point(0);
         if ($pponto == "") {
             $pponto = $pt;
         }
         if ($prjTema != "" && $prjMapa != $prjTema) {
             $pt->project($projInObj, $projOutObj);
         }
         $pontos[] = $pt->x;
         $pontos[] = $pt->y;
     }
     $pontos = implode(" ", $pontos);
     $pontos = xy2wkt($pontos);
     if ($para == "poligono") {
         $shape = ms_shapeObjFromWkt($pontos["poligono"]);
     } else {
         $shape = ms_shapeObjFromWkt($pontos["linha"]);
     }
     foreach ($items as $ni) {
         $reg[] = "-";
     }
     $novoshpf->addShape($shape);
     if ($this->dbaseExiste == false) {
         xbase_add_record($db, $reg);
         xbase_close($db);
     } else {
         dbase_add_record($db, $reg);
         dbase_close($db);
     }
     $this->layer->close();
     //cria o novo layer
     $layer = criaLayer($this->mapa, MS_LAYER_LINE, MS_DEFAULT, "", $metaClasse = "SIM");
     $layer->set("data", $nomeshp);
     $layer->setmetadata("tema", $novonomelayer . " (linear)");
     $layer->setmetadata("download", "sim");
     $layer->setmetadata("temalocal", "sim");
     $classe = $layer->getclass(0);
     $estilo = $classe->getstyle(0);
     $estilo->set("symbolname", "linha");
     if ($para == "poligono") {
         $layer->set("type", MS_LAYER_POLYGON);
         $layer->set("opacity", "50");
         $layer->setmetadata("tema", $novonomelayer . " (poligonal)");
     }
     return "ok";
 }
Example #14
0
function updatePtoDBFRecord($szFileName, $aszPointProperties, $nId = -1, $aPuntos)
{
    $dbfFile = dbase_open($szFileName . '.dbf', 2);
    // loop through the database and match the id
    $nCount = dbase_numrecords($dbfFile);
    //$nMaxID = 0;
    $nMaxID = $nCount + 1;
    $aszPointProperties[0] = $nMaxID;
    // add the record to the dbase file if the array is populated
    if (count($aszPointProperties) > 0) {
        $shpFile = ms_newShapefileObj(dirname(__FILE__) . '\\' . $szFileName, -2);
        $nPoints = count($aPuntos);
        if ($nPoints > 0) {
            $oShp = ms_newShapeObj(MS_SHP_POINT);
            $oPoint = ms_newLineObj();
            $oPoint->addXY($aPuntos[0], $aPuntos[1]);
            $oShp->add($oPoint);
            $oPoint->free();
            $shpFile->addShape($oShp);
            $oShp->free();
            dbase_add_record($dbfFile, array_values($aszPointProperties));
        }
    }
    $shpFile->free();
    // close the dbf
    dbase_close($dbfFile);
    // return success
    return true;
}
Example #15
0
function lcls_drawlayer($drawlayer)
{
    global $zMap, $zImage, $userlayers, $ext, $sizex, $sizey;
    if ($userlayers["{$drawlayer}"]["layertype"] == 'point') {
        $layertype = MS_LAYER_POINT;
        $shapetype = MS_SHAPE_POINT;
    } elseif ($userlayers["{$drawlayer}"]["layertype"] == 'line') {
        $layertype = MS_LAYER_LINE;
        $shapetype = MS_SHAPE_LINE;
    }
    $zUser = ms_newLayerObj($zMap);
    $zUser->set("status", MS_ON);
    $zUser->set("type", $layertype);
    $zUser->set("classitem", "item");
    $zUser->set("name", $userlayers["{$drawlayer}"]["layername"]);
    #$zUser->set("group", $userlayers["$drawlayer"]["layergroup"]);
    $zUclass = ms_newClassObj($zUser);
    $zUclass->set("name", $userlayers["{$drawlayer}"]["layername"]);
    if ($userlayers[$drawlayer][layercolor]) {
        list($r, $v, $b) = split(' ', $userlayers[$drawlayer][layercolor]);
        $zUclass->set("color", $zMap->addColor($r, $v, $b));
    }
    if ($userlayers["{$drawlayer}"]["layersymbol"]) {
        $zUclass->set("symbolname", $userlayers["{$drawlayer}"]["layersymbol"]);
    }
    $zUclass->set("size", $userlayers["{$drawlayer}"]["layersize"]);
    $zUclass->set("outlinecolor", "-1");
    $listlines = listlines($drawlayer, $ext);
    if (is_array($listlines)) {
        foreach ($listlines as $o => $l) {
            if (is_array($l[1])) {
                $zUclass->set("status", MS_ON);
                $zUshape = ms_newShapeObj($shapetype);
                foreach ($l[1] as $drawpoint) {
                    $zUline = ms_newLineObj();
                    $zUline->addXY($drawpoint[E], $drawpoint[N], 0);
                    $imgx = geo2pix($drawpoint[E], $ext[0], $ext[2], $sizex);
                    $imgy = $sizey - geo2pix($drawpoint[N], $ext[1], $ext[3], $sizey);
                    $pointslist["{$imgx}/{$imgy}"] = array($o, $l[0]);
                    $zUshape->add($zUline);
                }
            }
            if (is_object($zUshape)) {
                $zUshape->draw($zMap, $zUser, $zImage, 1, "test");
            }
        }
    }
    return $pointslist;
}