/// <summary>
/// Creates a new instance of CustomSymbolizer
/// </summary>
public CustomSymbolizer(IFeatureSymbolizer symbolizer, string uniqueName, string name, string categoryName)
{
_symbolizer = symbolizer;
_uniqueName = uniqueName;
_name = name;
_categoryName = categoryName;
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Creates a new instance of CustomSymbolizer
/// </summary>
public CustomSymbolizer(IFeatureSymbolizer symbolizer, string uniqueName, string name, string categoryName)
{
_symbolizer = symbolizer;
_uniqueName = uniqueName;
_name = name;
_categoryName = categoryName;
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Constructs a new instance of a custom symbolizer
/// </summary>
public CustomSymbolizer()
{
_symbolizer = new PointSymbolizer();
_uniqueName = "symbol 001";
_name = "symbol 001";
_categoryName = "default";
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Gets a string array of all available categories (groups) of custom predefined symbols
/// </summary>
public string[] GetAvailableCategories(SymbolizerType symbolType)
{
var query = (from item in _list
where item.SymbolType == symbolType
select item.Category).Distinct();
return query.ToArray();
}
/// <summary>
/// Constructs a new instance of a custom symbolizer
/// </summary>
public CustomSymbolizer()
{
_symbolizer = new PointSymbolizer();
_uniqueName = "symbol 001";
_name = "symbol 001";
_categoryName = "default";
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Gets a string array of all available categories (groups) of custom predefined symbols
/// </summary>
public string[] GetAvailableCategories(SymbolizerType symbolType)
{
var query = (from item in _list
where item.SymbolType == symbolType
select item.Category).Distinct();
return(query.ToArray());
}
public static RenderRule createDefaultRule(SymbolizerType symbolizertype)
{
switch (symbolizertype)
{
case SymbolizerType.POINT:
return(new RenderRule(null, pointsymbolizer.createDefaultpointsymbolizer(), new textsymbolizer()));
case SymbolizerType.LINE:
return(new RenderRule(null, linesymbolizer.createdefaultlinesymbolizer(), new textsymbolizer()));
case SymbolizerType.POLYGON:
return(new RenderRule(null, polygonsymbolizer.createdefalutpolygonsymbolizer(), new textsymbolizer()));
}
return(null);
}
public static Style createUniqueValueStyle(FeatureSource featuresource, string arrtributename)
{
//arrtributename = featuresource.schema.fields.Keys.First();//////????????????????????????????????????//
Schema schema = featuresource.schema;
SymbolizerType sign = SymbolizerType.POINT;
switch (schema.geometryType)
{
case OSGeo.OGR.wkbGeometryType.wkbPoint:
sign = SymbolizerType.POINT;
break;
case OSGeo.OGR.wkbGeometryType.wkbLineString:
sign = SymbolizerType.LINE;
break;
case OSGeo.OGR.wkbGeometryType.wkbPolygon:
sign = SymbolizerType.POLYGON;
break;
}
//获取attributename 所对应的所有不同属性值
HashSet <object> set = new HashSet <object>();
List <GisSmartTools.Data.Feature> featurelist = featuresource.features.featureList;
foreach (GisSmartTools.Data.Feature feature in featurelist)
{
set.Add(feature.GetArrtributeByName(arrtributename));
}
List <RenderRule> rulelist = new List <RenderRule>();
foreach (object value in set)
{
RenderRule rule = RenderRule.createDefaultRule(sign);
rule.filter = new Filter_Equals(arrtributename, value);
rulelist.Add(rule);
}
Style style = new Style("uniqueValueStyle", StyleType.UNIQUESTYLE, RenderRule.createDefaultRule(sign));
style.rulelist = rulelist;
return(style);
}
public static RenderRule createDefaultRule(SymbolizerType symbolizertype, Color color)
{
switch (symbolizertype)
{
case SymbolizerType.POINT:
pointsymbolizer pointsym = pointsymbolizer.createDefaultpointsymbolizer();
pointsym.color = color;
return(new RenderRule(null, pointsym, new textsymbolizer()));
case SymbolizerType.LINE:
linesymbolizer linesym = linesymbolizer.createdefaultlinesymbolizer();
linesym.color = color;
return(new RenderRule(null, linesym, new textsymbolizer()));
case SymbolizerType.POLYGON:
polygonsymbolizer polygonsym = polygonsymbolizer.createdefalutpolygonsymbolizer();
polygonsym.fillcolor = color;
//polygonsym.strokecolor = color;
polygonsym.strokecolor = Colors.Black;
return(new RenderRule(null, polygonsym, new textsymbolizer()));
}
return(null);
}
/// <summary>
/// Sets up the Table to work with the specified layer. This should be the copy,
/// and not the original.
/// </summary>
/// <param name="layer"></param>
public void Initialize(IFeatureLayer layer)
{
_original = layer.Symbology;
_newScheme = _original.Copy();
_source = layer.DataSet;
if (!layer.DataSet.AttributesPopulated)
{
if (layer.DataSet.NumRows() < 100000)
{
_source.FillAttributes(); // for small datasets, it is better to just load and cache it.
}
}
if (_source.AttributesPopulated)
{
_expressionDialog.Table = _source.DataTable;
}
else
{
_expressionDialog.AttributeSource = _source;
}
_schemeType = GetSchemeType(layer);
if (_schemeType != SymbolizerType.Polygon)
{
chkUseGradients.Visible = false;
angGradientAngle.Visible = false;
}
else
{
chkUseGradients.Visible = true;
angGradientAngle.Visible = true;
}
if (_schemeType == SymbolizerType.Point)
{
IPointScheme ps = _newScheme as IPointScheme;
if (ps != null)
{
IPointSymbolizer sym;
if (ps.Categories.Count == 0 || ps.Categories[0].Symbolizer == null)
{
sym = new PointSymbolizer();
}
else
{
sym = ps.Categories[0].Symbolizer;
}
_ignoreRefresh = true;
featureSizeRangeControl1.SizeRange = new FeatureSizeRange(sym, _newScheme.EditorSettings.StartSize, _newScheme.EditorSettings.EndSize);
featureSizeRangeControl1.Initialize(new SizeRangeEventArgs(_newScheme.EditorSettings.StartSize, _newScheme.EditorSettings.EndSize, sym, _newScheme.EditorSettings.UseSizeRange));
featureSizeRangeControl1.Scheme = ps;
featureSizeRangeControl1.Visible = true;
_ignoreRefresh = false;
}
}
else if (_schemeType == SymbolizerType.Line)
{
ILineScheme ls = _newScheme as ILineScheme;
if (ls != null)
{
ILineSymbolizer sym;
if (ls.Categories.Count == 0 || ls.Categories[0].Symbolizer == null)
{
sym = new LineSymbolizer();
}
else
{
sym = ls.Categories[0].Symbolizer;
}
_ignoreRefresh = true;
featureSizeRangeControl1.SizeRange = new FeatureSizeRange(sym, _newScheme.EditorSettings.StartSize, _newScheme.EditorSettings.EndSize);
featureSizeRangeControl1.Initialize(new SizeRangeEventArgs(_newScheme.EditorSettings.StartSize, _newScheme.EditorSettings.EndSize, sym, _newScheme.EditorSettings.UseSizeRange));
featureSizeRangeControl1.Scheme = ls;
featureSizeRangeControl1.Visible = true;
_ignoreRefresh = false;
}
}
else
{
featureSizeRangeControl1.Visible = false;
}
UpdateFields();
if (_newScheme.EditorSettings.ClassificationType != ClassificationType.Quantities) return;
nudCategoryCount.Enabled = true;
tabScheme.Visible = true;
dgvCategories.Height = 217;
UpdateStatistics(false, null);
}
public static Style createRankStyle(FeatureSource featuresource, string attributename, int num, Color startcolor, Color endcolor)
{
Schema schema = featuresource.schema;
SymbolizerType sign = SymbolizerType.POINT;
switch (schema.geometryType)
{
case OSGeo.OGR.wkbGeometryType.wkbPoint:
sign = SymbolizerType.POINT;
break;
case OSGeo.OGR.wkbGeometryType.wkbLineString:
sign = SymbolizerType.LINE;
break;
case OSGeo.OGR.wkbGeometryType.wkbPolygon:
sign = SymbolizerType.POLYGON;
break;
}
FieldDefn fielddefn = null;
if (schema.fields.TryGetValue(attributename, out fielddefn) || attributename.Equals("FeatureID"))
{
FieldType type = FieldType.OFTString;
if (!attributename.Equals("FeatureID"))
{
type = fielddefn.GetFieldType();
}
if (type == FieldType.OFTInteger || type == FieldType.OFTReal || attributename.Equals("FeatureID"))
{
double maxvalue = double.MinValue;
double minvalue = double.MaxValue;
foreach (GisSmartTools.Data.Feature feature in featuresource.features.featureList)
{
double value = 0;
if (type == FieldType.OFTInteger || attributename.Equals("FeatureID"))
{
value = (int)feature.GetArrtributeByName(attributename);
}
if (type == FieldType.OFTReal)
{
value = (double)feature.GetArrtributeByName(attributename);
}
if (value > maxvalue)
{
maxvalue = value;
}
if (value < minvalue)
{
minvalue = value;
}
}
if (num == 0)
{
return(null);
}
double x = (maxvalue - minvalue) / num;
//逐个创建对应的rule
Color[] colorarray = Utils.GetLinearColorList(startcolor, endcolor, num);
double temp_minvalue = minvalue;
double temp_maxvalue = minvalue + x;
List <RenderRule> rulelist = new List <RenderRule>();
// Printer.printnode("min=" + minvalue + " max=" + maxvalue, "");
for (int i = 0; i < num; i++)
{
RenderRule rule = RenderRule.createDefaultRule(sign, colorarray[i]);
Filter_Larger larger = new Filter_Larger(attributename, temp_minvalue);
Filter_Less less = new Filter_Less(attributename, temp_maxvalue);
List <Filter.Filter> filterlist = new List <Filter.Filter>();
filterlist.Add(larger); filterlist.Add(less);
Filter_And andfilter = new Filter_And(filterlist);
rule.filter = andfilter;
rulelist.Add(rule);
// Printer.printnode("temp_" + i, "min=" + temp_minvalue + " max=" + temp_maxvalue);
temp_minvalue += x; temp_maxvalue += x;
}
Style rankstyle = new Style("RankStyle", StyleType.RANKSTYLE, RenderRule.createDefaultRule(sign, startcolor));
rankstyle.rulelist = rulelist;
Printer.printnode("rulist,count=", "" + rulelist.Count);
return(rankstyle);
}
}
return(null);
}
