JeVois
1.17
JeVois Smart Embedded Machine Vision Toolkit
|
Share this page: |
|
|
|
 |
 |
|
Go to the documentation of this file.
21 #include <linux/videodev2.h>
36 #include <opencv2/core/hal/interface.h>
39 using namespace std::literals;
40 using namespace std::string_literals;
41 using namespace std::literals::string_literals;
46 if (fcc == 0)
return "NONE";
49 ret[0] =
static_cast<char>(fcc & 0xff);
50 ret[1] =
static_cast<char>((fcc >> 8) & 0xff);
51 ret[2] =
static_cast<char>((fcc >> 16) & 0xff);
52 ret[3] =
static_cast<char>((fcc >> 24) & 0xff);
62 uchar depth = cvtype & CV_MAT_DEPTH_MASK;
63 uchar chans = 1 + (cvtype >> CV_CN_SHIFT);
67 case CV_8U: r =
"8U";
break;
68 case CV_8S: r =
"8S";
break;
69 case CV_16U: r =
"16U";
break;
70 case CV_16S: r =
"16S";
break;
71 case CV_16F: r =
"16F";
break;
72 case CV_32S: r =
"32S";
break;
73 case CV_32F: r =
"32F";
break;
74 case CV_64F: r =
"64F";
break;
75 default: r =
"User";
break;
90 uchar depth = cvtype & CV_MAT_DEPTH_MASK;
91 uchar chans = 1 + (cvtype >> CV_CN_SHIFT);
95 case CV_8U: r = 1;
break;
96 case CV_8S: r = 1;
break;
97 case CV_16U: r = 2;
break;
98 case CV_16S: r = 2;
break;
99 case CV_16F: r = 2;
break;
100 case CV_32S: r = 4;
break;
101 case CV_32F: r = 4;
break;
102 case CV_64F: r = 4;
break;
103 default:
LFATAL(
"Unsupported OpenCV type " << cvtype);
112 if (str ==
"BAYER")
return V4L2_PIX_FMT_SRGGB8;
113 else if (str ==
"YUYV")
return V4L2_PIX_FMT_YUYV;
114 else if (str ==
"GREY" || str ==
"GRAY")
return V4L2_PIX_FMT_GREY;
115 else if (str ==
"MJPG")
return V4L2_PIX_FMT_MJPEG;
116 else if (str ==
"RGB565")
return V4L2_PIX_FMT_RGB565;
117 else if (str ==
"BGR24")
return V4L2_PIX_FMT_BGR24;
118 else if (str ==
"RGB3")
return V4L2_PIX_FMT_RGB24;
119 else if (str ==
"BGR3")
return V4L2_PIX_FMT_BGR24;
122 else if (str ==
"RGB24")
return V4L2_PIX_FMT_RGB24;
123 else if (str ==
"RGB32")
return V4L2_PIX_FMT_RGB32;
124 else if (str ==
"UYVY")
return V4L2_PIX_FMT_UYVY;
125 else if (str ==
"BAYER16")
return V4L2_PIX_FMT_SBGGR16;
126 else if (str ==
"NV12")
return V4L2_PIX_FMT_NV12;
127 else if (str ==
"YUV444")
return V4L2_PIX_FMT_YUV444;
132 else if (str ==
"NONE")
return 0;
133 else throw std::runtime_error(
"Invalid pixel format " + str);
141 case V4L2_PIX_FMT_YUYV:
return 2U;
142 case V4L2_PIX_FMT_GREY:
return 1U;
143 case V4L2_PIX_FMT_SRGGB8:
return 1U;
144 case V4L2_PIX_FMT_RGB565:
return 2U;
145 case V4L2_PIX_FMT_MJPEG:
return 2U;
146 case V4L2_PIX_FMT_BGR24:
return 3U;
147 case V4L2_PIX_FMT_RGB24:
return 3U;
148 case V4L2_PIX_FMT_RGB32:
return 4U;
149 case V4L2_PIX_FMT_UYVY:
return 2U;
150 case V4L2_PIX_FMT_SBGGR16:
return 2U;
151 case V4L2_PIX_FMT_NV12:
return 2U;
152 case V4L2_PIX_FMT_YUV444:
return 3U;
169 case V4L2_PIX_FMT_YUYV:
return 0x8000;
170 case V4L2_PIX_FMT_GREY:
return 0;
171 case V4L2_PIX_FMT_SRGGB8:
return 0;
172 case V4L2_PIX_FMT_RGB565:
return 0;
173 case V4L2_PIX_FMT_MJPEG:
return 0;
174 case V4L2_PIX_FMT_BGR24:
return 0;
175 case V4L2_PIX_FMT_RGB24:
return 0;
176 case V4L2_PIX_FMT_RGB32:
return 0;
177 case V4L2_PIX_FMT_UYVY:
return 0x8000;
178 case V4L2_PIX_FMT_SBGGR16:
return 0;
179 case V4L2_PIX_FMT_NV12:
return 0;
180 case V4L2_PIX_FMT_YUV444:
return 0x008080;
191 case V4L2_PIX_FMT_YUYV:
return 0x80ff;
192 case V4L2_PIX_FMT_GREY:
return 0xff;
193 case V4L2_PIX_FMT_SRGGB8:
return 0xff;
194 case V4L2_PIX_FMT_RGB565:
return 0xffff;
195 case V4L2_PIX_FMT_MJPEG:
return 0xff;
196 case V4L2_PIX_FMT_BGR24:
return 0xffffff;
197 case V4L2_PIX_FMT_RGB24:
return 0xffffff;
198 case V4L2_PIX_FMT_RGB32:
return 0xffffffff;
199 case V4L2_PIX_FMT_UYVY:
return 0xff80;
200 case V4L2_PIX_FMT_SBGGR16:
return 0xffff;
201 case V4L2_PIX_FMT_NV12:
return 0xffff;
202 case V4L2_PIX_FMT_YUV444:
return 0xff8080;
210 unsigned int const winw,
unsigned int const winh,
bool noalias)
212 if (imw == 0 || imh == 0 || winw == 0 || winh == 0)
LFATAL(
"Cannot handle zero width or height");
217 double const facw = double(winw) / imw, fach = double(winh) / imh;
218 double const minfac = std::min(facw, fach);
222 unsigned int const ifac = minfac;
223 imw *= ifac; imh *= ifac;
228 double const maxfac = std::max(facw, fach);
229 unsigned int const ifac = 1.0 / maxfac;
230 imw /= ifac; imh /= ifac;
236 double const ia = double(imw) / double (imh);
237 double const wa = double(winw) / double (winh);
244 imh = (
unsigned int)(imw / ia + 0.4999999);
251 imw = (
unsigned int)(imh * ia + 0.4999999);
257 std::vector<std::string>
jevois::split(std::string
const & input, std::string
const & regex)
261 std::regex re(regex);
262 std::sregex_token_iterator first{input.begin(), input.end(), re, -1}, last;
263 return { first, last };
267 std::string
jevois::join(std::vector<std::string>
const & strings, std::string
const & delimiter)
269 if (strings.empty())
return "";
270 if (strings.size() == 1)
return strings[0];
272 std::string ret;
size_t const szm1 = strings.size() - 1;
274 for (
size_t i = 0; i < szm1; ++i) ret += strings[i] + delimiter;
275 ret += strings[szm1];
283 return (strncmp(str.c_str(), prefix.c_str(), prefix.length()) == 0);
289 std::string ret = str;
290 for (
char & c : ret)
if (std::isspace(c)) c = rep;
297 int idx = str.length() - 1;
298 while (idx >= 0 && std::isspace(str[idx])) --idx;
299 return str.substr(0, idx + 1);
303 std::string
jevois::extractString(std::string
const & str, std::string
const & startsep, std::string
const & endsep)
305 size_t idx = str.find(startsep);
306 if (idx == std::string::npos)
return std::string();
307 idx += startsep.size();
309 if (endsep.empty())
return str.substr(idx);
311 size_t idx2 = str.find(endsep, idx);
312 if (idx2 == std::string::npos)
return std::string();
313 return str.substr(idx, idx2 - idx);
320 if (from.empty())
return 0;
322 size_t start_pos = str.find(from);
323 if (start_pos == std::string::npos)
return 0;
325 str.replace(start_pos, from.length(), to);
333 if (from.empty())
return 0;
335 size_t start_pos = 0, n = 0;
336 while((start_pos = str.find(from, start_pos)) != std::string::npos)
338 str.replace(start_pos, from.length(), to);
339 start_pos += to.length();
350 if (path.empty())
return root;
353 if (path[0] ==
'/')
return path;
356 if (root.empty())
return path;
359 return root +
'/' + path;
366 std::string vsformat(
char const * fmt, va_list ap)
369 if (fmt ==
nullptr || fmt[0] ==
'\0')
return std::string();
376 int const nchars = vsnprintf(buf, bufsize, fmt, ap);
382 LFATAL(
"vsnprintf failed for format '" << fmt <<
"' with bufsize = " << bufsize);
384 else if (nchars >= bufsize)
393 return std::string(&buf[0], nchars);
396 return std::string();
405 std::string result = vsformat(fmt, a);
413 #ifdef JEVOIS_PLATFORM_A33
414 std::ofstream ofs(
"/proc/sys/vm/drop_caches");
415 if (ofs.is_open()) ofs <<
"3" << std::endl;
416 else LERROR(
"Failed to flush cache -- ignored");
425 std::array<char, 128> buffer; std::string result;
426 std::shared_ptr<FILE> pip;
427 if (errtoo) pip.reset(popen((cmd +
" 2>&1").c_str(),
"r"), pclose);
428 else pip.reset(popen(cmd.c_str(),
"r"), pclose);
429 if (!pip)
LFATAL(
"popen() failed for command [" << cmd <<
']');
430 while (!feof(pip.get()))
if (fgets(buffer.data(), 128, pip.get()) != NULL) result += buffer.data();
438 else if (secs < 1.0e-3)
return jevois::sformat(
"%.2fus", secs * 1.0e6);
446 if (secs < 1.0e-6) ss << secs * 1.0e9 <<
"ns";
447 else if (secs < 1.0e-3) ss << secs * 1.0e6 <<
"us";
448 else if (secs < 1.0) ss << secs * 1.0e3 <<
"ms";
449 else ss << secs <<
's';
455 std::ifstream ifs(fname);
456 if (ifs.is_open() ==
false)
throw std::runtime_error(
"Cannot read file: "s + fname);
458 while (skip-- >= 0) std::getline(ifs, str);
#define JEVOISPRO_FMT_GUI
JeVois-Pro zero-copy display of camera input frame (to be used as output mode in VideoMapping)
unsigned int whiteColor(unsigned int fcc)
Return a value that corresponds to white for the given video format.
std::string sformat(char const *fmt,...) __attribute__((format(__printf__
Create a string using printf style arguments.
std::vector< std::string > split(std::string const &input, std::string const ®ex="\\s+")
Split string into vector of tokens using a regex to specify what to split on; default regex splits by...
unsigned int cvBytesPerPix(unsigned int cvtype)
Return the number of bytes per pixel for a given OpenCV pixel type.
void flushcache()
Flush the caches, may sometimes be useful when running the camera in turbo mode.
std::string cvtypestr(unsigned int cvtype)
Convert cv::Mat::type() code to to a string (e.g., CV_8UC1, CV_32SC3, etc)
size_t replaceStringFirst(std::string &str, std::string const &from, std::string const &to)
Replace first instance of 'from' with 'to'.
#define ISP_V4L2_PIX_FMT_META
Metadata V4L2 format used by Amlogic A311D camera ISP.
unsigned int blackColor(unsigned int fcc)
Return a value that corresponds to black for the given video format.
#define LERROR(msg)
Convenience macro for users to print out console or syslog messages, ERROR level.
std::string getFileString(char const *fname, int skip=0)
Read one line from a file and return it as a string.
std::string replaceWhitespace(std::string const &str, char rep='_')
Replace white space characters in a string with underscore (default) or another characters.
std::string system(std::string const &cmd, bool errtoo=true)
Execute a command and grab stdout output to a string.
unsigned int v4l2BytesPerPix(unsigned int fcc)
Return the number of bytes per pixel for a given V4L2_PIX_FMT_...
size_t replaceStringAll(std::string &str, std::string const &from, std::string const &to)
Replace all instances of 'from' with 'to'.
std::string join(std::vector< std::string > const &strings, std::string const &delimiter)
Concatenate a vector of tokens into a string.
std::string extractString(std::string const &str, std::string const &startsep, std::string const &endsep)
Extract a portion of a string between two delimiters.
std::string fccstr(unsigned int fcc)
Convert a V4L2 four-cc code (V4L2_PIX_FMT_...) to a 4-char string.
void applyLetterBox(unsigned int &imw, unsigned int &imh, unsigned int const winw, unsigned int const winh, bool noalias)
Apply a letterbox resizing to fit an image into a window.
#define LFATAL(msg)
Convenience macro for users to print out console or syslog messages, FATAL level.
std::string absolutePath(std::string const &root, std::string const &path)
Compute an absolute path from two paths.
bool stringStartsWith(std::string const &str, std::string const &prefix)
Return true if str starts with prefix (including if both strings are equal)
std::string secs2str(double secs)
Report a duration given in seconds with variable units (ns, us, ms, or s), with precision of 2 decima...
unsigned int v4l2ImageSize(unsigned int fcc, unsigned int width, unsigned int height)
Return the image size in bytes for a given V4L2_PIX_FMT_..., width, height.
unsigned int strfcc(std::string const &str)
Convert a JeVois video format string to V4L2 four-cc code (V4L2_PIX_FMT_...)
std::string strip(std::string const &str)
Strip white space (including CR, LF, tabs, etc) from the end of a string.