public async Task <double> GetOffsetZAsync()
{
return(await QueuedTask.Run(() =>
{
CIMBaseLayer cimBaseLayer = Layer?.GetDefinition();
CIMBasicFeatureLayer cimBasicFeatureLayer = cimBaseLayer as CIMBasicFeatureLayer;
CIMLayerElevationSurface layerElevation = cimBasicFeatureLayer?.LayerElevation;
return (layerElevation?.OffsetZ ?? 0.0);
}));
}
// 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())
{
using (var currentRow = rows.Current)
{
object origVal = currentRow.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);
}));
}
internal List <HierarchyRow> GetRelationshipChildrenFromLayer(BasicFeatureLayer member,
long objectID)
{
var children = new List <HierarchyRow>();
CIMBasicFeatureLayer bfl = member.GetDefinition() as CIMBasicFeatureLayer;
var relates = bfl.FeatureTable.Relates;
if (relates == null || relates.Length == 0)
{
return(children);
}
foreach (var relate in relates)
{
if (!(relate.DataConnection is CIMStandardDataConnection) &&
!(relate.DataConnection is CIMFeatureDatasetDataConnection))
{
continue;//Not supported in this sample
}
var sdc = relate.DataConnection as CIMStandardDataConnection;
var fdc = relate.DataConnection as CIMFeatureDatasetDataConnection;
var factory = sdc?.WorkspaceFactory ?? fdc.WorkspaceFactory;
var path = sdc?.WorkspaceConnectionString ?? fdc.WorkspaceConnectionString;
if (string.IsNullOrEmpty(path))
{
continue;//No connection information we can use
}
path = path.Replace("DATABASE=", "");
var dstype = sdc?.DatasetType ?? fdc.DatasetType;
if (dstype != esriDatasetType.esriDTFeatureClass &&
dstype != esriDatasetType.esriDTTable)
{
continue;//Not supported in the sample
}
var dsname = sdc?.Dataset ?? fdc.Dataset;
var featDatasetName = fdc?.FeatureDataset ?? "";
Geodatabase gdb = null;
if (factory == WorkspaceFactory.FileGDB)
{
gdb = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(path, UriKind.Absolute)));
}
else if (factory == WorkspaceFactory.SDE)
{
gdb = new Geodatabase(new DatabaseConnectionFile(new Uri(path, UriKind.Absolute)));
}
Table table = null;
//We have to open a type specific dataset - FeatureClass or Table
//We cannot simply use 'Table' for both
if (dstype == esriDatasetType.esriDTFeatureClass)
{
table = GetDatasetFromGeodatabase <FeatureClass>(gdb, dsname, featDatasetName);
}
else
{
table = GetDatasetFromGeodatabase <Table>(gdb, dsname, featDatasetName);
}
if (table == null)
{
continue;//Related dataset not found
}
//Get any related rows
var qry_fld = table.GetDefinition().GetFields().FirstOrDefault(f => f.Name == relate.ForeignKey);
if (qry_fld == null)
{
continue;//We cannot find the designated foreign key
}
//Load relevant values
var inspector = new Inspector();
inspector.Load(member, objectID);
var need_quotes = qry_fld.FieldType == FieldType.String;
var quote = need_quotes ? "'" : "";
var where = $"{relate.ForeignKey} = {quote}{inspector[relate.PrimaryKey]}{quote}";
var qf = new QueryFilter()
{
WhereClause = where,
SubFields = $"{table.GetDefinition().GetObjectIDField()}, {relate.ForeignKey}"
};
var childHRow = new HierarchyRow()
{
name = dsname,
type = $"{inspector[relate.PrimaryKey]}"
};
using (var rc = table.Search(qf))
{
while (rc.MoveNext())
{
using (var row = rc.Current)
{
var id = row.GetObjectID();
var HRow = new HierarchyRow()
{
name = $"{id}",
type = relate.ForeignKey
};
childHRow.children.Add(HRow);
}
}
}
children.Add(childHRow);
}
return(children);
}
// All layers type that yield have subLayes (IsGroup = true) should have no
// connection properties and have "Group" in the data type to get the group icon.
private void InitBasicFeature(CIMBasicFeatureLayer layer)
{
InitDataConnection(layer.FeatureTable.DataConnection);
GeometryType = BuildGeometryType(layer);
}
private string BuildGeometryType(CIMBasicFeatureLayer layer)
{
if (layer is CIMAnnotationLayer)
{
return("Annotation");
}
if (layer is CIMDimensionLayer)
{
return("Dimension");
}
if (layer is CIMFeatureLayer featureLayer)
{
string symbolName = null;
if (layer.SelectionSymbol != null)
{
symbolName = layer.SelectionSymbol.Symbol.GetType().Name;
}
else
{
if (featureLayer.Renderer is CIMSimpleRenderer sRenderer)
{
try
{
symbolName = sRenderer.Symbol.Symbol.GetType().Name;
}
catch { }
}
else if (featureLayer.Renderer is CIMUniqueValueRenderer uRenderer)
{
try
{
symbolName = uRenderer.Groups[0].Classes[0].Symbol.Symbol.GetType().Name;
}
catch { }
}
else if (featureLayer.Renderer is CIMClassBreaksRenderer cRenderer)
{
try
{
symbolName = cRenderer.Breaks[0].Symbol.Symbol.GetType().Name;
}
catch { }
}
}
switch (symbolName)
{
case "CIMLineSymbol": return("Polyline");
case "CIMMeshSymbol": return("Mesh");
case "CIMPointSymbol": return("Point");
case "CIMPolygonSymbol": return("Polygon");
case "CIMTextSymbol": return("Annotation");
default: return(null);
}
}
return(null);
}
