public void TestExplicitTransform()
{
const String csName1 = "EPSG:32636";
const String csName2 = "EPSG:4326";
CoordinateTransformFactory ctFactory = new CoordinateTransformFactory();
CoordinateReferenceSystemFactory csFactory = new CoordinateReferenceSystemFactory();
/*
* Create {@link CoordinateReferenceSystem} & CoordinateTransformation.
* Normally this would be carried out once and reused for all transformations
*/
CoordinateReferenceSystem crs1 = csFactory.CreateFromName(csName1);
CoordinateReferenceSystem crs2 = csFactory.CreateFromName(csName2);
ICoordinateTransform trans = ctFactory.CreateTransform(crs1, crs2);
/*
* Create input and output points.
* These can be constructed once per thread and reused.
*/
ProjCoordinate p1 = new ProjCoordinate();
ProjCoordinate p2 = new ProjCoordinate();
p1.X = 500000;
p1.Y = 4649776.22482;
/*
* Transform point
*/
trans.Transform(p1, p2);
Assert.IsTrue(IsInTolerance(p2, 33, 42, 0.000001));
}
private static Boolean CheckTransform(String csName, double lon, double lat, double expectedX, double expectedY, double tolerance)
{
CoordinateTransformFactory ctFactory = new CoordinateTransformFactory();
CoordinateReferenceSystemFactory csFactory = new CoordinateReferenceSystemFactory();
/*
* Create {@link CoordinateReferenceSystem} & CoordinateTransformation.
* Normally this would be carried out once and reused for all transformations
*/
CoordinateReferenceSystem crs = csFactory.CreateFromName(csName);
const String wgs84Param = "+title=long/lat:WGS84 +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees";
CoordinateReferenceSystem wgs84 = csFactory.CreateFromParameters("WGS84", wgs84Param);
ICoordinateTransform trans = ctFactory.CreateTransform(wgs84, crs);
/*
* Create input and output points.
* These can be constructed once per thread and reused.
*/
ProjCoordinate p = new ProjCoordinate();
ProjCoordinate p2 = new ProjCoordinate();
p.X = lon;
p.Y = lat;
/*
* Transform point
*/
trans.Transform(p, p2);
return(IsInTolerance(p2, expectedX, expectedY, tolerance));
}
public void Render(RenderArgs arg)
{
if (_locIcons == null || _locIcons.Count == 0)
{
return;
}
if (_img == null)
{
CreateBackgroudImage();
}
using (Font font = new Font("微软雅黑", 9))
{
ICoordinateTransform tran = (_mapRuntime as IFeatureRenderEnvironment).CoordinateTransform;
foreach (LocationIcon icon in _locIcons)
{
if (icon == null || string.IsNullOrEmpty(icon.Text) || icon.Feature == null)
{
continue;
}
SizeF fontsize = arg.Graphics.MeasureString(icon.Text, font);
ShapePoint prjpt = GetLocationByFeature(icon.Feature);
PointF[] pts = tran.PrjCoord2PixelCoord(new ShapePoint[] { prjpt });
pts[0].Y -= (_iconSize.Height + 5);
pts[0].X -= _iconSize.Width / 2;
arg.Graphics.DrawImage(_img, pts[0]);
arg.Graphics.DrawString(icon.Text, font, Brushes.Red, pts[0].X + (_iconSize.Width - fontsize.Width) / 2, pts[0].Y - (_iconSize.Height - fontsize.Height) / 2);
}
}
}
private void PrjToGeo(CoordPoint pt, ICoordinateTransform coordTran)
{
double prjX = 0, prjY = 0;
coordTran.Prj2Geo(pt.X, pt.Y, out prjX, out prjY);
pt.X = prjX;
pt.Y = prjY;
}
public MapImageGeneratorDefault(IMapRuntime mapRuntime)
{
_mapRuntime = mapRuntime;
_mapRuntime.ScaleBarArgs.Enabled = false;
_coordTransfrom = (_mapRuntime as IFeatureRenderEnvironment).CoordinateTransform;
BuildProjectionTransform();
SetViewportToDefault();
}
private unsafe void DrawContour(IDrawArgs drawArgs, ContourLine cntLine, ContourClass cntClass, ICanvas canvas)
{
if (!cntClass.IsDisplay)
{
return;
}
ICoordinateTransform tran = canvas.CoordTransform;
int nCount = cntLine.Count;
PointF[] pts = new PointF[nCount];
GCHandle dstHandle = GCHandle.Alloc(pts, GCHandleType.Pinned);
GCHandle srcHandle = GCHandle.Alloc(cntLine.Points, GCHandleType.Pinned);
try
{
MemoryCopy(dstHandle.AddrOfPinnedObject(), srcHandle.AddrOfPinnedObject(), nCount << _pointfSize); // nCount * sizeof(PointF)
QuickTransform quickTran = drawArgs.QuickTransformArgs;
fixed(PointF *ptr0 = pts)
{
PointF *ptr = ptr0;
for (int i = 0; i < nCount; i++, ptr++)
{
quickTran.Transform(ptr);
}
}
Graphics g = drawArgs.Graphics as Graphics;
//
if (_isUseCurveRender)
{
g.DrawCurve(cntClass.Pen, pts, _tension);
}
else
{
_grahpicPath.Reset();
_grahpicPath.AddLines(pts);
g.DrawPath(cntClass.Pen, _grahpicPath);
}
//
if (_isLabel)
{
if (_isCheckConflicting)
{
if (_conflictor.IsConflicted(pts[0], cntClass.LabelBuffer.Size))
{
return;
}
_conflictor.HoldPosition(pts[0], cntClass.LabelBuffer.Size);
}
g.DrawImageUnscaled(cntClass.LabelBuffer, (int)pts[0].X, (int)pts[0].Y);
}
}
finally
{
dstHandle.Free();
srcHandle.Free();
}
}
//魔术棒判识
private void HandleMagicWand(object result, Dictionary <string, object> args)
{
GeometryOfDrawed geometry = result as GeometryOfDrawed;
IRasterDrawing drawing = GetRasterDrawing(_canvasViewer);
if (drawing == null)
{
return;
}
double prjX = 0, prjY = 0;
ICoordinateTransform tran = _canvasViewer.Canvas.CoordTransform;
//如果鼠标没有点中图像有效区域则直接退出
tran.Raster2Prj(geometry.RasterPoints[0].X, geometry.RasterPoints[0].Y, out prjX, out prjY);
if (prjX < drawing.OriginalEnvelope.MinX ||
prjX > drawing.OriginalEnvelope.MaxX ||
prjY < drawing.OriginalEnvelope.MinY ||
prjY > drawing.OriginalEnvelope.MaxY)
{
return;
}
//计算鼠标在当前视窗位图中的位置
int x = (int)((prjX - drawing.Envelope.MinX) / (drawing.Envelope.Width / (float)drawing.Bitmap.Width));
int y = (int)((drawing.Envelope.MaxY - prjY) / (drawing.Envelope.Height / (float)drawing.Bitmap.Height));
using (IBitmapMagicWand magicWand = new BitmapMagicWand())
{
Bitmap crtBitmap = drawing.Bitmap;
BitmapData pdata = crtBitmap.LockBits(new Rectangle(0, 0, crtBitmap.Width, crtBitmap.Height), ImageLockMode.ReadWrite, crtBitmap.PixelFormat);
try
{
byte tolerance = 32;
bool isContinued = true;
if (args != null && args.Count == 2)
{
tolerance = byte.Parse(args["tolerance"].ToString());
isContinued = bool.Parse(args["iscontinued"].ToString());
}
/*
* 魔术棒提取
* ScanLineSegment为像素坐标扫描线三元组(Row,BeginCol,EndCol)
*/
ScanLineSegment[] segs = magicWand.ExtractSnappedPixels(pdata, new Point(x, y), tolerance, isContinued);
/*
* 将扫描线数组转换为判识结果
*/
MagicWandResult2ExtractReulst(segs, drawing);
}
finally
{
crtBitmap.UnlockBits(pdata);
}
_canvasViewer.Canvas.Refresh(enumRefreshType.All);
}
}
private CoordPoint SrceenToGeo(PointF pt, ICoordinateTransform coordTran)
{
double prjX = 0, prjY = 0;
double geoX = 0, geoY = 0;
coordTran.Screen2Prj(pt.X, pt.Y, out prjX, out prjY);
coordTran.Prj2Geo(prjX, prjY, out geoX, out geoY);
return(new CoordPoint(geoX, geoY));
}
public void ApplyDisplayForMg(IViewerControlCell cell)
{
DisplayData displayData = cell.Image.CurrentPage;
ICoordinateTransform transform = CoordinateTransformFactoryHelper.CoordinateTransformFactory.CreateCoordinateTransform(cell);
Point point1 = new Point();
Point point2 = new Point();
Vector v = new Vector();
var imageLaterality = string.Empty;
var isLaterality = displayData.ImageHeader.DicomHeader.TryGetValue(ServiceTagName.ImageLaterality, out imageLaterality);
if (!isLaterality)
{
return;
}
point1 = imageLaterality == "L" ? new Point(0, 0.5) : new Point(1, 0.5);
var pos = GetPostion(cell);
if (pos == -1)
{
return;
}
switch (pos)
{
case 0:
{
point2 = new Point(0, 0.5);
break;
}
case 1:
{
point2 = new Point(0.5, 0);
break;
}
case 2:
{
point2 = new Point(1, 0.5);
break;
}
case 3:
{
point2 = new Point(0.5, 1);
break;
}
}
Point p1 = transform.TranslatePoint(point1, PointType.RatioImage, PointType.Cell);
Point p2 = transform.TranslatePoint(point2, PointType.RatioCell, PointType.Cell);
v = p2 - p1;
displayData.PState.Translate(v.X, v.Y);
cell.Refresh(CellRefreshType.Image);
}
public unsafe void Render(object sender, IDrawArgs drawArgs)
{
if (_canvas == null)
{
_canvas = sender as ICanvas;
_spatialRef = GetSpatialRef();
_coordTransfrom = _canvas.CoordTransform;
}
Graphics g = drawArgs.Graphics as Graphics;
if (_gridLines == null)
{
bool isOK = ComputeValidGeoRange();
if (!isOK)
{
return;
}
ComputeGridLines(_coordTransfrom);
}
if (_gridLines != null)
{
GCHandle prjHandle = GCHandle.Alloc(_allPrjPoints, GCHandleType.Pinned);
GCHandle screenHandle = GCHandle.Alloc(_allPixelPoints, GCHandleType.Pinned);
try
{
QuickTransform qickTran = _coordTransfrom.QuickTransform;
int ptCount = _allPixelPoints.Length;
MemoryCopy(screenHandle.AddrOfPinnedObject(), prjHandle.AddrOfPinnedObject(), ptCount * Marshal.SizeOf(typeof(PointF)));
fixed(PointF *ptr0 = _allPixelPoints)
{
PointF *pixPtr = ptr0;
for (int i = 0; i < ptCount; i++, pixPtr++)
{
qickTran.Transform(pixPtr);
}
}
//draw lon lines
DrawLines(g, 0, _lonLines);
//draw lat lines
int end = Math.Min(_lonLines + _latLines, _gridLines.Count);
DrawLines(g, _lonLines, end);
//label
DrawLabel(g, qickTran);
}
finally
{
prjHandle.Free();
screenHandle.Free();
}
}
}
/// <summary>
/// 图像上绘制剖面图对应的直线
/// </summary>
/// <param name="canvas"></param>
/// <param name="drawArgs"></param>
private void DrawProfileLine(ICanvas canvas, IDrawArgs drawArgs)
{
if (_iserror)
{
return;
}
Graphics g = drawArgs.Graphics as Graphics;
SmoothingMode smode = g.SmoothingMode;
try
{
g.SmoothingMode = SmoothingMode.AntiAlias;
int x, y;
ICoordinateTransform coordTran = canvas.CoordTransform;
coordTran.Prj2Screen(_beginPoint.PrjX, _beginPoint.PrjY, out x, out y);
_vertices[0].X = x;
_vertices[0].Y = y;
if (!_endPoint.IsEmpty)
{
coordTran.Prj2Screen(_endPoint.PrjX, _endPoint.PrjY, out x, out y);
_vertices[1].X = x;
_vertices[1].Y = y;
}
else if (!_mousePoint.IsEmpty)
{
coordTran.Prj2Screen(_mousePoint.PrjX, _mousePoint.PrjY, out x, out y);
if (x == _vertices[0].X && y == _vertices[0].Y)
{
return;
}
if (MathHelp.DistanceLessThan(_vertices[0].X, _vertices[0].Y, x, y, 4))
{
return;
}
_vertices[1].X = x;
_vertices[1].Y = y;
}
g.DrawLines(_pofileLinePen, _vertices);
g.FillEllipse(_profileRectangleBrush, new RectangleF(_vertices[0].X - 2, _vertices[0].Y - 2, 4, 4)); //端点
}
catch (Exception ex)
{
_iserror = true;
SizeF fontSize = g.MeasureString(ex.Message, _labelFont);
RectangleF fontRect = new RectangleF(canvas.Container.Width - fontSize.Width - offsetToTopAndLeft, offsetToTopAndLeft, fontSize.Width, fontSize.Height);
g.DrawString(ex.Message, _labelFont, _profileRectangleBrush, fontRect);
}
finally
{
g.SmoothingMode = smode;
}
}
public void Render(object sender, IDrawArgs drawArgs)
{
//左上角绘制信息列表
if (_infoItems.Count == 0)
{
return;
}
Graphics g = drawArgs.Graphics as Graphics;
float x = 50;
float y = 10;
SizeF fontSize = g.MeasureString("100", _font);
int rowStep = (int)(fontSize.Height + 2);
foreach (InfoItem item in _infoItems)
{
g.DrawString(item.ToString(), _font, Brushes.Yellow, x, y);
y += rowStep;
}
ICanvas canvas = sender as ICanvas;
if (_visible)
{
ICoordinateTransform coordTran = canvas.CoordTransform;
QuickTransform qt = drawArgs.QuickTransformArgs;
//绘制拐点
foreach (InfoItem item in _infoItems)
{
int row = 0, col = 0;
double geoX, geoY;
coordTran.Geo2Prj(item.Longitude, item.Latitude, out geoX, out geoY);
coordTran.Prj2Screen(geoX, geoY, out col, out row);
g.FillEllipse(Brushes.Yellow, new RectangleF(col - 3, row - 3, 6, 6));
}
//绘制冰缘线
if (_geoItems != null)
{
foreach (CodeCell.AgileMap.Core.Feature items in _geoItems)
{
GraphicsPath path = ToGraphicsPath(items, canvas);
g.DrawPath(Pens.Red, path);
}
}
}
}
private void ToRasterPointF(ref PointF pt, ICanvas canvas)
{
ICoordinateTransform coordTran = canvas.CoordTransform;
//if (canvas.PrimaryDrawObject != null)//有活动影像是返回栅格坐标
//{
// float row = 0, col = 0;
// coordTran.Screen2Raster(pt.X, pt.Y, out row, out col);
// pt.X = col;
// pt.Y = row;
//}
//else//无活动影像时返回投影坐标
{
double prjX = 0, prjY = 0;
coordTran.Screen2Prj(pt.X, pt.Y, out prjX, out prjY);
pt.X = (float)prjX;
pt.Y = (float)prjY;
}
}
public ShapePoint GetLocationByFeature(Feature fet)
{
lock (fet)
{
ShapePoint pt = fet.Geometry.Centroid.Clone() as ShapePoint;
ICoordinateTransform tran = (_mapRuntime as IFeatureRenderEnvironment).CoordinateTransform;
if ((fet.Projected && fet.FeatureClass.OriginalCoordinateType == enumCoordinateType.Geographic) ||
fet.FeatureClass.OriginalCoordinateType == enumCoordinateType.Projection)
{
return(pt);
}
else if (!fet.Projected && fet.FeatureClass.OriginalCoordinateType == enumCoordinateType.Geographic)
{
tran.GeoCoord2PrjCoord(new ShapePoint[] { pt });
}
return(pt);
}
}
private void EventPoint(object sender, enumCanvasEventType eventType, DrawingMouseEventArgs e)
{
if (eventType != enumCanvasEventType.MouseDown)
{
return;
}
GeometryOfDrawed geometry = new GeometryOfDrawed();
geometry.ShapeType = _pencilType.ToString();
ICoordinateTransform tran = (sender as ICanvas).CoordTransform;
float row = 0, col = 0;
tran.Screen2Raster(e.ScreenX, e.ScreenY, out row, out col);
geometry.RasterPoints = new PointF[] { new PointF(row, col) };
if (this._pencilDrawedResultFinished != null)
{
this._pencilDrawedResultFinished(geometry);
}
}
private static Core.DrawEngine.CoordEnvelope GetDrawingEnvelop(ICanvas canvas, IRasterDataProvider prd)
{
if (prd == null)
{
return(null);
}
GeoDo.RSS.Core.DF.CoordEnvelope cop = prd.CoordEnvelope.Clone();
ICoordinateTransform tans = canvas.CoordTransform;
if (prd.CoordType == enumCoordType.PrjCoord)
{
return(new GeoDo.RSS.Core.DrawEngine.CoordEnvelope(cop.MinX, cop.MaxX, cop.MinY, cop.MaxY));
}
else
{
GeoDo.RSS.Core.DrawEngine.CoordEnvelope prjEvp = new Core.DrawEngine.CoordEnvelope(cop.MinX, cop.MaxX, cop.MinY, cop.MaxY);
tans.Geo2Prj(prjEvp);
return(prjEvp);
}
}
private PixelInfo GetPixelInfo(ICanvas canvas, int screenX, int screenY)
{
ICoordinateTransform coordTran = canvas.CoordTransform;
PixelInfo pInfo = new PixelInfo();
pInfo.ScreenX = screenX;
pInfo.ScreenY = screenY;
if (canvas.IsReverseDirection)
{
IReversedCoordinateTransform tran = canvas as IReversedCoordinateTransform;
tran.Screen2Prj(screenX, screenY, out pInfo.PrjX, out pInfo.PrjY);
tran.Screen2Raster((float)screenX, (float)screenY, out pInfo.RasterY, out pInfo.RasterX);
}
else
{
coordTran.Screen2Prj(screenX, screenY, out pInfo.PrjX, out pInfo.PrjY);
coordTran.Screen2Raster((float)screenX, (float)screenY, out pInfo.RasterY, out pInfo.RasterX);
}
//coordTran.Prj2Geo(pInfo.PrjX, pInfo.PrjY, out pInfo.GeoX, out pInfo.GeoY);
return(pInfo);
}
public static IEnumerable <Point> ToData(this ICoordinateTransform converter, IEnumerable <Point> screenPoints)
{
ICollection <Point> pointsCollection = screenPoints as ICollection <Point>;
List <Point> res;
if (pointsCollection != null)
{
res = new List <Point>(pointsCollection.Count);
}
else
{
res = new List <Point>();
}
foreach (var point in screenPoints)
{
res.Add(converter.ToData(point));
}
return(res);
}
private unsafe void Project(ContourLine cntLine, ICanvas canvas)
{
ICoordinateTransform tran = canvas.CoordTransform;
if (tran == null)
{
return;
}
int nCount = cntLine.Count;
fixed(PointF *ptr0 = cntLine.Points)
{
PointF *ptr = ptr0;
for (int i = 0; i < nCount; i++, ptr++)
{
tran.Raster2Prj(ptr);
}
}
cntLine.UpdateEnvelope();
}
private Envelope ToGeoEnvelope(IMapRuntime runtime, Envelope currentExtent)
{
ICoordinateTransform coord = runtime as ICoordinateTransform;
ShapePoint[] pts = currentExtent.Points;
coord.PrjCoord2GeoCoord(pts);
double minX = double.MaxValue;
double minY = double.MaxValue;
double maxX = double.MinValue;
double maxY = double.MinValue;
foreach (ShapePoint pt in pts)
{
if (pt.X < minX)
{
minX = pt.X;
}
if (pt.Y < minY)
{
minY = pt.Y;
}
if (pt.X > maxX)
{
maxX = pt.X;
}
if (pt.Y > maxY)
{
maxY = pt.Y;
}
}
Envelope envelope = new Envelope();
envelope.MinX = minX;
envelope.MinY = minY;
envelope.MaxX = maxX;
envelope.MaxY = maxY;
return(envelope);
}
public void Render(object sender, IDrawArgs drawArgs)
{
if (!_visible || _beginPoint.IsEmpty)
{
return;
}
if (_endPoint.IsEmpty && _mousePoint.IsEmpty)
{
return;
}
ICanvas canvas = sender as ICanvas;
ICoordinateTransform coordTran = canvas.CoordTransform;
//初始化剖面图缓存图像。
//...暂未实现
//绘制剖面线段
DrawProfileLine(canvas, drawArgs);
// 绘制剖面图
if (!_isGettingData)
{
DrawProfile(canvas, drawArgs);
}
}
private static Size GetMaxDataSize(ICanvas canvas, Core.DrawEngine.CoordEnvelope viewPrjEvp, IRasterDataProvider prd,
out GeoDo.RSS.Core.DF.CoordEnvelope viewGeoEvp)
{
viewGeoEvp = null;
if (prd == null)
{
return(Size.Empty);
}
viewGeoEvp = null;
ICoordinateTransform tans = canvas.CoordTransform;
viewGeoEvp = PrjToGeoCoordEvp(viewPrjEvp, tans);
if (prd.CoordType == enumCoordType.PrjCoord)
{
return(new Size((int)(viewPrjEvp.Width / prd.ResolutionX), (int)(viewPrjEvp.Height / prd.ResolutionY)));
}
else
{
double wid = 0;
double hei = 0;
tans.Prj2Geo(viewPrjEvp.Width, viewPrjEvp.Height, out wid, out hei);
return(new Size((int)(wid / prd.ResolutionX), (int)(hei / prd.ResolutionY)));
}
}
public List <string[]> transformCoords(string system, List <string[]> points, string type)
{
initRefSystem(system);
List <string[]> returnList = new List <string[]>();
if (type.Equals("reverse"))
{
trans = ctFac.CreateTransform(geographSystem, selectedSystem);
}
else
{
trans = ctFac.CreateTransform(selectedSystem, geographSystem);
}
NumberFormatInfo nFormatInfo = (NumberFormatInfo)NumberFormatInfo.CurrentInfo.Clone();
nFormatInfo.NumberDecimalSeparator = ",";
foreach (string[] sPoint in points)
{
double[] dPoint = new double[] { Convert.ToDouble(sPoint[0], nFormatInfo), Convert.ToDouble(sPoint[1], nFormatInfo) };
double[] newPoint = calcCoords(dPoint, type);
returnList.Add(new string[] { newPoint[0].ToString(nFormatInfo), newPoint[1].ToString(nFormatInfo) });
}
return(returnList);
}
public GeographicBounds TransformedWith <T>(ICoordinateTransform <T> transform)
{
return(new GeographicBounds(transform.From(MinimumCoordinates), transform.From(MaximumCoordinates)));
}
public void Event(object sender, enumCanvasEventType eventType, DrawingMouseEventArgs e)
{
if (!_enabled)
{
return;
}
ICanvas canvas = sender as ICanvas;
IRasterDrawing drawing = canvas.PrimaryDrawObject as IRasterDrawing;
if (drawing == null || drawing.DataProviderCopy == null)
{
return;
}
ICoordinateTransform coordTran = canvas.CoordTransform;
switch (eventType)
{
case enumCanvasEventType.MouseDown:
{
try
{
_isGettingData = true;
PixelInfo pInfo = GetPixelInfo(canvas, e.ScreenX, e.ScreenY);
if (_beginPoint.IsEmpty || _beginPoint.IsEmpty || _isNewProfile)
{ //开始一条新的
_beginPoint = pInfo;
_endPoint = PixelInfo.Empty;
_vertices = new Point[] { Point.Empty, Point.Empty };
_isNewProfile = false;
}
else
{ //完成一条线，完成本次剖面线选择
_endPoint = pInfo;
_enabled = false;
GetData(canvas);
}
}
finally
{
_isGettingData = false;
}
}
break;
case enumCanvasEventType.MouseMove:
if (_endPoint.IsEmpty && !_isNewProfile)
{
PixelInfo pInfo = GetPixelInfo(canvas, e.ScreenX, e.ScreenY);
_mousePoint = pInfo;
}
break;
case enumCanvasEventType.MouseUp:
break;
case enumCanvasEventType.MouseWheel:
break;
case enumCanvasEventType.Paning:
break;
case enumCanvasEventType.Zooming:
break;
case enumCanvasEventType.BeginPan:
break;
case enumCanvasEventType.BeginZoom:
break;
case enumCanvasEventType.DoubleClick:
break;
case enumCanvasEventType.EndPaning:
break;
case enumCanvasEventType.EndZoom:
break;
case enumCanvasEventType.KeyDown:
break;
case enumCanvasEventType.KeyPress:
break;
case enumCanvasEventType.KeyUp:
break;
default:
break;
}
}
public void Render(object sender, IDrawArgs drawArgs)
{
if (!_visible)
{
return;
}
ICanvas canvas = sender as ICanvas;
ICoordinateTransform coordTran = canvas.CoordTransform;
QuickTransform qt = drawArgs.QuickTransformArgs;
Graphics g = drawArgs.Graphics as Graphics;
g.SmoothingMode = SmoothingMode.AntiAlias;
Brush blue = new SolidBrush(Color.FromArgb(60, 0, 0, 255));
Pen bluePen = new Pen(Color.Blue, 2F);
Pen redPen = new Pen(Color.Red, 3F);
redPen.DashStyle = DashStyle.Dot;
Brush redBrush = new SolidBrush(Color.Red);
Brush yelloBrush = new SolidBrush(Color.Yellow);
Font font = new Font("微软雅黑", 10.0f);
SizeF distanceFontSize = g.MeasureString("12111.0", font);
Brush textBackgroundBrush = new SolidBrush(Color.FromArgb(100, 250, 250, 250));
Pen textBackUpPen = new Pen(Color.FromArgb(125, 125, 125));
if (_previousParts != null && _previousParts.Count > 0)
{
GraphicsPath previous = new GraphicsPath();
previous.FillMode = FillMode.Winding;
for (int i = 0; i < _previousParts.Count; i++)
{
List <PointF> points = new List <PointF>();
List <CoordPoint> part = _previousParts[i];
for (int j = 0; j < part.Count; j++)
{
int col = 0, row = 0;
coordTran.Prj2Screen(part[j].X, part[j].Y, out col, out row);
points.Add(new PointF(col, row));
}
g.DrawLines(bluePen, points.ToArray());
for (int j = 0; j < points.Count; j++)
{
g.FillEllipse(yelloBrush, new RectangleF(points[j].X - 3, points[j].Y - 3, 6, 6));
if (j == 0)
{
SizeF textRect = g.MeasureString("起点", font);
g.FillRectangle(textBackgroundBrush, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2, textRect.Width, textRect.Height);
g.DrawRectangle(textBackUpPen, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2, textRect.Width, textRect.Height);
g.DrawString("起点", font, redBrush, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2);
}
else if (j == _previousDistances[i].Length - 1)
{
SizeF textRect = g.MeasureString("总长" + FormatDistance(_previousDistances[i][j]), font);
g.FillRectangle(textBackgroundBrush, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2, textRect.Width, textRect.Height);
g.DrawRectangle(textBackUpPen, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2, textRect.Width, textRect.Height);
g.DrawString("总长" + FormatDistance(_previousDistances[i][j]), font, redBrush, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2);
}
else
{
SizeF textRect = g.MeasureString(FormatDistance(_previousDistances[i][j]), font);
g.FillRectangle(textBackgroundBrush, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2, textRect.Width, textRect.Height);
g.DrawRectangle(textBackUpPen, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2, textRect.Width, textRect.Height);
g.DrawString(FormatDistance(_previousDistances[i][j]), font, redBrush, points[j].X + 5, points[j].Y - distanceFontSize.Height / 2);
}
}
}
}
List <PointF> curpoints = new List <PointF>();
if (_coordinates != null)
{
int srceenX = 0, srceenY = 0;
for (int j = 0; j < _coordinates.Count; j++)
{
coordTran.Prj2Screen(_coordinates[j].X, _coordinates[j].Y, out srceenX, out srceenY);
curpoints.Add(new PointF(srceenX, srceenY));
}
if (curpoints.Count > 1)
{
g.DrawLines(bluePen, curpoints.ToArray());
for (int j = 0; j < curpoints.Count; j++)
{
PointF pt = curpoints[j];
g.FillRectangle(redBrush, new RectangleF(pt.X - 2.5f, pt.Y - 2.5f, 5f, 5f));
if (j == 0)
{
g.DrawString("起点", font, redBrush, pt.X + 5, pt.Y - distanceFontSize.Height / 2);
}
else
{
g.DrawString(FormatDistance(_curDistances[j]), font, redBrush, pt.X + 5, pt.Y - distanceFontSize.Height / 2);
}
}
}
if (curpoints.Count > 0 && _mouseDistance > 0)// && _standBy == false && hasMouse)
{
g.DrawLine(redPen, curpoints[curpoints.Count - 1], _mousePosition);
SizeF size = g.MeasureString("文字", font);
g.DrawString(string.Format("{0}", FormatDistance(_mouseDistance)), font, redBrush, _mousePosition.X + 2, _mousePosition.Y + size.Height);
g.DrawString("双击结束", font, redBrush, _mousePosition.X + 2, _mousePosition.Y + size.Height + size.Height);
//if (_areaMode && points.Count > 1)
//{
// g.DrawLine(redPen, points[0], _mousePosition);
//}
}
//if (points.Count > 1 && _areaMode && (_previousParts == null || _previousParts.Count == 0))
//{
// if (hasMouse && !_standBy)
// {
// points.Add(_mousePosition);
// }
// if (points.Count > 2)
// {
// g.FillPolygon(blue, points.ToArray());
// }
//}
}
bluePen.Dispose();
redPen.Dispose();
redBrush.Dispose();
yelloBrush.Dispose();
font.Dispose();
textBackgroundBrush.Dispose();
textBackUpPen.Dispose();
}
private void BuildVectorMapRuntime()
{
_vectorMapRuntime = new MapRuntime(this);
_coordTransfrom = (_vectorMapRuntime as IFeatureRenderEnvironment).CoordinateTransform;
}
public static Point ToData(this Point p, ICoordinateTransform converter)
{
return converter.ToData(p);
}
public ProjectionGridRoundTripper(CoordinateReferenceSystem cs)
{
_cs = cs;
_transInverse = CtFactory.CreateTransform(cs, WGS84);
_transForward = CtFactory.CreateTransform(WGS84, cs);
}
private void ComputeGridLines(ICoordinateTransform coordTran)
{
try
{
if (_gridLines != null)
{
_gridLines.Clear();
}
else
{
_gridLines = new List <GridLine>();
}
double span = _gridSpan;
int idx = 0;
double prjX, prjY;
double maxLon = 0d;
double maxLat = 0d;
double x = 0d, y = 0d;
//sample lon lines
foreach (Range range in _validLonRanges)
{
x = Math.Max(range.MinValue, _beginLon);
y = 0;
maxLon = Math.Min(range.MaxValue, _endLon);
maxLat = 0;
while (x <= maxLon)
{
y = Math.Max(_validLatRange.MinValue, _beginLat);
GridLine gridLine = new GridLine();
gridLine.BeginIndex = idx;
maxLat = Math.Min(_validLatRange.MaxValue, _endLat);
while (y <= maxLat)
{
coordTran.Geo2Prj(x, y, out prjX, out prjY);
_allPrjPoints[idx].X = (float)prjX;
_allPrjPoints[idx].Y = (float)prjY;
idx++;
y += span;
}
gridLine.SegmentCount = idx - gridLine.BeginIndex;
_gridLines.Add(gridLine);
x += span;
}
}
_lonLines = _gridLines.Count;
foreach (Range range in _validLonRanges)
{
//sample lat lines
y = _validLatRange.MinValue;
maxLat = Math.Min(_validLatRange.MaxValue, _endLat);
while (y <= _validLatRange.MaxValue)
{
GridLine gridLine = new GridLine();
gridLine.BeginIndex = idx;
x = range.MinValue;
maxLon = Math.Min(range.MaxValue, _endLon);
while (x <= maxLon)
{
coordTran.Geo2Prj(x, y, out prjX, out prjY);
_allPrjPoints[idx].X = (float)prjX;
_allPrjPoints[idx].Y = (float)prjY;
idx++;
x += span;
}
gridLine.SegmentCount = idx - gridLine.BeginIndex;
_gridLines.Add(gridLine);
y += span;
}
}
_latLines = _gridLines.Count - _lonLines;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static List<PointF> ParsePolygonString(String polygonString, String componentType, ICoordinateTransform coordinateTransformer)
{
List<PointF> returnList = new List<PointF>();
// left, center, right referring to ( , ) which wraps a point (1 , 2)
int searchFrom = 0;
while (searchFrom != -1 && polygonString.Length > 0)
{
int left = polygonString.IndexOf("(", searchFrom);
int center = polygonString.IndexOf(",", searchFrom);
int right = polygonString.IndexOf(")", searchFrom);
int leftPlusPlus = left + 1;
int centerPlusPlus = center + 1;
String xString = polygonString.Substring(leftPlusPlus, center - leftPlusPlus);
String yString = polygonString.Substring(centerPlusPlus, right - centerPlusPlus);
xString = xString.Replace("\r\n","").Trim();
yString = yString.Replace("\r\n","").Trim();
if (xString.Length > 0 && yString.Length > 0)
{
float xPoly = float.Parse(xString);
float yPoly = float.Parse(yString);
// use transform
xPoly = coordinateTransformer.RetrieveX(xPoly);
yPoly = coordinateTransformer.RetrieveY(yPoly);
returnList.Add(new PointF(xPoly, yPoly));
}
searchFrom = polygonString.IndexOf(",", right) + 1;
if (searchFrom == 0)
{
searchFrom = -1; // index returns 0 as failure, but we want 0 on the first iteration, so use -1
}
} // point load while
coordinateTransformer.PostProcessPolygon(returnList, componentType);
return returnList;
}
public static Point ToData(this Point p, ICoordinateTransform converter)
{
return(converter.ToData(p));
}
