public async void Example3()
{
Map map = MapView.Active.Map;
await QueuedTask.Run(() =>
{
#region Create a stream layer with a simple renderer
var url = @"https://geoeventsample1.esri.com:6443/arcgis/rest/services/LABus/StreamServer";
var uri = new Uri(url, UriKind.Absolute);
//Must be on QueuedTask!
var createParams = new FeatureLayerCreationParams(uri)
{
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(
ColorFactory.Instance.BlueRGB,
12,
SimpleMarkerStyle.Pushpin).MakeSymbolReference()
}
};
var streamLayer = LayerFactory.Instance.CreateLayer <StreamLayer>(
createParams, map);
#endregion
});
}
private Task addFeatureLayer()
{
Debug.WriteLine("addFeatureLayer enter");
return(ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
ArcGIS.Core.Data.DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.PostgreSQL)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = @"127.0.0.1",
Database = "geomapmaker2",
User = "******",
Password = "******",
//Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
{
using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>("geomapmaker2.geomapmaker2.line_features"))
{
var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClass)
{
IsVisible = true,
DefinitionFilter = new CIMDefinitionFilter()
{
Name = "User",
DefinitionExpression = "user_id = " + DataHelper.userID
}
};
featureLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(layerParamsQueryDefn, MapView.Active.Map);
}
}
}));
}
public static async Task <BA_ReturnCode> AddPointMarkersAsync(Uri aoiUri, string displayName, CIMColor markerColor,
SimpleMarkerStyle markerStyle, double markerSize)
{
// parse the uri for the folder and file
string strFileName = null;
string strFolderPath = null;
if (aoiUri.IsFile)
{
strFileName = System.IO.Path.GetFileName(aoiUri.LocalPath);
strFolderPath = System.IO.Path.GetDirectoryName(aoiUri.LocalPath);
}
BA_ReturnCode success = BA_ReturnCode.UnknownError;
await QueuedTask.Run(() =>
{
FeatureClass fClass = null;
// Opens a file geodatabase. This will open the geodatabase if the folder exists and contains a valid geodatabase.
using (Geodatabase geodatabase =
new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(strFolderPath))))
{
// Use the geodatabase.
try
{
fClass = geodatabase.OpenDataset <FeatureClass>(strFileName);
}
catch (GeodatabaseTableException e)
{
Debug.WriteLine("DisplayPointMarkersAsync: Unable to open feature class " + strFileName);
Debug.WriteLine("DisplayPointMarkersAsync: " + e.Message);
success = BA_ReturnCode.ReadError;
return;
}
}
// Create symbology for feature layer
var flyrCreatnParam = new FeatureLayerCreationParams(fClass)
{
Name = displayName,
IsVisible = true,
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(markerColor, markerSize, markerStyle)
.MakeSymbolReference()
}
};
FeatureLayer fLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(flyrCreatnParam, MapView.Active.Map);
});
success = BA_ReturnCode.Success;
return(success);
}
public static async Task <BA_ReturnCode> AddPolygonLayerAsync(Uri uri, CIMColor fillColor, bool isVisible, string displayName = "")
{
// parse the uri for the folder and file
string strFileName = null;
string strFolderPath = null;
if (uri.IsFile)
{
strFileName = System.IO.Path.GetFileName(uri.LocalPath);
strFolderPath = System.IO.Path.GetDirectoryName(uri.LocalPath);
}
BA_ReturnCode success = BA_ReturnCode.UnknownError;
await QueuedTask.Run(() =>
{
FeatureClass fClass = null;
// Opens a file geodatabase. This will open the geodatabase if the folder exists and contains a valid geodatabase.
using (Geodatabase geodatabase =
new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(strFolderPath))))
{
// Use the geodatabase.
fClass = geodatabase.OpenDataset <FeatureClass>(strFileName);
}
if (String.IsNullOrEmpty(displayName))
{
displayName = fClass.GetDefinition().GetAliasName();
}
// Create symbology for feature layer
var flyrCreatnParam = new FeatureLayerCreationParams(fClass)
{
Name = displayName,
IsVisible = true,
RendererDefinition = new SimpleRendererDefinition()
{
//SymbolTemplate = SymbolFactory.Instance.ConstructPolygonSymbol(fillColor).MakeSymbolReference()
SymbolTemplate = SymbolFactory.Instance.ConstructPolygonSymbol(
fillColor, SimpleFillStyle.Solid,
SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 0))
.MakeSymbolReference()
}
};
FeatureLayer fLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(flyrCreatnParam, MapView.Active.Map);
fLayer.SetVisibility(isVisible);
success = BA_ReturnCode.Success;
});
return(success);
}
public static FeatureLayerCreationParams CreateLayerParams([NotNull] FeatureClass featureClass)
{
var layerParams = new FeatureLayerCreationParams(featureClass);
// todo daro: apply renderer here from template
// LayerDocument is null!
//LayerDocument template
//CIMDefinition layerDefinition = layerParams.LayerDocument.LayerDefinitions[0];
//var uniqueValueRenderer = GetRenderer<CIMUniqueValueRenderer>(template);
//if (uniqueValueRenderer != null)
//{
// ((CIMFeatureLayer) layerDefinition).Renderer = uniqueValueRenderer;
//}
return(layerParams);
}
public static async Task AddAoiBoundaryToMapAsync(Uri aoiUri, string displayName = "", double lineSymbolWidth = 1.0)
{
// parse the uri for the folder and file
string strFileName = null;
string strFolderPath = null;
if (aoiUri.IsFile)
{
strFileName = System.IO.Path.GetFileName(aoiUri.LocalPath);
strFolderPath = System.IO.Path.GetDirectoryName(aoiUri.LocalPath);
}
await QueuedTask.Run(() =>
{
FeatureClass fClass = null;
// Opens a file geodatabase. This will open the geodatabase if the folder exists and contains a valid geodatabase.
using (Geodatabase geodatabase =
new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(strFolderPath))))
{
// Use the geodatabase.
fClass = geodatabase.OpenDataset <FeatureClass>(strFileName);
}
if (String.IsNullOrEmpty(displayName))
{
displayName = fClass.GetDefinition().GetAliasName();
}
// Create symbology for feature layer
var flyrCreatnParam = new FeatureLayerCreationParams(fClass)
{
Name = displayName,
IsVisible = true,
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPolygonSymbol(
ColorFactory.Instance.BlackRGB, SimpleFillStyle.Null,
SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, lineSymbolWidth, SimpleLineStyle.Solid))
.MakeSymbolReference()
}
};
FeatureLayer fLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(flyrCreatnParam, MapView.Active.Map);
});
}
public async void Example1()
{
Map map = MapView.Active.Map;
await QueuedTask.Run(() =>
{
#region Create Stream Layer with URI
//Must be on the QueuedTask
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
};
var 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
#endregion
});
}
public async void Example2()
{
Map map = MapView.Active.Map;
await QueuedTask.Run(() =>
{
#region Create a stream layer with a definition query
//Must be on the QueuedTask
var url = "https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
var lyrCreateParam = new FeatureLayerCreationParams(new Uri(url))
{
IsVisible = true,
DefinitionFilter = new CIMDefinitionFilter()
{
DefinitionExpression = "RWY = '29L'",
Name = "Runway"
}
};
var streamLayer = LayerFactory.Instance.CreateLayer <StreamLayer>(lyrCreateParam, map);
#endregion
});
}
private void CreateLayer()
{
Map map = MapView.Active.Map;
#region 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,
DefinitionFilter = new CIMDefinitionFilter()
{
DefinitionExpression = "Population > 100000",
Name = "More than 100k"
},
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
}
};
var featureLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(flyrCreatnParam, map, LayerPosition.AutoArrange);
#endregion
#region Create a subtype group layer
var subtypeGroupLayerCreateParam = new SubtypeGroupLayerCreationParams
(
new Uri(@"c:\data\SubtypeAndDomain.gdb\Fittings")
);
#region Define Subtype layers
subtypeGroupLayerCreateParam.SubtypeLayers = new List <SubtypeFeatureLayerCreationParams>()
{
//define first subtype layer with unique value renderer
new SubtypeFeatureLayerCreationParams()
{
SubtypeId = 1,
RendererDefinition = new UniqueValueRendererDefinition(new string[] { "type" })
},
//define second subtype layer with simple symbol renderer
new SubtypeFeatureLayerCreationParams()
{
SubtypeId = 2,
RendererDefinition = new SimpleRendererDefinition()
{
SymbolTemplate = SymbolFactory.Instance.ConstructPointSymbol(CIMColor.CreateRGBColor(255, 0, 0), 8, SimpleMarkerStyle.Hexagon).MakeSymbolReference()
}
}
};
#endregion
#region Define additional parameters
subtypeGroupLayerCreateParam.DefinitionFilter = new CIMDefinitionFilter()
{
Name = "IsActive",
DefinitionExpression = "Enabled = 1"
};
subtypeGroupLayerCreateParam.IsVisible = true;
subtypeGroupLayerCreateParam.MinimumScale = 50000;
#endregion
SubtypeGroupLayer subtypeGroupLayer =
LayerFactory.Instance.CreateLayer <SubtypeGroupLayer>(subtypeGroupLayerCreateParam, map);
#endregion
}
protected async override void OnClick()
{
// get the feature layer that's selected in the table of contents
var selectedLayers = MapView.Active.GetSelectedLayers();
var CADLayer = selectedLayers.OfType <FeatureLayer>().FirstOrDefault() as FeatureLayer;
if (CADLayer == null)
{
System.Windows.MessageBox.Show("Please select the CAD layer in the table of contents", "Layer Grid Scale");
return;
}
double dMetersPerUnit = 1;
string CadFeatClassNameForSelectedLayer = "";
//Run on MCT
bool isValid = await QueuedTask.Run(() =>
{
var CADFeatClass = CADLayer.GetFeatureClass();
var FilePathConnX = CADFeatClass.GetDatastore();
string sCADFilePath = FilePathConnX.GetConnectionString();
sCADFilePath = sCADFilePath.Replace("DATABASE=", "");
var FeatDS = CADFeatClass.GetFeatureDataset();
string CadFileName = System.IO.Path.Combine(sCADFilePath, FeatDS.GetName());
string fileExtension = System.IO.Path.GetExtension(CadFileName);
fileExtension = fileExtension.ToLower();
string sTargetFileName = System.IO.Path.GetFileNameWithoutExtension(CadFileName);
sTargetFile = System.IO.Path.Combine(sCADFilePath, sTargetFileName + ".wld");
//get name for layer
string FCName = CADFeatClass.GetName();
CadFeatClassNameForSelectedLayer = System.IO.Path.Combine(CadFileName, FCName);
FeatureClassDefinition CADFeatClassDef = CADFeatClass.GetDefinition();
var fcSR = CADFeatClassDef.GetSpatialReference();
if (fcSR.IsProjected)
{
dMetersPerUnit = fcSR.Unit.ConversionFactor; //meters per unit
}
bool bIsCAD = (fileExtension == ".dwg" || fileExtension == ".dgn" || fileExtension == ".dxf");
// zoom to the layer
MapView.Active.ZoomTo(CADLayer); //Layer's ZoomTo extent is used to get a good reference point later
return(bIsCAD & !fcSR.IsGeographic); //The addin requires that the CAD data is not in geographic coordinates
});
// if not a valid CAD file
if (!isValid)
{
System.Windows.MessageBox.Show("Please select the CAD layer in the table of contents." + Environment.NewLine +
"CAD data in a geographic coordinate system is not supported.", "Scale CAD Layer");
return;
}
// get the scale from the user
double dScaleFactor = 1.0000;
var sf = new ScaleFactorInput();
sf.Owner = FrameworkApplication.Current.MainWindow;
try
{
if (sf.ShowDialog() == true)
{
string sScaleFactor = sf.ScaleFactor.Text;
if (!Double.TryParse(sScaleFactor, out dScaleFactor))
{
MessageBox.Show("Please type a number", "Grid Scale");
return;
}
}
else
{
// cancelled from dialog
return;
}
}
finally
{
sf = null;
}
//use the layer's ZoomTo extent to get the approximate location of the CAD file for the reference point
var dataReferencePoint = (Coordinate2D)MapView.Active.Extent.Center; //this is sufficient for the reference point
var secondPoint = new Coordinate2D(dataReferencePoint.X + (100 / dMetersPerUnit), dataReferencePoint.Y + (100 / dMetersPerUnit));
var dataReferencePointScaled = new Coordinate2D(dataReferencePoint.X * dScaleFactor, dataReferencePoint.Y * dScaleFactor);
var SecondPointScaled = new Coordinate2D(secondPoint.X * dScaleFactor, secondPoint.Y * dScaleFactor);
if (WriteWorldFile(sTargetFile, dataReferencePoint, secondPoint, dataReferencePointScaled, SecondPointScaled))
{
await QueuedTask.Run(() =>
{
//Remove and then re-add layer
//remove layer
var map = MapView.Active.Map;
map.RemoveLayer(CADLayer.Parent as GroupLayer);
var featureClassUri = new Uri(CadFeatClassNameForSelectedLayer);
//Define the Feature Layer's parameters.
var layerParams = new FeatureLayerCreationParams(featureClassUri)
{
//Set visibility
IsVisible = true,
};
var createdCadLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(layerParams, MapView.Active.Map);
MapView.Active.ZoomTo(CADLayer); //ZoomTo the updated extent
});
}
else
{
MessageBox.Show("The world file could not be created.", "Grid Scale");
return;
}
}
public async void Example4()
{
Map map = MapView.Active.Map;
await QueuedTask.Run(() =>
{
//StreamLayer streamLayer = null;
//
#region Setting a unique value renderer for latest observations
var url = @"https://geoeventsample1.esri.com:6443/arcgis/rest/services/AirportTraffics/StreamServer";
var uri = new Uri(url, UriKind.Absolute);
//Must be on QueuedTask!
var createParams = new FeatureLayerCreationParams(uri)
{
IsVisible = false
};
var 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
classes.Add(
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()
});
classes.Add(
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
#endregion
});
}
protected async override void OnClick()
{
var catalog = Project.GetCatalogPane();
var items = catalog.SelectedItems;
var ProDataSubItems = items.OfType <ProDataSubItem>();
foreach (var item in ProDataSubItems)
{
try
{
await QueuedTask.Run(() =>
{
switch (item.SubItemType)
{
case ProDataSubItem.EnumSubItemType.DirType:
break;
case ProDataSubItem.EnumSubItemType.GpxType:
var conGpx = new PluginDatasourceConnectionPath("ProGpxPluginDatasource",
new Uri(item.Path, UriKind.Absolute));
var groupLayer = LayerFactory.Instance.CreateGroupLayer(MapView.Active.Map, 0, Path.GetFileNameWithoutExtension(item.Path));
ArcGIS.Core.Geometry.Envelope zoomToEnv = null;
using (var pluginGpx = new PluginDatastore(conGpx))
{
System.Diagnostics.Debug.Write($"Table: {item.Path}\r\n");
// because this is a GPX file we have both line and point variations
// we add them in a group layer
foreach (var tn in pluginGpx.GetTableNames())
{
using (var table = pluginGpx.OpenTable(tn))
{
var lyrParams = new FeatureLayerCreationParams((FeatureClass)table);
//Add as a layer to the active map or scene
LayerFactory.Instance.CreateLayer <FeatureLayer>(lyrParams, groupLayer);
zoomToEnv = ((FeatureClass)table).GetExtent().Clone() as ArcGIS.Core.Geometry.Envelope;
}
}
}
if (zoomToEnv != null)
{
MapView.Active.ZoomToAsync(zoomToEnv);
}
break;
case ProDataSubItem.EnumSubItemType.ImgDirType:
case ProDataSubItem.EnumSubItemType.ImgType:
var conJpg = new PluginDatasourceConnectionPath("ProJpgPluginDatasource",
new Uri(item.Path, UriKind.Absolute));
using (var pluginJpg = new PluginDatastore(conJpg))
{
System.Diagnostics.Debug.Write($"Table: {item.Path}\r\n");
//open each table....use the returned table name
//or just pass in the name of a csv file in the workspace folder
foreach (var tn in pluginJpg.GetTableNames())
{
using (var table = pluginJpg.OpenTable(tn))
{
var featureLyrParams = new FeatureLayerCreationParams((FeatureClass)table);
//Add as a layer to the active map or scene
LayerFactory.Instance.CreateLayer <FeatureLayer>(featureLyrParams, MapView.Active.Map);
}
}
}
break;
}
});
}
catch (Exception ex)
{
MessageBox.Show($@"Unable to add to map: {ex.Message}");
}
}
}
