1 : /******************************************************************************
2 : * $Id: dataset.cpp 23192 2011-10-06 20:31:54Z rouault $
3 : *
4 : * Project: WMS Client Driver
5 : * Purpose: Implementation of Dataset and RasterBand classes for WMS
6 : * and other similar services.
7 : * Author: Adam Nowacki, nowak@xpam.de
8 : *
9 : ******************************************************************************
10 : * Copyright (c) 2007, Adam Nowacki
11 : *
12 : * Permission is hereby granted, free of charge, to any person obtaining a
13 : * copy of this software and associated documentation files (the "Software"),
14 : * to deal in the Software without restriction, including without limitation
15 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
16 : * and/or sell copies of the Software, and to permit persons to whom the
17 : * Software is furnished to do so, subject to the following conditions:
18 : *
19 : * The above copyright notice and this permission notice shall be included
20 : * in all copies or substantial portions of the Software.
21 : *
22 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 : * DEALINGS IN THE SOFTWARE.
29 : ****************************************************************************
30 : *
31 : * dataset.cpp:
32 : * Initialization of the GDALWMSdriver, parsing the XML configuration file,
33 : * instantiation of the minidrivers and accessors used by minidrivers
34 : *
35 : ***************************************************************************/
36 :
37 :
38 : #include "stdinc.h"
39 :
40 9 : GDALWMSDataset::GDALWMSDataset() {
41 9 : m_mini_driver = 0;
42 9 : m_cache = 0;
43 9 : m_hint.m_valid = false;
44 9 : m_data_type = GDT_Byte;
45 9 : m_clamp_requests = true;
46 9 : m_unsafeSsl = false;
47 9 : m_data_window.m_sx = -1;
48 9 : nBands = 0;
49 9 : m_default_block_size_x = 1024;
50 9 : m_default_block_size_y = 1024;
51 9 : m_bNeedsDataWindow = TRUE;
52 9 : m_default_tile_count_x = 1;
53 9 : m_default_tile_count_y = 1;
54 9 : m_default_overview_count = -1;
55 9 : m_zeroblock_on_serverexceptions = 0;
56 9 : }
57 :
58 9 : GDALWMSDataset::~GDALWMSDataset() {
59 9 : if (m_mini_driver) delete m_mini_driver;
60 9 : if (m_cache) delete m_cache;
61 9 : }
62 :
63 9 : CPLErr GDALWMSDataset::Initialize(CPLXMLNode *config) {
64 9 : CPLErr ret = CE_None;
65 :
66 9 : char* pszXML = CPLSerializeXMLTree( config );
67 9 : if (pszXML)
68 : {
69 9 : m_osXML = pszXML;
70 9 : CPLFree(pszXML);
71 : }
72 :
73 : // Initialize the minidriver, which can set parameters for the dataset using member functions
74 9 : CPLXMLNode *service_node = CPLGetXMLNode(config, "Service");
75 9 : if (service_node != NULL) {
76 9 : const CPLString service_name = CPLGetXMLValue(service_node, "name", "");
77 9 : if (!service_name.empty()) {
78 9 : GDALWMSMiniDriverManager *const mdm = GetGDALWMSMiniDriverManager();
79 9 : GDALWMSMiniDriverFactory *const mdf = mdm->Find(service_name);
80 9 : if (mdf != NULL) {
81 9 : m_mini_driver = mdf->New();
82 9 : m_mini_driver->m_parent_dataset = this;
83 9 : if (m_mini_driver->Initialize(service_node) == CE_None) {
84 9 : m_mini_driver_caps.m_capabilities_version = -1;
85 9 : m_mini_driver->GetCapabilities(&m_mini_driver_caps);
86 9 : if (m_mini_driver_caps.m_capabilities_version == -1) {
87 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Internal error, mini-driver capabilities version not set.");
88 0 : ret = CE_Failure;
89 : }
90 : } else {
91 0 : delete m_mini_driver;
92 0 : m_mini_driver = NULL;
93 :
94 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize minidriver.");
95 0 : ret = CE_Failure;
96 : }
97 : } else {
98 : CPLError(CE_Failure, CPLE_AppDefined,
99 0 : "GDALWMS: No mini-driver registered for '%s'.", service_name.c_str());
100 0 : ret = CE_Failure;
101 : }
102 : } else {
103 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
104 0 : ret = CE_Failure;
105 9 : }
106 : } else {
107 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
108 0 : ret = CE_Failure;
109 : }
110 :
111 :
112 : /*
113 : Parameters that could be set by minidriver already, based on server side information.
114 : If the size is set, minidriver has done this already
115 : A "server" side minidriver needs to set at least:
116 : - Blocksize (x and y)
117 : - Clamp flag (defaults to true)
118 : - DataWindow
119 : - Band Count
120 : - Data Type
121 : It should also initialize and register the bands and overviews.
122 : */
123 :
124 9 : if (m_data_window.m_sx<1) {
125 :
126 7 : if (ret == CE_None) {
127 7 : m_block_size_x = atoi(CPLGetXMLValue(config, "BlockSizeX", CPLString().Printf("%d", m_default_block_size_x)));
128 14 : m_block_size_y = atoi(CPLGetXMLValue(config, "BlockSizeY", CPLString().Printf("%d", m_default_block_size_y)));
129 14 : if (m_block_size_x <= 0 || m_block_size_y <= 0) {
130 0 : CPLError( CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value in BlockSizeX or BlockSizeY" );
131 0 : ret = CE_Failure;
132 : }
133 : }
134 :
135 7 : if (ret == CE_None) {
136 7 : m_clamp_requests = StrToBool(CPLGetXMLValue(config, "ClampRequests", "true"));
137 7 : if (m_clamp_requests<0) {
138 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ClampRequests, true/false expected.");
139 0 : ret = CE_Failure;
140 : }
141 : }
142 :
143 7 : if (ret == CE_None) {
144 7 : CPLXMLNode *data_window_node = CPLGetXMLNode(config, "DataWindow");
145 7 : if (data_window_node == NULL && m_bNeedsDataWindow) {
146 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow missing.");
147 0 : ret = CE_Failure;
148 : } else {
149 7 : CPLString osDefaultX0, osDefaultX1, osDefaultY0, osDefaultY1;
150 7 : CPLString osDefaultTileCountX, osDefaultTileCountY, osDefaultTileLevel;
151 7 : CPLString osDefaultOverviewCount;
152 7 : osDefaultX0.Printf("%.8f", m_default_data_window.m_x0);
153 7 : osDefaultX1.Printf("%.8f", m_default_data_window.m_x1);
154 7 : osDefaultY0.Printf("%.8f", m_default_data_window.m_y0);
155 7 : osDefaultY1.Printf("%.8f", m_default_data_window.m_y1);
156 7 : osDefaultTileCountX.Printf("%d", m_default_tile_count_x);
157 7 : osDefaultTileCountY.Printf("%d", m_default_tile_count_y);
158 7 : if (m_default_data_window.m_tlevel >= 0)
159 1 : osDefaultTileLevel.Printf("%d", m_default_data_window.m_tlevel);
160 7 : if (m_default_overview_count >= 0)
161 1 : osDefaultOverviewCount.Printf("%d", m_default_overview_count);
162 7 : const char *overview_count = CPLGetXMLValue(config, "OverviewCount", osDefaultOverviewCount);
163 7 : const char *ulx = CPLGetXMLValue(data_window_node, "UpperLeftX", osDefaultX0);
164 7 : const char *uly = CPLGetXMLValue(data_window_node, "UpperLeftY", osDefaultY0);
165 7 : const char *lrx = CPLGetXMLValue(data_window_node, "LowerRightX", osDefaultX1);
166 7 : const char *lry = CPLGetXMLValue(data_window_node, "LowerRightY", osDefaultY1);
167 7 : const char *sx = CPLGetXMLValue(data_window_node, "SizeX", "");
168 7 : const char *sy = CPLGetXMLValue(data_window_node, "SizeY", "");
169 7 : const char *tx = CPLGetXMLValue(data_window_node, "TileX", "0");
170 7 : const char *ty = CPLGetXMLValue(data_window_node, "TileY", "0");
171 7 : const char *tlevel = CPLGetXMLValue(data_window_node, "TileLevel", osDefaultTileLevel);
172 7 : const char *str_tile_count_x = CPLGetXMLValue(data_window_node, "TileCountX", osDefaultTileCountX);
173 7 : const char *str_tile_count_y = CPLGetXMLValue(data_window_node, "TileCountY", osDefaultTileCountY);
174 7 : const char *y_origin = CPLGetXMLValue(data_window_node, "YOrigin", "default");
175 :
176 7 : if (ret == CE_None) {
177 14 : if ((ulx[0] != '\0') && (uly[0] != '\0') && (lrx[0] != '\0') && (lry[0] != '\0')) {
178 7 : m_data_window.m_x0 = atof(ulx);
179 7 : m_data_window.m_y0 = atof(uly);
180 7 : m_data_window.m_x1 = atof(lrx);
181 7 : m_data_window.m_y1 = atof(lry);
182 : } else {
183 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: UpperLeftX, UpperLeftY, LowerRightX, LowerRightY.");
184 0 : ret = CE_Failure;
185 : }
186 : }
187 :
188 7 : m_data_window.m_tlevel = atoi(tlevel);
189 :
190 7 : if (ret == CE_None) {
191 11 : if ((sx[0] != '\0') && (sy[0] != '\0')) {
192 4 : m_data_window.m_sx = atoi(sx);
193 4 : m_data_window.m_sy = atoi(sy);
194 6 : } else if ((tlevel[0] != '\0') && (str_tile_count_x[0] != '\0') && (str_tile_count_y[0] != '\0')) {
195 3 : int tile_count_x = atoi(str_tile_count_x);
196 3 : int tile_count_y = atoi(str_tile_count_y);
197 3 : m_data_window.m_sx = tile_count_x * m_block_size_x * (1 << m_data_window.m_tlevel);
198 3 : m_data_window.m_sy = tile_count_y * m_block_size_y * (1 << m_data_window.m_tlevel);
199 : } else {
200 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: SizeX, SizeY.");
201 0 : ret = CE_Failure;
202 : }
203 : }
204 7 : if (ret == CE_None) {
205 14 : if ((tx[0] != '\0') && (ty[0] != '\0')) {
206 7 : m_data_window.m_tx = atoi(tx);
207 7 : m_data_window.m_ty = atoi(ty);
208 : } else {
209 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: TileX, TileY.");
210 0 : ret = CE_Failure;
211 : }
212 : }
213 7 : if (ret == CE_None) {
214 7 : if (overview_count[0] != '\0') {
215 4 : m_overview_count = atoi(overview_count);
216 3 : } else if (tlevel[0] != '\0') {
217 2 : m_overview_count = m_data_window.m_tlevel;
218 : } else {
219 1 : const int min_overview_size = MAX(32, MIN(m_block_size_x, m_block_size_y));
220 : double a = log(static_cast<double>(MIN(m_data_window.m_sx, m_data_window.m_sy))) / log(2.0)
221 1 : - log(static_cast<double>(min_overview_size)) / log(2.0);
222 1 : m_overview_count = MAX(0, MIN(static_cast<int>(ceil(a)), 32));
223 : }
224 : }
225 7 : if (ret == CE_None) {
226 7 : CPLString y_origin_str = y_origin;
227 7 : if (y_origin_str == "top") {
228 2 : m_data_window.m_y_origin = GDALWMSDataWindow::TOP;
229 5 : } else if (y_origin_str == "bottom") {
230 0 : m_data_window.m_y_origin = GDALWMSDataWindow::BOTTOM;
231 5 : } else if (y_origin_str == "default") {
232 5 : m_data_window.m_y_origin = GDALWMSDataWindow::DEFAULT;
233 : } else {
234 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow YOrigin must be set to "
235 0 : "one of 'default', 'top', or 'bottom', not '%s'.", y_origin_str.c_str());
236 0 : ret = CE_Failure;
237 7 : }
238 7 : }
239 : }
240 : }
241 :
242 7 : if (ret == CE_None) {
243 7 : if (nBands<1)
244 7 : nBands=atoi(CPLGetXMLValue(config,"BandsCount","3"));
245 7 : if (nBands<1) {
246 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad number of bands.");
247 0 : ret = CE_Failure;
248 : }
249 : }
250 :
251 7 : if (ret == CE_None)
252 : {
253 7 : const char *data_type = CPLGetXMLValue(config, "DataType", "Byte");
254 7 : m_data_type = GDALGetDataTypeByName( data_type );
255 7 : if ( m_data_type == GDT_Unknown || m_data_type >= GDT_TypeCount )
256 : {
257 : CPLError( CE_Failure, CPLE_AppDefined,
258 0 : "GDALWMS: Invalid value in DataType. Data type \"%s\" is not supported.", data_type );
259 0 : ret = CE_Failure;
260 : }
261 : }
262 :
263 : // Initialize the bands and the overviews. Assumes overviews are powers of two
264 7 : if (ret == CE_None) {
265 7 : nRasterXSize = m_data_window.m_sx;
266 7 : nRasterYSize = m_data_window.m_sy;
267 :
268 7 : if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize) ||
269 : !GDALCheckBandCount(nBands, TRUE))
270 : {
271 0 : return CE_Failure;
272 : }
273 :
274 : GDALColorInterp default_color_interp[4][4] = {
275 : { GCI_GrayIndex, GCI_Undefined, GCI_Undefined, GCI_Undefined },
276 : { GCI_GrayIndex, GCI_AlphaBand, GCI_Undefined, GCI_Undefined },
277 : { GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_Undefined },
278 : { GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_AlphaBand }
279 7 : };
280 28 : for (int i = 0; i < nBands; ++i) {
281 21 : GDALColorInterp color_interp = (nBands <= 4 && i <= 3 ? default_color_interp[nBands - 1][i] : GCI_Undefined);
282 21 : GDALWMSRasterBand *band = new GDALWMSRasterBand(this, i, 1.0);
283 21 : band->m_color_interp = color_interp;
284 21 : SetBand(i + 1, band);
285 21 : double scale = 0.5;
286 390 : for (int j = 0; j < m_overview_count; ++j) {
287 369 : band->AddOverview(scale);
288 369 : band->m_color_interp = color_interp;
289 369 : scale *= 0.5;
290 : }
291 : }
292 : }
293 : }
294 :
295 9 : const char *pszUserAgent = CPLGetXMLValue(config, "UserAgent", "");
296 9 : if (pszUserAgent[0] != '\0')
297 0 : m_osUserAgent = pszUserAgent;
298 :
299 9 : const char *pszReferer = CPLGetXMLValue(config, "Referer", "");
300 9 : if (pszReferer[0] != '\0')
301 0 : m_osReferer = pszReferer;
302 :
303 9 : if (ret == CE_None) {
304 9 : const char *pszHttpZeroBlockCodes = CPLGetXMLValue(config, "ZeroBlockHttpCodes", "");
305 9 : if(pszHttpZeroBlockCodes == '\0') {
306 0 : m_http_zeroblock_codes.push_back(204);
307 : } else {
308 9 : char **kv = CSLTokenizeString2(pszHttpZeroBlockCodes,",",CSLT_HONOURSTRINGS);
309 9 : int nCount = CSLCount(kv);
310 9 : for(int i=0; i<nCount; i++) {
311 0 : int code = atoi(kv[i]);
312 0 : if(code <= 0) {
313 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockHttpCodes \"%s\", comma separated HTTP response codes expected.",
314 0 : kv[i]);
315 0 : ret = CE_Failure;
316 0 : break;
317 : }
318 0 : m_http_zeroblock_codes.push_back(code);
319 : }
320 9 : CSLDestroy(kv);
321 : }
322 : }
323 :
324 :
325 9 : if (ret == CE_None) {
326 9 : const char *pszZeroExceptions = CPLGetXMLValue(config, "ZeroBlockOnServerException", "");
327 9 : if(pszZeroExceptions[0] != '\0') {
328 0 : m_zeroblock_on_serverexceptions = StrToBool(pszZeroExceptions);
329 0 : if (m_zeroblock_on_serverexceptions == -1) {
330 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockOnServerException \"%s\", true/false expected.",
331 0 : pszZeroExceptions);
332 0 : ret = CE_Failure;
333 : }
334 : }
335 : }
336 :
337 9 : if (ret == CE_None) {
338 9 : const char *max_conn = CPLGetXMLValue(config, "MaxConnections", "");
339 9 : if (max_conn[0] != '\0') {
340 0 : m_http_max_conn = atoi(max_conn);
341 : } else {
342 9 : m_http_max_conn = 2;
343 : }
344 : }
345 9 : if (ret == CE_None) {
346 9 : const char *timeout = CPLGetXMLValue(config, "Timeout", "");
347 9 : if (timeout[0] != '\0') {
348 0 : m_http_timeout = atoi(timeout);
349 : } else {
350 9 : m_http_timeout = 300;
351 : }
352 : }
353 9 : if (ret == CE_None) {
354 9 : const char *offline_mode = CPLGetXMLValue(config, "OfflineMode", "");
355 9 : if (offline_mode[0] != '\0') {
356 0 : const int offline_mode_bool = StrToBool(offline_mode);
357 0 : if (offline_mode_bool == -1) {
358 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of OfflineMode, true / false expected.");
359 0 : ret = CE_Failure;
360 : } else {
361 0 : m_offline_mode = offline_mode_bool;
362 : }
363 : } else {
364 9 : m_offline_mode = 0;
365 : }
366 : }
367 :
368 9 : if (ret == CE_None) {
369 9 : const char *advise_read = CPLGetXMLValue(config, "AdviseRead", "");
370 9 : if (advise_read[0] != '\0') {
371 0 : const int advise_read_bool = StrToBool(advise_read);
372 0 : if (advise_read_bool == -1) {
373 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of AdviseRead, true / false expected.");
374 0 : ret = CE_Failure;
375 : } else {
376 0 : m_use_advise_read = advise_read_bool;
377 : }
378 : } else {
379 9 : m_use_advise_read = 0;
380 : }
381 : }
382 :
383 9 : if (ret == CE_None) {
384 9 : const char *verify_advise_read = CPLGetXMLValue(config, "VerifyAdviseRead", "");
385 9 : if (m_use_advise_read) {
386 0 : if (verify_advise_read[0] != '\0') {
387 0 : const int verify_advise_read_bool = StrToBool(verify_advise_read);
388 0 : if (verify_advise_read_bool == -1) {
389 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of VerifyAdviseRead, true / false expected.");
390 0 : ret = CE_Failure;
391 : } else {
392 0 : m_verify_advise_read = verify_advise_read_bool;
393 : }
394 : } else {
395 0 : m_verify_advise_read = 1;
396 : }
397 : }
398 : }
399 :
400 : // Let the local configuration override the minidriver supplied projection
401 :
402 9 : if (ret == CE_None) {
403 9 : const char *proj = CPLGetXMLValue(config, "Projection", "");
404 9 : if (proj[0] != '\0') {
405 4 : m_projection = ProjToWKT(proj);
406 4 : if (m_projection.size() == 0) {
407 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad projection specified.");
408 0 : ret = CE_Failure;
409 : }
410 : }
411 : }
412 :
413 9 : if (ret == CE_None) {
414 9 : CPLXMLNode *cache_node = CPLGetXMLNode(config, "Cache");
415 9 : if (cache_node != NULL) {
416 2 : m_cache = new GDALWMSCache();
417 2 : if (m_cache->Initialize(cache_node) != CE_None) {
418 0 : delete m_cache;
419 0 : m_cache = NULL;
420 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize cache.");
421 0 : ret = CE_Failure;
422 : }
423 : }
424 : }
425 :
426 9 : if (ret == CE_None) {
427 9 : const int v = StrToBool(CPLGetXMLValue(config, "UnsafeSSL", "false"));
428 9 : if (v == -1) {
429 0 : CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of UnsafeSSL: true or false expected.");
430 0 : ret = CE_Failure;
431 : } else {
432 9 : m_unsafeSsl = v;
433 : }
434 : }
435 :
436 9 : if (ret == CE_None) {
437 : /* If we dont have projection already set ask mini-driver. */
438 9 : if (!m_projection.size()) {
439 5 : const char *proj = m_mini_driver->GetProjectionInWKT();
440 5 : if (proj != NULL) {
441 5 : m_projection = proj;
442 : }
443 : }
444 : }
445 :
446 9 : return ret;
447 : }
448 :
449 1 : CPLErr GDALWMSDataset::IRasterIO(GDALRWFlag rw, int x0, int y0, int sx, int sy, void *buffer, int bsx, int bsy, GDALDataType bdt, int band_count, int *band_map, int pixel_space, int line_space, int band_space) {
450 : CPLErr ret;
451 :
452 1 : if (rw != GF_Read) return CE_Failure;
453 1 : if (buffer == NULL) return CE_Failure;
454 1 : if ((sx == 0) || (sy == 0) || (bsx == 0) || (bsy == 0) || (band_count == 0)) return CE_None;
455 :
456 1 : m_hint.m_x0 = x0;
457 1 : m_hint.m_y0 = y0;
458 1 : m_hint.m_sx = sx;
459 1 : m_hint.m_sy = sy;
460 1 : m_hint.m_overview = -1;
461 1 : m_hint.m_valid = true;
462 : // printf("[%p] GDALWMSDataset::IRasterIO(x0: %d, y0: %d, sx: %d, sy: %d, bsx: %d, bsy: %d, band_count: %d, band_map: %p)\n", this, x0, y0, sx, sy, bsx, bsy, band_count, band_map);
463 1 : ret = GDALDataset::IRasterIO(rw, x0, y0, sx, sy, buffer, bsx, bsy, bdt, band_count, band_map, pixel_space, line_space, band_space);
464 1 : m_hint.m_valid = false;
465 :
466 1 : return ret;
467 : }
468 :
469 2 : const char *GDALWMSDataset::GetProjectionRef() {
470 2 : return m_projection.c_str();
471 : }
472 :
473 0 : CPLErr GDALWMSDataset::SetProjection(const char *proj) {
474 0 : return CE_Failure;
475 : }
476 :
477 2 : CPLErr GDALWMSDataset::GetGeoTransform(double *gt) {
478 2 : gt[0] = m_data_window.m_x0;
479 2 : gt[1] = (m_data_window.m_x1 - m_data_window.m_x0) / static_cast<double>(m_data_window.m_sx);
480 2 : gt[2] = 0.0;
481 2 : gt[3] = m_data_window.m_y0;
482 2 : gt[4] = 0.0;
483 2 : gt[5] = (m_data_window.m_y1 - m_data_window.m_y0) / static_cast<double>(m_data_window.m_sy);
484 2 : return CE_None;
485 : }
486 :
487 0 : CPLErr GDALWMSDataset::SetGeoTransform(double *gt) {
488 0 : return CE_Failure;
489 : }
490 :
491 0 : const GDALWMSDataWindow *GDALWMSDataset::WMSGetDataWindow() const {
492 0 : return &m_data_window;
493 : }
494 :
495 2 : void GDALWMSDataset::WMSSetBlockSize(int x, int y) {
496 2 : m_block_size_x=x;
497 2 : m_block_size_y=y;
498 2 : }
499 :
500 2 : void GDALWMSDataset::WMSSetRasterSize(int x, int y) {
501 2 : nRasterXSize=x;
502 2 : nRasterYSize=y;
503 2 : }
504 :
505 2 : void GDALWMSDataset::WMSSetOverviewCount(int count) {
506 2 : m_overview_count=count;
507 2 : }
508 :
509 2 : void GDALWMSDataset::WMSSetBandsCount(int count) {
510 2 : nBands=count;
511 2 : }
512 :
513 2 : void GDALWMSDataset::WMSSetClamp(bool flag=true) {
514 2 : m_clamp_requests=flag;
515 2 : }
516 :
517 2 : void GDALWMSDataset::WMSSetDataType(GDALDataType type) {
518 2 : m_data_type=type;
519 2 : }
520 :
521 2 : void GDALWMSDataset::WMSSetDataWindow(GDALWMSDataWindow &window) {
522 2 : m_data_window=window;
523 2 : }
524 :
525 1 : void GDALWMSDataset::WMSSetDefaultBlockSize(int x, int y) {
526 1 : m_default_block_size_x=x;
527 1 : m_default_block_size_y=y;
528 1 : }
529 :
530 1 : void GDALWMSDataset::WMSSetDefaultDataWindowCoordinates(double x0, double y0, double x1, double y1)
531 : {
532 1 : m_default_data_window.m_x0 = x0;
533 1 : m_default_data_window.m_y0 = y0;
534 1 : m_default_data_window.m_x1 = x1;
535 1 : m_default_data_window.m_y1 = y1;
536 1 : }
537 :
538 0 : void GDALWMSDataset::WMSSetDefaultTileCount(int tilecountx, int tilecounty)
539 : {
540 0 : m_default_tile_count_x = tilecountx;
541 0 : m_default_tile_count_y = tilecounty;
542 0 : }
543 :
544 1 : void GDALWMSDataset::WMSSetDefaultTileLevel(int tlevel)
545 : {
546 1 : m_default_data_window.m_tlevel = tlevel;
547 1 : }
548 :
549 1 : void GDALWMSDataset::WMSSetDefaultOverviewCount(int overview_count)
550 : {
551 1 : m_default_overview_count = overview_count;
552 1 : }
553 :
554 1 : void GDALWMSDataset::WMSSetNeedsDataWindow(int flag)
555 : {
556 1 : m_bNeedsDataWindow = flag;
557 1 : }
558 :
559 0 : CPLErr GDALWMSDataset::AdviseRead(int x0, int y0, int sx, int sy, int bsx, int bsy, GDALDataType bdt, int band_count, int *band_map, char **options) {
560 : // printf("AdviseRead(%d, %d, %d, %d)\n", x0, y0, sx, sy);
561 0 : if (m_offline_mode || !m_use_advise_read) return CE_None;
562 0 : if (m_cache == NULL) return CE_Failure;
563 :
564 0 : GDALRasterBand *band = GetRasterBand(1);
565 0 : if (band == NULL) return CE_Failure;
566 0 : return band->AdviseRead(x0, y0, sx, sy, bsx, bsy, bdt, options);
567 : }
568 :
569 1 : const char *GDALWMSDataset::GetMetadataItem( const char * pszName,
570 : const char * pszDomain )
571 : {
572 1 : if( pszName != NULL && EQUAL(pszName, "XML") &&
573 : pszDomain != NULL && EQUAL(pszDomain, "WMS") )
574 : {
575 1 : return (m_osXML.size()) ? m_osXML.c_str() : NULL;
576 : }
577 :
578 0 : return GDALPamDataset::GetMetadataItem(pszName, pszDomain);
579 : }
|
