楼间距采光计算 保定市大概纬度38.8度,东经115.5度 两栋楼高都是11层的楼,楼间距40米左右 我买的后面4楼 请
问题描述：
楼间距采光计算 保定市大概纬度38.8度,东经115.5度 两栋楼高都是11层的楼,楼间距40米左右 我买的后面4楼 请问采光情况如何 是否一年之中冬季的有些时候被前面的楼遮住阳光 帮忙计算出采光时间呀 计算准确我再加分呀 每层楼高3米 两栋楼都是朝南的正房
问题解答：
楼高多少,每层的
我来回答：
剩余:2000字
楼高多少,每层的
假设小高层朝向是正南朝向,层高2.90米（普遍值）,一楼紧贴地面建设,屋顶的高度忽略.你住3层的话南面楼的水平垂直高度为9层*2.9=26.1米,楼间距35米,tgA=0.746 查三角函数表的话A=36度左右,就是说太阳的照射角度超过36度才能不影响采光,山东以青岛的纬度36.5计算的话冬天冬至日正午（角度最小）的照
你先看看是那栋楼挡住你们的采光,这里有个一采光计算器,需要知道你们楼遮阳楼的高度 和你们楼的层高,直接输入就可以算出来.下面文章里有,自己输入后计算结果就出来了.不知道的话可以给我留言,告诉我遮阳楼的楼高和你们楼层高
　　楼间距规定　　可以用：楼高：楼间距＝1：1.2比值计算.　　按照国家规定（设计规范）以冬至日照时间不低于1小时（房子最底层窗户）为标准.间距是用建筑物室外坪至房屋檐口的高度/tan(a) a-各地在冬至日正午时的太阳高度角.　　其他相关：房的采光状况是每个业主都十分关心的问题,当有新建的建筑在自己住房周围出现时,大
计算出楼房33层的总高度.在计算下30层楼的高度,在间距40米处,那么就要以冬至日日照角度及阳光遮挡的计算冬至日太阳在南纬23度24分.和你所在地区的维度来计算的,举例给你说明：石家庄岩山风景名胜区为例：冬至日太阳在南纬23度26分,石家庄的纬度为38度04分冬至日阳光照射角度为90-[38度04分-(-23度26分)
Private Sub Command1_Click()If Not IsNumeric(Trim(Text1.Text)) ThenMsgBox "A不是数字"Text1.SetFocusExit SubEnd IfIf Not IsNumeric(Trim(Text2.Text)) ThenMsgBox "B不是数
设在新楼第x层,旧楼第y层3.2x=2.8yx
2x1.5x3.14=9.42cm2x2x3.14=12.56cm比 9.42:1.5=6.=6.28可以组成比 9.42:1.5=12.56:2如果本题有什么不明白可以追问,
某地某时的太阳高度角(α)=90°-(当地纬度-太阳直射点纬度).(注:北纬为正,南纬为负)如宁波(30°N)夏至日的太阳高度为:90°-(30°-23.5°)=83.5°；北京(40°N)冬至日的太阳高度为:90°-[40°-(-23.5°)]=26.5°;赤道春分日的太阳高度为:90°-(0°-0°)=90°;赤道
打开下面这个网址看吧,那里很详细,是我的回答,一、经线、纬线纬线 经线1.形状 圆 半圆2.大小 赤道最长4万千米 都等长,2万千米网两极渐短成0千米 3.标数的界限 赤道(0°纬线) 0°、180°经线以北北纬、以南南纬 0°东180°西为东经度0°西180°东为西经度4.标度数的范围 0°~90° 0°~180°5
按照你所说的经纬度来看,位置应该处于广东省江门市.
谁知道离北海道多远,那里有事没.
记住下面就好判断了：赤道以北的是北纬,以南的是南纬；北纬（N）的在北半球,南纬（S）的在南半球；经度小于20度的在东半球,大于160度的在西半球,其它（20－160度之间）的东经（E）在东半球、西经（W）在西半球 .低纬度：0－30度；中纬度：30－60度；高纬度：60－90度所以北纬38.1度,东经142.3度在北半
在世界上纬度为40度,东经为116度的,这种记法在地球表面上有2处：北纬40度,东经116度；南纬40度,东经116度.
无稽之谈! 再问： 两栋高楼层高90米这样，最近的一栋大概40米，看上一个缝隙对着我家，狭缝宽度9米这样。看上别扭 再答： 如果你家遇到什么问题，可能算卦先生会找出一大堆风水问题，说明各种风向、地理、水流、建筑等等不合适！但如果你家遇到喜事，可能不会去找风水先生！所以它们嘴里只有灾祸，没有好事！其实，如果风水先生真能预
假设数据在A1:C5中,则公式为：=sumproduct((a2:a5=2)*(c2:c5""))
楼间距规定 可以用：楼高：楼间距＝1：1.2比值计算.按照国家规定（设计规范）以冬至日照时间不低于1小时（房子最底层窗户）为标准.间距是用建筑物室外坪至房屋檐口的高度/tan(a) a-各地在冬至日正午时的太阳高度角.因此结论 你们楼房会严重影响采光.楼间距需要在 150米左右.所以 50米是不符合规定民法规定：不动产
一一问答您.1.一平米的建筑面积,大概是2平米～2.5平米左右模板,这样估算还是比较初的.稍精确的一点的,就是取个典型的层,作一下模板图,计算一下,然后,分析一下这个放大系数（建筑面积乘多少的放大系数才是模板的用量）这些都是没有公式的,都是大家分析啊.统计出来的一些经验数据.2.最少要一套模板吧.一个工作段的模板,正常
也许感兴趣的知识经纬度坐标映射到平面直角坐标系
关键词：经纬度坐标，平面直角坐标，空间大地坐标系，坐标系映射
一、坐标系分类
在大地测量学中，坐标系分为两大类：地心坐标系和参心坐标系
1、地心坐标系
坐标原点与地球质心重合的坐标系。
世界大地坐标系WGS-84（world geodetic system）是地心坐标系。
2、参心坐标系
坐标系原点在参考椭球体中心，不与地球质心重合。
北京54，采用前苏联的椭球体，属于参心坐标系。
西安80，也属于参心坐标系
3、空间直角坐标系
空间直角坐标系的坐标原点位于参考椭球的中心，Z轴指向参考椭球的北极，X轴指向起始子午面与赤道的交点，Y轴位于赤道面上切按右手系于X轴呈90度夹角，某点中的坐标可用该点在此坐标系的各个坐标轴上的投影来表示。空间直角坐标系可用如下图所示（参考）：
4、空间大地坐标系
大地坐标系是采用大地纬度、经度和大地高程来描述空间位置的。纬度是空间的点与参考椭球面的法线与赤道面的夹角；经度是空间的点与参考椭球的自转轴所在的面与参考椭球的起始子午面的夹角；大地高程是空间的点沿着参考椭球的法线方向到参考椭球面的距离（参考）。
5、平面直角坐标系
平面直角坐标：如坐标原点o是任意假定的，则为独立的平面直角坐标系。
由于测量上所用的方向是从北方向(纵轴方向)起按顺时针方向以角度计值(象限也按顺时针编号)。因此，将数学上平面直角坐标系(角值从横轴正方向起按逆时针方向计值)的 x 和 y轴互换后，数学上的三角函数计算公式可不加改变直接用于测量数据的计算。
平面坐标系是利用投影变换，将空间直角坐标系或空间大地坐标系通过数学变化映射到平面上，这种变换称为投影变换。
二、坐标系转换
从空间坐标系到平面坐标系的映射方法有很多种：高斯-克吕格投影、墨卡托投影、兰伯特投影、UTM投影等。（参考，，，）
三、坐标系投影的实现（source code）
1、如何将GPS坐标转换为XY平面坐标（简易转换）
本文根据《GPS经纬度坐标转平面坐标的简化计算方法及精度分析》这篇文章中的的方法将GPS经纬度坐标转换为以地平面上平面直角坐标系中的X、Y坐标。这个转换方法的前提是在一定的范围以内。具体的转化公式请参考该文，下面是坐标转换的代码：
public class PlaneCoordinate {
private static final double MACRO_AXIS = 6378137;
private static final double MINOR_AXIS = 6356752;
private static double turnY(GePoint basePoint, GePoint point) {
double a = Math.pow(MACRO_AXIS, 2.0);
double b = Math.pow(MINOR_AXIS, 2.0);
double c = Math.pow(Math.tan(basePoint.getLatitude()), 2.0);
double d = Math.pow(1/Math.tan(basePoint.getLatitude()),2.0);
double x = a/Math.sqrt(a + b*c);
double y = b/Math.sqrt(b + a*d);
c = Math.pow(Math.tan(point.getLatitude()), 2.0);
d = Math.pow(1/Math.tan(point.getLatitude()), 2.0);
double m = a/Math.sqrt(a + b*c);
double n = b/Math.sqrt(b + a*d);
return new PePoint(x, y).distanceBetween(new PePoint(m, n));
private static double turnX(GePoint basePoint, GePoint point) {
double a = Math.pow(MACRO_AXIS, 2.0);
double b = Math.pow(MINOR_AXIS, 2.0);
double c = Math.pow(Math.tan(basePoint.getLatitude()), 2.0);
double x = a/Math.sqrt(a + b*c);
return x * (point.getLongtitude() - basePoint.getLongtitude());
public class GePoint {
private double
private double
public GePoint() {
public GePoint(double latitude, double longtitude) {
this.latitude =
this.longtitude =
public double getLatitude() {
return 2 * latitude * Math.PI / 360 ;
public void setLatitude(double latitude) {
this.latitude =
public double getLongtitude() {
return 2 * longtitude * Math.PI / 360;
public void setLongtitude(double longtitude) {
this.longtitude =
2、以上代码摘自，上述代码中PePoint类没有给出，需要进一步研究得出。文中还给出了另一种复杂的实现方法，代码摘录如下：
void GaussToGeo(double y, double x, short DH, double* L, double* B, double LP)
double l0;
double t_l0;
double t_B0;
double Bf0;
double X_3;
double PI = 3.79;
double b_e2 = 0.7;
double b_c = 78271;
Bf0 = 27. + 9. * X_3 - 0. * pow(X_3, 2)
- 0. * pow(X_3, 3) + 0. * pow(X_3, 4)
+ 0. * pow(X_3, 5) - 0. * pow(X_3, 6);
tf = tan(Bf0 * PI / 180);
etf = b_e2 * pow(cos(Bf0 * PI / 180), 2);
nf = y * sqrt(1 + etf) / b_c;
t_B0 = Bf0 - (1.0 + etf) * tf / PI * (90.0 * pow(nf, 2)
- 7.5 * (5.0 + 3 * pow(tf, 2) + etf - 9 * etf * pow(tf, 2)) * pow(nf, 4)
+ 0.25 * (61 + 90 * pow(tf, 2) + 45 * pow(tf, 4)) * pow(nf, 6));
t_l0 = (180 * nf - 30 * (1 + 2 * pow(tf, 2) + etf) * pow(nf, 3)
+ 1.5 * (5 + 28 * pow(tf, 2) + 24 * pow(tf, 4)) * pow(nf, 5))
/ (PI * cos(Bf0 * PI / 180));
l0 = (t_l0 * 3600.0);
if (LP == -1000)
*L = (double)((DH * 6 - 3) * 3600.0 + l0);
*L = LP * 3600.0 + l0;
*B = (double)(t_B0 * 3600.0);
void GeoToGauss(double jd, double wd, short DH, short DH_width, double* y, double* x, double LP)
double l0;
double jd_hd, wd_
double et2;
double tsin,
double PI = 3.79;
double b_e2 = 0.7;
double b_c = 78271;
jd_hd = jd / 3600.0 * PI / 180.0;
wd_hd = wd / 3600.0 * PI / 180.0;
if (LP == -1000)
L = (DH - 0.5) * DH_
l0 = jd / 3600.0 - L;
tsin = sin(wd_hd);
tcos = cos(wd_hd);
X = 1 / 3600.0 * wd - ( * tsin + 133.9238 * pow(tsin, 3)
+ 0.6976 * pow(tsin, 5) + 0.0039 * pow(tsin, 7)) *
et2 = b_e2 * pow(tcos, 2);
N = b_c / sqrt(1 + et2);
t = tan(wd_hd);
m = PI / 180 * l0 *
*x = X + N * t * (0.5 * pow(m, 2)
+ (5.0 - pow(t, 2) + 9.0 * et2 + 4 * pow(et2, 2)) * pow(m, 4) / 24.0
+ (61.0 - 58.0 * pow(t, 2) + pow(t, 4)) * pow(m, 6) / 720.0);
*y = N * (m + (1.0 - pow(t, 2) + et2) * pow(m, 3) / 6.0
+ (5.0 - 18.0 * pow(t, 2) + pow(t, 4) + 14.0 * et2
- 58.0 * et2 * pow(t, 2)) * pow(m, 5) / 120.0);
3、文章中给出了米勒坐标系投影和UTM坐标系投影的方法
米勒坐标系
package sg.edu.ntu.
public class MillerCoordinate {
public static double[] MillierConvertion(double lat, double lon)
double L = 6381372 * Math.PI * 2;
double W=L;
double H=L/2;
double mill=2.3;
double x = lon * Math.PI / 180;
double y = lat * Math.PI / 180;
y=1.25 * Math.log( Math.tan( 0.25 * Math.PI + 0.4 * y ) );
x = ( W / 2 ) + ( W / (2 * Math.PI) ) *
y = ( H / 2 ) - ( H / ( 2 * mill ) ) *
double[] result=new double[2];
result[0]=x;
result[1]=y;
使用这种方法转换后的Y轴方向似乎是反的，使用的时候需要注意。
package sg.edu.ntu.
import java.util.H
import java.util.M
public class CoordinateConversion
public CoordinateConversion()
public double[] utm2LatLon(String UTM)
UTM2LatLon c = new UTM2LatLon();
return c.convertUTMToLatLong(UTM);
public String latLon2UTM(double latitude, double longitude)
LatLon2UTM c = new LatLon2UTM();
return c.convertLatLonToUTM(latitude, longitude);
private void validate(double latitude, double longitude)
if (latitude & -90.0 || latitude & 90.0 || longitude & -180.0
|| longitude &= 180.0)
throw new IllegalArgumentException(
"Legal ranges: latitude [-90,90], longitude [-180,180).");
public String latLon2MGRUTM(double latitude, double longitude)
LatLon2MGRUTM c = new LatLon2MGRUTM();
return c.convertLatLonToMGRUTM(latitude, longitude);
public double[] mgrutm2LatLon(String MGRUTM)
MGRUTM2LatLon c = new MGRUTM2LatLon();
return c.convertMGRUTMToLatLong(MGRUTM);
public double degreeToRadian(double degree)
return degree * Math.PI / 180;
public double radianToDegree(double radian)
return radian * 180 / Math.PI;
private double POW(double a, double b)
return Math.pow(a, b);
private double SIN(double value)
return Math.sin(value);
private double COS(double value)
return Math.cos(value);
private double TAN(double value)
return Math.tan(value);
private class LatLon2UTM
public String convertLatLonToUTM(double latitude, double longitude)
validate(latitude, longitude);
String UTM = "";
setVariables(latitude, longitude);
String longZone = getLongZone(longitude);
LatZones latZones = new LatZones();
String latZone = latZones.getLatZone(latitude);
double _easting = getEasting();
double _northing = getNorthing(latitude);
UTM = longZone + " " + latZone + " " + ((int) _easting) + " "
+ ((int) _northing);
return UTM;
protected void setVariables(double latitude, double longitude)
latitude = degreeToRadian(latitude);
rho = equatorialRadius * (1 - e * e)
/ POW(1 - POW(e * SIN(latitude), 2), 3 / 2.0);
nu = equatorialRadius / POW(1 - POW(e * SIN(latitude), 2), (1 / 2.0));
double var1;
if (longitude & 0.0)
var1 = ((int) ((180 + longitude) / 6.0)) + 1;
var1 = ((int) (longitude / 6)) + 31;
double var2 = (6 * var1) - 183;
double var3 = longitude - var2;
p = var3 * 3600 / 10000;
S = A0 * latitude - B0 * SIN(2 * latitude) + C0 * SIN(4 * latitude) - D0
* SIN(6 * latitude) + E0 * SIN(8 * latitude);
K1 = S * k0;
K2 = nu * SIN(latitude) * COS(latitude) * POW(sin1, 2) * k0 * ()
K3 = ((POW(sin1, 4) * nu * SIN(latitude) * Math.pow(COS(latitude), 3)) / 24)
* (5 - POW(TAN(latitude), 2) + 9 * e1sq * POW(COS(latitude), 2) + 4
* POW(e1sq, 2) * POW(COS(latitude), 4))
* (00000L);
K4 = nu * COS(latitude) * sin1 * k0 * 10000;
K5 = POW(sin1 * COS(latitude), 3) * (nu / 6)
* (1 - POW(TAN(latitude), 2) + e1sq * POW(COS(latitude), 2)) * k0
A6 = (POW(p * sin1, 6) * nu * SIN(latitude) * POW(COS(latitude), 5) / 720)
* (61 - 58 * POW(TAN(latitude), 2) + POW(TAN(latitude), 4) + 270
* e1sq * POW(COS(latitude), 2) - 330 * e1sq
* POW(SIN(latitude), 2)) * k0 * (1E+24);
protected String getLongZone(double longitude)
double longZone = 0;
if (longitude & 0.0)
longZone = ((180.0 + longitude) / 6) + 1;
longZone = (longitude / 6) + 31;
String val = String.valueOf((int) longZone);
if (val.length() == 1)
val = "0" +
protected double getNorthing(double latitude)
double northing = K1 + K2 * p * p + K3 * POW(p, 4);
if (latitude & 0.0)
northing =
protected double getEasting()
return 500000 + (K4 * p + K5 * POW(p, 3));
double equatorialRadius = 6378137;
double polarRadius = ;
double flattening = 0.74748;
double inverseFlattening = 298.;
double rm = POW(equatorialRadius * polarRadius, 1 / 2.0);
double k0 = 0.9996;
double e = Math.sqrt(1 - POW(polarRadius / equatorialRadius, 2));
double e1sq = e * e / (1 - e * e);
double n = (equatorialRadius - polarRadius)
/ (equatorialRadius + polarRadius);
double rho = ;
double nu = ;
double S = ;
double A0 = ;
double B0 = ;
double C0 = 16.;
double D0 = 0.;
double E0 = 0.;
double p = -0.483084;
double sin1 = 4.84814E-06;
double K1 = ;
double K2 = ;
double K3 = 1.;
double K4 = 5;
double K5 = -2.;
double A6 = -1.00541E-07;
private class LatLon2MGRUTM extends LatLon2UTM
public String convertLatLonToMGRUTM(double latitude, double longitude)
validate(latitude, longitude);
String mgrUTM = "";
setVariables(latitude, longitude);
String longZone = getLongZone(longitude);
LatZones latZones = new LatZones();
String latZone = latZones.getLatZone(latitude);
double _easting = getEasting();
double _northing = getNorthing(latitude);
Digraphs digraphs = new Digraphs();
String digraph1 = digraphs.getDigraph1(Integer.parseInt(longZone),
_easting);
String digraph2 = digraphs.getDigraph2(Integer.parseInt(longZone),
_northing);
String easting = String.valueOf((int) _easting);
if (easting.length() & 5)
easting = "00000" +
easting = easting.substring(easting.length() - 5);
northing = String.valueOf((int) _northing);
if (northing.length() & 5)
northing = "0000" +
northing = northing.substring(northing.length() - 5);
mgrUTM = longZone + latZone + digraph1 + digraph2 + easting +
return mgrUTM;
private class MGRUTM2LatLon extends UTM2LatLon
public double[] convertMGRUTMToLatLong(String mgrutm)
double[] latlon = { 0.0, 0.0 };
int zone = Integer.parseInt(mgrutm.substring(0, 2));
String latZone = mgrutm.substring(2, 3);
String digraph1 = mgrutm.substring(3, 4);
String digraph2 = mgrutm.substring(4, 5);
easting = Double.parseDouble(mgrutm.substring(5, 10));
northing = Double.parseDouble(mgrutm.substring(10, 15));
LatZones lz = new LatZones();
double latZoneDegree = lz.getLatZoneDegree(latZone);
double a1 = latZoneDegree *
double a2 = 2000000 * Math.floor(a1 / );
Digraphs digraphs = new Digraphs();
double digraph2Index = digraphs.getDigraph2Index(digraph2);
double startindexEquator = 1;
if ((1 + zone % 2) == 1)
startindexEquator = 6;
double a3 = a2 + (digraph2Index - startindexEquator) * 100000;
if (a3 &= 0)
northing = a3 +
zoneCM = -183 + 6 *
double digraph1Index = digraphs.getDigraph1Index(digraph1);
int a5 = 1 + zone % 3;
double[] a6 = { 16, 0, 8 };
double a7 = 100000 * (digraph1Index - a6[a5 - 1]);
easting = easting + a7;
setVariables();
double latitude = 0;
latitude = 180 * (phi1 - fact1 * (fact2 + fact3 + fact4)) / Math.PI;
if (latZoneDegree & 0)
latitude = 90 -
double d = _a2 * 180 / Math.PI;
double longitude = zoneCM -
if (getHemisphere(latZone).equals("S"))
latitude = -
latlon[0] =
latlon[1] =
private class UTM2LatLon
String southernHemisphere = "ACDEFGHJKLM";
protected String getHemisphere(String latZone)
String hemisphere = "N";
if (southernHemisphere.indexOf(latZone) & -1)
hemisphere = "S";
public double[] convertUTMToLatLong(String UTM)
double[] latlon = { 0.0, 0.0 };
String[] utm = UTM.split(" ");
zone = Integer.parseInt(utm[0]);
String latZone = utm[1];
easting = Double.parseDouble(utm[2]);
northing = Double.parseDouble(utm[3]);
String hemisphere = getHemisphere(latZone);
double latitude = 0.0;
double longitude = 0.0;
if (hemisphere.equals("S"))
northing =
setVariables();
latitude = 180 * (phi1 - fact1 * (fact2 + fact3 + fact4)) / Math.PI;
if (zone & 0)
zoneCM = 6 * zone - 183.0;
zoneCM = 3.0;
longitude = zoneCM - _a3;
if (hemisphere.equals("S"))
latitude = -
latlon[0] =
latlon[1] =
protected void setVariables()
arc = northing / k0;
/ (a * (1 - POW(e, 2) / 4.0 - 3 * POW(e, 4) / 64.0 - 5 * POW(e, 6) / 256.0));
ei = (1 - POW((1 - e * e), (1 / 2.0)))
/ (1 + POW((1 - e * e), (1 / 2.0)));
ca = 3 * ei / 2 - 27 * POW(ei, 3) / 32.0;
cb = 21 * POW(ei, 2) / 16 - 55 * POW(ei, 4) / 32;
cc = 151 * POW(ei, 3) / 96;
cd = 1097 * POW(ei, 4) / 512;
phi1 = mu + ca * SIN(2 * mu) + cb * SIN(4 * mu) + cc * SIN(6 * mu) + cd
* SIN(8 * mu);
n0 = a / POW((1 - POW((e * SIN(phi1)), 2)), (1 / 2.0));
r0 = a * (1 - e * e) / POW((1 - POW((e * SIN(phi1)), 2)), (3 / 2.0));
fact1 = n0 * TAN(phi1) / r0;
_a1 = 500000 -
dd0 = _a1 / (n0 * k0);
fact2 = dd0 * dd0 / 2;
t0 = POW(TAN(phi1), 2);
Q0 = e1sq * POW(COS(phi1), 2);
fact3 = (5 + 3 * t0 + 10 * Q0 - 4 * Q0 * Q0 - 9 * e1sq) * POW(dd0, 4)
fact4 = (61 + 90 * t0 + 298 * Q0 + 45 * t0 * t0 - 252 * e1sq - 3 * Q0
* POW(dd0, 6) / 720;
lof1 = _a1 / (n0 * k0);
lof2 = (1 + 2 * t0 + Q0) * POW(dd0, 3) / 6.0;
lof3 = (5 - 2 * Q0 + 28 * t0 - 3 * POW(Q0, 2) + 8 * e1sq + 24 * POW(t0, 2))
* POW(dd0, 5) / 120;
_a2 = (lof1 - lof2 + lof3) / COS(phi1);
_a3 = _a2 * 180 / Math.PI;
double n0;
double r0;
double _a1;
double dd0;
double t0;
double Q0;
double lof1;
double lof2;
double lof3;
double _a2;
double phi1;
double fact1;
double fact2;
double fact3;
double fact4;
double zoneCM;
double _a3;
double b = ;
double a = 6378137;
double e = 0.;
double e1sq = 0.;
double k0 = 0.9996;
private class Digraphs
private Map digraph1 = new Hashtable();
private Map digraph2 = new Hashtable();
private String[] digraph1Array = { "A", "B", "C", "D", "E", "F", "G", "H",
"J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "X",
"Y", "Z" };
private String[] digraph2Array = { "V", "A", "B", "C", "D", "E", "F", "G",
"H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V" };
public Digraphs()
digraph1.put(new Integer(1), "A");
digraph1.put(new Integer(2), "B");
digraph1.put(new Integer(3), "C");
digraph1.put(new Integer(4), "D");
digraph1.put(new Integer(5), "E");
digraph1.put(new Integer(6), "F");
digraph1.put(new Integer(7), "G");
digraph1.put(new Integer(8), "H");
digraph1.put(new Integer(9), "J");
digraph1.put(new Integer(10), "K");
digraph1.put(new Integer(11), "L");
digraph1.put(new Integer(12), "M");
digraph1.put(new Integer(13), "N");
digraph1.put(new Integer(14), "P");
digraph1.put(new Integer(15), "Q");
digraph1.put(new Integer(16), "R");
digraph1.put(new Integer(17), "S");
digraph1.put(new Integer(18), "T");
digraph1.put(new Integer(19), "U");
digraph1.put(new Integer(20), "V");
digraph1.put(new Integer(21), "W");
digraph1.put(new Integer(22), "X");
digraph1.put(new Integer(23), "Y");
digraph1.put(new Integer(24), "Z");
digraph2.put(new Integer(0), "V");
digraph2.put(new Integer(1), "A");
digraph2.put(new Integer(2), "B");
digraph2.put(new Integer(3), "C");
digraph2.put(new Integer(4), "D");
digraph2.put(new Integer(5), "E");
digraph2.put(new Integer(6), "F");
digraph2.put(new Integer(7), "G");
digraph2.put(new Integer(8), "H");
digraph2.put(new Integer(9), "J");
digraph2.put(new Integer(10), "K");
digraph2.put(new Integer(11), "L");
digraph2.put(new Integer(12), "M");
digraph2.put(new Integer(13), "N");
digraph2.put(new Integer(14), "P");
digraph2.put(new Integer(15), "Q");
digraph2.put(new Integer(16), "R");
digraph2.put(new Integer(17), "S");
digraph2.put(new Integer(18), "T");
digraph2.put(new Integer(19), "U");
digraph2.put(new Integer(20), "V");
public int getDigraph1Index(String letter)
for (int i = 0; i & digraph1Array. i++)
if (digraph1Array[i].equals(letter))
return i + 1;
return -1;
public int getDigraph2Index(String letter)
for (int i = 0; i & digraph2Array. i++)
if (digraph2Array[i].equals(letter))
return -1;
public String getDigraph1(int longZone, double easting)
int a1 = longZ
double a2 = 8 * ((a1 - 1) % 3) + 1;
double a3 =
double a4 = a2 + ((int) (a3 / 100000)) - 1;
return (String) digraph1.get(new Integer((int) Math.floor(a4)));
public String getDigraph2(int longZone, double northing)
int a1 = longZ
double a2 = 1 + 5 * ((a1 - 1) % 2);
double a3 =
double a4 = (a2 + ((int) (a3 / 100000)));
a4 = (a2 + ((int) (a3 / ))) % 20;
a4 = Math.floor(a4);
if (a4 & 0)
a4 = a4 + 19;
return (String) digraph2.get(new Integer((int) Math.floor(a4)));
private class LatZones
private char[] letters = { 'A', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Z' };
private int[] degrees = { -90, -84, -72, -64, -56, -48, -40, -32, -24, -16,
-8, 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 84 };
private char[] negLetters = { 'A', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
'L', 'M' };
private int[] negDegrees = { -90, -84, -72, -64, -56, -48, -40, -32, -24,
-16, -8 };
private char[] posLetters = { 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Z' };
private int[] posDegrees = { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 84 };
private int arrayLength = 22;
public LatZones()
public int getLatZoneDegree(String letter)
char ltr = letter.charAt(0);
for (int i = 0; i & arrayL i++)
if (letters[i] == ltr)
return degrees[i];
return -100;
public String getLatZone(double latitude)
int latIndex = -2;
int lat = (int)
if (lat &= 0)
int len = posLetters.
for (int i = 0; i & i++)
if (lat == posDegrees[i])
latIndex =
if (lat & posDegrees[i])
latIndex = i - 1;
int len = negLetters.
for (int i = 0; i & i++)
if (lat == negDegrees[i])
latIndex =
if (lat & negDegrees[i])
latIndex = i - 1;
if (latIndex == -1)
latIndex = 0;
if (lat &= 0)
if (latIndex == -2)
latIndex = posLetters.length - 1;
return String.valueOf(posLetters[latIndex]);
if (latIndex == -2)
latIndex = negLetters.length - 1;
return String.valueOf(negLetters[latIndex]);
3、另外，文章给出了墨卡托投影的C#实现方法，摘录如下：
using System.Collections.G
using System.L
using System.T
using System.Threading.T
namespace MRP
public class ClassMct
static public int __IterativeTimes = 10;
static public double __IterativeValue = 0;
static public double __A = ;
static public double __B = ;
static public double __B0 = 0;
static public double __L0 = 0;
static public double DegreeToRad(double degree)
return Math.PI * degree / 180;
static public double RadToDegree(double rad)
return (180 * rad) / Math.PI;
static public void SetAB(double a, double b)
if (a &= 0 || b &= 0)
static public void SetLB0(double pmtL0, double pmtB0)
double l0 = DegreeToRad(pmtL0);
if (l0 & -Math.PI || l0 & Math.PI)
__L0 = l0;
double b0 = DegreeToRad(pmtB0);
if (b0 & -Math.PI / 2 || b0 & Math.PI / 2)
__B0 = b0;
/*******************************************
经纬度转XY坐标
pmtLB0: 参考点经纬度
pmtLB1: 要转换的经纬度
返回值: 直角坐标，单位：公里
*******************************************/
static public PointXY LBToXY(PointLB pmtLB0, PointLB pmtLB1)
SetLB0(pmtLB0.lon, pmtLB0.lat);
double B = DegreeToRad(pmtLB1.lat);
double L = DegreeToRad(pmtLB1.lon);
PointXY xy = new PointXY();
xy.x = 0; xy.y = 0;
double f, e, e_, NB0, K,
double E = Math.Exp(1);
if (L & -Math.PI || L & Math.PI || B & -Math.PI / 2 || B & Math.PI / 2)
if (__A &= 0 || __B &= 0)
f = (__A - __B) / __A;
dtemp = 1 - (__B / __A) * (__B / __A);
if (dtemp & 0)
e = Math.Sqrt(dtemp);
dtemp = (__A / __B) * (__A / __B) - 1;
if (dtemp & 0)
e_ = Math.Sqrt(dtemp);
NB0 = ((__A * __A) / __B) / Math.Sqrt(1 + e_ * e_ * Math.Cos(__B0) * Math.Cos(__B0));
K = NB0 * Math.Cos(__B0);
xy.x = K * (L - __L0);
xy.y = K * Math.Log(Math.Tan(Math.PI / 4 + (B) / 2) * Math.Pow((1 - e * Math.Sin(B)) / (1 + e * Math.Sin(B)), e / 2));
double y0 = K * Math.Log(Math.Tan(Math.PI / 4 + (__B0) / 2) * Math.Pow((1 - e * Math.Sin(__B0)) / (1 + e * Math.Sin(__B0)), e / 2));
xy.y = xy.y - y0;
xy.y = -xy.y;
/*******************************************
XY坐标转经纬度
pmtLB0: 参考点经纬度
pmtXY: 要转换的XY坐标，单位：公里
返回值: 经纬度
*******************************************/
static public PointLB XYtoLB(PointLB pmtLB0, PointXY pmtXY)
SetLB0(pmtLB0.lon, pmtLB0.lat);
double X = pmtXY.x;
double Y = -pmtXY.y;
double B = 0, L = 0;
PointLB lb = new PointLB();
lb.lat = 0; lb.lon = 0;
double f, e, e_, NB0, K,
double E = Math.Exp(1);
if (__A &= 0 || __B &= 0)
f = (__A - __B) / __A;
dtemp = 1 - (__B / __A) * (__B / __A);
if (dtemp & 0)
e = Math.Sqrt(dtemp);
dtemp = (__A / __B) * (__A / __B) - 1;
if (dtemp & 0)
e_ = Math.Sqrt(dtemp);
NB0 = ((__A * __A) / __B) / Math.Sqrt(1 + e_ * e_ * Math.Cos(__B0) * Math.Cos(__B0));
K = NB0 * Math.Cos(__B0);
double y0 = K * Math.Log(Math.Tan(Math.PI / 4 + (__B0) / 2) * Math.Pow((1 - e * Math.Sin(__B0)) / (1 + e * Math.Sin(__B0)), e / 2));
Y = Y + y0;
L = X / K + __L0;
B = __IterativeV
for (int i = 0; i & __IterativeT i++)
B = Math.PI / 2 - 2 * Math.Atan(Math.Pow(E, (-Y / K)) * Math.Pow(E, (e / 2) * Math.Log((1 - e * Math.Sin(B)) / (1 + e * Math.Sin(B)))));
lb.lon = RadToDegree(L);
lb.lat = RadToDegree(B);
4、开源坐标和投影转换库：
四、坐标系投影的工具
这里介绍几款坐标转换的工具
1、Excel转换工具
经纬度、平面坐标系转换方法
经纬度坐标转换成屏幕坐标
利用arcgis实现经纬度和平面坐标互转
经纬度与平面坐标的互相转换
利用米勒投影法实现经纬度和平面坐标的相互转换
openlayers3-经纬度坐标系转平面坐标系算法--米勒投影
经纬度坐标转换到平面坐标
经纬度坐标转为上海地方坐标代码（js代码）
没有更多推荐了，}