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()); }