00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 #define OSG_COMPILEIMAGE
00044
00045 #include <stdlib.h>
00046 #include <stdio.h>
00047
00048 #include <algorithm>
00049
00050 #include <OSGConfig.h>
00051 #include <OSGLog.h>
00052 #include <OSGImageGenericAtt.h>
00053 #include <OSGFieldContainerFields.h>
00054 #include <OSGFileSystem.h>
00055
00056 #include "OSGImageFileHandler.h"
00057 #include "OSGPathHandler.h"
00058 #include "OSGSceneFileHandler.h"
00059
00060 #include "OSGImage.h"
00061
00062 OSG_USING_NAMESPACE
00063
00068
00069
00070
00074 Int32 Image::_formatDic[][2] =
00075 {
00076 { OSG_A_PF, 1 },
00077 { OSG_I_PF, 1 },
00078 { OSG_L_PF, 1 },
00079 { OSG_LA_PF, 2 },
00080 { OSG_RGB_PF, 3 },
00081 { OSG_RGBA_PF, 4 },
00082 { OSG_BGR_PF, 3 },
00083 { OSG_BGRA_PF, 4 },
00084 { OSG_RGB_DXT1, 3},
00085 { OSG_RGBA_DXT1, 4},
00086 { OSG_RGBA_DXT3, 4},
00087 { OSG_RGBA_DXT5, 4},
00088 { OSG_ALPHA_INTEGER_PF, 1},
00089 { OSG_RGB_INTEGER_PF, 3},
00090 { OSG_RGBA_INTEGER_PF, 4},
00091 { OSG_BGR_INTEGER_PF, 3},
00092 { OSG_BGRA_INTEGER_PF, 4},
00093 { OSG_LUMINANCE_INTEGER_PF, 1},
00094 { OSG_LUMINANCE_ALPHA_INTEGER_PF, 2}
00095 };
00096
00097 Int32 Image::_typeDic[][2] =
00098 {
00099 { OSG_INVALID_IMAGEDATATYPE, 0 },
00100 { OSG_UINT8_IMAGEDATA, 1 },
00101 { OSG_UINT16_IMAGEDATA, 2 },
00102 { OSG_UINT32_IMAGEDATA, 4 },
00103 { OSG_FLOAT32_IMAGEDATA, 4 },
00104 { OSG_FLOAT16_IMAGEDATA, 2 },
00105 { OSG_INT16_IMAGEDATA, 2 },
00106 { OSG_INT32_IMAGEDATA, 4 }
00107 };
00108
00109
00110
00111 void Image::initMethod (void)
00112 {
00113 }
00114
00117 void Image::changed(BitVector whichField, UInt32 origin)
00118 {
00119 MFFieldContainerPtr::iterator parentsIt = _mfParents.begin();
00120 MFFieldContainerPtr::iterator parentsEnd = _mfParents.end();
00121
00122 while(parentsIt != parentsEnd)
00123 {
00124 (*parentsIt)->changed( TypeTraits<BitVector>::One <<
00125 parentsIt->getParentFieldPos(),
00126 ChangedOrigin::Child);
00127 ++parentsIt;
00128 }
00129
00130
00131 Int32 mapSizeType = sizeof(_typeDic) / sizeof(UInt32[2]);
00132 UInt32 typeFormat = 0;
00133 Int32 i;
00134 for(i = 0; i < mapSizeType; i++)
00135 {
00136 if(_typeDic[i][0] == getDataType())
00137 typeFormat = _typeDic[i][1];
00138 }
00139
00140 setComponentSize( typeFormat );
00141 setSideSize ( calcMipmapSumSize(getMipMapCount()) );
00142 setFrameSize( getSideSize() * getSideCount() );
00143
00144 Inherited::changed(whichField, origin);
00145 }
00146
00147
00148
00149 void Image::dump(UInt32 ,
00150 const BitVector ) const
00151 {
00152 const char *pfStr = "UNDEF_PIXEL_FORMAT";
00153 const char *typeStr = "INVALID_IMAGEDATA_TYPE";
00154
00155 switch(getPixelFormat())
00156 {
00157 case OSG_A_PF:
00158 pfStr = "ALPHA";
00159 break;
00160 case OSG_I_PF:
00161 pfStr = "INTENSITY";
00162 break;
00163 case OSG_L_PF:
00164 pfStr = "LUMINANCE";
00165 break;
00166 case OSG_LA_PF:
00167 pfStr = "LUMINANCE_ALPHA";
00168 break;
00169 case OSG_BGR_PF:
00170 pfStr = "BGR";
00171 break;
00172 case OSG_BGRA_PF:
00173 pfStr = "BGRA";
00174 break;
00175 case OSG_RGB_PF:
00176 pfStr = "RGB";
00177 break;
00178 case OSG_RGBA_PF:
00179 pfStr = "RGBA";
00180 break;
00181 case OSG_RGB_DXT1:
00182 pfStr = "RGB_DXT1";
00183 break;
00184 case OSG_RGBA_DXT1:
00185 pfStr = "RGBA_DXT1";
00186 break;
00187 case OSG_RGBA_DXT3:
00188 pfStr = "RGBA_DXT3";
00189 break;
00190 case OSG_RGBA_DXT5:
00191 pfStr = "RGBA_DXT5";
00192 break;
00193 case OSG_ALPHA_INTEGER_PF:
00194 pfStr = "ALPHA_INTEGER";
00195 break;
00196 case OSG_RGB_INTEGER_PF:
00197 pfStr = "RGB_INTEGER";
00198 break;
00199 case OSG_RGBA_INTEGER_PF:
00200 pfStr = "RGBA_INTEGER";
00201 break;
00202 case OSG_BGR_INTEGER_PF:
00203 pfStr = "BGR_INTEGER";
00204 break;
00205 case OSG_BGRA_INTEGER_PF:
00206 pfStr = "BGRA_INTEGER";
00207 break;
00208 case OSG_LUMINANCE_INTEGER_PF:
00209 pfStr = "LUMINANCE_INTEGER";
00210 break;
00211 case OSG_LUMINANCE_ALPHA_INTEGER_PF:
00212 pfStr = "LUMINANCE_ALPHA_INTEGER";
00213 break;
00214 default:
00215 pfStr = "UNKNOWN_PIXEL_FORMAT";
00216 break;
00217 };
00218
00219 switch (getDataType())
00220 {
00221 case OSG_UINT8_IMAGEDATA:
00222 typeStr = "IMAGEDATA_TYPE UCHAR8";
00223 break;
00224 case OSG_UINT16_IMAGEDATA:
00225 typeStr = "IMAGEDATA_TYPE UCHAR16";
00226 break;
00227 case OSG_UINT32_IMAGEDATA:
00228 typeStr = "IMAGEDATA_TYPE UCHAR32";
00229 break;
00230 case OSG_FLOAT16_IMAGEDATA:
00231 typeStr = "IMAGEDATA_TYPE FLOAT16";
00232 break;
00233 case OSG_FLOAT32_IMAGEDATA:
00234 typeStr = "IMAGEDATA_TYPE FLOAT32";
00235 break;
00236 case OSG_INT16_IMAGEDATA:
00237 typeStr = "IMAGEDATA_TYPE INT16";
00238 break;
00239 case OSG_INT32_IMAGEDATA:
00240 typeStr = "IMAGEDATA_TYPE INT32";
00241 break;
00242
00243 default:
00244 typeStr = "UNKNOWN_IMAGEDATA_TYPE";
00245 break;
00246 };
00247
00248 FLOG (("ImageDump: %s; %d/%d/%d; #mm: %d, #side: %d, #frame: %d, frameDelay %g, dataType %s, size: %d\n",
00249 pfStr, getWidth(),
00250 getHeight(), getDepth(),
00251 getMipMapCount(),
00252 getSideCount(),
00253 getFrameCount(), getFrameDelay(),
00254 typeStr,
00255 getSize()
00256 ));
00257 }
00258
00259
00260
00261
00262 UInt8 Image::getComponents(void) const
00263 {
00264 Int32 mapSizeFormat = sizeof(_formatDic) / sizeof(UInt32[2]);
00265
00266 for(UInt16 i = 0; i < mapSizeFormat; i++)
00267 {
00268 if(_formatDic[i][0] == getPixelFormat())
00269 return _formatDic[i][1];
00270 }
00271 FWARNING(("Image::getComponents: image %p has unknown pixel format 0x%x!",
00272 this, getPixelFormat()));
00273 return 0;
00274 }
00275
00276
00277
00281 bool Image::set(UInt32 pF,
00282 Int32 w, Int32 h,
00283 Int32 d, Int32 mmS, Int32 fS,
00284 Time fD, const UChar8 *da, Int32 t, bool allocMem,
00285 Int32 sS)
00286 {
00287 ImagePtr iPtr(this);
00288
00289 beginEditCP(iPtr,
00290 PixelFormatFieldMask |
00291 WidthFieldMask |
00292 HeightFieldMask |
00293 DepthFieldMask |
00294 MipMapCountFieldMask |
00295 SideCountFieldMask |
00296 FrameCountFieldMask |
00297 FrameDelayFieldMask |
00298 DataTypeFieldMask);
00299
00300 setPixelFormat(pF);
00301
00302 setWidth ( osgMax ( 1, w) );
00303 setHeight ( osgMax ( 1, h) );
00304 setDepth ( osgMax ( 1, d) );
00305
00306 setMipMapCount ( osgMax ( 1, mmS) );
00307 setSideCount ( osgMax ( 1, sS) );
00308 setFrameCount ( osgMax ( 1, fS) );
00309
00310 setFrameDelay(fD);
00311
00312 setDataType (t);
00313
00314 endEditCP(iPtr,
00315 PixelFormatFieldMask |
00316 WidthFieldMask |
00317 HeightFieldMask |
00318 DepthFieldMask |
00319 MipMapCountFieldMask |
00320 FrameCountFieldMask |
00321 FrameDelayFieldMask |
00322 DataTypeFieldMask);
00323
00324 return createData(da, allocMem);
00325 }
00326
00331 bool Image::set(ImagePtr image)
00332 {
00333 this->set(image->getPixelFormat(),
00334 image->getWidth(),
00335 image->getHeight(),
00336 image->getDepth(),
00337 image->getMipMapCount(),
00338 image->getFrameCount(),
00339 image->getFrameDelay(),
00340 image->getData(),
00341 image->getDataType(),
00342 true,
00343 image->getSideCount());
00344
00345 return true;
00346 }
00347
00351 bool Image::setData(const UChar8 *da)
00352 {
00353 if(da)
00354 {
00355 createData(da);
00356 }
00357 else
00358 {
00359 FWARNING(("Image::setData(Null) call\n"));
00360 }
00361
00362 return (da ? true : false);
00363 }
00364
00365 void Image::clearData(void)
00366 {
00367 getPixel().clear();
00368 }
00369
00373 bool Image::setSubData ( Int32 offX, Int32 offY, Int32 offZ,
00374 Int32 srcW, Int32 srcH, Int32 srcD,
00375 const UInt8 *src )
00376 {
00377 UChar8 *dest = getData();
00378 UInt64 lineSize;
00379
00380 FDEBUG(( "Image::setSubData (%d %d %d) - (%d %d %d) - src %p\n",
00381 offX, offY, offZ, srcW, srcH, srcD, src ));
00382
00383 if (hasCompressedData())
00384 {
00385 FFATAL (("Invalid Image::setSubData for compressed image\n"));
00386 return false;
00387 }
00388
00389 if(!src || !dest)
00390 {
00391 FFATAL(("Invalid data pointer in Image::setSubData\n"));
00392 return false;
00393 }
00394
00395
00396 UInt32 xMin = osgMax(0,offX);
00397 UInt32 yMin = osgMax(0,offY);
00398 UInt32 zMin = osgMax(0,offZ);
00399
00400 UInt32 xMax = osgMin(getWidth(), offX + srcW);
00401 UInt32 yMax = osgMin(getHeight(), offY + srcH);
00402 UInt32 zMax = osgMin(getDepth(), offZ + srcD);
00403
00404
00405 UInt32 destIdx, srcIdx = 0;
00406
00407 for(UInt32 z = zMin; z < zMax; z++)
00408 {
00409 for(UInt32 y = yMin; y < yMax; y++)
00410 {
00411 lineSize = (xMax - xMin) * getBpp();
00412 destIdx = ( (z * getHeight() + y) * getWidth() + xMin) * getBpp();
00413 memcpy (&dest[destIdx], &src[srcIdx], size_t(lineSize));
00414 srcIdx += Int32((srcW - (xMax - xMin)) * getBpp() + lineSize);
00415 }
00416 srcIdx += (srcH - (yMax - yMin)) * srcW * getBpp();
00417 }
00418
00419 return true;
00420 }
00421
00427 bool Image::flipDepthFrameData (void)
00428 {
00429 bool retCode = false;
00430 Int32 value;
00431
00432 if((getMipMapCount() == 1)&&((getFrameCount() == 1)||(getDepth() == 1)))
00433 {
00434 value = getFrameCount();
00435 setFrameCount(getDepth());
00436 setDepth(value);
00437 retCode = true;
00438 }
00439 else
00440 {
00441 FWARNING (("Cant flipDepthFrameData(); invalid data layout\n"));
00442 }
00443
00444 return retCode;
00445 }
00446
00450 bool Image::addValue(const char *value)
00451 {
00452 static Image *currentImage = 0;
00453 static UChar8 *currentData = 0;
00454
00455 Int64 j;
00456 Int64 v;
00457
00458 bool isHead = strchr(value, ' ') ? true : false;
00459
00460 if (hasCompressedData())
00461 {
00462 FFATAL (("Invalid Image::addValue for compressed image\n"));
00463 return false;
00464 }
00465
00466
00467 if(currentImage == this)
00468 {
00469 if(isHead)
00470 {
00471 FDEBUG(("Start new read cycle in image::addValue()\n"));
00472 }
00473 }
00474 else
00475 {
00476 if(!isHead)
00477 {
00478 FFATAL(("Additional image date for different image\n"));
00479 }
00480 }
00481
00482 currentImage = this;
00483
00484 if(isHead == true)
00485 {
00486 Int32 width;
00487 Int32 height;
00488 Int32 pixelDepth;
00489 PixelFormat pf = osg::Image::OSG_INVALID_PF;
00490
00491
00492 sscanf(value, "%d %d %d", &width, &height, &pixelDepth);
00493
00494 FDEBUG(("Image::addValue() set: w/h/bpp: %d/%d/%d\n",
00495 width, height, pixelDepth));
00496
00497 switch(getDataType())
00498 {
00499 case OSG_UINT8_IMAGEDATA:
00500 switch(pixelDepth)
00501 {
00502 case 1:
00503 pf = osg::Image::OSG_L_PF;
00504 break;
00505 case 2:
00506 pf = osg::Image::OSG_LA_PF;
00507 break;
00508 case 3:
00509 pf = osg::Image::OSG_RGB_PF;
00510 break;
00511 case 4:
00512 pf = osg::Image::OSG_RGBA_PF;
00513 break;
00514 default:
00515 pf = osg::Image::OSG_INVALID_PF;
00516 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00517 break;
00518 }
00519 break;
00520 case OSG_UINT16_IMAGEDATA:
00521 switch(pixelDepth)
00522 {
00523 case 2:
00524 pf = osg::Image::OSG_L_PF;
00525 break;
00526 case 4:
00527 pf = osg::Image::OSG_LA_PF;
00528 break;
00529 case 6:
00530 pf = osg::Image::OSG_RGB_PF;
00531 break;
00532 case 8:
00533 pf = osg::Image::OSG_RGBA_PF;
00534 break;
00535 default:
00536 pf = osg::Image::OSG_INVALID_PF;
00537 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00538 break;
00539 }
00540 break;
00541 case OSG_UINT32_IMAGEDATA:
00542 switch(pixelDepth)
00543 {
00544 case 4:
00545 pf = osg::Image::OSG_L_PF;
00546 break;
00547 case 8:
00548 pf = osg::Image::OSG_LA_PF;
00549 break;
00550 case 12:
00551 pf = osg::Image::OSG_RGB_PF;
00552 break;
00553 case 16:
00554 pf = osg::Image::OSG_RGBA_PF;
00555 break;
00556 default:
00557 pf = osg::Image::OSG_INVALID_PF;
00558 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00559 break;
00560 }
00561 break;
00562 case OSG_FLOAT32_IMAGEDATA:
00563 switch(pixelDepth)
00564 {
00565 case 4:
00566 pf = osg::Image::OSG_L_PF;
00567 break;
00568 case 8:
00569 pf = osg::Image::OSG_LA_PF;
00570 break;
00571 case 12:
00572 pf = osg::Image::OSG_RGB_PF;
00573 break;
00574 case 16:
00575 pf = osg::Image::OSG_RGBA_PF;
00576 break;
00577 default:
00578 pf = osg::Image::OSG_INVALID_PF;
00579 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00580 break;
00581 }
00582 break;
00583 case OSG_FLOAT16_IMAGEDATA:
00584 switch(pixelDepth)
00585 {
00586 case 2:
00587 pf = osg::Image::OSG_L_PF;
00588 break;
00589 case 4:
00590 pf = osg::Image::OSG_LA_PF;
00591 break;
00592 case 6:
00593 pf = osg::Image::OSG_RGB_PF;
00594 break;
00595 case 8:
00596 pf = osg::Image::OSG_RGBA_PF;
00597 break;
00598 default:
00599 pf = osg::Image::OSG_INVALID_PF;
00600 FFATAL(("Invalid pixel depth: %d\n", pixelDepth));
00601 break;
00602 }
00603 break;
00604 case OSG_INT16_IMAGEDATA:
00605 case OSG_INT32_IMAGEDATA:
00606 {
00607 FFATAL((" 'addValue' NYI\n "));
00608 }
00609 break;
00610 default:
00611 setDataType(OSG_INVALID_IMAGEDATATYPE);
00612 FFATAL(("Invalid type of image data: %d\n", getDataType()));
00613 }
00614
00615 if(pf != 0 && (width > 0) && (height > 0))
00616 {
00617 set(pf, width, height);
00618
00619 currentData = getData();
00620 }
00621 else
00622 {
00623 currentData = NULL;
00624 }
00625 }
00626 else
00627 {
00628 if(currentData != NULL)
00629 {
00630
00631
00632
00633 v = strtoul(value, 0, strchr(value, 'x') ? 16 : 10);
00634
00635 for(j = getBpp(); j--;)
00636 {
00637 *currentData++ = UChar8( (v >> (8 * j)) & 255 );
00638 }
00639
00640 }
00641 }
00642
00643 return currentData ? true : false;
00644 }
00645
00649 bool Image::reformat ( const Image::PixelFormat pixelFormat,
00650 ImagePtr destination )
00651 {
00652 UChar8 *data = 0,*sourceData = 0;
00653 UInt32 srcI, destI, destSize = 0;
00654 UInt32 sum;
00655 Real64 sumReal;
00656 ImagePtr dest = destination;
00657
00658 if (hasCompressedData())
00659 {
00660 FFATAL (("Invalid Image::reformat for compressed image\n"));
00661 return false;
00662 }
00663
00664 if(destination == NullFC)
00665 {
00666 dest = Image::create();
00667 addRefCP(dest);
00668 }
00669
00670 FINFO (( "Try to reformat image from pixelDepth %d to %d\n",
00671 getPixelFormat(), pixelFormat ));
00672
00673
00674
00675 if ( getSize() && pixelFormat &&
00676 (destination != NullFC || (pixelFormat != getPixelFormat()) ) )
00677 {
00678
00679 dest->set(pixelFormat, getWidth(), getHeight(), getDepth() );
00680 sourceData = getData();
00681 data = dest->getData();
00682 destSize = dest->getSize();
00683
00684 UInt16 *sourceDataUC16 = (UInt16*) sourceData;
00685 UInt16 *destDataUC16 = (UInt16*) data;
00686 UInt32 *sourceDataUC32 = (UInt32*) sourceData;
00687 UInt32 *destDataUC32 = (UInt32*) data;
00688 Real32 *sourceDataF32 = (Real32*) sourceData;
00689 Real32 *destDataF32 = (Real32*) data;
00690 Real16 *sourceDataH16 = (Real16*) sourceData;
00691 Real16 *destDataH16 = (Real16* ) data;
00692
00693 if (data)
00694 {
00695 switch (getPixelFormat())
00696 {
00697
00698 case OSG_A_PF:
00699 switch (pixelFormat) {
00700 case OSG_A_PF:
00701 case OSG_I_PF:
00702 switch (getDataType())
00703 {
00704 case OSG_UINT8_IMAGEDATA:
00705 memcpy (data, getData(), destSize);
00706 break;
00707 case OSG_UINT16_IMAGEDATA:
00708 memcpy (data, getData(), destSize);
00709 break;
00710 case OSG_UINT32_IMAGEDATA:
00711 memcpy (data, getData(), destSize);
00712 break;
00713 case OSG_FLOAT32_IMAGEDATA:
00714 memcpy (data, getData(), destSize);
00715 break;
00716 case OSG_FLOAT16_IMAGEDATA:
00717 memcpy (data, getData(), destSize);
00718 break;
00719
00720 default:
00721 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00722 break;
00723 }
00724 break;
00725
00726 case OSG_L_PF:
00727 switch (getDataType())
00728 {
00729 case OSG_UINT8_IMAGEDATA:
00730 memcpy (data, getData(), destSize);
00731 break;
00732 case OSG_UINT16_IMAGEDATA:
00733 memcpy (data, getData(), destSize);
00734 break;
00735 case OSG_UINT32_IMAGEDATA:
00736 memcpy (data, getData(), destSize);
00737 break;
00738 case OSG_FLOAT32_IMAGEDATA:
00739 memcpy (data, getData(), destSize);
00740 break;
00741 case OSG_FLOAT16_IMAGEDATA:
00742 memcpy (data, getData(), destSize);
00743 break;
00744
00745 default:
00746 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00747 break;
00748 }
00749 break;
00750
00751 case OSG_LA_PF:
00752 switch (getDataType())
00753 {
00754 case OSG_UINT8_IMAGEDATA:
00755 for (srcI = destI = 0; destI < destSize;)
00756 {
00757 data[destI++] = sourceData[srcI];
00758 data[destI++] = sourceData[srcI++];
00759 }
00760 break;
00761 case OSG_UINT16_IMAGEDATA:
00762 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00763 {
00764 destDataUC16[destI++] = sourceDataUC16[srcI];
00765 destDataUC16[destI++] = sourceDataUC16[srcI++];
00766 }
00767 break;
00768 case OSG_UINT32_IMAGEDATA:
00769 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00770 {
00771 destDataUC32[destI++] = sourceDataUC32[srcI];
00772 destDataUC32[destI++] = sourceDataUC32[srcI++];
00773 }
00774 break;
00775 case OSG_FLOAT32_IMAGEDATA:
00776 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00777 {
00778 destDataF32[destI++] = sourceDataF32[srcI];
00779 destDataF32[destI++] = sourceDataF32[srcI++];
00780 }
00781 break;
00782
00783 case OSG_FLOAT16_IMAGEDATA:
00784 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00785 {
00786 destDataH16[destI++] = sourceDataH16[srcI];
00787 destDataH16[destI++] = sourceDataH16[srcI++];
00788 }
00789 break;
00790 default:
00791 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00792 break;
00793 }
00794 break;
00795
00796 case OSG_RGB_PF:
00797 switch (getDataType())
00798 {
00799 case OSG_UINT8_IMAGEDATA:
00800 for (srcI = destI = 0; destI < destSize;)
00801 {
00802 data[destI++] = sourceData[srcI];
00803 data[destI++] = sourceData[srcI];
00804 data[destI++] = sourceData[srcI++];
00805 }
00806 break;
00807 case OSG_UINT16_IMAGEDATA:
00808 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00809 {
00810 destDataUC16[destI++] = sourceDataUC16[srcI];
00811 destDataUC16[destI++] = sourceDataUC16[srcI];
00812 destDataUC16[destI++] = sourceDataUC16[srcI++];
00813 }
00814 break;
00815 case OSG_UINT32_IMAGEDATA:
00816 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00817 {
00818 destDataUC32[destI++] = sourceDataUC32[srcI];
00819 destDataUC32[destI++] = sourceDataUC32[srcI];
00820 destDataUC32[destI++] = sourceDataUC32[srcI++];
00821 }
00822 break;
00823 case OSG_FLOAT32_IMAGEDATA:
00824 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00825 {
00826 destDataF32[destI++] = sourceDataF32[srcI];
00827 destDataF32[destI++] = sourceDataF32[srcI];
00828 destDataF32[destI++] = sourceDataF32[srcI++];
00829 }
00830 break;
00831 case OSG_FLOAT16_IMAGEDATA:
00832 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00833 {
00834 destDataH16[destI++] = sourceDataH16[srcI];
00835 destDataH16[destI++] = sourceDataH16[srcI];
00836 destDataH16[destI++] = sourceDataH16[srcI++];
00837 }
00838 break;
00839 default:
00840 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00841 break;
00842 }
00843 break;
00844
00845 case OSG_RGBA_PF:
00846 switch (getDataType())
00847 {
00848 case OSG_UINT8_IMAGEDATA:
00849 for (srcI = destI = 0; destI < destSize;)
00850 {
00851 data[destI++] = sourceData[srcI];
00852 data[destI++] = sourceData[srcI];
00853 data[destI++] = sourceData[srcI];
00854 data[destI++] = sourceData[srcI++];
00855 }
00856 break;
00857 case OSG_UINT16_IMAGEDATA:
00858 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00859 {
00860 destDataUC16[destI++] = sourceDataUC16[srcI];
00861 destDataUC16[destI++] = sourceDataUC16[srcI];
00862 destDataUC16[destI++] = sourceDataUC16[srcI];
00863 destDataUC16[destI++] = sourceDataUC16[srcI++];
00864 }
00865 break;
00866 case OSG_UINT32_IMAGEDATA:
00867 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00868 {
00869 destDataUC32[destI++] = sourceDataUC32[srcI];
00870 destDataUC32[destI++] = sourceDataUC32[srcI];
00871 destDataUC32[destI++] = sourceDataUC32[srcI];
00872 destDataUC32[destI++] = sourceDataUC32[srcI++];
00873 }
00874 break;
00875 case OSG_FLOAT32_IMAGEDATA:
00876 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00877 {
00878 destDataF32[destI++] = sourceDataF32[srcI];
00879 destDataF32[destI++] = sourceDataF32[srcI];
00880 destDataF32[destI++] = sourceDataF32[srcI];
00881 destDataF32[destI++] = sourceDataF32[srcI++];
00882 }
00883 break;
00884 case OSG_FLOAT16_IMAGEDATA:
00885 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00886 {
00887 destDataH16[destI++] = sourceDataH16[srcI];
00888 destDataH16[destI++] = sourceDataH16[srcI];
00889 destDataH16[destI++] = sourceDataH16[srcI];
00890 destDataH16[destI++] = sourceDataH16[srcI++];
00891 }
00892 break;
00893 default:
00894 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00895 break;
00896 }
00897 break;
00898 default:
00899 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00900 break;
00901 }
00902 break;
00903
00904
00905 case OSG_I_PF:
00906 switch (pixelFormat) {
00907 case OSG_A_PF:
00908 case OSG_I_PF:
00909 case OSG_L_PF:
00910 switch (getDataType())
00911 {
00912 case OSG_UINT8_IMAGEDATA:
00913 memcpy (data, getData(), destSize);
00914 break;
00915 case OSG_UINT16_IMAGEDATA:
00916 memcpy (data, getData(), destSize);
00917 break;
00918 case OSG_UINT32_IMAGEDATA:
00919 memcpy (data, getData(), destSize);
00920 break;
00921 case OSG_FLOAT32_IMAGEDATA:
00922 memcpy (data, getData(), destSize);
00923 break;
00924 case OSG_FLOAT16_IMAGEDATA:
00925 memcpy (data, getData(), destSize);
00926 break;
00927
00928 default:
00929 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00930 break;
00931 }
00932 break;
00933
00934 case OSG_LA_PF:
00935 switch (getDataType())
00936 {
00937 case OSG_UINT8_IMAGEDATA:
00938 for (srcI = destI = 0; destI < destSize;)
00939 {
00940 data[destI++] = sourceData[srcI];
00941 data[destI++] = sourceData[srcI++];
00942 }
00943 break;
00944 case OSG_UINT16_IMAGEDATA:
00945 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00946 {
00947 destDataUC16[destI++] = sourceDataUC16[srcI];
00948 destDataUC16[destI++] = sourceDataUC16[srcI++];
00949 }
00950 break;
00951 case OSG_UINT32_IMAGEDATA:
00952 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00953 {
00954 destDataUC32[destI++] = sourceDataUC32[srcI];
00955 destDataUC32[destI++] = sourceDataUC32[srcI++];
00956 }
00957 break;
00958 case OSG_FLOAT32_IMAGEDATA:
00959 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00960 {
00961 destDataF32[destI++] = sourceDataF32[srcI];
00962 destDataF32[destI++] = sourceDataF32[srcI++];
00963 }
00964 break;
00965
00966 case OSG_FLOAT16_IMAGEDATA:
00967 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00968 {
00969 destDataH16[destI++] = sourceDataH16[srcI];
00970 destDataH16[destI++] = sourceDataH16[srcI++];
00971 }
00972 break;
00973 default:
00974 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
00975 break;
00976 }
00977 break;
00978
00979 case OSG_RGB_PF:
00980 switch (getDataType())
00981 {
00982 case OSG_UINT8_IMAGEDATA:
00983 for (srcI = destI = 0; destI < destSize;)
00984 {
00985 data[destI++] = sourceData[srcI];
00986 data[destI++] = sourceData[srcI];
00987 data[destI++] = sourceData[srcI++];
00988 }
00989 break;
00990 case OSG_UINT16_IMAGEDATA:
00991 for (srcI = destI = 0; destI < destSize/getComponentSize();)
00992 {
00993 destDataUC16[destI++] = sourceDataUC16[srcI];
00994 destDataUC16[destI++] = sourceDataUC16[srcI];
00995 destDataUC16[destI++] = sourceDataUC16[srcI++];
00996 }
00997 break;
00998 case OSG_UINT32_IMAGEDATA:
00999 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01000 {
01001 destDataUC32[destI++] = sourceDataUC32[srcI];
01002 destDataUC32[destI++] = sourceDataUC32[srcI];
01003 destDataUC32[destI++] = sourceDataUC32[srcI++];
01004 }
01005 break;
01006 case OSG_FLOAT32_IMAGEDATA:
01007 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01008 {
01009 destDataF32[destI++] = sourceDataF32[srcI];
01010 destDataF32[destI++] = sourceDataF32[srcI];
01011 destDataF32[destI++] = sourceDataF32[srcI++];
01012 }
01013 break;
01014 case OSG_FLOAT16_IMAGEDATA:
01015 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01016 {
01017 destDataH16[destI++] = sourceDataH16[srcI];
01018 destDataH16[destI++] = sourceDataH16[srcI];
01019 destDataH16[destI++] = sourceDataH16[srcI++];
01020 }
01021 break;
01022 default:
01023 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01024 break;
01025 }
01026 break;
01027
01028 case OSG_RGBA_PF:
01029 switch (getDataType())
01030 {
01031 case OSG_UINT8_IMAGEDATA:
01032 for (srcI = destI = 0; destI < destSize;)
01033 {
01034 data[destI++] = sourceData[srcI];
01035 data[destI++] = sourceData[srcI];
01036 data[destI++] = sourceData[srcI];
01037 data[destI++] = sourceData[srcI++];
01038 }
01039 break;
01040 case OSG_UINT16_IMAGEDATA:
01041 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01042 {
01043 destDataUC16[destI++] = sourceDataUC16[srcI];
01044 destDataUC16[destI++] = sourceDataUC16[srcI];
01045 destDataUC16[destI++] = sourceDataUC16[srcI];
01046 destDataUC16[destI++] = sourceDataUC16[srcI++];
01047 }
01048 break;
01049 case OSG_UINT32_IMAGEDATA:
01050 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01051 {
01052 destDataUC32[destI++] = sourceDataUC32[srcI];
01053 destDataUC32[destI++] = sourceDataUC32[srcI];
01054 destDataUC32[destI++] = sourceDataUC32[srcI];
01055 destDataUC32[destI++] = sourceDataUC32[srcI++];
01056 }
01057 break;
01058 case OSG_FLOAT32_IMAGEDATA:
01059 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01060 {
01061 destDataF32[destI++] = sourceDataF32[srcI];
01062 destDataF32[destI++] = sourceDataF32[srcI];
01063 destDataF32[destI++] = sourceDataF32[srcI];
01064 destDataF32[destI++] = sourceDataF32[srcI++];
01065 }
01066 break;
01067 case OSG_FLOAT16_IMAGEDATA:
01068 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01069 {
01070 destDataH16[destI++] = sourceDataH16[srcI];
01071 destDataH16[destI++] = sourceDataH16[srcI];
01072 destDataH16[destI++] = sourceDataH16[srcI];
01073 destDataH16[destI++] = sourceDataH16[srcI++];
01074 }
01075 break;
01076 default:
01077 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01078 break;
01079 }
01080 break;
01081 default:
01082 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01083 break;
01084 }
01085 break;
01086
01087
01088
01089 case OSG_L_PF:
01090 switch (pixelFormat) {
01091 case OSG_A_PF:
01092 case OSG_I_PF:
01093 case OSG_L_PF:
01094 switch (getDataType())
01095 {
01096 case OSG_UINT8_IMAGEDATA:
01097 memcpy (data, getData(), destSize);
01098 break;
01099 case OSG_UINT16_IMAGEDATA:
01100 memcpy (data, getData(), destSize);
01101 break;
01102 case OSG_UINT32_IMAGEDATA:
01103 memcpy (data, getData(), destSize);
01104 break;
01105 case OSG_FLOAT32_IMAGEDATA:
01106 memcpy (data, getData(), destSize);
01107 break;
01108 case OSG_FLOAT16_IMAGEDATA:
01109 memcpy (data, getData(), destSize);
01110 break;
01111
01112 default:
01113 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01114 break;
01115 }
01116 break;
01117
01118 case OSG_LA_PF:
01119 switch (getDataType())
01120 {
01121 case OSG_UINT8_IMAGEDATA:
01122 for (srcI = destI = 0; destI < destSize;)
01123 {
01124 data[destI++] = sourceData[srcI];
01125 data[destI++] = sourceData[srcI++];
01126 }
01127 break;
01128 case OSG_UINT16_IMAGEDATA:
01129 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01130 {
01131 destDataUC16[destI++] = sourceDataUC16[srcI];
01132 destDataUC16[destI++] = sourceDataUC16[srcI++];
01133 }
01134 break;
01135 case OSG_UINT32_IMAGEDATA:
01136 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01137 {
01138 destDataUC32[destI++] = sourceDataUC32[srcI];
01139 destDataUC32[destI++] = sourceDataUC32[srcI++];
01140 }
01141 break;
01142 case OSG_FLOAT32_IMAGEDATA:
01143 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01144 {
01145 destDataF32[destI++] = sourceDataF32[srcI];
01146 destDataF32[destI++] = sourceDataF32[srcI++];
01147 }
01148 break;
01149
01150 case OSG_FLOAT16_IMAGEDATA:
01151 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01152 {
01153 destDataH16[destI++] = sourceDataH16[srcI];
01154 destDataH16[destI++] = sourceDataH16[srcI++];
01155 }
01156 break;
01157 default:
01158 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01159 break;
01160 }
01161 break;
01162
01163 case OSG_RGB_PF:
01164 switch (getDataType())
01165 {
01166 case OSG_UINT8_IMAGEDATA:
01167 for (srcI = destI = 0; destI < destSize;)
01168 {
01169 data[destI++] = sourceData[srcI];
01170 data[destI++] = sourceData[srcI];
01171 data[destI++] = sourceData[srcI++];
01172 }
01173 break;
01174 case OSG_UINT16_IMAGEDATA:
01175 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01176 {
01177 destDataUC16[destI++] = sourceDataUC16[srcI];
01178 destDataUC16[destI++] = sourceDataUC16[srcI];
01179 destDataUC16[destI++] = sourceDataUC16[srcI++];
01180 }
01181 break;
01182 case OSG_UINT32_IMAGEDATA:
01183 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01184 {
01185 destDataUC32[destI++] = sourceDataUC32[srcI];
01186 destDataUC32[destI++] = sourceDataUC32[srcI];
01187 destDataUC32[destI++] = sourceDataUC32[srcI++];
01188 }
01189 break;
01190 case OSG_FLOAT32_IMAGEDATA:
01191 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01192 {
01193 destDataF32[destI++] = sourceDataF32[srcI];
01194 destDataF32[destI++] = sourceDataF32[srcI];
01195 destDataF32[destI++] = sourceDataF32[srcI++];
01196 }
01197 break;
01198 case OSG_FLOAT16_IMAGEDATA:
01199 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01200 {
01201 destDataH16[destI++] = sourceDataH16[srcI];
01202 destDataH16[destI++] = sourceDataH16[srcI];
01203 destDataH16[destI++] = sourceDataH16[srcI++];
01204 }
01205 break;
01206 default:
01207 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01208 break;
01209 }
01210 break;
01211
01212 case OSG_RGBA_PF:
01213 switch (getDataType())
01214 {
01215 case OSG_UINT8_IMAGEDATA:
01216 for (srcI = destI = 0; destI < destSize;)
01217 {
01218 data[destI++] = sourceData[srcI];
01219 data[destI++] = sourceData[srcI];
01220 data[destI++] = sourceData[srcI];
01221 data[destI++] = sourceData[srcI++];
01222 }
01223 break;
01224 case OSG_UINT16_IMAGEDATA:
01225 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01226 {
01227 destDataUC16[destI++] = sourceDataUC16[srcI];
01228 destDataUC16[destI++] = sourceDataUC16[srcI];
01229 destDataUC16[destI++] = sourceDataUC16[srcI];
01230 destDataUC16[destI++] = sourceDataUC16[srcI++];
01231 }
01232 break;
01233 case OSG_UINT32_IMAGEDATA:
01234 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01235 {
01236 destDataUC32[destI++] = sourceDataUC32[srcI];
01237 destDataUC32[destI++] = sourceDataUC32[srcI];
01238 destDataUC32[destI++] = sourceDataUC32[srcI];
01239 destDataUC32[destI++] = sourceDataUC32[srcI++];
01240 }
01241 break;
01242 case OSG_FLOAT32_IMAGEDATA:
01243 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01244 {
01245 destDataF32[destI++] = sourceDataF32[srcI];
01246 destDataF32[destI++] = sourceDataF32[srcI];
01247 destDataF32[destI++] = sourceDataF32[srcI];
01248 destDataF32[destI++] = sourceDataF32[srcI++];
01249 }
01250 break;
01251 case OSG_FLOAT16_IMAGEDATA:
01252 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01253 {
01254 destDataH16[destI++] = sourceDataH16[srcI];
01255 destDataH16[destI++] = sourceDataH16[srcI];
01256 destDataH16[destI++] = sourceDataH16[srcI];
01257 destDataH16[destI++] = sourceDataH16[srcI++];
01258 }
01259 break;
01260 default:
01261 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01262 break;
01263 }
01264 break;
01265 default:
01266 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01267 break;
01268 }
01269 break;
01270
01271
01272 case OSG_LA_PF:
01273 switch (pixelFormat) {
01274 case OSG_A_PF:
01275 switch (getDataType())
01276 {
01277 case OSG_UINT8_IMAGEDATA:
01278 for (srcI = destI = 0; destI < destSize;)
01279 {
01280 srcI++;
01281 data[destI++] = sourceData[srcI++];
01282 }
01283 break;
01284 case OSG_UINT16_IMAGEDATA:
01285 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01286 {
01287 srcI++;
01288 destDataUC16[destI++] = sourceDataUC16[srcI++];
01289 }
01290 break;
01291 case OSG_UINT32_IMAGEDATA:
01292 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01293 {
01294 srcI++;
01295 destDataUC32[destI++] = sourceDataUC32[srcI++];
01296 }
01297 break;
01298 case OSG_FLOAT32_IMAGEDATA:
01299 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01300 {
01301 srcI++;
01302 destDataF32[destI++] = sourceDataF32[srcI++];
01303 }
01304 break;
01305 case OSG_FLOAT16_IMAGEDATA:
01306 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01307 {
01308 srcI++;
01309 destDataH16[destI++] = sourceDataH16[srcI++];
01310 }
01311 break;
01312 default:
01313 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01314 break;
01315 }
01316 break;
01317 case OSG_I_PF:
01318 case OSG_L_PF:
01319 switch (getDataType())
01320 {
01321 case OSG_UINT8_IMAGEDATA:
01322 for (srcI = destI = 0; destI < destSize;)
01323 {
01324 data[destI++] = sourceData[srcI++];
01325 srcI++;
01326 }
01327 break;
01328 case OSG_UINT16_IMAGEDATA:
01329 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01330 {
01331 destDataUC16[destI++] = sourceDataUC16[srcI++];
01332 srcI++;
01333 }
01334 break;
01335 case OSG_UINT32_IMAGEDATA:
01336 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01337 {
01338 destDataUC32[destI++] = sourceDataUC32[srcI++];
01339 srcI++;
01340 }
01341 break;
01342 case OSG_FLOAT32_IMAGEDATA:
01343 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01344 {
01345 destDataF32[destI++] = sourceDataF32[srcI++];
01346 srcI++;
01347 }
01348 break;
01349 case OSG_FLOAT16_IMAGEDATA:
01350 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01351 {
01352 destDataH16[destI++] = sourceDataH16[srcI++];
01353 srcI++;
01354 }
01355 break;
01356 default:
01357 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01358 break;
01359 }
01360 break;
01361 case OSG_LA_PF:
01362 switch (getDataType())
01363 {
01364 case OSG_UINT8_IMAGEDATA:
01365 memcpy (data, getData(), destSize);
01366 break;
01367 case OSG_UINT16_IMAGEDATA:
01368 memcpy (data, getData(), destSize);
01369 break;
01370 case OSG_UINT32_IMAGEDATA:
01371 memcpy (data, getData(), destSize);
01372 break;
01373 case OSG_FLOAT32_IMAGEDATA:
01374 memcpy (data, getData(), destSize);
01375 break;
01376 case OSG_FLOAT16_IMAGEDATA:
01377 memcpy (data, getData(), destSize);
01378 break;
01379 default:
01380 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01381 break;
01382 }
01383 break;
01384
01385 case OSG_RGB_PF:
01386 switch (getDataType())
01387 {
01388 case OSG_UINT8_IMAGEDATA:
01389 for (srcI = destI = 0; destI < destSize;)
01390 {
01391 data[destI++] = sourceData[srcI];
01392 data[destI++] = sourceData[srcI];
01393 data[destI++] = sourceData[srcI++];
01394 srcI++;
01395 }
01396 break;
01397 case OSG_UINT16_IMAGEDATA:
01398 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01399 {
01400 destDataUC16[destI++] = sourceDataUC16[srcI];
01401 destDataUC16[destI++] = sourceDataUC16[srcI];
01402 destDataUC16[destI++] = sourceDataUC16[srcI++];
01403 srcI++;
01404 }
01405 break;
01406 case OSG_UINT32_IMAGEDATA:
01407 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01408 {
01409 destDataUC32[destI++] = sourceDataUC32[srcI];
01410 destDataUC32[destI++] = sourceDataUC32[srcI];
01411 destDataUC32[destI++] = sourceDataUC32[srcI++];
01412 srcI++;
01413 }
01414 break;
01415 case OSG_FLOAT32_IMAGEDATA:
01416 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01417 {
01418 destDataF32[destI++] = sourceDataF32[srcI];
01419 destDataF32[destI++] = sourceDataF32[srcI];
01420 destDataF32[destI++] = sourceDataF32[srcI++];
01421 srcI++;
01422 }
01423 break;
01424 case OSG_FLOAT16_IMAGEDATA:
01425 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01426 {
01427 destDataH16[destI++] = sourceDataH16[srcI];
01428 destDataH16[destI++] = sourceDataH16[srcI];
01429 destDataH16[destI++] = sourceDataH16[srcI++];
01430 srcI++;
01431 }
01432 break;
01433 default:
01434 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01435 break;
01436 }
01437 break;
01438
01439 case OSG_RGBA_PF:
01440 switch (getDataType())
01441 {
01442 case OSG_UINT8_IMAGEDATA:
01443 for (srcI = destI = 0; destI < destSize;)
01444 {
01445 data[destI++] = sourceData[srcI];
01446 data[destI++] = sourceData[srcI];
01447 data[destI++] = sourceData[srcI++];
01448 data[destI++] = sourceData[srcI++];
01449 }
01450 break;
01451 case OSG_UINT16_IMAGEDATA:
01452 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01453 {
01454 destDataUC16[destI++] = sourceDataUC16[srcI];
01455 destDataUC16[destI++] = sourceDataUC16[srcI];
01456 destDataUC16[destI++] = sourceDataUC16[srcI++];
01457 destDataUC16[destI++] = sourceDataUC16[srcI++];
01458 }
01459 break;
01460 case OSG_UINT32_IMAGEDATA:
01461 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01462 {
01463 destDataUC32[destI++] = sourceDataUC32[srcI];
01464 destDataUC32[destI++] = sourceDataUC32[srcI];
01465 destDataUC32[destI++] = sourceDataUC32[srcI++];
01466 destDataUC32[destI++] = sourceDataUC32[srcI++];
01467 }
01468 break;
01469 case OSG_FLOAT32_IMAGEDATA:
01470 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01471 {
01472 destDataF32[destI++] = sourceDataF32[srcI];
01473 destDataF32[destI++] = sourceDataF32[srcI];
01474 destDataF32[destI++] = sourceDataF32[srcI++];
01475 destDataF32[destI++] = sourceDataF32[srcI++];
01476 }
01477 break;
01478 case OSG_FLOAT16_IMAGEDATA:
01479 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01480 {
01481 destDataH16[destI++] = sourceDataH16[srcI];
01482 destDataH16[destI++] = sourceDataH16[srcI];
01483 destDataH16[destI++] = sourceDataH16[srcI++];
01484 destDataH16[destI++] = sourceDataH16[srcI++];
01485 }
01486 break;
01487 default:
01488 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01489 break;
01490 }
01491 break;
01492 default:
01493 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01494 break;
01495 }
01496 break;
01497
01498
01499 case OSG_RGB_PF:
01500 switch (pixelFormat) {
01501 case OSG_A_PF:
01502 case OSG_I_PF:
01503 case OSG_L_PF:
01504 switch (getDataType())
01505 {
01506 case OSG_UINT8_IMAGEDATA:
01507 for (srcI = destI = 0; destI < destSize;)
01508 {
01509 sum = 0;
01510 sum += sourceData[srcI++];
01511 sum += sourceData[srcI++];
01512 sum += sourceData[srcI++];
01513 data[destI++] = sum / 3;
01514 }
01515 break;
01516 case OSG_UINT16_IMAGEDATA:
01517 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01518 {
01519 sum = 0;
01520 sum += sourceDataUC16[srcI++];
01521 sum += sourceDataUC16[srcI++];
01522 sum += sourceDataUC16[srcI++];
01523 destDataUC16[destI++] = sum / 3;
01524 }
01525 break;
01526 case OSG_UINT32_IMAGEDATA:
01527 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01528 {
01529 sum = 0;
01530 sum += sourceDataUC32[srcI++];
01531 sum += sourceDataUC32[srcI++];
01532 sum += sourceDataUC32[srcI++];
01533 destDataUC32[destI++] = sum / 3;
01534 }
01535 break;
01536 case OSG_FLOAT32_IMAGEDATA:
01537 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01538 {
01539 sumReal = 0;
01540 sumReal += sourceDataF32[srcI++];
01541 sumReal += sourceDataF32[srcI++];
01542 sumReal += sourceDataF32[srcI++];
01543 destDataF32[destI++] = sumReal / 3.0;
01544 }
01545 break;
01546 case OSG_FLOAT16_IMAGEDATA:
01547 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01548 {
01549 sumReal = 0;
01550 sumReal += sourceDataH16[srcI++];
01551 sumReal += sourceDataH16[srcI++];
01552 sumReal += sourceDataH16[srcI++];
01553 destDataH16[destI++] = sumReal / 3.0;
01554 }
01555 break;
01556 default:
01557 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01558 break;
01559 }
01560 break;
01561 case OSG_LA_PF:
01562 switch (getDataType())
01563 {
01564 case OSG_UINT8_IMAGEDATA:
01565 for (srcI = destI = 0; destI < destSize;)
01566 {
01567 sum = 0;
01568 sum += sourceData[srcI++];
01569 sum += sourceData[srcI++];
01570 sum += sourceData[srcI++];
01571 data[destI++] = sum / 3;
01572 data[destI++] = sum / 3;
01573 }
01574 break;
01575 case OSG_UINT16_IMAGEDATA:
01576 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01577 {
01578 sum = 0;
01579 sum += sourceDataUC16[srcI++];
01580 sum += sourceDataUC16[srcI++];
01581 sum += sourceDataUC16[srcI++];
01582 destDataUC16[destI++] = sum / 3;
01583 destDataUC16[destI++] = sum / 3;
01584 }
01585 break;
01586 case OSG_UINT32_IMAGEDATA:
01587 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01588 {
01589 sum = 0;
01590 sum += sourceDataUC32[srcI++];
01591 sum += sourceDataUC32[srcI++];
01592 sum += sourceDataUC32[srcI++];
01593 destDataUC32[destI++] = sum / 3;
01594 destDataUC32[destI++] = sum / 3;
01595 }
01596 break;
01597 case OSG_FLOAT32_IMAGEDATA:
01598 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01599 {
01600 sumReal = 0;
01601 sumReal += sourceDataF32[srcI++];
01602 sumReal += sourceDataF32[srcI++];
01603 sumReal += sourceDataF32[srcI++];
01604 destDataF32[destI++] = sumReal / 3.0;
01605 destDataF32[destI++] = sumReal / 3.0;
01606 }
01607 break;
01608 case OSG_FLOAT16_IMAGEDATA:
01609 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01610 {
01611 sumReal = 0;
01612 sumReal += sourceDataH16[srcI++];
01613 sumReal += sourceDataH16[srcI++];
01614 sumReal += sourceDataH16[srcI++];
01615 destDataH16[destI++] = sumReal / 3.0;
01616 destDataH16[destI++] = sumReal / 3.0;
01617 }
01618 break;
01619 default:
01620 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01621 break;
01622 }
01623 break;
01624 case OSG_RGB_PF:
01625 switch (getDataType())
01626 {
01627 case OSG_UINT8_IMAGEDATA:
01628 memcpy (data, getData(), destSize);
01629 break;
01630 case OSG_UINT16_IMAGEDATA:
01631 memcpy (data, getData(), destSize);
01632 break;
01633 case OSG_UINT32_IMAGEDATA:
01634 memcpy (data, getData(), destSize);
01635 break;
01636 case OSG_FLOAT32_IMAGEDATA:
01637 memcpy (data, getData(), destSize);
01638 break;
01639 case OSG_FLOAT16_IMAGEDATA:
01640 memcpy (data, getData(), destSize);
01641 break;
01642 default:
01643 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01644 break;
01645 }
01646 break;
01647
01648 case OSG_RGBA_PF:
01649 switch (getDataType())
01650 {
01651 case OSG_UINT8_IMAGEDATA:
01652 for (srcI = destI = 0; destI < destSize;)
01653 {
01654 sum = 0;
01655 sum += data[destI++] = sourceData[srcI++];
01656 sum += data[destI++] = sourceData[srcI++];
01657 sum += data[destI++] = sourceData[srcI++];
01658 data[destI++] = sum / 3;
01659 }
01660 break;
01661 case OSG_UINT16_IMAGEDATA:
01662 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01663 {
01664 sum = 0;
01665 sum += destDataUC16[destI++] = sourceDataUC16[srcI++];
01666 sum += destDataUC16[destI++] = sourceDataUC16[srcI++];
01667 sum += destDataUC16[destI++] = sourceDataUC16[srcI++];
01668 destDataUC16[destI++] = sum / 3;
01669 }
01670 break;
01671 case OSG_UINT32_IMAGEDATA:
01672 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01673 {
01674 sum = 0;
01675 sum += destDataUC32[destI++] = sourceDataUC32[srcI++];
01676 sum += destDataUC32[destI++] = sourceDataUC32[srcI++];
01677 sum += destDataUC32[destI++] = sourceDataUC32[srcI++];
01678 destDataUC32[destI++] = sum / 3;
01679 }
01680 break;
01681 case OSG_FLOAT32_IMAGEDATA:
01682 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01683 {
01684 sumReal = 0;
01685 sumReal += destDataF32[destI++] = sourceDataF32[srcI++];
01686 sumReal += destDataF32[destI++] = sourceDataF32[srcI++];
01687 sumReal += destDataF32[destI++] = sourceDataF32[srcI++];
01688 destDataF32[destI++] = sumReal / 3.0;
01689 }
01690 break;
01691 case OSG_FLOAT16_IMAGEDATA:
01692 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01693 {
01694 sumReal = 0;
01695 sumReal += destDataH16[destI++] = sourceDataH16[srcI++];
01696 sumReal += destDataH16[destI++] = sourceDataH16[srcI++];
01697 sumReal += destDataH16[destI++] = sourceDataH16[srcI++];
01698 destDataH16[destI++] = sumReal / 3.0;
01699 }
01700 break;
01701 default:
01702 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01703 break;
01704 }
01705 break;
01706 default:
01707 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01708 break;
01709 }
01710 break;
01711
01712 case OSG_RGBA_PF:
01713 switch (pixelFormat) {
01714 case OSG_A_PF:
01715 switch (getDataType())
01716 {
01717 case OSG_UINT8_IMAGEDATA:
01718 for (srcI = destI = 0; destI < destSize;)
01719 {
01720 srcI += 3;
01721 data[destI++] = sourceData[srcI++];;
01722 }
01723 break;
01724 case OSG_UINT16_IMAGEDATA:
01725 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01726 {
01727 srcI += 3;
01728 destDataUC16[destI++] = sourceDataUC16[srcI++];;
01729 }
01730 break;
01731 case OSG_UINT32_IMAGEDATA:
01732 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01733 {
01734 srcI += 3;
01735 destDataUC32[destI++] = sourceDataUC32[srcI++];;
01736 }
01737 break;
01738 case OSG_FLOAT32_IMAGEDATA:
01739 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01740 {
01741 srcI += 3;
01742 destDataF32[destI++] = sourceDataF32[srcI++];
01743 }
01744 break;
01745 case OSG_FLOAT16_IMAGEDATA:
01746 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01747 {
01748 srcI += 3;
01749 destDataH16[destI++] = sourceDataH16[srcI++];
01750 }
01751 break;
01752 default:
01753 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01754 break;
01755 }
01756 break;
01757 case OSG_I_PF:
01758 case OSG_L_PF:
01759 switch (getDataType())
01760 {
01761 case OSG_UINT8_IMAGEDATA:
01762 for (srcI = destI = 0; destI < destSize;)
01763 {
01764 sum = 0;
01765 sum += sourceData[srcI++];
01766 sum += sourceData[srcI++];
01767 sum += sourceData[srcI++];
01768 data[destI++] = sum / 3;
01769 srcI++;
01770 }
01771 break;
01772 case OSG_UINT16_IMAGEDATA:
01773 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01774 {
01775 sum = 0;
01776 sum += sourceDataUC16[srcI++];
01777 sum += sourceDataUC16[srcI++];
01778 sum += sourceDataUC16[srcI++];
01779 destDataUC16[destI++] = sum / 3;
01780 srcI++;
01781 }
01782 break;
01783 case OSG_UINT32_IMAGEDATA:
01784 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01785 {
01786 sum = 0;
01787 sum += sourceDataUC32[srcI++];
01788 sum += sourceDataUC32[srcI++];
01789 sum += sourceDataUC32[srcI++];
01790 destDataUC32[destI++] = sum / 3;
01791 srcI++;
01792 }
01793 break;
01794 case OSG_FLOAT32_IMAGEDATA:
01795 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01796 {
01797 sumReal = 0;
01798 sumReal += sourceDataF32[srcI++];
01799 sumReal += sourceDataF32[srcI++];
01800 sumReal += sourceDataF32[srcI++];
01801 destDataF32[destI++] = sumReal / 3.0;
01802 srcI++;
01803 }
01804 break;
01805 case OSG_FLOAT16_IMAGEDATA:
01806 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01807 {
01808 sumReal = 0;
01809 sumReal += sourceDataH16[srcI++];
01810 sumReal += sourceDataH16[srcI++];
01811 sumReal += sourceDataH16[srcI++];
01812 destDataH16[destI++] = sumReal / 3.0;
01813 srcI++;
01814 }
01815 break;
01816 default:
01817 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01818 break;
01819 }
01820 break;
01821 case OSG_LA_PF:
01822 switch (getDataType())
01823 {
01824 case OSG_UINT8_IMAGEDATA:
01825 for (srcI = destI = 0; destI < destSize;)
01826 {
01827 sum = 0;
01828 sum += sourceData[srcI++];
01829 sum += sourceData[srcI++];
01830 sum += sourceData[srcI++];
01831 data[destI++] = sum / 3;
01832 data[destI++] = sourceData[srcI++];;
01833 }
01834 break;
01835 case OSG_UINT16_IMAGEDATA:
01836 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01837 {
01838 sum = 0;
01839 sum += sourceDataUC16[srcI++];
01840 sum += sourceDataUC16[srcI++];
01841 sum += sourceDataUC16[srcI++];
01842 destDataUC16[destI++] = sum / 3;
01843 destDataUC16[destI++] = sourceDataUC16[srcI++];;
01844 }
01845 break;
01846 case OSG_UINT32_IMAGEDATA:
01847 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01848 {
01849 sum = 0;
01850 sum += sourceDataUC32[srcI++];
01851 sum += sourceDataUC32[srcI++];
01852 sum += sourceDataUC32[srcI++];
01853 destDataUC32[destI++] = sum / 3;
01854 destDataUC32[destI++] = sourceDataUC32[srcI++];;
01855 }
01856 break;
01857 case OSG_FLOAT32_IMAGEDATA:
01858 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01859 {
01860 sumReal = 0;
01861 sumReal += sourceDataF32[srcI++];
01862 sumReal += sourceDataF32[srcI++];
01863 sumReal += sourceDataF32[srcI++];
01864 destDataF32[destI++] = sumReal / 3.0;
01865 destDataF32[destI++] = sourceDataF32[srcI++];
01866 }
01867 break;
01868 case OSG_FLOAT16_IMAGEDATA:
01869 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01870 {
01871 sumReal = 0;
01872 sumReal += sourceDataH16[srcI++];
01873 sumReal += sourceDataH16[srcI++];
01874 sumReal += sourceDataH16[srcI++];
01875 destDataH16[destI++] = sumReal / 3.0;
01876 destDataH16[destI++] = sourceDataH16[srcI++];
01877 }
01878 break;
01879 default:
01880 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01881 break;
01882 }
01883 break;
01884 case OSG_RGB_PF:
01885 switch (getDataType())
01886 {
01887 case OSG_UINT8_IMAGEDATA:
01888 for (srcI = destI = 0; destI < destSize;)
01889 {
01890 data[destI++] = sourceData[srcI++];
01891 data[destI++] = sourceData[srcI++];
01892 data[destI++] = sourceData[srcI++];
01893 srcI++;
01894 }
01895 break;
01896 case OSG_UINT16_IMAGEDATA:
01897 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01898 {
01899 destDataUC16[destI++] = sourceDataUC16[srcI++];
01900 destDataUC16[destI++] = sourceDataUC16[srcI++];
01901 destDataUC16[destI++] = sourceDataUC16[srcI++];
01902 srcI++;
01903 }
01904 break;
01905 case OSG_UINT32_IMAGEDATA:
01906 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01907 {
01908 destDataUC32[destI++] = sourceDataUC32[srcI++];
01909 destDataUC32[destI++] = sourceDataUC32[srcI++];
01910 destDataUC32[destI++] = sourceDataUC32[srcI++];
01911 srcI++;
01912 }
01913 break;
01914 case OSG_FLOAT32_IMAGEDATA:
01915 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01916 {
01917 destDataF32[destI++] = sourceDataF32[srcI++];
01918 destDataF32[destI++] = sourceDataF32[srcI++];
01919 destDataF32[destI++] = sourceDataF32[srcI++];
01920 srcI++;
01921 }
01922 break;
01923 case OSG_FLOAT16_IMAGEDATA:
01924 for (srcI = destI = 0; destI < destSize/getComponentSize();)
01925 {
01926 destDataH16[destI++] = sourceDataH16[srcI++];
01927 destDataH16[destI++] = sourceDataH16[srcI++];
01928 destDataH16[destI++] = sourceDataH16[srcI++];
01929 srcI++;
01930 }
01931 break;
01932 default:
01933 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01934 break;
01935 }
01936 break;
01937 case OSG_RGBA_PF:
01938 switch (getDataType())
01939 {
01940 case OSG_UINT8_IMAGEDATA:
01941 memcpy (data, getData(), destSize);
01942 break;
01943 case OSG_UINT16_IMAGEDATA:
01944 memcpy (data, getData(), destSize);
01945 break;
01946 case OSG_UINT32_IMAGEDATA:
01947 memcpy (data, getData(), destSize);
01948 break;
01949 case OSG_FLOAT32_IMAGEDATA:
01950 memcpy (data, getData(), destSize);
01951 break;
01952 case OSG_FLOAT16_IMAGEDATA:
01953 memcpy (data, getData(), destSize);
01954 break;
01955 default:
01956 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
01957 break;
01958 }
01959 break;
01960
01961 default:
01962 break;
01963 }
01964 break;
01965 case OSG_ALPHA_INTEGER_PF:
01966 case OSG_RGB_INTEGER_PF:
01967 case OSG_RGBA_INTEGER_PF:
01968 case OSG_BGR_INTEGER_PF:
01969 case OSG_BGRA_INTEGER_PF:
01970 case OSG_LUMINANCE_INTEGER_PF:
01971 case OSG_LUMINANCE_ALPHA_INTEGER_PF:
01972 {
01973 FFATAL((" 'reformat' NYI\n "));
01974 }
01975 break;
01976 default:
01977 FWARNING (( "Unvalid pixeldepth (%d) in reformat() !\n",
01978 pixelFormat ));
01979 }
01980 }
01981 if (data)
01982 {
01983
01984 if(destination == NullFC)
01985 {
01986 this->set(dest);
01987 subRefCP(dest);
01988 }
01989 }
01990 }
01991
01992 return (data ? true : false);
01993 }
01994
01995 void Image::swapDataEndian(void)
01996 {
01997 UChar8 *data = getData();
01998
01999 Int32 size = getSize() / getComponentSize();
02000 UInt16 *dataUC16 = (UInt16*) data;
02001 UInt32 *dataUC32 = (UInt32*) data;
02002 Real32 *dataF32 = (Real32*) data;
02003
02004
02005 ImagePtr iPtr(this);
02006 beginEditCP(iPtr, PixelFieldMask);
02007
02008 switch (getDataType())
02009 {
02010 case OSG_UINT8_IMAGEDATA:
02011
02012 break;
02013
02014 case OSG_UINT16_IMAGEDATA:
02015 for(UInt32 i=0;i<size;++i)
02016 {
02017 UInt16 p = dataUC16[i];
02018 dataUC16[i] = (((p >> 8)) | (p << 8));
02019 }
02020 break;
02021
02022 case OSG_UINT32_IMAGEDATA:
02023 for(UInt32 i=0;i<size;++i)
02024 {
02025 UInt32 p = dataUC32[i];
02026 dataUC32[i] = (((p&0x000000FF)<<24) | ((p&0x0000FF00)<<8) |
02027 ((p&0x00FF0000)>>8) | ((p&0xFF000000)>>24));
02028 }
02029 break;
02030
02031 case OSG_FLOAT32_IMAGEDATA:
02032 for(UInt32 i=0;i<size;++i)
02033 {
02034 Real32 p = dataF32[i];
02035 UInt8 *b = (UInt8 *) &p;
02036 std::swap(b[0], b[3]);
02037 std::swap(b[1], b[2]);
02038 dataF32[i] = p;
02039 }
02040 break;
02041
02042 case OSG_INT16_IMAGEDATA:
02043 case OSG_INT32_IMAGEDATA:
02044 {
02045 FFATAL((" 'swapDataEndian' NYI\n "));
02046 }
02047 break;
02048
02049 default:
02050 FWARNING (( "invalid source data type \n"));
02051 break;
02052 }
02053
02054 endEditCP(iPtr, PixelFieldMask);
02055 }
02056
02060 bool Image::convertDataTypeTo (Int32 destDataType)
02061 {
02062 if (hasCompressedData())
02063 {
02064 FFATAL (("Invalid Image::convertDataTypeTo for compressed image\n"));
02065 return false;
02066 }
02067
02068 if (destDataType == getDataType())
02069 {
02070 FWARNING (( "source image and destination image have same data types: no conversion possible"));
02071 return true;
02072 }
02073
02074 FINFO (( "Try to convert image from dataType %d to %d\n",
02075 getDataType(), destDataType ));
02076
02077 ImagePtr dest;
02078 dest = Image::create();
02079 addRefCP(dest);
02080
02081 dest->set ( getPixelFormat(),
02082 getWidth(), getHeight(), getDepth(),
02083 getMipMapCount(),
02084 getFrameCount(), 0.0,
02085 0, destDataType,
02086 true,
02087 getSideCount());
02088
02089 UChar8 *sourceData = getData();
02090 UChar8 *destData = dest->getData();
02091
02092 Int32 sourceSize = getSize()/getComponentSize();
02093 Int32 destSize = dest->getSize()/dest->getComponentSize();
02094
02095 UInt16 *sourceDataUC16 = (UInt16*) sourceData;
02096 UInt16 *destDataUC16 = (UInt16*) destData;
02097 UInt32 *sourceDataUC32 = (UInt32*) sourceData;
02098 UInt32 *destDataUC32 = (UInt32*) destData;
02099 Real32 *sourceDataF32 = (Real32*) sourceData;
02100 Real32 *destDataF32 = (Real32*) destData;
02101 Real16 *sourceDataH16 = (Real16*) sourceData;
02102 Real16 *destDataH16 = (Real16*) destData;
02103
02104 switch (getDataType())
02105 {
02106 case OSG_UINT8_IMAGEDATA:
02107 switch (destDataType)
02108 {
02109 case OSG_UINT16_IMAGEDATA:
02110 for (int i = 0; i < sourceSize; i++)
02111 {
02112 destDataUC16[i] = (UInt16) (sourceData[i]<<8);
02113 }
02114 break;
02115 case OSG_UINT32_IMAGEDATA:
02116 for (int i = 0; i < sourceSize; i++)
02117 {
02118 destDataUC32[i] = (UInt32) (sourceData[i]<<24);
02119 }
02120 break;
02121 case OSG_FLOAT32_IMAGEDATA:
02122 for (int i = 0; i < sourceSize; i++)
02123 {
02124 destDataF32[i] = (Real32) (sourceData[i]/255.0);
02125 }
02126 break;
02127 case OSG_FLOAT16_IMAGEDATA:
02128 for (int i = 0; i < sourceSize; i++)
02129 {
02130 destDataH16[i] = (Real16) (sourceData[i]/255.0);
02131 }
02132 break;
02133 default:
02134 FWARNING (( "invalid destination data type \n" ));
02135 break;
02136 }
02137
02138 break;
02139
02140 case OSG_UINT16_IMAGEDATA:
02141 switch (destDataType)
02142 {
02143 case OSG_UINT8_IMAGEDATA:
02144 {
02145 UInt16 nMin = (UInt16) 65535;
02146 UInt16 nMax = (UInt16) 0;
02147 for (UInt32 i = 0; i < sourceSize; ++i)
02148 {
02149 if (sourceDataUC16[i] > nMax)
02150 nMax = sourceDataUC16[i];
02151 if (sourceDataUC16[i] < nMin)
02152 nMin = sourceDataUC16[i];
02153 }
02154
02155 Real32 fRange = (Real32) nMax - nMin;
02156 if (fRange <= 0.0)
02157 {
02158 for (UInt32 i = 0; i < sourceSize; ++i)
02159 destData[i] = 0;
02160 }
02161 else
02162 {
02163 for (UInt32 i = 0; i < sourceSize; ++i)
02164 destData[i] = (UInt8) (255.0 * ((Real32) (sourceDataUC16[i] - nMin)) / fRange);
02165 }
02166 }
02167 break;
02168 case OSG_UINT32_IMAGEDATA:
02169 for (int i = 0; i < sourceSize; i++)
02170 {
02171 destDataUC32[i] = (UInt32) (sourceDataUC16[i]<<16);
02172 }
02173 break;
02174 case OSG_FLOAT32_IMAGEDATA:
02175 for (int i = 0; i < sourceSize; i++)
02176 {
02177 destDataF32[i] = (Real32) (sourceDataUC16[i]/65535.0);
02178 }
02179 break;
02180 case OSG_FLOAT16_IMAGEDATA:
02181 for (int i = 0; i < sourceSize; i++)
02182 {
02183 destDataH16[i] = (Real16) (sourceDataUC16[i]/255.0);
02184 }
02185 break;
02186 default:
02187 FWARNING (( "invalid destination data type \n" ));
02188 break;
02189 }
02190 break;
02191
02192 case OSG_UINT32_IMAGEDATA:
02193 switch (destDataType)
02194 {
02195 case OSG_UINT8_IMAGEDATA:
02196 {
02197 UInt32 nMin = (UInt32) 4294967295ul;
02198 UInt32 nMax = (UInt32) 0;
02199 for (UInt32 i = 0; i < sourceSize; ++i)
02200 {
02201 if (sourceDataUC32[i] > nMax)
02202 nMax = sourceDataUC32[i];
02203 if (sourceDataUC32[i] < nMin)
02204 nMin = sourceDataUC32[i];
02205 }
02206
02207 Real32 fRange = (Real32) nMax - nMin;
02208 if (fRange <= 0.0)
02209 {
02210 for (UInt32 i = 0; i < sourceSize; ++i)
02211 destData[i] = 0;
02212 }
02213 else
02214 {
02215 for (UInt32 i = 0; i < sourceSize; ++i)
02216 destData[i] = (UInt8) (255.0 * ((Real32) (sourceDataUC32[i] - nMin)) / fRange);
02217 }
02218 }
02219 break;
02220 case OSG_UINT16_IMAGEDATA:
02221 {
02222 UInt32 nMin = (UInt32) 4294967295ul;
02223 UInt32 nMax = (UInt32) 0;
02224 for (UInt32 i = 0; i < sourceSize; ++i)
02225 {
02226 if (sourceDataUC32[i] > nMax)
02227 nMax = sourceDataUC32[i];
02228 if (sourceDataUC32[i] < nMin)
02229 nMin = sourceDataUC32[i];
02230 }
02231
02232 Real32 fRange = (Real32) nMax - nMin;
02233 if (fRange <= 0.0)
02234 {
02235 for (UInt32 i = 0; i < sourceSize; ++i)
02236 destDataUC16[i] = 0;
02237 }
02238 else
02239 {
02240 for (UInt32 i = 0; i < sourceSize; ++i)
02241 destDataUC16[i] = (UInt16) (65535.0 * ((Real32) (sourceDataUC32[i] - nMin)) / fRange);
02242 }
02243 }
02244 break;
02245 case OSG_FLOAT32_IMAGEDATA:
02246 for (int i = 0; i < sourceSize; i++)
02247 {
02248 destDataF32[i] = ((Real32) sourceDataUC32[i]) / 4294967295.0;
02249 }
02250 break;
02251 case OSG_FLOAT16_IMAGEDATA:
02252 for (int i = 0; i < sourceSize; i++)
02253 {
02254 destDataH16[i] = ((Real16) sourceDataUC32[i]) / REAL16_MAX;
02255 }
02256 break;
02257 default:
02258 FWARNING (( "invalid destination data type \n" ));
02259 break;
02260 }
02261 break;
02262
02263 case OSG_FLOAT32_IMAGEDATA:
02264 switch (destDataType)
02265 {
02266 case OSG_UINT8_IMAGEDATA:
02267 for (int i = 0; i < sourceSize; i++)
02268 {
02269 destData[i] = (UInt8) (sourceDataF32[i]*255.0);
02270 }
02271 break;
02272 case OSG_UINT16_IMAGEDATA:
02273 for (int i = 0; i < sourceSize; i++)
02274 {
02275 destDataUC16[i] = (UInt16) (sourceDataF32[i]*65535.0);
02276 }
02277 break;
02278 case OSG_UINT32_IMAGEDATA:
02279 for (int i = 0; i < sourceSize; i++)
02280 {
02281 destDataUC32[i] = (UInt32) (sourceDataF32[i]*4294967295.0);
02282 }
02283 break;
02284 case OSG_FLOAT16_IMAGEDATA:
02285 for (int i = 0; i < sourceSize; i++)
02286 {
02287 destDataH16[i] = Real16 (sourceDataF32[i]);
02288 }
02289 break;
02290 default:
02291 FWARNING (( "invalid destination data type \n" ));
02292 break;
02293 }
02294 break;
02295
02296 case OSG_INT16_IMAGEDATA:
02297 case OSG_INT32_IMAGEDATA:
02298 {
02299 FFATAL((" 'convertDataTypeTo' NYI\n "));
02300 }
02301 break;
02302
02303 default:
02304 FWARNING (( "invalid source data type \n"));
02305 break;
02306 }
02307
02308 if (dest->getData()!= NULL)
02309 {
02310 this->set(dest);
02311 subRefCP(dest);
02312 }
02313
02314 return (getData() ? true : false);
02315 }
02316
02320 void Image::clear(UChar8 pixelValue)
02321 {
02322 memset(getData(),pixelValue,getSize());
02323 }
02324
02325 void Image::clearFloat(Real32 pixelValue)
02326 {
02327 unsigned long n = getSize()/getComponentSize();
02328 Real32 *d = (Real32*) getData();
02329
02330 if(n && d)
02331 while(n--)
02332 *d++ = pixelValue;
02333 }
02334
02335 void Image::clearHalf(Real16 pixelValue)
02336 {
02337 unsigned long n = getSize()/getComponentSize();
02338 Real16 *d = (Real16*) getData();
02339
02340 if(n && d)
02341 while(n--)
02342 *d++ = pixelValue;
02343 }
02344
02345
02346
02347
02350 bool Image::hasAttachment (void) const
02351 {
02352 Image *img=const_cast<Image*>(this);
02353 ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
02354 img->Inherited::findAttachment(
02355 ImageGenericAtt::getClassType().getGroupId()));
02356 if(att != NullFC && att->getType().getNumFieldDescs() > 1)
02357 return true;
02358 else
02359 return false;
02360 }
02361
02364 UInt32 Image::attachmentCount (void) const
02365 {
02366 Image *img=const_cast<Image*>(this);
02367 ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
02368 img->Inherited::findAttachment(
02369 ImageGenericAtt::getClassType().getGroupId()));
02370 if(att != NullFC)
02371 return att->getType().getNumFieldDescs() -1;
02372 else
02373 return 0;
02374 }
02375
02378 void Image::setAttachmentField ( const std::string &key,
02379 const std::string &data)
02380 {
02381 ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
02382 findAttachment(
02383 ImageGenericAtt::getClassType().getGroupId()));
02384 if(att==NullFC)
02385 {
02386 att=ImageGenericAtt::create();
02387 addAttachment(att);
02388 }
02389 Field *field=att->getField(key.c_str());
02390 if(field == NULL)
02391 {
02392 FieldDescription desc(
02393 SFString::getClassType(),
02394 key.c_str(),
02395 0, 0,
02396 true,
02397 (FieldIndexAccessMethod) &ImageGenericAtt::getDynamicField);
02398
02399 UInt32 fieldId = att->addField(desc);
02400 field=att->getField(fieldId);
02401 }
02402 SFString *strField=dynamic_cast<SFString*>(field);
02403 if(strField)
02404 strField->setValue(data);
02405 }
02406
02409 const std::string * Image::findAttachmentField( const std::string &key) const
02410 {
02411 Image *img=const_cast<Image*>(this);
02412 ImageGenericAttPtr att=ImageGenericAttPtr::dcast(
02413 img->findAttachment(
02414 ImageGenericAtt::getClassType().getGroupId()));
02415 if(att!=NullFC)
02416 {
02417 Field *field=att->getField(key.c_str());
02418 if(field != NULL)
02419 {
02420 SFString *strField=dynamic_cast<SFString*>(field);
02421 if(strField != NULL)
02422 return &strField->getValue();
02423 }
02424 }
02425 return NULL;
02426 }
02427
02433 bool Image::scale(Int32 width, Int32 height, Int32 depth,
02434 ImagePtr destination)
02435 {
02436 ImagePtr destImage;
02437 UInt32 sw, sh, sd, dw, dh, dd;
02438 Int32 frame, side, mipmap;
02439 UChar8 *src, *dest;
02440 Int32 oldWidth =getWidth();
02441 Int32 oldHeight=getHeight();
02442 Int32 oldDepth =getDepth();
02443 MFUInt8 srcPixel;
02444
02445 if ( (oldWidth == width) &&
02446 (oldHeight == height) &&
02447 (oldDepth == depth) )
02448 {
02449 if (destination != osg::NullFC)
02450 *destination = *this;
02451
02452 return true;
02453 }
02454
02455 if (hasCompressedData())
02456 {
02457 FFATAL (("Invalid Image::scale for compressed image\n"));
02458 return false;
02459 }
02460
02461 if(destination != NullFC)
02462 destImage=destination;
02463 else
02464 destImage=ImagePtr(this);
02465
02466
02467 srcPixel=getPixel();
02468
02469 destImage->set((PixelFormat)getPixelFormat(),
02470 width, height, depth, getMipMapCount(),
02471 getFrameCount(), getFrameDelay(), 0, getDataType(),
02472 true,
02473 getSideCount());
02474
02475 beginEditCP(destImage,PixelFieldMask);
02476
02477
02478 for(frame = 0; frame < getFrameCount(); frame++)
02479 {
02480 for (side = 0; side < getSideCount(); side++)
02481 {
02482 for(mipmap = 0; mipmap < getMipMapCount(); mipmap++)
02483 {
02484
02485 src = (&srcPixel[0]) +
02486 (side * getSideSize()) +
02487 (frame * getFrameSize()) ;
02488 if(mipmap)
02489 src+=calcMipmapSumSize ( mipmap,
02490 oldWidth, oldHeight, oldDepth);
02491 dest=destImage->getData(mipmap,frame,side);
02492
02493
02494 sw = oldWidth >> mipmap;
02495 sh = oldHeight >> mipmap;
02496 sd = oldDepth >> mipmap;
02497 destImage->calcMipmapGeometry(mipmap, dw, dh, dd);
02498
02499
02500 scaleData(src, sw, sh, sd, dest, dw, dh, dd);
02501 }
02502 }
02503 }
02504
02505 endEditCP(destImage,PixelFieldMask);
02506
02507 return true;
02508 }
02509
02514 bool Image::scaleNextPower2(ImagePtr destination)
02515 {
02516 return scale ( osgnextpower2(getWidth()),
02517 osgnextpower2(getHeight()),
02518 osgnextpower2(getDepth()),
02519 destination );
02520 }
02521
02526 bool Image::subImage ( Int32 offX, Int32 offY, Int32 offZ,
02527 Int32 destW, Int32 destH, Int32 destD,
02528 ImagePtr destination)
02529 {
02530 ImagePtr destImage = destination;
02531 bool retCode = true;
02532
02533 if (hasCompressedData())
02534 {
02535 FFATAL (("Invalid Image::subImage for compressed image\n"));
02536 return false;
02537 }
02538
02539 if(destination == NullFC)
02540 {
02541 destImage = Image::create();
02542 addRefCP(destImage);
02543 }
02544
02545 destImage->set((PixelFormat)getPixelFormat(),
02546 destW, destH, destD,1,1,0.0,0,getDataType());
02547
02548 UChar8 *src = getData();
02549 UChar8 *dest = destImage->getData();
02550
02551 FDEBUG(("Image::subImage (%d %d %d) - (%d %d %d) - destPtr %p\n",
02552 offX, offY, offZ, destW, destH, destD, dest));
02553
02554
02555 memset(dest, 0, destImage->getSize());
02556
02557
02558 UInt32 xMin = offX;
02559 UInt32 yMin = offY;
02560 UInt32 zMin = offZ;
02561
02562 UInt32 xMax = osgMin(getWidth(), offX + destW);
02563 UInt32 yMax = osgMin(getHeight(), offY + destH);
02564 UInt32 zMax = osgMin(getDepth(), offZ + destD);
02565
02566
02567 UInt32 destIdx = 0;
02568
02569 for(UInt32 z = zMin; z < zMax; z++)
02570 {
02571 for(UInt32 y = yMin; y < yMax; y++)
02572 {
02573 for(UInt32 x = xMin; x < xMax; x++)
02574 {
02575 for(UInt32 i = 0; i < getBpp(); i++)
02576 {
02577 dest[destIdx] = src[((z * getHeight() + y) *
02578 getWidth() + x) * getBpp() + i];
02579 destIdx++;
02580 }
02581 }
02582 destIdx += (destW - (xMax - xMin)) * getBpp();
02583 }
02584 destIdx += (destH - (yMax - yMin)) * destW * getBpp();
02585 }
02586
02587
02588 if(destination == NullFC)
02589 {
02590 this->set(destImage);
02591 subRefCP(destImage);
02592 }
02593
02594 return retCode;
02595 }
02596
02601 bool Image::slice ( Int32 offX, Int32 offY, Int32 offZ,
02602 ImagePtr destination)
02603 {
02604 ImagePtr destImage = destination;
02605 bool retCode = true;
02606 UInt32 counter = 0;
02607
02608 if (hasCompressedData())
02609 {
02610 FFATAL (("Invalid Image::slice for compressed image\n"));
02611 return false;
02612 }
02613
02614 if(destination == NullFC)
02615 {
02616 destImage = Image::create();
02617 addRefCP(destImage);
02618 }
02619
02620 FDEBUG(("Image::slice (%d %d %d)\n",
02621 offX, offY, offZ));
02622
02623 if (offX >= 0) counter++;
02624 if (offY >= 0) counter++;
02625 if (offZ >= 0) counter++;
02626
02627 if (counter != 1) {
02628 FWARNING(("Image::slice - more/less than one non negative value\n"));
02629 return false;
02630 }
02631
02632 if (offZ >= 0) {
02633
02634 retCode = subImage( 0, 0, offZ, getWidth(), getHeight(), 1,
02635 destImage );
02636 }
02637
02638 if (offY >= 0) {
02639
02640 destImage->set((PixelFormat)getPixelFormat(),
02641 getWidth(), getDepth(), 1,1,1,0.0,0,getDataType());
02642
02643 UChar8 *src = getData();
02644 UChar8 *dest = destImage->getData();
02645
02646
02647 memset(dest, 0, destImage->getSize());
02648
02649 for(UInt32 z = 0; z < getDepth(); z++)
02650 {
02651 for(UInt32 x = 0; x < getWidth(); x++)
02652 {
02653 for(UInt32 i = 0; i < getBpp(); i++)
02654 {
02655 dest[(z * getWidth() + x) * getBpp() + i] = src[((z * getHeight() + offY) *
02656 getWidth() + x) *
02657 getBpp() + i];
02658 }
02659 }
02660 }
02661 }
02662
02663 if (offX >= 0) {
02664
02665 destImage->set((PixelFormat)getPixelFormat(),
02666 getWidth(), getDepth(), 1,1,1,0.0,0,getDataType());
02667
02668 UChar8 *src = getData();
02669 UChar8 *dest = destImage->getData();
02670
02671
02672 memset(dest, 0, destImage->getSize());
02673
02674 for(UInt32 z = 0; z < getDepth(); z++)
02675 {
02676 for(UInt32 y = 0; y < getHeight(); y++)
02677 {
02678 for(UInt32 i = 0; i < getBpp(); i++)
02679 {
02680 dest[(z * getHeight() + y) * getBpp() + i] = src[((z * getHeight() + y) *
02681 getWidth() + offX) *
02682 getBpp() + i];
02683 }
02684 }
02685 }
02686 }
02687
02688
02689 if(destination == NullFC)
02690 {
02691 this->set(destImage);
02692 subRefCP(destImage);
02693 }
02694
02695 return retCode;
02696 }
02697
02702 bool Image::createMipmap(Int32 level, ImagePtr destination)
02703 {
02704 struct Offset
02705 {
02706 Int32 d;
02707 Int32 h;
02708 Int32 w;
02709 };
02710
02711 Offset offset[][8] =
02712 {
02713 {
02714 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
02715 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02716 {
02717 { 0, 0, 0 }, { 1, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
02718 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02719 {
02720 { 0, 0, 0 }, { 0, 1, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
02721 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02722 {
02723 { 0, 0, 0 }, { 0, 1, 0 }, { 1, 0, 0 }, { 1, 1, 0 },
02724 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02725 {
02726 { 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 0 },
02727 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02728 {
02729 { 0, 0, 0 }, { 1, 0, 0 }, { 0, 0, 1 }, { 1, 0, 1 },
02730 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02731 {
02732 { 0, 0, 0 }, { 0, 0, 1 }, { 0, 1, 0 }, { 0, 1, 1 },
02733 { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
02734 {
02735 { 0, 0, 0 }, { 1, 0, 0 }, { 0, 1, 0 }, { 1, 1, 0 },
02736 { 0, 0, 1 }, { 1, 0, 1 }, { 0, 1, 1 }, { 1, 1, 1 } }
02737 };
02738 Int32 offsetSize[] = { 0, 2, 2, 4, 2, 4, 4, 8 };
02739 ImagePtr destImage = destination;
02740 Int32 w = getWidth(), h = getHeight(), d = getDepth();
02741 Int32 wm, hm, dm, wi, hi, di;
02742 UChar8 *src, *dest;
02743 UInt16 *sourceDataUC16, *destDataUC16;
02744 UInt32 *sourceDataUC32, *destDataUC32;
02745 Real32 *sourceDataF32, *destDataF32;
02746 Real16 *sourceDataH16, *destDataH16;
02747
02748 if (hasCompressedData())
02749 {
02750 FFATAL (("Invalid Image::createMipmap for compressed image\n"));
02751 return false;
02752 }
02753
02754 if(destImage == NullFC)
02755 {
02756 destImage = Image::create();
02757 addRefCP(destImage);
02758 }
02759
02760 Real32 valueFloat;
02761 Int32 value, i, elem, dim, side, frame, size, mipmap;
02762 Int32 channel, lineSize, sliceSize;
02763
02764
02765 if(level < 0)
02766 {
02767 level = calcMipmapLevelCount() - 1;
02768 }
02769
02770
02771 destImage->set(getPixelFormat(),
02772 getWidth(), getHeight(), getDepth(),
02773 level, getFrameCount(),
02774 getFrameDelay(), 0, getDataType(),
02775 true,
02776 getSideCount() );
02777
02778
02779 switch (getDataType())
02780 {
02781 case OSG_UINT8_IMAGEDATA:
02782 for(frame = 0; frame < getFrameCount(); frame++)
02783 {
02784 for(side = 0; side < getSideCount(); side++)
02785 {
02786 src = this->getData(0, frame, side);
02787 dest = destImage->getData(0, frame, side);
02788 size = getWidth() * getHeight() * getDepth() * getBpp();
02789 memcpy(dest,src, size);
02790 src = dest;
02791 dest = src + size;
02792 w = getWidth();
02793 h = getHeight();
02794 d = getDepth();
02795
02796 for(mipmap = 1; mipmap < level; mipmap++)
02797 {
02798 lineSize = w * getBpp();
02799 sliceSize = w * h * getBpp();
02800 wm = (w == 1) ? w : (w >> 1);
02801 hm = (h == 1) ? h : (h >> 1);
02802 dm = (d == 1) ? d : (d >> 1);
02803
02804 dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
02805 elem = offsetSize[dim];
02806
02807 for(di = 0; di < dm; di++)
02808 {
02809 for(hi = 0; hi < hm; hi++)
02810 {
02811 for(wi = 0; wi < wm; wi++)
02812 {
02813 for(channel = 0; channel < getBpp(); channel++)
02814 {
02815 value = 0;
02816 for(i = 0; i < elem; i++)
02817 {
02818 value += src[
02819 ((wi * 2) + offset[dim][i].w) * getBpp() +
02820 ((hi * 2) + offset[dim][i].h) * lineSize +
02821 ((di * 2) + offset[dim][i].d) * sliceSize +
02822 channel];
02823 }
02824 *dest++ = (Int8) (value / elem);
02825 }
02826 }
02827 }
02828 }
02829
02830 src += sliceSize;
02831 w = wm;
02832 h = hm;
02833 d = dm;
02834 }
02835 }
02836 }
02837 break;
02838
02839 case OSG_UINT16_IMAGEDATA:
02840 for(frame = 0; frame < getFrameCount(); frame++)
02841 {
02842 for(side = 0; side < getSideCount(); side++)
02843 {
02844 src = this->getData(0, frame, side);
02845
02846 dest = destImage->getData(0, frame, side);
02847
02848
02849 size = getWidth() * getHeight() * getDepth() * getBpp();
02850
02851
02852
02853 memcpy(dest,src, size);
02854
02855 src = dest;
02856 dest = src + size;
02857
02858
02859
02860 w = getWidth();
02861 h = getHeight();
02862 d = getDepth();
02863
02864 sourceDataUC16 = (UInt16*) src;
02865 destDataUC16 = (UInt16*) dest;
02866
02867 for(mipmap = 1; mipmap < level; mipmap++)
02868 {
02869 lineSize = w * getBpp()/getComponentSize();
02870 sliceSize = w * h * getBpp()/getComponentSize();
02871 wm = (w == 1) ? w : (w >> 1);
02872 hm = (h == 1) ? h : (h >> 1);
02873 dm = (d == 1) ? d : (d >> 1);
02874
02875 dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
02876 elem = offsetSize[dim];
02877
02878 for(di = 0; di < dm; di++)
02879 {
02880 for(hi = 0; hi < hm; hi++)
02881 {
02882 for(wi = 0; wi < wm; wi++)
02883 {
02884 for(channel = 0; channel < (getBpp()/getComponentSize()); channel++)
02885 {
02886 value = 0;
02887 for(i = 0; i < elem; i++)
02888 {
02889 value += sourceDataUC16[
02890 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
02891 ((hi * 2) + offset[dim][i].h) * lineSize +
02892 ((di * 2) + offset[dim][i].d) * sliceSize +
02893 channel];
02894 }
02895 *destDataUC16++ = (UInt16) (value / elem);
02896 }
02897 }
02898 }
02899 }
02900
02901 sourceDataUC16 += sliceSize;
02902 w = wm;
02903 h = hm;
02904 d = dm;
02905 }
02906 }
02907 }
02908 break;
02909
02910 case OSG_UINT32_IMAGEDATA:
02911 for(frame = 0; frame < getFrameCount(); frame++)
02912 {
02913 for(side = 0; side < getSideCount(); side++)
02914 {
02915 src = this->getData(0, frame,side);
02916
02917 dest = destImage->getData(0, frame,side);
02918
02919
02920 size = getWidth() * getHeight() * getDepth() * getBpp();
02921
02922
02923 memcpy(dest,src, size);
02924
02925 src = dest;
02926 dest = src + size;
02927
02928
02929
02930 w = getWidth();
02931 h = getHeight();
02932 d = getDepth();
02933
02934 sourceDataUC32 = (UInt32*) src;
02935 destDataUC32 = (UInt32*) dest;
02936
02937 for(mipmap = 1; mipmap < level; mipmap++)
02938 {
02939 lineSize = w * (getBpp() / getComponentSize());
02940 sliceSize = w * h * (getBpp() / getComponentSize());
02941 wm = (w == 1) ? w : (w >> 1);
02942 hm = (h == 1) ? h : (h >> 1);
02943 dm = (d == 1) ? d : (d >> 1);
02944
02945 dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
02946 elem = offsetSize[dim];
02947
02948 for(di = 0; di < dm; di++)
02949 {
02950 for(hi = 0; hi < hm; hi++)
02951 {
02952 for(wi = 0; wi < wm; wi++)
02953 {
02954 for(channel = 0; channel < (getBpp()/getComponentSize()); channel++)
02955 {
02956 value = 0;
02957 for(i = 0; i < elem; i++)
02958 {
02959 value += (sourceDataUC32[
02960 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
02961 ((hi * 2) + offset[dim][i].h) * lineSize +
02962 ((di * 2) + offset[dim][i].d) * sliceSize +
02963 channel]/elem);
02964 }
02965 *destDataUC32++ = (UInt32) value;
02966 }
02967 }
02968 }
02969 }
02970
02971 sourceDataUC32 += sliceSize;
02972 w = wm;
02973 h = hm;
02974 d = dm;
02975 }
02976 }
02977 }
02978 break;
02979
02980 case OSG_FLOAT32_IMAGEDATA:
02981 for(frame = 0; frame < getFrameCount(); frame++)
02982 {
02983 for(side = 0; side < getSideCount(); side++)
02984 {
02985 src = this->getData(0, frame,side);
02986 dest = destImage->getData(0, frame,side);
02987 size = getWidth() * getHeight() * getDepth() * getBpp();
02988 memcpy(dest,src, size);
02989 src = dest;
02990 dest = src + size;
02991 w = getWidth();
02992 h = getHeight();
02993 d = getDepth();
02994
02995 sourceDataF32 = (Real32*) src;
02996 destDataF32 = (Real32*) dest;
02997
02998 for(mipmap = 1; mipmap < level; mipmap++)
02999 {
03000 lineSize = w * (getBpp() / getComponentSize());
03001 sliceSize = w * h * (getBpp() / getComponentSize());
03002 wm = (w == 1) ? w : (w >> 1);
03003 hm = (h == 1) ? h : (h >> 1);
03004 dm = (d == 1) ? d : (d >> 1);
03005
03006 dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
03007 elem = offsetSize[dim];
03008
03009 for(di = 0; di < dm; di++)
03010 {
03011 for(hi = 0; hi < hm; hi++)
03012 {
03013 for(wi = 0; wi < wm; wi++)
03014 {
03015 for(channel = 0; channel < (getBpp()/getComponentSize()); channel++)
03016 {
03017 valueFloat = 0;
03018 for(i = 0; i < elem; i++)
03019 {
03020 valueFloat += sourceDataF32[
03021 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
03022 ((hi * 2) + offset[dim][i].h) * lineSize +
03023 ((di * 2) + offset[dim][i].d) * sliceSize +
03024 channel];
03025 }
03026 *destDataF32++ = (Real32) (valueFloat / elem);
03027 }
03028 }
03029 }
03030 }
03031
03032 sourceDataF32 += sliceSize;
03033 w = wm;
03034 h = hm;
03035 d = dm;
03036 }
03037 }
03038 }
03039 break;
03040 case OSG_FLOAT16_IMAGEDATA:
03041 for(frame = 0; frame < getFrameCount(); frame++)
03042 {
03043 for(side = 0; side < getSideCount(); side++)
03044 {
03045 src = this->getData(0, frame,side);
03046 dest = destImage->getData(0, frame,side);
03047 size = getWidth() * getHeight() * getDepth() * getBpp();
03048 memcpy(dest,src, size);
03049 src = dest;
03050 dest = src + size;
03051 w = getWidth();
03052 h = getHeight();
03053 d = getDepth();
03054
03055 sourceDataH16 = (Real16*) src;
03056 destDataH16 = (Real16*) dest;
03057
03058 for(mipmap = 1; mipmap < level; mipmap++)
03059 {
03060 lineSize = w * (getBpp() / getComponentSize());
03061 sliceSize = w * h * (getBpp() / getComponentSize());
03062 wm = (w == 1) ? w : (w >> 1);
03063 hm = (h == 1) ? h : (h >> 1);
03064 dm = (d == 1) ? d : (d >> 1);
03065
03066 dim = (d > dm) * 1 + (h > hm) * 2 + (w > wm) * 4;
03067 elem = offsetSize[dim];
03068
03069 for(di = 0; di < dm; di++)
03070 {
03071 for(hi = 0; hi < hm; hi++)
03072 {
03073 for(wi = 0; wi < wm; wi++)
03074 {
03075 for(channel = 0; channel < (getBpp()/getComponentSize()); channel++)
03076 {
03077 valueFloat = 0;
03078 for(i = 0; i < elem; i++)
03079 {
03080 valueFloat += sourceDataH16[
03081 ((wi * 2) + offset[dim][i].w) * (getBpp() / getComponentSize()) +
03082 ((hi * 2) + offset[dim][i].h) * lineSize +
03083 ((di * 2) + offset[dim][i].d) * sliceSize +
03084 channel];
03085 }
03086 *destDataH16++ = (Real16) (valueFloat / elem);
03087 }
03088 }
03089 }
03090 }
03091 sourceDataH16 += sliceSize;
03092 w = wm;
03093 h = hm;
03094 d = dm;
03095 }
03096 }
03097 }
03098 break;
03099
03100 case OSG_INT16_IMAGEDATA:
03101 case OSG_INT32_IMAGEDATA:
03102 {
03103 FFATAL((" 'createMipmap' NYI\n "));
03104 }
03105 break;
03106
03107 default:
03108 FWARNING (( "Invalid IMAGE_DATA_TYPE\n" ));
03109 break;
03110 }
03111
03112
03113 if(destination == NullFC)
03114 {
03115 this->set(destImage);
03116 subRefCP(destImage);
03117 }
03118
03119 return true;
03120 }
03121
03125 bool Image::write(const Char8 *fileName)
03126 {
03127 return ImageFileHandler::the().write(ImagePtr(this), fileName);
03128 }
03129
03132 bool Image::read(const Char8 *fileName)
03133 {
03134 ImagePtr iPtr(this);
03135
03136 return ImageFileHandler::the().read(iPtr, fileName);
03137 }
03138
03144 UInt64 Image::store(const Char8 *mimeType, UChar8 *mem, Int32 memSize)
03145 {
03146 ImagePtr iPtr(this);
03147 return ImageFileHandler::the().store(iPtr,
03148 mimeType, mem, memSize);
03149 }
03150
03154 UInt64 Image::restore(const UChar8 *mem, Int32 memSize)
03155 {
03156 ImagePtr iPtr(this);
03157 return ImageFileHandler::the().restore(iPtr, mem, memSize);;
03158 }
03159
03160
03161
03162
03165 Image::Image(void) :
03166 Inherited()
03167 {
03168 setPixelFormat(OSG_INVALID_PF);
03169 return;
03170 }
03171
03174 Image::Image(const Image &obj) :
03175 Inherited(obj)
03176 {
03177 }
03178
03181 Image::~Image(void)
03182 {
03183 }
03184
03185 #if defined(OSG_FIXED_MFIELDSYNC)
03186 void Image::onDestroyAspect(UInt32 uiId, UInt32 uiAspect)
03187 {
03188 Inherited::onDestroyAspect(uiId, uiAspect);
03189
03190 AttachmentMap::iterator attIt = _attachmentMap.getValue().begin();
03191 AttachmentMap::iterator attEnd = _attachmentMap.getValue().end();
03192
03193 AttachmentContainerPtr thisP = getPtr();
03194
03195 while(attIt != attEnd)
03196 {
03197 beginEditCP((*attIt).second, Attachment::ParentsFieldMask);
03198 {
03199 (*attIt).second->subParent(thisP);
03200 }
03201 endEditCP ((*attIt).second, Attachment::ParentsFieldMask);
03202
03203 subRefCP ((*attIt).second);
03204
03205 ++attIt;
03206 }
03207
03208 _attachmentMap.getValue().clear();
03209 }
03210 #endif
03211
03214 bool Image::hasAlphaChannel(void)
03215 {
03216 return
03217 getForceAlphaChannel()
03218 || getPixelFormat() == OSG_RGBA_PF
03219 || getPixelFormat() == OSG_BGRA_PF
03220 || getPixelFormat() == OSG_RGBA_DXT1
03221 || getPixelFormat() == OSG_RGBA_DXT3
03222 || getPixelFormat() == OSG_RGBA_DXT5
03223 || getPixelFormat() == OSG_A_PF
03224 || getPixelFormat() == OSG_I_PF
03225 || getPixelFormat() == OSG_LA_PF
03226 || getPixelFormat() == OSG_ALPHA_INTEGER_PF
03227 || getPixelFormat() == OSG_RGBA_INTEGER_PF
03228 || getPixelFormat() == OSG_BGRA_INTEGER_PF
03229 || getPixelFormat() == OSG_LUMINANCE_ALPHA_INTEGER_PF;
03230 }
03231
03235 bool Image::isAlphaBinary(void)
03236 {
03237 return
03238 getForceAlphaBinary()
03239 || getPixelFormat() == OSG_RGBA_DXT1;
03240 }
03241
03244 bool Image::hasCompressedData(void)
03245 {
03246 return
03247 getForceCompressedData() ||
03248 (getPixelFormat() == OSG_RGB_DXT1) ||
03249 (getPixelFormat() == OSG_RGBA_DXT1) ||
03250 (getPixelFormat() == OSG_RGBA_DXT3) ||
03251 (getPixelFormat() == OSG_RGBA_DXT5);
03252
03253 }
03254
03257 bool Image::hasColorChannel(void)
03258 {
03259 return !( getPixelFormat() == OSG_A_PF ||
03260 getPixelFormat() == OSG_I_PF ||
03261 getPixelFormat() == OSG_L_PF ||
03262 getPixelFormat() == OSG_LA_PF ||
03263 getPixelFormat() == OSG_ALPHA_INTEGER_PF ||
03264 getPixelFormat() == OSG_LUMINANCE_ALPHA_INTEGER_PF)
03265 || getForceColorChannel();
03266 }
03267
03270 UInt8 *Image::getDataByTime(Time time, UInt32)
03271 {
03272 UInt32 frameNum = calcFrameNum(time, true);
03273
03274 return getData(0, frameNum);
03275 }
03276
03281 bool Image::calcIsAlphaBinary(void)
03282 {
03283 if(!hasAlphaChannel() || getPixelFormat() == OSG_RGBA_DXT1)
03284 return true;
03285
03286 if(getPixelFormat() == OSG_RGBA_DXT3 || getPixelFormat() == OSG_RGBA_DXT5)
03287 {
03288 FWARNING(("Image::calcIsAlphaBinary: not implemenetd for DXT3 "
03289 "and DXT5 yet, assuming false.\n"));
03290 return false;
03291 }
03292
03293 UInt32 npix = getWidth() * getHeight() * getDepth() * getFrameCount();
03294 UInt8 pixelsize = getBpp();
03295
03296 UInt8 *data = getData();
03297
03298 switch(getPixelFormat())
03299 {
03300 case OSG_LA_PF: data += getComponentSize(); break;
03301 case OSG_BGRA_PF:
03302 case OSG_RGBA_PF: data += getComponentSize() * 3; break;
03303 default:
03304 FWARNING(("Image::calcIsAlphaBinary: found unknown "
03305 "image format %x, assumning false.\n",
03306 getPixelFormat()));
03307 return false;
03308 }
03309
03310 switch(getDataType())
03311 {
03312 case OSG_UINT8_IMAGEDATA:
03313 for(; npix > 0; --npix, data += pixelsize)
03314 {
03315 if(*data != 0 && *data != 0xffU)
03316 break;
03317 }
03318 break;
03319 case OSG_UINT16_IMAGEDATA:
03320 for(; npix > 0; --npix, data += pixelsize)
03321 {
03322 UInt16 *d = reinterpret_cast<UInt16*>(data);
03323 if(*d != 0 && *d != 0xffffU)
03324 break;
03325 }
03326 break;
03327 case OSG_UINT32_IMAGEDATA:
03328 for(; npix > 0; --npix, data += pixelsize)
03329 {
03330 UInt32 *d = reinterpret_cast<UInt32*>(data);
03331 if(*d != 0 && *d != 0xffffffffU)
03332 break;
03333 }
03334 break;
03335 case OSG_FLOAT16_IMAGEDATA:
03336 for(; npix > 0; --npix, data += pixelsize)
03337 {
03338 Real16 *d = reinterpret_cast<Real16*>(data);
03339 if(*d != 0 && *d != 1)
03340 break;
03341 }
03342 break;
03343 case OSG_FLOAT32_IMAGEDATA:
03344 for(; npix > 0; --npix, data += pixelsize)
03345 {
03346 Real32 *d = reinterpret_cast<Real32*>(data);
03347 if(*d != 0 && *d != 1)
03348 break;
03349 }
03350 break;
03351 case OSG_INT16_IMAGEDATA:
03352 case OSG_INT32_IMAGEDATA:
03353 {
03354 FFATAL((" 'calcIsAlphaBinary' NYI\n "));
03355 }
03356 break;
03357 default:
03358 FWARNING(("Image::calcIsAlphaBinary: found unknown "
03359 "data type %d, assumning false.\n",
03360 getDataType()));
03361 return false;
03362 }
03363
03364 return npix == 0;
03365 }
03366
03369 UInt32 Image::calcFrameNum(Time time, bool OSG_CHECK_ARG(loop)) const
03370 {
03371 UInt64 frameNum = ((getFrameDelay() > 0) && (getFrameCount() > 0)) ?
03372 (UInt64(time / getFrameDelay()) % getFrameCount()) : 0;
03373
03374 return ((frameNum > 0) ? UInt32(frameNum) : 0);
03375 }
03376
03379 void Image::calcMipmapGeometry ( UInt32 mipmapNum,
03380 UInt32 &width,
03381 UInt32 &height,
03382 UInt32 &depth ) const
03383 {
03384 width = getWidth() ? osgMax(getWidth() >> mipmapNum, 1) : 0 ;
03385 height = getHeight() ? osgMax(getHeight() >> mipmapNum, 1) : 0 ;
03386 depth = getDepth() ? osgMax(getDepth() >> mipmapNum, 1) : 0 ;
03387 }
03388
03389 #ifdef __sgi
03390 #pragma set woff 1209
03391 #endif
03392
03395 UInt32 Image::calcMipmapLevelCount ( void ) const
03396 {
03397 UInt32 w = getWidth(), h = getHeight(), d = getDepth();
03398 UInt32 level;
03399
03400 for (level = 1; true; level++)
03401 {
03402 if ((w == 1) && (h == 1) && (d == 1))
03403 break;
03404 else
03405 {
03406 w = (w >>= 1) ? w : 1;
03407 h = (h >>= 1) ? h : 1;
03408 d = (d >>= 1) ? d : 1;
03409 }
03410 }
03411 return level;
03412 }
03413
03414 #ifdef __sgi
03415 #pragma reset woff 1209
03416 #endif
03417
03418
03419
03420
03421
03424 UInt32 Image::calcMipmapLevelSize ( UInt32 mipmapNum,
03425 UInt32 w, UInt32 h, UInt32 d) const
03426 {
03427 Int32 sum;
03428
03429 switch (getPixelFormat())
03430 {
03431 case OSG_RGB_DXT1:
03432 case OSG_RGBA_DXT1:
03433 sum = (((w?w:1)+3)/4) * (((h?h:1)+3)/4) * 8;
03434 break;
03435 case OSG_RGBA_DXT3:
03436 case OSG_RGBA_DXT5:
03437 sum = (((w?w:1)+3)/4) * (((h?h:1)+3)/4) * 16;
03438 break;
03439 default:
03440 sum = (w?w:1) * (h?h:1) * getBpp();
03441 break;
03442 }
03443
03444 sum *= (d?d:1);
03445
03446 return sum;
03447 }
03448
03452 UInt32 Image::calcMipmapLevelSize (UInt32 mipmapNum) const
03453 {
03454 UInt32 w, h, d;
03455 calcMipmapGeometry(mipmapNum, w, h, d);
03456 return calcMipmapLevelSize(mipmapNum, w, h, d);
03457 }
03458
03461 UInt32 Image::calcMipmapSumSize ( UInt32 mipmapNum,
03462 UInt32 w, UInt32 h, UInt32 d) const
03463 {
03464 Int32 levelSum, sum = 0;
03465
03466 if (w && h && d)
03467 {
03468 while (mipmapNum--)
03469 {
03470 sum += calcMipmapLevelSize(mipmapNum,w,h,d);
03471
03472 w >>= 1;
03473 h >>= 1;
03474 d >>= 1;
03475 }
03476 }
03477
03478 return sum;
03479 }
03480
03484 UInt32 Image::calcMipmapSumSize (UInt32 mipmapNum) const
03485 {
03486 return calcMipmapSumSize(mipmapNum,getWidth(),getHeight(),getDepth());
03487 }
03488
03489
03490
03491
03494 bool Image::createData(const UInt8 *data, bool allocMem)
03495 {
03496 Int32 i;
03497 Int32 mapSizeFormat = sizeof(_formatDic) / sizeof(UInt32[2]);
03498 Int32 mapSizeType = sizeof(_typeDic) / sizeof(UInt32[2]);
03499
03500 UInt32 byteCount = 0;
03501 ImagePtr iPtr(this);
03502
03503 beginEditCP(iPtr,
03504 BppFieldMask |
03505 DimensionFieldMask |
03506 FrameSizeFieldMask |
03507 ComponentSizeFieldMask |
03508 PixelFieldMask);
03509
03510
03511 UInt32 pixelFormat = 0;
03512 UInt32 typeFormat = 0;
03513 for(i = 0; i < mapSizeFormat; i++)
03514 {
03515 if(_formatDic[i][0] == getPixelFormat())
03516 pixelFormat = _formatDic[i][1];
03517 }
03518 for(i = 0; i < mapSizeType; i++)
03519 {
03520 if(_typeDic[i][0] == getDataType())
03521 typeFormat = _typeDic[i][1];
03522 }
03523
03524 setComponentSize( typeFormat );
03525 setBpp( pixelFormat * typeFormat );
03526
03527
03528 setDimension(0);
03529 if(getDepth() == 1)
03530 {
03531 if(getHeight() == 1)
03532 {
03533 setDimension(1);
03534 }
03535 else
03536 {
03537 setDimension(2);
03538 }
03539 }
03540 else
03541 setDimension(3);
03542
03543
03544 UInt32 mipmapSumSize = calcMipmapSumSize(getMipMapCount());
03545 setSideSize ( mipmapSumSize );
03546
03547
03548 setFrameSize( getSideSize() * getSideCount() );
03549
03550
03551 if(allocMem && (byteCount = getSize()))
03552 {
03553 if(getPixel().getSize() != byteCount)
03554 {
03555 try
03556 {
03557 if(byteCount < getPixel().getSize())
03558 {
03559 getPixel().clear();
03560
03561 MFUInt8 tmp;
03562 tmp.swap(getPixel());
03563 }
03564
03565 getPixel().resize(byteCount);
03566 }
03567 catch(...)
03568 {
03569 FFATAL(("Image::createData : Couldn't allocate %u bytes!\n", byteCount));
03570 return false;
03571 }
03572 }
03573 if(data)
03574 memcpy(getData(), data, byteCount);
03575 }
03576 else
03577 {
03578 getPixel().clear();
03579 }
03580
03581 endEditCP(iPtr,
03582 BppFieldMask |
03583 DimensionFieldMask |
03584 FrameSizeFieldMask |
03585 ComponentSizeFieldMask |
03586 PixelFieldMask);
03587
03588 return (getData() != NULL);
03589 }
03590
03593 bool Image::scaleData(UInt8 *srcData, Int32 srcW, Int32 srcH, Int32 srcD,
03594 UInt8 *destData, Int32 destW, Int32 destH, Int32 destD)
03595 {
03596 Real32 sx = Real32(srcW) / Real32(destW);
03597 Real32 sy = Real32(srcH) / Real32(destH);
03598 Real32 sz = Real32(srcD) / Real32(destD);
03599 Int32 srcSize = srcW * srcH * srcD * getBpp();
03600
03601
03602 Int32 x, y, z, p;
03603 UInt8 *slice, *line, *pixel;
03604
03605 if(destW == srcW && destH == srcH && destD == srcD)
03606 {
03607
03608 memcpy(destData, srcData, srcSize);
03609 }
03610 else
03611 {
03612 for(z = 0; z < destD; z++)
03613 {
03614 slice = srcData + int(sz * z) * getBpp() * srcW * srcH;
03615 for(y = 0; y < destH; y++)
03616 {
03617 line = slice + int(sy * y) * getBpp() * srcW;
03618 for(x = 0; x < destW; x++)
03619 {
03620 pixel = line + int(sx * x) * getBpp();
03621 p = getBpp();
03622 while(p--)
03623 *destData++ = *pixel++;
03624 }
03625 }
03626 }
03627 }
03628
03629 return true;
03630 }
03631
03634 Image &Image::operator=(const Image &image)
03635 {
03636 this->set((PixelFormat)image.getPixelFormat(), image.getWidth(),
03637 image.getHeight(), image.getDepth(),
03638 image.getMipMapCount(), image.getFrameCount(),
03639 image.getFrameDelay(),
03640 image.getData(),
03641 image.getDataType(),
03642 true, image.getSideCount());
03643
03644 return *this;
03645 }
03646
03649 bool Image::operator<(const Image &image)
03650 {
03651 return (getSize() < image.getSize()) ? true : false;
03652 }
03653
03657 bool Image::operator==(const Image &image)
03658 {
03659 unsigned long i, s = getSize();
03660
03661 if((getWidth() == image.getWidth()) &&
03662 (getHeight() == image.getHeight()) &&
03663 (getDepth() == image.getDepth()) &&
03664 (getMipMapCount() == image.getMipMapCount()) &&
03665 (getFrameCount() == image.getFrameCount()) &&
03666 (getFrameDelay() == image.getFrameDelay()) &&
03667 (getPixelFormat() == image.getPixelFormat()) &&
03668 (getDataType() == image.getDataType()) &&
03669 (getSideCount() == image.getSideCount()))
03670 {
03671 for(i = 0; i < s; ++i)
03672 {
03673 if(image.getData()[i] != getData()[i])
03674 return false;
03675 }
03676 return true;
03677 }
03678 return false;
03679 }
03680
03684 bool Image::operator!=(const Image &image)
03685 {
03686 return !(*this == image);
03687 }
03688
03689
03690
03691
03692
03693
03694 #ifdef OSG_SGI_CC
03695 #pragma set woff 1174
03696 #endif
03697
03698 #ifdef OSG_LINUX_ICC
03699 #pragma warning( disable : 177 )
03700 #endif
03701
03702 namespace
03703 {
03704 static Char8 cvsid_cpp [] = "@(#)$Id: $";
03705 static Char8 cvsid_hpp [] = OSGIMAGEBASE_HEADER_CVSID;
03706 static Char8 cvsid_inl [] = OSGIMAGEBASE_INLINE_CVSID;
03707
03708 static Char8 cvsid_fields_hpp[] = OSGIMAGEFIELDS_HEADER_CVSID;
03709 }
03710
03711 #ifdef __sgi
03712 #pragma reset woff 1174
03713 #endif
03714
