private void cboClassifyMethod_SelectedIndexChanged(object sender, EventArgs e)
{
IClassify classify;
if (this.bool_0)
{
classify = null;
switch (this.cboClassifyMethod.SelectedIndex)
{
case 0:
classify = new EqualIntervalClass();
goto Label_0043;
case 1:
classify = new QuantileClass();
goto Label_0043;
case 2:
classify = new NaturalBreaksClass();
goto Label_0043;
}
}
return;
Label_0043:
(this.iclassBreaksRenderer_0 as IClassBreaksUIProperties).Method = classify.ClassID;
if (this.cboClassifyNum.SelectedIndex >= 0)
{
this.method_3();
}
else
{
this.cboClassifyNum.SelectedIndex = 4;
}
}
/// <summary>
/// 专题图渲染（多级颜色）。参数为需要渲染的字段（数值类型）,分级数目
/// </summary>
/// <param name="layer"></param>
/// <param name="strField"></param>
/// <param name="numDesiredClasses"></param>
public static void ClassBreaksMap(IFeatureLayer layer, string strField, int numDesiredClasses)
{
double[] classes = { 147.744196, 213.149274, 506.677245, 742.234523, 1096.249126, 4864.483353 }; //断点值，两端分别是渲染字段的最小值和最大值
IEnumColors pEnumColors; //颜色带
Color startColor = Color.FromArgb(100, 100, 190, 150); //低值颜色
Color endColor = Color.FromArgb(30, 0, 200, 0); //高值颜色
IGeoFeatureLayer pGeoFeatureLayer;
ITable pTable;
IClassifyGEN pClassify;
ITableHistogram pTableHistogram;
IBasicHistogram pBasicHistogram;
object dataFrequency;
object dataValues;
int classesCount;
IClassBreaksRenderer pClassBreaksRenderer;
IColor pColor;
ISimpleFillSymbol pSimpleFillSymbol;
int breakIndex;
pGeoFeatureLayer = (IGeoFeatureLayer)layer;
pTable = (ITable)pGeoFeatureLayer.FeatureClass;
pTableHistogram = new BasicTableHistogramClass();
pBasicHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strField;
pTableHistogram.Table = pTable;
pBasicHistogram.GetHistogram(out dataValues, out dataFrequency);
pClassify = new EqualIntervalClass();
try
{
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
}
catch (Exception ee)
{
//MessageBox.Show(ee.Message);
}
//classes = (double[])pClassify.ClassBreaks;
//classes[0] = 147.744196;
//classes[1]=213.149274;
//classes[2]=506.677245;
//classes[3]=742.234523;
//classes[4]=1096.249126;
//classes[5] = 4864.483353;
classesCount = classes.GetUpperBound(0);
pClassBreaksRenderer = new ClassBreaksRendererClass();
pClassBreaksRenderer.Field = strField;
pClassBreaksRenderer.BreakCount = classesCount;
pClassBreaksRenderer.SortClassesAscending = true;
pEnumColors = ProduceEnumColors(startColor, endColor, classesCount);//产生色带
for (breakIndex = 0; breakIndex < classesCount; breakIndex++)
{
pColor = pEnumColors.Next();
pSimpleFillSymbol = new SimpleFillSymbolClass();
pSimpleFillSymbol.Color = pColor;
pSimpleFillSymbol.Style = esriSimpleFillStyle.esriSFSSolid;
pClassBreaksRenderer.set_Symbol(breakIndex, pSimpleFillSymbol as ISymbol);
pClassBreaksRenderer.set_Break(breakIndex, classes[breakIndex + 1]);
}
pGeoFeatureLayer.Renderer = (IFeatureRenderer)pClassBreaksRenderer;
MainFrom.m_mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
private void initialClassify()
{
if (layer2Symbolize == null)
{
return;
}
IFeatureClass featureClass = layer2Symbolize.FeatureClass;
ITable pTable = (ITable)featureClass;
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
{
pTableHistogram.NormField = strNormalizeField;
}
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
IClassifyGEN pClassify = null;
int numDesiredClasses = classCount;
pClassify = new EqualIntervalClass();
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
double[] clsbreaks = (double[])pClassify.ClassBreaks;
double dblInterval = clsbreaks[1] - clsbreaks[0];
txtInterval.Text = dblInterval.ToString();
}
/// <summary>
/// 设置分级算法
/// </summary>
/// <param name="classProperties">栅格分级渲染属性</param>
/// <param name="classMethod">分级算法</param>
private static void SetClassMethod(IRasterClassifyUIProperties classProperties, string classMethod)
{
//分级方法初始化
IClassifyGEN pClassifyGen;
//判断分级方法，以获取分段点
switch (classMethod)
{
case "Equal Interval":
pClassifyGen = new EqualIntervalClass();
break;
case "Natural Breaks":
pClassifyGen = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGen = new QuantileClass();
break;
case "Geometrical Interval":
pClassifyGen = new GeometricalIntervalClass();
break;
default:
pClassifyGen = new NaturalBreaksClass();
break;
}
//获取分级算法UID
classProperties.ClassificationMethod = pClassifyGen.ClassID;
}
private void btnClassiFy_Click(object sender, EventArgs e)
{
ITable pTable = this.pLayer as ITable;
object dataValues;
object dataFrequency;
//以下代码用TableHistogram和BasicHistogram统计出Table某一字段的值和值的频率
ITableHistogram pTableHistogram;
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Table = pTable; //需传入一个ITable
pTableHistogram.Field = this.cbbClassBreakField.Text; //统计的字段
IBasicHistogram pBasicHistogram;
pBasicHistogram = pTableHistogram as IBasicHistogram;
pBasicHistogram.GetHistogram(out dataValues, out dataFrequency);//关键
//以下代码用IClassifyGEN和EqualInterval对象,基于分段数目,生成各段的临界值,并放在一个数组当中
IClassifyGEN pClassifyGEN;
switch (this.cbbClassBreaksMethod.SelectedIndex)
{
case 0:
pClassifyGEN = new EqualIntervalClass();
break;
case 1:
pClassifyGEN = new GeometricalIntervalClass();
break;
case 2:
pClassifyGEN = new NaturalBreaksClass();
break;
case 3:
pClassifyGEN = new QuantileClass();
break;
default:
pClassifyGEN = new EqualIntervalClass();
break;
}
//double[] classes;
int classCount = int.Parse(this.cbbClassBreaksCount.Text);
pClassifyGEN.Classify(dataValues, dataFrequency, ref classCount); //用到了上面ITableHistogram生成的值和值频率数组,关键!!!!!!
this.classBreaks = pClassifyGEN.ClassBreaks as double[]; //注意,此对象下标从1开始(我觉得0为最开头,所以临界值从1开始有意义),关键!!!!!!
this.lsvClassBreaksSymbol.Items.Clear();
string currentRange;
for (int i = 0; i < classCount; i++)
{
currentRange = this.classBreaks[i].ToString() + " ～ " + this.classBreaks[i + 1].ToString();
this.lsvClassBreaksSymbol.Items.Add(currentRange);
this.lsvClassBreaksSymbol.Items[i].SubItems.Add(currentRange);
}
}
private void classify()
{
if (layer2Symbolize == null)
{
return;
}
IFeatureClass featureClass = layer2Symbolize.FeatureClass;
ITable pTable = (ITable)featureClass;
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
{
pTableHistogram.NormField = strNormalizeField;
}
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
//下面是分级方法，用于根据获得的值计算得出符合要求的数据
//根据条件计算出Classes和ClassesCount，numDesiredClasses为预定的分级数目
IClassifyGEN pClassify = new NaturalBreaksClass();
switch (strClassifyMethod)
{
case "等间隔分类":
pClassify = new EqualIntervalClass();
break;
//case "预定义间隔分类":
// pClassify = new DefinedIntervalClass();
// break;
case "分位数分类":
pClassify = new QuantileClass();
break;
case "自然裂点分类":
pClassify = new NaturalBreaksClass();
break;
case "标准差分类":
pClassify = new StandardDeviationClass();
break;
case "几何间隔分类":
pClassify = new GeometricalIntervalClass();
break;
default:
break;
}
int numDesiredClasses = gClassCount;
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
gClassbreaks = (double[])pClassify.ClassBreaks;
}
private double[] fnClassification(IFeatureLayer pFLayer, decimal NClasses, string strClassifiedField, string ClassifiedMethod)
{
try
{
IFeatureClass pFClass = pFLayer.FeatureClass;
//Create Rendering of Mean Value at Target Layer
int intBreakeCount = Convert.ToInt32(NClasses);
ITable pTable = (ITable)pFClass;
IClassifyGEN pClassifyGEN;
switch (ClassifiedMethod)
{
case "Equal Interval":
pClassifyGEN = new EqualIntervalClass();
break;
case "Geometrical Interval":
pClassifyGEN = new GeometricalInterval();
break;
case "Natural Breaks":
pClassifyGEN = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGEN = new QuantileClass();
break;
case "StandardDeviation":
pClassifyGEN = new StandardDeviationClass();
break;
default:
pClassifyGEN = new NaturalBreaksClass();
break;
}
//Need to be changed 1/29/15
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strClassifiedField;
pTableHistogram.Table = pTable;
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
object xVals, frqs;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intBreakeCount);
double[] cb = (double[])pClassifyGEN.ClassBreaks;
return(cb);
}
catch (Exception ex)
{
frmErrorLog pfrmErrorLog = new frmErrorLog(); pfrmErrorLog.ex = ex; pfrmErrorLog.ShowDialog();
return(null);
}
}
public static void classifyRender(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp)
{
try
{
IRasterBand band = GetBand(rastlayer);
if (band.Histogram == null)
{
band.ComputeStatsAndHist();
}
IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
rasRender.Raster = rastlayer.Raster;
rasRender.Update();
int numClasses = count;
IClassify classify = null;
switch (classMethod)
{
case "等间距分级":
classify = new EqualIntervalClass();
break;
case "自然断点分级":
classify = new NaturalBreaksClass();
break;
}
classify.Classify(ref numClasses);
double[] Classes = classify.ClassBreaks as double[];
UID pUid = classify.ClassID;
IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
rasClassifyUI.ClassificationMethod = pUid;
rasClassifyRender.ClassField = "Value";
rasClassifyRender.ClassCount = count;
rasRender.Update();
IColor pColor;
ISimpleFillSymbol pSym;
for (int j = 0; j < count; j++)
{
pColor = ramp.get_Color(j * (ramp.Size - 1) / (count - 1));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
rasClassifyRender.set_Break(j, rasClassifyRender.get_Break(j));
}
rasRender.Update();
rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
}
catch
{
XtraMessageBox.Show("唯一值数量已达到限制（65536）");
}
}
private void mnuClassBreak_Click(object sender, EventArgs e)
{
ILayer pLayer = MainMap.get_Layer(0);
ITable pTable = pLayer as ITable;
IGeoFeatureLayer pGeoFeatureLayer = pLayer as IGeoFeatureLayer;
int classCount = 6;
ITableHistogram pTableHistogram;
IBasicHistogram pBasicHistogram;
pTableHistogram = new BasicTableHistogramClass();
//按照 数值字段分级
pTableHistogram.Table = pTable;
pTableHistogram.Field = "AREA";
pBasicHistogram = pTableHistogram as IBasicHistogram;
object values;
object frequencys;
//先统计每个值和各个值出现的次数
pBasicHistogram.GetHistogram(out values, out frequencys);
//创建等间距分级对象
IClassifyGEN classifyGEN = new EqualIntervalClass();
//用统计结果进行分级 ，级别数目为classCount
classifyGEN.Classify(values, frequencys, ref classCount);
//获得分级结果,是个 双精度类型数组
double[] classes;
classes = classifyGEN.ClassBreaks as double[];
IEnumColors enumColors = CreateAlgorithmicColorRamp(classes.Length).Colors;
IColor pColor;
IClassBreaksRenderer pClassBreaksRenderer = new ClassBreaksRendererClass();
pClassBreaksRenderer.Field = "AREA";
pClassBreaksRenderer.BreakCount = classCount;
pClassBreaksRenderer.SortClassesAscending = true;
ISimpleFillSymbol simpleFillSymbol;
for (int i = 0; i < classes.Length - 1; i++)
{
pColor = enumColors.Next();
simpleFillSymbol = new SimpleFillSymbolClass();
simpleFillSymbol.Color = pColor;
simpleFillSymbol.Style = esriSimpleFillStyle.esriSFSSolid;
pClassBreaksRenderer.set_Symbol(i, simpleFillSymbol as ISymbol);
pClassBreaksRenderer.set_Break(i, classes[i + 1]);
}
pGeoFeatureLayer.Renderer = pClassBreaksRenderer as IFeatureRenderer;
MainMap.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
public static void classifyRender(IFeatureLayer featLayer, string classMethod, string fieldName, IColorRamp colorRamp, int count)
{
try
{
//值分级
IBasicHistogram pBasicHis = new BasicTableHistogramClass();
ITableHistogram pTabHis = (ITableHistogram)pBasicHis;
IClassifyGEN pClassify = null;
switch (classMethod)
{
case "等间距分级":
pClassify = new EqualIntervalClass();
break;
case "自然断点分级":
pClassify = new NaturalBreaksClass();
break;
}
pTabHis.Field = fieldName;
ILayer Layer = (ILayer)featLayer;
ITable pTab = (ITable)Layer;
pTabHis.Table = pTab;
object doubleArrVal, longArrFreq;
pBasicHis.GetHistogram(out doubleArrVal, out longArrFreq);
int nDes = count;
pClassify.Classify(doubleArrVal, longArrFreq, ref nDes);
double[] ClassNum;
ClassNum = (double[])pClassify.ClassBreaks;
int ClassCountResult = ClassNum.GetUpperBound(0);
IClassBreaksRenderer pRender = new ClassBreaksRendererClass();
pRender.BreakCount = ClassCountResult;
pRender.Field = fieldName;
ISimpleFillSymbol pSym;
IColor pColor;
for (int j = 0; j < ClassCountResult; j++)
{
pColor = colorRamp.get_Color(j * (colorRamp.Size - 1) / (ClassCountResult - 1));
pRender.set_Symbol(j, getISymbolByGeomType(featLayer, pColor));
pRender.set_Break(j, ClassNum[j + 1]);
pRender.set_Label(j, ClassNum[j].ToString("0.00") + " - " + ClassNum[j + 1].ToString("0.00"));
}
IGeoFeatureLayer pGeoLyr = (IGeoFeatureLayer)Layer;
pGeoLyr.Renderer = (IFeatureRenderer)pRender;
}
catch {
XtraMessageBox.Show("嗯，哪个，就一个值，别分级了好不好^_^");
}
}
private void classify()
{
if (layer2Symbolize == null)
{
return;
}
IFeatureClass featureClass = layer2Symbolize.FeatureClass;
ITable pTable = featureClass as ITable;
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = pTableHistogram as IBasicHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
{
pTableHistogram.NormField = strNormalizeField;
}
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
IClassifyGEN pClassify = new NaturalBreaksClass();
switch (strClassifyMethod)
{
case "Equal Interval":
pClassify = new EqualIntervalClass();
break;
case "Quantile":
pClassify = new QuantileClass();
break;
case "Natural Breaks":
pClassify = new NaturalBreaksClass();
break;
case "Geometrical Interval":
pClassify = new GeometricalIntervalClass();
break;
default:
break;
}
int numDesiredClass = gClassCount;
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClass);
gClassbreaks = (double[])pClassify.ClassBreaks;
}
private void cboClassifyMethod_SelectedIndexChanged(object sender, EventArgs e)
{
IClassify classify;
if (this.bool_0)
{
classify = null;
switch (this.cboClassifyMethod.SelectedIndex)
{
case 0:
(this.itinColorRampRenderer_0 as IClassBreaksUIProperties).Method = new UIDClass();
this.cboClassifyNum.Enabled = false;
break;
case 1:
classify = new EqualIntervalClass();
goto Label_006D;
case 2:
classify = new QuantileClass();
goto Label_006D;
case 3:
classify = new NaturalBreaksClass();
goto Label_006D;
}
}
return;
Label_006D:
this.cboClassifyNum.Enabled = true;
(this.itinColorRampRenderer_0 as IClassBreaksUIProperties).Method = classify.ClassID;
if (this.cboClassifyNum.SelectedIndex >= 0)
{
this.method_4();
}
else
{
this.cboClassifyNum.SelectedIndex = 4;
}
}
private void method_1(int int_0)
{
IClassify classify;
switch (int_0)
{
case 0:
this.itinRenderer_0 = new TinBreaklineRendererClass();
this.itinRenderer_0.Tin = this.itin_0;
break;
case 1:
this.itinRenderer_0 = new TinEdgeRendererClass();
this.itinRenderer_0.Tin = this.itin_0;
break;
case 2:
this.itinRenderer_0 = new TinAspectRendererClass();
this.itinRenderer_0.Tin = this.itin_0;
break;
case 3:
this.itinRenderer_0 = new TinElevationRendererClass();
classify = new EqualIntervalClass();
(this.itinRenderer_0 as IClassBreaksUIProperties).Method = classify.ClassID;
this.itinRenderer_0.Tin = this.itin_0;
this.method_0(classify, this.itinRenderer_0 as ITinColorRampRenderer, 10, this.itin_0);
break;
case 4:
this.itinRenderer_0 = new TinSlopeRendererClass();
classify = new EqualIntervalClass();
(this.itinRenderer_0 as IClassBreaksUIProperties).Method = classify.ClassID;
this.itinRenderer_0.Tin = this.itin_0;
break;
case 5:
if (this.itin_0.HasTriangleTagValues)
{
this.itinRenderer_0 = new TinFaceValueRendererClass();
this.itinRenderer_0.Tin = this.itin_0;
break;
}
MessageBox.Show("无面标签值，该渲染不能入");
return;
case 6:
this.itinRenderer_0 = new TinFaceRendererClass();
break;
case 7:
this.itinRenderer_0 = new TinNodeElevationRendererClass();
classify = new EqualIntervalClass();
(this.itinRenderer_0 as IClassBreaksUIProperties).Method = classify.ClassID;
this.itinRenderer_0.Tin = this.itin_0;
this.method_0(classify, this.itinRenderer_0 as ITinColorRampRenderer, 10, this.itin_0);
break;
case 8:
if (this.itin_0.HasNodeTagValues)
{
this.itinRenderer_0 = new TinNodeValueRendererClass();
this.itinRenderer_0.Tin = this.itin_0;
break;
}
MessageBox.Show("无节点标签值，该渲染不能入");
return;
case 9:
this.itinRenderer_0 = new TinNodeRendererClass();
this.itinRenderer_0.Tin = this.itin_0;
break;
default:
return;
}
if (this.OnAddTinRender != null)
{
this.OnAddTinRender(this.itinRenderer_0);
}
}
public void GraduatedColors(IFeatureLayer pfeatLyr, string sFieldName, int numclasses)
{
IGeoFeatureLayer pGeoFeatureL = pfeatLyr as IGeoFeatureLayer;
object dataFrequency;
object dataValues;
bool ok;
int breakIndex;
ITable pTable = pGeoFeatureL.FeatureClass as ITable;//各个字段变成一个表
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pBasicHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = sFieldName;
pTableHistogram.Table = pTable;
pBasicHistogram.GetHistogram(out dataValues, out dataFrequency);//获取渲染值及其出现的频率
IClassifyGEN pClassify = new EqualIntervalClass();
pClassify.Classify(dataValues, dataFrequency, ref numclasses);//进行等级划分
double[] Classes = pClassify.ClassBreaks as double[];
int classescount = Classes.GetUpperBound(0);
IClassBreaksRenderer pClassBreaksRenderer = new ClassBreaksRendererClass();
pClassBreaksRenderer.Field = sFieldName; //分段字段
pClassBreaksRenderer.BreakCount = classescount; //设置分级数目
pClassBreaksRenderer.SortClassesAscending = true; //分机后的图例是否按升级顺序排列
//分级颜色带的开始颜色和结束颜色（即分级颜色在此范围内）
IHsvColor pFromColor = new HsvColorClass(); //起始颜色
pFromColor.Hue = 0; //黄色
pFromColor.Saturation = 50;
pFromColor.Value = 96;
IHsvColor ptocolor = new HsvColorClass(); //终止颜色
ptocolor.Hue = 80; //不知道什么颜色
ptocolor.Saturation = 100;
ptocolor.Value = 96;
//产生颜色带对象
IAlgorithmicColorRamp pAlgorithmicColorRamp = new AlgorithmicColorRampClass();
pAlgorithmicColorRamp.Algorithm = esriColorRampAlgorithm.esriHSVAlgorithm;
pAlgorithmicColorRamp.FromColor = pFromColor;
pAlgorithmicColorRamp.ToColor = ptocolor;
pAlgorithmicColorRamp.Size = classescount;
pAlgorithmicColorRamp.CreateRamp(out ok);
//获得颜色
IEnumColors pEnumColors = pAlgorithmicColorRamp.Colors;
//symbol和break下标从0开始
for (breakIndex = 0; breakIndex <= classescount - 1; breakIndex++)
{
IColor pColor = pEnumColors.Next();
switch (pGeoFeatureL.FeatureClass.ShapeType)
{
case esriGeometryType.esriGeometryPolygon:
{
ISimpleFillSymbol pSimpleFills = new SimpleFillSymbolClass();
pSimpleFills.Color = pColor;
pSimpleFills.Style = esriSimpleFillStyle.esriSFSSolid;
pClassBreaksRenderer.set_Symbol(breakIndex, (ISymbol)pSimpleFills); //设置填充符号
pClassBreaksRenderer.set_Break(breakIndex, Classes[breakIndex + 1]); //设定每一分级的分级断点
break;
}
case esriGeometryType.esriGeometryPolyline:
{
ISimpleLineSymbol pSimplelines = new SimpleLineSymbolClass();
pSimplelines.Color = pColor;
pClassBreaksRenderer.set_Symbol(breakIndex, (ISymbol)pSimplelines); //设置填充符号
pClassBreaksRenderer.set_Break(breakIndex, Classes[breakIndex + 1]); //设定每一分级的分级断点
break;
}
case esriGeometryType.esriGeometryPoint:
{
ISimpleMarkerSymbol pSimplemaker = new SimpleMarkerSymbolClass();
pSimplemaker.Color = pColor;
pClassBreaksRenderer.set_Symbol(breakIndex, (ISymbol)pSimplemaker); //设置填充符号
pClassBreaksRenderer.set_Break(breakIndex, Classes[breakIndex + 1]); //设定每一分级的分级断点
break;
}
}
}
pGeoFeatureL.Renderer = (IFeatureRenderer)pClassBreaksRenderer;
axMapControl1.Refresh();
axTOCControl1.Update();
}
/// <summary>
/// 分级色彩渲染
/// </summary>
/// <param name="pMapControl"></param>
/// <param name="pFtLayer"></param>
/// <param name="ClassCount"></param>
/// <param name="pFieldName"></param>
public static void ClassRender(IActiveView activeView, IFeatureLayer pFtLayer, int ClassCount, string pFieldName)
{
IGeoFeatureLayer pGeolayer;
IActiveView pActiveView;
pGeolayer = pFtLayer as IGeoFeatureLayer;
//以下是为了统计和分类所需要的对象 ITable pTable;
IClassifyGEN pClassify; //C\#要作为分类对象。
ITableHistogram pTableHist; //相当于一个统计表
IBasicHistogram pBasicHist; //这个对象有一个很重要的方法
double[] ClassNum = new double[6];
int ClassCountResult; //返回分类个数。 IHsvColor pFromColor;
IRgbColor pToColor; //用于构建另外一个颜色带对象。 IAlgorithmicColorRamp pAlgo;
ITable pTable = pGeolayer as ITable;
pBasicHist = new BasicTableHistogramClass(); //也可以实例化pTableHist
pTableHist = pBasicHist as ITableHistogram;
pTableHist.Table = pTable;
pTableHist.Field = pFieldName;
object datavalus;
object Frenquen;
pBasicHist.GetHistogram(out datavalus, out Frenquen); //获得数据和相应的频数。
pClassify = new EqualIntervalClass();
try
{
pClassify.Classify(datavalus, Frenquen, ref ClassCount);
} catch (Exception e)
{
MessageBox.Show(e.Message);
}
// 分类完成
//ClassNum = (double[])pClassify.ClassBreaks;\
ClassNum[0] = 10.0;
ClassNum[1] = 50.0;
ClassNum[2] = 100.0;
ClassNum[3] = 1000.0;
ClassNum[4] = 10000.0;
ClassNum[5] = 80000.0;
ClassCountResult = ClassNum.GetUpperBound(0); //返回分级个数。
IClassBreaksRenderer pClassBreak;
pClassBreak = new ClassBreaksRendererClass();
pClassBreak.Field = pFieldName;
pClassBreak.BreakCount = ClassCountResult;
pClassBreak.SortClassesAscending = true;
IAlgorithmicColorRamp pAlgo = new AlgorithmicColorRampClass();
pAlgo.Algorithm = esriColorRampAlgorithm.esriHSVAlgorithm;
IColor pFromColor = GetRgbColor(255, 240, 240);
pToColor = GetRgbColor(255, 0, 0);
pAlgo.FromColor = pFromColor;
pAlgo.ToColor = pToColor;
pAlgo.Size = ClassCountResult;
bool ok;
pAlgo.CreateRamp(out ok);
IEnumColors pEnumColor;
pEnumColor = pAlgo.Colors;
pEnumColor.Reset();
IColor pColor;
ISimpleFillSymbol pSimFill;
for (int indexColor = 0; indexColor <= ClassCountResult - 1; indexColor++)
{
pColor = pEnumColor.Next();
pSimFill = new SimpleFillSymbolClass();
pSimFill.Color = pColor;
// pSimFill.Color = pRgbColor[indexColor ];
pSimFill.Style = esriSimpleFillStyle.esriSFSSolid;
//染色
pClassBreak.set_Symbol(indexColor, pSimFill as ISymbol);
pClassBreak.set_Break(indexColor, ClassNum[indexColor + 1]);
}
pGeolayer.Renderer = pClassBreak as IFeatureRenderer;
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
private void btnClassBreakRender_Click(object sender, EventArgs e)
{
//先用一个ITableHistogram对象从一个要素类获取某一字段的所有值及频率,即dataValues和dataFrequency,这两个数组是分组的基本数据
//取得两个数组后,系统用IClassGEN对象对它们进行分级,得到classes及classCount,前者是分级临界点值的数组,后者为分级数目
//根据得到的分级数目和颜色带对象,可以分别设置ClassBreakRender对象的不同符号,产生不同的效果
IGeoFeatureLayer pGeoFeatLyr;
ITable pTable;
object dataValues;
object dataFrequency;
string strOutput;
pGeoFeatLyr = this.mainMapControl.get_Layer(0) as IGeoFeatureLayer;
pTable = pGeoFeatLyr as ITable;
//以下代码用TableHistogram和BasicHistogram统计出Table某一字段的值和值的频率
ITableHistogram pTableHistogram;
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Table = pTable;//需传入一个ITable
pTableHistogram.Field = "GDP_1999（";//统计的字段
IBasicHistogram pBasicHistogram;
pBasicHistogram = pTableHistogram as IBasicHistogram;
pBasicHistogram.GetHistogram(out dataValues, out dataFrequency);//关键
//以下代码用IClassifyGEN和EqualInterval对象,基于分段数目,生成各段的临界值,并放在一个数组当中
IClassifyGEN pClassifyGen = new EqualIntervalClass();
double[] classes;
int classCount = 5;
pClassifyGen.Classify(dataValues, dataFrequency, ref classCount);//用到了上面ITableHistogram生成的值和值频率数组,关键!!!!!!
classes = pClassifyGen.ClassBreaks as double[];//注意,此对象下标从1开始(我觉得0为最开头,所以临界值从1开始有意义),关键!!!!!!
//classCount = classes.Length; 此处应该为6
//for (int i = 0; i < classes.Length; i++)
//{
// MessageBox.Show(classes[i].ToString());
//}
//MessageBox.Show(classCount.ToString());
IClassBreaksRenderer pClassBreakRenderer = new ClassBreaksRendererClass();//设置分段着色属性
pClassBreakRenderer.Field = "GDP_1999（";
pClassBreakRenderer.BreakCount = 5;//分成5段
pClassBreakRenderer.SortClassesAscending = true;
//以下代码生成颜色带
IHsvColor pFromColor = getHsvColor(60, 100, 96);
IHsvColor pToColor = getHsvColor(0, 100, 96);
IAlgorithmicColorRamp pColorRamp = new AlgorithmicColorRampClass();
pColorRamp.FromColor = pFromColor as IColor;
pColorRamp.ToColor = pToColor as IColor;
pColorRamp.Size = classCount;//生成颜色的数目
//MessageBox.Show(classCount.ToString());
bool ok;
pColorRamp.CreateRamp(out ok);//创建颜色带,关键!!!
if (ok)//如果颜色带成功生成的话
{
IEnumColors pEnumColors = pColorRamp.Colors;//存放生成颜色带的各颜色
pEnumColors.Reset();//是必须吗?????关键!!!
IColor pColor;
ISimpleFillSymbol pSimpleFillSymbol;
//ISimpleMarkerSymbol pSimpleMarkerSymbol;
for (int i = 0; i < classCount; i++)//为每个值范围设置符号(此处为SimpleFillSymbol)
{
pColor = pEnumColors.Next();
pSimpleFillSymbol = new SimpleFillSymbolClass();
pSimpleFillSymbol.Color = pColor;
pSimpleFillSymbol.Style = esriSimpleFillStyle.esriSFSSolid;
//pSimpleMarkerSymbol = new SimpleMarkerSymbolClass();
//pSimpleMarkerSymbol.Color = pColor;
pClassBreakRenderer.set_Symbol(i, (ISymbol)pSimpleFillSymbol);//设置Symbol,关键!!!
pClassBreakRenderer.set_Break(i, classes[i + 1]);//设置临界值,注意下标,关键!!!
}
pGeoFeatLyr.Renderer = pClassBreakRenderer as IFeatureRenderer;
this.mainMapControl.Refresh(esriViewDrawPhase.esriViewGeography, null, null);
//this.axTOCControl.SetBuddyControl(this.mainMapControl.Object);
this.axTOCControl.Update();
}
}
private void DrawingChoroplethmap(IFeatureLayer pFLayer, string strRenderField, decimal NClasses)
{
IFeatureClass pFClass = pFLayer.FeatureClass;
//Create Rendering of Mean Value at Target Layer
int intGCBreakeCount = Convert.ToInt32(NClasses);
IGeoFeatureLayer pGeofeatureLayer;
IFeatureLayer pflOutput = new FeatureLayerClass();
pflOutput.FeatureClass = pFClass;
pflOutput.Name = strRenderField;
pflOutput.Visible = true;
pGeofeatureLayer = (IGeoFeatureLayer)pflOutput;
ITable pTable = (ITable)pFClass;
IClassifyGEN pClassifyGEN;
switch (cboGCClassify.Text)
{
case "Equal Interval":
pClassifyGEN = new EqualIntervalClass();
break;
case "Geometrical Interval":
pClassifyGEN = new GeometricalInterval();
break;
case "Natural Breaks":
pClassifyGEN = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGEN = new QuantileClass();
break;
case "StandardDeviation":
pClassifyGEN = new StandardDeviationClass();
break;
default:
pClassifyGEN = new NaturalBreaksClass();
break;
}
ITableHistogram pTableHistogram = new TableHistogramClass();
pTableHistogram.Field = strRenderField;
pTableHistogram.Table = pTable;
IHistogram pHistogram = (IHistogram)pTableHistogram;
object xVals, frqs;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intGCBreakeCount);
ClassBreaksRenderer pRender = new ClassBreaksRenderer();
double[] cb = (double[])pClassifyGEN.ClassBreaks;
pRender.Field = strRenderField;
pRender.BreakCount = intGCBreakeCount;
pRender.MinimumBreak = cb[0];
string strColorRamp = cboColorRamp.Text;
IEnumColors pEnumColors = MultiPartColorRamp(strColorRamp, intGCBreakeCount);
pEnumColors.Reset();
IRgbColor pColorOutline = new RgbColor();
//Can Change the color in here!
pColorOutline.Red = picGCLineColor.BackColor.R;
pColorOutline.Green = picGCLineColor.BackColor.G;
pColorOutline.Blue = picGCLineColor.BackColor.B;
double dblGCOutlineSize = Convert.ToDouble(nudGCLinewidth.Value);
ICartographicLineSymbol pOutLines = new CartographicLineSymbol();
pOutLines.Width = dblGCOutlineSize;
pOutLines.Color = (IColor)pColorOutline;
//' use this interface to set dialog properties
IClassBreaksUIProperties pUIProperties = (IClassBreaksUIProperties)pRender;
pUIProperties.ColorRamp = "Custom";
ISimpleFillSymbol pSimpleFillSym;
//' be careful, indices are different for the diff lists
for (int j = 0; j < intGCBreakeCount; j++)
{
pRender.Break[j] = cb[j + 1];
pRender.Label[j] = Math.Round(cb[j], 2).ToString() + " - " + Math.Round(cb[j + 1], 2).ToString();
pUIProperties.LowBreak[j] = cb[j];
pSimpleFillSym = new SimpleFillSymbolClass();
pSimpleFillSym.Color = pEnumColors.Next();
pSimpleFillSym.Outline = pOutLines;
pRender.Symbol[j] = (ISymbol)pSimpleFillSym;
}
pGeofeatureLayer.Renderer = (IFeatureRenderer)pRender;
mForm.axMapControl1.ActiveView.FocusMap.AddLayer(pGeofeatureLayer);
}
//public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp,double minValue)
//{
// IRasterBand band = GetBand(rastlayer);
// if (band.Histogram == null)
// {
// band.ComputeStatsAndHist();
// }
// IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
// IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
// rasRender.Raster = rastlayer.Raster;
// rasRender.Update();
// int numClasses = count;
// IRasterHistogram pRasterHistogram = band.Histogram;
// double[] dblValues = pRasterHistogram.Counts as double[];
// int intValueCount = dblValues.GetUpperBound(0) + 1;
// double[] vValues = new double[intValueCount];
// IRasterStatistics pRasterStatistic = band.Statistics;
// //double dMaxValue = pRasterStatistic.Maximum;
// double dMaxValue = minValue;
// double dMinValue = pRasterStatistic.Minimum;
// double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
// for (int i = 0; i < intValueCount; i++)
// {
// vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
// }
// long[] longvalues = new long[dblValues.Length];
// for (int i = 0; i <= dblValues.Length - 1; i++)
// {
// longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
// }
// //IClassifyGEN classify = null;
// IClassify classify = null;
// switch (classMethod)
// {
// case "等间距分级":
// EqualInterval eqclassify = new EqualIntervalClass();
// eqclassify.Classify(vValues, longvalues, ref numClasses);
// classify = eqclassify as IClassify;
// break;
// case "自然断点分级":
// NaturalBreaks naclassify = new NaturalBreaksClass();
// naclassify.Classify(vValues, longvalues, ref numClasses);
// classify = naclassify as IClassify;
// break;
// }
// //switch (classMethod)
// //{
// // case "等间距分级":
// // classify = new EqualIntervalClass();
// // break;
// // case "自然断点分级":
// // classify = new NaturalBreaksClass();
// // break;
// //}
// //classify.Classify(vValues, longvalues, ref numClasses);
// double[] Classes = classify.ClassBreaks as double[];
// UID pUid = classify.ClassID;
// IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
// rasClassifyUI.ClassificationMethod = pUid;
// rasClassifyRender.ClassCount = count;
// IColor pColor;
// ISimpleFillSymbol pSym;
// for (int j = 0; j < count; j++)
// {
// pColor = ramp.get_Color(j * (ramp.Size / count));
// pSym = new SimpleFillSymbolClass();
// pSym.Color = pColor;
// rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
// rasRender.Update();
// if (Classes[j] == 0)
// {
// rasClassifyRender.set_Label(j, Classes[j].ToString() + "-" + Classes[j + 1].ToString("0.000"));
// rasRender.Update();
// }
// else
// {
// rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
// rasRender.Update();
// }
// }
// rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp)
{
try
{ //进行唯一值判断
IUniqueValues values = new UniqueValuesClass();
IRasterCalcUniqueValues unique = new RasterCalcUniqueValuesClass();
unique.AddFromRaster(rastlayer.Raster, 0, values);
int uniquecount = values.get_UniqueCount(0);
//计算统计图
IRasterBand band = GetBand(rastlayer);
if (band.Histogram == null)
{
band.ComputeStatsAndHist();
}
IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
rasRender.Raster = rastlayer.Raster;
rasRender.Update();
int numClasses = count;
IRasterHistogram pRasterHistogram = band.Histogram;
double[] dblValues = pRasterHistogram.Counts as double[];
int intValueCount = dblValues.GetUpperBound(0) + 1;
double[] vValues = new double[intValueCount];
IRasterStatistics pRasterStatistic = band.Statistics;
double dMaxValue = pRasterStatistic.Maximum;
double dMinValue = pRasterStatistic.Minimum;
if (dMinValue == 0)
{
pRasterStatistic.IgnoredValues = pRasterStatistic.Minimum;
pRasterStatistic.Recalculate();
dMinValue = pRasterStatistic.Minimum;
}
double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
for (int i = 0; i < intValueCount; i++)
{
vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
}
long[] longvalues = new long[dblValues.Length];
for (int i = 0; i <= dblValues.Length - 1; i++)
{
longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
}
//IClassifyGEN classify = null;
IClassify classify = null;
switch (classMethod)
{
case "等间距分级":
EqualInterval eqclassify = new EqualIntervalClass();
eqclassify.Classify(vValues, longvalues, ref numClasses);
classify = eqclassify as IClassify;
break;
case "自然断点分级":
NaturalBreaks naclassify = new NaturalBreaksClass();
naclassify.Classify(vValues, longvalues, ref numClasses);
classify = naclassify as IClassify;
break;
}
#region
//switch (classMethod)
//{
// case "等间距分级":
// classify = new EqualIntervalClass();
// break;
// case "自然断点分级":
// classify = new NaturalBreaksClass();
// break;
//}
//classify.Classify(vValues, longvalues, ref numClasses);
#endregion
double[] Classes = classify.ClassBreaks as double[];
UID pUid = classify.ClassID;
IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
rasClassifyUI.ClassificationMethod = pUid;
rasClassifyRender.ClassCount = count;
IColor pColor;
ISimpleFillSymbol pSym;
//排除数值
double[] exdouble = new double[2] { 0, Classes[0] };
IRasterDataExclusion ex = rasClassifyRender as IRasterDataExclusion;
ex.ExcludeValues = exdouble;
ex.ExcludeColor = GET(255, 255, 255);
for (int j = 0; j < count; j++)
{
pColor = ramp.get_Color(j * (ramp.Size / count));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
rasRender.Update();
rasClassifyRender.set_Break(j, rasClassifyRender.get_Break(j));
rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
rasRender.Update();
}
//IRasterProps rasterProps = (IRasterProps)rastlayer.Raster;
//rasterProps.NoDataValue = 0;
//IRasterDisplayProps props = rasClassifyRender as IRasterDisplayProps;
//props.NoDataColor = GET(255, 255, 255);
//rasRender.Update();
rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
}
catch(Exception ex)
{
//MessageBox.Show(ex.ToString());
if (ex.ToString().Contains("唯一值过多"))
{
MessageBox.Show("唯一值数量已达到限制（65536）");
}
else
{
MessageBox.Show("还未计算唯一值，进行唯一值计算！");
}
}
//catch
//{
// MessageBox.Show("数据需要先计算统计值，请点击确定进行计算！");
//}
}
private void button5_Click(object sender, EventArgs e)
{
//先用TableHistogram统计，然后用某种实现IClassifyGEN的类来分类（classify），然后用ClassBreaksRenderer设置每个级别的渲染方式
//SetBreak()的参数是该分类的下标，该分类的值上限
ITable table = m_pTarFeatureLayer as ITable;
ITableHistogram tableHistogram = new BasicTableHistogramClass();
IBasicHistogram basicHistogram = tableHistogram as IBasicHistogram;
int curFieldIndex = m_pTarFeatureLayer.FeatureClass.Fields.FindField(comboBox1.SelectedItem.ToString());
IField curField = m_pTarFeatureLayer.FeatureClass.Fields.get_Field(curFieldIndex);
tableHistogram.Table = table;
tableHistogram.Field = curField.Name;
basicHistogram.GetHistogram(out object v, out object f);
IClassifyGEN clyGen = new EqualIntervalClass();
clyGen.Classify(v, f, trackBar2.Value);
double[] classes = clyGen.ClassBreaks as double[];
int classCount = classes.GetUpperBound(0);
IClassBreaksRenderer cbr = new ClassBreaksRendererClass
{
Field = curField.Name,
BreakCount = classCount
};
IAlgorithmicColorRamp acr = new AlgorithmicColorRampClass
{
FromColor = m_pFillColor,
ToColor = m_pOutlineColor,
Size = classCount
};
acr.CreateRamp(out _);
IEnumColors enumC = acr.Colors;
IColor curColor = enumC.Next();
for (int i = 0; i < classCount; i++)
{
switch (m_pTarFeatureLayer.FeatureClass.ShapeType)
{
case esriGeometryType.esriGeometryPolygon:
{
ISimpleFillSymbol sfs = new SimpleFillSymbolClass
{
Color = curColor
};
cbr.set_Symbol(i, sfs as ISymbol);
cbr.set_Break(i, classes[i + 1]);
break;
}
case esriGeometryType.esriGeometryPolyline:
{
ISimpleLineSymbol sls = new SimpleLineSymbolClass();
sls.Color = curColor;
sls.Style = esriSimpleLineStyle.esriSLSSolid;
cbr.set_Symbol(i, sls as ISymbol);
cbr.set_Break(i, classes[i + 1]);
break;
}
}
curColor = enumC.Next();
}
m_pTarGeoFeatureLayer.Renderer = cbr as IFeatureRenderer;
frmMainOper(OperationType.RefreshMapCtrl);
frmMainOper(OperationType.UpdateTOCCtrl);
}
private void getBreaksValues(ClassifyMethodName ClassifyMethod,ILayer layer,string fieldName,double intervl,bool bfeuq)
{
ITableHistogram tableHistogram = new BasicTableHistogramClass();
tableHistogram.Table = ((IDisplayTable)layer).DisplayTable;
tableHistogram.Field = fieldName;
object valueArray = null, freq = null;
IBasicHistogram basicHistogram = (IBasicHistogram)tableHistogram;
basicHistogram.GetHistogram(out valueArray, out freq);
IClassify classify = null;
int breakNum = (int)intervl;
//�����
switch (ClassifyMethod)
{
case ClassifyMethodName.EqualInterval:
{
EqualIntervalClass eq = new EqualIntervalClass();
eq.Classify(valueArray, freq, ref breakNum);
classify = (IClassify)eq;
break;
}
case ClassifyMethodName.StandardDeviation:
{
StandardDeviationClass sd = new StandardDeviationClass();
IStatisticsResults stat = basicHistogram as IStatisticsResults;
classify = sd as IClassify;
classify.SetHistogramData(valueArray, freq);
IDeviationInterval di = sd as IDeviationInterval;
di.DeviationInterval = 1;
di.Mean = stat.Mean;
di.StandardDev = stat.StandardDeviation;
classify.Classify(ref breakNum);
break;
}
case ClassifyMethodName.Quantile:
{
Quantile qc = new QuantileClass();
qc.Classify(valueArray, freq, ref breakNum);
classify = qc as IClassify;
break;
}
case ClassifyMethodName.NaturalBreaks:
{
NaturalBreaksClass nb = new NaturalBreaksClass();
nb.Classify(valueArray, freq, ref breakNum);
classify = nb as IClassify;
break;
}
case ClassifyMethodName.DefinedInterval:
{
DefinedIntervalClass di = new DefinedIntervalClass();
di.IntervalRange = intervl;
di.Classify(valueArray, freq, ref breakNum);
classify = di as IClassify;
break;
}
default:
{
EqualIntervalClass eq = new EqualIntervalClass();
eq.Classify(valueArray, freq, ref breakNum);
classify = (IClassify)eq;
break;
}
}
object o = classify.ClassBreaks;
System.Array breakArray = o as System.Array;
IFrequencyStatistics freqstat = basicHistogram as IFrequencyStatistics;
lscBreakValues.Items.Clear();
foreach (object oo in breakArray)
{
lscBreakValues.Items.Add(oo.ToString());
}
}
private IClassBreaksRenderer CreateClassBreaksRenderer(IFeatureClass featureClass, string breakMethod)
{
ITable pTable = (ITable)featureClass;
//从pTable的strRendererField字段中得到信息给datavalues和datafrequency两个数组
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
pTableHistogram.NormField = strNormalizeField;
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
//下面是分级方法，用于根据获得的值计算得出符合要求的数据
//根据条件计算出Classes和ClassesCount，numDesiredClasses为预定的分级数目
IClassifyGEN pClassify = null;
int numDesiredClasses = classCount;
switch (breakMethod)
{
case "等间隔":
pClassify = new EqualIntervalClass();
break;
case "已定义的间隔":
pClassify = new DefinedIntervalClass();
IIntervalRange2 intervalRange = pClassify as IIntervalRange2;
intervalRange.IntervalRange = dblDefinedInterval;
break;
case "分位数":
pClassify = new QuantileClass();
break;
case "自然裂点":
pClassify = new NaturalBreaksClass();
break;
case "标准差":
pClassify = new StandardDeviationClass();
IStatisticsResults pStatRes = pHistogram as IStatisticsResults;
IDeviationInterval pStdDev = pClassify as IDeviationInterval;
pStdDev.Mean = pStatRes.Mean;
pStdDev.StandardDev = pStatRes.StandardDeviation;
pStdDev.DeviationInterval = dblStdDevInterval;
break;
default:
break;
}
if (pClassify == null) return null;
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
//返回一个数组
double[] classBreaks = (double[])pClassify.ClassBreaks;
int ClassesCount = classBreaks.GetUpperBound(0);
nudClassCount.Value = ClassesCount;
IClassBreaksRenderer pClassBreaksRenderer = new ClassBreaksRendererClass();
pClassBreaksRenderer.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
pClassBreaksRenderer.NormField = strNormalizeField;
//设置着色对象的分级数目
pClassBreaksRenderer.BreakCount = ClassesCount;
pClassBreaksRenderer.SortClassesAscending = true;
if (colorRamp == null)
{
MessageBox.Show("请先选择色带！！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return null;
}
//通过色带设置各级分类符号的颜色
colorRamp.Size = ClassesCount;
bool createRamp;
colorRamp.CreateRamp(out createRamp);
IEnumColors enumColors = colorRamp.Colors;
enumColors.Reset();
IColor pColor = null;
ISymbol symbol = null;
if (gloabalSymbol == null)
{
MessageBox.Show("请选择符号...", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return null;
}
//需要注意的是分级着色对象中的symbol和break的下标都是从0开始
for (int i = 0; i < ClassesCount; i++)
{
pColor = enumColors.Next();
switch (featureClass.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
IMarkerSymbol markerSymbol = gloabalSymbol as IMarkerSymbol;
markerSymbol.Color = pColor;
symbol = markerSymbol as ISymbol;
break;
case esriGeometryType.esriGeometryPolyline:
ILineSymbol lineSymbol = gloabalSymbol as ILineSymbol;
lineSymbol.Color = pColor;
symbol = lineSymbol as ISymbol;
break;
case esriGeometryType.esriGeometryPolygon:
IFillSymbol fillSymbol = gloabalSymbol as IFillSymbol;
fillSymbol.Color = pColor;
symbol = fillSymbol as ISymbol;
break;
default:
break;
}
pClassBreaksRenderer.set_Symbol(i, symbol);
pClassBreaksRenderer.set_Break(i, classBreaks[i + 1]);
}
return pClassBreaksRenderer;
}
private void initialClassify()
{
if (layer2Symbolize == null) return;
IFeatureClass featureClass = layer2Symbolize.FeatureClass;
ITable pTable = (ITable)featureClass;
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
pTableHistogram.NormField = strNormalizeField;
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
IClassifyGEN pClassify = null;
int numDesiredClasses = classCount;
pClassify = new EqualIntervalClass();
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
double[] clsbreaks = (double[])pClassify.ClassBreaks;
double dblInterval = clsbreaks[1] - clsbreaks[0];
txtInterval.Text = dblInterval.ToString();
}
// 分级渲染
private void RenderByClass(IFeatureLayer featureLayer, string fieldName, int nBreaks)
{
if (featureLayer != null)
{
IFeatureClass featureClass = featureLayer.FeatureClass;
int n = featureClass.FindField(fieldName);
var type = featureClass.Fields.Field[n].Type;
if (!(type == esriFieldType.esriFieldTypeDouble || type == esriFieldType.esriFieldTypeInteger))
{
MessageBox.Show("The type of field do not belong to int or double !");
return;
}
if (n != -1 && featureClass.Fields.Field[n].Type == esriFieldType.esriFieldTypeDouble)
{
IClassBreaksRenderer classBreaksRenderer = new ClassBreaksRendererClass();
classBreaksRenderer.Field = fieldName;
ITableHistogram histogram = new BasicTableHistogramClass();
histogram.Field = fieldName;
histogram.Table = featureClass as ITable;
object dbArray, nArray;
(histogram as IBasicHistogram).GetHistogram(out dbArray, out nArray);
double[] dataArray = dbArray as double[];
int[] freqArray = nArray as int[];
// 分级方式
IClassifyGEN classifyGen = new EqualIntervalClass();
classifyGen.Classify(dataArray, freqArray, nBreaks);
classBreaksRenderer.BreakCount = nBreaks;
IAlgorithmicColorRamp algorithmicColorRamp = new AlgorithmicColorRampClass();
algorithmicColorRamp.Algorithm = esriColorRampAlgorithm.esriCIELabAlgorithm;
IRgbColor fromColor = new RgbColorClass();
fromColor.Red = 255;
fromColor.Green = 255;
fromColor.Blue = 0;
IRgbColor toColor = new RgbColorClass();
toColor.Red = 255;
toColor.Green = 0;
toColor.Blue = 0;
algorithmicColorRamp.FromColor = fromColor;
algorithmicColorRamp.ToColor = toColor;
algorithmicColorRamp.Size = nBreaks;
bool o;
algorithmicColorRamp.CreateRamp(out o);
if (o)
{
double[] breaks = classifyGen.ClassBreaks as double[];
if (breaks != null)
{
classBreaksRenderer.MinimumBreak = breaks[0];
for (int i = 0; i < classBreaksRenderer.BreakCount; i++)
{
classBreaksRenderer.Break[i] = breaks[i];
classBreaksRenderer.Label[i] = breaks[i].ToString(CultureInfo.InvariantCulture) + "-" + breaks[i + 1].ToString();
ISymbol symbol;
if (featureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
symbol = new SimpleFillSymbolClass();
(symbol as IFillSymbol).Outline.Width = 1.0;
(symbol as IFillSymbol).Color = algorithmicColorRamp.Color[i];
classBreaksRenderer.Symbol[i] = symbol;
}
else if (featureClass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
symbol = new SimpleLineSymbolClass();
(symbol as ILineSymbol).Width = 1.0;
(symbol as ILineSymbol).Color = algorithmicColorRamp.Color[i];
classBreaksRenderer.Symbol[i] = symbol;
}
else
{
MessageBox.Show("The ShapeType of this do not belong to Polygon or Polyline");
}
}
}
}
// 6.4
IGeoFeatureLayer geoFeatureLayer = featureLayer as IGeoFeatureLayer;
if (geoFeatureLayer != null)
{
geoFeatureLayer.Renderer = classBreaksRenderer as IFeatureRenderer;
IActiveView activeView = axMapControl1.ActiveView;
activeView.ContentsChanged();
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
}
}
}
public void ApplyClassBreaks(IGeoFeatureLayer geoLayer, string aFieldName, long numBreaks)
{
// Create a table from the geo feature layer
ITable table;
table = geoLayer as ITable;
ITableHistogram tableHistogram;
tableHistogram = new BasicTableHistogramClass();
tableHistogram.Table = table;
// equivalent to geoLayer.FeatureClass
// Retrieve frequency data from the field
tableHistogram.Field = aFieldName;
// MessageBox.Show("Field is: " & tableHistogram.Field)
IHistogram histogram;
histogram = tableHistogram as IHistogram;
object vValues;
object vFreqs;
histogram.GetHistogram(out vValues, out vFreqs);
// Classify the data
IClassifyGEN classifyGEN = new EqualIntervalClass();
int intBreaks;
intBreaks = Convert.ToInt32(numBreaks);
classifyGEN.Classify(vValues, vFreqs, ref intBreaks);
double[] vBreaks = (double[])classifyGEN.ClassBreaks; // need an array
// Create the class breaks renderer
IClassBreaksRenderer classBreaksRenderer;
classBreaksRenderer = new ClassBreaksRendererClass();
classBreaksRenderer.Field = aFieldName;
// passed as a String to the sub routine
classBreaksRenderer.BreakCount = (int)(numBreaks);
IRgbColor fromColor = new RgbColorClass();
fromColor.UseWindowsDithering = true;
fromColor.RGB = Microsoft.VisualBasic.Information.RGB(255, 255, 0);
IRgbColor toColor = new RgbColorClass();
toColor.UseWindowsDithering = true;
toColor.RGB = Microsoft.VisualBasic.Information.RGB(255, 0, 0);
// Set up the fill symbol
ISimpleFillSymbol sym = new SimpleFillSymbolClass();
IColor fillColor;
MessageBox.Show("vBreaks.Length: " + vBreaks.Length.ToString());
IEnumColors colors;
colors = GetColors(fromColor.RGB, toColor.RGB, numBreaks);
for (int i = 0; (i <= vBreaks.Length - 2); i++) // Length = 6; subtracted 2; why??
{
fillColor = colors.Next();
sym.Color = fillColor;
classBreaksRenderer.set_Break(i, vBreaks[(i + 1)]);
classBreaksRenderer.set_Symbol(i, sym as ISymbol);
geoLayer.Renderer = classBreaksRenderer as IFeatureRenderer;
this.m_mapControl.ActiveView.Refresh();
this.m_toolbar.Update();
}
}
private void DrawCCMaps()
{
m_intClassNumber = Convert.ToInt32(nudGCNClasses.Value);
IFeatureClass pFClass = pFLayer.FeatureClass;
//Determine Class Breaks for variable
int intValueFldIdx = pFClass.FindField(strVarFldName);
ITable pTable = (ITable)pFClass;
IClassifyGEN pClassifyGEN = null;
switch (cboGCClassify.Text)
{
case "Equal Interval":
pClassifyGEN = new EqualIntervalClass();
break;
case "Geometrical Interval":
pClassifyGEN = new GeometricalInterval();
break;
case "Natural Breaks":
pClassifyGEN = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGEN = new QuantileClass();
break;
case "StandardDeviation":
pClassifyGEN = new StandardDeviationClass();
break;
default:
pClassifyGEN = new NaturalBreaksClass();
break;
}
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strVarFldName;
pTableHistogram.Table = pTable;
//IHistogram pHistogram = (IHistogram)pTableHistogram2;
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
////Not working in ArcGIS 10.5 022417 HK
//ITableHistogram pTableHistogram = new TableHistogramClass();
//pTableHistogram.Field = strVarFldName;
//pTableHistogram.Table = pTable;
//IHistogram pHistogram = (IHistogram)pTableHistogram;
object xVals, frqs;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, m_intClassNumber);
double[] cb = (double[])pClassifyGEN.ClassBreaks;
//Class Determinations for vertical and horizontal axis
if (m_VerticalBreaks == null)
{
pClassifyGEN = new QuantileClass(); //Using Quatile
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strVerConFldName;
pTableHistogram.Table = pTable;
pHistogram = (IBasicHistogram)pTableHistogram;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intVerCnt);
m_VerticalBreaks = (double[])pClassifyGEN.ClassBreaks;
}
if (m_HorizontalBreaks == null)
{
pClassifyGEN = new QuantileClass(); //Using Quatile
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strHorConFldName;
pTableHistogram.Table = pTable;
pHistogram = (IBasicHistogram)pTableHistogram;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intHorCnt);
m_HorizontalBreaks = (double[])pClassifyGEN.ClassBreaks;
}
//Create Renderer
IClassBreaksRenderer pRender = new ClassBreaksRenderer();
pRender.Field = strVarFldName;
pRender.BreakCount = m_intClassNumber;
pRender.MinimumBreak = cb[0];
string strColorRamp = cboColorRamp.Text;
IEnumColors pEnumColors = MultiPartColorRamp(strColorRamp, "CIE Lab", m_intClassNumber);
pEnumColors.Reset();
int[,] arrColors = new int[m_intClassNumber, 3];
for (int k = 0; k < m_intClassNumber; k++)
{
IColor pColor = pEnumColors.Next();
IRgbColor pRGBColor = new RgbColorClass();
pRGBColor.RGB = pColor.RGB;
arrColors[k, 0] = pRGBColor.Red;
arrColors[k, 1] = pRGBColor.Green;
arrColors[k, 2] = pRGBColor.Blue;
}
pEnumColors.Reset();
IRgbColor pColorOutline = new RgbColor();
//Can Change the color in here!
pColorOutline = m_pSnippet.getRGB(picOutlineColor.BackColor.R, picOutlineColor.BackColor.G, picOutlineColor.BackColor.B);
double dblGCOutlineSize = Convert.ToDouble(nudOutlinewidth.Value);
ICartographicLineSymbol pOutLines = new CartographicLineSymbol();
pOutLines.Width = dblGCOutlineSize;
pOutLines.Color = (IColor)pColorOutline;
//' use this interface to set dialog properties
IClassBreaksUIProperties pUIProperties = (IClassBreaksUIProperties)pRender;
pUIProperties.ColorRamp = "Custom";
ISimpleFillSymbol pSimpleFillSym;
pEnumColors.Reset();
double dblAdding = Math.Pow(0.1, m_intRounding);
for (int j = 0; j < m_intClassNumber; j++)
{
pRender.Break[j] = cb[j + 1];
if (j == 0)
{
pRender.Label[j] = Math.Round(cb[j], m_intRounding).ToString("N" + m_intRounding.ToString()) + " - " + Math.Round(cb[j + 1], 2).ToString("N" + m_intRounding.ToString());
}
else
{
pRender.Label[j] = Math.Round(cb[j] + dblAdding, m_intRounding).ToString("N" + m_intRounding.ToString()) + " - " + Math.Round(cb[j + 1], 2).ToString("N" + m_intRounding.ToString());
}
pUIProperties.LowBreak[j] = cb[j];
pSimpleFillSym = new SimpleFillSymbolClass();
IRgbColor pRGBColor = m_pSnippet.getRGB(arrColors[j, 0], arrColors[j, 1], arrColors[j, 2]);
pSimpleFillSym.Color = (IColor)pRGBColor;
pSimpleFillSym.Outline = pOutLines;
pRender.Symbol[j] = (ISymbol)pSimpleFillSym;
}
//Background Layer
ISimpleRenderer pSimpleRender = new SimpleRendererClass();
ISimpleFillSymbol pBGSymbol = new SimpleFillSymbolClass();
pBGSymbol.Color = (IColor)m_pSnippet.getRGB(picBGColor.BackColor.R, picBGColor.BackColor.G, picBGColor.BackColor.B);
ICartographicLineSymbol pBGOutLines = new CartographicLineSymbol();
pBGOutLines.Width = 0;
pBGOutLines.Color = m_pSnippet.getRGB(255, 255, 255);
pBGSymbol.Outline = pBGOutLines;
pSimpleRender.Symbol = (ISymbol)pBGSymbol;
IFeatureLayer pflBG = new FeatureLayerClass();
pflBG.FeatureClass = pFClass;
IGeoFeatureLayer pGeoBG = (IGeoFeatureLayer)pflBG;
pGeoBG.Renderer = (IFeatureRenderer)pSimpleRender;
pGeoBG.Selectable = false;
//Feature Count for each map
m_intsFeatureCnts = new int[intVerCnt * intHorCnt];
int l = 0;
for (int i = 0; i < intVerCnt; i++)
{
for (int j = 0; j < intHorCnt; j++)
{
IFeatureLayer pflOutput = new FeatureLayerClass();
pflOutput.FeatureClass = pFClass;
IGeoFeatureLayer pGeofeatureLayer = (IGeoFeatureLayer)pflOutput;
pGeofeatureLayer.Renderer = (IFeatureRenderer)pRender;
IFeatureLayerDefinition2 pFDefinition = (IFeatureLayerDefinition2)pGeofeatureLayer;
string strWhereClause = null;
if (i == 0 && j == 0)
{
strWhereClause = strVerConFldName + " >= " + m_VerticalBreaks[i].ToString() + " AND " +
strVerConFldName + " <= " + m_VerticalBreaks[i + 1].ToString() + " AND " +
strHorConFldName + " >= " + m_HorizontalBreaks[j].ToString() + " AND " +
strHorConFldName + " <= " + m_HorizontalBreaks[j + 1].ToString();
}
else if (i != 0 && j == 0)
{
strWhereClause = strVerConFldName + " > " + m_VerticalBreaks[i].ToString() + " AND " +
strVerConFldName + " <= " + m_VerticalBreaks[i + 1].ToString() + " AND " +
strHorConFldName + " >= " + m_HorizontalBreaks[j].ToString() + " AND " +
strHorConFldName + " <= " + m_HorizontalBreaks[j + 1].ToString();
}
else if (i == 0 && j != 0)
{
strWhereClause = strVerConFldName + " >= " + m_VerticalBreaks[i].ToString() + " AND " +
strVerConFldName + " <= " + m_VerticalBreaks[i + 1].ToString() + " AND " +
strHorConFldName + " > " + m_HorizontalBreaks[j].ToString() + " AND " +
strHorConFldName + " <= " + m_HorizontalBreaks[j + 1].ToString();
}
else
{
strWhereClause = strVerConFldName + " > " + m_VerticalBreaks[i].ToString() + " AND " +
strVerConFldName + " <= " + m_VerticalBreaks[i + 1].ToString() + " AND " +
strHorConFldName + " > " + m_HorizontalBreaks[j].ToString() + " AND " +
strHorConFldName + " <= " + m_HorizontalBreaks[j + 1].ToString();
}
pFDefinition.DefinitionExpression = strWhereClause;
IQueryFilter pQfilter = new QueryFilterClass();
pQfilter.WhereClause = strWhereClause;
m_intsFeatureCnts[l] = pGeofeatureLayer.FeatureClass.FeatureCount(pQfilter);
m_axMapControls[l].ActiveView.FocusMap.ClearLayers();
m_axMapControls[l].ActiveView.FocusMap.AddLayer(pGeoBG);
m_axMapControls[l].ActiveView.FocusMap.AddLayer(pGeofeatureLayer);
m_axMapControls[l].ActiveView.Extent = m_axMapControls[l].ActiveView.FullExtent;
m_axMapControls[l].ActiveView.Refresh();
l++;
}
}
lblVariable.Text = "Selected Variable: " + strVarFldName;
UpdateRange(lvSymbol, m_intClassNumber, cb, arrColors, m_intRounding);
if (m_blnAddBoxes)
{
UpdateTextBoxes();
}
else
{
AddTextBoxes();
}
UpdateLabels();
UpdateHorVerLabels();
}
public ClassRender(AxMapControl pMapControl, String LayerName, int ClassCount, string Field)
{
IGeoFeatureLayer pGeolayer;
ILayer pLayer;
IActiveView pActiveView;
IEnumLayer pEnumLayer;
pEnumLayer = pMapControl.Map.get_Layers(null, true);
if (pEnumLayer == null)
{
return;
}
pEnumLayer.Reset();
int i = 0;
int LayerIndex = -1;
for (pLayer = pEnumLayer.Next(); pLayer != null; pLayer = pEnumLayer.Next())
{
i++;
if (pLayer.Name == LayerName)
{
LayerIndex = i - 1;
break;
}
}
if (LayerIndex == -1)
{
MessageBox.Show("没有找到要渲染的图层");
return;
}
pGeolayer = pMapControl.Map.get_Layer(LayerIndex) as IGeoFeatureLayer;
pActiveView = pMapControl.ActiveView;
//以下是为了统计和分类所需要的对象
ITable pTable;
IClassifyGEN pClassify; //C#要用这个不同于VB中的，分类对象。
ITableHistogram pTableHist; //相当于一个统计表
IBasicHistogram pBasicHist; //这个对象有一个很重要的方法
double[] ClassNum;
int ClassCountResult;//返回分类个数。
IHsvColor pFromColor;
IHsvColor pToColor;//用于构建另外一个颜色带对象。
IAlgorithmicColorRamp pAlgo;
pTable = pGeolayer as ITable;
IMap pMap;
pMap = pMapControl.Map;
pMap.ReferenceScale = 0;
pBasicHist = new BasicTableHistogramClass();//也可以实例化 pTableHist。学会这个灵活的思维
pTableHist = pBasicHist as ITableHistogram;
pTableHist.Table = pTable;
pTableHist.Field = Field;
object datavalus;
object Frenquen;
pBasicHist.GetHistogram(out datavalus, out Frenquen);//获得数据和相应的频数。
pClassify = new EqualIntervalClass();
try
{
pClassify.Classify(datavalus, Frenquen, ref ClassCount);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
// 分类完成
ClassNum = (double[])pClassify.ClassBreaks;
ClassCountResult = ClassNum.GetUpperBound(0);//返回分级个数。
IClassBreaksRenderer pClassBreak;
pClassBreak = new ClassBreaksRendererClass();
pClassBreak.Field = Field;
pClassBreak.BreakCount = ClassCountResult;
pClassBreak.SortClassesAscending = true;
pAlgo = new AlgorithmicColorRampClass();
pAlgo.Algorithm = esriColorRampAlgorithm.esriHSVAlgorithm;
pFromColor = Hsv(60, 100, 96);
pToColor = Hsv(0, 100, 96);
pAlgo.FromColor = pFromColor;
pAlgo.ToColor = pToColor;
pAlgo.Size = ClassCountResult;
bool ok;
pAlgo.CreateRamp(out ok);
IEnumColors pEnumColor;
pEnumColor = pAlgo.Colors;
pEnumColor.Reset();
IColor pColor;
ISimpleFillSymbol pSimFill;
/* IRgbColor[] pRgbColor;//可以构造颜色
*
* pRgbColor = new IRgbColor[ClassCountResult];
*
* for (int j = 0; j < ClassCountResult; j++)
* {
* int R = 50;
*
* int G = 100;
*
* int B = 50;
*
* R = R + 50;
*
* if (R > 250)
* {
* R = 50;
* }
* if (G > 250)
* {
* G = 100;
* }
* if (B > 250)
* {
* B = 50;
* }
*
* G = G + 100;
*
* B = B + 50;
*
*
*
* pRgbColor[j] = ColorRgb(R, G, B);
*
* }
*/
for (int indexColor = 0; indexColor <= ClassCountResult - 1; indexColor++)
{
pColor = pEnumColor.Next();
pSimFill = new SimpleFillSymbolClass();
pSimFill.Color = pColor;
// pSimFill.Color = pRgbColor[indexColor ];
pSimFill.Style = esriSimpleFillStyle.esriSFSSolid;
//染色
pClassBreak.set_Symbol(indexColor, pSimFill as ISymbol);
pClassBreak.set_Break(indexColor, ClassNum[indexColor + 1]);
}
pGeolayer.Renderer = pClassBreak as IFeatureRenderer;
pActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
new MainForm().axTOCControl1.Update();
}
private void btnApply_Click(object sender, EventArgs e)
{
try
{
string strLayerName = cboSourceLayer.Text;
if (cboSourceLayer.Text == "" || cboValueField.Text == "" || cboUField.Text == "")
{
MessageBox.Show("Assign proper layer and field");
return;
}
int intLIndex = pSnippet.GetIndexNumberFromLayerName(pActiveView, strLayerName);
ILayer pLayer = mForm.axMapControl1.get_Layer(intLIndex);
IFeatureLayer pFLayer = pLayer as IFeatureLayer;
IFeatureClass pFClass = pFLayer.FeatureClass;
//Create Rendering of Mean Value at Target Layer
int intGCBreakeCount = Convert.ToInt32(nudGCNClasses.Value);
string strGCRenderField = cboValueField.Text;
IGeoFeatureLayer pGeofeatureLayer;
if (chkNewLayer.Checked == true)
{
IFeatureLayer pflOutput = new FeatureLayerClass();
pflOutput.FeatureClass = pFClass;
pflOutput.Name = txtNewLayer.Text;
pflOutput.Visible = true;
pGeofeatureLayer = (IGeoFeatureLayer)pflOutput;
}
else
{
pGeofeatureLayer = (IGeoFeatureLayer)pFLayer;
}
ITable pTable = (ITable)pFClass;
IClassifyGEN pClassifyGEN;
switch (cboGCClassify.Text)
{
case "Equal Interval":
pClassifyGEN = new EqualIntervalClass();
break;
case "Geometrical Interval":
pClassifyGEN = new GeometricalInterval();
break;
case "Natural Breaks":
pClassifyGEN = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGEN = new QuantileClass();
break;
case "StandardDeviation":
pClassifyGEN = new StandardDeviationClass();
break;
default:
pClassifyGEN = new NaturalBreaksClass();
break;
}
//Need to be changed 1/29/15
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strGCRenderField;
pTableHistogram.Table = pTable;
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
object xVals, frqs;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intGCBreakeCount);
ClassBreaksRenderer pRender = new ClassBreaksRenderer();
double[] cb = (double[])pClassifyGEN.ClassBreaks;
pRender.Field = strGCRenderField;
pRender.BreakCount = intGCBreakeCount;
pRender.MinimumBreak = cb[0];
//' create our color ramp
IAlgorithmicColorRamp pColorRamp = new AlgorithmicColorRampClass();
pColorRamp.Algorithm = esriColorRampAlgorithm.esriCIELabAlgorithm;
IRgbColor pColor1 = new RgbColor();
IRgbColor pColor2 = new RgbColor();
//Can Change the color in here!
pColor1.Red = picSymolfrom.BackColor.R;
pColor1.Green = picSymolfrom.BackColor.G;
pColor1.Blue = picSymolfrom.BackColor.B;
Boolean blnOK = true;
pColor2.Red = picSymbolTo.BackColor.R;
pColor2.Green = picSymbolTo.BackColor.G;
pColor2.Blue = picSymbolTo.BackColor.B;
pColorRamp.FromColor = pColor1;
pColorRamp.ToColor = pColor2;
pColorRamp.Size = intGCBreakeCount;
pColorRamp.CreateRamp(out blnOK);
IEnumColors pEnumColors = pColorRamp.Colors;
pEnumColors.Reset();
IRgbColor pColorOutline = new RgbColor();
//Can Change the color in here!
pColorOutline.Red = picGCLineColor.BackColor.R;
pColorOutline.Green = picGCLineColor.BackColor.G;
pColorOutline.Blue = picGCLineColor.BackColor.B;
double dblGCOutlineSize = Convert.ToDouble(nudGCLinewidth.Value);
ICartographicLineSymbol pOutLines = new CartographicLineSymbol();
pOutLines.Width = dblGCOutlineSize;
pOutLines.Color = (IColor)pColorOutline;
//' use this interface to set dialog properties
IClassBreaksUIProperties pUIProperties = (IClassBreaksUIProperties)pRender;
pUIProperties.ColorRamp = "Custom";
ISimpleFillSymbol pSimpleFillSym;
//' be careful, indices are different for the diff lists
for (int j = 0; j < intGCBreakeCount; j++)
{
pRender.Break[j] = cb[j + 1];
pRender.Label[j] = Math.Round(cb[j], 2).ToString() + " - " + Math.Round(cb[j + 1], 2).ToString();
pUIProperties.LowBreak[j] = cb[j];
pSimpleFillSym = new SimpleFillSymbolClass();
pSimpleFillSym.Color = pEnumColors.Next();
pSimpleFillSym.Outline = pOutLines;
pRender.Symbol[j] = (ISymbol)pSimpleFillSym;
}
pGeofeatureLayer.Renderer = (IFeatureRenderer)pRender;
if (chkNewLayer.Checked == true)
{
mForm.axMapControl1.ActiveView.FocusMap.AddLayer(pGeofeatureLayer);
}
////* Uncertainty Part *////
//Declare variables in if parts
if (tcUncern.SelectedIndex == 0) //Graduated Color
{
int intUncernBreakCount = Convert.ToInt32(nudCoNClasses.Value);
string strUncerFieldName = cboUField.Text;
IFeatureLayer pflUncern = new FeatureLayerClass();
pflUncern.FeatureClass = pFClass;
pflUncern.Name = cboSourceLayer.Text + " Uncertainty";
pflUncern.Visible = true;
IGeoFeatureLayer pGFLUncern = (IGeoFeatureLayer)pflUncern;
switch (cboTeClassify.Text)
{
case "Equal Interval":
pClassifyGEN = new EqualIntervalClass();
break;
case "Geometrical Interval":
pClassifyGEN = new GeometricalInterval();
break;
case "Natural Breaks":
pClassifyGEN = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGEN = new QuantileClass();
break;
case "StandardDeviation":
pClassifyGEN = new StandardDeviationClass();
break;
default:
pClassifyGEN = new NaturalBreaksClass();
break;
}
//Need to be changed 1/29/15
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strUncerFieldName;
pTableHistogram.Table = pTable;
pHistogram = (IBasicHistogram)pTableHistogram;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intUncernBreakCount);
pRender = new ClassBreaksRenderer();
cb = (double[])pClassifyGEN.ClassBreaks;
pRender.Field = strUncerFieldName;
pRender.BreakCount = intUncernBreakCount;
pRender.MinimumBreak = cb[0];
IClassBreaksUIProperties pUIColProperties = (IClassBreaksUIProperties)pRender;
pUIColProperties.ColorRamp = "Custom";
pColorRamp = new AlgorithmicColorRampClass();
pColorRamp.Algorithm = esriColorRampAlgorithm.esriCIELabAlgorithm;
pColor1 = new RgbColor();
pColor2 = new RgbColor();
//Can Change the color in here!
pColor1 = pSnippet.getRGB(picCoColorFrom.BackColor.R, picCoColorFrom.BackColor.G, picCoColorFrom.BackColor.B);
pColor2 = pSnippet.getRGB(picCoColorTo.BackColor.R, picCoColorTo.BackColor.G, picCoColorTo.BackColor.B);
if (pColor1 == null || pColor2 == null)
{
return;
}
blnOK = true;
pColorRamp.FromColor = pColor1;
pColorRamp.ToColor = pColor2;
pColorRamp.Size = intUncernBreakCount;
pColorRamp.CreateRamp(out blnOK);
pEnumColors = pColorRamp.Colors;
pEnumColors.Reset();
pColorOutline = pSnippet.getRGB(picCoLineColor.BackColor.R, picCoLineColor.BackColor.G, picCoLineColor.BackColor.B);
if (pColorOutline == null)
{
return;
}
double dblCoOutlineSize = Convert.ToDouble(nudCoLinewidth.Value);
pOutLines = new CartographicLineSymbol();
pOutLines.Width = dblCoOutlineSize;
pOutLines.Color = (IColor)pColorOutline;
//' use this interface to set dialog properties
pUIColProperties = (IClassBreaksUIProperties)pRender;
pUIColProperties.ColorRamp = "Custom";
ISimpleMarkerSymbol pSimpleMarkerSym;
double dblCoSymSize = Convert.ToDouble(nudCoSymbolSize.Value);
//' be careful, indices are different for the diff lists
for (int j = 0; j < intUncernBreakCount; j++)
{
pRender.Break[j] = cb[j + 1];
pRender.Label[j] = Math.Round(cb[j], 2).ToString() + " - " + Math.Round(cb[j + 1], 2).ToString();
pUIColProperties.LowBreak[j] = cb[j];
pSimpleMarkerSym = new SimpleMarkerSymbolClass();
pSimpleMarkerSym.Size = dblCoSymSize;
pSimpleMarkerSym.Color = pEnumColors.Next();
pSimpleMarkerSym.Outline = true;
pSimpleMarkerSym.OutlineColor = pColorOutline;
pSimpleMarkerSym.OutlineSize = dblCoOutlineSize;
pRender.Symbol[j] = (ISymbol)pSimpleMarkerSym;
}
pGFLUncern.Renderer = (IFeatureRenderer)pRender;
mForm.axMapControl1.ActiveView.FocusMap.AddLayer(pGFLUncern);
}
else if (tcUncern.SelectedIndex == 1) //Texture
{
//Create Rendering of Uncertainty at Target Layer
int intUncernBreakCount = Convert.ToInt32(nudTeNClasses.Value);
string strUncerFieldName = cboUField.Text;
IFeatureLayer pflUncern = new FeatureLayerClass();
pflUncern.FeatureClass = pFClass;
pflUncern.Name = cboSourceLayer.Text + " Uncertainty";
pflUncern.Visible = true;
IGeoFeatureLayer pGFLUncern = (IGeoFeatureLayer)pflUncern;
switch (cboTeClassify.Text)
{
case "Equal Interval":
pClassifyGEN = new EqualIntervalClass();
break;
case "Geometrical Interval":
pClassifyGEN = new GeometricalInterval();
break;
case "Natural Breaks":
pClassifyGEN = new NaturalBreaksClass();
break;
case "Quantile":
pClassifyGEN = new QuantileClass();
break;
case "StandardDeviation":
pClassifyGEN = new StandardDeviationClass();
break;
default:
pClassifyGEN = new NaturalBreaksClass();
break;
}
//Need to be changed 1/29/15
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Field = strUncerFieldName;
pTableHistogram.Table = pTable;
pHistogram = (IBasicHistogram)pTableHistogram;
pHistogram.GetHistogram(out xVals, out frqs);
pClassifyGEN.Classify(xVals, frqs, intUncernBreakCount);
pRender = new ClassBreaksRenderer();
cb = (double[])pClassifyGEN.ClassBreaks;
pRender.Field = strUncerFieldName;
pRender.BreakCount = intUncernBreakCount;
pRender.MinimumBreak = cb[0];
IClassBreaksUIProperties pUITexProperties = (IClassBreaksUIProperties)pRender;
pUITexProperties.ColorRamp = "Custom";
ILineFillSymbol pLineFillSym = new LineFillSymbolClass();
double dblFromSep = Convert.ToDouble(nudSeperationFrom.Value);
double dblToSep = Convert.ToDouble(nudSeperationTo.Value);
double dblInstantSep = (dblFromSep - dblToSep) / Convert.ToDouble(intUncernBreakCount - 1);
double dblFromAngle = Convert.ToDouble(nudAngleFrom.Value);
double dblToAngle = Convert.ToDouble(nudAngleFrom.Value); // Remove the angle part (04/16)
double dblInstantAngle = (dblToAngle - dblFromAngle) / Convert.ToDouble(intUncernBreakCount - 1);
double dblLinewidth = Convert.ToDouble(nudTeLinewidth.Value);
IRgbColor pLineColor = new RgbColor();
pLineColor.Red = picTeLineColor.BackColor.R;
pLineColor.Green = picTeLineColor.BackColor.G;
pLineColor.Blue = picTeLineColor.BackColor.B;
//' be careful, indices are different for the diff lists
for (int j = 0; j < intUncernBreakCount; j++)
{
pRender.Break[j] = cb[j + 1];
pRender.Label[j] = Math.Round(cb[j], 5).ToString() + " - " + Math.Round(cb[j + 1], 5).ToString();
pUITexProperties.LowBreak[j] = cb[j];
pLineFillSym = new LineFillSymbolClass();
pLineFillSym.Angle = dblFromAngle + (dblInstantAngle * Convert.ToDouble(j));
pLineFillSym.Color = pLineColor;
pLineFillSym.Separation = dblFromSep - (dblInstantSep * Convert.ToDouble(j));
pLineFillSym.LineSymbol.Width = dblLinewidth;
pRender.Symbol[j] = (ISymbol)pLineFillSym;
}
pGFLUncern.Renderer = (IFeatureRenderer)pRender;
mForm.axMapControl1.ActiveView.FocusMap.AddLayer(pGFLUncern);
}
else if (tcUncern.SelectedIndex == 2) //For Proportional Symbols
{
string strUncerFieldName = cboUField.Text;
double dblMinPtSize = Convert.ToDouble(nudProSymbolSize.Value);
double dblLineWidth = Convert.ToDouble(nudProLinewidth.Value);
IFeatureLayer pflUncern = new FeatureLayerClass();
pflUncern.FeatureClass = pFClass;
pflUncern.Name = cboSourceLayer.Text + " Uncertainty";
pflUncern.Visible = true;
//Find Fields
int intUncernIdx = pTable.FindField(strUncerFieldName);
//Find Min value
//Set to initial value for min
IField pUncernField = pTable.Fields.get_Field(intUncernIdx);
ICursor pCursor = pTable.Search(null, false);
IDataStatistics pDataStat = new DataStatisticsClass();
pDataStat.Field = pUncernField.Name;
pDataStat.Cursor = pCursor;
IStatisticsResults pStatResults = pDataStat.Statistics;
double dblMinValue = pStatResults.Minimum;
double dblMaxValue = pStatResults.Maximum;
pCursor.Flush();
IRgbColor pSymbolRgb = pSnippet.getRGB(picProSymbolColor.BackColor.R, picProSymbolColor.BackColor.G, picProSymbolColor.BackColor.B);
if (pSymbolRgb == null)
{
return;
}
IRgbColor pLineRgb = pSnippet.getRGB(picProiLineColor.BackColor.R, picProiLineColor.BackColor.G, picProiLineColor.BackColor.B);
if (pLineRgb == null)
{
return;
}
ISimpleMarkerSymbol pSMarkerSym = new SimpleMarkerSymbolClass();
pSMarkerSym.Style = esriSimpleMarkerStyle.esriSMSCircle;
pSMarkerSym.Size = dblMinPtSize;
pSMarkerSym.OutlineSize = dblLineWidth;
pSMarkerSym.Outline = true;
pSMarkerSym.OutlineColor = (IColor)pLineRgb;
pSMarkerSym.Color = (IColor)pSymbolRgb;
IGeoFeatureLayer pGFLUncern = (IGeoFeatureLayer)pflUncern;
IProportionalSymbolRenderer pUncernRender = new ProportionalSymbolRendererClass();
pUncernRender.LegendSymbolCount = 2; //Need to be changed 0219
pUncernRender.Field = strUncerFieldName;
pUncernRender.MaxDataValue = dblMaxValue;
pUncernRender.MinDataValue = dblMinValue;
pUncernRender.MinSymbol = (ISymbol)pSMarkerSym;
pUncernRender.ValueUnit = esriUnits.esriUnknownUnits;
pUncernRender.BackgroundSymbol = null;
pUncernRender.CreateLegendSymbols();
pGFLUncern.Renderer = (IFeatureRenderer)pUncernRender;
mForm.axMapControl1.ActiveView.FocusMap.AddLayer(pGFLUncern);
}
else if (tcUncern.SelectedIndex == 3) // Bar
{
string strUncerFieldName = cboUField.Text;
double dblMaxLength = Convert.ToDouble(nudMaxBarHeight.Value);
double dblBarWidth = Convert.ToDouble(nudBarWidth.Value);
IFeatureLayer pflUncern = new FeatureLayerClass();
pflUncern.FeatureClass = pFClass;
pflUncern.Name = cboSourceLayer.Text + " Uncertainty";
pflUncern.Visible = true;
int intUncernIdx = pTable.FindField(strUncerFieldName);
IField pUncernField = pTable.Fields.get_Field(intUncernIdx);
ICursor pCursor = pTable.Search(null, false);
IDataStatistics pDataStat = new DataStatisticsClass();
pDataStat.Field = pUncernField.Name;
pDataStat.Cursor = pCursor;
IStatisticsResults pStatResults = pDataStat.Statistics;
double dblMaxValue = pStatResults.Maximum;
pCursor.Flush();
IChartRenderer chartRenderer = new ChartRendererClass();
IRendererFields rendererFields = chartRenderer as IRendererFields;
rendererFields.AddField(strUncerFieldName);
IBarChartSymbol barChartSymbol = new BarChartSymbolClass();
barChartSymbol.Width = dblBarWidth;
IMarkerSymbol markerSymbol = barChartSymbol as IMarkerSymbol;
markerSymbol.Size = dblMaxLength;
IChartSymbol chartSymbol = barChartSymbol as IChartSymbol;
chartSymbol.MaxValue = dblMaxValue;
ISymbolArray symbolArray = barChartSymbol as ISymbolArray;
IFillSymbol fillSymbol = new SimpleFillSymbolClass();
fillSymbol.Color = pSnippet.getRGB(picBarSymCol.BackColor.R, picBarSymCol.BackColor.G, picBarSymCol.BackColor.B);
if (fillSymbol.Color == null)
{
return;
}
symbolArray.AddSymbol(fillSymbol as ISymbol);
if (chk3D.Checked)
{
I3DChartSymbol p3DChartSymbol = barChartSymbol as I3DChartSymbol;
p3DChartSymbol.Display3D = true;
p3DChartSymbol.Thickness = 3;
}
chartRenderer.ChartSymbol = barChartSymbol as IChartSymbol;
SimpleFillSymbol pBaseFillSym = new SimpleFillSymbolClass();
//pBaseFillSym.Color = pSnippet.getRGB(picBarSymCol.BackColor.R, picBarSymCol.BackColor.G, picBarSymCol.BackColor.B);
//chartRenderer.BaseSymbol = pBaseFillSym as ISymbol;
chartRenderer.UseOverposter = false;
chartRenderer.CreateLegend();
IGeoFeatureLayer pGFLUncern = (IGeoFeatureLayer)pflUncern;
pGFLUncern.Renderer = (IFeatureRenderer)chartRenderer;
mForm.axMapControl1.ActiveView.FocusMap.AddLayer(pGFLUncern);
}
#region illumination
//This function is not applied in this version. 032317 HK
//}
// else if (tcUncern.SelectedIndex == 4) //illumination
// {
// frmProgress pfrmProgress = new frmProgress();
// pfrmProgress.lblStatus.Text = "Processing:";
// pfrmProgress.pgbProgress.Style = ProgressBarStyle.Marquee;
// pfrmProgress.Show();
// string strUncerFieldName = cboUField.Text;
// IGeoDataset geoDataset_output = createRasterfromPolygon(pFClass, strUncerFieldName, pFLayer, 100);
// double altitude = Convert.ToDouble(nudAltitude.Value);
// double azimuth = Convert.ToDouble(nudAzimuth.Value);
// object zFactor = Convert.ToDouble(nudZFactor.Value);
// ISurfaceOp2 pSurfOP = new RasterSurfaceOpClass();
// IRaster pOutputDS = (IRaster)pSurfOP.HillShade(geoDataset_output, azimuth, altitude, true, ref zFactor);
// ((IDataset)geoDataset_output).Delete();
// // Create a raster for viewing
// ESRI.ArcGIS.Carto.IRasterLayer rasterLayer = new ESRI.ArcGIS.Carto.RasterLayerClass();
// rasterLayer.CreateFromRaster(pOutputDS);
// //Calculate hillshade value at slope 0 to set as background value
// double dblRadian = (Math.PI / 180) * (90 - altitude);
// double dblBackValue = Math.Truncate(255 * Math.Cos(dblRadian));
// IRasterStretch pRasterStretch = new RasterStretchColorRampRendererClass();
// IColor pColor = new RgbColorClass();
// pColor.NullColor = true;
// pColor.Transparency = 0;
// pRasterStretch.Background = true;
// pRasterStretch.BackgroundColor = pColor;
// pRasterStretch.set_BackgroundValues(ref dblBackValue);
// rasterLayer.Name = "Uncertainty of " + strGCRenderField;
// rasterLayer.Renderer = pRasterStretch as IRasterRenderer;
// rasterLayer.Renderer.Update();
// //Apply Transparency
// ILayerEffects pLayerEffect = (ILayerEffects)rasterLayer;
// pLayerEffect.Transparency = Convert.ToInt16(nudTransparent.Value);
// pfrmProgress.Close();
// // Add the raster to the map
// pActiveView.FocusMap.AddLayer(rasterLayer);
// }
// mForm.axMapControl1.ActiveView.Refresh();
// mForm.axTOCControl1.Update();
#endregion
}
catch (Exception ex)
{
frmErrorLog pfrmErrorLog = new frmErrorLog(); pfrmErrorLog.ex = ex; pfrmErrorLog.ShowDialog();
return;
}
}
//新地科学分类方法 [没有使用]
public double[] getDivEquestStringArray2(int breakNum)
{
List <double> DivItemList = new List <double>();
if (breakNum != 0)
{
for (int ib = 0; ib < this.RasterLayerClass.BandCount; ib++)
{
IUniqueValues uv = new UniqueValuesClass();
IRasterCalcUniqueValues rcuv = new RasterCalcUniqueValuesClass();
rcuv.AddFromRaster(this.RasterLayerClass.Raster, ib, uv);
object valueArray = null, freq = null;
;
IClassify classify = null;
uv.GetHistogram(out valueArray, out freq);
//--
EqualIntervalClass eq = new EqualIntervalClass();
eq.Classify(valueArray, freq, ref breakNum);
classify = (IClassify)eq;
//object o = classify.ClassBreaks;
////--
//Quantile qc = new QuantileClass();
//qc.Classify(valueArray, freq, ref breakNum);
//classify = (IClassify)qc;
//o = classify.ClassBreaks;
////--
//NaturalBreaksClass nb = new NaturalBreaksClass();
//nb.Classify(valueArray, freq, ref breakNum);
//classify = nb as IClassify;
//o = classify.ClassBreaks;
////--
////DefinedIntervalClass di = new DefinedIntervalClass();
////di.IntervalRange = this.m_classBreaksParam.Interval;
////di.Classify(valueArray, freq, ref breakNum);
////--
////StandardDeviationClass sd = new StandardDeviationClass();
////IStatisticsResults stat = histogram as IStatisticsResults;
////classify = sd as IClassify;
////classify.SetHistogramData(valueArray, freq);
////IDeviationInterval di = sd as IDeviationInterval;
////di.DeviationInterval = 1;
////di.Mean = stat.Mean;
////di.StandardDev = stat.StandardDeviation;
////classify.Classify(ref breakNum);
////--
object o = classify.ClassBreaks;
System.Array breakArray = o as System.Array;
for (int i = breakArray.Length - 1; i >= 0; i--)
{
DivItemList.Add(double.Parse(breakArray.GetValue(i).ToString()));
}
}
}
return(DivItemList.ToArray());
}
/// <summary>
/// Class Break Render
/// </summary>
/// <param name="currentLayer"></param>
/// <param name="breakCount"></param>
/// <author>Shen Yongyuan</author>
/// <date>20091114</date>
public static void ClassBreakRender(ILayer currentLayer, int breakCount, string fieldName, ref double[] Classes, ref int[] Colors, bool reverse)
{
//Get All Value
object dataFrequency = null;
object dataValues = null;
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = fieldName;
pTableHistogram.Table = (currentLayer as IGeoFeatureLayer).DisplayFeatureClass as ITable;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
//Class
IClassifyGEN pClassify = new EqualIntervalClass();
pClassify.Classify(dataValues, dataFrequency, ref breakCount);
//Set Class Breaks
Classes = (double[])pClassify.ClassBreaks;
int ClassesCount = Classes.GetUpperBound(0);
IClassBreaksRenderer pClassBreaksRenderer = new ClassBreaksRendererClass();
pClassBreaksRenderer.Field = fieldName;
//Set From to Color
IHsvColor pFromColor = new HsvColorClass();
pFromColor.Hue = reverse ? 105 : 353;
pFromColor.Saturation = reverse ? 46 : 56;
pFromColor.Value = reverse ? 76 : 92;
IHsvColor pToColor = new HsvColorClass();
pToColor.Hue = reverse ? 353 : 105;
pToColor.Saturation = reverse ? 56 : 46;
pToColor.Value = reverse ? 92 : 76;
//Get Color
IAlgorithmicColorRamp pAlgorithmicCR = new AlgorithmicColorRampClass();
pAlgorithmicCR.Algorithm = esriColorRampAlgorithm.esriHSVAlgorithm;
pAlgorithmicCR.FromColor = pFromColor;
pAlgorithmicCR.ToColor = pToColor;
pAlgorithmicCR.Size = ClassesCount;
bool ok = false;
pAlgorithmicCR.CreateRamp(out ok);
IEnumColors pEnumColors = pAlgorithmicCR.Colors;
//Set Break Count
pClassBreaksRenderer.BreakCount = ClassesCount;
pClassBreaksRenderer.SortClassesAscending = true;
//Set Break Interval
for (int lbreakIndex = 0; lbreakIndex <= ClassesCount - 1; lbreakIndex++)
{
IColor pColor = pEnumColors.Next();
Colors[lbreakIndex] = pColor.RGB;
ISimpleFillSymbol pSimpleFillS = new SimpleFillSymbolClass();
pSimpleFillS.Color = pColor;
pSimpleFillS.Style = esriSimpleFillStyle.esriSFSSolid;
pClassBreaksRenderer.set_Symbol(lbreakIndex, (ISymbol)pSimpleFillS);
pClassBreaksRenderer.set_Break(lbreakIndex, Classes[lbreakIndex + 1]);
}
//Set Render
(currentLayer as IGeoFeatureLayer).Renderer = pClassBreaksRenderer as IFeatureRenderer;
}
private void classify()
{
if (layer2Symbolize == null) return;
IFeatureClass featureClass = layer2Symbolize.FeatureClass;
ITable pTable = (ITable)featureClass;
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
pTableHistogram.NormField = strNormalizeField;
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
//下面是分级方法，用于根据获得的值计算得出符合要求的数据
//根据条件计算出Classes和ClassesCount，numDesiredClasses为预定的分级数目
IClassifyGEN pClassify = new NaturalBreaksClass();
switch (strClassifyMethod)
{
case "等间隔分类":
pClassify = new EqualIntervalClass();
break;
//case "预定义间隔分类":
// pClassify = new DefinedIntervalClass();
// break;
case "分位数分类":
pClassify = new QuantileClass();
break;
case "自然裂点分类":
pClassify = new NaturalBreaksClass();
break;
//case "标准差分类":
// pClassify = new StandardDeviationClass();
// break;
case "几何间隔分类":
pClassify = new GeometricalIntervalClass();
break;
default:
break;
}
int numDesiredClasses = gClassCount;
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
gClassbreaks = (double[])pClassify.ClassBreaks;
}
public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp)
{
try
{
//计算统计图
IRasterBand band = GetBand(rastlayer);
if (band.Histogram == null)
{
band.ComputeStatsAndHist();
}
IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
rasRender.Raster = rastlayer.Raster;
rasRender.Update();
int numClasses = count;
IRasterHistogram pRasterHistogram = band.Histogram;
double[] dblValues = pRasterHistogram.Counts as double[];
int intValueCount = dblValues.GetUpperBound(0) + 1;
double[] vValues = new double[intValueCount];
IRasterStatistics pRasterStatistic = band.Statistics;
double dMaxValue = pRasterStatistic.Maximum;
double dMinValue = pRasterStatistic.Minimum;
double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
for (int i = 0; i < intValueCount; i++)
{
vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
}
long[] longvalues = new long[dblValues.Length];
for (int i = 0; i <= dblValues.Length - 1; i++)
{
longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
}
//IClassifyGEN classify = null;
IClassify classify = null;
switch (classMethod)
{
case "等间距分级":
classify = new EqualIntervalClass();
break;
case "自然断点分级":
classify = new NaturalBreaksClass();
break;
}
classify.Classify(ref numClasses);
double[] Classes = classify.ClassBreaks as double[];
UID pUid = classify.ClassID;
IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
rasClassifyUI.ClassificationMethod = pUid;
rasClassifyRender.ClassCount = count;
IColor pColor;
ISimpleFillSymbol pSym;
for (int j = 0; j < count; j++)
{
pColor = ramp.get_Color(j * (ramp.Size - 1) / (count - 1));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
rasRender.Update();
rasClassifyRender.set_Break(j, rasClassifyRender.get_Break(j));
//rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
rasRender.Update();
}
//IRasterProps rasterProps = (IRasterProps)rastlayer.Raster;
//rasterProps.NoDataValue = 0;
//IRasterDisplayProps props = rasClassifyRender as IRasterDisplayProps;
//props.NoDataColor = GET(255, 255, 255);
//rasRender.Update();
rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
}
catch
{
MessageBox.Show("唯一值数量已达到限制（65536）");
}
}
private void polygonClassificationDye(ILayer pLayer)
{
IGeoFeatureLayer pGeoFeatureLayer;
ITable pTable;
IClassifyGEN pClassify;
ITableHistogram pTableHistogram;
IBasicHistogram pHistogram;
object dataFrequency;
object dataValues;
double[] Classes;
int ClassesCount;
IClassBreaksRenderer pClassBreakRenderer;
IHsvColor pFromColor;
IHsvColor pToColor;
IAlgorithmicColorRamp pAIgorithmicCR;
IEnumColors pEnumColors;
bool ok;
IColor pColor;
ISimpleFillSymbol pSimpleFillS;
int IbreakIndex;
string strPopFiled = cbField1.Text;
int numDesiredClasses;
try
{
numDesiredClasses = int.Parse(textBox1.Text.ToString());
}
catch
{
MessageBox.Show("请输入分级个数");
return;
}
IMap pMap = axMapControl1.Map;
pMap.ReferenceScale = 0;
pGeoFeatureLayer = pLayer as IGeoFeatureLayer;
//从pTable的id字段中得到信息给dataValues和dataFrequency两个数组
pTable = (ITable)pGeoFeatureLayer.FeatureClass;
pTableHistogram = new BasicTableHistogramClass();
pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strPopFiled;
pTableHistogram.Table = pTable;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
//下面是分级方法，用于根据获取的值计算出符号要求的数据
pClassify = new EqualIntervalClass();
try
{
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//返回一个数组
Classes = (double[])pClassify.ClassBreaks;
ClassesCount = Classes.GetUpperBound(0);
pClassBreakRenderer = new ClassBreaksRendererClass();
pClassBreakRenderer.Field = strPopFiled;
//设置着色对象的分级数目
pClassBreakRenderer.BreakCount = ClassesCount;
pClassBreakRenderer.SortClassesAscending = true;
//产生分级着色需要的颜色带对象的起止颜色对象
pFromColor = new HsvColorClass();
pFromColor.Hue = 60;
pFromColor.Saturation = 100;
pFromColor.Value = 96;
pToColor = new HsvColorClass();
pToColor.Hue = 0;
pToColor.Saturation = 100;
pToColor.Value = 96;
//产生颜色带对象
pAIgorithmicCR = new AlgorithmicColorRampClass();
pAIgorithmicCR.Algorithm = esriColorRampAlgorithm.esriHSVAlgorithm;
pAIgorithmicCR.FromColor = pFromColor;
pAIgorithmicCR.ToColor = pToColor;
pAIgorithmicCR.Size = ClassesCount;
pAIgorithmicCR.CreateRamp(out ok);
//获得颜色
pEnumColors = pAIgorithmicCR.Colors;
//分类着色对象中的symbol和break的下标是从0开始
for (IbreakIndex = 0; IbreakIndex <= ClassesCount - 1; IbreakIndex++)
{
pColor = pEnumColors.Next();
pSimpleFillS = new SimpleFillSymbolClass();
pSimpleFillS.Color = pColor;
pSimpleFillS.Style = esriSimpleFillStyle.esriSFSSolid;
//这里是构造函数不同颜色着色的方法
pClassBreakRenderer.set_Symbol(IbreakIndex, (ISymbol)pSimpleFillS);
//着色对象的断点
pClassBreakRenderer.set_Break(IbreakIndex, Classes[IbreakIndex + 1]);
}
pGeoFeatureLayer.Renderer = (IFeatureRenderer)pClassBreakRenderer;
axMapControl1.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
private void btnClassiFy_Click(object sender, EventArgs e)
{
ITable pTable = this.pLayer as ITable;
object dataValues;
object dataFrequency;
//以下代码用TableHistogram和BasicHistogram统计出Table某一字段的值和值的频率
ITableHistogram pTableHistogram;
pTableHistogram = new BasicTableHistogramClass();
pTableHistogram.Table = pTable;//需传入一个ITable
pTableHistogram.Field = this.cbbClassBreakField.Text;//统计的字段
IBasicHistogram pBasicHistogram;
pBasicHistogram = pTableHistogram as IBasicHistogram;
pBasicHistogram.GetHistogram(out dataValues, out dataFrequency);//关键
//以下代码用IClassifyGEN和EqualInterval对象,基于分段数目,生成各段的临界值,并放在一个数组当中
IClassifyGEN pClassifyGEN;
switch (this.cbbClassBreaksMethod.SelectedIndex)
{
case 0:
pClassifyGEN = new EqualIntervalClass();
break;
case 1:
pClassifyGEN = new GeometricalIntervalClass();
break;
case 2:
pClassifyGEN = new NaturalBreaksClass();
break;
case 3:
pClassifyGEN = new QuantileClass();
break;
default:
pClassifyGEN = new EqualIntervalClass();
break;
}
//double[] classes;
int classCount = int.Parse(this.cbbClassBreaksCount.Text);
pClassifyGEN.Classify(dataValues, dataFrequency, ref classCount);//用到了上面ITableHistogram生成的值和值频率数组,关键!!!!!!
this.classBreaks = pClassifyGEN.ClassBreaks as double[];//注意,此对象下标从1开始(我觉得0为最开头,所以临界值从1开始有意义),关键!!!!!!
this.lsvClassBreaksSymbol.Items.Clear();
string currentRange;
for (int i = 0; i < classCount; i++)
{
currentRange = this.classBreaks[i].ToString() + " ～ " + this.classBreaks[i + 1].ToString();
this.lsvClassBreaksSymbol.Items.Add(currentRange);
this.lsvClassBreaksSymbol.Items[i].SubItems.Add(currentRange);
}
}
private IClassBreaksRenderer CreateClassBreaksRenderer(IFeatureClass featureClass, string breakMethod)
{
ITable pTable = (ITable)featureClass;
//从pTable的strRendererField字段中得到信息给datavalues和datafrequency两个数组
ITableHistogram pTableHistogram = new BasicTableHistogramClass();
IBasicHistogram pHistogram = (IBasicHistogram)pTableHistogram;
pTableHistogram.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
{
pTableHistogram.NormField = strNormalizeField;
}
pTableHistogram.Table = pTable;
object dataFrequency;
object dataValues;
pHistogram.GetHistogram(out dataValues, out dataFrequency);
//下面是分级方法，用于根据获得的值计算得出符合要求的数据
//根据条件计算出Classes和ClassesCount，numDesiredClasses为预定的分级数目
IClassifyGEN pClassify = null;
int numDesiredClasses = classCount;
switch (breakMethod)
{
case "等间隔":
pClassify = new EqualIntervalClass();
break;
case "已定义的间隔":
pClassify = new DefinedIntervalClass();
IIntervalRange2 intervalRange = pClassify as IIntervalRange2;
intervalRange.IntervalRange = dblDefinedInterval;
break;
case "分位数":
pClassify = new QuantileClass();
break;
case "自然裂点":
pClassify = new NaturalBreaksClass();
break;
case "标准差":
pClassify = new StandardDeviationClass();
IStatisticsResults pStatRes = pHistogram as IStatisticsResults;
IDeviationInterval pStdDev = pClassify as IDeviationInterval;
pStdDev.Mean = pStatRes.Mean;
pStdDev.StandardDev = pStatRes.StandardDeviation;
pStdDev.DeviationInterval = dblStdDevInterval;
break;
default:
break;
}
if (pClassify == null)
{
return(null);
}
pClassify.Classify(dataValues, dataFrequency, ref numDesiredClasses);
//返回一个数组
double[] classBreaks = (double[])pClassify.ClassBreaks;
int ClassesCount = classBreaks.GetUpperBound(0);
nudClassCount.Value = ClassesCount;
IClassBreaksRenderer pClassBreaksRenderer = new ClassBreaksRendererClass();
pClassBreaksRenderer.Field = strRendererField;
if (strNormalizeField.ToLower() != "none")
{
pClassBreaksRenderer.NormField = strNormalizeField;
}
//设置着色对象的分级数目
pClassBreaksRenderer.BreakCount = ClassesCount;
pClassBreaksRenderer.SortClassesAscending = true;
if (colorRamp == null)
{
MessageBox.Show("请先选择色带！！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(null);
}
//通过色带设置各级分类符号的颜色
colorRamp.Size = ClassesCount;
bool createRamp;
colorRamp.CreateRamp(out createRamp);
IEnumColors enumColors = colorRamp.Colors;
enumColors.Reset();
IColor pColor = null;
ISymbol symbol = null;
if (gloabalSymbol == null)
{
MessageBox.Show("请选择符号...", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(null);
}
//需要注意的是分级着色对象中的symbol和break的下标都是从0开始
for (int i = 0; i < ClassesCount; i++)
{
pColor = enumColors.Next();
switch (featureClass.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
IMarkerSymbol markerSymbol = gloabalSymbol as IMarkerSymbol;
markerSymbol.Color = pColor;
symbol = markerSymbol as ISymbol;
break;
case esriGeometryType.esriGeometryPolyline:
ILineSymbol lineSymbol = gloabalSymbol as ILineSymbol;
lineSymbol.Color = pColor;
symbol = lineSymbol as ISymbol;
break;
case esriGeometryType.esriGeometryPolygon:
IFillSymbol fillSymbol = gloabalSymbol as IFillSymbol;
fillSymbol.Color = pColor;
symbol = fillSymbol as ISymbol;
break;
default:
break;
}
pClassBreaksRenderer.set_Symbol(i, symbol);
pClassBreaksRenderer.set_Break(i, classBreaks[i + 1]);
}
return(pClassBreaksRenderer);
}
public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp)
{
IRasterBand band = GetBand(rastlayer);
if (band.Histogram == null)
{
band.ComputeStatsAndHist();
}
IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
rasRender.Raster = rastlayer.Raster;
rasRender.Update();
int numClasses = count;
IRasterHistogram pRasterHistogram = band.Histogram;
double[] dblValues = pRasterHistogram.Counts as double[];
int intValueCount = dblValues.GetUpperBound(0) + 1;
double[] vValues = new double[intValueCount];
IRasterStatistics pRasterStatistic = band.Statistics;
double dMaxValue = pRasterStatistic.Maximum;
double dMinValue = pRasterStatistic.Minimum;
if (dMinValue == 0)
{
pRasterStatistic.IgnoredValues = pRasterStatistic.Minimum;
pRasterStatistic.Recalculate();
dMinValue = pRasterStatistic.Minimum;
}
double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
for (int i = 0; i < intValueCount; i++)
{
vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
}
long[] longvalues = new long[dblValues.Length];
for (int i = 0; i <= dblValues.Length - 1; i++)
{
longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
}
//IClassifyGEN classify = null;
IClassify classify = null;
switch (classMethod)
{
case "等间距分级":
EqualInterval eqclassify = new EqualIntervalClass();
eqclassify.Classify(vValues, longvalues, ref numClasses);
classify = eqclassify as IClassify;
break;
case "自然断点分级":
NaturalBreaks naclassify = new NaturalBreaksClass();
naclassify.Classify(vValues, longvalues, ref numClasses);
classify = naclassify as IClassify;
break;
}
//switch (classMethod)
//{
// case "等间距分级":
// classify = new EqualIntervalClass();
// break;
// case "自然断点分级":
// classify = new NaturalBreaksClass();
// break;
//}
//classify.Classify(vValues, longvalues, ref numClasses);
double[] Classes = classify.ClassBreaks as double[];
UID pUid = classify.ClassID;
IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
rasClassifyUI.ClassificationMethod = pUid;
rasClassifyRender.ClassCount = count;
IColor pColor;
ISimpleFillSymbol pSym;
for (int j = 0; j < count; j++)
{
IRasterProps rasterProps = (IRasterProps)rastlayer.Raster;
rasterProps.NoDataValue = 0;
pColor = ramp.get_Color(j * (ramp.Size / count));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
rasRender.Update();
rasClassifyRender.set_Break(j,rasClassifyRender.get_Break(j));
rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
rasRender.Update();
}
rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
}
public void LayerRender()
{
try
{
//值分级
IBasicHistogram pBasicHis = new BasicTableHistogramClass();
ITableHistogram pTabHis = (ITableHistogram)pBasicHis;
IClassifyGEN pClassify = null;
switch (classname)
{
case "自然断点分级":
pClassify = new NaturalBreaksClass();
break;
case "等间距分级":
pClassify = new EqualIntervalClass();
break;
}
pTabHis.Field = FiledName;
//IGeoFeatureLayer geolayer = (IGeoFeatureLayer)Layer;
ITable pTab = (ITable)Layer;
pTabHis.Table = pTab;
object doubleArrVal, longArrFreq;
pBasicHis.GetHistogram(out doubleArrVal, out longArrFreq);
int nDes = count;
pClassify.Classify(doubleArrVal, longArrFreq, ref nDes);
object classes = pClassify.ClassBreaks;
double[] ClassNum;
ClassNum = (double[])pClassify.ClassBreaks;
int ClassCountResult = ClassNum.GetUpperBound(0);
IClassBreaksRenderer pRender = new ClassBreaksRendererClass();
pRender.BreakCount = ClassCountResult;
pRender.Field = FiledName;
ISimpleFillSymbol pSym;
IColor pColor;
for (int j = 0; j < ClassCountResult; j++)
{
pColor = ramp.get_Color(j * (ramp.Size / ClassCountResult));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
pRender.set_Symbol(j, (ISymbol)pSym);
pRender.set_Break(j, ClassNum[j + 1]);
if (ClassNum[j].ToString().Contains("."))
{
pRender.set_Label(j, ClassNum[j].ToString("0.000") + " - " + ClassNum[j + 1].ToString("0.000"));
}
else
{
pRender.set_Label(j, ClassNum[j].ToString() + " - " + ClassNum[j + 1].ToString());
}
}
IGeoFeatureLayer pGeoLyr = (IGeoFeatureLayer)Layer;
pGeoLyr.Renderer = (IFeatureRenderer)pRender;
axmapcontrol.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
axtoccontrol.Update();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp)
{
IRasterBand band = GetBand(rastlayer);
if (band.Histogram == null)
{
band.ComputeStatsAndHist();
}
IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
rasRender.Raster = rastlayer.Raster;
rasRender.Update();
int numClasses = count;
IRasterHistogram pRasterHistogram = band.Histogram;
double[] dblValues = pRasterHistogram.Counts as double[];
int intValueCount = dblValues.GetUpperBound(0) + 1;
double[] vValues = new double[intValueCount];
IRasterStatistics pRasterStatistic = band.Statistics;
double dMaxValue = pRasterStatistic.Maximum;
double dMinValue = pRasterStatistic.Minimum;
if (dMinValue == 0)
{
pRasterStatistic.IgnoredValues = pRasterStatistic.Minimum;
pRasterStatistic.Recalculate();
dMinValue = pRasterStatistic.Minimum;
}
double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
for (int i = 0; i < intValueCount; i++)
{
vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
}
long[] longvalues = new long[dblValues.Length];
for (int i = 0; i <= dblValues.Length - 1; i++)
{
longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
}
//IClassifyGEN classify = null;
IClassify classify = null;
switch (classMethod)
{
case "等间距分级":
EqualInterval eqclassify = new EqualIntervalClass();
eqclassify.Classify(vValues, longvalues, ref numClasses);
classify = eqclassify as IClassify;
break;
case "自然断点分级":
NaturalBreaks naclassify = new NaturalBreaksClass();
naclassify.Classify(vValues, longvalues, ref numClasses);
classify = naclassify as IClassify;
break;
}
//switch (classMethod)
//{
// case "等间距分级":
// classify = new EqualIntervalClass();
// break;
// case "自然断点分级":
// classify = new NaturalBreaksClass();
// break;
//}
//classify.Classify(vValues, longvalues, ref numClasses);
double[] Classes = classify.ClassBreaks as double[];
UID pUid = classify.ClassID;
IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
rasClassifyUI.ClassificationMethod = pUid;
rasClassifyRender.ClassCount = count;
IColor pColor;
ISimpleFillSymbol pSym;
for (int j = 0; j < count; j++)
{
IRasterProps rasterProps = (IRasterProps)rastlayer.Raster;
rasterProps.NoDataValue = 0;
pColor = ramp.get_Color(j * (ramp.Size / count));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
rasRender.Update();
rasClassifyRender.set_Break(j, rasClassifyRender.get_Break(j));
rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
rasRender.Update();
}
rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
}
//public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp,double minValue)
//{
// IRasterBand band = GetBand(rastlayer);
// if (band.Histogram == null)
// {
// band.ComputeStatsAndHist();
// }
// IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
// IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
// rasRender.Raster = rastlayer.Raster;
// rasRender.Update();
// int numClasses = count;
// IRasterHistogram pRasterHistogram = band.Histogram;
// double[] dblValues = pRasterHistogram.Counts as double[];
// int intValueCount = dblValues.GetUpperBound(0) + 1;
// double[] vValues = new double[intValueCount];
// IRasterStatistics pRasterStatistic = band.Statistics;
// //double dMaxValue = pRasterStatistic.Maximum;
// double dMaxValue = minValue;
// double dMinValue = pRasterStatistic.Minimum;
// double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
// for (int i = 0; i < intValueCount; i++)
// {
// vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
// }
// long[] longvalues = new long[dblValues.Length];
// for (int i = 0; i <= dblValues.Length - 1; i++)
// {
// longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
// }
// //IClassifyGEN classify = null;
// IClassify classify = null;
// switch (classMethod)
// {
// case "等间距分级":
// EqualInterval eqclassify = new EqualIntervalClass();
// eqclassify.Classify(vValues, longvalues, ref numClasses);
// classify = eqclassify as IClassify;
// break;
// case "自然断点分级":
// NaturalBreaks naclassify = new NaturalBreaksClass();
// naclassify.Classify(vValues, longvalues, ref numClasses);
// classify = naclassify as IClassify;
// break;
// }
// //switch (classMethod)
// //{
// // case "等间距分级":
// // classify = new EqualIntervalClass();
// // break;
// // case "自然断点分级":
// // classify = new NaturalBreaksClass();
// // break;
// //}
// //classify.Classify(vValues, longvalues, ref numClasses);
// double[] Classes = classify.ClassBreaks as double[];
// UID pUid = classify.ClassID;
// IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
// rasClassifyUI.ClassificationMethod = pUid;
// rasClassifyRender.ClassCount = count;
// IColor pColor;
// ISimpleFillSymbol pSym;
// for (int j = 0; j < count; j++)
// {
// pColor = ramp.get_Color(j * (ramp.Size / count));
// pSym = new SimpleFillSymbolClass();
// pSym.Color = pColor;
// rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
// rasRender.Update();
// if (Classes[j] == 0)
// {
// rasClassifyRender.set_Label(j, Classes[j].ToString() + "-" + Classes[j + 1].ToString("0.000"));
// rasRender.Update();
// }
// else
// {
// rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
// rasRender.Update();
// }
// }
// rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
public void RasterClassify(IRasterLayer rastlayer, string classMethod, int count, IColorRamp ramp)
{
try
{ //进行唯一值判断
IUniqueValues values = new UniqueValuesClass();
IRasterCalcUniqueValues unique = new RasterCalcUniqueValuesClass();
unique.AddFromRaster(rastlayer.Raster, 0, values);
int uniquecount = values.get_UniqueCount(0);
//计算统计图
IRasterBand band = GetBand(rastlayer);
if (band.Histogram == null)
{
band.ComputeStatsAndHist();
}
IRasterClassifyColorRampRenderer rasClassifyRender = new RasterClassifyColorRampRendererClass();
IRasterRenderer rasRender = rasClassifyRender as IRasterRenderer;
rasRender.Raster = rastlayer.Raster;
rasRender.Update();
int numClasses = count;
IRasterHistogram pRasterHistogram = band.Histogram;
double[] dblValues = pRasterHistogram.Counts as double[];
int intValueCount = dblValues.GetUpperBound(0) + 1;
double[] vValues = new double[intValueCount];
IRasterStatistics pRasterStatistic = band.Statistics;
double dMaxValue = pRasterStatistic.Maximum;
double dMinValue = pRasterStatistic.Minimum;
if (dMinValue == 0)
{
pRasterStatistic.IgnoredValues = pRasterStatistic.Minimum;
pRasterStatistic.Recalculate();
dMinValue = pRasterStatistic.Minimum;
}
double BinInterval = Convert.ToDouble((dMaxValue - dMinValue) / intValueCount);
for (int i = 0; i < intValueCount; i++)
{
vValues[i] = i * BinInterval + pRasterStatistic.Minimum;
}
long[] longvalues = new long[dblValues.Length];
for (int i = 0; i <= dblValues.Length - 1; i++)
{
longvalues[i] = long.Parse(Convert.ToString(dblValues[i]));
}
//IClassifyGEN classify = null;
IClassify classify = null;
switch (classMethod)
{
case "等间距分级":
EqualInterval eqclassify = new EqualIntervalClass();
eqclassify.Classify(vValues, longvalues, ref numClasses);
classify = eqclassify as IClassify;
break;
case "自然断点分级":
NaturalBreaks naclassify = new NaturalBreaksClass();
naclassify.Classify(vValues, longvalues, ref numClasses);
classify = naclassify as IClassify;
break;
}
#region
//switch (classMethod)
//{
// case "等间距分级":
// classify = new EqualIntervalClass();
// break;
// case "自然断点分级":
// classify = new NaturalBreaksClass();
// break;
//}
//classify.Classify(vValues, longvalues, ref numClasses);
#endregion
double[] Classes = classify.ClassBreaks as double[];
int n = Classes.Count();
double dn = Classes[0];
UID pUid = classify.ClassID;
IRasterClassifyUIProperties rasClassifyUI = rasClassifyRender as IRasterClassifyUIProperties;
rasClassifyUI.ClassificationMethod = pUid;
rasClassifyRender.ClassCount = count;
IColor pColor;
ISimpleFillSymbol pSym;
//排除数值
double[] exdouble = new double[2] {
0, Classes[0]
};
IRasterDataExclusion ex = rasClassifyRender as IRasterDataExclusion;
ex.ExcludeValues = exdouble;
ex.ExcludeColor = GET(255, 255, 255);
for (int j = 0; j < count; j++)
{
pColor = ramp.get_Color(j * (ramp.Size / count));
pSym = new SimpleFillSymbolClass();
pSym.Color = pColor;
rasClassifyRender.set_Symbol(j, (ISymbol)pSym);
rasRender.Update();
rasClassifyRender.set_Break(j, rasClassifyRender.get_Break(j));
rasClassifyRender.set_Label(j, Classes[j].ToString("0.000") + "-" + Classes[j + 1].ToString("0.000"));
rasRender.Update();
}
//IRasterProps rasterProps = (IRasterProps)rastlayer.Raster;
//rasterProps.NoDataValue = 0;
//IRasterDisplayProps props = rasClassifyRender as IRasterDisplayProps;
//props.NoDataColor = GET(255, 255, 255);
//rasRender.Update();
rastlayer.Renderer = rasClassifyRender as IRasterRenderer;
}
catch (Exception ex)
{
//MessageBox.Show(ex.ToString());
if (ex.ToString().Contains("唯一值过多"))
{
MessageBox.Show("唯一值数量已达到限制（65536）");
}
else
{
MessageBox.Show("还未计算唯一值，进行唯一值计算！");
}
}
//catch
//{
// MessageBox.Show("数据需要先计算统计值，请点击确定进行计算！");
//}
}
public ClassRender(AxMapControl pMapControl, IFeatureLayer pFtLayer, int ClassCount, string pFieldName)
{
IGeoFeatureLayer pGeolayer;
IActiveView pActiveView;
pGeolayer = pFtLayer as IGeoFeatureLayer;
pActiveView = pMapControl.ActiveView;
//������Ϊ��ͳ�ƺͷ�������Ҫ�Ķ���
ITable pTable;
IClassifyGEN pClassify;//C#Ҫ�������ͬ��VB�еģ��������
ITableHistogram pTableHist;//�൱��һ��ͳ�Ʊ�
IBasicHistogram pBasicHist;//���������һ������Ҫ�ķ���
double[] ClassNum;
int ClassCountResult;//���ط��������
IHsvColor pFromColor;
IHsvColor pToColor;//���ڹ�������һ����ɫ������
IAlgorithmicColorRamp pAlgo;
pTable = pGeolayer as ITable;
IMap pMap;
pMap = pMapControl.Map;
pMap.ReferenceScale = 0;
pBasicHist = new BasicTableHistogramClass();//Ҳ����ʵ���� pTableHist��ѧ���������˼ά
pTableHist = pBasicHist as ITableHistogram;
pTableHist.Table = pTable;
pTableHist.Field = pFieldName;
object datavalus;
object Frenquen;
pBasicHist.GetHistogram(out datavalus,out Frenquen);//������ݺ���Ӧ��Ƶ����
pClassify = new EqualIntervalClass();
try
{
pClassify.Classify(datavalus, Frenquen, ref ClassCount);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
// �������
ClassNum = (double[])pClassify.ClassBreaks;
ClassCountResult = ClassNum.GetUpperBound(0);//���طּ�������
IClassBreaksRenderer pClassBreak;
pClassBreak = new ClassBreaksRendererClass();
pClassBreak.Field = pFieldName;
pClassBreak.BreakCount = ClassCountResult;
pClassBreak.SortClassesAscending = true;
pAlgo = new AlgorithmicColorRampClass();
pAlgo.Algorithm = esriColorRampAlgorithm.esriHSVAlgorithm;
pFromColor = Hsv(60, 100, 96);
pToColor = Hsv(0, 100, 96);
pAlgo.FromColor = pFromColor;
pAlgo.ToColor = pToColor;
pAlgo.Size = ClassCountResult;
bool ok;
pAlgo.CreateRamp(out ok);
IEnumColors pEnumColor;
pEnumColor = pAlgo.Colors;
pEnumColor.Reset();
IColor pColor;
ISimpleFillSymbol pSimFill;
/* IRgbColor[] pRgbColor;//���Թ�����ɫ
pRgbColor = new IRgbColor[ClassCountResult];
for (int j = 0; j < ClassCountResult; j++)
{
int R = 50;
int G = 100;
int B = 50;
R = R + 50;
if (R > 250)
{
R = 50;
}
if (G > 250)
{
G = 100;
}
if (B > 250)
{
B = 50;
}
G = G + 100;
B = B + 50;
pRgbColor[j] = ColorRgb(R, G, B);
}
*/
for (int indexColor = 0; indexColor <= ClassCountResult - 1; indexColor++)
{
pColor = pEnumColor.Next();
pSimFill = new SimpleFillSymbolClass();
pSimFill.Color = pColor;
// pSimFill.Color = pRgbColor[indexColor ];
pSimFill.Style = esriSimpleFillStyle.esriSFSSolid;
//Ⱦɫ
pClassBreak.set_Symbol(indexColor, pSimFill as ISymbol);
pClassBreak.set_Break(indexColor, ClassNum[indexColor + 1]);
}
pGeolayer.Renderer = pClassBreak as IFeatureRenderer;
pActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
