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)); } } }
num_t SpatialCompositionAction::eigenvalue(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 0.0; return Eigenvalue::Compute(r, i); } catch(std::exception &e) { return std::numeric_limits<num_t>::quiet_NaN(); } }
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; } } }
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; } } } }