source: subversion/applications/editors/osm-editor/qt3/SRTMConGen.cpp @ 16590

Last change on this file since 16590 was 1158, checked in by nick, 14 years ago

moved current version to qt3 directory in preparation for qt4

File size: 6.0 KB
Line 
1/*
2    Copyright (C) 2005 Nick Whitelegg, Hogweed Software, nick@hogweed.org
3
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU Lesser General Public License as published by
6    the Free Software Foundation; either version 2 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public License
15    along with this program; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA
17
18 */
19#include "SRTMConGen.h"
20#include "Map.h"
21#include "llgr.h"
22#include <cmath>
23
24namespace OpenStreetMap
25{
26
27SRTMConGen::SRTMConGen(Map& map, int f)
28{
29        int w, h;
30
31        // Get the bounding rectangles for all lat/long squares
32        LATLON_TILE **tiles = get_latlon_tiles (map,&w,&h);
33
34        // Get the sampled heights from the .hgt file, and the screen coordinates
35        sampledata = new SRTMDataGrid(tiles,w,h,map,f);
36
37        for(int hcount=0; hcount<h; hcount++)
38                delete[] tiles[hcount];
39        delete[] tiles;
40}
41
42// Given the latitide and longitude of the bottom left and top right of the
43// visible area, this function returns an array of rectangles definining the
44// SRTM point indices for all latitude/longitude squares in the visible area.
45// This will normally be just one, but if, e.g., 51N and 1W both crossed the
46// visible area, it could be up to 4.
47LATLON_TILE ** SRTMConGen::get_latlon_tiles(Map& map,int *w,int *h)
48{
49
50        EarthPoint bottomleft= (map.isGridRef()) ? gr_to_ll(map.getBottomLeft()) :
51                        map.getBottomLeft(),
52                   topright= (map.isGridRef()) ? gr_to_ll(map.getTopRight()):
53                                   map.getTopRight();
54
55
56
57        // Get the latitude/longitude square of each rectangle
58        LATLON_TILE **rect=getrects(bottomleft,topright,w,h);
59        EarthPoint llsq;
60
61        // Fill in the actual bounds
62        for(int hcount=0; hcount<*h; hcount++)
63        {
64                for(int wcount=0; wcount<*w; wcount++)
65                {
66                        llsq = rect[hcount][wcount].origin;
67                        rect[hcount][wcount].left =  bottomleft.x> llsq.?
68                                        floor((bottomleft.x - llsq.x)*1200): 0;
69                        rect[hcount][wcount].right = (topright.x < llsq.x+1) ?
70                                        1+floor((topright.x - llsq.x)*1200) : 
71                                                        1200;
72       
73                        rect[hcount][wcount].top =(topright.y < llsq.y+1 ) ?
74                                        floor(((llsq.y+1)-topright.y)*1200) :  0;
75                        rect[hcount][wcount].bottom = bottomleft.y > llsq.?
76                                        1+floor(((llsq.y+1)-bottomleft.y)*1200) :
77                                                1200;
78                }
79        }
80
81        return rect;
82}
83
84// Given the latitude and longitude of the bottom left and top right of the
85// visible map area, this function returns the appropriate number of
86// rectangles specific to a given grid square. For example, if both 51N and 1W
87// passed through the visible area, four rectangles would be generated, one
88// for the 51N/1W square, one for the 50N/1W square etc. Only the base latitude
89// and longitude are filled in at this stage. The dimensions of each rectangle
90// within the visible area are filled in by the calling function.
91LATLON_TILE** SRTMConGen::getrects
92        (const EarthPoint& bottomleft,const EarthPoint& topright, int *w,int *h)
93{
94        LATLON_TILE** rects;
95        *h=0;
96        rects=new LATLON_TILE* [int(floor(topright.y)-floor(bottomleft.y))+1];
97
98        for(int lat=floor(topright.y); lat>=floor(bottomleft.y); lat--)
99        {
100                *w=0;
101                rects[*h]=new LATLON_TILE
102                                [int(floor(topright.x)-floor(bottomleft.x))+1];
103                for(int lon=floor(bottomleft.x); lon<=floor(topright.x); lon++)
104                {
105                        rects[*h][*w].origin.y=lat;
106                        rects[*h][*w].origin.x=lon;
107                        (*w)++;
108                }
109                (*h)++;
110        }
111        return rects;
112}
113
114
115void SRTMConGen::generate(DrawSurface *ds)
116{
117        std::map<int,vector<int> > last_pt;
118
119        for(int row=0; row<sampledata->getHeight()-1; row++)
120        {
121                // Do each point of the current row
122                for(int col=0; col<sampledata->getWidth()-1; col++)
123                {
124                        do_contours(ds,row,col,50, last_pt);
125                }
126        }
127}
128
129void SRTMConGen::do_contours (DrawSurface *ds,int row,int col, 
130                                int interval, std::map<int,vector<int> >&last_pt )
131{
132        sampledata->setPoint (row,col);
133        int start_ht = sampledata->startHeight(interval),
134                end_ht = sampledata->endHeight(interval);
135                       
136
137        LINE lines[2];
138        int n_line_pts;
139        char htstr[1024];
140
141        Colour colour, contour_colour(192,192,0), mint(0,192,64);
142
143        for(int ht=start_ht; ht<=end_ht; ht+=interval)
144        {
145                n_line_pts=0;
146                sampledata->getLine(lines,&n_line_pts,ht);
147
148
149                // draw line
150                if(n_line_pts!=0)
151                {
152                        for(int count=0; count<n_line_pts; count++)
153                        {
154                                colour = (ht%(interval*5)) ?  contour_colour : mint;
155                                if( (last_pt[ht].size()==0) || 
156                                                (sampledata->hgtptDistance(last_pt[ht])>20)) 
157                                {
158                                        // 08/02/05 changed parameters for slope_angle()
159                                        // 12/02/05 put all the text drawing code in angle_text()
160                                        double angle=slope_angle(lines[count].p[0].x, 
161                                                                        lines[count].p[0].y,
162                                                                        lines[count].p[1].x,
163                                                                        lines[count].p[1].y);
164                                        int i = (lines[count].p[1].x > lines[count].p[0].x) ? 0:1;
165                                        sprintf(htstr,"%d",ht);
166                                        ds->drawAngleText(8, angle, 
167                                                lines[count].p[i].x, lines[count].p[i].y, colour.r,
168                                                colour.g, colour.b, htstr);
169                                        last_pt[ht].push_back(sampledata->getPoint());
170                                }
171                                       
172                                ds->drawContour(lines[count].p[0].x,
173                                                lines[count].p[0].y,
174                                                lines[count].p[1].x,
175                                                lines[count].p[1].y, 
176                                                colour.r, colour.g, colour.b); 
177                        }       
178                }
179        }
180}
181
182void SRTMConGen::generateShading(DrawSurface *ds,double shadingres)
183{
184        Colour colour;
185        for(int row=0; row<sampledata->getHeight()-1; row++)
186        {
187                // Do each point of the current row
188                for(int col=0; col<sampledata->getWidth()-1; col++)
189                {
190                        sampledata->setPoint(row,col); 
191                        colour = sampledata->getHeightShading(shadingres);
192                        ds->heightShading(sampledata->getTopLeft().x,
193                                                          sampledata->getTopLeft().y,
194                                                          sampledata->getTopRight().x,
195                                                          sampledata->getTopRight().y,
196                                                          sampledata->getBottomRight().x,
197                                                          sampledata->getBottomRight().y,
198                                                          sampledata->getBottomLeft().x,
199                                                          sampledata->getBottomLeft().y, 
200                                                          colour.r,colour.g,colour.b);
201                }
202        }
203}
204
205}
Note: See TracBrowser for help on using the repository browser.