Polar 投影c#版本移植
from:http://hi.baidu.com/sungaoyong/item/0c4584d25873f131e3108f05
///刘泽军java版本的极坐标投影c#版本的移植
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
namespace MyPolar
{
/// <summary>
/// 自定义的Math类，支持角度到弧度和弧度到角度的计算
/// 对应Java Math中的Math.toDegrees和Math.toRadians
/// </summary>
class CMath
{
public static Double PI = Math.PI;
static public Double toDegrees(Double rad)
{
return (rad * (180.0f / PI));
}
static public Double toRadians(Double deg)
{
return (deg * (PI / 180.0f));
}
public static double cos(double d)
{
return Math.Cos(d);
}
public static double acos(double d)
{
return Math.Acos(d);
}
public static double sin(double d)
{
return Math.Sin(d);
}
public static double abs(double d)
{
return Math.Abs(d);
}
public static double IEEERemainder(double x, double y)
{
return Math.IEEERemainder(x, y);
}
public static double sqrt(double d)
{
return Math.Sqrt(d);
}
public static double atan(double d)
{
return Math.Atan(d);
}
}
/*
Polar 投影(扫描方式，自正北方向顺时针)
PACKAGE: cma.common.projection
FILENAME: Polar.java
LANGUAGE: Java2 v1.4
ORIGINAL: 无
DESCRIPTION: 极坐标投影(主要用于雷达图像处理)
RELATED: cma.common.projection.Lambert(兰勃特投影)
EDITOR: UltraEdit-32 v12.20a(Windows) NEdit(Linux)
CREATE: 2007-05-06 20:08:23
UPDATE: 2007-07-18 修改为抽象类Coordinate的扩展类
AUTHOR: 刘泽军 ()
广西气象减灾研究所
Guangxi Institude of Meteorology and Disaster-reducing Research(GIMDR)
Compile : javac Coordinate.java Polar.java
How to use Polar class:
Polar polar = new Polar(109.24, 24.35, 512, 384, 1.0, 0.0);//构造函数
...
孙高勇2011-02-10移植到DotNet版本。
*/
/**
*
* 扫描平面
* /
* /
* /
* /
* /
* / 仰角
* -------------------- 0度平面
*
* 如图所示：
* 扫描平面=>0度平面，需要乘以cos(仰角)
* 0度平面=>扫描平面，需要除以cos(仰角)
*
* 注意，日常显示的雷达图是扫描平面上的图。本类所说的屏幕指扫描平面。
*
*/
/**
* 雷达扫描示意图
*
* 359 0
* | radius
* | /
* | /
* |angle/
* | /
* | ^ /
* | /
* | /
* |/
* 270 -----------------中心----------------- 90
* |
* |
* |
* |
* |
* |
* |
* |
* |
* 180
*/
class Polar
{
//静态常量，地球半径，来源：《大气科学常用公式》，P601，附录
public static double RADIUS = 6371.004;//地球平均半径，单位：公里(Km)。
public static double RADIUS_POLAR = 6356.755;//地球两极半径，单位：公里(Km)。
public static double RADIUS_EQUATOR = 6373.140;//地球赤道半径，单位：公里(Km)。
//私有成员
private PointF center; //中心对应的屏幕位置
private Point place; //中心经纬度对应的屏幕坐标
private Point offset; //偏移量
//缩放系数
private double scale;
private double scaleOriginal;
//private double centerLongitude = 0.0; //中心经度
//private double centerLatitude = 0.0; //中心纬度
private double perKilometer = 1.0; //比例尺：一公里对应的像素点数(扫描平面)
private double elevation = 0.0; //仰角
private double cosineElevation = 1.0; //仰角的余弦值
private double kmPerDegreeX = 1.0; //1经度对应的距离(公里)，不同纬度数值不同
private double kmPerDegreeY = 1.0; //1纬度对应的距离(公里)，不同纬度数值不同
/**
* 功能：计算球面上两点间的距离(单位：公里)，原在edu.gimdr.Atmos.Meteorology类中写有，为避免import过多的类，故重写一份
* 参数：
* lon1,lat1 - 第1点的位置(经纬度)
* lon2,lat2 - 第2点的位置(经纬度)
* 返回值：
* 球面距离
*/
public static double distanceOfSphere(double lon1, double lat1, double lon2, double lat2)
{
/* 公式：
A(x,y) B(a,b)
AB点的球面距离=R*{arccos[cos(b)*cos(y)*cos(a-x)+sin(b)*sin(y)]}, by Google
*/
double rlon1 = CMath.toRadians(lon1);
double rlat1 = CMath.toRadians(lat1);
double rlon2 = CMath.toRadians(lon2);
double rlat2 = CMath.toRadians(lat2);
return (RADIUS * (CMath.acos(CMath.cos(rlat2) * CMath.cos(rlat1) * CMath.cos(rlon2 - rlon1) + CMath.sin(rlat2) * CMath.sin(rlat1))));
}
/**
* 功能:
* 重置参数
* 参数:
* lon,lat - 中心经纬度，
* px,py - 中心经纬度对应的屏幕坐标
* sc - 缩放系数
* agl - 仰角
* 返回值:
* 无
*/
public void reset(double lon, double lat, int px, int py, double sc, double agl)
{
//type = POLAR;
center = new PointF(
(float)(lon < 0.0 ? 0.0 : lon > 360.0 ? 360.0 : lon),
(float)(lat < -90.0 ? -90.0 : lat > 90.0 ? 90.0 : lat)
);
place = new Point(px, py);
elevation = CMath.toRadians(CMath.IEEERemainder(CMath.abs(agl), 90.0));//在0-90度之间，但不能为90度
cosineElevation = CMath.cos(elevation);//仰角的余弦值
scale = sc == 0.0 ? 1.0 : CMath.abs(sc);//缩放系数
scaleOriginal = scale;
offset = new Point(0, 0);
perKilometer = 1.0;//标准比例尺
////中心经纬度或仰角发生改变，必须重新计算经向和纬向的1度对应的球面距离
kmPerDegreeX = distanceOfSphere(center.X, center.Y, center.X + 1.0, center.Y) / cosineElevation;
kmPerDegreeY = distanceOfSphere(center.X, center.Y, center.X, center.Y + 1.0) / cosineElevation;
}
/**
* 功能：构造函数
* 参数：
* lon - 中心对应的经度坐标
* lat - 中心对应的纬度坐标
* x - 中心对应的屏幕位置x
* y - 中心对应的屏幕位置y
* sc - 缩放系数
* 返回值：
* 无
*/
public Polar(double lon, double lat, int x, int y, double sc)
{
reset(lon, lat, x, y, sc, 0.0);
}
/**
* 功能：构造函数
* 参数：
* lon - 中心对应的经度坐标
* lat - 中心对应的纬度坐标
* x - 中心对应的屏幕位置x
* y - 中心对应的屏幕位置y
* sc - 缩放系数
* agl = 仰角
* 返回值：
* 无
*/
public Polar(double lon, double lat, int x, int y, double sc, double agl)
{
reset(lon, lat, x, y, sc, agl);
}
/**
* 功能：获得仰角
* 参数：
* 无
* 返回值：
* 仰角的度数
*/
public double getElevation()
{
return (CMath.toDegrees(elevation));
}
/**
* 功能：获得经纬度对应的屏幕像素坐标，与雷达仰角有关，主要用于体扫数据显示、底图叠加等。
* 参数：
* lon - 经度
* lat - 纬度
* 返回值：
* 对应的屏幕坐标
*/
public Point getPosition(double lon, double lat)
{
double disX = distanceOfSphere(lon, center.Y, center.X, center.Y) / cosineElevation;
double disY = distanceOfSphere(center.X, lat, center.X, center.Y) / cosineElevation;
double x = (lon > center.X ? 1 : -1) * (disX * perKilometer * scale) + place.X + 0.5;
double y = -(lat > center.Y ? 1 : -1) * (disY * perKilometer * scale) + place.Y + 0.5;
return (new Point((int)x, (int)y));
}
/**
* 功能：获得极坐标对应的屏幕像素坐标，与雷达仰角无关，主要用于体扫数据显示、底图叠加等。
* 参数：
* radius - 极半径
* angle - 角度(以正北方向顺时针)
* 返回值：
* 对应的屏幕坐标
*/
public Point getXY(double radius, double angle)
{
int x = (int)(0.5 + radius * CMath.sin(CMath.toRadians(angle)));
int y = (int)(0.5 + radius * CMath.cos(CMath.toRadians(angle)));
return (new Point(place.X + x, place.Y - y));
}
/**
* 功能：获得屏幕像素点位置的极坐标半径，由于是输入参数是扫描平面上的值，故与雷达仰角无关。
* 参数：
* x - 水平坐标
* y - 垂直坐标
* 返回值：
* 与极坐标中心的距离，即极半径
*/
public double getRadius(int x, int y)
{
return (CMath.sqrt(1.0 * (x - place.X) * (x - place.X) + 1.0 * (y - place.Y) * (y - place.Y)));
}
/**
* 功能：获得经纬度位置的极坐标半径，与雷达仰角有关。
* 参数：
* lon - 经度坐标
* lat - 纬度坐标
* 返回值：
* 与极坐标中心的距离(象素点)，即极半径
*/
public double getRadius(double lon, double lat)
{
Point pos = getPosition(lon, lat);//此函数已经考虑了仰角的影响
return (getRadius(pos.X, pos.Y));
}
/**
* 功能：获得屏幕像素点位置的极坐标角度(扫描平面与0度平面均相同)，与雷达仰角无关。
* 参数：
* x - 水平坐标
* y - 垂直坐标
* 返回值：
* 角度值，自正北方向顺时针
*/
public double getAngle(int x, int y)
{
double agl = 0.0;
if (x == place.X && y == place.Y)
{
//重合
agl = 0.0;
}
else if (x == place.X)
{
agl = y > place.Y ? 180.0 : 360.0;
}
else if (y == place.Y)
{
agl = x > place.X ? 90.0 : 270.0;
}
else
{
agl = CMath.toDegrees(CMath.atan(1.0 * CMath.abs(x - place.X) / CMath.abs(y - place.Y)));
agl =
x > place.X && y < place.Y ? agl : //直角坐标的第一象限
x < place.X && y < place.Y ? 180.0 - agl : //直角坐标的第二象限
x < place.X && y > place.Y ? 180.0 + agl : //直角坐标的第三象限
x > place.X && y > place.Y ? 360.0 - agl : //直角坐标的第四象限
agl;
}
//System.out.println(agl);
return (agl);
}
/**
* 功能：获得经纬度位置的极坐标角度(扫描平面与0度平面均相同)，与雷达仰角无关。
* 参数：
* lon - 水平坐标
* lat - 垂直坐标
* 返回值：
* 角度值，自正北方向顺时针
*/
public double getAngle(double lon, double lat)
{
/*
//若通过获得屏幕坐标来计算角度，精度比较差，特别是在极坐标中心附近
Point p = getPosition(lon, lat);
return(getAngle(p.x, p.y);
*/
double agl = 0.0;
if( lon == center.X && lat == center.Y) //重合
{
agl = 0.0;
}
else if( lon == center.X )
{
agl = lat > center.Y ? 360.0 : 180.0;
}
else if( lat == center.Y )
{
agl = lon > center.X ? 90.0 : 270.0;
}
else
{
//注：由于经向和纬向的球面距离不等(华南，经向>纬向)，故点(1,1)与中心点(0,0)的极角不等45度，而应是略大于45度
agl = CMath.toDegrees(CMath.atan((CMath.abs(lon-center.X)*kmPerDegreeX)/(CMath.abs(lat-center.Y)*kmPerDegreeY)));
agl =
lon > center.X && lat > center.Y ? agl : //第一象限
lon < center.X && lat > center.Y ? 180.0 - agl : //第二象限
lon < center.X && lat < center.Y ? 180.0 + agl : //第三象限
lon > center.X && lat < center.Y ? 360.0 - agl : //第四象限
agl;
}
return(agl);
}
/**
* 功能:
* 获得屏幕坐标对应的经纬度
* 参数:
* x - 屏幕水平坐标
* y - 屏幕垂直坐标
* 返回值:
* 对应的经纬度
*/
public PointF getCoordinate(int x, int y)
{
/*
目标点 A(X,Y) 弧度
中心点 B(A,B) 弧度
AB球面距离=R*{arccos[cos(B)*cos(Y)*cos(A- X)+sin(B)*sin(Y)]}, by Google
经度相同 =& gt; AB = R*{arccos[cos(B)*cos(Y)+sin(B)*sin(Y)]}
=> AB = R*{arccos[cos(B-Y)]}
=> AB = R * (B-Y)
=> AB / R = B - Y
=> Y = B - AB /R
=> Y = B - (y-centerPosition.y)*cosineElevation/perKilometer/scale/R
*/
double lat = CMath.toDegrees(CMath.toRadians(center.Y) + (place.Y-y)*cosineElevation/perKilometer/scale/Polar.RADIUS);
double disX0 = distanceOfSphere(center.X, lat, center.X+1.0, lat);//0度平面上1经度的球面距离
double disX = disX0 / cosineElevation; //扫描平面上1经度的距离
double perDegreeX = disX * perKilometer * scale; //扫描平面上1经度的对应的像素点数
double lon = center.X + (x - place.X) / perDegreeX;
return (new PointF((float)lon, (float)lat));
}
/**
* 功能:
* 获得四角坐标对应的经纬度
* 参数:
* W - 图像高度
* H - 图像宽度
* 返回值:
* 对应的经纬度
* add by sungaoyong 2011-02-10
*/
public PointF[] getRecF(Double W, double H)
{
PointF PointLeftTop = getCoordinate((int)(0.5 + place.X - scale * W / 2), (int)(0.5 + place.Y - scale * H / 2));
PointF PointRightTop = getCoordinate((int)(0.5 + place.X + scale * W /2), (int)(0.5 + place.Y - scale * H / 2));
PointF PointLeftBottom = getCoordinate((int)(0.5 + place.X - scale * W / 2), (int)(0.5 + place.Y + scale * H / 2));
PointF PointRightBottom = getCoordinate((int)(0.5 + place.X + scale * W / 2), (int)(0.5 + place.Y + scale * H / 2));
return (new PointF[] { PointLeftTop, PointRightTop, PointLeftBottom, PointRightBottom });
}
/**
* 功能：
* 画经线、纬线
* 参数：
* g - 图形设备
* f - 字体
* c - 画线颜色
* inc_lon - 经线间隔//未使用
* inc_lat - 纬线间隔//未使用
* 返回值：
* 无
*/
public void drawGridLine(System.Drawing.Graphics g, Font f, Color c, int inc_lon, int inc_lat)
{
//Color saveColor = g.getColor();
//Font saveFont = g.getFont();
Pen blue = new Pen(Color.Blue);
//以下两行改进线条的锯齿
//RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
//g.setRenderingHints(renderHints);
// g.setColor(Color.black);//背景色
// g.fillRect(c.x-(int)(z*240), c.y-(int)(z*240), (int)(z*240*2), (int)(z*240*2));
//g.setColor(c);//雷达图形区域的边框颜色
g.DrawArc(blue,new RectangleF((int)(0.5+place.X-scale*240), (int)(0.5+place.Y-scale*240), (int)(0.5+scale*240*2), (int)(0.5+scale*240*2)),0,0);
//画极径
Point pos1, pos2;
for(double i=0.0; i<180.0; i=i+30.0)
{
pos1 = getXY(scale*240.0, 0.0+i);
pos2 = getXY(scale*240.0, 180.0+i);
g.DrawLine(blue,pos1.X, pos1.Y, pos2.X, pos2.Y);
}
//画极圈
for(int i=50; i<=200; i=i+50) //每50公里画一个圈
{
g.DrawArc(blue,new RectangleF((int)(0.5+place.X-scale*i), (int)(0.5+place.Y-scale*i), (int)(0.5+scale*i*2), (int)(0.5+scale*i*2)), 0, 360);
}
g.DrawArc(blue,new RectangleF((int)(0.5 + place.X - scale * 240), (int)(0.5 + place.Y - scale * 240), (int)(0.5 + scale * 240 * 2), (int)(0.5 + scale * 240 * 2)), 0, 360);//外圈240公里
//g.setFont(saveFont);
//g.setColor(saveColor);
}
}
}