diff --git a/Device/Resolution/ConvolutionDetectorResolution.cpp b/Device/Resolution/ConvolutionDetectorResolution.cpp
index 9416f2fc4217321fc4c4e8c28d130cb18f863588..32614837e657772f4470f425629fbb6cac2a8094 100644
--- a/Device/Resolution/ConvolutionDetectorResolution.cpp
+++ b/Device/Resolution/ConvolutionDetectorResolution.cpp
@@ -71,7 +71,7 @@ void ConvolutionDetectorResolution::setResolutionFunction(const IResolutionFunct
void ConvolutionDetectorResolution::apply1dConvolution(Datafield* intensity_map) const
{
- ASSERT(m_res_function_1d == nullptr);
+ ASSERT(m_res_function_1d);
ASSERT(intensity_map->rank() == 1);
const Scale& axis = intensity_map->axis(0);
@@ -101,7 +101,7 @@ void ConvolutionDetectorResolution::apply1dConvolution(Datafield* intensity_map)
void ConvolutionDetectorResolution::apply2dConvolution(Datafield* intensity_map) const
{
ASSERT(m_res_function_2d);
- ASSERT(intensity_map->rank() != 2);
+ ASSERT(intensity_map->rank() == 2);
const Scale& axis_1 = intensity_map->axis(0);
const Scale& axis_2 = intensity_map->axis(1);
size_t axis_size_1 = axis_1.size();
diff --git a/Device/Resolution/Convolve.cpp b/Device/Resolution/Convolve.cpp
index 5792a038e757321bcaaac5e393092a8214e8aed0..85c4de7dd779a64794a9dff372b6b0412e745642 100644
--- a/Device/Resolution/Convolve.cpp
+++ b/Device/Resolution/Convolve.cpp
@@ -13,9 +13,7 @@
// ************************************************************************************************
#include "Device/Resolution/Convolve.h"
-#include <iostream>
-#include <sstream>
-#include <stdexcept> // need overlooked by g++ 5.4
+#include "Base/Util/Assert.h"
Convolve::Convolve()
: m_mode(FFTW_UNDEFINED)
@@ -99,12 +97,11 @@ void Convolve::fftconvolve(const double2d_t& source, const double2d_t& kernel, d
result[i].resize(ws.w_dst, 0);
for (int j = 0; j < ws.w_dst; j++) {
// result[i][j]=ws.dst[i*ws.w_dst+j];
- if (m_mode == FFTW_CIRCULAR_SAME_SHIFTED) {
+ if (m_mode == FFTW_CIRCULAR_SAME_SHIFTED)
result[i][j] = ws.dst_fft[((i + int(ws.h_kernel / 2.0)) % ws.h_fftw) * ws.w_fftw
+ (j + int(ws.w_kernel / 2.0)) % ws.w_fftw];
- } else {
+ else
result[i][j] = ws.dst_fft[(i + ws.h_offset) * ws.w_fftw + j + ws.w_offset];
- }
}
}
}
@@ -121,8 +118,7 @@ void Convolve::fftconvolve(const double1d_t& source, const double1d_t& kernel, d
double2d_t result2d;
fftconvolve(source2d, kernel2d, result2d);
- if (result2d.size() != 1)
- throw std::runtime_error("Convolve::fftconvolve -> Panic in 1d");
+ ASSERT(result2d.size() == 1);
result = result2d[0];
}
@@ -131,12 +127,10 @@ void Convolve::fftconvolve(const double1d_t& source, const double1d_t& kernel, d
/* ************************************************************************* */
void Convolve::init(int h_src, int w_src, int h_kernel, int w_kernel)
{
- if (!h_src || !w_src || !h_kernel || !w_kernel) {
- std::ostringstream os;
- os << "Convolve::init -> Panic! Wrong dimensions " << h_src << " " << w_src << " "
- << h_kernel << " " << w_kernel << std::endl;
- throw std::runtime_error(os.str());
- }
+ ASSERT(h_src);
+ ASSERT(w_src);
+ ASSERT(h_kernel);
+ ASSERT(w_kernel);
ws.clear();
ws.h_src = h_src;
@@ -178,19 +172,12 @@ void Convolve::init(int h_src, int w_src, int h_kernel, int w_kernel)
break;
case FFTW_LINEAR_VALID:
// Valid Linear convolution
- if (ws.h_kernel > ws.h_src || ws.w_kernel > ws.w_src) {
- ws.h_fftw = 0;
- ws.w_fftw = 0;
- ws.h_dst = 0;
- ws.w_dst = 0;
- std::cout << "The 'valid' convolution results in an empty matrix" << std::endl;
- throw std::runtime_error("The 'valid' convolution results in an empty matrix");
- } else {
- ws.h_fftw = find_closest_factor(h_src);
- ws.w_fftw = find_closest_factor(w_src);
- ws.h_dst = h_src - h_kernel + 1;
- ws.w_dst = w_src - w_kernel + 1;
- }
+ ASSERT(ws.h_kernel <= ws.h_src);
+ ASSERT(ws.w_kernel <= ws.w_src);
+ ws.h_fftw = find_closest_factor(h_src);
+ ws.w_fftw = find_closest_factor(w_src);
+ ws.h_dst = h_src - h_kernel + 1;
+ ws.w_dst = w_src - w_kernel + 1;
// Here we just take [h_dst x w_dst] elements starting at [h_kernel-1;w_kernel-1]
ws.h_offset = ws.h_kernel - 1;
ws.w_offset = ws.w_kernel - 1;
@@ -210,11 +197,7 @@ void Convolve::init(int h_src, int w_src, int h_kernel, int w_kernel)
ws.w_offset = 0;
break;
default:
- std::cout
- << "Unrecognized convolution mode, possible modes are "
- << "FFTW_LINEAR_FULL, FFTW_LINEAR_SAME, FFTW_LINEAR_SAME_UNPADDED, FFTW_LINEAR_VALID, "
- << "FFTW_CIRCULAR_SAME, FFTW_CIRCULAR_SHIFTED " << std::endl;
- break;
+ ASSERT_NEVER;
}
ws.in_src = new double[ws.h_fftw * ws.w_fftw];
@@ -228,19 +211,15 @@ void Convolve::init(int h_src, int w_src, int h_kernel, int w_kernel)
// Initialization of the plans
ws.p_forw_src = fftw_plan_dft_r2c_2d(ws.h_fftw, ws.w_fftw, ws.in_src, (fftw_complex*)ws.out_src,
FFTW_ESTIMATE);
- if (ws.p_forw_src == nullptr)
- throw std::runtime_error("Convolve::init -> Error! Cannot initialise p_forw_src plan.");
-
+ ASSERT(ws.p_forw_src);
ws.p_forw_kernel = fftw_plan_dft_r2c_2d(ws.h_fftw, ws.w_fftw, ws.in_kernel,
(fftw_complex*)ws.out_kernel, FFTW_ESTIMATE);
- if (ws.p_forw_kernel == nullptr)
- throw std::runtime_error("Convolve::init -> Error! Cannot initialise p_forw_kernel plan.");
+ ASSERT(ws.p_forw_kernel);
// The backward FFT takes ws.out_kernel as input
ws.p_back = fftw_plan_dft_c2r_2d(ws.h_fftw, ws.w_fftw, (fftw_complex*)ws.out_kernel, ws.dst_fft,
FFTW_ESTIMATE);
- if (ws.p_back == nullptr)
- throw std::runtime_error("Convolve::init -> Error! Cannot initialise p_back plan.");
+ ASSERT(ws.p_back);
}
/* ************************************************************************* */
@@ -249,8 +228,8 @@ void Convolve::init(int h_src, int w_src, int h_kernel, int w_kernel)
void Convolve::fftw_circular_convolution(const double2d_t& src, const double2d_t& kernel)
{
- if (ws.h_fftw <= 0 || ws.w_fftw <= 0)
- throw std::runtime_error("Convolve::fftw_convolve -> Panic! Initialization is missed.");
+ ASSERT(ws.h_fftw > 0);
+ ASSERT(ws.w_fftw > 0);
double *ptr, *ptr_end, *ptr2;
@@ -319,9 +298,8 @@ bool Convolve::is_optimal(int n)
if (n == 1)
return false;
size_t ntest = n;
- for (size_t i = 0; i < m_implemented_factors.size(); i++) {
+ for (size_t i = 0; i < m_implemented_factors.size(); i++)
while ((ntest % m_implemented_factors[i]) == 0)
ntest = ntest / m_implemented_factors[i];
- }
return ntest == 1;
}