Source/System/Image/FileIO/OSGDBImageFileType.cpp

   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 "OSGDBImageFileType.h"
  48 #include "OSGGeoReferenceAttachment.h"
  49 #include "OSGImageFunctions.h"
  50
  51 #ifndef OSG_DO_DOC
  52 #    ifdef OSG_WITH_DB
  53 #        define OSG_DB_ARG(ARG) ARG
  54 #    else
  55 #        define OSG_DB_ARG(ARG)
  56 #    endif
  57 #else
  58 #    define OSG_DB_ARG(ARG) ARG
  59 #endif
  60
  61 // Static Class Varible implementations:
  62 static const OSG::Char8 *suffixArray[] =
  63 {
  64     "db"
  65 };
  66
  67 OSG_BEGIN_NAMESPACE
  68
  69 DBHeaderParameter::DBHeaderParameter(void) :
  70     _bLastParam(false)
  71 {
  72 }
  73
  74 DBHeaderParameter::~DBHeaderParameter(void)
  75 {
  76 }
  77
  78 void DBHeaderParameter::setLastParam(void)
  79 {
  80     _bLastParam = true;
  81 }
  82
  83 bool DBHeaderParameter::isLastParam(void)
  84 {
  85     return _bLastParam;
  86 }
  87
  88
  89 DBHeaderIntParameter::DBHeaderIntParameter(UInt32 &uiParam) :
  90      Inherited(       ),
  91     _uiParam  (uiParam)
  92 {
  93 }
  94
  95 DBHeaderIntParameter::~DBHeaderIntParameter(void)
  96 {
  97 }
  98
  99 void DBHeaderIntParameter::convert(const Char8 *str)
 100 {
 101     if(str != NULL)
 102     {
 103         sscanf(str, "%u", &_uiParam);
 104     }
 105 }
 106
 107 DBHeaderFloatParameter::DBHeaderFloatParameter(Real32 &rParam) :
 108      Inherited(      ),
 109     _rParam   (rParam)
 110 {
 111 }
 112
 113 DBHeaderFloatParameter::~DBHeaderFloatParameter(void)
 114 {
 115 }
 116
 117 void DBHeaderFloatParameter::convert(const Char8 *str)
 118 {
 119     if(str != NULL)
 120     {
 121         sscanf(str, "%f", &_rParam);
 122     }
 123 }
 124
 125 DBHeader::DBHeader(void) :
 126     uiMagic     (0  ),
 127     uiXSize     (0  ),
 128     uiYSize     (0  ),
 129     uiZSize     (0  ),
 130     uiTSteps    (0  ),
 131     uiType      (0  ),
 132
 133     rSWx        (0.f),
 134     rSWy        (0.f),
 135     rNWx        (0.f),
 136     rNWy        (0.f),
 137
 138     rNEx        (0.f),
 139     rNEy        (0.f),
 140     rSEx        (0.f),
 141     rSEy        (0.f),
 142
 143     rH0         (0.f),
 144     rDh         (0.f),
 145     rT0         (0.f),
 146     rDt         (0.f),
 147
 148     rScaling    (1.f),
 149     rBias       (0.f),
 150
 151     uiExtFormat (0  ),
 152     uiImplFormat(0  ),
 153
 154     LLWGS84_rSWx(0.f),
 155     LLWGS84_rSWy(0.f),
 156     LLWGS84_rNWx(0.f),
 157     LLWGS84_rNWy(0.f),
 158
 159     LLWGS84_rNEx(0.f),
 160     LLWGS84_rNEy(0.f),
 161     LLWGS84_rSEx(0.f),
 162     LLWGS84_rSEy(0.f),
 163
 164     uiBytes     (0  )
 165 {
 166     std::string szParamName("MAGIC");
 167
 168     _mParams[szParamName] = new DBHeaderIntParameter(uiMagic);
 169
 170     szParamName = "xsize";
 171
 172     _mParams[szParamName] = new DBHeaderIntParameter(uiXSize);
 173
 174     szParamName = "ysize";
 175
 176     _mParams[szParamName] = new DBHeaderIntParameter(uiYSize);
 177
 178     szParamName = "zsize";
 179
 180     _mParams[szParamName] = new DBHeaderIntParameter(uiZSize);
 181
 182     szParamName = "tsteps";
 183
 184     _mParams[szParamName] = new DBHeaderIntParameter(uiTSteps);
 185
 186     szParamName = "type";
 187
 188     _mParams[szParamName] = new DBHeaderIntParameter(uiType);
 189
 190
 191
 192     szParamName = "swx";
 193
 194     _mParams[szParamName] = new DBHeaderFloatParameter(rSWx);
 195
 196     szParamName = "swy";
 197
 198     _mParams[szParamName] = new DBHeaderFloatParameter(rSWy);
 199
 200     szParamName = "nwx";
 201
 202     _mParams[szParamName] = new DBHeaderFloatParameter(rNWx);
 203
 204     szParamName = "nwy";
 205
 206     _mParams[szParamName] = new DBHeaderFloatParameter(rNWy);
 207
 208
 209
 210     szParamName = "nex";
 211
 212     _mParams[szParamName] = new DBHeaderFloatParameter(rNEx);
 213
 214     szParamName = "ney";
 215
 216     _mParams[szParamName] = new DBHeaderFloatParameter(rNEy);
 217
 218     szParamName = "sex";
 219
 220     _mParams[szParamName] = new DBHeaderFloatParameter(rSEx);
 221
 222     szParamName = "sey";
 223
 224     _mParams[szParamName] = new DBHeaderFloatParameter(rSEy);
 225
 226
 227
 228     szParamName = "h0";
 229
 230     _mParams[szParamName] = new DBHeaderFloatParameter(rH0);
 231
 232     szParamName = "dh";
 233
 234     _mParams[szParamName] = new DBHeaderFloatParameter(rDh);
 235
 236     szParamName = "t0";
 237
 238     _mParams[szParamName] = new DBHeaderFloatParameter(rT0);
 239
 240     szParamName = "dt";
 241
 242     _mParams[szParamName] = new DBHeaderFloatParameter(rDt);
 243
 244
 245
 246     szParamName = "scaling";
 247
 248     _mParams[szParamName] = new DBHeaderFloatParameter(rScaling);
 249
 250     szParamName = "bias";
 251
 252     _mParams[szParamName] = new DBHeaderFloatParameter(rBias);
 253
 254
 255
 256     szParamName = "extformat";
 257
 258     _mParams[szParamName] = new DBHeaderIntParameter(uiExtFormat);
 259
 260     szParamName = "implformat";
 261
 262     _mParams[szParamName] = new DBHeaderIntParameter(uiImplFormat);
 263
 264
 265
 266     szParamName = "LLWGS84_swx";
 267
 268     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rSWx);
 269
 270     szParamName = "LLWGS84_swy";
 271
 272     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rSWy);
 273
 274     szParamName = "LLWGS84_nwx";
 275
 276     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rNWx);
 277
 278     szParamName = "LLWGS84_nwy";
 279
 280     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rNWy);
 281
 282
 283
 284     szParamName = "LLWGS84_nex";
 285
 286     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rNEx);
 287
 288     szParamName = "LLWGS84_ney";
 289
 290     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rNEy);
 291
 292     szParamName = "LLWGS84_sex";
 293
 294     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rSEx);
 295
 296     szParamName = "LLWGS84_sey";
 297
 298     _mParams[szParamName] = new DBHeaderFloatParameter(LLWGS84_rSEy);
 299
 300
 301
 302     szParamName = "bytes";
 303
 304     _mParams[szParamName] = new DBHeaderIntParameter(uiBytes);
 305
 306     _mParams[szParamName]->setLastParam();
 307 }
 308
 309 DBHeader::~DBHeader(void)
 310 {
 311     ParameterMap::iterator mapIt  = _mParams.begin();
 312     ParameterMap::iterator mapEnd = _mParams.end  ();
 313
 314     while(mapIt != mapEnd)
 315     {
 316         delete mapIt->second;
 317
 318         ++mapIt;
 319     }
 320 }
 321
 322 bool DBHeader::read(FILE *pIn)
 323 {
 324     bool returnValue = true;
 325
 326     if(pIn == NULL)
 327         return returnValue;
 328
 329     Char8  buffer[1024];
 330     bool   bEnd = false;
 331     Char8 *strIt;
 332
 333     while(!bEnd)
 334     {
 335         fgets(buffer, 1024, pIn);
 336
 337         strIt = strtok(buffer, "=");
 338
 339         if(strIt != NULL)
 340         {
 341             ParameterMap::iterator mapIt = _mParams.find(std::string(strIt));
 342
 343             if(mapIt != _mParams.end())
 344             {
 345                 bEnd = mapIt->second->isLastParam();
 346
 347                 strIt = strtok(NULL, "\n");
 348
 349                 mapIt->second->convert(strIt);
 350             }
 351             else
 352             {
 353                 fprintf(stderr, "Unknown parameter %s\n", strIt);
 354             }
 355         }
 356         else
 357         {
 358             bEnd = true;
 359         }
 360     }
 361
 362     buffer[0] = fgetc(pIn);
 363
 364     if(buffer[0] != '\0')
 365     {
 366         fprintf(stderr, "missing 0\n");
 367         returnValue = false;
 368     }
 369
 370     return returnValue;
 371 }
 372
 373 void DBHeader::dump(void) const
 374 {
 375     fprintf(stderr, "MAGIC       = %u\n", this->uiMagic     );
 376     fprintf(stderr, "xsize       = %u\n", this->uiXSize     );
 377     fprintf(stderr, "ysize       = %u\n", this->uiYSize     );
 378     fprintf(stderr, "zsize       = %u\n", this->uiZSize     );
 379     fprintf(stderr, "tsteps      = %u\n", this->uiTSteps    );
 380     fprintf(stderr, "type        = %u\n", this->uiType      );
 381     fprintf(stderr, "swx         = %f\n", this->rSWx        );
 382     fprintf(stderr, "swy         = %f\n", this->rSWy        );
 383     fprintf(stderr, "nwx         = %f\n", this->rNWx        );
 384     fprintf(stderr, "nwy         = %f\n", this->rNWy        );
 385     fprintf(stderr, "nex         = %f\n", this->rNEx        );
 386     fprintf(stderr, "ney         = %f\n", this->rNEy        );
 387     fprintf(stderr, "sex         = %f\n", this->rSEx        );
 388     fprintf(stderr, "sey         = %f\n", this->rSEy        );
 389     fprintf(stderr, "h0          = %f\n", this->rDh         );
 390     fprintf(stderr, "dh          = %f\n", this->rDh         );
 391     fprintf(stderr, "t0          = %f\n", this->rT0         );
 392     fprintf(stderr, "dt          = %f\n", this->rDt         );
 393     fprintf(stderr, "scaling     = %f\n", this->rScaling    );
 394     fprintf(stderr, "bias        = %f\n", this->rBias       );
 395     fprintf(stderr, "extformat   = %u\n", this->uiExtFormat );
 396     fprintf(stderr, "implformat  = %u\n", this->uiImplFormat);
 397     fprintf(stderr, "LLWGS84_swx = %f\n", this->LLWGS84_rSWx);
 398     fprintf(stderr, "LLWGS84_swy = %f\n", this->LLWGS84_rSWy);
 399     fprintf(stderr, "LLWGS84_nwx = %f\n", this->LLWGS84_rNWx);
 400     fprintf(stderr, "LLWGS84_nwy = %f\n", this->LLWGS84_rNWy);
 401     fprintf(stderr, "LLWGS84_nex = %f\n", this->LLWGS84_rNEx);
 402     fprintf(stderr, "LLWGS84_ney = %f\n", this->LLWGS84_rNEy);
 403     fprintf(stderr, "LLWGS84_sex = %f\n", this->LLWGS84_rSEx);
 404     fprintf(stderr, "LLWGS84_sey = %f\n", this->LLWGS84_rSEy);
 405     fprintf(stderr, "bytes       = %u\n", this->uiBytes     );
 406 }
 407
 408 DBBlockAccessor::~DBBlockAccessor(void)
 409 {
 410 }
 411
 412 bool DBBlockAccessor::isOpen(void)
 413 {
 414     return false;
 415 }
 416
 417
 418 DBBlockAccessor::DBBlockAccessor(void) :
 419     Inherited()
 420 {
 421 }
 422
 423 void DBBlockAccessor::open(const Char8 *szFilename)
 424 {
 425 #ifdef OSG_WITH_GDALX
 426     _pDataset = (GDALDataset *) GDALOpen(szFilename, GA_ReadOnly);
 427
 428     if(_pDataset != NULL)
 429     {
 430         _pGeoRef = GeoReferenceAttachment::create();
 431
 432         double adfGeoTransform[6];
 433
 434         if(_pDataset->GetGeoTransform(adfGeoTransform) == CE_None)
 435         {
 436             _pGeoRef->editOrigin().setValues(adfGeoTransform[0],
 437                                              adfGeoTransform[3]);
 438
 439             _pGeoRef->editPixelSize().setValues(adfGeoTransform[1],
 440                                                 adfGeoTransform[5]);
 441
 442             if(GDALGetProjectionRef(_pDataset) != NULL)
 443             {
 444                 OGRSpatialReferenceH  hSRS;
 445
 446                 Char8 *szProjection = (char *) GDALGetProjectionRef(_pDataset);
 447
 448                 hSRS = OSRNewSpatialReference(NULL);
 449
 450                 if(OSRImportFromWkt(hSRS, &szProjection) == CE_None)
 451                 {
 452                     _pGeoRef->editEllipsoidAxis().setValues(
 453                         OSRGetSemiMajor(hSRS, NULL),
 454                         OSRGetSemiMinor(hSRS, NULL));
 455
 456                     const Char8 *szDatum = OSRGetAttrValue(hSRS, "DATUM", 0);
 457
 458                     if(szDatum != NULL && 0 == strcmp(szDatum, "WGS_1984"))
 459                     {
 460                         _pGeoRef->editDatum() =
 461                             GeoReferenceAttachment::WGS84;
 462                     }
 463                     else
 464                     {
 465                         fprintf(stderr, "Unknow datum %s\n",
 466                                 szDatum);
 467
 468                         _pGeoRef->editDatum() =
 469                             GeoReferenceAttachment::UnknownDatum;
 470                     }
 471                 }
 472
 473                 OSRDestroySpatialReference(hSRS);
 474             }
 475         }
 476
 477         int             nBlockXSize, nBlockYSize;
 478         int             bGotMin, bGotMax;
 479         double          adfMinMax[2];
 480
 481         _pBand = _pDataset->GetRasterBand(1);
 482
 483         _pBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
 484
 485         adfMinMax[0] = _pBand->GetMinimum(&bGotMin);
 486         adfMinMax[1] = _pBand->GetMaximum(&bGotMax);
 487
 488         if(!(bGotMin && bGotMax))
 489         {
 490             GDALComputeRasterMinMax((GDALRasterBandH) _pBand, TRUE, adfMinMax);
 491         }
 492
 493         if(_pBand != NULL)
 494         {
 495             _eImgFormat = Image::OSG_INVALID_PF;
 496
 497             switch(_pDataset->GetRasterCount())
 498             {
 499                 case 1:
 500                     _eImgFormat = Image::OSG_L_PF;
 501                     break;
 502                 case 2:
 503                     _eImgFormat = Image::OSG_LA_PF;
 504                     break;
 505                 case 3:
 506                     _eImgFormat = Image::OSG_RGB_PF;
 507                     break;
 508                 case 4:
 509                     _eImgFormat = Image::OSG_RGBA_PF;
 510                     break;
 511             }
 512
 513             _eImgType = Image::OSG_INVALID_IMAGEDATATYPE;
 514
 515             switch(_pBand->GetRasterDataType())
 516             {
 517                 case GDT_Byte:
 518                     _eImgType = Image::OSG_UINT8_IMAGEDATA;
 519                     break;
 520
 521                 case GDT_UInt16:
 522                     _eImgType = Image::OSG_UINT16_IMAGEDATA;
 523                     break;
 524
 525                 case GDT_Int16:
 526                     _eImgType = Image::OSG_INT16_IMAGEDATA;
 527                     break;
 528
 529                 case GDT_UInt32:
 530                     _eImgType = Image::OSG_UINT32_IMAGEDATA;
 531                     break;
 532
 533                 case GDT_Int32:
 534                     _eImgType = Image::OSG_INT32_IMAGEDATA;
 535                     break;
 536
 537                 case GDT_Float32:
 538                     _eImgType = Image::OSG_FLOAT32_IMAGEDATA;
 539                     break;
 540
 541                 case GDT_Float64:
 542                 case GDT_CInt16:
 543                 case GDT_CInt32:
 544                 case GDT_CFloat32:
 545                 case GDT_CFloat64:
 546                 default:
 547                     GDALClose(_pDataset);
 548                     _pDataset = NULL;
 549                     break;
 550
 551             }
 552
 553             _vSize[0] = _pDataset->GetRasterXSize();
 554             _vSize[1] = _pDataset->GetRasterYSize();
 555
 556             _fNoDataValue = _pBand->GetNoDataValue();
 557
 558             _pGeoRef->setNoDataValue(_fNoDataValue);
 559         }
 560     }
 561 #endif
 562 }
 563
 564  bool DBBlockAccessor::readBlockA16(Vec2i   vSampleOrigin,
 565                                     Int32   iTextureSize,
 566                                     UInt16 *pTarget,
 567                                     Int32   iTargetSizeBytes)
 568 {
 569 #ifdef OSG_WITH_GDALX
 570     OSG_ASSERT(false);
 571
 572     UInt32 destIdx = 0;
 573
 574     UInt8 *pDst = (UInt8 *) pTarget;
 575
 576     Int32 xMin = vSampleOrigin.x();
 577     Int32 xMax = vSampleOrigin.x() + iTextureSize;
 578
 579     Int32 yMin = vSampleOrigin.y();
 580     Int32 yMax = vSampleOrigin.y() + iTextureSize;
 581
 582     for(UInt32 y = yMin; y < yMax; y++)
 583     {
 584         for(UInt32 x = xMin; x < xMax; x++)
 585         {
 586             for(UInt32 i = 0; i < 2; i++)
 587             {
 588                 pDst[destIdx] = 0;
 589
 590                 destIdx++;
 591             }
 592         }
 593
 594         destIdx += (iTextureSize - (xMax - xMin)) * 2;
 595     }
 596 #endif
 597
 598     return false;
 599 }
 600
 601 bool DBBlockAccessor::readBlockA16(Vec2i   vSampleOrigin,
 602                                    Int32   iTextureSize,
 603                                    Int16  *pTarget,
 604                                    Int32   iTargetSizeBytes)
 605 {
 606 #ifdef OSG_WITH_GDALX
 607     Int32 xMin = vSampleOrigin.x();
 608     Int32 xMax = vSampleOrigin.x() + iTextureSize;
 609
 610     Int32 yMin = vSampleOrigin.y();
 611     Int32 yMax = vSampleOrigin.y() + iTextureSize;
 612
 613     if(xMax > _vSize[0] || yMax > _vSize[1])
 614     {
 615         UInt32 destIdx = 0;
 616         UInt32 srcIdx  = 0;
 617
 618         _vI16Buffer.resize(iTextureSize * iTextureSize);
 619
 620         Int32 iSampleX = osgMin(_vSize[0] - vSampleOrigin.x(), iTextureSize);
 621         Int32 iSampleY = osgMin(_vSize[1] - vSampleOrigin.y(), iTextureSize);
 622
 623         _pBand->RasterIO(GF_Read,
 624                          vSampleOrigin.x(),
 625                          vSampleOrigin.y(),
 626                          iSampleX,
 627                          iSampleY,
 628                          &(_vI16Buffer[0]),
 629                          iSampleX,
 630                          iSampleY,
 631                          GDT_Int16,
 632                          0,
 633                          0);
 634
 635
 636         for(UInt32 y = yMin; y < yMax; y++)
 637         {
 638             for(UInt32 x = xMin; x < xMax; x++)
 639             {
 640                 if(x >= _vSize[0] || y >= _vSize[1])
 641                 {
 642                     pTarget[destIdx] = Int16(_fNoDataValue);
 643                 }
 644                 else
 645                 {
 646                     pTarget[destIdx] = _vI16Buffer[srcIdx];
 647
 648                     srcIdx++;
 649                 }
 650
 651                 destIdx++;
 652             }
 653         }
 654     }
 655     else
 656     {
 657         _pBand->RasterIO(GF_Read,
 658                          vSampleOrigin.x(),
 659                          vSampleOrigin.y(),
 660                          iTextureSize,
 661                          iTextureSize,
 662                          pTarget,
 663                          iTextureSize,
 664                          iTextureSize,
 665                          GDT_Int16,
 666                          0,
 667                          0);
 668     }
 669 #endif
 670
 671     return true;
 672 }
 673
 674
 675 /*! \class GDALImageFileType
 676
 677   Image File Type to read/write and store/restore Image objects as
 678   GDAL (tif/tiff suffix) data.
 679
 680   To be able to load TIFF images you need the IJG TIFF library,
 681   (check the Prerequisites page on www.opensg.org).
 682   The lib comes with all Linux distributions.
 683
 684   You have to --enable-tif in the configure line to enable
 685   the singleton object.
 686
 687  */
 688
 689 DBImageFileType DBImageFileType:: _the("image/db",
 690                                        suffixArray,
 691                                        sizeof(suffixArray),
 692                                        (OSG_READ_SUPPORTED));
 693
 694
 695 //-------------------------------------------------------------------------
 696 /*! Tries to fill the image object with the data read from
 697     the given fileName. Returns true on success.
 698  */
 699
 700
 701 bool DBImageFileType::read(      Image       *pImage,
 702                            const Char8       *fileName)
 703 {
 704     bool returnValue = false;
 705
 706     FILE *pIn = fopen(fileName, "rb");
 707
 708     if(pIn != NULL)
 709     {
 710         fprintf(stderr, "db::open %p\n", pIn);
 711
 712         DBHeader oHeader;
 713
 714         returnValue = oHeader.read(pIn);
 715
 716         if(returnValue == false)
 717         {
 718             fclose(pIn);
 719
 720             return returnValue;
 721         }
 722
 723 //        oHeader.dump();
 724
 725         if(oHeader.uiExtFormat != 0)
 726         {
 727             fprintf(stderr, "ext == 0 only support");
 728
 729             returnValue = false;
 730
 731             fclose(pIn);
 732
 733             return returnValue;
 734         }
 735
 736         Image::PixelFormat imagePf   = Image::OSG_RGBA_PF;
 737         Image::Type        imageType = Image::OSG_UINT8_IMAGEDATA;
 738
 739         switch(oHeader.uiType)
 740         {
 741             case 0:
 742                 imagePf   = Image::OSG_L_PF;
 743                 imageType = Image::OSG_UINT8_IMAGEDATA;
 744                 break;
 745             case 1:
 746                 imagePf   = Image::OSG_L_PF;
 747                 imageType = Image::OSG_INT16_IMAGEDATA;
 748                 break;
 749             case 2:
 750                 imagePf   = Image::OSG_L_PF;
 751                 imageType = Image::OSG_FLOAT32_IMAGEDATA;
 752                 break;
 753             case 3:
 754                 imagePf   = Image::OSG_RGB_PF;
 755                 imageType = Image::OSG_UINT8_IMAGEDATA;
 756                 break;
 757             case 4:
 758                 imagePf   = Image::OSG_RGBA_PF;
 759                 imageType = Image::OSG_UINT8_IMAGEDATA;
 760                 break;
 761             case 5:
 762                 imagePf   = Image::OSG_RGB_DXT1;
 763                 imageType = Image::OSG_UINT8_IMAGEDATA;
 764                 break;
 765             case 6:
 766                 imagePf   = Image::OSG_RGBA_DXT1;
 767                 imageType = Image::OSG_UINT8_IMAGEDATA;
 768                 break;
 769             default:
 770                 break;
 771         };
 772
 773         pImage->set(imagePf,
 774                     oHeader.uiXSize,
 775                     oHeader.uiYSize,
 776                     oHeader.uiZSize,
 777                     1,
 778                     1,
 779                     0.0,
 780                     NULL,
 781                     imageType,
 782                     true,
 783                     1);
 784
 785         if(pImage->getSize() == oHeader.uiBytes)
 786         {
 787             fread(pImage->editData(),
 788                   sizeof(UInt8),
 789                   oHeader.uiBytes,
 790                   pIn);
 791
 792 #if BYTE_ORDER == LITTLE_ENDIAN
 793             switch(oHeader.uiType)
 794             {
 795                 case 1:
 796                     swapAndConvertImageByteOrder<
 797                          Int16,
 798                         &clampMin<Int16, -100, 0> >(pImage);
 799                     break;
 800                 case 2:
 801                     swapImageByteOrder<Real32>(pImage);
 802                     break;
 803                 default:
 804                     break;
 805             };
 806 #endif
 807
 808             if(oHeader.uiXSize != 0 && oHeader.uiYSize != 0)
 809             {
 810                 if(oHeader.LLWGS84_rSWx != 0.f &&
 811                    oHeader.LLWGS84_rSWy != 0.f &&
 812                    oHeader.LLWGS84_rNWx != 0.f &&
 813                    oHeader.LLWGS84_rNWy != 0.f &&
 814                    oHeader.LLWGS84_rNEx != 0.f &&
 815                    oHeader.LLWGS84_rNEy != 0.f &&
 816                    oHeader.LLWGS84_rSEx != 0.f &&
 817                    oHeader.LLWGS84_rSEy != 0.f  )
 818                 {
 819                     GeoReferenceAttachmentUnrecPtr pGeoRef =
 820                         GeoReferenceAttachment::create();
 821
 822                     pGeoRef->setupWGS84Datum();
 823
 824                     pGeoRef->editOrigin().setValues(oHeader.LLWGS84_rNWx,
 825                                                     oHeader.LLWGS84_rNWy);
 826
 827                     pGeoRef->editPixelSize().setValues(
 828                         (oHeader.LLWGS84_rSEx -
 829                          oHeader.LLWGS84_rNWx) / oHeader.uiXSize,
 830                         (oHeader.LLWGS84_rSEy -
 831                          oHeader.LLWGS84_rNWy) / oHeader.uiYSize);
 832
 833                     pImage->addAttachment(pGeoRef);
 834                 }
 835                 else if(oHeader.rSWx != 0.f &&
 836                         oHeader.rSWy != 0.f &&
 837                         oHeader.rNWx != 0.f &&
 838                         oHeader.rNWy != 0.f &&
 839                         oHeader.rNEx != 0.f &&
 840                         oHeader.rNEy != 0.f &&
 841                         oHeader.rSEx != 0.f &&
 842                         oHeader.rSEy != 0.f  )
 843                 {
 844                     GeoReferenceAttachmentUnrecPtr pGeoRef =
 845                         GeoReferenceAttachment::create();
 846
 847                     pGeoRef->setupWGS84Datum();
 848
 849                     pGeoRef->editOrigin().setValues(oHeader.rNWx,
 850                                                     oHeader.rNWy);
 851
 852                     pGeoRef->editPixelSize().setValues(
 853                         (oHeader.rSEx - oHeader.rNWx) / oHeader.uiXSize,
 854                         (oHeader.rSEy - oHeader.rNWy) / oHeader.uiYSize);
 855
 856                     pImage->addAttachment(pGeoRef);
 857                 }
 858             }
 859         }
 860         else
 861         {
 862             fprintf(stderr, "size mismatch %" PRISize " %d\n",
 863                     pImage->getSize(),
 864                     oHeader.uiBytes);
 865
 866             returnValue = false;
 867         }
 868
 869         fclose(pIn);
 870     }
 871
 872     return returnValue;
 873
 874 #ifdef OSG_WITH_GDALX
 875
 876     GDALDataset *pDataset;
 877
 878     pDataset = (GDALDataset *) GDALOpen(fileName, GA_ReadOnly);
 879
 880     if(pDataset != NULL)
 881     {
 882         GeoReferenceAttachmentPtr pGeoRef = GeoReferenceAttachment::create();
 883
 884         pImage->addAttachment(pGeoRef);
 885
 886         double        adfGeoTransform[6];
 887
 888         if(pDataset->GetGeoTransform(adfGeoTransform) == CE_None)
 889         {
 890             pGeoRef->editOrigin().setValues(adfGeoTransform[0],
 891                                             adfGeoTransform[3]);
 892
 893             pGeoRef->editPixelSize().setValues(adfGeoTransform[1],
 894                                                adfGeoTransform[5]);
 895
 896             if(GDALGetProjectionRef(pDataset) != NULL)
 897             {
 898                 OGRSpatialReferenceH  hSRS;
 899
 900                 Char8 *szProjection = (char *) GDALGetProjectionRef(pDataset);
 901
 902                 hSRS = OSRNewSpatialReference(NULL);
 903
 904                 if(OSRImportFromWkt(hSRS, &szProjection) == CE_None)
 905                 {
 906                     pGeoRef->editEllipsoidAxis().setValues(
 907                         OSRGetSemiMajor(hSRS, NULL),
 908                         OSRGetSemiMinor(hSRS, NULL));
 909
 910                     const Char8 *szDatum = OSRGetAttrValue(hSRS, "DATUM", 0);
 911
 912                     if(szDatum != NULL && 0 == strcmp(szDatum, "WGS_1984"))
 913                     {
 914                         pGeoRef->editDatum() =
 915                             GeoReferenceAttachment::WGS84;
 916                     }
 917                     else
 918                     {
 919                         fprintf(stderr, "Unknow datum %s\n",
 920                                 szDatum);
 921
 922                         pGeoRef->editDatum() =
 923                             GeoReferenceAttachment::UnknownDatum;
 924                     }
 925                 }
 926
 927                 OSRDestroySpatialReference(hSRS);
 928             }
 929         }
 930
 931         GDALRasterBand *pBand;
 932         int             nBlockXSize, nBlockYSize;
 933         int             bGotMin, bGotMax;
 934         double          adfMinMax[2];
 935
 936         pBand = pDataset->GetRasterBand( 1 );
 937         pBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
 938
 939         adfMinMax[0] = pBand->GetMinimum( &bGotMin );
 940         adfMinMax[1] = pBand->GetMaximum( &bGotMax );
 941
 942         if(!(bGotMin && bGotMax))
 943             GDALComputeRasterMinMax((GDALRasterBandH) pBand, TRUE, adfMinMax);
 944
 945         pBand = pDataset->GetRasterBand(1);
 946
 947         if(pBand != NULL)
 948         {
 949             Image::PixelFormat ePF = Image::OSG_INVALID_PF;
 950
 951             switch(pDataset->GetRasterCount())
 952             {
 953                 case 1:
 954                     ePF = Image::OSG_L_PF;
 955                     break;
 956                 case 2:
 957                     ePF = Image::OSG_LA_PF;
 958                     break;
 959                 case 3:
 960                     ePF = Image::OSG_RGB_PF;
 961                     break;
 962                 case 4:
 963                     ePF = Image::OSG_RGBA_PF;
 964                     break;
 965             }
 966
 967             Image::Type eDT = Image::OSG_INVALID_IMAGEDATATYPE;
 968
 969             switch(pBand->GetRasterDataType())
 970             {
 971                 case GDT_Byte:
 972                     eDT = Image::OSG_UINT8_IMAGEDATA;
 973                     break;
 974
 975                 case GDT_UInt16:
 976                     eDT = Image::OSG_UINT16_IMAGEDATA;
 977                     break;
 978
 979                 case GDT_Int16:
 980                     eDT = Image::OSG_INT16_IMAGEDATA;
 981                     break;
 982
 983                 case GDT_UInt32:
 984                     eDT = Image::OSG_UINT32_IMAGEDATA;
 985                     break;
 986
 987                 case GDT_Int32:
 988                     eDT = Image::OSG_INT32_IMAGEDATA;
 989                     break;
 990
 991                 case GDT_Float32:
 992                     eDT = Image::OSG_FLOAT32_IMAGEDATA;
 993                     break;
 994
 995                 case GDT_Float64:
 996                 case GDT_CInt16:
 997                 case GDT_CInt32:
 998                 case GDT_CFloat32:
 999                 case GDT_CFloat64:
1000                 default:
1001                     GDALClose(pDataset);
1002                     return returnValue;
1003                     break;
1004
1005             }
1006
1007             pImage->set(ePF,
1008                         pDataset->GetRasterXSize(),
1009                         pDataset->GetRasterYSize(),
1010                         1,
1011                         1,
1012                         1,
1013                         0.0,
1014                         NULL,
1015                         eDT);
1016
1017             UChar8 *dst = pImage->editData();
1018
1019             pBand->RasterIO(GF_Read,
1020                             0,
1021                             0,
1022                             pDataset->GetRasterXSize(),
1023                             pDataset->GetRasterYSize(),
1024                             dst,
1025                             pDataset->GetRasterXSize(),
1026                             pDataset->GetRasterYSize(),
1027                             pBand->GetRasterDataType(),
1028                             0,
1029                             0);
1030
1031             pGeoRef->setNoDataValue(pBand->GetNoDataValue());
1032
1033             returnValue = true;
1034         }
1035
1036         GDALClose(pDataset);
1037     }
1038
1039     return returnValue;
1040 #endif // OSG_WITH_GDAL
1041 }
1042
1043 //-------------------------------------------------------------------------
1044 /*! Tries to write the image object to the given output stream.
1045     Returns true on success.
1046 */
1047
1048 bool DBImageFileType::write(const Image            *OSG_DB_ARG(pImage),
1049                             const Char8            *OSG_DB_ARG(fileName))
1050 {
1051     bool                retCode = false;
1052
1053 #ifdef OSG_WITH_GDALX
1054     if(pImage->getDimension() < 1 || pImage->getDimension() > 2)
1055     {
1056         FWARNING(("TIFImageFileType::write: invalid dimension %d!\n",
1057             pImage->getDimension()));
1058
1059         return false;
1060     }
1061
1062     TIFF         *out = TIFFClientOpen("dummy", "wm", (thandle_t)&os,
1063                                        osReadProc,
1064                                        osWriteProc,
1065                                        osSeekProc,
1066                                        closeProc,
1067                                                    osSizeProc,
1068                                        mapFileProc,
1069                                        unmapFileProc);
1070
1071     int           lineSize = pImage->getWidth() * pImage->getBpp();
1072     int           photometric = 0;
1073     int           samplesPerPixel = 0;
1074     const UChar8 *data;
1075     int           row;
1076
1077     // TODO: implement all cases correct
1078     switch(pImage->getBpp())
1079     {
1080         case 1:
1081             samplesPerPixel = 1;
1082             photometric = PHOTOMETRIC_MINISBLACK;
1083             break;
1084         case 2:
1085             samplesPerPixel = 2;
1086             photometric = PHOTOMETRIC_MINISBLACK;
1087             break;
1088         case 3:
1089             samplesPerPixel = 3;
1090             photometric = PHOTOMETRIC_RGB;
1091             break;
1092         case 4:
1093             samplesPerPixel = 4;
1094             photometric = PHOTOMETRIC_RGB;
1095             break;
1096     }
1097
1098     if(out)
1099     {
1100         TIFFSetField(out, TIFFTAG_IMAGEWIDTH, pImage->getWidth());
1101         TIFFSetField(out, TIFFTAG_IMAGELENGTH, pImage->getHeight());
1102         TIFFSetField(out, TIFFTAG_XRESOLUTION, pImage->getResX());
1103         TIFFSetField(out, TIFFTAG_YRESOLUTION, pImage->getResY());
1104         TIFFSetField(out, TIFFTAG_RESOLUTIONUNIT, pImage->getResUnit());
1105         TIFFSetField(out, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
1106         TIFFSetField(out, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel);
1107         TIFFSetField(out, TIFFTAG_BITSPERSAMPLE, 8);
1108         TIFFSetField(out, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
1109         TIFFSetField(out, TIFFTAG_PHOTOMETRIC, photometric);
1110
1111         if(_options.find("compressionType=LZW") != std::string::npos)
1112         {
1113             TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
1114         }
1115         else
1116         {
1117             TIFFSetField(out, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
1118         }
1119
1120         TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(out, 0));
1121
1122         for(row = 0; row < pImage->getHeight(); row++)
1123         {
1124             data =
1125                 pImage->getData() +
1126                 ((pImage->getHeight() - row - 1) * lineSize);
1127
1128             if(TIFFWriteScanline(out,
1129                                  (tdata_t) const_cast<UChar8 *>(data),
1130                                  row,
1131                                  0) < 0)
1132             {
1133                 break;
1134             }
1135         }
1136
1137         TIFFClose(out);
1138
1139         retCode = true;
1140     }
1141
1142 #else
1143     SWARNING << getMimeType()
1144              << " write is not compiled into the current binary "
1145              << std::endl;
1146 #endif
1147
1148     return retCode;
1149 }
1150
1151 bool DBImageFileType::validateHeader(const Char8 *fileName, bool &implemented)
1152 {
1153     implemented = true;
1154
1155     return true;
1156 }
1157
1158 #if 1
1159 ImageBlockAccessorPtr DBImageFileType::open(const Char8 *fileName)
1160 {
1161     DBBlockAccessorPtr returnValue(new DBBlockAccessor);
1162
1163     returnValue->open(fileName);
1164
1165     return returnValue;
1166 }
1167 #endif
1168
1169 //-------------------------------------------------------------------------
1170 /*! Constructor used for the singleton object
1171  */
1172
1173 DBImageFileType::DBImageFileType(const Char8  *mimeType,
1174                                  const Char8  *suffixArray[],
1175                                        UInt16  suffixByteCount,
1176                                        UInt32  flags) :
1177     Inherited(mimeType,
1178               suffixArray,
1179               suffixByteCount,
1180               flags          )
1181 {
1182 }
1183
1184 //-------------------------------------------------------------------------
1185 /*! Destructor
1186  */
1187
1188 DBImageFileType::~DBImageFileType(void)
1189 {
1190 }
1191
1192 OSG_END_NAMESPACE