PageRenderTime 71ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 1ms

/Source/System/Image/ES/OSGImage.cpp

https://github.com/msteners/OpenSGDevMaster_Toolbox
C++ | 4050 lines | 3342 code | 471 blank | 237 comment | 463 complexity | 965cbb2329f2e89da24bf671cb61cfe6 MD5 | raw file
Possible License(s): LGPL-2.0, BSD-3-Clause 
    

  1. /*---------------------------------------------------------------------------*\
    2. 

  2.  *                                OpenSG                                     *
    3. 

  3.  *                                                                           *
    4. 

  4.  *                                                                           *
    5. 

  5.  *               Copyright (C) 2000-2002 by the OpenSG Forum                 *
    6. 

  6.  *                                                                           *
    7. 

  7.  *                            www.opensg.org                                 *
    8. 

  8.  *                                                                           *
    9. 

  9.  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
    10. 

  10.  *                                                                           *
    11. 

  11. \*---------------------------------------------------------------------------*/
    12. 

  12. /*---------------------------------------------------------------------------*\
    13. 

  13.  *                                License                                    *
    14. 

  14.  *                                                                           *
    15. 

  15.  * This library is free software; you can redistribute it and/or modify it   *
    16. 

  16.  * under the terms of the GNU Library General Public License as published    *
    17. 

  17.  * by the Free Software Foundation, version 2.                               *
    18. 

  18.  *                                                                           *
    19. 

  19.  * This library is distributed in the hope that it will be useful, but       *
    20. 

  20.  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
    21. 

  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
    22. 

  22.  * Library General Public License for more details.                          *
    23. 

  23.  *                                                                           *
    24. 

  24.  * You should have received a copy of the GNU Library General Public         *
    25. 

  25.  * License along with this library; if not, write to the Free Software       *
    26. 

  26.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
    27. 

  27.  *                                                                           *
    28. 

  28. \*---------------------------------------------------------------------------*/
    29. 

  29. /*---------------------------------------------------------------------------*\
    30. 

  30.  *                                Changes                                    *
    31. 

  31.  *                                                                           *
    32. 

  32.  *                                                                           *
    33. 

  33.  *                                                                           *
    34. 

  34.  *                                                                           *
    35. 

  35.  *                                                                           *
    36. 

  36.  *                                                                           *
    37. 

  37. \*---------------------------------------------------------------------------*/
    38. 

  38. 

  39. //---------------------------------------------------------------------------
    40. 

  40. //  Includes
    41. 

  41. //---------------------------------------------------------------------------
    42. 

  42. 

  43. #define OSG_COMPILEIMAGE
    44. 

  44. 

  45. #include <cstdlib>
    46. 

  46. #include <cstdio>
    47. 

  47. 

  48. #include <algorithm>
    49. 

  49. 

  50. #include "OSGConfig.h"
    51. 

  51. #include "OSGLog.h"
    52. 

  52. #include "OSGImageGenericAtt.h"
    53. 

  53. #include "OSGFieldContainerFields.h"
    54. 

  54. #include "OSGFileSystem.h"
    55. 

  55. //#include "OSGImageFileHandler.h"
    56. 

  56. 

  57. /*
    58. 

  58. #include "OSGPathHandler.h"
    59. 

  59. #include "OSGSceneFileHandler.h"
    60. 

  60.  */
    61. 

  61. 

  62. #include "OSGImage.h"
    63. 

  63. 

  64. OSG_USING_NAMESPACE
    65. 

  65. 

  66. // Documentation for this class is emited in the
    67. 

  67. // OSGImageBase.cpp file.
    68. 

  68. // To modify it, please change the .fcd file (OSGImage.fcd) and
    69. 

  69. // regenerate the base file.
    70. 

  70. 

  71. /*------------------------------------------------------------------------*/
    72. 

  72. /*                              static member                             */
    73. 

  73. 

  74. /*! Static dictionary to map pixelData values to the bytes per pixel 
    75. 

  75.   (bpp) value.
    76. 

  76.   Internaly used in the createData() method.
    77. 

  77.  */
    78. 

  78. 

  79. Int32 Image::_formatDic[][2] =
    80. 

  80. {
    81. 

  81.     { OSG_A_PF,      1 },
    82. 

  82. #if !defined(OSG_EMBEDDED) || OSG_GL_ES_VERSION > 100
    83. 

  83.     { OSG_I_PF,      1 },
    84. 

  84. #endif
    85. 

  85.     { OSG_L_PF,      1 },
    86. 

  86.     { OSG_LA_PF,     2 },
    87. 

  87.     { OSG_RGB_PF,    3 },
    88. 

  88.     { OSG_RGBA_PF,   4 },
    89. 

  89.     { OSG_BGR_PF,    3 },
    90. 

  90.     { OSG_BGRA_PF,   4 },
    91. 

  91.     { OSG_RGB_DXT1,  3 },
    92. 

  92.     { OSG_RGBA_DXT1, 4 },
    93. 

  93.     { OSG_RGBA_DXT3, 4 },
    94. 

  94.     { OSG_RGBA_DXT5, 4 }
    95. 

  95. };
    96. 

  96. 

  97. Int32 Image::_typeDic[][2] =
    98. 

  98. {
    99. 

  99.     { OSG_INVALID_IMAGEDATATYPE, 0 },
    100. 

  100.     { OSG_UINT8_IMAGEDATA,       1 },
    101. 

  101. #if defined(GL_UNSIGNED_SHORT)
    102. 

  102.     { OSG_UINT16_IMAGEDATA,      2 },
    103. 

  103. #endif
    104. 

  104. #if !defined(OSG_EMBEDDED)
    105. 

  105.     { OSG_UINT32_IMAGEDATA,      4 },
    106. 

  106.     { OSG_FLOAT16_IMAGEDATA,     2 },
    107. 

  107. #endif
    108. 

  108.     { OSG_FLOAT32_IMAGEDATA,     4 }
    109. 

  109. };
    110. 

  110. 

  111. /*----------------------------- class specific ----------------------------*/
    112. 

  112. 

  113. void Image::initMethod(InitPhase ePhase)
    114. 

  114. {
    115. 

  115. }
    116. 

  116. 

  117. /*! Inform parents, when image was changed
    118. 

  118.  */
    119. 

  119. 

  120. void Image::changed(ConstFieldMaskArg whichField, 
    121. 

  121.                     UInt32            origin,
    122. 

  122.                     BitVector         details)
    123. 

  123. {
    124. 

  124.     MFParentFieldContainerPtr::iterator parentsIt  = _mfParents.begin();
    125. 

  125.     MFParentFieldContainerPtr::iterator parentsEnd = _mfParents.end();
    126. 

  126. 

  127.     while(parentsIt != parentsEnd)
    128. 

  128.     {
    129. 

  129.         (*parentsIt)->changed(
    130. 

  130.             TypeTraits<BitVector>::One << parentsIt->getParentFieldPos(),
    131. 

  131.             ChangedOrigin::Child,
    132. 

  132.             whichField);
    133. 

  133. 

  134.         ++parentsIt;
    135. 

  135.     }
    136. 

  136. 

  137.     if(0x0000 != (whichField & DataTypeFieldMask))
    138. 

  138.     {
    139. 

  139.         // Update internals
    140. 

  140.         Int32 mapSizeType = sizeof(_typeDic) / sizeof(UInt32[2]);
    141. 

  141.         UInt32 typeFormat  = 0;
    142. 

  142.         Int32 i;
    143. 

  143.         
    144. 

  144.         for(i = 0; i < mapSizeType; i++)
    145. 

  145.         {
    146. 

  146.             if(_typeDic[i][0] == _sfDataType.getValue())
    147. 

  147.             {
    148. 

  148.                 typeFormat = _typeDic[i][1];
    149. 

  149.             }
    150. 

  150.         }
    151. 

  151.         
    152. 

  152.         setComponentSize( typeFormat );
    153. 

  153.     }
    154. 

  154. 

  155.     if(0x0000 != (whichField & (MipMapCountFieldMask |
    156. 

  156.                                 WidthFieldMask       |
    157. 

  157.                                 HeightFieldMask      |
    158. 

  158.                                 DepthFieldMask       |
    159. 

  159.                                 PixelFormatFieldMask )))
    160. 

  160.     {
    161. 

  161.         setSideSize(calcMipmapSumSize(_sfMipMapCount.getValue()));
    162. 

  162.     }
    163. 

  163. 

  164.     if(0x0000 != (whichField & (SideSizeFieldMask | SideCountFieldMask)))
    165. 

  165.     {
    166. 

  166.         setFrameSize(_sfSideSize.getValue() * _sfSideCount.getValue());
    167. 

  167.     }
    168. 

  168. 

  169.     Inherited::changed(whichField, origin, details);
    170. 

  170. }
    171. 

  171. 

  172. /*----------------------------- output ------------------------------------*/
    173. 

  173. 

  174. void Image::dump(      UInt32    ,
    175. 

  175.                  const BitVector ) const
    176. 

  176. {
    177. 

  177.     const Char8  *pfStr   = "UNDEF_PIXEL_FORMAT";
    178. 

  178.     const Char8  *typeStr = "INVALID_IMAGEDATA_TYPE";
    179. 

  179. 

  180.     switch(getPixelFormat())
    181. 

  181.     {
    182. 

  182.         case OSG_A_PF:
    183. 

  183.             pfStr = "ALPHA";
    184. 

  184.             break;
    185. 

  185. #if !defined(OSG_EMBEDDED)
    186. 

  186.         case OSG_I_PF:
    187. 

  187.             pfStr = "INTENSITY";
    188. 

  188.             break;
    189. 

  189. #endif
    190. 

  190.         case OSG_L_PF:
    191. 

  191.             pfStr = "LUMINANCE";
    192. 

  192.             break;
    193. 

  193.         case OSG_LA_PF:
    194. 

  194.             pfStr = "LUMINANCE_ALPHA";
    195. 

  195.             break;
    196. 

  196. #if !defined(OSG_EMBEDDED)
    197. 

  197.         case OSG_BGR_PF:
    198. 

  198.             pfStr = "BGR";
    199. 

  199.             break;
    200. 

  200.         case OSG_BGRA_PF:
    201. 

  201.             pfStr = "BGRA";
    202. 

  202.             break;
    203. 

  203. #endif
    204. 

  204.         case OSG_RGB_PF:
    205. 

  205.             pfStr = "RGB";
    206. 

  206.             break;
    207. 

  207.         case OSG_RGBA_PF:
    208. 

  208.             pfStr = "RGBA";
    209. 

  209.             break;
    210. 

  210. #if !defined(OSG_EMBEDDED)
    211. 

  211.         case OSG_RGB_DXT1:
    212. 

  212.             pfStr = "RGB_DXT1";
    213. 

  213.             break;
    214. 

  214.         case OSG_RGBA_DXT1:
    215. 

  215.             pfStr = "RGBA_DXT1";
    216. 

  216.             break;
    217. 

  217.         case OSG_RGBA_DXT3:
    218. 

  218.             pfStr = "RGBA_DXT3";
    219. 

  219.             break;
    220. 

  220.         case OSG_RGBA_DXT5:
    221. 

  221.             pfStr = "RGBA_DXT5";
    222. 

  222.             break;
    223. 

  223. #endif
    224. 

  224.         default:
    225. 

  225.             pfStr = "UNKNOWN_PIXEL_FORMAT";
    226. 

  226.             break;
    227. 

  227.     };
    228. 

  228.     
    229. 

  229.     switch (getDataType())
    230. 

  230.     {
    231. 

  231.         case OSG_UINT8_IMAGEDATA:
    232. 

  232.             typeStr = "IMAGEDATA_TYPE UCHAR8";
    233. 

  233.             break;
    234. 

  234. #if defined(GL_UNSIGNED_SHORT)
    235. 

  235.         case OSG_UINT16_IMAGEDATA:
    236. 

  236.             typeStr = "IMAGEDATA_TYPE UCHAR16";
    237. 

  237.             break;
    238. 

  238. #endif
    239. 

  239. #if !defined(OSG_EMBEDDED)
    240. 

  240.         case OSG_UINT32_IMAGEDATA:
    241. 

  241.             typeStr = "IMAGEDATA_TYPE UCHAR32";
    242. 

  242.             break;
    243. 

  243.         case OSG_FLOAT16_IMAGEDATA:
    244. 

  244.             typeStr = "IMAGEDATA_TYPE FLOAT16";
    245. 

  245.             break;
    246. 

  246. #endif
    247. 

  247.         case OSG_FLOAT32_IMAGEDATA:
    248. 

  248.             typeStr = "IMAGEDATA_TYPE FLOAT32";
    249. 

  249.             break;
    250. 

  250.             
    251. 

  251.         default:
    252. 

  252.             typeStr = "UNKNOWN_IMAGEDATA_TYPE";
    253. 

  253.             break;
    254. 

  254.     };
    255. 

  255.     
    256. 

  256.     FLOG (("ImageDump: %s; %d/%d/%d; #mm: %d, side %d, #frame: %d, "
    257. 

  257.            "frameDelay %g, dataType %s, size: %d\n",
    258. 

  258.            pfStr, 
    259. 

  259.            getWidth(),
    260. 

  260.            getHeight(), 
    261. 

  261.            getDepth(),
    262. 

  262.            getMipMapCount(), 
    263. 

  263.            getSideCount(),
    264. 

  264.            getFrameCount(),
    265. 

  265.            getFrameDelay(), 
    266. 

  266.            typeStr,
    267. 

  267.            getSize()));
    268. 

  268. }
    269. 

  269. 

  270. // Return the number of components per pixel.
    271. 

  271. 

  272. UInt8  Image::getComponents(void) const
    273. 

  273. {
    274. 

  274.     Int32 mapSizeFormat = sizeof(_formatDic) / sizeof(UInt32[2]);
    275. 

  275. 

  276.     for(UInt16 i = 0; i < mapSizeFormat; i++)
    277. 

  277.     {
    278. 

  278.         if(_formatDic[i][0] == getPixelFormat())
    279. 

  279.             return _formatDic[i][1];
    280. 

  280.     }
    281. 

  281. 

  282.     FWARNING(("Image::getComponents: image %p has unknown pixel format 0x%x!",
    283. 

  283.                 this, getPixelFormat()));
    284. 

  284. 

  285.     return 0;
    286. 

  286. }
    287. 

  287. 

  288. /*------------------------------ set object data --------------------------*/
    289. 

  289. 

  290. /*! method to set the image data. Use the doCopy parameter to specify, whether
    291. 

  291.     the method should copy or link the pixel data.
    292. 

  292. */
    293. 

  293. bool Image::set(      UInt32  pF,
    294. 

  294.                       Int32   w, 
    295. 

  295.                       Int32   h,
    296. 

  296.                       Int32   d, 
    297. 

  297.                       Int32   mmS, 
    298. 

  298.                       Int32   fS,
    299. 

  299.                       Time    fD, 
    300. 

  300.                 const UChar8 *da, 
    301. 

  301.                       Int32   t, 
    302. 

  302.                       bool    allocMem,
    303. 

  303.                       Int32   sS)
    304. 

  304. {
    305. 

  305.     setPixelFormat(pF );
    306. 

  306. 

  307.     setWidth      (osgMax ( 1, w  ));
    308. 

  308.     setHeight     (osgMax ( 1, h  ));
    309. 

  309.     setDepth      (osgMax ( 1, d  ));
    310. 

  310. 

  311.     setMipMapCount(osgMax ( 1, mmS));
    312. 

  312.     setSideCount  (osgMax ( 1, sS ));
    313. 

  313.     setFrameCount (osgMax ( 1, fS ));
    314. 

  314. 

  315.     setFrameDelay (fD);
    316. 

  316. 

  317.     setDataType   (t );
    318. 

  318. 

  319.     return createData(da, allocMem);
    320. 

  320. }
    321. 

  321. 

  322. /*! method to set the image from another image object.
    323. 

  323.     Use the doCopy parameter to specify, whether
    324. 

  324.     the method should copy or link the pixel data.
    325. 

  325.  */
    326. 

  326. 

  327. bool Image::set(ImagePtr image)
    328. 

  328. {
    329. 

  329.     this->set(image->getPixelFormat(),
    330. 

  330.               image->getWidth      (),
    331. 

  331.               image->getHeight     (),
    332. 

  332.               image->getDepth      (),
    333. 

  333.               image->getMipMapCount(),
    334. 

  334.               image->getFrameCount (),
    335. 

  335.               image->getFrameDelay (),
    336. 

  336.               image->getData       (),
    337. 

  337.               image->getDataType   (),
    338. 

  338.               true,
    339. 

  339.               image->getSideCount  ());
    340. 

  340.     return true;
    341. 

  341. }
    342. 

  342. 

  343. /*! method to set only the image pixel data, all parameter (e. pixelFormat
    344. 

  344.     width,height and depth) stay the same
    345. 

  345.  */
    346. 

  346. 

  347. bool Image::setData(const UChar8 *da)
    348. 

  348. {
    349. 

  349.     if(da)
    350. 

  350.     {
    351. 

  351.         createData(da);
    352. 

  352.     }
    353. 

  353.     else
    354. 

  354.     {
    355. 

  355.         FWARNING(("Image::setData(Null) call\n"));
    356. 

  356.     }
    357. 

  357. 

  358.     return (da ? true : false);
    359. 

  359. }
    360. 

  360. 

  361. void Image::clearData(void)
    362. 

  362. {
    363. 

  363.     editPixel().clear();
    364. 

  364. }
    365. 

  365. 

  366. /*! method to update just a subregion of the image data
    367. 

  367.   all paramter (e. pixelFormat,width,height,depth) stay the same
    368. 

  368. */
    369. 

  369. bool Image::setSubData(      Int32  offX, 
    370. 

  370.                              Int32  offY, 
    371. 

  371.                              Int32  offZ,
    372. 

  372.                              Int32  srcW, 
    373. 

  373.                              Int32  srcH,
    374. 

  374.                              Int32  srcD,
    375. 

  375.                        const UInt8 *src )
    376. 

  376. {
    377. 

  377.     UChar8 *dest = editData();
    378. 

  378.     UInt64  lineSize;
    379. 

  379. 

  380.     FDEBUG(( "Image::setSubData (%d %d %d) - (%d %d %d) - src %p\n",
    381. 

  381.              offX, offY, offZ, srcW, srcH, srcD, src ));
    382. 

  382. 

  383.     if (hasCompressedData()) 
    384. 

  384.     {
    385. 

  385.         FFATAL (("Invalid Image::setSubData for compressed image\n"));
    386. 

  386.         return false;
    387. 

  387.     }
    388. 

  388. 

  389.     if(!src || !dest)
    390. 

  390.     {
    391. 

  391.         FFATAL(("Invalid data pointer in Image::setSubData\n"));
    392. 

  392.         return false;
    393. 

  393.     }
    394. 

  394. 

  395.     // determine the area to actually copy
    396. 

  396.     UInt32 xMin = osgMax(0, offX);
    397. 

  397.     UInt32 yMin = osgMax(0, offY);
    398. 

  398.     UInt32 zMin = osgMax(0, offZ);
    399. 

  399. 

  400.     UInt32 xMax = osgMin(getWidth (), offX + srcW);
    401. 

  401.     UInt32 yMax = osgMin(getHeight(), offY + srcH);
    402. 

  402.     UInt32 zMax = osgMin(getDepth (), offZ + srcD);
    403. 

  403. 

  404.     // fill the destination buffer with the subdata
    405. 

  405.     UInt32 destIdx, srcIdx = 0;
    406. 

  406. 

  407.     for(UInt32 z = zMin; z < zMax; z++)
    408. 

  408.     {
    409. 

  409.         for(UInt32 y = yMin; y < yMax; y++)
    410. 

  410.         {
    411. 

  411.             lineSize = (xMax - xMin) * getBpp();
    412. 

  412.             destIdx  = ((z * getHeight() + y) * getWidth() + xMin) * getBpp();
    413. 

  413. 

  414.             memcpy (&dest[destIdx], &src[srcIdx], size_t(lineSize));
    415. 

  415. 

  416.             srcIdx  += Int32((srcW - (xMax - xMin)) * getBpp() + lineSize);
    417. 

  417.         }
    418. 

  418.         srcIdx += (srcH - (yMax - yMin)) * srcW * getBpp();
    419. 

  419.     }
    420. 

  420. 

  421.     return true;
    422. 

  422. }
    423. 

  423. 

  424. /*! The Image is not just a 2D container. The class can hold 3D (volume)
    425. 

  425.     and movie data. If we have 3D/singleFrame or 2D/multiFrame data without
    426. 

  426.     mipmaps we can flip between this two formats by just swapping the
    427. 

  427.     getFrameCount() and getDepth() values.
    428. 

  428. */
    429. 

  429. bool Image::flipDepthFrameData(void)
    430. 

  430. {
    431. 

  431.     bool  retCode = false;
    432. 

  432.     Int32 value;
    433. 

  433. 

  434.     if((getMipMapCount() == 1) && 
    435. 

  435.        ((getFrameCount() == 1) || (getDepth() == 1)))
    436. 

  436.     {
    437. 

  437.         value = getFrameCount();
    438. 

  438. 

  439.         setFrameCount(getDepth());
    440. 

  440.         setDepth     (value     );
    441. 

  441. 

  442.         retCode = true;
    443. 

  443.     }
    444. 

  444.     else
    445. 

  445.     {
    446. 

  446.       FWARNING (("Cant flipDepthFrameData(); invalid data layout\n"));
    447. 

  447.     }
    448. 

  448.     
    449. 

  449.     return retCode;
    450. 

  450. }
    451. 

  451. 

  452. /*! This method is used by the parser to fill the image with
    453. 

  453.     string pixel data. It expects the data in VRML PixelTexture Format.
    454. 

  454. */
    455. 

  455. bool Image::addValue(const char *value)
    456. 

  456. {
    457. 

  457.     static Image  *currentImage = 0;
    458. 

  458.     static UChar8 *currentData  = 0;
    459. 

  459. 

  460.            Int64   j;
    461. 

  461.            Int64   v;
    462. 

  462. 

  463.            bool    isHead = strchr(value, ' ') ? true : false;
    464. 

  464. 

  465.     if (hasCompressedData()) 
    466. 

  466.     {
    467. 

  467.         FFATAL (("Invalid Image::addValue for compressed image\n"));
    468. 

  468.         return false;
    469. 

  469.     }
    470. 

  470. 

  471.     // make sure we only read one image at a time
    472. 

  472.     if(currentImage == this)
    473. 

  473.     {
    474. 

  474.         if(isHead)
    475. 

  475.         {
    476. 

  476.             FDEBUG(("Start new read cycle in image::addValue()\n"));
    477. 

  477.         }
    478. 

  478.     }
    479. 

  479.     else
    480. 

  480.     {
    481. 

  481.         if(!isHead)
    482. 

  482.         {
    483. 

  483.             FFATAL(("Additional image date for different image\n"));
    484. 

  484.         }
    485. 

  485.     }
    486. 

  486. 

  487.     currentImage = this;
    488. 

  488. 

  489.     if(isHead == true)
    490. 

  490.     {
    491. 

  491.         Int32        width;
    492. 

  492.         Int32        height;
    493. 

  493.         Int32        pixelDepth;
    494. 

  494.         PixelFormat  pf         = Image::OSG_INVALID_PF;
    495. 

  495. 

  496.         // read the head
    497. 

  497.         sscanf(value, "%d %d %d", &width, &height, &pixelDepth);
    498. 

  498. 

  499.         FDEBUG(("Image::addValue() set: w/h/bpp: %d/%d/%d\n",
    500. 

  500.                 width, height, pixelDepth));
    501. 

  501. 

  502.         switch(getDataType())
    503. 

  503.         {
    504. 

  504.             case OSG_UINT8_IMAGEDATA:
    505. 

  505.                 switch(pixelDepth)
    506. 

  506.                 {
    507. 

  507.                     case 1:
    508. 

  508.                         pf = OSG::Image::OSG_L_PF;
    509. 

  509.                         break;
    510. 

  510.                     case 2:
    511. 

  511.                         pf = OSG::Image::OSG_LA_PF;
    512. 

  512.                         break;
    513. 

  513.                     case 3:
    514. 

  514.                         pf = OSG::Image::OSG_RGB_PF;
    515. 

  515.                         break;
    516. 

  516.                     case 4:
    517. 

  517.                         pf = OSG::Image::OSG_RGBA_PF;
    518. 

  518.                         break;
    519. 

  519.                     default:
    520. 

  520.                         pf = OSG::Image::OSG_INVALID_PF;
    521. 

  521.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    522. 

  522.                         break;
    523. 

  523.                 }
    524. 

  524.                 break;
    525. 

  525. 

  526. #if !defined(OSG_EMBEDDED)
    527. 

  527.             case OSG_UINT16_IMAGEDATA:
    528. 

  528.                 switch(pixelDepth)
    529. 

  529.                 {
    530. 

  530.                     case 2:
    531. 

  531.                         pf = OSG::Image::OSG_L_PF;
    532. 

  532.                         break;
    533. 

  533.                     case 4:
    534. 

  534.                         pf = OSG::Image::OSG_LA_PF;
    535. 

  535.                         break;
    536. 

  536.                     case 6:
    537. 

  537.                         pf = OSG::Image::OSG_RGB_PF;
    538. 

  538.                         break;
    539. 

  539.                     case 8:
    540. 

  540.                         pf = OSG::Image::OSG_RGBA_PF;
    541. 

  541.                         break;
    542. 

  542.                     default:
    543. 

  543.                         pf = OSG::Image::OSG_INVALID_PF;
    544. 

  544.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    545. 

  545.                         break;
    546. 

  546.                 }
    547. 

  547.                 break;
    548. 

  548. 

  549.             case OSG_UINT32_IMAGEDATA:
    550. 

  550.                 switch(pixelDepth)
    551. 

  551.                 {
    552. 

  552.                     case 4:
    553. 

  553.                         pf = OSG::Image::OSG_L_PF;
    554. 

  554.                         break;
    555. 

  555.                     case 8:
    556. 

  556.                         pf = OSG::Image::OSG_LA_PF;
    557. 

  557.                         break;
    558. 

  558.                     case 12:
    559. 

  559.                         pf = OSG::Image::OSG_RGB_PF;
    560. 

  560.                         break;
    561. 

  561.                     case 16:
    562. 

  562.                         pf = OSG::Image::OSG_RGBA_PF;
    563. 

  563.                         break;
    564. 

  564.                     default:
    565. 

  565.                         pf = OSG::Image::OSG_INVALID_PF;
    566. 

  566.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    567. 

  567.                         break;
    568. 

  568.                 }
    569. 

  569.                 break;
    570. 

  570. #endif
    571. 

  571. 

  572.             case OSG_FLOAT32_IMAGEDATA:
    573. 

  573.                 switch(pixelDepth)
    574. 

  574.                 {
    575. 

  575.                     case 4:
    576. 

  576.                         pf = OSG::Image::OSG_L_PF;
    577. 

  577.                         break;
    578. 

  578.                     case 8:
    579. 

  579.                         pf = OSG::Image::OSG_LA_PF;
    580. 

  580.                         break;
    581. 

  581.                     case 12:
    582. 

  582.                         pf = OSG::Image::OSG_RGB_PF;
    583. 

  583.                         break;
    584. 

  584.                     case 16:
    585. 

  585.                         pf = OSG::Image::OSG_RGBA_PF;
    586. 

  586.                         break;
    587. 

  587.                     default:
    588. 

  588.                         pf = OSG::Image::OSG_INVALID_PF;
    589. 

  589.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    590. 

  590.                         break;
    591. 

  591.                 }
    592. 

  592.                 break;
    593. 

  593. 

  594. #if !defined(OSG_EMBEDDED)
    595. 

  595.             case OSG_FLOAT16_IMAGEDATA:
    596. 

  596.                 switch(pixelDepth)
    597. 

  597.                 {
    598. 

  598.                     case 2:
    599. 

  599.                         pf = OSG::Image::OSG_L_PF;
    600. 

  600.                         break;
    601. 

  601.                     case 4:
    602. 

  602.                         pf = OSG::Image::OSG_LA_PF;
    603. 

  603.                         break;
    604. 

  604.                     case 6:
    605. 

  605.                         pf = OSG::Image::OSG_RGB_PF;
    606. 

  606.                         break;
    607. 

  607.                     case 8:
    608. 

  608.                         pf = OSG::Image::OSG_RGBA_PF;
    609. 

  609.                         break;
    610. 

  610.                     default:
    611. 

  611.                         pf = OSG::Image::OSG_INVALID_PF;
    612. 

  612.                         FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
    613. 

  613.                         break;
    614. 

  614.                 }
    615. 

  615.                 break;
    616. 

  616. #endif
    617. 

  617. 

  618.             default:
    619. 

  619.                 setDataType(OSG_INVALID_IMAGEDATATYPE);
    620. 

  620.                 FFATAL(("Invalid type of image data: %d\n", getDataType()));
    621. 

  621.         }
    622. 

  622. 

  623.         if(pf != 0 && (width > 0) && (height > 0))
    624. 

  624.         {
    625. 

  625.             set(pf, width, height);
    626. 

  626. 

  627.             currentData = editData();
    628. 

  628.         }
    629. 

  629.         else
    630. 

  630.         {
    631. 

  631.             currentData = NULL;
    632. 

  632.         }
    633. 

  633.     }
    634. 

  634.     else
    635. 

  635.     {
    636. 

  636.         if(currentData != NULL)
    637. 

  637.         {
    638. 

  638.             // add data
    639. 

  639.             // TODO; should we check the bounds, should be done by the parser
    640. 

  640. 

  641.             v = strtoul(value, 0, strchr(value, 'x') ? 16 : 10);
    642. 

  642. 

  643.             for(j = getBpp(); j--;)
    644. 

  644.             {
    645. 

  645.                 *currentData++ = UChar8( (v >> (8 * j)) & 255 );
    646. 

  646.             }
    647. 

  647. 

  648.         }
    649. 

  649.     }
    650. 

  650. 

  651.     return currentData ? true : false;
    652. 

  652. }
    653. 

  653. 

  654. /*! It is a simple method to reformat the image pixelFormat (not the size).
    655. 

  655.     So you can for example convert a RGBA to RGB or RGB to Grey image.
    656. 

  656. */
    657. 

  657. bool Image::reformat(const Image::PixelFormat pixelFormat,
    658. 

  658.                            ImagePtr           destination)
    659. 

  659. {
    660. 

  660.           UChar8   *data       = NULL;
    661. 

  661.     const UChar8   *sourceData = NULL;
    662. 

  662.           UInt32    srcI, destI, destSize = 0;
    663. 

  663.           UInt32    sum;
    664. 

  664.           Real64    sumReal;
    665. 

  665.           ImagePtr  dest = destination;
    666. 

  666. 

  667.     if (hasCompressedData()) 
    668. 

  668.     {
    669. 

  669.         FFATAL (("Invalid Image::reformat for compressed image\n"));
    670. 

  670.         return false;
    671. 

  671.     }
    672. 

  672. 

  673.     if(destination == NullFC)
    674. 

  674.     {
    675. 

  675.         dest = Image::create();
    676. 

  676.         addRef(dest);
    677. 

  677.     }
    678. 

  678. 

  679.     FINFO(("Try to reformat image from pixelDepth %d to %d\n",
    680. 

  680.            getPixelFormat(), 
    681. 

  681.            pixelFormat    ));
    682. 

  682. 

  683.     // TODO !!! code all the cases !!!
    684. 

  684. 

  685.     if(getSize()   && 
    686. 

  686.        pixelFormat &&
    687. 

  687.        (destination != NullFC || (pixelFormat != getPixelFormat())))
    688. 

  688.     {
    689. 

  689. 

  690.         dest->set(pixelFormat, getWidth(), getHeight(), getDepth() );
    691. 

  691. 

  692.         sourceData = getData();
    693. 

  693. 

  694.         data       = dest->editData();
    695. 

  695.         destSize   = dest->getSize();
    696. 

  696. 

  697.         const UInt16 *sourceDataUC16 = (const UInt16 *) sourceData;
    698. 

  698.               UInt16 *destDataUC16   = (      UInt16 *) data;
    699. 

  699.         const UInt32 *sourceDataUC32 = (const UInt32 *) sourceData;
    700. 

  700.               UInt32 *destDataUC32   = (      UInt32 *) data;
    701. 

  701.         const Real32 *sourceDataF32  = (const Real32 *) sourceData;
    702. 

  702.               Real32 *destDataF32    = (      Real32 *) data;
    703. 

  703.         const Real16 *sourceDataH16  = (const Real16 *) sourceData;
    704. 

  704.               Real16 *destDataH16    = (      Real16 *) data;
    705. 

  705. 

  706.         if(data)
    707. 

  707.         {
    708. 

  708.             switch (getPixelFormat())
    709. 

  709.             {
    710. 

  710.                 //-----------------------------------------------------
    711. 

  711.                 case OSG_A_PF:
    712. 

  712.                     switch (pixelFormat) {
    713. 

  713.                         case OSG_A_PF:
    714. 

  714. #if !defined(OSG_EMBEDDED)
    715. 

  715.                         case OSG_I_PF:
    716. 

  716. #endif
    717. 

  717.                             switch (getDataType())
    718. 

  718.                             {
    719. 

  719.                             case OSG_UINT8_IMAGEDATA:
    720. 

  720.                                 memcpy (data, getData(), destSize);
    721. 

  721.                                 break;
    722. 

  722. #if !defined(OSG_EMBEDDED)
    723. 

  723.                             case OSG_UINT16_IMAGEDATA:
    724. 

  724.                                 memcpy (data, getData(), destSize);
    725. 

  725.                                 break;
    726. 

  726.                             case OSG_UINT32_IMAGEDATA:
    727. 

  727.                                 memcpy (data, getData(), destSize);
    728. 

  728.                                 break;
    729. 

  729. #endif
    730. 

  730.                             case OSG_FLOAT32_IMAGEDATA:
    731. 

  731.                                 memcpy (data, getData(), destSize);
    732. 

  732.                                 break;
    733. 

  733. #if !defined(OSG_EMBEDDED)
    734. 

  734.                             case OSG_FLOAT16_IMAGEDATA:
    735. 

  735.                                 memcpy (data, getData(), destSize);
    736. 

  736.                                 break;
    737. 

  737. #endif
    738. 

  738. 

  739.                             default:
    740. 

  740.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    741. 

  741.                                 break;
    742. 

  742.                             }
    743. 

  743.                             break;
    744. 

  744. 

  745.                         case OSG_L_PF:
    746. 

  746.                             switch (getDataType())
    747. 

  747.                             {
    748. 

  748.                             case OSG_UINT8_IMAGEDATA:
    749. 

  749.                                 memcpy (data, getData(), destSize);
    750. 

  750.                                 break;
    751. 

  751. #if !defined(OSG_EMBEDDED)
    752. 

  752.                             case OSG_UINT16_IMAGEDATA:
    753. 

  753.                                 memcpy (data, getData(), destSize);
    754. 

  754.                                 break;
    755. 

  755.                             case OSG_UINT32_IMAGEDATA:
    756. 

  756.                                 memcpy (data, getData(), destSize);
    757. 

  757.                                 break;
    758. 

  758. #endif
    759. 

  759.                             case OSG_FLOAT32_IMAGEDATA:
    760. 

  760.                                 memcpy (data, getData(), destSize);
    761. 

  761.                                 break;
    762. 

  762. #if !defined(OSG_EMBEDDED)
    763. 

  763.                             case OSG_FLOAT16_IMAGEDATA:
    764. 

  764.                                 memcpy (data, getData(), destSize);
    765. 

  765.                                 break;
    766. 

  766. #endif
    767. 

  767. 

  768.                             default:
    769. 

  769.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    770. 

  770.                                 break;
    771. 

  771.                             }
    772. 

  772.                             break;
    773. 

  773. 

  774.                         case OSG_LA_PF:
    775. 

  775.                             switch (getDataType())
    776. 

  776.                             {
    777. 

  777.                             case OSG_UINT8_IMAGEDATA:
    778. 

  778.                                 for (srcI = destI = 0; destI < destSize;)
    779. 

  779.                                 {
    780. 

  780.                                     data[destI++] = sourceData[srcI];
    781. 

  781.                                     data[destI++] = sourceData[srcI++];
    782. 

  782.                                 }
    783. 

  783.                                 break;
    784. 

  784. #if !defined(OSG_EMBEDDED)
    785. 

  785.                             case OSG_UINT16_IMAGEDATA:
    786. 

  786.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    787. 

  787.                                 {
    788. 

  788.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    789. 

  789.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    790. 

  790.                                 }
    791. 

  791.                                 break;
    792. 

  792.                             case OSG_UINT32_IMAGEDATA:
    793. 

  793.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    794. 

  794.                                 {
    795. 

  795.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    796. 

  796.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    797. 

  797.                                 }
    798. 

  798.                                 break;
    799. 

  799. #endif
    800. 

  800.                             case OSG_FLOAT32_IMAGEDATA:
    801. 

  801.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    802. 

  802.                                 {
    803. 

  803.                                     destDataF32[destI++] = sourceDataF32[srcI];
    804. 

  804.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    805. 

  805.                                 }
    806. 

  806.                                 break;
    807. 

  807. 

  808. #if !defined(OSG_EMBEDDED)
    809. 

  809.                             case OSG_FLOAT16_IMAGEDATA:
    810. 

  810.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    811. 

  811.                                 {
    812. 

  812.                                     destDataH16[destI++] = sourceDataH16[srcI];
    813. 

  813.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    814. 

  814.                                 }
    815. 

  815.                                 break;
    816. 

  816. #endif
    817. 

  817.                             default:
    818. 

  818.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    819. 

  819.                                 break;
    820. 

  820.                             }
    821. 

  821.                             break;
    822. 

  822. 

  823.                         case OSG_RGB_PF:
    824. 

  824.                             switch (getDataType())
    825. 

  825.                             {
    826. 

  826.                             case OSG_UINT8_IMAGEDATA:
    827. 

  827.                                 for (srcI = destI = 0; destI < destSize;)
    828. 

  828.                                 {
    829. 

  829.                                     data[destI++] = sourceData[srcI];
    830. 

  830.                                     data[destI++] = sourceData[srcI];
    831. 

  831.                                     data[destI++] = sourceData[srcI++];
    832. 

  832.                                 }
    833. 

  833.                                 break;
    834. 

  834. #if !defined(OSG_EMBEDDED)
    835. 

  835.                             case OSG_UINT16_IMAGEDATA:
    836. 

  836.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    837. 

  837.                                 {
    838. 

  838.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    839. 

  839.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    840. 

  840.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    841. 

  841.                                 }
    842. 

  842.                                 break;
    843. 

  843.                             case OSG_UINT32_IMAGEDATA:
    844. 

  844.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    845. 

  845.                                 {
    846. 

  846.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    847. 

  847.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    848. 

  848.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    849. 

  849.                                 }
    850. 

  850.                                 break;
    851. 

  851. #endif
    852. 

  852.                             case OSG_FLOAT32_IMAGEDATA:
    853. 

  853.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    854. 

  854.                                 {
    855. 

  855.                                     destDataF32[destI++] = sourceDataF32[srcI];
    856. 

  856.                                     destDataF32[destI++] = sourceDataF32[srcI];
    857. 

  857.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    858. 

  858.                                 }
    859. 

  859.                                 break;
    860. 

  860. #if !defined(OSG_EMBEDDED)
    861. 

  861.                             case OSG_FLOAT16_IMAGEDATA:
    862. 

  862.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    863. 

  863.                                 {
    864. 

  864.                                     destDataH16[destI++] = sourceDataH16[srcI];
    865. 

  865.                                     destDataH16[destI++] = sourceDataH16[srcI];
    866. 

  866.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    867. 

  867.                                 }
    868. 

  868.                                 break;
    869. 

  869. #endif
    870. 

  870.                             default:
    871. 

  871.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    872. 

  872.                                 break;
    873. 

  873.                             }
    874. 

  874.                             break;
    875. 

  875. 

  876.                         case OSG_RGBA_PF:
    877. 

  877.                             switch (getDataType())
    878. 

  878.                             {
    879. 

  879.                             case OSG_UINT8_IMAGEDATA:
    880. 

  880.                                 for (srcI = destI = 0; destI < destSize;)
    881. 

  881.                                 {
    882. 

  882.                                     data[destI++] = sourceData[srcI];
    883. 

  883.                                     data[destI++] = sourceData[srcI];
    884. 

  884.                                     data[destI++] = sourceData[srcI];
    885. 

  885.                                     data[destI++] = sourceData[srcI++];
    886. 

  886.                                 }
    887. 

  887.                                 break;
    888. 

  888. #if !defined(OSG_EMBEDDED)
    889. 

  889.                             case OSG_UINT16_IMAGEDATA:
    890. 

  890.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    891. 

  891.                                 {
    892. 

  892.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    893. 

  893.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    894. 

  894.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    895. 

  895.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    896. 

  896.                                 }
    897. 

  897.                                 break;
    898. 

  898.                             case OSG_UINT32_IMAGEDATA:
    899. 

  899.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    900. 

  900.                                 {
    901. 

  901.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    902. 

  902.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    903. 

  903.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    904. 

  904.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    905. 

  905.                                 }
    906. 

  906.                                 break;
    907. 

  907. #endif
    908. 

  908.                             case OSG_FLOAT32_IMAGEDATA:
    909. 

  909.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    910. 

  910.                                 {
    911. 

  911.                                     destDataF32[destI++] = sourceDataF32[srcI];
    912. 

  912.                                     destDataF32[destI++] = sourceDataF32[srcI];
    913. 

  913.                                     destDataF32[destI++] = sourceDataF32[srcI];
    914. 

  914.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    915. 

  915.                                 }
    916. 

  916.                                 break;
    917. 

  917. #if !defined(OSG_EMBEDDED)
    918. 

  918.                             case OSG_FLOAT16_IMAGEDATA:
    919. 

  919.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    920. 

  920.                                 {
    921. 

  921.                                     destDataH16[destI++] = sourceDataH16[srcI];
    922. 

  922.                                     destDataH16[destI++] = sourceDataH16[srcI];
    923. 

  923.                                     destDataH16[destI++] = sourceDataH16[srcI];
    924. 

  924.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    925. 

  925.                                 }
    926. 

  926.                                 break;
    927. 

  927. #endif
    928. 

  928.                             default:
    929. 

  929.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    930. 

  930.                                 break;
    931. 

  931.                             }
    932. 

  932.                             break;
    933. 

  933.                     default:
    934. 

  934.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    935. 

  935.                         break;
    936. 

  936.                     }
    937. 

  937.                     break;
    938. 

  938. 

  939.                 //-----------------------------------------------------
    940. 

  940. #if !defined(OSG_EMBEDDED)
    941. 

  941.                 case OSG_I_PF:
    942. 

  942.                     switch (pixelFormat) {
    943. 

  943.                         case OSG_A_PF:
    944. 

  944.                         case OSG_I_PF:
    945. 

  945.                         case OSG_L_PF:
    946. 

  946.                             switch (getDataType())
    947. 

  947.                             {
    948. 

  948.                             case OSG_UINT8_IMAGEDATA:
    949. 

  949.                                 memcpy (data, getData(), destSize);
    950. 

  950.                                 break;
    951. 

  951.                             case OSG_UINT16_IMAGEDATA:
    952. 

  952.                                 memcpy (data, getData(), destSize);
    953. 

  953.                                 break;
    954. 

  954.                             case OSG_UINT32_IMAGEDATA:
    955. 

  955.                                 memcpy (data, getData(), destSize);
    956. 

  956.                                 break;
    957. 

  957.                             case OSG_FLOAT32_IMAGEDATA:
    958. 

  958.                                 memcpy (data, getData(), destSize);
    959. 

  959.                                 break;
    960. 

  960.                             case OSG_FLOAT16_IMAGEDATA:
    961. 

  961.                                 memcpy (data, getData(), destSize);
    962. 

  962.                                 break;
    963. 

  963. 

  964.                             default:
    965. 

  965.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    966. 

  966.                                 break;
    967. 

  967.                             }
    968. 

  968.                             break;
    969. 

  969. 

  970.                         case OSG_LA_PF:
    971. 

  971.                             switch (getDataType())
    972. 

  972.                             {
    973. 

  973.                             case OSG_UINT8_IMAGEDATA:
    974. 

  974.                                 for (srcI = destI = 0; destI < destSize;)
    975. 

  975.                                 {
    976. 

  976.                                     data[destI++] = sourceData[srcI];
    977. 

  977.                                     data[destI++] = sourceData[srcI++];
    978. 

  978.                                 }
    979. 

  979.                                 break;
    980. 

  980.                             case OSG_UINT16_IMAGEDATA:
    981. 

  981.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    982. 

  982.                                 {
    983. 

  983.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    984. 

  984.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    985. 

  985.                                 }
    986. 

  986.                                 break;
    987. 

  987.                             case OSG_UINT32_IMAGEDATA:
    988. 

  988.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    989. 

  989.                                 {
    990. 

  990.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    991. 

  991.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    992. 

  992.                                 }
    993. 

  993.                                 break;
    994. 

  994.                             case OSG_FLOAT32_IMAGEDATA:
    995. 

  995.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    996. 

  996.                                 {
    997. 

  997.                                     destDataF32[destI++] = sourceDataF32[srcI];
    998. 

  998.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    999. 

  999.                                 }
    1000. 

  1000.                                 break;
    1001. 

  1001. 

  1002.                             case OSG_FLOAT16_IMAGEDATA:
    1003. 

  1003.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1004. 

  1004.                                 {
    1005. 

  1005.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1006. 

  1006.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1007. 

  1007.                                 }
    1008. 

  1008.                                 break;
    1009. 

  1009.                             default:
    1010. 

  1010.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1011. 

  1011.                                 break;
    1012. 

  1012.                             }
    1013. 

  1013.                             break;
    1014. 

  1014. 

  1015.                         case OSG_RGB_PF:
    1016. 

  1016.                             switch (getDataType())
    1017. 

  1017.                             {
    1018. 

  1018.                             case OSG_UINT8_IMAGEDATA:
    1019. 

  1019.                                 for (srcI = destI = 0; destI < destSize;)
    1020. 

  1020.                                 {
    1021. 

  1021.                                     data[destI++] = sourceData[srcI];
    1022. 

  1022.                                     data[destI++] = sourceData[srcI];
    1023. 

  1023.                                     data[destI++] = sourceData[srcI++];
    1024. 

  1024.                                 }
    1025. 

  1025.                                 break;
    1026. 

  1026.                             case OSG_UINT16_IMAGEDATA:
    1027. 

  1027.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1028. 

  1028.                                 {
    1029. 

  1029.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1030. 

  1030.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1031. 

  1031.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1032. 

  1032.                                 }
    1033. 

  1033.                                 break;
    1034. 

  1034.                             case OSG_UINT32_IMAGEDATA:
    1035. 

  1035.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1036. 

  1036.                                 {
    1037. 

  1037.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1038. 

  1038.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1039. 

  1039.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1040. 

  1040.                                 }
    1041. 

  1041.                                 break;
    1042. 

  1042.                             case OSG_FLOAT32_IMAGEDATA:
    1043. 

  1043.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1044. 

  1044.                                 {
    1045. 

  1045.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1046. 

  1046.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1047. 

  1047.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1048. 

  1048.                                 }
    1049. 

  1049.                                 break;
    1050. 

  1050.                             case OSG_FLOAT16_IMAGEDATA:
    1051. 

  1051.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1052. 

  1052.                                 {
    1053. 

  1053.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1054. 

  1054.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1055. 

  1055.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1056. 

  1056.                                 }
    1057. 

  1057.                                 break;
    1058. 

  1058.                             default:
    1059. 

  1059.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1060. 

  1060.                                 break;
    1061. 

  1061.                             }
    1062. 

  1062.                             break;
    1063. 

  1063. 

  1064.                         case OSG_RGBA_PF:
    1065. 

  1065.                             switch (getDataType())
    1066. 

  1066.                             {
    1067. 

  1067.                             case OSG_UINT8_IMAGEDATA:
    1068. 

  1068.                                 for (srcI = destI = 0; destI < destSize;)
    1069. 

  1069.                                 {
    1070. 

  1070.                                     data[destI++] = sourceData[srcI];
    1071. 

  1071.                                     data[destI++] = sourceData[srcI];
    1072. 

  1072.                                     data[destI++] = sourceData[srcI];
    1073. 

  1073.                                     data[destI++] = sourceData[srcI++];
    1074. 

  1074.                                 }
    1075. 

  1075.                                 break;
    1076. 

  1076.                             case OSG_UINT16_IMAGEDATA:
    1077. 

  1077.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1078. 

  1078.                                 {
    1079. 

  1079.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1080. 

  1080.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1081. 

  1081.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1082. 

  1082.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1083. 

  1083.                                 }
    1084. 

  1084.                                 break;
    1085. 

  1085.                             case OSG_UINT32_IMAGEDATA:
    1086. 

  1086.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1087. 

  1087.                                 {
    1088. 

  1088.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1089. 

  1089.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1090. 

  1090.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1091. 

  1091.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1092. 

  1092.                                 }
    1093. 

  1093.                                 break;
    1094. 

  1094.                             case OSG_FLOAT32_IMAGEDATA:
    1095. 

  1095.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1096. 

  1096.                                 {
    1097. 

  1097.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1098. 

  1098.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1099. 

  1099.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1100. 

  1100.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1101. 

  1101.                                 }
    1102. 

  1102.                                 break;
    1103. 

  1103.                             case OSG_FLOAT16_IMAGEDATA:
    1104. 

  1104.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1105. 

  1105.                                 {
    1106. 

  1106.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1107. 

  1107.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1108. 

  1108.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1109. 

  1109.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1110. 

  1110.                                 }
    1111. 

  1111.                                 break;
    1112. 

  1112.                             default:
    1113. 

  1113.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1114. 

  1114.                                 break;
    1115. 

  1115.                             }
    1116. 

  1116.                             break;
    1117. 

  1117.                     default:
    1118. 

  1118.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1119. 

  1119.                         break;
    1120. 

  1120.                     }
    1121. 

  1121.                     break;
    1122. 

  1122. #endif
    1123. 

  1123. 

  1124.                 //-----------------------------------------------------
    1125. 

  1125.                 case OSG_L_PF:
    1126. 

  1126.                     switch (pixelFormat) {
    1127. 

  1127.                         case OSG_A_PF:
    1128. 

  1128. #if !defined(OSG_EMBEDDED)
    1129. 

  1129.                         case OSG_I_PF:
    1130. 

  1130. #endif
    1131. 

  1131.                         case OSG_L_PF:
    1132. 

  1132.                             switch (getDataType())
    1133. 

  1133.                             {
    1134. 

  1134.                             case OSG_UINT8_IMAGEDATA:
    1135. 

  1135.                                 memcpy (data, getData(), destSize);
    1136. 

  1136.                                 break;
    1137. 

  1137. #if !defined(OSG_EMBEDDED)
    1138. 

  1138.                             case OSG_UINT16_IMAGEDATA:
    1139. 

  1139.                                 memcpy (data, getData(), destSize);
    1140. 

  1140.                                 break;
    1141. 

  1141.                             case OSG_UINT32_IMAGEDATA:
    1142. 

  1142.                                 memcpy (data, getData(), destSize);
    1143. 

  1143.                                 break;
    1144. 

  1144. #endif
    1145. 

  1145.                             case OSG_FLOAT32_IMAGEDATA:
    1146. 

  1146.                                 memcpy (data, getData(), destSize);
    1147. 

  1147.                                 break;
    1148. 

  1148. #if !defined(OSG_EMBEDDED)
    1149. 

  1149.                             case OSG_FLOAT16_IMAGEDATA:
    1150. 

  1150.                                 memcpy (data, getData(), destSize);
    1151. 

  1151.                                 break;
    1152. 

  1152. #endif
    1153. 

  1153. 

  1154.                             default:
    1155. 

  1155.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1156. 

  1156.                                 break;
    1157. 

  1157.                             }
    1158. 

  1158.                             break;
    1159. 

  1159. 

  1160.                         case OSG_LA_PF:
    1161. 

  1161.                             switch (getDataType())
    1162. 

  1162.                             {
    1163. 

  1163.                             case OSG_UINT8_IMAGEDATA:
    1164. 

  1164.                                 for (srcI = destI = 0; destI < destSize;)
    1165. 

  1165.                                 {
    1166. 

  1166.                                     data[destI++] = sourceData[srcI];
    1167. 

  1167.                                     data[destI++] = sourceData[srcI++];
    1168. 

  1168.                                 }
    1169. 

  1169.                                 break;
    1170. 

  1170. #if !defined(OSG_EMBEDDED)
    1171. 

  1171.                             case OSG_UINT16_IMAGEDATA:
    1172. 

  1172.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1173. 

  1173.                                 {
    1174. 

  1174.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1175. 

  1175.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1176. 

  1176.                                 }
    1177. 

  1177.                                 break;
    1178. 

  1178.                             case OSG_UINT32_IMAGEDATA:
    1179. 

  1179.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1180. 

  1180.                                 {
    1181. 

  1181.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1182. 

  1182.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1183. 

  1183.                                 }
    1184. 

  1184.                                 break;
    1185. 

  1185. #endif
    1186. 

  1186.                             case OSG_FLOAT32_IMAGEDATA:
    1187. 

  1187.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1188. 

  1188.                                 {
    1189. 

  1189.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1190. 

  1190.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1191. 

  1191.                                 }
    1192. 

  1192.                                 break;
    1193. 

  1193. 

  1194. #if !defined(OSG_EMBEDDED)
    1195. 

  1195.                             case OSG_FLOAT16_IMAGEDATA:
    1196. 

  1196.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1197. 

  1197.                                 {
    1198. 

  1198.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1199. 

  1199.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1200. 

  1200.                                 }
    1201. 

  1201.                                 break;
    1202. 

  1202. #endif
    1203. 

  1203.                             default:
    1204. 

  1204.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1205. 

  1205.                                 break;
    1206. 

  1206.                             }
    1207. 

  1207.                             break;
    1208. 

  1208. 

  1209.                         case OSG_RGB_PF:
    1210. 

  1210.                             switch (getDataType())
    1211. 

  1211.                             {
    1212. 

  1212.                             case OSG_UINT8_IMAGEDATA:
    1213. 

  1213.                                 for (srcI = destI = 0; destI < destSize;)
    1214. 

  1214.                                 {
    1215. 

  1215.                                     data[destI++] = sourceData[srcI];
    1216. 

  1216.                                     data[destI++] = sourceData[srcI];
    1217. 

  1217.                                     data[destI++] = sourceData[srcI++];
    1218. 

  1218.                                 }
    1219. 

  1219.                                 break;
    1220. 

  1220. #if !defined(OSG_EMBEDDED)
    1221. 

  1221.                             case OSG_UINT16_IMAGEDATA:
    1222. 

  1222.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1223. 

  1223.                                 {
    1224. 

  1224.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1225. 

  1225.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1226. 

  1226.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1227. 

  1227.                                 }
    1228. 

  1228.                                 break;
    1229. 

  1229.                             case OSG_UINT32_IMAGEDATA:
    1230. 

  1230.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1231. 

  1231.                                 {
    1232. 

  1232.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1233. 

  1233.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1234. 

  1234.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1235. 

  1235.                                 }
    1236. 

  1236.                                 break;
    1237. 

  1237. #endif
    1238. 

  1238.                             case OSG_FLOAT32_IMAGEDATA:
    1239. 

  1239.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1240. 

  1240.                                 {
    1241. 

  1241.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1242. 

  1242.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1243. 

  1243.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1244. 

  1244.                                 }
    1245. 

  1245.                                 break;
    1246. 

  1246. #if !defined(OSG_EMBEDDED)
    1247. 

  1247.                             case OSG_FLOAT16_IMAGEDATA:
    1248. 

  1248.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1249. 

  1249.                                 {
    1250. 

  1250.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1251. 

  1251.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1252. 

  1252.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1253. 

  1253.                                 }
    1254. 

  1254.                                 break;
    1255. 

  1255. #endif
    1256. 

  1256.                             default:
    1257. 

  1257.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1258. 

  1258.                                 break;
    1259. 

  1259.                             }
    1260. 

  1260.                             break;
    1261. 

  1261. 

  1262.                         case OSG_RGBA_PF:
    1263. 

  1263.                             switch (getDataType())
    1264. 

  1264.                             {
    1265. 

  1265.                             case OSG_UINT8_IMAGEDATA:
    1266. 

  1266.                                 for (srcI = destI = 0; destI < destSize;)
    1267. 

  1267.                                 {
    1268. 

  1268.                                     data[destI++] = sourceData[srcI];
    1269. 

  1269.                                     data[destI++] = sourceData[srcI];
    1270. 

  1270.                                     data[destI++] = sourceData[srcI];
    1271. 

  1271.                                     data[destI++] = sourceData[srcI++];
    1272. 

  1272.                                 }
    1273. 

  1273.                                 break;
    1274. 

  1274. #if !defined(OSG_EMBEDDED)
    1275. 

  1275.                             case OSG_UINT16_IMAGEDATA:
    1276. 

  1276.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1277. 

  1277.                                 {
    1278. 

  1278.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1279. 

  1279.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1280. 

  1280.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1281. 

  1281.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1282. 

  1282.                                 }
    1283. 

  1283.                                 break;
    1284. 

  1284.                             case OSG_UINT32_IMAGEDATA:
    1285. 

  1285.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1286. 

  1286.                                 {
    1287. 

  1287.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1288. 

  1288.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1289. 

  1289.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1290. 

  1290.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1291. 

  1291.                                 }
    1292. 

  1292.                                 break;
    1293. 

  1293. #endif
    1294. 

  1294.                             case OSG_FLOAT32_IMAGEDATA:
    1295. 

  1295.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1296. 

  1296.                                 {
    1297. 

  1297.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1298. 

  1298.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1299. 

  1299.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1300. 

  1300.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1301. 

  1301.                                 }
    1302. 

  1302.                                 break;
    1303. 

  1303. #if !defined(OSG_EMBEDDED)
    1304. 

  1304.                             case OSG_FLOAT16_IMAGEDATA:
    1305. 

  1305.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1306. 

  1306.                                 {
    1307. 

  1307.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1308. 

  1308.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1309. 

  1309.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1310. 

  1310.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1311. 

  1311.                                 }
    1312. 

  1312.                                 break;
    1313. 

  1313. #endif
    1314. 

  1314.                             default:
    1315. 

  1315.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1316. 

  1316.                                 break;
    1317. 

  1317.                             }
    1318. 

  1318.                             break;
    1319. 

  1319.                     default:
    1320. 

  1320.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1321. 

  1321.                         break;
    1322. 

  1322.                     }
    1323. 

  1323.                     break;
    1324. 

  1324. 

  1325.                 //-----------------------------------------------------
    1326. 

  1326.                 case OSG_LA_PF:
    1327. 

  1327.                     switch (pixelFormat) {
    1328. 

  1328.                         case OSG_A_PF:
    1329. 

  1329.                             switch (getDataType())
    1330. 

  1330.                             {
    1331. 

  1331.                             case OSG_UINT8_IMAGEDATA:
    1332. 

  1332.                                 for (srcI = destI = 0; destI < destSize;)
    1333. 

  1333.                                 {
    1334. 

  1334.                                     srcI++;
    1335. 

  1335.                                     data[destI++] = sourceData[srcI++];
    1336. 

  1336.                                 }
    1337. 

  1337.                                 break;
    1338. 

  1338. #if !defined(OSG_EMBEDDED)
    1339. 

  1339.                             case OSG_UINT16_IMAGEDATA:
    1340. 

  1340.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1341. 

  1341.                                 {
    1342. 

  1342.                                     srcI++;
    1343. 

  1343.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1344. 

  1344.                                 }
    1345. 

  1345.                                 break;
    1346. 

  1346.                             case OSG_UINT32_IMAGEDATA:
    1347. 

  1347.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1348. 

  1348.                                 {
    1349. 

  1349.                                     srcI++;
    1350. 

  1350.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1351. 

  1351.                                 }
    1352. 

  1352.                                 break;
    1353. 

  1353. #endif
    1354. 

  1354.                             case OSG_FLOAT32_IMAGEDATA:
    1355. 

  1355.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1356. 

  1356.                                 {
    1357. 

  1357.                                     srcI++;
    1358. 

  1358.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1359. 

  1359.                                 }
    1360. 

  1360.                                 break;
    1361. 

  1361. #if !defined(OSG_EMBEDDED)
    1362. 

  1362.                             case OSG_FLOAT16_IMAGEDATA:
    1363. 

  1363.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1364. 

  1364.                                 {
    1365. 

  1365.                                     srcI++;
    1366. 

  1366.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1367. 

  1367.                                 }
    1368. 

  1368.                                 break;
    1369. 

  1369. #endif
    1370. 

  1370.                             default:
    1371. 

  1371.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1372. 

  1372.                                 break;
    1373. 

  1373.                             }
    1374. 

  1374.                             break;
    1375. 

  1375. #if !defined(OSG_EMBEDDED)
    1376. 

  1376.                         case OSG_I_PF:
    1377. 

  1377. #endif
    1378. 

  1378.                         case OSG_L_PF:
    1379. 

  1379.                             switch (getDataType())
    1380. 

  1380.                             {
    1381. 

  1381.                             case OSG_UINT8_IMAGEDATA:
    1382. 

  1382.                                 for (srcI = destI = 0; destI < destSize;)
    1383. 

  1383.                                 {
    1384. 

  1384.                                     data[destI++] = sourceData[srcI++];
    1385. 

  1385.                                     srcI++;
    1386. 

  1386.                                 }
    1387. 

  1387.                                 break;
    1388. 

  1388. #if !defined(OSG_EMBEDDED)
    1389. 

  1389.                             case OSG_UINT16_IMAGEDATA:
    1390. 

  1390.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1391. 

  1391.                                 {
    1392. 

  1392.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1393. 

  1393.                                     srcI++;
    1394. 

  1394.                                 }
    1395. 

  1395.                                 break;
    1396. 

  1396.                             case OSG_UINT32_IMAGEDATA:
    1397. 

  1397.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1398. 

  1398.                                 {
    1399. 

  1399.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1400. 

  1400.                                     srcI++;
    1401. 

  1401.                                 }
    1402. 

  1402.                                 break;
    1403. 

  1403. #endif
    1404. 

  1404.                             case OSG_FLOAT32_IMAGEDATA:
    1405. 

  1405.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1406. 

  1406.                                 {
    1407. 

  1407.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1408. 

  1408.                                     srcI++;
    1409. 

  1409.                                 }
    1410. 

  1410.                                 break;
    1411. 

  1411. #if !defined(OSG_EMBEDDED)
    1412. 

  1412.                             case OSG_FLOAT16_IMAGEDATA:
    1413. 

  1413.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1414. 

  1414.                                 {
    1415. 

  1415.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1416. 

  1416.                                     srcI++;
    1417. 

  1417.                                 }
    1418. 

  1418.                                 break;
    1419. 

  1419. #endif
    1420. 

  1420.                             default:
    1421. 

  1421.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1422. 

  1422.                                 break;
    1423. 

  1423.                             }
    1424. 

  1424.                             break;
    1425. 

  1425.                         case OSG_LA_PF:
    1426. 

  1426.                             switch (getDataType())
    1427. 

  1427.                             {
    1428. 

  1428.                             case OSG_UINT8_IMAGEDATA:
    1429. 

  1429.                                 memcpy (data, getData(), destSize);
    1430. 

  1430.                                 break;
    1431. 

  1431. #if !defined(OSG_EMBEDDED)
    1432. 

  1432.                             case OSG_UINT16_IMAGEDATA:
    1433. 

  1433.                                 memcpy (data, getData(), destSize);
    1434. 

  1434.                                 break;
    1435. 

  1435.                             case OSG_UINT32_IMAGEDATA:
    1436. 

  1436.                                 memcpy (data, getData(), destSize);
    1437. 

  1437.                                 break;
    1438. 

  1438. #endif
    1439. 

  1439.                             case OSG_FLOAT32_IMAGEDATA:
    1440. 

  1440.                                 memcpy (data, getData(), destSize);
    1441. 

  1441.                                 break;
    1442. 

  1442. #if !defined(OSG_EMBEDDED)
    1443. 

  1443.                             case OSG_FLOAT16_IMAGEDATA:
    1444. 

  1444.                                 memcpy (data, getData(), destSize);
    1445. 

  1445.                                 break;
    1446. 

  1446. #endif
    1447. 

  1447.                             default:
    1448. 

  1448.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1449. 

  1449.                                 break;
    1450. 

  1450.                             }
    1451. 

  1451.                             break;
    1452. 

  1452. 

  1453.                         case OSG_RGB_PF:
    1454. 

  1454.                             switch (getDataType())
    1455. 

  1455.                             {
    1456. 

  1456.                             case OSG_UINT8_IMAGEDATA:
    1457. 

  1457.                                 for (srcI = destI = 0; destI < destSize;)
    1458. 

  1458.                                 {
    1459. 

  1459.                                     data[destI++] = sourceData[srcI];
    1460. 

  1460.                                     data[destI++] = sourceData[srcI];
    1461. 

  1461.                                     data[destI++] = sourceData[srcI++];
    1462. 

  1462.                                     srcI++;
    1463. 

  1463.                                 }
    1464. 

  1464.                                 break;
    1465. 

  1465. #if !defined(OSG_EMBEDDED)
    1466. 

  1466.                             case OSG_UINT16_IMAGEDATA:
    1467. 

  1467.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1468. 

  1468.                                 {
    1469. 

  1469.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1470. 

  1470.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1471. 

  1471.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1472. 

  1472.                                     srcI++;
    1473. 

  1473.                                 }
    1474. 

  1474.                                 break;
    1475. 

  1475.                             case OSG_UINT32_IMAGEDATA:
    1476. 

  1476.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1477. 

  1477.                                 {
    1478. 

  1478.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1479. 

  1479.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1480. 

  1480.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1481. 

  1481.                                     srcI++;
    1482. 

  1482.                                 }
    1483. 

  1483.                                 break;
    1484. 

  1484. #endif
    1485. 

  1485.                             case OSG_FLOAT32_IMAGEDATA:
    1486. 

  1486.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1487. 

  1487.                                 {
    1488. 

  1488.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1489. 

  1489.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1490. 

  1490.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1491. 

  1491.                                     srcI++;
    1492. 

  1492.                                 }
    1493. 

  1493.                                 break;
    1494. 

  1494. #if !defined(OSG_EMBEDDED)
    1495. 

  1495.                             case OSG_FLOAT16_IMAGEDATA:
    1496. 

  1496.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1497. 

  1497.                                 {
    1498. 

  1498.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1499. 

  1499.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1500. 

  1500.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1501. 

  1501.                                     srcI++;
    1502. 

  1502.                                 }
    1503. 

  1503.                                 break;
    1504. 

  1504. #endif
    1505. 

  1505.                             default:
    1506. 

  1506.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1507. 

  1507.                                 break;
    1508. 

  1508.                             }
    1509. 

  1509.                             break;
    1510. 

  1510. 

  1511.                         case OSG_RGBA_PF:
    1512. 

  1512.                             switch (getDataType())
    1513. 

  1513.                             {
    1514. 

  1514.                             case OSG_UINT8_IMAGEDATA:
    1515. 

  1515.                                 for (srcI = destI = 0; destI < destSize;)
    1516. 

  1516.                                 {
    1517. 

  1517.                                     data[destI++] = sourceData[srcI];
    1518. 

  1518.                                     data[destI++] = sourceData[srcI];
    1519. 

  1519.                                     data[destI++] = sourceData[srcI++];
    1520. 

  1520.                                     data[destI++] = sourceData[srcI++];
    1521. 

  1521.                                 }
    1522. 

  1522.                                 break;
    1523. 

  1523. #if !defined(OSG_EMBEDDED)
    1524. 

  1524.                             case OSG_UINT16_IMAGEDATA:
    1525. 

  1525.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1526. 

  1526.                                 {
    1527. 

  1527.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1528. 

  1528.                                     destDataUC16[destI++] = sourceDataUC16[srcI];
    1529. 

  1529.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1530. 

  1530.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    1531. 

  1531.                                 }
    1532. 

  1532.                                 break;
    1533. 

  1533.                             case OSG_UINT32_IMAGEDATA:
    1534. 

  1534.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1535. 

  1535.                                 {
    1536. 

  1536.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1537. 

  1537.                                     destDataUC32[destI++] = sourceDataUC32[srcI];
    1538. 

  1538.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1539. 

  1539.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    1540. 

  1540.                                 }
    1541. 

  1541.                                 break;
    1542. 

  1542. #endif
    1543. 

  1543.                             case OSG_FLOAT32_IMAGEDATA:
    1544. 

  1544.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1545. 

  1545.                                 {
    1546. 

  1546.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1547. 

  1547.                                     destDataF32[destI++] = sourceDataF32[srcI];
    1548. 

  1548.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1549. 

  1549.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1550. 

  1550.                                 }
    1551. 

  1551.                                 break;
    1552. 

  1552. #if !defined(OSG_EMBEDDED)
    1553. 

  1553.                             case OSG_FLOAT16_IMAGEDATA:
    1554. 

  1554.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1555. 

  1555.                                 {
    1556. 

  1556.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1557. 

  1557.                                     destDataH16[destI++] = sourceDataH16[srcI];
    1558. 

  1558.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1559. 

  1559.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1560. 

  1560.                                 }
    1561. 

  1561.                                 break;
    1562. 

  1562. #endif
    1563. 

  1563.                             default:
    1564. 

  1564.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1565. 

  1565.                                 break;
    1566. 

  1566.                             }
    1567. 

  1567.                             break;
    1568. 

  1568.                     default:
    1569. 

  1569.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1570. 

  1570.                         break;
    1571. 

  1571.                     }
    1572. 

  1572.                     break;
    1573. 

  1573. 

  1574.                 //-----------------------------------------------------
    1575. 

  1575.                 case OSG_RGB_PF:
    1576. 

  1576.                     switch (pixelFormat) {
    1577. 

  1577.                         case OSG_A_PF:
    1578. 

  1578. #if !defined(OSG_EMBEDDED)
    1579. 

  1579.                         case OSG_I_PF:
    1580. 

  1580. #endif
    1581. 

  1581.                         case OSG_L_PF:
    1582. 

  1582.                             switch (getDataType())
    1583. 

  1583.                             {
    1584. 

  1584.                             case OSG_UINT8_IMAGEDATA:
    1585. 

  1585.                                 for (srcI = destI = 0; destI < destSize;)
    1586. 

  1586.                                 {
    1587. 

  1587.                                     sum = 0;
    1588. 

  1588.                                     sum += sourceData[srcI++];
    1589. 

  1589.                                     sum += sourceData[srcI++];
    1590. 

  1590.                                     sum += sourceData[srcI++];
    1591. 

  1591.                                     data[destI++] = sum / 3;
    1592. 

  1592.                                 }
    1593. 

  1593.                                 break;
    1594. 

  1594. #if !defined(OSG_EMBEDDED)
    1595. 

  1595.                             case OSG_UINT16_IMAGEDATA:
    1596. 

  1596.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1597. 

  1597.                                 {
    1598. 

  1598.                                     sum = 0;
    1599. 

  1599.                                     sum += sourceDataUC16[srcI++];
    1600. 

  1600.                                     sum += sourceDataUC16[srcI++];
    1601. 

  1601.                                     sum += sourceDataUC16[srcI++];
    1602. 

  1602.                                     destDataUC16[destI++] = sum / 3;
    1603. 

  1603.                                 }
    1604. 

  1604.                                 break;
    1605. 

  1605.                             case OSG_UINT32_IMAGEDATA:
    1606. 

  1606.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1607. 

  1607.                                 {
    1608. 

  1608.                                     sum = 0;
    1609. 

  1609.                                     sum += sourceDataUC32[srcI++];
    1610. 

  1610.                                     sum += sourceDataUC32[srcI++];
    1611. 

  1611.                                     sum += sourceDataUC32[srcI++];
    1612. 

  1612.                                     destDataUC32[destI++] = sum / 3;
    1613. 

  1613.                                 }
    1614. 

  1614.                                 break;
    1615. 

  1615. #endif
    1616. 

  1616.                             case OSG_FLOAT32_IMAGEDATA:
    1617. 

  1617.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1618. 

  1618.                                 {
    1619. 

  1619.                                     sumReal = 0;
    1620. 

  1620.                                     sumReal += sourceDataF32[srcI++];
    1621. 

  1621.                                     sumReal += sourceDataF32[srcI++];
    1622. 

  1622.                                     sumReal += sourceDataF32[srcI++];
    1623. 

  1623.                                     destDataF32[destI++] = sumReal / 3.0;
    1624. 

  1624.                                 }
    1625. 

  1625.                                 break;
    1626. 

  1626. #if !defined(OSG_EMBEDDED)
    1627. 

  1627.                             case OSG_FLOAT16_IMAGEDATA:
    1628. 

  1628.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1629. 

  1629.                                 {
    1630. 

  1630.                                     sumReal = 0;
    1631. 

  1631.                                     sumReal += sourceDataH16[srcI++];
    1632. 

  1632.                                     sumReal += sourceDataH16[srcI++];
    1633. 

  1633.                                     sumReal += sourceDataH16[srcI++];
    1634. 

  1634.                                     destDataH16[destI++] = sumReal / 3.0;
    1635. 

  1635.                                 }
    1636. 

  1636.                                 break;
    1637. 

  1637. #endif
    1638. 

  1638.                             default:
    1639. 

  1639.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1640. 

  1640.                                 break;
    1641. 

  1641.                             }
    1642. 

  1642.                             break;
    1643. 

  1643.                         case OSG_LA_PF:
    1644. 

  1644.                             switch (getDataType())
    1645. 

  1645.                             {
    1646. 

  1646.                             case OSG_UINT8_IMAGEDATA:
    1647. 

  1647.                                 for (srcI = destI = 0; destI < destSize;)
    1648. 

  1648.                                 {
    1649. 

  1649.                                     sum = 0;
    1650. 

  1650.                                     sum += sourceData[srcI++];
    1651. 

  1651.                                     sum += sourceData[srcI++];
    1652. 

  1652.                                     sum += sourceData[srcI++];
    1653. 

  1653.                                     data[destI++] = sum / 3;
    1654. 

  1654.                                     data[destI++] = sum / 3;
    1655. 

  1655.                                 }
    1656. 

  1656.                                 break;
    1657. 

  1657. #if !defined(OSG_EMBEDDED)
    1658. 

  1658.                             case OSG_UINT16_IMAGEDATA:
    1659. 

  1659.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1660. 

  1660.                                 {
    1661. 

  1661.                                     sum = 0;
    1662. 

  1662.                                     sum += sourceDataUC16[srcI++];
    1663. 

  1663.                                     sum += sourceDataUC16[srcI++];
    1664. 

  1664.                                     sum += sourceDataUC16[srcI++];
    1665. 

  1665.                                     destDataUC16[destI++] = sum / 3;
    1666. 

  1666.                                     destDataUC16[destI++] = sum / 3;
    1667. 

  1667.                                 }
    1668. 

  1668.                                 break;
    1669. 

  1669.                             case OSG_UINT32_IMAGEDATA:
    1670. 

  1670.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1671. 

  1671.                                 {
    1672. 

  1672.                                     sum = 0;
    1673. 

  1673.                                     sum += sourceDataUC32[srcI++];
    1674. 

  1674.                                     sum += sourceDataUC32[srcI++];
    1675. 

  1675.                                     sum += sourceDataUC32[srcI++];
    1676. 

  1676.                                     destDataUC32[destI++] = sum / 3;
    1677. 

  1677.                                     destDataUC32[destI++] = sum / 3;
    1678. 

  1678.                                 }
    1679. 

  1679.                                 break;
    1680. 

  1680. #endif
    1681. 

  1681.                             case OSG_FLOAT32_IMAGEDATA:
    1682. 

  1682.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1683. 

  1683.                                 {
    1684. 

  1684.                                     sumReal = 0;
    1685. 

  1685.                                     sumReal += sourceDataF32[srcI++];
    1686. 

  1686.                                     sumReal += sourceDataF32[srcI++];
    1687. 

  1687.                                     sumReal += sourceDataF32[srcI++];
    1688. 

  1688.                                     destDataF32[destI++] = sumReal / 3.0;
    1689. 

  1689.                                     destDataF32[destI++] = sumReal / 3.0;
    1690. 

  1690.                                 }
    1691. 

  1691.                                 break;
    1692. 

  1692. #if !defined(OSG_EMBEDDED)
    1693. 

  1693.                             case OSG_FLOAT16_IMAGEDATA:
    1694. 

  1694.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1695. 

  1695.                                 {
    1696. 

  1696.                                     sumReal = 0;
    1697. 

  1697.                                     sumReal += sourceDataH16[srcI++];
    1698. 

  1698.                                     sumReal += sourceDataH16[srcI++];
    1699. 

  1699.                                     sumReal += sourceDataH16[srcI++];
    1700. 

  1700.                                     destDataH16[destI++] = sumReal / 3.0;
    1701. 

  1701.                                     destDataH16[destI++] = sumReal / 3.0;
    1702. 

  1702.                                 }
    1703. 

  1703.                                 break;
    1704. 

  1704. #endif
    1705. 

  1705.                             default:
    1706. 

  1706.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1707. 

  1707.                                 break;
    1708. 

  1708.                             }
    1709. 

  1709.                             break;
    1710. 

  1710.                         case OSG_RGB_PF:
    1711. 

  1711.                            switch (getDataType())
    1712. 

  1712.                             {
    1713. 

  1713.                             case OSG_UINT8_IMAGEDATA:
    1714. 

  1714.                                 memcpy (data, getData(), destSize);
    1715. 

  1715.                                 break;
    1716. 

  1716. #if !defined(OSG_EMBEDDED)
    1717. 

  1717.                             case OSG_UINT16_IMAGEDATA:
    1718. 

  1718.                                 memcpy (data, getData(), destSize);
    1719. 

  1719.                                 break;
    1720. 

  1720.                             case OSG_UINT32_IMAGEDATA:
    1721. 

  1721.                                 memcpy (data, getData(), destSize);
    1722. 

  1722.                                 break;
    1723. 

  1723. #endif
    1724. 

  1724.                             case OSG_FLOAT32_IMAGEDATA:
    1725. 

  1725.                                 memcpy (data, getData(), destSize);
    1726. 

  1726.                                 break;
    1727. 

  1727. #if !defined(OSG_EMBEDDED)
    1728. 

  1728.                             case OSG_FLOAT16_IMAGEDATA:
    1729. 

  1729.                                 memcpy (data, getData(), destSize);
    1730. 

  1730.                                 break;
    1731. 

  1731. #endif
    1732. 

  1732.                             default:
    1733. 

  1733.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1734. 

  1734.                                 break;
    1735. 

  1735.                             }
    1736. 

  1736.                             break;
    1737. 

  1737. 

  1738.                         case OSG_RGBA_PF:
    1739. 

  1739.                             switch (getDataType())
    1740. 

  1740.                             {
    1741. 

  1741.                             case OSG_UINT8_IMAGEDATA:
    1742. 

  1742.                                 for (srcI = destI = 0; destI < destSize;)
    1743. 

  1743.                                 {
    1744. 

  1744.                                     sum = 0;
    1745. 

  1745.                                     sum += data[destI++] = sourceData[srcI++];
    1746. 

  1746.                                     sum += data[destI++] = sourceData[srcI++];
    1747. 

  1747.                                     sum += data[destI++] = sourceData[srcI++];
    1748. 

  1748.                                     data[destI++] = sum / 3;
    1749. 

  1749.                                 }
    1750. 

  1750.                                 break;
    1751. 

  1751. #if !defined(OSG_EMBEDDED)
    1752. 

  1752.                             case OSG_UINT16_IMAGEDATA:
    1753. 

  1753.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1754. 

  1754.                                 {
    1755. 

  1755.                                     sum = 0;
    1756. 

  1756.                                     sum += destDataUC16[destI++] = sourceDataUC16[srcI++];
    1757. 

  1757.                                     sum += destDataUC16[destI++] = sourceDataUC16[srcI++];
    1758. 

  1758.                                     sum += destDataUC16[destI++] = sourceDataUC16[srcI++];
    1759. 

  1759.                                     destDataUC16[destI++] = sum / 3;
    1760. 

  1760.                                 }
    1761. 

  1761.                                 break;
    1762. 

  1762.                             case OSG_UINT32_IMAGEDATA:
    1763. 

  1763.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1764. 

  1764.                                 {
    1765. 

  1765.                                     sum = 0;
    1766. 

  1766.                                     sum += destDataUC32[destI++] = sourceDataUC32[srcI++];
    1767. 

  1767.                                     sum += destDataUC32[destI++] = sourceDataUC32[srcI++];
    1768. 

  1768.                                     sum += destDataUC32[destI++] = sourceDataUC32[srcI++];
    1769. 

  1769.                                     destDataUC32[destI++] = sum / 3;
    1770. 

  1770.                                 }
    1771. 

  1771.                                 break;
    1772. 

  1772. #endif
    1773. 

  1773.                             case OSG_FLOAT32_IMAGEDATA:
    1774. 

  1774.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1775. 

  1775.                                 {
    1776. 

  1776.                                     sumReal = 0;
    1777. 

  1777.                                     sumReal += destDataF32[destI++] = sourceDataF32[srcI++];
    1778. 

  1778.                                     sumReal += destDataF32[destI++] = sourceDataF32[srcI++];
    1779. 

  1779.                                     sumReal += destDataF32[destI++] = sourceDataF32[srcI++];
    1780. 

  1780.                                     destDataF32[destI++] = sumReal / 3.0;
    1781. 

  1781.                                 }
    1782. 

  1782.                                 break;
    1783. 

  1783. #if !defined(OSG_EMBEDDED)
    1784. 

  1784.                             case OSG_FLOAT16_IMAGEDATA:
    1785. 

  1785.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1786. 

  1786.                                 {
    1787. 

  1787.                                     sumReal = 0;
    1788. 

  1788.                                     sumReal += destDataH16[destI++] = sourceDataH16[srcI++];
    1789. 

  1789.                                     sumReal += destDataH16[destI++] = sourceDataH16[srcI++];
    1790. 

  1790.                                     sumReal += destDataH16[destI++] = sourceDataH16[srcI++];
    1791. 

  1791.                                     destDataH16[destI++] = sumReal / 3.0;
    1792. 

  1792.                                 }
    1793. 

  1793.                                 break;
    1794. 

  1794. #endif
    1795. 

  1795.                             default:
    1796. 

  1796.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1797. 

  1797.                                 break;
    1798. 

  1798.                             }
    1799. 

  1799.                             break;
    1800. 

  1800.                     default:
    1801. 

  1801.                         FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1802. 

  1802.                         break;
    1803. 

  1803.                     }
    1804. 

  1804.                     break;
    1805. 

  1805.                     //-----------------------------------------------------
    1806. 

  1806.                 case OSG_RGBA_PF:
    1807. 

  1807.                     switch (pixelFormat) {
    1808. 

  1808.                         case OSG_A_PF:
    1809. 

  1809.                             switch (getDataType())
    1810. 

  1810.                             {
    1811. 

  1811.                             case OSG_UINT8_IMAGEDATA:
    1812. 

  1812.                                 for (srcI = destI = 0; destI < destSize;)
    1813. 

  1813.                                 {
    1814. 

  1814.                                     srcI += 3;
    1815. 

  1815.                                     data[destI++] = sourceData[srcI++];;
    1816. 

  1816.                                 }
    1817. 

  1817.                                 break;
    1818. 

  1818. #if !defined(OSG_EMBEDDED)
    1819. 

  1819.                             case OSG_UINT16_IMAGEDATA:
    1820. 

  1820.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1821. 

  1821.                                 {
    1822. 

  1822.                                     srcI += 3;
    1823. 

  1823.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];;
    1824. 

  1824.                                 }
    1825. 

  1825.                                 break;
    1826. 

  1826.                             case OSG_UINT32_IMAGEDATA:
    1827. 

  1827.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1828. 

  1828.                                 {
    1829. 

  1829.                                     srcI += 3;
    1830. 

  1830.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];;
    1831. 

  1831.                                 }
    1832. 

  1832.                                 break;
    1833. 

  1833. #endif
    1834. 

  1834.                             case OSG_FLOAT32_IMAGEDATA:
    1835. 

  1835.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1836. 

  1836.                                 {
    1837. 

  1837.                                     srcI += 3;
    1838. 

  1838.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1839. 

  1839.                                 }
    1840. 

  1840.                                 break;
    1841. 

  1841. #if !defined(OSG_EMBEDDED)
    1842. 

  1842.                             case OSG_FLOAT16_IMAGEDATA:
    1843. 

  1843.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1844. 

  1844.                                 {
    1845. 

  1845.                                     srcI += 3;
    1846. 

  1846.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1847. 

  1847.                                 }
    1848. 

  1848.                                 break;
    1849. 

  1849. #endif
    1850. 

  1850.                             default:
    1851. 

  1851.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1852. 

  1852.                                 break;
    1853. 

  1853.                             }
    1854. 

  1854.                             break;
    1855. 

  1855. #if !defined(OSG_EMBEDDED)
    1856. 

  1856.                         case OSG_I_PF:
    1857. 

  1857. #endif
    1858. 

  1858.                         case OSG_L_PF:
    1859. 

  1859.                             switch (getDataType())
    1860. 

  1860.                             {
    1861. 

  1861.                             case OSG_UINT8_IMAGEDATA:
    1862. 

  1862.                                 for (srcI = destI = 0; destI < destSize;)
    1863. 

  1863.                                 {
    1864. 

  1864.                                     sum = 0;
    1865. 

  1865.                                     sum += sourceData[srcI++];
    1866. 

  1866.                                     sum += sourceData[srcI++];
    1867. 

  1867.                                     sum += sourceData[srcI++];
    1868. 

  1868.                                     data[destI++] = sum / 3;
    1869. 

  1869.                                     srcI++;
    1870. 

  1870.                                 }
    1871. 

  1871.                                 break;
    1872. 

  1872. #if !defined(OSG_EMBEDDED)
    1873. 

  1873.                             case OSG_UINT16_IMAGEDATA:
    1874. 

  1874.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1875. 

  1875.                                 {
    1876. 

  1876.                                     sum = 0;
    1877. 

  1877.                                     sum += sourceDataUC16[srcI++];
    1878. 

  1878.                                     sum += sourceDataUC16[srcI++];
    1879. 

  1879.                                     sum += sourceDataUC16[srcI++];
    1880. 

  1880.                                     destDataUC16[destI++] = sum / 3;
    1881. 

  1881.                                     srcI++;
    1882. 

  1882.                                 }
    1883. 

  1883.                                 break;
    1884. 

  1884.                             case OSG_UINT32_IMAGEDATA:
    1885. 

  1885.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1886. 

  1886.                                 {
    1887. 

  1887.                                     sum = 0;
    1888. 

  1888.                                     sum += sourceDataUC32[srcI++];
    1889. 

  1889.                                     sum += sourceDataUC32[srcI++];
    1890. 

  1890.                                     sum += sourceDataUC32[srcI++];
    1891. 

  1891.                                     destDataUC32[destI++] = sum / 3;
    1892. 

  1892.                                     srcI++;
    1893. 

  1893.                                 }
    1894. 

  1894.                                 break;
    1895. 

  1895. #endif
    1896. 

  1896.                             case OSG_FLOAT32_IMAGEDATA:
    1897. 

  1897.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1898. 

  1898.                                 {
    1899. 

  1899.                                     sumReal = 0;
    1900. 

  1900.                                     sumReal += sourceDataF32[srcI++];
    1901. 

  1901.                                     sumReal += sourceDataF32[srcI++];
    1902. 

  1902.                                     sumReal += sourceDataF32[srcI++];
    1903. 

  1903.                                     destDataF32[destI++] = sumReal / 3.0;
    1904. 

  1904.                                     srcI++;
    1905. 

  1905.                                 }
    1906. 

  1906.                                 break;
    1907. 

  1907. #if !defined(OSG_EMBEDDED)
    1908. 

  1908.                             case OSG_FLOAT16_IMAGEDATA:
    1909. 

  1909.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1910. 

  1910.                                 {
    1911. 

  1911.                                     sumReal = 0;
    1912. 

  1912.                                     sumReal += sourceDataH16[srcI++];
    1913. 

  1913.                                     sumReal += sourceDataH16[srcI++];
    1914. 

  1914.                                     sumReal += sourceDataH16[srcI++];
    1915. 

  1915.                                     destDataH16[destI++] = sumReal / 3.0;
    1916. 

  1916.                                     srcI++;
    1917. 

  1917.                                 }
    1918. 

  1918.                                 break;
    1919. 

  1919. #endif
    1920. 

  1920.                             default:
    1921. 

  1921.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1922. 

  1922.                                 break;
    1923. 

  1923.                             }
    1924. 

  1924.                             break;
    1925. 

  1925.                         case OSG_LA_PF:
    1926. 

  1926.                             switch (getDataType())
    1927. 

  1927.                             {
    1928. 

  1928.                             case OSG_UINT8_IMAGEDATA:
    1929. 

  1929.                                 for (srcI = destI = 0; destI < destSize;)
    1930. 

  1930.                                 {
    1931. 

  1931.                                     sum = 0;
    1932. 

  1932.                                     sum += sourceData[srcI++];
    1933. 

  1933.                                     sum += sourceData[srcI++];
    1934. 

  1934.                                     sum += sourceData[srcI++];
    1935. 

  1935.                                     data[destI++] = sum / 3;
    1936. 

  1936.                                     data[destI++] = sourceData[srcI++];;
    1937. 

  1937.                                 }
    1938. 

  1938.                                 break;
    1939. 

  1939. #if !defined(OSG_EMBEDDED)
    1940. 

  1940.                             case OSG_UINT16_IMAGEDATA:
    1941. 

  1941.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1942. 

  1942.                                 {
    1943. 

  1943.                                     sum = 0;
    1944. 

  1944.                                     sum += sourceDataUC16[srcI++];
    1945. 

  1945.                                     sum += sourceDataUC16[srcI++];
    1946. 

  1946.                                     sum += sourceDataUC16[srcI++];
    1947. 

  1947.                                     destDataUC16[destI++] = sum / 3;
    1948. 

  1948.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];;
    1949. 

  1949.                                 }
    1950. 

  1950.                                 break;
    1951. 

  1951.                             case OSG_UINT32_IMAGEDATA:
    1952. 

  1952.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1953. 

  1953.                                 {
    1954. 

  1954.                                     sum = 0;
    1955. 

  1955.                                     sum += sourceDataUC32[srcI++];
    1956. 

  1956.                                     sum += sourceDataUC32[srcI++];
    1957. 

  1957.                                     sum += sourceDataUC32[srcI++];
    1958. 

  1958.                                     destDataUC32[destI++] = sum / 3;
    1959. 

  1959.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];;
    1960. 

  1960.                                 }
    1961. 

  1961.                                 break;
    1962. 

  1962. #endif
    1963. 

  1963.                             case OSG_FLOAT32_IMAGEDATA:
    1964. 

  1964.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1965. 

  1965.                                 {
    1966. 

  1966.                                     sumReal = 0;
    1967. 

  1967.                                     sumReal += sourceDataF32[srcI++];
    1968. 

  1968.                                     sumReal += sourceDataF32[srcI++];
    1969. 

  1969.                                     sumReal += sourceDataF32[srcI++];
    1970. 

  1970.                                     destDataF32[destI++] = sumReal / 3.0;
    1971. 

  1971.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    1972. 

  1972.                                 }
    1973. 

  1973.                                 break;
    1974. 

  1974. #if !defined(OSG_EMBEDDED)
    1975. 

  1975.                             case OSG_FLOAT16_IMAGEDATA:
    1976. 

  1976.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    1977. 

  1977.                                 {
    1978. 

  1978.                                     sumReal = 0;
    1979. 

  1979.                                     sumReal += sourceDataH16[srcI++];
    1980. 

  1980.                                     sumReal += sourceDataH16[srcI++];
    1981. 

  1981.                                     sumReal += sourceDataH16[srcI++];
    1982. 

  1982.                                     destDataH16[destI++] = sumReal / 3.0;
    1983. 

  1983.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    1984. 

  1984.                                 }
    1985. 

  1985.                                 break;
    1986. 

  1986. #endif
    1987. 

  1987.                             default:
    1988. 

  1988.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    1989. 

  1989.                                 break;
    1990. 

  1990.                             }
    1991. 

  1991.                             break;
    1992. 

  1992.                         case OSG_RGB_PF:
    1993. 

  1993.                            switch (getDataType())
    1994. 

  1994.                             {
    1995. 

  1995.                             case OSG_UINT8_IMAGEDATA:
    1996. 

  1996.                                 for (srcI = destI = 0; destI < destSize;)
    1997. 

  1997.                                 {
    1998. 

  1998.                                     data[destI++] = sourceData[srcI++];
    1999. 

  1999.                                     data[destI++] = sourceData[srcI++];
    2000. 

  2000.                                     data[destI++] = sourceData[srcI++];
    2001. 

  2001.                                     srcI++;
    2002. 

  2002.                                 }
    2003. 

  2003.                                 break;
    2004. 

  2004. #if !defined(OSG_EMBEDDED)
    2005. 

  2005.                             case OSG_UINT16_IMAGEDATA:
    2006. 

  2006.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    2007. 

  2007.                                 {
    2008. 

  2008.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    2009. 

  2009.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    2010. 

  2010.                                     destDataUC16[destI++] = sourceDataUC16[srcI++];
    2011. 

  2011.                                     srcI++;
    2012. 

  2012.                                 }
    2013. 

  2013.                                 break;
    2014. 

  2014.                             case OSG_UINT32_IMAGEDATA:
    2015. 

  2015.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    2016. 

  2016.                                 {
    2017. 

  2017.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    2018. 

  2018.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    2019. 

  2019.                                     destDataUC32[destI++] = sourceDataUC32[srcI++];
    2020. 

  2020.                                     srcI++;
    2021. 

  2021.                                 }
    2022. 

  2022.                                 break;
    2023. 

  2023. #endif
    2024. 

  2024.                             case OSG_FLOAT32_IMAGEDATA:
    2025. 

  2025.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    2026. 

  2026.                                 {
    2027. 

  2027.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    2028. 

  2028.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    2029. 

  2029.                                     destDataF32[destI++] = sourceDataF32[srcI++];
    2030. 

  2030.                                     srcI++;
    2031. 

  2031.                                 }
    2032. 

  2032.                                 break;
    2033. 

  2033. #if !defined(OSG_EMBEDDED)
    2034. 

  2034.                             case OSG_FLOAT16_IMAGEDATA:
    2035. 

  2035.                                 for (srcI = destI = 0; destI < destSize/getComponentSize();)
    2036. 

  2036.                                 {
    2037. 

  2037.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    2038. 

  2038.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    2039. 

  2039.                                     destDataH16[destI++] = sourceDataH16[srcI++];
    2040. 

  2040.                                     srcI++;
    2041. 

  2041.                                 }
    2042. 

  2042.                                 break;
    2043. 

  2043. #endif
    2044. 

  2044.                             default:
    2045. 

  2045.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    2046. 

  2046.                                 break;
    2047. 

  2047.                             }
    2048. 

  2048.                             break;
    2049. 

  2049.                         case OSG_RGBA_PF:
    2050. 

  2050.                             switch (getDataType())
    2051. 

  2051.                             {
    2052. 

  2052.                             case OSG_UINT8_IMAGEDATA:
    2053. 

  2053.                                 memcpy (data, getData(), destSize);
    2054. 

  2054.                                 break;
    2055. 

  2055. #if !defined(OSG_EMBEDDED)
    2056. 

  2056.                             case OSG_UINT16_IMAGEDATA:
    2057. 

  2057.                                 memcpy (data, getData(), destSize);
    2058. 

  2058.                                 break;
    2059. 

  2059.                             case OSG_UINT32_IMAGEDATA:
    2060. 

  2060.                                 memcpy (data, getData(), destSize);
    2061. 

  2061.                                 break;
    2062. 

  2062. #endif
    2063. 

  2063.                             case OSG_FLOAT32_IMAGEDATA:
    2064. 

  2064.                                 memcpy (data, getData(), destSize);
    2065. 

  2065.                                 break;
    2066. 

  2066. #if !defined(OSG_EMBEDDED)
    2067. 

  2067.                             case OSG_FLOAT16_IMAGEDATA:
    2068. 

  2068.                                 memcpy (data, getData(), destSize);
    2069. 

  2069.                                 break;
    2070. 

  2070. #endif
    2071. 

  2071.                             default:
    2072. 

  2072.                                 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    2073. 

  2073.                                 break;
    2074. 

  2074.                             }
    2075. 

  2075.                             break;
    2076. 

  2076. 

  2077.                         default:
    2078. 

  2078.                             break;
    2079. 

  2079.                     }
    2080. 

  2080.                     break;
    2081. 

  2081. 

  2082.                 default:
    2083. 

  2083.                     FWARNING (( "Unvalid pixeldepth (%d) in reformat() !\n",
    2084. 

  2084.                                 pixelFormat ));
    2085. 

  2085.             }
    2086. 

  2086.         }
    2087. 

  2087.         if (data)
    2088. 

  2088.         {
    2089. 

  2089.             // rip the data from the local destImage if necessary
    2090. 

  2090.             if(destination == NullFC)
    2091. 

  2091.             {
    2092. 

  2092.                 this->set(dest);
    2093. 

  2093.                 subRef(dest);
    2094. 

  2094.             }
    2095. 

  2095.         }
    2096. 

  2096.     }
    2097. 

  2097.     
    2098. 

  2098.     return (data ? true : false);
    2099. 

  2099. }
    2100. 

  2100. 

  2101. void Image::swapDataEndian(void)
    2102. 

  2102. {
    2103. 

  2103.     UChar8 *data     = editData();
    2104. 

  2104. 

  2105.     UInt32  size     = getSize() / getComponentSize();
    2106. 

  2106.     UInt16 *dataUC16 = (UInt16 *) data;
    2107. 

  2107.     UInt32 *dataUC32 = (UInt32 *) data;
    2108. 

  2108.     Real32 *dataF32  = (Real32 *) data;
    2109. 

  2109.     
    2110. 

  2110. 

  2111.     switch (getDataType())
    2112. 

  2112.     {
    2113. 

  2113.         case OSG_UINT8_IMAGEDATA:
    2114. 

  2114.             // do nothing
    2115. 

  2115.             break;
    2116. 

  2116.             
    2117. 

  2117. #if !defined(OSG_EMBEDDED)
    2118. 

  2118.         case OSG_UINT16_IMAGEDATA:
    2119. 

  2119. 

  2120.             for(UInt32 i=0;i<size;++i)
    2121. 

  2121.             {
    2122. 

  2122.                 UInt16 p = dataUC16[i];
    2123. 

  2123. 

  2124.                 dataUC16[i] = (((p >> 8)) | (p << 8));
    2125. 

  2125.             }
    2126. 

  2126.             break;
    2127. 

  2127.             
    2128. 

  2128.         case OSG_UINT32_IMAGEDATA:
    2129. 

  2129. 

  2130.             for(UInt32 i=0;i<size;++i)
    2131. 

  2131.             {
    2132. 

  2132.                 UInt32 p = dataUC32[i];
    2133. 

  2133. 

  2134.                 dataUC32[i] = 
    2135. 

  2135.                     (((p & 0x000000FF) << 24) | ((p & 0x0000FF00) <<  8) |
    2136. 

  2136.                      ((p & 0x00FF0000) >>  8) | ((p & 0xFF000000) >> 24) );
    2137. 

  2137.             }
    2138. 

  2138. 

  2139.             break;
    2140. 

  2140. #endif            
    2141. 

  2141.         case OSG_FLOAT32_IMAGEDATA:
    2142. 

  2142. 

  2143.             for(UInt32 i=0;i<size;++i)
    2144. 

  2144.             {
    2145. 

  2145.                 Real32 p = dataF32[i];
    2146. 

  2146.                 UInt8 *b = (UInt8 *) &p;
    2147. 

  2147. 

  2148.                 std::swap(b[0], b[3]);
    2149. 

  2149.                 std::swap(b[1], b[2]);
    2150. 

  2150. 

  2151.                 dataF32[i] = p;
    2152. 

  2152.             }
    2153. 

  2153.             break;
    2154. 

  2154.             
    2155. 

  2155.         default:
    2156. 

  2156.             FWARNING (( "invalid source data type \n"));
    2157. 

  2157.             break;
    2158. 

  2158.     }
    2159. 

  2159. }
    2160. 

  2160. 

  2161. /*! It is a simple method to convert the image dataType. Does not change 
    2162. 

  2162.   the pixelFormat. So you can for example convert a image consisting of 
    2163. 

  2163.   UChar8 data to Float data.
    2164. 

  2164.  */
    2165. 

  2165. 

  2166. bool Image::convertDataTypeTo(Int32 destDataType)
    2167. 

  2167. {
    2168. 

  2168.     if (hasCompressedData()) 
    2169. 

  2169.     {
    2170. 

  2170.         FFATAL (("Invalid Image::convertDataTypeTo for compressed image\n"));
    2171. 

  2171.         return false;
    2172. 

  2172.     }
    2173. 

  2173. 

  2174.     if(destDataType == getDataType())
    2175. 

  2175.     {
    2176. 

  2176.         FWARNING (( "source image and destination image have same data "
    2177. 

  2177.                     "types: no conversion possible"));
    2178. 

  2178.         return true;
    2179. 

  2179.     }
    2180. 

  2180. 

  2181.     FINFO(("Try to convert image from dataType %d to %d\n",
    2182. 

  2182.            getDataType(), destDataType));
    2183. 

  2183. 

  2184.     ImagePtr dest;
    2185. 

  2185. 

  2186.     dest = Image::create();
    2187. 

  2187. 

  2188.     addRef(dest);
    2189. 

  2189. 

  2190.     dest->set(getPixelFormat(), 
    2191. 

  2191.               getWidth      (), 
    2192. 

  2192.               getHeight     (), 
    2193. 

  2193.               getDepth      (), 
    2194. 

  2194.               getMipMapCount(), 
    2195. 

  2195.               getFrameCount (), 
    2196. 

  2196.               0.0, 
    2197. 

  2197.               0, 
    2198. 

  2198.               destDataType,
    2199. 

  2199.               true,
    2200. 

  2200.               getSideCount()  );
    2201. 

  2201. 

  2202.     const UChar8 *sourceData = getData();
    2203. 

  2203.           UChar8 *destData   = dest->editData();
    2204. 

  2204. 

  2205.     Int32 sourceSize =       getSize() /       getComponentSize();
    2206. 

  2206.     Int32 destSize   = dest->getSize() / dest->getComponentSize();
    2207. 

  2207. 

  2208.     const UInt16 *sourceDataUC16 = (const UInt16 *) sourceData;
    2209. 

  2209.           UInt16 *destDataUC16   = (      UInt16 *) destData;
    2210. 

  2210.     const UInt32 *sourceDataUC32 = (const UInt32 *) sourceData;
    2211. 

  2211.           UInt32 *destDataUC32   = (      UInt32 *) destData;
    2212. 

  2212.     const Real32 *sourceDataF32  = (const Real32 *) sourceData;
    2213. 

  2213.           Real32 *destDataF32    = (      Real32 *) destData;
    2214. 

  2214.     const Real16 *sourceDataH16  = (const Real16 *) sourceData;
    2215. 

  2215.           Real16 *destDataH16    = (      Real16 *) destData;
    2216. 

  2216. 

  2217.     switch (getDataType())
    2218. 

  2218.     {
    2219. 

  2219.         case OSG_UINT8_IMAGEDATA:
    2220. 

  2220. 

  2221.             switch (destDataType)
    2222. 

  2222.             {
    2223. 

  2223. #if !defined(OSG_EMBEDDED)
    2224. 

  2224.                 case OSG_UINT16_IMAGEDATA:
    2225. 

  2225. 

  2226.                     for (int i = 0; i < sourceSize; i++)
    2227. 

  2227.                     {
    2228. 

  2228.                         destDataUC16[i] = (UInt16) (sourceData[i]<<8);
    2229. 

  2229.                     }
    2230. 

  2230.                     break;
    2231. 

  2231. 

  2232.                 case OSG_UINT32_IMAGEDATA:
    2233. 

  2233. 

  2234.                     for (int i = 0; i < sourceSize; i++)
    2235. 

  2235.                     {
    2236. 

  2236.                         destDataUC32[i] = (UInt32) (sourceData[i]<<24);
    2237. 

  2237.                     }
    2238. 

  2238.                     break;
    2239. 

  2239. #endif
    2240. 

  2240.                 case OSG_FLOAT32_IMAGEDATA:
    2241. 

  2241. 

  2242.                     for (int i = 0; i < sourceSize; i++)
    2243. 

  2243.                     {
    2244. 

  2244.                         destDataF32[i] = (Real32) (sourceData[i]/255.0);
    2245. 

  2245.                     }
    2246. 

  2246.                     break;
    2247. 

  2247. 

  2248. #if !defined(OSG_EMBEDDED)
    2249. 

  2249.                 case OSG_FLOAT16_IMAGEDATA:
    2250. 

  2250. 

  2251.                     for (int i = 0; i < sourceSize; i++)
    2252. 

  2252.                     {
    2253. 

  2253.                         destDataH16[i] = (Real16) (sourceData[i]/255.0);
    2254. 

  2254.                     }
    2255. 

  2255.                     break;
    2256. 

  2256. #endif
    2257. 

  2257.                 default:
    2258. 

  2258.                     FWARNING (( "invalid destination data type \n" ));
    2259. 

  2259.                     break;
    2260. 

  2260.             }
    2261. 

  2261.             
    2262. 

  2262.             break;
    2263. 

  2263.             
    2264. 

  2264. #if !defined(OSG_EMBEDDED)
    2265. 

  2265.         case OSG_UINT16_IMAGEDATA:
    2266. 

  2266. 

  2267.             switch (destDataType)
    2268. 

  2268.             {
    2269. 

  2269.                 case OSG_UINT8_IMAGEDATA:
    2270. 

  2270.                 {
    2271. 

  2271.                     UInt16 nMin = (UInt16) 65535;
    2272. 

  2272.                     UInt16 nMax = (UInt16) 0;
    2273. 

  2273. 

  2274.                     for (UInt32 i = 0; i < sourceSize; ++i)
    2275. 

  2275.                     {
    2276. 

  2276.                         if(sourceDataUC16[i] > nMax)
    2277. 

  2277.                             nMax = sourceDataUC16[i];
    2278. 

  2278. 

  2279.                         if(sourceDataUC16[i] < nMin)
    2280. 

  2280.                             nMin = sourceDataUC16[i];
    2281. 

  2281.                     }
    2282. 

  2282.                     
    2283. 

  2283.                     Real32 fRange = (Real32) nMax - nMin;
    2284. 

  2284. 

  2285.                     if (fRange <= 0.0)
    2286. 

  2286.                     {
    2287. 

  2287.                         for(UInt32 i = 0; i < sourceSize; ++i)
    2288. 

  2288.                             destData[i] = 0;
    2289. 

  2289.                     }
    2290. 

  2290.                     else
    2291. 

  2291.                     {
    2292. 

  2292.                         for(UInt32 i = 0; i < sourceSize; ++i)
    2293. 

  2293.                         {
    2294. 

  2294.                             destData[i] = (UInt8) 
    2295. 

  2295.                                 (255.0 * 
    2296. 

  2296.                                  ((Real32) (sourceDataUC16[i] - nMin)) / 
    2297. 

  2297.                                  fRange)                                ;
    2298. 

  2298.                         }
    2299. 

  2299.                     }
    2300. 

  2300.                 }
    2301. 

  2301.                 break;
    2302. 

  2302. 

  2303. #if !defined(OSG_EMBEDDED)
    2304. 

  2304.                 case OSG_UINT32_IMAGEDATA:
    2305. 

  2305. 

  2306.                     for (int i = 0; i < sourceSize; i++)
    2307. 

  2307.                     {
    2308. 

  2308.                         destDataUC32[i] = (UInt32) (sourceDataUC16[i]<<16);
    2309. 

  2309.                     }
    2310. 

  2310.                     break;
    2311. 

  2311. #endif
    2312. 

  2312.                 case OSG_FLOAT32_IMAGEDATA:
    2313. 

  2313. 

  2314.                     for (int i = 0; i < sourceSize; i++)
    2315. 

  2315.                     {
    2316. 

  2316.                         destDataF32[i] = (Real32) (sourceDataUC16[i]/65535.0);
    2317. 

  2317.                     }
    2318. 

  2318. 

  2319.                     break;
    2320. 

  2320. 

  2321. #if !defined(OSG_EMBEDDED)
    2322. 

  2322.                 case OSG_FLOAT16_IMAGEDATA:
    2323. 

  2323. 

  2324.                     for (int i = 0; i < sourceSize; i++)
    2325. 

  2325.                     {
    2326. 

  2326.                         destDataH16[i] = (Real16) (sourceDataUC16[i]/255.0);
    2327. 

  2327.                     }
    2328. 

  2328.                     break;
    2329. 

  2329. #endif
    2330. 

  2330.                 default:
    2331. 

  2331.                     FWARNING (( "invalid destination data type \n" ));
    2332. 

  2332.                     break;
    2333. 

  2333.             }
    2334. 

  2334.             break;
    2335. 

  2335. #endif
    2336. 

  2336.             
    2337. 

  2337. #if !defined(OSG_EMBEDDED)
    2338. 

  2338.         case OSG_UINT32_IMAGEDATA:
    2339. 

  2339. 

  2340.             switch (destDataType)
    2341. 

  2341.             {
    2342. 

  2342.                 case OSG_UINT8_IMAGEDATA:
    2343. 

  2343.                 {
    2344. 

  2344.                     UInt32 nMin = (UInt32) 4294967295ul;
    2345. 

  2345.                     UInt32 nMax = (UInt32) 0;
    2346. 

  2346. 

  2347.                     for (UInt32 i = 0; i < sourceSize; ++i)
    2348. 

  2348.                     {
    2349. 

  2349.                         if(sourceDataUC32[i] > nMax)
    2350. 

  2350.                             nMax = sourceDataUC32[i];
    2351. 

  2351. 

  2352.                         if(sourceDataUC32[i] < nMin)
    2353. 

  2353.                             nMin = sourceDataUC32[i];
    2354. 

  2354.                     }
    2355. 

  2355.                     
    2356. 

  2356.                     Real32 fRange = (Real32) nMax - nMin;
    2357. 

  2357. 

  2358.                     if (fRange <= 0.0)
    2359. 

  2359.                     {
    2360. 

  2360.                         for(UInt32 i = 0; i < sourceSize; ++i)
    2361. 

  2361.                             destData[i] = 0;
    2362. 

  2362.                     }
    2363. 

  2363.                     else
    2364. 

  2364.                     {
    2365. 

  2365.                         for(UInt32 i = 0; i < sourceSize; ++i)
    2366. 

  2366.                         {
    2367. 

  2367.                             destData[i] = (UInt8) 
    2368. 

  2368.                                 (255.0 * 
    2369. 

  2369.                                  ((Real32) (sourceDataUC32[i] - nMin)) / 
    2370. 

  2370.                                  fRange                                 );
    2371. 

  2371.                         }
    2372. 

  2372.                     }
    2373. 

  2373.                 }
    2374. 

  2374.                 break;
    2375. 

  2375. 

  2376.                 case OSG_UINT16_IMAGEDATA:
    2377. 

  2377.                 {
    2378. 

  2378.                     UInt32 nMin = (UInt32) 4294967295ul;
    2379. 

  2379.                     UInt32 nMax = (UInt32) 0;
    2380. 

  2380. 

  2381.                     for(UInt32 i = 0; i < sourceSize; ++i)
    2382. 

  2382.                     {
    2383. 

  2383.                         if(sourceDataUC32[i] > nMax)
    2384. 

  2384.                             nMax = sourceDataUC32[i];
    2385. 

  2385. 

  2386.                         if(sourceDataUC32[i] < nMin)
    2387. 

  2387.                             nMin = sourceDataUC32[i];
    2388. 

  2388.                     }
    2389. 

  2389.                     
    2390. 

  2390.                     Real32 fRange = (Real32) nMax - nMin;
    2391. 

  2391. 

  2392.                     if(fRange <= 0.0)
    2393. 

  2393.                     {
    2394. 

  2394.                         for(UInt32 i = 0; i < sourceSize; ++i)
    2395. 

  2395.                             destDataUC16[i] = 0;
    2396. 

  2396.                     }
    2397. 

  2397.                     else
    2398. 

  2398.                     {
    2399. 

  2399.                         for(UInt32 i = 0; i < sourceSize; ++i)
    2400. 

  2400.                             destDataUC16[i] = (UInt16) 
    2401. 

  2401.                                 (65535.0 * 
    2402. 

  2402.                                  ((Real32) (sourceDataUC32[i] - nMin)) / 
    2403. 

  2403.                                  fRange);
    2404. 

  2404.                     }
    2405. 

  2405.                 }
    2406. 

  2406.                 break;
    2407. 

  2407. 

  2408.                 case OSG_FLOAT32_IMAGEDATA:
    2409. 

  2409.                     for(int i = 0; i < sourceSize; i++)
    2410. 

  2410.                     {
    2411. 

  2411.                         destDataF32[i] = 
    2412. 

  2412.                             ((Real32) sourceDataUC32[i]) / 4294967295.0;
    2413. 

  2413.                     }
    2414. 

  2414.                     break;
    2415. 

  2415. 

  2416. #if !defined(OSG_EMBEDDED)
    2417. 

  2417.                 case OSG_FLOAT16_IMAGEDATA:
    2418. 

  2418. 

  2419.                     for (int i = 0; i < sourceSize; i++)
    2420. 

  2420.                     {
    2421. 

  2421.                         destDataH16[i] = 
    2422. 

  2422.                             ((Real16) sourceDataUC32[i]) / REAL16_MAX;
    2423. 

  2423.                     }
    2424. 

  2424.                     break;
    2425. 

  2425. #endif
    2426. 

  2426.                 default:
    2427. 

  2427.                     FWARNING(("invalid destination data type \n"));
    2428. 

  2428.                     break;
    2429. 

  2429.             }
    2430. 

  2430.             break;
    2431. 

  2431. #endif
    2432. 

  2432.             
    2433. 

  2433.         case OSG_FLOAT32_IMAGEDATA:
    2434. 

  2434. 

  2435.             switch(destDataType)
    2436. 

  2436.             {
    2437. 

  2437.                 case OSG_UINT8_IMAGEDATA:
    2438. 

  2438. 

  2439.                     for(int i = 0; i < sourceSize; i++)
    2440. 

  2440.                     {
    2441. 

  2441.                         destData[i] = (UInt8) (sourceDataF32[i]*255.0);
    2442. 

  2442.                     }
    2443. 

  2443.                     break;
    2444. 

  2444. 

  2445. #if !defined(OSG_EMBEDDED)
    2446. 

  2446.                 case OSG_UINT16_IMAGEDATA:
    2447. 

  2447. 

  2448.                     for(int i = 0; i < sourceSize; i++)
    2449. 

  2449.                     {
    2450. 

  2450.                         destDataUC16[i] = 
    2451. 

  2451.                             (UInt16) (sourceDataF32[i] * 65535.0);
    2452. 

  2452.                     }
    2453. 

  2453.                     break;
    2454. 

  2454. 

  2455.                 case OSG_UINT32_IMAGEDATA:
    2456. 

  2456.                     for(int i = 0; i < sourceSize; i++)
    2457. 

  2457.                     {
    2458. 

  2458.                         destDataUC32[i] = 
    2459. 

  2459.                             (UInt32) (sourceDataF32[i] * 4294967295.0);
    2460. 

  2460.                     }
    2461. 

  2461.                     break;
    2462. 

  2462. #endif
    2463. 

  2463. 

  2464. #if !defined(OSG_EMBEDDED)
    2465. 

  2465.                 case OSG_FLOAT16_IMAGEDATA:
    2466. 

  2466. 

  2467.                     for (int i = 0; i < sourceSize; i++)
    2468. 

  2468.                     {
    2469. 

  2469.                         destDataH16[i] = 
    2470. 

  2470.                             Real16 (sourceDataF32[i]); // half-constructor
    2471. 

  2471.                     }
    2472. 

  2472.                     break;
    2473. 

  2473. #endif
    2474. 

  2474.                 default:
    2475. 

  2475.                     FWARNING(("invalid destination data type \n"));
    2476. 

  2476.                     break;
    2477. 

  2477.             }
    2478. 

  2478.             break;
    2479. 

  2479.             
    2480. 

  2480.         default:
    2481. 

  2481.             FWARNING (( "invalid source data type \n"));
    2482. 

  2482.             break;
    2483. 

  2483.     }
    2484. 

  2484.     
    2485. 

  2485.     if(dest->getData() != NULL)
    2486. 

  2486.     {
    2487. 

  2487.         this->set(dest);
    2488. 

  2488. 

  2489.         subRef(dest);
    2490. 

  2490.     }
    2491. 

  2491.     
    2492. 

  2492.     return (getData() ? true : false);
    2493. 

  2493. }
    2494. 

  2494. 

  2495. /*! It just fills the hole image data with the given pixel value. It is
    2496. 

  2496.     mainly used to initialize the image data.
    2497. 

  2497.  */
    2498. 

  2498. 

  2499. void Image::clear(UChar8 pixelValue)
    2500. 

  2500. {
    2501. 

  2501.     memset(editData(), pixelValue, getSize());
    2502. 

  2502. }
    2503. 

  2503. 

  2504. void Image::clearFloat(Real32 pixelValue)
    2505. 

  2505. {
    2506. 

  2506.     unsigned long  n = getSize()/getComponentSize();
    2507. 

  2507.     Real32        *d = (Real32*) editData        ();
    2508. 

  2508.     
    2509. 

  2509.     if(n && d)
    2510. 

  2510.     {
    2511. 

  2511.         while(n--)
    2512. 

  2512.         {
    2513. 

  2513.             *d++ = pixelValue;
    2514. 

  2514.         }
    2515. 

  2515.     }
    2516. 

  2516. }
    2517. 

  2517. 

  2518. void Image::clearHalf(Real16 pixelValue)
    2519. 

  2519. {
    2520. 

  2520.     unsigned long   n = getSize()/getComponentSize();
    2521. 

  2521.     Real16       *d = (Real16*) getData();
    2522. 

  2522. 

  2523.     if(n && d)
    2524. 

  2524.         while(n--)
    2525. 

  2525.             *d++ = pixelValue;
    2526. 

  2526. }
    2527. 

  2527. 

  2528. /*-------------------------------------------------------------------------*/
    2529. 

  2529. /*                             attachment handling                         */
    2530. 

  2530. 

  2531. /*! returns true if the image has any attachments
    2532. 

  2532.  */
    2533. 

  2533. 

  2534. bool Image::hasAttachment(void) const
    2535. 

  2535. {
    2536. 

  2536.     Image *img=const_cast<Image*>(this);
    2537. 

  2537. 

  2538.     ImageGenericAttPtr att = dynamic_cast<ImageGenericAttPtr>(
    2539. 

  2539.         img->Inherited::findAttachment(
    2540. 

  2540.             ImageGenericAtt::getClassType().getGroupId()));
    2541. 

  2541. 

  2542.     if(att != NullFC && att->getType().getNumFieldDescs() > 1)
    2543. 

  2543.         return true;
    2544. 

  2544.     else
    2545. 

  2545.         return false;
    2546. 

  2546. }
    2547. 

  2547. 

  2548. /*! returns the number of attachments
    2549. 

  2549.  */
    2550. 

  2550. 

  2551. UInt32 Image::attachmentCount(void) const
    2552. 

  2552. {
    2553. 

  2553.     Image *img=const_cast<Image*>(this);
    2554. 

  2554. 

  2555.     ImageGenericAttPtr att = dynamic_cast<ImageGenericAttPtr>(
    2556. 

  2556.         img->Inherited::findAttachment(
    2557. 

  2557.             ImageGenericAtt::getClassType().getGroupId()));
    2558. 

  2558. 

  2559.     if(att != NullFC)
    2560. 

  2560.     {
    2561. 

  2561.         return att->getType().getNumFieldDescs() -1;
    2562. 

  2562.     }
    2563. 

  2563.     else
    2564. 

  2564.     {
    2565. 

  2565.         return 0;
    2566. 

  2566.     }
    2567. 

  2567. }
    2568. 

  2568. 

  2569. /*! set a single string attachment for the given key/data pair
    2570. 

  2570.  */
    2571. 

  2571. 

  2572. void Image::setAttachmentField(const std::string &key,
    2573. 

  2573.                                const std::string &data)
    2574. 

  2574. {
    2575. 

  2575.     ImageGenericAttPtr att = dynamic_cast<ImageGenericAttPtr>(
    2576. 

  2576.         findAttachment(
    2577. 

  2577.             ImageGenericAtt::getClassType().getGroupId()));
    2578. 

  2578. 

  2579.     FieldContainerAttachmentPtr fooP = att;
    2580. 

  2580. 

  2581.     if(att == NullFC)
    2582. 

  2582.     {
    2583. 

  2583.         att = ImageGenericAtt::create();
    2584. 

  2584.         
    2585. 

  2585.         addAttachment(att);
    2586. 

  2586.     }
    2587. 

  2587. 

  2588.     if(att == NullFC)
    2589. 

  2589.     {
    2590. 

  2590.         FWARNING(("Image::setAttachmentField - can not create attachment\n"));
    2591. 

  2591. 

  2592.         return;
    2593. 

  2593.     }
    2594. 

  2594. 

  2595.     EditFieldHandlePtr field = att->editDynamicFieldByName(key.c_str());
    2596. 

  2596. 

  2597.     if(field == NULL)
    2598. 

  2598.     {
    2599. 

  2599.         FieldDescriptionBase *pDesc;
    2600. 

  2600. 

  2601.         pDesc = new SFString::Description(
    2602. 

  2602.             SFString::getClassType(),
    2603. 

  2603.             key.c_str(),
    2604. 

  2604.             "",
    2605. 

  2605.             0, 
    2606. 

  2606.             0,
    2607. 

  2607.             true,
    2608. 

  2608.             Field::SFDefaultFlags,
    2609. 

  2609.             reinterpret_cast<FieldEditMethodSig>(
    2610. 

  2610.                 &ImageGenericAtt::editDynamicField),
    2611. 

  2611.             reinterpret_cast<FieldGetMethodSig >(
    2612. 

  2612.                 &ImageGenericAtt::getDynamicField ));
    2613. 

  2613. 

  2614. 

  2615.         UInt32 fieldId = att->addField(*pDesc);
    2616. 

  2616. 

  2617.         field = att->editDynamicField(fieldId);
    2618. 

  2618.     }
    2619. 

  2619. 

  2620.     SFString::EditHandlePtr strField = 
    2621. 

  2621.         boost::static_pointer_cast<SFString::EditHandle>(field);
    2622. 

  2622. 

  2623.     if(strField != NULL && strField->isValid() == true)
    2624. 

  2624.         (*strField)->setValue(data);
    2625. 

  2625. }
    2626. 

  2626. 

  2627. /*! returns the string attachment for the given key or Null
    2628. 

  2628.  */
    2629. 

  2629. 

  2630. const std::string *Image::findAttachmentField(const std::string &key) const
    2631. 

  2631. {
    2632. 

  2632.     Image *img=const_cast<Image*>(this);
    2633. 

  2633. 

  2634.     ImageGenericAttPtr att = dynamic_cast<ImageGenericAttPtr>(
    2635. 

  2635.         img->findAttachment(
    2636. 

  2636.             ImageGenericAtt::getClassType().getGroupId()));
    2637. 

  2637. 

  2638.     if(att != NullFC)
    2639. 

  2639.     {
    2640. 

  2640.         GetFieldHandlePtr field = att->getDynamicFieldByName(key.c_str());
    2641. 

  2641. 

  2642.         if(field != NULL)
    2643. 

  2643.         {
    2644. 

  2644.             SFString::GetHandlePtr strField = 
    2645. 

  2645.                 boost::static_pointer_cast<SFString::GetHandle>(field);
    2646. 

  2646. 

  2647.             if(strField != NULL && strField->isValid() == true)
    2648. 

  2648.                 return &((*strField)->getValue());
    2649. 

  2649.         }
    2650. 

  2650.     }
    2651. 

  2651. 

  2652.     return NULL;
    2653. 

  2653. }
    2654. 

  2654. 

  2655. /*! Method to scale the image. It just does a very simple but fast
    2656. 

  2656.   'nearest' scale. Should handle mipmap and frame data correct.
    2657. 

  2657.   The method can operate on the object or stores the result in
    2658. 

  2658.   the optional destination Image.
    2659. 

  2659.  */
    2660. 

  2660. 

  2661. bool Image::scale(Int32    width, 
    2662. 

  2662.                   Int32    height, 
    2663. 

  2663.                   Int32    depth,
    2664. 

  2664.                   ImagePtr destination)
    2665. 

  2665. {
    2666. 

  2666.     ImagePtr  destImage;
    2667. 

  2667.     UInt32    sw, sh, sd, dw, dh, dd;
    2668. 

  2668.     Int32     frame, scale, side, mipmap;
    2669. 

  2669.     UChar8   *src, *dest;
    2670. 

  2670.     Int32     oldWidth =getWidth();
    2671. 

  2671.     Int32     oldHeight=getHeight();
    2672. 

  2672.     Int32     oldDepth =getDepth();
    2673. 

  2673.     MFUInt8   srcPixel;
    2674. 

  2674. 

  2675.     if (hasCompressedData()) 
    2676. 

  2676.     {
    2677. 

  2677.         FFATAL (("Invalid Image::scale for compressed image\n"));
    2678. 

  2678.         return false;
    2679. 

  2679.     }
    2680. 

  2680. 

  2681.     if(destination != NullFC)
    2682. 

  2682.     {
    2683. 

  2683.         destImage = destination;
    2684. 

  2684.     }
    2685. 

  2685.     else
    2686. 

  2686.     {
    2687. 

  2687.         destImage = this;
    2688. 

  2688.     }
    2689. 

  2689. 

  2690.     // get pixel
    2691. 

  2691.     srcPixel = getPixel();
    2692. 

  2692. 

  2693.     // set image data
    2694. 

  2694. 

  2695.     destImage->set((PixelFormat) getPixelFormat(),
    2696. 

  2696.                    width, 
    2697. 

  2697.                    height, 
    2698. 

  2698.                    depth, 
    2699. 

  2699.                    getMipMapCount(),
    2700. 

  2700.                    getFrameCount (), 
    2701. 

  2701.                    getFrameDelay (), 
    2702. 

  2702.                    0, 
    2703. 

  2703.                    getDataType   (),
    2704. 

  2704.                    true,
    2705. 

  2705.                    getSideCount  ());
    2706. 

  2706. 

  2707.     // copy every mipmap in every side in every frame
    2708. 

  2708.     for(frame = 0; frame < getFrameCount(); frame++)
    2709. 

  2709.     {
    2710. 

  2710.         for (side = 0; side < getSideCount(); side++) 
    2711. 

  2711.         {
    2712. 

  2712. 

  2713.             for(mipmap = 0; mipmap < getMipMapCount(); mipmap++)
    2714. 

  2714.             {
    2715. 

  2715.                 // get the memory pointer
    2716. 

  2716.                 src = (&srcPixel[0]) +
    2717. 

  2717.                     (side  * getSideSize ()) +
    2718. 

  2718.                     (frame * getFrameSize()) ;
    2719. 

  2719. 

  2720.                 if(mipmap)
    2721. 

  2721.                 {
    2722. 

  2722.                     src += calcMipmapSumSize (mipmap,
    2723. 

  2723.                                               oldWidth, 
    2724. 

  2724.                                               oldHeight, 
    2725. 

  2725.                                               oldDepth);
    2726. 

  2726.                 }
    2727. 

  2727.                  
    2728. 

  2728.                 dest = destImage->editData(mipmap, frame, side);
    2729. 

  2729.                 
    2730. 

  2730.                 // calc the mipmap size
    2731. 

  2731.                 sw = oldWidth  >> mipmap;
    2732. 

  2732.                 sh = oldHeight >> mipmap;
    2733. 

  2733.                 sd = oldDepth  >> mipmap;
    2734. 

  2734.                 
    2735. 

  2735.                 destImage->calcMipmapGeometry(mipmap, dw, dh, dd);
    2736. 

  2736.                 
    2737. 

  2737.                 // copy and scale the data
    2738. 

  2738.                 scaleData(src, sw, sh, sd, dest, dw, dh, dd);
    2739. 

  2739.                 
    2740. 

  2740.             }
    2741. 

  2741.         }
    2742. 

  2742.     }
    2743. 

  2743. 

  2744.     return true;
    2745. 

  2745. }
    2746. 

  2746. 

  2747. /*! Scale the image to the next power of 2 dimensions
    2748. 

  2748.     The method can operate on the object or stores the result in
    2749. 

  2749.     the optional destination Image.
    2750. 

  2750.  */
    2751. 

  2751. 

  2752. bool Image::scaleNextPower2(ImagePtr destination)
    2753. 

  2753. {
    2754. 

  2754.   return scale(osgNextPower2(getWidth ()),
    2755. 

  2755.                osgNextPower2(getHeight()),
    2756. 

  2756.                osgNextPower2(getDepth ()),
    2757. 

  2757.                destination              );
    2758. 

  2758. }
    2759. 

  2759. 

  2760. /*! Crop the image to the given bounding box.
    2761. 

  2761.   The method can operate on the object or stores the result in
    2762. 

  2762.   the optional destination Image.
    2763. 

  2763.  */
    2764. 

  2764. 

  2765. bool Image::subImage(Int32    offX, 
    2766. 

  2766.                      Int32    offY, 
    2767. 

  2767.                      Int32    offZ,
    2768. 

  2768.                      Int32    destW, 
    2769. 

  2769.                      Int32    destH, 
    2770. 

  2770.                      Int32    destD,
    2771. 

  2771.                      ImagePtr destination)
    2772. 

  2772. {
    2773. 

  2773.     ImagePtr destImage = destination;
    2774. 

  2774.     bool     retCode   = true;
    2775. 

  2775. 

  2776.     if (hasCompressedData()) 
    2777. 

  2777.     {
    2778. 

  2778.         FFATAL (("Invalid Image::subImage for compressed image\n"));
    2779. 

  2779.         return false;
    2780. 

  2780.     }
    2781. 

  2781. 

  2782.     if(destination == NullFC)
    2783. 

  2783.     {
    2784. 

  2784.         destImage = Image::create();
    2785. 

  2785. 

  2786.         addRef(destImage);
    2787. 

  2787.     }
    2788. 

  2788. 

  2789.     destImage->set((PixelFormat) getPixelFormat(),
    2790. 

  2790.                    destW, 
    2791. 

  2791.                    destH, 
    2792. 

  2792.                    destD,
    2793. 

  2793.                    1,
    2794. 

  2794.                    1,
    2795. 

  2795.                    0.0,
    2796. 

  2796.                    0,
    2797. 

  2797.                    getDataType());
    2798. 

  2798. 

  2799.     const UChar8  *src =            getData ();
    2800. 

  2800.           UChar8 *dest = destImage->editData();
    2801. 

  2801. 

  2802.     FDEBUG(("Image::subImage (%d %d %d) - (%d %d %d) - destPtr %p\n",
    2803. 

  2803.             offX, offY, offZ, destW, destH, destD, dest));
    2804. 

  2804. 

  2805.     // ensure destination data is zero
    2806. 

  2806.     memset(dest, 0, destImage->getSize());
    2807. 

  2807. 

  2808.     // determine the area to actually copy
    2809. 

  2809.     UInt32 xMin = offX;
    2810. 

  2810.     UInt32 yMin = offY;
    2811. 

  2811.     UInt32 zMin = offZ;
    2812. 

  2812. 

  2813.     UInt32 xMax = osgMin(getWidth (), offX + destW);
    2814. 

  2814.     UInt32 yMax = osgMin(getHeight(), offY + destH);
    2815. 

  2815.     UInt32 zMax = osgMin(getDepth (), offZ + destD);
    2816. 

  2816. 

  2817.     // fill the destination buffer with the subdata
    2818. 

  2818.     UInt32 destIdx = 0;
    2819. 

  2819. 

  2820.     for(UInt32 z = zMin; z < zMax; z++)
    2821. 

  2821.     {
    2822. 

  2822.         for(UInt32 y = yMin; y < yMax; y++)
    2823. 

  2823.         {
    2824. 

  2824.             for(UInt32 x = xMin; x < xMax; x++)
    2825. 

  2825.             {
    2826. 

  2826.                 for(UInt32 i = 0; i < getBpp(); i++)
    2827. 

  2827.                 {
    2828. 

  2828.                     dest[destIdx] = src[((z * getHeight() + y) *
    2829. 

  2829.                                          getWidth() + x) * getBpp() + i];
    2830. 

  2830.                     destIdx++;
    2831. 

  2831.                 }
    2832. 

  2832.             }
    2833. 

  2833. 

  2834.             destIdx += (destW - (xMax - xMin)) * getBpp();
    2835. 

  2835.         }
    2836. 

  2836. 

  2837.         destIdx += (destH - (yMax - yMin)) * destW * getBpp();
    2838. 

  2838.     }
    2839. 

  2839. 

  2840.     // rip the data from the local destImage if necessary
    2841. 

  2841.     if(destination == NullFC)
    2842. 

  2842.     {
    2843. 

  2843.         this->set(destImage);
    2844. 

  2844. 

  2845.         subRef(destImage);
    2846. 

  2846.     }
    2847. 

  2847. 

  2848.     return retCode;
    2849. 

  2849. }
    2850. 

  2850. 

  2851. /*! Crop a slice.
    2852. 

  2852.   The method can operate on the object or stores the result in
    2853. 

  2853.   the optional destination Image.
    2854. 

  2854.  */
    2855. 

  2855. 

  2856. bool Image::slice(Int32    offX, 
    2857. 

  2857.                   Int32    offY, 
    2858. 

  2858.                   Int32    offZ,
    2859. 

  2859.                   ImagePtr destination)
    2860. 

  2860. {
    2861. 

  2861.     ImagePtr destImage = destination;
    2862. 

  2862.     bool     retCode   = true;
    2863. 

  2863.     UInt32   counter   = 0;
    2864. 

  2864. 

  2865.     if (hasCompressedData()) 
    2866. 

  2866.     {
    2867. 

  2867.         FFATAL (("Invalid Image::slice for compressed image\n"));
    2868. 

  2868.         return false;
    2869. 

  2869.     }
    2870. 

  2870. 

  2871.     if(destination == NullFC)
    2872. 

  2872.     {
    2873. 

  2873.         destImage = Image::create();
    2874. 

  2874. 

  2875.         addRef(destImage);
    2876. 

  2876.     }
    2877. 

  2877. 

  2878.     FDEBUG(("Image::slice (%d %d %d)\n",
    2879. 

  2879.             offX, offY, offZ));
    2880. 

  2880. 

  2881.     if(offX >= 0) 
    2882. 

  2882.         counter++;
    2883. 

  2883. 

  2884.     if(offY >= 0) 
    2885. 

  2885.         counter++;
    2886. 

  2886. 

  2887.     if(offZ >= 0) 
    2888. 

  2888.         counter++;
    2889. 

  2889. 

  2890.     if(counter != 1) 
    2891. 

  2891.     {
    2892. 

  2892.         FWARNING(("Image::slice - more/less than one non negative value\n"));
    2893. 

  2893.         return false;
    2894. 

  2894.     }
    2895. 

  2895. 

  2896.     if(offZ >= 0) 
    2897. 

  2897.     {
    2898. 

  2898.         // XY slice
    2899. 

  2899.         retCode = subImage(0, 
    2900. 

  2900.                            0, 
    2901. 

  2901.                            offZ, 
    2902. 

  2902.                            getWidth (), 
    2903. 

  2903.                            getHeight(), 
    2904. 

  2904.                            1,
    2905. 

  2905.                            destImage );
    2906. 

  2906.     }
    2907. 

  2907. 

  2908.     if(offY >= 0) 
    2909. 

  2909.     {
    2910. 

  2910.         // XZ slice
    2911. 

  2911.         destImage->set((PixelFormat) getPixelFormat(),
    2912. 

  2912.                        getWidth(), 
    2913. 

  2913.                        getDepth(), 
    2914. 

  2914.                        1,
    2915. 

  2915.                        1,
    2916. 

  2916.                        1,
    2917. 

  2917.                        0.0,
    2918. 

  2918.                        0,
    2919. 

  2919.                        getDataType());
    2920. 

  2920. 

  2921.         const UChar8 *src  =            getData ();
    2922. 

  2922.               UChar8 *dest = destImage->editData();
    2923. 

  2923. 

  2924.         // ensure destination data is zero
    2925. 

  2925.         memset(dest, 0, destImage->getSize());
    2926. 

  2926. 

  2927.         for(UInt32 z = 0; z < getDepth(); z++)
    2928. 

  2928.         {
    2929. 

  2929.             for(UInt32 x = 0; x < getWidth(); x++)
    2930. 

  2930.             {
    2931. 

  2931.                 for(UInt32 i = 0; i < getBpp(); i++)
    2932. 

  2932.                 {
    2933. 

  2933.                     dest[(z * getWidth() + x) * getBpp() + i] = 
    2934. 

  2934.                         src[((z * getHeight() + offY) * getWidth() + x) *
    2935. 

  2935.                             getBpp() + i];
    2936. 

  2936.                 }
    2937. 

  2937.             }
    2938. 

  2938.         }
    2939. 

  2939.     }
    2940. 

  2940.     
    2941. 

  2941.     if(offX >= 0) 
    2942. 

  2942.     {
    2943. 

  2943.         // YZ slice
    2944. 

  2944.         destImage->set((PixelFormat)getPixelFormat(),
    2945. 

  2945.                        getWidth(), 
    2946. 

  2946.                        getDepth(), 
    2947. 

  2947.                        1,
    2948. 

  2948.                        1,
    2949. 

  2949.                        1,
    2950. 

  2950.                        0.0,
    2951. 

  2951.                        0,
    2952. 

  2952.                        getDataType());
    2953. 

  2953. 

  2954.         const UChar8 *src  =            getData ();
    2955. 

  2955.               UChar8 *dest = destImage->editData();
    2956. 

  2956. 

  2957.         // ensure destination data is zero
    2958. 

  2958.         memset(dest, 0, destImage->getSize());
    2959. 

  2959. 

  2960.         for(UInt32 z = 0; z < getDepth(); z++)
    2961. 

  2961.         {
    2962. 

  2962.             for(UInt32 y = 0; y < getHeight(); y++)
    2963. 

  2963.             {
    2964. 

  2964.                 for(UInt32 i = 0; i < getBpp(); i++)
    2965. 

  2965.                 {
    2966. 

  2966.                     dest[(z * getHeight() + y) * getBpp() + i] = 
    2967. 

  2967.                         src[((z * getHeight() + y) * getWidth() + offX) *
    2968. 

  2968.                             getBpp() + i];
    2969. 

  2969.                 }
    2970. 

  2970.             }
    2971. 

  2971.         }
    2972. 

  2972.     }
    2973. 

  2973.     
    2974. 

  2974.     // rip the data from the local destImage if necessary
    2975. 

  2975.     if(destination == NullFC)
    2976. 

  2976.     {
    2977. 

  2977.         this->set(destImage);
    2978. 

  2978. 

  2979.         subRef(destImage);
    2980. 

  2980.     }
    2981. 

  2981. 

  2982.     return retCode;
    2983. 

  2983. }
    2984. 

  2984. 

  2985. /*! Create mipmaps data, level defines the number of level
    2986. 

  2986.   The method can operate on the object or stores the result in
    2987. 

  2987.   the optional destination Image.
    2988. 

  2988.  */
    2989. 

  2989. 

  2990. bool Image::createMipmap(Int32 level, ImagePtr destination)
    2991. 

  2991. {
    2992. 

  2992.     struct Offset
    2993. 

  2993.     {
    2994. 

  2994.         Int32   d;
    2995. 

  2995.         Int32   h;
    2996. 

  2996.         Int32   w;
    2997. 

  2997.     };
    2998. 

  2998.     
    2999. 

  2999.     Offset  offset[][8] =
    3000. 

  3000.     {
    3001. 

  3001.         {   // 000
    3002. 

  3002.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
    3003. 

  3003.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3004. 

  3004.         },
    3005. 

  3005.         {   // 100
    3006. 

  3006.             { 0, 0, 0 }, { 1, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
    3007. 

  3007.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3008. 

  3008.         },
    3009. 

  3009.         {   // 010
    3010. 

  3010.             { 0, 0, 0 }, { 0, 1, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
    3011. 

  3011.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3012. 

  3012.         },
    3013. 

  3013.         {   // 110
    3014. 

  3014.             { 0, 0, 0 }, { 0, 1, 0 }, { 1, 0, 0 }, { 1, 1, 0 },
    3015. 

  3015.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3016. 

  3016.         },
    3017. 

  3017.         {   // 001
    3018. 

  3018.             { 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 0 },
    3019. 

  3019.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3020. 

  3020.         },
    3021. 

  3021.         {   // 101
    3022. 

  3022.             { 0, 0, 0 }, { 1, 0, 0 }, { 0, 0, 1 }, { 1, 0, 1 },
    3023. 

  3023.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3024. 

  3024.         },
    3025. 

  3025.         {   // 011
    3026. 

  3026.             { 0, 0, 0 }, { 0, 0, 1 }, { 0, 1, 0 }, { 0, 1, 1 },
    3027. 

  3027.             { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } 
    3028. 

  3028.         },
    3029. 

  3029.         {   // 111
    3030. 

  3030.             { 0, 0, 0 }, { 1, 0, 0 }, { 0, 1, 0 }, { 1, 1, 0 },
    3031. 

  3031.             { 0, 0, 1 }, { 1, 0, 1 }, { 0, 1, 1 }, { 1, 1, 1 } 
    3032. 

  3032.         }
    3033. 

  3033.     };
    3034. 

  3034. 

  3035.     Int32   offsetSize[] = { 0, 2, 2, 4, 2, 4, 4, 8 };
    3036. 

  3036. 

  3037.     ImagePtr destImage = destination;
    3038. 

  3038. 

  3039.     Int32   w = getWidth(), h = getHeight(), d = getDepth();
    3040. 

  3040.     Int32   wm, hm, dm, wi, hi, di;
    3041. 

  3041. 

  3042.     const UChar8  *src;
    3043. 

  3043.           UChar8  *dest;
    3044. 

  3044.     const UInt16 *sourceDataUC16;
    3045. 

  3045.           UInt16 *destDataUC16;
    3046. 

  3046.     const UInt32 *sourceDataUC32;
    3047. 

  3047.           UInt32 *destDataUC32;
    3048. 

  3048.     const Real32 *sourceDataF32;
    3049. 

  3049.           Real32 *destDataF32;
    3050. 

  3050.     const Real16 *sourceDataH16;
    3051. 

  3051.           Real16 *destDataH16;
    3052. 

  3052. 

  3053.     if (hasCompressedData()) 
    3054. 

  3054.     {
    3055. 

  3055.         FFATAL (("Invalid Image::createMipmap for compressed image\n"));
    3056. 

  3056.         return false;
    3057. 

  3057.     }
    3058. 

  3058. 

  3059.     if(destImage == NullFC)
    3060. 

  3060.     {
    3061. 

  3061.         destImage = Image::create();
    3062. 

  3062. 

  3063.         addRef(destImage);
    3064. 

  3064.     }
    3065. 

  3065. 

  3066.     Real32 valueFloat;
    3067. 

  3067.     Int32  value, i, elem, dim, side, frame, size, mipmap;
    3068. 

  3068.     Int32  channel, lineSize, sliceSize;
    3069. 

  3069. 

  3070.     // calc the level count
    3071. 

  3071.     if(level < 0)
    3072. 

  3072.     {
    3073. 

  3073.         level = calcMipmapLevelCount() - 1;
    3074. 

  3074.     }
    3075. 

  3075.     
    3076. 

  3076.     // create destination image
    3077. 

  3077.     destImage->set(getPixelFormat(),
    3078. 

  3078.                    getWidth(), 
    3079. 

  3079.                    getHeight(), 
    3080. 

  3080.                    getDepth(),
    3081. 

  3081.                    level,
    3082. 

  3082.                    getFrameCount(),
    3083. 

  3083.                    getFrameDelay(), 
    3084. 

  3084.                    0, 
    3085. 

  3085.                    getDataType(),
    3086. 

  3086.                    true,
    3087. 

  3087.                    getSideCount());
    3088. 

  3088. 

  3089.     // copy the data;
    3090. 

  3090.     switch (getDataType())
    3091. 

  3091.     {
    3092. 

  3092.         case OSG_UINT8_IMAGEDATA:
    3093. 

  3093. 

  3094.             for(frame = 0; frame < getFrameCount(); frame++)
    3095. 

  3095.             {
    3096. 

  3096.                 for(side = 0; side < getSideCount(); side++) 
    3097. 

  3097.                 {
    3098. 

  3098.                     src = this      ->getData (0, frame, side);
    3099. 

  3099.                     dest = destImage->editData(0, frame, side);
    3100. 

  3100.                     
    3101. 

  3101.                     size = getWidth() * getHeight() * getDepth() * getBpp();
    3102. 

  3102.                     
    3103. 

  3103.                     memcpy(dest, src, size);
    3104. 

  3104.                     
    3105. 

  3105.                     src = dest;
    3106. 

  3106. 

  3107.                     dest = dest + size;
    3108. 

  3108.                     
    3109. 

  3109.                     w = getWidth ();
    3110. 

  3110.                     h = getHeight();
    3111. 

  3111.                     d = getDepth ();
    3112. 

  3112.                     
    3113. 

  3113.                     for(mipmap = 1; mipmap < level; mipmap++)
    3114. 

  3114.                     {
    3115. 

  3115.                         lineSize  = w *     getBpp();
    3116. 

  3116.                         sliceSize = w * h * getBpp();
    3117. 

  3117.                         
    3118. 

  3118.                         wm = (w == 1) ? w : (w >> 1);
    3119. 

  3119.                         hm = (h == 1) ? h : (h >> 1);
    3120. 

  3120.                         dm = (d == 1) ? d : (d >> 1);
    3121. 

  3121.                         
    3122. 

  3122.                         dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
    3123. 

  3123.                         
    3124. 

  3124.                         elem = offsetSize[dim];
    3125. 

  3125.                         
    3126. 

  3126.                         for(di = 0; di < dm; di++)
    3127. 

  3127.                         {
    3128. 

  3128.                             for(hi = 0; hi < hm; hi++)
    3129. 

  3129.                             {
    3130. 

  3130.                                 for(wi = 0; wi < wm; wi++)
    3131. 

  3131.                                 {
    3132. 

  3132.                                     for(channel = 0; channel < getBpp(); channel++)
    3133. 

  3133.                                     {
    3134. 

  3134.                                         value = 0;
    3135. 

  3135.                                         
    3136. 

  3136.                                         for(i = 0; i < elem; i++)
    3137. 

  3137.                                         {
    3138. 

  3138.                                             value += src[
    3139. 

  3139.                                                 ((wi * 2) + offset[dim][i].w) * getBpp() +
    3140. 

  3140.                                                 ((hi * 2) + offset[dim][i].h) * lineSize +
    3141. 

  3141.                                                 ((di * 2) + offset[dim][i].d) * sliceSize +
    3142. 

  3142.                                                 channel];
    3143. 

  3143.                                         }
    3144. 

  3144.                                         
    3145. 

  3145.                                         *dest++ = (Int8) (value / elem);
    3146. 

  3146.                                     }
    3147. 

  3147.                                 }
    3148. 

  3148.                             }
    3149. 

  3149.                         }
    3150. 

  3150.                         
    3151. 

  3151.                         src += sliceSize;
    3152. 

  3152.                         
    3153. 

  3153.                         w = wm;
    3154. 

  3154.                         h = hm;
    3155. 

  3155.                         d = dm;
    3156. 

  3156.                   }
    3157. 

  3157.                 }
    3158. 

  3158.             }
    3159. 

  3159.             break;
    3160. 

  3160.             
    3161. 

  3161. #if !defined(OSG_EMBEDDED)
    3162. 

  3162.         case OSG_UINT16_IMAGEDATA:
    3163. 

  3163. 

  3164.             for(frame = 0; frame < getFrameCount(); frame++)
    3165. 

  3165.             {
    3166. 

  3166.                 for(side = 0; side < getSideCount(); side++) 
    3167. 

  3167.                 {
    3168. 

  3168.                     src  = this     ->getData (0, frame, side);
    3169. 

  3169.                     dest = destImage->editData(0, frame, side);
    3170. 

  3170. 

  3171.                     size = getWidth() * getHeight() * getDepth() * getBpp();
    3172. 

  3172.                 
    3173. 

  3173.                     memcpy(dest, src, size);
    3174. 

  3174.                     
    3175. 

  3175.                     src  = dest;
    3176. 

  3176.                     dest = dest + size;
    3177. 

  3177.                 
    3178. 

  3178.                     w = getWidth ();
    3179. 

  3179.                     h = getHeight();
    3180. 

  3180.                     d = getDepth ();
    3181. 

  3181.                     
    3182. 

  3182.                     sourceDataUC16 = (const UInt16 *) src;
    3183. 

  3183.                     destDataUC16   = (      UInt16 *) dest;
    3184. 

  3184.                     
    3185. 

  3185.                     for(mipmap = 1; mipmap < level; mipmap++)
    3186. 

  3186.                     {
    3187. 

  3187.                         lineSize  = w *     (getBpp() / getComponentSize());
    3188. 

  3188.                         sliceSize = w * h * (getBpp() / getComponentSize());
    3189. 

  3189.                         
    3190. 

  3190.                         wm = (w == 1) ? w : (w >> 1);
    3191. 

  3191.                         hm = (h == 1) ? h : (h >> 1);
    3192. 

  3192.                         dm = (d == 1) ? d : (d >> 1);
    3193. 

  3193.                         
    3194. 

  3194.                         dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
    3195. 

  3195.                         
    3196. 

  3196.                         elem = offsetSize[dim];
    3197. 

  3197.                         
    3198. 

  3198.                         for(di = 0; di < dm; di++)
    3199. 

  3199.                         {
    3200. 

  3200.                             for(hi = 0; hi < hm; hi++)
    3201. 

  3201.                             {
    3202. 

  3202.                                 for(wi = 0; wi < wm; wi++)
    3203. 

  3203.                                 {
    3204. 

  3204.                                     for(channel = 0; 
    3205. 

  3205.                                         channel < (getBpp() / getComponentSize()); 
    3206. 

  3206.                                         channel++)
    3207. 

  3207.                                     {
    3208. 

  3208.                                         value = 0;
    3209. 

  3209.                                         
    3210. 

  3210.                                         for(i = 0; i < elem; i++)
    3211. 

  3211.                                         {
    3212. 

  3212.                                             value += sourceDataUC16[
    3213. 

  3213.                                                 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
    3214. 

  3214.                                                 ((hi * 2) + offset[dim][i].h) * lineSize +
    3215. 

  3215.                                                 ((di * 2) + offset[dim][i].d) * sliceSize +
    3216. 

  3216.                                                 channel];
    3217. 

  3217.                                         }
    3218. 

  3218.                                         
    3219. 

  3219.                                         *destDataUC16++ = (UInt16) (value / elem);
    3220. 

  3220.                                     }
    3221. 

  3221.                                 }
    3222. 

  3222.                             }
    3223. 

  3223.                         }
    3224. 

  3224.                         
    3225. 

  3225.                         sourceDataUC16 += sliceSize;
    3226. 

  3226.                         
    3227. 

  3227.                         w = wm;
    3228. 

  3228.                         h = hm;
    3229. 

  3229.                         d = dm;
    3230. 

  3230.                     }
    3231. 

  3231.                 }
    3232. 

  3232.             }
    3233. 

  3233.             break;
    3234. 

  3234.             
    3235. 

  3235.         case OSG_UINT32_IMAGEDATA:
    3236. 

  3236. 

  3237.             for(frame = 0; frame < getFrameCount(); frame++)
    3238. 

  3238.             {
    3239. 

  3239.                 for(side = 0; side < getSideCount(); side++) 
    3240. 

  3240.                 {
    3241. 

  3241.                     src  = this     ->getData (0, frame,side);
    3242. 

  3242.                     dest = destImage->editData(0, frame,side);
    3243. 

  3243. 

  3244.                     size = getWidth() * getHeight() * getDepth() * getBpp();
    3245. 

  3245.                 
    3246. 

  3246.                     memcpy(dest, src, size);
    3247. 

  3247.                     
    3248. 

  3248.                     src  = dest;
    3249. 

  3249.                     dest = dest + size;
    3250. 

  3250.                     
    3251. 

  3251.                     w = getWidth ();
    3252. 

  3252.                     h = getHeight();
    3253. 

  3253.                     d = getDepth ();
    3254. 

  3254.                     
    3255. 

  3255.                     sourceDataUC32 = (const UInt32 *) src;
    3256. 

  3256.                     destDataUC32   = (      UInt32 *) dest;
    3257. 

  3257.                     
    3258. 

  3258.                     for(mipmap = 1; mipmap < level; mipmap++)
    3259. 

  3259.                     {
    3260. 

  3260.                         lineSize  = w *     (getBpp() / getComponentSize());
    3261. 

  3261.                         sliceSize = w * h * (getBpp() / getComponentSize());
    3262. 

  3262.                         
    3263. 

  3263.                         wm = (w == 1) ? w : (w >> 1);
    3264. 

  3264.                         hm = (h == 1) ? h : (h >> 1);
    3265. 

  3265.                         dm = (d == 1) ? d : (d >> 1);
    3266. 

  3266.                         
    3267. 

  3267.                         dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
    3268. 

  3268.                         
    3269. 

  3269.                         elem = offsetSize[dim];
    3270. 

  3270.                         
    3271. 

  3271.                         for(di = 0; di < dm; di++)
    3272. 

  3272.                         {
    3273. 

  3273.                             for(hi = 0; hi < hm; hi++)
    3274. 

  3274.                             {
    3275. 

  3275.                                 for(wi = 0; wi < wm; wi++)
    3276. 

  3276.                                 {
    3277. 

  3277.                                     for(channel = 0; 
    3278. 

  3278.                                         channel < (getBpp()/getComponentSize()); 
    3279. 

  3279.                                         channel++)
    3280. 

  3280.                                     {
    3281. 

  3281.                                         value = 0;
    3282. 

  3282.                                         
    3283. 

  3283.                                         for(i = 0; i < elem; i++)
    3284. 

  3284.                                         {
    3285. 

  3285.                                             value += (sourceDataUC32[
    3286. 

  3286.                                                           ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
    3287. 

  3287.                                                           ((hi * 2) + offset[dim][i].h) * lineSize +
    3288. 

  3288.                                                           ((di * 2) + offset[dim][i].d) * sliceSize +
    3289. 

  3289.                                                           channel]/elem);
    3290. 

  3290.                                         }
    3291. 

  3291.                                         *destDataUC32++ = (UInt32) value;
    3292. 

  3292.                                     }
    3293. 

  3293.                                 }
    3294. 

  3294.                             }
    3295. 

  3295.                         }
    3296. 

  3296.                         
    3297. 

  3297.                         sourceDataUC32 += sliceSize;
    3298. 

  3298.                         
    3299. 

  3299.                         w = wm;
    3300. 

  3300.                         h = hm;
    3301. 

  3301.                         d = dm;
    3302. 

  3302.                     }
    3303. 

  3303.                 }
    3304. 

  3304.             }
    3305. 

  3305.             break;
    3306. 

  3306. #endif            
    3307. 

  3307.         case OSG_FLOAT32_IMAGEDATA:
    3308. 

  3308. 

  3309.             for(frame = 0; frame < getFrameCount(); frame++)
    3310. 

  3310.             {
    3311. 

  3311.                 for(side = 0; side < getSideCount(); side++) 
    3312. 

  3312.                 {
    3313. 

  3313.                     src  = this     ->getData (0, frame,side);
    3314. 

  3314.                     dest = destImage->editData(0, frame,side);
    3315. 

  3315. 

  3316.                     size = getWidth() * getHeight() * getDepth() * getBpp();
    3317. 

  3317.                     
    3318. 

  3318.                     memcpy(dest, src, size);
    3319. 

  3319.                     
    3320. 

  3320.                     src  = dest;
    3321. 

  3321.                     dest = dest + size;
    3322. 

  3322.                     
    3323. 

  3323.                     w = getWidth ();
    3324. 

  3324.                     h = getHeight();
    3325. 

  3325.                     d = getDepth ();
    3326. 

  3326.                     
    3327. 

  3327.                     sourceDataF32 = (const Real32 *) src;
    3328. 

  3328.                     destDataF32   = (      Real32 *) dest;
    3329. 

  3329.                     
    3330. 

  3330.                     for(mipmap = 1; mipmap < level; mipmap++)
    3331. 

  3331.                     {
    3332. 

  3332.                         lineSize  = w *     (getBpp() / getComponentSize());
    3333. 

  3333.                         sliceSize = w * h * (getBpp() / getComponentSize());
    3334. 

  3334.                         
    3335. 

  3335.                         wm = (w == 1) ? w : (w >> 1);
    3336. 

  3336.                         hm = (h == 1) ? h : (h >> 1);
    3337. 

  3337.                         dm = (d == 1) ? d : (d >> 1);
    3338. 

  3338.                         
    3339. 

  3339.                         dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
    3340. 

  3340.                         
    3341. 

  3341.                         elem = offsetSize[dim];
    3342. 

  3342.                         
    3343. 

  3343.                         for(di = 0; di < dm; di++)
    3344. 

  3344.                         {
    3345. 

  3345.                             for(hi = 0; hi < hm; hi++)
    3346. 

  3346.                             {
    3347. 

  3347.                                 for(wi = 0; wi < wm; wi++)
    3348. 

  3348.                                 {
    3349. 

  3349.                                     for(channel = 0; 
    3350. 

  3350.                                         channel < (getBpp() / getComponentSize()); 
    3351. 

  3351.                                         channel++)
    3352. 

  3352.                                     {
    3353. 

  3353.                                         valueFloat = 0;
    3354. 

  3354.                                         
    3355. 

  3355.                                         for(i = 0; i < elem; i++)
    3356. 

  3356.                                         {
    3357. 

  3357.                                             valueFloat += sourceDataF32[
    3358. 

  3358.                                                 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
    3359. 

  3359.                                                 ((hi * 2) + offset[dim][i].h) * lineSize +
    3360. 

  3360.                                                 ((di * 2) + offset[dim][i].d) * sliceSize +
    3361. 

  3361.                                                 channel];
    3362. 

  3362.                                         }
    3363. 

  3363.                                         
    3364. 

  3364.                                         *destDataF32++ = (Real32) (valueFloat / elem);
    3365. 

  3365.                                     }
    3366. 

  3366.                                 }
    3367. 

  3367.                             }
    3368. 

  3368.                         }
    3369. 

  3369.                         
    3370. 

  3370.                         sourceDataF32 += sliceSize;
    3371. 

  3371.                         
    3372. 

  3372.                         w = wm;
    3373. 

  3373.                         h = hm;
    3374. 

  3374.                         d = dm;
    3375. 

  3375.                     }
    3376. 

  3376.                 }
    3377. 

  3377.             }
    3378. 

  3378.             break;
    3379. 

  3379.             
    3380. 

  3380. #if !defined(OSG_EMBEDDED)
    3381. 

  3381.         case OSG_FLOAT16_IMAGEDATA:
    3382. 

  3382.             for(frame = 0; frame < getFrameCount(); frame++)
    3383. 

  3383.             {
    3384. 

  3384.                 for(side = 0; side < getSideCount(); side++) 
    3385. 

  3385.                 {
    3386. 

  3386.                     src = this->getData(0, frame,side);
    3387. 

  3387.                     dest = destImage->editData(0, frame,side);
    3388. 

  3388.                     size = getWidth() * getHeight() * getDepth() * getBpp();
    3389. 

  3389.                     memcpy(dest,src, size);
    3390. 

  3390.                     src = dest;
    3391. 

  3391.                     dest = dest + size;
    3392. 

  3392.                     w = getWidth();
    3393. 

  3393.                     h = getHeight();
    3394. 

  3394.                     d = getDepth();
    3395. 

  3395.                     
    3396. 

  3396.                     sourceDataH16 = (Real16*) src;
    3397. 

  3397.                     destDataH16 = (Real16*) dest;
    3398. 

  3398.                     
    3399. 

  3399.                     for(mipmap = 1; mipmap < level; mipmap++)
    3400. 

  3400.                     {
    3401. 

  3401.                         lineSize = w * (getBpp() / getComponentSize());
    3402. 

  3402.                         sliceSize = w * h * (getBpp() / getComponentSize());
    3403. 

  3403.                         wm = (w == 1) ? w : (w >> 1);
    3404. 

  3404.                         hm = (h == 1) ? h : (h >> 1);
    3405. 

  3405.                         dm = (d == 1) ? d : (d >> 1);
    3406. 

  3406.                         
    3407. 

  3407.                         dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
    3408. 

  3408.                         elem = offsetSize[dim];
    3409. 

  3409.                         
    3410. 

  3410.                         for(di = 0; di < dm; di++)
    3411. 

  3411.                         {
    3412. 

  3412.                             for(hi = 0; hi < hm; hi++)
    3413. 

  3413.                             {
    3414. 

  3414.                                 for(wi = 0; wi < wm; wi++)
    3415. 

  3415.                                 {
    3416. 

  3416.                                     for(channel = 0; channel < (getBpp()/getComponentSize()); channel++)
    3417. 

  3417.                                     {
    3418. 

  3418.                                         valueFloat = 0;
    3419. 

  3419.                                         for(i = 0; i < elem; i++)
    3420. 

  3420.                                         {
    3421. 

  3421.                                             valueFloat += sourceDataH16[
    3422. 

  3422.                                                 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
    3423. 

  3423.                                                 ((hi * 2) + offset[dim][i].h) * lineSize +
    3424. 

  3424.                                                 ((di * 2) + offset[dim][i].d) * sliceSize +
    3425. 

  3425.                                                 channel];
    3426. 

  3426.                                         }
    3427. 

  3427.                                         *destDataH16++ = (Real16) (valueFloat / elem);
    3428. 

  3428.                                     }
    3429. 

  3429.                                 }
    3430. 

  3430.                             }
    3431. 

  3431.                         }
    3432. 

  3432.                         sourceDataH16 += sliceSize;
    3433. 

  3433.                         w = wm;
    3434. 

  3434.                         h = hm;
    3435. 

  3435.                         d = dm;
    3436. 

  3436.                     }
    3437. 

  3437.                 }
    3438. 

  3438.             }
    3439. 

  3439.             break;
    3440. 

  3440. #endif
    3441. 

  3441. 

  3442.         default:
    3443. 

  3443.             FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
    3444. 

  3444.             break;
    3445. 

  3445.     }
    3446. 

  3446.     
    3447. 

  3447.     // rip the data from the local destImage if necessary
    3448. 

  3448.     if(destination == NullFC)
    3449. 

  3449.     {
    3450. 

  3450.         this->set(destImage);
    3451. 

  3451. 

  3452.         subRef(destImage);
    3453. 

  3453.     }
    3454. 

  3454.     
    3455. 

  3455.     return true;
    3456. 

  3456. }
    3457. 

  3457. 

  3458. /*! Write the image to the a file. The mimetype will be set automatically
    3459. 

  3459.   from the fileName suffix. Returns true on success.
    3460. 

  3460.  */
    3461. 

  3461. 

  3462. bool Image::write(const Char8 *fileName)
    3463. 

  3463. {
    3464. 

  3464. #if !defined(OSG_EMBEDDED)
    3465. 

  3465.     return ImageFileHandler::the()->write(this, fileName);
    3466. 

  3466. #else
    3467. 

  3467.     return false;
    3468. 

  3468. #endif
    3469. 

  3469. }
    3470. 

  3470. 

  3471. /*! Read the image data from a file. Returns true on success.
    3472. 

  3472.  */
    3473. 

  3473. 

  3474. bool Image::read(const Char8 *fileName)
    3475. 

  3475. {
    3476. 

  3476. #if !defined(OSG_EMBEDDED)
    3477. 

  3477.     return ImageFileHandler::the()->read(this, fileName);
    3478. 

  3478. #else
    3479. 

  3479.     return false;
    3480. 

  3480. #endif
    3481. 

  3481. }
    3482. 

  3482. 

  3483. 

  3484. /*! Store the image to the given mem block as 'mimeType'.
    3485. 

  3485.   mimeType can be 0, in which case the method will store the
    3486. 

  3486.   object as uncompressed mtd data.
    3487. 

  3487.   Returns the number of bytes used.
    3488. 

  3488.  */
    3489. 

  3489. 

  3490. UInt64 Image::store(const Char8 *mimeType, UChar8 *mem, Int32 memSize)
    3491. 

  3491. {
    3492. 

  3492. #if !defined(OSG_EMBEDDED)
    3493. 

  3493.     return ImageFileHandler::the()->store(this,
    3494. 

  3494.                                           mimeType, 
    3495. 

  3495.                                           mem, 
    3496. 

  3496.                                           memSize);
    3497. 

  3497. #else
    3498. 

  3498.     return false;
    3499. 

  3499. #endif
    3500. 

  3500. }
    3501. 

  3501. 

  3502. /*! Restore the image from the given mem block. Returns the
    3503. 

  3503.   number of bytes used.
    3504. 

  3504.  */
    3505. 

  3505. 

  3506. UInt64 Image::restore(const UChar8 *mem, Int32 memSize)
    3507. 

  3507. {
    3508. 

  3508. #if !defined(OSG_EMBEDDED)
    3509. 

  3509.     return ImageFileHandler::the()->restore(this, mem, memSize);;
    3510. 

  3510. #else
    3511. 

  3511.     return false;
    3512. 

  3512. #endif
    3513. 

  3513. }
    3514. 

  3514. 

  3515. 

  3516. /*-------------------------------------------------------------------------*/
    3517. 

  3517. /*                               Constructor / Destructor                  */
    3518. 

  3518. 

  3519. /*! Default Constructor. Creates a invalid Image of the size 0x0x0
    3520. 

  3520.  */
    3521. 

  3521. 

  3522. Image::Image(void) :
    3523. 

  3523.     Inherited()
    3524. 

  3524. {
    3525. 

  3525. }
    3526. 

  3526. 

  3527. /*! Copy Constructor. Creates a copy of the given image
    3528. 

  3528.  */
    3529. 

  3529. 

  3530. Image::Image(const Image &obj) :
    3531. 

  3531.     Inherited(obj)
    3532. 

  3532. {
    3533. 

  3533. }
    3534. 

  3534. 

  3535. /*! Destructor.
    3536. 

  3536.  */
    3537. 

  3537. 

  3538. Image::~Image(void)
    3539. 

  3539. {
    3540. 

  3540. }
    3541. 

  3541. 

  3542. /*! Method to check, whether the object data defines a alpha channel or not
    3543. 

  3543.  */
    3544. 

  3544. 

  3545. bool Image::hasAlphaChannel(void)
    3546. 

  3546. {
    3547. 

  3547.     return 
    3548. 

  3548.         (getForceAlphaChannel() == true         ) ||
    3549. 

  3549.         (getPixelFormat      () == OSG_RGBA_PF  ) ||
    3550. 

  3550.         (getPixelFormat      () == OSG_BGRA_PF  ) || 
    3551. 

  3551.         (getPixelFormat      () == OSG_RGBA_DXT1) ||
    3552. 

  3552.         (getPixelFormat      () == OSG_RGBA_DXT3) ||
    3553. 

  3553.         (getPixelFormat      () == OSG_RGBA_DXT5) ||
    3554. 

  3554.         (getPixelFormat      () == OSG_A_PF     ) ||
    3555. 

  3555. #if !defined(OSG_EMBEDDED)
    3556. 

  3556.         (getPixelFormat      () == OSG_I_PF     ) ||
    3557. 

  3557. #endif
    3558. 

  3558.         (getPixelFormat      () == OSG_LA_PF    );
    3559. 

  3559. }
    3560. 

  3560. 

  3561. /*! Method to check, whether the alpha channel is just fully transparent/
    3562. 

  3562.     fully opaque
    3563. 

  3563.  */
    3564. 

  3564. bool Image::isAlphaBinary(void)
    3565. 

  3565. {
    3566. 

  3566.     return 
    3567. 

  3567.         (getForceAlphaBinary() == true         ) || 
    3568. 

  3568.         (getPixelFormat     () == OSG_RGBA_DXT1);
    3569. 

  3569. }
    3570. 

  3570. 

  3571. /*! Method to check, whether the data is compressed
    3572. 

  3572.  */
    3573. 

  3573. bool Image::hasCompressedData(void)
    3574. 

  3574. {
    3575. 

  3575.   return 
    3576. 

  3576.       (getForceCompressedData() == true         ) ||
    3577. 

  3577.       (getPixelFormat        () == OSG_RGB_DXT1 ) ||
    3578. 

  3578.       (getPixelFormat        () == OSG_RGBA_DXT1) ||
    3579. 

  3579.       (getPixelFormat        () == OSG_RGBA_DXT3) ||
    3580. 

  3580.       (getPixelFormat        () == OSG_RGBA_DXT5);
    3581. 

  3581.     
    3582. 

  3582. }
    3583. 

  3583. 

  3584. /*! Method to check, whether the object data defines a color channel or not
    3585. 

  3585.  */
    3586. 

  3586. bool Image::hasColorChannel(void)
    3587. 

  3587. {
    3588. 

  3588.     return 
    3589. 

  3589.         ( !( getPixelFormat() == OSG_A_PF ||
    3590. 

  3590. #if !defined(OSG_EMBEDDED)
    3591. 

  3591.              getPixelFormat() == OSG_I_PF ||
    3592. 

  3592. #endif
    3593. 

  3593.              getPixelFormat() == OSG_L_PF ||
    3594. 

  3594.              getPixelFormat() == OSG_LA_PF )) ||
    3595. 

  3595.         getForceColorChannel();
    3596. 

  3596. }
    3597. 

  3597. 

  3598. /*! Method returns the right frame data for the given time.
    3599. 

  3599.  */
    3600. 

  3600. 

  3601. const UInt8 *Image::getDataByTime(Time time, UInt32) const
    3602. 

  3602. {
    3603. 

  3603.     UInt32 frameNum = calcFrameNum(time, true);
    3604. 

  3604.     
    3605. 

  3605.     return getData(0, frameNum);
    3606. 

  3606. }
    3607. 

  3607. 

  3608. UInt8 *Image::editDataByTime(Time time, UInt32) 
    3609. 

  3609. {
    3610. 

  3610.     UInt32 frameNum = calcFrameNum(time, true);
    3611. 

  3611.     
    3612. 

  3612.     return editData(0, frameNum);
    3613. 

  3613. }
    3614. 

  3614. 

  3615. /*! Check all the alpha values to see if they're 0 or 1, return true if they
    3616. 

  3616.   are, false if no alpha or intermediate values. No Alpha channel is considered
    3617. 

  3617.   0.
    3618. 

  3618.  */
    3619. 

  3619. 

  3620. bool Image::calcIsAlphaBinary(void)
    3621. 

  3621. {
    3622. 

  3622.     if(!hasAlphaChannel() || getPixelFormat() == OSG_RGBA_DXT1)
    3623. 

  3623.         return true;
    3624. 

  3624.     
    3625. 

  3625.     if(getPixelFormat() == OSG_RGBA_DXT3 || getPixelFormat() == OSG_RGBA_DXT5)
    3626. 

  3626.     {
    3627. 

  3627.         FWARNING(("Image::calcIsAlphaBinary: not implemenetd for DXT3 "
    3628. 

  3628.                   "and DXT5 yet, assuming false.\n"));
    3629. 

  3629.         return false;
    3630. 

  3630.     }
    3631. 

  3631.     
    3632. 

  3632.     UInt32 npix = getWidth() * getHeight() * getDepth() * getFrameCount();
    3633. 

  3633.     UInt8 pixelsize = getBpp();
    3634. 

  3634.     
    3635. 

  3635.     const UInt8 *data = getData();
    3636. 

  3636.     
    3637. 

  3637.     switch(getPixelFormat())
    3638. 

  3638.     {
    3639. 

  3639.         case OSG_LA_PF:     
    3640. 

  3640.             data += getComponentSize(); break;
    3641. 

  3641.         case OSG_BGRA_PF:
    3642. 

  3642.         case OSG_RGBA_PF:   
    3643. 

  3643.             data += getComponentSize() * 3; break;
    3644. 

  3644.         default:
    3645. 

  3645.             FWARNING(("Image::calcIsAlphaBinary: found unknown "
    3646. 

  3646.                       "image format %x, assumning false.\n", 
    3647. 

  3647.                       getPixelFormat()));
    3648. 

  3648.             return false;
    3649. 

  3649.     }
    3650. 

  3650.     
    3651. 

  3651.     switch(getDataType())
    3652. 

  3652.     {
    3653. 

  3653.         case OSG_UINT8_IMAGEDATA:
    3654. 

  3654.             for(; npix > 0; --npix, data += pixelsize)
    3655. 

  3655.             {
    3656. 

  3656.                 if(*data != 0 && *data != 0xffU)
    3657. 

  3657.                     break;
    3658. 

  3658.             }
    3659. 

  3659.             break;
    3660. 

  3660. #if !defined(OSG_EMBEDDED)
    3661. 

  3661.         case OSG_UINT16_IMAGEDATA:
    3662. 

  3662.             for(; npix > 0; --npix, data += pixelsize)
    3663. 

  3663.             {
    3664. 

  3664.                 const UInt16 *d = reinterpret_cast<const UInt16*>(data);
    3665. 

  3665.                 if(*d != 0 && *d != 0xffffU)
    3666. 

  3666.                     break;
    3667. 

  3667.             }
    3668. 

  3668.             break;
    3669. 

  3669.         case OSG_UINT32_IMAGEDATA:
    3670. 

  3670.             for(; npix > 0; --npix, data += pixelsize)
    3671. 

  3671.             {
    3672. 

  3672.                 const UInt32 *d = reinterpret_cast<const UInt32*>(data);
    3673. 

  3673.                 if(*d != 0 && *d != 0xffffffffU)
    3674. 

  3674.                     break;
    3675. 

  3675.             }
    3676. 

  3676.             break;
    3677. 

  3677.         case OSG_FLOAT16_IMAGEDATA:
    3678. 

  3678.             for(; npix > 0; --npix, data += pixelsize)
    3679. 

  3679.             {
    3680. 

  3680.                 const Real16 *d = reinterpret_cast<const Real16*>(data);
    3681. 

  3681.                 if(*d != 0 && *d != 1)
    3682. 

  3682.                     break;
    3683. 

  3683.             }
    3684. 

  3684.             break;
    3685. 

  3685. #endif
    3686. 

  3686.         case OSG_FLOAT32_IMAGEDATA:
    3687. 

  3687.             for(; npix > 0; --npix, data += pixelsize)
    3688. 

  3688.             {
    3689. 

  3689.                 const Real32 *d = reinterpret_cast<const Real32*>(data);
    3690. 

  3690.                 if(*d != 0 && *d != 1)
    3691. 

  3691.                     break;
    3692. 

  3692.             }
    3693. 

  3693.             break;
    3694. 

  3694.         default:
    3695. 

  3695.             FWARNING(("Image::calcIsAlphaBinary: found unknown "
    3696. 

  3696.                       "data type %d, assumning false.\n", 
    3697. 

  3697.                       getDataType()));
    3698. 

  3698.             return false;
    3699. 

  3699.     }
    3700. 

  3700.     
    3701. 

  3701.     return npix == 0;
    3702. 

  3702. }
    3703. 

  3703. 

  3704. /*! Method which returns the frame number for the given time
    3705. 

  3705.  */
    3706. 

  3706. UInt32 Image::calcFrameNum(Time time, bool OSG_CHECK_ARG(loop)) const
    3707. 

  3707. {
    3708. 

  3708.     UInt64 frameNum = ((getFrameDelay() > 0) && (getFrameCount() > 0)) ?
    3709. 

  3709.         (UInt64(time / getFrameDelay()) % getFrameCount()) : 0;
    3710. 

  3710.     
    3711. 

  3711.     return ((frameNum > 0) ? UInt32(frameNum) : 0);
    3712. 

  3712. }
    3713. 

  3713. 

  3714. /*! Internal used method to calculate the next mipmap geo for the given level
    3715. 

  3715.  */
    3716. 

  3716. void Image::calcMipmapGeometry(UInt32 mipmapNum,
    3717. 

  3717.                                UInt32 &width,
    3718. 

  3718.                                UInt32 &height,
    3719. 

  3719.                                UInt32 &depth   ) const
    3720. 

  3720. {
    3721. 

  3721.     width  = getWidth()  ? osgMax(getWidth () >> mipmapNum, 1) : 0 ;
    3722. 

  3722.     height = getHeight() ? osgMax(getHeight() >> mipmapNum, 1) : 0 ;
    3723. 

  3723.     depth  = getDepth()  ? osgMax(getDepth () >> mipmapNum, 1) : 0 ;
    3724. 

  3724. }
    3725. 

  3725. 

  3726. #ifdef __sgi
    3727. 

  3727. #pragma set woff 1209
    3728. 

  3728. #endif
    3729. 

  3729. 

  3730. /*! Internal used method to calculate the number of mipmaps levels
    3731. 

  3731.  */
    3732. 

  3732. UInt32 Image::calcMipmapLevelCount(void) const
    3733. 

  3733. {
    3734. 

  3734.     UInt32  w = getWidth(), h = getHeight(), d = getDepth();
    3735. 

  3735.     UInt32 level;
    3736. 

  3736.     
    3737. 

  3737.     for (level = 1; true; level++)
    3738. 

  3738.     {
    3739. 

  3739.         if ((w == 1) && (h == 1) && (d == 1))
    3740. 

  3740.         {
    3741. 

  3741.             break;
    3742. 

  3742.         }
    3743. 

  3743.         else
    3744. 

  3744.         {
    3745. 

  3745.             w = (w >>= 1) ? w : 1;
    3746. 

  3746.             h = (h >>= 1) ? h : 1;
    3747. 

  3747.             d = (d >>= 1) ? d : 1;
    3748. 

  3748.         }
    3749. 

  3749.     }
    3750. 

  3750.     return level;
    3751. 

  3751. }
    3752. 

  3752. 

  3753. #ifdef __sgi
    3754. 

  3754. #pragma reset woff 1209
    3755. 

  3755. #endif
    3756. 

  3756. 

  3757. /*-------------------------------------------------------------------------*/
    3758. 

  3758. /*                            Calculate Mipmap Size                        */
    3759. 

  3759. 

  3760. /*! Method to calculate the mem sum of a mipmap level in byte
    3761. 

  3761.  */
    3762. 

  3762. UInt32 Image::calcMipmapLevelSize ( UInt32 mipmapNum,
    3763. 

  3763.                                     UInt32 w, UInt32 h, UInt32 d) const
    3764. 

  3764. {
    3765. 

  3765.     Int32 sum;
    3766. 

  3766. 

  3767.     switch (getPixelFormat()) 
    3768. 

  3768.     {
    3769. 

  3769. #if !defined(OSG_EMBEDDED)
    3770. 

  3770.         case OSG_RGB_DXT1:
    3771. 

  3771.         case OSG_RGBA_DXT1:
    3772. 

  3772.             sum = (((w?w:1)+3)/4) * (((h?h:1)+3)/4) * 8;
    3773. 

  3773.             break;
    3774. 

  3774.         case OSG_RGBA_DXT3:
    3775. 

  3775.         case OSG_RGBA_DXT5:
    3776. 

  3776.             sum = (((w?w:1)+3)/4) * (((h?h:1)+3)/4) * 16;
    3777. 

  3777.             break;
    3778. 

  3778. #endif
    3779. 

  3779.         default:
    3780. 

  3780.             sum = (w?w:1) * (h?h:1) * getBpp();
    3781. 

  3781.             break;
    3782. 

  3782.     }
    3783. 

  3783.     
    3784. 

  3784.     sum *= (d?d:1);
    3785. 

  3785.     
    3786. 

  3786.     return sum;
    3787. 

  3787. }
    3788. 

  3788. 

  3789. /*! Internal used method to calculate the size in bpp of a single mipmap
    3790. 

  3790.   level for the current image settings
    3791. 

  3791.  */
    3792. 

  3792. 

  3793. UInt32 Image::calcMipmapLevelSize(UInt32 mipmapNum) const
    3794. 

  3794. {
    3795. 

  3795.     UInt32 w, h, d;
    3796. 

  3796.     calcMipmapGeometry(mipmapNum, w, h, d);
    3797. 

  3797.     return calcMipmapLevelSize(mipmapNum, w, h, d);
    3798. 

  3798. }
    3799. 

  3799. 

  3800. /*! Internal used method to calculate the mem sum of all mipmap levels in bpp
    3801. 

  3801.  */
    3802. 

  3802. 

  3803. UInt32 Image::calcMipmapSumSize(UInt32 mipmapNum,
    3804. 

  3804.                                 UInt32 w, 
    3805. 

  3805.                                 UInt32 h, 
    3806. 

  3806.                                 UInt32 d) const
    3807. 

  3807. {
    3808. 

  3808.     Int32 levelSum, sum = 0;
    3809. 

  3809. 

  3810.     if (w && h && d)
    3811. 

  3811.     { 
    3812. 

  3812.         while (mipmapNum--)
    3813. 

  3813.         {
    3814. 

  3814.             sum += calcMipmapLevelSize(mipmapNum,w,h,d);
    3815. 

  3815.       
    3816. 

  3816.             w >>= 1;
    3817. 

  3817.             h >>= 1;
    3818. 

  3818.             d >>= 1;
    3819. 

  3819.         }
    3820. 

  3820.     }
    3821. 

  3821. 

  3822.     return sum;
    3823. 

  3823. }
    3824. 

  3824. 

  3825. /*! Method to calculate the mem sum of all mipmap levels in byte
    3826. 

  3826.   for the current Image paramter
    3827. 

  3827.  */
    3828. 

  3828. UInt32 Image::calcMipmapSumSize (UInt32 mipmapNum) const
    3829. 

  3829. {
    3830. 

  3830.     return calcMipmapSumSize(mipmapNum, getWidth(), getHeight(), getDepth());
    3831. 

  3831. }
    3832. 

  3832. 

  3833. /*-------------------------------------------------------------------------*/
    3834. 

  3834. /*                            Image data                                   */
    3835. 

  3835. 

  3836. /*! Internal method to set the data and update related properties.
    3837. 

  3837.  */
    3838. 

  3838. 

  3839. bool Image::createData(const UInt8 *data, bool allocMem)
    3840. 

  3840. {
    3841. 

  3841.     Int32 i;
    3842. 

  3842.     Int32 mapSizeFormat = sizeof(_formatDic) / sizeof(UInt32[2]);
    3843. 

  3843.     Int32 mapSizeType   = sizeof(_typeDic  ) / sizeof(UInt32[2]);
    3844. 

  3844. 

  3845.     UInt32 byteCount = 0;
    3846. 

  3846. 

  3847.     // set bpp
    3848. 

  3848.     UInt32 pixelFormat = 0;
    3849. 

  3849.     UInt32 typeFormat  = 0;
    3850. 

  3850. 

  3851.     for(i = 0; i < mapSizeFormat; i++)
    3852. 

  3852.     {
    3853. 

  3853.         if(_formatDic[i][0] == getPixelFormat())
    3854. 

  3854.             pixelFormat = _formatDic[i][1];
    3855. 

  3855.     }
    3856. 

  3856. 

  3857.     for(i = 0; i < mapSizeType; i++)
    3858. 

  3858.     {
    3859. 

  3859.         if(_typeDic[i][0] == getDataType())
    3860. 

  3860.             typeFormat = _typeDic[i][1];
    3861. 

  3861.     }
    3862. 

  3862.     
    3863. 

  3863.     setComponentSize(typeFormat              );
    3864. 

  3864.     setBpp          (pixelFormat * typeFormat);
    3865. 

  3865.     
    3866. 

  3866.     // set dimension
    3867. 

  3867.     setDimension(0);
    3868. 

  3868. 

  3869.     if(getDepth() == 1)
    3870. 

  3870.     {
    3871. 

  3871.         if(getHeight() == 1)
    3872. 

  3872.         {
    3873. 

  3873.             setDimension(1);
    3874. 

  3874.         }
    3875. 

  3875.         else
    3876. 

  3876.         {
    3877. 

  3877.             setDimension(2);
    3878. 

  3878.         }
    3879. 

  3879.     }
    3880. 

  3880.     else
    3881. 

  3881.     {
    3882. 

  3882.         setDimension(3);
    3883. 

  3883.     }
    3884. 

  3884. 

  3885.     // set sideSize
    3886. 

  3886.     setSideSize (calcMipmapSumSize(getMipMapCount()    ));
    3887. 

  3887. 

  3888.     // set frameSize
    3889. 

  3889.     setFrameSize(getSideSize() * getSideCount());
    3890. 

  3890.     
    3891. 

  3891.     
    3892. 

  3892.     // copy the data
    3893. 

  3893.     if(allocMem && (byteCount = getSize()))
    3894. 

  3894.     {
    3895. 

  3895.         if(getPixel().size() != byteCount)
    3896. 

  3896.         {
    3897. 

  3897.             try
    3898. 

  3898.             {
    3899. 

  3899.                 if(byteCount < getPixel().size())
    3900. 

  3900.                 {
    3901. 

  3901.                     editPixel().clear();
    3902. 

  3902.                     // free unused memory.
    3903. 

  3903.                     MFUInt8 tmp;
    3904. 

  3904.                     tmp.swap(editPixel());
    3905. 

  3905.                 }
    3906. 

  3906.                 editPixel().resize(byteCount);
    3907. 

  3907.             }
    3908. 

  3908.             catch(...)
    3909. 

  3909.             {
    3910. 

  3910.                 FFATAL(("Image::createData : Couldn't allocate %u bytes!\n", 
    3911. 

  3911.                         byteCount));
    3912. 

  3912. 

  3913.                 return false;
    3914. 

  3914.             }
    3915. 

  3915.         }
    3916. 

  3916. 

  3917.         if(data)
    3918. 

  3918.         {
    3919. 

  3919.             memcpy(editData(), data, byteCount);
    3920. 

  3920.         }
    3921. 

  3921.     }
    3922. 

  3922.     else
    3923. 

  3923.     {
    3924. 

  3924.         editPixel().clear();
    3925. 

  3925.     }
    3926. 

  3926.     
    3927. 

  3927.     return (getData() != NULL);
    3928. 

  3928. }
    3929. 

  3929. 

  3930. /*! Internal method to scale image data blocks
    3931. 

  3931.  */
    3932. 

  3932. bool Image::scaleData(UInt8 *srcData, 
    3933. 

  3933.                       Int32  srcW, 
    3934. 

  3934.                       Int32  srcH, 
    3935. 

  3935.                       Int32  srcD,
    3936. 

  3936.                       UInt8 *destData, 
    3937. 

  3937.                       Int32  destW, 
    3938. 

  3938.                       Int32  destH, 
    3939. 

  3939.                       Int32  destD   )
    3940. 

  3940. {
    3941. 

  3941.     Real32  sx = Real32(srcW) / Real32(destW);
    3942. 

  3942.     Real32  sy = Real32(srcH) / Real32(destH);
    3943. 

  3943.     Real32  sz = Real32(srcD) / Real32(destD);
    3944. 

  3944. 

  3945.     Int32   srcSize = srcW * srcH * srcD * getBpp();
    3946. 

  3946. 

  3947.     //  Int32 destDize = destW * destH * destD;
    3948. 

  3948. 

  3949.     Int32   x, y, z, p;
    3950. 

  3950.     UInt8  *slice, *line, *pixel;
    3951. 

  3951. 

  3952.     if(destW == srcW && destH == srcH && destD == srcD)
    3953. 

  3953.     {
    3954. 

  3954.         // same size, just copy
    3955. 

  3955.         memcpy(destData, srcData, srcSize);
    3956. 

  3956.     }
    3957. 

  3957.     else
    3958. 

  3958.     {       // different size, to 'nearest' copy
    3959. 

  3959.         for(z = 0; z < destD; z++)
    3960. 

  3960.         {
    3961. 

  3961.             slice = srcData + int(sz * z) * getBpp() * srcW * srcH;
    3962. 

  3962. 

  3963.             for(y = 0; y < destH; y++)
    3964. 

  3964.             {
    3965. 

  3965.                 line = slice + int(sy * y) * getBpp() * srcW;
    3966. 

  3966. 

  3967.                 for(x = 0; x < destW; x++)
    3968. 

  3968.                 {
    3969. 

  3969.                     pixel = line + int(sx * x) * getBpp();
    3970. 

  3970. 

  3971.                     p = getBpp();
    3972. 

  3972. 

  3973.                     while(p--)
    3974. 

  3974.                     {
    3975. 

  3975.                         *destData++ = *pixel++;
    3976. 

  3976.                     }
    3977. 

  3977.                 }
    3978. 

  3978.             }
    3979. 

  3979.         }
    3980. 

  3980.     }
    3981. 

  3981.     
    3982. 

  3982.     return true;
    3983. 

  3983. }
    3984. 

  3984. 

  3985. /*! Assign operator. Does a copy of the given Image object.
    3986. 

  3986.  */
    3987. 

  3987. 

  3988. Image &Image::operator=(const Image &image)
    3989. 

  3989. {
    3990. 

  3990.     this->set((PixelFormat) image.getPixelFormat(), 
    3991. 

  3991.               image.getWidth      (),
    3992. 

  3992.               image.getHeight     (), 
    3993. 

  3993.               image.getDepth      (),
    3994. 

  3994.               image.getMipMapCount(), 
    3995. 

  3995.               image.getFrameCount (),
    3996. 

  3996.               image.getFrameDelay (),
    3997. 

  3997.               image.getData       (),
    3998. 

  3998.               image.getDataType   (),
    3999. 

  3999.               true, 
    4000. 

  4000.               image.getSideCount  ());
    4001. 

  4001. 

  4002.     return *this;
    4003. 

  4003. }
    4004. 

  4004. 

  4005. /*! Less operator; compares the data sizes of the two images
    4006. 

  4006. */
    4007. 

  4007. bool Image::operator<(const Image &image)
    4008. 

  4008. {
    4009. 

  4009.     return (getSize() < image.getSize()) ? true : false;
    4010. 

  4010. }
    4011. 

  4011. 

  4012. /*! Method to compare the object to another Image instance;
    4013. 

  4013.     Checks first all parameter and afterwards the Image data;
    4014. 

  4014. */
    4015. 

  4015. 

  4016. bool Image::operator ==(const Image &image)
    4017. 

  4017. {
    4018. 

  4018.     unsigned long   i, s = getSize();
    4019. 

  4019.     
    4020. 

  4020.     if((getWidth      () == image.getWidth      ()) &&
    4021. 

  4021.        (getHeight     () == image.getHeight     ()) &&
    4022. 

  4022.        (getDepth      () == image.getDepth      ()) &&
    4023. 

  4023.        (getMipMapCount() == image.getMipMapCount()) &&
    4024. 

  4024.        (getFrameCount () == image.getFrameCount ()) &&
    4025. 

  4025.        (getFrameDelay () == image.getFrameDelay ()) &&
    4026. 

  4026.        (getPixelFormat() == image.getPixelFormat()) &&
    4027. 

  4027.        (getDataType   () == image.getDataType   ()) &&
    4028. 

  4028.        (getSideCount  () == image.getSideCount  ()))
    4029. 

  4029.         
    4030. 

  4030.     {
    4031. 

  4031.         for(i = 0; i < s; ++i)
    4032. 

  4032.         {
    4033. 

  4033.             if(image.getData()[i] != getData()[i])
    4034. 

  4034.                 return false;
    4035. 

  4035.         }
    4036. 

  4036.         return true;
    4037. 

  4037.     }
    4038. 

  4038.     return false;
    4039. 

  4039. }
    4040. 

  4040. 

  4041. /*! Method to compare the object to another Image instance;
    4042. 

  4042.   Checks first all parameter and afterwards the Image data;
    4043. 

  4043.  */
    4044. 

  4044. 

  4045. bool Image::operator !=(const Image &image)
    4046. 

  4046. {
    4047. 

  4047.     return !(*this == image);
    4048. 

  4048. }
    4049. 

  4049. 

  4050. 

  4051.