/// <summary>
/// Renders a feature into displayable render objects.
/// </summary>
/// <param name="feature">The feature to render.</param>
/// <param name="style">The style to use to render the feature.</param>
/// <returns>An enumeration of positioned render objects for display.</returns>
public IEnumerable <TRenderObject> RenderFeature(IFeatureDataRecord feature,
TStyle style,
RenderState renderState,
ILayer layer)
{
Boolean cancel = false;
OnFeatureRendering(ref cancel);
if (cancel)
{
yield break;
}
if (style == default(TStyle))
{
throw new InvalidOperationException("Cannot render feature without a style.");
}
IEnumerable <TRenderObject> renderedObjects = DoRenderFeature(feature, style, renderState, layer);
OnFeatureRendered();
foreach (TRenderObject renderObject in renderedObjects)
{
yield return(renderObject);
}
}
private IConvertData GetConverter(Type tsource, Type ttarget, IFeatureDataRecord sourcetable, int index, IGeometryFactory geometryFactory)
{
Type t = typeof(ConvertData <,>);
Type g = t.MakeGenericType(tsource, ttarget);
return((IConvertData)Activator.CreateInstance(g, sourcetable, index, geometryFactory));
}
public void TestGetFeatureByOid()
{
GeometryServices services = new GeometryServices();
MsSqlServer2008Provider <long> search = new MsSqlServer2008Provider <long>(services.DefaultGeometryFactory,
ConfigurationManager.
ConnectionStrings["sql2008"].
ConnectionString,
"dbo",
"vw_iMARS_BRANCH", "ACSId", "Geom")
{
DefaultProviderProperties
= new ProviderPropertiesExpression(
new ProviderPropertyExpression[]
{
new WithNoLockExpression(true),
new ForceIndexExpression(true)
})
};
IFeatureDataRecord record = search.GetFeatureByOid(1);
Assert.IsNotNull(record);
}
IEnumerable <TRenderObject> IFeatureRenderer <TRenderObject> .RenderFeature(IFeatureDataRecord feature,
IStyle style,
RenderState renderState,
ILayer layer)
{
return(RenderFeature(feature, style as TStyle, renderState, layer));
}
public static string WriteFeature(IGeoJsonFeatureStyle style, IFeatureDataRecord feature)
{
StringBuilder sb = new StringBuilder();
WriteFeature(sb, style, feature);
return(sb.ToString());
}
protected override IEnumerable <TRenderObject> DoRenderFeature(IFeatureDataRecord feature,
GeoJsonGeometryStyle style,
RenderState state,
ILayer layer)
{
if (feature == null)
{
throw new ArgumentNullException("feature");
}
if (style == null)
{
throw new ArgumentNullException("style");
}
if (feature.Geometry == null)
{
throw new InvalidOperationException("Feature must have a geometry to be rendered.");
}
StringBuilder sb = new StringBuilder();
GeoJsonFeatureWriter.WriteFeature(sb, style, feature);
yield return((TRenderObject)(object)(new GeoJsonRenderObject(sb.ToString())));
/* oh dear - i feel very dirty now */
}
IStyle ITheme.GetStyle(IFeatureDataRecord row)
{
if (!(row is FeatureDataRow))
{
throw new ArgumentException("Parameter 'row' must be of type FeatureDataRow");
}
return(GetStyle(row as FeatureDataRow));
}
public bool Read()
{
record = null;
if (_enumerator.MoveNext())
{
read++;
record = _enumerator.Current;
return true;
}
return false;
}
public bool Read()
{
record = null;
if (_enumerator.MoveNext())
{
read++;
record = _enumerator.Current;
return(true);
}
return(false);
}
/// <summary>
/// Renders a feature into displayable render objects.
/// </summary>
/// <param name="feature">The feature to render.</param>
/// <returns>An enumeration of positioned render objects for display.</returns>
public IEnumerable <TRenderObject> RenderFeature(IFeatureDataRecord feature)
{
TStyle style = DefaultStyle;
if (style == null)
{
throw new InvalidOperationException("Cannot render feature without style. " +
"DefaultStyle is null.");
}
return(RenderFeature(feature, style, RenderState.Normal, null));
}
public bool Symbolize(IFeatureDataRecord obj, out object output)
{
TOutput toutput;
if (Symbolize(obj, out toutput))
{
output = toutput;
return(true);
}
output = null;
return(false);
}
public Boolean Read()
{
checkDisposed();
Boolean reading = _objectEnumerator.MoveNext();
if (reading)
{
_currentFeature = _shapeFile.GetFeatureByOid(_objectEnumerator.Current);
}
return(reading);
}
/// <summary>
/// Renders the geometry of the <paramref name="feature"/>.
/// </summary>
/// <param name="feature">The feature to render.</param>
/// <param name="style">The style to use to render the feature.</param>
/// <returns>An enumeration of positioned render objects suitable for display.</returns>
protected override IEnumerable <TRenderObject> DoRenderFeature(IFeatureDataRecord feature, GeometryStyle style, RenderState renderState, ILayer layer)
{
if (feature == null)
{
throw new ArgumentNullException("feature");
}
if (style == null)
{
throw new ArgumentNullException("style");
}
if (feature.Geometry == null)
{
throw new InvalidOperationException("Feature must have a geometry to be rendered.");
}
return(renderGeometry(feature.Geometry, style, renderState));
}
public FeatureDataRow <TTarget> ConvertRow(IFeatureDataRecord source)
{
if (typeof(TSource) == typeof(TTarget) && source is FeatureDataRow)
{
return(source as FeatureDataRow <TTarget>);
}
TTarget oid = _conversionDelegate((TSource)source.GetOid());
FeatureDataRow <TTarget> row = _target.NewRow(oid);
object[] vals = new object[source.FieldCount];
vals[_oidColumnIndex] = oid;
source.GetValues(vals);
row.ItemArray = vals;
//row.Geometry = source.Geometry.IsValid ? source.Geometry : source.Geometry.Buffer(0.0);
row.Geometry = source.Geometry;
return(row);
}
public static void WriteFeature(StringBuilder sb, IGeoJsonFeatureStyle style, IFeatureDataRecord feature)
{
IGeometry g = style.PreProcessGeometries
? style.GeometryPreProcessor(feature.Geometry)
: feature.Geometry;
sb.Append("{");
sb.Append("\"type\":\"Feature\",");
if (feature.HasOid)
{
sb.Append(JsonUtility.FormatJsonAttribute("id", feature.GetOid()));
sb.Append(",");
}
sb.Append("\"properties\":");
WriteFeatureAttributes(sb, style, feature);
sb.Append(",");
if (style.IncludeBBox)
{
sb.Append("\"bbox\":");
WriteExtents(sb, g.Extents, style.CoordinateNumberFormatString);
sb.Append(",");
}
/* Ideally this should be higher up e.g at the layer level but we dont currently
* have anywhere where we can group features by layer.
* It still complies with the spec but will be considerably more verbose */
if (g.SpatialReference != null || !string.IsNullOrEmpty(g.Srid))
{
sb.Append("\"crs\":");
WriteNamedCrs(sb,
g.SpatialReference != null
? g.SpatialReference.Name
: "EPSG:" + SridMap.DefaultInstance.Process(g.SpatialReference, 0));
sb.Append(",");
}
sb.Append("\"geometry\":");
WriteGeometry(sb, g, style.CoordinateNumberFormatString);
sb.Append("}");
sb.AppendLine();
}
private static void WriteFeatureAttributes(StringBuilder sb, IGeoJsonFeatureStyle style,
IFeatureDataRecord feature)
{
sb.Append("{");
if (style.IncludeAttributes)
{
IDictionary <string, object> attributes = style.AttributeExtractionDelegate(feature);
int i = 0;
foreach (KeyValuePair <string, object> kvp in attributes)
{
sb.Append(JsonUtility.FormatJsonAttribute(kvp.Key, kvp.Value));
if (i < attributes.Count - 1)
{
sb.Append(",");
}
i++;
}
}
sb.Append("}");
}
public DataConverter(Func <TSource, TTarget> conversionDlgt, IFeatureDataRecord source, int oidColumnIndex, IGeometryFactory geometryFactory)
{
_conversionDelegate = conversionDlgt;
_oidColumnIndex = oidColumnIndex;
string oidColName = source.GetName(oidColumnIndex);
FeatureDataTable <TTarget> trgt = new FeatureDataTable <TTarget>("SchemaTable", oidColName,
geometryFactory);
for (int i = 0; i < source.FieldCount; i++)
{
if (i != oidColumnIndex)
{
trgt.Columns.Add(new DataColumn(source.GetName(i), source.GetFieldType(i)));
}
}
_target = trgt;
}
protected override IEnumerable <GeoJsonRenderObject> DoRenderFeature(IFeatureDataRecord feature,
GeoJsonLabelStyle style,
RenderState state, ILayer layer)
{
FeatureDataRow fdr = (FeatureDataRow)feature;
string text = fdr.Evaluate(style.LabelExpression);
StringBuilder sb = new StringBuilder();
sb.Append("{");
sb.Append(JsonUtility.FormatJsonAttribute("type", "Label"));
sb.Append(",");
sb.Append(JsonUtility.FormatJsonAttribute("id", feature.GetOid()));
sb.Append(",");
sb.Append(JsonUtility.FormatJsonAttribute("text", text));
sb.Append(",");
IGeometry geom;
if (style.IncludeGeometryData)
{
geom = style.PreProcessGeometries
? style.GeometryPreProcessor(feature.Geometry)
: feature.Geometry;
}
else
{
geom = feature.Geometry.Centroid;
}
sb.Append("\"shape\":");
GeoJsonFeatureWriter.WriteGeometry(sb, geom, style.CoordinateNumberFormatString);
sb.Append("}");
yield return(new GeoJsonRenderObject(sb.ToString()));
}
public DataConverter(IFeatureDataRecord source, int oidColumnIndex, IGeometryFactory geometryFactory)
: this(
delegate(TSource o) { return((TTarget)Convert.ChangeType(o, typeof(TTarget))); }, source, oidColumnIndex, geometryFactory)
{
}
public static void WriteFeature(StringBuilder sb, IGeoJsonFeatureStyle style, IFeatureDataRecord feature)
{
IGeometry g = style.PreProcessGeometries
? style.GeometryPreProcessor(feature.Geometry)
: feature.Geometry;
sb.Append("{");
sb.Append("\"type\":\"Feature\",");
if (feature.HasOid)
{
sb.Append(JsonUtility.FormatJsonAttribute("id", feature.GetOid()));
sb.Append(",");
}
sb.Append("\"properties\":");
WriteFeatureAttributes(sb, style, feature);
sb.Append(",");
if (style.IncludeBBox)
{
sb.Append("\"bbox\":");
WriteExtents(sb, g.Extents, style.CoordinateNumberFormatString);
sb.Append(",");
}
/* Ideally this should be higher up e.g at the layer level but we dont currently
* have anywhere where we can group features by layer.
* It still complies with the spec but will be considerably more verbose */
if (g.SpatialReference != null || !string.IsNullOrEmpty(g.Srid))
{
sb.Append("\"crs\":");
WriteNamedCrs(sb,
g.SpatialReference != null
? g.SpatialReference.Name
: "EPSG:" + SridMap.DefaultInstance.Process(g.SpatialReference, 0));
sb.Append(",");
}
sb.Append("\"geometry\":");
WriteGeometry(sb, g, style.CoordinateNumberFormatString);
sb.Append("}");
sb.AppendLine();
}
private static void WriteFeatureAttributes(StringBuilder sb, IGeoJsonFeatureStyle style,
IFeatureDataRecord feature)
{
sb.Append("{");
if (style.IncludeAttributes)
{
IDictionary<string, object> attributes = style.AttributeExtractionDelegate(feature);
int i = 0;
foreach (KeyValuePair<string, object> kvp in attributes)
{
sb.Append(JsonUtility.FormatJsonAttribute(kvp.Key, kvp.Value));
if (i < attributes.Count - 1)
sb.Append(",");
i++;
}
}
sb.Append("}");
}
public static string WriteFeature(IGeoJsonFeatureStyle style, IFeatureDataRecord feature)
{
StringBuilder sb = new StringBuilder();
WriteFeature(sb, style, feature);
return sb.ToString();
}
//private SchemaMap _schemaMap = new SchemaMap();
//private delegate Object Converter(Object input);
//private class SchemaMap
//{
// private readonly List<SchemaMapColumnMatch> _columnMatches = new List<SchemaMapColumnMatch>();
// private readonly List<SchemaMapKeyMatch> _keyMatches = new List<SchemaMapKeyMatch>();
// public void AddColumnMatch(DataColumn src, DataColumn dst)
// {
// AddColumnMatch(src, dst, null);
// }
// public void AddColumnMatch(DataColumn src, DataColumn dst, Converter converter)
// {
// SchemaMapColumnMatch match = new SchemaMapColumnMatch(src, dst, converter);
// _columnMatches.Add(match);
// }
// public void AddKeyMatch(DataColumn src, DataColumn dst)
// {
// SchemaMapKeyMatch match = new SchemaMapKeyMatch(src, dst);
// _keyMatches.Add(match);
// }
// public SchemaMapColumnMatch GetColumnMatch(Int32 index)
// {
// return _columnMatches[index];
// }
// public SchemaMapKeyMatch GetKeyMatch(Int32 index)
// {
// return _keyMatches[index];
// }
//}
//private class SchemaMapKeyMatch
//{
// private readonly DataColumn _srcColumn;
// private readonly DataColumn _dstColumn;
// public SchemaMapKeyMatch(DataColumn src, DataColumn dst)
// {
// _srcColumn = src;
// _dstColumn = dst;
// }
// public DataColumn Destination
// {
// get { return _dstColumn; }
// }
// public DataColumn Source
// {
// get { return _srcColumn; }
// }
//}
//private class SchemaMapColumnMatch
//{
// private readonly DataColumn _srcColumn;
// private readonly DataColumn _dstColumn;
// private readonly Converter _converter;
// public SchemaMapColumnMatch(DataColumn src, DataColumn dst, Converter converter)
// {
// _srcColumn = src;
// _converter = converter;
// _dstColumn = dst;
// }
// public Converter Converter
// {
// get { return _converter; }
// }
// public DataColumn Destination
// {
// get { return _dstColumn; }
// }
// public DataColumn Source
// {
// get { return _srcColumn; }
// }
//}
//private static DataTable mergeSchema(DataTable source, DataSet targetDataSet, DataTable target, SchemaMergeAction mergeAction, Boolean preserveChanges)
//{
// Boolean ignoreCase = ((Int32)(mergeAction & SchemaMergeAction.CaseInsensitive) != 0);
// DataTable targetTable = null;
// if (targetDataSet != null)
// {
// if (tablesContain(targetDataSet, ignoreCase, source.TableName))
// {
// targetTable = targetDataSet.Namespace != source.Namespace
// ? targetDataSet.Tables[source.TableName]
// : targetDataSet.Tables[source.TableName, source.Namespace];
// }
// }
// else
// {
// targetTable = target;
// }
// if (targetTable == null) // This will be true when the targetDataSet doesn't have a table by the same name
// {
// throw new NotImplementedException("DataSet merges not yet implemented.");
// }
// else
// {
// if (mergeAction == SchemaMergeAction.None)
// {
// mergeExtendedProperties(source.ExtendedProperties, targetTable.ExtendedProperties, mergeAction, preserveChanges);
// return targetTable;
// }
// Int32 initialTargetCount = targetTable.Columns.Count;
// Boolean matchIfConvertible = (Int32)(mergeAction & SchemaMergeAction.MatchIfConvertible) != 0;
// Boolean includeKey = (Int32)(mergeAction & SchemaMergeAction.Key) != 0;
// Boolean add = (Int32)(mergeAction & SchemaMergeAction.AddAll) != 0;
// Boolean replace = (Int32)(mergeAction & SchemaMergeAction.Replace) != 0;
// for (int i = 0; i < source.Columns.Count; i++)
// {
// DataColumn src = source.Columns[i];
// DataColumn dest = columnsContain(targetTable, source, src.ColumnName, src.DataType, ignoreCase, matchIfConvertible, includeKey)
// ? targetTable.Columns[src.ColumnName]
// : null;
// if (dest == null)
// {
// // rematch using type coersion to System.Object to ensure match
// dest = columnsContain(targetTable, src.ColumnName, typeof(Object), ignoreCase, true, includeKey)
// ? targetTable.Columns[src.ColumnName]
// : null;
// if (dest != null && replace)
// {
// // Find common type to convert to (widen for numeric and character data, cast up for objects)
// // Add new column with found type
// // Copy existing dest data to new column from old column
// // Remove original destination column
// throw new NotImplementedException("Schema replacement not yet implemented");
// }
// }
// if (dest == null)
// {
// if (add)
// {
// dest = _cloneDataColumn(src);
// targetTable.Columns.Add(dest);
// }
// else if (!isKey(source, src) || (includeKey && isKey(source, src)))
// {
// // TODO: raise merge failed event
// throw new DataException("Merge failed, can't match column: " + src.ColumnName);
// }
// }
// else
// {
// if (matchIfConvertible)
// {
// throw new NotImplementedException("Schema matching on convertible types not yet implemented");
// }
// else if (dest.DataType != src.DataType ||
// ((dest.DataType == typeof(DateTime)) &&
// (dest.DateTimeMode != src.DateTimeMode) &&
// ((dest.DateTimeMode & src.DateTimeMode) != DataSetDateTime.Unspecified)))
// {
// throw new DataException("Merge failed, data type mismatch: " + src.ColumnName);
// }
// mergeExtendedProperties(src.ExtendedProperties, dest.ExtendedProperties, mergeAction, preserveChanges);
// }
// // Set expressions
// if (targetDataSet != null)
// {
// throw new NotImplementedException("DataSet merges not yet implemented.");
// //for (int i = initialTargetCount; i < targetTable.Columns.Count; i++)
// //{
// // targetTable.Columns[i].Expression = source.Columns[targetTable.Columns[i].ColumnName].Expression;
// //}
// }
// //
// DataColumn[] targetKey = targetTable.PrimaryKey;
// DataColumn[] sourceKey = source.PrimaryKey;
// if (targetKey.Length != sourceKey.Length)
// {
// // special case when the target table does not have the PrimaryKey
// if (targetKey.Length == 0)
// {
// DataColumn[] key = new DataColumn[sourceKey.Length];
// for (Int32 i = 0; i < sourceKey.Length; i++)
// {
// key[i] = targetTable.Columns[sourceKey[i].ColumnName];
// }
// targetTable.PrimaryKey = key;
// }
// else if (sourceKey.Length != 0)
// {
// targetDataSet.RaiseMergeFailed(targetTable, Res.GetString(Res.DataMerge_PrimaryKeyMismatch), missingSchemaAction);
// }
// }
// else
// {
// for (int i = 0; i < targetKey.Length; i++)
// {
// if (String.Compare(targetKey[i].ColumnName, sourceKey[i].ColumnName, false, targetTable.Locale) != 0)
// {
// targetDataSet.RaiseMergeFailed(source,
// Res.GetString(Res.DataMerge_PrimaryKeyColumnsMismatch, targetKey[i].ColumnName, sourceKey[i].ColumnName),
// missingSchemaAction
// );
// }
// }
// }
// }
// mergeExtendedProperties(source.ExtendedProperties, targetTable.ExtendedProperties, mergeAction, preserveChanges);
// }
// return targetTable;
//}
//private static Boolean isKey(DataTable table, DataColumn column)
//{
// return Array.Exists(table.PrimaryKey, delegate(DataColumn find) { return ReferenceEquals(find, column); });
//}
//private static Boolean tablesContain(DataSet targetDataSet, Boolean ignoreCase, String name)
//{
// StringComparer comparer = StringComparer.Create(targetDataSet.Locale ?? CultureInfo.CurrentCulture, ignoreCase);
// foreach (DataTable table in targetDataSet.Tables)
// {
// if (comparer.Compare(table.TableName, name) == 0)
// {
// return true;
// }
// }
// return false;
//}
//private static Boolean columnsContain(DataTable table, String columnName, Type columnType, Boolean ignoreCase, Boolean matchIfConvertible, Boolean includeKey)
//{
// StringComparer comparer = StringComparer.Create(table.Locale ?? CultureInfo.CurrentCulture, ignoreCase);
// foreach (DataColumn column in table.Columns)
// {
// if (comparer.Compare(column.ColumnName, columnName) == 0)
// {
// return true;
// }
// }
// return false;
//}
#endregion
internal void MergeFeature(IFeatureDataRecord record, IGeometryFactory factory)
{
if (record == null)
{
throw new ArgumentNullException("record");
}
Boolean checkForTarget = _targetDataTable.Rows.Count > 0 &&
(_targetDataTable.PrimaryKey.Length > 0);
mergeSchemaIfNeeded(record, factory);
FeatureDataRow targetFeature = null;
if (checkForTarget && record.HasOid)
{
targetFeature = _targetDataTable.Find(record.GetOid());
}
mergeFeature(_targetDataTable, record, targetFeature, _columnMap, _transform, _geoFactory, PreserveChanges);
}
private static void mergeFeature(FeatureDataTable target,
IFeatureDataRecord srcFeature,
FeatureDataRow targetFeature,
ColumnMapper columnMapper,
ICoordinateTransformation transform,
IGeometryFactory geoFactory,
Boolean preserveChanges)
{
if (targetFeature == null)
{
targetFeature = target.NewRow();
setFeatureRowFromIFeatureDataRecord(srcFeature, targetFeature, columnMapper, transform, geoFactory);
target.AddRow(targetFeature);
}
else
{
if (preserveChanges && targetFeature.RowState == DataRowState.Modified)
{
throw new NotImplementedException("Merging updates to original features " +
"state not yet implemented.");
}
setFeatureRowFromIFeatureDataRecord(srcFeature, targetFeature, columnMapper, transform, geoFactory);
}
}
private void mergeSchemaIfNeeded(IFeatureDataRecord record, IGeometryFactory factory)
{
if ((SchemaMergeAction & SchemaMergeAction.AddAll) != SchemaMergeAction.None)
{
// HACK: Parsing and setting the schema should be less clunky here.
// We probably need to just do the schema merge ourselves without
// having to rely on System.Data.Merger
FeatureDataTable schemaModel = record is FeatureDataRow
? (record as FeatureDataRow).Table
: createModelFromFeature(record, factory);
MergeSchema(schemaModel);
Int32 sourceCount = schemaModel.Columns.Count;
Int32 targetCount = _targetDataTable.Columns.Count;
if (targetCount != sourceCount)
{
_columnMap = generateColumnMapper(schemaModel);
return;
}
for (Int32 i = 0; i < _targetDataTable.Columns.Count; i++)
{
//jd: this seems to fix an issue where the columns would be mapped incorrectly..
//however I think there is another issue where the destination table is one column short..
string columnName = _targetDataTable.Columns[i].ColumnName;
if (_targetDataTable.Columns[i].Ordinal != schemaModel.Columns[columnName].Ordinal)
{
_columnMap = generateColumnMapper(schemaModel);
return;
}
//jd:the following test is always true
//if (_targetDataTable.Columns[i].Ordinal != schemaModel.Columns[i].Ordinal)
//{
// _columnMap = generateColumnMapper(schemaModel);
// return;
//}
}
}
_columnMap = generateDefaultColumnMapper();
}
private void LoadAttributes(IFeatureDataRecord data)
{
Shape = data.GetGeometry();
const string idColumnName = "TransectID";
if (data.GetOrdinal(idColumnName) < 0)
throw new ArgumentException(string.Format("Column '{0}' does not belong to table {1}",idColumnName, FeatureSource.Name));
Name = data[idColumnName] as string;
}
FeatureDataRow IConvertData.ConvertRecord(IFeatureDataRecord source)
{
return(ConvertRow(source));
}
private static void setFeatureRowFromIFeatureDataRecord(IFeatureDataRecord srcFeature, FeatureDataRow targetFeature)
{
for (int i = 0; i < srcFeature.FieldCount; i++)
{
string colName = srcFeature.GetName(i);
targetFeature[colName] = srcFeature.GetValue(i);
}
targetFeature.Geometry = srcFeature.Geometry;
targetFeature.IsFullyLoaded = targetFeature.IsFullyLoaded || srcFeature.IsFullyLoaded;
}
// FIX_PERF
private static void setFeatureRowFromIFeatureDataRecord(IFeatureDataRecord srcFeature,
FeatureDataRow targetFeature,
ColumnMapper columnMapper,
ICoordinateTransformation transform,
IGeometryFactory geoFactory)
{
//for (Int32 i = 0; i < srcFeature.FieldCount; i++)
//{
// String colName = srcFeature.GetName(i);
// targetFeature[colName] = srcFeature.GetValue(i);
//}
if (transform != null)//jd: to prevent case when transform is null - probably because a test was done earlier. need to check
{
if (srcFeature.Geometry.SpatialReference.EqualParams(transform.Target))
{
transform = null;
}
}
srcFeature.GetValues(columnMapper.SourceValues);
targetFeature.ItemArray = columnMapper.Map();
targetFeature.Geometry = transform == null
? srcFeature.Geometry
: transform.Transform(srcFeature.Geometry, geoFactory);
targetFeature.IsFullyLoaded = targetFeature.IsFullyLoaded || srcFeature.IsFullyLoaded;
}
private static FeatureDataTable createModelFromFeature(IFeatureDataRecord srcFeature)
{
FeatureDataTable schemaModel = new FeatureDataTable();
for (int fieldIndex = 0; fieldIndex < srcFeature.FieldCount; fieldIndex++)
{
schemaModel.Columns.Add(srcFeature.GetName(fieldIndex),
srcFeature.GetFieldType(fieldIndex));
}
return schemaModel;
}
/// <summary>
/// Template method to perform the actual geometry rendering.
/// </summary>
/// <param name="feature">Feature to render.</param>
/// <param name="style">Style to use in rendering geometry.</param>
/// <param name="state">
/// A <see cref="RenderState"/> value to indicate how to render the feature.
/// </param>
/// <returns></returns>
/// <param name="layer"></param>
protected abstract IEnumerable <TRenderObject> DoRenderFeature(IFeatureDataRecord feature, TStyle style,
RenderState state, ILayer layer);
private static FeatureDataTable createModelFromFeature(IFeatureDataRecord srcFeature,
IGeometryFactory factory)
{
FeatureDataTable schemaModel = new FeatureDataTable(factory);
for (Int32 fieldIndex = 0; fieldIndex < srcFeature.FieldCount; fieldIndex++)
{
schemaModel.Columns.Add(srcFeature.GetName(fieldIndex),
srcFeature.GetFieldType(fieldIndex));
}
return schemaModel;
}
internal void MergeFeature(IFeatureDataRecord record)
{
if (record == null) throw new ArgumentNullException("record");
bool checkForTarget = false;
if ((SchemaMergeAction & SchemaMergeAction.Add) != SchemaMergeAction.None)
{
// HACK: Parsing and setting the schema should be less clunky here.
// We probably need to just do the schema merge ourselves without having
// to rely on System.Data.Merger
FeatureDataTable schemaModel = createModelFromFeature(record);
MergeSchema(schemaModel);
checkForTarget = _target.Rows.Count > 0 && (_target.PrimaryKey.Length > 0);
}
FeatureDataRow targetFeature = null;
if (checkForTarget && record.HasOid)
{
targetFeature = _target.Find(record.GetOid());
}
mergeFeature(_target, record, targetFeature, PreserveChanges);
}
IEnumerable IFeatureRenderer.RenderFeature(IFeatureDataRecord feature)
{
return(RenderFeature(feature));
}
private static void mergeFeature(FeatureDataTable target, IFeatureDataRecord srcFeature, FeatureDataRow targetFeature, bool preserveChanges)
{
if (targetFeature == null)
{
targetFeature = target.NewRow();
setFeatureRowFromIFeatureDataRecord(srcFeature, targetFeature);
target.AddRow(targetFeature);
}
else
{
if (preserveChanges && targetFeature.RowState == DataRowState.Modified)
{
throw new NotImplementedException("Merging updates to original features state not yet implemented.");
}
else
{
setFeatureRowFromIFeatureDataRecord(srcFeature, targetFeature);
}
}
}
IStyle ITheme.GetStyle(IFeatureDataRecord row)
{
if (!(row is FeatureDataRow))
{
throw new ArgumentException("Parameter 'row' must be of type FeatureDataRow");
}
return GetStyle(row as FeatureDataRow);
}
public ConvertData(IFeatureDataRecord source, int oidColumnIndex, IGeometryFactory geometryFactory)
: base(source, oidColumnIndex, geometryFactory)
{
}
public abstract bool Symbolize(IFeatureDataRecord obj, out TOutput output);
private IConvertData GetConverter(Type tsource, Type ttarget, IFeatureDataRecord sourcetable, int index, IGeometryFactory geometryFactory )
{
Type t = typeof(ConvertData<,>);
Type g = t.MakeGenericType(tsource, ttarget);
return (IConvertData)Activator.CreateInstance(g, sourcetable, index, geometryFactory);
}
protected override IEnumerable <TRenderObject> DoRenderFeature(IFeatureDataRecord inFeature,
LabelStyle style,
RenderState renderState,
ILayer inLayer)
{
FeatureDataRow feature = inFeature as FeatureDataRow;
LabelLayer layer = inLayer as LabelLayer;
if (style == null)
{
throw new ArgumentNullException("style", "LabelStyle is a required argument " +
"to properly render the label");
}
Label2D newLabel = null;
LabelLayer.LabelTextFormatter formatter = null;
LabelCollisionDetection2D collisionDetector;
if (layer != null)
{
if (!layer.RenderCache.TryGetValue(feature.GetOid(), out newLabel))
{
formatter = layer.TextFormatter;
}
collisionDetector = layer.CollisionDetector;
collisionDetector.TextRenderer = TextRenderer;
}
else
{
if (!textFormatters.TryGetValue(style, out formatter))
{
// setup formatter based on style.LabelFormatExpression
formatter = delegate(FeatureDataRow row)
{
return(row.Evaluate(style.LabelExpression));
};
textFormatters.Add(style, formatter);
}
if (!collisionDetectors.TryGetValue(style, out collisionDetector))
{
collisionDetector = new LabelCollisionDetection2D();
collisionDetector.TextRenderer = TextRenderer;
collisionDetectors.Add(style, collisionDetector);
}
}
if (newLabel == null)
{
String labelText = formatter.Invoke(feature);
if (feature.Geometry is ILineString)
{
newLabel = new Label2D(labelText, new Point2D(), style);
calculateLabelOnLineString(feature.Geometry as ILineString, ref newLabel);
}
else
{
ICoordinate p = feature.Geometry.Extents.Center;
Double x = p[Ordinates.X], y = p[Ordinates.Y];
/* Moved to RenderLabel function
* if (style.HorizontalAlignment != HorizontalAlignment.Right || style.VerticalAlignment != VerticalAlignment.Bottom)
* {
* Size2D size = TextRenderer.MeasureString(labelText, style.Font);
* //Point2D pt = RenderTransform.TransformVector(Math.Ceiling(size.Width), Math.Ceiling(size.Height));
* size = new Size2D(size.Width / (Double)RenderTransform[0,0], size.Height / (Double)RenderTransform[1,1]);
* switch (style.HorizontalAlignment)
* {
* case HorizontalAlignment.Center:
* x -= (Int32)(size.Width / 2.0f);
* break;
* case HorizontalAlignment.Left:
* x -= size.Width;
* break;
* default:
* break;
* }
*
* switch (style.VerticalAlignment)
* {
* case VerticalAlignment.Middle:
* y += (Int32)(size.Height / 2.0f);
* break;
* case VerticalAlignment.Top:
* y += size.Height;
* break;
* default:
* break;
* }
* }
*/
newLabel = new Label2D(labelText, new Point2D(x, y), style);
}
if (layer != null)
{
layer.RenderCache.Add(feature.GetOid(), newLabel);
}
}
// now find out if we even need to render this label...
if (style.CollisionDetectionType != CollisionDetectionType.None)
{
if (style.CollisionDetectionType == CollisionDetectionType.Simple)
{
if (collisionDetector.SimpleCollisionTest(newLabel))
{
// we are not going to render this label
if (layer != null)
{
layer.RenderCache.Remove(newLabel);
}
yield break;
}
}
else if (style.CollisionDetectionType == CollisionDetectionType.Advanced)
{
if (collisionDetector.AdvancedCollisionTest(newLabel))
{
// we are not going to render this label
if (layer != null)
{
layer.RenderCache.Remove(newLabel);
}
yield break;
}
}
}
foreach (TRenderObject ro in RenderLabel(newLabel))
{
yield return(ro);
}
}
