void HighPassFilter::applyLowPass(const Image2DPtr &image)
{
// Guassian convolution can be separated in two 1D convolution
// because of properties of the 2D Gaussian function.
Image2DPtr temp = Image2D::CreateZeroImagePtr(image->Width(), image->Height());
size_t hKernelMid = _hWindowSize/2;
for(size_t i=0; i<_hWindowSize; ++i) {
const num_t kernelValue = _hKernel[i];
const size_t
xStart = (i >= hKernelMid) ? 0 : (hKernelMid-i),
xEnd = (i <= hKernelMid) ? image->Width() : image->Width()-i+hKernelMid;
for(unsigned y=0;y<image->Height();++y) {
for(unsigned x=xStart;x<xEnd;++x)
temp->AddValue(x, y, image->Value(x+i-hKernelMid, y)*kernelValue);
}
}
image->SetAll(0.0);
size_t vKernelMid = _vWindowSize/2;
for(size_t i=0; i<_vWindowSize; ++i) {
const num_t kernelValue = _vKernel[i];
const size_t
yStart = (i >= vKernelMid) ? 0 : (vKernelMid-i),
yEnd = (i <= vKernelMid) ? image->Height() : image->Height()-i+vKernelMid;
for(unsigned y=yStart;y<yEnd;++y) {
for(unsigned x=0;x<image->Width();++x)
image->AddValue(x, y, temp->Value(x, y+i-vKernelMid)*kernelValue);
}
}
}
void TimeConvolutionAction::PerformFFTSincOperation(ArtifactSet &artifacts, Image2DPtr real, Image2DPtr imag) const
{
fftw_complex
*fftIn = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * real->Width()),
*fftOut = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * real->Width());
// FFTW plan routines are not thread safe, so lock.
boost::mutex::scoped_lock lock(artifacts.IOMutex());
fftw_plan
fftPlanForward = fftw_plan_dft_1d(real->Width(), fftIn, fftOut, FFTW_FORWARD, FFTW_MEASURE),
fftPlanBackward = fftw_plan_dft_1d(real->Width(), fftIn, fftOut, FFTW_BACKWARD, FFTW_MEASURE);
lock.unlock();
const size_t width = real->Width();
const BandInfo band = artifacts.MetaData()->Band();
for(unsigned y=0;y<real->Height();++y)
{
const numl_t sincScale = ActualSincScaleInSamples(artifacts, band.channels[y].frequencyHz);
const numl_t limitFrequency = (numl_t) width / sincScale;
if(y == real->Height()/2)
{
AOLogger::Debug << "Horizontal sinc scale: " << sincScale << " (filter scale: " << Angle::ToString(ActualSincScaleAsRaDecDist(artifacts, band.channels[y].frequencyHz)) << ")\n";
}
if(sincScale > 1.0)
{
for(unsigned x=0;x<width;++x)
{
fftIn[x][0] = real->Value(x, y);
fftIn[x][1] = imag->Value(x, y);
}
fftw_execute_dft(fftPlanForward, fftIn, fftOut);
size_t filterIndexSize = (limitFrequency > 1.0) ? (size_t) ceil(limitFrequency/2.0) : 1;
// Remove the high frequencies [filterIndexSize : n-filterIndexSize]
for(size_t f=filterIndexSize;f<width - filterIndexSize;++f)
{
fftOut[f][0] = 0.0;
fftOut[f][1] = 0.0;
}
fftw_execute_dft(fftPlanBackward, fftOut, fftIn);
const double n = width;
for(unsigned x=0;x<width;++x)
{
real->SetValue(x, y, fftIn[x][0] / n);
imag->SetValue(x, y, fftIn[x][1] / n);
}
}
}
fftw_free(fftIn);
fftw_free(fftOut);
}
void HighPassFilter::elementWiseDivide(const Image2DPtr &leftHand, const Image2DCPtr &rightHand)
{
for(unsigned y=0;y<leftHand->Height();++y) {
for(unsigned x=0;x<leftHand->Width();++x) {
if(rightHand->Value(x, y) == 0.0)
leftHand->SetValue(x, y, 0.0);
else
leftHand->SetValue(x, y, leftHand->Value(x, y) / rightHand->Value(x, y));
}
}
}
std::pair<num_t, num_t> SpatialCompositionAction::removeEigenvalue(Image2DCPtr real, Image2DCPtr imaginary) const
{
try {
Image2DPtr
r = Image2D::CreateCopy(real),
i = Image2D::CreateCopy(imaginary);
for(size_t y=0;y<r->Height();++y)
{
for(size_t x=0;x<r->Width();++x)
{
if(!std::isfinite(r->Value(x,y))) r->SetValue(x, y, 0.0);
if(!std::isfinite(i->Value(x,y))) i->SetValue(x, y, 0.0);
}
}
if(r->ContainsOnlyZeros() && i->ContainsOnlyZeros()) return std::pair<num_t, num_t>(0.0, 0.0);
Eigenvalue::Remove(r, i);
return std::pair<num_t, num_t>(r->Value(0,1), i->Value(0,1));
} catch(std::exception &e)
{
return std::pair<num_t, num_t>(std::numeric_limits<num_t>::quiet_NaN(), std::numeric_limits<num_t>::quiet_NaN());
}
}
