/// <summary>
/// 从比例尺列表中，选择能够展示指定要素范围的最合适比例尺
/// </summary>
/// <param name="pageLayout">页面布局</param>
/// <param name="mapFrame">要设定显示范围及比例尺的地图数据框</param>
/// <param name="featureEnv">地图要素显示范围</param>
/// <param name="scaleList">比例尺列表，将从中选取最合适的比例尺</param>
/// <param name="bufferDistance">要素与图廓的缓冲距离(厘米)，即地图实际显示范围是featEnvelope + 2 * bufferDistance</param>
/// <returns></returns>
public static double SetMapScale(this IPageLayout pageLayout, IMapFrame mapFrame,
IEnvelope featureEnv, double[] scaleList, double bufferDistance = 2)
{
esriUnits pageUnit = pageLayout.Page.Units;
esriUnits mapUnit = mapFrame.Map.DistanceUnits;
esriUnits cmUnit = esriUnits.esriCentimeters; //厘米
IEnvelope mapFrameEnv = (mapFrame as IElement)?.Geometry.Envelope;
IUnitConverter unitConverter = new UnitConverterClass();
double wScale = unitConverter.ConvertUnits(featureEnv.Width, mapUnit, cmUnit) / (unitConverter.ConvertUnits(mapFrameEnv.Width, pageUnit, cmUnit) - 2 * bufferDistance);
double hScale = unitConverter.ConvertUnits(featureEnv.Height, mapUnit, cmUnit) / (unitConverter.ConvertUnits(mapFrameEnv.Height, pageUnit, cmUnit) - 2 * bufferDistance);
double dScale = wScale > hScale ? wScale : hScale;
int maxIndex = 0;
while (maxIndex < scaleList.Length && dScale > scaleList[maxIndex])
{
maxIndex++;//寻找比要素全图廓显示所确定的比例尺小一级的比例尺
}
if (maxIndex == scaleList.Length)
{
throw new Exception("需要更小的比例尺！");
}
return(scaleList[maxIndex]);
}
public double ang = 0;//yjl20110816 add 角度测量的角度
//构造函数
public frmMeasureResult(esriUnits in_DisplayUnit, ControlsMapMeasureToolDefClass inTool)
{
InitializeComponent();
m_CurMeasureType = 0;
m_bIsFeatureMeasure = false;
toolMeasureArea.Checked = false;
toolMeasureFeature.Checked = false;
toolMeasureLine.Checked = true;
m_bShowSum = false;
m_bSnapToFeature = false;
toolShowSum.Checked = false;
toolSnapToFeature.Checked = false;
toolM.Checked = true;//选中M
toolKM.Checked = false;
// toolM.ReadOnly = true;
//toolSquareM.ReadOnly = true;
/////
this.m_Displayunit = in_DisplayUnit;
if (in_DisplayUnit == esriUnits.esriUnknownUnits)//地图单位
{
m_Displayunit = esriUnits.esriMeters;
}
pTool = inTool;
}
private void combox_unit_SelectedIndexChanged(object sender, EventArgs e)
{
switch (combox_unit.SelectedIndex)
{
case 0:
unit = esriUnits.esriMeters;
break;
case 1:
unit = esriUnits.esriKilometers;
break;
case 2:
unit = esriUnits.esriFeet;
break;
case 3:
unit = esriUnits.esriMiles;
break;
default:
unit = esriUnits.esriMeters;
break;
}
double len = conv.ConvertUnits(pCurve.Length, mapunit, unit);
trkbar_seg.Maximum = (int)len / 3;
trkbar_seg.Minimum = (int)len / 300;
trkbar_seg.Value = (int)len / 30;
txtbox_seg.Text = ((int)len / 30).ToString();
txtbox_min.Text = ((int)len / 300).ToString();
txtbox_max.Text = ((int)len / 3).ToString();
}
//获得单位
private string GetUnitsName(esriUnits nUnit)
{
switch ((int)nUnit)
{
case 1:
return("英寸");
case 3:
return("英尺");
case 7:
return("毫米");
case 8:
return("厘米");
case 9:
return("米");
case 10:
return("千米");
case 12:
return("分米");
default:
return("未知");
}
}
/// <summary>
/// 将输入的数据单位转化为米
/// </summary>
/// <param name="dValue"></param>
/// <param name="outUnits"></param>
/// <returns></returns>
public double UnitsConvertToMeters(double dValue, esriUnits outUnits)
{
IUnitConverter unitConverter = new UnitConverterClass();
double newValue = unitConverter.ConvertUnits(dValue, esriUnits.esriMeters, outUnits);
return(newValue);
}
private double method_9(esriUnits esriUnits_0, double double_0)
{
switch (esriUnits_0)
{
case esriUnits.esriMillimeters:
return(double_0 * 0.1);
case esriUnits.esriCentimeters:
return(double_0);
case esriUnits.esriMeters:
return(double_0 * 100.0);
case esriUnits.esriKilometers:
return(double_0 * 100000.0);
case esriUnits.esriDecimalDegrees:
return(double_0);
case esriUnits.esriDecimeters:
return(double_0 * 10.0);
case esriUnits.esriInches:
return(double_0 * 2.54);
}
return(double_0);
}
protected double UnitFactor(ISpatialReference sr, esriUnits units,
double referenceScale)
{
var pc = sr as IProjectedCoordinateSystem;
if (pc == null)
{
return(1);
}
if (_unitConverter == null)
{
_unitConverter = new UnitConverterClass();
}
double f = _unitConverter.ConvertUnits(1, esriUnits.esriMeters, units);
f = f * pc.CoordinateUnit.MetersPerUnit;
f = f * referenceScale;
if (_unitsType == typeof(LengthUnits))
{
}
else if (_unitsType == typeof(AreaUnits))
{
f = f * f;
}
else
{
throw new ArgumentException("Unhandled Unit type " + _unitsType);
}
return(f);
}
internal static string GetUnitString(esriUnits lengthUnit)
{
switch (lengthUnit)
{
case esriUnits.esriKilometers:
return("km");
case esriUnits.esriMeters:
return("m");
case esriUnits.esriDecimeters:
return("dm");
case esriUnits.esriCentimeters:
return("cm");
case esriUnits.esriMillimeters:
return("mm");
case esriUnits.esriUnknownUnits:
return(null);
default:
return(GetEsriUnitsAsString(lengthUnit));
}
}
private void method_0()
{
if (ScaleTextFormatPropertyPage.m_pScaleText != null)
{
this.symbolItem1.Symbol = ScaleTextFormatPropertyPage.m_pScaleText;
this.txtMapUnitLabel.Text = ScaleTextFormatPropertyPage.m_pScaleText.MapUnitLabel;
this.txtPageUnitLabel.Text = ScaleTextFormatPropertyPage.m_pScaleText.PageUnitLabel;
this.cboMapUnit.SelectedIndex = (int)ScaleTextFormatPropertyPage.m_pScaleText.MapUnits;
this.rdoStyle.SelectedIndex = (int)ScaleTextFormatPropertyPage.m_pScaleText.Style;
esriUnits pageUnits = ScaleTextFormatPropertyPage.m_pScaleText.PageUnits;
switch (pageUnits)
{
case esriUnits.esriInches:
this.cboPageUnit.SelectedIndex = 1;
return;
case esriUnits.esriPoints:
this.cboPageUnit.SelectedIndex = 2;
return;
}
if (pageUnits == esriUnits.esriCentimeters)
{
this.cboPageUnit.SelectedIndex = 0;
}
}
}
//坐标单位转换为中文
public string GetUnitNameChn(esriUnits vUnit)
{
switch (vUnit)
{
case esriUnits.esriKilometers:
return("公里");
case esriUnits.esriMeters:
return("米");
case esriUnits.esriCentimeters:
return("厘米");
case esriUnits.esriDecimeters:
return("分米");
case esriUnits.esriMillimeters:
return("毫米");
case esriUnits.esriDecimalDegrees:
return("度");
default:
return("未知");
}
}
static public bool UnitFactor(string sourceUnit, out double factor)
{
esriUnits esriUnit = UnitEsri(sourceUnit);
if (esriUnit != esriUnits.esriUnknownUnits)
{
return(UnitFactor(esriUnit, out factor));
}
switch (sourceUnit.ToLower())
{
case "foot":
case "feet":
factor = UnitFactor(esriCadastralDistanceUnits.eFeet);
return(true);
case "foot_us":
case "feet_us":
factor = UnitFactor(esriCadastralDistanceUnits.eSurveyFeet);
return(true);
case "meter":
case "metre":
factor = UnitFactor(esriCadastralDistanceUnits.eMeters);
return(true);
}
factor = 1.0;
return(false);
}
static public esriCadastralAreaUnits DefaultAreaUnit(esriUnits eCadastralLayerDistanceUnit)
{
switch (eCadastralLayerDistanceUnit)
{
case esriUnits.esriMeters:
return(esriCadastralAreaUnits.esriCAUSquareMeter);
case esriUnits.esriFeet:
return(esriCadastralAreaUnits.esriCAUSquareFoot); // esriCAUAcre;
// TODO...
//case esriCDUUSSurveyFoot:
// return esriCAUAcre;
//break;
//// aka, default to meters for:
//case esriCDUChain:
//case esriCDULink:
//case esriCDURod:
// return esriCadastralAreaUnits.esriCAUMetric;
//case esriCDUUSSurveyChain:
//case esriCDUUSSurveyLink:
//case esriCDUUSSurveyRod:
// return esriCadastralAreaUnits.esriCAUAcre;
}
return(esriCadastralAreaUnits.esriCAUSquareMeter); // default will always catch this.
}
static public string GetUnit(esriUnits eDistanceType, bool shortNotation)
{
if (!shortNotation)
{
switch (eDistanceType)
{
case esriUnits.esriMeters:
return((string)Application.Current.FindResource("strMeters"));
case esriUnits.esriFeet:
return((string)Application.Current.FindResource("strFeet"));
}
}
else
{
switch (eDistanceType)
{
case esriUnits.esriMeters:
return((string)Application.Current.FindResource("strMetersShort"));
case esriUnits.esriFeet:
return((string)Application.Current.FindResource("strFeetShort"));
}
}
return("");
}
/// <summary>
/// Handler operation Identify Route
/// </summary>
/// <param name="boundVariables">list of variables bound</param>
/// <param name="operationInput">input of operation</param>
/// <param name="outputFormat">format of output</param>
/// <param name="requestProperties">list of request properties</param>
/// <param name="responseProperties">list of response properties </param>
/// <returns>response in byte</returns>
private byte[] IdentifyRouteOperHandler(NameValueCollection boundVariables, JsonObject operationInput, string outputFormat, string requestProperties, out string responseProperties)
{
responseProperties = "{\"Content-Type\" : \"application/json\"}";
string methodName = MethodBase.GetCurrentMethod().Name;
int routeLayerID = Convert.ToInt32(boundVariables["RouteLayersID"], CultureInfo.InvariantCulture);
esriUnits routeMeasureUnit = DSUtility.GetMeasureUnit(operationInput, MeasureUnit.routeMeasureUnit);
IFeatureClass featureClass = this.GetRouteFeatureClass(routeLayerID);
string routeIDFieldNameValue = DSUtility.GetRouteIDFieldName(operationInput, featureClass.OIDFieldName);
IRouteLocator2 routeLocator = DSUtility.GetRouteLocator(featureClass, routeIDFieldNameValue, routeMeasureUnit);
double?tolerance;
bool found = operationInput.TryGetAsDouble("tolerance", out tolerance);
if (!found || !tolerance.HasValue)
{
tolerance = 0.0;
}
JsonObject jsonLocation;
if (!operationInput.TryGetJsonObject("location", out jsonLocation))
{
throw new ArgumentException("Invalid location", methodName);
}
IPoint location = Conversion.ToGeometry(jsonLocation, esriGeometryType.esriGeometryPoint) as IPoint;
if (location == null)
{
throw new ArgumentException("Invalid location", methodName);
}
IEnvelope envelope = location.Envelope;
envelope.Expand(tolerance.Value, tolerance.Value, false);
IRouteMeasurePointLocation routeMeasurePointLocation = new RouteMeasurePointLocationClass();
IRouteLocation routeLocation;
IFeature feature;
JsonObject result = new JsonObject();
List <JsonObject> measures = new List <JsonObject>();
IEnumRouteIdentifyResult enumResult = routeLocator.Identify(envelope, string.Empty);
for (int i = 1; i <= enumResult.Count; i++)
{
enumResult.Next(out routeLocation, out feature);
routeMeasurePointLocation = (IRouteMeasurePointLocation)routeLocation;
JsonObject measure = new JsonObject();
measure.AddString("routeID", routeLocation.RouteID.ToString());
measure.AddDouble("measure", routeMeasurePointLocation.Measure);
measures.Add(measure);
}
result.AddArray("location", measures.ToArray());
return(result.JsonByte());
}
/// <summary>
/// 设置测量格网的单位和间隔
/// </summary>
/// <param name="pMeasuredGrid">测量格网</param>
/// <param name="units">单位</param>
/// <param name="xInter">X间隔</param>
/// <param name="yInter">Y间隔</param>
public static void SetMeasuredGrid(IMeasuredGrid pMeasuredGrid, esriUnits units, double xInter, double yInter)
{
pMeasuredGrid.Units = units; //单位
pMeasuredGrid.FixedOrigin = false;
pMeasuredGrid.XIntervalSize = xInter; //间隔
pMeasuredGrid.YIntervalSize = yInter; //间隔
}
public static double AsMeters(esriUnits sourceUnit, double value)
{
double factor = 1.0;
UnitFactor(sourceUnit, out factor); // will return 1.0 on error.
return factor * value;
}
private string sMapUnit = "未知单位";//地图单位变量
private string GetMapUnit(esriUnits esriUnit)
{
string MapUnit = "";
switch (esriUnit)
{
case esriUnits.esriCentimeters:
MapUnit = "厘米";
break;
case esriUnits.esriDecimalDegrees:
MapUnit = "十进制";
break;
case esriUnits.esriDecimeters:
MapUnit = "分米";
break;
case esriUnits.esriFeet:
MapUnit = "尺";
break;
case esriUnits.esriInches:
MapUnit = "英尺";
break;
case esriUnits.esriKilometers:
MapUnit = "千米";
break;
case esriUnits.esriMeters:
MapUnit = "米";
break;
case esriUnits.esriMiles:
MapUnit = "英里";
break;
case esriUnits.esriMillimeters:
MapUnit = "毫米";
break;
case esriUnits.esriNauticalMiles:
MapUnit = "海里";
break;
case esriUnits.esriPoints:
MapUnit = "点";
break;
case esriUnits.esriYards:
MapUnit = "码";
break;
case esriUnits.esriUnknownUnits:
MapUnit = "未知单位";
break;
}
return(MapUnit);
}
//单位
private void axMapControl1_OnMapReplaced(object sender, IMapControlEvents2_OnMapReplacedEvent e)
{
esriUnits mapUnits = axMapControl1.MapUnits;
switch (mapUnits)
{
case esriUnits.esriCentimeters:
sMapUnits = "Centimeters";
break;
case esriUnits.esriDecimalDegrees:
sMapUnits = "Decimal Degrees";
break;
case esriUnits.esriDecimeters:
sMapUnits = "Decimeters";
break;
case esriUnits.esriFeet:
sMapUnits = "Feet";
break;
case esriUnits.esriInches:
sMapUnits = "Inches";
break;
case esriUnits.esriKilometers:
sMapUnits = "Kilometers";
break;
case esriUnits.esriMeters:
sMapUnits = "Meters";
break;
case esriUnits.esriMiles:
sMapUnits = "Miles";
break;
case esriUnits.esriMillimeters:
sMapUnits = "Millimeters";
break;
case esriUnits.esriNauticalMiles:
sMapUnits = "NauticalMiles";
break;
case esriUnits.esriPoints:
sMapUnits = "Points";
break;
case esriUnits.esriUnknownUnits:
sMapUnits = "Unknown";
break;
case esriUnits.esriYards:
sMapUnits = "Yards";
break;
}
}
static public double AsMeters(esriUnits sourceUnit, double value)
{
double factor = 1.0;
UnitFactor(sourceUnit, out factor); // will return 1.0 on error.
return(factor * value);
}
private void toolMM_Click(object sender, EventArgs e)
{
this.m_Units = esriUnits.esriMillimeters;
toolKM.Checked = false;
toolM.Checked = false;
toolCM.Checked = false;
toolMM.Checked = true;
}
//将厘米转换为其他单位
private void ConvertUnit(esriUnits units, ref double x, ref double y)
{
switch (units)
{
case esriUnits.esriDecimeters:
x /= 10;
y /= 10;
break;
case esriUnits.esriFeet:
x /= 30.48;
y /= 30.48;
break;
case esriUnits.esriInches:
x /= 2.54;
y /= 2.54;
break;
case esriUnits.esriKilometers:
x /= 100000;
y /= 100000;
break;
case esriUnits.esriMeters:
x /= 100;
y /= 100;
break;
case esriUnits.esriMiles:
x /= 160934.4;
y /= 160934.4;
break;
case esriUnits.esriMillimeters:
x *= 10;
y *= 10;
break;
case esriUnits.esriNauticalMiles:
x /= 185200;
y /= 185200;
break;
case esriUnits.esriPoints:
x *= 28.346456;
y *= 28.346456;
break;
case esriUnits.esriYards:
x /= 91.44;
y /= 91.44;
break;
default:
break;
}
}
/// <summary>
/// 转换点坐标，从默认坐标转换当前坐标
/// </summary>
/// <param name="vPoint"></param>
/// <param name="defaultUnit"></param>
/// <param name="currentUnit"></param>
/// <returns></returns>
public static IPoint ConvertPointCoordinate(IPoint vPoint, esriUnits defaultUnit, esriUnits currentUnit)
{
IUnitConverter pUnitConverter = new UnitConverter();
IPoint pPt = new PointClass();
pPt.X = pUnitConverter.ConvertUnits(vPoint.X, defaultUnit, currentUnit);
pPt.Y = pUnitConverter.ConvertUnits(vPoint.Y, defaultUnit, currentUnit);
return(pPt);
}
public static String ConvertEsriUnit(esriUnits units)
{
String zhUnits = "unknown";
if (units.ToString().Contains("esri"))
{
zhUnits = units.ToString().Substring(4);
}
return(zhUnits);
}
private void BufferAnalysisForm_Load(object sender, EventArgs e)
{
if (null == _hookHelper || null == _hookHelper.Hook || 0 == _hookHelper.FocusMap.LayerCount)
{
return;
}
//load all the feature layers in the map to the layers combo
IEnumLayer layers = GetLayers();
layers.Reset();
ILayer layer;
while ((layer = layers.Next()) != null)
{
inputComBox.Items.Add(layer.Name);
}
//select the first layer
if (inputComBox.Items.Count > 0)
{
inputComBox.SelectedIndex = 0;
}
string tempDir = System.IO.Path.GetTempPath();
outputPath.Text = System.IO.Path.Combine(tempDir, ((string)inputComBox.SelectedItem + "_buffer.shp"));
//set the default units of the buffer
esriUnits mapUnit = _hookHelper.FocusMap.MapUnits;
switch (mapUnit)
{
case esriUnits.esriMeters:
unitsComBox.SelectedIndex = 0;
break;
case esriUnits.esriKilometers:
unitsComBox.SelectedIndex = 1;
break;
case esriUnits.esriMiles:
unitsComBox.SelectedIndex = 2;
break;
default:
Show(String.Format("未知单位 : {0} ", mapUnit));
break;
}
}
public static double UnitSacleToMeter(esriUnits unit)
{
switch (unit)
{
case esriUnits.esriKilometers:
return(1000);
case esriUnits.esriMeters:
return(1);
default:
return(-1);
}
}
private void UpdatePageSizedisplay()
{
double dPageWidth = 0.0;
double dPageHeight = 0.0;//页面的宽度和高度
esriUnits unit = m_pPageLayoutCtl.Page.Units;;
IPage page = m_pPageLayoutCtl.Page;
if (page.FormID == esriPageFormID.esriPageFormSameAsPrinter)
{
if (m_pPageLayoutCtl.Printer == null)
{
page.QuerySize(out dPageWidth, out dPageHeight);
}
else
{
ESRI.ArcGIS.Output.IPaper paper = m_pPageLayoutCtl.Printer.Paper;
paper.QueryPaperSize(out dPageWidth, out dPageHeight);
unit = paper.Units;
}
}
else
{
page.QuerySize(out dPageWidth, out dPageHeight);
}
if (unit != page.Units)
{
IGPLinearUnit gpLinearUnit = new GPLinearUnitClass();
gpLinearUnit.Units = page.Units;
gpLinearUnit.Value = dPageWidth;
dPageWidth = gpLinearUnit.ConvertValue(page.Units);
gpLinearUnit.Value = dPageHeight;
dPageHeight = gpLinearUnit.ConvertValue(page.Units);
}
txtPageWidth.Value = dPageWidth;
txtPageHeight.Value = dPageHeight;
if (m_pPageLayoutCtl.Page.Orientation == 1)
{
radioOritationPortrait.Checked = true;
}
else
{
radioOritationLandscape.Checked = true;
}
//设置单位列表
cmbPageUnit.SelectedIndex = (int)page.Units;
}
public MapInfo(IMap pMap)
{
_Map = pMap;
_Description = pMap.Description;
_DistanceUnits = pMap.DistanceUnits;
_Expanded = pMap.Expanded;
_IsFramed = pMap.IsFramed;
_LayoutCount = pMap.LayerCount;
_MapsurroundCount = pMap.MapSurroundCount;
_MapUnits = pMap.MapUnits;
_Name = pMap.Name;
_ReferenceScale = pMap.ReferenceScale;
_SelectionCount = pMap.SelectionCount;
_UseSymbolLevels = pMap.UseSymbolLevels;
}
public MapInfo(IMap pMap)
{
_Map = pMap;
_Description = pMap.Description;
_DistanceUnits = pMap.DistanceUnits;
_Expanded = pMap.Expanded;
_IsFramed = pMap.IsFramed;
_LayoutCount = pMap.LayerCount;
_MapsurroundCount = pMap.MapSurroundCount;
_MapUnits = pMap.MapUnits;
_Name = pMap.Name;
_ReferenceScale = pMap.ReferenceScale;
_SelectionCount = pMap.SelectionCount;
_UseSymbolLevels = pMap.UseSymbolLevels;
}
static public bool UnitFactor(esriUnits sourceUnit, out double factor)
{
factor = 1.0;
switch (sourceUnit)
{
case esriUnits.esriCentimeters:
factor = 0.01;
break;
case esriUnits.esriFeet:
factor = 0.3048; // International feet is 0.30480060960121919;
break;
case esriUnits.esriInches:
factor = 0.0254;
break;
case esriUnits.esriKilometers:
factor = 1000.0;
break;
case esriUnits.esriMeters:
factor = 1.0;
break;
case esriUnits.esriMiles:
factor = 1609.344;
break;
case esriUnits.esriMillimeters:
factor = 0.001;
break;
case esriUnits.esriNauticalMiles:
factor = 1852.0;
break;
case esriUnits.esriYards:
factor = 0.9144;
break;
default:
factor = 1.0;
return(false);
}
return(true);
}
public string FormatMapCoordinate(double dMapX, double dMapY, esriUnits eInUnits)
{
try
{
string str = null;
string str2 = null;
str = this.FormatMapCoordinate(dMapX, eInUnits);
str2 = this.FormatMapCoordinate(dMapY, eInUnits);
return(str + " " + str2);
}
catch (Exception exception)
{
this.mErrOpt.ErrorOperate(this.mSubSysName, "FunFactory.FormatFun", "FormatMapCoordinate", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
return(null);
}
}
public double ConvertESRIUnits(double dValue, esriUnits eInUnits, esriUnits eOutUnits)
{
try
{
if (this.mESRIConvertUnits == null)
{
this.mESRIConvertUnits = new UnitConverterClass();
}
return(this.mESRIConvertUnits.ConvertUnits(dValue, eInUnits, eOutUnits));
}
catch (Exception exception)
{
this.mErrOpt.ErrorOperate(this.mSubSysName, "FunFactory.UnitFun", "ConvertESRIUnits", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
return(-1.0);
}
}
public string FormatMapCoordinate(IPoint pPoint, esriUnits eInUnits)
{
try
{
if (pPoint == null)
{
return("");
}
return(this.FormatMapCoordinate(pPoint.X, pPoint.Y, eInUnits));
}
catch (Exception exception)
{
this.mErrOpt.ErrorOperate(this.mSubSysName, "FunFactory.FormatFun", "FormatMapCoordinate", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
return(null);
}
}
internal static string Key(esriUnits units)
{
switch (units)
{
case esriUnits.esriCentimeters:
return "Centimeters";
case esriUnits.esriDecimalDegrees:
throw new InvalidOperationException("DecimalDegrees");
case esriUnits.esriDecimeters:
return "Decimeters";
case esriUnits.esriFeet:
return "Feet (US Survey)";
case esriUnits.esriInches:
return "Inches (US Survey)";
case esriUnits.esriKilometers:
return "Kilometers";
case esriUnits.esriMeters:
return "Meters";
case esriUnits.esriMiles:
return "Miles (US Survey)";
case esriUnits.esriMillimeters:
return "Millimeters";
case esriUnits.esriNauticalMiles:
return "Nautical Miles (US)";
case esriUnits.esriPoints:
throw new InvalidOperationException("Pointss");
case esriUnits.esriUnitsLast:
throw new InvalidOperationException("Last Units");
case esriUnits.esriUnknownUnits:
return "Meters";
case esriUnits.esriYards:
return "Yards (US Survey)";
default:
return "Meters";
}
}
private void cboSize_TextChanged(object sender, System.EventArgs e)
{
Debug.WriteLine("size text changed");
this._BoxSize = double.NaN;
this._Units = esriUnits.esriUnknownUnits;
if (this._SizeRE.IsMatch(this.cboSize.Text))
{
Match theMatch = this._SizeRE.Match(this.cboSize.Text);
double theInput = Convert.ToDouble(theMatch.Groups[1].Value);
string theUnits = theMatch.Groups[2].Value;
this._BoxSize = theInput;
switch (theUnits)
{
case "ft":
this._Units = esriUnits.esriFeet;
break;
case "m":
this._Units = esriUnits.esriMeters;
break;
case "yd":
this._Units = esriUnits.esriYards;
break;
case "h":
this._BoxSize = theInput * 66;
this._Units = esriUnits.esriFeet;
break;
}
}
this.OnBoxChange(new EventArgs());
}
private long SpatialSelect(string sSedCoreLayer, string sSounderLayer, double dblRange, esriUnits eEsriUnitsContant)
{
IMxDocument pmxdoc = ArcMap.Document as IMxDocument;
IMap pmap = pmxdoc.FocusMap;
IFeatureSelection pFSel = FindLayer(pmap, sSedCoreLayer) as IFeatureSelection;
//pFSel.Clear();
IQueryByLayer pQBLayer = new QueryByLayerClass();
pQBLayer.ByLayer = FindLayer(pmap, sSounderLayer) as IFeatureLayer;
pQBLayer.FromLayer = pFSel as IFeatureLayer;
pQBLayer.BufferDistance = dblRange;
pQBLayer.BufferUnits = eEsriUnitsContant;
pQBLayer.ResultType = esriSelectionResultEnum.esriSelectionResultAdd;
pQBLayer.LayerSelectionMethod = esriLayerSelectionMethod.esriLayerSelectIntersect;
pQBLayer.UseSelectedFeatures = true;
pFSel.SelectionSet = pQBLayer.Select();
return pFSel.SelectionSet.Count;
}
public static double UnitSacleToMeter(esriUnits unit)
{
switch (unit)
{
case esriUnits.esriKilometers:
return 1000;
case esriUnits.esriMeters:
return 1;
default:
return -1;
}
}
private void selectFeatures()
{
IQueryByLayer _qrBl = new QueryByLayerClass();
int method=cbxMethod.SelectedIndex;
switch (method)
{
case 0:
_method = esriLayerSelectionMethod.esriLayerSelectIntersect;
break;
case 1:
_method = esriLayerSelectionMethod.esriLayerSelectContainedBy;
break;
case 2:
_method = esriLayerSelectionMethod.esriLayerSelectContains;
break;
default:
_method = esriLayerSelectionMethod.esriLayerSelectIntersect;
break;
}
int selectLayer = cbxSelectLayer.SelectedIndex;
_byLayer = _mapControl.get_Layer(selectLayer);
int resultType=cbxResultType.SelectedIndex;
switch (resultType)
{
case 0:
_resultType = esriSelectionResultEnum.esriSelectionResultNew;
break;
case 1:
_resultType = esriSelectionResultEnum.esriSelectionResultAdd;
break;
case 2:
_resultType = esriSelectionResultEnum.esriSelectionResultSubtract;
break;
case 3:
_resultType = esriSelectionResultEnum.esriSelectionResultAnd;
break;
case 4:
_resultType = esriSelectionResultEnum.esriSelectionResultXOR;
break;
default:
_resultType = esriSelectionResultEnum.esriSelectionResultNew;
break;
}
if (chkUseSelected.CheckState == CheckState.Unchecked)
{
_useSelected = false;
}
else
{
_useSelected = true;
}
bool re = false;
try
{
re = double.TryParse(txtBuffer.Text, out _buffer);
}
catch { }
if (!re)
{
_buffer = 0;
}
int unit = cbxUnit.SelectedIndex;
switch (unit)
{
case 0:
_bufferUnit = esriUnits.esriCentimeters;
break;
case 1:
_bufferUnit = esriUnits.esriDecimeters;
break;
case 2:
_bufferUnit = esriUnits.esriMeters;
break;
case 3:
_bufferUnit = esriUnits.esriKilometers;
break;
default:
_bufferUnit = esriUnits.esriMeters;
break;
}
_qrBl.ByLayer = (IFeatureLayer)_byLayer;
_qrBl.LayerSelectionMethod = _method;
_qrBl.ResultType = _resultType;
_qrBl.UseSelectedFeatures = _useSelected;
_qrBl.BufferDistance = _buffer;
_qrBl.BufferUnits = _bufferUnit;
foreach (object o in lstInputLayer.SelectedItems)
{
int index = lstInputLayer.Items.IndexOf(o);
_fromLayer = _mapControl.get_Layer(index);
_qrBl.FromLayer = (IFeatureLayer)_fromLayer;
ISelectionSet selectionSet;
IFeatureSelection featureSelection;
try
{
selectionSet = _qrBl.Select();
featureSelection = (IFeatureSelection)_fromLayer;
featureSelection.SelectionSet = selectionSet;
//MessageBox.Show("line 255 count=" + selectionSet.Count);
}
catch(Exception ex)
{ //MessageBox.Show("line 257 SelectByLocation, ex=" + ex);
continue; }
}
_mapControl.ActiveView.Refresh();
}
/// <summary>
/// 将输入的数据单位转化为米
/// </summary>
/// <param name="dValue"></param>
/// <param name="outUnits"></param>
/// <returns></returns>
public double UnitsConvertToMeters(double dValue,esriUnits outUnits)
{
IUnitConverter unitConverter = new UnitConverterClass();
double newValue = unitConverter.ConvertUnits(dValue, esriUnits.esriMeters, outUnits);
return newValue;
}
public UnitsParameterInfo(string name, string text, esriUnits initValue)
{
base._name = name;
base._text = text;
this._value = initValue;
}
private void button5_Click(object sender, EventArgs e)
{
IPoint pPoint = new PointClass();
pPoint.X = 40;
pPoint.Y = -101;
ISpatialReferenceFactory pSRF = new SpatialReferenceEnvironmentClass();
pPoint.SpatialReference = pSRF.CreateProjectedCoordinateSystem(4152);
pPoint.Project(pSRF.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_NAD1983HARN));
GeoToGra(pPoint);
esriUnits eu = new esriUnits();
axMapControl.MapUnits = esriUnits.esriMeters;
}
private static string XMLDistanceUnits(esriUnits unit)
{
// These are all the types. Not all can be mapped to esitUnits.
//
// _T("Meter"),_T("Metre"),_T("Foot"),_T("Link"),_T("Foot_US"),
// _T("Link_US"),_T("Chain"),_T("Chain_US"),_T("Rod"),_T("Rod_US")};
switch (unit)
{
case esriUnits.esriFeet:
return "Foot_US";
case esriUnits.esriMeters:
return "Meter";
//case esriUnits.esriKilometers:
//case esriUnits.esriMiles:
//case esriUnits.esriNauticalMiles:
//case esriUnits.esriYards:
}
return "Meter";
}
private IPolygon CreateBox(IPoint centre, double orientation, double size, esriUnits units)
{
// Orientation is in degrees from east, counterclockwise
// First point in the polygon will be on a face, at the orientation point
// Four points on the corners will be at sqrt(2) * size,
// at orientation+45, orientation+135, orientation+225 and orientation+315
ISDUTExtension theExt = this.Extension;
IPolygon theBox = new PolygonClass();
ISpatialReference theWorkingReference = theExt.FocusMap.SpatialReference;
theBox.SpatialReference = theWorkingReference;
esriUnits theWorkingUnits = esriUnits.esriMeters;
UnitConverter theConverter = new UnitConverterClass();
double theSize = theConverter.ConvertUnits(size, units, theWorkingUnits);
double theCornerDistance = Math.Sqrt(2) * theSize;
IPoint theCentroid = this._Wellsite;
theCentroid.Project(theWorkingReference);
Debug.WriteLine("Box centroid X: " + theCentroid.X + " Y: " + theCentroid.Y);
IPointCollection thePtColl = (IPointCollection)theBox;
object theMissing = Type.Missing;
// Place the first point
IPoint thePoint = new PointClass();
thePoint.SpatialReference = theWorkingReference;
double theAngle = orientation * Math.PI / 180;
((IConstructPoint2)thePoint).ConstructAngleDistance(theCentroid, theAngle, theSize);
Debug.WriteLine(" First point X: " + thePoint.X + " Y: " + thePoint.Y);
thePtColl.AddPoint(thePoint, ref theMissing, ref theMissing);
// Place the corners
for (int i = 1; i <= 4; i++)
{
thePoint = new PointClass();
thePoint.SpatialReference = theWorkingReference;
theAngle = (orientation - 45 + (i * 90)) * Math.PI / 180;
((IConstructPoint2)thePoint).ConstructAngleDistance(theCentroid, theAngle, theCornerDistance);
Debug.WriteLine(" Corner " + i + " X: " + thePoint.X + " Y: " + thePoint.Y);
thePtColl.AddPoint(thePoint, ref theMissing, ref theMissing);
}
theBox.Close();
return theBox;
}
public static esriCadastralAreaUnits DefaultAreaUnit(esriUnits eCadastralLayerDistanceUnit)
{
switch (eCadastralLayerDistanceUnit)
{
case esriUnits.esriMeters:
return esriCadastralAreaUnits.esriCAUSquareMeter;
case esriUnits.esriFeet:
return esriCadastralAreaUnits.esriCAUSquareFoot; // esriCAUAcre;
// TODO...
//case esriCDUUSSurveyFoot:
// return esriCAUAcre;
//break;
//// aka, default to meters for:
//case esriCDUChain:
//case esriCDULink:
//case esriCDURod:
// return esriCadastralAreaUnits.esriCAUMetric;
//case esriCDUUSSurveyChain:
//case esriCDUUSSurveyLink:
//case esriCDUUSSurveyRod:
// return esriCadastralAreaUnits.esriCAUAcre;
}
return esriCadastralAreaUnits.esriCAUSquareMeter; // default will always catch this.
}
public static string GetUnit(esriUnits eDistanceType, bool shortNotation)
{
if (!shortNotation)
switch (eDistanceType)
{
case esriUnits.esriMeters:
return (string)Application.Current.FindResource("strMeters");
case esriUnits.esriFeet:
return (string)Application.Current.FindResource("strFeet");
}
else
switch (eDistanceType)
{
case esriUnits.esriMeters:
return (string)Application.Current.FindResource("strMetersShort");
case esriUnits.esriFeet:
return (string)Application.Current.FindResource("strFeetShort");
}
return "";
}
public static bool UnitFactor(esriUnits sourceUnit, out double factor)
{
factor = 1.0;
switch (sourceUnit)
{
case esriUnits.esriCentimeters:
factor = 0.01;
break;
case esriUnits.esriFeet:
factor = 0.3048; // International feet is 0.30480060960121919;
break;
case esriUnits.esriInches:
factor = 0.0254;
break;
case esriUnits.esriKilometers:
factor = 1000.0;
break;
case esriUnits.esriMeters:
factor = 1.0;
break;
case esriUnits.esriMiles:
factor = 1609.344;
break;
case esriUnits.esriMillimeters:
factor = 0.001;
break;
case esriUnits.esriNauticalMiles:
factor = 1852.0;
break;
case esriUnits.esriYards:
factor = 0.9144;
break;
default:
factor = 1.0;
return false;
}
return true;
}
/// <summary>
/// 显示中文地图单位
/// </summary>
/// <param name="mapUnit"></param>
/// <returns></returns>
private string MapUnitChinese(esriUnits mapUnit)
{
string mapUnitChinese = "未知单位";
switch (mapUnit)
{
case esriUnits.esriCentimeters:
mapUnitChinese = "厘米";
break;
case esriUnits.esriDecimalDegrees:
mapUnitChinese = "分米";
break;
case esriUnits.esriDecimeters:
mapUnitChinese = "";
break;
//case esriUnits.esriFeet:
// mapUnitChinese = "";
// break;
//case esriUnits.esriInches:
// mapUnitChinese = "";
// break;
case esriUnits.esriKilometers:
mapUnitChinese = "千米";
break;
case esriUnits.esriMeters:
mapUnitChinese = "米";
break;
case esriUnits.esriMiles:
mapUnitChinese = "英里";
break;
case esriUnits.esriMillimeters:
mapUnitChinese = "毫米";
break;
//case esriUnits.esriYards:
// mapUnitChinese = "";
// break;
}
return mapUnitChinese;
}
public void ProcessFeature(IWorkspaceEdit iwe, IFeatureLayer ifl_active, IRow rw)
{
double value = double.NaN;
if (CoordinateSystem == "")
{
CoordinateSystem = ((IFeature)rw).Shape.SpatialReference.Name;
}
if (this.LinearUnit == null || this.LinearUnit == "")
{
if (fieldTier == 2)
{
LinearUnit = rw.get_Value(GetFieldUnitIndex()).ToString();
}
if (this.LinearUnit == null || this.LinearUnit.Trim() == "")
{
LinearUnit = GetSpatialReferenceLinearUnit(((IFeature)rw).Shape.SpatialReference);
}
}
if (LinearUnit.IndexOf("meter", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
if (useArealUnit)
{
currentAreaUnit = esriAreaUnits.esriSquareMeters;
LinearUnit = "Square Meters";
}
else
{
currentLinearUnit = esriUnits.esriMeters;
}
}
else if (LinearUnit.IndexOf("foot", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
if (useArealUnit)
{
currentAreaUnit = esriAreaUnits.esriSquareFeet;
LinearUnit = "Square Feet";
}
else
{
currentLinearUnit = esriUnits.esriFeet;
}
}
else if (LinearUnit.IndexOf("acre", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
currentAreaUnit = esriAreaUnits.esriAcres;
currentLinearUnit = esriUnits.esriUnknownUnits;
LinearUnit = "Acres";
}
if (doReCalcValues || !double.TryParse(rw.get_Value(GetFieldIndex()).ToString(), out value) || value == double.NaN || value == 0.0)
{
value = DoMeasure(rw);
//try writing the (single) measured value to the table
try
{
IFeature feat = (IFeature)rw;
//if we are re-calculating all values, there is no need to start editing on each row
if (!doReCalcValues)
{
if (!iwe.IsBeingEdited())
iwe.StartEditing(true);
iwe.StartEditOperation();
}
feat.set_Value(GetFieldIndex(), value);
feat.set_Value(GetFieldUnitIndex(), LinearUnit);
feat.Store();
}
catch (Exception err)
{
}
finally
{
if (!doReCalcValues)
{
iwe.StopEditOperation();
if (iwe.IsBeingEdited())
iwe.StopEditing(true);
//there may be more than one row that requires editing
doReCalcValues = true;
}
}
}
values.Add(value);
}
