polyvox_shared_ptr< VolumeType< VoxelType > > PolyVox::loadVolumeRaw ( std::istream & stream,
VolumeSerializationProgressListener * progressListener = 0
)

void loadraw(const char *filename){

int width = 256;
int height = 256;
int depth = 256;
//Create a volume

LargeVolume<MaterialDensityPair44> volData(&load, &unload, 256);
FILE *fp = fopen(filename, "rb");
if (!fp){
std::cout<<"raw file missed! "<<"\n";
return 0;
}

float *data = new float [width*height*depth];
fread(data, sizeof(float), width*height*depth, fp);
fclose(fp);

//Clear volume to zeros.
//FIXME - Add function to PolyVox for this.
for(unsigned int z = 0; z < volData.getDepth(); ++z)
{
for(unsigned int y = 0; y < volData.getHeight(); ++y)
{
for(unsigned int x = 0; x < volData.getWidth(); ++x)
{
float voxelVal;

MaterialDensityPair44 voxel;
if(voxelVal > 0.0f)
{
voxel.setDensity(MaterialDensityPair44::getMaxDensity());
voxel.setMaterial(1);
}
else
{
voxel.setDensity(MaterialDensityPair44::getMinDensity());
voxel.setMaterial(0);
}
volData.setVoxelAt(x,y,z,voxel);
}
}
cout << z << endl;
}

SimpleVolume<MaterialDensityPair88> Volume(const PolyVox::Region& reg);
//polyvox_shared_ptr< VolumeType > volume(new LargeVolume<VolumeType::VoxelType>(width, height, depth));
//polyvox_shared_ptr< volData > loadVolumeRaw(fp);
polyvox_shared_ptr< Volume > loadVolumeRaw(fp);
//loadVolumeRaw(fp);

}

Actually that function has been deprecated in PolyVox... if you run in debug mode you should find you hit an assert() which prevents it running. Also, when it refers to 'raw' data it really just means that it dumps the data to disk without any real formatting, and does not neessarily correspond to any defined .raw format (and I don't think there is a .raw format defined anywhere).

Create a volume of the correct size and type, open the file, and just iterate over each voxel reading one at a time with fread() and writing it to the volume with setVoxelAt(). If you look at the implementation of 'loadVolumeRaw()' then it will still give you an idea about how the code can be structured.

void load( const ConstVolumeProxy<MaterialDensityPair44>& volume, const PolyVox::Region& reg)
{
Vector3DFloat v3dVolCenter;

ifstream stream;
filebuf * fb;

fb =stream.rdbuf();
fb->open ("data.raw",ios::in);

if ( fb->is_open() )

cout << "file data.raw is open!.\n";
else
cout << "file data.raw is not open.\n";



//Read volume dimensions
uint8_t volumeWidthPower = 0;
uint8_t volumeHeightPower = 0;
uint8_t volumeDepthPower = 0;
stream.read(reinterpret_cast<char*>(&volumeWidthPower), sizeof(volumeWidthPower));
stream.read(reinterpret_cast<char*>(&volumeHeightPower), sizeof(volumeHeightPower));
stream.read(reinterpret_cast<char*>(&volumeDepthPower), sizeof(volumeDepthPower));

uint16_t volumeWidth = 0x0001 << volumeWidthPower;
uint16_t volumeHeight = 0x0001 << volumeHeightPower;
uint16_t volumeDepth = 0x0001 << volumeDepthPower;

//Read data
bool firstTime = true;
uint32_t runLength = 0;
//VolumeType::VoxelType value;
MaterialDensityPair44 voxel;
//stream.read(reinterpret_cast<char*>(&value), sizeof(value));
stream.read(reinterpret_cast<char*>(&voxel), sizeof(voxel));
stream.read(reinterpret_cast<char*>(&runLength), sizeof(runLength));
/*
int32_t wdt = reg.width();
int32_t hgt = reg.height();
int32_t dpt = reg.depth();
wdt = volumeWidth;
cout << "volumeWidth:" << wdt <<endl;
hgt = volumeHeight;
cout << "volumeHeight:" << hgt <<endl;
dpt = volumeDepth;
cout << "volumeDepth:" << dpt <<endl;
*/
for(int x = reg.getLowerCorner().getX() ; x <= reg.getUpperCorner().getX(); x++)
//for(int x = 0; x <= volumeWidth; x++)
{
for(int y = reg.getLowerCorner().getY(); y <= reg.getUpperCorner().getY(); y++)
//for(int y = 0; y <= volumeHeight; y++)
{

for(int z = reg.getLowerCorner().getZ(); z <= reg.getUpperCorner().getZ(); z++)
//for(int z = 0; z <= volumeDepth; z++)
{


if(runLength != 0)
{
voxel.setMaterial(0);
voxel.setDensity(MaterialDensityPair44::getMinDensity());
volume.setVoxelAt(x,y,z, voxel);
runLength--;
}
else
{
//stream.read(reinterpret_cast<char*>(&value), sizeof(value));
stream.read(reinterpret_cast<char*>(& voxel), sizeof( voxel));
stream.read(reinterpret_cast<char*>(&runLength), sizeof(runLength));
voxel.setMaterial(245);
voxel.setDensity(MaterialDensityPair44::getMaxDensity());
volume.setVoxelAt(x,y,z, voxel);
runLength--;
}
volume.setVoxelAt(x, y, z, voxel);
}
}
}
//fclose(fb);

fb->close();
}

LargeVolume<MaterialDensityPair44> volData(&load, &unload, 256);

volData.setMaxNumberOfBlocksInMemory(4096);
volData.setMaxNumberOfUncompressedBlocks(64);

load() refer to:

sure my approach isn't correct, not sure if make sense create a region without get the dimensions of the raw file , i tried but reg.height() is deprecated and don't know another options, what can you suggest me to do?

// this in load()
ofFloatImage img;

img.loadImage("nyc-small.exr");

float perlinVal = img.getColor(x, y).getBrightness();

perlinVal += 1.0f;
perlinVal *= 0.5f;
perlinVal *= 255;