small edits and fixes

Author: Erfan-Ahmadi

62_CAD/CMakeLists.txt

@@ -4,8 +4,8 @@ if(NOT RES)
 endif()
 
 set(EXAMPLE_SOURCES
-  "${CMAKE_CURRENT_SOURCE_DIR}/curves.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/curves.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/Curves.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/Curves.h"
   "${CMAKE_CURRENT_SOURCE_DIR}/Hatch.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/Hatch.h"
   "${CMAKE_CURRENT_SOURCE_DIR}/Polyline.h"

62_CAD/DrawResourcesFiller.h

@@ -1,6 +1,7 @@
 #include "Polyline.h"
 #include "Hatch.h"
 #include <nbl/video/utilities/SIntendedSubmitInfo.h>
+#include <nbl/core/containers/LRUCache.h>
 
 using namespace nbl;
 using namespace nbl::video;

62_CAD/Hatch.cpp

@@ -9,193 +9,6 @@
 
 using namespace nbl;
 
-#ifdef DEPRECATED_ROOT_FINDER
-#include <boost/math/tools/polynomial.hpp>
-using std::complex;
-using boost::math::tools::polynomial;
-
-template<typename T, size_t Order>
-polynomial<complex<T>> polynomialDerivative(polynomial<complex<T>> values)
-{
-	std::array<complex<T>, Order> output;
-	for (uint32_t i = 1; i < Order + 1; i++)
-	{
-		complex<T> originalValue = values[i];
-		uint32_t originalPosition = i;
-		output[i - 1] = T(originalPosition) * originalValue;
-	}
-	return polynomial<complex<T>>(output.data(), Order - 1);
-}
-
-template<typename T, size_t Order>
-complex<T> evaluatePolynomial(polynomial<complex<T>> values, complex<T> x)
-{
-	if constexpr (Order == -1)
-		return complex<T>(0.0, 0.0);
-	complex<T> acc = values[Order];
-	for (int i = Order - 1; i >= 0; i--)
-		acc = acc * x + values[i];
-
-	return acc;
-}
-
-constexpr double LaguerrePolynomialThreshhold = 2e-300;
-constexpr double LaguerreAThreshhold = 1e-40;
-constexpr uint32_t MaxIterations = 256;
-constexpr double LaguerreInitialGuess = 0.0;
-constexpr double EPS = 2e-6;
-
-// https://en.m.wikipedia.org/wiki/Laguerre's_method
-template<typename float_t, size_t Order>
-complex<float_t> solveLaguerreRoot(polynomial<complex<float_t>> p, complex<float_t> initialGuess)
-{
-	using complex_t = complex<float_t>;
-	using polynomial_t = polynomial<complex_t>;
-
-	polynomial_t pd = polynomialDerivative<float_t, Order>(p);
-	polynomial_t pdd = polynomialDerivative <float_t, Order - 1>(pd);
-
-	assert(p.size() == Order + 1);
-	assert(pd.size() == Order);
-	assert(pdd.size() == Order - 1);
-
-	const uint32_t n = Order;
-	uint32_t k = 0;
-	complex_t x = initialGuess;
-	complex_t a;
-
-	do {
-		complex_t f = evaluatePolynomial<float_t, Order>(p, x); // p(x)
-		complex_t fd = evaluatePolynomial<float_t, Order - 1>(pd, x); // p'(x)
-		complex_t fdd = evaluatePolynomial<float_t, Order - 2>(pdd, x); // p''(x)
-		// If p(x) is very small, exit the loop
-		if (abs(f) < LaguerrePolynomialThreshhold) break;
-
-		// TODO: Using polynomial math (division, multiplication & subtraction) we can turn G and H into
-		// polynomials and evaluate them here
-		complex_t G = fd / f; // p'(x) / p(x)
-		complex_t H = G * G - fdd / f; // G² - p''(x) / p(x)
-
-		// this value fed to sqrt could end up negative, meaning we can get 
-		// an imaginary value with complex sqrt
-		complex_t det = std::sqrt(complex_t(n - 1, 0.0) * (complex_t(n, 0.0) * H - G * G));
-
-		// n / (G +- sqrt((n - 1) * (nH - G²)))
-		complex_t aSign0 = G + det;
-		complex_t aSign1 = G - det;
-		a = complex_t(n, 0.0) / (abs(aSign0) > abs(aSign1) ? aSign0 : aSign1);
-		//if (core::isnan(a) || isinf(a)) return nbl::core::nan<double>();
-		x -= a;
-		k++;
-	// Repeat until a is small enough or if the maximum number of iterations has been reached.
-	} while (abs(a) >= LaguerreAThreshhold && k < MaxIterations);
-
-	// Collapse complex into real variable
-	if (abs(x.imag()) < 2.0 * EPS * abs(x.real())) 
-		return complex_t(x.real(), 0);
-	return x;
-}
-
-template<typename T>
-polynomial<complex<T>> deflatePolynomial(polynomial<complex<T>> poly, complex<T> root)
-{
-	// divide by x - root
-	// (-root, 1)
-	std::array<complex<T>, 2> divisionPoly = { -root, complex<T>(1.0, 0.0) };
-	return poly / polynomial<complex<T>>(divisionPoly.data(), 1);
-}
-
-// https://stackoverflow.com/a/12683219
-template<size_t Order, typename T>
-class SolvePolynomialRoots
-{
-public:
-	static std::array<complex<T>, Order> solveRoots(polynomial<complex<T>> p)
-	{
-		std::array<complex<T>, Order> roots = {};
-		polynomial <complex<T>> poly = p;
-
-		// Values of 0 may reduce the order of the polynomial, so we always check before performing
-		// solveLaguerreRoot for that order
-		if (p.size() == Order + 1)
-		{
-			roots[0] = solveLaguerreRoot<T, Order>(p, LaguerreInitialGuess);
-			// If a root has been found, the corresponding linear factor can be removed from p.
-			// This deflation step reduces the degree of the polynomial by one, so that eventually,
-			// approximations for all roots of p can be found.Note however that deflation can lead 
-			// to approximate factors that differ significantly from the corresponding exact factors.
-			// This error is least if the roots are found in the order of increasing magnitude.
-			poly = deflatePolynomial<T>(poly, roots[0]);
-		}
-
-		auto otherRoots = SolvePolynomialRoots<Order - 1, T>::solveRoots(poly);
-		std::copy(otherRoots.begin(), otherRoots.end(), roots.begin() + 1);
-		return roots;
-	}
-};
-
-template<typename T>
-class SolvePolynomialRoots<1, T>
-{
-public:
-	static std::array<complex<T>, 1> solveRoots(polynomial<complex<T>> p)
-	{
-		if (p.size() == 2)
-			return { solveLaguerreRoot<T, 1>(p, LaguerreInitialGuess) };
-		return { complex<T>(core::nan<double>()) };
-	}
-};
-
-template<typename T>
-std::array<complex<T>, 4> solveQuarticRootsLaguerre(std::array<T, 5> p)
-{
-	std::array<complex<T>, 5> polynomialValues = {
-		complex<T>(p[0]),complex<T>(p[1]),complex<T>(p[2]),complex<T>(p[3]),complex<T>(p[4])
-	};
-	std::array<complex<T>, 4> roots = SolvePolynomialRoots<4, T>::solveRoots(polynomial <complex<T>>(polynomialValues.data(), 4));
-
-	// Improve initial guess (polish numerical error)
-	// TODO: use Halley for this?
-	// TODO: find better way of checking for the size
-	polynomial<complex<T>> poly(polynomialValues.data(), 4);
-	if (poly.size() == 5)
-	{
-		for (uint32_t i = 0; i < roots.size(); i++)
-		{
-			roots[i] = solveLaguerreRoot<T, 4>(poly, roots[i]);
-		}
-	}
-
-	return roots;
-}
-
-std::array<double, 4> Hatch::solveQuarticRootsLaguerre(double a, double b, double c, double d, double e, double t_start, double t_end)
-{
-	auto laguerreRoots = solveQuarticRootsLaguerre<double>({ e, d, c, b, a });
-	std::array<double, 4> roots = { -1.0, -1.0, -1.0, -1.0 }; // only two candidates in range, ever
-	uint32_t realRootCount = 0;
-
-	for (uint32_t i = 0; i < laguerreRoots.size(); i++)
-	{
-		if (laguerreRoots[i].imag() == 0.0)
-		{
-			bool duplicatedRoot = false;
-			
-			for (uint32_t realRoot = 0; realRoot < realRootCount; realRoot++)
-				if (roots[realRoot] == laguerreRoots[i].real())
-					duplicatedRoot = true;
-
-			if (duplicatedRoot)
-				continue;
-
-			roots[realRootCount++] = laguerreRoots[i].real();
-		}
-	}
-	
-	return roots;
-}
-#endif
-
 bool Hatch::Segment::isStraightLineConstantMajor() const
 {
 	auto major = (uint32_t)SelectedMajorAxis;

62_CAD/Hatch.h

@@ -7,7 +7,7 @@
 #include <nbl/builtin/hlsl/cpp_compat.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/vector.hlsl>
-#include "curves.h"
+#include "Curves.h"
 #include "Polyline.h"
 
 #include <nbl/builtin/hlsl/math/equations/cubic.hlsl>

62_CAD/Polyline.h

@@ -5,7 +5,7 @@
 #include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
 #include <nbl/builtin/hlsl/math/geometry.hlsl>
 #include <nbl/builtin/hlsl/shapes/util.hlsl>
-#include "curves.h"
+#include "Curves.h"
 
 // holds values for `LineStyle` struct and caculates stipple pattern re values, cant think of better name
 struct LineStyleInfo

62_CAD/curves.cpp

@@ -1,5 +1,5 @@
 
-#include "curves.h"
+#include "Curves.h"
 #include <nbl/builtin/hlsl/math/quadrature/gauss_legendre/gauss_legendre.hlsl>
 #include <nbl/builtin/hlsl/shapes/util.hlsl>
 #include <nbl/builtin/hlsl/math/equations/quadratic.hlsl>

62_CAD/main.cpp

@@ -18,14 +18,13 @@ using namespace video;
 #include "glm/glm/glm.hpp"
 #include <nbl/builtin/hlsl/cpp_compat.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
-#include "curves.h"
+#include "Curves.h"
 #include "Hatch.h"
 #include "Polyline.h"
 #include "DrawResourcesFiller.h"
 
 #include "nbl/video/surface/CSurfaceVulkan.h"
 #include "nbl/ext/FullScreenTriangle/FullScreenTriangle.h"
-#include "nbl/core/containers/LRUCache.h"
 
 #include <chrono>
 #define BENCHMARK_TILL_FIRST_FRAME