rmcv  v0.1.0
A library for RoboMaster computer vision based on OpenCV.
daheng.h
1 //
2 // Created by yaione on 3/7/22.
3 //
4 
5 #ifndef RMCV_DAHENG_H
6 #define RMCV_DAHENG_H
7 
8 #include "daheng/GxIAPI.h"
9 #include "daheng/DxImageProc.h"
10 #include <iostream>
11 #include <opencv2/opencv.hpp>
12 #include <cstdlib>
13 
14 using namespace std;
15 using namespace cv;
16 
17 namespace rm {
18  class DahengCamera {
19  private:
20  GX_STATUS status = GX_STATUS_SUCCESS;
21  GX_DEV_HANDLE hDevice = nullptr;
22  GX_FRAME_DATA frameData{};
23  void *pRaw8Buffer = nullptr;
24  void *pMirrorBuffer = nullptr;
25  void *pRGBframeData = nullptr;
26  int64_t PixelFormat = GX_PIXEL_FORMAT_BAYER_GR8;
27  int64_t ColorFilter = GX_COLOR_FILTER_NONE;
28 
29 
30  public:
31  long fps = 0;
32  int64_t SensorWidth = -1, SensorHeight = -1;
33 
40  bool
41  dahengCameraInit(char *sn, bool autoWhiteBalance = false, int expoosureTime = 2000, double gainFactor = 1.0) {
42  GXInitLib();
43 
44  auto *openParam = new GX_OPEN_PARAM;
45  openParam->openMode = GX_OPEN_SN;
46  openParam->accessMode = GX_ACCESS_EXCLUSIVE;
47  openParam->pszContent = sn;
48  status = GXOpenDevice(openParam, &hDevice);
49  if (status != GX_STATUS_SUCCESS) {
50  return false;
51  }
52 
53  int64_t nPayLoadSize = 0;
54 
55  status = GXGetInt(hDevice, GX_INT_PAYLOAD_SIZE, &nPayLoadSize);
56  if (status != GX_STATUS_SUCCESS) {
57  return false;
58  }
59 
60  frameData.pImgBuf = malloc((size_t) nPayLoadSize);
61  GXGetInt(hDevice, GX_INT_SENSOR_WIDTH, &SensorWidth);
62  GXGetInt(hDevice, GX_INT_SENSOR_HEIGHT, &SensorHeight);
63 
64  pRaw8Buffer = malloc(nPayLoadSize);
65  pMirrorBuffer = malloc(nPayLoadSize * 3);
66  pRGBframeData = malloc(nPayLoadSize * 3);
67  GXGetEnum(hDevice, GX_ENUM_PIXEL_FORMAT, &PixelFormat);
68  GXGetEnum(hDevice, GX_ENUM_PIXEL_COLOR_FILTER, &ColorFilter);
69  GXSetEnum(hDevice, GX_ENUM_ACQUISITION_MODE, GX_ACQ_MODE_CONTINUOUS);
70 
71  GXSetEnum(hDevice, GX_ENUM_BALANCE_WHITE_AUTO,
72  autoWhiteBalance ? GX_BALANCE_WHITE_AUTO_CONTINUOUS : GX_BALANCE_WHITE_AUTO_OFF);
73  GXSetFloat(hDevice, GX_FLOAT_EXPOSURE_TIME, expoosureTime);
74 
75  GXSetEnum(hDevice, GX_ENUM_GAIN_SELECTOR, GX_GAIN_SELECTOR_ALL);
76  GX_FLOAT_RANGE gainRange;
77  GXGetFloatRange(hDevice, GX_FLOAT_GAIN, &gainRange);
78  GXSetFloat(hDevice, GX_FLOAT_GAIN, gainRange.dMax * gainFactor);
79 
80  status = GXSendCommand(hDevice, GX_COMMAND_ACQUISITION_START);
81  if (status != GX_STATUS_SUCCESS) {
82  return false;
83  }
84  return true;
85  }
86 
87  ~DahengCamera() {
88  status = GXSendCommand(hDevice, GX_COMMAND_ACQUISITION_STOP);
89 
90  free(frameData.pImgBuf);
91  frameData.pImgBuf = nullptr;
92  free(pRaw8Buffer);
93  pRaw8Buffer = nullptr;
94  free(pRGBframeData);
95  pRGBframeData = nullptr;
96 
97  GXCloseDevice(hDevice);
98  GXCloseLib();
99  }
100 
101  Mat getFrame(bool flip = false, bool mirror = false) {
102  if (GXGetImage(hDevice, &frameData, 100) == GX_STATUS_SUCCESS) {
103  if (frameData.nStatus == 0) {
104  ProcessData(frameData.pImgBuf, pRaw8Buffer, pRGBframeData, frameData.nWidth, frameData.nHeight,
105  (int) PixelFormat, mirror ? 2 : 4, flip, mirror);
106  fps++;
107  Mat src(Size(frameData.nWidth, frameData.nHeight), CV_8UC3, pRGBframeData);
108  return src;
109  }
110  }
111 
112  return {};
113  }
114 
115  void ProcessData(void *pImageBuf, void *pImageRaw8Buf, void *pImageRGBBuf, int nImageWidth, int nImageHeight,
116  int nPixelFormat, int nPixelColorFilter, bool flip = false, bool mirror = false) {
117  switch (nPixelFormat) {
118  case GX_PIXEL_FORMAT_BAYER_GR12:
119  case GX_PIXEL_FORMAT_BAYER_RG12:
120  case GX_PIXEL_FORMAT_BAYER_GB12:
121  case GX_PIXEL_FORMAT_BAYER_BG12:
122  if (mirror) {
123  DxImageMirror(pImageBuf, pMirrorBuffer, nImageWidth, nImageHeight, HORIZONTAL_MIRROR);
124  DxRaw16toRaw8(pMirrorBuffer, pImageRaw8Buf, nImageWidth, nImageHeight, DX_BIT_4_11);
125  DxRaw8toRGB24(pImageRaw8Buf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
126  DX_PIXEL_COLOR_FILTER(nPixelColorFilter), flip);
127  } else {
128  DxRaw16toRaw8(pImageBuf, pImageRaw8Buf, nImageWidth, nImageHeight, DX_BIT_4_11);
129  DxRaw8toRGB24(pImageRaw8Buf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
130  DX_PIXEL_COLOR_FILTER(nPixelColorFilter), flip);
131  }
132  break;
133 
134  case GX_PIXEL_FORMAT_BAYER_GR10:
135  case GX_PIXEL_FORMAT_BAYER_RG10:
136  case GX_PIXEL_FORMAT_BAYER_GB10:
137  case GX_PIXEL_FORMAT_BAYER_BG10:
138  if (mirror) {
139  DxImageMirror(pImageBuf, pMirrorBuffer, nImageWidth, nImageHeight, HORIZONTAL_MIRROR);
140  DxRaw16toRaw8(pMirrorBuffer, pImageRaw8Buf, nImageWidth, nImageHeight, DX_BIT_2_9);
141  DxRaw8toRGB24(pImageRaw8Buf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
142  DX_PIXEL_COLOR_FILTER(nPixelColorFilter), flip);
143  } else {
144  DxRaw16toRaw8(pImageBuf, pImageRaw8Buf, nImageWidth, nImageHeight, DX_BIT_2_9);
145  DxRaw8toRGB24(pImageRaw8Buf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
146  DX_PIXEL_COLOR_FILTER(nPixelColorFilter), flip);
147  }
148  break;
149 
150  case GX_PIXEL_FORMAT_BAYER_GR8:
151  case GX_PIXEL_FORMAT_BAYER_RG8:
152  case GX_PIXEL_FORMAT_BAYER_GB8:
153  case GX_PIXEL_FORMAT_BAYER_BG8:
154  if (mirror) {
155  DxImageMirror(pImageBuf, pMirrorBuffer, nImageWidth, nImageHeight, HORIZONTAL_MIRROR);
156  DxRaw8toRGB24(pMirrorBuffer, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
157  DX_PIXEL_COLOR_FILTER(nPixelColorFilter), flip); //RAW2RGB_ADAPTIVE
158  } else {
159  DxRaw8toRGB24(pImageBuf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
160  DX_PIXEL_COLOR_FILTER(nPixelColorFilter), flip); //RAW2RGB_ADAPTIVE
161  }
162  break;
163 
164  case GX_PIXEL_FORMAT_MONO12:
165  case GX_PIXEL_FORMAT_MONO10:
166  if (mirror) {
167  DxImageMirror(pImageBuf, pMirrorBuffer, nImageWidth, nImageHeight, HORIZONTAL_MIRROR);
168  DxRaw16toRaw8(pMirrorBuffer, pImageRaw8Buf, nImageWidth, nImageHeight, DX_BIT_4_11);
169  DxRaw8toRGB24(pImageRaw8Buf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
170  DX_PIXEL_COLOR_FILTER(NONE), flip);
171  } else {
172  DxRaw16toRaw8(pImageBuf, pImageRaw8Buf, nImageWidth, nImageHeight, DX_BIT_4_11);
173  DxRaw8toRGB24(pImageRaw8Buf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
174  DX_PIXEL_COLOR_FILTER(NONE), flip);
175  }
176  break;
177 
178  case GX_PIXEL_FORMAT_MONO8:
179  if (mirror) {
180  DxImageMirror(pImageBuf, pMirrorBuffer, nImageWidth, nImageHeight, HORIZONTAL_MIRROR);
181  DxRaw8toRGB24(pMirrorBuffer, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
182  DX_PIXEL_COLOR_FILTER(NONE), flip);
183  } else {
184  DxRaw8toRGB24(pImageBuf, pImageRGBBuf, nImageWidth, nImageHeight, RAW2RGB_NEIGHBOUR,
185  DX_PIXEL_COLOR_FILTER(NONE), flip);
186  }
187  break;
188 
189  default:
190  break;
191  }
192  }
193  };
194 }
195 
196 
197 #endif //RMCV_DAHENG_H
rm::DahengCamera
Definition: daheng.h:18
rm
Main modules.
Definition: daheng.h:17
rm::DahengCamera::dahengCameraInit
bool dahengCameraInit(char *sn, bool autoWhiteBalance=false, int expoosureTime=2000, double gainFactor=1.0)
Definition: daheng.h:41
Generated by   doxygen 1.8.17