Refactor lightfields bezier

.vscode/settings.json

@@ -1,6 +1,7 @@
 {
     "C_Cpp.intelliSenseEngineFallback": "Disabled",
     "files.associations": {
+        "*.inl": "cpp",
         "functional": "cpp",
         "hash_map": "cpp",
         "unordered_map": "cpp",
@@ -71,6 +72,8 @@
         "typeinfo": "cpp",
         "variant": "cpp",
         "bit": "cpp",
-        "compare": "cpp"
+        "compare": "cpp",
+        "*.ipp": "cpp",
+        "valarray": "cpp"
     }
 }

src/libs/lightfields/nearest_integration.cpp

@@ -22,29 +22,29 @@ IntegrationResult integrate(const lightfields::Samples& samples, const Imath::Ve
 	const float widthf = width;
 	const float heightf = height;
 
-	tbb::parallel_for(
-	    tbb::blocked_range<lightfields::Samples::const_iterator>(samples.begin(), samples.end()),
-	    [&](const tbb::blocked_range<lightfields::Samples::const_iterator> range) {
-		    for(const lightfields::Samples::Sample& sample : range) {
-			    const float target_x = (sample.xy[0] + offset * sample.uv[0]) * x_scale;
-			    const float target_y = (sample.xy[1] + offset * sample.uv[1]) * y_scale;
-
-			    if((target_x >= 0.0f) && (target_y >= 0.0f) && (target_x < widthf) && (target_y < heightf)) {
-				    float* color = average.ptr<float>(floor(target_y), floor(target_x));
-				    uint16_t* n = norm.ptr<uint16_t>(floor(target_y), floor(target_x));
-
-				    if(sample.color == lightfields::Samples::kRGB)
-					    for(int a = 0; a < 3; ++a) {
-						    color[a] += sample.value[a];
-						    ++n[a];
-					    }
-				    else {
-					    color[sample.color] += sample.value[sample.color];
-					    ++n[sample.color];
-				    }
-			    }
-		    }
-	    });
+	const tbb::blocked_range<lightfields::Samples::const_iterator> range(samples.begin(), samples.end());
+
+	tbb::parallel_for(range, [&](const tbb::blocked_range<lightfields::Samples::const_iterator> range) {
+		for(const lightfields::Samples::Sample& sample : range) {
+			const float target_x = (sample.xy[0] + offset * sample.uv[0]) * x_scale;
+			const float target_y = (sample.xy[1] + offset * sample.uv[1]) * y_scale;
+
+			if((target_x >= 0.0f) && (target_y >= 0.0f) && (target_x < widthf) && (target_y < heightf)) {
+				float* color = average.ptr<float>(floor(target_y), floor(target_x));
+				uint16_t* n = norm.ptr<uint16_t>(floor(target_y), floor(target_x));
+
+				if(sample.color == lightfields::Samples::kRGB)
+					for(int a = 0; a < 3; ++a) {
+						color[a] += sample.value[a];
+						++n[a];
+					}
+				else {
+					color[sample.color] += sample.value[sample.color];
+					++n[sample.color];
+				}
+			}
+		}
+	});
 
 	tbb::parallel_for(0, average.rows, [&](int y) {
 		for(int x = 0; x < average.cols; ++x)

src/libs/lightfields/samples.cpp

@@ -6,7 +6,7 @@
 
 namespace lightfields {
 
-Samples::Samples() {
+Samples::Samples(const Imath::V2i& sensor) : m_size(sensor) {
 }
 
 Samples::~Samples() {
@@ -65,6 +65,14 @@ Samples::const_iterator Samples::end() const {
 	return m_samples.end();
 }
 
+Samples::iterator Samples::begin() {
+	return m_samples.begin();
+}
+
+Samples::iterator Samples::end() {
+	return m_samples.end();
+}
+
 std::size_t Samples::size() const {
 	return m_samples.size();
 }
@@ -160,6 +168,20 @@ Samples Samples::fromPattern(const Pattern& pattern, const cv::Mat& m) {
 	return result;
 }
 
+void Samples::resize(std::size_t size) {
+	m_samples.resize(size);
+}
+
+Samples::Sample& Samples::operator[](std::size_t index) {
+	assert(index < m_samples.size());
+	return m_samples[index];
+}
+
+const Samples::Sample& Samples::operator[](std::size_t index) const {
+	assert(index < m_samples.size());
+	return m_samples[index];
+}
+
 /////////
 
 std::ostream& operator<<(std::ostream& out, const Samples& f) {

src/libs/lightfields/samples.h

@@ -23,7 +23,7 @@ class Samples {
 		Imath::V3f value;  ///< Sample colour value (only the valid channels are populated)
 	};
 
-	Samples();
+	Samples(const Imath::V2i& sensorSize = Imath::V2i(0, 0));
 	~Samples();
 
 	Samples(const Samples&) = default;
@@ -33,10 +33,14 @@ class Samples {
 	Samples& operator=(Samples&&) = default;
 
 	using const_iterator = std::vector<Sample>::const_iterator;
+	using iterator = std::vector<Sample>::iterator;
 
 	const_iterator begin() const;
 	const_iterator end() const;
 
+	iterator begin();
+	iterator end();
+
 	std::size_t size() const;
 	bool empty() const;
 
@@ -49,6 +53,10 @@ class Samples {
 
 	static Samples fromPattern(const Pattern& p, const cv::Mat& data);
 
+	void resize(std::size_t size);
+	Sample& operator[](std::size_t index);
+	const Sample& operator[](std::size_t index) const;
+
   private:
 	std::vector<Sample> m_samples;
 	Imath::V2i m_size;

src/plugins/opencv/bspline.h

@@ -10,26 +10,31 @@ namespace opencv {
 template <unsigned DEGREE>
 class BSpline {
   public:
-	BSpline(unsigned subdiv, const std::array<double, DEGREE>& min = initArray(0.0),
-	        const std::array<double, DEGREE>& max = initArray(1.0));
+	explicit BSpline(const std::array<std::size_t, DEGREE>& subdiv = initArray(std::size_t(0)));
 
-	void addSample(const std::array<double, DEGREE>& coords, double value);
-	double sample(const std::array<double, DEGREE>& coords) const;
+	void addSample(const std::array<float, DEGREE>& coords, float value);
+	float sample(const std::array<float, DEGREE>& coords) const;
+
+	std::size_t size(unsigned dim) const;
 
 	bool operator==(const BSpline& b) const;
 	bool operator!=(const BSpline& b) const;
 
   private:
-	static double B(double t, unsigned k);
+	static float B(float t, unsigned k);
 
 	template <typename FN>
-	inline void visit(const std::array<double, DEGREE>& coords, const FN& fn) const;
-	static std::array<double, DEGREE> initArray(double val);
+	inline void visit(const std::array<float, DEGREE>& coords, const FN& fn) const;
+
+	template <typename T>
+	static std::array<T, DEGREE> initArray(T val);
 
-	std::size_t m_subdiv;
+	std::array<std::size_t, DEGREE> m_subdiv;
 	std::vector<std::pair<float, float>> m_controls;
-	std::array<double, DEGREE> m_min, m_max;
 };
 
+template <unsigned DEGREE>
+std::ostream& operator<<(std::ostream& out, const BSpline<DEGREE>& spline);
+
 }  // namespace opencv
 }  // namespace possumwood