cine-handler 0.2.0__py3-none-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,57 @@
1
+ """Compatibility wrapper around Rust's standalone frame decoder."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import numpy as np
6
+
7
+ from ._native import check, library
8
+
9
+
10
+ def decode_frame_payload(
11
+ raw: bytes,
12
+ *,
13
+ bit_count: int,
14
+ width: int,
15
+ height_signed: int,
16
+ real_bpp: int,
17
+ unpack_10bit_fn,
18
+ compression: int | None = None,
19
+ ) -> np.ndarray:
20
+ """Decode a payload in legacy storage-row/BGR order.
21
+
22
+ Supply bitmap ``compression`` when available (0 normal, 256 packed10,
23
+ 1024 packed12). Older callers omit it; packed10 is then recognized from
24
+ its payload length as well as RealBPP, so normal 10-bit-in-16-bit data is
25
+ decoded correctly. The historical packed decoder callback is preserved.
26
+ """
27
+ if bit_count not in (8, 16, 24, 48) or width <= 0 or height_signed == 0:
28
+ raise ValueError("Unsupported bit depth or image dimensions")
29
+ channels = 1 if bit_count in (8, 16) else 3
30
+ height = abs(int(height_signed))
31
+ samples = height * int(width) * channels
32
+ if compression is None:
33
+ compression = 256 if real_bpp == 10 and len(raw) == ((samples + 3) // 4) * 5 else 0
34
+ shape = (height, int(width)) + (() if channels == 1 else (3,))
35
+ if compression == 256 and unpack_10bit_fn is not None:
36
+ output = unpack_10bit_fn(raw)
37
+ if output.size < samples:
38
+ raise ValueError("Packed 10-bit decode returned too few samples")
39
+ return output[:samples].reshape(shape)
40
+ output = np.empty(shape, dtype=np.uint8 if bit_count in (8, 24) else "<u2")
41
+ payload = np.frombuffer(raw, dtype=np.uint8)
42
+ lib = library()
43
+ check(
44
+ lib.cine_decode(
45
+ payload.ctypes.data,
46
+ payload.nbytes,
47
+ width,
48
+ height_signed,
49
+ bit_count,
50
+ compression,
51
+ 0,
52
+ output.ctypes.data,
53
+ output.nbytes,
54
+ ),
55
+ lib,
56
+ )
57
+ return output
cine_reader/headers.py ADDED
@@ -0,0 +1,498 @@
1
+ """Header/setup dataclasses and binary parsing helpers for Phantom CINE files."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import struct
6
+ from dataclasses import dataclass, field
7
+ from typing import Any, BinaryIO
8
+
9
+ import numpy as np
10
+
11
+
12
+ def _decode_text(raw: bytes) -> str:
13
+ """Decode NUL-terminated text from setup/header payload bytes."""
14
+ return raw.split(b"\x00", 1)[0].decode("utf-8", errors="ignore").strip()
15
+
16
+
17
+ def _f32(data: bytes, start: int) -> float:
18
+ return struct.unpack("<f", data[start : start + 4].ljust(4, b"\0"))[0]
19
+
20
+
21
+ def _f64(data: bytes, start: int) -> float:
22
+ return struct.unpack("<d", data[start : start + 8].ljust(8, b"\0"))[0]
23
+
24
+
25
+ @dataclass
26
+ class CineHeader:
27
+ """CINE file header (44 bytes at file start)."""
28
+
29
+ FileHeaderData: bytes # Raw 44-byte header block.
30
+ Type: bytes # File signature (e.g., b"CI").
31
+ Headersize: int # Header size in bytes.
32
+ Compression: int # Compression identifier.
33
+ Version: int # Offset table version (0=32-bit, 1=64-bit).
34
+ FirstMovieImage: int # First movie image index.
35
+ TotalImageCount: int # Total images in movie.
36
+ FirstImageNo: int # Global frame number of first stored image.
37
+ ImageCount: int # Number of stored images in this cine.
38
+ OffImageHeader: int # Byte offset to BITMAPINFOHEADER.
39
+ OffSetup: int # Byte offset to setup block.
40
+ OffImageOffsets: int # Byte offset to image-offset table.
41
+ TriggerTime: int # 64-bit trigger timestamp token from header.
42
+
43
+ @property
44
+ def first_frame_number(self) -> int:
45
+ """Alias for `FirstImageNo`."""
46
+ return int(self.FirstImageNo)
47
+
48
+ @property
49
+ def total_frames(self) -> int:
50
+ """Alias for `ImageCount`."""
51
+ return int(self.ImageCount)
52
+
53
+ @property
54
+ def last_frame_number(self) -> int:
55
+ """Derived last frame number (`FirstImageNo + ImageCount - 1`)."""
56
+ return int(self.FirstImageNo) + int(self.ImageCount) - 1
57
+
58
+
59
+ @dataclass
60
+ class BitmapHeader:
61
+ """Bitmap (DIB) image header block."""
62
+
63
+ ImageHeaderData: bytes # Raw 40-byte bitmap header payload.
64
+ biSize: int # DIB header size.
65
+ biWidth: int # Image width in pixels.
66
+ biHeight: int # Signed image height (negative means top-down).
67
+ biPlanes: int # Number of color planes.
68
+ biBitCount: int # Container bit depth (8/16/24/48 expected).
69
+ biCompression: int # Compression mode code.
70
+ biSizeImage: int # Declared image byte count.
71
+ biXPelsPerMeter: int # Horizontal pixels-per-meter.
72
+ biYPelsPerMeter: int # Vertical pixels-per-meter.
73
+ biClrUsed: int # Color table entries in use.
74
+ biClrImportant: int # Number of important colors.
75
+
76
+ @property
77
+ def width(self) -> int:
78
+ """Alias for `biWidth`."""
79
+ return int(self.biWidth)
80
+
81
+ @property
82
+ def height(self) -> int:
83
+ """Absolute image height in pixels."""
84
+ return abs(int(self.biHeight))
85
+
86
+ @property
87
+ def bit_count(self) -> int:
88
+ """Alias for `biBitCount`."""
89
+ return int(self.biBitCount)
90
+
91
+
92
+ @dataclass
93
+ class ImageOffsets:
94
+ """Frame offset table (plus file-size sentinel)."""
95
+
96
+ pImageData: bytes # Raw bytes of offsets table.
97
+ pImage: np.ndarray # `uint64` offsets array with N+1 entries.
98
+
99
+ def __getattribute__(self, name):
100
+ if name in {"pImage", "pImageData"}:
101
+ state = object.__getattribute__(self, "__dict__")
102
+ loader = state.get("_lazy_loader")
103
+ if loader is not None:
104
+ raw, offsets = loader()
105
+ state.update(pImageData=raw, pImage=offsets, _lazy_loader=None)
106
+ return object.__getattribute__(self, name)
107
+
108
+ @property
109
+ def image_offsets(self) -> np.ndarray:
110
+ """Alias for `pImage`."""
111
+ return self.pImage
112
+
113
+
114
+ @dataclass
115
+ class Setup:
116
+ """Camera setup block.
117
+
118
+ This dataclass keeps frequently used setup values as explicit fields and
119
+ also exposes parsed setup keys as dynamic attributes for compatibility.
120
+ """
121
+
122
+ SetupData: bytes # Raw setup block bytes (`OffSetup .. OffImageOffsets`).
123
+ Length: int = 0 # Setup block length field.
124
+ FrameRate: int = 0 # Integer frame rate from setup block.
125
+ dFrameRate: float = 0.0 # Floating-point frame rate when available.
126
+ Shutter: int = 0 # Legacy shutter/exposure token.
127
+ ShutterNs: int = 0 # Exposure time in nanoseconds.
128
+ RecordingTimeZone: int = 0 # Seconds west of UTC (opposite the UTC offset sign).
129
+ RealBPP: int = 0 # Sensor bit depth (e.g., 10/12/14).
130
+ bEnableColor: bool = False # Color enable flag.
131
+ Description: str = "" # User description text.
132
+ LensDescription: str = "" # Lens description text.
133
+ CineName: str = "" # Cine clip name.
134
+ CreatedBy: str = "" # Creator/user text.
135
+ _extra: dict[str, Any] = field(default_factory=dict, repr=False)
136
+
137
+ def __getattribute__(self, name):
138
+ if name == "SetupData":
139
+ state = object.__getattribute__(self, "__dict__")
140
+ loader = state.get("_setup_data_loader")
141
+ if loader is not None:
142
+ state["SetupData"] = loader()
143
+ state["_setup_data_loader"] = None
144
+ return object.__getattribute__(self, name)
145
+
146
+ def __post_init__(self) -> None:
147
+ for key, value in self._extra.items():
148
+ setattr(self, key, value)
149
+
150
+ @property
151
+ def frame_rate_hz(self) -> float:
152
+ """Best available frame rate in Hz (`dFrameRate` preferred)."""
153
+ if float(self.dFrameRate) > 0.0:
154
+ return float(self.dFrameRate)
155
+ return float(self.FrameRate)
156
+
157
+ @property
158
+ def exposure_time_ns(self) -> int:
159
+ """Best available exposure time in nanoseconds."""
160
+ if int(self.ShutterNs) > 0:
161
+ return int(self.ShutterNs)
162
+ return int(self.Shutter)
163
+
164
+ @property
165
+ def exposure_time_seconds(self) -> float:
166
+ """Best available exposure time in seconds."""
167
+ ns = self.exposure_time_ns
168
+ return float(ns) * 1e-9 if ns > 0 else 0.0
169
+
170
+
171
+ def read_cine_header(file_obj: BinaryIO) -> CineHeader:
172
+ """Read and parse the fixed-size CINE file header."""
173
+ file_obj.seek(0, 0)
174
+ raw = file_obj.read(44)
175
+ return CineHeader(
176
+ FileHeaderData=raw,
177
+ Type=raw[0:2],
178
+ Headersize=int.from_bytes(raw[2:4], "little", signed=False),
179
+ Compression=int.from_bytes(raw[4:6], "little", signed=False),
180
+ Version=int.from_bytes(raw[6:8], "little", signed=False),
181
+ FirstMovieImage=int.from_bytes(raw[8:12], "little", signed=True),
182
+ TotalImageCount=int.from_bytes(raw[12:16], "little", signed=False),
183
+ FirstImageNo=int.from_bytes(raw[16:20], "little", signed=True),
184
+ ImageCount=int.from_bytes(raw[20:24], "little", signed=False),
185
+ OffImageHeader=int.from_bytes(raw[24:28], "little", signed=False),
186
+ OffSetup=int.from_bytes(raw[28:32], "little", signed=False),
187
+ OffImageOffsets=int.from_bytes(raw[32:36], "little", signed=False),
188
+ TriggerTime=int.from_bytes(raw[36:44], "little", signed=False),
189
+ )
190
+
191
+
192
+ def read_bitmap_header(file_obj: BinaryIO, *, off_image_header: int) -> BitmapHeader:
193
+ """Read and parse the 40-byte BITMAPINFOHEADER block."""
194
+ file_obj.seek(off_image_header, 0)
195
+ raw = file_obj.read(40)
196
+ return BitmapHeader(
197
+ ImageHeaderData=raw,
198
+ biSize=int.from_bytes(raw[0:4], "little", signed=False),
199
+ biWidth=int.from_bytes(raw[4:8], "little", signed=True),
200
+ biHeight=int.from_bytes(raw[8:12], "little", signed=True),
201
+ biPlanes=int.from_bytes(raw[12:14], "little", signed=False),
202
+ biBitCount=int.from_bytes(raw[14:16], "little", signed=False),
203
+ biCompression=int.from_bytes(raw[16:20], "little", signed=False),
204
+ biSizeImage=int.from_bytes(raw[20:24], "little", signed=False),
205
+ biXPelsPerMeter=int.from_bytes(raw[24:28], "little", signed=True),
206
+ biYPelsPerMeter=int.from_bytes(raw[28:32], "little", signed=True),
207
+ biClrUsed=int.from_bytes(raw[32:36], "little", signed=False),
208
+ biClrImportant=int.from_bytes(raw[36:40], "little", signed=False),
209
+ )
210
+
211
+
212
+ def read_image_offsets(
213
+ file_obj: BinaryIO,
214
+ *,
215
+ off_image_offsets: int,
216
+ image_count: int,
217
+ version: int,
218
+ ) -> ImageOffsets:
219
+ """Read the frame offset table and append file-size sentinel."""
220
+ file_obj.seek(off_image_offsets, 0)
221
+ if version == 0:
222
+ raw = file_obj.read(image_count * 4)
223
+ offsets = np.frombuffer(raw, dtype="<u4").astype(np.uint64, copy=False)
224
+ elif version == 1:
225
+ raw = file_obj.read(image_count * 8)
226
+ offsets = np.frombuffer(raw, dtype="<u8").astype(np.uint64, copy=False)
227
+ else:
228
+ raise ValueError(f"Invalid file version: {version}")
229
+
230
+ file_obj.seek(0, 2)
231
+ file_size = np.uint64(file_obj.tell())
232
+ offsets = np.concatenate((offsets, np.array([file_size], dtype=np.uint64)))
233
+ return ImageOffsets(pImageData=raw, pImage=offsets)
234
+
235
+
236
+ def read_setup(
237
+ file_obj: BinaryIO,
238
+ *,
239
+ off_setup: int,
240
+ off_image_offsets: int,
241
+ ) -> Setup:
242
+ """Read and parse the setup block fields used by the reader."""
243
+ file_obj.seek(off_setup, 0)
244
+ setup_data = file_obj.read(off_image_offsets - off_setup)
245
+ values: dict[str, Any] = {}
246
+
247
+ values["FrameRate16"] = int.from_bytes(setup_data[0:2], "little", signed=False)
248
+ values["Shutter16"] = int.from_bytes(setup_data[2:4], "little", signed=False)
249
+ values["PostTrigger16"] = int.from_bytes(setup_data[4:6], "little", signed=False)
250
+ values["FrameDelay16"] = int.from_bytes(setup_data[6:8], "little", signed=False)
251
+ values["AspectRatio"] = int.from_bytes(setup_data[8:10], "little", signed=False)
252
+ values["Res7"] = int.from_bytes(setup_data[10:12], "little", signed=False)
253
+ values["Res8"] = int.from_bytes(setup_data[12:14], "little", signed=False)
254
+ values["Res9"] = int.from_bytes(setup_data[14:15], "little", signed=False)
255
+ values["Res10"] = int.from_bytes(setup_data[15:16], "little", signed=False)
256
+ values["Res11"] = int.from_bytes(setup_data[16:17], "little", signed=False)
257
+ values["TrigFrame"] = int.from_bytes(setup_data[17:18], "little", signed=False)
258
+ values["Res12"] = int.from_bytes(setup_data[18:19], "little", signed=False)
259
+ values["DescriptionOld"] = setup_data[19:140]
260
+ values["Mark"] = setup_data[140:142]
261
+ values["Length"] = int.from_bytes(setup_data[142:144], "little", signed=False)
262
+ values["Res13"] = int.from_bytes(setup_data[144:146], "little", signed=False)
263
+ values["SigOption"] = int.from_bytes(setup_data[146:148], "little", signed=False)
264
+ values["BinChannels"] = int.from_bytes(setup_data[148:150], "little", signed=True)
265
+ values["SamplesPerImage"] = int.from_bytes(setup_data[150:151], "little", signed=False)
266
+ values["BinName"] = [setup_data[151 + 11 * i : 162 + 11 * i] for i in range(8)]
267
+ values["AnaOption"] = int.from_bytes(setup_data[239:241], "little", signed=False)
268
+ values["AnaChannels"] = int.from_bytes(setup_data[241:243], "little", signed=True)
269
+ values["Res6"] = int.from_bytes(setup_data[243:244], "little", signed=False)
270
+ values["AnaBoard"] = int.from_bytes(setup_data[244:245], "little", signed=False)
271
+ values["ChOption"] = [
272
+ int.from_bytes(setup_data[245 + 2 * i : 247 + 2 * i], "little", signed=False)
273
+ for i in range(8)
274
+ ]
275
+ values["AnaGain"] = [_f32(setup_data, 261 + 4 * i) for i in range(8)]
276
+ values["AnaUnit"] = [setup_data[293 + 6 * i : 299 + 6 * i] for i in range(8)]
277
+ values["AnaName"] = [setup_data[341 + 11 * i : 352 + 11 * i] for i in range(8)]
278
+ values["lFirstImage"] = int.from_bytes(setup_data[429:433], "little", signed=True)
279
+ values["dwImageCount"] = int.from_bytes(setup_data[433:437], "little", signed=False)
280
+ values["nQFactor"] = int.from_bytes(setup_data[437:439], "little", signed=True)
281
+ values["wCineFileType"] = int.from_bytes(setup_data[439:441], "little", signed=False)
282
+ values["szCinePath"] = [setup_data[441 + 65 * i : 506 + 65 * i] for i in range(4)]
283
+ values["Res14"] = int.from_bytes(setup_data[701:703], "little", signed=False)
284
+ values["Res15"] = int.from_bytes(setup_data[703:704], "little", signed=False)
285
+ values["Res16"] = int.from_bytes(setup_data[704:705], "little", signed=False)
286
+ values["Res17"] = int.from_bytes(setup_data[705:707], "little", signed=False)
287
+ values["Res18"] = int.from_bytes(setup_data[707:715], "little", signed=False)
288
+ values["Res19"] = int.from_bytes(setup_data[715:723], "little", signed=False)
289
+ values["Res20"] = int.from_bytes(setup_data[723:725], "little", signed=False)
290
+ values["Res1"] = int.from_bytes(setup_data[725:729], "little", signed=False)
291
+ values["Res2"] = int.from_bytes(setup_data[729:733], "little", signed=False)
292
+ values["Res3"] = int.from_bytes(setup_data[733:737], "little", signed=False)
293
+ values["ImWidth"] = int.from_bytes(setup_data[737:739], "little", signed=False)
294
+ values["ImHeight"] = int.from_bytes(setup_data[739:741], "little", signed=False)
295
+ values["EDRShutter16"] = int.from_bytes(setup_data[741:743], "little", signed=False)
296
+ values["Serial"] = int.from_bytes(setup_data[743:747], "little", signed=False)
297
+ values["Saturation"] = int.from_bytes(setup_data[747:751], "little", signed=True)
298
+ values["Res5"] = int.from_bytes(setup_data[751:752], "little", signed=False)
299
+ values["AutoExposure"] = int.from_bytes(setup_data[752:756], "little", signed=False)
300
+ values["bFlipH"] = bool(int.from_bytes(setup_data[756:760], "little", signed=False))
301
+ values["bFlipV"] = bool(int.from_bytes(setup_data[760:764], "little", signed=False))
302
+ values["Grid"] = int.from_bytes(setup_data[764:768], "little", signed=False)
303
+ values["FrameRate"] = int.from_bytes(setup_data[768:772], "little", signed=False)
304
+ values["Shutter"] = int.from_bytes(setup_data[772:776], "little", signed=False)
305
+ values["EDRSshutter"] = int.from_bytes(setup_data[776:780], "little", signed=False)
306
+ values["PostTrigger"] = int.from_bytes(setup_data[780:784], "little", signed=False)
307
+ values["FrameDelay"] = int.from_bytes(setup_data[784:788], "little", signed=False)
308
+ values["bEnableColor"] = bool(int.from_bytes(setup_data[788:792], "little", signed=False))
309
+ values["CameraVersion"] = int.from_bytes(setup_data[792:796], "little", signed=False)
310
+ values["FirmwareVersion"] = int.from_bytes(setup_data[796:800], "little", signed=False)
311
+ values["SoftwareVersion"] = int.from_bytes(setup_data[800:804], "little", signed=False)
312
+ values["RecordingTimeZone"] = int.from_bytes(setup_data[804:808], "little", signed=True)
313
+ values["CFA"] = int.from_bytes(setup_data[808:812], "little", signed=False)
314
+ values["Bright"] = int.from_bytes(setup_data[812:816], "little", signed=True)
315
+ values["Contrast"] = int.from_bytes(setup_data[816:820], "little", signed=True)
316
+ values["Gamma"] = int.from_bytes(setup_data[820:824], "little", signed=True)
317
+ values["Res21"] = int.from_bytes(setup_data[824:828], "little", signed=False)
318
+ values["AutoExpLevel"] = int.from_bytes(setup_data[828:832], "little", signed=False)
319
+ values["AutoExpSpeed"] = int.from_bytes(setup_data[832:836], "little", signed=False)
320
+ values["AutoExpRect"] = [
321
+ [
322
+ int.from_bytes(
323
+ setup_data[836 + 4 * a + 8 * b : 840 + 4 * a + 8 * b], "little", signed=False
324
+ )
325
+ for a in range(2)
326
+ ]
327
+ for b in range(2)
328
+ ]
329
+ values["WBGain"] = [[_f32(setup_data, 852 + 4 * b + 8 * a) for b in range(2)] for a in range(4)]
330
+ values["Rotate"] = int.from_bytes(setup_data[884:888], "little", signed=True)
331
+ values["WBView"] = [_f32(setup_data, 888 + 4 * b) for b in range(2)]
332
+ values["RealBPP"] = int.from_bytes(setup_data[896:900], "little", signed=False)
333
+ values["Conv8Min"] = int.from_bytes(setup_data[900:904], "little", signed=False)
334
+ values["Conv8Max"] = int.from_bytes(setup_data[904:908], "little", signed=False)
335
+ values["FilterCode"] = int.from_bytes(setup_data[908:912], "little", signed=True)
336
+ values["FilterParam"] = int.from_bytes(setup_data[912:916], "little", signed=True)
337
+ values["UF"] = [
338
+ int.from_bytes(setup_data[916:920], "little", signed=True),
339
+ int.from_bytes(setup_data[920:924], "little", signed=True),
340
+ int.from_bytes(setup_data[924:928], "little", signed=True),
341
+ [
342
+ int.from_bytes(setup_data[928 + 4 * a : 932 + 4 * a], "little", signed=True)
343
+ for a in range(25)
344
+ ],
345
+ ]
346
+ values["BlackCalSVer"] = int.from_bytes(setup_data[1028:1032], "little", signed=False)
347
+ values["WhiteCalSVer"] = int.from_bytes(setup_data[1032:1036], "little", signed=False)
348
+ values["GrayCalSVer"] = int.from_bytes(setup_data[1036:1040], "little", signed=False)
349
+ values["bStampTime"] = bool(int.from_bytes(setup_data[1040:1044], "little", signed=False))
350
+ values["SoundDest"] = int.from_bytes(setup_data[1044:1048], "little", signed=False)
351
+ values["FRPSteps"] = int.from_bytes(setup_data[1048:1052], "little", signed=False)
352
+ values["FRPImgNr"] = [
353
+ int.from_bytes(setup_data[1052 + 4 * a : 1056 + 4 * a], "little", signed=True)
354
+ for a in range(16)
355
+ ]
356
+ values["FRPRate"] = [
357
+ int.from_bytes(setup_data[1116 + 4 * a : 1120 + 4 * a], "little", signed=False)
358
+ for a in range(16)
359
+ ]
360
+ values["FRPExp"] = [
361
+ int.from_bytes(setup_data[1180 + 4 * a : 1184 + 4 * a], "little", signed=False)
362
+ for a in range(16)
363
+ ]
364
+ values["MCCnt"] = int.from_bytes(setup_data[1244:1248], "little", signed=True)
365
+ values["MCPercent"] = [_f32(setup_data, 1248 + 4 * a) for a in range(64)]
366
+ values["CICalib"] = int.from_bytes(setup_data[1504:1508], "little", signed=False)
367
+ values["CalibWidth"] = int.from_bytes(setup_data[1508:1512], "little", signed=False)
368
+ values["CalibHeight"] = int.from_bytes(setup_data[1512:1516], "little", signed=False)
369
+ values["CalibRate"] = int.from_bytes(setup_data[1516:1520], "little", signed=False)
370
+ values["CalibExp"] = int.from_bytes(setup_data[1520:1524], "little", signed=False)
371
+ values["CalibEDR"] = int.from_bytes(setup_data[1524:1528], "little", signed=False)
372
+ values["CalibTemp"] = int.from_bytes(setup_data[1528:1532], "little", signed=False)
373
+ values["HeadSerial"] = [
374
+ int.from_bytes(setup_data[1532 + 4 * a : 1536 + 4 * a], "little", signed=False)
375
+ for a in range(4)
376
+ ]
377
+ values["RangeCode"] = int.from_bytes(setup_data[1548:1552], "little", signed=False)
378
+ values["RangeSize"] = int.from_bytes(setup_data[1552:1556], "little", signed=False)
379
+ values["Decimation"] = int.from_bytes(setup_data[1556:1560], "little", signed=False)
380
+ values["MasterSerial"] = int.from_bytes(setup_data[1560:1564], "little", signed=False)
381
+ values["Sensor"] = int.from_bytes(setup_data[1564:1568], "little", signed=False)
382
+ values["ShutterNs"] = int.from_bytes(setup_data[1568:1572], "little", signed=False)
383
+ values["EDRShutterNs"] = int.from_bytes(setup_data[1572:1576], "little", signed=False)
384
+ values["FrameDelayNs"] = int.from_bytes(setup_data[1576:1580], "little", signed=False)
385
+ values["ImPosXAcq"] = int.from_bytes(setup_data[1580:1584], "little", signed=False)
386
+ values["ImPosYAcq"] = int.from_bytes(setup_data[1584:1588], "little", signed=False)
387
+ values["ImWidthAcq"] = int.from_bytes(setup_data[1588:1592], "little", signed=False)
388
+ values["ImHeightAcq"] = int.from_bytes(setup_data[1592:1596], "little", signed=False)
389
+ values["Description"] = _decode_text(setup_data[1596:5692])
390
+ values["RisingEdge"] = bool(int.from_bytes(setup_data[5692:5696], "little", signed=False))
391
+ values["FilterTime"] = int.from_bytes(setup_data[5696:5700], "little", signed=False)
392
+ values["LongReady"] = bool(int.from_bytes(setup_data[5700:5704], "little", signed=False))
393
+ values["ShutterOff"] = bool(int.from_bytes(setup_data[5704:5708], "little", signed=False))
394
+ values["Res4"] = [
395
+ int.from_bytes(setup_data[5708 + a : 5709 + a], "little", signed=False) for a in range(16)
396
+ ]
397
+ values["bMetaWB"] = bool(int.from_bytes(setup_data[5724:5728], "little", signed=False))
398
+ values["Hue"] = int.from_bytes(setup_data[5728:5732], "little", signed=True)
399
+ values["BlackLevel"] = int.from_bytes(setup_data[5732:5736], "little", signed=True)
400
+ values["WhiteLevel"] = int.from_bytes(setup_data[5736:5740], "little", signed=True)
401
+ values["LensDescription"] = _decode_text(setup_data[5740:5996])
402
+ values["LensAperture"] = _f32(setup_data, 5996)
403
+ values["LensFocusDistance"] = _f32(setup_data, 6000)
404
+ values["LensFocalLength"] = _f32(setup_data, 6004)
405
+ values["fOffset"] = _f32(setup_data, 6008)
406
+ values["fGain"] = _f32(setup_data, 6012)
407
+ values["fSaturation"] = _f32(setup_data, 6016)
408
+ values["fHue"] = _f32(setup_data, 6020)
409
+ values["fGamma"] = _f32(setup_data, 6024)
410
+ values["fGammaR"] = _f32(setup_data, 6028)
411
+ values["fGammaB"] = _f32(setup_data, 6032)
412
+ values["fFlare"] = _f32(setup_data, 6036)
413
+ values["fPedestalR"] = _f32(setup_data, 6040)
414
+ values["fPedestalG"] = _f32(setup_data, 6044)
415
+ values["fPedestalB"] = _f32(setup_data, 6048)
416
+ values["fChroma"] = _f32(setup_data, 6052)
417
+ values["ToneLabel"] = _decode_text(setup_data[6056:6312])
418
+ values["TonePoints"] = int.from_bytes(setup_data[6312:6316], "little", signed=True)
419
+ values["fTone"] = [
420
+ [_f32(setup_data, 6316 + 4 * b + 8 * a) for b in range(2)] for a in range(32)
421
+ ]
422
+ values["UserMatrixLabel"] = _decode_text(setup_data[6572:6828])
423
+ values["EnableMatrices"] = bool(int.from_bytes(setup_data[6828:6832], "little", signed=False))
424
+ values["cmUser"] = [_f32(setup_data, 6832 + 4 * b) for b in range(9)]
425
+ values["EnableCrop"] = bool(int.from_bytes(setup_data[6868:6872], "little", signed=False))
426
+ values["CropRect"] = [
427
+ [
428
+ int.from_bytes(
429
+ setup_data[6872 + 4 * a + 8 * b : 6876 + 4 * a + 8 * b], "little", signed=False
430
+ )
431
+ for a in range(2)
432
+ ]
433
+ for b in range(2)
434
+ ]
435
+ values["EnableResample"] = bool(int.from_bytes(setup_data[6888:6892], "little", signed=False))
436
+ values["ResampleWidth"] = int.from_bytes(setup_data[6892:6896], "little", signed=False)
437
+ values["ResampleHeight"] = int.from_bytes(setup_data[6896:6900], "little", signed=False)
438
+ values["fGain16"] = _f32(setup_data, 6900)
439
+ values["FRPShape"] = [
440
+ int.from_bytes(setup_data[6904 + 4 * a : 6908 + 4 * a], "little", signed=False)
441
+ for a in range(16)
442
+ ]
443
+ values["TrigTC"] = int.from_bytes(setup_data[6968:6976], "little", signed=False)
444
+ values["fPbRate"] = _f32(setup_data, 6976)
445
+ values["fTcRate"] = _f32(setup_data, 6980)
446
+ values["CineName"] = _decode_text(setup_data[6984:7240])
447
+ values["fGainR"] = _f32(setup_data, 7240)
448
+ values["fGainG"] = _f32(setup_data, 7244)
449
+ values["fGainB"] = _f32(setup_data, 7248)
450
+ values["cmCalib"] = [_f32(setup_data, 7252 + 4 * a) for a in range(9)]
451
+ values["fWBTemp"] = _f32(setup_data, 7288)
452
+ values["fWBCc"] = _f32(setup_data, 7292)
453
+ values["CalibrationInfo"] = _decode_text(setup_data[7296:8320])
454
+ values["OpticalFilter"] = _decode_text(setup_data[8320:9344])
455
+ values["GpsInfo"] = _decode_text(setup_data[9344:9600])
456
+ values["Uuid"] = _decode_text(setup_data[9600:9856])
457
+ values["CreatedBy"] = _decode_text(setup_data[9856:10112])
458
+ values["RecBPP"] = int.from_bytes(setup_data[10112:10116], "little", signed=False)
459
+ values["LowestFormatBPP"] = int.from_bytes(setup_data[10116:10118], "little", signed=False)
460
+ values["LowestFormatQ"] = int.from_bytes(setup_data[10118:10120], "little", signed=False)
461
+ values["fToe"] = _f32(setup_data, 10120)
462
+ values["LogMode"] = int.from_bytes(setup_data[10124:10128], "little", signed=False)
463
+ values["CameraModel"] = setup_data[10128:10384]
464
+ values["WBType"] = int.from_bytes(setup_data[10384:10388], "little", signed=False)
465
+ values["fDecimation"] = _f32(setup_data, 10388)
466
+ values["MagSerial"] = int.from_bytes(setup_data[10392:10396], "little", signed=False)
467
+ values["CSSerial"] = int.from_bytes(setup_data[10396:10400], "little", signed=False)
468
+ values["dFrameRate"] = _f64(setup_data, 10400)
469
+ values["SensorMode"] = int.from_bytes(setup_data[10408:10412], "little", signed=False)
470
+ values["UndecFirst"] = int.from_bytes(setup_data[10412:10416], "little", signed=False)
471
+ values["SupportsBinning"] = bool(
472
+ int.from_bytes(setup_data[10416:10420], "little", signed=False)
473
+ )
474
+ values["UvSensor"] = bool(int.from_bytes(setup_data[10420:10424], "little", signed=False))
475
+ values["AnaDaqDescription"] = setup_data[10424:10552]
476
+ values["BinDaqDescription"] = setup_data[10552:10680]
477
+ values["DaqOptions"] = bool(int.from_bytes(setup_data[10680:10684], "little", signed=False))
478
+
479
+ # Legacy typo aliases kept only as secondary names.
480
+ values["LensAperature"] = values["LensAperture"]
481
+ values["EnableMatricies"] = values["EnableMatrices"]
482
+
483
+ return Setup(
484
+ SetupData=setup_data,
485
+ Length=int(values.get("Length", 0)),
486
+ FrameRate=int(values.get("FrameRate", 0)),
487
+ dFrameRate=float(values.get("dFrameRate", 0.0)),
488
+ Shutter=int(values.get("Shutter", 0)),
489
+ ShutterNs=int(values.get("ShutterNs", 0)),
490
+ RecordingTimeZone=int(values.get("RecordingTimeZone", 0)),
491
+ RealBPP=int(values.get("RealBPP", 0)),
492
+ bEnableColor=bool(values.get("bEnableColor", False)),
493
+ Description=str(values.get("Description", "")),
494
+ LensDescription=str(values.get("LensDescription", "")),
495
+ CineName=str(values.get("CineName", "")),
496
+ CreatedBy=str(values.get("CreatedBy", "")),
497
+ _extra=values,
498
+ )
@@ -0,0 +1,112 @@
1
+ """Thin NumPy adapters for Rust image processing."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import numpy as np
6
+
7
+ from ._native import check, library
8
+
9
+ _BAYER_PHASE_ROLES = {
10
+ "RGGB": ((0, 0, "R"), (0, 1, "G_R"), (1, 0, "G_B"), (1, 1, "B")),
11
+ "BGGR": ((0, 0, "B"), (0, 1, "G_B"), (1, 0, "G_R"), (1, 1, "R")),
12
+ "GRBG": ((0, 0, "G_R"), (0, 1, "R"), (1, 0, "B"), (1, 1, "G_B")),
13
+ "GBRG": ((0, 0, "G_B"), (0, 1, "B"), (1, 0, "R"), (1, 1, "G_R")),
14
+ }
15
+
16
+
17
+ def _bayer_phase_roles(pattern: str) -> tuple[tuple[int, int, str], ...]:
18
+ try:
19
+ return _BAYER_PHASE_ROLES[pattern.upper()]
20
+ except KeyError as exc:
21
+ raise ValueError(f"Unsupported Bayer pattern: {pattern}") from exc
22
+
23
+
24
+ def _process(frame, op: int, param: int = 0, value: float = 0):
25
+ original = np.asarray(frame)
26
+ types = {
27
+ np.dtype("uint8"): 1,
28
+ np.dtype("uint16"): 2,
29
+ np.dtype("float32"): 4,
30
+ np.dtype("float64"): 8,
31
+ }
32
+ dtype = original.dtype.newbyteorder("=")
33
+ if dtype not in types:
34
+ if dtype.kind not in "biuf":
35
+ raise TypeError("Image data must be numeric")
36
+ dtype = np.dtype("float64")
37
+ source = np.ascontiguousarray(original, dtype=dtype)
38
+ shape = source.shape + (3,) if op == 3 else source.shape
39
+ result = np.empty(shape, dtype=dtype)
40
+ if source.size:
41
+ lib = library()
42
+ check(
43
+ lib.cine_process(
44
+ source.ctypes.data,
45
+ result.ctypes.data,
46
+ source.shape[1],
47
+ source.shape[0],
48
+ source.shape[2] if source.ndim == 3 else 1,
49
+ types[dtype],
50
+ op,
51
+ param,
52
+ value,
53
+ ),
54
+ lib,
55
+ )
56
+ return result.astype(original.dtype, copy=False)
57
+
58
+
59
+ def replace_dead_pixels_mono(
60
+ frame: np.ndarray, dead_value: int = 4095, *, dead_is_threshold: bool = False
61
+ ) -> np.ndarray:
62
+ """Replace dead mono samples with the valid 8-neighbor mean in Rust."""
63
+ if frame.ndim != 2:
64
+ return frame
65
+ return _process(frame, 1, int(dead_is_threshold), float(dead_value))
66
+
67
+
68
+ def replace_dead_pixels_bayer(
69
+ frame: np.ndarray, dead_value: int = 4095, *, dead_is_threshold: bool = False
70
+ ) -> np.ndarray:
71
+ """Repair each Bayer phase using neighbors of the same color phase."""
72
+ if frame.ndim != 2:
73
+ return frame
74
+ return _process(frame, 2, int(dead_is_threshold), float(dead_value))
75
+
76
+
77
+ def replace_dead_pixels_rgb(
78
+ frame: np.ndarray, dead_value: int = 4095, *, dead_is_threshold: bool = False
79
+ ) -> np.ndarray:
80
+ """Repair RGB/BGR samples independently within each channel."""
81
+ if frame.ndim != 3:
82
+ return frame
83
+ if frame.shape[-1] <= 1:
84
+ return frame.reshape(frame.shape[:2])
85
+ return _process(frame, 1, int(dead_is_threshold), float(dead_value))
86
+
87
+
88
+ def replace_dead_pixels(
89
+ frame: np.ndarray,
90
+ *,
91
+ dead_value: int = 4095,
92
+ dead_is_threshold: bool = False,
93
+ bayer_raw: bool = False,
94
+ ) -> np.ndarray:
95
+ """Dispatch repair for mono, Bayer, and multichannel image arrays."""
96
+ function = (
97
+ replace_dead_pixels_rgb
98
+ if frame.ndim == 3
99
+ else (
100
+ replace_dead_pixels_bayer if frame.ndim == 2 and bayer_raw else replace_dead_pixels_mono
101
+ )
102
+ )
103
+ return function(frame, dead_value, dead_is_threshold=dead_is_threshold)
104
+
105
+
106
+ def demosaic_bilinear(frame: np.ndarray, pattern: str = "RGGB") -> np.ndarray:
107
+ """Bilinear demosaic with clamped borders and the existing rounding rules."""
108
+ if frame.ndim != 2:
109
+ raise ValueError("Bayer input must be a two-dimensional array")
110
+ token = pattern.upper()
111
+ _bayer_phase_roles(token)
112
+ return _process(frame, 3, ("RGGB", "BGGR", "GRBG", "GBRG").index(token))