std::shared_ptr<BufferRAM> BufferGL2RAMConverter::createFrom(
std::shared_ptr<const BufferGL> src) const {
auto dst = createBufferRAM(src->getSize(), src->getDataFormat(), src->getBufferUsage(), src->getBufferTarget());
if (!dst)
throw ConverterException(std::string("Cannot convert format from GL to RAM: ") +
src->getDataFormat()->getString(),
IvwContext);
src->download(dst->getData());
return dst;
}
std::shared_ptr<VolumeRAM> VolumeGL2RAMConverter::createFrom(
std::shared_ptr<const VolumeGL> volumeGL) const {
auto volume = createVolumeRAM(volumeGL->getDimensions(), volumeGL->getDataFormat());
if (volume) {
volumeGL->getTexture()->download(volume->getData());
return volume;
} else {
LogError("Cannot convert format from GL to RAM:" << volumeGL->getDataFormat()->getString());
}
return nullptr;
}
std::shared_ptr<LayerRAM> LayerGL2RAMConverter::createFrom(
std::shared_ptr<const LayerGL> layerGL) const {
auto layerRAM =
createLayerRAM(layerGL->getDimensions(), layerGL->getLayerType(), layerGL->getDataFormat());
if (layerRAM) {
layerGL->getTexture()->download(layerRAM->getData());
return layerRAM;
} else {
LogError("Cannot convert format from GL to RAM:" << layerGL->getDataFormat()->getString());
}
return nullptr;
}
std::shared_ptr<VolumeGL> VolumeRAM2GLConverter::createFrom(
std::shared_ptr<const VolumeRAM> volumeRAM) const {
auto volume =
std::make_shared<VolumeGL>(volumeRAM->getDimensions(), volumeRAM->getDataFormat(), false);
volume->getTexture()->initialize(volumeRAM->getData());
return volume;
}
std::shared_ptr<LayerGL> LayerRAM2GLConverter::createFrom(
std::shared_ptr<const LayerRAM> layerRAM) const {
auto layerGL = std::make_shared<LayerGL>(layerRAM->getDimensions(), layerRAM->getLayerType(),
layerRAM->getDataFormat());
layerGL->getTexture()->initialize(layerRAM->getData());
return layerGL;
}
std::shared_ptr<LayerCL> LayerRAM2CLConverter::createFrom(
std::shared_ptr<const LayerRAM> layerRAM) const {
uvec2 dimensions = layerRAM->getDimensions();
const void* data = layerRAM->getData();
return std::make_shared<LayerCL>(dimensions, layerRAM->getLayerType(),
layerRAM->getDataFormat(), data);
}
std::shared_ptr<BufferGL> BufferRAM2GLConverter::createFrom(
std::shared_ptr<const BufferRAM> bufferRAM) const {
auto buffer = std::make_shared<BufferGL>(bufferRAM->getSize(), bufferRAM->getDataFormat(),
bufferRAM->getBufferUsage(), bufferRAM->getBufferTarget());
buffer->upload(bufferRAM->getData(), bufferRAM->getSize() * bufferRAM->getSizeOfElement());
return buffer;
}
std::shared_ptr<BufferRAM> BufferCLGL2RAMConverter::createFrom(
std::shared_ptr<const BufferCLGL> src) const {
size_t size = src->getSize();
auto destination = createBufferRAM(size, src->getDataFormat(), src->getBufferUsage());
if (destination) {
src->getBufferGL()->download(destination->getData());
} else {
LogError("Invalid conversion or not implemented");
}
return destination;
}
std::shared_ptr<BufferCL> BufferCLGL2CLConverter::createFrom(
std::shared_ptr<const BufferCLGL> src) const {
size_t size = src->getSize();
auto destination =
std::make_shared<BufferCL>(size, src->getDataFormat(), src->getBufferUsage());
{
SyncCLGL glSync;
glSync.addToAquireGLObjectList(src.get());
glSync.aquireAllObjects();
OpenCL::getPtr()->getQueue().enqueueCopyBuffer(src->get(), destination->get(), 0, 0,
src->getSize() * src->getSizeOfElement());
}
return destination;
}
std::shared_ptr<VolumeRAM> VolumeCL2RAMConverter::createFrom(
std::shared_ptr<const VolumeCL> volumeCL) const {
size3_t dimensions = volumeCL->getDimensions();
auto destination = createVolumeRAM(dimensions, volumeCL->getDataFormat());
if (destination) {
volumeCL->download(destination->getData());
// const cl::CommandQueue& queue = OpenCL::getInstance()->getQueue();
// queue.enqueueReadImage(volumeCL->getVolume(), true, glm::size3_t(0),
// glm::size3_t(dimension), 0, 0, volumeRAM->getData());
}
return destination;
}
std::shared_ptr<VolumeRAM> VolumeCLGL2RAMConverter::createFrom(
std::shared_ptr<const VolumeCLGL> volumeCLGL) const {
const size3_t dimensions{volumeCLGL->getDimensions()};
auto destination = createVolumeRAM(dimensions, volumeCLGL->getDataFormat());
if (destination) {
volumeCLGL->getTexture()->download(destination->getData());
// const cl::CommandQueue& queue = OpenCL::getPtr()->getQueue();
// queue.enqueueReadVolume(volumeCL->get(), true, glm::size3_t(0), glm::size3_t(dimensions,
// 1), 0, 0, volumeRAM->getData());
} else {
LogError("Invalid conversion or not implemented");
}
return destination;
}
std::shared_ptr<VolumeCL> VolumeCLGL2CLConverter::createFrom(
std::shared_ptr<const VolumeCLGL> volumeCLGL) const {
#ifdef IVW_DEBUG
LogWarn("Performance warning: Use shared CLGL representation instead of CL ");
#endif
const size3_t dimensions{volumeCLGL->getDimensions()};
auto destination = std::make_shared<VolumeCL>(dimensions, volumeCLGL->getDataFormat());
{
SyncCLGL glSync;
glSync.addToAquireGLObjectList(volumeCLGL.get());
glSync.aquireAllObjects();
OpenCL::getPtr()->getQueue().enqueueCopyImage(volumeCLGL->get(), destination->get(),
glm::size3_t(0), glm::size3_t(0),
glm::size3_t(dimensions));
}
return destination;
}
std::shared_ptr<LayerRAM> LayerCL2RAMConverter::createFrom(
std::shared_ptr<const LayerCL> layerCL) const {
uvec2 dimensions = layerCL->getDimensions();
auto destination =
createLayerRAM(dimensions, layerCL->getLayerType(), layerCL->getDataFormat());
if (destination) {
layerCL->download(destination->getData());
// const cl::CommandQueue& queue = OpenCL::getInstance()->getQueue();
// queue.enqueueReadLayer(layerCL->getLayer(), true, glm::size3_t(0),
// glm::size3_t(dimensions,
// 1), 0, 0, layerRAM->getData());
} else {
LogError("Invalid conversion or not implemented");
}
return destination;
}
Layer::Layer(std::shared_ptr<LayerRepresentation> in)
: Data<LayerRepresentation>(in->getDataFormat())
, StructuredGridEntity<2>(in->getDimensions())
, layerType_(in->getLayerType()) {
addRepresentation(in);
}
std::shared_ptr<VolumeCLGL> VolumeGL2CLGLConverter::createFrom(
std::shared_ptr<const VolumeGL> volumeGL) const {
return std::make_shared<VolumeCLGL>(volumeGL->getDimensions(), volumeGL->getDataFormat(),
volumeGL->getTexture());
}
std::shared_ptr<Volume> util::volumeLaplacian(std::shared_ptr<const Volume> volume,
VolumeLaplacianPostProcessing postProcessing,
double scale) {
util::detail::VolumeLaplacianDispatcher disp;
return volume->getDataFormat()->dispatch(disp, volume, postProcessing, scale);
}
std::shared_ptr<VolumeGL> VolumeCLGL2GLConverter::createFrom(
std::shared_ptr<const VolumeCLGL> src) const {
return std::make_shared<VolumeGL>(src->getTexture(), src->getDataFormat());
}
std::shared_ptr<Mesh> MarchingTetrahedron::apply(std::shared_ptr<const Volume> volume, const double &iso,
const vec4 &color, std::function<void(float)> progressCallback) {
detail::MarchingTetrahedronDispatcher disp;
return volume->getDataFormat()->dispatch(disp, volume, iso, color, progressCallback);
}
std::shared_ptr<VolumeCL> VolumeRAM2CLConverter::createFrom(
std::shared_ptr<const VolumeRAM> volumeRAM) const {
size3_t dimensions = volumeRAM->getDimensions();
const void* data = volumeRAM->getData();
return std::make_shared<VolumeCL>(dimensions, volumeRAM->getDataFormat(), data);
}
std::shared_ptr<BufferCL> BufferRAM2CLConverter::createFrom(
std::shared_ptr<const BufferRAM> bufferRAM) const {
return std::make_shared<BufferCL>(bufferRAM->getSize(), bufferRAM->getDataFormat(),
bufferRAM->getBufferUsage(), bufferRAM->getData());
}
std::shared_ptr<BufferRAM> BufferCL2RAMConverter::createFrom(
std::shared_ptr<const BufferCL> src) const {
auto dst = createBufferRAM(src->getSize(), src->getDataFormat(), src->getBufferUsage());
src->download(dst->getData());
return dst;
}
Volume::Volume(std::shared_ptr<VolumeRepresentation> in)
: Data<VolumeRepresentation>(in->getDataFormat())
, StructuredGridEntity<3>(in->getDimensions())
, dataMap_(in->getDataFormat()) {
addRepresentation(in);
}
std::shared_ptr<BufferCLGL> BufferGL2CLGLConverter::createFrom(
std::shared_ptr<const BufferGL> src) const {
return std::make_shared<BufferCLGL>(src->getSize(), src->getDataFormat(), src->getBufferUsage(),
src->getBufferObject());
}
