size2_t Layer::getDimensions() const {
if (hasRepresentations() && lastValidRepresentation_) {
size2_t dim = lastValidRepresentation_->getDimensions();
if (dim != size2_t(0)) return dim;
}
return StructuredGridEntity<2>::getDimensions();
}
void RunningImageMeanAndStandardDeviationCL::computeMeanAndStandardDeviation(const uvec2& nSamples, const LayerCLBase* samples, int iteration, const LayerCLBase* prevMean, LayerCLBase* nextMean, const LayerCLBase* prevStandardDeviation, LayerCLBase* nextStandardDeviation, const size2_t& workGroupSize, const VECTOR_CLASS<cl::Event> *waitForEvents, cl::Event *event) {
size_t workGroupSizeX = static_cast<size_t>(workGroupSize.x); size_t workGroupSizeY = static_cast<size_t>(workGroupSize.y);
size_t globalWorkSizeX = getGlobalWorkGroupSize(nSamples.x, workGroupSizeX);
size_t globalWorkSizeY = getGlobalWorkGroupSize(nSamples.y, workGroupSizeY);
int argIndex = 0;
kernel_->setArg(argIndex++, nSamples);
kernel_->setArg(argIndex++, *samples);
kernel_->setArg(argIndex++, static_cast<float>(iteration+1));
kernel_->setArg(argIndex++, *prevMean);
kernel_->setArg(argIndex++, *nextMean);
kernel_->setArg(argIndex++, *prevStandardDeviation);
kernel_->setArg(argIndex++, *nextStandardDeviation);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(*kernel_, cl::NullRange, size2_t(globalWorkSizeX, globalWorkSizeY) , size2_t(workGroupSizeX, workGroupSizeY), waitForEvents, event);
}
void LayerCLGL::notifyAfterTextureInitialization() {
const auto it = LayerCLGL::clImageSharingMap_.find(texture_);
if (it != LayerCLGL::clImageSharingMap_.end()) {
clImage_ = std::static_pointer_cast<cl::Image2DGL>(it->second);
} else {
if (glm::all(glm::greaterThan(texture_->getDimensions(), size2_t(0)))) {
try {
clImage_ = std::make_shared<cl::Image2DGL>(OpenCL::getPtr()->getContext(),
CL_MEM_READ_WRITE, GL_TEXTURE_2D, 0,
texture_->getID());
LayerCLGL::clImageSharingMap_.insert(TextureCLImageSharingPair(texture_, clImage_));
} catch (cl::Error& err) {
LogOpenCLError(err.err());
throw err;
}
}
}
}
VolumeRaycasterCL::VolumeRaycasterCL()
: KernelOwner()
, workGroupSize_(size2_t(8, 8))
, useGLSharing_(true)
, outputOffset_(0)
, outputSize_(1)
, camera_(nullptr)
, samplingRate_(2.f)
, background_(nullptr)
, defaultBackground_(uvec2(1), DataVec4UInt8::get())
, lightStruct_(sizeof(utilcl::LightParameters), DataUInt8::get(), BufferUsage::STATIC, nullptr,
CL_MEM_READ_ONLY)
, kernel_(nullptr) {
light_.ambientColor = vec4(1.f);
light_.diffuseColor = vec4(1.f);
light_.specularColor = vec4(1.f);
light_.specularExponent = 110.f;
light_.position = vec4(0.7f);
light_.shadingMode = ShadingMode::Phong;
compileKernel();
}
size2_t getGlobalWorkGroupSize(size2_t nItems, glm::size2_t localWorkGroupSize)
{
return localWorkGroupSize*size2_t(glm::ceil(vec2(nItems) / vec2(localWorkGroupSize)));
}
/*
Algorithm as describe by:
http://devmag.org.za/2009/05/03/poisson-disk-sampling/
*/
void NoiseProcessor::poissonDisk(Image *img) {
float minDist = size_.get().x;
minDist /= poissonDotsAlongX_; //min pixel distance between samples
auto minDist2 = minDist*minDist;
size2_t gridSize = size2_t(1)+ size2_t(vec2(size_.get()) * (1.0f / minDist));
auto gridImg = util::make_unique<Image>(gridSize, DataVec2INT32::get());
auto grid = gridImg->getColorLayer()->getEditableRepresentation<LayerRAM>();
auto imgData = static_cast<float*>(img->getColorLayer()->getEditableRepresentation<LayerRAM>()->getData());
auto gridData = static_cast<glm::i32vec2*>(grid->getData());
util::IndexMapper2D imgIndex(size_.get());
util::IndexMapper2D gridIndex(gridSize);
for (size_t i = 0; i < gridSize.x*gridSize.y; i++) {
gridData[i] = glm::i32vec2(-2 * minDist);
}
std::uniform_int_distribution<int> rx(0, size_.get().x);
std::uniform_int_distribution<int> ry(0, size_.get().y);
std::uniform_real_distribution<float> rand(0, 1);
std::vector<glm::i32vec2> processList;
std::vector<glm::i32vec2> samplePoints;
auto firstPoint = glm::i32vec2(rx(mt_), ry(mt_));
processList.push_back(firstPoint);
samplePoints.push_back(firstPoint);
auto toGrid = [minDist](glm::i32vec2 p)->glm::i32vec2 { return glm::i32vec2(vec2(p)/minDist); };
gridData[gridIndex(toGrid(firstPoint))] = firstPoint;
int someNumber = 30;
while (processList.size() != 0 && samplePoints.size() < static_cast<size_t>(poissonMaxPoints_)) {
std::uniform_int_distribution<size_t> ri(0, processList.size()-1);
auto i = ri(mt_);
auto p = processList[i];
processList.erase(processList.begin() + i);
for (int j = 0; j < someNumber; j++) {
auto newPoint = generateRandomPointAround(p, minDist, rand, mt_);
if (newPoint.x < 0) continue;
if (newPoint.y < 0) continue;
if (newPoint.x >= size_.get().x) continue;
if (newPoint.y >= size_.get().y) continue;
auto newGridPoint = toGrid(newPoint);
bool neighbourhood = false;
int startX = std::max(0, newGridPoint.x - 2);
int startY = std::max(0, newGridPoint.y - 2);
int endX = std::min(static_cast<int>(gridSize.x) - 1, newGridPoint.x + 2);
int endY = std::min(static_cast<int>(gridSize.y) - 1, newGridPoint.y + 2);
for (int x = startX; x <= endX && !neighbourhood; x++) {
for (int y = startY; y <= endY && !neighbourhood; y++) {
auto p2 = gridData[gridIndex(glm::i32vec2(x, y))];
auto dist = glm::distance2(vec2(newPoint), vec2(p2));
if (dist < minDist2) {
neighbourhood = true;
}
}
}//*/
if (!neighbourhood) {
processList.push_back(newPoint);
samplePoints.push_back(newPoint);
auto idx = gridIndex(newGridPoint);
gridData[idx] = newPoint;
imgData[imgIndex(newPoint)] = 1;
}
}
}
}
