void SharedDataVolume::mapData(const std::string& filename)
{
_cacheFileDescriptor = open(filename.c_str(), O_RDONLY);
if (_cacheFileDescriptor == NO_DESCRIPTOR)
throw std::runtime_error("Failed to open volume file " + filename);
struct stat sb;
if (::fstat(_cacheFileDescriptor, &sb) == NO_DESCRIPTOR)
{
::close(_cacheFileDescriptor);
_cacheFileDescriptor = NO_DESCRIPTOR;
throw std::runtime_error("Failed to open volume file " + filename);
}
_size = sb.st_size;
_memoryMapPtr =
::mmap(0, _size, PROT_READ, MAP_PRIVATE, _cacheFileDescriptor, 0);
if (_memoryMapPtr == MAP_FAILED)
{
_memoryMapPtr = nullptr;
::close(_cacheFileDescriptor);
_cacheFileDescriptor = NO_DESCRIPTOR;
throw std::runtime_error("Failed to open volume file " + filename);
}
setVoxels(_memoryMapPtr);
}
bool EntityScriptingInterface::setVoxelsInCuboid(QUuid entityID, const glm::vec3& lowPosition,
const glm::vec3& cuboidSize, int value) {
return setVoxels(entityID, [lowPosition, cuboidSize, value](PolyVoxEntityItem& polyVoxEntity) {
return polyVoxEntity.setCuboid(lowPosition, cuboidSize, value);
});
}
bool EntityScriptingInterface::setAllVoxels(QUuid entityID, int value) {
return setVoxels(entityID, [value](PolyVoxEntityItem& polyVoxEntity) {
return polyVoxEntity.setAll(value);
});
}
bool EntityScriptingInterface::setVoxel(QUuid entityID, const glm::vec3& position, int value) {
return setVoxels(entityID, [position, value](PolyVoxEntityItem& polyVoxEntity) {
return polyVoxEntity.setVoxelInVolume(position, value);
});
}
bool EntityScriptingInterface::setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value) {
return setVoxels(entityID, [center, radius, value](PolyVoxEntityItem& polyVoxEntity) {
return polyVoxEntity.setSphere(center, radius, value);
});
}
/*
* resize
*/
void Volume::resize(void) {
int w = 0;
int h = 0;
int d = 0;
int start_width = 0;
int start_height = 0;
int start_depth = 0;
if (!isPowerOfTwo(getWidth())) {
w = nextPowerOfTwo(getWidth());
start_width = (w - getWidth()) / 2;
}
if (!isPowerOfTwo(getHeight())) {
h = nextPowerOfTwo(getHeight());
start_height = (h - getHeight()) / 2;
}
if (!isPowerOfTwo(getDepth())) {
d = nextPowerOfTwo(getDepth());
start_depth = (d - getDepth()) / 2;
}
if ((w != 0) || (h != 0) || (d != 0)) {
if (w == 0) {
w = getWidth();
}
if (h == 0) {
h = getHeight();
}
if (d == 0) {
d = getDepth();
}
int _size[3];
_size[0] = w;
_size[1] = h;
_size[2] = d;
int _borderSize = 0;
int _numberOfVoxels = (_size[0] + 2 * _borderSize) * (_size[1] + 2 * _borderSize) * (_size[2] + 2 * _borderSize);
unsigned char* _voxelsBase = new unsigned char[_numberOfVoxels];
for (int k = 0; k < getDepth(); k++) {
for (int j = 0; j < getHeight(); j++) {
for (int i = 0; i < getWidth(); i++) {
_voxelsBase[((start_depth + k) * (w * h)) + ((start_height + j) * w) + (start_width + i)] = voxels[(k
* (getWidth() * getHeight())) + (j * getWidth()) + i];
}
}
}
Point _origin = Point::origin;
Size _extent;
Point _center;
for (int i = 0; i < 3; ++i) {
_extent[i] = Scalar(_size[i]) * scale[i];
_center[i] = _origin[i] + _extent[i] * Scalar(0.5);
}
unsigned char* _voxels = _voxelsBase + borderSize;
int _increments[3];
_increments[2] = 1;
for (int i = 2; i > 0; --i) {
_increments[i - 1] = _increments[i] * (_size[i] + 2 * _borderSize);
_voxels += _borderSize * _increments[i - 1];
}
setNumberOfVoxels(_numberOfVoxels);
setSize(_size);
setOrigin(_origin);
setExtent(_extent);
setCenter(_center);
delete byteVoxelsBase;
setByteVoxelsBase(_voxelsBase);
setBorderSize(_borderSize);
setIncrements(_increments);
setVoxels(_voxels);
}
} // end resize()
void SharedDataVolume::mapData(uint8_ts&& buffer)
{
_memoryBuffer = std::move(buffer);
setVoxels(_memoryBuffer.data());
}
void SharedDataVolume::mapData(const uint8_ts& buffer)
{
_memoryBuffer.insert(_memoryBuffer.begin(), buffer.begin(), buffer.end());
setVoxels(_memoryBuffer.data());
}
