IntensityMap GaussianBlur::calculate(IntensityMap &input, double radius, bool tileable) {
IntensityMap result = IntensityMap(input.getWidth(), input.getHeight());
gaussBlur(input, result, radius, tileable);
return result;
}
//the displacement map is generated with the specularmapGenerator (similar controls and output needed)
void MainWindow::calcDisplace() {
if(input.isNull())
return;
//color channel mode
IntensityMap::Mode mode = IntensityMap::AVERAGE;
if(ui->comboBox_mode_displace->currentIndex() == 0)
mode = IntensityMap::AVERAGE;
else if(ui->comboBox_mode_displace->currentIndex() == 1)
mode = IntensityMap::MAX;
//color channel multipliers to use
double redMultiplier = ui->doubleSpinBox_displace_redMul->value();
double greenMultiplier = ui->doubleSpinBox_displace_greenMul->value();
double blueMultiplier = ui->doubleSpinBox_displace_blueMul->value();
double alphaMultiplier = 0.0;
double scale = ui->doubleSpinBox_displace_scale->value();
double contrast = ui->doubleSpinBox_displace_contrast->value();
//setup generator and calculate map
SpecularmapGenerator specularmapGenerator(mode, redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier);
displacementmap = specularmapGenerator.calculateSpecmap(input, scale, contrast);
if(ui->checkBox_displace_blur->isChecked()) {
int radius = ui->spinBox_displace_blurRadius->value();
bool tileable = ui->checkBox_displace_blur_tileable->isChecked();
IntensityMap inputMap(displacementmap, IntensityMap::AVERAGE);
BoxBlur filter;
IntensityMap outputMap = filter.calculate(inputMap, radius, tileable);
displacementmap = outputMap.convertToQImage();
}
}
void GaussianBlur::boxBlur(IntensityMap &input, IntensityMap &result, double radius, bool tileable) {
for(size_t i = 0; i < input.getWidth() * input.getHeight(); i++) {
result.setValue(i, input.at(i));
}
boxBlurH(result, input, radius, tileable);
boxBlurT(input, result, radius, tileable);
}
//displays single color channels of the image (handled by an intensitymap)
void MainWindow::displayChannelIntensity() {
if(input.isNull())
return;
IntensityMap temp;
if(ui->radioButton_displayRed->isChecked())
temp = IntensityMap(input, IntensityMap::AVERAGE, true, false, false, false);
else if(ui->radioButton_displayGreen->isChecked())
temp = IntensityMap(input, IntensityMap::AVERAGE, false, true, false, false);
else if(ui->radioButton_displayBlue->isChecked())
temp = IntensityMap(input, IntensityMap::AVERAGE, false, false, true, false);
else
temp = IntensityMap(input, IntensityMap::AVERAGE, false, false, false, true);
this->channelIntensity = temp.convertToQImage();
preview(0);
}
void GaussianBlur::boxBlurT(IntensityMap &input, IntensityMap &result, double radius, bool tileable) {
const int width = input.getWidth();
const int height = input.getHeight();
#pragma omp parallel for // OpenMP
for(int i = 0; i < height; i++) {
for(int j = 0; j < width; j++) {
double val = 0.0;
for(int iy = i - radius; iy < i + radius + 1; iy++) {
const int y = handleEdges(iy, height, tileable);
val += input.at(j, y);
}
result.setValue(j, i, val / (radius + radius + 1));
}
}
}
void add_pair_to_appropriate_place(IntensityMap & small_piece,IntensityMap & accumulator,vec3<int> r,vector<bool> periodic) {
vec3<int> piece_size=small_piece.size();
vec3<int> acc_size=accumulator.size();
r=r-(piece_size/2);
vec3<int> borders;
for(int i=0; i<3; i++)
{
borders[i]=0;//(acc_size[i]>1);
}
vec3<int> llimits, ulimits;
for(int i=0; i<3; ++i)
{
llimits[i]=r[i];
ulimits[i]=r[i]+piece_size[i]+borders[i];
if(!periodic.at(i))
{
llimits[i]=max(0,llimits[i]);
ulimits[i]=min(acc_size[i],ulimits[i]);
}
}
for(int i=llimits[0];i<ulimits[0]; i++)
{
int is=(i-r[0])%piece_size[0];
for(int j=llimits[1];j<ulimits[1]; j++)
{
int js=(j-r[1])%piece_size[1];
for(int k=llimits[2];k<ulimits[2]; k++)
{
int ks=(k-r[2])%piece_size[2];
accumulator.at((i+acc_size[0])%acc_size[0],
(j+acc_size[1])%acc_size[1],
(k+acc_size[2])%acc_size[2])+=small_piece.at(is,js,ks);
}
}
}
}
osg::Image* readIntensityImage(osgDB::Input &fr, bool &itrAdvanced)
{
if (fr.matchSequence("intensityMap {"))
{
int entry = fr[0].getNoNestedBrackets();
fr += 2;
typedef std::map<float, float> IntensityMap;
IntensityMap intensityMap;
while (!fr.eof() && fr[0].getNoNestedBrackets() > entry)
{
float position, intensity;
if (fr.read(position, intensity))
{
intensityMap[position] = intensity;
}
else
{
++fr;
}
}
++fr;
itrAdvanced = true;
if (!intensityMap.empty())
{
unsigned int numPixels = 256;
osg::Image *image = new osg::Image;
image->allocateImage(1, numPixels, 1, GL_LUMINANCE, GL_FLOAT);
float intensityMultiplier = 0.01f;
float *ptr = reinterpret_cast<float*>(image->data());
for (unsigned int i = 0; i < numPixels; ++i)
{
float position = (1.0f - float(i) / float(numPixels - 1)) * 180.0f;
float intensity = 1.0f;
if (position <= intensityMap.begin()->first)
{
intensity = intensityMap.begin()->second * intensityMultiplier;
}
else if (position >= intensityMap.rbegin()->first)
{
intensity = intensityMap.rbegin()->second * intensityMultiplier;
}
else
{
IntensityMap::iterator above_itr = intensityMap.lower_bound(position);
if (above_itr != intensityMap.begin())
{
IntensityMap::iterator below_itr = above_itr;
--below_itr;
float r = (position - below_itr->first) / (above_itr->first - below_itr->first);
intensity = (below_itr->second + (above_itr->second - below_itr->second) * r) * intensityMultiplier;
}
else
{
intensity = above_itr->second * intensityMultiplier;
}
}
*ptr++ = intensity;
}
return image;
}
}
return 0;
}
