?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / System / Image / FileIO / OSGITFImageFileType.cpp
blobfd19cf27ac843d58a602a1ad5bc3657a790831d7
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2002 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38 //-------------------------------
39 // Includes
40 //-------------------------------
41
42 #include <cstdlib>
43 #include <cstdio>
44
45 #include "OSGConfig.h"
46
47 #include "OSGITFImageFileType.h"
48 #include "OSGGeoReferenceAttachment.h"
49 #include "OSGImageFileHandler.h"
50 #include "OSGPathHandler.h"
51
52 // Static Class Varible implementations:
53 static const OSG::Char8 *suffixArray[] =
54 {
55 "itf"
56 };
57
58 OSG_BEGIN_NAMESPACE
59
60 TiledImageBlockAccessor::~TiledImageBlockAccessor(void)
61 {
62 }
63
64 bool TiledImageBlockAccessor::isOpen(void)
65 {
66 return (_vImages.size() != 0);
67 }
68
69
70 TiledImageBlockAccessor::TiledImageBlockAccessor(void) :
71 Inherited ( ),
72 _uiRows (0),
73 _uiColumns (0),
74 _vImages ( ),
75 _vSampleDescs( ),
76 _vI16Buffer ( )
77 {
78 }
79
80 void TiledImageBlockAccessor::open(const Char8 *szFilename)
81 {
82 fprintf(stderr, "Open Tiled %s\n", szFilename);
83
84 FILE *pFile = fopen(szFilename, "r");
85
86 Char8 szRow[1024];
87
88 const Char8 *szDelim = " \t\n ";
89
90 std::string szBuffer;
91
92 if(pFile != NULL)
93 {
94 while(!feof(pFile))
95 {
96 fgets(szRow, 1024, pFile);
97
98 szBuffer.append(szRow);
99 }
100
101 PathHandler *pOrgHandler = ImageFileHandler::the()->getPathHandler();
102 PathHandler tmpHandler;
103
104 tmpHandler.setBaseFile(szFilename);
105
106 ImageFileHandler::the()->setPathHandler(&tmpHandler);
107
108 fprintf(stderr, "got %s\n", szBuffer.c_str());
109
110 string_token_iterator cIt (szBuffer, szDelim);
111 string_token_iterator cEnd;
112
113 _uiColumns = TypeTraits<UInt32>::getFromCString((*cIt).c_str());
114
115 fprintf(stderr, "C: %d\n", _uiColumns);
116
117 ++cIt;
118
119 _uiRows = TypeTraits<UInt32>::getFromCString((*cIt).c_str());
120
121 fprintf(stderr, "R: %d\n", _uiRows);
122
123 ++cIt;
124
125 for(UInt32 i = 0; i < _uiRows * _uiColumns; ++i)
126 {
127 if(cIt == cEnd)
128 {
129 break;
130 }
131
132 fprintf(stderr, "File -%s-\n", (*cIt).c_str());
133
134 ImageBlockAccessorPtr pAccess;
135
136 if(strncmp((*cIt).c_str(), "default:", 7) == 0)
137 {
138 DefaultBlockAccessorPtr pDefAccess(
139 new DefaultBlockAccessor());
140
141 pAccess = pDefAccess;
142
143 pDefAccess->open((*cIt).c_str());
144 }
145 else
146 {
147 pAccess = ImageFileHandler::the()->open((*cIt).c_str());
148 }
149
150 _vImages.push_back(pAccess);
151
152 ++cIt;
153
154 }
155
156 ImageFileHandler::the()->setPathHandler(pOrgHandler);
157
158 if(_vImages.size() != _uiRows * _uiColumns || _vImages.size() == 0)
159 {
160 fprintf(stderr, "Images missing %" PRISize " %d\n",
161 _vImages.size(),
162 _uiRows * _uiColumns);
163
164 _vImages.clear();
165
166 return;
167 }
168
169 _vSampleDescs.resize(_vImages.size());
170
171 UInt32 uiIdx = 0;
172 UInt32 uiOtherIdx = 0;
173
174 _vSampleDescs[0].setBounds( 0,
175 0,
176 _vImages[0]->getSize()[0],
177 _vImages[0]->getSize()[1]);
178
179 for(UInt32 i = 1; i < _uiRows; ++i)
180 {
181 uiIdx = i * _uiColumns;
182 uiOtherIdx = uiIdx - _uiColumns;
183
184 _vSampleDescs[uiIdx].setBounds(
185 _vSampleDescs[uiOtherIdx]._x0,
186 _vSampleDescs[uiOtherIdx]._y1,
187 _vImages [uiIdx ]->getSize()[0],
188 _vImages [uiIdx ]->getSize()[1]);
189 }
190
191 for(UInt32 i = 1; i < _uiColumns; ++i)
192 {
193 _vSampleDescs[i].setBounds(
194 _vSampleDescs[i - 1]._x1,
195 _vSampleDescs[i - 1]._y0,
196 _vImages [i ]->getSize()[0],
197 _vImages [i ]->getSize()[1]);
198 }
199
200
201 for(UInt32 i = 1; i < _uiRows; ++i)
202 {
203 for(UInt32 j = 1; j < _uiColumns; ++j)
204 {
205 uiIdx = i * _uiColumns + j;
206 uiOtherIdx = (i - 1) * _uiColumns + (j - 1);
207
208 _vSampleDescs[uiIdx].setBounds(
209 _vSampleDescs[uiOtherIdx]._x1,
210 _vSampleDescs[uiOtherIdx]._y1,
211 _vImages [uiIdx ]->getSize()[0],
212 _vImages [uiIdx ]->getSize()[1]);
213 }
214 }
215
216 for(UInt32 i = 0; i < _uiRows; ++i)
217 {
218 for(UInt32 j = 0; j < _uiColumns; ++j)
219 {
220 uiIdx = i * _uiColumns + j;
221
222 fprintf(stderr, "(%d)(%d %d) | %d %d %d %d\n",
223 uiIdx, i, j,
224 _vSampleDescs[uiIdx]._x0,
225 _vSampleDescs[uiIdx]._y0,
226 _vSampleDescs[uiIdx]._x1,
227 _vSampleDescs[uiIdx]._y1);
228 }
229 }
230
231 _vSize.setValues(_vSampleDescs.back()._x1,
232 _vSampleDescs.back()._y1);
233
234 GeoReferenceAttachment *pFirstRef =
235 _vImages.front()->getGeoRef();
236
237 if(pFirstRef != NULL)
238 {
239 _pGeoRef = GeoReferenceAttachment::create();
240
241 _pGeoRef->setOrigin (pFirstRef->getOrigin ());
242 _pGeoRef->setPixelSize (pFirstRef->getPixelSize ());
243 _pGeoRef->setEllipsoidAxis(pFirstRef->getEllipsoidAxis());
244 _pGeoRef->setDatum (pFirstRef->getDatum ());
245 _pGeoRef->setNoDataValue (pFirstRef->getNoDataValue ());
246 }
247
248 _eImgType = _vImages.front()->getType ();
249 _eImgFormat = _vImages.front()->getFormat();
250
251 _fNoDataValue = _vImages.front()->getNoDataValue();
252
253 fclose(pFile);
254 }
255 }
256
257 bool TiledImageBlockAccessor::readBlockA16(Vec2i vSampleOrigin,
258 Int32 iTextureSize,
259 UInt16 *pTarget,
260 Int32 iTargetSizeBytes)
261 {
262 #if 0
263 UInt32 destIdx = 0;
264
265 UInt8 *pDst = (UInt8 *) pTarget;
266
267 Int32 xMin = vSampleOrigin.x();
268 Int32 xMax = vSampleOrigin.x() + iTextureSize;
269
270 Int32 yMin = vSampleOrigin.y();
271 Int32 yMax = vSampleOrigin.y() + iTextureSize;
272
273 for(UInt32 y = yMin; y < yMax; y++)
274 {
275 for(UInt32 x = xMin; x < xMax; x++)
276 {
277 for(UInt32 i = 0; i < 2; i++)
278 {
279 pDst[destIdx] = 0;
280
281 destIdx++;
282 }
283 }
284
285 destIdx += (iTextureSize - (xMax - xMin)) * 2;
286 }
287 #endif
288
289 return true;
290 }
291
292 bool TiledImageBlockAccessor::readBlockA16(Vec2i vSampleOrigin,
293 Int32 iTextureSize,
294 Int16 *pTarget,
295 Int32 iTargetSizeBytes)
296 {
297 Vec2i vLow (vSampleOrigin.x(), vSampleOrigin.y());
298
299 Vec2i vHeigh(vSampleOrigin.x() + iTextureSize,
300 vSampleOrigin.y() + iTextureSize);
301
302 UInt32 iFound = 0;
303
304 Int32 iLow = -1;
305 Int32 iHeigh = -1;
306
307 for(UInt32 i = 0; i < _vSampleDescs.size(); ++i)
308 {
309 if(_vSampleDescs[i].contains(vLow) == true)
310 {
311 iLow = i;
312
313 ++iFound;
314 }
315
316 if(_vSampleDescs[i].contains(vHeigh) == true)
317 {
318 iHeigh = i;
319
320 ++iFound;
321 }
322
323 if(iFound == 2)
324 break;
325 }
326
327
328 if(iLow == -1 && iHeigh == -1)
329 {
330 UInt32 destIdx = 0;
331
332 for(Int32 y = 0; y < iTextureSize; y++)
333 {
334 for(Int32 x = 0; x < iTextureSize; x++)
335 {
336 pTarget[destIdx] = Int16(_fNoDataValue);
337
338 destIdx++;
339 }
340 }
341 }
342 else if(iLow == iHeigh)
343 {
344 Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow]._x0,
345 vSampleOrigin.y() - _vSampleDescs[iLow]._y0);
346
347 return _vImages[iLow]->readBlockA16(vNewSampleOrigin,
348 iTextureSize,
349 pTarget,
350 iTargetSizeBytes);
351 }
352 else if( (iHeigh - iLow) == 1)
353 {
354 read2HBlocksA16(iLow,
355 iHeigh,
356 vSampleOrigin,
357 iTextureSize,
358 pTarget,
359 iTargetSizeBytes);
360 }
361 else if( (iHeigh - iLow) == Int32(_uiColumns))
362 {
363 read2VBlocksA16(iLow,
364 iHeigh,
365 vSampleOrigin,
366 iTextureSize,
367 pTarget,
368 iTargetSizeBytes);
369 }
370 else if( (iHeigh - iLow) == Int32(_uiColumns + 1))
371 {
372 read4BlocksA16(iLow,
373 iHeigh,
374 vSampleOrigin,
375 iTextureSize,
376 pTarget,
377 iTargetSizeBytes);
378 }
379 else if(iLow != -1 && iHeigh == -1)
380 {
381 Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow]._x0,
382 vSampleOrigin.y() - _vSampleDescs[iLow]._y0);
383
384 return _vImages[iLow]->readBlockA16(vNewSampleOrigin,
385 iTextureSize,
386 pTarget,
387 iTargetSizeBytes);
388 }
389 else
390 {
391 UInt32 destIdx = 0;
392
393 for(Int32 y = 0; y < iTextureSize; y++)
394 {
395 for(Int32 x = 0; x < iTextureSize; x++)
396 {
397 pTarget[destIdx] = 15000;
398
399 destIdx++;
400 }
401 }
402 }
403
404 return true;
405 }
406
407 bool TiledImageBlockAccessor::read2HBlocksA16(Int32 iLow,
408 Int32 iHeigh,
409 Vec2i vSampleOrigin,
410 Int32 iTextureSize,
411 Int16 *pTarget,
412 Int32 iTargetSizeBytes)
413 {
414 Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow]._x0,
415 vSampleOrigin.y() - _vSampleDescs[iLow]._y0);
416
417 _vImages[iLow]->readBlockA16(vNewSampleOrigin,
418 iTextureSize,
419 pTarget,
420 iTargetSizeBytes);
421
422
423 _vI16Buffer.resize(iTextureSize * iTextureSize);
424
425 vNewSampleOrigin.setValues(0,
426 vSampleOrigin.y() - _vSampleDescs[iLow ]._y0);
427
428 _vImages[iHeigh]->readBlockA16(vNewSampleOrigin,
429 iTextureSize,
430 &(_vI16Buffer[0]),
431 iTargetSizeBytes);
432
433 UInt32 destIdx = 0;
434 UInt32 srcIdx = 0;
435
436 Int32 xMin = vSampleOrigin.x();
437 Int32 xMax = vSampleOrigin.x() + iTextureSize;
438
439 Int32 yMin = vSampleOrigin.y();
440 Int32 yMax = vSampleOrigin.y() + iTextureSize;
441
442 for(Int32 y = yMin; y < yMax; y++)
443 {
444 srcIdx = (y - yMin) * iTextureSize;
445
446 for(Int32 x = xMin; x < xMax; x++)
447 {
448 if(x >= _vSampleDescs[iHeigh]._x0)
449 {
450 pTarget[destIdx] = _vI16Buffer[srcIdx];
451
452 ++srcIdx;
453 }
454
455 ++destIdx;
456 }
457
458 }
459
460 return true;
461 }
462
463 bool TiledImageBlockAccessor::read2VBlocksA16(Int32 iLow,
464 Int32 iHeigh,
465 Vec2i vSampleOrigin,
466 Int32 iTextureSize,
467 Int16 *pTarget,
468 Int32 iTargetSizeBytes)
469 {
470 Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow]._x0,
471 vSampleOrigin.y() - _vSampleDescs[iLow]._y0);
472
473 _vImages[iLow]->readBlockA16(vNewSampleOrigin,
474 iTextureSize,
475 pTarget,
476 iTargetSizeBytes);
477
478
479 _vI16Buffer.resize(iTextureSize * iTextureSize);
480
481 vNewSampleOrigin.setValues(vSampleOrigin.x() - _vSampleDescs[iLow ]._x0,
482 0);
483
484 _vImages[iHeigh]->readBlockA16(vNewSampleOrigin,
485 iTextureSize,
486 &(_vI16Buffer[0]),
487 iTargetSizeBytes);
488
489 UInt32 destIdx = 0;
490 UInt32 srcIdx = 0;
491
492 Int32 xMin = vSampleOrigin.x();
493 Int32 xMax = vSampleOrigin.x() + iTextureSize;
494
495 Int32 yMin = vSampleOrigin.y();
496 Int32 yMax = vSampleOrigin.y() + iTextureSize;
497
498 for(Int32 y = yMin; y < yMax; y++)
499 {
500 for(Int32 x = xMin; x < xMax; x++)
501 {
502 if(y >= _vSampleDescs[iHeigh]._y0)
503 {
504 pTarget[destIdx] = _vI16Buffer[srcIdx];
505
506 ++srcIdx;
507 }
508
509 ++destIdx;
510 }
511 }
512
513 return true;
514 }
515
516 bool TiledImageBlockAccessor::read4BlocksA16(Int32 iLow,
517 Int32 iHeigh,
518 Vec2i vSampleOrigin,
519 Int32 iTextureSize,
520 Int16 *pTarget,
521 Int32 iTargetSizeBytes)
522 {
523 Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow]._x0,
524 vSampleOrigin.y() - _vSampleDescs[iLow]._y0);
525
526 _vImages[iLow]->readBlockA16(vNewSampleOrigin,
527 iTextureSize,
528 pTarget,
529 iTargetSizeBytes);
530
531
532 _vI16Buffer.resize(iTextureSize * iTextureSize);
533
534 vNewSampleOrigin.setValues(0,
535 vSampleOrigin.y() - _vSampleDescs[iLow ]._y0);
536
537 _vImages[iLow + 1]->readBlockA16(vNewSampleOrigin,
538 iTextureSize,
539 &(_vI16Buffer[0]),
540 iTargetSizeBytes);
541
542 UInt32 destIdx = 0;
543 UInt32 srcIdx = 0;
544
545 Int32 xMin = vSampleOrigin.x();
546 Int32 xMax = vSampleOrigin.x() + iTextureSize;
547
548 Int32 yMin = vSampleOrigin.y();
549 Int32 yMax = vSampleOrigin.y() + iTextureSize;
550
551 for(Int32 y = yMin; y < yMax; y++)
552 {
553 srcIdx = (y - yMin) * iTextureSize;
554
555 for(Int32 x = xMin; x < xMax; x++)
556 {
557 if(x >= _vSampleDescs[iLow + 1]._x0)
558 {
559 pTarget[destIdx] = _vI16Buffer[srcIdx];
560
561 ++srcIdx;
562 }
563
564 ++destIdx;
565 }
566 }
567
568 vNewSampleOrigin.setValues(vSampleOrigin.x() - _vSampleDescs[iLow ]._x0,
569 0);
570
571 _vImages[iLow + _uiColumns]->readBlockA16(vNewSampleOrigin,
572 iTextureSize,
573 &(_vI16Buffer[0]),
574 iTargetSizeBytes);
575
576 destIdx = 0;
577 srcIdx = 0;
578
579 for(Int32 y = yMin; y < yMax; y++)
580 {
581 for(Int32 x = xMin; x < xMax; x++)
582 {
583 if(y >= _vSampleDescs[iLow + _uiColumns]._y0)
584 {
585 pTarget[destIdx] = _vI16Buffer[srcIdx];
586
587 ++srcIdx;
588 }
589
590 ++destIdx;
591 }
592 }
593
594 vNewSampleOrigin.setValues(0, 0);
595
596 _vImages[iHeigh]->readBlockA16(vNewSampleOrigin,
597 iTextureSize,
598 &(_vI16Buffer[0]),
599 iTargetSizeBytes);
600 destIdx = 0;
601 srcIdx = 0;
602
603 for(Int32 y = yMin; y < yMax; y++)
604 {
605 srcIdx = (y - yMin) * iTextureSize;
606
607 for(Int32 x = xMin; x < xMax; x++)
608 {
609 if(x >= _vSampleDescs[iHeigh]._x0 &&
610 y >= _vSampleDescs[iHeigh]._y0)
611 {
612 pTarget[destIdx] = _vI16Buffer[srcIdx];
613
614 ++srcIdx;
615 }
616
617 ++destIdx;
618 }
619 }
620
621 return true;
622 }
623
624
625
626
627 DefaultBlockAccessor::~DefaultBlockAccessor(void)
628 {
629 }
630
631
632 bool DefaultBlockAccessor::isOpen(void)
633 {
634 return true;
635 }
636
637 bool DefaultBlockAccessor::readBlockA16(Vec2i vSampleOrigin,
638 Int32 iTextureSize,
639 UInt16 *pTarget,
640 Int32 iTargetSizeBytes)
641 {
642 return true;
643 }
644
645 bool DefaultBlockAccessor::readBlockA16(Vec2i vSampleOrigin,
646 Int32 iTextureSize,
647 Int16 *pTarget,
648 Int32 iTargetSizeBytes)
649 {
650 for(Int32 i = 0; i < iTextureSize * iTextureSize; ++i)
651 {
652 pTarget[i] = _iDefaultValue;
653 }
654
655 return true;
656 }
657
658 DefaultBlockAccessor::DefaultBlockAccessor(void) :
659 Inherited ( ),
660 _iDefaultValue(0)
661 {
662 }
663
664 void DefaultBlockAccessor::open(const Char8 *szFilename)
665 {
666 fprintf(stderr, "OpenDefault %s\n", szFilename);
667
668 std::string szFName(szFilename);
669 Char8 const *szDelim = ":";
670
671 string_token_iterator cIt (szFName, szDelim);
672 string_token_iterator cEnd;
673
674 fprintf(stderr, "File -%s-\n", (*cIt).c_str());
675
676 ++cIt;
677
678 if(cIt == cEnd)
679 return;
680
681 _iDefaultValue = TypeTraits<Int32>::getFromCString((*cIt).c_str());
682
683 fprintf(stderr, "Def %d\n", _iDefaultValue);
684
685 ++cIt;
686
687 if(cIt == cEnd)
688 return;
689
690 _vSize[0] = TypeTraits<Int32>::getFromCString((*cIt).c_str());
691
692 ++cIt;
693
694 if(cIt == cEnd)
695 return;
696
697 _vSize[1] = TypeTraits<Int32>::getFromCString((*cIt).c_str());
698
699 fprintf(stderr, "Size %d %d\n", _vSize[0], _vSize[1]);
700
701 ++cIt;
702
703 if(cIt == cEnd)
704 return;
705
706 _eImgType = Image::Type(TypeTraits<UInt32>::getFromCString((*cIt).c_str()));
707
708 ++cIt;
709
710 if(cIt == cEnd)
711 return;
712
713 _eImgFormat =
714 Image::PixelFormat(TypeTraits<UInt32>::getFromCString((*cIt).c_str()));
715
716 fprintf(stderr, "T: %x F: %x\n",
717 _eImgType,
718 _eImgFormat);
719
720 ++cIt;
721
722 if(cIt == cEnd)
723 return;
724
725 _pGeoRef = GeoReferenceAttachment::create();
726
727 _pGeoRef->editOrigin()[0] =
728 TypeTraits<Real32>::getFromCString((*cIt).c_str());
729
730 ++cIt;
731
732 if(cIt == cEnd)
733 return;
734
735 _pGeoRef->editOrigin()[1] =
736 TypeTraits<Real32>::getFromCString((*cIt).c_str());
737
738 ++cIt;
739
740 if(cIt == cEnd)
741 return;
742
743 _pGeoRef->editPixelSize()[0] =
744 TypeTraits<Real32>::getFromCString((*cIt).c_str());
745
746 ++cIt;
747
748 if(cIt == cEnd)
749 return;
750
751 _pGeoRef->editPixelSize()[1] =
752 TypeTraits<Real32>::getFromCString((*cIt).c_str());
753
754 ++cIt;
755
756 if(cIt == cEnd)
757 return;
758
759 _pGeoRef->editDatum() =
760 TypeTraits<UInt32>::getFromCString((*cIt).c_str());
761
762 ++cIt;
763
764 if(cIt == cEnd)
765 return;
766
767 _pGeoRef->editEllipsoidAxis()[0] =
768 TypeTraits<Real32>::getFromCString((*cIt).c_str());
769
770 _pGeoRef->editEllipsoidAxis()[1] =
771 TypeTraits<Real32>::getFromCString((*cIt).c_str());
772
773 fprintf(stderr, "GeoRef : %f %f | %f %f | %d | %f %f\n",
774 _pGeoRef->getOrigin()[0],
775 _pGeoRef->getOrigin()[1],
776 _pGeoRef->getPixelSize()[0],
777 _pGeoRef->getPixelSize()[1],
778 _pGeoRef->getDatum(),
779 _pGeoRef->getEllipsoidAxis()[0],
780 _pGeoRef->getEllipsoidAxis()[1]);
781
782 }
783
784
785 /*! \class GDALImageFileType
786
787 Image File Type to read/write and store/restore Image objects as
788 GDAL (tif/tiff suffix) data.
789
790 To be able to load TIFF images you need the IJG TIFF library,
791 (check the Prerequisites page on www.opensg.org).
792 The lib comes with all Linux distributions.
793
794 You have to --enable-tif in the configure line to enable
795 the singleton object.
796
797 */
798
799 ITFImageFileType ITFImageFileType:: _the("image/itf",
800 suffixArray,
801 sizeof(suffixArray),
802 0);
803
804
805 //-------------------------------------------------------------------------
806 /*! Tries to fill the image object with the data read from
807 the given fileName. Returns true on success.
808 */
809
810
811 //-------------------------------------------------------------------------
812 /*! Tries to write the image object to the given output stream.
813 Returns true on success.
814 */
815
816
817 bool ITFImageFileType::validateHeader(const Char8 *fileName, bool &implemented)
818 {
819 implemented = true;
820
821 return true;
822 }
823
824 ImageBlockAccessorPtr ITFImageFileType::open(const Char8 *fileName)
825 {
826 TiledImageBlockAccessorPtr returnValue(new TiledImageBlockAccessor);
827
828 returnValue->open(fileName);
829
830 return returnValue;
831 }
832
833 //-------------------------------------------------------------------------
834 /*! Constructor used for the singleton object
835 */
836
837 ITFImageFileType::ITFImageFileType(const Char8 *mimeType,
838 const Char8 *suffixArray[],
839 UInt16 suffixByteCount,
840 UInt32 flags) :
841 Inherited(mimeType,
842 suffixArray,
843 suffixByteCount,
844 flags )
845 {
846 }
847
848 //-------------------------------------------------------------------------
849 /*! Destructor
850 */
851
852 ITFImageFileType::~ITFImageFileType(void)
853 {
854 }
855
856 OSG_END_NAMESPACE
857