private void createVerticalCoordinateSystem()
{
ISpatialReferenceFactory3 spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
IVerticalDatum verticalDatum = spatialReferenceFactory.CreateVerticalDatum((int)esriSRVerticalDatumType.esriSRVertDatum_Taranaki);
IHVDatum hvDatum = verticalDatum as IHVDatum;
ILinearUnit linearUnit = spatialReferenceFactory.CreateUnit((int)esriSRUnitType.esriSRUnit_Meter) as ILinearUnit;
IVerticalCoordinateSystemEdit verticalCoordinateSystemEdit = new VerticalCoordinateSystemClass();
object name = "New VCoordinateSystem";
object alias = "VCoordinateSystem alias";
object abbreviation = "abbr";
object remarks = "Test for options";
object usage = "New Zealand";
object hvDatumObject = hvDatum as object;
object unitObject = linearUnit as object;
object verticalShift = 40 as object;
object positiveDirection = -1 as object;
verticalCoordinateSystemEdit.Define(ref name, ref alias, ref abbreviation, ref remarks, ref usage, ref hvDatumObject, ref unitObject, ref verticalShift, ref positiveDirection);
IVerticalCoordinateSystem verticalCoordinateSystem = verticalCoordinateSystemEdit as IVerticalCoordinateSystem;
m_map.SpatialReference = verticalCoordinateSystem as ISpatialReference;
m_activeView.Refresh();
MessageBox.Show("自定义verticalCoordinateSystem完成！");
}
private static ICoordinateSystem ReadCoordinateSystem(string coordinateSystem, WktStreamTokenizer tokenizer)
{
ICoordinateSystem returnCS = null;
switch (coordinateSystem)
{
case "VERT_CS":
IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(tokenizer);
returnCS = verticalCS;
break;
case "GEOGCS":
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(tokenizer);
returnCS = geographicCS;
break;
case "PROJCS":
IProjectedCoordinateSystem projectedCS = ReadProjectedCoordinateSystem(tokenizer);
returnCS = projectedCS;
break;
case "COMPD_CS":
ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(tokenizer);
returnCS = compoundCS;
break;
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
throw new InvalidOperationException(String.Format("{0} coordinate system is not recongized.", coordinateSystem));
}
return(returnCS);
}
public void TestCreateVerticalCoordinateSystem1()
{
IVerticalCoordinateSystem vcs = _factory.CreateVerticalCoordinateSystem("5701");
Assertion.AssertEquals("vcs ctor. 1", "Newlyn", vcs.Name);
Assertion.AssertEquals("vcs ctor. 2", "Ordnance Datum Newlyn", vcs.VerticalDatum.Name);
}
private static string GetVCSDisplayName([NotNull] ISpatialReference spatialReference)
{
IVerticalCoordinateSystem vcs =
SpatialReferenceUtils.GetVerticalCoordinateSystem(spatialReference);
return(vcs == null
? LocalizableStrings.QaSchemaSpatialReference_NotDefined
: vcs.Name);
}
public void TestReadVerticalCoordinateSystem2()
{
string testFile = Global.GetUnitTestRootDirectory() + @"\IO\VerticalCoordinateSystem.txt";
string wkt1 = FileToString(testFile);
IVerticalCoordinateSystem verticalCoordinateSystem = CoordinateSystemWktReader.Create(wkt1) as IVerticalCoordinateSystem;
string wkt2 = verticalCoordinateSystem.WKT;
bool same = Compare.CompareAgainstString(testFile, wkt2);
Assertion.AssertEquals("vertical coordinate system 1", true, same);
}
protected void ExecuteTests(IVerticalCoordinateSystem source, IVerticalCoordinateSystem target, bool inverse)
{
CoordinateTransformationFactory ctf = new CoordinateTransformationFactory();
ICoordinateTransformation coordinateTransformation = ctf.CreateFromCoordinateSystems(source, target);
if( inverse )
ExecuteTests(coordinateTransformation.MathTransform.Inverse);
else
ExecuteTests(coordinateTransformation.MathTransform);
}
public void TestWriteVerticalCoordinateSystem()
{
IVerticalCoordinateSystem VerticalCoordinateSystem = _factory.CreateVerticalCoordinateSystem("5701");
TextWriter textwriter = new StringWriter();
IndentedTextWriter indentedTextWriter = new IndentedTextWriter(textwriter);
CoordinateSystemWktWriter.Write(VerticalCoordinateSystem, indentedTextWriter);
bool same = Compare.CompareAgainstString(Global.GetUnitTestRootDirectory() + @"\IO\VerticalCoordinateSystem.txt", textwriter.ToString());
Assertion.AssertEquals("test 1", true, same);
}
private static void WriteVerticalCoordinateSystem(IVerticalCoordinateSystem verticalCoordinateSystem, IndentedTextWriter writer)
{
writer.WriteLine("VERT_CS[");
writer.Indent = writer.Indent + 1;
writer.WriteLine(String.Format("\"{0}\",", verticalCoordinateSystem.Name));
WriteDatum(verticalCoordinateSystem.VerticalDatum, writer);
WriteUnit(verticalCoordinateSystem.VerticalUnit, writer);
writer.WriteLine(String.Format("AUTHORITY[\"{0}\",\"{1}\"]", verticalCoordinateSystem.Authority, verticalCoordinateSystem.AuthorityCode));
writer.Indent = writer.Indent - 1;
writer.WriteLine("]");
}
public void TestCreateVerticalCoordinateSystem3()
{
try
{
IVerticalCoordinateSystem vcs = _factory.CreateVerticalCoordinateSystem("-1");
Assertion.Fail("ArguementException should be thrown.");
}
catch (ArgumentException)
{
}
}
public void TestCreateVerticalCoordinateSystem1()
{
IAxisInfo axis = AxisInfo.Altitude;
ILinearUnit unit = LinearUnit.Meters;
IVerticalDatum verticalDatum = _csFactory.CreateVerticalDatum("vertdatum", DatumType.IVD_Ellipsoidal);
IVerticalCoordinateSystem verticalCS = _csFactory.CreateVerticalCoordinateSystem("test", verticalDatum, unit, axis);
Assertion.AssertEquals("ctor. 1", "test", verticalCS.Name);
Assertion.AssertEquals("ctor. 2", verticalDatum, verticalCS.VerticalDatum);
Assertion.AssertEquals("ctor. 3", unit, verticalCS.VerticalUnit);
Assertion.AssertEquals("ctor. 4", axis, verticalCS.GetAxis(0));
}
private static void WriteVerticalCoordinateSystem(IVerticalCoordinateSystem verticalCoordinateSystem, XmlTextWriter writer)
{
writer.WriteStartElement("CS_VerticalCoordinateSystem");
//writer.WriteAttributeString("Dimension",verticalCoordinateSystem.Dimension.ToString());
WriteCSInfo(verticalCoordinateSystem, writer);
for (int i = 0; i < verticalCoordinateSystem.Dimension; i++)
{
WriteAxis(verticalCoordinateSystem.GetAxis(i), writer);
}
WriteVerticalDatum(verticalCoordinateSystem.VerticalDatum, writer);
WriteLinearUnit(verticalCoordinateSystem.VerticalUnit, writer);
writer.WriteEndElement();
}
private void VCSControlPage_Load(object sender, EventArgs e)
{
ISpatialReferenceFactory3 factory = new SpatialReferenceEnvironmentClass();
TreeNode node = new TreeNode("垂直坐标系文件夹", 0, 1);
this.treeView1.Nodes.Add(node);
string path = System.IO.Path.Combine(Application.StartupPath,
@"Coordinate Systems\Vertical Coordinate Systems");
if (Directory.Exists(path))
{
string[] directories = Directory.GetDirectories(path);
for (int i = 0; i < directories.Length; i++)
{
TreeNode node2 = new TreeNode(System.IO.Path.GetFileName(directories[i]), 0, 1);
node.Nodes.Add(node2);
string[] files = Directory.GetFiles(directories[i]);
for (int j = 0; j < files.Length; j++)
{
if (System.IO.Path.GetExtension(files[j]).ToLower() == ".prj")
{
IVerticalCoordinateSystem system =
factory.CreateESRISpatialReferenceInfoFromPRJFile(files[j]) as IVerticalCoordinateSystem;
if (system != null)
{
TreeNode node3 = new TreeNode(System.IO.Path.GetFileName(files[j]), 2, 2)
{
Tag = system
};
node2.Nodes.Add(node3);
}
}
}
}
}
node = new TreeNode("<NONE>", 2, 2)
{
Tag = null
};
this.treeView1.Nodes.Add(node);
}
private static ICoordinateSystem ReadCoordinateSystem(XmlTextReader reader)
{
//reader.Read();
ICoordinateSystem returnCS = null;
switch (reader.Name)
{
case "CS_VerticalCoordinateSystem":
IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(reader);
returnCS = verticalCS;
break;
case "CS_GeographicCoordinateSystem":
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(reader);
returnCS = geographicCS;
break;
case "CS_ProjectedCoordinateSystem":
IProjectedCoordinateSystem projectedCS = ReadProjectedCoordinateSystem(reader);
returnCS = projectedCS;
break;
case "CS_CompoundCoordinateSystem":
ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(reader);
returnCS = compoundCS;
break;
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
throw new InvalidOperationException(String.Format("{0} coordinate system is not recongized.", reader.Name));
//default:
// throw new ParseException(String.Format("Coordinate System {0} was not understoon.",reader.Name));
}
//reader.Read();
return(returnCS);
}
public static ISpatialReference GetUniqueSpatialReference(
[NotNull] IEnumerable <ISpatialReference> spatialReferences,
bool requireEqualVerticalCoordinateSystems)
{
Assert.ArgumentNotNull(spatialReferences, nameof(spatialReferences));
IVerticalCoordinateSystem uniqueVcs = null;
ISpatialReference uniqueSref = null;
double bestResolution = double.MaxValue;
foreach (ISpatialReference sref in spatialReferences)
{
if (uniqueSref == null)
{
uniqueSref = sref;
bestResolution = SpatialReferenceUtils.GetXyResolution(uniqueSref);
}
else
{
if (requireEqualVerticalCoordinateSystems)
{
IVerticalCoordinateSystem vcs =
SpatialReferenceUtils.GetVerticalCoordinateSystem(sref);
if (vcs != null)
{
if (uniqueVcs == null)
{
uniqueVcs = vcs;
}
else
{
if (vcs != uniqueVcs &&
!((IClone)uniqueVcs).IsEqual((IClone)vcs))
{
throw new ArgumentException(
string.Format(
"Defined vertical coordinate systems are not equal: {0}, {1}",
vcs.Name, uniqueVcs.Name));
}
}
}
}
if (uniqueSref != sref)
{
var compareSpatialReferences =
(ICompareCoordinateSystems)uniqueSref;
if (!compareSpatialReferences.IsEqualNoVCS(sref))
{
throw new ArgumentException(
string.Format(
"Coordinate systems are not equal: {0}, {1}",
sref.Name, uniqueSref.Name));
}
// if the resolution is higher --> use as new unique
double resolution = SpatialReferenceUtils.GetXyResolution(sref);
if (resolution < bestResolution)
{
bestResolution = resolution;
uniqueSref = sref;
}
}
}
}
return(uniqueSref);
}
/// <summary>
/// Creates the appropriate object given a string containing XML.
/// </summary>
/// <param name="wkt">String containing XML.</param>
/// <returns>Object representation of the XML.</returns>
/// <exception cref="ParseException">If a token is not recognised.</exception>
public static object Create(string wkt)
{
object returnObject = null;
StringReader reader = new StringReader(wkt);
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
tokenizer.NextToken();
string objectName = tokenizer.GetStringValue();
switch (objectName)
{
case "UNIT":
IUnit unit = ReadUnit(tokenizer);
returnObject = unit;
break;
case "VERT_DATUM":
IVerticalDatum verticalDatum = ReadVerticalDatum(tokenizer);
returnObject = verticalDatum;
break;
case "SPHEROID":
IEllipsoid ellipsoid = ReadEllipsoid(tokenizer);
returnObject = ellipsoid;
break;
case "TOWGS84":
WGS84ConversionInfo wgsInfo = ReadWGS84ConversionInfo(tokenizer);
returnObject = wgsInfo;
break;
case "DATUM":
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(tokenizer);
returnObject = horizontalDatum;
break;
case "PRIMEM":
IPrimeMeridian primeMeridian = ReadPrimeMeridian(tokenizer);
returnObject = primeMeridian;
break;
case "VERT_CS":
IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(tokenizer);
returnObject = verticalCS;
break;
case "GEOGCS":
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(tokenizer);
returnObject = geographicCS;
break;
case "PROJCS":
IProjectedCoordinateSystem projectedCS = ReadProjectedCoordinateSystem(tokenizer);
returnObject = projectedCS;
break;
case "COMPD_CS":
ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(tokenizer);
returnObject = compoundCS;
break;
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
throw new NotSupportedException(String.Format("{0} is not implemented.", objectName));
default:
throw new ParseException(String.Format("'{0'} is not recongnized.", objectName));
}
reader.Close();
return(returnObject);
}
protected void ExecuteTests(IVerticalCoordinateSystem source, IVerticalCoordinateSystem target)
{
ExecuteTests(source, target, false);
}
public static object Create(XmlTextReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
// we don't want to handle whitespace
reader.WhitespaceHandling = WhitespaceHandling.None;
object returnObject = null;
reader.Read();
// skip declarions and comments.
while (reader.NodeType != XmlNodeType.Element)
{
reader.Read();
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "CS_LinearUnit":
ILinearUnit linearUnit = ReadLinearUnit(reader);
returnObject = linearUnit;
break;
case "CS_AngularUnit":
IAngularUnit angularUnit = ReadAngularUnit(reader);
returnObject = angularUnit;
break;
case "CS_VerticalDatum":
IVerticalDatum verticalDatum = ReadVerticalDatum(reader);
returnObject = verticalDatum;
break;
case "CS_Ellipsoid":
IEllipsoid ellipsoid = ReadEllipsoid(reader);
returnObject = ellipsoid;
break;
case "CS_WGS84ConversionInfo":
WGS84ConversionInfo wgsInfo = ReadWGS84ConversionInfo(reader);
returnObject = wgsInfo;
break;
case "CS_HorizontalDatum":
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(reader);
returnObject = horizontalDatum;
break;
case "CS_PrimeMeridian":
IPrimeMeridian primeMeridian = ReadPrimeMeridian(reader);
returnObject = primeMeridian;
break;
case "CS_VerticalCoordinateSystem":
IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(reader);
returnObject = verticalCS;
break;
case "CS_GeographicCoordinateSystem":
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(reader);
returnObject = geographicCS;
break;
case "CS_ProjectedCoordinateSystem":
IProjectedCoordinateSystem projectedCS = ReadProjectedCoordinateSystem(reader);
returnObject = projectedCS;
break;
case "CS_CompoundCoordinateSystem":
ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(reader);
returnObject = compoundCS;
break;
case "CS_Projection":
IProjection projection = ReadProjection(reader);
returnObject = projection;
break;
case "CS_CoordinateSystem":
// must be a compound coord sys since all other coord system should have been
// taken care of by now.
reader.Read();
ICoordinateSystem coordinateSystem = ReadCompoundCoordinateSystem(reader);
reader.Read();
returnObject = coordinateSystem;
break;
case "CS_GEOCCS":
case "CS_FITTED_CS":
case "CS_LOCAL_CS":
throw new NotSupportedException(String.Format("{0} is not implemented.", reader.Name));
default:
throw new ParseException(String.Format("Element type {0} was is not understoon.", reader.Name));
}
}
return(returnObject);
}
private void btnOK_Click(object sender, EventArgs e)
{
if (this.textEditName.Text.Length == 0)
{
MessageBox.Show("未指定名字，必须为坐标系统指定一个名字！");
}
else
{
double num;
if (this.cboLineUnitName.SelectedIndex <= 0)
{
num = Convert.ToDouble(this.txtValue.Text);
((ILinearUnitEdit)this.iunit_0).DefineEx(this.cboLineUnitName.Text, null, null, null, ref num);
}
if (this.rdoVCSBase.SelectedIndex == 0)
{
string name = this.cboProjectName.Text;
if (name.Trim().Length == 0)
{
MessageBox.Show("请选择数据框架！");
return;
}
this.ihvdatum_0 = new VerticalDatumClass();
((IVerticalDatumEdit)this.ihvdatum_0).DefineEx(name, name, name, name);
}
else
{
if (this.cboDatumName.Text.Trim().Length == 0)
{
MessageBox.Show("请选择数据框架！");
return;
}
if (this.cboSpheres.SelectedIndex <= 0)
{
double num2;
num = Convert.ToDouble(this.txtMajorAxis.Text);
if (this.rdoFlattening.Checked)
{
num2 = 1.0 / Convert.ToDouble(this.txtFlattening.Text);
}
else
{
double num3 = Convert.ToDouble(this.txtMiniorAxis.Text);
num2 = (num - num3) / num;
}
((ISpheroidEdit)this.ispheroid_0).DefineEx(this.cboSpheres.Text, null, null, null, ref num,
ref num2);
}
if (this.cboDatumName.SelectedIndex <= 0)
{
this.ihvdatum_0 = new DatumClass();
((IDatumEdit)this.ihvdatum_0).DefineEx(this.cboDatumName.Text, null, null, null,
this.ispheroid_0);
}
}
object text = this.textEditName.Text;
object alias = this.textEditName.Text;
object abbreviation = this.textEditName.Text;
object remarks = this.textEditName.Text;
object useage = "everywhere!";
object hvDatum = this.ihvdatum_0;
object projectedUnit = this.iunit_0;
object verticalShift = this.double_0[0];
object positiveDirection = this.double_0[1];
if (this.iverticalCoordinateSystem_0 == null)
{
this.iverticalCoordinateSystem_0 = new VerticalCoordinateSystemClass();
}
(this.iverticalCoordinateSystem_0 as IVerticalCoordinateSystemEdit).Define(ref text, ref alias,
ref abbreviation, ref remarks, ref useage, ref hvDatum, ref projectedUnit, ref verticalShift,
ref positiveDirection);
base.DialogResult = DialogResult.OK;
}
}
private static void WriteVerticalCoordinateSystem(IVerticalCoordinateSystem verticalCoordinateSystem, IndentedTextWriter writer)
{
writer.WriteLine("VERT_CS[");
writer.Indent=writer.Indent+1;
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "\"{0}\",", verticalCoordinateSystem.Name));
WriteDatum( verticalCoordinateSystem.VerticalDatum, writer );
WriteUnit( verticalCoordinateSystem.VerticalUnit, writer );
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "AUTHORITY[\"{0}\",\"{1}\"]", verticalCoordinateSystem.Authority, verticalCoordinateSystem.AuthorityCode));
writer.Indent=writer.Indent-1;
writer.WriteLine("]");
}
public void Test_StaticConstructor()
{
IVerticalCoordinateSystem vcs = VerticalCoordinateSystem.Ellipsoidal;
Assertion.AssertEquals("Test1", "Ellipsoidal", vcs.Name);
}
private void frmNewVCS_Load(object sender, EventArgs e)
{
int index;
if (this.bool_1)
{
this.Text = "编辑垂直坐标系";
}
else
{
this.Text = "新建垂直坐标系";
}
this.rdoMiniorAxis.Checked = true;
this.txtFlattening.Enabled = false;
if (this.iverticalCoordinateSystem_0 == null)
{
this.bool_0 = true;
index = -1;
this.iverticalCoordinateSystem_0 = new VerticalCoordinateSystemClass();
this.iunit_0 = this.iverticalCoordinateSystem_0.CoordinateUnit;
this.ihvdatum_0 = this.iverticalCoordinateSystem_0.Datum;
if (this.ihvdatum_0 is IDatum)
{
this.ispheroid_0 = (this.ihvdatum_0 as IDatum).Spheroid;
this.rdoVCSBase.SelectedIndex = 1;
index = this.cboDatumName.Properties.Items.IndexOf((this.ihvdatum_0 as IDatum).Name);
if (index != -1)
{
this.cboDatumName.SelectedIndex = index;
}
else
{
this.cboDatumName.Text = (this.ihvdatum_0 as IDatum).Name;
if (this.cboDatumName.Text == "")
{
this.cboDatumName.SelectedIndex = 0;
}
else
{
index = this.cboSpheres.Properties.Items.IndexOf((this.ihvdatum_0 as IDatum).Spheroid.Name);
if (index != -1)
{
this.cboSpheres.SelectedIndex = index;
}
else
{
this.cboSpheres.Text = (this.ihvdatum_0 as IDatum).Spheroid.Name;
this.txtMajorAxis.Text = this.ispheroid_0.SemiMajorAxis.ToString();
this.txtMiniorAxis.Text = this.ispheroid_0.SemiMinorAxis.ToString();
double num2 = 1.0 / this.ispheroid_0.Flattening;
this.txtFlattening.Text = num2.ToString();
}
}
}
}
else
{
this.rdoVCSBase.SelectedIndex = 0;
this.cboProjectName.Text = (this.ihvdatum_0 as IVerticalDatum).Name;
}
this.cboLineUnitName.SelectedIndex = 1;
index = this.cboLineUnitName.Properties.Items.IndexOf(this.iunit_0.Name);
if (index != -1)
{
this.cboLineUnitName.SelectedIndex = index;
}
else
{
this.cboLineUnitName.Text = this.iunit_0.Name;
this.txtValue.Text = (this.iunit_0 as ILinearUnit).MetersPerUnit.ToString();
}
}
else
{
this.textEditName.Text = this.iverticalCoordinateSystem_0.Name;
this.ihvdatum_0 = this.iverticalCoordinateSystem_0.Datum;
index = -1;
this.iunit_0 = this.iverticalCoordinateSystem_0.CoordinateUnit;
if (this.ihvdatum_0 is IDatum)
{
this.ispheroid_0 = (this.ihvdatum_0 as IDatum).Spheroid;
this.rdoVCSBase.SelectedIndex = 1;
index = this.cboDatumName.Properties.Items.IndexOf((this.ihvdatum_0 as IDatum).Name);
if (index != -1)
{
this.cboDatumName.SelectedIndex = index;
}
else
{
this.cboDatumName.Text = (this.ihvdatum_0 as IDatum).Name;
index = this.cboSpheres.Properties.Items.IndexOf((this.ihvdatum_0 as IDatum).Spheroid.Name);
if (index != -1)
{
this.cboSpheres.SelectedIndex = index;
}
else
{
this.cboSpheres.Text = (this.ihvdatum_0 as IDatum).Spheroid.Name;
this.txtMajorAxis.Text = this.ispheroid_0.SemiMajorAxis.ToString();
this.txtMiniorAxis.Text = this.ispheroid_0.SemiMinorAxis.ToString();
this.txtFlattening.Text = (1.0 / this.ispheroid_0.Flattening).ToString();
}
}
}
else
{
this.rdoVCSBase.SelectedIndex = 0;
this.cboProjectName.Text = (this.ihvdatum_0 as IVerticalDatum).Name;
}
index = this.cboLineUnitName.Properties.Items.IndexOf(this.iunit_0.Name);
if (index != -1)
{
this.cboLineUnitName.SelectedIndex = index;
}
else
{
this.cboLineUnitName.Text = this.iunit_0.Name;
this.txtValue.Text = (this.iunit_0 as ILinearUnit).MetersPerUnit.ToString();
}
(this.iverticalCoordinateSystem_0 as IVerticalCoordinateSystemGEN).GetParameters(ref this.iparameter_0);
if (this.iparameter_0[0] != null)
{
this.double_0[0] = this.iparameter_0[0].Value;
if (this.iparameter_0[1] != null)
{
this.double_0[1] = this.iparameter_0[1].Value;
}
}
this.bool_0 = true;
}
this.method_0(this.iparameter_0);
}
