internal ActualCoordinateSystem(ICoordinateSystem coordinateSystem)
{
if (coordinateSystem == null)
throw new ArgumentNullException("coordinateSystem"); //NOXLATE
CoordinateTransformationFactory f = new CoordinateTransformationFactory();
CoordinateSystemFactory cf = new CoordinateSystemFactory();
m_transform = f.CreateFromCoordinateSystems(coordinateSystem, cf.CreateFromWkt(XY_M));
}
/// <summary>
/// Creates a transformation between two coordinate systems.
/// </summary>
/// <remarks>
/// This method will examine the coordinate systems in order to construct
/// a transformation between them. This method may fail if no path between
/// the coordinate systems is found, using the normal failing behavior of
/// the DCP (e.g. throwing an exception).</remarks>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <returns></returns>
public ICoordinateTransformation CreateFromCoordinateSystems(ICoordinateSystem sourceCS, ICoordinateSystem targetCS)
{
ICoordinateTransformation trans;
if (sourceCS is IProjectedCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Projected -> Geographic
trans = Proj2Geog((IProjectedCoordinateSystem)sourceCS, (IGeographicCoordinateSystem)targetCS);
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IProjectedCoordinateSystem) //Geographic -> Projected
trans = Geog2Proj((IGeographicCoordinateSystem)sourceCS, (IProjectedCoordinateSystem)targetCS);
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IGeocentricCoordinateSystem) //Geocentric -> Geographic
trans = Geog2Geoc((IGeographicCoordinateSystem)sourceCS, (IGeocentricCoordinateSystem)targetCS);
else if (sourceCS is IGeocentricCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Geocentric -> Geographic
trans = Geoc2Geog((IGeocentricCoordinateSystem)sourceCS, (IGeographicCoordinateSystem)targetCS);
else if (sourceCS is IProjectedCoordinateSystem && targetCS is IProjectedCoordinateSystem) //Projected -> Projected
trans = Proj2Proj((sourceCS as IProjectedCoordinateSystem), (targetCS as IProjectedCoordinateSystem));
else if (sourceCS is IGeocentricCoordinateSystem && targetCS is IGeocentricCoordinateSystem) //Geocentric -> Geocentric
trans = CreateGeoc2Geoc((IGeocentricCoordinateSystem)sourceCS, (IGeocentricCoordinateSystem)targetCS);
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Geographic -> Geographic
trans = CreateGeog2Geog(sourceCS as IGeographicCoordinateSystem, targetCS as IGeographicCoordinateSystem);
else
throw new NotSupportedException("No support for transforming between the two specified coordinate systems");
//if (trans.MathTransform is ConcatenatedTransform) {
// List<ICoordinateTransformation> MTs = new List<ICoordinateTransformation>();
// SimplifyTrans(trans.MathTransform as ConcatenatedTransform, ref MTs);
// return new CoordinateTransformation(sourceCS,
// targetCS, TransformType.Transformation, new ConcatenatedTransform(MTs),
// String.Empty, String.Empty, -1, String.Empty, String.Empty);
//}
return trans;
}
/// <summary>
/// Creates a compound coordinate system.
/// </summary>
/// <param name="headCRS">The first coordinate system.</param>
/// <param name="tailCRS">The second coordinate system.</param>
/// <param name="remarks">Remarks about this object.</param>
/// <param name="authority">The name of the authority.</param>
/// <param name="authorityCode">The code the authority uses to identidy this object.</param>
/// <param name="name">The name of the object.</param>
/// <param name="alias">The alias of the object.</param>
/// <param name="abbreviation">The abbreviated name of this object.</param>
internal CompoundCoordinateSystem(ICoordinateSystem headCRS,
ICoordinateSystem tailCRS,
string remarks, string authority, string authorityCode, string name, string alias, string abbreviation)
: base(remarks, authority, authorityCode, name, alias, abbreviation)
{
if (headCRS==null)
{
throw new ArgumentNullException("headCRS");
}
if (tailCRS==null)
{
throw new ArgumentNullException("tailCRS");
}
_headCRS = headCRS;
_tailCRS = tailCRS;
_axisInfo = new IAxisInfo[this.Dimension];
// copy axis information
for(int i=0;i<headCRS.Dimension;i++)
{
_axisInfo[i]=_headCRS.GetAxis(i);
}
int offset=headCRS.Dimension;
for (int i=0;i<tailCRS.Dimension;i++)
{
_axisInfo[i+offset]=_tailCRS.GetAxis(i);
}
}
/// <summary>
/// Creates a transformation between two coordinate systems.
/// </summary>
/// <remarks>
/// This method will examine the coordinate systems in order to construct
/// a transformation between them. This method may fail if no path between
/// the coordinate systems is found, using the normal failing behavior of
/// the DCP (e.g. throwing an exception).</remarks>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <returns></returns>
public ICoordinateTransformation CreateFromCoordinateSystems(ICoordinateSystem sourceCS, ICoordinateSystem targetCS)
{
if ((sourceCS is IProjectedCoordinateSystem) && (targetCS is IGeographicCoordinateSystem))
{
return Proj2Geog((IProjectedCoordinateSystem) sourceCS, (IGeographicCoordinateSystem) targetCS);
}
if ((sourceCS is IGeographicCoordinateSystem) && (targetCS is IProjectedCoordinateSystem))
{
return Geog2Proj((IGeographicCoordinateSystem) sourceCS, (IProjectedCoordinateSystem) targetCS);
}
if ((sourceCS is IGeographicCoordinateSystem) && (targetCS is IGeocentricCoordinateSystem))
{
return Geog2Geoc((IGeographicCoordinateSystem) sourceCS, (IGeocentricCoordinateSystem) targetCS);
}
if ((sourceCS is IGeocentricCoordinateSystem) && (targetCS is IGeographicCoordinateSystem))
{
return Geoc2Geog((IGeocentricCoordinateSystem) sourceCS, (IGeographicCoordinateSystem) targetCS);
}
if ((sourceCS is IProjectedCoordinateSystem) && (targetCS is IProjectedCoordinateSystem))
{
return Proj2Proj(sourceCS as IProjectedCoordinateSystem, targetCS as IProjectedCoordinateSystem);
}
if ((sourceCS is IGeocentricCoordinateSystem) && (targetCS is IGeocentricCoordinateSystem))
{
return CreateGeoc2Geoc((IGeocentricCoordinateSystem) sourceCS, (IGeocentricCoordinateSystem) targetCS);
}
if (!(sourceCS is IGeographicCoordinateSystem) || !(targetCS is IGeographicCoordinateSystem))
{
throw new NotSupportedException("No support for transforming between the two specified coordinate systems");
}
return this.CreateGeog2Geog(sourceCS as IGeographicCoordinateSystem, targetCS as IGeographicCoordinateSystem);
}
/// <summary>
/// Creates a transformation between two coordinate systems.
/// </summary>
/// <remarks>
/// This method will examine the coordinate systems in order to construct
/// a transformation between them. This method may fail if no path between
/// the coordinate systems is found, using the normal failing behavior of
/// the DCP (e.g. throwing an exception).</remarks>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <returns></returns>
public ICoordinateTransformation CreateFromCoordinateSystems(ICoordinateSystem sourceCS, ICoordinateSystem targetCS)
{
if (sourceCS is IProjectedCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Projected -> Geographic
return Proj2Geog((IProjectedCoordinateSystem)sourceCS, (IGeographicCoordinateSystem)targetCS);
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IProjectedCoordinateSystem) //Geographic -> Projected
return Geog2Proj((IGeographicCoordinateSystem)sourceCS, (IProjectedCoordinateSystem)targetCS);
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IGeocentricCoordinateSystem) //Geocentric -> Geographic
return Geog2Geoc((IGeographicCoordinateSystem)sourceCS, (IGeocentricCoordinateSystem)targetCS);
else if (sourceCS is IGeocentricCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Geocentric -> Geographic
return Geoc2Geog((IGeocentricCoordinateSystem)sourceCS, (IGeographicCoordinateSystem)targetCS);
else if (sourceCS is IProjectedCoordinateSystem && targetCS is IProjectedCoordinateSystem) //Projected -> Projected
return Proj2Proj((sourceCS as IProjectedCoordinateSystem),(targetCS as IProjectedCoordinateSystem));
else if (sourceCS is IGeocentricCoordinateSystem && targetCS is IGeocentricCoordinateSystem) //Geocentric -> Geocentric
return CreateGeoc2Geoc((IGeocentricCoordinateSystem)sourceCS, (IGeocentricCoordinateSystem)targetCS);
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Geographic -> Geographic
return CreateGeog2Geog(sourceCS as IGeographicCoordinateSystem, targetCS as IGeographicCoordinateSystem);
throw new NotSupportedException("No support for transforming between the two specified coordinate systems");
}
public void RenderFeatures(ICoordinateSystem coordsys, IEnumerable<IFeature> items)
{
if (items == null) return;
m_sourceCoordsys = coordsys;
foreach (IFeature g in items)
{
IGeometry geom = g.Geometry;
if (ProjectionConverter != null)
{
geom = ProjectionConverter(this, geom);
if (geom == null) continue;
}
if (Generalizer != null)
{
geom = Generalizer(this, geom);
if (geom == null) continue;
}
if (CoordinateMapper != null)
geom = CoordinateMapper(this, geom);
else
geom = PrimitiveCoordinateMapper(geom);
if (geom == null) continue;
Draw(geom, g.Style);
}
m_sourceCoordsys = null;
}
public static ProjNet.CoordinateSystems.Transformations.ICoordinateTransformation Transform2Lambert(ICoordinateSystem source)
{
if (source == null)
throw new ArgumentException("Source coordinate system is null");
if (!(source is IGeographicCoordinateSystem))
throw new ArgumentException("Source coordinate system must be geographic");
CoordinateSystemFactory cFac = new CoordinateSystemFactory();
List<ProjectionParameter> parameters = new List<ProjectionParameter>();
parameters.Add(new ProjectionParameter("latitude_of_origin", 50));
parameters.Add(new ProjectionParameter("central_meridian", -95));
parameters.Add(new ProjectionParameter("standard_parallel_1", 33));
parameters.Add(new ProjectionParameter("standard_parallel_2", 45));
parameters.Add(new ProjectionParameter("false_easting", 0));
parameters.Add(new ProjectionParameter("false_northing", 0));
IProjection projection = cFac.CreateProjection("Lambert Conformal Conic 2SP", "lambert_conformal_conic_2sp",
parameters);
IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Lambert Conformal Conic 2SP",
source as IGeographicCoordinateSystem,
projection, ProjNet.CoordinateSystems.LinearUnit.Metre,
new AxisInfo("East",
AxisOrientationEnum.East),
new AxisInfo("North",
AxisOrientationEnum.
North));
return new CoordinateTransformationFactory().CreateFromCoordinateSystems(source, coordsys);
}
public void Test(string title, ICoordinateSystem source, ICoordinateSystem target,
double[] testPoint, double[] expectedPoint,
double tolerance, double reverseTolerance = double.NaN)
{
var ct = CoordinateTransformationFactory.CreateFromCoordinateSystems(source, target);
var forwardResult = ct.MathTransform.Transform(testPoint);
var reverseResult = Double.IsNaN(reverseTolerance)
? testPoint
: ct.MathTransform.Inverse().Transform(forwardResult);
var forward = ToleranceLessThan(forwardResult, expectedPoint, tolerance);
var reverse = Double.IsNaN(reverseTolerance) ||
ToleranceLessThan(reverseResult, testPoint, reverseTolerance);
if (!forward)
TransformationError(title, expectedPoint, forwardResult);
if (!reverse)
TransformationError(title, testPoint, reverseResult, true);
Assert.IsTrue(forward && reverse);
}
internal SqlGeography(SqlTypes.SqlGeography sg, ICoordinateSystem coordinateSystem)
{
Debug.Assert(sg!=null);
if (sg==null)
throw new ArgumentNullException("sg");
_Geography=sg;
_CoordinateSystem=coordinateSystem;
}
internal SpatialGeometry(DbGeometry g, ICoordinateSystem coordinateSystem)
{
Debug.Assert(g!=null);
if (g==null)
throw new ArgumentNullException("g");
_Geometry=g;
_CoordinateSystem=coordinateSystem;
}
/// <summary>Parses the geometry defined by the specified WKT representation, in the specified coordinate system.</summary>
/// <param name="text">The WKT representation of the geometry.</param>
/// <param name="system">The coordinate system of the WKT representation.</param>
public void Parse(string text, ICoordinateSystem system)
{
Debug.Assert(system!=null);
if (system==null)
throw new ArgumentNullException("system");
_Builder=new Gml.GmlGeometryBuilder(system);
_Builder.Parse(text, system);
}
/// <summary>Indicates whether the current coordinate system is equivalent to the specified one.</summary>
/// <param name="other">The coordinate system to compare the current one against.</param>
/// <returns><c>true</c> if the coordinate systems are equivalent; or else <c>false</c>.</returns>
public bool IsEquivalentTo(ICoordinateSystem other)
{
if (other==null)
return false;
if (Equals(other))
return true;
return false;
}
/// <summary>Indicates whether the current coordinate system is equal to the specified one.</summary>
/// <param name="other">The coordinate system to compare the current one against.</param>
/// <returns><c>true</c> if the coordinate systems are equal; or else <c>false</c>.</returns>
public bool Equals(ICoordinateSystem other)
{
if (other==null)
return false;
var cs=other as CoordinateSystem;
if (cs!=null)
return _System.Equals(cs._System) || _System.EqualParams(cs._System);
return false;
}
public ProjNetSpatialReference(ICoordinateSystem cs)
{
var authorityCode = cs.AuthorityCode;
if (authorityCode <= 0)
{
authorityCode = ++_newId;
}
_oid = cs.Authority ?? "SM" + ":" + authorityCode;
Definition = cs.WKT;
CoordinateSystem = cs;
}
/// <summary>Indicates whether the current coordinate system is equal to the specified one.</summary>
/// <param name="other">The coordinate system to compare the current one against.</param>
/// <returns><c>true</c> if the coordinate systems are equal; or else <c>false</c>.</returns>
public bool Equals(ICoordinateSystem other)
{
if (other==null)
return false;
var cs=other as CoordinateSystem;
if (cs!=null)
return _Projection.Equals(cs._Projection);
return false;
}
public static DsProjections.ProjectionInfo Convert(ICoordinateSystem system)
{
if (system==null)
return null;
var cs=system as CoordinateSystem;
if (cs==null)
return DsProjections.ProjectionInfo.FromEsriString(system.ToString());
return cs.Projection;
}
/// <summary>Creates a new instance of the <see cref="FdoGeometry" /> class that encapsulates
/// a copy of the specified FDO geometry, in the specified coordinate system.</summary>
/// <param name="geometry">The FDO geometry for which a copy will be encapsulated.</param>
/// <param name="coordinateSystem">The coordinate system of the encapsulated FDO geometry.</param>
/// <remarks>
/// <para>This instance encapsulates a copy of the specified <paramref name="geometry" />. It is thus
/// the responsibility of the caller to <see cref="IDisposable.Dispose()" /> the specified <paramref name="geometry" />.</para>
/// </remarks>
public FdoGeometry(FGeometry.IGeometry geometry, ICoordinateSystem coordinateSystem)
{
Debug.Assert(geometry!=null);
if (geometry==null)
throw new ArgumentNullException("geometry");
Debug.Assert(coordinateSystem!=null);
if (coordinateSystem==null)
throw new ArgumentNullException("coordinateSystem");
_Geometry=FdoGeometryBuilder.Factory.CreateGeometry(geometry);
_CoordinateSystem=coordinateSystem;
}
public GeometryFactory(ICoordinateFactory coordFactory, ICoordinateSequenceFactory sequenceFactory, Int32? srid, ICoordinateSystem spatialReference)
{
_coordFactory = coordFactory;
_sequenceFactory = sequenceFactory;
_srid = srid;
_spatialReference = spatialReference;
_spatialOps = new BoundingBoxSpatialOperations(this);
_wktEncoder = new WktWriter();
_wktDecoder = new WktReader(this, null);
_wkbEncoder = new WkbWriter();
_wkbDecoder = new WkbReader(this);
}
/// <summary>Creates a new instance of the <see cref="FdoGeometry" /> class that encapsulates
/// a copy of the specified FDO envelope, in the specified coordinate system.</summary>
/// <param name="envelope">The FDO envelope for which a copy will be encapsulated.</param>
/// <param name="coordinateSystem">The coordinate system of the encapsulated FDO geometry.</param>
/// <remarks>
/// <para>This instance encapsulates a copy of the specified <paramref name="envelope" />. It is thus
/// the responsibility of the caller to <see cref="IDisposable.Dispose()" /> the specified <paramref name="envelope" />.</para>
/// </remarks>
public FdoEnvelope(FGeometry.IEnvelope envelope, ICoordinateSystem coordinateSystem)
{
Debug.Assert(envelope!=null);
if (envelope==null)
throw new ArgumentNullException("envelope");
Debug.Assert(coordinateSystem!=null);
if (coordinateSystem==null)
throw new ArgumentNullException("coordinateSystem");
_Envelope=FdoGeometryBuilder.Factory.CreateEnvelope(envelope);
_CoordinateSystem=coordinateSystem;
}
internal CoordinatesTransformer(ICoordinateSystem source, ICoordinateSystem target)
{
Debug.Assert(source!=null);
if (source==null)
throw new ArgumentNullException("source");
Debug.Assert(target!=null);
if (target==null)
throw new ArgumentNullException("target");
_Source=CoordinateSystemUtils.Convert(source);
_Target=CoordinateSystemUtils.Convert(target);
}
/// <summary>
/// Initializes an instance of a CoordinateTransformation
/// </summary>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <param name="transformType">Transformation type</param>
/// <param name="mathTransform">Math transform</param>
/// <param name="name">Name of transform</param>
/// <param name="authority">Authority</param>
/// <param name="authorityCode">Authority code</param>
/// <param name="areaOfUse">Area of use</param>
/// <param name="remarks">Remarks</param>
internal CoordinateTransformation(ICoordinateSystem sourceCS, ICoordinateSystem targetCS, Topology.CoordinateSystems.Transformations.TransformType transformType, IMathTransform mathTransform, string name, string authority, long authorityCode, string areaOfUse, string remarks)
{
this._TargetCS = targetCS;
this._SourceCS = sourceCS;
this._TransformType = transformType;
this._MathTransform = mathTransform;
this._Name = name;
this._Authority = authority;
this._AuthorityCode = authorityCode;
this._AreaOfUse = areaOfUse;
this._Remarks = remarks;
}
/// <summary>
/// Creates an instance of FittedCoordinateSystem using the specified parameters
/// </summary>
/// <param name="baseSystem">Underlying coordinate system.</param>
/// <param name="transform">Transformation from fitted coordinate system to the base one</param>
/// <param name="name">Name</param>
/// <param name="authority">Authority name</param>
/// <param name="code">Authority-specific identification code.</param>
/// <param name="alias">Alias</param>
/// <param name="abbreviation">Abbreviation</param>
/// <param name="remarks">Provider-supplied remarks</param>
protected internal FittedCoordinateSystem (ICoordinateSystem baseSystem, IMathTransform transform,
string name, string authority, long code, string alias, string remarks, string abbreviation)
: base(name, authority, code, alias, abbreviation, remarks)
{
_BaseCoordinateSystem = baseSystem;
_ToBaseTransform = transform;
//get axis infos from the source
base.AxisInfo = new List<AxisInfo> (baseSystem.Dimension);
for (int dim = 0; dim < baseSystem.Dimension; dim++)
{
base.AxisInfo.Add (baseSystem.GetAxis (dim));
}
}
/// <summary>
/// Combines two coorindate system.
/// </summary>
/// <param name="name">The name of the new coordinate system.</param>
/// <param name="headCS">The first coordinate system.</param>
/// <param name="tailCS">The second coordinate system.</param>
/// <returns>An object that implements the ICompoundCoordinateSystem interface.</returns>
public ICompoundCoordinateSystem CreateCompoundCoordinateSystem(string name, ICoordinateSystem headCS, ICoordinateSystem tailCS)
{
if (headCS==null)
{
throw new ArgumentNullException("headCS");
}
if (tailCS==null)
{
throw new ArgumentNullException("tailCS");
}
CompoundCoordinateSystem compoundsCS = new CompoundCoordinateSystem(headCS,tailCS,"","","",name,"","");
return compoundsCS;
}
public static ProjNet.CoordinateSystems.ICoordinateSystem Convert(ICoordinateSystem system)
{
if (system==null)
return null;
var ret=system as ProjNet.CoordinateSystems.ICoordinateSystem;
if (ret==null)
{
var factory=new ProjNet.CoordinateSystems.CoordinateSystemFactory();
ret=factory.CreateFromWkt(system.ToString());
}
return ret;
}
/// <summary>
/// Initializes an instance of a CoordinateTransformation
/// </summary>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <param name="transformType">Transformation type</param>
/// <param name="mathTransform">Math transform</param>
/// <param name="name">Name of transform</param>
/// <param name="authority">Authority</param>
/// <param name="authorityCode">Authority code</param>
/// <param name="areaOfUse">Area of use</param>
/// <param name="remarks">Remarks</param>
internal CoordinateTransformation(ICoordinateSystem sourceCS, ICoordinateSystem targetCS, TransformType transformType, IMathTransform mathTransform,
string name, string authority, long authorityCode, string areaOfUse, string remarks)
: base()
{
_TargetCS = targetCS;
_SourceCS = sourceCS;
_TransformType = transformType;
_MathTransform = mathTransform;
_Name = name;
_Authority = authority;
_AuthorityCode = authorityCode;
_AreaOfUse = areaOfUse;
_Remarks = remarks;
}
public static ProjNetCS.ICoordinateSystem Convert(ICoordinateSystem system)
{
if (system==null)
return null;
var cs=system as CoordinateSystem;
if (cs==null)
{
var factory=new ProjNetCS.CoordinateSystemFactory();
return factory.CreateFromWkt(system.ToString());
}
return cs.System;
}
/// <summary>Parses the geometry defined by the specified WKT representation, in the specified coordinate system.</summary>
/// <param name="text">The WKT representation of the geometry.</param>
/// <param name="system">The coordinate system of the WKT representation.</param>
public void Parse(string text, ICoordinateSystem system)
{
Debug.Assert(system!=null);
if (system==null)
throw new ArgumentNullException("system");
IGeometryBuilder builder=CreateBuilder(system);
builder.Parse(text, system);
IGeometry g=(IGeometry)builder.ConstructedGeometry;
if ((TargetSystem!=null) && !system.IsEquivalentTo(TargetSystem))
g.Populate(this);
else
_Geometry=g;
}
/// <summary>Defines the coordinate system of the geometry source.</summary>
/// <param name="sourceSystem">The coordinate system of the geometry source.</param>
/// <remarks>
/// <para>If <paramref name="sourceSystem" /> is the same coordinate system as the target coordinate system,
/// no transformation will occur.</para>
/// </remarks>
public void SetCoordinateSystem(ICoordinateSystem sourceSystem)
{
Debug.Assert(sourceSystem!=null);
if (sourceSystem==null)
throw new ArgumentNullException("sourceSystem");
if (_TargetSystem==null)
_TargetSystem=sourceSystem;
DoSetCoordinateSystem(_TargetSystem);
_SourceSystem=sourceSystem;
if (!_TargetSystem.IsEquivalentTo(_SourceSystem))
_Converter=CommonServiceLocator.GetCoordinateSystemProvider().CreateTransformer(_SourceSystem, _TargetSystem);
}
private static string PrintResultTable(ICoordinateSystem fromCoordSys, ICoordinateSystem toCoordSys, Coordinate fromPnt,
Coordinate toPnt, Coordinate refPnt, Coordinate backPnt, string header)
{
string table = "<table style=\"border: 1px solid #000; margin: 10px;\">";
table += "<tr><td colspan=\"2\"><h3>" + header + "</h3></td></tr>";
table += "<tr><td width=\"130px\" valign=\"top\">Input coordsys:</td><td>" + fromCoordSys.WKT + "</td></tr>";
table += "<tr><td valign=\"top\">Output coordsys:</td><td>" + toCoordSys.WKT + "</td></tr>";
table += "<tr><td>Input coordinate:</td><td>" + fromPnt + "</td></tr>";
table += "<tr><td>Ouput coordinate:</td><td>" + toPnt + "</td></tr>";
table += "<tr><td>Expected coordinate:</td><td>" + refPnt + "</td></tr>";
table += "<tr><td>Difference:</td><td>" + (refPnt.Subtract(toPnt)) + "</td></tr>";
table += "<tr><td>Reverse transform:</td><td>" + backPnt + "</td></tr>";
table += "<tr><td>Difference:</td><td>" + (backPnt.Subtract(fromPnt)) + "</td></tr>";
table += "</table>";
return table;
}
public SpatialReference(KinectReader kinectReader, PositionReader positionReader)
{
this.kinectReader = kinectReader;
this.positionReader = positionReader;
string wkt = "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.0174532925199433]]";
this.wgs84 = (ICoordinateSystem)ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(wkt);
//hardcoded UTM 55S - should parameterize
string toWKT = "PROJCS[\"WGS 72BE / UTM zone 55S\",GEOGCS[\"WGS 72BE\",DATUM[\"WGS_1972_Transit_Broadcast_Ephemeris\",SPHEROID[\"WGS 72\",6378135,298.26,AUTHORITY[\"EPSG\",\"7043\"]],TOWGS84[0,0,1.9,0,0,0.814,-0.38],AUTHORITY[\"EPSG\",\"6324\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4324\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",147],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",10000000],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AUTHORITY[\"EPSG\",\"32555\"]]";
this.toCs = (ICoordinateSystem)ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(toWKT);
CoordinateTransformationFactory ctfac = new CoordinateTransformationFactory();
this.toGridtrans = ctfac.CreateFromCoordinateSystems(wgs84, toCs);
}
/// <summary>
/// Creates the search criteria based on filter settings.
/// </summary>
/// <param name="mySettings">
/// The my settings object.
/// </param>
/// <returns>
/// The <see cref="SpeciesObservationSearchCriteria"/>.
/// </returns>
public SpeciesObservationSearchCriteria CreateSearchCriteria(
MySettings.MySettings mySettings,
ICoordinateSystem coordinateSystem)
{
var searchCriteria = new SpeciesObservationSearchCriteria();
// Default settings
searchCriteria.IncludePositiveObservations = true;
// Taxa filter
if (mySettings.Filter.Taxa.IsActive && mySettings.Filter.Taxa.HasSettings)
{
searchCriteria.TaxonIds = mySettings.Filter.Taxa.TaxonIds.ToList();
}
// Temporal filter
if (mySettings.Filter.Temporal.IsActive)
{
// Observation date
if (mySettings.Filter.Temporal.ObservationDate.UseSetting)
{
searchCriteria.ObservationDateTime = new DateTimeSearchCriteria();
searchCriteria.ObservationDateTime.Operator = CompareOperator.Excluding;
if (mySettings.Filter.Temporal.ObservationDate.Annually)
{
searchCriteria.ObservationDateTime.Begin = new DateTime(1800, 1, 1);
searchCriteria.ObservationDateTime.End = DateTime.Now.AddDays(1);
searchCriteria.ObservationDateTime.PartOfYear = new List <IDateTimeInterval>();
IDateTimeInterval dateTimeInterval = new DateTimeInterval();
dateTimeInterval.Begin = mySettings.Filter.Temporal.ObservationDate.StartDate;
dateTimeInterval.End = mySettings.Filter.Temporal.ObservationDate.EndDate;
searchCriteria.ObservationDateTime.PartOfYear.Add(dateTimeInterval);
}
else
{
searchCriteria.ObservationDateTime.Begin = mySettings.Filter.Temporal.ObservationDate.StartDate;
searchCriteria.ObservationDateTime.End = mySettings.Filter.Temporal.ObservationDate.EndDate;
}
}
// Registration date
if (mySettings.Filter.Temporal.RegistrationDate.UseSetting)
{
searchCriteria.ReportedDateTime = new DateTimeSearchCriteria();
searchCriteria.ReportedDateTime.Operator = CompareOperator.Excluding;
if (mySettings.Filter.Temporal.RegistrationDate.Annually)
{
searchCriteria.ReportedDateTime.Begin = new DateTime(1800, 1, 1);
searchCriteria.ReportedDateTime.End = DateTime.Now.AddDays(1);
searchCriteria.ReportedDateTime.PartOfYear = new List <IDateTimeInterval>();
IDateTimeInterval dateTimeInterval = new DateTimeInterval();
dateTimeInterval.Begin = mySettings.Filter.Temporal.RegistrationDate.StartDate;
dateTimeInterval.End = mySettings.Filter.Temporal.RegistrationDate.EndDate;
searchCriteria.ReportedDateTime.PartOfYear.Add(dateTimeInterval);
}
else
{
searchCriteria.ReportedDateTime.Begin = mySettings.Filter.Temporal.RegistrationDate.StartDate;
searchCriteria.ReportedDateTime.End = mySettings.Filter.Temporal.RegistrationDate.EndDate;
}
}
// Change date
if (mySettings.Filter.Temporal.ChangeDate.UseSetting)
{
searchCriteria.ChangeDateTime = new DateTimeSearchCriteria();
searchCriteria.ChangeDateTime.Operator = CompareOperator.Excluding;
if (mySettings.Filter.Temporal.ChangeDate.Annually)
{
searchCriteria.ChangeDateTime.Begin = new DateTime(1800, 1, 1);
searchCriteria.ChangeDateTime.End = DateTime.Now.AddDays(1);
searchCriteria.ChangeDateTime.PartOfYear = new List <IDateTimeInterval>();
IDateTimeInterval dateTimeInterval = new DateTimeInterval();
dateTimeInterval.Begin = mySettings.Filter.Temporal.ChangeDate.StartDate;
dateTimeInterval.End = mySettings.Filter.Temporal.ChangeDate.EndDate;
searchCriteria.ChangeDateTime.PartOfYear.Add(dateTimeInterval);
}
else
{
searchCriteria.ChangeDateTime.Begin = mySettings.Filter.Temporal.ChangeDate.StartDate;
searchCriteria.ChangeDateTime.End = mySettings.Filter.Temporal.ChangeDate.EndDate;
}
}
}
// Accuracy filter
if (mySettings.Filter.Accuracy.IsActive)
{
if (mySettings.Filter.Accuracy.IsCoordinateAccuracyActive)
{
searchCriteria.Accuracy = mySettings.Filter.Accuracy.MaxCoordinateAccuracy;
searchCriteria.IsAccuracyConsidered = mySettings.Filter.Accuracy.Inclusive;
}
else
{
searchCriteria.Accuracy = null;
searchCriteria.IsAccuracyConsidered = false;
}
}
// Spatial filter
if (mySettings.Filter.Spatial.IsActive)
{
if (mySettings.Filter.Spatial.Polygons.Count > 0)
{
var dataContext = new DataContext(_userContext);
ICoordinateSystem fromCoordinateSystem = mySettings.Filter.Spatial.PolygonsCoordinateSystem;
//ICoordinateSystem toCoordinateSystem = mySettings.Presentation.Map.DisplayCoordinateSystem;
ICoordinateSystem toCoordinateSystem = coordinateSystem;
List <IPolygon> polygons = mySettings.Filter.Spatial.Polygons.ToList().ToPolygons(dataContext);
polygons = GisTools.CoordinateConversionManager.GetConvertedPolygons(polygons, fromCoordinateSystem, toCoordinateSystem);
GeometryTools geometryTools = new GeometryTools();
foreach (IPolygon polygon in polygons)
{
var polygonStatus = geometryTools.ValidateGeometry(polygon);
if (!polygonStatus.IsValid)
{
throw new Exception(string.Format("Polygon error! {0}", polygonStatus.Description));
}
}
searchCriteria.Polygons = polygons;
}
if (mySettings.Filter.Spatial.RegionIds.Count > 0)
{
searchCriteria.RegionGuids = new List <string>();
RegionList regions = CoreData.RegionManager.GetRegionsByIds(_userContext, mySettings.Filter.Spatial.RegionIds.ToList());
foreach (IRegion region in regions)
{
searchCriteria.RegionGuids.Add(region.GUID);
}
}
// Locality name search
if (!string.IsNullOrEmpty(mySettings.Filter.Spatial.Locality.LocalityName))
{
searchCriteria.LocalityNameSearchString = new StringSearchCriteria();
searchCriteria.LocalityNameSearchString.SearchString = mySettings.Filter.Spatial.Locality.LocalityName;
searchCriteria.LocalityNameSearchString.CompareOperators = new List <StringCompareOperator>();
searchCriteria.LocalityNameSearchString.CompareOperators.Add(mySettings.Filter.Spatial.Locality.CompareOperator);
}
}
// Occurrence filter
if (mySettings.Filter.Occurrence.IsActive)
{
searchCriteria.IncludeNeverFoundObservations = mySettings.Filter.Occurrence.IncludeNeverFoundObservations;
searchCriteria.IncludeNotRediscoveredObservations = mySettings.Filter.Occurrence.IncludeNotRediscoveredObservations;
searchCriteria.IncludePositiveObservations = mySettings.Filter.Occurrence.IncludePositiveObservations;
if (mySettings.Filter.Occurrence.IsNaturalOccurrence ==
mySettings.Filter.Occurrence.IsNotNaturalOccurrence)
{
// TODO: Set ignore IsNaturalOccurence
}
else
{
searchCriteria.IsNaturalOccurrence = mySettings.Filter.Occurrence.IsNaturalOccurrence;
}
}
// Data providers
if (mySettings.DataProvider.DataProviders.IsActive && mySettings.DataProvider.DataProviders.HasSettings)
{
//Get all data providers
bool providersWithObservationDisabled;
var dataProviders = DataProviderManager.GetAllDataProviders(_userContext, out providersWithObservationDisabled);
//If all providers are selected and we don't have any providers with observation disabled, we don't set data source guids since it will decrease performance
//All existing providers will be used if the property is not set and the performance is better compared to setting all providers explicit
if (providersWithObservationDisabled || dataProviders.Count != mySettings.DataProvider.DataProviders.DataProvidersGuids.Count)
{
searchCriteria.DataSourceGuids = new List <string>();
foreach (var guid in mySettings.DataProvider.DataProviders.DataProvidersGuids)
{
searchCriteria.DataSourceGuids.Add(guid);
}
}
}
// Field filter
if (mySettings.Filter.Field.IsActive && mySettings.Filter.Field.HasSettings)
{
searchCriteria.FieldSearchCriteria = new SpeciesObservationFieldSearchCriteriaList();
foreach (var fieldFilterExpression in mySettings.Filter.Field.FieldFilterExpressions)
{
searchCriteria.FieldSearchCriteria.Add(fieldFilterExpression);
}
searchCriteria.FieldLogicalOperator = mySettings.Filter.Field.FieldLogicalOperator;
}
return(searchCriteria);
}
/// <summary>
/// Get the extents for a MapTubeD geometry.
/// This needs to be WGS84 extents when the database has Mercator!
/// </summary>
/// <param name="GeometryName"></param>
/// <param name="minlat"></param>
/// <param name="minlon"></param>
/// <param name="maxlat"></param>
/// <param name="maxlon"></param>
/// <returns></returns>
public bool GetExtentsForGeometry(string GeometryName, out float minlat, out float minlon, out float maxlat, out float maxlon)
{
//According to sharpgis, this is the official webmercator one with EPSG 3785
//It's also the one used by the latest GMapCreator
const string GoogleProj =
"PROJCS[\"Popular Visualisation CRS / Mercator\","
+ "GEOGCS[\"Popular Visualisation CRS\", DATUM[\"Popular Visualisation Datum\","
+ "SPHEROID[\"Popular Visualisation Sphere\", 6378137, 0, AUTHORITY[\"EPSG\",\"7059\"]],"
+ "TOWGS84[0, 0, 0, 0, 0, 0, 0], AUTHORITY[\"EPSG\",\"6055\"]],"
+ "PRIMEM[\"Greenwich\", 0, AUTHORITY[\"EPSG\", \"8901\"]],"
+ "UNIT[\"degree\", 0.0174532925199433, AUTHORITY[\"EPSG\", \"9102\"]],"
+ "AXIS[\"E\", EAST], AXIS[\"N\", NORTH], AUTHORITY[\"EPSG\",\"4055\"]], PROJECTION[\"Mercator\"],"
+ "PARAMETER[\"False_Easting\", 0], PARAMETER[\"False_Northing\", 0], PARAMETER[\"Central_Meridian\", 0],"
+ "PARAMETER[\"Latitude_of_origin\", 0], UNIT[\"metre\", 1, AUTHORITY[\"EPSG\", \"9001\"]],"
+ "AXIS[\"East\", EAST], AXIS[\"North\", NORTH], AUTHORITY[\"EPSG\",\"3785\"]]";
const string WGS84Proj =
"GEOGCS[\"GCS_WGS_1984\","
+ "DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],"
+ "PRIMEM[\"Greenwich\",0],"
+ "UNIT[\"Degree\",0.0174532925199433]"
+ "]";
minlat = 0; minlon = 0; maxlat = 0; maxlon = 0;
string sql = "SELECT {0}.STEnvelope() as [envelope],{1} as [areakey] FROM {2}";
MapTubeD.GeoDataSources geodb = MapTubeD.GeoDataSources.GetInstance(configFilename);
string ConnectionString, TableName, GeomFieldName, AreaFieldName;
//MapScale=0 means get the most detailed boundary we have
bool Success = geodb.GetInfo(GeometryName, 0, out ConnectionString, out TableName, out GeomFieldName, out AreaFieldName);
if (!Success)
{
return(false);
}
Envelope MercEnv = new Envelope();
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand(string.Format(sql, GeomFieldName, AreaFieldName, TableName), conn);
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
SqlGeometry sqlgeom = reader["envelope"] as SqlGeometry;
//TODO: removed bit that determines whether an area key is present before expanding the box - this gets bounds for ALL geometry, not joined geometry
//get data value from hash to make sure it exists
//String areakey = reader["areakey"] as string;
//if (areakey == null) continue;
//areakey = areakey.Trim();
//Object ob = (MapDescriptor.Data as DBJoin).Data[areakey];
//if (ob != null)
//{
//expand bounds to include data geometry box
MercEnv.ExpandToInclude(sqlgeom.STPointN(1).STX.Value, sqlgeom.STPointN(1).STY.Value);
MercEnv.ExpandToInclude(sqlgeom.STPointN(3).STX.Value, sqlgeom.STPointN(3).STY.Value);
//}
}
}
}
//now env contains the bounds in Mercator, we need to convert back to WGS84
//setup coordinate transformations
CoordinateSystemFactory CSFactory = new CoordinateSystemFactory();
ICoordinateSystem CSMerc = CSFactory.CreateFromWkt(GoogleProj);
ICoordinateSystem CSWGS84 = CSFactory.CreateFromWkt(WGS84Proj);
CoordinateTransformationFactory ctf = new CoordinateTransformationFactory();
ICoordinateTransformation trans = ctf.CreateFromCoordinateSystems(CSMerc, CSWGS84);
Envelope env = NetTopologySuite.CoordinateSystems.Transformations.GeometryTransform.TransformBox(MercEnv, trans.MathTransform);
double EnvWidth = env.Width;
//program out error when minx==maxx==-180 for world maps (it wraps wrongly)
//added a delta minimum for the width, min and max
if ((EnvWidth <= 0.0000001) && (Math.Abs(env.MinX + 180.0) <= 0.0000001) && (Math.Abs(env.MaxX + 180.0) <= 0.0000001))
{
EnvWidth = 360.0;
}
minlat = (float)env.MinY;
minlon = (float)env.MinX;
maxlat = (float)env.MaxY;
maxlon = (float)env.MaxX;
return(true);
}
/// <summary>
/// Creates a transformation between two coordinate systems.
/// </summary>
/// <remarks>
/// This method will examine the coordinate systems in order to construct
/// a transformation between them. This method may fail if no path between
/// the coordinate systems is found, using the normal failing behavior of
/// the DCP (e.g. throwing an exception).</remarks>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <returns></returns>
public ICoordinateTransformation CreateFromCoordinateSystems(ICoordinateSystem sourceCS, ICoordinateSystem targetCS)
{
ICoordinateTransformation trans;
if (sourceCS is IProjectedCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Projected -> Geographic
{
trans = Proj2Geog((IProjectedCoordinateSystem)sourceCS, (IGeographicCoordinateSystem)targetCS);
}
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IProjectedCoordinateSystem) //Geographic -> Projected
{
trans = Geog2Proj((IGeographicCoordinateSystem)sourceCS, (IProjectedCoordinateSystem)targetCS);
}
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IGeocentricCoordinateSystem) //Geocentric -> Geographic
{
trans = Geog2Geoc((IGeographicCoordinateSystem)sourceCS, (IGeocentricCoordinateSystem)targetCS);
}
else if (sourceCS is IGeocentricCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Geocentric -> Geographic
{
trans = Geoc2Geog((IGeocentricCoordinateSystem)sourceCS, (IGeographicCoordinateSystem)targetCS);
}
else if (sourceCS is IProjectedCoordinateSystem && targetCS is IProjectedCoordinateSystem) //Projected -> Projected
{
trans = Proj2Proj((sourceCS as IProjectedCoordinateSystem), (targetCS as IProjectedCoordinateSystem));
}
else if (sourceCS is IGeocentricCoordinateSystem && targetCS is IGeocentricCoordinateSystem) //Geocentric -> Geocentric
{
trans = CreateGeoc2Geoc((IGeocentricCoordinateSystem)sourceCS, (IGeocentricCoordinateSystem)targetCS);
}
else if (sourceCS is IGeographicCoordinateSystem && targetCS is IGeographicCoordinateSystem) //Geographic -> Geographic
{
trans = CreateGeog2Geog(sourceCS as IGeographicCoordinateSystem, targetCS as IGeographicCoordinateSystem);
}
else
{
throw new NotSupportedException("No support for transforming between the two specified coordinate systems");
}
//if (trans.MathTransform is ConcatenatedTransform) {
// List<ICoordinateTransformation> MTs = new List<ICoordinateTransformation>();
// SimplifyTrans(trans.MathTransform as ConcatenatedTransform, ref MTs);
// return new CoordinateTransformation(sourceCS,
// targetCS, TransformType.Transformation, new ConcatenatedTransform(MTs),
// String.Empty, String.Empty, -1, String.Empty, String.Empty);
//}
return(trans);
}
/// <summary>Creates a new instance of the <see cref="SqlGeometryBuilder" /> class.</summary>
/// <param name="targetSystem">The target coordinate system. If different from the source, transformations will occur.</param>
public SqlGeometryBuilder(ICoordinateSystem targetSystem) :
base(targetSystem)
{
}
public ICoordinateTransformation CreateTransformation(ICoordinateSystem src, ICoordinateSystem tgt)
{
return(_ctFactory.CreateFromCoordinateSystems(src, tgt));
}
/// <summary>
/// Creates a transformation between two coordinate systems.
/// </summary>
/// <remarks>
/// This method will examine the coordinate systems in order to construct
/// a transformation between them. This method may fail if no path between
/// the coordinate systems is found, using the normal failing behavior of
/// the DCP (e.g. throwing an exception).</remarks>
/// <param name="sourceCS">Source coordinate system</param>
/// <param name="targetCS">Target coordinate system</param>
/// <returns>A coordinate transformation object</returns>
/// <remarks>
/// For this method to work properly, the input coordinate systems must either be
/// <see cref="DotSpatialCoordinateSystem"/>s or return valid <see cref="ICoordinateSystem.WKT"/> values.
/// </remarks>
public ICoordinateTransformation CreateFromCoordinateSystems(ICoordinateSystem sourceCS, ICoordinateSystem targetCS)
{
var source = sourceCS as DotSpatialCoordinateSystem ??
new DotSpatialCoordinateSystem(ProjectionInfo.FromEsriString(sourceCS.WKT));
var target = targetCS as DotSpatialCoordinateSystem ??
new DotSpatialCoordinateSystem(ProjectionInfo.FromEsriString(targetCS.WKT));
return(new DotSpatialCoordinateTransformation(source, target));
}
//=============================================================================
public void Draw(ICoordinateSystem cs, DrawingContext dc)
{
if (cs != null && dc != null && m_bFirstPnt_IsSetted)
{
Pen _pen = new Pen(new SolidColorBrush(m_Color), m_Thickness);
PathFigure pf = new PathFigure();
if (!m_bInvalidData && m_bSecondPnt_IsSetted)
{
double scaledRadius = m_rRadius * cs.Get_Scale();
double rFirstAngle = Math.Atan2(m_FirstPnt.Y - m_CenterPnt.Y, m_FirstPnt.X - m_CenterPnt.X);
// Atan2 return result in [-pi, pi]. Convert it to [0, 2pi].
if (rFirstAngle < 0)
{
rFirstAngle += 2 * Math.PI;
}
double rSecondAngle = Math.Atan2(m_SecondPnt.Y - m_CenterPnt.Y, m_SecondPnt.X - m_CenterPnt.X);
if (rSecondAngle < 0)
{
rSecondAngle += 2 * Math.PI;
}
double rThirdAngle = Math.Atan2(m_ThirdPnt.Y - m_CenterPnt.Y, m_ThirdPnt.X - m_CenterPnt.X);
if (rThirdAngle < 0)
{
rThirdAngle += 2 * Math.PI;
}
Point startPnt = m_FirstPnt;
Point endPnt = new Point(0, 0);
SweepDirection sd = SweepDirection.Clockwise;
bool bIsLargeArc = false;
if (rFirstAngle > rSecondAngle)
{
if (rFirstAngle > rThirdAngle)
{
if (rSecondAngle > rThirdAngle)
{
endPnt = m_ThirdPnt;
sd = SweepDirection.Clockwise;
//sd = SweepDirection.Counterclockwise;
bIsLargeArc = (rFirstAngle - rThirdAngle) >= Math.PI;
}
else
{
endPnt = m_ThirdPnt;
sd = SweepDirection.Counterclockwise;
//sd = SweepDirection.Clockwise;
bIsLargeArc = (2 * Math.PI - (rFirstAngle - rThirdAngle)) >= Math.PI;
}
}
else
{
endPnt = m_ThirdPnt;
sd = SweepDirection.Clockwise;
//sd = SweepDirection.Counterclockwise;
double rDiff = rFirstAngle - rThirdAngle;
rDiff += 2 * Math.PI;
bIsLargeArc = rDiff >= Math.PI;
}
}
else
{
if (rFirstAngle > rThirdAngle)
{
endPnt = m_ThirdPnt;
sd = SweepDirection.Counterclockwise;
//sd = SweepDirection.Clockwise;
double rDiff = rFirstAngle - rThirdAngle;
rDiff -= 2 * Math.PI;
bIsLargeArc = Math.Abs(rDiff) >= Math.PI;
}
else
{
if (rSecondAngle > rThirdAngle)
{
endPnt = m_ThirdPnt;
sd = SweepDirection.Clockwise;
//sd = SweepDirection.Counterclockwise;
double rDiff = rFirstAngle - rThirdAngle;
rDiff += 2 * Math.PI;
bIsLargeArc = Math.Abs(rDiff) >= Math.PI;
}
else
{
endPnt = m_ThirdPnt;
sd = SweepDirection.Counterclockwise;
//sd = SweepDirection.Clockwise;
double rDiff = rFirstAngle - rThirdAngle;
//if (true || rDiff > 0)
// rDiff += 2 * Math.PI;
bIsLargeArc = Math.Abs(rDiff) >= Math.PI;
}
}
}
pf.StartPoint = cs.GetLocalPoint(startPnt);
// draw arc
pf.Segments.Add(new ArcSegment(cs.GetLocalPoint(endPnt), new Size(scaledRadius, scaledRadius), 0, bIsLargeArc, sd, true));
// DEBUG INFO
if (false)
{
string str = string.Format("{0:F2}, {1:F2}, {2:F2}", rFirstAngle, rSecondAngle, rThirdAngle);
Debug.WriteLine(str);
Vector vec = new Vector(4.0, 4.0);
Point pnt = cs.GetLocalPoint(m_SecondPnt);
Point pnt1 = pnt - vec;
Point pnt2 = pnt + vec;
Rect rect = new Rect(pnt1, pnt2);
dc.DrawRectangle(Brushes.Aqua, _pen, rect);
pnt = cs.GetLocalPoint(m_CenterPnt);
pnt1 = pnt - vec;
pnt2 = pnt + vec;
rect = new Rect(pnt1, pnt2);
dc.DrawRectangle(Brushes.Red, _pen, rect);
dc.DrawEllipse(null, new Pen(new SolidColorBrush(Colors.Red), 3), cs.GetLocalPoint(m_CenterPnt), scaledRadius, scaledRadius);
}
}
else
{
pf.StartPoint = cs.GetLocalPoint(m_FirstPnt);
// draw line
pf.Segments.Add(new LineSegment(cs.GetLocalPoint(m_SecondPnt), true));
}
PathGeometry pg = new PathGeometry(new[] { pf });
dc.DrawGeometry(null, _pen, pg);
}
}
