IDS peak AFL v2.0.1
Loading...
Searching...
No Matches
peak_common_pixel_format_traits.ipp
Go to the documentation of this file.
1
11
12#pragma once
13
14
15namespace peak
16{
17namespace common
18{
19namespace detail
20{
22template <peak::common::PixelFormat pixelFormat>
23struct PixelFormatTraits;
25template <>
26struct PixelFormatTraits<PixelFormat::BayerGR8>
27{
28 using underlying_type = uint8_t;
29
30 static constexpr std::array<Channel, 1> Channels()
31 {
32 return { Channel::Bayer };
33 }
34
35 static constexpr auto Name()
36 {
37 return "BayerGR8";
38 }
39
40 static constexpr size_t storageBitsPerPixel = 8;
41 static constexpr size_t allocatedBitsPerPixel = 8;
42 static constexpr bool isPacked = false;
43 static constexpr bool isInterleaved = false;
44 static constexpr auto unpackedFormat = PixelFormat::BayerGR8;
45};
46
47template <>
48struct PixelFormatTraits<PixelFormat::BayerGR10>
49{
50 using underlying_type = uint16_t;
51
52 static constexpr std::array<Channel, 1> Channels()
53 {
54 return { Channel::Bayer };
55 }
56
57 static constexpr auto Name()
58 {
59 return "BayerGR10";
60 }
61
62 static constexpr size_t storageBitsPerPixel = 10;
63 static constexpr size_t allocatedBitsPerPixel = 16;
64 static constexpr bool isPacked = false;
65 static constexpr bool isInterleaved = false;
66 static constexpr auto unpackedFormat = PixelFormat::BayerGR10;
67};
68
69template <>
70struct PixelFormatTraits<PixelFormat::BayerGR12>
71{
72 using underlying_type = uint16_t;
73
74 static constexpr std::array<Channel, 1> Channels()
75 {
76 return { Channel::Bayer };
77 }
78
79 static constexpr auto Name()
80 {
81 return "BayerGR12";
82 }
83
84 static constexpr size_t storageBitsPerPixel = 12;
85 static constexpr size_t allocatedBitsPerPixel = 16;
86 static constexpr bool isPacked = false;
87 static constexpr bool isInterleaved = false;
88 static constexpr auto unpackedFormat = PixelFormat::BayerGR12;
89};
90
91template <>
92struct PixelFormatTraits<PixelFormat::BayerRG8>
93{
94 using underlying_type = uint8_t;
95
96 static constexpr std::array<Channel, 1> Channels()
97 {
98 return { Channel::Bayer };
99 }
100
101 static constexpr auto Name()
102 {
103 return "BayerRG8";
104 }
105
106 static constexpr size_t storageBitsPerPixel = 8;
107 static constexpr size_t allocatedBitsPerPixel = 8;
108 static constexpr bool isPacked = false;
109 static constexpr bool isInterleaved = false;
110 static constexpr auto unpackedFormat = PixelFormat::BayerRG8;
111};
112
113template <>
114struct PixelFormatTraits<PixelFormat::BayerRG10>
115{
116 using underlying_type = uint16_t;
117
118 static constexpr std::array<Channel, 1> Channels()
119 {
120 return { Channel::Bayer };
121 }
122
123 static constexpr auto Name()
124 {
125 return "BayerRG10";
126 }
127
128 static constexpr size_t storageBitsPerPixel = 10;
129 static constexpr size_t allocatedBitsPerPixel = 16;
130 static constexpr bool isPacked = false;
131 static constexpr bool isInterleaved = false;
132 static constexpr auto unpackedFormat = PixelFormat::BayerRG10;
133};
134
135template <>
136struct PixelFormatTraits<PixelFormat::BayerRG12>
137{
138 using underlying_type = uint16_t;
139
140 static constexpr std::array<Channel, 1> Channels()
141 {
142 return { Channel::Bayer };
143 }
144
145 static constexpr auto Name()
146 {
147 return "BayerRG12";
148 }
149
150 static constexpr size_t storageBitsPerPixel = 12;
151 static constexpr size_t allocatedBitsPerPixel = 16;
152 static constexpr bool isPacked = false;
153 static constexpr bool isInterleaved = false;
154 static constexpr auto unpackedFormat = PixelFormat::BayerRG12;
155};
156
157template <>
158struct PixelFormatTraits<PixelFormat::BayerGB8>
159{
160 using underlying_type = uint8_t;
161
162 static constexpr std::array<Channel, 1> Channels()
163 {
164 return { Channel::Bayer };
165 }
166
167 static constexpr auto Name()
168 {
169 return "BayerGB8";
170 }
171
172 static constexpr size_t storageBitsPerPixel = 8;
173 static constexpr size_t allocatedBitsPerPixel = 8;
174 static constexpr bool isPacked = false;
175 static constexpr bool isInterleaved = false;
176 static constexpr auto unpackedFormat = PixelFormat::BayerGB8;
177};
178
179template <>
180struct PixelFormatTraits<PixelFormat::BayerGB10>
181{
182 using underlying_type = uint16_t;
183
184 static constexpr std::array<Channel, 1> Channels()
185 {
186 return { Channel::Bayer };
187 }
188
189 static constexpr auto Name()
190 {
191 return "BayerGB10";
192 }
193
194 static constexpr size_t storageBitsPerPixel = 10;
195 static constexpr size_t allocatedBitsPerPixel = 16;
196 static constexpr bool isPacked = false;
197 static constexpr bool isInterleaved = false;
198 static constexpr auto unpackedFormat = PixelFormat::BayerGB10;
199};
200
201template <>
202struct PixelFormatTraits<PixelFormat::BayerGB12>
203{
204 using underlying_type = uint16_t;
205
206 static constexpr std::array<Channel, 1> Channels()
207 {
208 return { Channel::Bayer };
209 }
210
211 static constexpr auto Name()
212 {
213 return "BayerGB12";
214 }
215
216 static constexpr size_t storageBitsPerPixel = 12;
217 static constexpr size_t allocatedBitsPerPixel = 16;
218 static constexpr bool isPacked = false;
219 static constexpr bool isInterleaved = false;
220 static constexpr auto unpackedFormat = PixelFormat::BayerGB12;
221};
222
223template <>
224struct PixelFormatTraits<PixelFormat::BayerBG8>
225{
226 using underlying_type = uint8_t;
227
228 static constexpr std::array<Channel, 1> Channels()
229 {
230 return { Channel::Bayer };
231 }
232
233 static constexpr auto Name()
234 {
235 return "BayerBG8";
236 }
237
238 static constexpr size_t storageBitsPerPixel = 8;
239 static constexpr size_t allocatedBitsPerPixel = 8;
240 static constexpr bool isPacked = false;
241 static constexpr bool isInterleaved = false;
242 static constexpr auto unpackedFormat = PixelFormat::BayerBG8;
243};
244
245template <>
246struct PixelFormatTraits<PixelFormat::BayerBG10>
247{
248 using underlying_type = uint16_t;
249
250 static constexpr std::array<Channel, 1> Channels()
251 {
252 return { Channel::Bayer };
253 }
254
255 static constexpr auto Name()
256 {
257 return "BayerBG10";
258 }
259
260 static constexpr size_t storageBitsPerPixel = 10;
261 static constexpr size_t allocatedBitsPerPixel = 16;
262 static constexpr bool isPacked = false;
263 static constexpr bool isInterleaved = false;
264 static constexpr auto unpackedFormat = PixelFormat::BayerBG10;
265};
266
267template <>
268struct PixelFormatTraits<PixelFormat::BayerBG12>
269{
270 using underlying_type = uint16_t;
271
272 static constexpr std::array<Channel, 1> Channels()
273 {
274 return { Channel::Bayer };
275 }
276
277 static constexpr auto Name()
278 {
279 return "BayerBG12";
280 }
281
282 static constexpr size_t storageBitsPerPixel = 12;
283 static constexpr size_t allocatedBitsPerPixel = 16;
284 static constexpr bool isPacked = false;
285 static constexpr bool isInterleaved = false;
286 static constexpr auto unpackedFormat = PixelFormat::BayerBG12;
287};
288
289template <>
290struct PixelFormatTraits<PixelFormat::Mono8>
291{
292 using underlying_type = uint8_t;
293
294 static constexpr std::array<Channel, 1> Channels()
295 {
296 return { Channel::Intensity };
297 }
298
299 static constexpr auto Name()
300 {
301 return "Mono8";
302 }
303
304 static constexpr size_t storageBitsPerPixel = 8;
305 static constexpr size_t allocatedBitsPerPixel = 8;
306 static constexpr bool isPacked = false;
307 static constexpr bool isInterleaved = false;
308 static constexpr auto unpackedFormat = PixelFormat::Mono8;
309};
310
311template <>
312struct PixelFormatTraits<PixelFormat::Mono10>
313{
314 using underlying_type = uint16_t;
315
316 static constexpr std::array<Channel, 1> Channels()
317 {
318 return { Channel::Intensity };
319 }
320
321 static constexpr auto Name()
322 {
323 return "Mono10";
324 }
325
326 static constexpr size_t storageBitsPerPixel = 10;
327 static constexpr size_t allocatedBitsPerPixel = 16;
328 static constexpr bool isPacked = false;
329 static constexpr bool isInterleaved = false;
330 static constexpr auto unpackedFormat = PixelFormat::Mono10;
331};
332
333template <>
334struct PixelFormatTraits<PixelFormat::Mono12>
335{
336 using underlying_type = uint16_t;
337
338 static constexpr std::array<Channel, 1> Channels()
339 {
340 return { Channel::Intensity };
341 }
342
343 static constexpr auto Name()
344 {
345 return "Mono12";
346 }
347
348 static constexpr size_t storageBitsPerPixel = 12;
349 static constexpr size_t allocatedBitsPerPixel = 16;
350 static constexpr bool isPacked = false;
351 static constexpr bool isInterleaved = false;
352 static constexpr auto unpackedFormat = PixelFormat::Mono12;
353};
354
355template <>
356struct PixelFormatTraits<PixelFormat::Mono16>
357{
358 using underlying_type = uint16_t;
359
360 static constexpr std::array<Channel, 1> Channels()
361 {
362 return { Channel::Intensity };
363 }
364
365 static constexpr auto Name()
366 {
367 return "Mono16";
368 }
369
370 static constexpr size_t storageBitsPerPixel = 16;
371 static constexpr size_t allocatedBitsPerPixel = 16;
372 static constexpr bool isPacked = false;
373 static constexpr bool isInterleaved = false;
374 static constexpr auto unpackedFormat = PixelFormat::Mono16;
375};
376
377template <>
378struct PixelFormatTraits<PixelFormat::Confidence8>
379{
380 using underlying_type = uint8_t;
381
382 static constexpr std::array<Channel, 1> Channels()
383 {
384 return { Channel::Intensity };
385 }
386
387 static constexpr auto Name()
388 {
389 return "Confidence8";
390 }
391
392 static constexpr size_t storageBitsPerPixel = 8;
393 static constexpr size_t allocatedBitsPerPixel = 8;
394 static constexpr bool isPacked = false;
395 static constexpr bool isInterleaved = false;
396 static constexpr auto unpackedFormat = PixelFormat::Confidence8;
397};
398
399template <>
400struct PixelFormatTraits<PixelFormat::Confidence16>
401{
402 using underlying_type = uint16_t;
403
404 static constexpr std::array<Channel, 1> Channels()
405 {
406 return { Channel::Intensity };
407 }
408
409 static constexpr auto Name()
410 {
411 return "Confidence16";
412 }
413
414 static constexpr size_t storageBitsPerPixel = 16;
415 static constexpr size_t allocatedBitsPerPixel = 16;
416 static constexpr bool isPacked = false;
417 static constexpr bool isInterleaved = false;
418 static constexpr auto unpackedFormat = PixelFormat::Confidence16;
419};
420
421template <>
422struct PixelFormatTraits<PixelFormat::Coord3D_C8>
423{
424 using underlying_type = uint8_t;
425
426 static constexpr std::array<Channel, 1> Channels()
427 {
428 return { Channel::Intensity };
429 }
430
431 static constexpr auto Name()
432 {
433 return "Coord3D_C8";
434 }
435
436 static constexpr size_t storageBitsPerPixel = 8;
437 static constexpr size_t allocatedBitsPerPixel = 8;
438 static constexpr bool isPacked = false;
439 static constexpr bool isInterleaved = false;
440 static constexpr auto unpackedFormat = PixelFormat::Coord3D_C8;
441};
442
443template <>
444struct PixelFormatTraits<PixelFormat::Coord3D_C16>
445{
446 using underlying_type = uint16_t;
447
448 static constexpr std::array<Channel, 1> Channels()
449 {
450 return { Channel::Intensity };
451 }
452
453 static constexpr auto Name()
454 {
455 return "Coord3D_C16";
456 }
457
458 static constexpr size_t storageBitsPerPixel = 16;
459 static constexpr size_t allocatedBitsPerPixel = 16;
460 static constexpr bool isPacked = false;
461 static constexpr bool isInterleaved = false;
462 static constexpr auto unpackedFormat = PixelFormat::Coord3D_C16;
463};
464
465template <>
466struct PixelFormatTraits<PixelFormat::Coord3D_C32f>
467{
468 using underlying_type = float;
469
470 static constexpr std::array<Channel, 1> Channels()
471 {
472 return { Channel::Intensity };
473 }
474
475 static constexpr auto Name()
476 {
477 return "Coord3D_C32f";
478 }
479
480 static constexpr size_t storageBitsPerPixel = 32;
481 static constexpr size_t allocatedBitsPerPixel = 32;
482 static constexpr bool isPacked = false;
483 static constexpr bool isInterleaved = false;
484 static constexpr auto unpackedFormat = PixelFormat::Coord3D_C32f;
485};
486
487template <>
488struct PixelFormatTraits<PixelFormat::Coord3D_ABC32f>
489{
490 using underlying_type = float;
491
492 static constexpr std::array<Channel, 3> Channels()
493 {
494 return { Channel::X, Channel::Y, Channel::Z };
495 }
496
497 static constexpr auto Name()
498 {
499 return "Coord3D_ABC32f";
500 }
501
502 static constexpr size_t storageBitsPerPixel = 96;
503 static constexpr size_t allocatedBitsPerPixel = 96;
504 static constexpr bool isPacked = false;
505 static constexpr bool isInterleaved = false;
506 static constexpr auto unpackedFormat = PixelFormat::Coord3D_ABC32f;
507};
508
509template <>
510struct PixelFormatTraits<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>
511{
512 using underlying_type = uint8_t;
513
514 static constexpr std::array<Channel, 3> Channels()
515 {
516 return { Channel::Intensity, Channel::ChromaU, Channel::ChromaV };
517 }
518
519 static constexpr auto Name()
520 {
521 return "YUV420_8_YY_UV_SemiplanarIDS";
522 }
523
524 static constexpr size_t storageBitsPerPixel = 8;
525 static constexpr size_t allocatedBitsPerPixel = 12;
526 static constexpr bool isPacked = false;
527 static constexpr bool isInterleaved = false;
528 static constexpr auto unpackedFormat = PixelFormat::YUV420_8_YY_UV_SemiplanarIDS;
529};
530
531template <>
532struct PixelFormatTraits<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>
533{
534 using underlying_type = uint8_t;
535
536 static constexpr std::array<Channel, 3> Channels()
537 {
538 return { Channel::Intensity, Channel::ChromaV, Channel::ChromaU };
539 }
540
541 static constexpr auto Name()
542 {
543 return "YUV420_8_YY_VU_SemiplanarIDS";
544 }
545
546 static constexpr size_t storageBitsPerPixel = 8;
547 static constexpr size_t allocatedBitsPerPixel = 12;
548 static constexpr bool isPacked = false;
549 static constexpr bool isInterleaved = false;
550 static constexpr auto unpackedFormat = PixelFormat::YUV420_8_YY_VU_SemiplanarIDS;
551};
552
553template <>
554struct PixelFormatTraits<PixelFormat::YUV422_8_UYVY>
555{
556 using underlying_type = uint8_t;
557
558 static constexpr std::array<Channel, 3> Channels()
559 {
560 return { Channel::Intensity, Channel::ChromaU, Channel::ChromaV };
561 }
562
563 static constexpr auto Name()
564 {
565 return "YUV422_8_UYVY";
566 }
567
568 static constexpr size_t storageBitsPerPixel = 8;
569 static constexpr size_t allocatedBitsPerPixel = 16;
570 static constexpr bool isPacked = false;
571 static constexpr bool isInterleaved = false;
572 static constexpr auto unpackedFormat = PixelFormat::YUV422_8_UYVY;
573};
574
575template <>
576struct PixelFormatTraits<PixelFormat::RGB8>
577{
578 using underlying_type = uint8_t;
579
580 static constexpr std::array<Channel, 3> Channels()
581 {
582 return { Channel::Red, Channel::Green, Channel::Blue };
583 }
584
585 static constexpr auto Name()
586 {
587 return "RGB8";
588 }
589
590 static constexpr size_t storageBitsPerPixel = 24;
591 static constexpr size_t allocatedBitsPerPixel = 24;
592 static constexpr bool isPacked = false;
593 static constexpr bool isInterleaved = false;
594 static constexpr auto unpackedFormat = PixelFormat::RGB8;
595};
596
597template <>
598struct PixelFormatTraits<PixelFormat::RGB10>
599{
600 using underlying_type = uint16_t;
601
602 static constexpr std::array<Channel, 3> Channels()
603 {
604 return { Channel::Red, Channel::Green, Channel::Blue };
605 }
606
607 static constexpr auto Name()
608 {
609 return "RGB10";
610 }
611
612 static constexpr size_t storageBitsPerPixel = 30;
613 static constexpr size_t allocatedBitsPerPixel = 48;
614 static constexpr bool isPacked = false;
615 static constexpr bool isInterleaved = false;
616 static constexpr auto unpackedFormat = PixelFormat::RGB10;
617};
618
619template <>
620struct PixelFormatTraits<PixelFormat::RGB12>
621{
622 using underlying_type = uint16_t;
623
624 static constexpr std::array<Channel, 3> Channels()
625 {
626 return { Channel::Red, Channel::Green, Channel::Blue };
627 }
628
629 static constexpr auto Name()
630 {
631 return "RGB12";
632 }
633
634 static constexpr size_t storageBitsPerPixel = 36;
635 static constexpr size_t allocatedBitsPerPixel = 48;
636 static constexpr bool isPacked = false;
637 static constexpr bool isInterleaved = false;
638 static constexpr auto unpackedFormat = PixelFormat::RGB12;
639};
640
641template <>
642struct PixelFormatTraits<PixelFormat::BGR8>
643{
644 using underlying_type = uint8_t;
645
646 static constexpr std::array<Channel, 3> Channels()
647 {
648 return { Channel::Blue, Channel::Green, Channel::Red };
649 }
650
651 static constexpr auto Name()
652 {
653 return "BGR8";
654 }
655
656 static constexpr size_t storageBitsPerPixel = 24;
657 static constexpr size_t allocatedBitsPerPixel = 24;
658 static constexpr bool isPacked = false;
659 static constexpr bool isInterleaved = false;
660 static constexpr auto unpackedFormat = PixelFormat::BGR8;
661};
662
663template <>
664struct PixelFormatTraits<PixelFormat::BGR10>
665{
666 using underlying_type = uint16_t;
667
668 static constexpr std::array<Channel, 3> Channels()
669 {
670 return { Channel::Blue, Channel::Green, Channel::Red };
671 }
672
673 static constexpr auto Name()
674 {
675 return "BGR10";
676 }
677
678 static constexpr size_t storageBitsPerPixel = 30;
679 static constexpr size_t allocatedBitsPerPixel = 48;
680 static constexpr bool isPacked = false;
681 static constexpr bool isInterleaved = false;
682 static constexpr auto unpackedFormat = PixelFormat::BGR10;
683};
684
685template <>
686struct PixelFormatTraits<PixelFormat::BGR12>
687{
688 using underlying_type = uint16_t;
689
690 static constexpr std::array<Channel, 3> Channels()
691 {
692 return { Channel::Blue, Channel::Green, Channel::Red };
693 }
694
695 static constexpr auto Name()
696 {
697 return "BGR12";
698 }
699
700 static constexpr size_t storageBitsPerPixel = 36;
701 static constexpr size_t allocatedBitsPerPixel = 48;
702 static constexpr bool isPacked = false;
703 static constexpr bool isInterleaved = false;
704 static constexpr auto unpackedFormat = PixelFormat::BGR12;
705};
706
707template <>
708struct PixelFormatTraits<PixelFormat::RGBa8>
709{
710 using underlying_type = uint8_t;
711
712 static constexpr std::array<Channel, 4> Channels()
713 {
714 return { Channel::Red, Channel::Green, Channel::Blue, Channel::Alpha };
715 }
716
717 static constexpr auto Name()
718 {
719 return "RGBa8";
720 }
721
722 static constexpr size_t storageBitsPerPixel = 32;
723 static constexpr size_t allocatedBitsPerPixel = 32;
724 static constexpr bool isPacked = false;
725 static constexpr bool isInterleaved = false;
726 static constexpr auto unpackedFormat = PixelFormat::RGBa8;
727};
728
729template <>
730struct PixelFormatTraits<PixelFormat::RGBa10>
731{
732 using underlying_type = uint16_t;
733
734 static constexpr std::array<Channel, 4> Channels()
735 {
736 return { Channel::Red, Channel::Green, Channel::Blue, Channel::Alpha };
737 }
738
739 static constexpr auto Name()
740 {
741 return "RGBa10";
742 }
743
744 static constexpr size_t storageBitsPerPixel = 40;
745 static constexpr size_t allocatedBitsPerPixel = 64;
746 static constexpr bool isPacked = false;
747 static constexpr bool isInterleaved = false;
748 static constexpr auto unpackedFormat = PixelFormat::RGBa10;
749};
750
751template <>
752struct PixelFormatTraits<PixelFormat::RGBa12>
753{
754 using underlying_type = uint16_t;
755
756 static constexpr std::array<Channel, 4> Channels()
757 {
758 return { Channel::Red, Channel::Green, Channel::Blue, Channel::Alpha };
759 }
760
761 static constexpr auto Name()
762 {
763 return "RGBa12";
764 }
765
766 static constexpr size_t storageBitsPerPixel = 48;
767 static constexpr size_t allocatedBitsPerPixel = 64;
768 static constexpr bool isPacked = false;
769 static constexpr bool isInterleaved = false;
770 static constexpr auto unpackedFormat = PixelFormat::RGBa12;
771};
772
773template <>
774struct PixelFormatTraits<PixelFormat::BGRa8>
775{
776 using underlying_type = uint8_t;
777
778 static constexpr std::array<Channel, 4> Channels()
779 {
780 return { Channel::Blue, Channel::Green, Channel::Red, Channel::Alpha };
781 }
782
783 static constexpr auto Name()
784 {
785 return "BGRa8";
786 }
787
788 static constexpr size_t storageBitsPerPixel = 32;
789 static constexpr size_t allocatedBitsPerPixel = 32;
790 static constexpr bool isPacked = false;
791 static constexpr bool isInterleaved = false;
792 static constexpr auto unpackedFormat = PixelFormat::BGRa8;
793};
794
795template <>
796struct PixelFormatTraits<PixelFormat::BGRa10>
797{
798 using underlying_type = uint16_t;
799
800 static constexpr std::array<Channel, 4> Channels()
801 {
802 return { Channel::Blue, Channel::Green, Channel::Red, Channel::Alpha };
803 }
804
805 static constexpr auto Name()
806 {
807 return "BGRa10";
808 }
809
810 static constexpr size_t storageBitsPerPixel = 40;
811 static constexpr size_t allocatedBitsPerPixel = 64;
812 static constexpr bool isPacked = false;
813 static constexpr bool isInterleaved = false;
814 static constexpr auto unpackedFormat = PixelFormat::BGRa10;
815};
816
817template <>
818struct PixelFormatTraits<PixelFormat::BGRa12>
819{
820 using underlying_type = uint16_t;
821
822 static constexpr std::array<Channel, 4> Channels()
823 {
824 return { Channel::Blue, Channel::Green, Channel::Red, Channel::Alpha };
825 }
826
827 static constexpr auto Name()
828 {
829 return "BGRa12";
830 }
831
832 static constexpr size_t storageBitsPerPixel = 48;
833 static constexpr size_t allocatedBitsPerPixel = 64;
834 static constexpr bool isPacked = false;
835 static constexpr bool isInterleaved = false;
836 static constexpr auto unpackedFormat = PixelFormat::BGRa12;
837};
838
839template <>
840struct PixelFormatTraits<PixelFormat::BayerBG10p>
841{
842 using underlying_type = uint8_t;
843
844 static constexpr std::array<Channel, 1> Channels()
845 {
846 return { Channel::Bayer };
847 }
848
849 static constexpr auto Name()
850 {
851 return "BayerBG10p";
852 }
853
854 static constexpr size_t storageBitsPerPixel = 10;
855 static constexpr size_t allocatedBitsPerPixel = 10;
856 static constexpr bool isPacked = true;
857 static constexpr bool isInterleaved = false;
858 static constexpr auto unpackedFormat = PixelFormat::BayerBG10;
859};
860
861template <>
862struct PixelFormatTraits<PixelFormat::BayerBG12p>
863{
864 using underlying_type = uint8_t;
865
866 static constexpr std::array<Channel, 1> Channels()
867 {
868 return { Channel::Bayer };
869 }
870
871 static constexpr auto Name()
872 {
873 return "BayerBG12p";
874 }
875
876 static constexpr size_t storageBitsPerPixel = 12;
877 static constexpr size_t allocatedBitsPerPixel = 12;
878 static constexpr bool isPacked = true;
879 static constexpr bool isInterleaved = false;
880 static constexpr auto unpackedFormat = PixelFormat::BayerBG12;
881};
882
883template <>
884struct PixelFormatTraits<PixelFormat::BayerGB10p>
885{
886 using underlying_type = uint8_t;
887
888 static constexpr std::array<Channel, 1> Channels()
889 {
890 return { Channel::Bayer };
891 }
892
893 static constexpr auto Name()
894 {
895 return "BayerGB10p";
896 }
897
898 static constexpr size_t storageBitsPerPixel = 10;
899 static constexpr size_t allocatedBitsPerPixel = 10;
900 static constexpr bool isPacked = true;
901 static constexpr bool isInterleaved = false;
902 static constexpr auto unpackedFormat = PixelFormat::BayerGB10;
903};
904
905template <>
906struct PixelFormatTraits<PixelFormat::BayerGB12p>
907{
908 using underlying_type = uint8_t;
909
910 static constexpr std::array<Channel, 1> Channels()
911 {
912 return { Channel::Bayer };
913 }
914
915 static constexpr auto Name()
916 {
917 return "BayerGB12p";
918 }
919
920 static constexpr size_t storageBitsPerPixel = 12;
921 static constexpr size_t allocatedBitsPerPixel = 12;
922 static constexpr bool isPacked = true;
923 static constexpr bool isInterleaved = false;
924 static constexpr auto unpackedFormat = PixelFormat::BayerGB12;
925};
926
927template <>
928struct PixelFormatTraits<PixelFormat::BayerGR10p>
929{
930 using underlying_type = uint8_t;
931
932 static constexpr std::array<Channel, 1> Channels()
933 {
934 return { Channel::Bayer };
935 }
936
937 static constexpr auto Name()
938 {
939 return "BayerGR10p";
940 }
941
942 static constexpr size_t storageBitsPerPixel = 10;
943 static constexpr size_t allocatedBitsPerPixel = 10;
944 static constexpr bool isPacked = true;
945 static constexpr bool isInterleaved = false;
946 static constexpr auto unpackedFormat = PixelFormat::BayerGR10;
947};
948
949template <>
950struct PixelFormatTraits<PixelFormat::BayerGR12p>
951{
952 using underlying_type = uint8_t;
953
954 static constexpr std::array<Channel, 1> Channels()
955 {
956 return { Channel::Bayer };
957 }
958
959 static constexpr auto Name()
960 {
961 return "BayerGR12p";
962 }
963
964 static constexpr size_t storageBitsPerPixel = 12;
965 static constexpr size_t allocatedBitsPerPixel = 12;
966 static constexpr bool isPacked = true;
967 static constexpr bool isInterleaved = false;
968 static constexpr auto unpackedFormat = PixelFormat::BayerGR12;
969};
970
971template <>
972struct PixelFormatTraits<PixelFormat::BayerRG10p>
973{
974 using underlying_type = uint8_t;
975
976 static constexpr std::array<Channel, 1> Channels()
977 {
978 return { Channel::Bayer };
979 }
980
981 static constexpr auto Name()
982 {
983 return "BayerRG10p";
984 }
985
986 static constexpr size_t storageBitsPerPixel = 10;
987 static constexpr size_t allocatedBitsPerPixel = 10;
988 static constexpr bool isPacked = true;
989 static constexpr bool isInterleaved = false;
990 static constexpr auto unpackedFormat = PixelFormat::BayerRG10;
991};
992
993template <>
994struct PixelFormatTraits<PixelFormat::BayerRG12p>
995{
996 using underlying_type = uint8_t;
997
998 static constexpr std::array<Channel, 1> Channels()
999 {
1000 return { Channel::Bayer };
1001 }
1002
1003 static constexpr auto Name()
1004 {
1005 return "BayerRG12p";
1006 }
1007
1008 static constexpr size_t storageBitsPerPixel = 12;
1009 static constexpr size_t allocatedBitsPerPixel = 12;
1010 static constexpr bool isPacked = true;
1011 static constexpr bool isInterleaved = false;
1012 static constexpr auto unpackedFormat = PixelFormat::BayerRG12;
1013};
1014
1015template <>
1016struct PixelFormatTraits<PixelFormat::Mono10p>
1017{
1018 using underlying_type = uint8_t;
1019
1020 static constexpr std::array<Channel, 1> Channels()
1021 {
1022 return { Channel::Intensity };
1023 }
1024
1025 static constexpr auto Name()
1026 {
1027 return "Mono10p";
1028 }
1029
1030 static constexpr size_t storageBitsPerPixel = 10;
1031 static constexpr size_t allocatedBitsPerPixel = 10;
1032 static constexpr bool isPacked = true;
1033 static constexpr bool isInterleaved = false;
1034 static constexpr auto unpackedFormat = PixelFormat::Mono10;
1035};
1036
1037template <>
1038struct PixelFormatTraits<PixelFormat::Mono12p>
1039{
1040 using underlying_type = uint8_t;
1041
1042 static constexpr std::array<Channel, 1> Channels()
1043 {
1044 return { Channel::Intensity };
1045 }
1046
1047 static constexpr auto Name()
1048 {
1049 return "Mono12p";
1050 }
1051
1052 static constexpr size_t storageBitsPerPixel = 12;
1053 static constexpr size_t allocatedBitsPerPixel = 12;
1054 static constexpr bool isPacked = true;
1055 static constexpr bool isInterleaved = false;
1056 static constexpr auto unpackedFormat = PixelFormat::Mono12;
1057};
1058
1059template <>
1060struct PixelFormatTraits<PixelFormat::RGB10p32>
1061{
1062 using underlying_type = uint32_t;
1063
1064 static constexpr std::array<Channel, 3> Channels()
1065 {
1066 return { Channel::Red, Channel::Green, Channel::Blue };
1067 }
1068
1069 static constexpr auto Name()
1070 {
1071 return "RGB10p32";
1072 }
1073
1074 static constexpr size_t storageBitsPerPixel = 30;
1075 static constexpr size_t allocatedBitsPerPixel = 32;
1076 static constexpr bool isPacked = true;
1077 static constexpr bool isInterleaved = false;
1078 static constexpr auto unpackedFormat = PixelFormat::RGB10;
1079};
1080
1081template <>
1082struct PixelFormatTraits<PixelFormat::BGR10p32>
1083{
1084 using underlying_type = uint32_t;
1085
1086 static constexpr std::array<Channel, 3> Channels()
1087 {
1088 return { Channel::Blue, Channel::Green, Channel::Red };
1089 }
1090
1091 static constexpr auto Name()
1092 {
1093 return "BGR10p32";
1094 }
1095
1096 static constexpr size_t storageBitsPerPixel = 30;
1097 static constexpr size_t allocatedBitsPerPixel = 32;
1098 static constexpr bool isPacked = true;
1099 static constexpr bool isInterleaved = false;
1100 static constexpr auto unpackedFormat = PixelFormat::BGR10;
1101};
1102
1103template <>
1104struct PixelFormatTraits<PixelFormat::BayerRG10g40IDS>
1105{
1106 using underlying_type = uint8_t;
1107
1108 static constexpr std::array<Channel, 1> Channels()
1109 {
1110 return { Channel::Bayer };
1111 }
1112
1113 static constexpr auto Name()
1114 {
1115 return "BayerRG10g40IDS";
1116 }
1117
1118 static constexpr size_t storageBitsPerPixel = 10;
1119 static constexpr size_t allocatedBitsPerPixel = 10;
1120 static constexpr bool isPacked = true;
1121 static constexpr bool isInterleaved = false;
1122 static constexpr auto unpackedFormat = PixelFormat::BayerRG10;
1123};
1124
1125template <>
1126struct PixelFormatTraits<PixelFormat::BayerGB10g40IDS>
1127{
1128 using underlying_type = uint8_t;
1129
1130 static constexpr std::array<Channel, 1> Channels()
1131 {
1132 return { Channel::Bayer };
1133 }
1134
1135 static constexpr auto Name()
1136 {
1137 return "BayerGB10g40IDS";
1138 }
1139
1140 static constexpr size_t storageBitsPerPixel = 10;
1141 static constexpr size_t allocatedBitsPerPixel = 10;
1142 static constexpr bool isPacked = true;
1143 static constexpr bool isInterleaved = false;
1144 static constexpr auto unpackedFormat = PixelFormat::BayerGB10;
1145};
1146
1147template <>
1148struct PixelFormatTraits<PixelFormat::BayerGR10g40IDS>
1149{
1150 using underlying_type = uint8_t;
1151
1152 static constexpr std::array<Channel, 1> Channels()
1153 {
1154 return { Channel::Bayer };
1155 }
1156
1157 static constexpr auto Name()
1158 {
1159 return "BayerGR10g40IDS";
1160 }
1161
1162 static constexpr size_t storageBitsPerPixel = 10;
1163 static constexpr size_t allocatedBitsPerPixel = 10;
1164 static constexpr bool isPacked = true;
1165 static constexpr bool isInterleaved = false;
1166 static constexpr auto unpackedFormat = PixelFormat::BayerGR10;
1167};
1168
1169template <>
1170struct PixelFormatTraits<PixelFormat::BayerBG10g40IDS>
1171{
1172 using underlying_type = uint8_t;
1173
1174 static constexpr std::array<Channel, 1> Channels()
1175 {
1176 return { Channel::Bayer };
1177 }
1178
1179 static constexpr auto Name()
1180 {
1181 return "BayerBG10g40IDS";
1182 }
1183
1184 static constexpr size_t storageBitsPerPixel = 10;
1185 static constexpr size_t allocatedBitsPerPixel = 10;
1186 static constexpr bool isPacked = true;
1187 static constexpr bool isInterleaved = false;
1188 static constexpr auto unpackedFormat = PixelFormat::BayerBG10;
1189};
1190
1191template <>
1192struct PixelFormatTraits<PixelFormat::BayerRG12g24IDS>
1193{
1194 using underlying_type = uint8_t;
1195
1196 static constexpr std::array<Channel, 1> Channels()
1197 {
1198 return { Channel::Bayer };
1199 }
1200
1201 static constexpr auto Name()
1202 {
1203 return "BayerRG12g24IDS";
1204 }
1205
1206 static constexpr size_t storageBitsPerPixel = 12;
1207 static constexpr size_t allocatedBitsPerPixel = 12;
1208 static constexpr bool isPacked = true;
1209 static constexpr bool isInterleaved = false;
1210 static constexpr auto unpackedFormat = PixelFormat::BayerRG12;
1211};
1212
1213template <>
1214struct PixelFormatTraits<PixelFormat::BayerGB12g24IDS>
1215{
1216 using underlying_type = uint8_t;
1217
1218 static constexpr std::array<Channel, 1> Channels()
1219 {
1220 return { Channel::Bayer };
1221 }
1222
1223 static constexpr auto Name()
1224 {
1225 return "BayerGB12g24IDS";
1226 }
1227
1228 static constexpr size_t storageBitsPerPixel = 12;
1229 static constexpr size_t allocatedBitsPerPixel = 12;
1230 static constexpr bool isPacked = true;
1231 static constexpr bool isInterleaved = false;
1232 static constexpr auto unpackedFormat = PixelFormat::BayerGB12;
1233};
1234
1235template <>
1236struct PixelFormatTraits<PixelFormat::BayerGR12g24IDS>
1237{
1238 using underlying_type = uint8_t;
1239
1240 static constexpr std::array<Channel, 1> Channels()
1241 {
1242 return { Channel::Bayer };
1243 }
1244
1245 static constexpr auto Name()
1246 {
1247 return "BayerGR12g24IDS";
1248 }
1249
1250 static constexpr size_t storageBitsPerPixel = 12;
1251 static constexpr size_t allocatedBitsPerPixel = 12;
1252 static constexpr bool isPacked = true;
1253 static constexpr bool isInterleaved = false;
1254 static constexpr auto unpackedFormat = PixelFormat::BayerGR12;
1255};
1256
1257template <>
1258struct PixelFormatTraits<PixelFormat::BayerBG12g24IDS>
1259{
1260 using underlying_type = uint8_t;
1261
1262 static constexpr std::array<Channel, 1> Channels()
1263 {
1264 return { Channel::Bayer };
1265 }
1266
1267 static constexpr auto Name()
1268 {
1269 return "BayerBG12g24IDS";
1270 }
1271
1272 static constexpr size_t storageBitsPerPixel = 12;
1273 static constexpr size_t allocatedBitsPerPixel = 12;
1274 static constexpr bool isPacked = true;
1275 static constexpr bool isInterleaved = false;
1276 static constexpr auto unpackedFormat = PixelFormat::BayerBG12;
1277};
1278
1279template <>
1280struct PixelFormatTraits<PixelFormat::Mono10g40IDS>
1281{
1282 using underlying_type = uint8_t;
1283
1284 static constexpr std::array<Channel, 1> Channels()
1285 {
1286 return { Channel::Intensity };
1287 }
1288
1289 static constexpr auto Name()
1290 {
1291 return "Mono10g40IDS";
1292 }
1293
1294 static constexpr size_t storageBitsPerPixel = 10;
1295 static constexpr size_t allocatedBitsPerPixel = 10;
1296 static constexpr bool isPacked = true;
1297 static constexpr bool isInterleaved = false;
1298 static constexpr auto unpackedFormat = PixelFormat::Mono10;
1299};
1300
1301template <>
1302struct PixelFormatTraits<PixelFormat::Mono12g24IDS>
1303{
1304 using underlying_type = uint8_t;
1305
1306 static constexpr std::array<Channel, 1> Channels()
1307 {
1308 return { Channel::Intensity };
1309 }
1310
1311 static constexpr auto Name()
1312 {
1313 return "Mono12g24IDS";
1314 }
1315
1316 static constexpr size_t storageBitsPerPixel = 12;
1317 static constexpr size_t allocatedBitsPerPixel = 12;
1318 static constexpr bool isPacked = true;
1319 static constexpr bool isInterleaved = false;
1320 static constexpr auto unpackedFormat = PixelFormat::Mono12;
1321};
1322
1323template <>
1324struct PixelFormatTraits<PixelFormat::Mono32fIDS>
1325{
1326 using underlying_type = float;
1327
1328 static constexpr std::array<Channel, 1> Channels()
1329 {
1330 return { Channel::Intensity };
1331 }
1332
1333 static constexpr auto Name()
1334 {
1335 return "Mono32fIDS";
1336 }
1337
1338 static constexpr size_t storageBitsPerPixel = 32;
1339 static constexpr size_t allocatedBitsPerPixel = 32;
1340 static constexpr bool isPacked = false;
1341 static constexpr bool isInterleaved = false;
1342 static constexpr auto unpackedFormat = PixelFormat::Mono32fIDS;
1343};
1344
1345template <>
1346struct PixelFormatTraits<PixelFormat::RGB32fIDS>
1347{
1348 using underlying_type = float;
1349
1350 static constexpr std::array<Channel, 3> Channels()
1351 {
1352 return { Channel::Red, Channel::Green, Channel::Blue };
1353 }
1354
1355 static constexpr auto Name()
1356 {
1357 return "RGB32fIDS";
1358 }
1359
1360 static constexpr size_t storageBitsPerPixel = 96;
1361 static constexpr size_t allocatedBitsPerPixel = 96;
1362 static constexpr bool isPacked = false;
1363 static constexpr bool isInterleaved = false;
1364 static constexpr auto unpackedFormat = PixelFormat::RGB32fIDS;
1365};
1366
1367template <>
1368struct PixelFormatTraits<PixelFormat::Mono10g40IDS_I_A_B>
1369{
1370 using underlying_type = uint8_t;
1371
1372 static constexpr std::array<Channel, 1> Channels()
1373 {
1374 return { Channel::Intensity };
1375 }
1376
1377 static constexpr auto Name()
1378 {
1379 return "Mono10g40IDS_I_A_B";
1380 }
1381
1382 static constexpr size_t storageBitsPerPixel = 10;
1383 static constexpr size_t allocatedBitsPerPixel = 10;
1384 static constexpr bool isPacked = true;
1385 static constexpr bool isInterleaved = true;
1386 static constexpr auto unpackedFormat = PixelFormat::Mono10_AB;
1387};
1388
1389template <>
1390struct PixelFormatTraits<PixelFormat::BayerRG10g40IDS_I_A_B>
1391{
1392 using underlying_type = uint8_t;
1393
1394 static constexpr std::array<Channel, 1> Channels()
1395 {
1396 return { Channel::Bayer };
1397 }
1398
1399 static constexpr auto Name()
1400 {
1401 return "BayerRG10g40IDS_I_A_B";
1402 }
1403
1404 static constexpr size_t storageBitsPerPixel = 10;
1405 static constexpr size_t allocatedBitsPerPixel = 10;
1406 static constexpr bool isPacked = true;
1407 static constexpr bool isInterleaved = true;
1408 static constexpr auto unpackedFormat = PixelFormat::BayerRG10_AB;
1409};
1410
1411template <>
1412struct PixelFormatTraits<PixelFormat::BayerBG10g40IDS_I_A_B>
1413{
1414 using underlying_type = uint8_t;
1415
1416 static constexpr std::array<Channel, 1> Channels()
1417 {
1418 return { Channel::Bayer };
1419 }
1420
1421 static constexpr auto Name()
1422 {
1423 return "BayerBG10g40IDS_I_A_B";
1424 }
1425
1426 static constexpr size_t storageBitsPerPixel = 10;
1427 static constexpr size_t allocatedBitsPerPixel = 10;
1428 static constexpr bool isPacked = true;
1429 static constexpr bool isInterleaved = true;
1430 static constexpr auto unpackedFormat = PixelFormat::BayerBG10_AB;
1431};
1432
1433template <>
1434struct PixelFormatTraits<PixelFormat::BayerGR10g40IDS_I_A_B>
1435{
1436 using underlying_type = uint8_t;
1437
1438 static constexpr std::array<Channel, 1> Channels()
1439 {
1440 return { Channel::Bayer };
1441 }
1442
1443 static constexpr auto Name()
1444 {
1445 return "BayerGR10g40IDS_I_A_B";
1446 }
1447
1448 static constexpr size_t storageBitsPerPixel = 10;
1449 static constexpr size_t allocatedBitsPerPixel = 10;
1450 static constexpr bool isPacked = true;
1451 static constexpr bool isInterleaved = true;
1452 static constexpr auto unpackedFormat = PixelFormat::BayerGR10_AB;
1453};
1454
1455template <>
1456struct PixelFormatTraits<PixelFormat::BayerGB10g40IDS_I_A_B>
1457{
1458 using underlying_type = uint8_t;
1459
1460 static constexpr std::array<Channel, 1> Channels()
1461 {
1462 return { Channel::Bayer };
1463 }
1464
1465 static constexpr auto Name()
1466 {
1467 return "BayerGB10g40IDS_I_A_B";
1468 }
1469
1470 static constexpr size_t storageBitsPerPixel = 10;
1471 static constexpr size_t allocatedBitsPerPixel = 10;
1472 static constexpr bool isPacked = true;
1473 static constexpr bool isInterleaved = true;
1474 static constexpr auto unpackedFormat = PixelFormat::BayerGB10_AB;
1475};
1476
1477template <>
1478struct PixelFormatTraits<PixelFormat::Mono12g24IDS_I_A_B>
1479{
1480 using underlying_type = uint8_t;
1481
1482 static constexpr std::array<Channel, 1> Channels()
1483 {
1484 return { Channel::Intensity };
1485 }
1486
1487 static constexpr auto Name()
1488 {
1489 return "Mono12g24IDS_I_A_B";
1490 }
1491
1492 static constexpr size_t storageBitsPerPixel = 12;
1493 static constexpr size_t allocatedBitsPerPixel = 12;
1494 static constexpr bool isPacked = true;
1495 static constexpr bool isInterleaved = true;
1496 static constexpr auto unpackedFormat = PixelFormat::Mono12_AB;
1497};
1498
1499template <>
1500struct PixelFormatTraits<PixelFormat::BayerRG12g24IDS_I_A_B>
1501{
1502 using underlying_type = uint8_t;
1503
1504 static constexpr std::array<Channel, 1> Channels()
1505 {
1506 return { Channel::Bayer };
1507 }
1508
1509 static constexpr auto Name()
1510 {
1511 return "BayerRG12g24IDS_I_A_B";
1512 }
1513
1514 static constexpr size_t storageBitsPerPixel = 12;
1515 static constexpr size_t allocatedBitsPerPixel = 12;
1516 static constexpr bool isPacked = true;
1517 static constexpr bool isInterleaved = true;
1518 static constexpr auto unpackedFormat = PixelFormat::BayerRG12_AB;
1519};
1520
1521template <>
1522struct PixelFormatTraits<PixelFormat::BayerBG12g24IDS_I_A_B>
1523{
1524 using underlying_type = uint8_t;
1525
1526 static constexpr std::array<Channel, 1> Channels()
1527 {
1528 return { Channel::Bayer };
1529 }
1530
1531 static constexpr auto Name()
1532 {
1533 return "BayerBG12g24IDS_I_A_B";
1534 }
1535
1536 static constexpr size_t storageBitsPerPixel = 12;
1537 static constexpr size_t allocatedBitsPerPixel = 12;
1538 static constexpr bool isPacked = true;
1539 static constexpr bool isInterleaved = true;
1540 static constexpr auto unpackedFormat = PixelFormat::BayerBG12_AB;
1541};
1542
1543template <>
1544struct PixelFormatTraits<PixelFormat::BayerGR12g24IDS_I_A_B>
1545{
1546 using underlying_type = uint8_t;
1547
1548 static constexpr std::array<Channel, 1> Channels()
1549 {
1550 return { Channel::Bayer };
1551 }
1552
1553 static constexpr auto Name()
1554 {
1555 return "BayerGR12g24IDS_I_A_B";
1556 }
1557
1558 static constexpr size_t storageBitsPerPixel = 12;
1559 static constexpr size_t allocatedBitsPerPixel = 12;
1560 static constexpr bool isPacked = true;
1561 static constexpr bool isInterleaved = true;
1562 static constexpr auto unpackedFormat = PixelFormat::BayerGR12_AB;
1563};
1564
1565template <>
1566struct PixelFormatTraits<PixelFormat::BayerGB12g24IDS_I_A_B>
1567{
1568 using underlying_type = uint8_t;
1569
1570 static constexpr std::array<Channel, 1> Channels()
1571 {
1572 return { Channel::Bayer };
1573 }
1574
1575 static constexpr auto Name()
1576 {
1577 return "BayerGB12g24IDS_I_A_B";
1578 }
1579
1580 static constexpr size_t storageBitsPerPixel = 12;
1581 static constexpr size_t allocatedBitsPerPixel = 12;
1582 static constexpr bool isPacked = true;
1583 static constexpr bool isInterleaved = true;
1584 static constexpr auto unpackedFormat = PixelFormat::BayerGB12_AB;
1585};
1586
1587template <>
1588struct PixelFormatTraits<PixelFormat::Mono8_I_A_B>
1589{
1590 using underlying_type = uint8_t;
1591
1592 static constexpr std::array<Channel, 1> Channels()
1593 {
1594 return { Channel::Intensity };
1595 }
1596
1597 static constexpr auto Name()
1598 {
1599 return "Mono8_I_A_B";
1600 }
1601
1602 static constexpr size_t storageBitsPerPixel = 8;
1603 static constexpr size_t allocatedBitsPerPixel = 8;
1604 static constexpr bool isPacked = false;
1605 static constexpr bool isInterleaved = true;
1606 static constexpr auto unpackedFormat = PixelFormat::Mono8_AB;
1607};
1608
1609template <>
1610struct PixelFormatTraits<PixelFormat::BayerRG8_I_A_B>
1611{
1612 using underlying_type = uint8_t;
1613
1614 static constexpr std::array<Channel, 1> Channels()
1615 {
1616 return { Channel::Bayer };
1617 }
1618
1619 static constexpr auto Name()
1620 {
1621 return "BayerRG8_I_A_B";
1622 }
1623
1624 static constexpr size_t storageBitsPerPixel = 8;
1625 static constexpr size_t allocatedBitsPerPixel = 8;
1626 static constexpr bool isPacked = false;
1627 static constexpr bool isInterleaved = true;
1628 static constexpr auto unpackedFormat = PixelFormat::BayerRG8_AB;
1629};
1630
1631template <>
1632struct PixelFormatTraits<PixelFormat::BayerBG8_I_A_B>
1633{
1634 using underlying_type = uint8_t;
1635
1636 static constexpr std::array<Channel, 1> Channels()
1637 {
1638 return { Channel::Bayer };
1639 }
1640
1641 static constexpr auto Name()
1642 {
1643 return "BayerBG8_I_A_B";
1644 }
1645
1646 static constexpr size_t storageBitsPerPixel = 8;
1647 static constexpr size_t allocatedBitsPerPixel = 8;
1648 static constexpr bool isPacked = false;
1649 static constexpr bool isInterleaved = true;
1650 static constexpr auto unpackedFormat = PixelFormat::BayerBG8_AB;
1651};
1652
1653template <>
1654struct PixelFormatTraits<PixelFormat::BayerGR8_I_A_B>
1655{
1656 using underlying_type = uint8_t;
1657
1658 static constexpr std::array<Channel, 1> Channels()
1659 {
1660 return { Channel::Bayer };
1661 }
1662
1663 static constexpr auto Name()
1664 {
1665 return "BayerGR8_I_A_B";
1666 }
1667
1668 static constexpr size_t storageBitsPerPixel = 8;
1669 static constexpr size_t allocatedBitsPerPixel = 8;
1670 static constexpr bool isPacked = false;
1671 static constexpr bool isInterleaved = true;
1672 static constexpr auto unpackedFormat = PixelFormat::BayerGR8_AB;
1673};
1674
1675template <>
1676struct PixelFormatTraits<PixelFormat::BayerGB8_I_A_B>
1677{
1678 using underlying_type = uint8_t;
1679
1680 static constexpr std::array<Channel, 1> Channels()
1681 {
1682 return { Channel::Bayer };
1683 }
1684
1685 static constexpr auto Name()
1686 {
1687 return "BayerGB8_I_A_B";
1688 }
1689
1690 static constexpr size_t storageBitsPerPixel = 8;
1691 static constexpr size_t allocatedBitsPerPixel = 8;
1692 static constexpr bool isPacked = false;
1693 static constexpr bool isInterleaved = true;
1694 static constexpr auto unpackedFormat = PixelFormat::BayerGB8_AB;
1695};
1696
1697template <>
1698struct PixelFormatTraits<PixelFormat::Mono10_I_A_B>
1699{
1700 using underlying_type = uint16_t;
1701
1702 static constexpr std::array<Channel, 1> Channels()
1703 {
1704 return { Channel::Intensity };
1705 }
1706
1707 static constexpr auto Name()
1708 {
1709 return "Mono10_I_A_B";
1710 }
1711
1712 static constexpr size_t storageBitsPerPixel = 10;
1713 static constexpr size_t allocatedBitsPerPixel = 16;
1714 static constexpr bool isPacked = false;
1715 static constexpr bool isInterleaved = true;
1716 static constexpr auto unpackedFormat = PixelFormat::Mono10_AB;
1717};
1718
1719template <>
1720struct PixelFormatTraits<PixelFormat::BayerRG10_I_A_B>
1721{
1722 using underlying_type = uint16_t;
1723
1724 static constexpr std::array<Channel, 1> Channels()
1725 {
1726 return { Channel::Bayer };
1727 }
1728
1729 static constexpr auto Name()
1730 {
1731 return "BayerRG10_I_A_B";
1732 }
1733
1734 static constexpr size_t storageBitsPerPixel = 10;
1735 static constexpr size_t allocatedBitsPerPixel = 16;
1736 static constexpr bool isPacked = false;
1737 static constexpr bool isInterleaved = true;
1738 static constexpr auto unpackedFormat = PixelFormat::BayerRG10_AB;
1739};
1740
1741template <>
1742struct PixelFormatTraits<PixelFormat::BayerBG10_I_A_B>
1743{
1744 using underlying_type = uint16_t;
1745
1746 static constexpr std::array<Channel, 1> Channels()
1747 {
1748 return { Channel::Bayer };
1749 }
1750
1751 static constexpr auto Name()
1752 {
1753 return "BayerBG10_I_A_B";
1754 }
1755
1756 static constexpr size_t storageBitsPerPixel = 10;
1757 static constexpr size_t allocatedBitsPerPixel = 16;
1758 static constexpr bool isPacked = false;
1759 static constexpr bool isInterleaved = true;
1760 static constexpr auto unpackedFormat = PixelFormat::BayerBG10_AB;
1761};
1762
1763template <>
1764struct PixelFormatTraits<PixelFormat::BayerGR10_I_A_B>
1765{
1766 using underlying_type = uint16_t;
1767
1768 static constexpr std::array<Channel, 1> Channels()
1769 {
1770 return { Channel::Bayer };
1771 }
1772
1773 static constexpr auto Name()
1774 {
1775 return "BayerGR10_I_A_B";
1776 }
1777
1778 static constexpr size_t storageBitsPerPixel = 10;
1779 static constexpr size_t allocatedBitsPerPixel = 16;
1780 static constexpr bool isPacked = false;
1781 static constexpr bool isInterleaved = true;
1782 static constexpr auto unpackedFormat = PixelFormat::BayerGR10_AB;
1783};
1784
1785template <>
1786struct PixelFormatTraits<PixelFormat::BayerGB10_I_A_B>
1787{
1788 using underlying_type = uint16_t;
1789
1790 static constexpr std::array<Channel, 1> Channels()
1791 {
1792 return { Channel::Bayer };
1793 }
1794
1795 static constexpr auto Name()
1796 {
1797 return "BayerGB10_I_A_B";
1798 }
1799
1800 static constexpr size_t storageBitsPerPixel = 10;
1801 static constexpr size_t allocatedBitsPerPixel = 16;
1802 static constexpr bool isPacked = false;
1803 static constexpr bool isInterleaved = true;
1804 static constexpr auto unpackedFormat = PixelFormat::BayerGB10_AB;
1805};
1806
1807template <>
1808struct PixelFormatTraits<PixelFormat::Mono12_I_A_B>
1809{
1810 using underlying_type = uint16_t;
1811
1812 static constexpr std::array<Channel, 1> Channels()
1813 {
1814 return { Channel::Intensity };
1815 }
1816
1817 static constexpr auto Name()
1818 {
1819 return "Mono12_I_A_B";
1820 }
1821
1822 static constexpr size_t storageBitsPerPixel = 12;
1823 static constexpr size_t allocatedBitsPerPixel = 16;
1824 static constexpr bool isPacked = false;
1825 static constexpr bool isInterleaved = true;
1826 static constexpr auto unpackedFormat = PixelFormat::Mono12_AB;
1827};
1828
1829template <>
1830struct PixelFormatTraits<PixelFormat::BayerRG12_I_A_B>
1831{
1832 using underlying_type = uint16_t;
1833
1834 static constexpr std::array<Channel, 1> Channels()
1835 {
1836 return { Channel::Bayer };
1837 }
1838
1839 static constexpr auto Name()
1840 {
1841 return "BayerRG12_I_A_B";
1842 }
1843
1844 static constexpr size_t storageBitsPerPixel = 12;
1845 static constexpr size_t allocatedBitsPerPixel = 16;
1846 static constexpr bool isPacked = false;
1847 static constexpr bool isInterleaved = true;
1848 static constexpr auto unpackedFormat = PixelFormat::BayerRG12_AB;
1849};
1850
1851template <>
1852struct PixelFormatTraits<PixelFormat::BayerBG12_I_A_B>
1853{
1854 using underlying_type = uint16_t;
1855
1856 static constexpr std::array<Channel, 1> Channels()
1857 {
1858 return { Channel::Bayer };
1859 }
1860
1861 static constexpr auto Name()
1862 {
1863 return "BayerBG12_I_A_B";
1864 }
1865
1866 static constexpr size_t storageBitsPerPixel = 12;
1867 static constexpr size_t allocatedBitsPerPixel = 16;
1868 static constexpr bool isPacked = false;
1869 static constexpr bool isInterleaved = true;
1870 static constexpr auto unpackedFormat = PixelFormat::BayerBG12_AB;
1871};
1872
1873template <>
1874struct PixelFormatTraits<PixelFormat::BayerGR12_I_A_B>
1875{
1876 using underlying_type = uint16_t;
1877
1878 static constexpr std::array<Channel, 1> Channels()
1879 {
1880 return { Channel::Bayer };
1881 }
1882
1883 static constexpr auto Name()
1884 {
1885 return "BayerGR12_I_A_B";
1886 }
1887
1888 static constexpr size_t storageBitsPerPixel = 12;
1889 static constexpr size_t allocatedBitsPerPixel = 16;
1890 static constexpr bool isPacked = false;
1891 static constexpr bool isInterleaved = true;
1892 static constexpr auto unpackedFormat = PixelFormat::BayerGR12_AB;
1893};
1894
1895template <>
1896struct PixelFormatTraits<PixelFormat::BayerGB12_I_A_B>
1897{
1898 using underlying_type = uint16_t;
1899
1900 static constexpr std::array<Channel, 1> Channels()
1901 {
1902 return { Channel::Bayer };
1903 }
1904
1905 static constexpr auto Name()
1906 {
1907 return "BayerGB12_I_A_B";
1908 }
1909
1910 static constexpr size_t storageBitsPerPixel = 12;
1911 static constexpr size_t allocatedBitsPerPixel = 16;
1912 static constexpr bool isPacked = false;
1913 static constexpr bool isInterleaved = true;
1914 static constexpr auto unpackedFormat = PixelFormat::BayerGB12_AB;
1915};
1916
1917template <>
1918struct PixelFormatTraits<PixelFormat::Mono10p_I_A_B>
1919{
1920 using underlying_type = uint8_t;
1921
1922 static constexpr std::array<Channel, 1> Channels()
1923 {
1924 return { Channel::Intensity };
1925 }
1926
1927 static constexpr auto Name()
1928 {
1929 return "Mono10p_I_A_B";
1930 }
1931
1932 static constexpr size_t storageBitsPerPixel = 10;
1933 static constexpr size_t allocatedBitsPerPixel = 10;
1934 static constexpr bool isPacked = true;
1935 static constexpr bool isInterleaved = true;
1936 static constexpr auto unpackedFormat = PixelFormat::Mono10_AB;
1937};
1938
1939template <>
1940struct PixelFormatTraits<PixelFormat::BayerRG10p_I_A_B>
1941{
1942 using underlying_type = uint8_t;
1943
1944 static constexpr std::array<Channel, 1> Channels()
1945 {
1946 return { Channel::Bayer };
1947 }
1948
1949 static constexpr auto Name()
1950 {
1951 return "BayerRG10p_I_A_B";
1952 }
1953
1954 static constexpr size_t storageBitsPerPixel = 10;
1955 static constexpr size_t allocatedBitsPerPixel = 10;
1956 static constexpr bool isPacked = true;
1957 static constexpr bool isInterleaved = true;
1958 static constexpr auto unpackedFormat = PixelFormat::BayerRG10_AB;
1959};
1960
1961template <>
1962struct PixelFormatTraits<PixelFormat::BayerBG10p_I_A_B>
1963{
1964 using underlying_type = uint8_t;
1965
1966 static constexpr std::array<Channel, 1> Channels()
1967 {
1968 return { Channel::Bayer };
1969 }
1970
1971 static constexpr auto Name()
1972 {
1973 return "BayerBG10p_I_A_B";
1974 }
1975
1976 static constexpr size_t storageBitsPerPixel = 10;
1977 static constexpr size_t allocatedBitsPerPixel = 10;
1978 static constexpr bool isPacked = true;
1979 static constexpr bool isInterleaved = true;
1980 static constexpr auto unpackedFormat = PixelFormat::BayerBG10_AB;
1981};
1982
1983template <>
1984struct PixelFormatTraits<PixelFormat::BayerGR10p_I_A_B>
1985{
1986 using underlying_type = uint8_t;
1987
1988 static constexpr std::array<Channel, 1> Channels()
1989 {
1990 return { Channel::Bayer };
1991 }
1992
1993 static constexpr auto Name()
1994 {
1995 return "BayerGR10p_I_A_B";
1996 }
1997
1998 static constexpr size_t storageBitsPerPixel = 10;
1999 static constexpr size_t allocatedBitsPerPixel = 10;
2000 static constexpr bool isPacked = true;
2001 static constexpr bool isInterleaved = true;
2002 static constexpr auto unpackedFormat = PixelFormat::BayerGR10_AB;
2003};
2004
2005template <>
2006struct PixelFormatTraits<PixelFormat::BayerGB10p_I_A_B>
2007{
2008 using underlying_type = uint8_t;
2009
2010 static constexpr std::array<Channel, 1> Channels()
2011 {
2012 return { Channel::Bayer };
2013 }
2014
2015 static constexpr auto Name()
2016 {
2017 return "BayerGB10p_I_A_B";
2018 }
2019
2020 static constexpr size_t storageBitsPerPixel = 10;
2021 static constexpr size_t allocatedBitsPerPixel = 10;
2022 static constexpr bool isPacked = true;
2023 static constexpr bool isInterleaved = true;
2024 static constexpr auto unpackedFormat = PixelFormat::BayerGB10_AB;
2025};
2026
2027template <>
2028struct PixelFormatTraits<PixelFormat::Mono12p_I_A_B>
2029{
2030 using underlying_type = uint8_t;
2031
2032 static constexpr std::array<Channel, 1> Channels()
2033 {
2034 return { Channel::Intensity };
2035 }
2036
2037 static constexpr auto Name()
2038 {
2039 return "Mono12p_I_A_B";
2040 }
2041
2042 static constexpr size_t storageBitsPerPixel = 12;
2043 static constexpr size_t allocatedBitsPerPixel = 12;
2044 static constexpr bool isPacked = true;
2045 static constexpr bool isInterleaved = true;
2046 static constexpr auto unpackedFormat = PixelFormat::Mono12_AB;
2047};
2048
2049template <>
2050struct PixelFormatTraits<PixelFormat::BayerRG12p_I_A_B>
2051{
2052 using underlying_type = uint8_t;
2053
2054 static constexpr std::array<Channel, 1> Channels()
2055 {
2056 return { Channel::Bayer };
2057 }
2058
2059 static constexpr auto Name()
2060 {
2061 return "BayerRG12p_I_A_B";
2062 }
2063
2064 static constexpr size_t storageBitsPerPixel = 12;
2065 static constexpr size_t allocatedBitsPerPixel = 12;
2066 static constexpr bool isPacked = true;
2067 static constexpr bool isInterleaved = true;
2068 static constexpr auto unpackedFormat = PixelFormat::BayerRG12_AB;
2069};
2070
2071template <>
2072struct PixelFormatTraits<PixelFormat::BayerBG12p_I_A_B>
2073{
2074 using underlying_type = uint8_t;
2075
2076 static constexpr std::array<Channel, 1> Channels()
2077 {
2078 return { Channel::Bayer };
2079 }
2080
2081 static constexpr auto Name()
2082 {
2083 return "BayerBG12p_I_A_B";
2084 }
2085
2086 static constexpr size_t storageBitsPerPixel = 12;
2087 static constexpr size_t allocatedBitsPerPixel = 12;
2088 static constexpr bool isPacked = true;
2089 static constexpr bool isInterleaved = true;
2090 static constexpr auto unpackedFormat = PixelFormat::BayerBG12_AB;
2091};
2092
2093template <>
2094struct PixelFormatTraits<PixelFormat::BayerGR12p_I_A_B>
2095{
2096 using underlying_type = uint8_t;
2097
2098 static constexpr std::array<Channel, 1> Channels()
2099 {
2100 return { Channel::Bayer };
2101 }
2102
2103 static constexpr auto Name()
2104 {
2105 return "BayerGR12p_I_A_B";
2106 }
2107
2108 static constexpr size_t storageBitsPerPixel = 12;
2109 static constexpr size_t allocatedBitsPerPixel = 12;
2110 static constexpr bool isPacked = true;
2111 static constexpr bool isInterleaved = true;
2112 static constexpr auto unpackedFormat = PixelFormat::BayerGR12_AB;
2113};
2114
2115template <>
2116struct PixelFormatTraits<PixelFormat::BayerGB12p_I_A_B>
2117{
2118 using underlying_type = uint8_t;
2119
2120 static constexpr std::array<Channel, 1> Channels()
2121 {
2122 return { Channel::Bayer };
2123 }
2124
2125 static constexpr auto Name()
2126 {
2127 return "BayerGB12p_I_A_B";
2128 }
2129
2130 static constexpr size_t storageBitsPerPixel = 12;
2131 static constexpr size_t allocatedBitsPerPixel = 12;
2132 static constexpr bool isPacked = true;
2133 static constexpr bool isInterleaved = true;
2134 static constexpr auto unpackedFormat = PixelFormat::BayerGB12_AB;
2135};
2136
2137template <>
2138struct PixelFormatTraits<PixelFormat::Mono8_I_AB_CD>
2139{
2140 using underlying_type = uint8_t;
2141
2142 static constexpr std::array<Channel, 1> Channels()
2143 {
2144 return { Channel::Intensity };
2145 }
2146
2147 static constexpr auto Name()
2148 {
2149 return "Mono8_I_AB_CD";
2150 }
2151
2152 static constexpr size_t storageBitsPerPixel = 8;
2153 static constexpr size_t allocatedBitsPerPixel = 8;
2154 static constexpr bool isPacked = false;
2155 static constexpr bool isInterleaved = true;
2156 static constexpr auto unpackedFormat = PixelFormat::Mono8_ABCD;
2157};
2158
2159template <>
2160struct PixelFormatTraits<PixelFormat::Mono10_I_AB_CD>
2161{
2162 using underlying_type = uint16_t;
2163
2164 static constexpr std::array<Channel, 1> Channels()
2165 {
2166 return { Channel::Intensity };
2167 }
2168
2169 static constexpr auto Name()
2170 {
2171 return "Mono10_I_AB_CD";
2172 }
2173
2174 static constexpr size_t storageBitsPerPixel = 10;
2175 static constexpr size_t allocatedBitsPerPixel = 16;
2176 static constexpr bool isPacked = false;
2177 static constexpr bool isInterleaved = true;
2178 static constexpr auto unpackedFormat = PixelFormat::Mono10_ABCD;
2179};
2180
2181template <>
2182struct PixelFormatTraits<PixelFormat::Mono12_I_AB_CD>
2183{
2184 using underlying_type = uint16_t;
2185
2186 static constexpr std::array<Channel, 1> Channels()
2187 {
2188 return { Channel::Intensity };
2189 }
2190
2191 static constexpr auto Name()
2192 {
2193 return "Mono12_I_AB_CD";
2194 }
2195
2196 static constexpr size_t storageBitsPerPixel = 12;
2197 static constexpr size_t allocatedBitsPerPixel = 16;
2198 static constexpr bool isPacked = false;
2199 static constexpr bool isInterleaved = true;
2200 static constexpr auto unpackedFormat = PixelFormat::Mono12_ABCD;
2201};
2202
2203template <>
2204struct PixelFormatTraits<PixelFormat::Mono10p_I_AB_CD>
2205{
2206 using underlying_type = uint8_t;
2207
2208 static constexpr std::array<Channel, 1> Channels()
2209 {
2210 return { Channel::Intensity };
2211 }
2212
2213 static constexpr auto Name()
2214 {
2215 return "Mono10p_I_AB_CD";
2216 }
2217
2218 static constexpr size_t storageBitsPerPixel = 10;
2219 static constexpr size_t allocatedBitsPerPixel = 10;
2220 static constexpr bool isPacked = true;
2221 static constexpr bool isInterleaved = true;
2222 static constexpr auto unpackedFormat = PixelFormat::Mono10_ABCD;
2223};
2224
2225template <>
2226struct PixelFormatTraits<PixelFormat::Mono12p_I_AB_CD>
2227{
2228 using underlying_type = uint8_t;
2229
2230 static constexpr std::array<Channel, 1> Channels()
2231 {
2232 return { Channel::Intensity };
2233 }
2234
2235 static constexpr auto Name()
2236 {
2237 return "Mono12p_I_AB_CD";
2238 }
2239
2240 static constexpr size_t storageBitsPerPixel = 12;
2241 static constexpr size_t allocatedBitsPerPixel = 12;
2242 static constexpr bool isPacked = true;
2243 static constexpr bool isInterleaved = true;
2244 static constexpr auto unpackedFormat = PixelFormat::Mono12_ABCD;
2245};
2246
2247template <>
2248struct PixelFormatTraits<PixelFormat::Mono10g40IDS_I_AB_CD>
2249{
2250 using underlying_type = uint8_t;
2251
2252 static constexpr std::array<Channel, 1> Channels()
2253 {
2254 return { Channel::Intensity };
2255 }
2256
2257 static constexpr auto Name()
2258 {
2259 return "Mono10g40IDS_I_AB_CD";
2260 }
2261
2262 static constexpr size_t storageBitsPerPixel = 10;
2263 static constexpr size_t allocatedBitsPerPixel = 10;
2264 static constexpr bool isPacked = true;
2265 static constexpr bool isInterleaved = true;
2266 static constexpr auto unpackedFormat = PixelFormat::Mono10_ABCD;
2267};
2268
2269template <>
2270struct PixelFormatTraits<PixelFormat::Mono12g24IDS_I_AB_CD>
2271{
2272 using underlying_type = uint8_t;
2273
2274 static constexpr std::array<Channel, 1> Channels()
2275 {
2276 return { Channel::Intensity };
2277 }
2278
2279 static constexpr auto Name()
2280 {
2281 return "Mono12g24IDS_I_AB_CD";
2282 }
2283
2284 static constexpr size_t storageBitsPerPixel = 12;
2285 static constexpr size_t allocatedBitsPerPixel = 12;
2286 static constexpr bool isPacked = true;
2287 static constexpr bool isInterleaved = true;
2288 static constexpr auto unpackedFormat = PixelFormat::Mono12_ABCD;
2289};
2290
2291template <>
2292struct PixelFormatTraits<PixelFormat::Mono10_AB>
2293{
2294 using underlying_type = uint16_t;
2295
2296 static constexpr std::array<Channel, 2> Channels()
2297 {
2298 return { Channel::Intensity, Channel::Intensity };
2299 }
2300
2301 static constexpr auto Name()
2302 {
2303 return "Mono10_AB";
2304 }
2305
2306 static constexpr size_t storageBitsPerPixel = 20;
2307 static constexpr size_t allocatedBitsPerPixel = 32;
2308 static constexpr bool isPacked = false;
2309 static constexpr bool isInterleaved = false;
2310 static constexpr auto unpackedFormat = PixelFormat::Mono10_AB;
2311};
2312
2313template <>
2314struct PixelFormatTraits<PixelFormat::BayerRG10_AB>
2315{
2316 using underlying_type = uint16_t;
2317
2318 static constexpr std::array<Channel, 2> Channels()
2319 {
2320 return { Channel::Bayer, Channel::Bayer };
2321 }
2322
2323 static constexpr auto Name()
2324 {
2325 return "BayerRG10_AB";
2326 }
2327
2328 static constexpr size_t storageBitsPerPixel = 20;
2329 static constexpr size_t allocatedBitsPerPixel = 32;
2330 static constexpr bool isPacked = false;
2331 static constexpr bool isInterleaved = false;
2332 static constexpr auto unpackedFormat = PixelFormat::BayerRG10_AB;
2333};
2334
2335template <>
2336struct PixelFormatTraits<PixelFormat::BayerBG10_AB>
2337{
2338 using underlying_type = uint16_t;
2339
2340 static constexpr std::array<Channel, 2> Channels()
2341 {
2342 return { Channel::Bayer, Channel::Bayer };
2343 }
2344
2345 static constexpr auto Name()
2346 {
2347 return "BayerBG10_AB";
2348 }
2349
2350 static constexpr size_t storageBitsPerPixel = 20;
2351 static constexpr size_t allocatedBitsPerPixel = 32;
2352 static constexpr bool isPacked = false;
2353 static constexpr bool isInterleaved = false;
2354 static constexpr auto unpackedFormat = PixelFormat::BayerBG10_AB;
2355};
2356
2357template <>
2358struct PixelFormatTraits<PixelFormat::BayerGR10_AB>
2359{
2360 using underlying_type = uint16_t;
2361
2362 static constexpr std::array<Channel, 2> Channels()
2363 {
2364 return { Channel::Bayer, Channel::Bayer };
2365 }
2366
2367 static constexpr auto Name()
2368 {
2369 return "BayerGR10_AB";
2370 }
2371
2372 static constexpr size_t storageBitsPerPixel = 20;
2373 static constexpr size_t allocatedBitsPerPixel = 32;
2374 static constexpr bool isPacked = false;
2375 static constexpr bool isInterleaved = false;
2376 static constexpr auto unpackedFormat = PixelFormat::BayerGR10_AB;
2377};
2378
2379template <>
2380struct PixelFormatTraits<PixelFormat::BayerGB10_AB>
2381{
2382 using underlying_type = uint16_t;
2383
2384 static constexpr std::array<Channel, 2> Channels()
2385 {
2386 return { Channel::Bayer, Channel::Bayer };
2387 }
2388
2389 static constexpr auto Name()
2390 {
2391 return "BayerGB10_AB";
2392 }
2393
2394 static constexpr size_t storageBitsPerPixel = 20;
2395 static constexpr size_t allocatedBitsPerPixel = 32;
2396 static constexpr bool isPacked = false;
2397 static constexpr bool isInterleaved = false;
2398 static constexpr auto unpackedFormat = PixelFormat::BayerGB10_AB;
2399};
2400
2401template <>
2402struct PixelFormatTraits<PixelFormat::Mono12_AB>
2403{
2404 using underlying_type = uint16_t;
2405
2406 static constexpr std::array<Channel, 2> Channels()
2407 {
2408 return { Channel::Intensity, Channel::Intensity };
2409 }
2410
2411 static constexpr auto Name()
2412 {
2413 return "Mono12_AB";
2414 }
2415
2416 static constexpr size_t storageBitsPerPixel = 24;
2417 static constexpr size_t allocatedBitsPerPixel = 32;
2418 static constexpr bool isPacked = false;
2419 static constexpr bool isInterleaved = false;
2420 static constexpr auto unpackedFormat = PixelFormat::Mono12_AB;
2421};
2422
2423template <>
2424struct PixelFormatTraits<PixelFormat::BayerRG12_AB>
2425{
2426 using underlying_type = uint16_t;
2427
2428 static constexpr std::array<Channel, 2> Channels()
2429 {
2430 return { Channel::Bayer, Channel::Bayer };
2431 }
2432
2433 static constexpr auto Name()
2434 {
2435 return "BayerRG12_AB";
2436 }
2437
2438 static constexpr size_t storageBitsPerPixel = 24;
2439 static constexpr size_t allocatedBitsPerPixel = 32;
2440 static constexpr bool isPacked = false;
2441 static constexpr bool isInterleaved = false;
2442 static constexpr auto unpackedFormat = PixelFormat::BayerRG12_AB;
2443};
2444
2445template <>
2446struct PixelFormatTraits<PixelFormat::BayerBG12_AB>
2447{
2448 using underlying_type = uint16_t;
2449
2450 static constexpr std::array<Channel, 2> Channels()
2451 {
2452 return { Channel::Bayer, Channel::Bayer };
2453 }
2454
2455 static constexpr auto Name()
2456 {
2457 return "BayerBG12_AB";
2458 }
2459
2460 static constexpr size_t storageBitsPerPixel = 24;
2461 static constexpr size_t allocatedBitsPerPixel = 32;
2462 static constexpr bool isPacked = false;
2463 static constexpr bool isInterleaved = false;
2464 static constexpr auto unpackedFormat = PixelFormat::BayerBG12_AB;
2465};
2466
2467template <>
2468struct PixelFormatTraits<PixelFormat::BayerGR12_AB>
2469{
2470 using underlying_type = uint16_t;
2471
2472 static constexpr std::array<Channel, 2> Channels()
2473 {
2474 return { Channel::Bayer, Channel::Bayer };
2475 }
2476
2477 static constexpr auto Name()
2478 {
2479 return "BayerGR12_AB";
2480 }
2481
2482 static constexpr size_t storageBitsPerPixel = 24;
2483 static constexpr size_t allocatedBitsPerPixel = 32;
2484 static constexpr bool isPacked = false;
2485 static constexpr bool isInterleaved = false;
2486 static constexpr auto unpackedFormat = PixelFormat::BayerGR12_AB;
2487};
2488
2489template <>
2490struct PixelFormatTraits<PixelFormat::BayerGB12_AB>
2491{
2492 using underlying_type = uint16_t;
2493
2494 static constexpr std::array<Channel, 2> Channels()
2495 {
2496 return { Channel::Bayer, Channel::Bayer };
2497 }
2498
2499 static constexpr auto Name()
2500 {
2501 return "BayerGB12_AB";
2502 }
2503
2504 static constexpr size_t storageBitsPerPixel = 24;
2505 static constexpr size_t allocatedBitsPerPixel = 32;
2506 static constexpr bool isPacked = false;
2507 static constexpr bool isInterleaved = false;
2508 static constexpr auto unpackedFormat = PixelFormat::BayerGB12_AB;
2509};
2510
2511template <>
2512struct PixelFormatTraits<PixelFormat::Mono8_AB>
2513{
2514 using underlying_type = uint8_t;
2515
2516 static constexpr std::array<Channel, 2> Channels()
2517 {
2518 return { Channel::Intensity, Channel::Intensity };
2519 }
2520
2521 static constexpr auto Name()
2522 {
2523 return "Mono8_AB";
2524 }
2525
2526 static constexpr size_t storageBitsPerPixel = 16;
2527 static constexpr size_t allocatedBitsPerPixel = 16;
2528 static constexpr bool isPacked = false;
2529 static constexpr bool isInterleaved = false;
2530 static constexpr auto unpackedFormat = PixelFormat::Mono8_AB;
2531};
2532
2533template <>
2534struct PixelFormatTraits<PixelFormat::BayerRG8_AB>
2535{
2536 using underlying_type = uint8_t;
2537
2538 static constexpr std::array<Channel, 2> Channels()
2539 {
2540 return { Channel::Bayer, Channel::Bayer };
2541 }
2542
2543 static constexpr auto Name()
2544 {
2545 return "BayerRG8_AB";
2546 }
2547
2548 static constexpr size_t storageBitsPerPixel = 16;
2549 static constexpr size_t allocatedBitsPerPixel = 16;
2550 static constexpr bool isPacked = false;
2551 static constexpr bool isInterleaved = false;
2552 static constexpr auto unpackedFormat = PixelFormat::BayerRG8_AB;
2553};
2554
2555template <>
2556struct PixelFormatTraits<PixelFormat::BayerBG8_AB>
2557{
2558 using underlying_type = uint8_t;
2559
2560 static constexpr std::array<Channel, 2> Channels()
2561 {
2562 return { Channel::Bayer, Channel::Bayer };
2563 }
2564
2565 static constexpr auto Name()
2566 {
2567 return "BayerBG8_AB";
2568 }
2569
2570 static constexpr size_t storageBitsPerPixel = 16;
2571 static constexpr size_t allocatedBitsPerPixel = 16;
2572 static constexpr bool isPacked = false;
2573 static constexpr bool isInterleaved = false;
2574 static constexpr auto unpackedFormat = PixelFormat::BayerBG8_AB;
2575};
2576
2577template <>
2578struct PixelFormatTraits<PixelFormat::BayerGR8_AB>
2579{
2580 using underlying_type = uint8_t;
2581
2582 static constexpr std::array<Channel, 2> Channels()
2583 {
2584 return { Channel::Bayer, Channel::Bayer };
2585 }
2586
2587 static constexpr auto Name()
2588 {
2589 return "BayerGR8_AB";
2590 }
2591
2592 static constexpr size_t storageBitsPerPixel = 16;
2593 static constexpr size_t allocatedBitsPerPixel = 16;
2594 static constexpr bool isPacked = false;
2595 static constexpr bool isInterleaved = false;
2596 static constexpr auto unpackedFormat = PixelFormat::BayerGR8_AB;
2597};
2598
2599template <>
2600struct PixelFormatTraits<PixelFormat::BayerGB8_AB>
2601{
2602 using underlying_type = uint8_t;
2603
2604 static constexpr std::array<Channel, 2> Channels()
2605 {
2606 return { Channel::Bayer, Channel::Bayer };
2607 }
2608
2609 static constexpr auto Name()
2610 {
2611 return "BayerGB8_AB";
2612 }
2613
2614 static constexpr size_t storageBitsPerPixel = 16;
2615 static constexpr size_t allocatedBitsPerPixel = 16;
2616 static constexpr bool isPacked = false;
2617 static constexpr bool isInterleaved = false;
2618 static constexpr auto unpackedFormat = PixelFormat::BayerGB8_AB;
2619};
2620
2621template <>
2622struct PixelFormatTraits<PixelFormat::Mono8_ABCD>
2623{
2624 using underlying_type = uint8_t;
2625
2626 static constexpr std::array<Channel, 4> Channels()
2627 {
2628 return { Channel::Intensity, Channel::Intensity, Channel::Intensity, Channel::Intensity };
2629 }
2630
2631 static constexpr auto Name()
2632 {
2633 return "Mono8_ABCD";
2634 }
2635
2636 static constexpr size_t storageBitsPerPixel = 32;
2637 static constexpr size_t allocatedBitsPerPixel = 32;
2638 static constexpr bool isPacked = false;
2639 static constexpr bool isInterleaved = false;
2640 static constexpr auto unpackedFormat = PixelFormat::Mono8_ABCD;
2641};
2642
2643template <>
2644struct PixelFormatTraits<PixelFormat::Mono10_ABCD>
2645{
2646 using underlying_type = uint16_t;
2647
2648 static constexpr std::array<Channel, 4> Channels()
2649 {
2650 return { Channel::Intensity, Channel::Intensity, Channel::Intensity, Channel::Intensity };
2651 }
2652
2653 static constexpr auto Name()
2654 {
2655 return "Mono10_ABCD";
2656 }
2657
2658 static constexpr size_t storageBitsPerPixel = 40;
2659 static constexpr size_t allocatedBitsPerPixel = 64;
2660 static constexpr bool isPacked = false;
2661 static constexpr bool isInterleaved = false;
2662 static constexpr auto unpackedFormat = PixelFormat::Mono10_ABCD;
2663};
2664
2665template <>
2666struct PixelFormatTraits<PixelFormat::Mono12_ABCD>
2667{
2668 using underlying_type = uint16_t;
2669
2670 static constexpr std::array<Channel, 4> Channels()
2671 {
2672 return { Channel::Intensity, Channel::Intensity, Channel::Intensity, Channel::Intensity };
2673 }
2674
2675 static constexpr auto Name()
2676 {
2677 return "Mono12_ABCD";
2678 }
2679
2680 static constexpr size_t storageBitsPerPixel = 48;
2681 static constexpr size_t allocatedBitsPerPixel = 64;
2682 static constexpr bool isPacked = false;
2683 static constexpr bool isInterleaved = false;
2684 static constexpr auto unpackedFormat = PixelFormat::Mono12_ABCD;
2685};
2686
2687} // namespace detail
2688} // namespace common
2689} // namespace peak
2690
2691
peak::common::PixelFormat
PixelFormat
Enum listing all supported pixel formats and their internal IDs.
Definition peak_common_pixel_format.hpp:51
peak::common::PixelFormat::RGB32fIDS
@ RGB32fIDS
RGB 32-Bit float format (IDS)
Definition peak_common_pixel_format.hpp:135
peak::common::PixelFormat::BayerGR12p_I_A_B
@ BayerGR12p_I_A_B
BayerGR 12-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:170
peak::common::PixelFormat::BayerGB12_AB
@ BayerGB12_AB
BayerGB 12-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:189
peak::common::PixelFormat::BayerRG12g24IDS
@ BayerRG12g24IDS
BayerRG 12-Bit grouped 24-bit (IDS)
Definition peak_common_pixel_format.hpp:126
peak::common::PixelFormat::BayerBG12p_I_A_B
@ BayerBG12p_I_A_B
BayerBG 12-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:169
peak::common::PixelFormat::Coord3D_C8
@ Coord3D_C8
3D coordinate C 8-Bit format
Definition peak_common_pixel_format.hpp:76
peak::common::PixelFormat::Mono10g40IDS_I_A_B
@ Mono10g40IDS_I_A_B
Mono 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:137
peak::common::PixelFormat::RGBa10
@ RGBa10
RGBA 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:96
peak::common::PixelFormat::RGB8
@ RGB8
RGB 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:87
peak::common::PixelFormat::Mono10_I_AB_CD
@ Mono10_I_AB_CD
Mono 10-Bit pixel format pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:173
peak::common::PixelFormat::Mono12p
@ Mono12p
Mono 12-Bit packed format.
Definition peak_common_pixel_format.hpp:116
peak::common::PixelFormat::Mono12
@ Mono12
Mono 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:70
peak::common::PixelFormat::BGR10p32
@ BGR10p32
BGR 10-Bit packed 32-bit format.
Definition peak_common_pixel_format.hpp:119
peak::common::PixelFormat::BayerGR12_AB
@ BayerGR12_AB
BayerGR 12-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:188
peak::common::PixelFormat::BayerGB10
@ BayerGB10
BayerGB 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:61
peak::common::PixelFormat::BayerBG8_I_A_B
@ BayerBG8_I_A_B
BayerBG 8-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:149
peak::common::PixelFormat::BayerGB12p_I_A_B
@ BayerGB12p_I_A_B
BayerGB 12-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:171
peak::common::PixelFormat::BayerRG12p
@ BayerRG12p
BayerRG 12-Bit packed format.
Definition peak_common_pixel_format.hpp:113
peak::common::PixelFormat::BayerBG10
@ BayerBG10
BayerBG 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:65
peak::common::PixelFormat::BayerGR10_I_A_B
@ BayerGR10_I_A_B
BayerGR 10-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:155
peak::common::PixelFormat::RGBa8
@ RGBa8
RGBA 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:95
peak::common::PixelFormat::Mono10g40IDS
@ Mono10g40IDS
Mono 10-Bit grouped 40-bit (IDS)
Definition peak_common_pixel_format.hpp:131
peak::common::PixelFormat::BayerRG8_I_A_B
@ BayerRG8_I_A_B
BayerRG 8-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:148
peak::common::PixelFormat::BayerGB10g40IDS_I_A_B
@ BayerGB10g40IDS_I_A_B
BayerGB 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:141
peak::common::PixelFormat::BayerGR10g40IDS
@ BayerGR10g40IDS
BayerGR 10-Bit grouped 40-bit (IDS)
Definition peak_common_pixel_format.hpp:123
peak::common::PixelFormat::BayerGR12_I_A_B
@ BayerGR12_I_A_B
BayerGR 12-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:160
peak::common::PixelFormat::BayerBG8_AB
@ BayerBG8_AB
BayerBG 8-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:192
peak::common::PixelFormat::BayerBG10p
@ BayerBG10p
BayerBG 10-Bit packed format.
Definition peak_common_pixel_format.hpp:103
peak::common::PixelFormat::BayerRG10p_I_A_B
@ BayerRG10p_I_A_B
BayerRG 10-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:163
peak::common::PixelFormat::Mono10_ABCD
@ Mono10_ABCD
Mono 10-Bit pixel format Components A, B, C, D.
Definition peak_common_pixel_format.hpp:196
peak::common::PixelFormat::RGBa12
@ RGBa12
RGBA 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:97
peak::common::PixelFormat::BayerGB10p_I_A_B
@ BayerGB10p_I_A_B
BayerGB 10-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:166
peak::common::PixelFormat::BayerGB12p
@ BayerGB12p
BayerGB 12-Bit packed format.
Definition peak_common_pixel_format.hpp:107
peak::common::PixelFormat::BGRa12
@ BGRa12
BGRA 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:101
peak::common::PixelFormat::BayerGR12
@ BayerGR12
BayerGR 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:54
peak::common::PixelFormat::Mono10p_I_A_B
@ Mono10p_I_A_B
Mono 10-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:162
peak::common::PixelFormat::BayerRG10p
@ BayerRG10p
BayerRG 10-Bit packed format.
Definition peak_common_pixel_format.hpp:112
peak::common::PixelFormat::BayerGR8_I_A_B
@ BayerGR8_I_A_B
BayerGR 8-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:150
peak::common::PixelFormat::BayerGR10p_I_A_B
@ BayerGR10p_I_A_B
BayerGR 10-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:165
peak::common::PixelFormat::BayerRG12
@ BayerRG12
BayerRG 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:58
peak::common::PixelFormat::BayerBG10g40IDS_I_A_B
@ BayerBG10g40IDS_I_A_B
BayerBG 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:139
peak::common::PixelFormat::BayerGR12p
@ BayerGR12p
BayerGR 12-Bit packed format.
Definition peak_common_pixel_format.hpp:110
peak::common::PixelFormat::BayerGR8
@ BayerGR8
BayerGR 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:52
peak::common::PixelFormat::BayerBG12p
@ BayerBG12p
BayerBG 12-Bit packed format.
Definition peak_common_pixel_format.hpp:104
peak::common::PixelFormat::BayerBG8
@ BayerBG8
BayerBG 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:64
peak::common::PixelFormat::BayerBG12_AB
@ BayerBG12_AB
BayerBG 12-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:187
peak::common::PixelFormat::Confidence16
@ Confidence16
Confidence 16-Bit format.
Definition peak_common_pixel_format.hpp:74
peak::common::PixelFormat::BayerGB12_I_A_B
@ BayerGB12_I_A_B
BayerGB 12-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:161
peak::common::PixelFormat::Mono12g24IDS
@ Mono12g24IDS
Mono 12-Bit grouped 24-bit (IDS)
Definition peak_common_pixel_format.hpp:132
peak::common::PixelFormat::BayerRG10
@ BayerRG10
BayerRG 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:57
peak::common::PixelFormat::BayerGB12
@ BayerGB12
BayerGB 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:62
peak::common::PixelFormat::Mono8_I_AB_CD
@ Mono8_I_AB_CD
Mono 8-Bit pixel format pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:172
peak::common::PixelFormat::BayerRG8
@ BayerRG8
BayerRG 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:56
peak::common::PixelFormat::BayerGR10p
@ BayerGR10p
BayerGR 10-Bit packed format.
Definition peak_common_pixel_format.hpp:109
peak::common::PixelFormat::BayerBG12_I_A_B
@ BayerBG12_I_A_B
BayerBG 12-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:159
peak::common::PixelFormat::BayerBG10_AB
@ BayerBG10_AB
BayerBG 10-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:182
peak::common::PixelFormat::YUV422_8_UYVY
@ YUV422_8_UYVY
UYVY 4:2:2 8-Bit format.
Definition peak_common_pixel_format.hpp:85
peak::common::PixelFormat::YUV420_8_YY_VU_SemiplanarIDS
@ YUV420_8_YY_VU_SemiplanarIDS
YUV4:2:0 8-Bit YY/VU semiplanar (IDS)
Definition peak_common_pixel_format.hpp:83
peak::common::PixelFormat::BayerRG12g24IDS_I_A_B
@ BayerRG12g24IDS_I_A_B
BayerRG 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:143
peak::common::PixelFormat::Mono8_ABCD
@ Mono8_ABCD
Mono 8-Bit pixel format Components A, B, C, D.
Definition peak_common_pixel_format.hpp:195
peak::common::PixelFormat::Mono12p_I_AB_CD
@ Mono12p_I_AB_CD
Mono 12-Bit packed format pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:176
peak::common::PixelFormat::BayerGB8
@ BayerGB8
BayerGB 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:60
peak::common::PixelFormat::Mono12_I_AB_CD
@ Mono12_I_AB_CD
Mono 12-Bit pixel format pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:174
peak::common::PixelFormat::Mono10_I_A_B
@ Mono10_I_A_B
Mono 10-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:152
peak::common::PixelFormat::BGR12
@ BGR12
BGR 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:93
peak::common::PixelFormat::Mono8_AB
@ Mono8_AB
Mono 8-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:190
peak::common::PixelFormat::Confidence8
@ Confidence8
Confidence 8-Bit format.
Definition peak_common_pixel_format.hpp:73
peak::common::PixelFormat::Mono10g40IDS_I_AB_CD
@ Mono10g40IDS_I_AB_CD
Mono 10-Bit grouped 40-bit (IDS) pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:177
peak::common::PixelFormat::BayerRG10g40IDS_I_A_B
@ BayerRG10g40IDS_I_A_B
BayerRG 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:138
peak::common::PixelFormat::BayerGR12g24IDS_I_A_B
@ BayerGR12g24IDS_I_A_B
BayerGR 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:145
peak::common::PixelFormat::RGB10
@ RGB10
RGB 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:88
peak::common::PixelFormat::BayerGR12g24IDS
@ BayerGR12g24IDS
BayerGR 12-Bit grouped 24-bit (IDS)
Definition peak_common_pixel_format.hpp:128
peak::common::PixelFormat::YUV420_8_YY_UV_SemiplanarIDS
@ YUV420_8_YY_UV_SemiplanarIDS
YUV4:2:0 8-Bit YY/UV semiplanar (IDS)
Definition peak_common_pixel_format.hpp:82
peak::common::PixelFormat::BayerGR10
@ BayerGR10
BayerGR 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:53
peak::common::PixelFormat::Coord3D_C32f
@ Coord3D_C32f
3D coordinate C 32-Bit float format
Definition peak_common_pixel_format.hpp:78
peak::common::PixelFormat::Mono16
@ Mono16
Mono 16-Bit pixel format.
Definition peak_common_pixel_format.hpp:71
peak::common::PixelFormat::Mono10
@ Mono10
Mono 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:69
peak::common::PixelFormat::BayerRG12_AB
@ BayerRG12_AB
BayerRG 12-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:186
peak::common::PixelFormat::Mono10p_I_AB_CD
@ Mono10p_I_AB_CD
Mono 10-Bit packed format pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:175
peak::common::PixelFormat::Mono12g24IDS_I_A_B
@ Mono12g24IDS_I_A_B
Mono 12-Bit grouped 24-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:142
peak::common::PixelFormat::BayerRG10_AB
@ BayerRG10_AB
BayerRG 10-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:181
peak::common::PixelFormat::Mono8
@ Mono8
Mono 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:68
peak::common::PixelFormat::Mono12_I_A_B
@ Mono12_I_A_B
Mono 12-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:157
peak::common::PixelFormat::BGR10
@ BGR10
BGR 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:92
peak::common::PixelFormat::BayerBG10_I_A_B
@ BayerBG10_I_A_B
BayerBG 10-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:154
peak::common::PixelFormat::Mono12p_I_A_B
@ Mono12p_I_A_B
Mono 12-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:167
peak::common::PixelFormat::BayerGB12g24IDS_I_A_B
@ BayerGB12g24IDS_I_A_B
BayerGB 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:146
peak::common::PixelFormat::Coord3D_ABC32f
@ Coord3D_ABC32f
3D coordinates A, B, C 32-Bit float format
Definition peak_common_pixel_format.hpp:80
peak::common::PixelFormat::RGB12
@ RGB12
RGB 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:89
peak::common::PixelFormat::BayerGB10_I_A_B
@ BayerGB10_I_A_B
BayerGB 10-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:156
peak::common::PixelFormat::BayerBG10p_I_A_B
@ BayerBG10p_I_A_B
BayerBG 10-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:164
peak::common::PixelFormat::BayerGR10_AB
@ BayerGR10_AB
BayerGR 10-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:183
peak::common::PixelFormat::BayerBG12
@ BayerBG12
BayerBG 12-Bit pixel format.
Definition peak_common_pixel_format.hpp:66
peak::common::PixelFormat::BayerBG10g40IDS
@ BayerBG10g40IDS
BayerBG 10-Bit grouped 40-bit (IDS)
Definition peak_common_pixel_format.hpp:124
peak::common::PixelFormat::BayerGR8_AB
@ BayerGR8_AB
BayerGR 8-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:193
peak::common::PixelFormat::BayerGB10p
@ BayerGB10p
BayerGB 10-Bit packed format.
Definition peak_common_pixel_format.hpp:106
peak::common::PixelFormat::Mono12g24IDS_I_AB_CD
@ Mono12g24IDS_I_AB_CD
Mono 12-Bit grouped 24-bit (IDS) pixel Interleaved Components A, B, C, D.
Definition peak_common_pixel_format.hpp:178
peak::common::PixelFormat::Mono32fIDS
@ Mono32fIDS
Mono 32-Bit float format (IDS)
Definition peak_common_pixel_format.hpp:134
peak::common::PixelFormat::BayerRG8_AB
@ BayerRG8_AB
BayerRG 8-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:191
peak::common::PixelFormat::BGRa8
@ BGRa8
BGRA 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:99
peak::common::PixelFormat::BayerGB8_AB
@ BayerGB8_AB
BayerGB 8-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:194
peak::common::PixelFormat::BayerGB10_AB
@ BayerGB10_AB
BayerGB 10-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:184
peak::common::PixelFormat::BGRa10
@ BGRa10
BGRA 10-Bit pixel format.
Definition peak_common_pixel_format.hpp:100
peak::common::PixelFormat::Coord3D_C16
@ Coord3D_C16
3D coordinate C 16-Bit format
Definition peak_common_pixel_format.hpp:77
peak::common::PixelFormat::BayerRG12_I_A_B
@ BayerRG12_I_A_B
BayerRG 12-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:158
peak::common::PixelFormat::BGR8
@ BGR8
BGR 8-Bit pixel format.
Definition peak_common_pixel_format.hpp:91
peak::common::PixelFormat::BayerBG12g24IDS_I_A_B
@ BayerBG12g24IDS_I_A_B
BayerBG 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:144
peak::common::PixelFormat::BayerBG12g24IDS
@ BayerBG12g24IDS
BayerBG 12-Bit grouped 24-bit (IDS)
Definition peak_common_pixel_format.hpp:129
peak::common::PixelFormat::Mono8_I_A_B
@ Mono8_I_A_B
Mono 8-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:147
peak::common::PixelFormat::Mono12_AB
@ Mono12_AB
Mono 12-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:185
peak::common::PixelFormat::Mono10_AB
@ Mono10_AB
Mono 10-Bit pixel format Components A, B.
Definition peak_common_pixel_format.hpp:180
peak::common::PixelFormat::BayerGR10g40IDS_I_A_B
@ BayerGR10g40IDS_I_A_B
BayerGR 10-Bit grouped 40-bit (IDS) line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:140
peak::common::PixelFormat::Mono10p
@ Mono10p
Mono 10-Bit packed format.
Definition peak_common_pixel_format.hpp:115
peak::common::PixelFormat::BayerRG10g40IDS
@ BayerRG10g40IDS
BayerRG 10-Bit grouped 40-bit (IDS)
Definition peak_common_pixel_format.hpp:121
peak::common::PixelFormat::BayerGB8_I_A_B
@ BayerGB8_I_A_B
BayerGB 8-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:151
peak::common::PixelFormat::BayerRG12p_I_A_B
@ BayerRG12p_I_A_B
BayerRG 12-Bit packed format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:168
peak::common::PixelFormat::Mono12_ABCD
@ Mono12_ABCD
Mono 12-Bit pixel format Components A, B, C, D.
Definition peak_common_pixel_format.hpp:197
peak::common::PixelFormat::BayerRG10_I_A_B
@ BayerRG10_I_A_B
BayerRG 10-Bit pixel format line Interleaved Components A, B.
Definition peak_common_pixel_format.hpp:153
peak::common::PixelFormat::RGB10p32
@ RGB10p32
RGB 10-Bit packed 32-bit format.
Definition peak_common_pixel_format.hpp:118
peak::common::PixelFormat::BayerGB10g40IDS
@ BayerGB10g40IDS
BayerGB 10-Bit grouped 40-bit (IDS)
Definition peak_common_pixel_format.hpp:122
peak::common::PixelFormat::BayerGB12g24IDS
@ BayerGB12g24IDS
BayerGB 12-Bit grouped 24-bit (IDS)
Definition peak_common_pixel_format.hpp:127
peak::common::detail
Namespace for internal implementation details and low-level types.
Definition peak_common_math.hpp:24
peak::common
Root namespace for common types and interfaces shared across multiple libraries.
Definition peak_common_math.hpp:22