加入新的自定义相机类型

Author: KingRichord

example/CustomCam/cus_cam.cpp

@@ -0,0 +1,50 @@
+#include "cus_cam.h"
+#include "infinite_sense.h"
+namespace infinite_sense {
+
+ CustomCam::~CustomCam() {
+
+ }
+
+bool CustomCam::Initialization() {
+  return true;
+}
+
+void CustomCam::Stop() {
+  Disable();
+  std::this_thread::sleep_for(std::chrono::milliseconds{500});
+  for (auto &cam_thread : cam_threads_) {
+    while (cam_thread.joinable()) {
+      cam_thread.join();
+    }
+  }
+  cam_threads_.clear();
+  cam_threads_.shrink_to_fit();
+}
+void CustomCam::Receive(void *handle, const std::string &name)  {
+  while (is_running_) {
+      // 这里的time_stamp_us是相机触发时间，需要加上曝光时间的一半，以获得相机拍摄的时间
+      if (params_.find(name) == params_.end()) {
+        LOG(ERROR) << "cam " << name << " not found!";
+      }
+      else {
+        if (uint64_t time; GET_LAST_TRIGGER_STATUS(params_[name], time)) {
+          cam_data.time_stamp_us = time;
+        }
+        else {
+          LOG(ERROR) << "cam " << name << " not found!";
+        }
+      }
+
+      cam_data.image = GMat(st_out_frame.stFrameInfo.nHeight, st_out_frame.stFrameInfo.nWidth,
+                                GMatType<uint8_t, 1>::Type, st_out_frame.pBufAddr);
+
+      messenger.PubStruct(name,&cam_data,sizeof(cam_data));
+      std::this_thread::sleep_for(std::chrono::milliseconds{2});
+    }
+}
+void CustomCam::Start() {
+  std::string name = "cam";
+  cam_threads_.emplace_back(&CustomCam::Receive, this, nullptr, name);
+}
+}  // namespace infinite_sense

example/CustomCam/cus_cam.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "infinite_sense.h"
+namespace infinite_sense {
+class CustomCam final : public Cam {
+ public:
+  explicit CustomCam(const std::map<std::string, TriggerDevice>& params) : params_(params) {}
+  ~CustomCam() override;
+
+  CustomCam(const CustomCam&) = delete;
+  CustomCam& operator=(const CustomCam&) = delete;
+
+  bool Initialization() override;
+  void Stop() override;
+  void Start() override;
+
+ private:
+  void Receive(void* handle, const std::string&) override;
+};
+}  // namespace infinite_sense

example/GigeCam/mvcam.cpp example/GigeCam/mv_cam.cppexample/GigeCam/mvcam.cpp renamed to example/GigeCam/mv_cam.cpp

@@ -1,4 +1,4 @@
-#include "mvcam.h"
+#include "mv_cam.h"
 #include "infinite_sense.h"
 #include "MvCameraControl.h"
 namespace infinite_sense {

example/GigeCam/mvcam.h example/GigeCam/mv_cam.hexample/GigeCam/mvcam.h renamed to example/GigeCam/mv_cam.h

@@ -6,13 +6,9 @@ class CamManger final : public Cam {
   explicit CamManger(const std::map<std::string, TriggerDevice>& params) : params_(params) {}
   ~CamManger() override;
 
-  CamManger(const CamManger&) = delete;
-  CamManger& operator=(const CamManger&) = delete;
-
   bool Initialization() override;
   void Stop() override;
   void Start() override;
-  void Restart() override;
 
  private:
   void Receive(void* handle, const std::string&) override;

infinite_sense_core/include/cam.h

@@ -16,14 +16,23 @@ class Cam{
   virtual bool Initialization();
   virtual void Stop();
   virtual void Start();
-  virtual void Restart();
+  virtual void Restart() {
+      Stop();
+      std::this_thread::sleep_for(std::chrono::milliseconds{500});
+      if (!Initialization()) {
+        LOG(INFO) << "Camera initialization failed after restart!";
+      } else {
+        Start();
+        LOG(INFO) << "Cameras successfully restarted!";
+      }
+  }
   void Enable() { is_running_ = true; }
   void Disable() { is_running_ = false; }
 private:
   virtual void Receive(void* handle, const std::string&);
   bool is_running_{false};
-  std::vector<std::thread> cam_threads_;
-  std::map<std::string, TriggerDevice> params_;
+  std::vector<std::thread> cam_threads_{};
+  std::map<std::string, TriggerDevice> params_{};
 };
 
 }  // namespace infinite_sense

infinite_sense_core/src/infinite_sense.cpp

@@ -3,7 +3,7 @@
 #include "trigger.h"
 #include "net.h"
 #include "usb.h"
-#include "../../example/GigeCam/mvcam.h"
+#include "../../example/GigeCam/mv_cam.h"
 #include "messenger.h"
 #include "log.h"