cmake and clang-tidy actionclang-tidy fixesfixes some warnings

Author: tsl

.clang-tidy

@@ -0,0 +1,60 @@
+name: CMake-build-lint-test
+
+on:
+  pull_request:
+    branches:
+      - master
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally
+    # well on Windows or Mac.  You can convert this to a matrix build if you need
+    # cross-platform coverage.
+    # See: https://docs.github.com/en/actions/configuring-and-managing-workflows/configuring-a-workflow#configuring-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install dependencies, opencv, Qt5 for GUIs and clang-10
+      run: sudo apt-get install libopencv-dev qtbase5-dev clang-10 ninja-build
+
+    - name: Create Build Environment
+      # Some projects don't allow in-source building, so create a separate build directory
+      # We'll use this as our working directory for all subsequent commands
+      run: cmake -E make_directory ${{runner.workspace}}/build
+
+    - name: Configure CMake
+      # Use a bash shell so we can use the same syntax for environment variable
+      # access regardless of the host operating system
+      shell: bash
+      working-directory: ${{runner.workspace}}/build
+      # Note the current convention is to use the -S and -B options here to specify source
+      # and build directories, but this is only available with CMake 3.13 and higher.
+      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
+      run: cmake $GITHUB_WORKSPACE -DCMAKE_C_COMPILER=/usr/bin/clang-10 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-10 -DCMAKE_BUILD_TYPE=$BUILD_TYPE -GNinja
+
+    - name: Build
+      working-directory: ${{runner.workspace}}/build
+      shell: bash
+      # Execute the build.  You can specify a specific target with "--target <NAME>"
+      run: cmake --build . --config $BUILD_TYPE
+
+    - name: clang-tidy
+      build_dir: ${{runner.workspace}}/build
+      uses: ZedThree/[email protected]
+      id: review
+    # If there are any comments, fail the check
+    - if: steps.review.outpus.total_comments > 0
+      run: exit 1
+
+    - name: Test
+      working-directory: ${{runner.workspace}}/build
+      shell: bash
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest -C $BUILD_TYPE

.github/workflows/cmake.yml

@@ -1,4 +1,4 @@
-# painty ![Bazel build and test](https://github.com/lindemeier/painty/workflows/bazel-tests/badge.svg) ![clang-format](https://github.com/lindemeier/painty/workflows/clang-format/badge.svg)
+# painty ![CMake build, test and lint](https://github.com/lindemeier/painty/workflows/CMake-build-lint-test/badge.svg) ![Bazel build and test](https://github.com/lindemeier/painty/workflows/bazel-tests/badge.svg) ![clang-format](https://github.com/lindemeier/painty/workflows/clang-format/badge.svg)
 
 Library containing several algorithms for:
 - Image processing.

README.md

@@ -118,7 +118,12 @@ class ColorConverter {
       Scalar weight = t * t * (3 - 2 * t);
       return A + weight * (B - A);
     };
-    Scalar x0, x1, x2, x3, y0, y1;
+    Scalar x0;
+    Scalar x1;
+    Scalar x2;
+    Scalar x3;
+    Scalar y0;
+    Scalar y1;
     // red
     x0     = cubicInt(ryb[2], 1., 0.163);
     x1     = cubicInt(ryb[2], 1., 0.);
@@ -181,18 +186,20 @@ class ColorConverter {
 
   // make linear rgb, no chromatic adaption
   void srgb2rgb(const Scalar s, Scalar& l) const {
-    if (s <= 0.0404482362771082)
+    if (s <= 0.0404482362771082) {
       l = s / 12.92;
-    else
+    } else {
       l = std::pow(((s + 0.055) / 1.055), 2.4);
+    }
   }
 
   // make sRGB, with gamma
   void rgb2srgb(const Scalar l, Scalar& s) const {
-    if (l <= 0.00313066844250063)
+    if (l <= 0.00313066844250063) {
       s = l * 12.92;
-    else
+    } else {
       s = 1.055 * std::pow(l, 1. / 2.4) - 0.055;
+    }
   }
 
   // make linear rgb, no chromatic adaption
@@ -297,17 +304,19 @@ class ColorConverter {
 
     const Scalar fa = 1. / 360.0;
 
-    if (fuzzyCompare(max, min, Epsilon))
+    if (fuzzyCompare(max, min, Epsilon)) {
       hsv[0] = 0;
-    else if (fuzzyCompare(max, srgb[0], Epsilon))
+    } else if (fuzzyCompare(max, srgb[0], Epsilon)) {
       hsv[0] = 60.0 * (0 + (srgb[1] - srgb[2]) * delMax);
-    else if (fuzzyCompare(max, srgb[1], Epsilon))
+    } else if (fuzzyCompare(max, srgb[1], Epsilon)) {
       hsv[0] = 60.0 * (2 + (srgb[2] - srgb[0]) * delMax);
-    else if (fuzzyCompare(max, srgb[2], Epsilon))
+    } else if (fuzzyCompare(max, srgb[2], Epsilon)) {
       hsv[0] = 60.0 * (4 + (srgb[0] - srgb[1]) * delMax);
+    }
 
-    if (hsv[0] < 0.0)
+    if (hsv[0] < 0.0) {
       hsv[0] += 360.0;
+    }
 
     if (fuzzyCompare(max, 0.0, Epsilon)) {
       hsv[1] = 0.0;
@@ -346,16 +355,22 @@ class ColorConverter {
     XYZ[1] =
       (Luv[0] > keps) ? (std::pow((Luv[0] + 16.) / 116., 3.)) : (Luv[1] / k);
 
-    Scalar Xr, Yr, Zr;
+    Scalar Xr;
+    Scalar Yr;
+    Scalar Zr;
     Xr = illuminant[0];
     Yr = illuminant[1];
     Zr = illuminant[2];
 
-    Scalar u0, v0;
+    Scalar u0;
+    Scalar v0;
     u0 = (4. * Xr) / (Xr + 15. * Yr + 3. * Zr);
     v0 = (9. * Yr) / (Xr + 15. * Yr + 3. * Zr);
 
-    Scalar a, b, c, d;
+    Scalar a;
+    Scalar b;
+    Scalar c;
+    Scalar d;
     a = (1. / 3.) * (((52. * Luv[0]) / (Luv[1] + 13. * Luv[0] * u0)) - 1.);
     b = -5. * XYZ[1];
     c = -(1. / 3.);
@@ -666,27 +681,33 @@ class ColorConverter {
 
     // Ensure hue is between 0 and 2pi
     Scalar hpstd = std::atan2(bstd, apstd);
-    if (hpstd < 0)
+    if (hpstd < 0) {
       hpstd += 2. * Pi<Scalar>;  // rollover ones that come -ve
+    }
 
     Scalar hpsample = std::atan2(bsample, apsample);
-    if (hpsample < 0)
+    if (hpsample < 0) {
       hpsample += 2. * Pi<Scalar>;
-    if (fuzzyCompare((fabs(apsample) + fabs(bsample)), 0., Epsilon))
+    }
+    if (fuzzyCompare((fabs(apsample) + fabs(bsample)), 0., Epsilon)) {
       hpsample = 0.;
+    }
 
     Scalar dL = (Lsample - Lstd);
     Scalar dC = (Cpsample - Cpstd);
 
     // Computation of hue difference
     Scalar dhp = (hpsample - hpstd);
-    if (dhp > Pi<Scalar>)
+    if (dhp > Pi<Scalar>) {
       dhp -= 2. * Pi<Scalar>;
-    if (dhp < -Pi<Scalar>)
+    }
+    if (dhp < -Pi<Scalar>) {
       dhp += 2. * Pi<Scalar>;
+    }
     // set chroma difference to zero if the product of chromas is zero
-    if (fuzzyCompare(Cpprod, 0., Epsilon))
+    if (fuzzyCompare(Cpprod, 0., Epsilon)) {
       dhp = 0.;
+    }
 
     // Note that the defining equations actually need
     // signed Hue and chroma differences which is different
@@ -705,16 +726,19 @@ class ColorConverter {
     // where needed
     Scalar hp = (hpstd + hpsample) / 2.;
     // Identify positions for which abs hue diff exceeds 180 degrees
-    if (fabs(hpstd - hpsample) > Pi<Scalar>)
+    if (fabs(hpstd - hpsample) > Pi<Scalar>) {
       hp -= Pi<Scalar>;
+    }
     // rollover ones that come -ve
-    if (hp < 0)
+    if (hp < 0) {
       hp += 2. * Pi<Scalar>;
+    }
 
     // Check if one of the chroma values is zero, in which case set
     // mean hue to the sum which is equivalent to other value
-    if (fuzzyCompare(Cpprod, 0., Epsilon))
+    if (fuzzyCompare(Cpprod, 0., Epsilon)) {
       hp = hpsample + hpstd;
+    }
 
     Scalar Lpm502 = (Lp - 50.) * (Lp - 50.);
     Scalar Sl     = 1. + 0.015 * Lpm502 / std::sqrt(20.0 + Lpm502);
@@ -749,9 +773,8 @@ class ColorConverter {
     Scalar d                   = ColorDifferenceCIEDE2000(lab1, lab2);
     if (d >= 0 && d <= d0) {
       return d / d0;
-    } else {
-      return 1.;
     }
+    return 1.;
   }
 
  private:

painty/core/Color.h

@@ -33,8 +33,7 @@ static constexpr auto Pi = static_cast<Float>(
  */
 template <typename Float>
 typename std::enable_if<std::is_floating_point<Float>::value, bool>::type
-fuzzyCompare(const Float firstValue, const Float secondValue,
-             const Float epsilon) {
+fuzzyCompare(Float firstValue, Float secondValue, Float epsilon) {
   return std::fabs(firstValue - secondValue) < epsilon;
 }
 
@@ -80,7 +79,8 @@ Value generalizedBarycentricCoordinatesInterpolate(
 
   if (polygon.empty() || values.empty()) {
     throw std::invalid_argument("Polygon is empty");
-  } else if (polygon.size() != values.size()) {
+  }
+  if (polygon.size() != values.size()) {
     throw std::invalid_argument("Polygon size differs from values size");
   } else if (n == 1U) {
     return values.front();
@@ -142,9 +142,8 @@ Value generalizedBarycentricCoordinatesInterpolate(
   }
   if (!fuzzyCompare(W, 0.0, Eps)) {
     return f * (1.0 / W);
-  } else {
-    return values.front();
   }
+  return values.front();
 }
 
 /**
@@ -160,13 +159,12 @@ template <typename Float, typename std::enable_if_t<
 Float coth(const Float& x) {
   if (x > static_cast<Float>(20.0)) {
     return static_cast<Float>(1.0);
+  }
+  if (std::fabs(x) > static_cast<Float>(0.0)) {
+    const auto res = std::cosh(x) / std::sinh(x);
+    return std::isnan(res) ? static_cast<Float>(1.0) : res;
   } else {
-    if (std::fabs(x) > static_cast<Float>(0.0)) {
-      const auto res = std::cosh(x) / std::sinh(x);
-      return std::isnan(res) ? static_cast<Float>(1.0) : res;
-    } else {
-      return std::numeric_limits<Float>::infinity();
-    }
+    return std::numeric_limits<Float>::infinity();
   }
 }
 
@@ -187,11 +185,10 @@ Float acoth(const Float& x) {
         x, 1.0,
         static_cast<Float>(100.0) * std::numeric_limits<Float>::epsilon())) {
     return std::numeric_limits<Float>::infinity();
-  } else {
-    return std::log((x + static_cast<Float>(1.0)) /
-                    (x - static_cast<Float>(1.0))) /
-           static_cast<Float>(2.0);
   }
+  return std::log((x + static_cast<Float>(1.0)) /
+                  (x - static_cast<Float>(1.0))) /
+         static_cast<Float>(2.0);
 }
 
 template <

painty/core/Math.h

@@ -49,7 +49,10 @@ inline T Cubic(const T& p_1, const T& p0, const T& p1, const T& p2,
   using Float = typename DataType<T>::channel_type;
 
   Float t2;
-  T a0, a1, a2, a3;
+  T a0;
+  T a1;
+  T a2;
+  T a3;
 
   t2 = t * t;
   a0 = p2 - p1 - p_1 + p0;
@@ -104,44 +107,43 @@ class SplineEval {
   SplineEval(ContainerIt begin, ContainerIt end) : _begin(begin), _end(end) {}
 
   value_type linear(value u) {
-    int32_t index;
+    int32_t index = 0;
     value t;
     getControl(u, index, t);
     return Linear(getIndexClamped(index), getIndexClamped(index + 1), t);
   }
 
   value_type linearDerivative(value u) {
-    int32_t index;
+    int32_t index = 0;
     value t;
     getControl(u, index, t);
     return LinearDerivative(getIndexClamped(index), getIndexClamped(index + 1));
   }
 
   value_type cubic(value u) {
-    int32_t index;
+    int32_t index = 0;
     value t;
     getControl(u, index, t);
     return Cubic(getIndexClamped(index - 1), getIndexClamped(index),
                  getIndexClamped(index + 1), getIndexClamped(index + 2), t);
   }
 
   value_type cubicDerivative(value u, int32_t order) {
-    int32_t index;
+    int32_t index = 0;
     value t;
     getControl(u, index, t);
     if (order == 2) {
       return CubicDerivativeSecond(
         getIndexClamped(index - 1), getIndexClamped(index),
         getIndexClamped(index + 1), getIndexClamped(index + 2), t);
-    } else {
-      return CubicDerivativeFirst(
-        getIndexClamped(index - 1), getIndexClamped(index),
-        getIndexClamped(index + 1), getIndexClamped(index + 2), t);
     }
+    return CubicDerivativeFirst(
+      getIndexClamped(index - 1), getIndexClamped(index),
+      getIndexClamped(index + 1), getIndexClamped(index + 2), t);
   }
 
   value cubicCurvature(value u) {
-    int32_t index;
+    int32_t index = 0;
     value t;
     getControl(u, index, t);
     return CubicCurvature(getIndexClamped(index - 1), getIndexClamped(index),
@@ -150,7 +152,7 @@ class SplineEval {
   }
 
   value_type catmullRom(value u) {
-    int32_t index;
+    int32_t index = 0;
     value t;
     getControl(u, index, t);
     return CatmullRom(getIndexClamped(index - 1), getIndexClamped(index),

painty/core/Spline.h

@@ -33,10 +33,10 @@ inline T gaussSigmaFromKernelRadius(const int32_t radius) {
   return gaussSigmaFromKernelSize<T>(radius * 2 + 1);
 }
 
-Mat1d createGauss1stDerivativeKernel(const double sigma, const double theta,
+Mat1d createGauss1stDerivativeKernel(double sigma, double theta,
                                      bool normalized = true);
 
-Mat1d createGauss2ndDerivativeKernel(const double sigma, const double theta,
+Mat1d createGauss2ndDerivativeKernel(double sigma, double theta,
                                      bool normalized = true);
 /**
  *  article{DBLP:journals/saj/GwetuTV14,
@@ -97,7 +97,8 @@ Mat<T> convolve2d(const Mat<T>& source, const Mat1d& kernel) {
 template <class T>
 Mat<T> differencesOfGaussians(const Mat<T>& input, const double sigma,
                               const double tau = 0.99) {
-  Mat<T> d0, d1;
+  Mat<T> d0;
+  Mat<T> d1;
   cv::GaussianBlur(input, d0, cv::Size(-1, -1), sigma);
   cv::GaussianBlur(input, d1, cv::Size(-1, -1), 1.6 * sigma);