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