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<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadSingleBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadAllBeamlets(timestepStart, timestepEnd, beamletCount);
const unsigned width = timestepEnd - timestepStart;
Image2DPtr realX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr realY = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryY = Image2D::CreateZeroImagePtr(width, 1);
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(width, 1);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr maskWithBeamlets = data.first.GetSingleMask();
for(unsigned x=0;x<width;++x)
{
realX->SetValue(x, 0, xr->Value(x, beamletIndex));
imaginaryX->SetValue(x, 0, xi->Value(x, beamletIndex));
realY->SetValue(x, 0, yr->Value(x, beamletIndex));
imaginaryY->SetValue(x, 0, yi->Value(x, beamletIndex));
mask->SetValue(x, 0, maskWithBeamlets->Value(x, beamletIndex));
}
data.first = TimeFrequencyData(Polarization::XX, realX, imaginaryX, Polarization::YY, realY, imaginaryY);
data.first.SetGlobalMask(mask);
BandInfo band = data.second->Band();
band.channels[0] = data.second->Band().channels[beamletIndex];
band.channels.resize(1);
data.second->SetBand(band);
return data;
}
void HighPassFilter::setFlaggedValuesToZeroAndMakeWeights(const Image2DCPtr &inputImage, const Image2DPtr &outputImage, const Mask2DCPtr &inputMask, const Image2DPtr &weightsOutput)
{
const size_t width = inputImage->Width();
for(size_t y=0;y<inputImage->Height();++y)
{
for(size_t x=0;x<width;++x)
{
if(inputMask->Value(x, y) || !isfinite(inputImage->Value(x, y)))
{
outputImage->SetValue(x, y, 0.0);
weightsOutput->SetValue(x, y, 0.0);
} else {
outputImage->SetValue(x, y, inputImage->Value(x, y));
weightsOutput->SetValue(x, y, 1.0);
}
}
}
}
void HighPassFilter::setFlaggedValuesToZeroAndMakeWeightsSSE(const Image2DCPtr &inputImage, const Image2DPtr &outputImage, const Mask2DCPtr &inputMask, const Image2DPtr &weightsOutput)
{
const size_t width = inputImage->Width();
const __m128i zero4i = _mm_set_epi32(0, 0, 0, 0);
const __m128 zero4 = _mm_set_ps(0.0, 0.0, 0.0, 0.0);
const __m128 one4 = _mm_set_ps(1.0, 1.0, 1.0, 1.0);
for(size_t y=0;y<inputImage->Height();++y)
{
const bool *rowPtr = inputMask->ValuePtr(0, y);
const float *inputPtr = inputImage->ValuePtr(0, y);
float *outputPtr = outputImage->ValuePtr(0, y);
float *weightsPtr = weightsOutput->ValuePtr(0, y);
const float *end = inputPtr + width;
while(inputPtr < end)
{
// Assign each integer to one bool in the mask
// Convert false to 0xFFFFFFFF and true to 0
__m128 conditionMask = _mm_castsi128_ps(
_mm_cmpeq_epi32(_mm_set_epi32(rowPtr[3] || !isfinite(inputPtr[3]), rowPtr[2] || !isfinite(inputPtr[2]),
rowPtr[1] || !isfinite(inputPtr[1]), rowPtr[0] || !isfinite(inputPtr[0])),
zero4i));
_mm_store_ps(weightsPtr, _mm_or_ps(
_mm_and_ps(conditionMask, one4),
_mm_andnot_ps(conditionMask, zero4)
));
_mm_store_ps(outputPtr, _mm_or_ps(
_mm_and_ps(conditionMask, _mm_load_ps(inputPtr)),
_mm_andnot_ps(conditionMask, zero4)
));
rowPtr += 4;
outputPtr += 4;
inputPtr += 4;
weightsPtr += 4;
}
}
}
void ImageTile::LineThreshold(bool evaluateBaseline, long double mean, long double variance, bool convolve)
{
Image2DPtr input = Image2D::CreateEmptyImagePtr(_scanCount, _channelCount);
Mask2DPtr output = Mask2D::CreateSetMaskPtr<false>(_scanCount, _channelCount);
if(evaluateBaseline) {
for(unsigned channel = 0;channel<_channelCount;++channel)
for(unsigned scan = 0;scan<_scanCount;++scan)
input->SetValue(scan, channel, GetValueAt(channel, scan) - EvaluateBaselineFunction(scan, channel));
} else {
for(unsigned channel = 0;channel<_channelCount;++channel)
for(unsigned scan = 0;scan<_scanCount;++scan)
input->SetValue(scan, channel, GetValueAt(channel, scan) - mean);
}
ThresholdMitigater::SumThreshold(input, output, 1, _trigger * variance);
ThresholdMitigater::SumThreshold(input, output, 2, _trigger * variance * 1.6);
ThresholdMitigater::SumThreshold(input, output, 3, _trigger * variance * 2.2);
ThresholdMitigater::SumThreshold(input, output, 5, _trigger * variance * 3.0);
ThresholdMitigater::SumThreshold(input, output, 10, _trigger * variance * 5.0);
unsigned count = 0;
for(unsigned channel = 0;channel<_channelCount;++channel) {
for(unsigned scan = 0;scan<_scanCount;++scan) {
if(output->Value(scan, channel)) {
Window(scan, channel);
count++;
}
}
}
while(count*2 > _channelCount*_scanCount) {
size_t x = (size_t) (RNG::Uniform()*_scanCount);
size_t y = (size_t) (RNG::Uniform()*_channelCount);
if(_isWindowed[y][x]) {
count--;
_isWindowed[y][x]=false;
}
}
if(convolve)
ConvolveWindows();
}
void HighPassFilter::elementWiseDivideSSE(const Image2DPtr &leftHand, const Image2DCPtr &rightHand)
{
const __m128 zero4 = _mm_set_ps(0.0, 0.0, 0.0, 0.0);
for(unsigned y=0;y<leftHand->Height();++y) {
float *leftHandPtr = leftHand->ValuePtr(0, y);
const float *rightHandPtr = rightHand->ValuePtr(0, y);
float *end = leftHandPtr + leftHand->Width();
while(leftHandPtr < end)
{
__m128
l = _mm_load_ps(leftHandPtr),
r = _mm_load_ps(rightHandPtr);
__m128 conditionMask = _mm_cmpeq_ps(r, zero4);
_mm_store_ps(leftHandPtr, _mm_or_ps(
_mm_and_ps(conditionMask, zero4),
_mm_andnot_ps(conditionMask, _mm_div_ps(l, r))
));
leftHandPtr += 4;
rightHandPtr += 4;
}
}
}
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());
}
}
Image2DPtr Compress::Read(std::ifstream &stream, Image2DPtr image, Mask2DCPtr mask)
{
num_t max = 0.0, min = 0.0;
size_t width = 0, height = 0;
char mode = 0;
stream.read(reinterpret_cast<char*>(&max), sizeof(max));
stream.read(reinterpret_cast<char*>(&min), sizeof(min));
stream.read(reinterpret_cast<char*>(&width), sizeof(width));
stream.read(reinterpret_cast<char*>(&height), sizeof(height));
stream.read(&mode, sizeof(mode));
num_t normalizeFactor = (max - min) / (num_t) ((2<<22) + ((2<<22)-1));
for(unsigned y=0;y<height;++y)
{
for(unsigned x=0;x<width;++x)
{
if(!mask->Value(x, y))
{
int32_t value;
stream.read(reinterpret_cast<char*>(&value), 3);
value >>= 8;
image->SetValue(x, y, value / normalizeFactor + min);
}
}
}
void BHFitsImageSet::loadImageData(TimeFrequencyData &data, const TimeFrequencyMetaDataPtr &metaData, const BHFitsImageSetIndex &index)
{
std::vector<num_t> buffer(_width * _height);
_file->ReadCurrentImageData(0, &buffer[0], _width * _height);
int
rangeStart = _timeRanges[index._imageIndex].start,
rangeEnd = _timeRanges[index._imageIndex].end;
Image2DPtr image = Image2D::CreateZeroImagePtr(rangeEnd-rangeStart, _height);
std::vector<num_t>::const_iterator bufferPtr = buffer.begin() + _height*rangeStart;
for(int x=rangeStart; x!=rangeEnd; ++x)
{
for(int y=0; y!=_height; ++y)
{
image->SetValue(x-rangeStart, y, *bufferPtr);
++bufferPtr;
}
}
data = TimeFrequencyData(TimeFrequencyData::AmplitudePart, SinglePolarisation, image);
try {
FitsFile flagFile(flagFilePath());
flagFile.Open(FitsFile::ReadOnlyMode);
flagFile.ReadCurrentImageData(0, &buffer[0], _width * _height);
bufferPtr = buffer.begin() + _height*rangeStart;
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(rangeEnd-rangeStart, _height);
for(int x=rangeStart; x!=rangeEnd; ++x)
{
for(int y=0; y!=_height; ++y)
{
bool flag = false;
if(*bufferPtr == 0.0)
flag = false;
else if(*bufferPtr == 1.0)
flag = true;
else std::runtime_error("Expecting a flag file with only ones and zeros, but this file contained other values.");
mask->SetValue(x-rangeStart, y, flag);
++bufferPtr;
}
}
data.SetGlobalMask(mask);
} catch(std::exception &)
{
// Flag file could not be read; probably does not exist. Ignore this, flags will be initialized to false.
}
double
frequencyDelta = _file->GetDoubleKeywordValue("CDELT1"),
timeDelta = _file->GetDoubleKeywordValue("CDELT2");
BandInfo band;
for(int ch=0; ch!=_height; ++ch)
{
ChannelInfo channel;
channel.frequencyHz = ch * frequencyDelta * 1000000.0;
band.channels.push_back(channel);
}
metaData->SetBand(band);
const int rangeWidth = rangeEnd-rangeStart;
std::vector<double> observationTimes(rangeWidth);
for(int t=0; t!=rangeWidth; ++t)
observationTimes[t] = (t + rangeStart) * timeDelta;
metaData->SetObservationTimes(observationTimes);
AntennaInfo antennaInfo;
antennaInfo.id = 0;
antennaInfo.name = RangeName(index._imageIndex);
antennaInfo.diameter = 0.0;
antennaInfo.mount = "Unknown";
antennaInfo.station = GetTelescopeName();
metaData->SetAntenna1(antennaInfo);
metaData->SetAntenna2(antennaInfo);
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadChannelBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
const unsigned width = timestepEnd - timestepStart;
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadSingleBeamlet(timestepStart*(unsigned long) 256, timestepEnd*(unsigned long) 256, beamletCount, beamletIndex);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr mask = data.first.GetSingleMask();
Image2DPtr
outXR = Image2D::CreateUnsetImagePtr(width, 256),
outXI = Image2D::CreateUnsetImagePtr(width, 256),
outYR = Image2D::CreateUnsetImagePtr(width, 256),
outYI = Image2D::CreateUnsetImagePtr(width, 256);
Mask2DPtr
outMask = Mask2D::CreateUnsetMaskPtr(width, 256);
std::vector<double> observationTimes;
for(unsigned long timestep = 0;timestep < timestepEnd-timestepStart;++timestep)
{
unsigned long timestepIndex = timestep * 256;
SampleRow
realX = SampleRow::MakeFromRow(xr.get(), timestepIndex, 256, 0),
imaginaryX = SampleRow::MakeFromRow(xi.get(), timestepIndex, 256, 0),
realY = SampleRow::MakeFromRow(yr.get(), timestepIndex, 256, 0),
imaginaryY = SampleRow::MakeFromRow(yi.get(), timestepIndex, 256, 0);
FFTTools::FFT(realX, imaginaryX);
FFTTools::FFT(realY, imaginaryY);
realX.SetVerticalImageValues(outXR.get(), timestep);
imaginaryX.SetVerticalImageValues(outXI.get(), timestep);
realY.SetVerticalImageValues(outYR.get(), timestep);
imaginaryY.SetVerticalImageValues(outYI.get(), timestep);
observationTimes.push_back(data.second->ObservationTimes()[timestepIndex + 256/2]);
size_t validValues = 0;
for(unsigned y=0;y<256;++y)
{
if(!mask->Value(timestepIndex + y, 0))
++validValues;
}
for(unsigned y=0;y<256;++y)
{
outMask->SetValue(timestep, y , validValues == 0);
}
}
data.first = TimeFrequencyData(Polarization::XX, outXR, outXI, Polarization::YY, outYR, outYI);
data.first.SetGlobalMask(outMask);
BandInfo band = data.second->Band();
band.channels.clear();
for(unsigned i=0;i<256;++i)
{
ChannelInfo channel;
channel.frequencyHz = i+1;
channel.frequencyIndex = i;
band.channels.push_back(channel);
}
data.second->SetBand(band);
data.second->SetObservationTimes(observationTimes);
return data;
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadAllBeamlets(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount)
{
const unsigned width = timestepEnd - timestepStart;
Image2DPtr realX = Image2D::CreateZeroImagePtr(width, beamletCount);
Image2DPtr imaginaryX = Image2D::CreateZeroImagePtr(width, beamletCount);
Image2DPtr realY = Image2D::CreateZeroImagePtr(width, beamletCount);
Image2DPtr imaginaryY = Image2D::CreateZeroImagePtr(width, beamletCount);
Mask2DPtr mask = Mask2D::CreateSetMaskPtr<true>(width, beamletCount);
std::ifstream file(_rawFile.c_str(), std::ios_base::binary | std::ios_base::in);
size_t frame = 0;
std::set<short> stations;
TimeFrequencyMetaDataPtr metaData = TimeFrequencyMetaDataPtr(new TimeFrequencyMetaData());
BandInfo band;
for(size_t i=0;i<beamletCount;++i)
{
ChannelInfo channel;
channel.frequencyHz = i+1;
channel.frequencyIndex = i;
band.channels.push_back(channel);
}
metaData->SetBand(band);
std::vector<double> observationTimes;
// Read a header and determine the reading start position
// Because timestepStart might fall within a block, the
RCPApplicationHeader firstHeader;
firstHeader.Read(file);
const unsigned long bytesPerFrame = beamletCount * firstHeader.nofBlocks * RCPBeamletData::SIZE + RCPApplicationHeader::SIZE;
const unsigned long startFrame = timestepStart / (unsigned long) firstHeader.nofBlocks;
const unsigned long startByte = startFrame * bytesPerFrame;
const unsigned long offsetFromStart = timestepStart - (startFrame * firstHeader.nofBlocks);
//Logger::Debug << "Seeking to " << startByte << " (timestepStart=" << timestepStart << ", offsetFromStart=" << offsetFromStart << ", startFrame=" << startFrame << ",bytesPerFrame=" << bytesPerFrame << ")\n";
file.seekg(startByte, std::ios_base::beg);
// Read the frames
unsigned long x=0;
while(x < width + offsetFromStart && file.good()) {
RCPApplicationHeader header;
header.Read(file);
if(header.versionId != 2)
{
std::stringstream s;
s << "Corrupted header found in frame " << frame << "!";
throw std::runtime_error(s.str());
}
if(stations.count(header.stationId)==0)
{
stations.insert(header.stationId);
AntennaInfo antenna;
std::stringstream s;
s << "LOFAR station with index " << header.stationId;
antenna.name = s.str();
metaData->SetAntenna1(antenna);
metaData->SetAntenna2(antenna);
}
for(size_t j=0;j<beamletCount;++j)
{
for(size_t i=0;i<header.nofBlocks;++i)
{
RCPBeamletData data;
data.Read(file);
if(i + x < width + offsetFromStart && i + x >= offsetFromStart)
{
const unsigned long pos = i + x - offsetFromStart;
realX->SetValue(pos, j, data.xr);
imaginaryX->SetValue(pos, j, data.xi);
realY->SetValue(pos, j, data.yr);
imaginaryY->SetValue(pos, j, data.yi);
mask->SetValue(pos, j, false);
}
}
}
x += header.nofBlocks;
++frame;
}
//Logger::Debug << "Read " << frame << " frames.\n";
for(unsigned long i=0;i<width;++i)
{
const unsigned long pos = i + timestepStart;
const double time =
(double) pos * (double) STATION_INTEGRATION_STEPS / (double) _clockSpeed;
observationTimes.push_back(time);
}
metaData->SetObservationTimes(observationTimes);
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data;
data.first = TimeFrequencyData(Polarization::XX, realX, imaginaryX, Polarization::YY, realY, imaginaryY);
data.first.SetGlobalMask(mask);
data.second = metaData;
return data;
}
void HighPassFilter::applyLowPassSSE(const Image2DPtr &image)
{
Image2DPtr temp = Image2D::CreateZeroImagePtr(image->Width(), image->Height());
unsigned hKernelMid = _hWindowSize/2;
for(unsigned i=0; i<_hWindowSize; ++i) {
const num_t k = _hKernel[i];
const __m128 k4 = _mm_set_ps(k, k, k, k);
unsigned
/* xStart is the first column to start writing to. Note that it might be larger
* than the width. */
xStart = (i >= hKernelMid) ? 0 : (hKernelMid-i),
xEnd = (i <= hKernelMid) ? image->Width() : (image->Width()+hKernelMid > i ? (image->Width()-i+hKernelMid) : 0);
for(unsigned y=0;y<image->Height();++y) {
float *tempPtr = temp->ValuePtr(xStart, y);
const float *imagePtr = image->ValuePtr(xStart+i-hKernelMid, y);
unsigned x = xStart;
for(;x+4<xEnd;x+=4) {
const __m128
imageVal = _mm_loadu_ps(imagePtr),
tempVal = _mm_loadu_ps(tempPtr);
// *tempPtr += k * (*imagePtr);
_mm_storeu_ps(tempPtr, _mm_add_ps(tempVal, _mm_mul_ps(imageVal, k4)));
tempPtr += 4;
imagePtr += 4;
}
for(;x<xEnd;++x) {
*tempPtr += k * (*imagePtr);
++tempPtr;
++imagePtr;
}
}
}
image->SetAll(0.0);
unsigned vKernelMid = _vWindowSize/2;
for(unsigned i=0; i<_vWindowSize; ++i) {
const num_t k = _vKernel[i];
const __m128 k4 = _mm_set_ps(k, k, k, k);
const unsigned
yStart = (i >= vKernelMid) ? 0 : (vKernelMid-i),
yEnd = (i <= vKernelMid) ? image->Height() : ((image->Height()+vKernelMid>i) ? (image->Height()-i+vKernelMid) : 0);
for(unsigned y=yStart;y<yEnd;++y) {
const float *tempPtr = temp->ValuePtr(0, y+i-vKernelMid);
float *imagePtr = image->ValuePtr(0, y);
unsigned x=0;
for(;x+4<image->Width();x += 4) {
const __m128
imageVal = _mm_load_ps(imagePtr),
tempVal = _mm_load_ps(tempPtr);
// *imagePtr += k * (*tempPtr);
_mm_store_ps(imagePtr, _mm_add_ps(imageVal, _mm_mul_ps(tempVal, k4)));
tempPtr += 4;
imagePtr += 4;
}
for(;x<image->Width();++x) {
*imagePtr += k * (*tempPtr);
++tempPtr;
++imagePtr;
}
}
}
}
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);
}
}
}
Image2DPtr HighPassFilter::ApplyHighPass(const Image2DCPtr &image, const Mask2DCPtr &mask)
{
Image2DPtr outputImage = ApplyLowPass(image, mask);
outputImage->SubtractAsRHS(image);
return outputImage;
}
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);
}
