Doppler天气雷达扫描产品(RadialImage)

多普勒天气雷达的体扫产品处理代码。
包含RadialImage.java、RadialImageBlock.java、RadialProductBlock.java三个类。
由SymbologyImage.java类判断产品为Symbology且特征码为AF1F时调用。

 

---

RadialImage.java

---

001 /**
002  * PACKAGE      : cma.gmb.doppler
003  * FILENAME     : RadialImage.java
004  * DESCRIPTION  : 处理多普勒雷达产品数据(扫描产品Radial)
005  * AUTHOR       : 刘泽军
006  * EMAIL        : BJ0773@gmail.com
007  * Date         : 2007-06-02 23:52:38
008  * Update       : 2007-06-13 从SymbologyImage.java独立出来
009  * Reference    : 《National Climatic Data Center DATA DOCUMENTATION FOR TD7000 -
010  *                 TD7599 NEXRAD LEVEL III》
011  *
012  * 注：部份代码参考了山东装备中心黄磊(stonehuang@126.com)的Pascal代码，特此声明并致谢。
013  *
014  */
015 
016 package cma.gmb.doppler;
017 
018 import java.io.*;
019 import java.awt.*;
020 
021 import cma.common.dataio.*;
022 import cma.common.projection.*;
023 import cma.micaps.diamond.*;
024 import cma.gmb.doppler.datatype.*;
025 
026 public class RadialImage {
027 
028     //外部传入的数据
029     public  MessageHeaderBlock          messageHeaderBlock;
030     public  ProductDescriptionBlock     productDescriptionBlock;
031     public  ProductSymbologyBlock       productSymbologyBlock;
032     public  ProductSymbologyLayerBlock  productSymbologyLayerBlock;
033 
034     //需要读取的数据
035     public  RadialProductBlock          radialProductBlock;
036     public  RadialImageBlock[]          radialImageBlock;
037 
038     public  static  Color[] levels  = {
039         new Color(  0,  0,  0), new Color(  0,  0,246), new Color(  1,159,246), new Color(  0,236,236),
040         new Color(  1,255,  0), new Color(  0,200,  0), new Color(  1,144,  0), new Color(255,255,  0),
041         new Color(231,192,  0), new Color(255,144,  0), new Color(254,  0,  0), new Color(214,  0,  0),
042         new Color(192,  0,  0), new Color(255,  0,250), new Color(174,144,240), new Color(255,255,255)
043     };
044 
045 /**
046  * 功能：构造函数
047  * 参数：
048  *      无
049  * 返回值：
050  *      无
051  */
052     public RadialImage() {
053     }
054 
055 /**
056  * 功能：读取Radial Image产品数据，不包括文件头信息，注意在调用前先定位好偏移量
057  * 参数：
058  *      fin     - 随机访问文件
059  * 返回值：
060  *      是否成功
061  */
062     public boolean read(RandomAccessFile fin) throws Exception {
063 
064         if( !"AF1F".equalsIgnoreCase(productSymbologyLayerBlock.PacketCode) ) {//非扫描数据 Radial Image
065             return(false);
066         }
067         boolean ok  = false;
068         radialProductBlock      = new RadialProductBlock();
069         ok  = radialProductBlock.read(fin);
070         if( ok && radialProductBlock.NumberOfRadials > 0 ) {
071             radialImageBlock    = new RadialImageBlock[radialProductBlock.NumberOfRadials];
072             for(int i=0;i<radialProductBlock.NumberOfRadials;i++) {
073                 radialImageBlock[i] = new RadialImageBlock();
074                 ok  = ok && radialImageBlock[i].read(fin);
075             }
076         }
077         return(ok);
078     }
079 
080 /**
081  * 功能：读取Radial Image产品数据，不包括文件头信息，注意在调用前先定位好读取偏移。主要是考虑直接从 .tar.gz 中读取
082  * 参数：
083  *      in      - InputStream，注意不能使用 in.close() 方法，因为在函数外部可能还需要继续从 in 读数据
084  * 返回值：
085  *      是否成功
086  */
087     public boolean read(InputStream fin) throws Exception {
088 
089         if( !"AF1F".equalsIgnoreCase(productSymbologyLayerBlock.PacketCode) ) {//非扫描数据 Radial Image
090             return(false);
091         }
092         boolean ok  = false;
093         radialProductBlock      = new RadialProductBlock();
094         ok  = radialProductBlock.read(fin);
095         if( ok && radialProductBlock.NumberOfRadials > 0 ) {
096             radialImageBlock    = new RadialImageBlock[radialProductBlock.NumberOfRadials];
097             for(int i=0;i<radialProductBlock.NumberOfRadials;i++) {
098                 radialImageBlock[i] = new RadialImageBlock();
099                 ok  = ok && radialImageBlock[i].read(fin);
100             }
101         }
102         return(ok);
103     }
104 
105 /**
106  * 功能：绘制雷达背景图(图形区域为640*480，雷达图形区域为480*480，雷达站点信息区域为160*480)
107  * 参数：
108  *      z       - 缩放系数
109  *      g       - 图形设备
110  *      c       - 雷达中心位置
111  *      pc      - 极圈
112  *      agl     - 径线间隔，非正值则不画径线
113  *      bnd     - 省市县边界
114  * 返回值：
115  *      是否成功
116  */
117     public boolean drawBackground(double z, Graphics2D g, Point c, boolean pc, double agl, boolean bnd) {
118         if( z <= 0.0 ) {
119             return(false);
120         }
121         try {
122             Polar   polar   = new Polar(c, 0.001*productDescriptionBlock.RadarLongitude, 0.001*productDescriptionBlock.RadarLatitude);
123             polar.setScale(1.0*z);
124             //以下两行改进线条的锯齿
125             RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
126             g.setRenderingHints(renderHints);
127 
128 //          g.setColor(Color.black);//背景色
129 //          g.fillRect(c.x-(int)(z*240), c.y-(int)(z*240), (int)(z*240*2), (int)(z*240*2));
130 
131             g.setColor(Color.white);//雷达图形区域的边框颜色
132             g.drawRect(c.x-(int)(z*240), c.y-(int)(z*240), (int)(z*240*2), (int)(z*240*2)-2);
133 
134             if( bnd ) {//画行政边界
135                 Coordinate  coordinate  = new Coordinate(polar);
136                 Diamond09.drawBorderline(g, new Color(92,92,92), coordinate, "/GIMDR/gmiss/config/CountyMap.dat");
137                 Diamond09.drawBorderline(g, new Color(160,160,160), coordinate, "/GIMDR/gmiss/config/ProvinceMap.dat");
138             }
139 
140             if( pc ) {//画极圈
141                 g.setColor(new Color(255,255,255));
142                 for(int i=50;i<=200;i=i+50) {//每50公里画一个圈
143                     g.drawArc(c.x-(int)(z*i), c.y-(int)(z*i), (int)(z*i)*2, (int)(z*i)*2, 0, 360);
144                 }
145                 g.drawArc(c.x-(int)(z*240), c.y-(int)(z*240), (int)(z*240)*2, (int)(z*240)*2, 0, 360);//外圈240公里
146             }
147 
148             if( agl >= 1.0 ) {//画极径
149                 Point   pos1, pos2;
150                 for(double i=0.0;i<180.0;i=i+agl) {
151                     pos1    = polar.getXY(z*240.0,   0.0+i);
152                     pos2    = polar.getXY(z*240.0, 180.0+i);
153                     g.drawLine(pos1.x, pos1.y, pos2.x, pos2.y);
154                 }
155             }
156             return(true);
157         }
158         catch(Exception ex) {
159             System.out.println(ex.getMessage());
160             ex.printStackTrace();
161             return(false);
162         }
163     }
164 
165 /**
166  * 功能：绘制雷达信息区域
167  * 参数：
168  *      g       - 图形设备
169  *      m       - 雷达信息区域左上角位置
170  * 返回值：
171  *      是否成功
172  */
173     public boolean drawInformation(Graphics2D g, Point m) {
174         //以下两行改进线条的锯齿
175         RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
176         g.setRenderingHints(renderHints);
177         g.setColor(Color.white);//信息区域的边框颜色
178         g.drawRect(m.x, m.y, 160, 479);//住处区域的边框
179         return(true);
180     }
181 
182 /**
183  * 功能：绘制雷达产品图，根据不同类型分别调用相应的画图函数
184  * 参数：
185  *      z       - 缩放系数
186  *      g       - 图形设备
187  *      c       - 雷达中心位置
188  * 返回值：
189  *      是否成功
190  */
191     public boolean draw(double z, Graphics2D g, Point c) {
192         return(
193             z <= 0.0 ||
194             null == radialProductBlock ||
195             radialProductBlock.NumberOfRadials <= 0 ||
196             drawRadialImage(z, g, c)
197         );
198     }
199 /**
200  * 功能：绘制RadialImage扫描图像(采用多边形填充法代替弧形填充)
201  * 参数：
202  *      z       - 缩放系数
203  *      g       - 图形设备
204  *      c       - 雷达中心位置
205  * 返回值：
206  *      是否成功
207  */
208     public boolean drawRadialImage(double z, Graphics2D g, Point c) {
209 
210         Polar   polar   = new Polar(c, 0.001*productDescriptionBlock.RadarLongitude, 0.001*productDescriptionBlock.RadarLatitude);
211         polar.setScale(1.0);
212 //背景
213         //以下两行改进线条的锯齿
214         RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
215         g.setRenderingHints(renderHints);
216 
217         Point   pos;
218         double  rangeScaleFactor    = 0.001 * (int)radialProductBlock.RangeScaleFactor;
219         Polygon p   = new Polygon();
220         for(int i=0;i<radialProductBlock.NumberOfRadials;i++) {
221             int iRunCount   = 0;
222             int iRunValue   = 0;
223             int iColor      = -1;
224             for(int j=0;j<radialImageBlock[i].NumberOfRadialRLE*2;j++) {
225                 iRunValue   = radialImageBlock[i].Data[j] >> 4 & 0xF;
226                 iColor      = radialImageBlock[i].Data[j] & 0xF;
227                 if( iRunValue > 0 && iColor >= 0 && iColor < 15 && radialImageBlock[i].DeltaAngle > 0 ) {
228                     g.setColor(RadialImage.levels[iColor]);
229                     p.reset();//重置多边形为空
230                     if( iRunCount == 0 ) {
231                         p.addPoint(c.x, c.y);
232                     }
233                     else {
234 /*
235                         //矩形填充
236                         pos = polar.getXY(z*rangeScaleFactor*iRunCount, 0.1*radialImageBlock[index][i].StartAngle);
237                         p.addPoint(pos.x, pos.y);
238                         pos = polar.getXY(z*rangeScaleFactor*iRunCount, 0.1*(radialImageBlock[index][i].StartAngle+radialImageBlock[index][i].DeltaAngle-1));
239                         p.addPoint(pos.x, pos.y);
240 */
241                         for(double k=0.0;k<=0.1*radialImageBlock[i].DeltaAngle-0.1;k=k+0.01) {
242                             pos = polar.getXY(z*rangeScaleFactor*iRunCount, 0.1*radialImageBlock[i].StartAngle+k);
243                             p.addPoint(pos.x, pos.y);
244                         }
245 
246                     }
247 /*
248                     //矩形填充
249                     pos = polar.getXY(z*rangeScaleFactor*(iRunCount+iRunValue), 0.1*(radialImageBlock[index][i].StartAngle+radialImageBlock[index][i].DeltaAngle-1));
250                     p.addPoint(pos.x, pos.y);
251                     pos = polar.getXY(z*rangeScaleFactor*(iRunCount+iRunValue), 0.1*radialImageBlock[index][i].StartAngle);
252                     p.addPoint(pos.x, pos.y);
253 */
254                     //多边形填充
255                     for(double k=0.1*radialImageBlock[i].DeltaAngle-0.1;k>=0.0;k=k-0.01) {
256                         pos = polar.getXY(z*rangeScaleFactor*(iRunCount+iRunValue), 0.1*radialImageBlock[i].StartAngle+k);
257                         p.addPoint(pos.x, pos.y);
258                     }
259 
260                     if( p.npoints >= 3 ) {
261 //                      p.addPoint(p.xpoints[0], p.ypoints[0]);
262                         g.fillPolygon(p);//仅填充多边形内部
263                         g.drawPolygon(p);//画多边形边框
264                     }
265                 }
266                 iRunCount   += iRunValue > 0 ? iRunValue : 0;
267             }
268         }
269         return(true);
270     }
271 
272 }

 

---

RadialImageBlock.java

---

001 /**
002  * PACKAGE     : cma.gmb.doppler.datatype
003    FILENAME    : RadialImageBlock.java
004  * DESCRIPTION : 多普勒雷达产品数据结构(Radial格式)
005  * AUTHOR      : 刘泽军
006  * EMAIL       : BJ0773@gmail.com
007  * Date        : 2007-06-02 03:47:35
008  * Update      : 2007-06-12
009  * Reference   : 《NEXRAD LEVEL II数据格式》中文版及英文版
010  */
011 
012 package cma.gmb.doppler.datatype;
013 
014 import java.io.*;
015 import java.lang.*;
016 
017 import cma.common.dataio.*;
018 
019 public class RadialImageBlock {//极坐标扫描图像数据
020 
021     public  static  int SIZE    = 6;
022 
023     public  short   NumberOfRadialRLE;
024     public  short   StartAngle;
025     public  short   DeltaAngle;
026     public  byte[]  Data;
027 
028 /**
029  * 功能：构造函数
030  * 参数：
031  *      无
032  * 返回：
033  *      无
034  */
035     public RadialImageBlock() {
036     }
037 
038 /**
039  * 功能：从随机文件中读取数据，并进行BigEndian转换
040  * 参数：
041  *      raf     - 随机访问的文件对象
042  * 返回：
043  *      是否成功
044  */
045     public boolean read(RandomAccessFile raf) {
046         try {
047             byte[]  buf = new byte[RadialImageBlock.SIZE];
048             int     len = raf.read(buf);
049             boolean ok  = len == RadialImageBlock.SIZE ? parse(buf, 0) : false;
050             if( ok && NumberOfRadialRLE > 0 ) {
051                 Data    = new byte[NumberOfRadialRLE*2];
052                 len     = raf.read(Data);
053             }
054             return(ok && len == NumberOfRadialRLE*2);
055         }
056         catch(Exception ex) {
057             return(false);
058         }
059     }
060 
061 /**
062  * 功能：从输入流文件中读取数据，并进行BigEndian转换
063  * 参数：
064  *      in      - InputStream对象
065  * 返回：
066  *      是否成功
067  */
068     public boolean read(InputStream in) {
069         try {
070             byte[]  buf = new byte[RadialImageBlock.SIZE];
071             int     len = in.read(buf);
072             boolean ok  = len == RadialImageBlock.SIZE ? parse(buf, 0) : false;
073             if( ok && NumberOfRadialRLE > 0 ) {
074                 Data    = new byte[NumberOfRadialRLE*2];
075                 len     = in.read(Data);
076             }
077             return(ok && len == NumberOfRadialRLE*2);
078         }
079         catch(Exception ex) {
080             return(false);
081         }
082     }
083 
084 /**
085  * 功能：从缓冲区中读数据
086  *       (在外部方法中，一次性读入所有数据，然后逐类分析数据)
087  * 参数：
088  *      buf     - 缓冲数据
089  *      index   - 偏移
090  * 返回：
091  *      正确读出的数据字节数
092  */
093     public int read(byte[] buf, int index) {
094         boolean ok  = parse(buf, index);
095         if( ok && NumberOfRadialRLE > 0 && buf.length >= index+NumberOfRadialRLE*2 ) {
096             Data    = new byte[NumberOfRadialRLE*2];
097             for(int i=0;i<NumberOfRadialRLE*2;i++) {
098                 Data[i] = buf[index+i];
099             }
100             return(RadialImageBlock.SIZE+NumberOfRadialRLE*2);
101         }
102         return(0);
103     }
104 
105 /**
106  * 功能：从缓冲区中分析出数据
107  * 参数：
108  *      buf     - 缓冲数据
109  * 返回：
110  *      是否成功
111  */
112     public boolean parse(byte[] buf) {
113         return(parse(buf, 0));
114     }
115 
116 /**
117  * 功能：从缓冲区中分析出数据
118  * 参数：
119  *      buf     - 缓冲数据
120  *      index   - 偏移
121  * 返回：
122  *      是否成功
123  */
124     public boolean parse(byte[] buf, int index) {
125         NumberOfRadialRLE   = DataConverterBE.getShort(buf, index+ 0);
126         StartAngle          = DataConverterBE.getShort(buf, index+ 2);
127         DeltaAngle          = DataConverterBE.getShort(buf, index+ 4);
128         return(true);
129     }
130 
131 /**
132  * 功能：获得数据信息
133  * 参数：
134  *      无
135  * 返回：
136  *      数据信息
137  */
138     public String info() {
139         String  msg =
140             "/nRadialImageBlock.SIZE = " + String.valueOf(RadialImageBlock.SIZE) +
141             "/n    NumberOfRadialRLE = " + String.valueOf(NumberOfRadialRLE) +
142             "/n    StartAngle        = " + String.valueOf(StartAngle) +
143             "/n    DeltaAngle        = " + String.valueOf(DeltaAngle) +
144             "/n";
145 /*      for(int i=0;i<NumberOfRadialRLE*2;i++) {
146             msg = msg + String.valueOf((new Byte(Data[i])).intValue()/16)+","+String.valueOf((new Byte(Data[i])).intValue()%16)+" ";
147         }
148         msg = msg + "/n";
149 */
150         return(msg);
151     }
152 /**
153  * 功能：打印数据，主要用于测试
154  * 参数：
155  *      无
156  * 返回：
157  *      无
158  */
159     public void print() {
160         System.out.println(info());
161     }
162 
163 }

 

---

RadialProductBlock.java

---

001 /**
002  * PACKAGE     : cma.gmb.doppler.datatype
003    FILENAME    : RadialProductBlock.java
004  * DESCRIPTION : 多普勒雷达产品数据结构(Radial格式)
005  * AUTHOR      : 刘泽军
006  * EMAIL       : BJ0773@gmail.com
007  * Date        : 2007-06-07 11:01:44
008  * Update      :
009  * Reference   : 《NEXRAD LEVEL II数据格式》中文版及英文版
010  */
011 
012 package cma.gmb.doppler.datatype;
013 
014 import java.io.*;
015 import java.lang.*;
016 
017 import cma.common.dataio.*;
018 
019 public class RadialProductBlock {//层数据包
020 
021     public  static  int SIZE    = 12;
022 
023     public  short   IndexOfFirstRangeBin;
024     public  short   NumberOfRangeBins;
025     public  short   CenterOfSweepI;
026     public  short   CenterOfSweepJ;
027     public  short   RangeScaleFactor;
028     public  short   NumberOfRadials;
029 
030 /**
031  * 功能：构造函数
032  * 参数：
033  *      无
034  * 返回：
035  *      无
036  */
037     public RadialProductBlock() {
038     }
039 
040 /**
041  * 功能：从文件中读取数据，并进行BigEndian转换
042  * 参数：
043  *      raf     - 随机访问的文件对象
044  * 返回：
045  *      是否成功
046  */
047     public boolean read(RandomAccessFile raf) {
048         try {
049             byte[]  buf = new byte[RadialProductBlock.SIZE];
050             int     len = raf.read(buf);
051             return(len == RadialProductBlock.SIZE ? parse(buf, 0) : false);
052         }
053         catch(Exception ex) {
054             return(false);
055         }
056     }
057 
058 /**
059  * 功能：从输入流文件中读取数据，并进行BigEndian转换
060  * 参数：
061  *      in      - InputStream对象
062  * 返回：
063  *      是否成功
064  */
065     public boolean read(InputStream in) {
066         try {
067             byte[]  buf = new byte[RadialProductBlock.SIZE];
068             int     len = in.read(buf);
069             return(len == RadialProductBlock.SIZE ? parse(buf, 0) : false);
070         }
071         catch(Exception ex) {
072             return(false);
073         }
074     }
075 
076 /**
077  * 功能：从缓冲区中读数据
078  *       (在外部方法中，一次性读入所有数据，然后逐类分析数据)
079  * 参数：
080  *      buf     - 缓冲数据
081  *      index   - 偏移
082  * 返回：
083  *      正确读出的数据字节数
084  */
085     public int read(byte[] buf, int index) {
086         return(parse(buf, index)?RadialProductBlock.SIZE:0);
087     }
088 
089 /**
090  * 功能：从缓冲区中分析出数据
091  * 参数：
092  *      buf     - 缓冲数据
093  * 返回：
094  *      是否成功
095  */
096     public boolean parse(byte[] buf) {
097         return(parse(buf, 0));
098     }
099 
100 /**
101  * 功能：从缓冲区中分析出数据
102  * 参数：
103  *      buf     - 缓冲数据
104  *      index   - 偏移
105  * 返回：
106  *      是否成功
107  */
108     public boolean parse(byte[] buf, int index) {
109         IndexOfFirstRangeBin    = DataConverterBE.getShort(buf, index+ 0);
110         NumberOfRangeBins       = DataConverterBE.getShort(buf, index+ 2);
111         CenterOfSweepI          = DataConverterBE.getShort(buf, index+ 4);
112         CenterOfSweepJ          = DataConverterBE.getShort(buf, index+ 6);
113         RangeScaleFactor        = DataConverterBE.getShort(buf, index+ 8);
114         NumberOfRadials         = DataConverterBE.getShort(buf, index+10);
115         return(true);
116     }
117 
118 /**
119  * 功能：获得数据信息
120  * 参数：
121  *      无
122  * 返回：
123  *      数据信息
124  */
125     public String info() {
126         String  msg =
127             "/nRadialProductBlock.SIZE  = " + String.valueOf(RadialProductBlock.SIZE) +
128             "/n    IndexOfFirstRangeBin = " + String.valueOf(IndexOfFirstRangeBin) +
129             "/n    NumberOfRangeBins    = " + String.valueOf(NumberOfRangeBins) +
130             "/n    CenterOfSweepI       = " + String.valueOf(CenterOfSweepI) +
131             "/n    CenterOfSweepJ       = " + String.valueOf(CenterOfSweepJ) +
132             "/n    RangeScaleFactor     = " + String.valueOf(RangeScaleFactor) +
133             "/n    NumberOfRadials      = " + String.valueOf(NumberOfRadials) +
134             "/n";
135         return(msg);
136     }
137 
138 /**
139  * 功能：打印数据，主要用于测试
140  * 参数：
141  *      无
142  * 返回：
143  *      无
144  */
145     public void print() {
146         System.out.println(info());
147     }
148 
149 }