Example #1
0
function CreateFeatureSource($map, $dataSourceId, $featureName, $featureService, $geomType, $schema = "")
{
    //create feature source
    $classDef = new MgClassDefinition();
    $classDef->SetName($featureName);
    $classDef->SetDescription($featureName . " feature layer");
    $classDef->SetDefaultGeometryPropertyName("GEOM");
    //Set KEY property
    $prop = new MgDataPropertyDefinition("KEY");
    $prop->SetDataType(MgPropertyType::Int32);
    $prop->SetAutoGeneration(true);
    $prop->SetReadOnly(true);
    $classDef->GetIdentityProperties()->Add($prop);
    $classDef->GetProperties()->Add($prop);
    $prop = new MgGeometricPropertyDefinition("GEOM");
    $prop->SetGeometryTypes($geomType);
    $classDef->GetProperties()->Add($prop);
    //Create the schema
    if ($schema == "") {
        $schema = "DrawToolSchema";
    }
    $schema = new MgFeatureSchema($schema, "Temporary draw layer schema");
    $schema->GetClasses()->Add($classDef);
    //finally, creation of the feature source
    $params = new MgCreateSdfParams("LatLong", GetMapSRS($map), $schema);
    $featureService->CreateFeatureSource($dataSourceId, $params);
}
Example #2
0
 static function CreateTextProperty($length)
 {
     $textProperty = new MgDataPropertyDefinition('Text');
     $textProperty->SetDataType(MgPropertyType::String);
     $textProperty->SetLength($length);
     return $textProperty;
 }
Example #3
0
function CreateAddressMarkerFeatureSource($featureService, $addressMarkerDataResId)
{
    $ll84Wkt = 'GEOGCS["WGS84 Lat/Long\'s, Degrees, -180 ==> +180",DATUM["D_WGS_1984",SPHEROID["World_Geodetic_System_of_1984",6378137,298.257222932867]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]';
    $addressClass = new MgClassDefinition();
    $addressClass->SetName('AddressMarker');
    $properties = $addressClass->GetProperties();
    $idProperty = new MgDataPropertyDefinition('ID');
    $idProperty->SetDataType(MgPropertyType::Int32);
    $idProperty->SetReadOnly(true);
    $idProperty->SetNullable(false);
    $idProperty->SetAutoGeneration(true);
    $properties->Add($idProperty);
    $addressProperty = new MgDataPropertyDefinition('Address');
    $addressProperty->SetDataType(MgPropertyType::String);
    $addressProperty->SetLength(512);
    $properties->Add($addressProperty);
    $locationProperty = new MgGeometricPropertyDefinition('Location');
    $locationProperty->SetGeometryTypes(MgGeometryType::Point);
    $locationProperty->SetHasElevation(false);
    $locationProperty->SetHasMeasure(false);
    $locationProperty->SetReadOnly(false);
    $locationProperty->SetSpatialContextAssociation('LL84');
    $properties->Add($locationProperty);
    $idProperties = $addressClass->GetIdentityProperties();
    $idProperties->Add($idProperty);
    $addressClass->SetDefaultGeometryPropertyName('Location');
    $addressSchema = new MgFeatureSchema();
    $addressSchema->SetName('AddressMarkerSchema');
    $addressSchema->GetClasses()->Add($addressClass);
    $sdfParams = new MgCreateSdfParams('LL84', $ll84Wkt, $addressSchema);
    $featureService->CreateFeatureSource($addressMarkerDataResId, $sdfParams);
}
Example #4
0
 function InitMarkupRegistry()
 {
     //NOTE: EnumerateResources does not work for session repositories. So to be able to "enumerate"
     //resources, we create a registry feature source that would store this information
     $this->markupRegistryId = new MgResourceIdentifier($this->GetResourceIdPrefix() . MarkupManager::MARKUP_REGISTRY_NAME . ".FeatureSource");
     $resourceService = $this->site->CreateService(MgServiceType::ResourceService);
     //Create the markup registry feature source if it doesn't already exist
     if (!$resourceService->ResourceExists($this->markupRegistryId)) {
         $featureService = $this->site->CreateService(MgServiceType::FeatureService);
         //Markup Registry Feature Source Schema
         //
         //Default
         //  MarkupRegistry
         //    ResourceId (String, Identity, Not Null)
         //    LayerDefintion (String, Not Null)
         //    Name (String, Not Null)
         //    FdoProvider (String, Not Null)
         //    GeometryTypes (Int, Not Null)
         $markupRegSchema = new MgFeatureSchema("Default", "");
         $markupRegClass = new MgClassDefinition();
         $markupRegClass->SetName("MarkupRegistry");
         $markupRegId = new MgDataPropertyDefinition("ResourceId");
         $markupRegId->SetDataType(MgPropertyType::String);
         $markupRegId->SetLength(1024);
         $markupRegId->SetNullable(false);
         $layerDefId = new MgDataPropertyDefinition("LayerDefinition");
         $layerDefId->SetDataType(MgPropertyType::String);
         $layerDefId->SetLength(1024);
         $layerDefId->SetNullable(false);
         $markupRegName = new MgDataPropertyDefinition("Name");
         $markupRegName->SetDataType(MgPropertyType::String);
         $markupRegName->SetLength(512);
         $markupRegName->SetNullable(false);
         $fdoProvider = new MgDataPropertyDefinition("FdoProvider");
         $fdoProvider->SetDataType(MgPropertyType::String);
         $fdoProvider->SetLength(512);
         $fdoProvider->SetNullable(false);
         $geomTypes = new MgDataPropertyDefinition("GeometryTypes");
         $geomTypes->SetDataType(MgPropertyType::Int32);
         $geomTypes->SetNullable(false);
         $dataProps = $markupRegClass->GetProperties();
         $dataProps->Add($markupRegId);
         $dataProps->Add($layerDefId);
         $dataProps->Add($markupRegName);
         $dataProps->Add($fdoProvider);
         $dataProps->Add($geomTypes);
         $idProps = $markupRegClass->GetIdentityProperties();
         $idProps->Add($markupRegId);
         $classes = $markupRegSchema->GetClasses();
         $classes->Add($markupRegClass);
         $createSdf = new MgFileFeatureSourceParams("OSGeo.SDF", "Default", "", $markupRegSchema);
         $featureService->CreateFeatureSource($this->markupRegistryId, $createSdf);
     }
 }
Example #5
0
 function ClassDefinition()
 {
     $classDef = new MgClassDefinition();
     $classDef->SetName("StringKey");
     $classDef->SetDescription("String key feature class");
     $classDef->SetDefaultGeometryPropertyName("GEOM");
     // Set key property
     $prop = new MgDataPropertyDefinition("SKEY");
     $prop->SetDataType(MgPropertyType::String);
     $prop->SetAutoGeneration(false);
     $classDef->GetIdentityProperties()->Add($prop);
     $classDef->GetProperties()->Add($prop);
     $prop = new MgDataPropertyDefinition("NAME");
     $prop->SetDataType(MgPropertyType::String);
     $classDef->GetProperties()->Add($prop);
     // Set geometry property
     $prop = new MgGeometricPropertyDefinition("GEOM");
     $prop->SetGeometryTypes(4);
     $classDef->GetProperties()->Add($prop);
     return $classDef;
 }
Example #6
0
function CreateParcelMarkerFeatureSource($featureService, $wkt, $parcelMarkerDataResId)
{
    $parcelClass = new MgClassDefinition();
    $parcelClass->SetName('ParcelMarkerClass');
    $properties = $parcelClass->GetProperties();
    $idProperty = new MgDataPropertyDefinition('ID');
    $idProperty->SetDataType(MgPropertyType::Int32);
    $idProperty->SetReadOnly(true);
    $idProperty->SetNullable(false);
    $idProperty->SetAutoGeneration(true);
    $properties->Add($idProperty);
    $pointProperty = new MgGeometricPropertyDefinition('ParcelLocation');
    $pointProperty->SetGeometryTypes(MgGeometryType::Point);
    $pointProperty->SetHasElevation(false);
    $pointProperty->SetHasMeasure(false);
    $pointProperty->SetReadOnly(false);
    $pointProperty->SetSpatialContextAssociation('defaultSrs');
    $properties->Add($pointProperty);
    $idProperties = $parcelClass->GetIdentityProperties();
    $idProperties->Add($idProperty);
    $parcelClass->SetDefaultGeometryPropertyName('ParcelLocation');
    $parcelSchema = new MgFeatureSchema('ParcelLayerSchema', 'temporary schema to hold parcel markers');
    $parcelSchema->GetClasses()->Add($parcelClass);
    $sdfParams = new MgCreateSdfParams('defaultSrs', $wkt, $parcelSchema);
    $featureService->CreateFeatureSource($parcelMarkerDataResId, $sdfParams);
}
Example #7
0
 private function CreateFilterSchema()
 {
     $filterSchema = new MgFeatureSchema();
     $filterSchema->SetName('FilterSchema');
     $filterClass = new MgClassDefinition();
     $filterClass->SetName('Filter');
     $properties = $filterClass->GetProperties();
     $idProperty = new MgDataPropertyDefinition('ID');
     $idProperty->SetDataType(MgPropertyType::Int32);
     $idProperty->SetReadOnly(true);
     $idProperty->SetNullable(false);
     $idProperty->SetAutoGeneration(true);
     $properties->Add($idProperty);
     $geometryProperty = new MgGeometricPropertyDefinition('Geometry');
     $geometryProperty->SetGeometryTypes(MgFeatureGeometricType::Surface);
     $geometryProperty->SetHasElevation(false);
     $geometryProperty->SetHasMeasure(false);
     $geometryProperty->SetReadOnly(false);
     $geometryProperty->SetSpatialContextAssociation('MAPCS');
     $properties->Add($geometryProperty);
     $filterClass->GetIdentityProperties()->Add($idProperty);
     $filterClass->SetDefaultGeometryPropertyName('Geometry');
     $filterSchema->GetClasses()->Add($filterClass);
     return $filterSchema;
 }
 public function CreateFeatureSource($resId, $inputFormat)
 {
     //Check for unsupported representations
     $fmt = $this->ValidateRepresentation($inputFormat, array("xml", "json"));
     $sessionId = "";
     if ($resId->GetRepositoryType() == MgRepositoryType::Session) {
         $sessionId = $resId->GetRepositoryName();
     }
     $mimeType = $this->GetMimeTypeForFormat($fmt);
     $this->EnsureAuthenticationForSite($sessionId, false, $mimeType);
     $siteConn = new MgSiteConnection();
     $siteConn->Open($this->userInfo);
     $site = $siteConn->GetSite();
     $this->VerifyWhitelist($resId->ToString(), $mimeType, "CREATEFEATURESOURCE", $fmt, $site, $this->userName);
     $this->EnsureAuthenticationForSite($sessionId);
     $siteConn = new MgSiteConnection();
     $siteConn->Open($this->userInfo);
     $featSvc = $siteConn->CreateService(MgServiceType::FeatureService);
     if ($fmt == "json") {
         $body = $this->app->request->getBody();
         $json = json_decode($body);
         if ($json == NULL) {
             throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
         }
     } else {
         $body = $this->app->request->getBody();
         $jsonStr = MgUtils::Xml2Json($body);
         $json = json_decode($jsonStr);
     }
     if (!isset($json->FeatureSourceParams)) {
         throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
     }
     $fsParams = $json->FeatureSourceParams;
     if (!isset($fsParams->File)) {
         throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
     }
     if (!isset($fsParams->SpatialContext)) {
         throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
     }
     if (!isset($fsParams->FeatureSchema)) {
         throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
     }
     $mkParams = new MgFileFeatureSourceParams();
     if (isset($fsParams->File->Provider)) {
         $mkParams->SetProviderName($fsParams->File->Provider);
     }
     if (isset($fsParams->File->FileName)) {
         $mkParams->SetFileName($fsParams->File->FileName);
     }
     if (isset($fsParams->SpatialContext->Name)) {
         $mkParams->SetSpatialContextName($fsParams->SpatialContext->Name);
     }
     if (isset($fsParams->SpatialContext->Description)) {
         $mkParams->SetSpatialContextDescription($fsParams->SpatialContext->Description);
     }
     if (isset($fsParams->SpatialContext->CoordinateSystem)) {
         $mkParams->SetCoordinateSystemWkt($fsParams->SpatialContext->CoordinateSystem);
     }
     if (isset($fsParams->SpatialContext->XYTolerance)) {
         $mkParams->SetXYTolerance($fsParams->SpatialContext->XYTolerance);
     }
     if (isset($fsParams->SpatialContext->ZTolerance)) {
         $mkParams->SetZTolerance($fsParams->SpatialContext->ZTolerance);
     }
     $mkSchema = $fsParams->FeatureSchema;
     $schema = new MgFeatureSchema();
     if (isset($mkSchema->Name)) {
         $schema->SetName($mkSchema->Name);
     }
     if (isset($mkSchema->Description)) {
         $schema->SetDescription($mkSchema->Description);
     }
     $classes = $schema->GetClasses();
     foreach ($mkSchema->ClassDefinition as $mkClass) {
         $cls = new MgClassDefinition();
         if (isset($mkClass->Name)) {
             $cls->SetName($mkClass->Name);
         }
         if (isset($mkClass->Description)) {
             $cls->SetDescription($mkClass->Description);
         }
         if (isset($mkClass->DefaultGeometryPropertyName)) {
             $cls->SetDefaultGeometryPropertyName($mkClass->DefaultGeometryPropertyName);
         }
         $clsProps = $cls->GetProperties();
         $idProps = $cls->GetIdentityProperties();
         foreach ($mkClass->PropertyDefinition as $propDef) {
             if (isset($propDef->PropertyType)) {
                 $mkProp = null;
                 switch ($propDef->PropertyType) {
                     case MgFeaturePropertyType::DataProperty:
                         $mkProp = new MgDataPropertyDefinition($propDef->Name);
                         if (isset($propDef->DataType)) {
                             $mkProp->SetDataType($propDef->DataType);
                         }
                         if (isset($propDef->Nullable)) {
                             $mkProp->SetNullable($propDef->Nullable);
                         }
                         if (isset($propDef->IsAutoGenerated)) {
                             $mkProp->SetAutoGeneration($propDef->IsAutoGenerated);
                         }
                         if (isset($propDef->DefaultValue)) {
                             $mkProp->SetDefaultValue($propDef->DefaultValue);
                         }
                         if (isset($propDef->Length)) {
                             $mkProp->SetLength($propDef->Length);
                         }
                         if (isset($propDef->Precision)) {
                             $mkProp->SetPrecision($propDef->Precision);
                         }
                         if (isset($propDef->Scale)) {
                             $mkProp->SetScale($propDef->Scale);
                         }
                         break;
                     case MgFeaturePropertyType::GeometricProperty:
                         $mkProp = new MgGeometricPropertyDefinition($propDef->Name);
                         if (isset($propDef->GeometryTypes)) {
                             $mkProp->SetGeometryTypes($propDef->GeometryTypes);
                         }
                         if (isset($propDef->HasElevation)) {
                             $mkProp->SetHasElevation($propDef->HasElevation);
                         }
                         if (isset($propDef->HasMeasure)) {
                             $mkProp->SetHasMeasure($propDef->HasMeasure);
                         }
                         if (isset($propDef->SpatialContextAssociation)) {
                             $mkProp->SetSpatialContextAssociation($propDef->SpatialContextAssociation);
                         }
                         break;
                     default:
                         throw new Exception($this->app->localizer->getText("E_UNSUPPORTED_PROPERTY_TYPE"));
                 }
                 if ($mkProp != null) {
                     if (isset($propDef->Description)) {
                         $mkProp->SetDescription($propDef->Description);
                     }
                     if (isset($propDef->ReadOnly)) {
                         $mkProp->SetReadOnly($propDef->ReadOnly);
                     }
                     $clsProps->Add($mkProp);
                     if (isset($propDef->IsIdentity) && $propDef->IsIdentity == true) {
                         $idProps->Add($mkProp);
                     }
                 }
             }
         }
         if (isset($mkClass->DefaultGeometryPropertyName)) {
             $cls->SetDefaultGeometryPropertyName($mkClass->DefaultGeometryPropertyName);
         }
         $classes->Add($cls);
     }
     $mkParams->SetFeatureSchema($schema);
     try {
         $featSvc->CreateFeatureSource($resId, $mkParams);
     } catch (MgException $ex) {
         $this->OnException($ex, $mimeType);
     }
 }
Example #9
0
 // source
 $classDefinition = new MgClassDefinition();
 $classDefinition->SetName("Lines");
 $classDefinition->SetDescription("Lines to display.");
 $geometryPropertyName = "SHPGEOM";
 $classDefinition->SetDefaultGeometryPropertyName($geometryPropertyName);
 // Create an identify property
 $identityProperty = new MgDataPropertyDefinition("KEY");
 $identityProperty->SetDataType(MgPropertyType::Int32);
 $identityProperty->SetAutoGeneration(true);
 $identityProperty->SetReadOnly(true);
 // Add the identity property to the class definition
 $classDefinition->GetIdentityProperties()->Add($identityProperty);
 $classDefinition->GetProperties()->Add($identityProperty);
 // Create a name property
 $nameProperty = new MgDataPropertyDefinition("NAME");
 $nameProperty->SetDataType(MgPropertyType::String);
 // Add the name property to the class definition
 $classDefinition->GetProperties()->Add($nameProperty);
 // Create a geometry property
 $geometryProperty = new MgGeometricPropertyDefinition($geometryPropertyName);
 $geometryProperty->SetGeometryTypes(MgFeatureGeometricType::Surface);
 // Add the geometry property to the class definition
 $classDefinition->GetProperties()->Add($geometryProperty);
 // Create a feature schema
 $featureSchema = new MgFeatureSchema("SHP_Schema", "Line schema");
 // Add the feature schema to the class definition
 $featureSchema->GetClasses()->Add($classDefinition);
 // Create the feature source
 $wkt = $map->GetMapSRS();
 $sdfParams = new MgCreateSdfParams("spatial context", $wkt, $featureSchema);
Example #10
0
    return;
}
echo "Created Services\n";
// Create class definition for new feature  class
$classDef = new MgClassDefinition();
$classDef->SetName("Buffer");
$classDef->SetDescription("Feature class for buffer layer");
$classDef->SetDefaultGeometryPropertyName("GEOM");
// Set key property
$prop = new MgDataPropertyDefinition("KEY");
$prop->SetDataType(MgPropertyType::Int32);
$prop->SetAutoGeneration(true);
$prop->SetReadOnly(true);
$classDef->GetIdentityProperties()->Add($prop);
$classDef->GetProperties()->Add($prop);
$prop = new MgDataPropertyDefinition("NAME");
$prop->SetDataType(MgPropertyType::String);
$classDef->GetProperties()->Add($prop);
// Set geometry property
$prop = new MgGeometricPropertyDefinition("GEOM");
$prop->SetGeometryTypes(MgFeatureGeometricType::Surface);
$classDef->GetProperties()->Add($prop);
$schema = new MgFeatureSchema("BufferSchema", "Temporary buffer schema");
$schema->GetClasses()->Add($classDef);
$wkt = "LOCALCS[\"Non-Earth (Meter)\",LOCAL_DATUM[\"Local Datum\",0],UNIT[\"Meter\", 1],AXIS[\"X\",EAST],AXIS[\"Y\",NORTH]]";
$params = new MgCreateSdfParams("ArbitraryXY", $wkt, $schema);
echo "Created sdfparams\n";
$layerName = 'Library://TrevorWekel/NewSdf.FeatureSource';
$id = new MgResourceIdentifier($layerName);
try {
    $svc->CreateFeatureSource($id, $params);
Example #11
0
 $id->SetDataType(MgPropertyType::Int32);
 $id->SetNullable(false);
 $id->SetAutoGeneration(true);
 $pid = new MgDataPropertyDefinition("ParcelID");
 $pid->SetDataType(MgPropertyType::Int32);
 $pid->SetNullable(false);
 $pid->SetLength(255);
 $name = new MgDataPropertyDefinition("Name");
 $name->SetDataType(MgPropertyType::String);
 $name->SetNullable(true);
 $name->SetLength(255);
 $comment = new MgDataPropertyDefinition("Comment");
 $comment->SetDataType(MgPropertyType::String);
 $comment->SetNullable(true);
 $comment->SetLength(255);
 $recordedDate = new MgDataPropertyDefinition("RecordedDate");
 $recordedDate->SetDataType(MgPropertyType::DateTime);
 $recordedDate->SetNullable(false);
 $props->Add($id);
 $idProps->Add($id);
 $props->Add($pid);
 $props->Add($name);
 $props->Add($comment);
 $props->Add($recordedDate);
 $classes = $schema->GetClasses();
 $classes->Add($clsDef);
 $createParams = new MgFileFeatureSourceParams("OSGeo.SDF");
 $createParams->SetFeatureSchema($schema);
 $featSvc->CreateFeatureSource($commentsId, $createParams);
 //Web Layout demonstrating intergration with REST-enabled published data
 $bs3 = new MgByteSource(dirname(__FILE__) . "/RESTWebLayout.mgp");
Example #12
0
 $classDef->SetName($featureName);
 $classDef->SetDescription(GetLocalizedString("MEASUREFEATURECLASS", $locale));
 $classDef->SetDefaultGeometryPropertyName("GEOM");
 //Set KEY property
 $prop = new MgDataPropertyDefinition("KEY");
 $prop->SetDataType(MgPropertyType::Int32);
 $prop->SetAutoGeneration(true);
 $prop->SetReadOnly(true);
 $classDef->GetIdentityProperties()->Add($prop);
 $classDef->GetProperties()->Add($prop);
 //Set PARTIAL property. Hold the distance for this segment
 $prop = new MgDataPropertyDefinition("PARTIAL");
 $prop->SetDataType(MgPropertyType::Double);
 $classDef->GetProperties()->Add($prop);
 //Set TOTAL property. Hold the total distance up to this segment, including it
 $prop = new MgDataPropertyDefinition("TOTAL");
 $prop->SetDataType(MgPropertyType::Double);
 $classDef->GetProperties()->Add($prop);
 //Set geometry property
 $prop = new MgGeometricPropertyDefinition("GEOM");
 //$prop->SetGeometryTypes(MgFeatureGeometricType::mfgtSurface); //TODO use the constant when exposed
 $prop->SetGeometryTypes(4);
 $classDef->GetProperties()->Add($prop);
 //Create the schema
 $schema = new MgFeatureSchema("MeasureSchema", GetLocalizedString("MEASURESCHEMADESCR", $locale));
 $schema->GetClasses()->Add($classDef);
 //finally, creation of the feature source
 $params = new MgCreateSdfParams("MapSrs", $srs, $schema);
 $featureSrvc->CreateFeatureSource($dataSourceId, $params);
 //build map tip
 $unitText = "";