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