void VolumeRAM2GLConverter::update(std::shared_ptr<const VolumeRAM> volumeSrc,
std::shared_ptr<VolumeGL> volumeDst) const {
if (volumeSrc->getDimensions() != volumeDst->getDimensions()) {
volumeDst->setDimensions(volumeSrc->getDimensions());
}
volumeDst->getTexture()->upload(volumeSrc->getData());
}
void VolumeGL2CLGLConverter::update(std::shared_ptr<const VolumeGL> volumeSrc,
std::shared_ptr<VolumeCLGL> volumeDst) const {
// Do nothing since they are sharing data
if (volumeSrc->getDimensions() != volumeDst->getDimensions()) {
volumeDst->setDimensions(volumeSrc->getDimensions());
}
}
void LayerGL2RAMConverter::update(std::shared_ptr<const LayerGL> layerSrc,
std::shared_ptr<LayerRAM> layerDst) const {
if (layerSrc->getDimensions() != layerDst->getDimensions()) {
layerDst->setDimensions(layerSrc->getDimensions());
}
layerSrc->getTexture()->download(layerDst->getData());
}
void LayerRAM2CLConverter::update(std::shared_ptr<const LayerRAM> layerSrc,
std::shared_ptr<LayerCL> layerDst) const {
if (layerSrc->getDimensions() != layerDst->getDimensions()) {
layerDst->setDimensions(layerSrc->getDimensions());
}
layerDst->upload(layerSrc->getData());
}
void VolumeCLGL2RAMConverter::update(std::shared_ptr<const VolumeCLGL> volumeSrc,
std::shared_ptr<VolumeRAM> volumeDst) const {
if (volumeSrc->getDimensions() != volumeDst->getDimensions()) {
volumeDst->setDimensions(volumeSrc->getDimensions());
}
volumeSrc->getTexture()->download(volumeDst->getData());
if (volumeDst->hasHistograms()) volumeDst->getHistograms()->setValid(false);
}
void VolumeCLGL2CLConverter::update(std::shared_ptr<const VolumeCLGL> volumeSrc,
std::shared_ptr<VolumeCL> volumeDst) const {
if (volumeSrc->getDimensions() != volumeDst->getDimensions()) {
volumeDst->setDimensions(volumeSrc->getDimensions());
}
{
SyncCLGL glSync;
glSync.addToAquireGLObjectList(volumeSrc.get());
glSync.aquireAllObjects();
OpenCL::getPtr()->getQueue().enqueueCopyImage(volumeSrc->get(), volumeDst->get(),
glm::size3_t(0), glm::size3_t(0),
glm::size3_t(volumeSrc->getDimensions()));
}
}
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<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<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;
}
void MipmapMinValueRenderer::generateMipmapsMinValue( std::shared_ptr< Texture2D< TexUsage::Default, TexBind::RenderTarget_UnorderedAccess_ShaderResource, float > >& texture )
{
if ( !m_initialized )
throw std::exception( "MipmapMinValueRenderer::generateMipmapsMinValue - renderer not initialized." );
std::vector< std::shared_ptr< Texture2DSpecBind< TexBind::RenderTarget, float > > > renderTargetsF1;
std::vector< std::shared_ptr< Texture2DSpecBind< TexBind::RenderTarget, float2 > > > renderTargetsF2;
std::vector< std::shared_ptr< Texture2DSpecBind< TexBind::RenderTarget, float4 > > > renderTargetsF4;
std::vector< std::shared_ptr< Texture2DSpecBind< TexBind::RenderTarget, unsigned char > > > renderTargetsU1;
std::vector< std::shared_ptr< Texture2DSpecBind< TexBind::RenderTarget, uchar4 > > > renderTargetsU4;
renderTargetsF1.push_back( texture );
const int mipmapCount = texture->getMipMapCountOnGpu();
m_rendererCore.enableRasterizerState( *m_rasterizerState.Get() );
m_rendererCore.enableBlendState( *m_blendState.Get() );
m_rendererCore.enableRenderingShaders( m_generateMipmapMinValueVertexShader, m_generateMipmapMinValueFragmentShader );
for ( int srcMipmapLevel = 0; srcMipmapLevel + 1 < mipmapCount; ++srcMipmapLevel )
{
const int destMipmapLevel = srcMipmapLevel + 1;
m_rendererCore.setViewport( (float2)texture->getDimensions( destMipmapLevel ) );
m_rendererCore.enableRenderTargets( renderTargetsF1, renderTargetsF2, renderTargetsF4, renderTargetsU1, renderTargetsU4, nullptr, destMipmapLevel );
m_generateMipmapMinValueVertexShader->setParameters( *m_deviceContext.Get() );
m_generateMipmapMinValueFragmentShader->setParameters( *m_deviceContext.Get(), *texture, srcMipmapLevel );
m_rendererCore.draw( m_rectangleMesh );
}
m_generateMipmapMinValueFragmentShader->unsetParameters( *m_deviceContext.Get() );
m_rendererCore.disableRenderTargetViews();
}
Volume::Volume(std::shared_ptr<VolumeRepresentation> in)
: Data<VolumeRepresentation>(in->getDataFormat())
, StructuredGridEntity<3>(in->getDimensions())
, dataMap_(in->getDataFormat()) {
addRepresentation(in);
}
std::shared_ptr<Volume> curlVolume(std::shared_ptr<const Volume> volume) {
auto newVolume = std::make_shared<Volume>(volume->getDimensions(), DataVec3Float32::get());
newVolume->setModelMatrix(volume->getModelMatrix());
newVolume->setWorldMatrix(volume->getWorldMatrix());
newVolume->dataMap_ = volume->dataMap_;
auto m = newVolume->getCoordinateTransformer().getDataToWorldMatrix();
auto a = m * vec4(0, 0, 0, 1);
auto b = m * vec4(1.0f / vec3(volume->getDimensions() - size3_t(1)), 1);
auto spacing = b - a;
vec3 ox = vec3(spacing.x, 0, 0);
vec3 oy = vec3(0, spacing.y, 0);
vec3 oz = vec3(0, 0, spacing.z);
VolumeDoubleSampler<4> sampler(volume);
auto worldSpace = VolumeDoubleSampler<3>::Space::World;
util::IndexMapper3D index(volume->getDimensions());
auto data = static_cast<vec3*>(newVolume->getEditableRepresentation<VolumeRAM>()->getData());
float minV = std::numeric_limits<float>::max(), maxV = std::numeric_limits<float>::lowest();
std::function<void(const size3_t&)> func = [&](const size3_t& pos) {
vec3 world = (m * vec4(vec3(pos) / vec3(volume->getDimensions() - size3_t(1)), 1)).xyz();
auto Fx =
(sampler.sample(world + ox, worldSpace) - sampler.sample(world - ox, worldSpace)) /
(2.0 * spacing.x);
auto Fy =
(sampler.sample(world + oy, worldSpace) - sampler.sample(world - oy, worldSpace)) /
(2.0 * spacing.y);
auto Fz =
(sampler.sample(world + oz, worldSpace) - sampler.sample(world - oz, worldSpace)) /
(2.0 * spacing.z);
vec3 c;
c.x = static_cast<float>(Fy.z - Fz.y);
c.y = static_cast<float>(Fz.x - Fx.z);
c.z = static_cast<float>(Fx.y - Fy.x);
minV = std::min(minV, c.x);
minV = std::min(minV, c.y);
minV = std::min(minV, c.z);
maxV = std::max(maxV, c.x);
maxV = std::max(maxV, c.y);
maxV = std::max(maxV, c.z);
data[index(pos)] = c;
};
util::forEachVoxel(*volume->getRepresentation<VolumeRAM>(), func);
auto range = std::max(std::abs(minV), std::abs(maxV));
newVolume->dataMap_.dataRange = dvec2(-range, range);
newVolume->dataMap_.valueRange = dvec2(minV, maxV);
return newVolume;
}
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);
}
VolumeGL::VolumeGL(std::shared_ptr<Texture3D> tex, const DataFormatBase* format)
: VolumeRepresentation(format), dimensions_(tex->getDimensions()), volumeTexture_(tex) {}
std::shared_ptr<VolumeCLGL> VolumeGL2CLGLConverter::createFrom(
std::shared_ptr<const VolumeGL> volumeGL) const {
return std::make_shared<VolumeCLGL>(volumeGL->getDimensions(), volumeGL->getDataFormat(),
volumeGL->getTexture());
}
Layer::Layer(std::shared_ptr<LayerRepresentation> in)
: Data<LayerRepresentation>(in->getDataFormat())
, StructuredGridEntity<2>(in->getDimensions())
, layerType_(in->getLayerType()) {
addRepresentation(in);
}
