function EmitAddressResults($featureService, $addressMarkerDataResId, $mgSessionId)
{
echo '<table class="RegText" border="0" cellspacing="0" width="100%">';
echo '<tr><td class="SubTitle">Previous Results</td></tr>';
$geometryReaderWriter = new MgAgfReaderWriter();
$featureReader = $featureService->SelectFeatures($addressMarkerDataResId, 'AddressMarker', null);
while ($featureReader->ReadNext()) {
$address = $featureReader->GetString('Address');
$byteReader = $featureReader->GetGeometry('Location');
$geometry = $geometryReaderWriter->Read($byteReader);
$x = $geometry->GetCoordinate()->GetX();
$y = $geometry->GetCoordinate()->GetY();
echo '<tr><td>';
echo '<img src="../images/pushpinblue.jpg">';
echo '<a href="gotopoint.php?X=' . $x . '&Y=' . $y . '&Scale=2000" target="scriptFrame"> ' . $address . '</a></td></tr>';
}
$featureReader->Close();
echo '</table>';
echo '<form action="clearaddressresults.php" method="get" target="scriptFrame">';
echo '<input type="hidden" name="SESSION" value="' . $mgSessionId . '">';
echo '<input type="button" class="Ctrl" value="Clear Results" onClick="javascript:submit()">';
echo '</form>';
echo '<hr>';
}
function MultiGeometryFromSelection($featureSrvc, $map, $selText)
{
$sel = new MgSelection($map, $selText);
$selLayers = $sel->GetLayers();
$geomColl = new MgGeometryCollection();
$agfRW = new MgAgfReaderWriter();
$simplyPolygonOnly = true;
for ($i = 0; $i < $selLayers->GetCount(); $i++) {
$layer = $selLayers->GetItem($i);
$filter = $sel->GenerateFilter($layer, $layer->GetFeatureClassName());
$query = new MgFeatureQueryOptions();
$query->SetFilter($filter);
$featureSource = new MgResourceIdentifier($layer->GetFeatureSourceId());
$features = $featureSrvc->SelectFeatures($featureSource, $layer->GetFeatureClassName(), $query);
if ($features) {
$classDef = $features->GetClassDefinition();
$geomPropName = $classDef->GetDefaultGeometryPropertyName();
$j = 0;
while ($features->ReadNext()) {
$geomReader = $features->GetGeometry($geomPropName);
$geom = $agfRW->Read($geomReader);
$type = $geom->GetGeometryType();
if ($type == MgGeometryType::MultiPolygon || $type == MgGeometryType::CurvePolygon || $type == MgGeometryType::MultiCurvePolygon) {
$simplyPolygonOnly = false;
} else {
if ($type != MgGeometryType::Polygon) {
continue;
}
}
$geomColl->Add($geom);
}
}
}
if ($geomColl->GetCount() == 0) {
return null;
}
$gf = new MgGeometryFactory();
if ($simplyPolygonOnly) {
$polyColl = new MgPolygonCollection();
for ($i = 0; $i < $geomColl->GetCount(); $i++) {
$polyColl->Add($geomColl->GetItem($i));
}
return $gf->CreateMultiPolygon($polyColl);
} else {
return $gf->CreateMultiGeometry($geomColl);
}
}
function InsertCommand($key)
{
$props = new MgPropertyCollection();
$keyProp = new MgStringProperty("SKEY", $key);
$props->Add($keyProp);
$nameProp = new MgStringProperty("NAME", "StringKey" . $key);
$props->Add($nameProp);
$wkt = new MgWktReaderWriter();
$agf = new MgAgfReaderWriter();
$geom = $wkt->Read("POLYGON ((20 20, 20 100, 120 100, 140 20, 20 20))");
$geomReader = $agf->Write($geom);
$geomProp = new MgGeometryProperty("GEOM", $geomReader);
$props->Add($geomProp);
$cmd = new MgInsertFeatures("StringKey", $props);
return $cmd;
}
$map->Open($mapName);
// Check for selection data passed via HTTP POST
if (isset($_POST['SELECTION']) && $_POST['SELECTION'] != '') {
$selection = new MgSelection($map, $_POST['SELECTION']);
$selectedLayers = $selection->GetLayers();
} else {
$selectedLayers = 0;
}
if ($selectedLayers) {
include 'bufferfunctions.php';
$bufferRingSize = 100;
// measured in metres
$bufferRingCount = 5;
// Set up some objects for coordinate conversion
$mapWktSrs = $map->GetMapSRS();
$agfReaderWriter = new MgAgfReaderWriter();
$wktReaderWriter = new MgWktReaderWriter();
$coordinateSystemFactory = new MgCoordinateSystemFactory();
$srs = $coordinateSystemFactory->Create($mapWktSrs);
$srsMeasure = $srs->GetMeasure();
// Check for a buffer layer. If it exists, delete
// the current features.
// If it does not exist, create a feature source and
// a layer to hold the buffer.
/*
// Old way, pre MapGuide OS 2.0. Kept here for reference
try
{
$bufferLayer = $map->GetLayers()->GetItem('Buffer');
$bufferFeatureResId = new MgResourceIdentifier($bufferLayer->GetFeatureSourceId());
$addressLayer = GetLayerByName($map, 'AddressMarker');
if ($addressLayer == null) {
CreateAddressMarkerFeatureSource($featureService, $addressMarkerDataResId);
$addressLayer = CreateAddressMarkerLayer($resourceService, $addressMarkerDataResId, $mgSessionId);
$map->GetLayers()->Insert(0, $addressLayer);
} else {
if ($addressLayer->GetVisible()) {
// If the layer exists and is visible, then display the
// previous results.
EmitAddressResults($featureService, $addressMarkerDataResId, $mgSessionId);
}
}
// Insert the results of the Geo-Code into the temporary
// feature source and ensure the address marker layer
// is visible.
$geometryReaderWriter = new MgAgfReaderWriter();
$geometryFactory = new MgGeometryFactory();
$addrPoint = $geometryFactory->CreatePoint($geometryFactory->CreateCoordinateXY((double) $long, (double) $lat));
$properties = new MgPropertyCollection();
$properties->Add(new MgStringProperty('Address', $address1));
$properties->Add(new MgGeometryProperty('Location', $geometryReaderWriter->Write($addrPoint)));
$commands = new MgFeatureCommandCollection();
$commands->Add(new MgInsertFeatures('AddressMarker', $properties));
$featureService->UpdateFeatures($addressMarkerDataResId, $commands, false);
$addressLayer->SetVisible(true);
$addressLayer->ForceRefresh();
$map->Save($resourceService);
$success = true;
} else {
echo '<tr><td>Address not found: ' . $address . '<hr></td></tr>';
$success = false;
if ($layer == null) {
$legendName = GetLocalizedString("MEASURELAYER", $locale);
$layer = new MgLayer($layerDefId, $resourceSrvc);
$layer->SetDisplayInLegend(true);
$layer->SetLegendLabel($legendName);
$layers->Insert(0, $layer);
}
}
// create a feature representing this segment and insert it into the data source
//
$measureProps = new MgPropertyCollection();
$partialProp = new MgDoubleProperty("PARTIAL", $distance);
$measureProps->Add($partialProp);
$totalProp = new MgDoubleProperty("TOTAL", $total);
$measureProps->Add($totalProp);
$agf = new MgAgfReaderWriter();
$geomReader = $agf->Write($geom);
$geomProp = new MgGeometryProperty("GEOM", $geomReader);
$measureProps->Add($geomProp);
$cmd = new MgInsertFeatures($featureName, $measureProps);
$commands = new MgFeatureCommandCollection();
$commands->Add($cmd);
ReleaseReader($featureSrvc->UpdateFeatures($dataSourceId, $commands, false));
}
if ($layer != null) {
$layer->ForceRefresh();
}
$map->Save($resourceSrvc);
} catch (MgException $e) {
OnError(GetLocalizedString("MEASUREERROR", $locale), $e->GetDetails());
return;
function Execute()
{
$result = array();
$resourceService = $this->site->CreateService(MgServiceType::ResourceService);
$map = new MgMap();
$map->Open($resourceService, $this->args['MAPNAME']);
$layer = $map->GetLayers()->GetItem($this->args['LAYERNAME']);
$featureService = $this->site->CreateService(MgServiceType::FeatureService);
$resId = new MgResourceIdentifier($layer->GetFeatureSourceId());
$featureClass = $layer->GetFeatureClassName();
$featureGeometry = $layer->GetFeatureGeometryName();
// Initialize the coordinate system transform
$schemaAndClass = explode(":", $featureClass);
$classDef = $featureService->GetClassDefinition($resId, $schemaAndClass[0], $schemaAndClass[1]);
$geomProp = $classDef->GetProperties()->GetItem($featureGeometry);
$spatialContext = $geomProp->GetSpatialContextAssociation();
$csTransform = null;
$csInverseTransform = null;
$coordSysFactory = new MgCoordinateSystemFactory();
$scReader = $featureService->GetSpatialContexts($resId, false);
while ($scReader->ReadNext() && $csTransform == null) {
if ($scReader->GetName() == $spatialContext) {
$source = $coordSysFactory->Create($scReader->GetCoordinateSystemWkt());
$target = $coordSysFactory->Create($map->GetMapSRS());
$csTransform = new MgCoordinateSystemTransform($source, $target);
$csInverseTransform = new MgCoordinateSystemTransform($target, $source);
}
}
$scReader->Close();
// Execute the query
$queryMax = (int) $this->args['QUERYMAX'];
$queryOptions = new MgFeatureQueryOptions();
if ($this->args['USEPROPERTYFILTER'] == 'true') {
$propertyFilter = $this->args['PROPERTYNAME'];
if ($this->args['ISSTRING'] == 'true') {
$propertyFilter .= sprintf($this->strExpressions[$this->args['OPERATOR']], $this->args['VALUE']);
} else {
$propertyFilter .= sprintf($this->numExpressions[$this->args['OPERATOR']], $this->args['VALUE']);
}
$queryOptions->SetFilter($propertyFilter);
}
if ($this->args['USESPATIALFILTER'] == 'true') {
$polygon = $this->CreatePolygonFromGeomText($this->args['GEOMTEXT']);
$polygon = $polygon->Transform($csInverseTransform);
$queryOptions->SetSpatialFilter($featureGeometry, $polygon, MgFeatureSpatialOperations::Intersects);
}
$count = 0;
$geometryReaderWriter = new MgAgfReaderWriter();
$featureReader = $featureService->SelectFeatures($resId, $layer->GetFeatureClassName(), $queryOptions);
while ($featureReader->ReadNext() && ($queryMax <= 0 || $count < $queryMax)) {
$displayValue = $this->GetFeaturePropertyValue($featureReader, $this->args['OUTPUTPROPERTY']);
$byteReader = $featureReader->GetGeometry($featureGeometry);
$geometry = $geometryReaderWriter->Read($byteReader);
$centerPoint = $geometry->GetCentroid();
$centerPoint = $centerPoint->Transform($csTransform);
$idList = $this->GetFeatureIdList($map, $layer, $featureReader);
array_push($result, new Feature($displayValue, $centerPoint, $idList));
$count++;
}
return $result;
}
echo "Created sdfparams\n";
$layerName = 'Library://TrevorWekel/NewSdf.FeatureSource';
$id = new MgResourceIdentifier($layerName);
try {
$svc->CreateFeatureSource($id, $params);
} catch (MgException $exc) {
echo $exc->GetExceptionMessage() . "\n";
echo $exc->GetDetails() . "\n";
return;
}
echo "Created featuresource\n";
// We need to add some data to the sdf before using it. The spatial context
// reader must have an extent.
$batchProp = new MgBatchPropertyCollection();
$wkt = new MgWktReaderWriter();
$agf = new MgAgfReaderWriter();
$fact = new MgGeometryFactory();
echo "Created wkt/agf\n";
$count = 100;
$i = 0;
for ($i = 1; $i <= $count; $i++) {
$bufferProps = new MgPropertyCollection();
$nameProp = new MgStringProperty("NAME", "NewName_" . $i);
$bufferProps->Add($nameProp);
$x = 120 + $i / $count;
$y = 100 + $i / $count;
//$wktText = "POLYGON ((20 20, 20 100, {$x} {$y}, 140 20, 20 20))";
//$geom = $wkt->Read($wktText);
$coord = $fact->CreateCoordinateXY($x, $y);
$geom = $fact->CreatePoint($coord);
$geomReader = $agf->Write($geom);
function AddPolygon()
{
$geometryFactory = new MgGeometryFactory();
$agfWriter = new MgAgfReaderWriter();
$vertices = explode(',', $this->args['GEOMETRY']);
$count = $vertices[0];
$coords = new MgCoordinateCollection();
for ($i = 0; $i < $count; $i++) {
$coord = $geometryFactory->CreateCoordinateXY((double) $vertices[$i * 2 + 1], (double) $vertices[$i * 2 + 2]);
$coords->Add($coord);
}
// Add the first vertex to make the ring close
if ($count > 2) {
$coord = $geometryFactory->CreateCoordinateXY((double) $vertices[1], (double) $vertices[2]);
$coords->Add($coord);
}
$linearRing = $geometryFactory->CreateLinearRing($coords);
$polygon = $geometryFactory->CreatePolygon($linearRing, null);
$trans = $this->GetTransform();
if (null != $trans) {
$polygon = $polygon->Transform($trans);
}
$byteReader = $agfWriter->Write($polygon);
$propertyValues = new MgPropertyCollection();
$propertyValues->Add(new MgStringProperty('Text', $this->args['TEXT']));
$propertyValues->Add(new MgGeometryProperty('Geometry', $byteReader));
$this->InsertMarkupFeature($propertyValues);
}
private function OutputXml($schemas)
{
$read = 0;
$agfRw = new MgAgfReaderWriter();
$wktRw = new MgWktReaderWriter();
$this->writer->SetHeader("Content-Type", MgMimeType::Xml);
$this->writer->StartChunking();
$output = "<?xml version=\"1.0\" encoding=\"utf-8\"?><FeatureSet>";
if (!$this->IsEmpty($schemas)) {
$classXml = $this->featSvc->SchemaToXml($schemas);
$classXml = substr($classXml, strpos($classXml, "<xs:schema"));
$output .= $classXml;
}
$hasMoreFeatures = $this->reader->ReadNext();
$writeXmlFooter = false;
if ($hasMoreFeatures) {
$output .= "<Features>";
$this->writer->WriteChunk($output);
$output = "";
$writeXmlFooter = true;
}
$propCount = $this->reader->GetPropertyCount();
while ($hasMoreFeatures) {
$read++;
if ($this->limit > 0 && $read > $this->limit) {
break;
}
$output = "<Feature>";
for ($i = 0; $i < $propCount; $i++) {
$name = $this->reader->GetPropertyName($i);
$propType = $this->reader->GetPropertyType($i);
$output .= "<Property><Name>{$name}</Name>";
if (!$this->reader->IsNull($i)) {
$output .= "<Value>";
switch ($propType) {
case MgPropertyType::Boolean:
//NOTE: It appears PHP booleans are not string-able
$output .= $this->reader->GetBoolean($i) ? "true" : "false";
break;
case MgPropertyType::Byte:
$output .= $this->reader->GetByte($i);
break;
case MgPropertyType::DateTime:
$dt = $this->reader->GetDateTime($i);
$output .= $dt->ToString();
break;
case MgPropertyType::Decimal:
case MgPropertyType::Double:
$output .= $this->reader->GetDouble($i);
break;
case MgPropertyType::Geometry:
try {
$agf = $this->reader->GetGeometry($i);
$geom = $this->transform != null ? $agfRw->Read($agf, $this->transform) : $agfRw->Read($agf);
$output .= $wktRw->Write($geom);
} catch (MgException $ex) {
}
break;
case MgPropertyType::Int16:
$output .= $this->reader->GetInt16($i);
break;
case MgPropertyType::Int32:
$output .= $this->reader->GetInt32($i);
break;
case MgPropertyType::Int64:
$output .= $this->reader->GetInt64($i);
break;
case MgPropertyType::Single:
$output .= $this->reader->GetSingle($i);
break;
case MgPropertyType::String:
$output .= MgUtils::EscapeXmlChars($this->reader->GetString($i));
break;
}
$output .= "</Value>";
}
$output .= "</Property>";
}
$output .= "</Feature>";
$this->writer->WriteChunk($output);
$output = "";
$hasMoreFeatures = $this->reader->ReadNext();
}
if ($writeXmlFooter) {
$output .= "</Features>";
}
$output .= "</FeatureSet>";
$this->writer->WriteChunk($output);
$this->writer->EndChunking();
$this->reader->Close();
}
$borderColor = $_REQUEST['bordercolor'];
$schemaName = 'BufferSchema';
$map = new MgMap();
$map->Open($resourceService, $mapName);
/* Get the map SRS - we use this to convert distances */
$srsFactory = new MgCoordinateSystemFactory();
//safely get an SRS ... (in Utilities)
$srsDefMap = GetMapSRS($map);
$mapSrsUnits = "";
$srsMap = $srsFactory->Create($srsDefMap);
$arbitraryMapSrs = $srsMap->GetType() == MgCoordinateSystemType::Arbitrary;
if ($arbitraryMapSrs) {
$mapSrsUnits = $srsMap->GetUnits();
}
$featureService = $siteConnection->CreateService(MgServiceType::FeatureService);
$agfRW = new MgAgfReaderWriter();
$layers = $map->GetLayers();
try {
/* if the layer already exists, we'll clear the existing features
* from it and reset the content
*/
$bValidLayer = false;
$j = 2;
while (!$bValidLayer) {
$layer = $layers->GetItem($layerName);
$featureClassName = $layer->GetFeatureClassName();
if ($featureClassName != $schemaName . ':' . $layerName) {
$layerName = $layerName . ' (' . $j . ')';
} else {
$bValidLayer = true;
}
private function CollectQueryMapFeaturesResult($resSvc, $reqData, $featInfo, $selection, $bRequestAttributes, $inlineSelectionImg)
{
$xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<FeatureInformation>\n";
$tooltip = "";
$hyperlink = "";
if ($featInfo != null) {
$tooltip = $featInfo->GetTooltip();
$hyperlink = $featInfo->GetHyperlink();
}
$selXml = $selection->ToXml();
if (strlen($selXml) > 0) {
//Need to strip the XML prolog from this fragment
$fsdoc = new DOMDocument();
$fsdoc->loadXML($selXml);
$selXml = $fsdoc->saveXML($fsdoc->documentElement);
$xml .= $selXml;
} else {
$xml .= "<FeatureSet />\n";
}
if (($reqData & self::REQUEST_TOOLTIP) == self::REQUEST_TOOLTIP && strlen($tooltip) > 0) {
$xml .= "<Tooltip>" . MgUtils::EscapeXmlChars($tooltip) . "</Tooltip>\n";
} else {
$xml .= "<Tooltip />\n";
}
if (($reqData & self::REQUEST_HYPERLINK) == self::REQUEST_HYPERLINK && strlen($hyperlink) > 0) {
$xml .= "<Hyperlink>" . MgUtils::EscapeXmlChars($hyperlink) . "</Hyperlink>\n";
} else {
$xml .= "<Hyperlink />\n";
}
if (($reqData & self::REQUEST_INLINE_SELECTION) == self::REQUEST_INLINE_SELECTION && $inlineSelectionImg != null) {
$xml .= "<InlineSelectionImage>\n";
$xml .= "<MimeType>" . $inlineSelectionImg->GetMimeType() . "</MimeType>\n";
$b64 = MgUtils::ByteReaderToBase64($inlineSelectionImg);
$xml .= "<Content>{$b64}</Content>\n";
$xml .= "</InlineSelectionImage>\n";
}
if ($bRequestAttributes) {
$agfRw = new MgAgfReaderWriter();
$layerDoc = new DOMDocument();
$xml .= "<SelectedFeatures>";
$selLayers = $selection->GetLayers();
if ($selLayers != null) {
$selLayerCount = $selLayers->GetCount();
for ($i = 0; $i < $selLayerCount; $i++) {
$selLayer = $selLayers->GetItem($i);
$layerName = $selLayer->GetName();
$xml .= "<SelectedLayer id=\"" . $selLayer->GetObjectId() . "\" name=\"{$layerName}\">";
$xml .= "<LayerMetadata>\n";
$ldfId = $selLayer->GetLayerDefinition();
$layerContent = $resSvc->GetResourceContent($ldfId);
$layerDoc->loadXML($layerContent->ToString());
$propMapNodes = $layerDoc->getElementsByTagName("PropertyMapping");
$clsDef = $selLayer->GetClassDefinition();
$clsProps = $clsDef->GetProperties();
$propMappings = array();
for ($j = 0; $j < $propMapNodes->length; $j++) {
$propMapNode = $propMapNodes->item($j);
$propName = $propMapNode->getElementsByTagName("Name")->item(0)->nodeValue;
$pidx = $clsProps->IndexOf($propName);
if ($pidx >= 0) {
$propDispName = MgUtils::EscapeXmlChars($propMapNode->getElementsByTagName("Value")->item(0)->nodeValue);
$propDef = $clsProps->GetItem($pidx);
$propType = MgPropertyType::Null;
if ($propDef->GetPropertyType() == MgFeaturePropertyType::DataProperty) {
$propType = $propDef->GetDataType();
} else {
if ($propDef->GetPropertyType() == MgFeaturePropertyType::DataProperty) {
$propType = MgPropertyType::Geometry;
}
}
$xml .= "<Property>\n";
$xml .= "<Name>{$propName}</Name>\n<Type>{$propType}</Type>\n<DisplayName>{$propDispName}</DisplayName>\n";
$xml .= "</Property>\n";
$propMappings[$propName] = $propDispName;
}
}
$xml .= "</LayerMetadata>\n";
$reader = $selection->GetSelectedFeatures($selLayer, $selLayer->GetFeatureClassName(), false);
$rdrClass = $reader->GetClassDefinition();
$geomPropName = $rdrClass->GetDefaultGeometryPropertyName();
while ($reader->ReadNext()) {
$xml .= "<Feature>\n";
$bounds = "";
if (!$reader->IsNull($geomPropName)) {
$agf = $reader->GetGeometry($geomPropName);
$geom = $agfRw->Read($agf);
$env = $geom->Envelope();
$ll = $env->GetLowerLeftCoordinate();
$ur = $env->GetUpperRightCoordinate();
$bounds = $ll->GetX() . " " . $ll->GetY() . " " . $ur->GetX() . " " . $ur->GetY();
}
$xml .= "<Bounds>{$bounds}</Bounds>\n";
foreach ($propMappings as $propName => $displayName) {
$value = MgUtils::EscapeXmlChars(MgUtils::GetBasicValueFromReader($reader, $propName));
$xml .= "<Property>\n";
$xml .= "<Name>{$displayName}</Name>\n";
if (!$reader->IsNull($propName)) {
$xml .= "<Value>{$value}</Value>\n";
}
$xml .= "</Property>\n";
}
$xml .= "</Feature>\n";
}
$reader->Close();
$xml .= "</SelectedLayer>";
}
}
$xml .= "</SelectedFeatures>";
}
$xml .= "</FeatureInformation>";
return $xml;
}
$map = new MgMap($siteConnection);
$map->Open($mapName);
// Check for selection data passed via HTTP POST
if (isset($_POST['SELECTION']) && $_POST['SELECTION'] != '') {
$selection = new MgSelection($map, $_POST['SELECTION']);
$selectedLayers = $selection->GetLayers();
} else {
$selectedLayers = 0;
}
if ($selectedLayers) {
include 'bufferfunctions.php';
$bufferRingSize = 500;
// measured in metres
// Set up some objects for coordinate conversion
$mapWktSrs = $map->GetMapSRS();
$agfReaderWriter = new MgAgfReaderWriter();
$wktReaderWriter = new MgWktReaderWriter();
$coordinateSystemFactory = new MgCoordinateSystemFactory();
$srs = $coordinateSystemFactory->Create($mapWktSrs);
$srsMeasure = $srs->GetMeasure();
// Check for a buffer layer. If it exists, delete
// the current features.
// If it does not exist, create a feature source and
// a layer to hold the buffer.
/*
// Old way, pre MapGuide OS 2.0. Kept here for reference
try
{
$bufferLayer = $map->GetLayers()->GetItem('Buffer');
$bufferFeatureResId = new MgResourceIdentifier($bufferLayer->GetFeatureSourceId());
if ($layer && $layer->GetName() == 'Parcels') {
// Create a filter containing the IDs of the selected features on this layer
$layerClassName = $layer->GetFeatureClassName();
$selectionString = $selection->GenerateFilter($layer, $layerClassName);
// Get the feature resource for the selected layer
$layerFeatureId = $layer->GetFeatureSourceId();
$layerFeatureResource = new MgResourceIdentifier($layerFeatureId);
// Apply the filter to the feature resource for the selected layer. This returns
// an MgFeatureReader of all the selected features.
$queryOptions->SetFilter($selectionString);
$featureReader = $featureService->SelectFeatures($layerFeatureResource, $layerClassName, $queryOptions);
// Create the report details using the first selected parcel. Position the image so the
// centroid of the selected parcel is in the center of the map.
$featureReader->ReadNext();
$featureAgfGeometry = $featureReader->GetGeometry('SHPGEOM');
$agfReaderWriter = new MgAgfReaderWriter();
$featureGeometry = $agfReaderWriter->Read($featureAgfGeometry);
$centroid = $featureGeometry->GetCentroid();
$mapCenterX = $centroid->GetCoordinate()->GetX();
$mapCenterY = $centroid->GetCoordinate()->GetY();
$owner = $featureReader->GetString('RNAME');
$address = $featureReader->GetString('RPROPAD');
$billingAddress = $featureReader->GetString('RBILAD');
$description = $featureReader->GetString('RLDESCR1') . '<br/>' . $featureReader->GetString('RLDESCR2') . '<br/>' . $featureReader->GetString('RLDESCR3') . '<br/>';
}
}
}
}
} catch (MgException $e) {
echo '<p>' . $e->GetExceptionMessage() . '</p>';
echo '<p>' . $e->GetDetails() . '</p>';
private static function GetLayerExtent($csFactory, $doc, $csObj, $featSvc, $resSvc)
{
$agfRw = new MgAgfReaderWriter();
$vlNodes = $doc->getElementsByTagName("VectorLayerDefinition");
$glNodes = $doc->getElementsByTagName("GridLayerDefinition");
$dlNodes = $doc->getElementsByTagName("DrawingLayerDefinition");
if ($vlNodes->length == 1 || $glNodes->length == 1) {
$node = null;
if ($vlNodes->length == 1) {
$node = $vlNodes->item(0);
} else {
if ($glNodes->length == 1) {
$node = $glNodes->item(0);
}
}
$resIdStr = $node->getElementsByTagName("ResourceId")->item(0)->nodeValue;
$qClsName = $node->getElementsByTagName("FeatureName")->item(0)->nodeValue;
$geom = $node->getElementsByTagName("Geometry")->item(0)->nodeValue;
$tokens = explode(":", $qClsName);
$fsId = new MgResourceIdentifier($resIdStr);
$clsDef = $featSvc->GetClassDefinition($fsId, $tokens[0], $tokens[1]);
$clsProps = $clsDef->GetProperties();
$scReader = $featSvc->GetSpatialContexts($fsId, false);
$pi = $clsProps->IndexOf($geom);
$scName = null;
if ($pi >= 0) {
$prop = $clsProps->GetItem($pi);
if (is_callable(array($prop, "GetSpatialContextAssociation"))) {
$scName = $prop->GetSpatialContextAssociation();
}
}
if ($scName == null) {
if ($scReader->ReadNext()) {
$sourceCs = $csFactory->Create($scReader->GetCoordinateSystemWkt());
$transform = $csFactory->GetTransform($sourceCs, $csObj);
$scExtent = $scReader->GetExtent();
if ($scExtent != null) {
$geom = $agfRw->Read($scExtent);
if ($geom != null) {
return $geom->Envelope();
}
}
}
} else {
while ($scReader->ReadNext()) {
if ($scReader->GetName() == $scName) {
$sourceCs = $csFactory->Create($scReader->GetCoordinateSystemWkt());
$transform = $csFactory->GetTransform($sourceCs, $csObj);
$scExtent = $scReader->GetExtent();
if ($scExtent != null) {
$geom = $agfRw->Read($scExtent);
if ($geom != null) {
return $geom->Envelope();
}
}
}
}
}
} else {
if ($dlNodes->length == 1) {
$dsId = new MgResourceIdentifier($dlNodes->item(0)->getElementsByTagName("ResourceId")->item(0)->nodeValue);
$sheetName = $dlNodes->item(0)->getElementsByTagName("Sheet")->nodeValue;
$dsContent = $resSvc->GetResourceContent($dsId);
$dsDoc = new DOMDocument();
$dsDoc->loadXML($dsContent->ToString());
$csNodes = $dsDoc->getElementsByTagName("CoordinateSpace");
$csTrans = null;
if ($csNodes->length == 1) {
$srcCs = $csFactory->Create($csNodes->item(0)->nodeValue);
$csTrans = $csFactory->GetTransform($srcCs, $csObj);
$csTrans->IgnoreDatumShiftWarning(true);
$csTrans->IgnoreOutsideDomainWarning(true);
}
$shtNodes = $dlNodes->item(0)->getElementsByTagName("Sheet");
if ($shtNodes->length > 0) {
for ($i = 0; $i < $shtNodes->length; $i++) {
$shtNode = $shtNodes->item($i);
$shtName = $shtNode->getElementsByTagName("Name")->item(0)->nodeValue;
if ($sheetName == $shtName) {
$extNodes = $shtNode->getElementsByTagName("Extent");
if ($extNodes->length == 1) {
$minX = $extNodes->item(0)->getElementsByTagName("MinX")->item(0)->nodeValue;
$minY = $extNodes->item(0)->getElementsByTagName("MinY")->item(0)->nodeValue;
$maxX = $extNodes->item(0)->getElementsByTagName("MaxX")->item(0)->nodeValue;
$maxY = $extNodes->item(0)->getElementsByTagName("MaxY")->item(0)->nodeValue;
$env = new MgEnvelope($minX, $minY, $maxX, $maxY);
if ($csTrans != null) {
return $env->Transform($csTrans);
} else {
return $env;
}
}
}
}
}
}
}
return null;
}
$featureSrvc->CreateFeatureSource($dataSourceId, $sdfParams);
//Add layer to map
$layer = new MgLayer($layerDefId, $resourceSrvc);
$layer->SetName($bufferName);
$layer->SetLegendLabel($bufferName);
$layer->SetDisplayInLegend(true);
$layer->SetSelectable(true);
$layers->Insert(0, $layer);
} else {
//data source already exist. clear its content
//
ClearDataSource($featureSrvc, $dataSourceId, $featureName);
}
$sel = new MgSelection($map, $selText);
$selLayers = $sel->GetLayers();
$agfRW = new MgAgfReaderWriter();
$bufferGeometries = new MgGeometryCollection();
$commands = new MgFeatureCommandCollection();
$featId = 0;
$propCollection = new MgBatchPropertyCollection();
$excludedLayers = 0;
$srsDs = null;
$inputGeometries = new MgGeometryCollection();
$bufferFeatures = 0;
$allCompatible = false;
for ($li = 0; $li < $selLayers->GetCount(); $li++) {
$selLayer = $selLayers->GetItem($li);
$inputLayer = false;
$selLayerName = $selLayer->GetName();
for ($il = 0; $il < count($layerNames); $il++) {
if ($layerNames[$il] == $selLayerName) {
protected function OutputMgPropertyCollection($props, $mimeType = MgMimeType::Xml)
{
$content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><PropertyCollection />";
$count = $props->GetCount();
$agfRw = null;
$wktRw = null;
$this->app->response->header("Content-Type", $mimeType);
if ($count > 0) {
$content = "<PropertyCollection>";
for ($i = 0; $i < $count; $i++) {
$prop = $props->GetItem($i);
$name = $prop->GetName();
$type = null;
$propType = $prop->GetPropertyType();
switch ($propType) {
case MgPropertyType::Boolean:
$type = "boolean";
break;
case MgPropertyType::Byte:
$type = "byte";
break;
case MgPropertyType::DateTime:
$type = "datetime";
break;
case MgPropertyType::Decimal:
case MgPropertyType::Double:
$type = "double";
break;
case MgPropertyType::Geometry:
$type = "geometry";
break;
case MgPropertyType::Int16:
$type = "int16";
break;
case MgPropertyType::Int32:
$type = "int32";
break;
case MgPropertyType::Int64:
$type = "int64";
break;
case MgPropertyType::Single:
$type = "single";
break;
case MgPropertyType::String:
$type = "string";
break;
}
if ($prop->IsNull()) {
$content .= "<Property><Name>{$name}</Name><Type>{$type}</Type></Property>";
} else {
$value = "";
if ($propType === MgPropertyType::DateTime) {
$dt = $prop->GetValue();
$value = $dt->ToString();
} else {
if ($propType === MgPropertyType::Geometry) {
if ($wktRw == null) {
$wktRw = new MgWktReaderWriter();
}
if ($agfRw == null) {
$agfRw = new MgAgfReaderWriter();
}
try {
$agf = $prop->GetValue();
$geom = $agfRw->Read($agf);
if ($geom != null) {
$value = $wktRw->Write($geom);
}
} catch (MgException $ex) {
$value = "";
}
} else {
$value = $prop->GetValue();
}
}
$content .= "<Property><Name>{$name}</Name><Type>{$type}</Type><Value>{$value}</Value></Property>";
}
}
$content .= "</PropertyCollection>";
}
if ($mimeType === MgMimeType::Json) {
$content = MgUtils::Xml2Json($content);
}
$this->app->response->header("Content-Type", $mimeType);
$this->app->response->setBody($content);
}
/**
keep all the attributes of selected features in an array
*/
function BuildSelectionArray($featureReader, $layerName, $properties, $bComputedProperties, $srsLayer, $bNeedsTransform, $layerObj, $isLayerNameEncoded)
{
$agf = new MgAgfReaderWriter();
$srsFactory = new MgCoordinateSystemFactory();
if ($isLayerNameEncoded) {
// Add prefix to avoid layer name beginning with number
// So $isLayerNameEncoded should be true when and only when the properties will be stored in session
$layerName = GetEncodedLayerName($layerName);
}
$properties->{$layerName}->propertynames = array();
$properties->{$layerName}->propertyvalues = array();
$properties->{$layerName}->propertytypes = array();
$properties->{$layerName}->numelements = 0;
$properties->{$layerName}->values = array();
$properties->{$layerName}->metadatanames = array();
array_push($properties->{$layerName}->metadatanames, 'dimension');
array_push($properties->{$layerName}->metadatanames, 'bbox');
array_push($properties->{$layerName}->metadatanames, 'center');
array_push($properties->{$layerName}->metadatanames, 'area');
array_push($properties->{$layerName}->metadatanames, 'length');
if (isset($_SESSION)) {
$mappings = $_SESSION['property_mappings'][$layerObj->GetObjectId()];
foreach ((array) $mappings as $name => $value) {
$propType = $featureReader->GetPropertyType($name);
array_push($properties->{$layerName}->propertynames, $name);
array_push($properties->{$layerName}->propertyvalues, $value);
array_push($properties->{$layerName}->propertytypes, $propType);
}
}
$srsTarget = null;
$srsXform = null;
while ($featureReader->ReadNext()) {
$properties->{$layerName}->values[$properties->{$layerName}->numelements] = array();
$properties->{$layerName}->metadata[$properties->{$layerName}->numelements] = array();
$dimension = '';
$bbox = '';
$center = '';
$area = '';
$length = '';
if ($bComputedProperties) {
$classDef = $featureReader->GetClassDefinition();
$geomName = $classDef->GetDefaultGeometryPropertyName();
if ($geomName != '') {
$geomByteReader = $featureReader->GetGeometry($geomName);
/* is this needed? We declare one outside the loop too?*/
$agf = new MgAgfReaderWriter();
$geom = $agf->Read($geomByteReader);
$envelope = $geom->Envelope();
$ll = $envelope->GetLowerLeftCoordinate();
$ur = $envelope->GetUpperRightCoordinate();
$bbox = $ll->GetX() . ',' . $ll->GetY() . ',' . $ur->GetX() . ',' . $ur->GetY();
$centroid = $geom->GetCentroid()->GetCoordinate();
$center = $centroid->GetX() . ',' . $centroid->GetY();
/* 0 = point, 1 = curve, 2 = surface */
$dimension = $geom->GetDimension();
if ($geom->GetDimension() > 0) {
//conver the geometry to UTM auto so that local measurements
//are accruate in meters
if ($bNeedsTransform && $srsTarget == null && $srsXform == null) {
$wkt = getUtmWkt($centroid->GetX(), $centroid->GetY());
$srsTarget = $srsFactory->Create($wkt);
$verMajor = subStr(GetSiteVersion(), 0, 1);
if ($verMajor == '1') {
$srsXform = new MgCoordinateSystemTransform($srsLayer, $srsTarget);
} else {
$srsXform = $srsFactory->GetTransform($srsLayer, $srsTarget);
}
}
if ($srsXform != null) {
try {
$ageom = $geom->Transform($srsXform);
$geom = $ageom;
} catch (MgException $ee) {
echo "/*transform exception:";
echo "ERROR: " . $ee->GetExceptionMessage() . "\n";
echo $ee->GetDetails() . "\n*/";
}
}
if ($geom->GetDimension() > 1) {
$area = $geom->GetArea();
}
if ($geom->GetDimension() > 0) {
$length = $geom->GetLength();
}
}
}
}
array_push($properties->{$layerName}->metadata[$properties->{$layerName}->numelements], $dimension);
array_push($properties->{$layerName}->metadata[$properties->{$layerName}->numelements], $bbox);
array_push($properties->{$layerName}->metadata[$properties->{$layerName}->numelements], $center);
array_push($properties->{$layerName}->metadata[$properties->{$layerName}->numelements], $area);
array_push($properties->{$layerName}->metadata[$properties->{$layerName}->numelements], $length);
$numproperties = count($properties->{$layerName}->propertynames);
for ($j = 0; $j < $numproperties; $j++) {
$propname = $properties->{$layerName}->propertynames[$j];
$value = GetPropertyValueFromFeatReader($featureReader, $properties->{$layerName}->propertytypes[$j], $propname);
$value = htmlentities($value, ENT_COMPAT, 'UTF-8');
$value = addslashes($value);
$value = preg_replace("/\r?\n/", "<br>", $value);
array_push($properties->{$layerName}->values[$properties->{$layerName}->numelements], $value);
//$properties->$layerName->values[$properties->$layerName->numelements][$propname] = $value;
}
$properties->{$layerName}->numelements = $properties->{$layerName}->numelements + 1;
}
return $properties;
}
// the Web Extensions session identifier stored in PHP session state.
MgInitializeWebTier($webconfigFilePath);
$userInfo = new MgUserInformation($sessionId);
$siteConnection = new MgSiteConnection();
$siteConnection->Open($userInfo);
$map = new MgMap($siteConnection);
$map->Open($mapName);
// Get the geometry for the boundaries of District 1
$districtQuery = new MgFeatureQueryOptions();
$districtQuery->SetFilter("Autogenerated_SDF_ID = 1");
$layer = $map->GetLayers()->GetItem('Districts');
$featureReader = $layer->SelectFeatures($districtQuery);
$featureReader->ReadNext();
$districtGeometryData = $featureReader->GetGeometry('Data');
// Convert the AGF binary data to MgGeometry.
$agfReaderWriter = new MgAgfReaderWriter();
$districtGeometry = $agfReaderWriter->Read($districtGeometryData);
// Create a filter to select the desired features. Combine
// a basic filter and a spatial filter.
$queryOptions = new MgFeatureQueryOptions();
$queryOptions->SetFilter("RNAME LIKE 'SCHMITT%'");
$queryOptions->SetSpatialFilter('SHPGEOM', $districtGeometry, MgFeatureSpatialOperations::Inside);
// Get the features from the feature source,
// turn it into a selection, then save the selection as XML.
$layer = $map->GetLayers()->GetItem('Parcels');
$featureReader = $layer->SelectFeatures($queryOptions);
$layer = $map->GetLayers()->GetItem('Parcels');
$selection = new MgSelection($map);
$selection->AddFeatures($layer, $featureReader, 0);
$selectionXml = $selection->ToXml();
echo 'Selecting parcels owned by Schmitt in District 1';
function MakeLine($name, $x0, $y0, $x1, $y1)
{
$propertyCollection = new MgPropertyCollection();
$nameProperty = new MgStringProperty("NAME", $name);
$propertyCollection->Add($nameProperty);
$wktReaderWriter = new MgWktReaderWriter();
$agfReaderWriter = new MgAgfReaderWriter();
$geometry = $wktReaderWriter->Read("LINESTRING XY ({$x0} {$y0}, {$x1} {$y1})");
$geometryByteReader = $agfReaderWriter->Write($geometry);
$geometryProperty = new MgGeometryProperty("SHPGEOM", $geometryByteReader);
$propertyCollection->Add($geometryProperty);
return $propertyCollection;
}
public static function GetFeatureClassMBR($app, $featureSrvc, $featuresId, $schemaName, $className, $geomName = null, $transformToCsCode = null)
{
$extentGeometryAgg = null;
$extentGeometrySc = null;
$extentByteReader = null;
$mbr = new stdClass();
$csFactory = new MgCoordinateSystemFactory();
$clsDef = $featureSrvc->GetClassDefinition($featuresId, $schemaName, $className);
$props = $clsDef->GetProperties();
if ($geomName == null) {
$geomName = $clsDef->GetDefaultGeometryPropertyName();
}
$geomProp = $props->GetItem($geomName);
if ($geomProp->GetPropertyType() != MgFeaturePropertyType::GeometricProperty) {
throw new Exception($app->localizer->getText("E_NOT_GEOMETRY_PROPERTY", $geomName));
}
$spatialContext = $geomProp->GetSpatialContextAssociation();
// Finds the coordinate system
$agfReaderWriter = new MgAgfReaderWriter();
$spatialcontextReader = $featureSrvc->GetSpatialContexts($featuresId, false);
while ($spatialcontextReader->ReadNext()) {
if ($spatialcontextReader->GetName() == $spatialContext) {
$mbr->coordinateSystem = $spatialcontextReader->GetCoordinateSystemWkt();
$mbr->csCode = $csFactory->ConvertWktToCoordinateSystemCode($mbr->coordinateSystem);
$mbr->epsg = $csFactory->ConvertWktToEpsgCode($mbr->coordinateSystem);
// Finds the extent
$extentByteReader = $spatialcontextReader->GetExtent();
break;
}
}
$spatialcontextReader->Close();
if ($extentByteReader != null) {
// Get the extent geometry from the spatial context
$extentGeometrySc = $agfReaderWriter->Read($extentByteReader);
}
// Try to get the extents using the selectaggregate as sometimes the spatial context
// information is not set
$aggregateOptions = new MgFeatureAggregateOptions();
$featureProp = 'SPATIALEXTENTS("' . $geomName . '")';
$aggregateOptions->AddComputedProperty('EXTENTS', $featureProp);
try {
$dataReader = $featureSrvc->SelectAggregate($featuresId, $className, $aggregateOptions);
if ($dataReader->ReadNext()) {
// Get the extents information
$byteReader = $dataReader->GetGeometry('EXTENTS');
$extentGeometryAgg = $agfReaderWriter->Read($byteReader);
}
$dataReader->Close();
} catch (MgException $e) {
if ($extentGeometryAgg == null) {
//We do have one last hope. EXTENT() is an internal MapGuide custom function that's universally supported
//as it operates against an underlying select query result. This raw-spins the reader server-side so there
//is no server -> web tier transmission overhead involved.
try {
$aggregateOptions = new MgFeatureAggregateOptions();
$aggregateOptions->AddComputedProperty("COMP_EXTENT", "EXTENT(" . $geomName . ")");
$dataReader = $featureSrvc->SelectAggregate($featuresId, $className, $aggregateOptions);
if ($dataReader->ReadNext()) {
// Get the extents information
$byteReader = $dataReader->GetGeometry('COMP_EXTENT');
$extentGeometryAgg = $agfReaderWriter->Read($byteReader);
}
$dataReader->Close();
} catch (MgException $e2) {
}
}
}
$mbr->extentGeometry = null;
// Prefer SpatialExtents() of EXTENT() result over spatial context extent
if ($extentGeometryAgg != null) {
$mbr->extentGeometry = $extentGeometryAgg;
}
if ($mbr->extentGeometry == null) {
//Stil null? Now try spatial context
if ($extentGeometrySc != null) {
$mbr->extentGeometry = $extentGeometrySc;
}
}
if ($transformToCsCode != null) {
$sourceCs = $csFactory->CreateFromCode($mbr->csCode);
$targetCs = $csFactory->CreateFromCode($transformToCsCode);
$xform = $csFactory->GetTransform($sourceCs, $targetCs);
$mbr->extentGeometry = $mbr->extentGeometry->Transform($xform);
$mbr->csCode = $targetCs->GetCsCode();
$mbr->epsg = $targetCs->GetEpsgCode();
}
return $mbr;
}
function GetFeatureClassMBR($featuresId, $className, $geomProp, $featureSrvc)
{
$extentGeometryAgg = null;
$extentGeometrySc = null;
$extentByteReader = null;
$mbr = new MBR();
$geomName = $geomProp->GetName();
$spatialContext = $geomProp->GetSpatialContextAssociation();
// Finds the coordinate system
$agfReaderWriter = new MgAgfReaderWriter();
$spatialcontextReader = $featureSrvc->GetSpatialContexts($featuresId, false);
while ($spatialcontextReader->ReadNext()) {
if ($spatialcontextReader->GetName() == $spatialContext) {
$mbr->coordinateSystem = $spatialcontextReader->GetCoordinateSystemWkt();
// Finds the extent
$extentByteReader = $spatialcontextReader->GetExtent();
break;
}
}
$spatialcontextReader->Close();
if ($extentByteReader != null) {
// Get the extent geometry from the spatial context
$extentGeometrySc = $agfReaderWriter->Read($extentByteReader);
}
// Try to get the extents using the selectaggregate as sometimes the spatial context
// information is not set
$aggregateOptions = new MgFeatureAggregateOptions();
$featureProp = 'SPATIALEXTENTS("' . $geomName . '")';
$aggregateOptions->AddComputedProperty('EXTENTS', $featureProp);
try {
$dataReader = $featureSrvc->SelectAggregate($featuresId, $className, $aggregateOptions);
if ($dataReader->ReadNext()) {
// Get the extents information
$byteReader = $dataReader->GetGeometry('EXTENTS');
$extentGeometryAgg = $agfReaderWriter->Read($byteReader);
}
$dataReader->Close();
} catch (MgException $e) {
if ($extentGeometryAgg == null) {
//We do have one last hope. EXTENT() is an internal MapGuide custom function that's universally supported
//as it operates against an underlying select query result. This raw-spins the reader server-side so there
//is no server -> web tier transmission overhead involved.
try {
$aggregateOptions = new MgFeatureAggregateOptions();
$aggregateOptions->AddComputedProperty("COMP_EXTENT", "EXTENT(" . $geomName . ")");
$dataReader = $featureSrvc->SelectAggregate($featuresId, $className, $aggregateOptions);
if ($dataReader->ReadNext()) {
// Get the extents information
$byteReader = $dataReader->GetGeometry('COMP_EXTENT');
$extentGeometryAgg = $agfReaderWriter->Read($byteReader);
}
$dataReader->Close();
} catch (MgException $e2) {
}
}
}
$mbr->extentGeometry = null;
// Prefer SpatialExtents() of EXTENT() result over spatial context extent
if ($extentGeometryAgg != null) {
$mbr->extentGeometry = $extentGeometryAgg;
}
if ($mbr->extentGeometry == null) {
//Stil null? Now try spatial context
if ($extentGeometrySc != null) {
$mbr->extentGeometry = $extentGeometrySc;
}
}
return $mbr;
}
function MakePoint($name, $x, $y)
{
$propertyCollection = new MgPropertyCollection();
$nameProperty = new MgStringProperty("NAME", $name);
$propertyCollection->Add($nameProperty);
$wktReaderWriter = new MgWktReaderWriter();
$agfReaderWriter = new MgAgfReaderWriter();
$geometry = $wktReaderWriter->Read("POINT XY ({$x} {$y})");
$geometryByteReader = $agfReaderWriter->Write($geometry);
$geometryProperty = new MgGeometryProperty("GEOM", $geometryByteReader);
$propertyCollection->Add($geometryProperty);
return $propertyCollection;
}
