Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: PCRaster Integration
4 : * Purpose: PCRaster driver support functions.
5 : * Author: Kor de Jong, Oliver Schmitz
6 : *
7 : ******************************************************************************
8 : * Copyright (c) PCRaster owners
9 : *
10 : * Permission is hereby granted, free of charge, to any person obtaining a
11 : * copy of this software and associated documentation files (the "Software"),
12 : * to deal in the Software without restriction, including without limitation
13 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 : * and/or sell copies of the Software, and to permit persons to whom the
15 : * Software is furnished to do so, subject to the following conditions:
16 : *
17 : * The above copyright notice and this permission notice shall be included
18 : * in all copies or substantial portions of the Software.
19 : *
20 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 : * DEALINGS IN THE SOFTWARE.
27 : ****************************************************************************/
28 :
29 : #include <cfloat>
30 :
31 : #include <algorithm>
32 : #include <limits>
33 :
34 : #include "pcrasterutil.h"
35 : #include "pcrtypes.h"
36 :
37 : //! Converts PCRaster data type to GDAL data type.
38 : /*!
39 : \param cellRepresentation Cell representation.
40 : \return GDAL data type, GDT_Uknown if conversion is not possible.
41 : */
42 13 : GDALDataType cellRepresentation2GDALType(CSF_CR cellRepresentation)
43 : {
44 13 : GDALDataType type = GDT_Unknown;
45 :
46 13 : switch (cellRepresentation)
47 : {
48 : // CSF version 2.
49 : // ----------------------------------------------------------
50 7 : case CR_UINT1:
51 : {
52 7 : type = GDT_Byte;
53 7 : break;
54 : }
55 1 : case CR_INT4:
56 : {
57 1 : type = GDT_Int32;
58 1 : break;
59 : }
60 5 : case CR_REAL4:
61 : {
62 5 : type = GDT_Float32;
63 5 : break;
64 : }
65 0 : case CR_REAL8:
66 : {
67 0 : type = GDT_Float64;
68 0 : break;
69 : }
70 : // CSF version 1.
71 : // ----------------------------------------------------------
72 0 : case CR_INT1:
73 : {
74 0 : type = GDT_Byte;
75 0 : break;
76 : }
77 0 : case CR_INT2:
78 : {
79 0 : type = GDT_Int16;
80 0 : break;
81 : }
82 0 : case CR_UINT2:
83 : {
84 0 : type = GDT_UInt16;
85 0 : break;
86 : }
87 0 : case CR_UINT4:
88 : {
89 0 : type = GDT_UInt32;
90 0 : break;
91 : }
92 0 : default:
93 : {
94 0 : break;
95 : }
96 : }
97 :
98 13 : return type;
99 : }
100 :
101 2 : CSF_VS string2ValueScale(std::string const &string)
102 : {
103 2 : CSF_VS valueScale = VS_UNDEFINED;
104 :
105 : // CSF version 2.
106 : // ------------------------------------------------------------
107 2 : if (string == "VS_BOOLEAN")
108 : {
109 0 : valueScale = VS_BOOLEAN;
110 : }
111 2 : else if (string == "VS_NOMINAL")
112 : {
113 0 : valueScale = VS_NOMINAL;
114 : }
115 2 : else if (string == "VS_ORDINAL")
116 : {
117 0 : valueScale = VS_ORDINAL;
118 : }
119 2 : else if (string == "VS_SCALAR")
120 : {
121 1 : valueScale = VS_SCALAR;
122 : }
123 1 : else if (string == "VS_DIRECTION")
124 : {
125 0 : valueScale = VS_DIRECTION;
126 : }
127 1 : else if (string == "VS_LDD")
128 : {
129 1 : valueScale = VS_LDD;
130 : }
131 : // CSF version1.
132 : // -------------------------------------------------------------
133 0 : else if (string == "VS_CLASSIFIED")
134 : {
135 0 : valueScale = VS_CLASSIFIED;
136 : }
137 0 : else if (string == "VS_CONTINUOUS")
138 : {
139 0 : valueScale = VS_CONTINUOUS;
140 : }
141 0 : else if (string == "VS_NOTDETERMINED")
142 : {
143 0 : valueScale = VS_NOTDETERMINED;
144 : }
145 :
146 2 : return valueScale;
147 : }
148 :
149 13 : std::string valueScale2String(CSF_VS valueScale)
150 : {
151 13 : std::string result = "VS_UNDEFINED";
152 :
153 13 : switch (valueScale)
154 : {
155 : // CSF version 2.
156 : // ----------------------------------------------------------
157 1 : case VS_BOOLEAN:
158 : {
159 1 : result = "VS_BOOLEAN";
160 1 : break;
161 : }
162 1 : case VS_NOMINAL:
163 : {
164 1 : result = "VS_NOMINAL";
165 1 : break;
166 : }
167 0 : case VS_ORDINAL:
168 : {
169 0 : result = "VS_ORDINAL";
170 0 : break;
171 : }
172 5 : case VS_SCALAR:
173 : {
174 5 : result = "VS_SCALAR";
175 5 : break;
176 : }
177 0 : case VS_DIRECTION:
178 : {
179 0 : result = "VS_DIRECTION";
180 0 : break;
181 : }
182 6 : case VS_LDD:
183 : {
184 6 : result = "VS_LDD";
185 6 : break;
186 : }
187 : // CSF version 1.
188 : // ----------------------------------------------------------
189 0 : case VS_CLASSIFIED:
190 : {
191 0 : result = "VS_CLASSIFIED";
192 0 : break;
193 : }
194 0 : case VS_CONTINUOUS:
195 : {
196 0 : result = "VS_CONTINUOUS";
197 0 : break;
198 : }
199 0 : case VS_NOTDETERMINED:
200 : {
201 0 : result = "VS_NOTDETERMINED";
202 0 : break;
203 : }
204 0 : default:
205 : {
206 0 : break;
207 : }
208 : }
209 :
210 13 : return result;
211 : }
212 :
213 0 : std::string cellRepresentation2String(CSF_CR cellRepresentation)
214 : {
215 0 : std::string result = "CR_UNDEFINED";
216 :
217 0 : switch (cellRepresentation)
218 : {
219 :
220 : // CSF version 2.
221 : // ----------------------------------------------------------
222 0 : case CR_UINT1:
223 : {
224 0 : result = "CR_UINT1";
225 0 : break;
226 : }
227 0 : case CR_INT4:
228 : {
229 0 : result = "CR_INT4";
230 0 : break;
231 : }
232 0 : case CR_REAL4:
233 : {
234 0 : result = "CR_REAL4";
235 0 : break;
236 : }
237 0 : case CR_REAL8:
238 : {
239 0 : result = "CR_REAL8";
240 0 : break;
241 : }
242 : // CSF version 1.
243 : // ----------------------------------------------------------
244 0 : case CR_INT1:
245 : {
246 0 : result = "CR_INT1";
247 0 : break;
248 : }
249 0 : case CR_INT2:
250 : {
251 0 : result = "CR_INT2";
252 0 : break;
253 : }
254 0 : case CR_UINT2:
255 : {
256 0 : result = "CR_UINT2";
257 0 : break;
258 : }
259 0 : case CR_UINT4:
260 : {
261 0 : result = "CR_UINT4";
262 0 : break;
263 : }
264 0 : default:
265 : {
266 0 : break;
267 : }
268 : }
269 :
270 0 : return result;
271 : }
272 :
273 : //! Converts GDAL data type to PCRaster value scale.
274 : /*!
275 : \param type GDAL data type.
276 : \return Value scale.
277 : \warning \a type must be one of the standard numerical types and not
278 : complex.
279 :
280 : GDAL byte is regarded as PCRaster boolean, integral as nominal and float
281 : as scalar. This function will never return VS_LDD, VS_ORDINAL or
282 : VS_DIRECTION.
283 : */
284 10 : CSF_VS GDALType2ValueScale(GDALDataType type)
285 : {
286 10 : CSF_VS valueScale = VS_UNDEFINED;
287 :
288 10 : switch (type)
289 : {
290 4 : case GDT_Byte:
291 : {
292 : // A foreign dataset is unlikely to support our LDD's.
293 4 : valueScale = VS_BOOLEAN;
294 4 : break;
295 : }
296 4 : case GDT_UInt16:
297 : case GDT_UInt32:
298 : case GDT_Int16:
299 : case GDT_Int32:
300 : {
301 4 : valueScale = VS_NOMINAL;
302 4 : break;
303 : }
304 1 : case GDT_Float32:
305 : {
306 : // A foreign dataset is unlikely to support our directional.
307 1 : valueScale = VS_SCALAR;
308 1 : break;
309 : }
310 1 : case GDT_Float64:
311 : {
312 : // A foreign dataset is unlikely to support our directional.
313 1 : valueScale = VS_SCALAR;
314 1 : break;
315 : }
316 0 : default:
317 : {
318 0 : CPLAssert(false);
319 : break;
320 : }
321 : }
322 :
323 10 : return valueScale;
324 : }
325 :
326 : //! Converts a GDAL type to a PCRaster cell representation.
327 : /*!
328 : \param type GDAL type.
329 : \param exact Whether an exact match or a CSF2.0 supported cell
330 : representation should be returned.
331 : \return Cell representation.
332 : \warning \a type must be one of the standard numerical types and not
333 : complex.
334 :
335 : If exact is false, conversion to CSF2.0 types will take place. This is
336 : useful for in file cell representations. If exact is true, and exact match
337 : is made. This is useful for in app cell representations.
338 :
339 : If exact is false, this function always returns one of CR_UINT1, CR_INT4
340 : or CR_REAL4.
341 : */
342 27 : CSF_CR GDALType2CellRepresentation(GDALDataType type, bool exact)
343 : {
344 27 : CSF_CR cellRepresentation = CR_UNDEFINED;
345 :
346 27 : switch (type)
347 : {
348 10 : case GDT_Byte:
349 : {
350 10 : cellRepresentation = CR_UINT1;
351 10 : break;
352 : }
353 2 : case GDT_UInt16:
354 : {
355 2 : cellRepresentation = exact ? CR_UINT2 : CR_UINT1;
356 2 : break;
357 : }
358 2 : case GDT_UInt32:
359 : {
360 2 : cellRepresentation = exact ? CR_UINT4 : CR_UINT1;
361 2 : break;
362 : }
363 2 : case GDT_Int16:
364 : {
365 2 : cellRepresentation = exact ? CR_INT2 : CR_INT4;
366 2 : break;
367 : }
368 2 : case GDT_Int32:
369 : {
370 2 : cellRepresentation = CR_INT4;
371 2 : break;
372 : }
373 3 : case GDT_Float32:
374 : {
375 3 : cellRepresentation = CR_REAL4;
376 3 : break;
377 : }
378 2 : case GDT_Float64:
379 : {
380 2 : cellRepresentation = exact ? CR_REAL8 : CR_REAL4;
381 2 : break;
382 : }
383 4 : default:
384 : {
385 4 : break;
386 : }
387 : }
388 :
389 27 : return cellRepresentation;
390 : }
391 :
392 : //! Determines a missing value to use for data of \a cellRepresentation.
393 : /*!
394 : \param cellRepresentation Cell representation of the data.
395 : \return Missing value.
396 : \exception .
397 : \sa .
398 : */
399 18 : double missingValue(CSF_CR cellRepresentation)
400 : {
401 : // It turns out that the missing values set here should be equal to the ones
402 : // used in gdal's code to do data type conversion. Otherwise missing values
403 : // in the source raster will be lost in the destination raster. It seems
404 : // that when assigning new missing values gdal uses its own nodata values
405 : // instead of the value set in the dataset.
406 :
407 18 : double missingValue = 0.0;
408 :
409 18 : switch (cellRepresentation)
410 : {
411 : // CSF version 2.
412 : // ----------------------------------------------------------
413 7 : case CR_UINT1:
414 : {
415 : // missingValue = static_cast<double>(MV_UINT1);
416 7 : missingValue = UINT1(255);
417 7 : break;
418 : }
419 1 : case CR_INT4:
420 : {
421 : // missingValue = static_cast<double>(MV_INT4);
422 1 : missingValue = INT4(-2147483647);
423 1 : break;
424 : }
425 10 : case CR_REAL4:
426 : {
427 : // using <limits> breaks on gcc 2.95
428 : // CPLAssert(std::numeric_limits<REAL4>::is_iec559);
429 : // missingValue = -std::numeric_limits<REAL4>::max();
430 10 : missingValue = std::numeric_limits<float>::lowest();
431 10 : break;
432 : }
433 : // CSF version 1.
434 : // ----------------------------------------------------------
435 0 : case CR_INT1:
436 : {
437 0 : missingValue = static_cast<double>(MV_INT1);
438 0 : break;
439 : }
440 0 : case CR_INT2:
441 : {
442 0 : missingValue = static_cast<double>(MV_INT2);
443 0 : break;
444 : }
445 0 : case CR_UINT2:
446 : {
447 0 : missingValue = static_cast<double>(MV_UINT2);
448 0 : break;
449 : }
450 0 : case CR_UINT4:
451 : {
452 0 : missingValue = static_cast<double>(MV_UINT4);
453 0 : break;
454 : }
455 0 : default:
456 : {
457 0 : CPLError(CE_Failure, CPLE_NotSupported,
458 : "Unexpected value for cellRepresentation = %d",
459 : cellRepresentation);
460 0 : break;
461 : }
462 : }
463 :
464 18 : return missingValue;
465 : }
466 :
467 : //! Opens the raster in \a filename using mode \a mode.
468 : /*!
469 : \param filename Filename of raster to open.
470 : \return Pointer to CSF MAP structure.
471 : \exception .
472 : \warning .
473 : \sa .
474 : */
475 13 : MAP *mapOpen(std::string const &filename, MOPEN_PERM mode)
476 : {
477 13 : MAP *map = Mopen(filename.c_str(), mode);
478 :
479 13 : return map;
480 : }
481 :
482 420 : void alterFromStdMV(void *buffer, size_t size, CSF_CR cellRepresentation,
483 : double missingValue)
484 : {
485 420 : switch (cellRepresentation)
486 : {
487 : // CSF version 2.
488 : // ----------------------------------------------------------
489 400 : case (CR_UINT1):
490 : {
491 : std::for_each(
492 : static_cast<UINT1 *>(buffer),
493 : static_cast<UINT1 *>(buffer) + size,
494 400 : pcr::AlterFromStdMV<UINT1>(static_cast<UINT1>(missingValue)));
495 400 : break;
496 : }
497 0 : case (CR_INT4):
498 : {
499 : std::for_each(
500 0 : static_cast<INT4 *>(buffer), static_cast<INT4 *>(buffer) + size,
501 0 : pcr::AlterFromStdMV<INT4>(static_cast<INT4>(missingValue)));
502 0 : break;
503 : }
504 20 : case (CR_REAL4):
505 : {
506 : std::for_each(
507 : static_cast<REAL4 *>(buffer),
508 20 : static_cast<REAL4 *>(buffer) + size,
509 20 : pcr::AlterFromStdMV<REAL4>(static_cast<REAL4>(missingValue)));
510 20 : break;
511 : }
512 0 : case (CR_REAL8):
513 : {
514 : std::for_each(
515 : static_cast<REAL8 *>(buffer),
516 0 : static_cast<REAL8 *>(buffer) + size,
517 0 : pcr::AlterFromStdMV<REAL8>(static_cast<REAL8>(missingValue)));
518 0 : break;
519 : }
520 : // CSF version 1.
521 : // ----------------------------------------------------------
522 0 : case CR_INT1:
523 : {
524 : std::for_each(
525 : static_cast<INT1 *>(buffer), static_cast<INT1 *>(buffer) + size,
526 0 : pcr::AlterFromStdMV<INT1>(static_cast<INT1>(missingValue)));
527 0 : break;
528 : }
529 0 : case CR_INT2:
530 : {
531 : std::for_each(
532 0 : static_cast<INT2 *>(buffer), static_cast<INT2 *>(buffer) + size,
533 0 : pcr::AlterFromStdMV<INT2>(static_cast<INT2>(missingValue)));
534 0 : break;
535 : }
536 0 : case CR_UINT2:
537 : {
538 : std::for_each(
539 : static_cast<UINT2 *>(buffer),
540 0 : static_cast<UINT2 *>(buffer) + size,
541 0 : pcr::AlterFromStdMV<UINT2>(static_cast<UINT2>(missingValue)));
542 0 : break;
543 : }
544 0 : case CR_UINT4:
545 : {
546 : std::for_each(
547 : static_cast<UINT4 *>(buffer),
548 0 : static_cast<UINT4 *>(buffer) + size,
549 0 : pcr::AlterFromStdMV<UINT4>(static_cast<UINT4>(missingValue)));
550 0 : break;
551 : }
552 0 : default:
553 : {
554 0 : CPLAssert(false);
555 : break;
556 : }
557 : }
558 420 : }
559 :
560 120 : void alterToStdMV(void *buffer, size_t size, CSF_CR cellRepresentation,
561 : double missingValue)
562 : {
563 120 : switch (cellRepresentation)
564 : {
565 : // CSF version 2.
566 : // ----------------------------------------------------------
567 100 : case (CR_UINT1):
568 : {
569 : std::for_each(
570 : static_cast<UINT1 *>(buffer),
571 : static_cast<UINT1 *>(buffer) + size,
572 100 : pcr::AlterToStdMV<UINT1>(static_cast<UINT1>(missingValue)));
573 100 : break;
574 : }
575 0 : case (CR_INT4):
576 : {
577 : std::for_each(
578 0 : static_cast<INT4 *>(buffer), static_cast<INT4 *>(buffer) + size,
579 0 : pcr::AlterToStdMV<INT4>(static_cast<INT4>(missingValue)));
580 0 : break;
581 : }
582 20 : case (CR_REAL4):
583 : {
584 : std::for_each(
585 : static_cast<REAL4 *>(buffer),
586 20 : static_cast<REAL4 *>(buffer) + size,
587 20 : pcr::AlterToStdMV<REAL4>(static_cast<REAL4>(missingValue)));
588 20 : break;
589 : }
590 0 : case (CR_REAL8):
591 : {
592 : std::for_each(
593 : static_cast<REAL8 *>(buffer),
594 0 : static_cast<REAL8 *>(buffer) + size,
595 0 : pcr::AlterToStdMV<REAL8>(static_cast<REAL8>(missingValue)));
596 0 : break;
597 : }
598 : // CSF version 1.
599 : // ----------------------------------------------------------
600 0 : case CR_INT1:
601 : {
602 : std::for_each(
603 : static_cast<INT1 *>(buffer), static_cast<INT1 *>(buffer) + size,
604 0 : pcr::AlterToStdMV<INT1>(static_cast<INT1>(missingValue)));
605 0 : break;
606 : }
607 0 : case CR_INT2:
608 : {
609 : std::for_each(
610 0 : static_cast<INT2 *>(buffer), static_cast<INT2 *>(buffer) + size,
611 0 : pcr::AlterToStdMV<INT2>(static_cast<INT2>(missingValue)));
612 0 : break;
613 : }
614 0 : case CR_UINT2:
615 : {
616 : std::for_each(
617 : static_cast<UINT2 *>(buffer),
618 0 : static_cast<UINT2 *>(buffer) + size,
619 0 : pcr::AlterToStdMV<UINT2>(static_cast<UINT2>(missingValue)));
620 0 : break;
621 : }
622 0 : case CR_UINT4:
623 : {
624 : std::for_each(
625 : static_cast<UINT4 *>(buffer),
626 0 : static_cast<UINT4 *>(buffer) + size,
627 0 : pcr::AlterToStdMV<UINT4>(static_cast<UINT4>(missingValue)));
628 0 : break;
629 : }
630 0 : default:
631 : {
632 0 : CPLAssert(false);
633 : break;
634 : }
635 : }
636 120 : }
637 :
638 11 : CSF_VS fitValueScale(CSF_VS valueScale, CSF_CR cellRepresentation)
639 : {
640 11 : CSF_VS result = valueScale;
641 :
642 11 : switch (cellRepresentation)
643 : {
644 5 : case CR_UINT1:
645 : {
646 5 : switch (valueScale)
647 : {
648 1 : case VS_LDD:
649 : {
650 1 : result = VS_LDD;
651 1 : break;
652 : }
653 4 : default:
654 : {
655 4 : result = VS_BOOLEAN;
656 4 : break;
657 : }
658 : }
659 5 : break;
660 : }
661 1 : case CR_INT4:
662 : {
663 1 : switch (valueScale)
664 : {
665 0 : case VS_BOOLEAN:
666 : {
667 0 : result = VS_NOMINAL;
668 0 : break;
669 : }
670 0 : case VS_SCALAR:
671 : {
672 0 : result = VS_ORDINAL;
673 0 : break;
674 : }
675 0 : case VS_DIRECTION:
676 : {
677 0 : result = VS_ORDINAL;
678 0 : break;
679 : }
680 0 : case VS_LDD:
681 : {
682 0 : result = VS_NOMINAL;
683 0 : break;
684 : }
685 1 : default:
686 : {
687 1 : result = valueScale;
688 1 : break;
689 : }
690 : }
691 1 : break;
692 : }
693 1 : case CR_REAL4:
694 : {
695 1 : switch (valueScale)
696 : {
697 0 : case VS_DIRECTION:
698 : {
699 0 : result = VS_DIRECTION;
700 0 : break;
701 : }
702 1 : default:
703 : {
704 1 : result = VS_SCALAR;
705 1 : break;
706 : }
707 : }
708 1 : break;
709 : }
710 4 : default:
711 : {
712 4 : break;
713 : }
714 : }
715 :
716 11 : return result;
717 : }
718 :
719 10 : void castValuesToBooleanRange(void *buffer, size_t size,
720 : CSF_CR cellRepresentation)
721 : {
722 10 : switch (cellRepresentation)
723 : {
724 : // CSF version 2.
725 : // ----------------------------------------------------------
726 10 : case (CR_UINT1):
727 : {
728 : std::for_each(static_cast<UINT1 *>(buffer),
729 : static_cast<UINT1 *>(buffer) + size,
730 10 : CastToBooleanRange<UINT1>());
731 10 : break;
732 : }
733 0 : case (CR_INT4):
734 : {
735 : std::for_each(static_cast<INT4 *>(buffer),
736 0 : static_cast<INT4 *>(buffer) + size,
737 0 : CastToBooleanRange<INT4>());
738 0 : break;
739 : }
740 0 : case (CR_REAL4):
741 : {
742 : std::for_each(static_cast<REAL4 *>(buffer),
743 0 : static_cast<REAL4 *>(buffer) + size,
744 0 : CastToBooleanRange<REAL4>());
745 0 : break;
746 : }
747 0 : case (CR_REAL8):
748 : {
749 : std::for_each(static_cast<REAL8 *>(buffer),
750 0 : static_cast<REAL8 *>(buffer) + size,
751 0 : CastToBooleanRange<REAL8>());
752 0 : break;
753 : }
754 : // CSF version 1.
755 : // ----------------------------------------------------------
756 0 : case CR_INT1:
757 : {
758 : std::for_each(static_cast<INT1 *>(buffer),
759 : static_cast<INT1 *>(buffer) + size,
760 0 : CastToBooleanRange<INT1>());
761 0 : break;
762 : }
763 0 : case CR_INT2:
764 : {
765 : std::for_each(static_cast<INT2 *>(buffer),
766 0 : static_cast<INT2 *>(buffer) + size,
767 0 : CastToBooleanRange<INT2>());
768 0 : break;
769 : }
770 0 : case CR_UINT2:
771 : {
772 : std::for_each(static_cast<UINT2 *>(buffer),
773 0 : static_cast<UINT2 *>(buffer) + size,
774 0 : CastToBooleanRange<UINT2>());
775 0 : break;
776 : }
777 0 : case CR_UINT4:
778 : {
779 : std::for_each(static_cast<UINT4 *>(buffer),
780 0 : static_cast<UINT4 *>(buffer) + size,
781 0 : CastToBooleanRange<UINT4>());
782 0 : break;
783 : }
784 0 : default:
785 : {
786 0 : CPLAssert(false);
787 : break;
788 : }
789 : }
790 10 : }
791 :
792 0 : void castValuesToDirectionRange(void *buffer, size_t size)
793 : {
794 : std::for_each(static_cast<REAL4 *>(buffer),
795 0 : static_cast<REAL4 *>(buffer) + size, CastToDirection());
796 0 : }
797 :
798 0 : void castValuesToLddRange(void *buffer, size_t size)
799 : {
800 : std::for_each(static_cast<UINT1 *>(buffer),
801 0 : static_cast<UINT1 *>(buffer) + size, CastToLdd());
802 0 : }
|
