FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved osgVolume::ImageUtils to osg::ImageUtils, updated wrappers, and started moving osgvolume example across to create osgVolume subgraphs

Browse Source
This commit is contained in:
Robert Osfield 2009-01-09 15:19:25 +00:00
parent 9b4c6e25ea
commit 458993fa88
13 changed files with 155 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
examples/osgvolume/osgvolume.cpp
View File

@ -60,7 +60,9 @@
#include <algorithm>
#include <iostream>
#include <osgVolume/ImageUtils>
#include <osg/ImageUtils>
#include <osgVolume/Volume>
#include <osgVolume/VolumeTile>
typedef std::vector< osg::ref_ptr<osg::Image> > ImageList;
@ -1519,8 +1521,8 @@ osg::Image* readRaw(int sizeX, int sizeY, int sizeZ, int numberBytesPerComponent
{
// compute range of values
osg::Vec4 minValue, maxValue;
osgVolume::computeMinMax(image.get(), minValue, maxValue);
osgVolume::modifyImage(image.get(),ScaleOperator(1.0f/maxValue.r()));
osg::computeMinMax(image.get(), minValue, maxValue);
osg::modifyImage(image.get(),ScaleOperator(1.0f/maxValue.r()));
}
@ -1545,12 +1547,12 @@ osg::Image* readRaw(int sizeX, int sizeY, int sizeZ, int numberBytesPerComponent
writeOp._pos = 0;
// read the pixels into readOp's _colour array
osgVolume::readRow(sizeS, pixelFormat, dataType, image->data(0,t,r), readOp);
osg::readRow(sizeS, pixelFormat, dataType, image->data(0,t,r), readOp);
// pass readOp's _colour array contents over to writeOp (note this is just a pointer swap).
writeOp._colours.swap(readOp._colours);
osgVolume::modifyRow(sizeS, pixelFormat, GL_UNSIGNED_BYTE, new_image->data(0,t,r), writeOp);
osg::modifyRow(sizeS, pixelFormat, GL_UNSIGNED_BYTE, new_image->data(0,t,r), writeOp);
// return readOp's _colour array contents back to its rightful owner.
writeOp._colours.swap(readOp._colours);
@ -1617,19 +1619,19 @@ osg::Image* doColourSpaceConversion(ColourSpaceOperation op, osg::Image* image,
case (MODULATE_ALPHA_BY_LUMINANCE):
{
std::cout<<"doing conversion MODULATE_ALPHA_BY_LUMINANCE"<<std::endl;
osgVolume::modifyImage(image,ModulateAlphaByLuminanceOperator());
osg::modifyImage(image,ModulateAlphaByLuminanceOperator());
return image;
}
case (MODULATE_ALPHA_BY_COLOUR):
{
std::cout<<"doing conversion MODULATE_ALPHA_BY_COLOUR"<<std::endl;
osgVolume::modifyImage(image,ModulateAlphaByColourOperator(colour));
osg::modifyImage(image,ModulateAlphaByColourOperator(colour));
return image;
}
case (REPLACE_ALPHA_WITH_LUMINANACE):
{
std::cout<<"doing conversion REPLACE_ALPHA_WITH_LUMINANACE"<<std::endl;
osgVolume::modifyImage(image,ReplaceAlphaWithLuminanceOperator());
osg::modifyImage(image,ReplaceAlphaWithLuminanceOperator());
return image;
}
case (REPLACE_RGB_WITH_LUMINANCE):
@ -1637,8 +1639,8 @@ osg::Image* doColourSpaceConversion(ColourSpaceOperation op, osg::Image* image,
std::cout<<"doing conversion REPLACE_ALPHA_WITH_LUMINANACE"<<std::endl;
osg::Image* newImage = new osg::Image;
newImage->allocateImage(image->s(), image->t(), image->r(), GL_LUMINANCE, image->getDataType());
osgVolume::copyImage(image, 0, 0, 0, image->s(), image->t(), image->r(),
newImage, 0, 0, 0, false);
osg::copyImage(image, 0, 0, 0, image->s(), image->t(), image->r(),
newImage, 0, 0, 0, false);
return newImage;
}
default:
@ -1694,7 +1696,7 @@ osg::Image* applyTransferFunction(osg::Image* image, osg::TransferFunction1D* tr
output_image->allocateImage(image->s(),image->t(), image->r(), GL_RGBA, GL_UNSIGNED_BYTE);
ApplyTransferFunctionOperator op(transferFunction, output_image->data());
osgVolume::readImage(image,op);
osg::readImage(image,op);
return output_image;
}
@ -1938,6 +1940,10 @@ int main( int argc, char **argv )
unsigned int numComponentsDesired = 0;
while(arguments.read("--num-components", numComponentsDesired)) {}
bool useOsgVolume = true;
while(arguments.read("--osgVolume")) { useOsgVolume = true; }
while(arguments.read("--no-osgVolume")) { useOsgVolume = false; }
bool useShader = true;
while(arguments.read("--shader")) { useShader = true; }
while(arguments.read("--no-shader")) { useShader = true; }
@ -2139,7 +2145,7 @@ int main( int argc, char **argv )
++itr)
{
osg::Vec4 localMinValue, localMaxValue;
if (osgVolume::computeMinMax(itr->get(), localMinValue, localMaxValue))
if (osg::computeMinMax(itr->get(), localMinValue, localMaxValue))
{
if (localMinValue.r()<minValue.r()) minValue.r() = localMinValue.r();
if (localMinValue.g()<minValue.g()) minValue.g() = localMinValue.g();
@ -2187,7 +2193,7 @@ int main( int argc, char **argv )
itr != images.end();
++itr)
{
osgVolume::offsetAndScaleImage(itr->get(),
osg::offsetAndScaleImage(itr->get(),
osg::Vec4(offset, offset, offset, offset),
osg::Vec4(scale, scale, scale, scale));
}
@ -2201,7 +2207,7 @@ int main( int argc, char **argv )
itr != images.end();
++itr)
{
osgVolume::offsetAndScaleImage(itr->get(),
osg::offsetAndScaleImage(itr->get(),
osg::Vec4(offset, offset, offset, offset),
osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
}
@ -2280,35 +2286,50 @@ int main( int argc, char **argv )
// create a model from the images.
osg::Node* rootNode = 0;
if (useShader)
if (useOsgVolume)
{
rootNode = createShaderModel(shadingModel,
image_3d, normalmap_3d.get(),
(gpuTransferFunction ? transferFunction.get() : 0),
internalFormatMode,
xSize, ySize, zSize,
xMultiplier, yMultiplier, zMultiplier,
numSlices, sliceEnd, alphaFunc);
osg::ref_ptr<osgVolume::Volume> volume = new osgVolume::Volume;
osg::ref_ptr<osgVolume::VolumeTile> tile = new osgVolume::VolumeTile;
osg::ref_ptr<osgVolume::Layer> layer = new osgVolume::ImageLayer(image_3d);
tile->addLayer(layer.get());
volume->addChild(tile);
rootNode = volume.get();
}
else
{
rootNode = createModel(shadingModel,
image_3d, normalmap_3d,
internalFormatMode,
xSize, ySize, zSize,
xMultiplier, yMultiplier, zMultiplier,
numSlices, sliceEnd, alphaFunc);
}
if (matrix && rootNode)
{
osg::MatrixTransform* mt = new osg::MatrixTransform;
mt->setMatrix(*matrix);
mt->addChild(rootNode);
if (useShader)
{
rootNode = createShaderModel(shadingModel,
image_3d, normalmap_3d.get(),
(gpuTransferFunction ? transferFunction.get() : 0),
internalFormatMode,
xSize, ySize, zSize,
xMultiplier, yMultiplier, zMultiplier,
numSlices, sliceEnd, alphaFunc);
}
else
{
rootNode = createModel(shadingModel,
image_3d, normalmap_3d,
internalFormatMode,
xSize, ySize, zSize,
xMultiplier, yMultiplier, zMultiplier,
numSlices, sliceEnd, alphaFunc);
}
rootNode = mt;
if (matrix && rootNode)
{
osg::MatrixTransform* mt = new osg::MatrixTransform;
mt->setMatrix(*matrix);
mt->addChild(rootNode);
rootNode = mt;
}
}
if (!outputFile.empty())
{
std::string ext = osgDB::getFileExtension(outputFile);

16
include/osgVolume/ImageUtils → include/osg/ImageUtils
View File

@ -11,14 +11,14 @@
* OpenSceneGraph Public License for more details.
*/
#ifndef OSGVOLUME_IMAGEUTILS
#define OSGVOLUME_IMAGEUTILS 1
#ifndef OSG_IMAGEUTILS
#define OSG_IMAGEUTILS 1
#include <osgVolume/Export>
#include <osg/Export>
#include <osg/Image>
namespace osgVolume {
namespace osg {
template <typename T, class O>
void _readRow(unsigned int num, GLenum pixelFormat, const T* data,float scale, O& operation)
@ -121,17 +121,17 @@ void modifyImage(osg::Image* image, const M& operation)
}
/** Compute the min max colour values in the image.*/
extern OSGVOLUME_EXPORT bool computeMinMax(const osg::Image* image, osg::Vec4& min, osg::Vec4& max);
extern OSG_EXPORT bool computeMinMax(const osg::Image* image, osg::Vec4& min, osg::Vec4& max);
/** Compute the min max colour values in the image.*/
extern OSGVOLUME_EXPORT bool offsetAndScaleImage(osg::Image* image, const osg::Vec4& offset, const osg::Vec4& scale);
extern OSG_EXPORT bool offsetAndScaleImage(osg::Image* image, const osg::Vec4& offset, const osg::Vec4& scale);
/** Compute source image to destination image.*/
extern OSGVOLUME_EXPORT bool copyImage(const osg::Image* srcImage, int src_s, int src_t, int src_r, int width, int height, int depth,
extern OSG_EXPORT bool copyImage(const osg::Image* srcImage, int src_s, int src_t, int src_r, int width, int height, int depth,
osg::Image* destImage, int dest_s, int dest_t, int dest_r, bool doRescale = false);
/** Compute the min max colour values in the image.*/
extern OSGVOLUME_EXPORT bool clearImageToColor(osg::Image* image, const osg::Vec4& colour);
extern OSG_EXPORT bool clearImageToColor(osg::Image* image, const osg::Vec4& colour);
}

2
include/osgVolume/Locator
View File

@ -27,6 +27,8 @@ class OSGVOLUME_EXPORT Locator : public osg::Object
Locator() {}
Locator(const osg::Matrixd& transform) { setTransform(transform); }
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
Locator(const Locator& locator,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
osg::Object(locator, copyop),

24
include/osgVolume/VolumeTile
View File

@ -19,6 +19,7 @@
#include <osgDB/ReaderWriter>
#include <osgVolume/Layer>
#include <osgVolume/VolumeTechnique>
namespace osgVolume {
@ -109,14 +110,19 @@ class OSGVOLUME_EXPORT VolumeTile : public osg::Group
const TileID& getTileID() const { return _tileID; }
void setLocator(osg::RefMatrix* locator) { _locator = locator; }
osg::RefMatrix* getLocator() { return _locator.get(); }
const osg::RefMatrix* getLocator() const { return _locator.get(); }
void setLocator(Locator* locator) { _locator = locator; }
Locator* getLocator() { return _locator.get(); }
const Locator* getLocator() const { return _locator.get(); }
void setImage(unsigned int i, osg::Image* image);
osg::Image* getImage(unsigned int i) { return i<_images.size() ? _images[i].get() : 0; }
const osg::Image* getImage(unsigned int i) const { return i<_images.size() ? _images[i].get() : 0; }
void setLayer(unsigned int i, Layer* layer);
Layer* getLayer(unsigned int i) { return i<_layers.size() ? _layers[i].get() : 0; }
const Layer* getImage(unsigned int i) const { return i<_layers.size() ? _layers[i].get() : 0; }
void addLayer(Layer* layer) { if (layer) _layers.push_back(layer); }
unsigned int getNumLayers() { return _layers.size(); }
/** Set the VolumeTechnique*/
void setVolumeTechnique(VolumeTechnique* VolumeTechnique);
@ -152,10 +158,10 @@ class OSGVOLUME_EXPORT VolumeTile : public osg::Group
osg::ref_ptr<VolumeTechnique> _volumeTechnique;
osg::ref_ptr<osg::RefMatrix> _locator;
osg::ref_ptr<Locator> _locator;
typedef std::vector< osg::ref_ptr<osg::Image> > Images;
Images _images;
typedef std::vector< osg::ref_ptr<Layer> > Layers;
Layers _layers;
};
}

2
src/osg/CMakeLists.txt
View File

@ -82,6 +82,7 @@ SET(LIB_PUBLIC_HEADERS
${HEADER_PATH}/Image
${HEADER_PATH}/ImageSequence
${HEADER_PATH}/ImageStream
${HEADER_PATH}/ImageUtils
${HEADER_PATH}/io_utils
${HEADER_PATH}/KdTree
${HEADER_PATH}/Light
@ -241,6 +242,7 @@ ADD_LIBRARY(${LIB_NAME}
Image.cpp
ImageSequence.cpp
ImageStream.cpp
ImageUtils.cpp
KdTree.cpp
Light.cpp
LightModel.cpp

13
src/osgVolume/ImageUtils.cpp → src/osg/ImageUtils.cpp
View File

@ -13,11 +13,12 @@
#include <float.h>
#include <string.h>
#include <osg/Math>
#include <osg/Notify>
#include <osgVolume/ImageUtils>
#include <osg/ImageUtils>
namespace osgVolume
namespace osg
{
struct FindRangeOperator
@ -89,7 +90,7 @@ bool computeMinMax(const osg::Image* image, osg::Vec4& minValue, osg::Vec4& maxV
{
if (!image) return false;
osgVolume::FindRangeOperator rangeOp;
osg::FindRangeOperator rangeOp;
readImage(image, rangeOp);
minValue.r() = rangeOp._rmin;
minValue.g() = rangeOp._gmin;
@ -111,7 +112,7 @@ bool offsetAndScaleImage(osg::Image* image, const osg::Vec4& offset, const osg::
{
if (!image) return false;
osgVolume::modifyImage(image,osgVolume::OffsetAndScaleOperator(offset, scale));
osg::modifyImage(image,osg::OffsetAndScaleOperator(offset, scale));
return true;
}
@ -302,12 +303,12 @@ bool copyImage(const osg::Image* srcImage, int src_s, int src_t, int src_r, int
writeOp._pos = 0;
// read the pixels into readOp's _colour array
osgVolume::readRow(width, srcImage->getPixelFormat(), srcImage->getDataType(), srcImage->data(src_s,src_t+row,src_r+slice), readOp);
osg::readRow(width, srcImage->getPixelFormat(), srcImage->getDataType(), srcImage->data(src_s,src_t+row,src_r+slice), readOp);
// pass readOp's _colour array contents over to writeOp (note this is just a pointer swap).
writeOp._colours.swap(readOp._colours);
osgVolume::modifyRow(width, destImage->getPixelFormat(), destImage->getDataType(), destImage->data(dest_s, dest_t+row,dest_r+slice), writeOp);
osg::modifyRow(width, destImage->getPixelFormat(), destImage->getDataType(), destImage->data(dest_s, dest_t+row,dest_r+slice), writeOp);
// return readOp's _colour array contents back to its rightful owner.
writeOp._colours.swap(readOp._colours);

21
src/osgPlugins/dicom/ReaderWriterDICOM.cpp
View File

@ -8,6 +8,7 @@
#include <osg/Geode>
#include <osg/GL>
#include <osg/io_utils>
#include <osg/ImageUtils>
#include <osgDB/FileNameUtils>
#include <osgDB/FileUtils>
@ -15,7 +16,6 @@
#include <osgVolume/Volume>
#include <osgVolume/VolumeTile>
#include <osgVolume/ImageUtils>
#ifdef USE_DCMTK
#define HAVE_CONFIG_H
@ -121,7 +121,10 @@ class ReaderWriterDICOM : public osgDB::ReaderWriter
osg::ref_ptr<osgVolume::VolumeTile> tile = new osgVolume::VolumeTile;
tile->setVolume(volume.get());
tile->setImage(0, result.getImage());
osg::ref_ptr<osgVolume::Layer> layer= new osgVolume::ImageLayer(result.getImage());
tile->addLayer(layer.get());
// get matrix providing size of texels (in mm)
osg::RefMatrix* matrix = dynamic_cast<osg::RefMatrix*>(result.getImage()->getUserData());
@ -134,7 +137,7 @@ class ReaderWriterDICOM : public osgDB::ReaderWriter
osg::Vec3d scale(osg::Vec3(result.getImage()->s(),result.getImage()->t(), result.getImage()->r()));
matrix->postMultScale(scale);
tile->setLocator(matrix);
tile->setLocator(new osgVolume::Locator(*matrix));
result.getImage()->setUserData(0);
@ -637,15 +640,15 @@ class ReaderWriterDICOM : public osgDB::ReaderWriter
image->allocateImage(dcmImage->getWidth(), dcmImage->getHeight(), totalNumSlices,
pixelFormat, dataType);
osgVolume::copyImage(previous_image.get(), 0,0,0, previous_image->s(), previous_image->t(), imageNum,
image.get(), 0, 0, 0,
false);
osg::copyImage(previous_image.get(), 0,0,0, previous_image->s(), previous_image->t(), imageNum,
image.get(), 0, 0, 0,
false);
}
osgVolume::copyImage(imageAdapter.get(), 0,0,0, imageAdapter->s(), imageAdapter->t(), imageAdapter->r(),
image.get(), 0, 0, imageNum,
false);
osg::copyImage(imageAdapter.get(), 0,0,0, imageAdapter->s(), imageAdapter->t(), imageAdapter->r(),
image.get(), 0, 0, imageNum,
false);
imageNum += dcmImage->getFrameCount();
}

2
src/osgPlugins/pdf/CMakeLists.txt
View File

@ -4,7 +4,7 @@ INCLUDE_DIRECTORIES( ${CAIRO_INCLUDE_DIRS} ${POPPLER_INCLUDE_DIRS} )
LINK_DIRECTORIES(${CAIRO_LIBRARY_DIRS} ${POPPLER_LIB_DIRS})
SET(TARGET_EXTERNAL_LIBRARIES ${CAIRO_LIBRARIES} ${POPPLER_LIBRARIES} )
SET(TARGET_ADDED_LIBRARIES osgWidget osgVolume)
SET(TARGET_ADDED_LIBRARIES osgWidget)
#### end var setup ###
SETUP_PLUGIN(pdf pdf)

4
src/osgPlugins/pdf/ReaderWriterPDF.cpp
View File

@ -16,7 +16,7 @@
#include <osgDB/FileUtils>
#include <osgWidget/PdfReader>
#include <osgVolume/ImageUtils>
#include <osg/ImageUtils>
#include <cairo.h>
#include <poppler.h>
@ -200,7 +200,7 @@ class PopplerPdfImage : public osgWidget::PdfImage
_cairoImage->create((unsigned int)(w*2.0),(unsigned int)(h*2.0));
osgVolume::clearImageToColor(this, _backgroundColor);
osg::clearImageToColor(this, _backgroundColor);
cairo_save(_cairoImage->getContext());

2
src/osgVolume/CMakeLists.txt
View File

@ -9,7 +9,6 @@ SET(LIB_NAME osgVolume)
SET(HEADER_PATH ${OpenSceneGraph_SOURCE_DIR}/include/${LIB_NAME})
SET(LIB_PUBLIC_HEADERS
${HEADER_PATH}/Export
${HEADER_PATH}/ImageUtils
${HEADER_PATH}/Version
${HEADER_PATH}/Volume
${HEADER_PATH}/Locator
@ -22,7 +21,6 @@ SET(LIB_PUBLIC_HEADERS
ADD_LIBRARY(${LIB_NAME}
${OPENSCENEGRAPH_USER_DEFINED_DYNAMIC_OR_STATIC}
${LIB_PUBLIC_HEADERS}
ImageUtils.cpp
Version.cpp
Volume.cpp
VolumeTechnique.cpp

11
src/osgVolume/VolumeTile.cpp
View File

@ -35,9 +35,9 @@ VolumeTile::VolumeTile(const VolumeTile& volumeTile,const osg::CopyOp& copyop):
_volume(0),
_dirty(false),
_hasBeenTraversal(false),
_images(volumeTile._images)
_layers(volumeTile._layers)
{
if (volumeTile.getVolumeTechnique())
if (volumeTile.getVolumeTechnique()) ;
{
setVolumeTechnique(osg::clone(volumeTile.getVolumeTechnique()));
}
@ -47,6 +47,13 @@ VolumeTile::~VolumeTile()
{
if (_volume) setVolume(0);
}
void VolumeTile::setLayer(unsigned int i, Layer* layer)
{
if (_layers.size() <= i) _layers.resize(i+1);
_layers[i] = layer;
}
void VolumeTile::setVolume(Volume* volume)
{

5
src/osgWrappers/osgVolume/Locator.cpp
View File

@ -30,6 +30,11 @@ BEGIN_OBJECT_REFLECTOR(osgVolume::Locator)
I_Constructor0(____Locator,
"",
"");
I_Constructor1(IN, const osg::Matrixd &, transform,
Properties::NON_EXPLICIT,
____Locator__C5_osg_Matrixd_R1,
"",
"");
I_ConstructorWithDefaults2(IN, const osgVolume::Locator &, locator, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY,
____Locator__C5_Locator_R1__C5_osg_CopyOp_R1,
"Copy constructor using CopyOp to manage deep vs shallow copy. ",

55
src/osgWrappers/osgVolume/VolumeTile.cpp
View File

@ -12,10 +12,10 @@
#include <osg/BoundingSphere>
#include <osg/CopyOp>
#include <osg/Image>
#include <osg/Matrix>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osgVolume/Layer>
#include <osgVolume/Locator>
#include <osgVolume/Volume>
#include <osgVolume/VolumeTechnique>
#include <osgVolume/VolumeTile>
@ -123,34 +123,44 @@ BEGIN_OBJECT_REFLECTOR(osgVolume::VolumeTile)
__C5_TileID_R1__getTileID,
"Get the TileID (layer, x,y,z) of the VolumeTile. ",
"");
I_Method1(void, setLocator, IN, osg::RefMatrix *, locator,
I_Method1(void, setLocator, IN, osgVolume::Locator *, locator,
Properties::NON_VIRTUAL,
__void__setLocator__osg_RefMatrix_P1,
__void__setLocator__Locator_P1,
"",
"");
I_Method0(osg::RefMatrix *, getLocator,
I_Method0(osgVolume::Locator *, getLocator,
Properties::NON_VIRTUAL,
__osg_RefMatrix_P1__getLocator,
__Locator_P1__getLocator,
"",
"");
I_Method0(const osg::RefMatrix *, getLocator,
I_Method0(const osgVolume::Locator *, getLocator,
Properties::NON_VIRTUAL,
__C5_osg_RefMatrix_P1__getLocator,
__C5_Locator_P1__getLocator,
"",
"");
I_Method2(void, setImage, IN, unsigned int, i, IN, osg::Image *, image,
I_Method2(void, setLayer, IN, unsigned int, i, IN, osgVolume::Layer *, layer,
Properties::NON_VIRTUAL,
__void__setImage__unsigned_int__osg_Image_P1,
__void__setLayer__unsigned_int__Layer_P1,
"",
"");
I_Method1(osg::Image *, getImage, IN, unsigned int, i,
I_Method1(osgVolume::Layer *, getLayer, IN, unsigned int, i,
Properties::NON_VIRTUAL,
__osg_Image_P1__getImage__unsigned_int,
__Layer_P1__getLayer__unsigned_int,
"",
"");
I_Method1(const osg::Image *, getImage, IN, unsigned int, i,
I_Method1(const osgVolume::Layer *, getImage, IN, unsigned int, i,
Properties::NON_VIRTUAL,
__C5_osg_Image_P1__getImage__unsigned_int,
__C5_Layer_P1__getImage__unsigned_int,
"",
"");
I_Method1(void, addLayer, IN, osgVolume::Layer *, layer,
Properties::NON_VIRTUAL,
__void__addLayer__Layer_P1,
"",
"");
I_Method0(unsigned int, getNumLayers,
Properties::NON_VIRTUAL,
__unsigned_int__getNumLayers,
"",
"");
I_Method1(void, setVolumeTechnique, IN, osgVolume::VolumeTechnique *, VolumeTechnique,
@ -186,13 +196,16 @@ BEGIN_OBJECT_REFLECTOR(osgVolume::VolumeTile)
I_SimpleProperty(bool, Dirty,
__bool__getDirty,
__void__setDirty__bool);
I_IndexedProperty(osg::Image *, Image,
__osg_Image_P1__getImage__unsigned_int,
__void__setImage__unsigned_int__osg_Image_P1,
0);
I_SimpleProperty(osg::RefMatrix *, Locator,
__osg_RefMatrix_P1__getLocator,
__void__setLocator__osg_RefMatrix_P1);
I_ArrayProperty(osgVolume::Layer *, Layer,
__Layer_P1__getLayer__unsigned_int,
__void__setLayer__unsigned_int__Layer_P1,
__unsigned_int__getNumLayers,
__void__addLayer__Layer_P1,
0,
0);
I_SimpleProperty(osgVolume::Locator *, Locator,
__Locator_P1__getLocator,
__void__setLocator__Locator_P1);
I_SimpleProperty(const osgVolume::TileID &, TileID,
__C5_TileID_R1__getTileID,
__void__setTileID__C5_TileID_R1);