CreateLayer<T>(LayerCreationParams,ILayerContainerEdit) Method
Creates a new Layer instance using the specified LayerCreationParams and adds that to a container such as a map or group layer.
This method must be called on the MCT. Use QueuedTask.Run.
Parameters
- layerParams
- Can be one of LayerCreationParams derived objects.
- container
- A map or group layer instance to which the Layer will be added.
Type Parameters
- T
- Expected Layer Type
Return Value
A specific
Layer instance corresponding to type .
Create a KG Layer containing a subset of Entity and Relate types
{
await QueuedTask.Run(() =>
{
//To create a KG layer (on a map or link chart) with a subset of
//entities and relates, you must create an "id set". The workflow
//is very similar to how you would create a SelectionSet.
//First, create a dictionary containing the names of the types to be
//added plus a corresponding list of ids (just like with a selection set).
//Note: null or an empty list means add all records for "that" type..
var kg_datamodel = kg.GetDataModel();
//Arbitrarily get the name of the first entity and relate type
var first_entity = kg_datamodel.GetEntityTypes().Keys.First();
var first_relate = kg_datamodel.GetRelationshipTypes().Keys.First();
//Make entries in the dictionary for each
var dict = new Dictionary<string, List<long>>();
dict.Add(first_entity, new List<long>());//Empty list means all records
dict.Add(first_relate, null);//null list means all records
//or specific records - however the ids are obtained
//dict.Add(entity_or_relate_name, new List<long>() { 1, 5, 18, 36, 78});
//Create the id set...
var idSet = KnowledgeGraphLayerIDSet.FromDictionary(kg, dict);
//Create the layer params and assign the id set
var kg_params = new KnowledgeGraphLayerCreationParams(kg)
{
Name = "KG_With_ID_Set",
IsVisible = false,
IDSet = idSet
};
//Call layer factory with map or group layer container
//A KG layer containing just the feature layer(s) and/or standalone table(s)
//for the entity and/or relate types + associated records will be created
var kg_layer = LayerFactory.Instance.CreateLayer<KnowledgeGraphLayer>(
kg_params, map);
});
}
Create layer with create-params
{
var flyrCreatnParam = new FeatureLayerCreationParams(new Uri(@"c:\data\world.gdb\cities"))
{
Name = "World Cities",
IsVisible = false,
MinimumScale = 1000000,
MaximumScale = 5000,
DefinitionQuery = new DefinitionQuery(whereClause: "Population > 100000", name: "More than 100k"),
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
}
};
var featureLayerWithParams = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(flyrCreatnParam, map));
}
Create FeatureLayer and add to Map using LayerCreationParams
{
//Get the LayerDocument from a lyrx file
var layerDoc = new LayerDocument(@"E:\Data\SDK\Default2DPointSymbols.lyrx");
//Get the CIMLayerDocument from the LayerDocument and use it to create LayerCreationParams
var createParams = new LayerCreationParams(layerDoc.GetCIMLayerDocument());
//Create a FeatureLayer using the LayerCreationParams
await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer<FeatureLayer>(createParams, map));
}
Create FeatureLayer and set to not display in Map.
{
//The catalog path of the feature layer to add to the map
var featureClassUriVisibility = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
//Define the Feature Layer's parameters.
var layerParamsVisibility = new FeatureLayerCreationParams(featureClassUriVisibility)
{
//Set visibility
IsVisible = false,
};
//Create the layer with the feature layer parameters and add it to the active map
var createdFC = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsVisibility, map));
}
Create FeatureLayer with a Renderer
{
//Define a simple renderer to draw the Point US Cities feature class.
var simpleRender = new SimpleRendererDefinition
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.RedRGB, 4.0, SimpleMarkerStyle.Circle).MakeSymbolReference()
};
//The catalog path of the feature layer to add to the map
var featureClassUri = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
//Define the Feature Layer's parameters.
var layerParams = new FeatureLayerCreationParams(featureClassUri)
{
//Set visibility
IsVisible = true,
//Set Renderer
RendererDefinition = simpleRender,
};
//Create the layer with the feature layer parameters and add it to the active map
var createdFCWithRenderer = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
}
Create FeatureLayer with a Query Definition
{
//The catalog path of the feature layer to add to the map
var featureClassUriDefinition = new Uri(@"C:\Data\Admin\AdminData.gdb\USA\cities");
//Define the Feature Layer's parameters.
var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClassUriDefinition)
{
IsVisible = true,
DefinitionQuery = new DefinitionQuery(whereClause: "STATE_NAME = 'California'", name: "CACities")
};
//Create the layer with the feature layer parameters and add it to the active map
var createdFCWithQueryDefn = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParamsQueryDefn, map));
}
Create TopologyLayer with an Uri pointing to a Topology dataset
{
var path = @"D:\Data\CommunitySamplesData\Topology\GrandTeton.gdb\BackCountry\Backcountry_Topology";
var lcp = new TopologyLayerCreationParams(new Uri(path));
lcp.Name = "GrandTeton_Backcountry";
lcp.AddAssociatedLayers = true;
var topoLayer = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.TopologyLayer>(lcp, map));
}
Create Topology Layer using Topology dataset
{
//Get the Topology of another Topology layer
var existingTopology = map.GetLayersAsFlattenedList().OfType<TopologyLayer>().FirstOrDefault();
if (existingTopology != null)
{
await QueuedTask.Run(() =>
{
var topology = existingTopology.GetTopology();
//Configure the settings for a new Catalog layer using the CatalogDataset of an existing layer
var topologyLyrParams = new TopologyLayerCreationParams(topology);
topologyLyrParams.Name = "NewTopologyLayerFromAnotherTopologyLayer";
topologyLyrParams.AddAssociatedLayers = true;
LayerFactory.Instance.CreateLayer<TopologyLayer>(topologyLyrParams, map);
});
}
}
Create Catalog Layer using Uri to a Catalog Feature Class
{
var createParams = new CatalogLayerCreationParams(new Uri(@"C:\CatalogLayer\CatalogDS.gdb\HurricaneCatalogDS"));
//Set the definition query
createParams.DefinitionQuery = new DefinitionQuery("Query1", "cd_itemname = 'PuertoRico'");
//Set name of the new Catalog Layer
createParams.Name = "PuertoRico";
//Create Layer
var catalogLayer = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<CatalogLayer>(createParams, map));
}
Create Catalog Layer using CatalogDataset
{
//Get the CatalogDataset of another Catalog layer
var existingCatalogLayer = map.GetLayersAsFlattenedList().OfType<CatalogLayer>().FirstOrDefault();
if (existingCatalogLayer != null)
{
await QueuedTask.Run(() =>
{
var catalogDataset = existingCatalogLayer.GetCatalogDataset();
//Configure the settings for a new Catalog layer using the CatalogDataset of an existing layer
var catalogLyrParams = new CatalogLayerCreationParams(catalogDataset);
catalogLyrParams.Name = "NewCatalogLayerFromAnotherCatalogLayer";
catalogLyrParams.DefinitionQuery = new DefinitionQuery("Query1", "cd_itemname = 'Asia'");
LayerFactory.Instance.CreateLayer<CatalogLayer>(catalogLyrParams, map);
});
}
}
Add MapNotes to the active map
{
//Gets the collection of layer template packages installed with Pro for use with maps
var items = map.LayerTemplatePackages;
//Iterate through the collection of items to add each Map Note to the active map
foreach (var item in items)
{
//Create a parameter item for the map note
var layer_params = new LayerCreationParams(item);
layer_params.IsVisible = false;
//Create a feature layer for the map note
var layerCreated = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<Layer>(layer_params, map));
}
}
Apply Symbology from a Layer in the TOC
{
await QueuedTask.Run(() =>
{
if (map == null)
{
return;
}
//Get an existing Layer. This layer has a symbol you want to use in a new layer.
var lyr = map.GetLayersAsFlattenedList().OfType<FeatureLayer>()
.Where(l => l.ShapeType == esriGeometryType.esriGeometryPoint).FirstOrDefault();
//This is the renderer to use in the new Layer
var renderer = lyr.GetRenderer() as CIMSimpleRenderer;
//Set the DataConnection for the new layer
Geodatabase geodatabase = new Geodatabase(
new FileGeodatabaseConnectionPath(new Uri(@"E:\Data\Admin\AdminData.gdb")));
FeatureClass featureClass = geodatabase.OpenDataset<FeatureClass>("Cities");
var dataConnection = featureClass.GetDataConnection();
//Create the definition for the new feature layer
var featureLayerParams = new FeatureLayerCreationParams(dataConnection)
{
RendererDefinition = new SimpleRendererDefinition(renderer.Symbol),
IsVisible = true,
};
//create the new layer
LayerFactory.Instance.CreateLayer<FeatureLayer>(
featureLayerParams, map);
});
}
Create a new SubTypeGroupLayer
{
var subtypeGroupLayerCreateParam = new SubtypeGroupLayerCreationParams
(new Uri(@"c:\data\SubtypeAndDomain.gdb\Fittings"));
// Define Subtype layers
var rendererDefn1 = new UniqueValueRendererDefinition(new List<string> { "type" });
var renderDefn2 = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
};
subtypeGroupLayerCreateParam.SubtypeLayers = new List<SubtypeFeatureLayerCreationParams>()
{
//define first subtype layer with unique value renderer
new SubtypeFeatureLayerCreationParams(new UniqueValueRendererDefinition(new List<string> { "type" }), 1),
//define second subtype layer with simple symbol renderer
new SubtypeFeatureLayerCreationParams(renderDefn2, 2)
};
// Define additional parameters
subtypeGroupLayerCreateParam.DefinitionQuery = new DefinitionQuery(whereClause: "Enabled = 1", name: "IsActive");
subtypeGroupLayerCreateParam.IsVisible = true;
subtypeGroupLayerCreateParam.MinimumScale = 50000;
SubtypeGroupLayer subtypeGroupLayer2 = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<SubtypeGroupLayer>(subtypeGroupLayerCreateParam, map));
}
Create layer from a lyrx file
{
await QueuedTask.Run(() =>
{
var lyrDocFromLyrxFile = new LayerDocument(@"d:\data\cities.lyrx");
var cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();
//modifying its renderer symbol to red
var cimSimpleRenderer = ((CIMFeatureLayer)cimLyrDoc.LayerDefinitions[0]).Renderer as CIMSimpleRenderer;
cimSimpleRenderer?.Symbol.Symbol.SetColor(new CIMRGBColor() { R = 255 });
//optionally save the updates out as a file
lyrDocFromLyrxFile.Save(@"c:\data\cities_red.lyrx");
//get a json representation of the layer document and you want store away...
var aJSONString = lyrDocFromLyrxFile.AsJson();
//... and load it back when needed
lyrDocFromLyrxFile.Load(aJSONString);
cimLyrDoc = lyrDocFromLyrxFile.GetCIMLayerDocument();
//create a layer and add it to a map
var lcp = new LayerCreationParams(cimLyrDoc);
var lyr = LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map);
});
}
Add a WMS service
{
// Create a connection to the WMS server
var serverConnection = new CIMInternetServerConnection { URL = "URL of the WMS service" };
var connection = new CIMWMSServiceConnection { ServerConnection = serverConnection };
// Add a new layer to the map
var layerParams = new LayerCreationParams(connection);
var layerCreated = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
}
Add a WFS Service
{
CIMStandardDataConnection cIMStandardDataConnection = new CIMStandardDataConnection()
{
WorkspaceConnectionString = @"SWAPXY=TRUE;SWAPXYFILTER=FALSE;URL=http://sampleserver6.arcgisonline.com/arcgis/services/SampleWorldCities/MapServer/WFSServer;VERSION=2.0.0",
WorkspaceFactory = WorkspaceFactory.WFS,
Dataset = "Continent",
DatasetType = esriDatasetType.esriDTFeatureClass
};
// Add a new layer to the map
var layerPamsDC = new LayerCreationParams(cIMStandardDataConnection);
Layer layerCreated = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerPamsDC, map));
}
Add a WMTS service
{
// Create a connection to the WMS server
var serverConnection = new CIMProjectServerConnection
{
URL = "URL of the WMTS service.xml",
ServerType = ServerType.WMTS,
};
var service_connection = new CIMWMTSServiceConnection
{
ServerConnection = serverConnection,
LayerName = "AdminBoundaries", // Specify the layer name you want to add
};
// Add a new layer to the map
var layerParams = new LayerCreationParams(service_connection);
layerParams.MapMemberPosition = MapMemberPosition.AddToBottom;
var layerCreated = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
}
Connect to an AGS Service using a .ags File
{
//This workflow would work for
var agsFilePath = @"C:\Data\ServerConnectionFiles\AcmeSampleService.ags";
//ServerConnectionProjectItem supports .ags, .wms, .wmts, .wfs, and .wcs files
var server_conn_item = ItemFactory.Instance.Create(agsFilePath)
as ArcGIS.Desktop.Catalog.ServerConnectionProjectItem;
//Get the server connection - passwords are never returned
var serverConnection = server_conn_item.ServerConnection as CIMProjectServerConnection;
//Add to an AGS service connection
var service_connection = new CIMAGSServiceConnection()
{
URL = "URL to the AGS _service_ on the AGS _server_",
ServerConnection = serverConnection
};
// Add a new layer to the map
var layerParams = new LayerCreationParams(service_connection);
layerParams.MapMemberPosition = MapMemberPosition.AddToBottom;
var layerCreated = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParams, map));
}
Connect to an AGS Service using ServiceConnectionProperties
{
//Connect to the AGS service. Note: the connection will persist for the
//duration of the Pro session.
var serverUrl = "https://sampleserver6.arcgisonline.com/arcgis/rest/services";
var username = "user1";
var password = "user1";
//at any point before creating a layer, first make a connection to the server
//if one has not been already established for the current session
var uri = new Uri(serverUrl);
var props = new ServiceConnectionProperties(uri)
{
User = username
};
//It is preferred that you use the Windows Credential Manager to store the password
//However, it can be set as clear text if you so choose
props.Password = password; //not recommended
//Establish a connection to the server at any point in time _before_
//creating a layer from a service on the server
await QueuedTask.Run(() =>
{
using var gdb = new Geodatabase(props);
});
//later in the session, as needed...create a layer from one of the services
//on the server
var serviceUrl = "https://sampleserver6.arcgisonline.com/arcgis/rest/services/Wildfire_secure/MapServer";
var lc = new LayerCreationParams(new Uri(serviceUrl));
await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer<MapImageLayer>(lc, map));
}
Adding and changing styles for WMS Service Layer
{
var serverConnection = new CIMInternetServerConnection { URL = "https://spritle.esri.com/arcgis/services/sanfrancisco_sld/MapServer/WMSServer" };
var connection = new CIMWMSServiceConnection { ServerConnection = serverConnection };
LayerCreationParams parameters = new LayerCreationParams(connection);
parameters.MapMemberPosition = MapMemberPosition.AddToBottom;
await QueuedTask.Run(() =>
{
var compositeLyr = LayerFactory.Instance.CreateLayer<WMSLayer>(parameters, map);
//wms layer in ArcGIS Pro always has a composite layer inside it
var wmsLayers = compositeLyr.Layers[0] as ServiceCompositeSubLayer;
//each wms sublayer belongs in that composite layer
var highwayLayerWMSSub = wmsLayers.Layers[1] as WMSSubLayer;
//toggling a sublayer's visibility
if ((highwayLayerWMSSub != null))
{
bool visibility = highwayLayerWMSSub.IsVisible;
highwayLayerWMSSub.SetVisibility(!visibility);
}
//applying an existing style to a wms sub layer
var pizzaLayerWMSSub = wmsLayers.Layers[0] as WMSSubLayer;
var currentStyles = pizzaLayerWMSSub.GetStyleNames();
pizzaLayerWMSSub.SetStyleName(currentStyles[1]);
});
}
Create a query layer
{
Geodatabase geodatabase = new Geodatabase(new DatabaseConnectionFile(new Uri(@"C:\Connections\mySDE.sde")));
CIMSqlQueryDataConnection sqldc = new CIMSqlQueryDataConnection()
{
WorkspaceConnectionString = geodatabase.GetConnectionString(),
GeometryType = esriGeometryType.esriGeometryPolygon,
OIDFields = "OBJECTID",
Srid = "102008",
SqlQuery = "select * from MySDE.dbo.STATES",
Dataset = "States"
};
var lcp = new LayerCreationParams(sqldc)
{
Name = "States"
};
FeatureLayer flyr = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<FeatureLayer>(lcp, map));
}
Create a feature layer with class breaks renderer with defaults
{
var featureLayerCreationParams = new FeatureLayerCreationParams(new Uri(@"c:\data\countydata.gdb\counties"))
{
Name = "Population Density (sq mi) Year 2010",
RendererDefinition = new GraduatedColorsRendererDefinition("POP10_SQMI")
};
await QueuedTask.Run(() => LayerFactory.Instance.CreateLayer<FeatureLayer>(
featureLayerCreationParams, map));
}
Create a New Elevation Surface
{
//Define a ServiceConnection to use for the new Elevation surface
var serverConnection = new CIMInternetServerConnection
{
Anonymous = true,
HideUserProperty = true,
URL = "https://elevation.arcgis.com/arcgis/services"
};
CIMAGSServiceConnection serviceConnection = new CIMAGSServiceConnection
{
ObjectName = "WorldElevation/Terrain",
ObjectType = "ImageServer",
URL = "https://elevation.arcgis.com/arcgis/services/WorldElevation/Terrain/ImageServer",
ServerConnection = serverConnection
};
//Defines a new elevation source set to the CIMAGSServiceConnection defined above
//Get the elevation surfaces defined in the map
var listOfElevationSurfaces = map.GetElevationSurfaceLayers();
//Add the new elevation surface
var elevationLyrCreationParams = new ElevationLayerCreationParams(serviceConnection);
var elevationSurface = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<ElevationSurfaceLayer>(elevationLyrCreationParams, map));
}
Add an elevation source to an existing elevation surface layer
{
ElevationSurfaceLayer surfaceLayer = null;
// surfaceLayer could also be the ground layer
string uri = "https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer";
var createParams = new ElevationLayerCreationParams(new Uri(uri));
createParams.Name = "Terrain 3D";
var eleSourceLayer = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<Layer>(createParams, surfaceLayer));
}
Create a raster layer with a new colorizer definition
{
// Create a new stretch colorizer definition using default constructor.
StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
// Create a raster layer creation parameters object with the raster file path.
var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri("rasterPath"))
{
ColorizerDefinition = stretchColorizerDef,
Name = "rasterLayerName",
MapMemberIndex = 0
};
// Create a raster layer using the colorizer definition created above.
// Note: You can create a raster layer from a url, project item, or data connection.
RasterLayer rasterLayerfromURL = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<RasterLayer>(rasterLayerCreationParams, map));
}
Create a mosaic layer with a new colorizer definition
// Create a new colorizer definition using default constructor.
{
StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri("url"))
{
Name = "layerRasterName",
ColorizerDefinition = stretchColorizerDef,
MapMemberIndex = 0
};
// Create a mosaic layer using the colorizer definition created above.
// Note: You can create a mosaic layer from a url, project item, or data connection.
MosaicLayer newMosaicLayer = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<MosaicLayer>(rasterLayerCreationParams, map));
}
Create an image service layer with a new colorizer definition
{
// Create a new colorizer definition using default constructor.
StretchColorizerDefinition stretchColorizerDef = new StretchColorizerDefinition();
var rasterLayerCreationParams = new RasterLayerCreationParams(new Uri(url))
{
Name = "RasterLayer",
ColorizerDefinition = stretchColorizerDef,
MapMemberIndex = 0
};
// Create an image service layer using the colorizer definition created above.
ImageServiceLayer imageServiceLayerWithColorizer = await QueuedTask.Run(() =>
LayerFactory.Instance.CreateLayer<ImageServiceLayer>(rasterLayerCreationParams, map));
}
EsriHttpClient: Get a Service Layer and Add it to Pro
{
UriBuilder searchURL = new UriBuilder(ArcGISPortalManager.Current.GetActivePortal().PortalUri)
{
Path = "sharing/rest/search"
};
string layers = "(type:\"Map Service\" OR type:\"Image Service\" OR type:\"Feature Service\" OR type:\"WMS\" OR type:\"KML\")";
//any public layer content
searchURL.Query = string.Format("q={0}&f=json", layers);
EsriHttpClient httpClient = new EsriHttpClient();
var searchResponse = httpClient.Get(searchURL.Uri.ToString());
dynamic resultItems = JObject.Parse(await searchResponse.Content.ReadAsStringAsync());
long numberOfTotalItems = resultItems.total.Value;
if (numberOfTotalItems == 0)
{
return;
}
List<dynamic> resultItemList = new List<dynamic>();
resultItemList.AddRange(resultItems.results);
//get the first result
dynamic item = resultItemList[0];
string itemID = item.id;
Item currentItem = ItemFactory.Instance.Create(itemID, ItemFactory.ItemType.PortalItem);
var mapView = MapView.Active;
if (mapView == null)
return;
await QueuedTask.Run(() =>
{
//Create a LayerCreationParam
var layerParam = new LayerCreationParams(currentItem);
// if we have an item that can be turned into a layer
// add it to the map
if (LayerFactory.Instance.CanCreateLayerFrom(currentItem))
{
LayerFactory.Instance.CreateLayer<FeatureLayer>(layerParam, mapView.Map);
}
});
}
Create a TinLayer
{
string tinPath = @"d:\Data\Tin\TinDataset";
var tinURI = new Uri(tinPath);
var tinCP = new TinLayerCreationParams(tinURI);
tinCP.Name = "My TIN Layer";
tinCP.IsVisible = false;
await QueuedTask.Run(() =>
{
//Create the layer to the TIN
tinLayer = LayerFactory.Instance.CreateLayer<TinLayer>(tinCP, map);
});
}
Create a TinLayer from a dataset
{
var tinCP_ds = new TinLayerCreationParams(tinDataset);
tinCP_ds.Name = "My TIN Layer";
tinCP_ds.IsVisible = false;
//Create the layer to the TIN
await QueuedTask.Run(() =>
{
var tinLayer_ds = LayerFactory.Instance.CreateLayer<TinLayer>(tinCP_ds, map);
});
}
Create a TinLayer with renderers
{
var tinCP_renderers = new TinLayerCreationParams(tinDataset)
{
Name = "My TIN layer",
IsVisible = true
};
// define the node renderer - use defaults
var node_rd = new TinNodeRendererDefinition();
// define the face/surface renderer
var face_rd = new TinFaceClassBreaksRendererDefinition();
face_rd.ClassificationMethod = ClassificationMethod.NaturalBreaks;
// accept default color ramp, breakCount
// set up the renderer dictionary
var rendererDict = new Dictionary<SurfaceRendererTarget, TinRendererDefinition>
{
{ SurfaceRendererTarget.Points, node_rd },
{ SurfaceRendererTarget.Surface, face_rd }
};
// assign the dictionary to the creation params
tinCP_renderers.RendererDefinitions = rendererDict;
await QueuedTask.Run(() =>
{
// create the layer
var tinLayer_rd = LayerFactory.Instance.CreateLayer<TinLayer>(tinCP_renderers, mapView.Map);
});
}
Create a TerrainLayer
{
await QueuedTask.Run(() =>
{
string terrainPath = @"d:\Data\Terrain\filegdb_Containing_A_Terrain.gdb\FeatureDataset\Terrain_name";
var terrainURI = new Uri(terrainPath);
var terrainCP = new TerrainLayerCreationParams(terrainURI);
terrainCP.Name = "My Terrain Layer";
terrainCP.IsVisible = false;
//Create the layer to the terrain
terrainLayer = LayerFactory.Instance.CreateLayer<TerrainLayer>(terrainCP, map);
});
}
Create a TerrainLayer from a dataset
{
var terrainCP_ds = new TerrainLayerCreationParams(terrain);
terrainCP_ds.Name = "My Terrain Layer";
terrainCP_ds.IsVisible = true;
//Create the layer to the terrain
await QueuedTask.Run(() =>
{
var terrainLayer_ds = LayerFactory.Instance.CreateLayer<TerrainLayer>(terrainCP_ds, map);
});
}
Create a TerrainLayer with renderers
{
var terrainCP_renderers = new TerrainLayerCreationParams(terrain);
terrainCP_renderers.Name = "My LAS Layer";
terrainCP_renderers.IsVisible = true;
// define the edge type renderer - use defaults
var edgeRD = new TinBreaklineRendererDefinition();
// define the face/surface renderer
var faceRD = new TinFaceClassBreaksRendererDefinition();
faceRD.ClassificationMethod = ClassificationMethod.NaturalBreaks;
// accept default color ramp, breakCount
// define the dirty area renderer - use defaults
var dirtyAreaRD = new TerrainDirtyAreaRendererDefinition();
// add renderers to dictionary
var t_dict = new Dictionary<SurfaceRendererTarget, TinRendererDefinition>();
t_dict.Add(SurfaceRendererTarget.Edges, edgeRD);
t_dict.Add(SurfaceRendererTarget.Surface, faceRD);
t_dict.Add(SurfaceRendererTarget.DirtyArea, dirtyAreaRD);
// assign dictionary to creation params
terrainCP_renderers.RendererDefinitions = t_dict;
await QueuedTask.Run(() =>
{
//Create the layer to the terrain
var terrainLayer_rd = LayerFactory.Instance.CreateLayer<TerrainLayer>(terrainCP_renderers, map);
});
}
Create a LasDatasetLayer
{
string lasPath = @"d:\Data\LASDataset.lasd";
var lasURI = new Uri(lasPath);
var lasCP = new LasDatasetLayerCreationParams(lasURI);
lasCP.Name = "My LAS Layer";
lasCP.IsVisible = false;
await QueuedTask.Run(() =>
{
//Create the layer to the LAS dataset
lasDatasetLayer = LayerFactory.Instance.CreateLayer<LasDatasetLayer>(lasCP, map);
});
}
Create a LasDatasetLayer from a LasDataset
{
if (lasDataset == null)
{
throw new ArgumentNullException(nameof(lasDataset));
}
var lasCP_ds = new LasDatasetLayerCreationParams(lasDataset);
lasCP_ds.Name = "My LAS Layer";
lasCP_ds.IsVisible = false;
await QueuedTask.Run(() =>
{
//Create the layer to the LAS dataset
var lasDatasetLayer_ds = LayerFactory.Instance.CreateLayer<LasDatasetLayer>(lasCP_ds, map);
});
}
Create a LasDatasetLayer with renderers
{
var lasCP_renderers = new LasDatasetLayerCreationParams(lasDataset);
lasCP_renderers.Name = "My LAS Layer";
lasCP_renderers.IsVisible = false;
// create a point elevation renderer
var ptR = new LasStretchRendererDefinition();
// accept all defaults
// create a simple edge renderer
var edgeR = new TinEdgeRendererDefintion();
// accept all defaults
// add renderers to dictionary
var l_dict = new Dictionary<SurfaceRendererTarget, TinRendererDefinition>();
l_dict.Add(SurfaceRendererTarget.Points, ptR);
l_dict.Add(SurfaceRendererTarget.Edges, edgeR);
// assign dictionary to creation params
lasCP_renderers.RendererDefinitions = l_dict;
await QueuedTask.Run(() =>
{
//Create the layer to the LAS dataset
var lasDatasetLayer_rd = LayerFactory.Instance.CreateLayer<LasDatasetLayer>(lasCP_renderers, map);
});
}
Create GraphicsLayer
{
if (map.MapType != MapType.Map)
{
return;// not 2D
}
var gl_param = new GraphicsLayerCreationParams { Name = "Graphics Layer" };
await QueuedTask.Run(() =>
{
//By default will be added to the top of the TOC
graphicsLayer = LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.GraphicsLayer>(gl_param, map);
//Add to the bottom of the TOC
gl_param.MapMemberIndex = -1; //bottom
LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.GraphicsLayer>(gl_param, map);
//Add a graphics layer to a group layer...
var group_layer = map.GetLayersAsFlattenedList().OfType<GroupLayer>().First();
LayerFactory.Instance.CreateLayer<ArcGIS.Desktop.Mapping.GraphicsLayer>(gl_param, group_layer);
//TODO...use the graphics layer
//
// or use the specific CreateGroupLayer method
LayerFactory.Instance.CreateGroupLayer(map, -1, "Graphics Layer");
});
}
Create a Scene Layer
{
var map = MapView.Active?.Map;
if (map == null)
return;
await QueuedTask.Run(() =>
{
//Create with initial visibility set to false. Add to current scene
var createparams = new LayerCreationParams(new Uri(sceneLayerUrl, UriKind.Absolute))
{
IsVisible = false
};
//cast to specific type of scene layer being created - in this case FeatureSceneLayer
var sceneLayer = LayerFactory.Instance.CreateLayer<Layer>(
createparams, map) as FeatureSceneLayer;
//or...specify the cast directly
var sceneLayer2 = LayerFactory.Instance.CreateLayer<FeatureSceneLayer>(
createparams, map);
//ditto for BuildingSceneLayer, PointCloudSceneLayer, IntegratedMeshSceneLayer
//...
});
}
Create Stream Layer with URI
{
await QueuedTask.Run(() =>
{
var url = "https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
var createParam = new FeatureLayerCreationParams(new Uri(url))
{
IsVisible = false //turned off by default
};
streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(createParam, map);
//or use "original" create layer (will be visible by default)
Uri uri = new Uri(url);
streamLayer = LayerFactory.Instance.CreateLayer(uri, map) as StreamLayer;
streamLayer.SetVisibility(false);//turn off
});
}
Create a stream layer with a definition query
{
await QueuedTask.Run(() =>
{
var url = "https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
var lyrCreateParam = new FeatureLayerCreationParams(new Uri(url))
{
IsVisible = true,
DefinitionQuery = new DefinitionQuery(whereClause: "RWY = '29L'", name: "Runway")
};
streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(lyrCreateParam, map);
});
}
Create a stream layer with a simple renderer
{
await QueuedTask.Run(() =>
{
var url = @"https://geoeventsample1.esri.com:6443/arcgis/rest/services/LABus/StreamServer";
var uri = new Uri(url, UriKind.Absolute);
var createParams = new FeatureLayerCreationParams(uri)
{
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
ColorFactory.Instance.BlueRGB,
12,
SimpleMarkerStyle.Pushpin).MakeSymbolReference()
}
};
streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(
createParams, map);
});
}
Setting a unique value renderer for latest observations
{
await QueuedTask.Run(() =>
{
var url = @"https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
var uri = new Uri(url, UriKind.Absolute);
var createParams = new FeatureLayerCreationParams(uri)
{
IsVisible = false
};
streamLayer = LayerFactory.Instance.CreateLayer<StreamLayer>(
createParams, map);
//Define the unique values by hand
var uvr = new CIMUniqueValueRenderer()
{
Fields = new string[] { "ACTYPE" },
UseDefaultSymbol = true,
DefaultLabel = "Others",
DefaultSymbol = SymbolFactory.Instance.ConstructPointSymbol(
CIMColor.CreateRGBColor(185, 185, 185), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
};
var classes = new List<CIMUniqueValueClass>
{
//add in classes - one for ACTYPE of 727, one for DC 9
new CIMUniqueValueClass()
{
Values = new CIMUniqueValue[] {
new CIMUniqueValue() { FieldValues = new string[] { "B727" } } },
Visible = true,
Label = "Boeing 727",
Symbol = SymbolFactory.Instance.ConstructPointSymbol(
ColorFactory.Instance.RedRGB, 10, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
},
new CIMUniqueValueClass()
{
Values = new CIMUniqueValue[] {
new CIMUniqueValue() { FieldValues = new string[] { "DC9" } } },
Visible = true,
Label = "DC 9",
Symbol = SymbolFactory.Instance.ConstructPointSymbol(
ColorFactory.Instance.GreenRGB, 10, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
}
};
//add the classes to a group
var groups = new List<CIMUniqueValueGroup>()
{
new CIMUniqueValueGroup() {
Classes = classes.ToArray()
}
};
//add the groups to the renderer
uvr.Groups = groups.ToArray();
//Apply the renderer (for current observations)
streamLayer.SetRenderer(uvr);
streamLayer.SetVisibility(true);//turn on the layer
});
}
Create Voxel Layer
{
await QueuedTask.Run(() =>
{
//Must be a .NetCDF file for voxels
var url = @"C:\MyData\AirQuality_Redlands.nc";
var cim_connection = new CIMVoxelDataConnection()
{
URI = url
};
//Create a VoxelLayerCreationParams
var createParams = VoxelLayerCreationParams.Create(cim_connection);
createParams.IsVisible = true;
//Can also just use the path directly...
//var createParams = VoxelLayerCreationParams.Create(url);
//Use VoxelLayerCreationParams to enumerate the variables within
//the voxel
var variables = createParams.Variables;
foreach (var variable in variables)
{
var line = $"{variable.Variable}: {variable.DataType}, " +
$"{variable.Description}, {variable.IsDefault}, {variable.IsSelected}";
System.Diagnostics.Debug.WriteLine(line);
}
//Optional: set the default variable
createParams.SetDefaultVariable(variables.Last());
//Create the layer - map must be a local scene
voxelLayer = LayerFactory.Instance.CreateLayer<VoxelLayer>(createParams, map);
});
}
Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)
ArcGIS Pro version: 3.0 or higher.