Replace soon to be deprecated emg::Buffer<> with std::vector<>

Author: parnham

include/iconograph/canvas.h

@@ -17,7 +17,7 @@ class Canvas : public QLabel
 			Select
 		};
 
-		Canvas(QWidget *parent = 0, Qt::WindowFlags f = 0);
+		Canvas(QWidget *parent = 0, Qt::WindowFlags f = {});
 //		~Canvas() {}
 
 

include/iconograph/mainwindow.h

@@ -123,7 +123,7 @@ class MainWindow : public QMainWindow
 
 		psinc::ImageHandler<uint16_t> hdrHandler;
 		emg::Image<uint16_t, emg::rgb> hdrImage;
-		emg::Buffer<int> histogram;
+		std::array<int, 4096> histogram;
 
 
 //		bool lensCorrect	= false;

include/psinc/Camera.h

@@ -136,10 +136,10 @@ namespace psinc
 
 			/// Byte buffer containing the packet to be transmitted to the actual device
 			/// this class represents.
-			emg::Buffer<byte> send;
+			std::vector<byte> send;
 
 			/// Byte buffer used to receive data from the device during a capture.
-			emg::Buffer<byte> receive;
+			std::vector<byte> receive;
 
 
 			/// Image capture complete callback

include/psinc/Transport.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <emergent/Emergent.hpp>
-#include <emergent/struct/Buffer.hpp>
 // #include <psinc/TransportBuffer.hpp>
 #include <libusb-1.0/libusb.h>
 #include <atomic>
@@ -46,7 +45,7 @@ namespace psinc
 
 
 			/// Transfer packets to and from the actual device
-			bool Transfer(emg::Buffer<byte> *send, emg::Buffer<byte> *receive, std::atomic<bool> &waiting, bool check = true, bool truncate = false);
+			bool Transfer(std::vector<byte> *send, std::vector<byte> *receive, std::atomic<bool> &waiting, bool check = true, bool truncate = false);
 
 
 			/// Reset the connection to the actual device.
@@ -93,7 +92,7 @@ namespace psinc
 
 
 			/// Tranfer the given data to the device (write) or from the device (!write)
-			bool Transfer(emg::Buffer<byte> *buffer, bool write, bool check, bool truncate);
+			bool Transfer(std::vector<byte> *buffer, bool write, bool check, bool truncate);
 
 
 			/// Releases the device.

include/psinc/driver/Device.h

@@ -58,7 +58,7 @@ namespace psinc
 
 
 			/// Write the binary data to the device
-			bool Write(const emg::Buffer<byte> &buffer);
+			bool Write(const std::vector<byte> &buffer);
 
 
 			/// Write the binary data to the device
@@ -70,12 +70,12 @@ namespace psinc
 
 
 			/// Read binary data from the device
-			emg::Buffer<byte> Read();
+			std::vector<byte> Read();
 
 
 			/// Read binary data from the device into the supplied buffer. The buffer size
 			/// is used to determine how much data can be received from the device
-			bool Read(emg::Buffer<byte> &buffer);
+			bool Read(std::vector<byte> &buffer);
 
 
 			/// Set the channel for this device. Will return the channel information including

include/psinc/driver/Register.h

@@ -39,7 +39,7 @@ namespace psinc
 			/// When performing a full refresh of all registers, the values are returned
 			/// in page blocks and this is used to update a particular register from that
 			/// data block.
-			void Refresh(emg::Buffer<byte> &data);
+			void Refresh(std::vector<byte> &data);
 
 
 			/// Returns the address of this particular register

include/psinc/handlers/DataHandler.hpp

@@ -16,7 +16,7 @@ namespace psinc
 			virtual ~DataHandler() {}
 
 			/// Process the data in the supplied buffer using the known width and height of the image
-			virtual bool Process(bool monochrome, bool hdr, emg::Buffer<emg::byte> &data, int width, int height, emg::byte bayerMode) = 0;
+			virtual bool Process(bool monochrome, const bool hdr, const std::vector<emg::byte> &data, const int width, const int height, const emg::byte bayerMode) = 0;
 
 			// This should only be written to by the acquisition system, but can be read
 			// from outside to know when the USB transport has prepped the camera for

include/psinc/handlers/ImageHandler.hpp

@@ -7,7 +7,6 @@
 #include <emergent/image/Image.hpp>
 
 
-
 namespace psinc
 {
 	enum class DecodeMode
@@ -28,8 +27,6 @@ namespace psinc
 			struct Configuration
 			{
 				DecodeMode mode = DecodeMode::Automatic;
-				// bool forceBayer = false;
-				// Filter::Configuration filter;
 			};
 
 			ImageHandler() {}
@@ -62,7 +59,7 @@ namespace psinc
 			}
 
 
-			bool Process(bool monochrome, bool hdr, emg::Buffer<byte> &data, int width, int height, byte bayerMode) override
+			bool Process(bool monochrome, const bool hdr, const std::vector<byte> &data, const int width, const int height, const byte bayerMode) override
 			{
 				// Allow the monochrome flag to be overridden - could have unexpected effects.
 				switch (configuration.mode)
@@ -73,25 +70,25 @@ namespace psinc
 					default:													break;
 				}
 
-				int w = monochrome ? width : width - 4;
-				int h = monochrome ? height : height - 4;
+				const int w = monochrome ? width : width - 4;
+				const int h = monochrome ? height : height - 4;
 
-				if (w > 0 && h > 0 && data.Size() == width * height * (hdr ? 2 : 1))
+				if (w > 0 && h > 0 && data.size() == width * height * (hdr ? 2 : 1))
 				{
-					int depth = this->image->Depth();
+					const byte depth = this->image->Depth();
 					this->image->Resize(w, h);
 
 					if (hdr)
 					{
-						if (monochrome)			Monochrome::Decode((uint16_t *)data.Data(), this->image->Data(), width, height, depth, this->shiftBits);
-						else if (depth == 3)	Bayer::Colour((uint16_t *)data.Data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
-						else					Bayer::Grey((uint16_t *)data.Data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
+						if (monochrome)			Monochrome::Decode((uint16_t *)data.data(), this->image->Data(), width, height, depth, this->shiftBits);
+						else if (depth == 3)	Bayer::Colour((uint16_t *)data.data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
+						else					Bayer::Grey((uint16_t *)data.data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
 					}
 					else
 					{
-						if (monochrome)			Monochrome::Decode(data.Data(), this->image->Data(), width, height, depth, this->shiftBits);
-						else if (depth == 3)	Bayer::Colour(data.Data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
-						else					Bayer::Grey(data.Data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
+						if (monochrome)			Monochrome::Decode(data.data(), this->image->Data(), width, height, depth, this->shiftBits);
+						else if (depth == 3)	Bayer::Colour(data.data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
+						else					Bayer::Grey(data.data(), this->image->Data(), width, height, bayerMode, this->shiftBits);
 					}
 
 					// Filter::Process(this->configuration.filter, *this->image);

include/psinc/handlers/NoopHandler.hpp

@@ -12,7 +12,7 @@ namespace psinc
 		public:
 
 			// Refer to parent documentation
-			bool Process(bool monochrome, bool hdr, emg::Buffer<emg::byte> &data, int width, int height, emg::byte bayerMode) override
+			bool Process(bool monochrome, const bool hdr, const std::vector<emg::byte> &data, const int width, const int height, const emg::byte bayerMode) override
 			{
 				return true;
 			}

include/psinc/handlers/helpers/Bayer.hpp

@@ -57,10 +57,10 @@ namespace psinc
 			}
 
 
-			static inline void Clamp(int value, uint16_t*, uint16_t *dst, const uint16_t)	{ *dst = value > 65535 ? 65535 : value < 0 ? 0 : value; }
-			static inline void Clamp(int value, uint16_t*, byte *dst, const uint16_t shift)	{ value = value >> shift; *dst = value > 255 ? 255 : value < 0 ? 0 : value; }
-			static inline void Clamp(int value, byte*, uint16_t *dst, const uint16_t)		{ *dst = value < 0 ? 0 : value; }
-			static inline void Clamp(int value, byte*, byte *dst, const uint16_t)			{ *dst = value > 255 ? 255 : value < 0 ? 0 : value; }
+			static inline void Clamp(int value, const uint16_t*, uint16_t *dst, const uint16_t)		{ *dst = value > 65535 ? 65535 : value < 0 ? 0 : value; }
+			static inline void Clamp(int value, const uint16_t*, byte *dst, const uint16_t shift)	{ value = value >> shift; *dst = value > 255 ? 255 : value < 0 ? 0 : value; }
+			static inline void Clamp(int value, const byte*, uint16_t *dst, const uint16_t)			{ *dst = value < 0 ? 0 : value; }
+			static inline void Clamp(int value, const byte*, byte *dst, const uint16_t)				{ *dst = value > 255 ? 255 : value < 0 ? 0 : value; }
 
 
 			// Even row

packages/debian/changelog

@@ -1,3 +1,9 @@
+libpsinc0 (0.1.42) unstable; urgency=medium
+
+  * Replace soon to be deprecated emg::Buffer<> with std::vector<>
+
+ -- Dan Parnham <dan@emergent-design.co.uk>  Wed, 21 Dec 2022 11:51:14 +0000
+
 libpsinc0 (0.1.41) unstable; urgency=medium
 
   * Patch the patch so that it compiles.

packages/version

@@ -1 +1 @@
-0.1.41
+0.1.42

src/examples/build.sh

@@ -2,9 +2,9 @@
 
 for var in "$@"; do
 	if [ "$var" = "control-flash.cpp" ]; then
-		clang++ -O3 -o ${var%.*} -std=c++14 $var -lserialport -lpthread
+		clang++ -g -O3 -o ${var%.*} -std=c++17 $var -lserialport -lpthread
 	else
-		clang++ -O3 -o ${var%.*} -std=c++14 $var -lpsinc -lfreeimage -lpthread
+		clang++ -g -O3 -o ${var%.*} -std=c++17 $var -lpsinc -lfreeimage -lpthread
 	fi
 done
 

src/examples/capture-images.cpp

@@ -2,9 +2,16 @@
 #include <psinc/Camera.h>
 #include <psinc/handlers/ImageHandler.hpp>
 
-using namespace std;
-using namespace emg;
-using namespace psinc;
+// using namespace std;
+// using namespace emg;
+// using namespace psinc;
+using namespace std::chrono_literals;
+
+using psinc::Camera;
+using psinc::ImageHandler;
+using emg::Image;
+using emg::byte;
+
 
 void CaptureMonoImage(Camera &camera, ImageHandler<byte> &handler)
 {
@@ -31,7 +38,10 @@ void CaptureMonoImage(Camera &camera, ImageHandler<byte> &handler)
 	// Need to make sure we've finished grabbing before re-using the camera
 	// or exiting the program (as the grab call is asynchronous and we're 
 	// calling it from a trivial single-thread application)
-	while (camera.Grabbing()) this_thread::sleep_for(1ms);
+	while (camera.Grabbing())
+	{
+		std::this_thread::sleep_for(1ms);
+	}
 
 }
 
@@ -61,7 +71,10 @@ void CaptureColourImage(Camera &camera, ImageHandler<byte> &handler)
 	// Need to make sure we've finished grabbing before re-using the camera
 	// or exiting the program (as the grab call is asynchronous and we're 
 	// calling it from a trivial single-thread application)
-	while (camera.Grabbing()) this_thread::sleep_for(1ms);
+	while (camera.Grabbing())
+	{
+		std::this_thread::sleep_for(1ms);
+	}
 }
 
 
@@ -90,7 +103,11 @@ void CaptureHdrMonoImage(Camera &camera, ImageHandler<uint16_t> &handler)
 	// Need to make sure we've finished grabbing before re-using the camera
 	// or exiting the program (as the grab call is asynchronous and we're 
 	// calling it from a trivial single-thread application)
-	while (camera.Grabbing()) this_thread::sleep_for(1ms);
+	while (camera.Grabbing())
+	{
+		std::this_thread::sleep_for(1ms);
+	}
+
 }
 
 
@@ -119,14 +136,17 @@ void CaptureHdrColourImage(Camera &camera, ImageHandler<uint16_t> &handler)
 	// Need to make sure we've finished grabbing before re-using the camera
 	// or exiting the program (as the grab call is asynchronous and we're 
 	// calling it from a trivial single-thread application)
-	while (camera.Grabbing()) this_thread::sleep_for(1ms);
+	while (camera.Grabbing())
+	{
+		std::this_thread::sleep_for(1ms);
+	}
 }
 
 
 int main(int argc, char *argv[])
 {
-	cout << "This test application connects to the first camera it finds" << endl;
-	cout << "and captures various types of image" << endl;
+	std::cout << "This test application connects to the first camera it finds\n";
+	std::cout << "and captures various types of image\n";
 
 	Camera camera;
 
@@ -144,7 +164,10 @@ int main(int argc, char *argv[])
 	// thread like this - using the callback function as shown
 	// in https://github.com/emergent-design/libpsinc/wiki#camera
 	// is a better idea.
-	while (!camera.Connected()) this_thread::sleep_for(1ms);
+	while (!camera.Connected())
+	{
+		std::this_thread::sleep_for(1ms);
+	}
 
 	//Use the camera and normal image handler for byte images
 	CaptureMonoImage(camera, handler);

src/iconograph/canvas.cpp

@@ -161,15 +161,18 @@ void Canvas::wheelEvent(QWheelEvent *event)
 			this->offset	= this->rect.topLeft();
 		}
 
+		const auto position = event->position();
+
 		// Origin of zoom in image space
-		double x		= (event->x() - this->offset.x()) / this->zoom;
-		double y		= (event->y() - this->offset.y()) / this->zoom;
+		const double x	= (position.x() - this->offset.x()) / this->zoom;
+		const double y	= (position.y() - this->offset.y()) / this->zoom;
 
-		double step		= event->delta() < 0 ? -0.05 : 0.05;
+//		double step		= event->delta() < 0 ? -0.05 : 0.05;
+		double step		= event->angleDelta().y() < 0 ? -0.05 : 0.05;
 		this->zoom		= std::max(this->minScale, std::min(1.0, this->zoom + step));
 		this->offset	= {
-			(int)lrint(event->x() - this->zoom * x),
-			(int)lrint(event->y() - this->zoom * y)
+			(int)lrint(position.x() - this->zoom * x),
+			(int)lrint(position.y() - this->zoom * y)
 		};
 	}
 }

src/iconograph/mainwindow.cpp

@@ -138,8 +138,7 @@ QImage *MainWindow::ConvertWindow()
 	int jump		= (width - rw) * 3;
 	uint16_t *src	= this->hdrImage + roi.top() * width * 3 + roi.left() * 3;
 
-	this->histogram.Resize(4096);
-	this->histogram.Clear();
+	this->histogram.fill(0);
 
 	for (y=0; y<rh; y++, src+=jump)
 	{
@@ -323,7 +322,7 @@ template <typename T> std::array<int64_t, 7> GetRegionMeans(const emg::Image<T,
 	auto sum		= std::array<int64_t, 3>{ 0, 0, 0 };
 	auto bayer		= std::array<int64_t, 4> { 0, 0, 0, 0 };
 	auto tally		= std::array<int, 4> { 0, 0, 0, 0 };
-	T *src			= image + sy * width * 3 + sx * 3;
+	auto *src		= image + sy * width * 3 + sx * 3;
 
 	for (int y=0; y<roi.height(); y++, src+=jump)
 	{

src/psinc-c/device.cpp

@@ -52,14 +52,14 @@ extern "C"
 
 		// Perhaps we need some sort of buffer view to handle this case without
 		// unnecessary memory allocation and copying.
-		Buffer<emg::byte> data(size);
+		std::vector<emg::byte> data(size);
 
 		if (c->devices.count(device))
 		{
 			if (c->devices[device].Read(data))
 			{
-				used = data.Size();
-				memcpy(buffer, data.Data(), used);
+				used = data.size();
+				memcpy(buffer, data.data(), used);
 				return PSINC_OK;
 			}
 			else return PSINC_CAMERA_IO_ERROR;