private double GetReferenceFactor(IUnit entity)
{
Contract.Requires(entity != null);
IUnit convertTo;
if (StringComparer.OrdinalIgnoreCase.Equals("Length", entity.Type))
{
convertTo = OgcLinearUnit.DefaultMeter;
}
else if (StringComparer.OrdinalIgnoreCase.Equals("Angle", entity.Type))
{
convertTo = OgcAngularUnit.DefaultRadians;
}
else
{
return(Double.NaN);
}
var conversion = SimpleUnitConversionGenerator.FindConversion(entity, convertTo) as IUnitScalarConversion <double>;
if (null != conversion)
{
return(conversion.Factor);
}
return(Double.NaN);
}
private static ISpheroid <double> ConvertSpheroidUnit(ISpheroid <double> spheroid, IUnit toUnit)
{
Contract.Requires(spheroid != null);
Contract.Ensures(Contract.Result <ISpheroid <double> >() != null);
if (null == toUnit)
{
return(spheroid);
}
var spheroidInfo = spheroid as ISpheroidInfo;
if (null == spheroidInfo)
{
return(spheroid);
}
var fromUnit = spheroidInfo.AxisUnit;
if (null != fromUnit && !UnitEqualityComparer.Default.Equals(fromUnit, toUnit) && UnitEqualityComparer.Default.AreSameType(fromUnit, toUnit))
{
var conversion = SimpleUnitConversionGenerator.FindConversion(spheroidInfo.AxisUnit, toUnit);
if (null != conversion && !(conversion is UnitUnityConversion))
{
return(new SpheroidLinearUnitConversionWrapper(spheroidInfo, conversion));
}
}
return(spheroid);
}
public static ITransformation CreateCoordinateUnitConversion(IUnit from, IUnit to)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
Contract.EndContractBlock();
// if (null == from || null == to)
// return null;
if (!UnitEqualityComparer.Default.Equals(from, to) && UnitEqualityComparer.Default.AreSameType(from, to))
{
var conv = SimpleUnitConversionGenerator.FindConversion(from, to);
if (null != conv && !(conv is UnitUnityConversion))
{
if (UnitEqualityComparer.Default.NameNormalizedComparer.Equals("LENGTH", from.Type))
{
return(new LinearElementTransformation(conv));
}
if (UnitEqualityComparer.Default.NameNormalizedComparer.Equals("ANGLE", from.Type))
{
return(new AngularElementTransformation(conv));
}
}
}
return(null);
}
public void LocalCrsTest()
{
var input = String.Join(Environment.NewLine, new[] {
"LOCAL_CS[\"Astra Minas Grid\",",
"\tLOCAL_DATUM[\"Astra Minas\",10000,AUTHORITY[\"EPSG\",\"9300\"]],",
"\tUNIT[\"metre\",1],",
"\tAXIS[\"X\",NORTH],",
"\tAXIS[\"Y\",WEST],",
"\tAUTHORITY[\"EPSG\",\"5800\"]]"
});
var result = Default.Parse(input) as ICrsLocal;
Assert.IsNotNull(result);
Assert.AreEqual("Astra Minas Grid", result.Name);
Assert.AreEqual(new AuthorityTag("EPSG", "5800"), result.Authority);
var datum = result.Datum;
Assert.IsNotNull(datum);
Assert.AreEqual("Astra Minas", datum.Name);
Assert.AreEqual("Local", datum.Type);
Assert.AreEqual(new AuthorityTag("EPSG", "9300"), datum.Authority);
Assert.IsNotNull(result.Unit);
Assert.AreEqual("metre", result.Unit.Name);
Assert.AreEqual(1, (SimpleUnitConversionGenerator.FindConversion(result.Unit, OgcLinearUnit.DefaultMeter) as IUnitScalarConversion <double>).Factor);
Assert.IsNotNull(result.Axes);
Assert.AreEqual(2, result.Axes.Count);
Assert.AreEqual("X", result.Axes[0].Name);
Assert.AreEqual("North", result.Axes[0].Orientation);
Assert.AreEqual("Y", result.Axes[1].Name);
Assert.AreEqual("West", result.Axes[1].Orientation);
}
public void GradToDegreeTest()
{
var grad = new OgcAngularUnit("grad", Math.PI / 200);
var degree = new OgcAngularUnit("degree", Math.PI / 180);
var conversion = SimpleUnitConversionGenerator.FindConversion(grad, degree);
Assert.IsNotNull(conversion);
Assert.AreEqual(0.9, conversion.TransformValue(1), 0.00001);
}
public void BridgedReverseConversion()
{
var conversion = SimpleUnitConversionGenerator.FindConversion(Waffle, Chicken);
Assert.IsNotNull(conversion);
var chickensToMakeAWaffle = conversion.TransformValue(1);
Assert.AreEqual(1.0 / 3.0, chickensToMakeAWaffle);
}
public void BridgedForwardConversion()
{
var conversion = SimpleUnitConversionGenerator.FindConversion(Chicken, Waffle);
Assert.IsNotNull(conversion);
var wafflesFromAChicken = conversion.TransformValue(1);
Assert.AreEqual(3, wafflesFromAChicken);
}
public void SimpleReverseConversion()
{
var conversion = SimpleUnitConversionGenerator.FindConversion(Egg, Chicken);
Assert.IsNotNull(conversion);
var chickensForAnEgg = conversion.TransformValue(1);
Assert.AreEqual(1.0 / 6.0, chickensForAnEgg);
}
public void SimpleForwardConversion()
{
var conversion = SimpleUnitConversionGenerator.FindConversion(Chicken, Egg);
Assert.IsNotNull(conversion);
var eggsFromAChicken = conversion.TransformValue(1);
Assert.AreEqual(6, eggsFromAChicken);
}
public void SiAndImperialLengthTest()
{
var km = new OgcLinearUnit("kilometer", 1000);
var mile = new OgcLinearUnit("mile", 1609.344);
var conversion = SimpleUnitConversionGenerator.FindConversion(km, mile);
Assert.IsNotNull(conversion);
Assert.AreEqual(0.621371192, conversion.TransformValue(1), 0.00001);
}
public static Spheroid Create(ISpheroidInfo spheroidInfo)
{
if (spheroidInfo == null)
{
throw new ArgumentNullException("spheroidInfo");
}
Contract.Ensures(Contract.Result <Spheroid>() != null);
var aMeters = spheroidInfo.A;
var bMeters = spheroidInfo.B;
if (spheroidInfo.AxisUnit != null)
{
var conversion = SimpleUnitConversionGenerator.FindConversion(spheroidInfo.AxisUnit, Proj4LinearUnit.Meter);
if (conversion != null && !(conversion is UnitUnityConversion))
{
aMeters = conversion.TransformValue(aMeters);
bMeters = conversion.TransformValue(bMeters);
}
}
Spheroid result;
if (aMeters == bMeters)
{
var knownMatch = AllKnownSpheroids
.Where(k => k.PolarRadius == aMeters)
.OrderByDescending(k => SpheroidNameNormalizedComparer.Default.Equals(k.Name, spheroidInfo.Name))
.FirstOrDefault();
if (knownMatch != null)
{
return(knownMatch);
}
result = new Spheroid(Proj4Ellipsoid.Custom);
result.PolarRadius = aMeters;
}
else
{
var knownMatch = AllKnownSpheroids
.Where(k => k.EquatorialRadius == aMeters && (k.InverseFlattening == spheroidInfo.InvF || k.PolarRadius == bMeters))
.OrderByDescending(k => SpheroidNameNormalizedComparer.Default.Equals(k.Name, spheroidInfo.Name))
.FirstOrDefault();
if (knownMatch != null)
{
return(knownMatch);
}
result = new Spheroid(Proj4Ellipsoid.Custom);
result.EquatorialRadius = aMeters;
// NOTE: do not directly set the InverseFlattening as it is stored as PolarRadius
result.PolarRadius = bMeters;
}
result.Name = spheroidInfo.Name;
return(result);
}
private bool ComputationallyEqual(IUnit a, IUnit b)
{
if (a == b)
{
return(true);
}
if (a == null || b == null)
{
return(false);
}
var conversion = SimpleUnitConversionGenerator.FindConversion(a, b);
return(ConversionIsUnity(conversion));
}
private static bool ConvertIfVaild(IUnit from, IUnit to, ref double value)
{
if (null == from || null == to)
{
return(false);
}
var conv = SimpleUnitConversionGenerator.FindConversion(from, to);
if (null == conv)
{
return(false);
}
value = conv.TransformValue(value);
return(true);
}
public double?GetValueAsDouble(IUnit unit)
{
var value = GetValueAsDouble();
if (unit != null && Selection.Unit != null && value.HasValue && !unit.Equals(Selection.Unit))
{
var conversion = SimpleUnitConversionGenerator.FindConversion(Selection.Unit, unit);
if (conversion == null)
{
throw new InvalidOperationException();
}
value = conversion.TransformValue(value.GetValueOrDefault());
}
return(value);
}
public bool TryGetValueAsDouble(IUnit unit, out double value)
{
if (!TryGetValueAsDouble(out value))
{
return(false);
}
if (unit != null && Selection.Unit != null && !unit.Equals(Selection.Unit))
{
var conversion = SimpleUnitConversionGenerator.FindConversion(Selection.Unit, unit);
if (conversion == null)
{
throw new InvalidOperationException();
}
value = conversion.TransformValue(value);
}
return(true);
}
public static LinearUnit ConvertToProj4(IUnit unit)
{
if (unit == null)
{
throw new ArgumentNullException("unit");
}
Contract.EndContractBlock();
var conversion = SimpleUnitConversionGenerator.FindConversion(unit, MetersUnitWrapped);
if (conversion != null)
{
if (conversion is UnitUnityConversion)
{
return(MetersUnit);
}
var scalarConversion = conversion as IUnitScalarConversion <double>;
if (scalarConversion != null)
{
var knownMatch = KnownUnits.FirstOrDefault(x => x.Meters == scalarConversion.Factor);
if (knownMatch != null)
{
return(knownMatch);
}
var customResult = new LinearUnit();
customResult.Meters = scalarConversion.Factor;
customResult.Name = unit.Name;
return(customResult);
}
}
return(new LinearUnit {
Meters = 1,
Name = unit.Name
});
}
public static Meridian Create(IPrimeMeridianInfo primeMeridian)
{
if (primeMeridian == null)
{
throw new ArgumentNullException("primeMeridian");
}
Contract.Ensures(Contract.Result <Meridian>() != null);
var lon = primeMeridian.Longitude;
if (primeMeridian.Unit.Name != "degrees")
{
var conversion = SimpleUnitConversionGenerator.FindConversion(primeMeridian.Unit, OgcAngularUnit.DefaultDegrees);
if (conversion != null)
{
lon = conversion.TransformValue(lon);
}
else
{
throw new InvalidOperationException("Could not convert meridian unit.");
}
}
var result = new Meridian(lon, primeMeridian.Name);
if (primeMeridian.Authority != null)
{
int epsgCode;
if (primeMeridian.Authority.Name == "EPSG" && Int32.TryParse(primeMeridian.Authority.Code, out epsgCode))
{
result.Code = epsgCode;
}
}
return(result);
}
public void Write(ISpheroidInfo entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
Contract.EndContractBlock();
Write(WktKeyword.Spheroid);
WriteOpenParenthesis();
Indent();
WriteQuoted(entity.Name);
WriteComma();
// the axis value must be in meters
var a = entity.A;
if (entity.AxisUnit != null)
{
var conversion = SimpleUnitConversionGenerator.FindConversion(entity.AxisUnit, OgcLinearUnit.DefaultMeter);
if (null != conversion)
{
a = conversion.TransformValue(a);
}
}
WriteValue(a);
WriteComma();
WriteValue(entity.InvF);
if (null != entity.Authority)
{
WriteComma();
Write(entity.Authority);
}
UnIndent();
WriteCloseParenthesis();
}
public void FittedTest()
{
var input = String.Join(Environment.NewLine, new[] {
"FITTED_CS[\"Test Fitted\",",
"\tPARAM_MT[\"Abc\",",
"\t\tPARAMETER[\"def\",\"blah\"]],",
"\tGEOCCS[\"aaaa\",",
"\t\tDATUM[\"?\",",
"\t\t\tSPHEROID[\"a ball\",123456,278]],",
"\t\tPRIMEM[\"most important place in the word\",99999],",
"\t\tUNIT[\"a stick\",1.123],",
"\t\tAXIS[\"a\",UP]]]"
});
var result = Default.Parse(input);
Assert.IsNotNull(result);
var fitted = result as ICrsFitted;
Assert.IsNotNull(fitted);
Assert.AreEqual("Test Fitted", fitted.Name);
var coordinateOperation = fitted.ToBaseOperation as IParameterizedCoordinateOperationInfo;
Assert.IsNotNull(coordinateOperation);
Assert.AreEqual("Abc", coordinateOperation.Name);
Assert.AreEqual(coordinateOperation.IsInverseOfDefinition, false);
Assert.AreEqual(coordinateOperation.HasInverse, true);
Assert.AreEqual(1, coordinateOperation.Parameters.Count());
Assert.AreEqual("def", coordinateOperation.Parameters.First().Name);
Assert.AreEqual("blah", coordinateOperation.Parameters.First().Value);
Assert.AreEqual("Abc", coordinateOperation.Method.Name);
var baseCrs = fitted.BaseCrs as ICrsGeodetic;
Assert.IsNotNull(baseCrs);
Assert.AreEqual("aaaa", baseCrs.Name);
var datum = baseCrs.Datum;
Assert.IsNotNull(datum);
Assert.AreEqual("?", datum.Name);
var spheroid = datum.Spheroid;
Assert.IsNotNull(spheroid);
Assert.AreEqual(123456, spheroid.A);
Assert.AreEqual(278, spheroid.InvF);
Assert.AreEqual("a ball", spheroid.Name);
var meridian = datum.PrimeMeridian;
Assert.IsNotNull(meridian);
Assert.AreEqual("most important place in the word", meridian.Name);
Assert.AreEqual(99999, meridian.Longitude);
var unit = baseCrs.Unit;
Assert.IsNotNull(unit);
Assert.AreEqual("a stick", unit.Name);
Assert.AreEqual(1.123, (SimpleUnitConversionGenerator.FindConversion(unit, OgcLinearUnit.DefaultMeter) as IUnitScalarConversion <double>).Factor);
var axis = baseCrs.Axes.FirstOrDefault();
Assert.IsNotNull(axis);
Assert.AreEqual("a", axis.Name);
Assert.AreEqual("Up", axis.Orientation);
}
