void VolumeRaycasterCL::setDefaultBackgroundColor(const vec4 color) {
LayerRAM* defaultBGRAM =
defaultBackground_.getEditableRepresentation<LayerRAM>();
unsigned char* data = static_cast<unsigned char*>(defaultBGRAM->getData());
for (int i = 0; i < 4; ++i) {
data[i] = static_cast<unsigned char>(glm::floor(color[i] * 255.f + 0.5f));
}
}
void LayerDisk2RAMConverter::update(const DataRepresentation* source,
DataRepresentation* destination) {
const LayerDisk* layerSrc = static_cast<const LayerDisk*>(source);
LayerRAM* layerDst = static_cast<LayerRAM*>(destination);
if (layerSrc->getDimensions() != layerDst->getDimensions())
layerDst->setDimensions(layerSrc->getDimensions());
layerSrc->readDataInto(layerDst->getData());
}
void HeightFieldMapper::process() {
if (!inport_.isReady()) return;
auto srcImg = inport_.getData();
if (!srcImg) {
LogWarn("No valid input image given");
return;
}
// check the number of channels
const DataFormatBase *format = srcImg->getDataFormat();
std::size_t numInputChannels = format->getComponents();
size2_t dim = srcImg->getDimensions();
Image *outImg = nullptr;
// check format of output image
if (!outImg || (outImg->getDataFormat()->getId() != DataFormatId::Float32)) {
// replace with new floating point image
Image *img = new Image(dim, DataFloat32::get());
outport_.setData(img);
outImg = img;
} else if (outImg->getDimensions() != dim) {
// adjust dimensions of output image
outImg->setDimensions(dim);
}
LayerRAM *dstLayer = outImg->getColorLayer(0)->getEditableRepresentation<LayerRAM>();
float *data = static_cast<float *>(dstLayer->getData());
// convert input image to float image
const LayerRAM *srcLayer = srcImg->getColorLayer(0)->getRepresentation<LayerRAM>();
// special case: input image is already FLOAT32 with 1 channel
if ((numInputChannels == 1) && (format->getId() == DataFormatId::Float32)) {
const float *srcData = static_cast<const float *>(srcLayer->getData());
std::copy(srcData, srcData + dim.x * dim.y, data);
} else {
switch (numInputChannels) {
case 2:
for (unsigned int y = 0; y < dim.y; ++y) {
for (unsigned int x = 0; x < dim.x; ++x) {
data[y * dim.x + x] =
static_cast<float>(srcLayer->getValueAsVec2Double(glm::uvec2(x, y)).r);
}
}
break;
case 3:
for (unsigned int y = 0; y < dim.y; ++y) {
for (unsigned int x = 0; x < dim.x; ++x) {
data[y * dim.x + x] =
static_cast<float>(srcLayer->getValueAsVec3Double(glm::uvec2(x, y)).r);
}
}
break;
case 4:
for (unsigned int y = 0; y < dim.y; ++y) {
for (unsigned int x = 0; x < dim.x; ++x) {
data[y * dim.x + x] =
static_cast<float>(srcLayer->getValueAsVec4Double(glm::uvec2(x, y)).r);
}
}
break;
case 1:
default:
for (unsigned int y = 0; y < dim.y; ++y) {
for (unsigned int x = 0; x < dim.x; ++x) {
data[y * dim.x + x] =
static_cast<float>(srcLayer->getValueAsSingleDouble(glm::uvec2(x, y)));
}
}
break;
}
}
// rescale data set
std::size_t numValues = dim.x * dim.y;
// determine min/max values
float minVal = *std::min_element(data, data + numValues);
float maxVal = *std::max_element(data, data + numValues);
switch (scalingModeProp_.get()) {
case HeightFieldScaling::SeaLevel: {
// scale heightfield based on sea level and min/max height
float sealevel = seaLevel_.get();
float aboveSea = maxVal - sealevel;
float belowSea = minVal - sealevel;
float factor = maxHeight_.get() / std::max(aboveSea, std::abs(belowSea));
for (std::size_t i = 0; i < numValues; ++i) {
data[i] = (data[i] - sealevel) * factor;
}
} break;
case HeightFieldScaling::DataRange: {
// scale data to [heightRange_.min : heightRange_.max]
glm::vec2 range(heightRange_.get());
float factor = (range.y - range.x) / (maxVal - minVal);
for (std::size_t i = 0; i < numValues; ++i) {
data[i] = (data[i] - minVal) * factor + range.x;
}
} break;
case HeightFieldScaling::FixedRange:
default: {
// scale data to [0:1] range
float delta = 1.0f / (maxVal - minVal);
for (std::size_t i = 0; i < numValues; ++i) {
data[i] = (data[i] - minVal) * delta;
}
} break;
}
}
