/// <summary>
/// Creates the report
/// </summary>
/// <returns></returns>
private async Task CreateReport()
{
ReportDataSource reportDataSource = null;
Report report = null;
//_isCreateReport = false;
var reportTemplate = await GetReportTemplate(SelectedReportTemplate);
await QueuedTask.Run(() =>
{
//Adding all fields to the report
List <CIMReportField> reportFields = new List <CIMReportField>();
var selectedReportFields = ReportFields.Where((fld) => fld.IsSelected);
foreach (var rfld in selectedReportFields)
{
var cimReportField = new CIMReportField()
{
Name = rfld.Name
};
reportFields.Add(cimReportField);
//Defining grouping field
if (rfld.Name == SelectedGroupField?.Name)
{
cimReportField.Group = true;
}
//To DO: Do sort info here.
}
//Report field statistics
List <ReportFieldStatistic> reportFieldStats = new List <ReportFieldStatistic>();
if (SelectedStatsField != null)
{
ReportFieldStatistic reportStat = new ReportFieldStatistic();
reportStat.Field = SelectedStatsField.Name;
reportStat.Statistic = (FieldStatisticsFlag)Enum.Parse(typeof(FieldStatisticsFlag), SelectedStatsOption);
reportFieldStats.Add(reportStat);
}
//Set Datasource
reportDataSource = new ReportDataSource(SelectedLayer, "", IsUseSelection, reportFields);
try
{
report = ReportFactory.Instance.CreateReport(ReportName, reportDataSource, null, reportFieldStats, reportTemplate, SelectedReportStyle);
//_isCreateReport = true;
}
catch (System.InvalidOperationException e)
{
if (e.Message.Contains("Group field defined for a non-grouping template"))
{
MessageBox.Show("A group field cannot be defined for a non-grouping template.");
}
else if (e.Message.Contains("Grouping template specified but no group field defined"))
{
MessageBox.Show("A group field should be defined for a grouping template.");
}
}
});
//Open the report
IReportPane iNewReportPane = await ProApp.Panes.CreateReportPaneAsync(report); //GUI thread
}
/// <summary>
/// Create keyframes centered around a point.
/// </summary>
/// <param name="point">The center point around which the keyframes are created.</param>
internal Task CreateKeyframesAroundPoint(MapPoint point)
{
return(QueuedTask.Run(() =>
{
var mapView = MapView.Active;
var degrees = Animation.Settings.Degrees;
if (mapView == null || degrees == 0)
{
return;
}
//Get the camera track from the active map's animation.
//There will always be only one camera track in the animation.
var cameraTrack = mapView.Map.Animation.Tracks.OfType <CameraTrack>().First();
var camera = mapView.Camera;
//Calculate the number of keys to create.
var keyEvery = (degrees < 0) ? -10 : 10; //10 degrees
var numOfKeys = Math.Floor(degrees / keyEvery);
var remainder = degrees % keyEvery;
//To maintain a constant speed we need to divide the total time we want the animation to take by the number of degrees of rotation.
var duration = Animation.Settings.Duration;
double timeInterval = duration / Math.Abs(degrees);
double currentTimeSeconds = GetInsertTime(mapView.Map.Animation);
//Get the distance from the current location to the point we want to rotate around to get the radius.
var cameraPoint = MapPointBuilder.CreateMapPoint(camera.X, camera.Y, camera.SpatialReference);
var radius = GeometryEngine.Instance.GeodesicDistance(cameraPoint, point);
var radian = ((camera.Heading - 90) / 180.0) * Math.PI;
//If the spatial reference of the point is projected and the unit is not in meters we need to convert the Z values to meters.
if (!point.SpatialReference.IsGeographic && point.SpatialReference.Unit.ConversionFactor != 1.0)
{
point = MapPointBuilder.CreateMapPoint(point.X, point.Y,
point.Z * point.SpatialReference.Unit.ConversionFactor, point.SpatialReference);
}
//For all geodesic calculations we will use WGS84 so we will project the point if it is not already.
if (point.SpatialReference.Wkid != SpatialReferences.WGS84.Wkid)
{
var transformation = ProjectionTransformation.Create(point.SpatialReference, SpatialReferences.WGS84);
point = GeometryEngine.Instance.ProjectEx(point, transformation) as MapPoint;
}
//Create an ellipse around the center point.
var parameter = new GeodesicEllipseParameter()
{
Center = point.Coordinate2D,
SemiAxis1Length = radius,
SemiAxis2Length = radius,
AxisDirection = radian,
LinearUnit = LinearUnit.Meters,
OutGeometryType = GeometryType.Polyline,
VertexCount = 36
};
var ellipse = GeometryEngine.Instance.GeodesicEllipse(parameter, point.SpatialReference) as Polyline;
//For each key we will progressively rotate around the ellipse and calculate the camera position at each.
for (int i = 0; i <= numOfKeys; i++)
{
var percentAlong = ((Math.Abs(keyEvery) * i) % 360) / 360.0;
if (keyEvery > 0)
{
percentAlong = 1 - percentAlong;
}
//Get the camera at the position around the ellipse.
camera = OffsetCamera(camera, ellipse, point, percentAlong);
//Increment the time by the amount of time per key.
if (i != 0)
{
currentTimeSeconds += (timeInterval * Math.Abs(keyEvery));
}
//Create a new keyframe for the camera.
cameraTrack.CreateKeyframe(camera, TimeSpan.FromSeconds(currentTimeSeconds), AnimationTransition.FixedArc);
}
//For any degree rotation left over create a keyframe. For example 155, would have a keyframe every 10 degrees and then one for the final 5 degrees.
if (remainder != 0.0)
{
var percentAlong = ((Math.Abs(keyEvery) * numOfKeys + Math.Abs(remainder)) % 360) / 360.0;
if (remainder > 0)
{
percentAlong = 1 - percentAlong;
}
OffsetCamera(camera, ellipse, point, percentAlong);
//Increment the time and create the keyframe.
currentTimeSeconds += (timeInterval * Math.Abs(remainder));
cameraTrack.CreateKeyframe(camera, TimeSpan.FromSeconds(currentTimeSeconds), AnimationTransition.FixedArc);
}
}));
}
private async Task <bool> ExecuteVisibilityLLOS()
{
bool success = false;
try
{
// Check surface spatial reference
var surfaceSR = await GetSpatialReferenceFromLayer(SelectedSurfaceName);
if (surfaceSR == null || !surfaceSR.IsProjected)
{
MessageBox.Show(VisibilityLibrary.Properties.Resources.RLOSUserPrompt, VisibilityLibrary.Properties.Resources.RLOSUserPromptCaption);
Application.Current.Dispatcher.Invoke(() =>
{
TargetAddInPoints.Clear();
ObserverAddInPoints.Clear();
ObserverInExtentPoints.Clear();
TargetInExtentPoints.Clear();
ObserverOutExtentPoints.Clear();
TargetOutExtentPoints.Clear();
ClearTempGraphics();
});
await Reset(true);
return(false);
}
var observerPoints = new ObservableCollection <AddInPoint>(LLOS_ObserversInExtent.Select(x => x.AddInPoint).Union(ObserverInExtentPoints));
var targetPoints = new ObservableCollection <AddInPoint>(LLOS_TargetsInExtent.Select(x => x.AddInPoint).Union(TargetInExtentPoints));
// Warn if Image Service layer
Layer surfaceLayer = GetLayerFromMapByName(SelectedSurfaceName);
if (surfaceLayer is ImageServiceLayer)
{
MessageBoxResult mbr = MessageBox.Show(VisibilityLibrary.Properties.Resources.MsgLayerIsImageService,
VisibilityLibrary.Properties.Resources.CaptionLayerIsImageService, MessageBoxButton.YesNo);
if (mbr == MessageBoxResult.No)
{
System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.MsgTryAgain, VisibilityLibrary.Properties.Resources.MsgCalcCancelled);
return(false);
}
}
//Validate Dataframe Spatial reference with surface spatial reference
if (MapView.Active.Map.SpatialReference.Wkid != surfaceSR.Wkid)
{
MessageBox.Show(VisibilityLibrary.Properties.Resources.LOSDataFrameMatch, VisibilityLibrary.Properties.Resources.LOSSpatialReferenceCaption);
return(false);
}
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(CoreModule.CurrentProject.DefaultGeodatabasePath))))
{
executionCounter = 0;
int featureDataSetSuffix = 0;
var enterpriseDefinitionNames = geodatabase.GetDefinitions <FeatureDatasetDefinition>().Where(i => i.GetName().StartsWith(VisibilityLibrary.Properties.Resources.LLOSFeatureDatasetName)).Select(i => i.GetName()).ToList();
foreach (var defName in enterpriseDefinitionNames)
{
int n;
bool isNumeric = int.TryParse(Regex.Match(defName, @"\d+$").Value, out n);
if (isNumeric)
{
featureDataSetSuffix = featureDataSetSuffix < n ? n : featureDataSetSuffix;
}
}
featureDataSetSuffix = enterpriseDefinitionNames.Count > 0 ? featureDataSetSuffix + 1 : 0;
var observerLyrSuffix = GetLayerSuffix(VisibilityLibrary.Properties.Resources.LLOSObserversLayerName, geodatabase);
var targetLyrSuffix = GetLayerSuffix(VisibilityLibrary.Properties.Resources.LLOSTargetsLayerName, geodatabase);
var sightLinesLyrSuffix = GetLayerSuffix(VisibilityLibrary.Properties.Resources.LLOSSightLinesLayerName, geodatabase);
var outputLyrSuffix = GetLayerSuffix(VisibilityLibrary.Properties.Resources.LLOSOutputLayerName, geodatabase);
executionCounter = new List <int> {
featureDataSetSuffix, observerLyrSuffix, targetLyrSuffix, sightLinesLyrSuffix, outputLyrSuffix
}.Max();
}
});
//Create Feature dataset
success = await FeatureClassHelper.CreateFeatureDataset(FeatureDatasetName);
if (!success)
{
return(false);
}
success = await FeatureClassHelper.CreateLayer(FeatureDatasetName, ObserversLayerName, "POINT", true, true);
if (!success)
{
return(false);
}
// add fields for observer offset
await FeatureClassHelper.AddFieldToLayer(ObserversLayerName, VisibilityLibrary.Properties.Resources.OffsetFieldName, "DOUBLE");
await FeatureClassHelper.AddFieldToLayer(ObserversLayerName, VisibilityLibrary.Properties.Resources.OffsetWithZFieldName, "DOUBLE");
await FeatureClassHelper.AddFieldToLayer(ObserversLayerName, VisibilityLibrary.Properties.Resources.TarIsVisFieldName, "SHORT");
success = await FeatureClassHelper.CreateLayer(FeatureDatasetName, TargetsLayerName, "POINT", true, true);
if (!success)
{
return(false);
}
// add fields for target offset
await FeatureClassHelper.AddFieldToLayer(TargetsLayerName, VisibilityLibrary.Properties.Resources.OffsetFieldName, "DOUBLE");
await FeatureClassHelper.AddFieldToLayer(TargetsLayerName, VisibilityLibrary.Properties.Resources.OffsetWithZFieldName, "DOUBLE");
await FeatureClassHelper.AddFieldToLayer(TargetsLayerName, VisibilityLibrary.Properties.Resources.NumOfObserversFieldName, "SHORT");
// add observer points to feature layer
await FeatureClassHelper.CreatingFeatures(ObserversLayerName, observerPoints, GetAsMapZUnits(surfaceSR, ObserverOffset.Value));
// add target points to feature layer
await FeatureClassHelper.CreatingFeatures(TargetsLayerName, targetPoints, GetAsMapZUnits(surfaceSR, TargetOffset.Value));
// update with surface information
success = await FeatureClassHelper.AddSurfaceInformation(ObserversLayerName, SelectedSurfaceName, VisibilityLibrary.Properties.Resources.ZFieldName);
if (!success)
{
return(false);
}
success = await FeatureClassHelper.AddSurfaceInformation(TargetsLayerName, SelectedSurfaceName, VisibilityLibrary.Properties.Resources.ZFieldName);
if (!success)
{
return(false);
}
await FeatureClassHelper.UpdateShapeWithZ(ObserversLayerName, VisibilityLibrary.Properties.Resources.ZFieldName, GetAsMapZUnits(surfaceSR, ObserverOffset.Value));
await FeatureClassHelper.UpdateShapeWithZ(TargetsLayerName, VisibilityLibrary.Properties.Resources.ZFieldName, GetAsMapZUnits(surfaceSR, TargetOffset.Value));
// create sight lines
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
success = await FeatureClassHelper.CreateSightLines(ObserversLayerName,
TargetsLayerName,
CoreModule.CurrentProject.DefaultGeodatabasePath + System.IO.Path.DirectorySeparatorChar + FeatureDatasetName + System.IO.Path.DirectorySeparatorChar + SightLinesLayerName,
VisibilityLibrary.Properties.Resources.OffsetWithZFieldName,
VisibilityLibrary.Properties.Resources.OffsetWithZFieldName);
if (!success)
{
return(false);
}
// LOS
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
success = await FeatureClassHelper.CreateLOS(SelectedSurfaceName,
CoreModule.CurrentProject.DefaultGeodatabasePath + System.IO.Path.DirectorySeparatorChar + FeatureDatasetName + System.IO.Path.DirectorySeparatorChar + SightLinesLayerName,
CoreModule.CurrentProject.DefaultGeodatabasePath + System.IO.Path.DirectorySeparatorChar + FeatureDatasetName + System.IO.Path.DirectorySeparatorChar + OutputLayerName);
if (!success)
{
return(false);
}
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
// join fields with sight lines
await FeatureClassHelper.JoinField(CoreModule.CurrentProject.DefaultGeodatabasePath + System.IO.Path.DirectorySeparatorChar + FeatureDatasetName + System.IO.Path.DirectorySeparatorChar + SightLinesLayerName,
"OID",
CoreModule.CurrentProject.DefaultGeodatabasePath + System.IO.Path.DirectorySeparatorChar + FeatureDatasetName + System.IO.Path.DirectorySeparatorChar + OutputLayerName,
"SourceOID",
new string[] { "TarIsVis" });
// gather results for updating observer and target layers
var sourceOIDs = await FeatureClassHelper.GetSourceOIDs(OutputLayerName);
//if (sourceOIDs.Count > 0)
//{
var visStats = await FeatureClassHelper.GetVisibilityStats(sourceOIDs, SightLinesLayerName);
await FeatureClassHelper.UpdateLayersWithVisibilityStats(visStats, ObserversLayerName, TargetsLayerName);
//}
var observersLayer = GetLayerFromMapByName(ObserversLayerName) as FeatureLayer;
var targetsLayer = GetLayerFromMapByName(TargetsLayerName) as FeatureLayer;
var sightLinesLayer = GetLayerFromMapByName(SightLinesLayerName) as FeatureLayer;
var outputLayer = GetLayerFromMapByName(OutputLayerName) as FeatureLayer;
var observerOutOfExtent = new ObservableCollection <AddInPoint>(LLOS_ObserversOutOfExtent.Select(x => x.AddInPoint).Union(ObserverOutExtentPoints));
// add observer points present out of extent to feature layer
await FeatureClassHelper.CreatingFeatures(ObserversLayerName, observerOutOfExtent, GetAsMapZUnits(surfaceSR, TargetOffset.Value), VisibilityLibrary.Properties.Resources.TarIsVisFieldName);
var targetOutOfExtent = new ObservableCollection <AddInPoint>(LLOS_TargetsOutOfExtent.Select(x => x.AddInPoint).Union(TargetOutExtentPoints));
// add target points present out of extent to feature layer
await FeatureClassHelper.CreatingFeatures(TargetsLayerName, targetOutOfExtent, GetAsMapZUnits(surfaceSR, TargetOffset.Value), VisibilityLibrary.Properties.Resources.NumOfObserversFieldName);
if (observersLayer != null && targetsLayer != null && sightLinesLayer != null && outputLayer != null)
{
await FeatureClassHelper.CreateObserversRenderer(GetLayerFromMapByName(ObserversLayerName) as FeatureLayer);
await FeatureClassHelper.CreateTargetsRenderer(GetLayerFromMapByName(TargetsLayerName) as FeatureLayer);
await FeatureClassHelper.CreateTargetLayerLabels(GetLayerFromMapByName(TargetsLayerName) as FeatureLayer);
await FeatureClassHelper.CreateVisCodeRenderer(GetLayerFromMapByName(SightLinesLayerName) as FeatureLayer,
VisibilityLibrary.Properties.Resources.TarIsVisFieldName,
1,
0,
ColorFactory.Instance.WhiteRGB,
ColorFactory.Instance.BlackRGB,
6.0,
6.0);
await FeatureClassHelper.CreateVisCodeRenderer(GetLayerFromMapByName(OutputLayerName) as FeatureLayer,
VisibilityLibrary.Properties.Resources.VisCodeFieldName,
1,
2,
ColorFactory.Instance.GreenRGB,
ColorFactory.Instance.RedRGB,
5.0,
3.0);
//await Reset(true);
//string groupName = "LLOS Group";
//if (executionCounter > 0)
// groupName = string.Format("{0}_{1}", groupName, executionCounter.ToString());
//await FeatureClassHelper.CreateGroupLayer(layerList, groupName);
// for now we are not resetting after a run of the tool
//await Reset(true);
List <Layer> lyrList = new List <Layer>();
lyrList.Add(observersLayer);
lyrList.Add(targetsLayer);
lyrList.Add(outputLayer);
lyrList.Add(sightLinesLayer);
await FeatureClassHelper.MoveLayersToGroupLayer(lyrList, FeatureDatasetName);
var envelope = await QueuedTask.Run(() => outputLayer.QueryExtent());
await ZoomToExtent(envelope);
var surfaceEnvelope = await GetSurfaceEnvelope();
await DisplayOutOfExtentMsg(surfaceEnvelope);
success = true;
}
else
{
success = false;
}
}
catch (Exception ex)
{
success = false;
Debug.Print(ex.Message);
}
return(success);
}
// Set range for feature layer
// Map Exploration Team Routine
private Task SetRangeProperties(FeatureLayer ftrLyr, string fieldName, bool hasCustomRange = false, double customMin = 0, double customMax = 1, bool inSingleValueMode = false, int rangeStepCount = 0)
{
return(QueuedTask.Run(() =>
{
//Get min/max values for the field
double minValue = 0;
double maxValue = 0;
//Calculate min/max if custom range is not defined
if (!hasCustomRange)
{
int ftrCount = 0;
RowCursor rows = ftrLyr.Search(null);
while (rows.MoveNext())
{
ftrCount++;
}
double[] fieldVals = new double[ftrCount];
rows = ftrLyr.Search(null);
//Looping through to count
int i = 0;
while (rows.MoveNext())
{
object origVal = rows.Current.GetOriginalValue(rows.FindField(fieldName));
if (!(origVal is DBNull))
{
fieldVals[i] = System.Convert.ToDouble(origVal);
}
i++;
}
if (fieldVals.Count() > 0)
{
minValue = fieldVals.Min();
maxValue = fieldVals.Max();
}
}
else
{
minValue = customMin;
maxValue = customMax;
}
CIMBasicFeatureLayer baseLyr = (CIMBasicFeatureLayer)ftrLyr.GetDefinition();
CIMFeatureTable ftrTable = baseLyr.FeatureTable;
//CIMRange theRange = new CIMRange();
CIMRangeDefinition[] rangeDefn = new CIMRangeDefinition[1];
rangeDefn[0] = new CIMRangeDefinition();
rangeDefn[0].FieldName = fieldName;
rangeDefn[0].Name = fieldName;
rangeDefn[0].CustomFullExtent = new CIMRange();
rangeDefn[0].CustomFullExtent.Min = minValue;
rangeDefn[0].CustomFullExtent.Max = maxValue;
//Set current range with either step count == 1 OR for some cases with step count == 0
rangeDefn[0].CurrentRange = new CIMRange();
rangeDefn[0].CurrentRange.Min = minValue;
//rangeDefn[0].CurrentRange.Max = (rangeStepCount == 1) ? minValue + 1 : minValue;
//set range step to 0 if in single value mode and to rangeStepCount otherwise
rangeDefn[0].CurrentRange.Max = (inSingleValueMode) ? minValue : minValue + rangeStepCount;
//rangeDefn[0].CurrentRange.Max = maxValue;
ftrTable.RangeDefinitions = rangeDefn;
ftrTable.ActiveRangeName = fieldName;
baseLyr.FeatureTable = ftrTable;
ftrLyr.SetDefinition(baseLyr);
}));
}
async public static void MethodSnippets()
{
LayoutProjectItem layoutItem = Project.Current.GetItems <LayoutProjectItem>().FirstOrDefault(item => item.Name.Equals("Layout Name"));
Layout layout = await QueuedTask.Run(() => layoutItem.GetLayout());
Element element = layout.FindElement("Group Element");
#region Element_ConvertToGraphics
//Convert a legend to a graphic and move the Title to the bottom of the legend and also move
//the label in the contents pane to the bottom of the list.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
Legend leg = layout.FindElement("Legend") as Legend;
GroupElement result = leg.ConvertToGraphics().First() as GroupElement;
Element firstElm = result.Elements.First(); //Note: Bottom element is first in drawing order.
foreach (Element elm in result.Elements)
{
if (elm.Name == "Title")
{
elm.SetY(firstElm.GetY() - 0.25); //Move title below other legend elements
elm.SetTOCPositionAbsolute(result, false); // Move Title item in TOC to bottom as well
}
}
});
#endregion Element_ConvertToGraphics
#region Element_GetSetAnchor
//Change the element's anchor position
//Perform on the worker thread
await QueuedTask.Run(() =>
{
Anchor elmAnchor = element.GetAnchor();
elmAnchor = Anchor.CenterPoint;
element.SetAnchor(elmAnchor); //You don't have to get to set; a shortcut would be: element.SetAnchor(Anchor.CenterPoint);
});
#endregion Element_GetSetAnchor
#region Element_GetCustomProperty
//Get a custom property that has been previously set.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
String custProp = element.GetCustomProperty("MyKeyString");
});
#endregion Element_GetCustomProperty
#region Element_GetSetDefinition
//Modify an element's CIM properties.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
CIMElement CIMElm = element.GetDefinition();
//Modify a CIM value
element.SetDefinition(CIMElm);
});
#endregion Element_GetSetDefinition
#region Element_GetSetHeight
//Modify an element's hieght.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
double elmHeight = element.GetHeight();
elmHeight = 11;
element.SetHeight(elmHeight); //You don't have to get to set; a shortcut would be: element.SetHieght(11);
});
#endregion Element_GetSetHeight
#region Element_SetLocked
//Modify an element's locked state if it isn't already
//Perform on the worker thread
await QueuedTask.Run(() =>
{
if (!element.IsLocked)
{
element.SetLocked(true);
}
});
#endregion Element_GetSetLocked
#region Element_GetSetLockedAspectRatio
//Modify an element's aspect ratio.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
bool elmLocked = element.GetLockedAspectRatio();
elmLocked = false; //Turn off the locked state.
element.SetLockedAspectRatio(elmLocked); //You don't have to get to set; a shortcut would be: element.SetLockedAspectRatio(false);
});
#endregion Element_GetSetLockedAspectRatio
#region Element_GetSetRotation
//Modify and element's rotation value.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
double elmRot = element.GetRotation();
elmRot = 22.5;
element.SetRotation(elmRot); //You don't have to get to set; a shortcut would be: element.SetRotation(22.5);
});
#endregion Element_GetSetRotation
#region Element_GetSetWidth
//Modify an element's width.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
double elmWidth = element.GetWidth();
elmWidth = 8.5;
element.SetWidth(elmWidth); //You don't have to get to set; a shortcut would be: element.SetWidth(8.5);
});
#endregion Element_GetSetWidth
#region Element_GetSetX
//Modify an element's X position.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
double elmX = element.GetX();
elmX = 4.25;
element.SetX(elmX); //You don't have to get to set; a shortcut would be: element.SetX(4.25);
});
#endregion Element_GetSetX
#region Element_GetSetY
//Modify an element's Y position.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
double elmY = element.GetY();
elmY = 5.5;
element.SetY(elmY); //You don't have to get to set; a shortcut would be: element.SetY(5.5);
});
#endregion Element_GetSetY
#region Element_SetCustomProperty
//Set a custom property on an element.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
element.SetCustomProperty("MyKeyString", "MyValueString");
});
#endregion Element_SetCustomProperty
#region Element_SetName
//Modify an element's name.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
element.SetName("New Name");
});
#endregion Element_SetName
#region Element_SetTOCPositionAbsolute
//Move an element to the top of the TOC
//Perform on the worker thread
await QueuedTask.Run(() =>
{
element.SetTOCPositionAbsolute(layout, true);
});
#endregion Element_SetTOCPositionAbsolute
#region Element_SetTOCPositionRelative
//Move a layout element above an existing layout element.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
element.SetTOCPositionRelative(element, true);
});
#endregion Element_SetTOCPositionRelative
#region Element_SetVisible
//Modify an element's visibility.
//Perform on the worker thread
await QueuedTask.Run(() =>
{
element.SetVisible(true); //Turn it on / make visible.
});
#endregion Element_SetVisible
}
private void QueueTask(QueuedTask task)
{
// Add task to priority queue
lock (taskPriorityQueue)
{
taskPriorityQueue.Enqueue(task);
}
if (task.Scheduler != null && task.Scheduler.Priority < 0)
{
notifyHighPriorityQueuedTaskEvent.Set();
}
else
{
notifyQueuedTaskEvent.Set();
}
// If necessary, create threads
if (threads == null)
{
lock (lockObject)
{
if (threads == null)
{
var waitHandles = new WaitHandle[] { notifyThreadExitEvent, notifyHighPriorityQueuedTaskEvent, notifyQueuedTaskEvent };
var waitHandlesHighPriorityOnly = new WaitHandle[] { notifyThreadExitEvent, notifyHighPriorityQueuedTaskEvent };
threads = new Thread[maximumConcurrencyLevel];
for (int i = 0; i < maximumConcurrencyLevel; i++)
{
int threadIndex = i;
threads[i] = new Thread(() =>
{
while (!threadShouldExit)
{
// TODO: ResetEvent, and exit signal
var t = default(QueuedTask);
lock (taskPriorityQueue)
{
if (!taskPriorityQueue.Empty)
{
t = taskPriorityQueue.Dequeue();
}
}
if (t.Task != null)
{
// High priority task (<0) gets an above normal thread priority
if (t.Scheduler.Priority < 0)
{
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
}
if (t.Scheduler != null)
{
t.Scheduler.TryExecuteTaskInternal(t.Task);
}
else
{
TryExecuteTask(t.Task);
}
if (t.Scheduler.Priority < 0)
{
Thread.CurrentThread.Priority = ThreadPriority.Normal;
}
}
else
{
// If more than one thread, one will be dedicated to high-priority tasks
if (threadIndex == 0 && maximumConcurrencyLevel > 1)
{
WaitHandle.WaitAny(waitHandlesHighPriorityOnly);
}
else
{
WaitHandle.WaitAny(waitHandles);
}
}
}
})
{
Name = string.Format("PriorityScheduler: {0}", i),
Priority = threadPriority,
IsBackground = true,
};
threads[i].Start();
}
}
}
}
}
protected override Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
// execute on the MCT
return(QueuedTask.Run(() =>
{
// find features under the sketch
var features = MapView.Active.GetFeatures(geometry);
if (features.Count == 0)
{
return false;
}
EditOperation op = null;
foreach (var layerKey in features.Keys)
{
// is it an anno layer?
if (!(layerKey is AnnotationLayer))
{
continue;
}
// are there features?
var featOids = features[layerKey];
if (featOids.Count == 0)
{
continue;
}
// use the inspector methodology - load multiple features at once
var insp = new Inspector();
insp.Load(layerKey, featOids);
// make sure tha attribute exists - remember TextString is not guaranteed in the schema
Attribute att = insp.FirstOrDefault(a => a.FieldName.ToUpper() == "TEXTSTRING");
if (att == null)
{
continue;
}
insp["TEXTSTRING"] = "Hello World";
// create the edit operation
if (op == null)
{
op = new EditOperation();
op.Name = "Update annotation text";
op.SelectModifiedFeatures = true;
op.SelectNewFeatures = false;
}
op.Modify(insp);
// OR
// rather than using the inspector you can use the Dictionary methodology - again TextString has to exist in the schema for the attributes to be applied.
//Dictionary<string, object> newAtts = new Dictionary<string, object>();
//newAtts.Add("TEXTSTRING", "Hello World");
//foreach (var oid in featOids)
// op.Modify(layerKey, oid, newAtts);
}
// execute the operation
if ((op != null) && !op.IsEmpty)
{
return op.Execute();
}
return
false;
}));
}
private async Task SetupDefinitionDetailsAsync()
{
DefinitionDetails.Clear();
try
{
var lstDefs = await QueuedTask.Run <List <string> >(() =>
{
Definition datasetDefinition = Dataset.DatasetDefinition;
List <string> lstDefDetails = new List <string>();
if (datasetDefinition is TableDefinition)
{
TableDefinition tableDefinition = datasetDefinition as TableDefinition;
lstDefDetails.Add($"Object ID Field: {tableDefinition.GetObjectIDField()}");
StringBuilder stringBuilder = new StringBuilder();
if (!(_datastore is FileSystemDatastore))
{
lstDefDetails.Add($"Alias Name: {tableDefinition.GetAliasName()}");
lstDefDetails.Add($"CreatedAt Field: {tableDefinition.GetCreatedAtField()}");
lstDefDetails.Add($"Creator Field: {tableDefinition.GetCreatorField()}");
lstDefDetails.Add($"Subtype Field: {tableDefinition.GetSubtypeField()}");
lstDefDetails.Add($"Default Subtype Code: {tableDefinition.GetDefaultSubtypeCode()}");
lstDefDetails.Add($"EditedAt Field: {tableDefinition.GetEditedAtField()}");
lstDefDetails.Add($"Editor Field: {tableDefinition.GetEditorField()}");
lstDefDetails.Add($"Global ID Field: {tableDefinition.GetGlobalIDField()}");
lstDefDetails.Add($"Model Name: {tableDefinition.GetModelName()}");
foreach (var subtype in tableDefinition.GetSubtypes())
{
stringBuilder.Append(subtype.GetCode()).Append(": ").Append(subtype.GetName()).Append(Environment.NewLine);
}
lstDefDetails.Add($"Subtypes: {stringBuilder}");
}
stringBuilder = new StringBuilder();
foreach (Index index in tableDefinition.GetIndexes())
{
stringBuilder.Append(index.GetName()).Append(",");
string order = index.IsAscending() ? "Ascending" : "Descending";
stringBuilder.Append(order).Append(", ");
string unique = index.IsUnique() ? "Unique" : "Not Unique";
stringBuilder.Append(unique);
}
lstDefDetails.Add($"Indexes: {stringBuilder}");
}
if (datasetDefinition is FeatureClassDefinition)
{
FeatureClassDefinition featureClassDefinition = datasetDefinition as FeatureClassDefinition;
if (!(_datastore is FileSystemDatastore))
{
lstDefDetails.Add($"Area Field: {featureClassDefinition.GetAreaField()}");
lstDefDetails.Add($"Length Field: {featureClassDefinition.GetLengthField()}");
}
lstDefDetails.Add($"Shape Field: {featureClassDefinition.GetShapeField()}");
lstDefDetails.Add($"Shape Type: {featureClassDefinition.GetShapeType()}");
lstDefDetails.Add($"Spatial Reference Name: {featureClassDefinition.GetSpatialReference().Name}");
Envelope extent = featureClassDefinition.GetExtent();
lstDefDetails.Add($"Extent Details: XMin-{extent.XMin} XMax-{extent.XMax} YMin-{extent.YMin} YMax-{extent.YMax}");
}
if (datasetDefinition is FeatureDatasetDefinition)
{
FeatureDatasetDefinition featureDatasetDefinition = datasetDefinition as FeatureDatasetDefinition;
lstDefDetails.Add($"Spatial Reference Name: {featureDatasetDefinition.GetSpatialReference().Name}");
try
{
Envelope extent = featureDatasetDefinition.GetExtent();
lstDefDetails.Add($"Extent Details: XMin-{extent.XMin} XMax-{extent.XMax} YMin-{extent.YMin} YMax-{extent.YMax}");
}
catch (Exception)
{
lstDefDetails.Add("Could not get extent");
}
}
if (datasetDefinition is RelationshipClassDefinition)
{
RelationshipClassDefinition relationshipClassDefinition = datasetDefinition as RelationshipClassDefinition;
lstDefDetails.Add($"Alias Name: {relationshipClassDefinition.GetAliasName()}");
lstDefDetails.Add($"Cardinality: {relationshipClassDefinition.GetCardinality()}");
lstDefDetails.Add($"Origin Class: {relationshipClassDefinition.GetOriginClass()}");
lstDefDetails.Add($"Destination Class: {relationshipClassDefinition.GetDestinationClass()}");
lstDefDetails.Add($"Origin Primary Key: {relationshipClassDefinition.GetOriginKeyField()}");
lstDefDetails.Add($"Origin Foreign Key: {relationshipClassDefinition.GetOriginForeignKeyField()}");
lstDefDetails.Add($"Is Attachement?: {relationshipClassDefinition.IsAttachmentRelationship()}");
lstDefDetails.Add($"Is Composite Relationship?: {relationshipClassDefinition.IsComposite()}");
}
if (datasetDefinition is AttributedRelationshipClassDefinition)
{
AttributedRelationshipClassDefinition relationshipClassDefinition = datasetDefinition as AttributedRelationshipClassDefinition;
lstDefDetails.Add($"Destination Key: {relationshipClassDefinition.GetDestinationKeyField()}");
lstDefDetails.Add($"Destination Foreign Key: {relationshipClassDefinition.GetDestinationForeignKeyField()}");
lstDefDetails.Add($"Object ID Field: {relationshipClassDefinition.GetObjectIDField()}");
}
return(lstDefDetails);
});
DefinitionDetails.AddRange(lstDefs);
}
catch (Exception exObj)
{
MessageBox.Show(exObj.Message, "Error");
}
}
protected override async void OnClick()
{
#region Initialization
// set up a set of TextureCoordinates - these determine how the texture is draped over a face
// In this scenario we will use the same textureCoordinates for each face
var textureCoords = new List <Coordinate2D>()
{
new Coordinate2D(4.67909908294678, -2.89953231811523),
new Coordinate2D(-3.7085223197937, -2.89953231811523),
new Coordinate2D(-3.6790623664856, 1.89953279495239),
new Coordinate2D(4.67909908294678, -2.89953231811523),
new Coordinate2D(-3.6790623664856, 1.89953279495239),
new Coordinate2D(4.7085223197937, 1.89953327178955)
};
TextureCompressionType compressionType = TextureCompressionType.CompressionJPEG;
byte[] glassImageBuffer = GetBufferImage("pack://application:,,,/MultipatchBuilder;component/Textures/Glass.jpg", compressionType);
var glassTextureResource = new TextureResource(new JPEGTexture(glassImageBuffer));
byte[] roofImageBuffer = GetBufferImage("pack://application:,,,/MultipatchBuilder;component/Textures/Roof.jpg", compressionType);
var roofTextureResource = new TextureResource(new JPEGTexture(roofImageBuffer));
var materialGray = new BasicMaterial
{
Color = System.Windows.Media.Colors.Gray
};
#endregion
if (MapView.Active?.Map == null)
{
return;
}
// find footprint layer
var footPrintLyr = MapView.Active.Map.GetLayersAsFlattenedList().FirstOrDefault(l => l.Name == "BuildingFootprints") as FeatureLayer;
if (footPrintLyr == null)
{
MessageBox.Show("Can't find layer: BuildingFootprint");
return;
}
var buildingLyr = MapView.Active.Map.GetLayersAsFlattenedList().FirstOrDefault(l => l.Name == "BuildingStructure") as FeatureLayer;
if (buildingLyr == null)
{
MessageBox.Show("Can't find layer: BuildingStructure");
return;
}
// create the multipatch
var mpb = await QueuedTask.Run <MultipatchBuilderEx>(() =>
{
// get all selected lines and use them as the building footprint
var footPrintSelection = footPrintLyr.GetSelection();
Polygon footPrint = null;
int floorLevels = 1;
#region Get Footprint and Floor levels
foreach (var footprintOid in footPrintSelection.GetObjectIDs())
{
// get the multipatch shape using the Inspector
var insp = new Inspector();
insp.Load(footPrintLyr, footprintOid);
footPrint = GeometryEngine.Instance.ReverseOrientation(insp.Shape as Multipart) as Polygon;
floorLevels = (int)insp["Floors"];
}
if (footPrint == null)
{
MessageBox.Show("No selected building footprint found");
return(null);
}
#endregion
// Create the MultipatchBuilder using the building footprints and the floorlevels as height
return(MyMultipatchBuilder.CreateTriangleMultipatchBuilder(footPrint, floorLevels));
});
// apply texture or material
// create a builder to work on the multipatch geometry
switch (Module1.SelectedTexture)
{
case "Glass":
// create the textures for walls and roof
BasicMaterial glassMaterialTexture = new BasicMaterial
{
TextureResource = glassTextureResource
};
BasicMaterial roofMaterialTexture = new BasicMaterial
{
TextureResource = roofTextureResource
};
// apply the texture materials to the patches
var patches = mpb.Patches;
for (var iPatch = 0; iPatch < patches.Count; iPatch++)
{
if (iPatch == patches.Count - 1)
{
// roof
patches[iPatch].Material = roofMaterialTexture;
patches[iPatch].TextureCoords2D = textureCoords;
}
else
{
// walls
patches[iPatch].Material = glassMaterialTexture;
patches[iPatch].TextureCoords2D = textureCoords;
}
}
break;
case "Red-solid":
// create some materials
var materialRed = new BasicMaterial
{
Color = System.Windows.Media.Colors.Brown
};
// apply the materials to the patches
for (var iPatch = 0; iPatch < mpb.Patches.Count; iPatch++)
{
if (iPatch == mpb.Patches.Count - 1)
{
// roof
mpb.Patches[iPatch].Material = materialGray;
}
else
{
// walls
mpb.Patches[iPatch].Material = materialRed;
}
}
break;
case "Gray-solid":
// create some materials
var materialSilver = new BasicMaterial
{
Color = System.Windows.Media.Colors.Silver
};
// apply the materials to the patches
for (var iPatch = 0; iPatch < mpb.Patches.Count; iPatch++)
{
if (iPatch == mpb.Patches.Count - 1)
{
// roof
mpb.Patches[iPatch].Material = materialGray;
}
else
{
// walls
mpb.Patches[iPatch].Material = materialSilver;
}
}
break;
}
// create a new feature using the multipatch
bool result = await QueuedTask.Run(() =>
{
var op = new EditOperation
{
Name = "Create multipatch feature",
SelectNewFeatures = false
};
Module1.NewMultipatch = mpb.ToGeometry() as Multipatch;
var rowToken = op.Create(buildingLyr, Module1.NewMultipatch);
if (op.Execute())
{
// track the newly created objectID
// save the oid in the module for other commands to use
Module1.NewMultipatchOID = rowToken.ObjectID.Value;
return(true);
}
var msg = op.ErrorMessage;
return(false);
});
}
protected override Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
return(QueuedTask.Run(() =>
{
try
{
ActiveMapView.SelectFeatures(geometry, SelectionCombinationMethod.New);
var map = MapView.Active.Map;
var mhLayer = map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault((m => m.Name == "Manholes"));
// Get the currently selected features in the map
var selectedFeatures = map.GetSelection();
var selectCount = mhLayer.SelectionCount;
if (selectCount == 0)
{
MessageBox.Show("No manhole was selected.\n\nTry selecting a manhole again.", "WARNING!");
}
else if (selectCount > 1)
{
MessageBox.Show("More than one manhole selected.\n\nTry selecting manholes again.", "WARNING!");
}
else
{
progDial.Show();
// get the first layer and its corresponding selected feature OIDs
var firstSelectionSet = selectedFeatures.First();
// create an instance of the inspector class
var inspector = new Inspector();
// load the selected features into the inspector using a list of object IDs
inspector.Load(firstSelectionSet.Key, firstSelectionSet.Value);
//get the value of
string mhNum = inspector["MH_NO"].ToString();
// Create the workArcList to store the Arcs(VALUES as int) from the nodeArcListDict
// for the selected mhNum(KEY as string)
List <int> workArcList = new List <int>();
// Output the Arc ObjectID (VALUES) as List<int> for the selected mhNum (KEY)
nodeArcListDict.TryGetValue(mhNum, out List <int> arcValues);
// Loop through Output List<int> and add VALUE to workArcList
foreach (var arcValue in arcValues)
{
workArcList.Add(arcValue);
}
// Create the removeArcsList to store the Arcs(VALUES as int)
List <int> removeArcsList = new List <int>();
// loop through workArcList check if it contains downstream node = mhNum selected by user
foreach (var workArc in workArcList)
{
// Get the list of Values from the arcNodeListDict for the current arc KEY (workArc) in workArcList.
arcNodeListDict.TryGetValue(workArc, out List <string> nodeWorkVals);
//Get the downstream manhole [0] from list.
string downMH = nodeWorkVals[1];
// Check if downstream manhole and selected manhole are the same.
if (downMH == mhNum)
{
// Add to removeArcList
removeArcsList.Add(workArc);
}
}
// Loop through removeArcsList remove each removeArc in list from workArcList (this is getting confusing)
foreach (var removeArc in removeArcsList)
{
// Remove from workArcList
workArcList.Remove(removeArc);
}
if (workArcList.Count() == 0)
{
MessageBox.Show("No downstream sewer lines found.", "WARNING!");
}
// Create dictionary to store downstream arcs that will be used to create query string.
// Only reason dictionary is used is because it's a quick way to prevent duplicate KEYS.
Dictionary <string, string> downStreamArcDict = new Dictionary <string, string>();
//string downStreamNode = "";
List <string> workManholeList = new List <string>();
int loopCount = 0;
// At start of loop, workArcList has >0 arcs from initial selection.
do
{
loopCount++;
workManholeList.Clear();
removeArcsList.Clear();
foreach (var arc in workArcList)
{
if (!downStreamArcDict.ContainsKey(arc.ToString()))
{
// Add arc to downstream arc dictionary
downStreamArcDict.Add(arc.ToString(), "TRUE");
}
}
foreach (var dwnArc in workArcList)
{
arcNodeListDict.TryGetValue(dwnArc, out List <string> nodeWorkVals);
//Get the downstream manhole [1] from list.
string downMH = nodeWorkVals[1];
// Add downstream manhole for selected downstream arc to workManholeList.
// This will be used to get more more downstream arcs later.
workManholeList.Add(downMH);
}
// Clear workArcList to add new arcs later.
workArcList.Clear();
// Get all the arcs connected to all the manholes in the workManholeList using nodeArcListDict dictionary.
// Add these arcs to workArcList.
foreach (var mh in workManholeList)
{
// Get all the arcs attached to manhole/node.
nodeArcListDict.TryGetValue(mh, out List <int> arcVals);
// Add list of arcs to workArcList list.
workArcList.AddRange(arcVals);
}
// Loop through all the arcs in workArcList and for arcs that have downstream manholes in the workManholeList,
// add that arc to removeArcsList.
foreach (var arc2 in workArcList)
{
// get list of nodes for arcs in workArcList.
arcNodeListDict.TryGetValue(arc2, out List <string> nodeWorkVals2);
// Get the downstream manhole [0] from list.
string downMH = nodeWorkVals2[1];
// Check workManholeList for downMH and remove from removeArcList if TRUE.
if (workManholeList.Contains(downMH))
{
removeArcsList.Add(arc2);
}
}
// Remove arcs in removeArcsList from workArcsList
foreach (var arc3 in removeArcsList)
{
workArcList.Remove(arc3);
}
// Loop through again if condition is met.
} while (workArcList.Count > 0);
// Build the query string from the downStreamArcDict KEYS to select the downstream sewer lines.
int count = 0;
var stringBuilder = new StringBuilder();
foreach (var key in downStreamArcDict.Keys)
{
if (count == 0)
{
stringBuilder.Append($"OBJECTID IN ({key}");
}
else if (count < downStreamArcDict.Keys.Count)
{
stringBuilder.Append($",{key}");
}
count++;
}
stringBuilder.Append($")");
// Select sewers using StringBuilder object above for the WhereClause.
QueryFilter queryFilter = new QueryFilter {
WhereClause = stringBuilder.ToString()
};
var sewerLines = map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault(s => s.Name == "Sewer Lines");
var manholes = map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault(s => s.Name == "Manholes");
sewerLines.Select(queryFilter, SelectionCombinationMethod.New);
progDial.Hide();
}
}
catch (Exception)
{
string caption = "WARNING!";
string message = "Downstream trace failed! \n\nSave and restart ArcGIS Pro and try process again.\n\n" +
"If problem persist, contact your local GIS nerd.";
progDial.Hide();
//Using the ArcGIS Pro SDK MessageBox class
MessageBox.Show(message, caption);
}
return true;
}));
}
/// <summary>
/// Divide the first selected feature into equal parts or by map unit distance.
/// </summary>
/// <param name="numberOfParts">Number of parts to create.</param>
/// <param name="value">Value for number or parts or distance.</param>
/// <returns></returns>
private static Task DivideLinesAsync(bool numberOfParts, double value)
{
//Run on MCT
return(QueuedTask.Run(() =>
{
//get selected feature
var selectedFeatures = MapView.Active.Map.GetSelection();
//get the layer of the selected feature
var featLayer = selectedFeatures.Keys.First() as FeatureLayer;
var oid = selectedFeatures.Values.First().First();
var feature = featLayer.Inspect(oid);
//get geometry and length
var origPolyLine = feature.Shape as Polyline;
var origLength = GeometryEngine.Instance.Length(origPolyLine);
string xml = origPolyLine.ToXML();
//List of mappoint geometries for the split
var splitPoints = new List <MapPoint>();
var enteredValue = (numberOfParts) ? origLength / value : value;
var splitAtDistance = 0 + enteredValue;
while (splitAtDistance < origLength)
{
//create a mapPoint at splitDistance and add to splitpoint list
MapPoint pt = null;
try
{
pt = GeometryEngine.Instance.MovePointAlongLine(origPolyLine, splitAtDistance, false, 0, SegmentExtension.NoExtension);
}
catch (GeometryObjectException)
{
// line is an arc?
}
if (pt != null)
{
splitPoints.Add(pt);
}
splitAtDistance += enteredValue;
}
if (splitPoints.Count == 0)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Divide lines was unable to process your selected line. Please select another.", "Divide Lines");
return;
}
//create and execute the edit operation
var op = new EditOperation()
{
Name = "Divide Lines",
SelectModifiedFeatures = false,
SelectNewFeatures = false
};
op.Split(featLayer, oid, splitPoints);
op.Execute();
//clear selection
featLayer.ClearSelection();
}));
}
public static async void AddLayer(string targets, string name)
{
try
{
using (HttpClientHandler handler = new HttpClientHandler())
{
handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
using (HttpClient client = new HttpClient(handler))
{
client.BaseAddress = new Uri("https://api.planet.com");
//HttpClientHandler handler = new HttpClientHandler()
//{
// AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
//};
//HttpClient client = new HttpClient(handler)
//{
// BaseAddress = new Uri("https://api.planet.com")
//};
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "data/v1/layers");
//request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded"));
request.Headers.Host = "tiles2.planet.com";
request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
var nvc = new List <KeyValuePair <string, string> >();
//nvc.Add(new KeyValuePair<string, string>("ids", "PSScene4Band:20190603_205042_1042,PSScene4Band:20190528_205949_43_1061,PSScene4Band:20190818_205116_1009"));
nvc.Add(new KeyValuePair <string, string>("ids", targets));
//var content = new StringContent(json, Encoding.UTF8, "application/json");
var content = new FormUrlEncodedContent(nvc);
request.Content = content;
var byteArray = Encoding.ASCII.GetBytes(Module1.Current.API_KEY.API_KEY_Value + ":hgvhgv");
client.DefaultRequestHeaders.Host = "api.planet.com";
//_client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded"));
content.Headers.Remove("Content-Type");
content.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
client.DefaultRequestHeaders.Add("Connection", "keep-alive");
client.DefaultRequestHeaders.Add("User-Agent", "ArcGISProC#");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
using (HttpResponseMessage httpResponse = client.SendAsync(request).Result)
{
using (HttpContent content2 = httpResponse.Content)
{
var json2 = content2.ReadAsStringAsync().Result;
customwmts customwmts = JsonConvert.DeserializeObject <customwmts>(json2);
customwmts.wmtsURL = new Uri("https://tiles.planet.com/data/v1/layers/wmts/" + customwmts.name + "?api_key=" + Module1.Current.API_KEY.API_KEY_Value);
//Geometry geometry2 = GeometryEngine.Instance.ImportFromJSON(JSONImportFlags.jsonImportDefaults, JsonConvert.SerializeObject( quickSearchResult.features[5].geometry));
var serverConnection = new CIMProjectServerConnection {
URL = customwmts.wmtsURL.ToString()
};
var connection = new CIMWMTSServiceConnection {
ServerConnection = serverConnection
};
await QueuedTask.Run(() =>
{
Layer group = MapView.Active.Map.FindLayer(Asset.RootGroup);
GroupLayer groupLayer = null;
if (group != null)
{
groupLayer = group as GroupLayer;
}
else
{
int index = Asset.FindRootIndex();
groupLayer = LayerFactory.Instance.CreateGroupLayer(MapView.Active.Map, index, Asset.RootGroup);
}
BasicRasterLayer layer2 = LayerFactory.Instance.CreateRasterLayer(connection, groupLayer, 0, name);
});
}
}
}
}
}
catch (Exception e)
{
MessageBox.Show("Error adding to Map", "Add to Map");
}
}
/// <summary>
/// Renders a polygon feature layer with Dot Density symbols to represent quantities.
/// 
/// </summary>
/// <remarks></remarks>
/// <returns></returns>
internal static Task DotDensityRendererAsync()
{
//Check feature layer name
//Code works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data
var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault(f => f.Name == "USDemographics");
if (featureLayer == null)
{
MessageBox.Show("This renderer works with the USDemographics feature layer available with the ArcGIS Pro SDK Sample data", "Data missing");
return(Task.FromResult(0));
}
return(QueuedTask.Run(() =>
{
//Define size of the dot to use for the renderer
int dotSize = 3;
//Check if the TOTPOP10 field exists
int idxField = -1;
using (var table = featureLayer.GetTable())
{
var def = table.GetDefinition();
idxField = def.FindField("TOTPOP10");
}
// "TOTPOP10" field was not found
if (idxField == -1)
{
return;
}
//array of fields to be represented in the renderer
var valueFields = new List <string> {
"TOTPOP10"
};
//Create the DotDensityRendererDefinition object
var dotDensityDef = new DotDensityRendererDefinition(valueFields, SDKHelpers.GetColorRamp(),
dotSize, 30000, "Dot", "people");
//Create the renderer using the DotDensityRendererDefinition
CIMDotDensityRenderer dotDensityRndr = (CIMDotDensityRenderer)featureLayer.CreateRenderer(dotDensityDef);
//if you want to customize the dot symbol for the renderer, create a "DotDensitySymbol" which is an
//Amalgamation of 3 symbol layers: CIMVectorMarker, CIMSolidFill and CIMSolidStroke
//Define CIMVectorMarker layer
var cimMarker = SymbolFactory.Instance.ConstructMarker(ColorFactory.Instance.RedRGB, dotSize);
var dotDensityMarker = cimMarker as CIMVectorMarker;
//Definte the placement
CIMMarkerPlacementInsidePolygon markerPlacement = new CIMMarkerPlacementInsidePolygon {
Randomness = 100, GridType = PlacementGridType.RandomFixedQuantity, Clipping = PlacementClip.RemoveIfCenterOutsideBoundary
};
dotDensityMarker.MarkerPlacement = markerPlacement;
//Define CIMSolidFill layer
CIMSolidFill solidFill = new CIMSolidFill {
Color = new CIMRGBColor {
R = 249, G = 232, B = 189, Alpha = 50
}
};
//Define CIMSolidStroke
CIMSolidStroke solidStroke = new CIMSolidStroke {
Color = ColorFactory.Instance.GreyRGB, Width = .5
};
//Create the amalgamated CIMPolygonSymbol that includes the 3 layers
var dotDensitySymbol = new CIMPolygonSymbol
{
SymbolLayers = new CIMSymbolLayer[] { dotDensityMarker, solidFill, solidStroke }
};
//Apply the dotDensitySymbol to the CIMDotDenstityRenderer's DotDensitySymbol property.
dotDensityRndr.DotDensitySymbol = dotDensitySymbol.MakeSymbolReference();
//Apply the renderer to the polygon Feature Layer.
featureLayer.SetRenderer(dotDensityRndr);
}));
}
//
// Posts the @contents to the @url. The post is done in a queue
// system that is flushed regularly, so it is safe to call Post to
// fire and forget
//
public void Post(string url, string content)
{
var qtask = new QueuedTask () {
AccountId = LocalAccountId,
Url = url,
PostData = content,
};
lock (Database.Main)
Database.Main.Insert (qtask);
FlushTasks ();
}
/// <summary>
/// This method makes sure
/// 1. The Mapview is Active
/// 2. There is at least one Layer selected
/// 3. The selected Layer is a FeatureLayer
/// 4. The selected Layer is backed by an Enterprise Sql Server Geodatabase FeatureClass
///
/// If all of these hold good, the DatabaseClient is used to execute a query which creates
/// a Database Table containing the gdb_items records corresponding to all domains. The Table is
/// then opened using the API and the domains combobox populated. Finally, the Table is deleted
/// </summary>
/// <param name="mapViewEventArgs"></param>
private async void UpdateDomainList(MapViewEventArgs mapViewEventArgs)
{
if (MapView.Active == null ||
mapViewEventArgs.MapView.GetSelectedLayers().Count < 1 ||
!(mapViewEventArgs.MapView.GetSelectedLayers()[0] is FeatureLayer))
{
Enabled = false;
return;
}
EnterpriseDatabaseType enterpriseDatabaseType = EnterpriseDatabaseType.Unknown;
await QueuedTask.Run(() =>
{
using (Table table = (mapViewEventArgs.MapView.GetSelectedLayers()[0] as FeatureLayer).GetTable())
{
if (!(table.GetDatastore() is Geodatabase))
{
return;
}
try
{
var gdb = table.GetDatastore() as Geodatabase;
var gdbConnector = gdb.GetConnector() as DatabaseConnectionProperties;
enterpriseDatabaseType = gdbConnector != null ? gdbConnector.DBMS : EnterpriseDatabaseType.Unknown;
}
catch
{
System.Diagnostics.Debug.WriteLine("Exception was thrown!");
}
}
});
if (enterpriseDatabaseType != EnterpriseDatabaseType.SQLServer)
{
Enabled = false;
return;
}
Enabled = true;
Clear();
await QueuedTask.Run(() =>
{
using (Table table = (mapViewEventArgs.MapView.GetSelectedLayers()[0] as FeatureLayer).GetTable())
{
var geodatabase = table.GetDatastore() as Geodatabase;
Version defaultVersion = geodatabase.GetVersionManager().GetVersions().FirstOrDefault(version =>
{
string name = version.GetName();
return(name.ToLowerInvariant().Equals("dbo.default") || name.ToLowerInvariant().Equals("sde.default"));
});
if (defaultVersion == null)
{
return;
}
string tableName = String.Format("NewTable{0}{1}{2}{3}", DateTime.Now.Hour, DateTime.Now.Minute,
DateTime.Now.Second, DateTime.Now.Millisecond);
gdbItemsOwner = defaultVersion.GetName().Split('.')[0];
string statement =
String.Format(
@"select {1}.GDB_ITEMTYPES.Name as Type, {1}.GDB_ITEMS.Name into {0} from {1}.GDB_ITEMS JOIN {1}.GDB_ITEMTYPES ON {1}.GDB_ITEMS.Type = {1}.GDB_ITEMTYPES.UUID where {1}.GDB_ITEMTYPES.Name = 'Domain' OR {1}.GDB_ITEMTYPES.Name = 'Coded Value Domain' OR {1}.GDB_ITEMTYPES.Name = 'Range Domain'",
tableName, gdbItemsOwner);
try
{
DatabaseClient.ExecuteStatement(geodatabase, statement);
}
catch (GeodatabaseTableException exception)
{
MessageBox.Show(exception.Message);
return;
}
var newTable = geodatabase.OpenDataset <Table>(tableName);
using (RowCursor rowCursor = newTable.Search(null, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
Add(new ComboBoxItem(row["Name"].ToString()));
}
}
}
statement = String.Format(@"DROP TABLE {0}", tableName);
DatabaseClient.ExecuteStatement(geodatabase, statement);
}
});
}
/// <summary>
/// Called when the sketch finishes. This is where we will create the sketch operation and then execute it.
/// </summary>
/// <param name="geometry">The geometry created by the sketch.</param>
/// <returns>A Task returning a Boolean indicating if the sketch complete event was successfully handled.</returns>
protected override async Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
if (geometry == null)
{
return(false);
}
// Create an edit operation
var createOperation = new EditOperation()
{
Name = "Create Transformer Bank",
SelectNewFeatures = true
};
bool success = false;
string errorMessage = "";
await QueuedTask.Run(() =>
{
Map map = GetMap();
using (UtilityNetwork utilityNetwork = GetUtilityNetwork())
{
if (utilityNetwork == null)
{
errorMessage = "Please select a layer that participates in a utility network.";
}
else
{
if (!ValidateDataModel(utilityNetwork))
{
errorMessage = "This sample is designed for a different utility network data model";
}
else
{
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
// Get the NetworkSource, FeatureClass, AssetGroup, and AssetTypes for all of the features we want to create
// The existence of these values has already been confirmed in the ValidateDataModel() routine
// TransformerBank
using (NetworkSource transformerBankNetworkSource = GetNetworkSource(utilityNetworkDefinition, AssemblyNetworkSourceName))
using (FeatureClass transformerBankFeatureClass = utilityNetwork.GetTable(transformerBankNetworkSource) as FeatureClass)
using (AssetGroup transformerBankAssetGroup = transformerBankNetworkSource.GetAssetGroup(TransformerBankAssetGroupName))
using (AssetType transformerBankAssetType = transformerBankAssetGroup.GetAssetType(TransformerBankAssetTypeName))
// Transformer
using (NetworkSource deviceNetworkSource = GetNetworkSource(utilityNetworkDefinition, DeviceNetworkSourceName))
using (FeatureClass deviceFeatureClass = utilityNetwork.GetTable(deviceNetworkSource) as FeatureClass)
using (AssetGroup transformerAssetGroup = deviceNetworkSource.GetAssetGroup(TransformerAssetGroupName))
using (AssetType transformerAssetType = transformerAssetGroup.GetAssetType(TransformerAssetTypeName))
// Arrester
using (AssetGroup arresterAssetGroup = deviceNetworkSource.GetAssetGroup(ArresterAssetGroupName))
using (AssetType arresterAssetType = arresterAssetGroup.GetAssetType(ArresterAssetTypeName))
// Fuse
using (AssetGroup fuseAssetGroup = deviceNetworkSource.GetAssetGroup(FuseAssetGroupName))
using (AssetType fuseAssetType = fuseAssetGroup.GetAssetType(FuseAssetTypeName))
{
MapPoint clickPoint = geometry as MapPoint;
// Create a transformer bank
RowToken token = createOperation.Create(transformerBankFeatureClass, CreateAttributes(transformerBankAssetGroup, transformerBankAssetType, clickPoint));
RowHandle transformerBankHandle = new RowHandle(token);
// Create three transformers, one for each phase
MapPoint transformerPointA = CreateOffsetMapPoint(clickPoint, -1 * XOffset, YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(transformerAssetGroup, transformerAssetType, transformerPointA, APhase));
RowHandle transformerHandleA = new RowHandle(token);
MapPoint transformerPointB = CreateOffsetMapPoint(clickPoint, 0, YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(transformerAssetGroup, transformerAssetType, transformerPointB, BPhase));
RowHandle transformerHandleB = new RowHandle(token);
MapPoint transformerPointC = CreateOffsetMapPoint(clickPoint, XOffset, YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(transformerAssetGroup, transformerAssetType, transformerPointC, CPhase));
RowHandle transformerHandleC = new RowHandle(token);
// Create containment associations between the bank and the transformers
AssociationDescription containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, transformerHandleA, false);
createOperation.Create(containmentAssociationDescription);
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, transformerHandleB, false);
createOperation.Create(containmentAssociationDescription);
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, transformerHandleC, false);
createOperation.Create(containmentAssociationDescription);
// Find the high-side terminal for transformers
TerminalConfiguration transformerTerminalConfiguration = transformerAssetType.GetTerminalConfiguration();
IReadOnlyList <Terminal> terminals = transformerTerminalConfiguration.Terminals;
Terminal highSideTerminal = terminals.First(x => x.IsUpstreamTerminal == true);
long highSideTerminalID = highSideTerminal.ID;
// Create three fuses, one for each phase
MapPoint fusePointA = CreateOffsetMapPoint(clickPoint, -1 * XOffset, 2 * YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(fuseAssetGroup, fuseAssetType, fusePointA, APhase));
RowHandle fuseHandleA = new RowHandle(token);
MapPoint fusePointB = CreateOffsetMapPoint(clickPoint, 0, 2 * YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(fuseAssetGroup, fuseAssetType, fusePointB, BPhase));
RowHandle fuseHandleB = new RowHandle(token);
MapPoint fusePointC = CreateOffsetMapPoint(clickPoint, XOffset, 2 * YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(fuseAssetGroup, fuseAssetType, fusePointC, CPhase));
RowHandle fuseHandleC = new RowHandle(token);
// Create containment associations between the bank and the fuses
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, fuseHandleA, false);
createOperation.Create(containmentAssociationDescription);
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, fuseHandleB, false);
createOperation.Create(containmentAssociationDescription);
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, fuseHandleC, false);
createOperation.Create(containmentAssociationDescription);
// Connect the high-side transformer terminals to the fuses (connect the A-phase transformer to the A-phase fuse, and so on)
AssociationDescription connectivityAssociationDescription = new AssociationDescription(AssociationType.JunctionJunctionConnectivity, transformerHandleA, highSideTerminalID, fuseHandleA);
createOperation.Create(connectivityAssociationDescription);
connectivityAssociationDescription = new AssociationDescription(AssociationType.JunctionJunctionConnectivity, transformerHandleB, highSideTerminalID, fuseHandleB);
createOperation.Create(connectivityAssociationDescription);
connectivityAssociationDescription = new AssociationDescription(AssociationType.JunctionJunctionConnectivity, transformerHandleC, highSideTerminalID, fuseHandleC);
createOperation.Create(connectivityAssociationDescription);
// Create three arresters, one for each phase
MapPoint arresterPointA = CreateOffsetMapPoint(clickPoint, -1 * XOffset, 3 * YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(arresterAssetGroup, arresterAssetType, arresterPointA, APhase));
RowHandle arresterHandleA = new RowHandle(token);
MapPoint arresterPointB = CreateOffsetMapPoint(clickPoint, 0, 3 * YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(arresterAssetGroup, arresterAssetType, arresterPointB, BPhase));
RowHandle arresterHandleB = new RowHandle(token);
MapPoint arresterPointC = CreateOffsetMapPoint(clickPoint, XOffset, 3 * YOffset);
token = createOperation.Create(deviceFeatureClass, CreateDeviceAttributes(arresterAssetGroup, arresterAssetType, arresterPointC, CPhase));
RowHandle arresterHandleC = new RowHandle(token);
// Create containment associations between the bank and the arresters
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, arresterHandleA, false);
createOperation.Create(containmentAssociationDescription);
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, arresterHandleB, false);
createOperation.Create(containmentAssociationDescription);
containmentAssociationDescription = new AssociationDescription(AssociationType.Containment, transformerBankHandle, arresterHandleC, false);
createOperation.Create(containmentAssociationDescription);
// Create connectivity associations between the fuses and the arresters (connect the A-phase fuse the A-phase arrester, and so on)
connectivityAssociationDescription = new AssociationDescription(AssociationType.JunctionJunctionConnectivity, fuseHandleA, arresterHandleA);
createOperation.Create(connectivityAssociationDescription);
connectivityAssociationDescription = new AssociationDescription(AssociationType.JunctionJunctionConnectivity, fuseHandleB, arresterHandleB);
createOperation.Create(connectivityAssociationDescription);
connectivityAssociationDescription = new AssociationDescription(AssociationType.JunctionJunctionConnectivity, fuseHandleC, arresterHandleC);
createOperation.Create(connectivityAssociationDescription);
// Execute the edit operation, which creates all of the rows and associations
success = createOperation.Execute();
if (!success)
{
errorMessage = createOperation.ErrorMessage;
}
}
}
}
}
});
if (!success)
{
MessageBox.Show(errorMessage, "Create Transformer Bank Tool");
}
return(success);
}
/// <summary>
/// In order to illustrate that Geodatabase calls have to be made on the MCT
/// </summary>
/// <returns></returns>
public async Task FeatureClassValidateAsync()
{
await QueuedTask.Run(() => MainMethodCode());
}
async public static void CreateElementSnippets()
{
//There are already many Create element snippets in the PRO snippets section. This section will only contain examples that are NOT in the Pro snippets section
//Pro snippets region names includes:
// Create point graphic with symbology
// Create line graphic with symbology
// Create rectangle graphic with simple symbology
// Create text element with basic font properties
// Create rectangle text with more advanced symbol settings
// Create a new picture element with advanced symbol settings
// Create a map frame and zoom to a bookmark
// Create a legend for a specific map frame
// Creating group elements
LayoutView lytView = LayoutView.Active;
Layout layout = lytView.Layout;
#region Create_BezierCurve
//Create a beizier curve element with a simple line style.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D pt1 = new Coordinate2D(1, 7.5);
Coordinate2D pt2 = new Coordinate2D(1.66, 8);
Coordinate2D pt3 = new Coordinate2D(2.33, 7.1);
Coordinate2D pt4 = new Coordinate2D(3, 7.5);
CubicBezierBuilder bez = new CubicBezierBuilder(pt1, pt2, pt3, pt4);
CubicBezierSegment bezSeg = bez.ToSegment();
Polyline bezPl = PolylineBuilder.CreatePolyline(bezSeg);
//Set symbology, create and add element to layout
CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.RedRGB, 4.0, SimpleLineStyle.DashDot);
GraphicElement bezElm = LayoutElementFactory.Instance.CreateLineGraphicElement(layout, bezPl, lineSym);
bezElm.SetName("New Bezier Curve");
});
#endregion Create_BezierCurve
#region Create_freehand
//Create a graphic freehand element with a simple line style.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plCoords = new List <Coordinate2D>();
plCoords.Add(new Coordinate2D(1.5, 10.5));
plCoords.Add(new Coordinate2D(1.25, 9.5));
plCoords.Add(new Coordinate2D(1, 10.5));
plCoords.Add(new Coordinate2D(0.75, 9.5));
plCoords.Add(new Coordinate2D(0.5, 10.5));
plCoords.Add(new Coordinate2D(0.5, 1));
plCoords.Add(new Coordinate2D(0.75, 2));
plCoords.Add(new Coordinate2D(1, 1));
Polyline linePl = PolylineBuilder.CreatePolyline(plCoords);
//Set symbolology, create and add element to layout
CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid);
GraphicElement lineElm = LayoutElementFactory.Instance.CreateLineGraphicElement(layout, linePl, lineSym);
lineElm.SetName("New Freehand");
});
#endregion Create_freehand
#region Create_polygon_poly
//Create a polygon graphic with simple line and fill styles.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(1, 7));
plyCoords.Add(new Coordinate2D(2, 7));
plyCoords.Add(new Coordinate2D(2, 6.7));
plyCoords.Add(new Coordinate2D(3, 6.7));
plyCoords.Add(new Coordinate2D(3, 6.1));
plyCoords.Add(new Coordinate2D(1, 6.1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.DashDotDot);
CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
GraphicElement polyElm = LayoutElementFactory.Instance.CreatePolygonGraphicElement(layout, poly, polySym);
polyElm.SetName("New Polygon");
});
#endregion Create_polygon_poly
#region Create_polygon_env
//Create a polygon graphic using an envelope with simple line and fill styles.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build 2D envelope
Coordinate2D env_ll = new Coordinate2D(1.0, 4.75);
Coordinate2D env_ur = new Coordinate2D(3.0, 5.75);
Envelope env = EnvelopeBuilder.CreateEnvelope(env_ll, env_ur);
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.DashDotDot);
CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
GraphicElement polyElm = LayoutElementFactory.Instance.CreatePolygonGraphicElement(layout, env, polySym);
polyElm.SetName("New Polygon");
});
#endregion Create_polygon_env
#region Create_circle
//Create a circle graphic element using a simple line and fill styles.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(2, 4);
EllipticArcBuilder eabCir = new EllipticArcBuilder(center, 0.5, esriArcOrientation.esriArcClockwise);
EllipticArcSegment cir = eabCir.ToSegment();
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Dash);
CIMPolygonSymbol circleSym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, outline);
GraphicElement cirElm = LayoutElementFactory.Instance.CreateCircleGraphicElement(layout, cir, circleSym);
cirElm.SetName("New Circle");
});
#endregion
#region Create_ellipse
//Create an ellipse graphic with simple line and fill styles.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(2, 2.75);
EllipticArcBuilder eabElp = new EllipticArcBuilder(center, 0, 1, 0.45, esriArcOrientation.esriArcClockwise);
EllipticArcSegment ellipse = eabElp.ToSegment();
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.GreenRGB, 2.0, SimpleLineStyle.Dot);
CIMPolygonSymbol ellipseSym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.GreyRGB, SimpleFillStyle.Vertical, outline);
GraphicElement elpElm = LayoutElementFactory.Instance.CreateEllipseGraphicElement(layout, ellipse, ellipseSym);
elpElm.SetName("New Ellipse");
});
#endregion
#region Create_lasso
//Create a graphic lasso element with simple line and fill styles.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(1, 1));
plyCoords.Add(new Coordinate2D(1.25, 2));
plyCoords.Add(new Coordinate2D(1.5, 1.1));
plyCoords.Add(new Coordinate2D(1.75, 2));
plyCoords.Add(new Coordinate2D(2, 1.1));
plyCoords.Add(new Coordinate2D(2.25, 2));
plyCoords.Add(new Coordinate2D(2.5, 1.1));
plyCoords.Add(new Coordinate2D(2.75, 2));
plyCoords.Add(new Coordinate2D(3, 1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid);
CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
GraphicElement polyElm = LayoutElementFactory.Instance.CreatePolygonGraphicElement(layout, poly, polySym);
polyElm.SetName("New Lasso");
});
#endregion Create_lasso
#region Create_CurveText
//Create curve text with basic text properties.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D pt1 = new Coordinate2D(3.6, 7.5);
Coordinate2D pt2 = new Coordinate2D(4.26, 8);
Coordinate2D pt3 = new Coordinate2D(4.93, 7.1);
Coordinate2D pt4 = new Coordinate2D(5.6, 7.5);
CubicBezierBuilder bez = new CubicBezierBuilder(pt1, pt2, pt3, pt4);
CubicBezierSegment bezSeg = bez.ToSegment();
Polyline bezPl = PolylineBuilder.CreatePolyline(bezSeg);
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlackRGB, 24, "Comic Sans MS", "Regular");
GraphicElement bezTxtElm = LayoutElementFactory.Instance.CreateCurvedTextGraphicElement(layout, bezPl, "Curved Text", sym);
bezTxtElm.SetName("New Splinned Text");
});
#endregion Create_CurveText
#region Create_PolygonText
//Create polygon paragraph text with basic text properties.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
List <Coordinate2D> plyCoords = new List <Coordinate2D>();
plyCoords.Add(new Coordinate2D(3.5, 7));
plyCoords.Add(new Coordinate2D(4.5, 7));
plyCoords.Add(new Coordinate2D(4.5, 6.7));
plyCoords.Add(new Coordinate2D(5.5, 6.7));
plyCoords.Add(new Coordinate2D(5.5, 6.1));
plyCoords.Add(new Coordinate2D(3.5, 6.1));
Polygon poly = PolygonBuilder.CreatePolygon(plyCoords);
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.GreyRGB, 10, "Arial", "Regular");
string text = "Some Text String that is really long and is <BOL>forced to wrap to other lines</BOL> so that we can see the effects." as String;
GraphicElement polyTxtElm = LayoutElementFactory.Instance.CreatePolygonParagraphGraphicElement(layout, poly, text, sym);
polyTxtElm.SetName("New Polygon Text");
//(Optionally) Modify paragraph border
CIMGraphic polyTxtGra = polyTxtElm.GetGraphic();
CIMParagraphTextGraphic cimPolyTxtGra = polyTxtGra as CIMParagraphTextGraphic;
cimPolyTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimPolyTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
polyTxtElm.SetGraphic(polyTxtGra);
});
#endregion Create_PolygonText
#region Create_CircleText
//Create circle paragraph text with basic text settings and optionally a modified border.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(4.5, 4);
EllipticArcBuilder eabCir = new EllipticArcBuilder(center, 0.5, esriArcOrientation.esriArcClockwise);
EllipticArcSegment cir = eabCir.ToSegment();
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.GreenRGB, 10, "Arial", "Regular");
string text = "Circle, circle, circle, circle, circle, circle, circle, circle, circle, circle, circle";
GraphicElement cirTxtElm = LayoutElementFactory.Instance.CreateCircleParagraphGraphicElement(layout, cir, text, sym);
cirTxtElm.SetName("New Circle Text");
//(Optionally) Modify paragraph border
CIMGraphic cirTxtGra = cirTxtElm.GetGraphic();
CIMParagraphTextGraphic cimCirTxtGra = cirTxtGra as CIMParagraphTextGraphic;
cimCirTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimCirTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
cirTxtElm.SetGraphic(cirTxtGra);
});
#endregion
#region Create_EllipseText
//Create ellipse paragraph text with basic text settings and optionally a modified border.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D center = new Coordinate2D(4.5, 2.75);
EllipticArcBuilder eabElp = new EllipticArcBuilder(center, 0, 1, 0.45, esriArcOrientation.esriArcClockwise);
EllipticArcSegment ellipse = eabElp.ToSegment();
//Set symbolology, create and add element to layout
CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlueRGB, 10, "Arial", "Regular");
string text = "Ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse, ellipse";
GraphicElement elpTxtElm = LayoutElementFactory.Instance.CreateEllipseParagraphGraphicElement(layout, ellipse, text, sym);
elpTxtElm.SetName("New Ellipse Text");
//(Optionally) Modify paragraph border
CIMGraphic elpTxtGra = elpTxtElm.GetGraphic();
CIMParagraphTextGraphic cimElpTxtGra = elpTxtGra as CIMParagraphTextGraphic;
cimElpTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
cimElpTxtGra.Frame.BorderSymbol.Symbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
elpTxtElm.SetGraphic(elpTxtGra);
});
#endregion Create_EllipseText
MapFrame mfElm = null;
#region Create_MapFrame
//Creates a new map frame and changes the camera's scale.
//Constuct on the worker thread
await QueuedTask.Run(() =>
{
//Build geometry
Coordinate2D ll = new Coordinate2D(6.0, 8.5);
Coordinate2D ur = new Coordinate2D(8.0, 10.5);
Envelope env = EnvelopeBuilder.CreateEnvelope(ll, ur);
//Reference map, create MF and add to layout
MapProjectItem mapPrjItem = Project.Current.GetItems <MapProjectItem>().FirstOrDefault(item => item.Name.Equals("Map"));
Map mfMap = mapPrjItem.GetMap();
mfElm = LayoutElementFactory.Instance.CreateMapFrame(layout, env, mfMap);
mfElm.SetName("New Map Frame");
//Set the camera
Camera camera = mfElm.Camera;
camera.Scale = 24000;
mfElm.SetCamera(camera);
});
#endregion Create_MapFrame
#region Create_ScaleBar
//Create a scale bar for a specific map frame and assign a scale bar style item.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Reference a North Arrow in a style
StyleProjectItem stylePrjItm = Project.Current.GetItems <StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars("Double Alternating Scale Bar 1")[0];
//Build geometry
Coordinate2D center = new Coordinate2D(7, 8);
//Reference MF, create north arrow and add to layout
MapFrame mf = layout.FindElement("New Map Frame") as MapFrame;
if (mf == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Map frame not found", "WARNING");
return;
}
ScaleBar sbElm = LayoutElementFactory.Instance.CreateScaleBar(layout, center, mf, sbStyleItm);
sbElm.SetName("New Scale Bar");
sbElm.SetWidth(2);
sbElm.SetX(6);
sbElm.SetY(7.5);
});
#endregion Create_ScaleBar
#region Create_NorthArrow
//Create a north arrow for a specific map frame and assign a north arrow style item.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
//Reference a North Arrow in a style
StyleProjectItem stylePrjItm = Project.Current.GetItems <StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
NorthArrowStyleItem naStyleItm = stylePrjItm.SearchNorthArrows("ArcGIS North 10")[0];
//Build geometry
Coordinate2D center = new Coordinate2D(7, 5.5);
//Reference MF, create north arrow and add to layout
MapFrame mf = layout.FindElement("New Map Frame") as MapFrame;
if (mf == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Map frame not found", "WARNING");
return;
}
NorthArrow arrowElm = LayoutElementFactory.Instance.CreateNorthArrow(layout, center, mf, naStyleItm);
arrowElm.SetName("New North Arrow");
arrowElm.SetHeight(1.75);
arrowElm.SetX(7);
arrowElm.SetY(6);
});
#endregion Create_NorthArrow
#region Create_Empty_Group_Root
//Create an empty group element at the root level of the contents pane.
//Construct on the worker thread
await QueuedTask.Run(() =>
{
GroupElement emptyGroupAtRoot = LayoutElementFactory.Instance.CreateGroupElement(layout);
emptyGroupAtRoot.SetName("Empty group at root");
});
#endregion
#region Create_Empty_Group_Group
//Create an empty group element at the root level of another group element.
//Find an existing group element
GroupElement existingGroupAtRoot = layout.FindElement("Empty group at root") as GroupElement;
//Construct on the worker thread
await QueuedTask.Run(() =>
{
GroupElement emptyGroupInGroupAtRoot = LayoutElementFactory.Instance.CreateGroupElement(existingGroupAtRoot);
emptyGroupInGroupAtRoot.SetName("Empty group in group at root");
});
#endregion
#region Create_Group_With_Single_Element_Root
//Create a group with a single element at the root level of the contents pane.
//Find an existing element
Element titleElm = layout.FindElement("Title") as Element;
//Construct on the worker thread
await QueuedTask.Run(() =>
{
GroupElement groupWithSingleElementAtRoot = LayoutElementFactory.Instance.CreateGroupElement(layout, titleElm);
groupWithSingleElementAtRoot.SetName("Group with single element at root");
});
#endregion
#region Create_Group_With_List_Elements_Root
//Create a group with a list of elements at the root level of the contents pane.
//Find an existing elements
Element scaleBar = layout.FindElement("Scale Bar") as Element;
Element northArrow = layout.FindElement("North Arrow") as Element;
Element legend = layout.FindElement("Legend") as Element;
//Build a list and add the elements
List <Element> elmList = new List <Element>
{
scaleBar,
northArrow,
legend
};
//Construct on the worker thread
await QueuedTask.Run(() =>
{
GroupElement groupWithListOfElementsAtRoot = LayoutElementFactory.Instance.CreateGroupElement(layout, elmList);
groupWithListOfElementsAtRoot.SetName("Group with list of elements at root");
});
#endregion
#region Create_Group_With_List_Element_Names_Root
//Create a group using a list of element names at the root level of the contents pane.
//Build list of element names
var elmNameList = new[] { "Table Frame", "Chart Frame" };
//Construct on the worker thread
await QueuedTask.Run(() =>
{
GroupElement groupWithListOfElementNamesAtRoot = LayoutElementFactory.Instance.CreateGroupElement(layout, elmNameList);
groupWithListOfElementNamesAtRoot.SetName("Group with list of element names at root");
});
#endregion
}
public static async Task CreateKeyframes()
{
FeatureLayer ftrLayer = null;
MapView mapView = MapView.Active;
if (mapView == null)
{
return;
}
var mapSelection = await QueuedTask.Run(() => MapView.Active.Map.GetSelection());
if (mapSelection.Count == 1)
{
var layer = mapSelection.First().Key;
if (layer is FeatureLayer)
{
ftrLayer = (FeatureLayer)layer;
if (ftrLayer.ShapeType != ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolyline)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select a polyline feature.");
return;
}
int numFtrsSelected = await QueuedTask.Run(() => ftrLayer.GetSelection().GetCount());
if (numFtrsSelected != 1)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select only one polyline feature.");
return;
}
}
else
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select a polyline feature.");
return;
}
}
else
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Select a polyline feature.");
return;
}
if (SelectedCameraView == "Face target" && TargetPoint == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Selected view type is - Face target - but a target point is not set.");
return;
}
string oid_fieldName = await QueuedTask.Run(() => ftrLayer.GetTable().GetDefinition().GetObjectIDField());
//get selected polyline
Polyline lineGeom = await QueuedTask.Run <Polyline>(() =>
{
var selectedFtrOID = MapView.Active.Map.GetSelection()[ftrLayer][0];
QueryFilter qf = new QueryFilter();
qf.WhereClause = oid_fieldName + " = " + selectedFtrOID.ToString();
RowCursor result = ftrLayer.GetFeatureClass().Search(qf);
if (result != null)
{
result.MoveNext();
Feature selectedFtr = result.Current as Feature;
return(selectedFtr.GetShape() as Polyline);
}
return(null);
});
//couldn't get the selected feature
if (lineGeom == null)
{
return;
}
ProjectionTransformation transformation = await QueuedTask.Run(() => ProjectionTransformation.Create(ftrLayer.GetSpatialReference(), mapView.Map.SpatialReference));
SpatialReference layerSpatRef = await QueuedTask.Run(() => ftrLayer.GetSpatialReference());
if (layerSpatRef.Unit.Name != "Degree")
{
Z_CONVERSION_FACTOR = layerSpatRef.Unit.ConversionFactor;
}
//Project target point if method is Face target
if (SelectedCameraView == "Face target")
{
if (TargetPoint != null && TargetPoint.SpatialReference != layerSpatRef)
{
ProjectionTransformation transf_forTarget = await QueuedTask.Run(() => ProjectionTransformation.Create(TargetPoint.SpatialReference, layerSpatRef));
MapPoint projected_targetPoint = (MapPoint)GeometryEngine.Instance.ProjectEx(TargetPoint, transf_forTarget);
TargetPoint = null;
TargetPoint = projected_targetPoint;
}
}
var animation = mapView.Map.Animation;
var cameraTrack = animation.Tracks.OfType <CameraTrack>().First();
var keyframes = cameraTrack.Keyframes;
//Get segment list for line
ReadOnlyPartCollection polylineParts = lineGeom.Parts;
//get total segment count and determine path length
double pathLength = 0;
int segmentCount = 0;
IEnumerator <ReadOnlySegmentCollection> segments = polylineParts.GetEnumerator();
while (segments.MoveNext())
{
ReadOnlySegmentCollection seg = segments.Current;
foreach (Segment s in seg)
{
//pathLength += s.Length;//s.Length returns 2D length
double length3D = Math.Sqrt((s.EndPoint.X - s.StartPoint.X) * (s.EndPoint.X - s.StartPoint.X) +
(s.EndPoint.Y - s.StartPoint.Y) * (s.EndPoint.Y - s.StartPoint.Y) +
(s.EndPoint.Z - s.StartPoint.Z) * (s.EndPoint.Z - s.StartPoint.Z));
pathLength += length3D;
segmentCount += 1;
}
}
//reset heading and pitch
_keyframeHeading = 0;
_keyframePitch = 0;
// Create keyframes based on chosen method
if (SelectedMethod == "Keyframes along path")
{
await CreateKeyframes_AlongPath(mapView, layerSpatRef, transformation, cameraTrack, segments, segmentCount, pathLength);
}
else if (SelectedMethod == "Keyframes every N seconds")
{
await CreateKeyframes_EveryNSeconds(mapView, layerSpatRef, transformation, cameraTrack, segments, segmentCount, pathLength, KeyEveryNSecond);
}
else if (SelectedMethod == "Keyframes only at vertices")
{
await CreateKeyframes_AtVertices(mapView, layerSpatRef, transformation, cameraTrack, lineGeom, segments, segmentCount, pathLength);
}
}
public async Task <string> LoadData(string[] splitter, string[] fieldTypes, string csvFilePath)
{
await QueuedTask.Run(() =>
{
string lineOfTxtFile = "";
FileStream fs = new FileStream(csvFilePath, FileMode.Open);
StreamReader sr = new StreamReader(fs);
lineOfTxtFile = sr.ReadLine(); // skip the title line
lineOfTxtFile = sr.ReadLine();
using (Geodatabase projectWorkspace = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(Project.Current.DefaultGeodatabasePath))))
using (Table table = projectWorkspace.OpenDataset <Table>("TestTable"))
using (RowBuffer rowBuffer = table.CreateRowBuffer())
{
while (lineOfTxtFile != null)
{
string[] dataItems = lineOfTxtFile.Split(splitter, StringSplitOptions.None);
for (int i = 0; i < dataItems.Length; i++)
{
switch (fieldTypes[i])
{
case "Text":
rowBuffer[i + 1] = dataItems[i].Trim();
break;
case "Short":
if (dataItems[i].Length > 0)
{
if (dataItems[i].Contains("."))
{
rowBuffer[i + 1] = Int16.Parse(dataItems[i].Substring(0, dataItems[i].IndexOf('.')));
}
else
{
rowBuffer[i + 1] = Int16.Parse(dataItems[i]);
}
}
else
{
rowBuffer[i + 1] = null;
}
break;
case "Long":
if (dataItems[i].Length > 0)
{
if (dataItems[i].Contains("."))
{
rowBuffer[i + 1] = int.Parse(dataItems[i].Substring(0, dataItems[i].IndexOf('.')));
}
else
{
rowBuffer[i + 1] = int.Parse(dataItems[i]);
}
}
else
{
rowBuffer[i + 1] = null;
}
break;
case "Date":
if (dataItems[i].Length > 0)
{
rowBuffer[i + 1] = DateTime.Parse(dataItems[i]);
}
else
{
rowBuffer[i + 1] = null;
}
break;
case "Double":
if (dataItems[i].Length > 0)
{
rowBuffer[i + 1] = double.Parse(dataItems[i]);
}
else
{
rowBuffer[i + 1] = null;
}
break;
default:
break;
}
}
table.CreateRow(rowBuffer);
lineOfTxtFile = sr.ReadLine();
}
rowBuffer.Dispose();
}
});
return("ok");
}
//Use this method for smoother turns at corners. Additionally this method processes straight line segments and arc segments separately
//For arc segments a keyframe is created at every second. However a minimum of 5 keyframes are created for arcs.
//So if arc segment length is less than 5 then we default to at least 5 keyframes. This is an attempt to stick to the path as much as possible.
//For straight line segments, rotation is ignored at end point of each segment except for the end point of the path itself. Two keyframes with rotation
//are created at certain distance (determined by LINE_CONSTRAINT_FACTOR) before and after the end point of each segment. This is an attempt to avoid
//sharp turns at corners along the path.
public static async Task CreateKeyframes_AlongPath(MapView mapView, SpatialReference layerSpatRef, ProjectionTransformation transformation,
CameraTrack cameraTrack, IEnumerator <ReadOnlySegmentCollection> segments,
int segmentCount, double pathLength)
{
double segmentLength = 0;
int num_iterations = 0;
segments.Reset();
//process each segment depending upon its type - straight line or arc
while (segments.MoveNext())
{
ReadOnlySegmentCollection seg = segments.Current;
double accumulatedDuration = mapView.Map.Animation.Duration.TotalSeconds + ((mapView.Map.Animation.Duration.TotalSeconds > 0) ? ANIMATION_APPEND_TIME : 0); // 0;
foreach (Segment s in seg)
{
double length3D = Math.Sqrt((s.EndPoint.X - s.StartPoint.X) * (s.EndPoint.X - s.StartPoint.X) +
(s.EndPoint.Y - s.StartPoint.Y) * (s.EndPoint.Y - s.StartPoint.Y) +
(s.EndPoint.Z - s.StartPoint.Z) * (s.EndPoint.Z - s.StartPoint.Z));
double segmentDuration = (TotalDuration / pathLength) * length3D;
segmentLength = length3D;
//straight line segments
if (s.SegmentType == SegmentType.Line)
{
MapPoint startPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.StartPoint.X, s.StartPoint.Y, s.StartPoint.Z *Z_CONVERSION_FACTOR, layerSpatRef));
MapPoint endPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.EndPoint.X, s.EndPoint.Y, s.EndPoint.Z *Z_CONVERSION_FACTOR, layerSpatRef));
//we will be creating three intermediate keyframes for staright segments only if segment length is more than a set threshold
//the threshold is just a guess and might have to be altered depending upon the path geometry. Should work for most cases though
MapPoint firstIntPoint = null;
MapPoint midIntPoint = null;
MapPoint lastIntPoint = null;
if (segmentLength >= STRAIGHT_SEGMENT_LENGTH_THRESHOLD)
{
//first intermediate point
firstIntPoint = await CreatePointAlongSegment(startPt, endPt, LINE_CONSTRAINT_FACTOR *segmentLength, layerSpatRef);
//mid point
midIntPoint = await CreatePointAlongSegment(startPt, endPt, 0.5 *segmentLength, layerSpatRef);
//last intermediate point
lastIntPoint = await CreatePointAlongSegment(startPt, endPt, (1 - LINE_CONSTRAINT_FACTOR) *segmentLength, layerSpatRef);
}
//create keyframe at start vertex of path in map space
double timeSpanValue = accumulatedDuration;
TimeSpan keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
if (segmentLength >= STRAIGHT_SEGMENT_LENGTH_THRESHOLD)
{
SetPitchAndHeadingForLine(startPt, firstIntPoint);
}
else
{
SetPitchAndHeadingForLine(startPt, endPt);
}
//ignore rotation for all start vertices (which would also be end vertices of previous segments) EXCEPT for the first vertex of path
if (num_iterations == 0 || segmentLength < STRAIGHT_SEGMENT_LENGTH_THRESHOLD)
{
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
else
{
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading, true, false);
}
if (segmentLength > STRAIGHT_SEGMENT_LENGTH_THRESHOLD)
{
//Create a keyframe at PATH_CONSTRAINT_FACTOR distance along the segment from start point
double distanceAlong = LINE_CONSTRAINT_FACTOR * segmentLength;
timeSpanValue = accumulatedDuration + LINE_CONSTRAINT_FACTOR * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(firstIntPoint, midIntPoint);
await CreateCameraKeyframe(mapView, firstIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at middle of segment
distanceAlong = 0.5 * segmentLength;
timeSpanValue = accumulatedDuration + 0.5 * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(midIntPoint, lastIntPoint);
//await CreateCameraKeyframe(mapView, midIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at (1 - PATH_CONSTRAINT_FACTOR) distance along the segment from start point
distanceAlong = (1 - LINE_CONSTRAINT_FACTOR) * segmentLength;
timeSpanValue = accumulatedDuration + (1 - LINE_CONSTRAINT_FACTOR) * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(lastIntPoint, endPt);
await CreateCameraKeyframe(mapView, lastIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
//Create a keyframe at end point of segment only for the end point of last segment
//Otherwise we will get duplicate keyframes at end of one segment and start of the next one
if (num_iterations == segmentCount - 1)
{
timeSpanValue = accumulatedDuration + segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
if (SelectedCameraView == "Face target")
{
SetPitchAndHeadingForLine(endPt, TargetPoint);
}
await CreateCameraKeyframe(mapView, endPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
}
//processing for arcs - create a keyframe every second for arcs
//we will create a minimum of 5 keyframes along the arc
else if (s.SegmentType == SegmentType.EllipticArc && segmentDuration > 5)
{
EllipticArcSegment ellipArc = s as EllipticArcSegment;
MapPoint startPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.StartPoint.X, s.StartPoint.Y, s.StartPoint.Z, layerSpatRef));
MapPoint endPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.EndPoint.X, s.EndPoint.Y, s.EndPoint.Z, layerSpatRef));
double radius = Math.Sqrt((ellipArc.CenterPoint.X - startPt.X) * (ellipArc.CenterPoint.X - startPt.X) + (ellipArc.CenterPoint.Y - startPt.Y) * (ellipArc.CenterPoint.Y - startPt.Y));
double angle = ellipArc.CentralAngle;
MapPoint centerPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(ellipArc.CenterPoint.X, ellipArc.CenterPoint.Y, (s.StartPoint.Z + s.EndPoint.Z) / 2, layerSpatRef));
int num_keys = (int)segmentDuration;
MapPoint firstIntPoint = null;
//first intermediate keyframe for arc - needed for setting heading for start vertex
// >2 to account for start and end
if (num_keys > 2)
{
firstIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, angle / (num_keys - 1), radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
}
//Create keyframe at start vertex of path in map space
double timeSpanValue = accumulatedDuration;
TimeSpan keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
if (firstIntPoint != null)
{
SetPitchAndHeadingForLine(startPt, firstIntPoint);
}
else
{
SetPitchAndHeadingForLine(startPt, endPt);
}
//Ignore rotation for all start vertices EXCEPT for the first vertex of path
if (num_iterations == 0)
{
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
else
{
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading, true, false);
}
//Loop to create intermediate keyframes at each second
for (int i = 0; i < num_keys - 2; i++)
{
MapPoint currentIntPoint = null;
MapPoint nextIntPoint = null;
currentIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, (angle / (num_keys - 1)) *(i + 1), radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
if (i < num_keys - 3)
{
nextIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, (angle / (num_keys - 1)) *(i + 2), radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
}
else //for the last intermediate keyframe, heading/pitch has to be determined relative to the end point fo segment
{
nextIntPoint = endPt;
}
//timeSpanValue = accumulatedDuration + (i + 1) * 1; //at each second
timeSpanValue = accumulatedDuration + (i + 1) * (segmentDuration / (num_keys - 1));
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(currentIntPoint, nextIntPoint);
await CreateCameraKeyframe(mapView, currentIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
//Create a keyframe at end point of segment only for the end point of last segment
if (num_iterations == segmentCount - 1)
{
timeSpanValue = accumulatedDuration + segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
if (SelectedCameraView == "Face target")
{
SetPitchAndHeadingForLine(endPt, TargetPoint);
}
await CreateCameraKeyframe(mapView, endPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
}
//create a minimum of 5 keyframes along the arc
else if (s.SegmentType == SegmentType.EllipticArc)
{
EllipticArcSegment ellipArc = s as EllipticArcSegment;
MapPoint startPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.StartPoint.X, s.StartPoint.Y, s.StartPoint.Z, layerSpatRef));
MapPoint endPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.EndPoint.X, s.EndPoint.Y, s.EndPoint.Z, layerSpatRef));
double radius = Math.Sqrt((ellipArc.CenterPoint.X - startPt.X) * (ellipArc.CenterPoint.X - startPt.X) + (ellipArc.CenterPoint.Y - startPt.Y) * (ellipArc.CenterPoint.Y - startPt.Y));
double angle = ellipArc.CentralAngle;
MapPoint centerPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(ellipArc.CenterPoint.X, ellipArc.CenterPoint.Y, (s.StartPoint.Z + s.EndPoint.Z) / 2, layerSpatRef));
//we are creating five intermediate keyframes for arcs
MapPoint firstIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, angle *ARC_CONSTRAINT_FACTOR, radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
MapPoint secondIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, angle *ARC_CONSTRAINT_FACTOR * 2, radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
MapPoint midIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, angle * 0.5, radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
MapPoint secondLastIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, angle *(1 - ARC_CONSTRAINT_FACTOR * 2), radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
MapPoint lastIntPoint = await CreatePointAlongArc(startPt, endPt, centerPt, angle *(1 - ARC_CONSTRAINT_FACTOR), radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
//Create keyframe at start vertex of path in map space
double timeSpanValue = accumulatedDuration;
TimeSpan keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(startPt, firstIntPoint);
//Ignore rotation for all start vertices EXCEPT for the first vertex of path
if (num_iterations == 0)
{
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
else
{
await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading, true, false);
}
//await CreateCameraKeyframe(mapView, startPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at PATH_CONSTRAINT_FACTOR distance along the segment from start point
timeSpanValue = accumulatedDuration + ARC_CONSTRAINT_FACTOR * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(firstIntPoint, secondIntPoint);
await CreateCameraKeyframe(mapView, firstIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at 2* PATH_CONSTRAINT_FACTOR distance along the segment from start point
timeSpanValue = accumulatedDuration + ARC_CONSTRAINT_FACTOR * 2 * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(secondIntPoint, midIntPoint);
await CreateCameraKeyframe(mapView, secondIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at middle of segment
timeSpanValue = accumulatedDuration + 0.5 * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(midIntPoint, secondLastIntPoint);
await CreateCameraKeyframe(mapView, midIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at (1 - PATH_CONSTRAINT_FACTOR * 2) distance along the segment from start point
timeSpanValue = accumulatedDuration + (1 - ARC_CONSTRAINT_FACTOR * 2) * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(secondLastIntPoint, lastIntPoint);
await CreateCameraKeyframe(mapView, secondLastIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at (1 - PATH_CONSTRAINT_FACTOR) distance along the segment from start point
timeSpanValue = accumulatedDuration + (1 - ARC_CONSTRAINT_FACTOR) * segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(lastIntPoint, endPt);
await CreateCameraKeyframe(mapView, lastIntPoint, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
//Create a keyframe at end point of segment only for the end point of last segment
if (num_iterations == segmentCount - 1)
{
timeSpanValue = accumulatedDuration + segmentDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
if (SelectedCameraView == "Face target")
{
SetPitchAndHeadingForLine(endPt, TargetPoint);
}
await CreateCameraKeyframe(mapView, endPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
}
accumulatedDuration += segmentDuration;
num_iterations++;
}
}
}
public async void Examples()
{
#region Get symbol from SymbolStyleItem
SymbolStyleItem symbolItem = null;
CIMSymbol symbol = await QueuedTask.Run <CIMSymbol>(() =>
{
return(symbolItem.Symbol);
});
#endregion
#region Get color from ColorStyleItem
ColorStyleItem colorItem = null;
CIMColor color = await QueuedTask.Run <CIMColor>(() =>
{
return(colorItem.Color);
});
#endregion
#region Get color ramp from ColorRampStyleItem
ColorRampStyleItem colorRampItem = null;
CIMColorRamp colorRamp = await QueuedTask.Run <CIMColorRamp>(() =>
{
return(colorRampItem.ColorRamp);
});
#endregion
#region Get north arrow from NorthArrowStyleItem
NorthArrowStyleItem northArrowItem = null;
CIMNorthArrow northArrow = await QueuedTask.Run <CIMNorthArrow>(() =>
{
return(northArrowItem.NorthArrow);
});
#endregion
#region Get scale bar from ScaleBarStyleItem
ScaleBarStyleItem scaleBarItem = null;
CIMScaleBar scaleBar = await QueuedTask.Run <CIMScaleBar>(() =>
{
return(scaleBarItem.ScaleBar);
});
#endregion
#region Get label placement from LabelPlacementStyleItem
LabelPlacementStyleItem labelPlacementItem = null;
CIMLabelPlacementProperties labelPlacement = await QueuedTask.Run <CIMLabelPlacementProperties>(() =>
{
return(labelPlacementItem.LabelPlacement);
});
#endregion
#region Get grid from GridStyleItem
GridStyleItem gridItem = null;
CIMMapGrid grid = await QueuedTask.Run <CIMMapGrid>(() =>
{
return(gridItem.Grid);
});
#endregion
#region Get legend from LegendStyleItem
LegendStyleItem legendItem = null;
CIMLegend legend = await QueuedTask.Run <CIMLegend>(() =>
{
return(legendItem.Legend);
});
#endregion
#region Get table frame from TableFrameStyleItem
TableFrameStyleItem tableFrameItem = null;
CIMTableFrame tableFrame = await QueuedTask.Run <CIMTableFrame>(() =>
{
return(tableFrameItem.TableFrame);
});
#endregion
#region Get map surround from MapSurroundStyleItem
MapSurroundStyleItem mapSurroundItem = null;
CIMMapSurround mapSurround = await QueuedTask.Run <CIMMapSurround>(() =>
{
return(mapSurroundItem.MapSurround);
});
#endregion
#region Get dimension style from DimensionStyleStyleItem
DimensionStyleStyleItem dimensionStyleStyleItem = null;
CIMDimensionStyle dimensionStyle = await QueuedTask.Run <CIMDimensionStyle>(() =>
{
return(dimensionStyleStyleItem.DimensionStyle);
});
#endregion
}
//Use this method to create a keyframe at every n-second of the specified animation duration
public static async Task CreateKeyframes_EveryNSeconds(MapView mapView, SpatialReference layerSpatRef, ProjectionTransformation transformation,
CameraTrack cameraTrack, IEnumerator <ReadOnlySegmentCollection> segments,
int segmentCount, double pathLength, double keyEveryNSecond = 1)
{
double segmentLength = 0;
int numKeysToCreate = (int)(TotalDuration / keyEveryNSecond); //approximately
double createKeyAtDist = pathLength / numKeysToCreate;
double skippedDistance = 0;
double accumulatedDuration = mapView.Map.Animation.Duration.TotalSeconds + ((mapView.Map.Animation.Duration.TotalSeconds > 0) ? ANIMATION_APPEND_TIME : 0); // 0;
int num_iterations = 0;
segments.Reset();
List <MapPoint> pointsForKeyframes = new List <MapPoint>();
MapPoint pathEndPt = null;
//process each segment depending upon its type - straight line or arc
while (segments.MoveNext())
{
ReadOnlySegmentCollection seg = segments.Current;
foreach (Segment s in seg)
{
segmentLength = Math.Sqrt((s.EndPoint.X - s.StartPoint.X) * (s.EndPoint.X - s.StartPoint.X) +
(s.EndPoint.Y - s.StartPoint.Y) * (s.EndPoint.Y - s.StartPoint.Y) +
(s.EndPoint.Z - s.StartPoint.Z) * (s.EndPoint.Z - s.StartPoint.Z));
double segmentDuration = (TotalDuration / pathLength) * segmentLength;
//straight line segments
if (s.SegmentType == SegmentType.Line)
{
MapPoint startPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.StartPoint.X, s.StartPoint.Y, s.StartPoint.Z, layerSpatRef));
MapPoint endPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.EndPoint.X, s.EndPoint.Y, s.EndPoint.Z, layerSpatRef));
//add start of path to points collection
if (num_iterations == 0)
{
pointsForKeyframes.Add(startPt);
}
if (num_iterations == segmentCount - 1 || segmentCount == 1)
{
pathEndPt = endPt; //store path end pt. This will be the last keyframe.
}
double distCoveredAlongSeg = Math.Abs(createKeyAtDist - skippedDistance); //we are accouunting for skipped distances from previous segments
if (distCoveredAlongSeg < segmentLength)
{
MapPoint keyPt = await CreatePointAlongSegment(startPt, endPt, distCoveredAlongSeg, layerSpatRef);
//add point to collection
pointsForKeyframes.Add(keyPt);
//skipped distance is used now, reset to zero
skippedDistance = 0;
//are more keyframes possible for this segment
bool moreKeysPossible = ((segmentLength - distCoveredAlongSeg) >= createKeyAtDist);
while (moreKeysPossible)
{
double keyAtDistAlongSeg = distCoveredAlongSeg + createKeyAtDist;
keyPt = await CreatePointAlongSegment(startPt, endPt, keyAtDistAlongSeg, layerSpatRef);
//add point to collection
pointsForKeyframes.Add(keyPt);
distCoveredAlongSeg += createKeyAtDist;
moreKeysPossible = ((segmentLength - distCoveredAlongSeg) > createKeyAtDist);
}
//if any segment length left then add to skipped distance
skippedDistance += (segmentLength - distCoveredAlongSeg);
}
else
{
//add this segment's length to skipped distance as no keyframe could be created along it
skippedDistance += segmentLength;
}
}
else if (s.SegmentType == SegmentType.EllipticArc)
{
EllipticArcSegment ellipArc = s as EllipticArcSegment;
MapPoint startPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.StartPoint.X, s.StartPoint.Y, s.StartPoint.Z, layerSpatRef));
MapPoint endPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(s.EndPoint.X, s.EndPoint.Y, s.EndPoint.Z, layerSpatRef));
double radius = Math.Sqrt((ellipArc.CenterPoint.X - startPt.X) * (ellipArc.CenterPoint.X - startPt.X) + (ellipArc.CenterPoint.Y - startPt.Y) * (ellipArc.CenterPoint.Y - startPt.Y));
double angle = ellipArc.CentralAngle;
MapPoint centerPt = await QueuedTask.Run(() => MapPointBuilder.CreateMapPoint(ellipArc.CenterPoint.X, ellipArc.CenterPoint.Y, (s.StartPoint.Z + s.EndPoint.Z) / 2, layerSpatRef));
//add start of path to points collection
if (num_iterations == 0)
{
pointsForKeyframes.Add(startPt);
}
if (num_iterations == segmentCount - 1 || segmentCount == 1)
{
pathEndPt = endPt; //store path end pt. This will be the last keyframe.
}
double distCoveredAlongSeg = Math.Abs(createKeyAtDist - skippedDistance); //we are accouunting for skipped distances from previous segments
if (distCoveredAlongSeg < segmentLength)
{
MapPoint keyPt = await CreatePointAlongArc(startPt, endPt, centerPt, angle *distCoveredAlongSeg / segmentLength, radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
//add point to collection
pointsForKeyframes.Add(keyPt);
//skipped distance is used now, reset to zero
skippedDistance = 0;
//are more keyframes possible for this segment
bool moreKeysPossible = ((segmentLength - distCoveredAlongSeg) >= createKeyAtDist);
while (moreKeysPossible)
{
double keyAtDistAlongSeg = distCoveredAlongSeg + createKeyAtDist;
keyPt = await CreatePointAlongArc(startPt, endPt, centerPt, angle *keyAtDistAlongSeg / segmentLength, radius, layerSpatRef, ellipArc.IsMinor, ellipArc.IsCounterClockwise);
//add point to collection
pointsForKeyframes.Add(keyPt);
distCoveredAlongSeg += createKeyAtDist;
moreKeysPossible = ((segmentLength - distCoveredAlongSeg) > createKeyAtDist);
}
//if any segment length left then add to skipped distance
skippedDistance += (segmentLength - distCoveredAlongSeg);
}
else
{
//add this segment's length to skipped distance as no keyframe could be created along it
skippedDistance += segmentLength;
}
}
num_iterations++;
}
}
//now iterate over the points list and create keyframes
double timeSpanValue = accumulatedDuration;
TimeSpan keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
for (int i = 0; i < pointsForKeyframes.Count; i++)
{
MapPoint currentPt = pointsForKeyframes[i];
MapPoint nextPt = null;
if (i + 1 < pointsForKeyframes.Count)
{
nextPt = pointsForKeyframes[i + 1];
}
else
{
nextPt = pathEndPt;
}
timeSpanValue = i * keyEveryNSecond + accumulatedDuration;
keyframeTimespan = TimeSpan.FromSeconds(timeSpanValue);
SetPitchAndHeadingForLine(currentPt, nextPt);
await CreateCameraKeyframe(mapView, currentPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
if (i == pointsForKeyframes.Count - 1 && skippedDistance > 0)
{
keyframeTimespan = TimeSpan.FromSeconds(TotalDuration + accumulatedDuration);
await CreateCameraKeyframe(mapView, pathEndPt, transformation, cameraTrack, keyframeTimespan, _keyframePitch, _keyframeHeading);
}
}
}
public void GenerateKeyframes(string animationType)
{
try
{
QueuedTask.Run(async() =>
{
if (VehicleListComboBoxValue.Text == "" || VehicleListComboBoxValue.Text == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("No Vehicle Route selected. Exiting...", "Value Needed");
return;
}
string VehiclePointsLayer = VehicleListComboBoxValue.Text + "_Route";
// Iterate and list the layers within the group layer
// string pointLayerName = System.IO.Path.GetFileName(outfc);
var pointLayer = MapView.Active.Map.FindLayers("VehiclePoints_" + VehiclePointsLayer).FirstOrDefault() as BasicFeatureLayer;
if (pointLayer == null)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Can't find the layer: " + "VehiclePoints_" + VehiclePointsLayer + ". Exiting...", "Info");
return;
}
// Ensure there's a value in the speed edit box
if (SpeedValueEditBox.Text == "" && animationType == "use speed")
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("The Speed in MPH value Editbox is empty. Exiting...", "Value Needed");
SpeedValueEditBox.Text = "";
return;
}
double speedValueMPH;
bool isNumeric = Double.TryParse(SpeedValueEditBox.Text, out speedValueMPH);
// Ensure there's a value in the speed edit box
if (isNumeric != true && animationType == "use speed")
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("The Speed in MPH value Editbox is not invalid. Type in a new value. Exiting...", "Value Needed");
SpeedValueEditBox.Text = "";
return;
}
// Prompt for confirmation, and if answer is no, return.
if (animationType == "use speed")
{
var result = MessageBox.Show("Confirm building of " + VehicleListComboBoxValue.Text.ToUpper() + " animation simulating vehicle speed of " + SpeedValueEditBox.Text + " MPH?", "Build Animation", System.Windows.MessageBoxButton.OKCancel, System.Windows.MessageBoxImage.Asterisk);
// Return if cancel value is chosen
if (Convert.ToString(result) == "Cancel")
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Operation cancelled.", "Info");
return;
}
}
else if (animationType == "ten-second")
{
var result = MessageBox.Show("Confirm building of " + VehicleListComboBoxValue.Text.ToUpper() + " 10-SECOND duration animation?", "Build Animation", System.Windows.MessageBoxButton.OKCancel, System.Windows.MessageBoxImage.Asterisk);
// Return if cancel value is chosen
if (Convert.ToString(result) == "Cancel")
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Operation cancelled.", "Info");
return;
}
}
int viewDistance = 0;
if (VehiclePointsLayer == "Car_Route")
{
viewDistance = 100;
}
else if (VehiclePointsLayer == "Boat_Route")
{
viewDistance = 200;
}
else if (VehiclePointsLayer == "Helicopter_Route")
{
viewDistance = 300;
}
// SET UP 3D MODEL SYMBOL AND SETTINGS
// Use the speed value to set keyframe timespan - Calculate distance covered in seconds and milliseconds based on speed and distance between points
// NOTE: Assumes map units are in feet. This is key.
// Calculate the Timespan using speed:
int rowNumber;
RowCursor pointsRowcursor;
int numPoints;
// Tempororily set to empty timespans
TimeSpan temp_span = new TimeSpan(0, 0, 0, 0, 0);
TimeSpan temp_newTimeSpan = new TimeSpan(0, 0, 0, 0, 0);
if (animationType == "use speed")
{
// Get the value of the distance between features.
rowNumber = 0;
MapPoint mapPoint1 = null;
MapPoint mapPoint2 = null;
pointsRowcursor = pointLayer.Search(null);
numPoints = pointLayer.GetTable().GetCount();
while (rowNumber < 3)
{
rowNumber = rowNumber + 1;
using (Row currentRow = pointsRowcursor.Current)
{
pointsRowcursor.MoveNext();
var pointFeature = pointsRowcursor.Current as Feature;
if (rowNumber == 1)
{
mapPoint1 = pointFeature.GetShape() as MapPoint;
}
else if (rowNumber == 2)
{
mapPoint2 = pointFeature.GetShape() as MapPoint;
}
}
}
pointsRowcursor.Dispose();
double dblDistBetween = GeometryEngine.Instance.Distance(mapPoint1, mapPoint2);
double dblFeetPerSecond = (speedValueMPH * 5280) / 3600;
double dblSecondsPerPoint = dblDistBetween / dblFeetPerSecond;
Double dblSec = Math.Truncate(dblSecondsPerPoint);
Double dblMilliSec = dblSecondsPerPoint - dblSec;
// round it
dblMilliSec = Math.Round(dblMilliSec, 3);
string strFixMilliSec = Convert.ToString(dblMilliSec);
strFixMilliSec = strFixMilliSec.Remove(0, 2);
Int32 intMilliSec = Convert.ToInt32(strFixMilliSec);
Int32 intSec = Convert.ToInt32(dblSec);
temp_span = new TimeSpan(0, 0, 0, intSec, intMilliSec);
temp_newTimeSpan = new TimeSpan(0, 0, 0, 0, 0);
}
else if (animationType == "ten-second")
{
temp_span = new TimeSpan(0, 0, 0, 0, 40);
temp_newTimeSpan = new TimeSpan(0, 0, 0, 0, 0);
}
TimeSpan span = temp_span;
TimeSpan newTimeSpan = temp_newTimeSpan;
var currentmapview = MapView.Active;
var mapAnimation = currentmapview.Map.Animation;
var currentcamera = currentmapview.Camera;
var newCamera = currentcamera;
// Use GetDisconnectedTracks
List <Track> tracks = mapAnimation.GetDisconnectedTracks();
var cameraTrack = tracks.OfType <CameraTrack>().First();
var rangeTrack = tracks.OfType <RangeTrack>().First();
int cameraJumpVal = 0;
rowNumber = 0;
string cameraSetting = "perspective";
Feature prevFeature = null;
MapPoint prevPoint = null;
pointsRowcursor = pointLayer.Search(null);
numPoints = pointLayer.GetTable().GetCount();
while (pointsRowcursor.MoveNext())
{
rowNumber = rowNumber + 1;
using (Row currentRow = pointsRowcursor.Current)
{
var pointFeature = pointsRowcursor.Current as Feature;
var mapPoint = pointFeature.GetShape() as MapPoint;
// if prevPoint == null, skip creation of keyframe
if (prevFeature != null)
{
double bearingRadians = 0;
string bearingValForKeyframe = Convert.ToString(currentRow["BEARING"]);
if (rowNumber == 2) // View from behind vehicle to begin animation
{
double bearingVal = Convert.ToDouble(currentRow["BEARING"]) + 180;
bearingRadians = (Math.PI / 180) * bearingVal;
cameraJumpVal = 12;
}
else if (rowNumber == numPoints) // Last point, build keyframe with camera facing the front of the vehicle:
{
double bearingVal = Convert.ToDouble(currentRow["BEARING"]) + 0;
bearingRadians = (Math.PI / 180) * bearingVal;
cameraJumpVal = 12;
}
else // View from the side
{
double bearingVal = Convert.ToDouble(currentRow["BEARING"]) + 270;
bearingRadians = (Math.PI / 270) * bearingVal;
}
double xNew = mapPoint.X + viewDistance * Math.Cos(Math.PI / 2 - bearingRadians);
double yNew = mapPoint.Y + viewDistance * Math.Sin(Math.PI / 2 - bearingRadians);
MapPoint newprevPoint = MapPointBuilder.CreateMapPoint(xNew, yNew);
double headingCalc = CalculateHeading(newprevPoint, mapPoint);
newCamera.Heading = headingCalc;
newCamera.X = xNew;
newCamera.Y = yNew;
if (VehiclePointsLayer == "Helicopter_Route")
{
newCamera.Z = mapPoint.Z + 60;
}
else
{
newCamera.Z = 60;
}
newCamera.Pitch = -5;
newCamera.Viewpoint = CameraViewpoint.LookAt;
double sequenceVal = Convert.ToDouble(currentRow["Sequence"]);
Range newRange = new Range();
newRange.Min = sequenceVal;
newRange.Max = sequenceVal;
// Create and edit the keyframes
rangeTrack.CreateKeyframe(newRange, newTimeSpan, AnimationTransition.Linear);
//newTimeSpan = newTimeSpan.Add(span);
if (cameraSetting == "perspective" && cameraJumpVal == 12)
{
// rangeTrack.CreateKeyframe(newRange, newTimeSpan, AnimationTransition.Linear);
// Set up side / angle perspective for the camera and create keyframe
cameraTrack.CreateKeyframe(newCamera, newTimeSpan, AnimationTransition.Linear);
cameraJumpVal = 0;
}
newTimeSpan = newTimeSpan.Add(span);
}
prevFeature = pointFeature;
prevPoint = prevFeature.GetShape() as MapPoint;
}
cameraJumpVal = cameraJumpVal + 1;
}
// Wrap up the animation
mapAnimation.Tracks = tracks;
// Final calculation for the recommendation on keyframes for video export:
// Get decimal seconds of newTimeSpan and use numPoints for number of keyframes
double keyframesTotal = Convert.ToDouble(numPoints);
double seconds = newTimeSpan.TotalSeconds;
double kpsValue = keyframesTotal / seconds;
double reccomendedKPS;
if (kpsValue > 50)
{
var kpsDivision = kpsValue / 25;
int kpsDivider = Convert.ToInt16(Math.Truncate(kpsDivision));
reccomendedKPS = kpsValue / kpsDivider;
}
else
{
reccomendedKPS = kpsValue;
}
string strReccKPS = Convert.ToString(Math.Round(reccomendedKPS, 0));
MessageBox.Show("Animation built. View timeline and/or export movie. \r\n" +
"NOTE: Recommended Frames Per Second setting for Export: \r\n" +
strReccKPS + " Frames Per Second", "Info");
});
}
catch (Exception ex)
{
MessageBox.Show("Error in GenerateKeyframes: " + ex.ToString(), "Error");
}
} // End of GenerateKeyframes()
protected override Task OnToolActivateAsync(bool active)
{
//return addFeatureLayer();
/*
* 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))
* {
* IReadOnlyList<string> createParams = Geoprocessing.MakeValueArray(new object[] { geodatabase, "fc01", null, null });
* return Geoprocessing.ExecuteToolAsync("management.CreateFeatureClass", createParams);
* }
*/
return(QueuedTask.Run(async() =>
{
//This works, but creates an xml representation of the connect string. Not sure that's what the next call wants
var cStr = "";
IReadOnlyList <string> cParams = Geoprocessing.MakeValueArray(new object[] {
"POSTGRESQL",
@"127.0.0.1",
"DATABASE_AUTH ",
"geomapmaker2",
"password",
"geomapmaker2"
});
IGPResult res = await Geoprocessing.ExecuteToolAsync("management.CreateDatabaseConnectionString", cParams);
if (!res.IsFailed)
{
Debug.WriteLine("conn string = " + res.ReturnValue);
cStr = res.ReturnValue;
}
else
{
Debug.WriteLine("failed ErrorCode " + res.ErrorCode);
Debug.WriteLine("failed ReturnValue " + res.ReturnValue);
foreach (IGPMessage msg in res.Messages)
{
Debug.WriteLine("failed msg text " + msg.Text);
}
}
/*
* // this works
* IReadOnlyList<string> cParams = Geoprocessing.MakeValueArray(new object[] {
* "C:/toolTest",
* "test01"
* });
* IGPResult res = await Geoprocessing.ExecuteToolAsync("management.CreateFolder", cParams);
* if (!res.IsFailed)
* {
* Debug.WriteLine("folder = " + res.ReturnValue);
* }
* else
* {
* Debug.WriteLine("failed!!!! " + res.ErrorCode);
* Debug.WriteLine("failed!!!! " + res.ReturnValue);
* foreach (IGPMessage msg in res.Messages)
* {
* Debug.WriteLine("failed!!!! " + msg.Text);
*
* }
* }
*/
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))
{
//Call fails no matter what I pass as connection string. No error is generated.
cStr = geodatabase.GetConnectionString();
//cStr = "ENCRYPTED_PASSWORD=00022e6877513471743162776f4c684e454a3363556157765177616373677361465977513463364c2b314c386165733d2a00;SERVER=127.0.0.1;INSTANCE=sde:postgresql:127.0.0.1;DBCLIENT=postgresql;DB_CONNECTION_PROPERTIES=127.0.0.1;DATABASE=geomapmaker2;USER=geomapmaker2;VERSION=sde.DEFAULT;AUTHENTICATION_MODE=DBMS";
//TODO: build this connection string using GeoProcessing "management.CreateDatabaseConnectionString"?
Debug.WriteLine("cStr = " + cStr);
IReadOnlyList <string> createParams = Geoprocessing.MakeValueArray(new object[] { cStr, "fc01", "POLYGON" });
//file gdb works:
//IReadOnlyList<string> createParams = Geoprocessing.MakeValueArray(new object[] { "C:/toolTest", "fc01", "POLYGON" });
res = await Geoprocessing.ExecuteToolAsync("management.CreateFeatureclass", createParams);
if (res.IsFailed)
{
Debug.WriteLine("feature class fail!!! = " + res.ErrorCode);
Debug.WriteLine("fc failed ReturnValue " + res.ReturnValue);
foreach (IGPMessage msg in res.Messages)
{
Debug.WriteLine("fc failed msg text " + msg.Text);
}
}
}
}));
}
public Task <int> CountFeaturesAsyc()
{
Func <int> methodToCall = CountFeatures;
return(QueuedTask.Run(methodToCall));
}
/// <summary>
/// Method used to convert a string to a known coordinate
/// Assumes WGS84 for now
/// </summary>
/// <param name="coordinate">the coordinate as a string</param>
/// <returns>MapPoint if successful, null if not</returns>
internal MapPoint GetMapPointFromString(string coordinate)
{
MapPoint point = null;
// future use if order of GetValues is not acceptable
//var listOfTypes = new List<GeoCoordinateType>(new GeoCoordinateType[] {
// GeoCoordinateType.DD,
// GeoCoordinateType.DDM,
// GeoCoordinateType.DMS,
// GeoCoordinateType.GARS,
// GeoCoordinateType.GeoRef,
// GeoCoordinateType.MGRS,
// GeoCoordinateType.USNG,
// GeoCoordinateType.UTM
//});
var listOfTypes = Enum.GetValues(typeof(GeoCoordinateType)).Cast <GeoCoordinateType>();
foreach (var type in listOfTypes)
{
try
{
point = QueuedTask.Run(() =>
{
return(MapPointBuilder.FromGeoCoordinateString(coordinate, MapView.Active.Map.SpatialReference, type, FromGeoCoordinateMode.Default));
}).Result;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
if (point != null)
{
return(point);
}
}
try
{
point = QueuedTask.Run(() =>
{
return(MapPointBuilder.FromGeoCoordinateString(coordinate, MapView.Active.Map.SpatialReference, GeoCoordinateType.UTM, FromGeoCoordinateMode.UtmNorthSouth));
}).Result;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
if (point == null)
{
coordinate = coordinate.Trim();
Regex regexMercator = new Regex(@"^(?<latitude>\-?\d+\.?\d*)[+,;:\s]*(?<longitude>\-?\d+\.?\d*)");
var matchMercator = regexMercator.Match(coordinate);
if (matchMercator.Success && matchMercator.Length == coordinate.Length)
{
try
{
var Lat = Double.Parse(matchMercator.Groups["latitude"].Value);
var Lon = Double.Parse(matchMercator.Groups["longitude"].Value);
point = QueuedTask.Run(() =>
{
return(MapPointBuilder.CreateMapPoint(Lon, Lat, MapView.Active.Map.SpatialReference));
}).Result;
return(point);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
return(null);
}
}
}
return(point);
}
/// <summary>
/// Updates the report with the new field and the title of the field.
/// </summary>
/// <remarks>
/// New Field: The new field gets added to the ReportDetails section.
/// Field title: If the report is grouped, the title goes in the "GroupHeader". If not, the title goes in the PageHeader section.
/// </remarks>
/// <returns></returns>
private async Task UpdateReport()
{
await QueuedTask.Run(() =>
{
//report to update
var reportToUpdate = _reportsInProject.FirstOrDefault(r => r.Name == ReportName);
//Create field
foreach (var field in _fieldsAddToReport)
{
//Get the "ReportSectionElement"
var mainReportSection = reportToUpdate.Elements.OfType <ReportSectionElement>().FirstOrDefault();
if (mainReportSection == null)
{
return;
}
#region Field content
//Get the "ReportDetails" within the ReportSectionElement. ReportDetails is where "fields" are.
var reportDetailsSection = mainReportSection?.Elements.OfType <ReportDetails>().FirstOrDefault();
if (reportDetailsSection == null)
{
return;
}
//Within ReportDetails find the envelope that encloses a field.
//We get the first CIMParagraphTextGraphic in the collection so that we can add the new field next to it.
var lastFieldGraphic = reportDetailsSection.Elements.FirstOrDefault((r) =>
{
var gr = r as GraphicElement;
if (gr == null)
{
return(false);
}
return(gr.GetGraphic() is CIMParagraphTextGraphic ? true : false);
});
//Get the Envelope of the last field
var graphicBounds = lastFieldGraphic.GetBounds();
//Min and Max values of the envelope
var xMinOfFieldEnvelope = graphicBounds.XMin;
var yMinOfFieldEnvelope = graphicBounds.YMin;
var xMaxOfFieldEnvelope = graphicBounds.XMax;
var YMaxOfFieldEnvelope = graphicBounds.YMax;
//create the new Envelope to be offset from the existing field
MapPoint newMinPoint = MapPointBuilder.CreateMapPoint(xMinOfFieldEnvelope + fieldIncrement, yMinOfFieldEnvelope);
MapPoint newMaxPoint = MapPointBuilder.CreateMapPoint(xMaxOfFieldEnvelope + fieldIncrement, YMaxOfFieldEnvelope);
Envelope newFieldEnvelope = EnvelopeBuilder.CreateEnvelope(newMinPoint, newMaxPoint);
#endregion
//Create field
GraphicElement fieldGraphic = ReportElementFactory.Instance.CreateFieldValueTextElement(reportDetailsSection, newFieldEnvelope, field);
#region Field title
Envelope envelopeOfLastField = null;
ILayoutElementContainer reportsSection;
//Field title in Page Header.
//Get the Page header section
var pageHeaderSection = mainReportSection?.Elements.OfType <ReportPageHeader>();
//Check if there are any elements in the page header section. If there are none, the report is "Grouped"
if (pageHeaderSection.FirstOrDefault().Elements.Count() == 0) //Page header has no child elements. The report is grouped on a field.
{
//Get Group Header.
// the title needs to be in the GroupHeader section.
var reportGroupHeader = mainReportSection?.Elements.OfType <ReportGroupHeader>().FirstOrDefault();
//Get the paragraph text element (the last title)
var lastFieldGroupHeaderGraphic = reportGroupHeader.Elements.FirstOrDefault((h) =>
{
var graphic = h as GraphicElement;
if (graphic == null)
{
return(false);
}
return(graphic.GetGraphic() is CIMParagraphTextGraphic ? true : false);
});
//Get the Envelope of the last field header
envelopeOfLastField = lastFieldGroupHeaderGraphic?.GetBounds();
//The ILayoutElementContainer is the "GroupHeader". Needed for the CreateRectangleParagraphGraphicElement method
reportsSection = reportGroupHeader;
}
else //not grouped
{
//Get the "ReportPageHeader" within the ReportSectionElement. ReportPageHeader is where "fields titles" are.
var reportPageHeader = mainReportSection?.Elements.OfType <ReportPageHeader>().FirstOrDefault();
//Get the paragraph text element (the last title)
var lastFieldPageHeaderGraphic = reportPageHeader.Elements.FirstOrDefault((h) =>
{
var graphic = h as GraphicElement;
if (graphic == null)
{
return(false);
}
return(graphic.GetGraphic() is CIMParagraphTextGraphic ? true : false);
});
//Get the Envelope of the last field header
envelopeOfLastField = lastFieldPageHeaderGraphic?.GetBounds();
//The ILayoutElementContainer is the "PageHeader". Needed for the CreateRectangleParagraphGraphicElement method
reportsSection = reportPageHeader;
}
//Min and Max values of the envelope
var xMinOfHeaderFieldEnvelope = envelopeOfLastField.XMin;
var yMinOfHeaderFieldEnvelope = envelopeOfLastField.YMin;
var xMaxOfHeaderFieldEnvelope = envelopeOfLastField.XMax;
var YMaxOfHeaderFieldEnvelope = envelopeOfLastField.YMax;
//create the new Envelope to be offset from the existing field
MapPoint newHeaderMinPoint = MapPointBuilder.CreateMapPoint(xMinOfHeaderFieldEnvelope + fieldIncrement, yMinOfHeaderFieldEnvelope);
MapPoint newHeaderMaxPoint = MapPointBuilder.CreateMapPoint(xMaxOfHeaderFieldEnvelope + fieldIncrement, YMaxOfHeaderFieldEnvelope);
Envelope newHeaderFieldEnvelope = EnvelopeBuilder.CreateEnvelope(newHeaderMinPoint, newHeaderMaxPoint);
#endregion
//Create field header title
GraphicElement fieldHeaderGraphic = ReportElementFactory.Instance.CreateRectangleParagraphGraphicElement(reportsSection, newHeaderFieldEnvelope, field.Name);
}
});
}
internal async Task <string> AddGraphicToMap(Geometry geom, CIMColor color, bool IsTempGraphic = false, double size = 1.0, string text = "", SimpleMarkerStyle markerStyle = SimpleMarkerStyle.Circle, string tag = "")
{
if (geom == null || MapView.Active == null)
{
return(string.Empty);
}
CIMSymbolReference symbol = null;
if (!string.IsNullOrWhiteSpace(text) && geom.GeometryType == GeometryType.Point)
{
await QueuedTask.Run(() =>
{
// TODO add text graphic
//var tg = new CIMTextGraphic() { Placement = Anchor.CenterPoint, Text = text};
});
}
else if (geom.GeometryType == GeometryType.Point)
{
await QueuedTask.Run(() =>
{
var s = SymbolFactory.Instance.ConstructPointSymbol(color, size, markerStyle);
symbol = new CIMSymbolReference()
{
Symbol = s
};
});
}
else if (geom.GeometryType == GeometryType.Polyline)
{
await QueuedTask.Run(() =>
{
var s = SymbolFactory.Instance.ConstructLineSymbol(color, size);
symbol = new CIMSymbolReference()
{
Symbol = s
};
});
}
else if (geom.GeometryType == GeometryType.Polygon)
{
await QueuedTask.Run(() =>
{
var outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 1.0, SimpleLineStyle.Solid);
var s = SymbolFactory.Instance.ConstructPolygonSymbol(color, SimpleFillStyle.Solid, outline);
symbol = new CIMSymbolReference()
{
Symbol = s
};
});
}
var result = await QueuedTask.Run(() =>
{
var disposable = MapView.Active.AddOverlay(geom, symbol);
var guid = Guid.NewGuid().ToString();
ProGraphicsList.Add(new ProGraphic(disposable, guid, geom, IsTempGraphic, tag));
return(guid);
});
return(result);
}
protected override void RunTask(QueuedTask queuedTask)
{
_log.Info($"Running task {queuedTask.Id}");
if (queuedTask.GetType() == typeof(QueuedModuleTask))
{
RunModuleTask(queuedTask as QueuedModuleTask);
}
else
{
if (queuedTask.GetType() == typeof(QueuedInternalTask))
{
var task = (QueuedInternalTask)queuedTask;
switch(task.TaskType)
{
case InternalTaskType.PersistResults:
internalTaskPersistResults();
break;
case InternalTaskType.UploadResults:
internalTaskUploadResults();
break;
case InternalTaskType.SendHeartbeat:
internalTaskSendHeartbeat();
break;
default:
break;
}
}
}
}
private async Task SetupDefinitionAsync()
{
try
{
var lstDefinitions = await QueuedTask.Run <List <DatasetInfo> >(() =>
{
List <DatasetInfo> definitions = new List <DatasetInfo>();
if (_datastore is Geodatabase)
{
var geodatabase = _datastore as Geodatabase;
switch (DatasetTypeCategory.DatasetType)
{
case DatasetType.Table:
definitions = geodatabase.GetDefinitions <TableDefinition>().Select(CreateDataSetInfo).ToList();
break;
case DatasetType.FeatureClass:
definitions = geodatabase.GetDefinitions <FeatureClassDefinition>().Select(CreateDataSetInfo).ToList();
break;
case DatasetType.FeatureDataset:
definitions = geodatabase.GetDefinitions <FeatureDatasetDefinition>().Select(CreateDataSetInfo).ToList();
break;
case DatasetType.RelationshipClass:
definitions = geodatabase.GetDefinitions <RelationshipClassDefinition>().Select(CreateDataSetInfo).ToList();
break;
case DatasetType.AttributedRelationshipClass:
definitions = geodatabase.GetDefinitions <AttributedRelationshipClassDefinition>().Select(CreateDataSetInfo).ToList();
break;
}
}
else if (_datastore is Database)
{
var database = _datastore as Database;
IReadOnlyList <string> tableNames = database.GetTableNames();
foreach (string tableName in tableNames)
{
QueryDescription queryDescription = database.GetQueryDescription(tableName);
TableDefinition tableDefinition = database.GetDefinition(queryDescription);
if (DatasetTypeCategory.DatasetType == DatasetType.Table || DatasetTypeCategory.DatasetType == DatasetType.FeatureClass)
{
definitions.Add(new DatasetInfo
{
Name = tableDefinition.GetName(),
DatasetDefinition = tableDefinition
});
}
}
}
else if (_datastore is FileSystemDatastore)
{
var shapefile = _datastore as FileSystemDatastore;
FileSystemConnectionPath shapefileConnectionPath = (FileSystemConnectionPath)shapefile.GetConnector();
DirectoryInfo directoryInfo = new DirectoryInfo(shapefileConnectionPath.Path.LocalPath);
if (DatasetTypeCategory.DatasetType == DatasetType.FeatureClass)
{
FileInfo[] filesWithShpExtension = directoryInfo.GetFiles("*.shp");
foreach (FileInfo file in filesWithShpExtension)
{
definitions.Add(CreateDataSetInfo(shapefile.GetDefinition <FeatureClassDefinition>(file.Name)));
}
}
if (DatasetTypeCategory.DatasetType == DatasetType.Table)
{
FileInfo[] filesWithDbfExtension = directoryInfo.GetFiles("*.dbf");
foreach (FileInfo file in filesWithDbfExtension)
{
definitions.Add(CreateDataSetInfo(shapefile.GetDefinition <TableDefinition>(file.Name)));
}
}
}
return(definitions);
});
Datasets.Clear();
Datasets.AddRange(lstDefinitions);
DefinitionDetails.Clear();
}
catch (Exception exObj)
{
MessageBox.Show(exObj.Message, "Error");
}
}
//
// TODO ITEMS:
// * Need to change this to use HttpWebRequest, since I need to erad
// the result back and create a tweet out of it, and insert in DB.
//
// * Report error to the user? Perhaps have a priority flag
// (posts show dialog, btu starring does not?
//
// Runs on a thread from the threadpool.
void PostTask(QueuedTask [] tasks)
{
var client = GetClient ();
try {
Util.PushNetworkActive ();
foreach (var task in tasks){
Uri taskUri = new Uri (task.Url);
client.Headers [HttpRequestHeader.Authorization] = OAuthAuthorizer.AuthorizeRequest (OAuthConfig, OAuthToken, OAuthTokenSecret, "POST", taskUri, task.PostData);
try {
client.UploadData (taskUri, "POST", Encoding.UTF8.GetBytes (task.PostData));
} catch (Exception){
// Can happen if we had already favorited this status
}
lock (Database.Main)
Database.Main.Execute ("DELETE FROM QueuedTask WHERE TaskId = ?", task.TaskId);
}
} catch (Exception e) {
Console.WriteLine (e);
} finally {
Util.PopNetworkActive ();
}
}
public async void SearchAndSubscribeToStreamData()
{
Map map = MapView.Active.Map;
StreamLayer streamLayer = null;
QueryFilter qfilter = null;
#region Search And Subscribe for Streaming Data
await QueuedTask.Run(async() =>
{
//query filter can be null to search and retrieve all rows
//true means recycling cursor
using (var rc = streamLayer.SearchAndSubscribe(qfilter, true))
{
//waiting for new features to be streamed
//default is no cancellation
while (await rc.WaitForRowsAsync())
{
while (rc.MoveNext())
{
using (var row = rc.Current)
{
//determine the origin of the row event
switch (row.GetRowSource())
{
case RealtimeRowSource.PreExisting:
//pre-existing row at the time of subscribe
continue;
case RealtimeRowSource.EventInsert:
//row was inserted after subscribe
continue;
case RealtimeRowSource.EventDelete:
//row was deleted after subscribe
continue;
}
}
}
}
}//row cursor is disposed. row cursor is unsubscribed
//....or....
//Use the feature class instead of the layer
using (var rfc = streamLayer.GetFeatureClass())
{
//non-recycling cursor - 2nd param "false"
using (var rc = rfc.SearchAndSubscribe(qfilter, false))
{
//waiting for new features to be streamed
//default is no cancellation
while (await rc.WaitForRowsAsync())
{
//etc
}
}
}
});
#endregion
#region Search And Subscribe With Cancellation
await QueuedTask.Run(async() =>
{
//Recycling cursor - 2nd param "true"
//or streamLayer.Subscribe(qfilter, true) to just subscribe
using (var rc = streamLayer.SearchAndSubscribe(qfilter, true))
{
//auto-cancel after 20 seconds
var cancel = new CancellationTokenSource(new TimeSpan(0, 0, 20));
//catch TaskCanceledException
try
{
while (await rc.WaitForRowsAsync(cancel.Token))
{
//check for row events
while (rc.MoveNext())
{
using (var row = rc.Current)
{
//etc
}
}
}
}
catch (TaskCanceledException tce)
{
//Handle cancellation as needed
}
cancel.Dispose();
}
});
#endregion
}
