+
+ );
+};
+
+export default CameraStream;
+```
+
+### Multi-Camera Dashboard Component
+
+```jsx
+import React, { useState, useEffect } from 'react';
+import CameraStream from './CameraStream';
+
+const CameraDashboard = ({ apiBaseUrl = 'http://vision:8000' }) => {
+ const [cameras, setCameras] = useState({});
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ fetchCameras();
+
+ // Refresh camera status every 30 seconds
+ const interval = setInterval(fetchCameras, 30000);
+ return () => clearInterval(interval);
+ }, []);
+
+ const fetchCameras = async () => {
+ try {
+ const response = await fetch(`${apiBaseUrl}/cameras`);
+ if (response.ok) {
+ const data = await response.json();
+ setCameras(data);
+ setError(null);
+ } else {
+ setError('Failed to fetch cameras');
+ }
+ } catch (err) {
+ setError(`Network error: ${err.message}`);
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ if (loading) {
+ return Camera: {cameraName}
+ + {/* Video Stream */} +
+ {isStreaming ? (
+ }`})
setError('Stream connection lost')}
+ />
+ ) : (
+
+
+ {/* Controls */}
+
+ No Stream Active
+
+ )}
+
+
+
+
+
+
+ {/* Error Display */}
+ {error && (
+
+ Error: {error}
+
+ )}
+ Loading cameras...
;
+ }
+
+ if (error) {
+ return (
+
+ Error: {error}
+
+
+ );
+ }
+
+ return (
+
+
+ );
+};
+
+export default CameraDashboard;
+```
+
+### Custom Hook for Camera Management
+
+```jsx
+import { useState, useEffect, useCallback } from 'react';
+
+const useCameraStream = (cameraName, apiBaseUrl = 'http://vision:8000') => {
+ const [isStreaming, setIsStreaming] = useState(false);
+ const [loading, setLoading] = useState(false);
+ const [error, setError] = useState(null);
+
+ const startStream = useCallback(async () => {
+ setLoading(true);
+ setError(null);
+
+ try {
+ const response = await fetch(`${apiBaseUrl}/cameras/${cameraName}/start-stream`, {
+ method: 'POST',
+ });
+
+ if (response.ok) {
+ setIsStreaming(true);
+ return { success: true };
+ } else {
+ const errorData = await response.json();
+ const errorMsg = errorData.detail || 'Failed to start stream';
+ setError(errorMsg);
+ return { success: false, error: errorMsg };
+ }
+ } catch (err) {
+ const errorMsg = `Network error: ${err.message}`;
+ setError(errorMsg);
+ return { success: false, error: errorMsg };
+ } finally {
+ setLoading(false);
+ }
+ }, [cameraName, apiBaseUrl]);
+
+ const stopStream = useCallback(async () => {
+ setLoading(true);
+
+ try {
+ const response = await fetch(`${apiBaseUrl}/cameras/${cameraName}/stop-stream`, {
+ method: 'POST',
+ });
+
+ if (response.ok) {
+ setIsStreaming(false);
+ return { success: true };
+ } else {
+ const errorData = await response.json();
+ const errorMsg = errorData.detail || 'Failed to stop stream';
+ setError(errorMsg);
+ return { success: false, error: errorMsg };
+ }
+ } catch (err) {
+ const errorMsg = `Network error: ${err.message}`;
+ setError(errorMsg);
+ return { success: false, error: errorMsg };
+ } finally {
+ setLoading(false);
+ }
+ }, [cameraName, apiBaseUrl]);
+
+ const getStreamUrl = useCallback(() => {
+ return `${apiBaseUrl}/cameras/${cameraName}/stream?t=${Date.now()}`;
+ }, [cameraName, apiBaseUrl]);
+
+ return {
+ isStreaming,
+ loading,
+ error,
+ startStream,
+ stopStream,
+ getStreamUrl,
+ };
+};
+
+export default useCameraStream;
+```
+
+## 🎨 Styling with Tailwind CSS
+
+```jsx
+const CameraStreamTailwind = ({ cameraName }) => {
+ const { isStreaming, loading, error, startStream, stopStream, getStreamUrl } = useCameraStream(cameraName);
+
+ return (
+ USDA Vision Camera Dashboard
+ +
+ {Object.entries(cameras).map(([cameraName, cameraInfo]) => (
+
+
+
+ ))}
+
+
+ Status: {cameraInfo.status}
+ Recording: {cameraInfo.is_recording ? 'Yes' : 'No'}
+ Last Checked: {new Date(cameraInfo.last_checked).toLocaleString()}
+
+
+ );
+};
+```
+
+## 🔧 Configuration Options
+
+### Environment Variables (.env)
+```env
+# Production configuration (using 'vision' hostname)
+REACT_APP_CAMERA_API_URL=http://vision:8000
+REACT_APP_STREAM_REFRESH_INTERVAL=30000
+REACT_APP_STREAM_TIMEOUT=10000
+
+# Development configuration (using localhost)
+# REACT_APP_CAMERA_API_URL=http://localhost:8000
+
+# Custom IP configuration
+# REACT_APP_CAMERA_API_URL=http://192.168.1.100:8000
+```
+
+### API Configuration
+```javascript
+const apiConfig = {
+ baseUrl: process.env.REACT_APP_CAMERA_API_URL || 'http://vision:8000',
+ timeout: parseInt(process.env.REACT_APP_STREAM_TIMEOUT) || 10000,
+ refreshInterval: parseInt(process.env.REACT_APP_STREAM_REFRESH_INTERVAL) || 30000,
+};
+```
+
+### Hostname Setup Guide
+```bash
+# Option 1: Add to /etc/hosts (Linux/Mac)
+echo "127.0.0.1 vision" | sudo tee -a /etc/hosts
+
+# Option 2: Add to hosts file (Windows)
+# Add to C:\Windows\System32\drivers\etc\hosts:
+# 127.0.0.1 vision
+
+# Option 3: Configure DNS
+# Point 'vision' hostname to your server's IP address
+
+# Verify hostname resolution
+ping vision
+```
+
+## 🚨 Important Implementation Notes
+
+### 1. MJPEG Stream Handling
+- Use HTML `Camera: {cameraName}
+ + {/* Stream Container */} +
+ {isStreaming ? (
+ })
setError('Stream connection lost')}
+ />
+ ) : (
+
+
+ {/* Controls */}
+
+ No Stream Active
+
+ )}
+
+
+
+
+
+
+ {/* Error Display */}
+ {error && (
+
+ Error: {error}
+
+ )}
+
+#
+# {isStreaming && (
+# }`})
+# )}
+#
+# );
+# };
+
+### JavaScript Fetch Example:
+# const streamAPI = {
+# async startStream(cameraName) {
+# const response = await fetch(`${baseUrl}/cameras/${cameraName}/start-stream`, {
+# method: 'POST',
+# headers: { 'Content-Type': 'application/json' }
+# });
+# return response.json();
+# },
+#
+# async stopStream(cameraName) {
+# const response = await fetch(`${baseUrl}/cameras/${cameraName}/stop-stream`, {
+# method: 'POST',
+# headers: { 'Content-Type': 'application/json' }
+# });
+# return response.json();
+# },
+#
+# getStreamUrl(cameraName) {
+# return `${baseUrl}/cameras/${cameraName}/stream?t=${Date.now()}`;
+# }
+# };
+
+### Vue.js Integration:
+#
+#
+#
+# ![]()
+#
+#
+#
+#
+
+### =============================================================================
+### TROUBLESHOOTING
+### =============================================================================
+
+### If streams don't start:
+# 1. Check camera status: GET /cameras
+# 2. Verify system health: GET /health
+# 3. Test camera connection: POST /cameras/{name}/test-connection
+# 4. Check if camera is already recording (shouldn't matter, but good to know)
+
+### If stream image doesn't load:
+# 1. Verify stream was started: POST /cameras/{name}/start-stream
+# 2. Check browser console for CORS errors
+# 3. Try accessing stream URL directly in browser
+# 4. Add timestamp to prevent caching: ?t=${Date.now()}
+
+### If concurrent operations fail:
+# 1. This should work - streaming and recording use separate connections
+# 2. Check system logs for resource conflicts
+# 3. Verify sufficient system resources (CPU/Memory)
+# 4. Test with one camera first, then multiple
+
+### Performance Notes:
+# - Streaming uses ~10 FPS by default (configurable)
+# - JPEG quality set to 70% (configurable)
+# - Each stream uses additional CPU/memory
+# - Multiple concurrent streams may impact performance
+
+### =============================================================================
+### CAMERA CONFIGURATION ENDPOINTS (NEW)
+### =============================================================================
+
+### Get camera configuration
+GET {{baseUrl}}/cameras/camera1/config
+
+### Expected Response:
+# {
+# "name": "camera1",
+# "machine_topic": "vibratory_conveyor",
+# "storage_path": "/storage/camera1",
+# "enabled": true,
+# "auto_start_recording_enabled": true,
+# "auto_recording_max_retries": 3,
+# "auto_recording_retry_delay_seconds": 2,
+# "exposure_ms": 1.0,
+# "gain": 3.5,
+# "target_fps": 0,
+# "sharpness": 120,
+# "contrast": 110,
+# "saturation": 100,
+# "gamma": 100,
+# "noise_filter_enabled": true,
+# "denoise_3d_enabled": false,
+# "auto_white_balance": true,
+# "color_temperature_preset": 0,
+# "wb_red_gain": 1.0,
+# "wb_green_gain": 1.0,
+# "wb_blue_gain": 1.0,
+# "anti_flicker_enabled": true,
+# "light_frequency": 1,
+# "bit_depth": 8,
+# "hdr_enabled": false,
+# "hdr_gain_mode": 0
+# }
+
+###
+
+### Update basic camera settings (real-time, no restart required)
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "exposure_ms": 2.0,
+ "gain": 4.0,
+ "target_fps": 10.0
+}
+
+###
+
+### Update image quality settings
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "sharpness": 150,
+ "contrast": 120,
+ "saturation": 110,
+ "gamma": 90
+}
+
+###
+
+### Update advanced settings
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "anti_flicker_enabled": true,
+ "light_frequency": 1,
+ "auto_white_balance": false,
+ "color_temperature_preset": 2
+}
+
+###
+
+### Update white balance RGB gains (manual white balance)
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "auto_white_balance": false,
+ "wb_red_gain": 1.2,
+ "wb_green_gain": 1.0,
+ "wb_blue_gain": 0.8
+}
+
+###
+
+### Enable HDR mode
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "hdr_enabled": true,
+ "hdr_gain_mode": 1
+}
+
+###
+
+### Update noise reduction settings (requires restart)
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "noise_filter_enabled": false,
+ "denoise_3d_enabled": true
+}
+
+###
+
+### Apply configuration (restart camera with new settings)
+POST {{baseUrl}}/cameras/camera1/apply-config
+
+### Expected Response:
+# {
+# "success": true,
+# "message": "Configuration applied to camera camera1"
+# }
+
+###
+
+### Get camera2 configuration
+GET {{baseUrl}}/cameras/camera2/config
+
+###
+
+### Update camera2 for outdoor lighting
+PUT {{baseUrl}}/cameras/camera2/config
+Content-Type: application/json
+
+{
+ "exposure_ms": 0.5,
+ "gain": 2.0,
+ "sharpness": 130,
+ "contrast": 115,
+ "anti_flicker_enabled": true,
+ "light_frequency": 1
+}
+
+### =============================================================================
+### CONFIGURATION TESTING SCENARIOS
+### =============================================================================
+
+### Scenario 1: Low light optimization
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "exposure_ms": 5.0,
+ "gain": 8.0,
+ "noise_filter_enabled": true,
+ "denoise_3d_enabled": true
+}
+
+###
+
+### Scenario 2: High speed capture
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "exposure_ms": 0.2,
+ "gain": 1.0,
+ "target_fps": 30.0,
+ "sharpness": 180
+}
+
+###
+
+### Scenario 3: Color accuracy for food inspection
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "auto_white_balance": false,
+ "color_temperature_preset": 1,
+ "saturation": 120,
+ "contrast": 105,
+ "gamma": 95
+}
+
+###
+
+### Scenario 4: HDR for high contrast scenes
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "hdr_enabled": true,
+ "hdr_gain_mode": 2,
+ "exposure_ms": 1.0,
+ "gain": 3.0
+}
+
+### =============================================================================
+### ERROR TESTING FOR CONFIGURATION
+### =============================================================================
+
+### Test invalid camera name
+GET {{baseUrl}}/cameras/invalid_camera/config
+
+###
+
+### Test invalid exposure range
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "exposure_ms": 2000.0
+}
+
+### Expected: HTTP 422 validation error
+
+###
+
+### Test invalid gain range
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{
+ "gain": 50.0
+}
+
+### Expected: HTTP 422 validation error
+
+###
+
+### Test empty configuration update
+PUT {{baseUrl}}/cameras/camera1/config
+Content-Type: application/json
+
+{}
+
+### Expected: HTTP 400 "No configuration updates provided"
diff --git a/api/camera_preview.html b/api/camera_preview.html
new file mode 100644
index 0000000..99d321e
--- /dev/null
+++ b/api/camera_preview.html
@@ -0,0 +1,336 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/api/camera_sdk/README.md b/api/camera_sdk/README.md
new file mode 100644
index 0000000..c507622
--- /dev/null
+++ b/api/camera_sdk/README.md
@@ -0,0 +1,66 @@
+# Camera SDK Library
+
+This directory contains the core GigE camera SDK library required for the USDA Vision Camera System.
+
+## Contents
+
+### Core SDK Library
+- **`mvsdk.py`** - Python wrapper for the GigE camera SDK
+ - Provides Python bindings for camera control functions
+ - Handles camera initialization, configuration, and image capture
+ - **Critical dependency** - Required for all camera operations
+
+## Important Notes
+
+⚠️ **This is NOT demo code** - This directory contains the core SDK library that the entire system depends on for camera functionality.
+
+### SDK Library Details
+- The `mvsdk.py` file is a Python wrapper around the native camera SDK
+- It provides ctypes bindings to the underlying C/C++ camera library
+- Contains all camera control functions, constants, and data structures
+- Used by all camera modules in `usda_vision_system/camera/`
+
+### Dependencies
+- Requires the native camera SDK library (`libMVSDK.so` on Linux)
+- The native library should be installed system-wide or available in the library path
+
+## Usage
+
+This SDK is automatically imported by the camera modules:
+```python
+# Imported by camera modules
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "camera_sdk"))
+import mvsdk
+```
+
+## Demo Code
+
+For camera usage examples and demo code, see the `../demos/` directory:
+- `cv_grab.py` - Basic camera capture example
+- `cv_grab2.py` - Multi-camera capture example
+- `cv_grab_callback.py` - Callback-based capture example
+- `grab.py` - Simple image capture example
+
+## Troubleshooting
+
+If you encounter camera SDK issues:
+
+1. **Check SDK Installation**:
+ ```bash
+ ls -la camera_sdk/mvsdk.py
+ ```
+
+2. **Test SDK Import**:
+ ```bash
+ python -c "import sys; sys.path.append('./camera_sdk'); import mvsdk; print('SDK imported successfully')"
+ ```
+
+3. **Check Native Library**:
+ ```bash
+ # On Linux
+ ldconfig -p | grep MVSDK
+ ```
+
+For more troubleshooting, see the main [README.md](../README.md#troubleshooting).
diff --git a/api/camera_sdk/mvsdk.py b/api/camera_sdk/mvsdk.py
new file mode 100644
index 0000000..6a3af90
--- /dev/null
+++ b/api/camera_sdk/mvsdk.py
@@ -0,0 +1,2454 @@
+#coding=utf-8
+import platform
+from ctypes import *
+from threading import local
+
+# 回调函数类型
+CALLBACK_FUNC_TYPE = None
+
+# SDK动态库
+_sdk = None
+
+def _Init():
+ global _sdk
+ global CALLBACK_FUNC_TYPE
+
+ is_win = (platform.system() == "Windows")
+ is_x86 = (platform.architecture()[0] == '32bit')
+
+ if is_win:
+ _sdk = windll.MVCAMSDK if is_x86 else windll.MVCAMSDK_X64
+ CALLBACK_FUNC_TYPE = WINFUNCTYPE
+ else:
+ _sdk = cdll.LoadLibrary("libMVSDK.so")
+ CALLBACK_FUNC_TYPE = CFUNCTYPE
+
+_Init()
+
+#-------------------------------------------类型定义--------------------------------------------------
+
+# 状态码定义
+CAMERA_STATUS_SUCCESS = 0 # 操作成功
+CAMERA_STATUS_FAILED = -1 # 操作失败
+CAMERA_STATUS_INTERNAL_ERROR = -2 # 内部错误
+CAMERA_STATUS_UNKNOW = -3 # 未知错误
+CAMERA_STATUS_NOT_SUPPORTED = -4 # 不支持该功能
+CAMERA_STATUS_NOT_INITIALIZED = -5 # 初始化未完成
+CAMERA_STATUS_PARAMETER_INVALID = -6 # 参数无效
+CAMERA_STATUS_PARAMETER_OUT_OF_BOUND = -7 # 参数越界
+CAMERA_STATUS_UNENABLED = -8 # 未使能
+CAMERA_STATUS_USER_CANCEL = -9 # 用户手动取消了，比如roi面板点击取消，返回
+CAMERA_STATUS_PATH_NOT_FOUND = -10 # 注册表中没有找到对应的路径
+CAMERA_STATUS_SIZE_DISMATCH = -11 # 获得图像数据长度和定义的尺寸不匹配
+CAMERA_STATUS_TIME_OUT = -12 # 超时错误
+CAMERA_STATUS_IO_ERROR = -13 # 硬件IO错误
+CAMERA_STATUS_COMM_ERROR = -14 # 通讯错误
+CAMERA_STATUS_BUS_ERROR = -15 # 总线错误
+CAMERA_STATUS_NO_DEVICE_FOUND = -16 # 没有发现设备
+CAMERA_STATUS_NO_LOGIC_DEVICE_FOUND = -17 # 未找到逻辑设备
+CAMERA_STATUS_DEVICE_IS_OPENED = -18 # 设备已经打开
+CAMERA_STATUS_DEVICE_IS_CLOSED = -19 # 设备已经关闭
+CAMERA_STATUS_DEVICE_VEDIO_CLOSED = -20 # 没有打开设备视频，调用录像相关的函数时，如果相机视频没有打开，则回返回该错误。
+CAMERA_STATUS_NO_MEMORY = -21 # 没有足够系统内存
+CAMERA_STATUS_FILE_CREATE_FAILED = -22 # 创建文件失败
+CAMERA_STATUS_FILE_INVALID = -23 # 文件格式无效
+CAMERA_STATUS_WRITE_PROTECTED = -24 # 写保护，不可写
+CAMERA_STATUS_GRAB_FAILED = -25 # 数据采集失败
+CAMERA_STATUS_LOST_DATA = -26 # 数据丢失，不完整
+CAMERA_STATUS_EOF_ERROR = -27 # 未接收到帧结束符
+CAMERA_STATUS_BUSY = -28 # 正忙(上一次操作还在进行中)，此次操作不能进行
+CAMERA_STATUS_WAIT = -29 # 需要等待(进行操作的条件不成立)，可以再次尝试
+CAMERA_STATUS_IN_PROCESS = -30 # 正在进行，已经被操作过
+CAMERA_STATUS_IIC_ERROR = -31 # IIC传输错误
+CAMERA_STATUS_SPI_ERROR = -32 # SPI传输错误
+CAMERA_STATUS_USB_CONTROL_ERROR = -33 # USB控制传输错误
+CAMERA_STATUS_USB_BULK_ERROR = -34 # USB BULK传输错误
+CAMERA_STATUS_SOCKET_INIT_ERROR = -35 # 网络传输套件初始化失败
+CAMERA_STATUS_GIGE_FILTER_INIT_ERROR = -36 # 网络相机内核过滤驱动初始化失败，请检查是否正确安装了驱动，或者重新安装。
+CAMERA_STATUS_NET_SEND_ERROR = -37 # 网络数据发送错误
+CAMERA_STATUS_DEVICE_LOST = -38 # 与网络相机失去连接，心跳检测超时
+CAMERA_STATUS_DATA_RECV_LESS = -39 # 接收到的字节数比请求的少
+CAMERA_STATUS_FUNCTION_LOAD_FAILED = -40 # 从文件中加载程序失败
+CAMERA_STATUS_CRITICAL_FILE_LOST = -41 # 程序运行所必须的文件丢失。
+CAMERA_STATUS_SENSOR_ID_DISMATCH = -42 # 固件和程序不匹配，原因是下载了错误的固件。
+CAMERA_STATUS_OUT_OF_RANGE = -43 # 参数超出有效范围。
+CAMERA_STATUS_REGISTRY_ERROR = -44 # 安装程序注册错误。请重新安装程序，或者运行安装目录Setup/Installer.exe
+CAMERA_STATUS_ACCESS_DENY = -45 # 禁止访问。指定相机已经被其他程序占用时，再申请访问该相机，会返回该状态。(一个相机不能被多个程序同时访问)
+#AIA的标准兼容的错误码
+CAMERA_AIA_PACKET_RESEND = 0x0100 #该帧需要重传
+CAMERA_AIA_NOT_IMPLEMENTED = 0x8001 #设备不支持的命令
+CAMERA_AIA_INVALID_PARAMETER = 0x8002 #命令参数非法
+CAMERA_AIA_INVALID_ADDRESS = 0x8003 #不可访问的地址
+CAMERA_AIA_WRITE_PROTECT = 0x8004 #访问的对象不可写
+CAMERA_AIA_BAD_ALIGNMENT = 0x8005 #访问的地址没有按照要求对齐
+CAMERA_AIA_ACCESS_DENIED = 0x8006 #没有访问权限
+CAMERA_AIA_BUSY = 0x8007 #命令正在处理中
+CAMERA_AIA_DEPRECATED = 0x8008 #0x8008-0x0800B 0x800F 该指令已经废弃
+CAMERA_AIA_PACKET_UNAVAILABLE = 0x800C #包无效
+CAMERA_AIA_DATA_OVERRUN = 0x800D #数据溢出，通常是收到的数据比需要的多
+CAMERA_AIA_INVALID_HEADER = 0x800E #数据包头部中某些区域与协议不匹配
+CAMERA_AIA_PACKET_NOT_YET_AVAILABLE = 0x8010 #图像分包数据还未准备好，多用于触发模式，应用程序访问超时
+CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY = 0x8011 #需要访问的分包已经不存在。多用于重传时数据已经不在缓冲区中
+CAMERA_AIA_PACKET_REMOVED_FROM_MEMORY = 0x8012 #CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY
+CAMERA_AIA_NO_REF_TIME = 0x0813 #没有参考时钟源。多用于时间同步的命令执行时
+CAMERA_AIA_PACKET_TEMPORARILY_UNAVAILABLE = 0x0814 #由于信道带宽问题，当前分包暂时不可用，需稍后进行访问
+CAMERA_AIA_OVERFLOW = 0x0815 #设备端数据溢出，通常是队列已满
+CAMERA_AIA_ACTION_LATE = 0x0816 #命令执行已经超过有效的指定时间
+CAMERA_AIA_ERROR = 0x8FFF #错误
+
+# 图像格式定义
+CAMERA_MEDIA_TYPE_MONO = 0x01000000
+CAMERA_MEDIA_TYPE_RGB = 0x02000000
+CAMERA_MEDIA_TYPE_COLOR = 0x02000000
+CAMERA_MEDIA_TYPE_OCCUPY1BIT = 0x00010000
+CAMERA_MEDIA_TYPE_OCCUPY2BIT = 0x00020000
+CAMERA_MEDIA_TYPE_OCCUPY4BIT = 0x00040000
+CAMERA_MEDIA_TYPE_OCCUPY8BIT = 0x00080000
+CAMERA_MEDIA_TYPE_OCCUPY10BIT = 0x000A0000
+CAMERA_MEDIA_TYPE_OCCUPY12BIT = 0x000C0000
+CAMERA_MEDIA_TYPE_OCCUPY16BIT = 0x00100000
+CAMERA_MEDIA_TYPE_OCCUPY24BIT = 0x00180000
+CAMERA_MEDIA_TYPE_OCCUPY32BIT = 0x00200000
+CAMERA_MEDIA_TYPE_OCCUPY36BIT = 0x00240000
+CAMERA_MEDIA_TYPE_OCCUPY48BIT = 0x00300000
+CAMERA_MEDIA_TYPE_EFFECTIVE_PIXEL_SIZE_MASK = 0x00FF0000
+CAMERA_MEDIA_TYPE_EFFECTIVE_PIXEL_SIZE_SHIFT = 16
+CAMERA_MEDIA_TYPE_ID_MASK = 0x0000FFFF
+CAMERA_MEDIA_TYPE_COUNT = 0x46
+
+#mono
+CAMERA_MEDIA_TYPE_MONO1P = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY1BIT | 0x0037)
+CAMERA_MEDIA_TYPE_MONO2P = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY2BIT | 0x0038)
+CAMERA_MEDIA_TYPE_MONO4P = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY4BIT | 0x0039)
+CAMERA_MEDIA_TYPE_MONO8 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0001)
+CAMERA_MEDIA_TYPE_MONO8S = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0002)
+CAMERA_MEDIA_TYPE_MONO10 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0003)
+CAMERA_MEDIA_TYPE_MONO10_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0004)
+CAMERA_MEDIA_TYPE_MONO12 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0005)
+CAMERA_MEDIA_TYPE_MONO12_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0006)
+CAMERA_MEDIA_TYPE_MONO14 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0025)
+CAMERA_MEDIA_TYPE_MONO16 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0007)
+
+# Bayer
+CAMERA_MEDIA_TYPE_BAYGR8 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0008)
+CAMERA_MEDIA_TYPE_BAYRG8 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x0009)
+CAMERA_MEDIA_TYPE_BAYGB8 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x000A)
+CAMERA_MEDIA_TYPE_BAYBG8 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY8BIT | 0x000B)
+
+CAMERA_MEDIA_TYPE_BAYGR10_MIPI = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0026)
+CAMERA_MEDIA_TYPE_BAYRG10_MIPI = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0027)
+CAMERA_MEDIA_TYPE_BAYGB10_MIPI = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0028)
+CAMERA_MEDIA_TYPE_BAYBG10_MIPI = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY10BIT | 0x0029)
+
+CAMERA_MEDIA_TYPE_BAYGR10 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000C)
+CAMERA_MEDIA_TYPE_BAYRG10 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000D)
+CAMERA_MEDIA_TYPE_BAYGB10 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000E)
+CAMERA_MEDIA_TYPE_BAYBG10 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x000F)
+
+CAMERA_MEDIA_TYPE_BAYGR12 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0010)
+CAMERA_MEDIA_TYPE_BAYRG12 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0011)
+CAMERA_MEDIA_TYPE_BAYGB12 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0012)
+CAMERA_MEDIA_TYPE_BAYBG12 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0013)
+
+CAMERA_MEDIA_TYPE_BAYGR10_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0026)
+CAMERA_MEDIA_TYPE_BAYRG10_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0027)
+CAMERA_MEDIA_TYPE_BAYGB10_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0028)
+CAMERA_MEDIA_TYPE_BAYBG10_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0029)
+
+CAMERA_MEDIA_TYPE_BAYGR12_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002A)
+CAMERA_MEDIA_TYPE_BAYRG12_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002B)
+CAMERA_MEDIA_TYPE_BAYGB12_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002C)
+CAMERA_MEDIA_TYPE_BAYBG12_PACKED = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x002D)
+
+CAMERA_MEDIA_TYPE_BAYGR16 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x002E)
+CAMERA_MEDIA_TYPE_BAYRG16 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x002F)
+CAMERA_MEDIA_TYPE_BAYGB16 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0030)
+CAMERA_MEDIA_TYPE_BAYBG16 = (CAMERA_MEDIA_TYPE_MONO | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0031)
+
+# RGB
+CAMERA_MEDIA_TYPE_RGB8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0014)
+CAMERA_MEDIA_TYPE_BGR8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0015)
+CAMERA_MEDIA_TYPE_RGBA8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x0016)
+CAMERA_MEDIA_TYPE_BGRA8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x0017)
+CAMERA_MEDIA_TYPE_RGB10 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0018)
+CAMERA_MEDIA_TYPE_BGR10 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0019)
+CAMERA_MEDIA_TYPE_RGB12 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x001A)
+CAMERA_MEDIA_TYPE_BGR12 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x001B)
+CAMERA_MEDIA_TYPE_RGB16 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0033)
+CAMERA_MEDIA_TYPE_RGB10V1_PACKED = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x001C)
+CAMERA_MEDIA_TYPE_RGB10P32 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY32BIT | 0x001D)
+CAMERA_MEDIA_TYPE_RGB12V1_PACKED = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY36BIT | 0X0034)
+CAMERA_MEDIA_TYPE_RGB565P = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0035)
+CAMERA_MEDIA_TYPE_BGR565P = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0X0036)
+
+# YUV and YCbCr
+CAMERA_MEDIA_TYPE_YUV411_8_UYYVYY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x001E)
+CAMERA_MEDIA_TYPE_YUV422_8_UYVY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x001F)
+CAMERA_MEDIA_TYPE_YUV422_8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0032)
+CAMERA_MEDIA_TYPE_YUV8_UYV = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0020)
+CAMERA_MEDIA_TYPE_YCBCR8_CBYCR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x003A)
+#CAMERA_MEDIA_TYPE_YCBCR422_8 : YYYYCbCrCbCr
+CAMERA_MEDIA_TYPE_YCBCR422_8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x003B)
+CAMERA_MEDIA_TYPE_YCBCR422_8_CBYCRY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0043)
+CAMERA_MEDIA_TYPE_YCBCR411_8_CBYYCRYY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x003C)
+CAMERA_MEDIA_TYPE_YCBCR601_8_CBYCR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x003D)
+CAMERA_MEDIA_TYPE_YCBCR601_422_8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x003E)
+CAMERA_MEDIA_TYPE_YCBCR601_422_8_CBYCRY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0044)
+CAMERA_MEDIA_TYPE_YCBCR601_411_8_CBYYCRYY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x003F)
+CAMERA_MEDIA_TYPE_YCBCR709_8_CBYCR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0040)
+CAMERA_MEDIA_TYPE_YCBCR709_422_8 = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0041)
+CAMERA_MEDIA_TYPE_YCBCR709_422_8_CBYCRY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY16BIT | 0x0045)
+CAMERA_MEDIA_TYPE_YCBCR709_411_8_CBYYCRYY = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY12BIT | 0x0042)
+
+# RGB Planar
+CAMERA_MEDIA_TYPE_RGB8_PLANAR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY24BIT | 0x0021)
+CAMERA_MEDIA_TYPE_RGB10_PLANAR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0022)
+CAMERA_MEDIA_TYPE_RGB12_PLANAR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0023)
+CAMERA_MEDIA_TYPE_RGB16_PLANAR = (CAMERA_MEDIA_TYPE_COLOR | CAMERA_MEDIA_TYPE_OCCUPY48BIT | 0x0024)
+
+# 保存格式
+FILE_JPG = 1
+FILE_BMP = 2
+FILE_RAW = 4
+FILE_PNG = 8
+FILE_BMP_8BIT = 16
+FILE_PNG_8BIT = 32
+FILE_RAW_16BIT = 64
+
+# 触发信号
+EXT_TRIG_LEADING_EDGE = 0
+EXT_TRIG_TRAILING_EDGE = 1
+EXT_TRIG_HIGH_LEVEL = 2
+EXT_TRIG_LOW_LEVEL = 3
+EXT_TRIG_DOUBLE_EDGE = 4
+
+# IO模式
+IOMODE_TRIG_INPUT = 0
+IOMODE_STROBE_OUTPUT = 1
+IOMODE_GP_INPUT = 2
+IOMODE_GP_OUTPUT = 3
+IOMODE_PWM_OUTPUT = 4
+
+
+# 相机操作异常信息
+class CameraException(Exception):
+ """docstring for CameraException"""
+ def __init__(self, error_code):
+ super(CameraException, self).__init__()
+ self.error_code = error_code
+ self.message = CameraGetErrorString(error_code)
+
+ def __str__(self):
+ return 'error_code:{} message:{}'.format(self.error_code, self.message)
+
+class MvStructure(Structure):
+ def __str__(self):
+ strs = []
+ for field in self._fields_:
+ name = field[0]
+ value = getattr(self, name)
+ if isinstance(value, type(b'')):
+ value = _string_buffer_to_str(value)
+ strs.append("{}:{}".format(name, value))
+ return '\n'.join(strs)
+
+ def __repr__(self):
+ return self.__str__()
+
+ def clone(self):
+ obj = type(self)()
+ memmove(byref(obj), byref(self), sizeof(self))
+ return obj
+
+# 相机的设备信息，只读信息，请勿修改
+class tSdkCameraDevInfo(MvStructure):
+ _fields_ = [("acProductSeries", c_char * 32), #产品系列
+ ("acProductName", c_char * 32), #产品名称
+ ("acFriendlyName", c_char * 32), #产品昵称
+ ("acLinkName", c_char * 32), #内核符号连接名，内部使用
+ ("acDriverVersion", c_char * 32), #驱动版本
+ ("acSensorType", c_char * 32), #sensor类型
+ ("acPortType", c_char * 32), #接口类型
+ ("acSn", c_char * 32), #产品唯一序列号
+ ("uInstance", c_uint)] #该型号相机在该电脑上的实例索引号，用于区分同型号多相机
+
+ def GetProductSeries(self):
+ return _string_buffer_to_str(self.acProductSeries)
+ def GetProductName(self):
+ return _string_buffer_to_str(self.acProductName)
+ def GetFriendlyName(self):
+ return _string_buffer_to_str(self.acFriendlyName)
+ def GetLinkName(self):
+ return _string_buffer_to_str(self.acLinkName)
+ def GetDriverVersion(self):
+ return _string_buffer_to_str(self.acDriverVersion)
+ def GetSensorType(self):
+ return _string_buffer_to_str(self.acSensorType)
+ def GetPortType(self):
+ return _string_buffer_to_str(self.acPortType)
+ def GetSn(self):
+ return _string_buffer_to_str(self.acSn)
+
+# 相机的分辨率设定范围
+class tSdkResolutionRange(MvStructure):
+ _fields_ = [("iHeightMax", c_int), #图像最大高度
+ ("iHeightMin", c_int), #图像最小高度
+ ("iWidthMax", c_int), #图像最大宽度
+ ("iWidthMin", c_int), #图像最小宽度
+ ("uSkipModeMask", c_uint), #SKIP模式掩码，为0，表示不支持SKIP 。bit0为1,表示支持SKIP 2x2 bit1为1，表示支持SKIP 3x3....
+ ("uBinSumModeMask", c_uint), #BIN(求和)模式掩码，为0，表示不支持BIN 。bit0为1,表示支持BIN 2x2 bit1为1，表示支持BIN 3x3....
+ ("uBinAverageModeMask", c_uint),#BIN(求均值)模式掩码，为0，表示不支持BIN 。bit0为1,表示支持BIN 2x2 bit1为1，表示支持BIN 3x3....
+ ("uResampleMask", c_uint)] #硬件重采样的掩码
+
+#相机的分辨率描述
+class tSdkImageResolution(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 索引号，[0,N]表示预设的分辨率(N 为预设分辨率的最大个数，一般不超过20),OXFF 表示自定义分辨率(ROI)
+ ("acDescription", c_char * 32), # 该分辨率的描述信息。仅预设分辨率时该信息有效。自定义分辨率可忽略该信息
+ ("uBinSumMode", c_uint), # BIN(求和)的模式,范围不能超过tSdkResolutionRange中uBinSumModeMask
+ ("uBinAverageMode", c_uint), # BIN(求均值)的模式,范围不能超过tSdkResolutionRange中uBinAverageModeMask
+ ("uSkipMode", c_uint), # 是否SKIP的尺寸，为0表示禁止SKIP模式，范围不能超过tSdkResolutionRange中uSkipModeMask
+ ("uResampleMask", c_uint), # 硬件重采样的掩码
+ ("iHOffsetFOV", c_int), # 采集视场相对于Sensor最大视场左上角的垂直偏移
+ ("iVOffsetFOV", c_int), # 采集视场相对于Sensor最大视场左上角的水平偏移
+ ("iWidthFOV", c_int), # 采集视场的宽度
+ ("iHeightFOV", c_int), # 采集视场的高度
+ ("iWidth", c_int), # 相机最终输出的图像的宽度
+ ("iHeight", c_int), # 相机最终输出的图像的高度
+ ("iWidthZoomHd", c_int), # 硬件缩放的宽度,不需要进行此操作的分辨率，此变量设置为0.
+ ("iHeightZoomHd", c_int), # 硬件缩放的高度,不需要进行此操作的分辨率，此变量设置为0.
+ ("iWidthZoomSw", c_int), # 软件缩放的宽度,不需要进行此操作的分辨率，此变量设置为0.
+ ("iHeightZoomSw", c_int), # 软件缩放的高度,不需要进行此操作的分辨率，此变量设置为0.
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#相机白平衡模式描述信息
+class tSdkColorTemperatureDes(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 模式索引号
+ ("acDescription", c_char * 32), # 描述信息
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#相机帧率描述信息
+class tSdkFrameSpeed(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 帧率索引号，一般0对应于低速模式，1对应于普通模式，2对应于高速模式
+ ("acDescription", c_char * 32), # 描述信息
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#相机曝光功能范围定义
+class tSdkExpose(MvStructure):
+ _fields_ = [
+ ("uiTargetMin", c_uint), #自动曝光亮度目标最小值
+ ("uiTargetMax", c_uint), #自动曝光亮度目标最大值
+ ("uiAnalogGainMin", c_uint), #模拟增益的最小值，单位为fAnalogGainStep中定义
+ ("uiAnalogGainMax", c_uint), #模拟增益的最大值，单位为fAnalogGainStep中定义
+ ("fAnalogGainStep", c_float), #模拟增益每增加1，对应的增加的放大倍数。例如，uiAnalogGainMin一般为16，fAnalogGainStep一般为0.125，那么最小放大倍数就是16*0.125 = 2倍
+ ("uiExposeTimeMin", c_uint), #手动模式下，曝光时间的最小值，单位:行。根据CameraGetExposureLineTime可以获得一行对应的时间(微秒),从而得到整帧的曝光时间
+ ("uiExposeTimeMax", c_uint), #手动模式下，曝光时间的最大值，单位:行
+ ]
+
+#触发模式描述
+class tSdkTrigger(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 模式索引号
+ ("acDescription", c_char * 32), # 描述信息
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#传输分包大小描述(主要是针对网络相机有效)
+class tSdkPackLength(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 模式索引号
+ ("acDescription", c_char * 32), # 描述信息
+ ("iPackSize", c_uint),
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#预设的LUT表描述
+class tSdkPresetLut(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 编号
+ ("acDescription", c_char * 32), # 描述信息
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#AE算法描述
+class tSdkAeAlgorithm(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 编号
+ ("acDescription", c_char * 32), # 描述信息
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#RAW转RGB算法描述
+class tSdkBayerDecodeAlgorithm(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 编号
+ ("acDescription", c_char * 32), # 描述信息
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#帧率统计信息
+class tSdkFrameStatistic(MvStructure):
+ _fields_ = [
+ ("iTotal", c_int), #当前采集的总帧数（包括错误帧）
+ ("iCapture", c_int), #当前采集的有效帧的数量
+ ("iLost", c_int), #当前丢帧的数量
+ ]
+
+#相机输出的图像数据格式
+class tSdkMediaType(MvStructure):
+ _fields_ = [
+ ("iIndex", c_int), # 格式种类编号
+ ("acDescription", c_char * 32), # 描述信息
+ ("iMediaType", c_uint), # 对应的图像格式编码，如CAMERA_MEDIA_TYPE_BAYGR8。
+ ]
+
+ def GetDescription(self):
+ return _string_buffer_to_str(self.acDescription)
+
+#伽马的设定范围
+class tGammaRange(MvStructure):
+ _fields_ = [
+ ("iMin", c_int), #最小值
+ ("iMax", c_int), #最大值
+ ]
+
+#对比度的设定范围
+class tContrastRange(MvStructure):
+ _fields_ = [
+ ("iMin", c_int), #最小值
+ ("iMax", c_int), #最大值
+ ]
+
+#RGB三通道数字增益的设定范围
+class tRgbGainRange(MvStructure):
+ _fields_ = [
+ ("iRGainMin", c_int), #红色增益的最小值
+ ("iRGainMax", c_int), #红色增益的最大值
+ ("iGGainMin", c_int), #绿色增益的最小值
+ ("iGGainMax", c_int), #绿色增益的最大值
+ ("iBGainMin", c_int), #蓝色增益的最小值
+ ("iBGainMax", c_int), #蓝色增益的最大值
+ ]
+
+#饱和度设定的范围
+class tSaturationRange(MvStructure):
+ _fields_ = [
+ ("iMin", c_int), #最小值
+ ("iMax", c_int), #最大值
+ ]
+
+#锐化的设定范围
+class tSharpnessRange(MvStructure):
+ _fields_ = [
+ ("iMin", c_int), #最小值
+ ("iMax", c_int), #最大值
+ ]
+
+#ISP模块的使能信息
+class tSdkIspCapacity(MvStructure):
+ _fields_ = [
+ ("bMonoSensor", c_int), #表示该型号相机是否为黑白相机,如果是黑白相机，则颜色相关的功能都无法调节
+ ("bWbOnce", c_int), #表示该型号相机是否支持手动白平衡功能
+ ("bAutoWb", c_int), #表示该型号相机是否支持自动白平衡功能
+ ("bAutoExposure", c_int), #表示该型号相机是否支持自动曝光功能
+ ("bManualExposure", c_int), #表示该型号相机是否支持手动曝光功能
+ ("bAntiFlick", c_int), #表示该型号相机是否支持抗频闪功能
+ ("bDeviceIsp", c_int), #表示该型号相机是否支持硬件ISP功能
+ ("bForceUseDeviceIsp", c_int), #bDeviceIsp和bForceUseDeviceIsp同时为TRUE时，表示强制只用硬件ISP，不可取消。
+ ("bZoomHD", c_int), #相机硬件是否支持图像缩放输出(只能是缩小)。
+ ]
+
+# 定义整合的设备描述信息，这些信息可以用于动态构建UI
+class tSdkCameraCapbility(MvStructure):
+ _fields_ = [
+ ("pTriggerDesc", POINTER(tSdkTrigger)),
+ ("iTriggerDesc", c_int), #触发模式的个数，即pTriggerDesc数组的大小
+ ("pImageSizeDesc", POINTER(tSdkImageResolution)),
+ ("iImageSizeDesc", c_int), #预设分辨率的个数，即pImageSizeDesc数组的大小
+ ("pClrTempDesc", POINTER(tSdkColorTemperatureDes)),
+ ("iClrTempDesc", c_int), #预设色温个数
+ ("pMediaTypeDesc", POINTER(tSdkMediaType)),
+ ("iMediaTypeDesc", c_int), #相机输出图像格式的种类个数，即pMediaTypeDesc数组的大小。
+ ("pFrameSpeedDesc", POINTER(tSdkFrameSpeed)), #可调节帧速类型，对应界面上普通 高速 和超级三种速度设置
+ ("iFrameSpeedDesc", c_int), #可调节帧速类型的个数，即pFrameSpeedDesc数组的大小。
+ ("pPackLenDesc", POINTER(tSdkPackLength)), #传输包长度，一般用于网络设备
+ ("iPackLenDesc", c_int), #可供选择的传输分包长度的个数，即pPackLenDesc数组的大小。
+ ("iOutputIoCounts", c_int), #可编程输出IO的个数
+ ("iInputIoCounts", c_int), #可编程输入IO的个数
+ ("pPresetLutDesc", POINTER(tSdkPresetLut)), #相机预设的LUT表
+ ("iPresetLut", c_int), #相机预设的LUT表的个数，即pPresetLutDesc数组的大小
+ ("iUserDataMaxLen", c_int), #指示该相机中用于保存用户数据区的最大长度。为0表示无。
+ ("bParamInDevice", c_int), #指示该设备是否支持从设备中读写参数组。1为支持，0不支持。
+ ("pAeAlmSwDesc", POINTER(tSdkAeAlgorithm)),#软件自动曝光算法描述
+ ("iAeAlmSwDesc", c_int), #软件自动曝光算法个数
+ ("pAeAlmHdDesc", POINTER(tSdkAeAlgorithm)),#硬件自动曝光算法描述，为NULL表示不支持硬件自动曝光
+ ("iAeAlmHdDesc", c_int), #硬件自动曝光算法个数，为0表示不支持硬件自动曝光
+ ("pBayerDecAlmSwDesc", POINTER(tSdkBayerDecodeAlgorithm)),#软件Bayer转换为RGB数据的算法描述
+ ("iBayerDecAlmSwDesc", c_int), #软件Bayer转换为RGB数据的算法个数
+ ("pBayerDecAlmHdDesc", POINTER(tSdkBayerDecodeAlgorithm)),#硬件Bayer转换为RGB数据的算法描述，为NULL表示不支持
+ ("iBayerDecAlmHdDesc", c_int), #硬件Bayer转换为RGB数据的算法个数，为0表示不支持
+
+ # 图像参数的调节范围定义,用于动态构建UI
+ ("sExposeDesc", tSdkExpose), #曝光的范围值
+ ("sResolutionRange", tSdkResolutionRange), #分辨率范围描述
+ ("sRgbGainRange", tRgbGainRange), #图像数字增益范围描述
+ ("sSaturationRange", tSaturationRange), #饱和度范围描述
+ ("sGammaRange", tGammaRange), #伽马范围描述
+ ("sContrastRange", tContrastRange), #对比度范围描述
+ ("sSharpnessRange", tSharpnessRange), #锐化范围描述
+ ("sIspCapacity", tSdkIspCapacity), #ISP能力描述
+ ]
+
+#图像帧头信息
+class tSdkFrameHead(MvStructure):
+ _fields_ = [
+ ("uiMediaType", c_uint), # 图像格式,Image Format
+ ("uBytes", c_uint), # 图像数据字节数,Total bytes
+ ("iWidth", c_int), # 宽度 Image height
+ ("iHeight", c_int), # 高度 Image width
+ ("iWidthZoomSw", c_int), # 软件缩放的宽度,不需要进行软件裁剪的图像，此变量设置为0.
+ ("iHeightZoomSw", c_int), # 软件缩放的高度,不需要进行软件裁剪的图像，此变量设置为0.
+ ("bIsTrigger", c_int), # 指示是否为触发帧 is trigger
+ ("uiTimeStamp", c_uint), # 该帧的采集时间，单位0.1毫秒
+ ("uiExpTime", c_uint), # 当前图像的曝光值，单位为微秒us
+ ("fAnalogGain", c_float), # 当前图像的模拟增益倍数
+ ("iGamma", c_int), # 该帧图像的伽马设定值，仅当LUT模式为动态参数生成时有效，其余模式下为-1
+ ("iContrast", c_int), # 该帧图像的对比度设定值，仅当LUT模式为动态参数生成时有效，其余模式下为-1
+ ("iSaturation", c_int), # 该帧图像的饱和度设定值，对于黑白相机无意义，为0
+ ("fRgain", c_float), # 该帧图像处理的红色数字增益倍数，对于黑白相机无意义，为1
+ ("fGgain", c_float), # 该帧图像处理的绿色数字增益倍数，对于黑白相机无意义，为1
+ ("fBgain", c_float), # 该帧图像处理的蓝色数字增益倍数，对于黑白相机无意义，为1
+ ]
+
+# Grabber统计信息
+class tSdkGrabberStat(MvStructure):
+ _fields_ = [
+ ("Width", c_int), # 帧图像大小
+ ("Height", c_int), # 帧图像大小
+ ("Disp", c_int), # 显示帧数量
+ ("Capture", c_int), # 采集的有效帧的数量
+ ("Lost", c_int), # 丢帧的数量
+ ("Error", c_int), # 错帧的数量
+ ("DispFps", c_float), # 显示帧率
+ ("CapFps", c_float), # 捕获帧率
+ ]
+
+# 方法回调辅助类
+class method(object):
+ def __init__(self, FuncType):
+ super(method, self).__init__()
+ self.FuncType = FuncType
+ self.cache = {}
+
+ def __call__(self, cb):
+ self.cb = cb
+ return self
+
+ def __get__(self, obj, objtype):
+ try:
+ return self.cache[obj]
+ except KeyError as e:
+ def cl(*args):
+ return self.cb(obj, *args)
+ r = self.cache[obj] = self.FuncType(cl)
+ return r
+
+# 图像捕获的回调函数定义
+CAMERA_SNAP_PROC = CALLBACK_FUNC_TYPE(None, c_int, c_void_p, POINTER(tSdkFrameHead), c_void_p)
+
+# 相机连接状态回调
+CAMERA_CONNECTION_STATUS_CALLBACK = CALLBACK_FUNC_TYPE(None, c_int, c_uint, c_uint, c_void_p)
+
+# 异步抓图完成回调
+pfnCameraGrabberSaveImageComplete = CALLBACK_FUNC_TYPE(None, c_void_p, c_void_p, c_int, c_void_p)
+
+# 帧监听回调
+pfnCameraGrabberFrameListener = CALLBACK_FUNC_TYPE(c_int, c_void_p, c_int, c_void_p, POINTER(tSdkFrameHead), c_void_p)
+
+# 采集器图像捕获的回调
+pfnCameraGrabberFrameCallback = CALLBACK_FUNC_TYPE(None, c_void_p, c_void_p, POINTER(tSdkFrameHead), c_void_p)
+
+#-----------------------------------函数接口------------------------------------------
+
+# 线程局部存储
+_tls = local()
+
+# 存储最后一次SDK调用返回的错误码
+def GetLastError():
+ try:
+ return _tls.last_error
+ except AttributeError as e:
+ _tls.last_error = 0
+ return 0
+
+def SetLastError(err_code):
+ _tls.last_error = err_code
+
+def _string_buffer_to_str(buf):
+ s = buf if isinstance(buf, type(b'')) else buf.value
+
+ for codec in ('gbk', 'utf-8'):
+ try:
+ s = s.decode(codec)
+ break
+ except UnicodeDecodeError as e:
+ continue
+
+ if isinstance(s, str):
+ return s
+ else:
+ return s.encode('utf-8')
+
+def _str_to_string_buffer(str):
+ if type(str) is type(u''):
+ s = str.encode('gbk')
+ else:
+ s = str.decode('utf-8').encode('gbk')
+ return create_string_buffer(s)
+
+def CameraSdkInit(iLanguageSel):
+ err_code = _sdk.CameraSdkInit(iLanguageSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetSysOption(optionName, value):
+ err_code = _sdk.CameraSetSysOption(_str_to_string_buffer(optionName), _str_to_string_buffer(str(value)))
+ SetLastError(err_code)
+ return err_code
+
+def CameraEnumerateDevice(MaxCount = 32):
+ Nums = c_int(MaxCount)
+ pCameraList = (tSdkCameraDevInfo * Nums.value)()
+ err_code = _sdk.CameraEnumerateDevice(pCameraList, byref(Nums))
+ SetLastError(err_code)
+ return pCameraList[0:Nums.value]
+
+def CameraEnumerateDeviceEx():
+ return _sdk.CameraEnumerateDeviceEx()
+
+def CameraIsOpened(pCameraInfo):
+ pOpened = c_int()
+ err_code = _sdk.CameraIsOpened(byref(pCameraInfo), byref(pOpened) )
+ SetLastError(err_code)
+ return pOpened.value != 0
+
+def CameraInit(pCameraInfo, emParamLoadMode = -1, emTeam = -1):
+ pCameraHandle = c_int()
+ err_code = _sdk.CameraInit(byref(pCameraInfo), emParamLoadMode, emTeam, byref(pCameraHandle))
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return pCameraHandle.value
+
+def CameraInitEx(iDeviceIndex, emParamLoadMode = -1, emTeam = -1):
+ pCameraHandle = c_int()
+ err_code = _sdk.CameraInitEx(iDeviceIndex, emParamLoadMode, emTeam, byref(pCameraHandle))
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return pCameraHandle.value
+
+def CameraInitEx2(CameraName):
+ pCameraHandle = c_int()
+ err_code = _sdk.CameraInitEx2(_str_to_string_buffer(CameraName), byref(pCameraHandle))
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return pCameraHandle.value
+
+def CameraSetCallbackFunction(hCamera, pCallBack, pContext = 0):
+ err_code = _sdk.CameraSetCallbackFunction(hCamera, pCallBack, c_void_p(pContext), None)
+ SetLastError(err_code)
+ return err_code
+
+def CameraUnInit(hCamera):
+ err_code = _sdk.CameraUnInit(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetInformation(hCamera):
+ pbuffer = c_char_p()
+ err_code = _sdk.CameraGetInformation(hCamera, byref(pbuffer) )
+ SetLastError(err_code)
+ if err_code == 0 and pbuffer.value is not None:
+ return _string_buffer_to_str(pbuffer)
+ return ''
+
+def CameraImageProcess(hCamera, pbyIn, pbyOut, pFrInfo):
+ err_code = _sdk.CameraImageProcess(hCamera, c_void_p(pbyIn), c_void_p(pbyOut), byref(pFrInfo))
+ SetLastError(err_code)
+ return err_code
+
+def CameraImageProcessEx(hCamera, pbyIn, pbyOut, pFrInfo, uOutFormat, uReserved):
+ err_code = _sdk.CameraImageProcessEx(hCamera, c_void_p(pbyIn), c_void_p(pbyOut), byref(pFrInfo), uOutFormat, uReserved)
+ SetLastError(err_code)
+ return err_code
+
+def CameraDisplayInit(hCamera, hWndDisplay):
+ err_code = _sdk.CameraDisplayInit(hCamera, hWndDisplay)
+ SetLastError(err_code)
+ return err_code
+
+def CameraDisplayRGB24(hCamera, pFrameBuffer, pFrInfo):
+ err_code = _sdk.CameraDisplayRGB24(hCamera, c_void_p(pFrameBuffer), byref(pFrInfo) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetDisplayMode(hCamera, iMode):
+ err_code = _sdk.CameraSetDisplayMode(hCamera, iMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetDisplayOffset(hCamera, iOffsetX, iOffsetY):
+ err_code = _sdk.CameraSetDisplayOffset(hCamera, iOffsetX, iOffsetY)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetDisplaySize(hCamera, iWidth, iHeight):
+ err_code = _sdk.CameraSetDisplaySize(hCamera, iWidth, iHeight)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetImageBuffer(hCamera, wTimes):
+ pbyBuffer = c_void_p()
+ pFrameInfo = tSdkFrameHead()
+ err_code = _sdk.CameraGetImageBuffer(hCamera, byref(pFrameInfo), byref(pbyBuffer), wTimes)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (pbyBuffer.value, pFrameInfo)
+
+def CameraGetImageBufferEx(hCamera, wTimes):
+ _sdk.CameraGetImageBufferEx.restype = c_void_p
+ piWidth = c_int()
+ piHeight = c_int()
+ pFrameBuffer = _sdk.CameraGetImageBufferEx(hCamera, byref(piWidth), byref(piHeight), wTimes)
+ err_code = CAMERA_STATUS_SUCCESS if pFrameBuffer else CAMERA_STATUS_TIME_OUT
+ SetLastError(err_code)
+ if pFrameBuffer:
+ return (pFrameBuffer, piWidth.value, piHeight.value)
+ else:
+ raise CameraException(err_code)
+
+def CameraSnapToBuffer(hCamera, wTimes):
+ pbyBuffer = c_void_p()
+ pFrameInfo = tSdkFrameHead()
+ err_code = _sdk.CameraSnapToBuffer(hCamera, byref(pFrameInfo), byref(pbyBuffer), wTimes)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (pbyBuffer.value, pFrameInfo)
+
+def CameraReleaseImageBuffer(hCamera, pbyBuffer):
+ err_code = _sdk.CameraReleaseImageBuffer(hCamera, c_void_p(pbyBuffer) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraPlay(hCamera):
+ err_code = _sdk.CameraPlay(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraPause(hCamera):
+ err_code = _sdk.CameraPause(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraStop(hCamera):
+ err_code = _sdk.CameraStop(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraInitRecord(hCamera, iFormat, pcSavePath, b2GLimit, dwQuality, iFrameRate):
+ err_code = _sdk.CameraInitRecord(hCamera, iFormat, _str_to_string_buffer(pcSavePath), b2GLimit, dwQuality, iFrameRate)
+ SetLastError(err_code)
+ return err_code
+
+def CameraStopRecord(hCamera):
+ err_code = _sdk.CameraStopRecord(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraPushFrame(hCamera, pbyImageBuffer, pFrInfo):
+ err_code = _sdk.CameraPushFrame(hCamera, c_void_p(pbyImageBuffer), byref(pFrInfo) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveImage(hCamera, lpszFileName, pbyImageBuffer, pFrInfo, byFileType, byQuality):
+ err_code = _sdk.CameraSaveImage(hCamera, _str_to_string_buffer(lpszFileName), c_void_p(pbyImageBuffer), byref(pFrInfo), byFileType, byQuality)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveImageEx(hCamera, lpszFileName, pbyImageBuffer, uImageFormat, iWidth, iHeight, byFileType, byQuality):
+ err_code = _sdk.CameraSaveImageEx(hCamera, _str_to_string_buffer(lpszFileName), c_void_p(pbyImageBuffer), uImageFormat, iWidth, iHeight, byFileType, byQuality)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetImageResolution(hCamera):
+ psCurVideoSize = tSdkImageResolution()
+ err_code = _sdk.CameraGetImageResolution(hCamera, byref(psCurVideoSize) )
+ SetLastError(err_code)
+ return psCurVideoSize
+
+def CameraSetImageResolution(hCamera, pImageResolution):
+ err_code = _sdk.CameraSetImageResolution(hCamera, byref(pImageResolution) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetImageResolutionEx(hCamera, iIndex, Mode, ModeSize, x, y, width, height, ZoomWidth, ZoomHeight):
+ err_code = _sdk.CameraSetImageResolutionEx(hCamera, iIndex, Mode, ModeSize, x, y, width, height, ZoomWidth, ZoomHeight)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetMediaType(hCamera):
+ piMediaType = c_int()
+ err_code = _sdk.CameraGetMediaType(hCamera, byref(piMediaType) )
+ SetLastError(err_code)
+ return piMediaType.value
+
+def CameraSetMediaType(hCamera, iMediaType):
+ err_code = _sdk.CameraSetMediaType(hCamera, iMediaType)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetAeState(hCamera, bAeState):
+ err_code = _sdk.CameraSetAeState(hCamera, bAeState)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeState(hCamera):
+ pAeState = c_int()
+ err_code = _sdk.CameraGetAeState(hCamera, byref(pAeState) )
+ SetLastError(err_code)
+ return pAeState.value
+
+def CameraSetSharpness(hCamera, iSharpness):
+ err_code = _sdk.CameraSetSharpness(hCamera, iSharpness)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetSharpness(hCamera):
+ piSharpness = c_int()
+ err_code = _sdk.CameraGetSharpness(hCamera, byref(piSharpness) )
+ SetLastError(err_code)
+ return piSharpness.value
+
+def CameraSetLutMode(hCamera, emLutMode):
+ err_code = _sdk.CameraSetLutMode(hCamera, emLutMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetLutMode(hCamera):
+ pemLutMode = c_int()
+ err_code = _sdk.CameraGetLutMode(hCamera, byref(pemLutMode) )
+ SetLastError(err_code)
+ return pemLutMode.value
+
+def CameraSelectLutPreset(hCamera, iSel):
+ err_code = _sdk.CameraSelectLutPreset(hCamera, iSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetLutPresetSel(hCamera):
+ piSel = c_int()
+ err_code = _sdk.CameraGetLutPresetSel(hCamera, byref(piSel) )
+ SetLastError(err_code)
+ return piSel.value
+
+def CameraSetCustomLut(hCamera, iChannel, pLut):
+ pLutNative = (c_ushort * 4096)(*pLut)
+ err_code = _sdk.CameraSetCustomLut(hCamera, iChannel, pLutNative)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetCustomLut(hCamera, iChannel):
+ pLutNative = (c_ushort * 4096)()
+ err_code = _sdk.CameraGetCustomLut(hCamera, iChannel, pLutNative)
+ SetLastError(err_code)
+ return pLutNative[:]
+
+def CameraGetCurrentLut(hCamera, iChannel):
+ pLutNative = (c_ushort * 4096)()
+ err_code = _sdk.CameraGetCurrentLut(hCamera, iChannel, pLutNative)
+ SetLastError(err_code)
+ return pLutNative[:]
+
+def CameraSetWbMode(hCamera, bAuto):
+ err_code = _sdk.CameraSetWbMode(hCamera, bAuto)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetWbMode(hCamera):
+ pbAuto = c_int()
+ err_code = _sdk.CameraGetWbMode(hCamera, byref(pbAuto) )
+ SetLastError(err_code)
+ return pbAuto.value
+
+def CameraSetPresetClrTemp(hCamera, iSel):
+ err_code = _sdk.CameraSetPresetClrTemp(hCamera, iSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetPresetClrTemp(hCamera):
+ piSel = c_int()
+ err_code = _sdk.CameraGetPresetClrTemp(hCamera, byref(piSel) )
+ SetLastError(err_code)
+ return piSel.value
+
+def CameraSetUserClrTempGain(hCamera, iRgain, iGgain, iBgain):
+ err_code = _sdk.CameraSetUserClrTempGain(hCamera, iRgain, iGgain, iBgain)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetUserClrTempGain(hCamera):
+ piRgain = c_int()
+ piGgain = c_int()
+ piBgain = c_int()
+ err_code = _sdk.CameraGetUserClrTempGain(hCamera, byref(piRgain), byref(piGgain), byref(piBgain) )
+ SetLastError(err_code)
+ return (piRgain.value, piGgain.value, piBgain.value)
+
+def CameraSetUserClrTempMatrix(hCamera, pMatrix):
+ pMatrixNative = (c_float * 9)(*pMatrix)
+ err_code = _sdk.CameraSetUserClrTempMatrix(hCamera, pMatrixNative)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetUserClrTempMatrix(hCamera):
+ pMatrixNative = (c_float * 9)()
+ err_code = _sdk.CameraGetUserClrTempMatrix(hCamera, pMatrixNative)
+ SetLastError(err_code)
+ return pMatrixNative[:]
+
+def CameraSetClrTempMode(hCamera, iMode):
+ err_code = _sdk.CameraSetClrTempMode(hCamera, iMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetClrTempMode(hCamera):
+ piMode = c_int()
+ err_code = _sdk.CameraGetClrTempMode(hCamera, byref(piMode) )
+ SetLastError(err_code)
+ return piMode.value
+
+def CameraSetOnceWB(hCamera):
+ err_code = _sdk.CameraSetOnceWB(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetOnceBB(hCamera):
+ err_code = _sdk.CameraSetOnceBB(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetAeTarget(hCamera, iAeTarget):
+ err_code = _sdk.CameraSetAeTarget(hCamera, iAeTarget)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeTarget(hCamera):
+ piAeTarget = c_int()
+ err_code = _sdk.CameraGetAeTarget(hCamera, byref(piAeTarget) )
+ SetLastError(err_code)
+ return piAeTarget.value
+
+def CameraSetAeExposureRange(hCamera, fMinExposureTime, fMaxExposureTime):
+ err_code = _sdk.CameraSetAeExposureRange(hCamera, c_double(fMinExposureTime), c_double(fMaxExposureTime) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeExposureRange(hCamera):
+ fMinExposureTime = c_double()
+ fMaxExposureTime = c_double()
+ err_code = _sdk.CameraGetAeExposureRange(hCamera, byref(fMinExposureTime), byref(fMaxExposureTime) )
+ SetLastError(err_code)
+ return (fMinExposureTime.value, fMaxExposureTime.value)
+
+def CameraSetAeAnalogGainRange(hCamera, iMinAnalogGain, iMaxAnalogGain):
+ err_code = _sdk.CameraSetAeAnalogGainRange(hCamera, iMinAnalogGain, iMaxAnalogGain)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeAnalogGainRange(hCamera):
+ iMinAnalogGain = c_int()
+ iMaxAnalogGain = c_int()
+ err_code = _sdk.CameraGetAeAnalogGainRange(hCamera, byref(iMinAnalogGain), byref(iMaxAnalogGain) )
+ SetLastError(err_code)
+ return (iMinAnalogGain.value, iMaxAnalogGain.value)
+
+def CameraSetAeThreshold(hCamera, iThreshold):
+ err_code = _sdk.CameraSetAeThreshold(hCamera, iThreshold)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeThreshold(hCamera):
+ iThreshold = c_int()
+ err_code = _sdk.CameraGetAeThreshold(hCamera, byref(iThreshold))
+ SetLastError(err_code)
+ return iThreshold.value
+
+def CameraSetExposureTime(hCamera, fExposureTime):
+ err_code = _sdk.CameraSetExposureTime(hCamera, c_double(fExposureTime) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetExposureLineTime(hCamera):
+ pfLineTime = c_double()
+ err_code = _sdk.CameraGetExposureLineTime(hCamera, byref(pfLineTime))
+ SetLastError(err_code)
+ return pfLineTime.value
+
+def CameraGetExposureTime(hCamera):
+ pfExposureTime = c_double()
+ err_code = _sdk.CameraGetExposureTime(hCamera, byref(pfExposureTime))
+ SetLastError(err_code)
+ return pfExposureTime.value
+
+def CameraGetExposureTimeRange(hCamera):
+ pfMin = c_double()
+ pfMax = c_double()
+ pfStep = c_double()
+ err_code = _sdk.CameraGetExposureTimeRange(hCamera, byref(pfMin), byref(pfMax), byref(pfStep))
+ SetLastError(err_code)
+ return (pfMin.value, pfMax.value, pfStep.value)
+
+def CameraSetAnalogGain(hCamera, iAnalogGain):
+ err_code = _sdk.CameraSetAnalogGain(hCamera, iAnalogGain)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAnalogGain(hCamera):
+ piAnalogGain = c_int()
+ err_code = _sdk.CameraGetAnalogGain(hCamera, byref(piAnalogGain))
+ SetLastError(err_code)
+ return piAnalogGain.value
+
+def CameraSetAnalogGainX(hCamera, fGain):
+ err_code = _sdk.CameraSetAnalogGainX(hCamera, c_float(fGain) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAnalogGainX(hCamera):
+ fGain = c_float()
+ err_code = _sdk.CameraGetAnalogGainX(hCamera, byref(fGain))
+ SetLastError(err_code)
+ return fGain.value
+
+def CameraGetAnalogGainXRange(hCamera):
+ pfMin = c_float()
+ pfMax = c_float()
+ pfStep = c_float()
+ err_code = _sdk.CameraGetAnalogGainXRange(hCamera, byref(pfMin), byref(pfMax), byref(pfStep))
+ SetLastError(err_code)
+ return (pfMin.value, pfMax.value, pfStep.value)
+
+def CameraSetGain(hCamera, iRGain, iGGain, iBGain):
+ err_code = _sdk.CameraSetGain(hCamera, iRGain, iGGain, iBGain)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetGain(hCamera):
+ piRGain = c_int()
+ piGGain = c_int()
+ piBGain = c_int()
+ err_code = _sdk.CameraGetGain(hCamera, byref(piRGain), byref(piGGain), byref(piBGain))
+ SetLastError(err_code)
+ return (piRGain.value, piGGain.value, piBGain.value)
+
+def CameraSetGamma(hCamera, iGamma):
+ err_code = _sdk.CameraSetGamma(hCamera, iGamma)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetGamma(hCamera):
+ piGamma = c_int()
+ err_code = _sdk.CameraGetGamma(hCamera, byref(piGamma))
+ SetLastError(err_code)
+ return piGamma.value
+
+def CameraSetContrast(hCamera, iContrast):
+ err_code = _sdk.CameraSetContrast(hCamera, iContrast)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetContrast(hCamera):
+ piContrast = c_int()
+ err_code = _sdk.CameraGetContrast(hCamera, byref(piContrast))
+ SetLastError(err_code)
+ return piContrast.value
+
+def CameraSetSaturation(hCamera, iSaturation):
+ err_code = _sdk.CameraSetSaturation(hCamera, iSaturation)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetSaturation(hCamera):
+ piSaturation = c_int()
+ err_code = _sdk.CameraGetSaturation(hCamera, byref(piSaturation))
+ SetLastError(err_code)
+ return piSaturation.value
+
+def CameraSetMonochrome(hCamera, bEnable):
+ err_code = _sdk.CameraSetMonochrome(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetMonochrome(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetMonochrome(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraSetInverse(hCamera, bEnable):
+ err_code = _sdk.CameraSetInverse(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetInverse(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetInverse(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraSetAntiFlick(hCamera, bEnable):
+ err_code = _sdk.CameraSetAntiFlick(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAntiFlick(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetAntiFlick(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraGetLightFrequency(hCamera):
+ piFrequencySel = c_int()
+ err_code = _sdk.CameraGetLightFrequency(hCamera, byref(piFrequencySel))
+ SetLastError(err_code)
+ return piFrequencySel.value
+
+def CameraSetLightFrequency(hCamera, iFrequencySel):
+ err_code = _sdk.CameraSetLightFrequency(hCamera, iFrequencySel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetFrameSpeed(hCamera, iFrameSpeed):
+ err_code = _sdk.CameraSetFrameSpeed(hCamera, iFrameSpeed)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetFrameSpeed(hCamera):
+ piFrameSpeed = c_int()
+ err_code = _sdk.CameraGetFrameSpeed(hCamera, byref(piFrameSpeed))
+ SetLastError(err_code)
+ return piFrameSpeed.value
+
+def CameraSetParameterMode(hCamera, iMode):
+ err_code = _sdk.CameraSetParameterMode(hCamera, iMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetParameterMode(hCamera):
+ piTarget = c_int()
+ err_code = _sdk.CameraGetParameterMode(hCamera, byref(piTarget))
+ SetLastError(err_code)
+ return piTarget.value
+
+def CameraSetParameterMask(hCamera, uMask):
+ err_code = _sdk.CameraSetParameterMask(hCamera, uMask)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveParameter(hCamera, iTeam):
+ err_code = _sdk.CameraSaveParameter(hCamera, iTeam)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveParameterToFile(hCamera, sFileName):
+ err_code = _sdk.CameraSaveParameterToFile(hCamera, _str_to_string_buffer(sFileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraReadParameterFromFile(hCamera, sFileName):
+ err_code = _sdk.CameraReadParameterFromFile(hCamera, _str_to_string_buffer(sFileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraLoadParameter(hCamera, iTeam):
+ err_code = _sdk.CameraLoadParameter(hCamera, iTeam)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetCurrentParameterGroup(hCamera):
+ piTeam = c_int()
+ err_code = _sdk.CameraGetCurrentParameterGroup(hCamera, byref(piTeam))
+ SetLastError(err_code)
+ return piTeam.value
+
+def CameraSetTransPackLen(hCamera, iPackSel):
+ err_code = _sdk.CameraSetTransPackLen(hCamera, iPackSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetTransPackLen(hCamera):
+ piPackSel = c_int()
+ err_code = _sdk.CameraGetTransPackLen(hCamera, byref(piPackSel))
+ SetLastError(err_code)
+ return piPackSel.value
+
+def CameraIsAeWinVisible(hCamera):
+ pbIsVisible = c_int()
+ err_code = _sdk.CameraIsAeWinVisible(hCamera, byref(pbIsVisible))
+ SetLastError(err_code)
+ return pbIsVisible.value
+
+def CameraSetAeWinVisible(hCamera, bIsVisible):
+ err_code = _sdk.CameraSetAeWinVisible(hCamera, bIsVisible)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeWindow(hCamera):
+ piHOff = c_int()
+ piVOff = c_int()
+ piWidth = c_int()
+ piHeight = c_int()
+ err_code = _sdk.CameraGetAeWindow(hCamera, byref(piHOff), byref(piVOff), byref(piWidth), byref(piHeight))
+ SetLastError(err_code)
+ return (piHOff.value, piVOff.value, piWidth.value, piHeight.value)
+
+def CameraSetAeWindow(hCamera, iHOff, iVOff, iWidth, iHeight):
+ err_code = _sdk.CameraSetAeWindow(hCamera, iHOff, iVOff, iWidth, iHeight)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetMirror(hCamera, iDir, bEnable):
+ err_code = _sdk.CameraSetMirror(hCamera, iDir, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetMirror(hCamera, iDir):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetMirror(hCamera, iDir, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraSetRotate(hCamera, iRot):
+ err_code = _sdk.CameraSetRotate(hCamera, iRot)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetRotate(hCamera):
+ iRot = c_int()
+ err_code = _sdk.CameraGetRotate(hCamera, byref(iRot))
+ SetLastError(err_code)
+ return iRot.value
+
+def CameraGetWbWindow(hCamera):
+ PiHOff = c_int()
+ PiVOff = c_int()
+ PiWidth = c_int()
+ PiHeight = c_int()
+ err_code = _sdk.CameraGetWbWindow(hCamera, byref(PiHOff), byref(PiVOff), byref(PiWidth), byref(PiHeight))
+ SetLastError(err_code)
+ return (PiHOff.value, PiVOff.value, PiWidth.value, PiHeight.value)
+
+def CameraSetWbWindow(hCamera, iHOff, iVOff, iWidth, iHeight):
+ err_code = _sdk.CameraSetWbWindow(hCamera, iHOff, iVOff, iWidth, iHeight)
+ SetLastError(err_code)
+ return err_code
+
+def CameraIsWbWinVisible(hCamera):
+ pbShow = c_int()
+ err_code = _sdk.CameraIsWbWinVisible(hCamera, byref(pbShow))
+ SetLastError(err_code)
+ return pbShow.value
+
+def CameraSetWbWinVisible(hCamera, bShow):
+ err_code = _sdk.CameraSetWbWinVisible(hCamera, bShow)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImageOverlay(hCamera, pRgbBuffer, pFrInfo):
+ err_code = _sdk.CameraImageOverlay(hCamera, c_void_p(pRgbBuffer), byref(pFrInfo))
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetCrossLine(hCamera, iLine, x, y, uColor, bVisible):
+ err_code = _sdk.CameraSetCrossLine(hCamera, iLine, x, y, uColor, bVisible)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetCrossLine(hCamera, iLine):
+ px = c_int()
+ py = c_int()
+ pcolor = c_uint()
+ pbVisible = c_int()
+ err_code = _sdk.CameraGetCrossLine(hCamera, iLine, byref(px), byref(py), byref(pcolor), byref(pbVisible))
+ SetLastError(err_code)
+ return (px.value, py.value, pcolor.value, pbVisible.value)
+
+def CameraGetCapability(hCamera):
+ pCameraInfo = tSdkCameraCapbility()
+ err_code = _sdk.CameraGetCapability(hCamera, byref(pCameraInfo))
+ SetLastError(err_code)
+ return pCameraInfo
+
+def CameraWriteSN(hCamera, pbySN, iLevel):
+ err_code = _sdk.CameraWriteSN(hCamera, _str_to_string_buffer(pbySN), iLevel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraReadSN(hCamera, iLevel):
+ pbySN = create_string_buffer(64)
+ err_code = _sdk.CameraReadSN(hCamera, pbySN, iLevel)
+ SetLastError(err_code)
+ return _string_buffer_to_str(pbySN)
+
+def CameraSetTriggerDelayTime(hCamera, uDelayTimeUs):
+ err_code = _sdk.CameraSetTriggerDelayTime(hCamera, uDelayTimeUs)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetTriggerDelayTime(hCamera):
+ puDelayTimeUs = c_uint()
+ err_code = _sdk.CameraGetTriggerDelayTime(hCamera, byref(puDelayTimeUs))
+ SetLastError(err_code)
+ return puDelayTimeUs.value
+
+def CameraSetTriggerCount(hCamera, iCount):
+ err_code = _sdk.CameraSetTriggerCount(hCamera, iCount)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetTriggerCount(hCamera):
+ piCount = c_int()
+ err_code = _sdk.CameraGetTriggerCount(hCamera, byref(piCount))
+ SetLastError(err_code)
+ return piCount.value
+
+def CameraSoftTrigger(hCamera):
+ err_code = _sdk.CameraSoftTrigger(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetTriggerMode(hCamera, iModeSel):
+ err_code = _sdk.CameraSetTriggerMode(hCamera, iModeSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetTriggerMode(hCamera):
+ piModeSel = c_int()
+ err_code = _sdk.CameraGetTriggerMode(hCamera, byref(piModeSel))
+ SetLastError(err_code)
+ return piModeSel.value
+
+def CameraSetStrobeMode(hCamera, iMode):
+ err_code = _sdk.CameraSetStrobeMode(hCamera, iMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetStrobeMode(hCamera):
+ piMode = c_int()
+ err_code = _sdk.CameraGetStrobeMode(hCamera, byref(piMode))
+ SetLastError(err_code)
+ return piMode.value
+
+def CameraSetStrobeDelayTime(hCamera, uDelayTimeUs):
+ err_code = _sdk.CameraSetStrobeDelayTime(hCamera, uDelayTimeUs)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetStrobeDelayTime(hCamera):
+ upDelayTimeUs = c_uint()
+ err_code = _sdk.CameraGetStrobeDelayTime(hCamera, byref(upDelayTimeUs))
+ SetLastError(err_code)
+ return upDelayTimeUs.value
+
+def CameraSetStrobePulseWidth(hCamera, uTimeUs):
+ err_code = _sdk.CameraSetStrobePulseWidth(hCamera, uTimeUs)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetStrobePulseWidth(hCamera):
+ upTimeUs = c_uint()
+ err_code = _sdk.CameraGetStrobePulseWidth(hCamera, byref(upTimeUs))
+ SetLastError(err_code)
+ return upTimeUs.value
+
+def CameraSetStrobePolarity(hCamera, uPolarity):
+ err_code = _sdk.CameraSetStrobePolarity(hCamera, uPolarity)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetStrobePolarity(hCamera):
+ upPolarity = c_uint()
+ err_code = _sdk.CameraGetStrobePolarity(hCamera, byref(upPolarity))
+ SetLastError(err_code)
+ return upPolarity.value
+
+def CameraSetExtTrigSignalType(hCamera, iType):
+ err_code = _sdk.CameraSetExtTrigSignalType(hCamera, iType)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetExtTrigSignalType(hCamera):
+ ipType = c_int()
+ err_code = _sdk.CameraGetExtTrigSignalType(hCamera, byref(ipType))
+ SetLastError(err_code)
+ return ipType.value
+
+def CameraSetExtTrigShutterType(hCamera, iType):
+ err_code = _sdk.CameraSetExtTrigShutterType(hCamera, iType)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetExtTrigShutterType(hCamera):
+ ipType = c_int()
+ err_code = _sdk.CameraGetExtTrigShutterType(hCamera, byref(ipType))
+ SetLastError(err_code)
+ return ipType.value
+
+def CameraSetExtTrigDelayTime(hCamera, uDelayTimeUs):
+ err_code = _sdk.CameraSetExtTrigDelayTime(hCamera, uDelayTimeUs)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetExtTrigDelayTime(hCamera):
+ upDelayTimeUs = c_uint()
+ err_code = _sdk.CameraGetExtTrigDelayTime(hCamera, byref(upDelayTimeUs))
+ SetLastError(err_code)
+ return upDelayTimeUs.value
+
+def CameraSetExtTrigJitterTime(hCamera, uTimeUs):
+ err_code = _sdk.CameraSetExtTrigJitterTime(hCamera, uTimeUs)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetExtTrigJitterTime(hCamera):
+ upTimeUs = c_uint()
+ err_code = _sdk.CameraGetExtTrigJitterTime(hCamera, byref(upTimeUs))
+ SetLastError(err_code)
+ return upTimeUs.value
+
+def CameraGetExtTrigCapability(hCamera):
+ puCapabilityMask = c_uint()
+ err_code = _sdk.CameraGetExtTrigCapability(hCamera, byref(puCapabilityMask))
+ SetLastError(err_code)
+ return puCapabilityMask.value
+
+def CameraPauseLevelTrigger(hCamera):
+ err_code = _sdk.CameraPauseLevelTrigger(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetResolutionForSnap(hCamera):
+ pImageResolution = tSdkImageResolution()
+ err_code = _sdk.CameraGetResolutionForSnap(hCamera, byref(pImageResolution))
+ SetLastError(err_code)
+ return pImageResolution
+
+def CameraSetResolutionForSnap(hCamera, pImageResolution):
+ err_code = _sdk.CameraSetResolutionForSnap(hCamera, byref(pImageResolution))
+ SetLastError(err_code)
+ return err_code
+
+def CameraCustomizeResolution(hCamera):
+ pImageCustom = tSdkImageResolution()
+ err_code = _sdk.CameraCustomizeResolution(hCamera, byref(pImageCustom))
+ SetLastError(err_code)
+ return pImageCustom
+
+def CameraCustomizeReferWin(hCamera, iWinType, hParent):
+ piHOff = c_int()
+ piVOff = c_int()
+ piWidth = c_int()
+ piHeight = c_int()
+ err_code = _sdk.CameraCustomizeReferWin(hCamera, iWinType, hParent, byref(piHOff), byref(piVOff), byref(piWidth), byref(piHeight))
+ SetLastError(err_code)
+ return (piHOff.value, piVOff.value, piWidth.value, piHeight.value)
+
+def CameraShowSettingPage(hCamera, bShow):
+ err_code = _sdk.CameraShowSettingPage(hCamera, bShow)
+ SetLastError(err_code)
+ return err_code
+
+def CameraCreateSettingPage(hCamera, hParent, pWinText, pCallbackFunc = None, pCallbackCtx = 0, uReserved = 0):
+ err_code = _sdk.CameraCreateSettingPage(hCamera, hParent, _str_to_string_buffer(pWinText), pCallbackFunc, c_void_p(pCallbackCtx), uReserved)
+ SetLastError(err_code)
+ return err_code
+
+def CameraCreateSettingPageEx(hCamera):
+ err_code = _sdk.CameraCreateSettingPageEx(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetActiveSettingSubPage(hCamera, index):
+ err_code = _sdk.CameraSetActiveSettingSubPage(hCamera, index)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetSettingPageParent(hCamera, hParentWnd, Flags):
+ err_code = _sdk.CameraSetSettingPageParent(hCamera, hParentWnd, Flags)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetSettingPageHWnd(hCamera):
+ hWnd = c_void_p()
+ err_code = _sdk.CameraGetSettingPageHWnd(hCamera, byref(hWnd))
+ SetLastError(err_code)
+ return hWnd.value
+
+def CameraSpecialControl(hCamera, dwCtrlCode, dwParam, lpData):
+ err_code = _sdk.CameraSpecialControl(hCamera, dwCtrlCode, dwParam, c_void_p(lpData) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetFrameStatistic(hCamera):
+ psFrameStatistic = tSdkFrameStatistic()
+ err_code = _sdk.CameraGetFrameStatistic(hCamera, byref(psFrameStatistic))
+ SetLastError(err_code)
+ return psFrameStatistic
+
+def CameraSetNoiseFilter(hCamera, bEnable):
+ err_code = _sdk.CameraSetNoiseFilter(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetNoiseFilterState(hCamera):
+ pEnable = c_int()
+ err_code = _sdk.CameraGetNoiseFilterState(hCamera, byref(pEnable))
+ SetLastError(err_code)
+ return pEnable.value
+
+def CameraRstTimeStamp(hCamera):
+ err_code = _sdk.CameraRstTimeStamp(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveUserData(hCamera, uStartAddr, pbData):
+ err_code = _sdk.CameraSaveUserData(hCamera, uStartAddr, pbData, len(pbData))
+ SetLastError(err_code)
+ return err_code
+
+def CameraLoadUserData(hCamera, uStartAddr, ilen):
+ pbData = create_string_buffer(ilen)
+ err_code = _sdk.CameraLoadUserData(hCamera, uStartAddr, pbData, ilen)
+ SetLastError(err_code)
+ return pbData[:]
+
+def CameraGetFriendlyName(hCamera):
+ pName = create_string_buffer(64)
+ err_code = _sdk.CameraGetFriendlyName(hCamera, pName)
+ SetLastError(err_code)
+ return _string_buffer_to_str(pName)
+
+def CameraSetFriendlyName(hCamera, pName):
+ pNameBuf = _str_to_string_buffer(pName)
+ resize(pNameBuf, 64)
+ err_code = _sdk.CameraSetFriendlyName(hCamera, pNameBuf)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSdkGetVersionString():
+ pVersionString = create_string_buffer(64)
+ err_code = _sdk.CameraSdkGetVersionString(pVersionString)
+ SetLastError(err_code)
+ return _string_buffer_to_str(pVersionString)
+
+def CameraCheckFwUpdate(hCamera):
+ pNeedUpdate = c_int()
+ err_code = _sdk.CameraCheckFwUpdate(hCamera, byref(pNeedUpdate))
+ SetLastError(err_code)
+ return pNeedUpdate.value
+
+def CameraGetFirmwareVersion(hCamera):
+ pVersion = create_string_buffer(64)
+ err_code = _sdk.CameraGetFirmwareVersion(hCamera, pVersion)
+ SetLastError(err_code)
+ return _string_buffer_to_str(pVersion)
+
+def CameraGetEnumInfo(hCamera):
+ pCameraInfo = tSdkCameraDevInfo()
+ err_code = _sdk.CameraGetEnumInfo(hCamera, byref(pCameraInfo))
+ SetLastError(err_code)
+ return pCameraInfo
+
+def CameraGetInerfaceVersion(hCamera):
+ pVersion = create_string_buffer(64)
+ err_code = _sdk.CameraGetInerfaceVersion(hCamera, pVersion)
+ SetLastError(err_code)
+ return _string_buffer_to_str(pVersion)
+
+def CameraSetIOState(hCamera, iOutputIOIndex, uState):
+ err_code = _sdk.CameraSetIOState(hCamera, iOutputIOIndex, uState)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetIOStateEx(hCamera, iOutputIOIndex, uState):
+ err_code = _sdk.CameraSetIOStateEx(hCamera, iOutputIOIndex, uState)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetOutPutIOState(hCamera, iOutputIOIndex):
+ puState = c_int()
+ err_code = _sdk.CameraGetOutPutIOState(hCamera, iOutputIOIndex, byref(puState))
+ SetLastError(err_code)
+ return puState.value
+
+def CameraGetOutPutIOStateEx(hCamera, iOutputIOIndex):
+ puState = c_int()
+ err_code = _sdk.CameraGetOutPutIOStateEx(hCamera, iOutputIOIndex, byref(puState))
+ SetLastError(err_code)
+ return puState.value
+
+def CameraGetIOState(hCamera, iInputIOIndex):
+ puState = c_int()
+ err_code = _sdk.CameraGetIOState(hCamera, iInputIOIndex, byref(puState))
+ SetLastError(err_code)
+ return puState.value
+
+def CameraGetIOStateEx(hCamera, iInputIOIndex):
+ puState = c_int()
+ err_code = _sdk.CameraGetIOStateEx(hCamera, iInputIOIndex, byref(puState))
+ SetLastError(err_code)
+ return puState.value
+
+def CameraSetInPutIOMode(hCamera, iInputIOIndex, iMode):
+ err_code = _sdk.CameraSetInPutIOMode(hCamera, iInputIOIndex, iMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetOutPutIOMode(hCamera, iOutputIOIndex, iMode):
+ err_code = _sdk.CameraSetOutPutIOMode(hCamera, iOutputIOIndex, iMode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetOutPutPWM(hCamera, iOutputIOIndex, iCycle, uDuty):
+ err_code = _sdk.CameraSetOutPutPWM(hCamera, iOutputIOIndex, iCycle, uDuty)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetAeAlgorithm(hCamera, iIspProcessor, iAeAlgorithmSel):
+ err_code = _sdk.CameraSetAeAlgorithm(hCamera, iIspProcessor, iAeAlgorithmSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAeAlgorithm(hCamera, iIspProcessor):
+ piAlgorithmSel = c_int()
+ err_code = _sdk.CameraGetAeAlgorithm(hCamera, iIspProcessor, byref(piAlgorithmSel))
+ SetLastError(err_code)
+ return piAlgorithmSel.value
+
+def CameraSetBayerDecAlgorithm(hCamera, iIspProcessor, iAlgorithmSel):
+ err_code = _sdk.CameraSetBayerDecAlgorithm(hCamera, iIspProcessor, iAlgorithmSel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetBayerDecAlgorithm(hCamera, iIspProcessor):
+ piAlgorithmSel = c_int()
+ err_code = _sdk.CameraGetBayerDecAlgorithm(hCamera, iIspProcessor, byref(piAlgorithmSel))
+ SetLastError(err_code)
+ return piAlgorithmSel.value
+
+def CameraSetIspProcessor(hCamera, iIspProcessor):
+ err_code = _sdk.CameraSetIspProcessor(hCamera, iIspProcessor)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetIspProcessor(hCamera):
+ piIspProcessor = c_int()
+ err_code = _sdk.CameraGetIspProcessor(hCamera, byref(piIspProcessor))
+ SetLastError(err_code)
+ return piIspProcessor.value
+
+def CameraSetBlackLevel(hCamera, iBlackLevel):
+ err_code = _sdk.CameraSetBlackLevel(hCamera, iBlackLevel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetBlackLevel(hCamera):
+ piBlackLevel = c_int()
+ err_code = _sdk.CameraGetBlackLevel(hCamera, byref(piBlackLevel))
+ SetLastError(err_code)
+ return piBlackLevel.value
+
+def CameraSetWhiteLevel(hCamera, iWhiteLevel):
+ err_code = _sdk.CameraSetWhiteLevel(hCamera, iWhiteLevel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetWhiteLevel(hCamera):
+ piWhiteLevel = c_int()
+ err_code = _sdk.CameraGetWhiteLevel(hCamera, byref(piWhiteLevel))
+ SetLastError(err_code)
+ return piWhiteLevel.value
+
+def CameraSetIspOutFormat(hCamera, uFormat):
+ err_code = _sdk.CameraSetIspOutFormat(hCamera, uFormat)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetIspOutFormat(hCamera):
+ puFormat = c_int()
+ err_code = _sdk.CameraGetIspOutFormat(hCamera, byref(puFormat))
+ SetLastError(err_code)
+ return puFormat.value
+
+def CameraGetErrorString(iStatusCode):
+ _sdk.CameraGetErrorString.restype = c_char_p
+ msg = _sdk.CameraGetErrorString(iStatusCode)
+ if msg:
+ return _string_buffer_to_str(msg)
+ else:
+ return ''
+
+def CameraGetImageBufferEx2(hCamera, pImageData, uOutFormat, wTimes):
+ piWidth = c_int()
+ piHeight = c_int()
+ err_code = _sdk.CameraGetImageBufferEx2(hCamera, c_void_p(pImageData), uOutFormat, byref(piWidth), byref(piHeight), wTimes)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (piWidth.value, piHeight.value)
+
+def CameraGetImageBufferEx3(hCamera, pImageData, uOutFormat, wTimes):
+ piWidth = c_int()
+ piHeight = c_int()
+ puTimeStamp = c_int()
+ err_code = _sdk.CameraGetImageBufferEx3(hCamera, c_void_p(pImageData), uOutFormat, byref(piWidth), byref(piHeight), byref(puTimeStamp), wTimes)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (piWidth.value, piHeight.value, puTimeStamp.value)
+
+def CameraGetCapabilityEx2(hCamera):
+ pMaxWidth = c_int()
+ pMaxHeight = c_int()
+ pbColorCamera = c_int()
+ err_code = _sdk.CameraGetCapabilityEx2(hCamera, byref(pMaxWidth), byref(pMaxHeight), byref(pbColorCamera))
+ SetLastError(err_code)
+ return (pMaxWidth.value, pMaxHeight.value, pbColorCamera.value)
+
+def CameraReConnect(hCamera):
+ err_code = _sdk.CameraReConnect(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraConnectTest(hCamera):
+ err_code = _sdk.CameraConnectTest(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetLedEnable(hCamera, index, enable):
+ err_code = _sdk.CameraSetLedEnable(hCamera, index, enable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetLedEnable(hCamera, index):
+ enable = c_int()
+ err_code = _sdk.CameraGetLedEnable(hCamera, index, byref(enable))
+ SetLastError(err_code)
+ return enable.value
+
+def CameraSetLedOnOff(hCamera, index, onoff):
+ err_code = _sdk.CameraSetLedOnOff(hCamera, index, onoff)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetLedOnOff(hCamera, index):
+ onoff = c_int()
+ err_code = _sdk.CameraGetLedOnOff(hCamera, index, byref(onoff))
+ SetLastError(err_code)
+ return onoff.value
+
+def CameraSetLedDuration(hCamera, index, duration):
+ err_code = _sdk.CameraSetLedDuration(hCamera, index, duration)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetLedDuration(hCamera, index):
+ duration = c_uint()
+ err_code = _sdk.CameraGetLedDuration(hCamera, index, byref(duration))
+ SetLastError(err_code)
+ return duration.value
+
+def CameraSetLedBrightness(hCamera, index, uBrightness):
+ err_code = _sdk.CameraSetLedBrightness(hCamera, index, uBrightness)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetLedBrightness(hCamera, index):
+ uBrightness = c_uint()
+ err_code = _sdk.CameraGetLedBrightness(hCamera, index, byref(uBrightness))
+ SetLastError(err_code)
+ return uBrightness.value
+
+def CameraEnableTransferRoi(hCamera, uEnableMask):
+ err_code = _sdk.CameraEnableTransferRoi(hCamera, uEnableMask)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetTransferRoi(hCamera, index, X1, Y1, X2, Y2):
+ err_code = _sdk.CameraSetTransferRoi(hCamera, index, X1, Y1, X2, Y2)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetTransferRoi(hCamera, index):
+ pX1 = c_uint()
+ pY1 = c_uint()
+ pX2 = c_uint()
+ pY2 = c_uint()
+ err_code = _sdk.CameraGetTransferRoi(hCamera, index, byref(pX1), byref(pY1), byref(pX2), byref(pY2))
+ SetLastError(err_code)
+ return (pX1.value, pY1.value, pX2.value, pY2.value)
+
+def CameraAlignMalloc(size, align = 16):
+ _sdk.CameraAlignMalloc.restype = c_void_p
+ r = _sdk.CameraAlignMalloc(size, align)
+ return r
+
+def CameraAlignFree(membuffer):
+ _sdk.CameraAlignFree(c_void_p(membuffer))
+
+def CameraSetAutoConnect(hCamera, bEnable):
+ err_code = _sdk.CameraSetAutoConnect(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetAutoConnect(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetAutoConnect(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraGetReConnectCounts(hCamera):
+ puCounts = c_int()
+ err_code = _sdk.CameraGetReConnectCounts(hCamera, byref(puCounts))
+ SetLastError(err_code)
+ return puCounts.value
+
+def CameraSetSingleGrabMode(hCamera, bEnable):
+ err_code = _sdk.CameraSetSingleGrabMode(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetSingleGrabMode(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetSingleGrabMode(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraRestartGrab(hCamera):
+ err_code = _sdk.CameraRestartGrab(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraEvaluateImageDefinition(hCamera, iAlgorithSel, pbyIn, pFrInfo):
+ DefinitionValue = c_double()
+ err_code = _sdk.CameraEvaluateImageDefinition(hCamera, iAlgorithSel, c_void_p(pbyIn), byref(pFrInfo), byref(DefinitionValue))
+ SetLastError(err_code)
+ return DefinitionValue.value
+
+def CameraDrawText(pRgbBuffer, pFrInfo, pFontFileName, FontWidth, FontHeight, pText, Left, Top, Width, Height, TextColor, uFlags):
+ err_code = _sdk.CameraDrawText(c_void_p(pRgbBuffer), byref(pFrInfo), _str_to_string_buffer(pFontFileName), FontWidth, FontHeight, _str_to_string_buffer(pText), Left, Top, Width, Height, TextColor, uFlags)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGigeEnumerateDevice(ipList, MaxCount = 32):
+ if type(ipList) in (list, tuple):
+ ipList = map(lambda x: _str_to_string_buffer(x), ipList)
+ else:
+ ipList = (_str_to_string_buffer(ipList),)
+ numIP = len(ipList)
+ ppIpList = (c_void_p * numIP)(*map(lambda x: addressof(x), ipList))
+ Nums = c_int(MaxCount)
+ pCameraList = (tSdkCameraDevInfo * Nums.value)()
+ err_code = _sdk.CameraGigeEnumerateDevice(ppIpList, numIP, pCameraList, byref(Nums))
+ SetLastError(err_code)
+ return pCameraList[0:Nums.value]
+
+def CameraGigeGetIp(pCameraInfo):
+ CamIp = create_string_buffer(32)
+ CamMask = create_string_buffer(32)
+ CamGateWay = create_string_buffer(32)
+ EtIp = create_string_buffer(32)
+ EtMask = create_string_buffer(32)
+ EtGateWay = create_string_buffer(32)
+ err_code = _sdk.CameraGigeGetIp(byref(pCameraInfo), CamIp, CamMask, CamGateWay, EtIp, EtMask, EtGateWay)
+ SetLastError(err_code)
+ return (_string_buffer_to_str(CamIp), _string_buffer_to_str(CamMask), _string_buffer_to_str(CamGateWay),
+ _string_buffer_to_str(EtIp), _string_buffer_to_str(EtMask), _string_buffer_to_str(EtGateWay) )
+
+def CameraGigeSetIp(pCameraInfo, Ip, SubMask, GateWay, bPersistent):
+ err_code = _sdk.CameraGigeSetIp(byref(pCameraInfo),
+ _str_to_string_buffer(Ip), _str_to_string_buffer(SubMask), _str_to_string_buffer(GateWay), bPersistent)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGigeGetMac(pCameraInfo):
+ CamMac = create_string_buffer(32)
+ EtMac = create_string_buffer(32)
+ err_code = _sdk.CameraGigeGetMac(byref(pCameraInfo), CamMac, EtMac)
+ SetLastError(err_code)
+ return (_string_buffer_to_str(CamMac), _string_buffer_to_str(EtMac) )
+
+def CameraEnableFastResponse(hCamera):
+ err_code = _sdk.CameraEnableFastResponse(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetCorrectDeadPixel(hCamera, bEnable):
+ err_code = _sdk.CameraSetCorrectDeadPixel(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetCorrectDeadPixel(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraGetCorrectDeadPixel(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraFlatFieldingCorrectSetEnable(hCamera, bEnable):
+ err_code = _sdk.CameraFlatFieldingCorrectSetEnable(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraFlatFieldingCorrectGetEnable(hCamera):
+ pbEnable = c_int()
+ err_code = _sdk.CameraFlatFieldingCorrectGetEnable(hCamera, byref(pbEnable))
+ SetLastError(err_code)
+ return pbEnable.value
+
+def CameraFlatFieldingCorrectSetParameter(hCamera, pDarkFieldingImage, pDarkFieldingFrInfo, pLightFieldingImage, pLightFieldingFrInfo):
+ err_code = _sdk.CameraFlatFieldingCorrectSetParameter(hCamera, c_void_p(pDarkFieldingImage), byref(pDarkFieldingFrInfo), c_void_p(pLightFieldingImage), byref(pLightFieldingFrInfo))
+ SetLastError(err_code)
+ return err_code
+
+def CameraFlatFieldingCorrectGetParameterState(hCamera):
+ pbValid = c_int()
+ pFilePath = create_string_buffer(1024)
+ err_code = _sdk.CameraFlatFieldingCorrectGetParameterState(hCamera, byref(pbValid), pFilePath)
+ SetLastError(err_code)
+ return (pbValid.value, _string_buffer_to_str(pFilePath) )
+
+def CameraFlatFieldingCorrectSaveParameterToFile(hCamera, pszFileName):
+ err_code = _sdk.CameraFlatFieldingCorrectSaveParameterToFile(hCamera, _str_to_string_buffer(pszFileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraFlatFieldingCorrectLoadParameterFromFile(hCamera, pszFileName):
+ err_code = _sdk.CameraFlatFieldingCorrectLoadParameterFromFile(hCamera, _str_to_string_buffer(pszFileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraCommonCall(hCamera, pszCall, uResultBufSize):
+ pszResult = create_string_buffer(uResultBufSize) if uResultBufSize > 0 else None
+ err_code = _sdk.CameraCommonCall(hCamera, _str_to_string_buffer(pszCall), pszResult, uResultBufSize)
+ SetLastError(err_code)
+ return _string_buffer_to_str(pszResult) if pszResult else ''
+
+def CameraSetDenoise3DParams(hCamera, bEnable, nCount, Weights):
+ assert(nCount >= 2 and nCount <= 8)
+ if Weights:
+ assert(len(Weights) == nCount)
+ WeightsNative = (c_float * nCount)(*Weights)
+ else:
+ WeightsNative = None
+ err_code = _sdk.CameraSetDenoise3DParams(hCamera, bEnable, nCount, WeightsNative)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetDenoise3DParams(hCamera):
+ bEnable = c_int()
+ nCount = c_int()
+ bUseWeight = c_int()
+ Weights = (c_float * 8)()
+ err_code = _sdk.CameraGetDenoise3DParams(hCamera, byref(bEnable), byref(nCount), byref(bUseWeight), Weights)
+ SetLastError(err_code)
+ bEnable, nCount, bUseWeight = bEnable.value, nCount.value, bUseWeight.value
+ if bUseWeight:
+ Weights = Weights[:nCount]
+ else:
+ Weights = None
+ return (bEnable, nCount, bUseWeight, Weights)
+
+def CameraManualDenoise3D(InFramesHead, InFramesData, nCount, Weights, OutFrameHead, OutFrameData):
+ assert(nCount > 0)
+ assert(len(InFramesData) == nCount)
+ assert(Weights is None or len(Weights) == nCount)
+ InFramesDataNative = (c_void_p * nCount)(*InFramesData)
+ WeightsNative = (c_float * nCount)(*Weights) if Weights else None
+ err_code = _sdk.CameraManualDenoise3D(byref(InFramesHead), InFramesDataNative, nCount, WeightsNative, byref(OutFrameHead), c_void_p(OutFrameData))
+ SetLastError(err_code)
+ return err_code
+
+def CameraCustomizeDeadPixels(hCamera, hParent):
+ err_code = _sdk.CameraCustomizeDeadPixels(hCamera, hParent)
+ SetLastError(err_code)
+ return err_code
+
+def CameraReadDeadPixels(hCamera):
+ pNumPixel = c_int()
+ err_code = _sdk.CameraReadDeadPixels(hCamera, None, None, byref(pNumPixel))
+ SetLastError(err_code)
+ if pNumPixel.value < 1:
+ return None
+ UShortArray = c_ushort * pNumPixel.value
+ pRows = UShortArray()
+ pCols = UShortArray()
+ err_code = _sdk.CameraReadDeadPixels(hCamera, pRows, pCols, byref(pNumPixel))
+ SetLastError(err_code)
+ if err_code == 0:
+ pNumPixel = pNumPixel.value
+ else:
+ pNumPixel = 0
+ return (pRows[:pNumPixel], pCols[:pNumPixel])
+
+def CameraAddDeadPixels(hCamera, pRows, pCols, NumPixel):
+ UShortArray = c_ushort * NumPixel
+ pRowsNative = UShortArray(*pRows)
+ pColsNative = UShortArray(*pCols)
+ err_code = _sdk.CameraAddDeadPixels(hCamera, pRowsNative, pColsNative, NumPixel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraRemoveDeadPixels(hCamera, pRows, pCols, NumPixel):
+ UShortArray = c_ushort * NumPixel
+ pRowsNative = UShortArray(*pRows)
+ pColsNative = UShortArray(*pCols)
+ err_code = _sdk.CameraRemoveDeadPixels(hCamera, pRowsNative, pColsNative, NumPixel)
+ SetLastError(err_code)
+ return err_code
+
+def CameraRemoveAllDeadPixels(hCamera):
+ err_code = _sdk.CameraRemoveAllDeadPixels(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveDeadPixels(hCamera):
+ err_code = _sdk.CameraSaveDeadPixels(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSaveDeadPixelsToFile(hCamera, sFileName):
+ err_code = _sdk.CameraSaveDeadPixelsToFile(hCamera, _str_to_string_buffer(sFileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraLoadDeadPixelsFromFile(hCamera, sFileName):
+ err_code = _sdk.CameraLoadDeadPixelsFromFile(hCamera, _str_to_string_buffer(sFileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetImageBufferPriority(hCamera, wTimes, Priority):
+ pFrameInfo = tSdkFrameHead()
+ pbyBuffer = c_void_p()
+ err_code = _sdk.CameraGetImageBufferPriority(hCamera, byref(pFrameInfo), byref(pbyBuffer), wTimes, Priority)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (pbyBuffer.value, pFrameInfo)
+
+def CameraGetImageBufferPriorityEx(hCamera, wTimes, Priority):
+ _sdk.CameraGetImageBufferPriorityEx.restype = c_void_p
+ piWidth = c_int()
+ piHeight = c_int()
+ pFrameBuffer = _sdk.CameraGetImageBufferPriorityEx(hCamera, byref(piWidth), byref(piHeight), wTimes, Priority)
+ err_code = CAMERA_STATUS_SUCCESS if pFrameBuffer else CAMERA_STATUS_TIME_OUT
+ SetLastError(err_code)
+ if pFrameBuffer:
+ return (pFrameBuffer, piWidth.value, piHeight.value)
+ else:
+ raise CameraException(err_code)
+
+def CameraGetImageBufferPriorityEx2(hCamera, pImageData, uOutFormat, wTimes, Priority):
+ piWidth = c_int()
+ piHeight = c_int()
+ err_code = _sdk.CameraGetImageBufferPriorityEx2(hCamera, c_void_p(pImageData), uOutFormat, byref(piWidth), byref(piHeight), wTimes, Priority)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (piWidth.value, piHeight.value)
+
+def CameraGetImageBufferPriorityEx3(hCamera, pImageData, uOutFormat, wTimes, Priority):
+ piWidth = c_int()
+ piHeight = c_int()
+ puTimeStamp = c_uint()
+ err_code = _sdk.CameraGetImageBufferPriorityEx3(hCamera, c_void_p(pImageData), uOutFormat, byref(piWidth), byref(piHeight), byref(puTimeStamp), wTimes, Priority)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return (piWidth.value, piHeight.value, puTimeStamp.value)
+
+def CameraClearBuffer(hCamera):
+ err_code = _sdk.CameraClearBuffer(hCamera)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSoftTriggerEx(hCamera, uFlags):
+ err_code = _sdk.CameraSoftTriggerEx(hCamera, uFlags)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetHDR(hCamera, value):
+ err_code = _sdk.CameraSetHDR(hCamera, value)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetHDR(hCamera):
+ value = c_int()
+ err_code = _sdk.CameraGetHDR(hCamera, byref(value))
+ SetLastError(err_code)
+ return value.value
+
+def CameraGetFrameID(hCamera):
+ FrameID = c_uint()
+ err_code = _sdk.CameraGetFrameID(hCamera, byref(FrameID))
+ SetLastError(err_code)
+ return FrameID.value
+
+def CameraGetFrameTimeStamp(hCamera):
+ TimeStamp = c_uint64()
+ TimeStampL = c_uint32.from_buffer(TimeStamp)
+ TimeStampH = c_uint32.from_buffer(TimeStamp, 4)
+ err_code = _sdk.CameraGetFrameTimeStamp(hCamera, byref(TimeStampL), byref(TimeStampH))
+ SetLastError(err_code)
+ return TimeStamp.value
+
+def CameraSetHDRGainMode(hCamera, value):
+ err_code = _sdk.CameraSetHDRGainMode(hCamera, value)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetHDRGainMode(hCamera):
+ value = c_int()
+ err_code = _sdk.CameraGetHDRGainMode(hCamera, byref(value))
+ SetLastError(err_code)
+ return value.value
+
+def CameraCreateDIBitmap(hDC, pFrameBuffer, pFrameHead):
+ outBitmap = c_void_p()
+ err_code = _sdk.CameraCreateDIBitmap(hDC, c_void_p(pFrameBuffer), byref(pFrameHead), byref(outBitmap))
+ SetLastError(err_code)
+ return outBitmap.value
+
+def CameraDrawFrameBuffer(pFrameBuffer, pFrameHead, hWnd, Algorithm, Mode):
+ err_code = _sdk.CameraDrawFrameBuffer(c_void_p(pFrameBuffer), byref(pFrameHead), c_void_p(hWnd), Algorithm, Mode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraFlipFrameBuffer(pFrameBuffer, pFrameHead, Flags):
+ err_code = _sdk.CameraFlipFrameBuffer(c_void_p(pFrameBuffer), byref(pFrameHead), Flags)
+ SetLastError(err_code)
+ return err_code
+
+def CameraConvertFrameBufferFormat(hCamera, pInFrameBuffer, pOutFrameBuffer, outWidth, outHeight, outMediaType, pFrameHead):
+ err_code = _sdk.CameraConvertFrameBufferFormat(hCamera, c_void_p(pInFrameBuffer), c_void_p(pOutFrameBuffer), outWidth, outHeight, outMediaType, byref(pFrameHead))
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetConnectionStatusCallback(hCamera, pCallBack, pContext = 0):
+ err_code = _sdk.CameraSetConnectionStatusCallback(hCamera, pCallBack, c_void_p(pContext) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetLightingControllerMode(hCamera, index, mode):
+ err_code = _sdk.CameraSetLightingControllerMode(hCamera, index, mode)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetLightingControllerState(hCamera, index, state):
+ err_code = _sdk.CameraSetLightingControllerState(hCamera, index, state)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetFrameResendCount(hCamera, count):
+ err_code = _sdk.CameraSetFrameResendCount(hCamera, count)
+ SetLastError(err_code)
+ return err_code
+
+def CameraSetUndistortParams(hCamera, width, height, cameraMatrix, distCoeffs):
+ assert(len(cameraMatrix) == 4)
+ assert(len(distCoeffs) == 5)
+ cameraMatrixNative = (c_double * len(cameraMatrix))(*cameraMatrix)
+ distCoeffsNative = (c_double * len(distCoeffs))(*distCoeffs)
+ err_code = _sdk.CameraSetUndistortParams(hCamera, width, height, cameraMatrixNative, distCoeffsNative)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetUndistortParams(hCamera):
+ width = c_int()
+ height = c_int()
+ cameraMatrix = (c_double * 4)()
+ distCoeffs = (c_double * 5)()
+ err_code = _sdk.CameraGetUndistortParams(hCamera, byref(width), byref(height), cameraMatrix, distCoeffs)
+ SetLastError(err_code)
+ width, height = width.value, height.value
+ cameraMatrix = cameraMatrix[:]
+ distCoeffs = distCoeffs[:]
+ return (width, height, cameraMatrix, distCoeffs)
+
+def CameraSetUndistortEnable(hCamera, bEnable):
+ err_code = _sdk.CameraSetUndistortEnable(hCamera, bEnable)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetUndistortEnable(hCamera):
+ value = c_int()
+ err_code = _sdk.CameraGetUndistortEnable(hCamera, byref(value))
+ SetLastError(err_code)
+ return value.value
+
+def CameraCustomizeUndistort(hCamera, hParent):
+ err_code = _sdk.CameraCustomizeUndistort(hCamera, hParent)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGetEyeCount(hCamera):
+ EyeCount = c_int()
+ err_code = _sdk.CameraGetEyeCount(hCamera, byref(EyeCount))
+ SetLastError(err_code)
+ return EyeCount.value
+
+def CameraMultiEyeImageProcess(hCamera, iEyeIndex, pbyIn, pInFrInfo, pbyOut, pOutFrInfo, uOutFormat, uReserved):
+ err_code = _sdk.CameraMultiEyeImageProcess(hCamera, iEyeIndex, c_void_p(pbyIn), byref(pInFrInfo), c_void_p(pbyOut), byref(pOutFrInfo), uOutFormat, uReserved)
+ SetLastError(err_code)
+ return err_code
+
+# CameraGrabber
+
+def CameraGrabber_CreateFromDevicePage():
+ Grabber = c_void_p()
+ err_code = _sdk.CameraGrabber_CreateFromDevicePage(byref(Grabber))
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return Grabber.value
+
+def CameraGrabber_CreateByIndex(Index):
+ Grabber = c_void_p()
+ err_code = _sdk.CameraGrabber_CreateByIndex(byref(Grabber), Index)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return Grabber.value
+
+def CameraGrabber_CreateByName(Name):
+ Grabber = c_void_p()
+ err_code = _sdk.CameraGrabber_CreateByName(byref(Grabber), _str_to_string_buffer(Name))
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return Grabber.value
+
+def CameraGrabber_Create(pDevInfo):
+ Grabber = c_void_p()
+ err_code = _sdk.CameraGrabber_Create(byref(Grabber), byref(pDevInfo))
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return Grabber.value
+
+def CameraGrabber_Destroy(Grabber):
+ err_code = _sdk.CameraGrabber_Destroy(c_void_p(Grabber))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SetHWnd(Grabber, hWnd):
+ err_code = _sdk.CameraGrabber_SetHWnd(c_void_p(Grabber), c_void_p(hWnd) )
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SetPriority(Grabber, Priority):
+ err_code = _sdk.CameraGrabber_SetPriority(c_void_p(Grabber), Priority)
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_StartLive(Grabber):
+ err_code = _sdk.CameraGrabber_StartLive(c_void_p(Grabber))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_StopLive(Grabber):
+ err_code = _sdk.CameraGrabber_StopLive(c_void_p(Grabber))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SaveImage(Grabber, TimeOut):
+ Image = c_void_p()
+ err_code = _sdk.CameraGrabber_SaveImage(c_void_p(Grabber), byref(Image), TimeOut)
+ SetLastError(err_code)
+ if err_code != 0:
+ raise CameraException(err_code)
+ return Image.value
+
+def CameraGrabber_SaveImageAsync(Grabber):
+ err_code = _sdk.CameraGrabber_SaveImageAsync(c_void_p(Grabber))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SaveImageAsyncEx(Grabber, UserData):
+ err_code = _sdk.CameraGrabber_SaveImageAsyncEx(c_void_p(Grabber), c_void_p(UserData))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SetSaveImageCompleteCallback(Grabber, Callback, Context = 0):
+ err_code = _sdk.CameraGrabber_SetSaveImageCompleteCallback(c_void_p(Grabber), Callback, c_void_p(Context))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SetFrameListener(Grabber, Listener, Context = 0):
+ err_code = _sdk.CameraGrabber_SetFrameListener(c_void_p(Grabber), Listener, c_void_p(Context))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SetRawCallback(Grabber, Callback, Context = 0):
+ err_code = _sdk.CameraGrabber_SetRawCallback(c_void_p(Grabber), Callback, c_void_p(Context))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_SetRGBCallback(Grabber, Callback, Context = 0):
+ err_code = _sdk.CameraGrabber_SetRGBCallback(c_void_p(Grabber), Callback, c_void_p(Context))
+ SetLastError(err_code)
+ return err_code
+
+def CameraGrabber_GetCameraHandle(Grabber):
+ hCamera = c_int()
+ err_code = _sdk.CameraGrabber_GetCameraHandle(c_void_p(Grabber), byref(hCamera))
+ SetLastError(err_code)
+ return hCamera.value
+
+def CameraGrabber_GetStat(Grabber):
+ stat = tSdkGrabberStat()
+ err_code = _sdk.CameraGrabber_GetStat(c_void_p(Grabber), byref(stat))
+ SetLastError(err_code)
+ return stat
+
+def CameraGrabber_GetCameraDevInfo(Grabber):
+ DevInfo = tSdkCameraDevInfo()
+ err_code = _sdk.CameraGrabber_GetCameraDevInfo(c_void_p(Grabber), byref(DevInfo))
+ SetLastError(err_code)
+ return DevInfo
+
+# CameraImage
+
+def CameraImage_Create(pFrameBuffer, pFrameHead, bCopy):
+ Image = c_void_p()
+ err_code = _sdk.CameraImage_Create(byref(Image), c_void_p(pFrameBuffer), byref(pFrameHead), bCopy)
+ SetLastError(err_code)
+ return Image.value
+
+def CameraImage_CreateEmpty():
+ Image = c_void_p()
+ err_code = _sdk.CameraImage_CreateEmpty(byref(Image))
+ SetLastError(err_code)
+ return Image.value
+
+def CameraImage_Destroy(Image):
+ err_code = _sdk.CameraImage_Destroy(c_void_p(Image))
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_GetData(Image):
+ DataBuffer = c_void_p()
+ HeadPtr = c_void_p()
+ err_code = _sdk.CameraImage_GetData(c_void_p(Image), byref(DataBuffer), byref(HeadPtr))
+ SetLastError(err_code)
+ if err_code == 0:
+ return (DataBuffer.value, tSdkFrameHead.from_address(HeadPtr.value) )
+ else:
+ return (0, None)
+
+def CameraImage_GetUserData(Image):
+ UserData = c_void_p()
+ err_code = _sdk.CameraImage_GetUserData(c_void_p(Image), byref(UserData))
+ SetLastError(err_code)
+ return UserData.value
+
+def CameraImage_SetUserData(Image, UserData):
+ err_code = _sdk.CameraImage_SetUserData(c_void_p(Image), c_void_p(UserData))
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_IsEmpty(Image):
+ IsEmpty = c_int()
+ err_code = _sdk.CameraImage_IsEmpty(c_void_p(Image), byref(IsEmpty))
+ SetLastError(err_code)
+ return IsEmpty.value
+
+def CameraImage_Draw(Image, hWnd, Algorithm):
+ err_code = _sdk.CameraImage_Draw(c_void_p(Image), c_void_p(hWnd), Algorithm)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_DrawFit(Image, hWnd, Algorithm):
+ err_code = _sdk.CameraImage_DrawFit(c_void_p(Image), c_void_p(hWnd), Algorithm)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_DrawToDC(Image, hDC, Algorithm, xDst, yDst, cxDst, cyDst):
+ err_code = _sdk.CameraImage_DrawToDC(c_void_p(Image), c_void_p(hDC), Algorithm, xDst, yDst, cxDst, cyDst)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_DrawToDCFit(Image, hDC, Algorithm, xDst, yDst, cxDst, cyDst):
+ err_code = _sdk.CameraImage_DrawToDCFit(c_void_p(Image), c_void_p(hDC), Algorithm, xDst, yDst, cxDst, cyDst)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_BitBlt(Image, hWnd, xDst, yDst, cxDst, cyDst, xSrc, ySrc):
+ err_code = _sdk.CameraImage_BitBlt(c_void_p(Image), c_void_p(hWnd), xDst, yDst, cxDst, cyDst, xSrc, ySrc)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_BitBltToDC(Image, hDC, xDst, yDst, cxDst, cyDst, xSrc, ySrc):
+ err_code = _sdk.CameraImage_BitBltToDC(c_void_p(Image), c_void_p(hDC), xDst, yDst, cxDst, cyDst, xSrc, ySrc)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_SaveAsBmp(Image, FileName):
+ err_code = _sdk.CameraImage_SaveAsBmp(c_void_p(Image), _str_to_string_buffer(FileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_SaveAsJpeg(Image, FileName, Quality):
+ err_code = _sdk.CameraImage_SaveAsJpeg(c_void_p(Image), _str_to_string_buffer(FileName), Quality)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_SaveAsPng(Image, FileName):
+ err_code = _sdk.CameraImage_SaveAsPng(c_void_p(Image), _str_to_string_buffer(FileName))
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_SaveAsRaw(Image, FileName, Format):
+ err_code = _sdk.CameraImage_SaveAsRaw(c_void_p(Image), _str_to_string_buffer(FileName), Format)
+ SetLastError(err_code)
+ return err_code
+
+def CameraImage_IPicture(Image):
+ NewPic = c_void_p()
+ err_code = _sdk.CameraImage_IPicture(c_void_p(Image), byref(NewPic))
+ SetLastError(err_code)
+ return NewPic.value
diff --git a/api/config.json b/api/config.json
new file mode 100644
index 0000000..4f258b4
--- /dev/null
+++ b/api/config.json
@@ -0,0 +1,92 @@
+{
+ "mqtt": {
+ "broker_host": "192.168.1.110",
+ "broker_port": 1883,
+ "username": null,
+ "password": null,
+ "topics": {
+ "vibratory_conveyor": "vision/vibratory_conveyor/state",
+ "blower_separator": "vision/blower_separator/state"
+ }
+ },
+ "storage": {
+ "base_path": "/storage",
+ "max_file_size_mb": 1000,
+ "max_recording_duration_minutes": 60,
+ "cleanup_older_than_days": 30
+ },
+ "system": {
+ "camera_check_interval_seconds": 2,
+ "log_level": "DEBUG",
+ "log_file": "usda_vision_system.log",
+ "api_host": "0.0.0.0",
+ "api_port": 8000,
+ "enable_api": true,
+ "timezone": "America/New_York",
+ "auto_recording_enabled": true
+ },
+ "cameras": [
+ {
+ "name": "camera1",
+ "machine_topic": "blower_separator",
+ "storage_path": "/storage/camera1",
+ "exposure_ms": 0.3,
+ "gain": 4.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+ "sharpness": 0,
+ "contrast": 100,
+ "saturation": 100,
+ "gamma": 100,
+ "noise_filter_enabled": false,
+ "denoise_3d_enabled": false,
+ "auto_white_balance": false,
+ "color_temperature_preset": 0,
+ "wb_red_gain": 0.94,
+ "wb_green_gain": 1.0,
+ "wb_blue_gain": 0.87,
+ "anti_flicker_enabled": false,
+ "light_frequency": 0,
+ "bit_depth": 8,
+ "hdr_enabled": false,
+ "hdr_gain_mode": 2
+ },
+ {
+ "name": "camera2",
+ "machine_topic": "vibratory_conveyor",
+ "storage_path": "/storage/camera2",
+ "exposure_ms": 0.2,
+ "gain": 2.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+ "sharpness": 0,
+ "contrast": 100,
+ "saturation": 100,
+ "gamma": 100,
+ "noise_filter_enabled": false,
+ "denoise_3d_enabled": false,
+ "auto_white_balance": false,
+ "color_temperature_preset": 0,
+ "wb_red_gain": 1.01,
+ "wb_green_gain": 1.0,
+ "wb_blue_gain": 0.87,
+ "anti_flicker_enabled": false,
+ "light_frequency": 0,
+ "bit_depth": 8,
+ "hdr_enabled": false,
+ "hdr_gain_mode": 0
+ }
+ ]
+}
\ No newline at end of file
diff --git a/api/container_init.sh b/api/container_init.sh
new file mode 100755
index 0000000..f7c792d
--- /dev/null
+++ b/api/container_init.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Container initialization script for USDA Vision Camera System
+# This script sets up and starts the systemd service in a container environment
+
+echo "🐳 Container Init - USDA Vision Camera System"
+echo "============================================="
+
+# Start systemd if not already running (for containers)
+if ! pgrep systemd > /dev/null; then
+ echo "🔧 Starting systemd..."
+ exec /sbin/init &
+ sleep 5
+fi
+
+# Setup the service if not already installed
+if [ ! -f "/etc/systemd/system/usda-vision-camera.service" ]; then
+ echo "📦 Setting up USDA Vision Camera service..."
+ cd /home/alireza/USDA-vision-cameras
+ sudo ./setup_service.sh
+fi
+
+# Start the service
+echo "🚀 Starting USDA Vision Camera service..."
+sudo systemctl start usda-vision-camera
+
+# Follow the logs
+echo "📋 Following service logs (Ctrl+C to exit)..."
+sudo journalctl -u usda-vision-camera -f
diff --git a/api/convert_avi_to_mp4.sh b/api/convert_avi_to_mp4.sh
new file mode 100755
index 0000000..4be2d0c
--- /dev/null
+++ b/api/convert_avi_to_mp4.sh
@@ -0,0 +1,182 @@
+#!/bin/bash
+
+# Script to convert AVI files to MP4 using H.264 codec
+# Converts files in /storage directory and saves them in the same location
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_status() {
+ echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+ echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+ echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+ echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Function to get video duration in seconds
+get_duration() {
+ local file="$1"
+ ffprobe -v quiet -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$file" 2>/dev/null | cut -d. -f1
+}
+
+# Function to show progress bar
+show_progress() {
+ local current=$1
+ local total=$2
+ local width=50
+ local percentage=$((current * 100 / total))
+ local filled=$((current * width / total))
+ local empty=$((width - filled))
+
+ printf "\r["
+ printf "%*s" $filled | tr ' ' '='
+ printf "%*s" $empty | tr ' ' '-'
+ printf "] %d%% (%ds/%ds)" $percentage $current $total
+}
+
+# Check if ffmpeg is installed
+if ! command -v ffmpeg &> /dev/null; then
+ print_error "ffmpeg is not installed. Please install ffmpeg first."
+ exit 1
+fi
+
+# Check if /storage directory exists
+if [ ! -d "/storage" ]; then
+ print_error "/storage directory does not exist."
+ exit 1
+fi
+
+# Check if we have read/write permissions to /storage
+if [ ! -r "/storage" ] || [ ! -w "/storage" ]; then
+ print_error "No read/write permissions for /storage directory."
+ exit 1
+fi
+
+print_status "Starting AVI to MP4 conversion in /storage directory..."
+
+# Counter variables
+total_files=0
+converted_files=0
+skipped_files=0
+failed_files=0
+
+# Find all AVI files in /storage directory (including subdirectories)
+while IFS= read -r -d '' avi_file; do
+ total_files=$((total_files + 1))
+
+ # Get the directory and filename without extension
+ dir_path=$(dirname "$avi_file")
+ filename=$(basename "$avi_file" .avi)
+ mp4_file="$dir_path/$filename.mp4"
+
+ print_status "Processing: $avi_file"
+
+ # Check if MP4 file already exists
+ if [ -f "$mp4_file" ]; then
+ print_warning "MP4 file already exists: $mp4_file (skipping)"
+ skipped_files=$((skipped_files + 1))
+ continue
+ fi
+
+ # Get video duration for progress calculation
+ duration=$(get_duration "$avi_file")
+ if [ -z "$duration" ] || [ "$duration" -eq 0 ]; then
+ print_warning "Could not determine video duration, converting without progress bar..."
+ # Fallback to simple conversion without progress
+ if ffmpeg -i "$avi_file" -c:v libx264 -c:a aac -preset medium -crf 18 -nostdin "$mp4_file" -y 2>/dev/null; then
+ echo
+ print_success "Converted: $avi_file -> $mp4_file"
+ converted_files=$((converted_files + 1))
+ else
+ echo
+ print_error "Failed to convert: $avi_file"
+ failed_files=$((failed_files + 1))
+ fi
+ continue
+ fi
+
+ # Convert AVI to MP4 using H.264 codec with 95% quality (CRF 18) and show progress
+ echo "Converting... (Duration: ${duration}s)"
+
+ # Create a temporary file for ffmpeg progress
+ progress_file=$(mktemp)
+
+ # Start ffmpeg conversion in background with progress output
+ ffmpeg -i "$avi_file" -c:v libx264 -c:a aac -preset medium -crf 18 \
+ -progress "$progress_file" -nostats -loglevel 0 -nostdin "$mp4_file" -y &
+
+ ffmpeg_pid=$!
+
+ # Monitor progress
+ while kill -0 $ffmpeg_pid 2>/dev/null; do
+ if [ -f "$progress_file" ]; then
+ # Extract current time from progress file
+ current_time=$(tail -n 10 "$progress_file" 2>/dev/null | grep "out_time_ms=" | tail -n 1 | cut -d= -f2)
+ if [ -n "$current_time" ] && [ "$current_time" != "N/A" ]; then
+ # Convert microseconds to seconds
+ current_seconds=$((current_time / 1000000))
+ if [ "$current_seconds" -gt 0 ] && [ "$current_seconds" -le "$duration" ]; then
+ show_progress $current_seconds $duration
+ fi
+ fi
+ fi
+ sleep 0.5
+ done
+
+ # Wait for ffmpeg to complete and get exit status
+ wait $ffmpeg_pid
+ ffmpeg_exit_code=$?
+
+ # Clean up progress file
+ rm -f "$progress_file"
+
+ # Check if conversion was successful
+ if [ $ffmpeg_exit_code -eq 0 ] && [ -f "$mp4_file" ]; then
+ show_progress $duration $duration # Show 100% completion
+ echo
+ print_success "Converted: $avi_file -> $mp4_file"
+ converted_files=$((converted_files + 1))
+
+ # Optional: Remove original AVI file (uncomment the next line if you want this)
+ # rm "$avi_file"
+ else
+ echo
+ print_error "Failed to convert: $avi_file"
+ failed_files=$((failed_files + 1))
+ # Clean up incomplete file
+ [ -f "$mp4_file" ] && rm "$mp4_file"
+ fi
+
+ echo # Add blank line between files
+
+done < <(find /storage -name "*.avi" -type f -print0)
+
+# Print summary
+echo
+print_status "=== CONVERSION SUMMARY ==="
+echo "Total AVI files found: $total_files"
+echo "Successfully converted: $converted_files"
+echo "Skipped (MP4 exists): $skipped_files"
+echo "Failed conversions: $failed_files"
+
+if [ $total_files -eq 0 ]; then
+ print_warning "No AVI files found in /storage directory."
+elif [ $failed_files -eq 0 ] && [ $converted_files -gt 0 ]; then
+ print_success "All conversions completed successfully!"
+elif [ $failed_files -gt 0 ]; then
+ print_warning "Some conversions failed. Check the output above for details."
+fi
diff --git a/api/docs/AI_AGENT_VIDEO_INTEGRATION_GUIDE.md b/api/docs/AI_AGENT_VIDEO_INTEGRATION_GUIDE.md
new file mode 100644
index 0000000..8901049
--- /dev/null
+++ b/api/docs/AI_AGENT_VIDEO_INTEGRATION_GUIDE.md
@@ -0,0 +1,415 @@
+# 🤖 AI Agent Video Integration Guide
+
+This guide provides comprehensive step-by-step instructions for AI agents and external systems to successfully integrate with the USDA Vision Camera System's video streaming functionality.
+
+## 🎯 Overview
+
+The USDA Vision Camera System provides a complete video streaming API that allows AI agents to:
+- Browse and select videos from multiple cameras
+- Stream videos with seeking capabilities
+- Generate thumbnails for preview
+- Access video metadata and technical information
+
+## 🔗 API Base Configuration
+
+### Connection Details
+```bash
+# Default API Base URL
+API_BASE_URL="http://localhost:8000"
+
+# For remote access, replace with actual server IP/hostname
+API_BASE_URL="http://192.168.1.100:8000"
+```
+
+### Authentication
+**⚠️ IMPORTANT: No authentication is currently required.**
+- All endpoints are publicly accessible
+- No API keys or tokens needed
+- CORS is enabled for web browser integration
+
+## 📋 Step-by-Step Integration Workflow
+
+### Step 1: Verify System Connectivity
+```bash
+# Test basic connectivity
+curl -f "${API_BASE_URL}/health" || echo "❌ System not accessible"
+
+# Check system status
+curl "${API_BASE_URL}/system/status"
+```
+
+**Expected Response:**
+```json
+{
+ "status": "healthy",
+ "timestamp": "2025-08-05T10:30:00Z"
+}
+```
+
+### Step 2: List Available Videos
+```bash
+# Get all videos with metadata
+curl "${API_BASE_URL}/videos/?include_metadata=true&limit=50"
+
+# Filter by specific camera
+curl "${API_BASE_URL}/videos/?camera_name=camera1&include_metadata=true"
+
+# Filter by date range
+curl "${API_BASE_URL}/videos/?start_date=2025-08-04T00:00:00&end_date=2025-08-05T23:59:59"
+```
+
+**Response Structure:**
+```json
+{
+ "videos": [
+ {
+ "file_id": "camera1_auto_blower_separator_20250804_143022.mp4",
+ "camera_name": "camera1",
+ "filename": "camera1_auto_blower_separator_20250804_143022.mp4",
+ "file_size_bytes": 31457280,
+ "format": "mp4",
+ "status": "completed",
+ "created_at": "2025-08-04T14:30:22",
+ "start_time": "2025-08-04T14:30:22",
+ "end_time": "2025-08-04T14:32:22",
+ "machine_trigger": "blower_separator",
+ "is_streamable": true,
+ "needs_conversion": false,
+ "metadata": {
+ "duration_seconds": 120.5,
+ "width": 1920,
+ "height": 1080,
+ "fps": 30.0,
+ "codec": "mp4v",
+ "bitrate": 5000000,
+ "aspect_ratio": 1.777
+ }
+ }
+ ],
+ "total_count": 1
+}
+```
+
+### Step 3: Select and Validate Video
+```bash
+# Get detailed video information
+FILE_ID="camera1_auto_blower_separator_20250804_143022.mp4"
+curl "${API_BASE_URL}/videos/${FILE_ID}"
+
+# Validate video is playable
+curl -X POST "${API_BASE_URL}/videos/${FILE_ID}/validate"
+
+# Get streaming technical details
+curl "${API_BASE_URL}/videos/${FILE_ID}/info"
+```
+
+### Step 4: Generate Video Thumbnail
+```bash
+# Generate thumbnail at 5 seconds, 320x240 resolution
+curl "${API_BASE_URL}/videos/${FILE_ID}/thumbnail?timestamp=5.0&width=320&height=240" \
+ --output "thumbnail_${FILE_ID}.jpg"
+
+# Generate multiple thumbnails for preview
+for timestamp in 1 30 60 90; do
+ curl "${API_BASE_URL}/videos/${FILE_ID}/thumbnail?timestamp=${timestamp}&width=160&height=120" \
+ --output "preview_${timestamp}s.jpg"
+done
+```
+
+### Step 5: Stream Video Content
+```bash
+# Stream entire video
+curl "${API_BASE_URL}/videos/${FILE_ID}/stream" --output "video.mp4"
+
+# Stream specific byte range (for seeking)
+curl -H "Range: bytes=0-1048575" \
+ "${API_BASE_URL}/videos/${FILE_ID}/stream" \
+ --output "video_chunk.mp4"
+
+# Test range request support
+curl -I -H "Range: bytes=0-1023" \
+ "${API_BASE_URL}/videos/${FILE_ID}/stream"
+```
+
+## 🔧 Programming Language Examples
+
+### Python Integration
+```python
+import requests
+import json
+from typing import List, Dict, Optional
+
+class USDAVideoClient:
+ def __init__(self, base_url: str = "http://localhost:8000"):
+ self.base_url = base_url.rstrip('/')
+ self.session = requests.Session()
+
+ def list_videos(self, camera_name: Optional[str] = None,
+ include_metadata: bool = True, limit: int = 50) -> Dict:
+ """List available videos with optional filtering."""
+ params = {
+ 'include_metadata': include_metadata,
+ 'limit': limit
+ }
+ if camera_name:
+ params['camera_name'] = camera_name
+
+ response = self.session.get(f"{self.base_url}/videos/", params=params)
+ response.raise_for_status()
+ return response.json()
+
+ def get_video_info(self, file_id: str) -> Dict:
+ """Get detailed video information."""
+ response = self.session.get(f"{self.base_url}/videos/{file_id}")
+ response.raise_for_status()
+ return response.json()
+
+ def get_thumbnail(self, file_id: str, timestamp: float = 1.0,
+ width: int = 320, height: int = 240) -> bytes:
+ """Generate and download video thumbnail."""
+ params = {
+ 'timestamp': timestamp,
+ 'width': width,
+ 'height': height
+ }
+ response = self.session.get(
+ f"{self.base_url}/videos/{file_id}/thumbnail",
+ params=params
+ )
+ response.raise_for_status()
+ return response.content
+
+ def stream_video_range(self, file_id: str, start_byte: int,
+ end_byte: int) -> bytes:
+ """Stream specific byte range of video."""
+ headers = {'Range': f'bytes={start_byte}-{end_byte}'}
+ response = self.session.get(
+ f"{self.base_url}/videos/{file_id}/stream",
+ headers=headers
+ )
+ response.raise_for_status()
+ return response.content
+
+ def validate_video(self, file_id: str) -> bool:
+ """Validate that video is accessible and playable."""
+ response = self.session.post(f"{self.base_url}/videos/{file_id}/validate")
+ response.raise_for_status()
+ return response.json().get('is_valid', False)
+
+# Usage example
+client = USDAVideoClient("http://192.168.1.100:8000")
+
+# List videos from camera1
+videos = client.list_videos(camera_name="camera1")
+print(f"Found {videos['total_count']} videos")
+
+# Select first video
+if videos['videos']:
+ video = videos['videos'][0]
+ file_id = video['file_id']
+
+ # Validate video
+ if client.validate_video(file_id):
+ print(f"✅ Video {file_id} is valid")
+
+ # Get thumbnail
+ thumbnail = client.get_thumbnail(file_id, timestamp=5.0)
+ with open(f"thumbnail_{file_id}.jpg", "wb") as f:
+ f.write(thumbnail)
+
+ # Stream first 1MB
+ chunk = client.stream_video_range(file_id, 0, 1048575)
+ print(f"Downloaded {len(chunk)} bytes")
+```
+
+### JavaScript/Node.js Integration
+```javascript
+class USDAVideoClient {
+ constructor(baseUrl = 'http://localhost:8000') {
+ this.baseUrl = baseUrl.replace(/\/$/, '');
+ }
+
+ async listVideos(options = {}) {
+ const params = new URLSearchParams({
+ include_metadata: options.includeMetadata || true,
+ limit: options.limit || 50
+ });
+
+ if (options.cameraName) {
+ params.append('camera_name', options.cameraName);
+ }
+
+ const response = await fetch(`${this.baseUrl}/videos/?${params}`);
+ if (!response.ok) throw new Error(`HTTP ${response.status}`);
+ return response.json();
+ }
+
+ async getVideoInfo(fileId) {
+ const response = await fetch(`${this.baseUrl}/videos/${fileId}`);
+ if (!response.ok) throw new Error(`HTTP ${response.status}`);
+ return response.json();
+ }
+
+ async getThumbnail(fileId, options = {}) {
+ const params = new URLSearchParams({
+ timestamp: options.timestamp || 1.0,
+ width: options.width || 320,
+ height: options.height || 240
+ });
+
+ const response = await fetch(
+ `${this.baseUrl}/videos/${fileId}/thumbnail?${params}`
+ );
+ if (!response.ok) throw new Error(`HTTP ${response.status}`);
+ return response.blob();
+ }
+
+ async validateVideo(fileId) {
+ const response = await fetch(
+ `${this.baseUrl}/videos/${fileId}/validate`,
+ { method: 'POST' }
+ );
+ if (!response.ok) throw new Error(`HTTP ${response.status}`);
+ const result = await response.json();
+ return result.is_valid;
+ }
+
+ getStreamUrl(fileId) {
+ return `${this.baseUrl}/videos/${fileId}/stream`;
+ }
+}
+
+// Usage example
+const client = new USDAVideoClient('http://192.168.1.100:8000');
+
+async function integrateWithVideos() {
+ try {
+ // List videos
+ const videos = await client.listVideos({ cameraName: 'camera1' });
+ console.log(`Found ${videos.total_count} videos`);
+
+ if (videos.videos.length > 0) {
+ const video = videos.videos[0];
+ const fileId = video.file_id;
+
+ // Validate video
+ const isValid = await client.validateVideo(fileId);
+ if (isValid) {
+ console.log(`✅ Video ${fileId} is valid`);
+
+ // Get thumbnail
+ const thumbnail = await client.getThumbnail(fileId, {
+ timestamp: 5.0,
+ width: 320,
+ height: 240
+ });
+
+ // Create video element for playback
+ const videoElement = document.createElement('video');
+ videoElement.controls = true;
+ videoElement.src = client.getStreamUrl(fileId);
+ document.body.appendChild(videoElement);
+ }
+ }
+ } catch (error) {
+ console.error('Integration error:', error);
+ }
+}
+```
+
+## 🚨 Error Handling
+
+### Common HTTP Status Codes
+```bash
+# Success responses
+200 # OK - Request successful
+206 # Partial Content - Range request successful
+
+# Client error responses
+400 # Bad Request - Invalid parameters
+404 # Not Found - Video file doesn't exist
+416 # Range Not Satisfiable - Invalid range request
+
+# Server error responses
+500 # Internal Server Error - Failed to process video
+503 # Service Unavailable - Video module not available
+```
+
+### Error Response Format
+```json
+{
+ "detail": "Video camera1_recording_20250804_143022.avi not found"
+}
+```
+
+### Robust Error Handling Example
+```python
+def safe_video_operation(client, file_id):
+ try:
+ # Validate video first
+ if not client.validate_video(file_id):
+ return {"error": "Video is not valid or accessible"}
+
+ # Get video info
+ video_info = client.get_video_info(file_id)
+
+ # Check if streamable
+ if not video_info.get('is_streamable', False):
+ return {"error": "Video is not streamable"}
+
+ return {"success": True, "video_info": video_info}
+
+ except requests.exceptions.HTTPError as e:
+ if e.response.status_code == 404:
+ return {"error": "Video not found"}
+ elif e.response.status_code == 416:
+ return {"error": "Invalid range request"}
+ else:
+ return {"error": f"HTTP error: {e.response.status_code}"}
+ except requests.exceptions.ConnectionError:
+ return {"error": "Cannot connect to video server"}
+ except Exception as e:
+ return {"error": f"Unexpected error: {str(e)}"}
+```
+
+## ✅ Integration Checklist
+
+### Pre-Integration
+- [ ] Verify network connectivity to USDA Vision Camera System
+- [ ] Test basic API endpoints (`/health`, `/system/status`)
+- [ ] Understand video file naming conventions
+- [ ] Plan error handling strategy
+
+### Video Selection
+- [ ] Implement video listing with appropriate filters
+- [ ] Add video validation before processing
+- [ ] Handle pagination for large video collections
+- [ ] Implement caching for video metadata
+
+### Video Playback
+- [ ] Test video streaming with range requests
+- [ ] Implement thumbnail generation for previews
+- [ ] Add progress tracking for video playback
+- [ ] Handle different video formats (MP4, AVI)
+
+### Error Handling
+- [ ] Handle network connectivity issues
+- [ ] Manage video not found scenarios
+- [ ] Deal with invalid range requests
+- [ ] Implement retry logic for transient failures
+
+### Performance
+- [ ] Use range requests for efficient seeking
+- [ ] Implement client-side caching where appropriate
+- [ ] Monitor bandwidth usage for video streaming
+- [ ] Consider thumbnail caching for better UX
+
+## 🎯 Next Steps
+
+1. **Test Integration**: Use the provided examples to test basic connectivity
+2. **Implement Error Handling**: Add robust error handling for production use
+3. **Optimize Performance**: Implement caching and efficient streaming
+4. **Monitor Usage**: Track API usage and performance metrics
+5. **Security Review**: Consider authentication if exposing externally
+
+This guide provides everything needed for successful integration with the USDA Vision Camera System's video streaming functionality. The system is designed to be simple and reliable for AI agents and external systems to consume video content efficiently.
diff --git a/api/docs/API_CHANGES_SUMMARY.md b/api/docs/API_CHANGES_SUMMARY.md
new file mode 100644
index 0000000..d7af414
--- /dev/null
+++ b/api/docs/API_CHANGES_SUMMARY.md
@@ -0,0 +1,207 @@
+# API Changes Summary: Camera Settings and Video Format Updates
+
+## Overview
+This document tracks major API changes including camera settings enhancements and the MP4 video format update.
+
+## 🎥 Latest Update: MP4 Video Format (v2.1)
+**Date**: August 2025
+
+**Major Changes**:
+- **Video Format**: Changed from AVI/XVID to MP4/MPEG-4 format
+- **File Extensions**: New recordings use `.mp4` instead of `.avi`
+- **File Size**: ~40% reduction in file sizes
+- **Streaming**: Better web browser compatibility
+
+**New Configuration Fields**:
+```json
+{
+ "video_format": "mp4", // File format: "mp4" or "avi"
+ "video_codec": "mp4v", // Video codec: "mp4v", "XVID", "MJPG"
+ "video_quality": 95 // Quality: 0-100 (higher = better)
+}
+```
+
+**Frontend Impact**:
+- ✅ Better streaming performance and browser support
+- ✅ Smaller file sizes for faster transfers
+- ✅ Universal HTML5 video player compatibility
+- ✅ Backward compatible with existing AVI files
+
+**Documentation**: See [MP4 Format Update Guide](MP4_FORMAT_UPDATE.md)
+
+---
+
+## Previous Changes: Camera Settings and Filename Handling
+
+Enhanced the `POST /cameras/{camera_name}/start-recording` API endpoint to accept optional camera settings (shutter speed/exposure, gain, and fps) and ensure all filenames have datetime prefixes.
+
+## Changes Made
+
+### 1. API Models (`usda_vision_system/api/models.py`)
+- **Enhanced `StartRecordingRequest`** to include optional parameters:
+ - `exposure_ms: Optional[float]` - Exposure time in milliseconds
+ - `gain: Optional[float]` - Camera gain value
+ - `fps: Optional[float]` - Target frames per second
+
+### 2. Camera Recorder (`usda_vision_system/camera/recorder.py`)
+- **Added `update_camera_settings()` method** to dynamically update camera settings:
+ - Updates exposure time using `mvsdk.CameraSetExposureTime()`
+ - Updates gain using `mvsdk.CameraSetAnalogGain()`
+ - Updates target FPS in camera configuration
+ - Logs all setting changes
+ - Returns boolean indicating success/failure
+
+### 3. Camera Manager (`usda_vision_system/camera/manager.py`)
+- **Enhanced `manual_start_recording()` method** to accept new parameters:
+ - Added optional `exposure_ms`, `gain`, and `fps` parameters
+ - Calls `update_camera_settings()` if any settings are provided
+ - **Automatic datetime prefix**: Always prepends timestamp to filename
+ - If custom filename provided: `{timestamp}_{custom_filename}`
+ - If no filename provided: `{camera_name}_manual_{timestamp}.avi`
+
+### 4. API Server (`usda_vision_system/api/server.py`)
+- **Updated start-recording endpoint** to:
+ - Pass new camera settings to camera manager
+ - Handle filename response with datetime prefix
+ - Maintain backward compatibility with existing requests
+
+### 5. API Tests (`api-tests.http`)
+- **Added comprehensive test examples**:
+ - Basic recording (existing functionality)
+ - Recording with camera settings
+ - Recording with settings only (no filename)
+ - Different parameter combinations
+
+## Usage Examples
+
+### Basic Recording (unchanged)
+```http
+POST http://localhost:8000/cameras/camera1/start-recording
+Content-Type: application/json
+
+{
+ "camera_name": "camera1",
+ "filename": "test.avi"
+}
+```
+**Result**: File saved as `20241223_143022_test.avi`
+
+### Recording with Camera Settings
+```http
+POST http://localhost:8000/cameras/camera1/start-recording
+Content-Type: application/json
+
+{
+ "camera_name": "camera1",
+ "filename": "high_quality.avi",
+ "exposure_ms": 2.0,
+ "gain": 4.0,
+ "fps": 5.0
+}
+```
+**Result**:
+- Camera settings updated before recording
+- File saved as `20241223_143022_high_quality.avi`
+
+### Maximum FPS Recording
+```http
+POST http://localhost:8000/cameras/camera1/start-recording
+Content-Type: application/json
+
+{
+ "camera_name": "camera1",
+ "filename": "max_speed.avi",
+ "exposure_ms": 0.1,
+ "gain": 1.0,
+ "fps": 0
+}
+```
+**Result**:
+- Camera captures at maximum possible speed (no delay between frames)
+- Video file saved with 30 FPS metadata for proper playback
+- Actual capture rate depends on camera hardware and exposure settings
+
+### Settings Only (no filename)
+```http
+POST http://localhost:8000/cameras/camera1/start-recording
+Content-Type: application/json
+
+{
+ "camera_name": "camera1",
+ "exposure_ms": 1.5,
+ "gain": 3.0,
+ "fps": 7.0
+}
+```
+**Result**:
+- Camera settings updated
+- File saved as `camera1_manual_20241223_143022.avi`
+
+## Key Features
+
+### 1. **Backward Compatibility**
+- All existing API calls continue to work unchanged
+- New parameters are optional
+- Default behavior preserved when no settings provided
+
+### 2. **Automatic Datetime Prefix**
+- **ALL filenames now have datetime prefix** regardless of what's sent
+- Format: `YYYYMMDD_HHMMSS_` (Atlanta timezone)
+- Ensures unique filenames and chronological ordering
+
+### 3. **Dynamic Camera Settings**
+- Settings can be changed per recording without restarting system
+- Based on proven implementation from `old tests/camera_video_recorder.py`
+- Proper error handling and logging
+
+### 4. **Maximum FPS Capture**
+- **`fps: 0`** = Capture at maximum possible speed (no delay between frames)
+- **`fps > 0`** = Capture at specified frame rate with controlled timing
+- **`fps` omitted** = Uses camera config default (usually 3.0 fps)
+- Video files saved with 30 FPS metadata when fps=0 for proper playback
+
+### 5. **Parameter Validation**
+- Uses Pydantic models for automatic validation
+- Optional parameters with proper type checking
+- Descriptive field documentation
+
+## Testing
+
+Run the test script to verify functionality:
+```bash
+# Start the system first
+python main.py
+
+# In another terminal, run tests
+python test_api_changes.py
+```
+
+The test script verifies:
+- Basic recording functionality
+- Camera settings application
+- Filename datetime prefix handling
+- API response accuracy
+
+## Implementation Notes
+
+### Camera Settings Mapping
+- **Exposure**: Converted from milliseconds to microseconds for SDK
+- **Gain**: Converted to camera units (multiplied by 100)
+- **FPS**: Stored in camera config, used by recording loop
+
+### Error Handling
+- Settings update failures are logged but don't prevent recording
+- Invalid camera names return appropriate HTTP errors
+- Camera initialization failures are handled gracefully
+
+### Filename Generation
+- Uses `format_filename_timestamp()` from timezone utilities
+- Ensures Atlanta timezone consistency
+- Handles both custom and auto-generated filenames
+
+## Similar to Old Implementation
+The camera settings functionality mirrors the proven approach in `old tests/camera_video_recorder.py`:
+- Same parameter names and ranges
+- Same SDK function calls
+- Same conversion factors
+- Proven to work with the camera hardware
diff --git a/api/docs/API_DOCUMENTATION.md b/api/docs/API_DOCUMENTATION.md
new file mode 100644
index 0000000..81ac03f
--- /dev/null
+++ b/api/docs/API_DOCUMENTATION.md
@@ -0,0 +1,824 @@
+# 🚀 USDA Vision Camera System - Complete API Documentation
+
+This document provides comprehensive documentation for all API endpoints in the USDA Vision Camera System, including recent enhancements and new features.
+
+## 📋 Table of Contents
+
+- [🔧 System Status & Health](#-system-status--health)
+- [📷 Camera Management](#-camera-management)
+- [🎥 Recording Control](#-recording-control)
+- [🤖 Auto-Recording Management](#-auto-recording-management)
+- [🎛️ Camera Configuration](#️-camera-configuration)
+- [📡 MQTT & Machine Status](#-mqtt--machine-status)
+- [💾 Storage & File Management](#-storage--file-management)
+- [🔄 Camera Recovery & Diagnostics](#-camera-recovery--diagnostics)
+- [📺 Live Streaming](#-live-streaming)
+- [🎬 Video Streaming & Playback](#-video-streaming--playback)
+- [🌐 WebSocket Real-time Updates](#-websocket-real-time-updates)
+
+## 🔧 System Status & Health
+
+### Get System Status
+```http
+GET /system/status
+```
+**Response**: `SystemStatusResponse`
+```json
+{
+ "system_started": true,
+ "mqtt_connected": true,
+ "last_mqtt_message": "2024-01-15T10:30:00Z",
+ "machines": {
+ "vibratory_conveyor": {
+ "name": "vibratory_conveyor",
+ "state": "ON",
+ "last_updated": "2024-01-15T10:30:00Z"
+ }
+ },
+ "cameras": {
+ "camera1": {
+ "name": "camera1",
+ "status": "ACTIVE",
+ "is_recording": false,
+ "auto_recording_enabled": true
+ }
+ },
+ "active_recordings": 0,
+ "total_recordings": 15,
+ "uptime_seconds": 3600.5
+}
+```
+
+### Health Check
+```http
+GET /health
+```
+**Response**: Simple health status
+```json
+{
+ "status": "healthy",
+ "timestamp": "2024-01-15T10:30:00Z"
+}
+```
+
+## 📷 Camera Management
+
+### Get All Cameras
+```http
+GET /cameras
+```
+**Response**: `Dict[str, CameraStatusResponse]`
+
+### Get Specific Camera Status
+```http
+GET /cameras/{camera_name}/status
+```
+**Response**: `CameraStatusResponse`
+```json
+{
+ "name": "camera1",
+ "status": "ACTIVE",
+ "is_recording": false,
+ "last_checked": "2024-01-15T10:30:00Z",
+ "last_error": null,
+ "device_info": {
+ "model": "GigE Camera",
+ "serial": "12345"
+ },
+ "current_recording_file": null,
+ "recording_start_time": null,
+ "auto_recording_enabled": true,
+ "auto_recording_active": false,
+ "auto_recording_failure_count": 0,
+ "auto_recording_last_attempt": null,
+ "auto_recording_last_error": null
+}
+```
+
+## 🎥 Recording Control
+
+### Start Recording
+```http
+POST /cameras/{camera_name}/start-recording
+Content-Type: application/json
+
+{
+ "filename": "test_recording.avi",
+ "exposure_ms": 2.0,
+ "gain": 4.0,
+ "fps": 5.0
+}
+```
+
+**Request Model**: `StartRecordingRequest`
+- `filename` (optional): Custom filename (datetime prefix will be added automatically)
+- `exposure_ms` (optional): Exposure time in milliseconds
+- `gain` (optional): Camera gain value
+- `fps` (optional): Target frames per second
+
+**Response**: `StartRecordingResponse`
+```json
+{
+ "success": true,
+ "message": "Recording started for camera1",
+ "filename": "20240115_103000_test_recording.avi"
+}
+```
+
+**Key Features**:
+- ✅ **Automatic datetime prefix**: All filenames get `YYYYMMDD_HHMMSS_` prefix
+- ✅ **Dynamic camera settings**: Adjust exposure, gain, and FPS per recording
+- ✅ **Backward compatibility**: All existing API calls work unchanged
+
+### Stop Recording
+```http
+POST /cameras/{camera_name}/stop-recording
+```
+**Response**: `StopRecordingResponse`
+```json
+{
+ "success": true,
+ "message": "Recording stopped for camera1",
+ "duration_seconds": 45.2
+}
+```
+
+## 🤖 Auto-Recording Management
+
+### Enable Auto-Recording for Camera
+```http
+POST /cameras/{camera_name}/auto-recording/enable
+```
+**Response**: `AutoRecordingConfigResponse`
+```json
+{
+ "success": true,
+ "message": "Auto-recording enabled for camera1",
+ "camera_name": "camera1",
+ "enabled": true
+}
+```
+
+### Disable Auto-Recording for Camera
+```http
+POST /cameras/{camera_name}/auto-recording/disable
+```
+**Response**: `AutoRecordingConfigResponse`
+
+### Get Auto-Recording Status
+```http
+GET /auto-recording/status
+```
+**Response**: `AutoRecordingStatusResponse`
+```json
+{
+ "running": true,
+ "auto_recording_enabled": true,
+ "retry_queue": {},
+ "enabled_cameras": ["camera1", "camera2"]
+}
+```
+
+**Auto-Recording Features**:
+- 🤖 **MQTT-triggered recording**: Automatically starts/stops based on machine state
+- 🔄 **Retry logic**: Failed recordings are retried with configurable delays
+- 📊 **Per-camera control**: Enable/disable auto-recording individually
+- 📈 **Status tracking**: Monitor failure counts and last attempts
+
+## 🎛️ Camera Configuration
+
+### Get Camera Configuration
+```http
+GET /cameras/{camera_name}/config
+```
+**Response**: `CameraConfigResponse`
+```json
+{
+ "name": "camera1",
+ "machine_topic": "blower_separator",
+ "storage_path": "/storage/camera1",
+ "exposure_ms": 0.3,
+ "gain": 4.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+ "contrast": 100,
+ "saturation": 100,
+ "gamma": 100,
+ "noise_filter_enabled": false,
+ "denoise_3d_enabled": false,
+ "auto_white_balance": false,
+ "color_temperature_preset": 0,
+ "wb_red_gain": 0.94,
+ "wb_green_gain": 1.0,
+ "wb_blue_gain": 0.87,
+ "anti_flicker_enabled": false,
+ "light_frequency": 0,
+ "bit_depth": 8,
+ "hdr_enabled": false,
+ "hdr_gain_mode": 2
+}
+```
+
+### Update Camera Configuration
+```http
+PUT /cameras/{camera_name}/config
+Content-Type: application/json
+
+{
+ "exposure_ms": 2.0,
+ "gain": 4.0,
+ "target_fps": 5.0,
+ "sharpness": 130
+}
+```
+
+### Apply Configuration (Restart Required)
+```http
+POST /cameras/{camera_name}/apply-config
+```
+
+**Configuration Categories**:
+- ✅ **Real-time**: `exposure_ms`, `gain`, `target_fps`, `sharpness`, `contrast`, etc.
+- ⚠️ **Restart required**: `noise_filter_enabled`, `denoise_3d_enabled`, `bit_depth`, `video_format`, `video_codec`, `video_quality`
+
+For detailed configuration options, see [Camera Configuration API Guide](api/CAMERA_CONFIG_API.md).
+
+## 📡 MQTT & Machine Status
+
+### Get All Machines
+```http
+GET /machines
+```
+**Response**: `Dict[str, MachineStatusResponse]`
+
+### Get MQTT Status
+```http
+GET /mqtt/status
+```
+**Response**: `MQTTStatusResponse`
+```json
+{
+ "connected": true,
+ "broker_host": "192.168.1.110",
+ "broker_port": 1883,
+ "subscribed_topics": ["vibratory_conveyor", "blower_separator"],
+ "last_message_time": "2024-01-15T10:30:00Z",
+ "message_count": 1250,
+ "error_count": 2,
+ "uptime_seconds": 3600.5
+}
+```
+
+### Get MQTT Events History
+```http
+GET /mqtt/events?limit=10
+```
+**Response**: `MQTTEventsHistoryResponse`
+```json
+{
+ "events": [
+ {
+ "machine_name": "vibratory_conveyor",
+ "topic": "vibratory_conveyor",
+ "payload": "ON",
+ "normalized_state": "ON",
+ "timestamp": "2024-01-15T10:30:00Z",
+ "message_number": 1250
+ }
+ ],
+ "total_events": 1250,
+ "last_updated": "2024-01-15T10:30:00Z"
+}
+```
+
+## 💾 Storage & File Management
+
+### Get Storage Statistics
+```http
+GET /storage/stats
+```
+**Response**: `StorageStatsResponse`
+```json
+{
+ "base_path": "/storage",
+ "total_files": 150,
+ "total_size_bytes": 5368709120,
+ "cameras": {
+ "camera1": {
+ "file_count": 75,
+ "total_size_bytes": 2684354560
+ },
+ "camera2": {
+ "file_count": 75,
+ "total_size_bytes": 2684354560
+ }
+ },
+ "disk_usage": {
+ "total_bytes": 107374182400,
+ "used_bytes": 53687091200,
+ "free_bytes": 53687091200,
+ "usage_percent": 50.0
+ }
+}
+```
+
+### Get File List
+```http
+POST /storage/files
+Content-Type: application/json
+
+{
+ "camera_name": "camera1",
+ "start_date": "2024-01-15",
+ "end_date": "2024-01-16",
+ "limit": 50
+}
+```
+**Response**: `FileListResponse`
+```json
+{
+ "files": [
+ {
+ "filename": "20240115_103000_test_recording.avi",
+ "camera_name": "camera1",
+ "size_bytes": 52428800,
+ "created_time": "2024-01-15T10:30:00Z",
+ "duration_seconds": 30.5
+ }
+ ],
+ "total_count": 1
+}
+```
+
+### Cleanup Old Files
+```http
+POST /storage/cleanup
+Content-Type: application/json
+
+{
+ "max_age_days": 30
+}
+```
+**Response**: `CleanupResponse`
+```json
+{
+ "files_removed": 25,
+ "bytes_freed": 1073741824,
+ "errors": []
+}
+```
+
+## 🔄 Camera Recovery & Diagnostics
+
+### Test Camera Connection
+```http
+POST /cameras/{camera_name}/test-connection
+```
+**Response**: `CameraTestResponse`
+
+### Reconnect Camera
+```http
+POST /cameras/{camera_name}/reconnect
+```
+**Response**: `CameraRecoveryResponse`
+
+### Restart Camera Grab Process
+```http
+POST /cameras/{camera_name}/restart-grab
+```
+**Response**: `CameraRecoveryResponse`
+
+### Reset Camera Timestamp
+```http
+POST /cameras/{camera_name}/reset-timestamp
+```
+**Response**: `CameraRecoveryResponse`
+
+### Full Camera Reset
+```http
+POST /cameras/{camera_name}/full-reset
+```
+**Response**: `CameraRecoveryResponse`
+
+### Reinitialize Camera
+```http
+POST /cameras/{camera_name}/reinitialize
+```
+**Response**: `CameraRecoveryResponse`
+
+**Recovery Response Example**:
+```json
+{
+ "success": true,
+ "message": "Camera camera1 reconnected successfully",
+ "camera_name": "camera1",
+ "operation": "reconnect",
+ "timestamp": "2024-01-15T10:30:00Z"
+}
+```
+
+## 📺 Live Streaming
+
+### Get Live MJPEG Stream
+```http
+GET /cameras/{camera_name}/stream
+```
+**Response**: MJPEG video stream (multipart/x-mixed-replace)
+
+### Start Camera Stream
+```http
+POST /cameras/{camera_name}/start-stream
+```
+
+### Stop Camera Stream
+```http
+POST /cameras/{camera_name}/stop-stream
+```
+
+**Streaming Features**:
+- 📺 **MJPEG format**: Compatible with web browsers and React apps
+- 🔄 **Concurrent operation**: Stream while recording simultaneously
+- ⚡ **Low latency**: Real-time preview for monitoring
+
+For detailed streaming integration, see [Streaming Guide](guides/STREAMING_GUIDE.md).
+
+## 🎬 Video Streaming & Playback
+
+The system includes a comprehensive video streaming module that provides YouTube-like video playback capabilities with HTTP range request support, thumbnail generation, and intelligent caching.
+
+### List Videos
+```http
+GET /videos/
+```
+**Query Parameters:**
+- `camera_name` (optional): Filter by camera name
+- `start_date` (optional): Filter videos created after this date (ISO format)
+- `end_date` (optional): Filter videos created before this date (ISO format)
+- `limit` (optional): Maximum number of results (default: 50, max: 1000)
+- `include_metadata` (optional): Include video metadata (default: false)
+
+**Response**: `VideoListResponse`
+```json
+{
+ "videos": [
+ {
+ "file_id": "camera1_auto_blower_separator_20250804_143022.mp4",
+ "camera_name": "camera1",
+ "filename": "camera1_auto_blower_separator_20250804_143022.mp4",
+ "file_size_bytes": 31457280,
+ "format": "mp4",
+ "status": "completed",
+ "created_at": "2025-08-04T14:30:22",
+ "start_time": "2025-08-04T14:30:22",
+ "end_time": "2025-08-04T14:32:22",
+ "machine_trigger": "blower_separator",
+ "is_streamable": true,
+ "needs_conversion": false,
+ "metadata": {
+ "duration_seconds": 120.5,
+ "width": 1920,
+ "height": 1080,
+ "fps": 30.0,
+ "codec": "mp4v",
+ "bitrate": 5000000,
+ "aspect_ratio": 1.777
+ }
+ }
+ ],
+ "total_count": 1
+}
+```
+
+### Get Video Information
+```http
+GET /videos/{file_id}
+```
+**Response**: `VideoInfoResponse` with detailed video information including metadata.
+
+### Stream Video
+```http
+GET /videos/{file_id}/stream
+```
+**Headers:**
+- `Range: bytes=0-1023` (optional): Request specific byte range for seeking
+
+**Features:**
+- ✅ **HTTP Range Requests**: Enables video seeking and progressive download
+- ✅ **Partial Content**: Returns 206 status for range requests
+- ✅ **Format Conversion**: Automatic AVI to MP4 conversion for web compatibility
+- ✅ **Intelligent Caching**: Optimized performance with byte-range caching
+- ✅ **CORS Enabled**: Ready for web browser integration
+
+**Response Headers:**
+- `Accept-Ranges: bytes`
+- `Content-Length: {size}`
+- `Content-Range: bytes {start}-{end}/{total}` (for range requests)
+- `Cache-Control: public, max-age=3600`
+
+### Get Video Thumbnail
+```http
+GET /videos/{file_id}/thumbnail?timestamp=5.0&width=320&height=240
+```
+**Query Parameters:**
+- `timestamp` (optional): Time position in seconds (default: 1.0)
+- `width` (optional): Thumbnail width in pixels (default: 320)
+- `height` (optional): Thumbnail height in pixels (default: 240)
+
+**Response**: JPEG image data with caching headers
+
+### Get Streaming Information
+```http
+GET /videos/{file_id}/info
+```
+**Response**: `StreamingInfoResponse`
+```json
+{
+ "file_id": "camera1_recording_20250804_143022.avi",
+ "file_size_bytes": 52428800,
+ "content_type": "video/mp4",
+ "supports_range_requests": true,
+ "chunk_size_bytes": 262144
+}
+```
+
+### Video Validation
+```http
+POST /videos/{file_id}/validate
+```
+**Response**: Validation status and accessibility check
+```json
+{
+ "file_id": "camera1_recording_20250804_143022.avi",
+ "is_valid": true
+}
+```
+
+### Cache Management
+```http
+POST /videos/{file_id}/cache/invalidate
+```
+**Response**: Cache invalidation status
+```json
+{
+ "file_id": "camera1_recording_20250804_143022.avi",
+ "cache_invalidated": true
+}
+```
+
+### Admin: Cache Cleanup
+```http
+POST /admin/videos/cache/cleanup?max_size_mb=100
+```
+**Response**: Cache cleanup results
+```json
+{
+ "cache_cleaned": true,
+ "entries_removed": 15,
+ "max_size_mb": 100
+}
+```
+
+**Video Streaming Features**:
+- 🎥 **Multiple Formats**: Native MP4 support with AVI conversion
+- 📱 **Web Compatible**: Direct integration with HTML5 video elements
+- ⚡ **High Performance**: Intelligent caching and adaptive chunking
+- 🖼️ **Thumbnail Generation**: Extract preview images at any timestamp
+- 🔄 **Range Requests**: Efficient seeking and progressive download
+
+## 🌐 WebSocket Real-time Updates
+
+### Connect to WebSocket
+```javascript
+const ws = new WebSocket('ws://localhost:8000/ws');
+
+ws.onmessage = (event) => {
+ const update = JSON.parse(event.data);
+ console.log('Real-time update:', update);
+};
+```
+
+**WebSocket Message Types**:
+- `system_status`: System status changes
+- `camera_status`: Camera status updates
+- `recording_started`: Recording start events
+- `recording_stopped`: Recording stop events
+- `mqtt_message`: MQTT message received
+- `auto_recording_event`: Auto-recording status changes
+
+**Example WebSocket Message**:
+```json
+{
+ "type": "recording_started",
+ "data": {
+ "camera_name": "camera1",
+ "filename": "20240115_103000_auto_recording.avi",
+ "timestamp": "2024-01-15T10:30:00Z"
+ },
+ "timestamp": "2024-01-15T10:30:00Z"
+}
+```
+
+## 🚀 Quick Start Examples
+
+### Basic System Monitoring
+```bash
+# Check system health
+curl http://localhost:8000/health
+
+# Get overall system status
+curl http://localhost:8000/system/status
+
+# Get all camera statuses
+curl http://localhost:8000/cameras
+```
+
+### Manual Recording Control
+```bash
+# Start recording with default settings
+curl -X POST http://localhost:8000/cameras/camera1/start-recording \
+ -H "Content-Type: application/json" \
+ -d '{"filename": "manual_test.avi"}'
+
+# Start recording with custom camera settings
+curl -X POST http://localhost:8000/cameras/camera1/start-recording \
+ -H "Content-Type: application/json" \
+ -d '{
+ "filename": "high_quality.avi",
+ "exposure_ms": 2.0,
+ "gain": 4.0,
+ "fps": 5.0
+ }'
+
+# Stop recording
+curl -X POST http://localhost:8000/cameras/camera1/stop-recording
+```
+
+### Auto-Recording Management
+```bash
+# Enable auto-recording for camera1
+curl -X POST http://localhost:8000/cameras/camera1/auto-recording/enable
+
+# Check auto-recording status
+curl http://localhost:8000/auto-recording/status
+
+# Disable auto-recording for camera1
+curl -X POST http://localhost:8000/cameras/camera1/auto-recording/disable
+```
+
+### Video Streaming Operations
+```bash
+# List all videos
+curl http://localhost:8000/videos/
+
+# List videos from specific camera with metadata
+curl "http://localhost:8000/videos/?camera_name=camera1&include_metadata=true"
+
+# Get video information
+curl http://localhost:8000/videos/camera1_recording_20250804_143022.avi
+
+# Get video thumbnail
+curl "http://localhost:8000/videos/camera1_recording_20250804_143022.avi/thumbnail?timestamp=5.0&width=320&height=240" \
+ --output thumbnail.jpg
+
+# Get streaming info
+curl http://localhost:8000/videos/camera1_recording_20250804_143022.avi/info
+
+# Stream video with range request
+curl -H "Range: bytes=0-1023" \
+ http://localhost:8000/videos/camera1_recording_20250804_143022.avi/stream
+
+# Validate video file
+curl -X POST http://localhost:8000/videos/camera1_recording_20250804_143022.avi/validate
+
+# Clean up video cache (admin)
+curl -X POST "http://localhost:8000/admin/videos/cache/cleanup?max_size_mb=100"
+```
+
+### Camera Configuration
+```bash
+# Get current camera configuration
+curl http://localhost:8000/cameras/camera1/config
+
+# Update camera settings (real-time)
+curl -X PUT http://localhost:8000/cameras/camera1/config \
+ -H "Content-Type: application/json" \
+ -d '{
+ "exposure_ms": 1.5,
+ "gain": 3.0,
+ "sharpness": 130,
+ "contrast": 120
+ }'
+```
+
+## 📈 Recent API Changes & Enhancements
+
+### ✨ New in Latest Version
+
+#### 1. Enhanced Recording API
+- **Dynamic camera settings**: Set exposure, gain, and FPS per recording
+- **Automatic datetime prefixes**: All filenames get timestamp prefixes
+- **Backward compatibility**: Existing API calls work unchanged
+
+#### 2. Auto-Recording Feature
+- **Per-camera control**: Enable/disable auto-recording individually
+- **MQTT integration**: Automatic recording based on machine states
+- **Retry logic**: Failed recordings are automatically retried
+- **Status tracking**: Monitor auto-recording attempts and failures
+
+#### 3. Advanced Camera Configuration
+- **Real-time settings**: Update exposure, gain, image quality without restart
+- **Image enhancement**: Sharpness, contrast, saturation, gamma controls
+- **Noise reduction**: Configurable noise filtering and 3D denoising
+- **HDR support**: High Dynamic Range imaging capabilities
+
+#### 4. Live Streaming
+- **MJPEG streaming**: Real-time camera preview
+- **Concurrent operation**: Stream while recording simultaneously
+- **Web-compatible**: Direct integration with React/HTML video elements
+
+#### 5. Enhanced Monitoring
+- **MQTT event history**: Track machine state changes over time
+- **Storage statistics**: Monitor disk usage and file counts
+- **WebSocket updates**: Real-time system status notifications
+
+#### 6. Video Streaming Module
+- **HTTP Range Requests**: Efficient video seeking and progressive download
+- **Thumbnail Generation**: Extract preview images from videos at any timestamp
+- **Format Conversion**: Automatic AVI to MP4 conversion for web compatibility
+- **Intelligent Caching**: Byte-range caching for optimal streaming performance
+- **Admin Tools**: Cache management and video validation endpoints
+
+### 🔄 Migration Notes
+
+#### From Previous Versions
+1. **Recording API**: All existing calls work, but now return filenames with datetime prefixes
+2. **Configuration**: New camera settings are optional and backward compatible
+3. **Auto-recording**: New feature, requires enabling in `config.json` and per camera
+
+#### Configuration Updates
+```json
+{
+ "cameras": [
+ {
+ "name": "camera1",
+ "auto_start_recording_enabled": true, // NEW: Enable auto-recording
+ "sharpness": 120, // NEW: Image quality settings
+ "contrast": 110,
+ "saturation": 100,
+ "gamma": 100,
+ "noise_filter_enabled": true,
+ "hdr_enabled": false
+ }
+ ],
+ "system": {
+ "auto_recording_enabled": true // NEW: Global auto-recording toggle
+ }
+}
+```
+
+## 🔗 Related Documentation
+
+- [📷 Camera Configuration API Guide](api/CAMERA_CONFIG_API.md) - Detailed camera settings
+- [🤖 Auto-Recording Feature Guide](features/AUTO_RECORDING_FEATURE_GUIDE.md) - React integration
+- [📺 Streaming Guide](guides/STREAMING_GUIDE.md) - Live video streaming
+- [🎬 Video Streaming Guide](VIDEO_STREAMING.md) - Video playback and streaming
+- [🤖 AI Agent Video Integration Guide](AI_AGENT_VIDEO_INTEGRATION_GUIDE.md) - Complete integration guide for AI agents
+- [🔧 Camera Recovery Guide](guides/CAMERA_RECOVERY_GUIDE.md) - Troubleshooting
+- [📡 MQTT Logging Guide](guides/MQTT_LOGGING_GUIDE.md) - MQTT configuration
+
+## 📞 Support & Integration
+
+### API Base URL
+- **Development**: `http://localhost:8000`
+- **Production**: Configure in `config.json` under `system.api_host` and `system.api_port`
+
+### Error Handling
+All endpoints return standard HTTP status codes:
+- `200`: Success
+- `206`: Partial Content (for video range requests)
+- `400`: Bad Request (invalid parameters)
+- `404`: Resource not found (camera, file, video, etc.)
+- `416`: Range Not Satisfiable (invalid video range request)
+- `500`: Internal server error
+- `503`: Service unavailable (camera manager, MQTT, etc.)
+
+**Video Streaming Specific Errors:**
+- `404`: Video file not found or not streamable
+- `416`: Invalid range request (malformed Range header)
+- `500`: Failed to read video data or generate thumbnail
+
+### Rate Limiting
+- No rate limiting currently implemented
+- WebSocket connections are limited to reasonable concurrent connections
+
+### CORS Support
+- CORS is enabled for web dashboard integration
+- Configure allowed origins in the API server settings
+```
+```
diff --git a/api/docs/API_QUICK_REFERENCE.md b/api/docs/API_QUICK_REFERENCE.md
new file mode 100644
index 0000000..1ec7a54
--- /dev/null
+++ b/api/docs/API_QUICK_REFERENCE.md
@@ -0,0 +1,195 @@
+# 🚀 USDA Vision Camera System - API Quick Reference
+
+Quick reference for the most commonly used API endpoints. For complete documentation, see [API_DOCUMENTATION.md](API_DOCUMENTATION.md).
+
+## 🔧 System Status
+
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# System overview
+curl http://localhost:8000/system/status
+
+# All cameras
+curl http://localhost:8000/cameras
+
+# All machines
+curl http://localhost:8000/machines
+```
+
+## 🎥 Recording Control
+
+### Start Recording (Basic)
+```bash
+curl -X POST http://localhost:8000/cameras/camera1/start-recording \
+ -H "Content-Type: application/json" \
+ -d '{"filename": "test.avi"}'
+```
+
+### Start Recording (With Settings)
+```bash
+curl -X POST http://localhost:8000/cameras/camera1/start-recording \
+ -H "Content-Type: application/json" \
+ -d '{
+ "filename": "high_quality.avi",
+ "exposure_ms": 2.0,
+ "gain": 4.0,
+ "fps": 5.0
+ }'
+```
+
+### Stop Recording
+```bash
+curl -X POST http://localhost:8000/cameras/camera1/stop-recording
+```
+
+## 🤖 Auto-Recording
+
+```bash
+# Enable auto-recording
+curl -X POST http://localhost:8000/cameras/camera1/auto-recording/enable
+
+# Disable auto-recording
+curl -X POST http://localhost:8000/cameras/camera1/auto-recording/disable
+
+# Check auto-recording status
+curl http://localhost:8000/auto-recording/status
+```
+
+## 🎛️ Camera Configuration
+
+```bash
+# Get camera config
+curl http://localhost:8000/cameras/camera1/config
+
+# Update camera settings
+curl -X PUT http://localhost:8000/cameras/camera1/config \
+ -H "Content-Type: application/json" \
+ -d '{
+ "exposure_ms": 1.5,
+ "gain": 3.0,
+ "sharpness": 130
+ }'
+```
+
+## 📺 Live Streaming
+
+```bash
+# Start streaming
+curl -X POST http://localhost:8000/cameras/camera1/start-stream
+
+# Get MJPEG stream (use in browser/video element)
+# http://localhost:8000/cameras/camera1/stream
+
+# Stop streaming
+curl -X POST http://localhost:8000/cameras/camera1/stop-stream
+```
+
+## 🔄 Camera Recovery
+
+```bash
+# Test connection
+curl -X POST http://localhost:8000/cameras/camera1/test-connection
+
+# Reconnect camera
+curl -X POST http://localhost:8000/cameras/camera1/reconnect
+
+# Full reset
+curl -X POST http://localhost:8000/cameras/camera1/full-reset
+```
+
+## 💾 Storage Management
+
+```bash
+# Storage statistics
+curl http://localhost:8000/storage/stats
+
+# List files
+curl -X POST http://localhost:8000/storage/files \
+ -H "Content-Type: application/json" \
+ -d '{"camera_name": "camera1", "limit": 10}'
+
+# Cleanup old files
+curl -X POST http://localhost:8000/storage/cleanup \
+ -H "Content-Type: application/json" \
+ -d '{"max_age_days": 30}'
+```
+
+## 📡 MQTT Monitoring
+
+```bash
+# MQTT status
+curl http://localhost:8000/mqtt/status
+
+# Recent MQTT events
+curl http://localhost:8000/mqtt/events?limit=10
+```
+
+## 🌐 WebSocket Connection
+
+```javascript
+// Connect to real-time updates
+const ws = new WebSocket('ws://localhost:8000/ws');
+
+ws.onmessage = (event) => {
+ const update = JSON.parse(event.data);
+ console.log('Update:', update);
+};
+```
+
+## 📊 Response Examples
+
+### System Status Response
+```json
+{
+ "system_started": true,
+ "mqtt_connected": true,
+ "cameras": {
+ "camera1": {
+ "name": "camera1",
+ "status": "ACTIVE",
+ "is_recording": false,
+ "auto_recording_enabled": true
+ }
+ },
+ "active_recordings": 0,
+ "total_recordings": 15
+}
+```
+
+### Recording Start Response
+```json
+{
+ "success": true,
+ "message": "Recording started for camera1",
+ "filename": "20240115_103000_test.avi"
+}
+```
+
+### Camera Status Response
+```json
+{
+ "name": "camera1",
+ "status": "ACTIVE",
+ "is_recording": false,
+ "auto_recording_enabled": true,
+ "auto_recording_active": false,
+ "auto_recording_failure_count": 0
+}
+```
+
+## 🔗 Related Documentation
+
+- [📚 Complete API Documentation](API_DOCUMENTATION.md)
+- [🎛️ Camera Configuration Guide](api/CAMERA_CONFIG_API.md)
+- [🤖 Auto-Recording Feature Guide](features/AUTO_RECORDING_FEATURE_GUIDE.md)
+- [📺 Streaming Guide](guides/STREAMING_GUIDE.md)
+
+## 💡 Tips
+
+- All filenames automatically get datetime prefixes: `YYYYMMDD_HHMMSS_`
+- Camera settings can be updated in real-time during recording
+- Auto-recording is controlled per camera and globally
+- WebSocket provides real-time updates for dashboard integration
+- CORS is enabled for web application integration
diff --git a/api/docs/CURRENT_CONFIGURATION.md b/api/docs/CURRENT_CONFIGURATION.md
new file mode 100644
index 0000000..905c657
--- /dev/null
+++ b/api/docs/CURRENT_CONFIGURATION.md
@@ -0,0 +1,217 @@
+# 📋 Current System Configuration Reference
+
+## Overview
+This document shows the exact current configuration structure of the USDA Vision Camera System, including all fields and their current values.
+
+## 🔧 Complete Configuration Structure
+
+### System Configuration (`config.json`)
+
+```json
+{
+ "mqtt": {
+ "broker_host": "192.168.1.110",
+ "broker_port": 1883,
+ "username": null,
+ "password": null,
+ "topics": {
+ "vibratory_conveyor": "vision/vibratory_conveyor/state",
+ "blower_separator": "vision/blower_separator/state"
+ }
+ },
+ "storage": {
+ "base_path": "/storage",
+ "max_file_size_mb": 1000,
+ "max_recording_duration_minutes": 60,
+ "cleanup_older_than_days": 30
+ },
+ "system": {
+ "camera_check_interval_seconds": 2,
+ "log_level": "DEBUG",
+ "log_file": "usda_vision_system.log",
+ "api_host": "0.0.0.0",
+ "api_port": 8000,
+ "enable_api": true,
+ "timezone": "America/New_York",
+ "auto_recording_enabled": true
+ },
+ "cameras": [
+ {
+ "name": "camera1",
+ "machine_topic": "blower_separator",
+ "storage_path": "/storage/camera1",
+ "exposure_ms": 0.3,
+ "gain": 4.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+ "sharpness": 0,
+ "contrast": 100,
+ "saturation": 100,
+ "gamma": 100,
+ "noise_filter_enabled": false,
+ "denoise_3d_enabled": false,
+ "auto_white_balance": false,
+ "color_temperature_preset": 0,
+ "wb_red_gain": 0.94,
+ "wb_green_gain": 1.0,
+ "wb_blue_gain": 0.87,
+ "anti_flicker_enabled": false,
+ "light_frequency": 0,
+ "bit_depth": 8,
+ "hdr_enabled": false,
+ "hdr_gain_mode": 2
+ },
+ {
+ "name": "camera2",
+ "machine_topic": "vibratory_conveyor",
+ "storage_path": "/storage/camera2",
+ "exposure_ms": 0.2,
+ "gain": 2.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+ "sharpness": 0,
+ "contrast": 100,
+ "saturation": 100,
+ "gamma": 100,
+ "noise_filter_enabled": false,
+ "denoise_3d_enabled": false,
+ "auto_white_balance": false,
+ "color_temperature_preset": 0,
+ "wb_red_gain": 1.01,
+ "wb_green_gain": 1.0,
+ "wb_blue_gain": 0.87,
+ "anti_flicker_enabled": false,
+ "light_frequency": 0,
+ "bit_depth": 8,
+ "hdr_enabled": false,
+ "hdr_gain_mode": 0
+ }
+ ]
+}
+```
+
+## 📊 Configuration Field Reference
+
+### MQTT Settings
+| Field | Value | Description |
+|-------|-------|-------------|
+| `broker_host` | `"192.168.1.110"` | MQTT broker IP address |
+| `broker_port` | `1883` | MQTT broker port |
+| `username` | `null` | MQTT authentication (not used) |
+| `password` | `null` | MQTT authentication (not used) |
+
+### MQTT Topics
+| Machine | Topic | Camera |
+|---------|-------|--------|
+| Vibratory Conveyor | `vision/vibratory_conveyor/state` | camera2 |
+| Blower Separator | `vision/blower_separator/state` | camera1 |
+
+### Storage Settings
+| Field | Value | Description |
+|-------|-------|-------------|
+| `base_path` | `"/storage"` | Root storage directory |
+| `max_file_size_mb` | `1000` | Maximum file size (1GB) |
+| `max_recording_duration_minutes` | `60` | Maximum recording duration |
+| `cleanup_older_than_days` | `30` | Auto-cleanup threshold |
+
+### System Settings
+| Field | Value | Description |
+|-------|-------|-------------|
+| `camera_check_interval_seconds` | `2` | Camera health check interval |
+| `log_level` | `"DEBUG"` | Logging verbosity |
+| `api_host` | `"0.0.0.0"` | API server bind address |
+| `api_port` | `8000` | API server port |
+| `timezone` | `"America/New_York"` | System timezone |
+| `auto_recording_enabled` | `true` | Enable MQTT-triggered recording |
+
+## 🎥 Camera Configuration Details
+
+### Camera 1 (Blower Separator)
+| Setting | Value | Description |
+|---------|-------|-------------|
+| **Basic Settings** | | |
+| `name` | `"camera1"` | Camera identifier |
+| `machine_topic` | `"blower_separator"` | MQTT topic to monitor |
+| `storage_path` | `"/storage/camera1"` | Video storage location |
+| `exposure_ms` | `0.3` | Exposure time (milliseconds) |
+| `gain` | `4.0` | Camera gain multiplier |
+| `target_fps` | `0` | Target FPS (0 = unlimited) |
+| **Video Recording** | | |
+| `video_format` | `"mp4"` | Video file format |
+| `video_codec` | `"mp4v"` | Video codec (MPEG-4) |
+| `video_quality` | `95` | Video quality (0-100) |
+| **Auto Recording** | | |
+| `auto_start_recording_enabled` | `true` | Enable auto-recording |
+| `auto_recording_max_retries` | `3` | Max retry attempts |
+| `auto_recording_retry_delay_seconds` | `2` | Delay between retries |
+| **Image Quality** | | |
+| `sharpness` | `0` | Sharpness adjustment |
+| `contrast` | `100` | Contrast level |
+| `saturation` | `100` | Color saturation |
+| `gamma` | `100` | Gamma correction |
+| **White Balance** | | |
+| `auto_white_balance` | `false` | Auto white balance disabled |
+| `wb_red_gain` | `0.94` | Red channel gain |
+| `wb_green_gain` | `1.0` | Green channel gain |
+| `wb_blue_gain` | `0.87` | Blue channel gain |
+| **Advanced** | | |
+| `bit_depth` | `8` | Color bit depth |
+| `hdr_enabled` | `false` | HDR disabled |
+| `hdr_gain_mode` | `2` | HDR gain mode |
+
+### Camera 2 (Vibratory Conveyor)
+| Setting | Value | Difference from Camera 1 |
+|---------|-------|--------------------------|
+| `name` | `"camera2"` | Different identifier |
+| `machine_topic` | `"vibratory_conveyor"` | Different MQTT topic |
+| `storage_path` | `"/storage/camera2"` | Different storage path |
+| `exposure_ms` | `0.2` | Faster exposure (0.2 vs 0.3) |
+| `gain` | `2.0` | Lower gain (2.0 vs 4.0) |
+| `wb_red_gain` | `1.01` | Different red balance (1.01 vs 0.94) |
+| `hdr_gain_mode` | `0` | Different HDR mode (0 vs 2) |
+
+*All other settings are identical to Camera 1*
+
+## 🔄 Recent Changes
+
+### MP4 Format Update
+- **Added**: `video_format`, `video_codec`, `video_quality` fields
+- **Changed**: Default recording format from AVI to MP4
+- **Impact**: Requires service restart to take effect
+
+### Current Status
+- ✅ Configuration updated with MP4 settings
+- ⚠️ Service restart required to apply changes
+- 📁 Existing AVI files remain accessible
+
+## 📝 Notes
+
+1. **Target FPS = 0**: Both cameras use unlimited frame rate for maximum capture speed
+2. **Auto Recording**: Both cameras automatically start recording when their respective machines turn on
+3. **White Balance**: Manual white balance settings optimized for each camera's environment
+4. **Storage**: Each camera has its own dedicated storage directory
+5. **Video Quality**: Set to 95/100 for high-quality recordings with MP4 compression benefits
+
+## 🔧 Configuration Management
+
+To modify these settings:
+1. Edit `config.json` file
+2. Restart the camera service: `sudo ./start_system.sh`
+3. Verify changes via API: `GET /cameras/{camera_name}/config`
+
+For real-time settings (exposure, gain, fps), use the API without restart:
+```bash
+PUT /cameras/{camera_name}/config
+```
diff --git a/api/docs/MP4_FORMAT_UPDATE.md b/api/docs/MP4_FORMAT_UPDATE.md
new file mode 100644
index 0000000..ecae663
--- /dev/null
+++ b/api/docs/MP4_FORMAT_UPDATE.md
@@ -0,0 +1,211 @@
+# 🎥 MP4 Video Format Update - Frontend Integration Guide
+
+## Overview
+The USDA Vision Camera System has been updated to record videos in **MP4 format** instead of AVI format for better streaming compatibility and smaller file sizes.
+
+## 🔄 What Changed
+
+### Video Format
+- **Before**: AVI files with XVID codec (`.avi` extension)
+- **After**: MP4 files with MPEG-4 codec (`.mp4` extension)
+
+### File Extensions
+- All new video recordings now use `.mp4` extension
+- Existing `.avi` files remain accessible and functional
+- File size reduction: ~40% smaller than equivalent AVI files
+
+### API Response Updates
+New fields added to camera configuration responses:
+
+```json
+{
+ "video_format": "mp4", // File format: "mp4" or "avi"
+ "video_codec": "mp4v", // Video codec: "mp4v", "XVID", "MJPG"
+ "video_quality": 95 // Quality: 0-100 (higher = better)
+}
+```
+
+## 🌐 Frontend Impact
+
+### 1. Video Player Compatibility
+**✅ Better Browser Support**
+- MP4 format has native support in all modern browsers
+- No need for additional codecs or plugins
+- Better mobile device compatibility (iOS/Android)
+
+### 2. File Handling Updates
+**File Extension Handling**
+```javascript
+// Update file extension checks
+const isVideoFile = (filename) => {
+ return filename.endsWith('.mp4') || filename.endsWith('.avi');
+};
+
+// Video MIME type detection
+const getVideoMimeType = (filename) => {
+ if (filename.endsWith('.mp4')) return 'video/mp4';
+ if (filename.endsWith('.avi')) return 'video/x-msvideo';
+ return 'video/mp4'; // default
+};
+```
+
+### 3. Video Streaming
+**Improved Streaming Performance**
+```javascript
+// MP4 files can be streamed directly without conversion
+const videoUrl = `/api/videos/${videoId}/stream`;
+
+// For HTML5 video element
+
+```
+
+### 4. File Size Display
+**Updated Size Expectations**
+- MP4 files are ~40% smaller than equivalent AVI files
+- Update any file size warnings or storage calculations
+- Better compression means faster downloads and uploads
+
+## 📡 API Changes
+
+### Camera Configuration Endpoint
+**GET** `/cameras/{camera_name}/config`
+
+**New Response Fields:**
+```json
+{
+ "name": "camera1",
+ "machine_topic": "blower_separator",
+ "storage_path": "/storage/camera1",
+ "exposure_ms": 0.3,
+ "gain": 4.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+
+ // ... other existing fields
+}
+```
+
+### Video Listing Endpoints
+**File Extension Updates**
+- Video files in responses will now have `.mp4` extensions
+- Existing `.avi` files will still appear in listings
+- Filter by both extensions when needed
+
+## 🔧 Configuration Options
+
+### Video Format Settings
+```json
+{
+ "video_format": "mp4", // Options: "mp4", "avi"
+ "video_codec": "mp4v", // Options: "mp4v", "XVID", "MJPG"
+ "video_quality": 95 // Range: 0-100 (higher = better quality)
+}
+```
+
+### Recommended Settings
+- **Production**: `"mp4"` format, `"mp4v"` codec, `95` quality
+- **Storage Optimized**: `"mp4"` format, `"mp4v"` codec, `85` quality
+- **Legacy Mode**: `"avi"` format, `"XVID"` codec, `95` quality
+
+## 🎯 Frontend Implementation Checklist
+
+### ✅ Video Player Updates
+- [ ] Verify HTML5 video player works with MP4 files
+- [ ] Update video MIME type handling
+- [ ] Test streaming performance with new format
+
+### ✅ File Management
+- [ ] Update file extension filters to include `.mp4`
+- [ ] Modify file type detection logic
+- [ ] Update download/upload handling for MP4 files
+
+### ✅ UI/UX Updates
+- [ ] Update file size expectations in UI
+- [ ] Modify any format-specific icons or indicators
+- [ ] Update help text or tooltips mentioning video formats
+
+### ✅ Configuration Interface
+- [ ] Add video format settings to camera config UI
+- [ ] Include video quality slider/selector
+- [ ] Add restart warning for video format changes
+
+### ✅ Testing
+- [ ] Test video playback with new MP4 files
+- [ ] Verify backward compatibility with existing AVI files
+- [ ] Test streaming performance and loading times
+
+## 🔄 Backward Compatibility
+
+### Existing AVI Files
+- All existing `.avi` files remain fully functional
+- No conversion or migration required
+- Video player should handle both formats
+
+### API Compatibility
+- All existing API endpoints continue to work
+- New fields are additive (won't break existing code)
+- Default values provided for new configuration fields
+
+## 📊 Performance Benefits
+
+### File Size Reduction
+```
+Example 5-minute recording at 1280x1024:
+- AVI/XVID: ~180 MB
+- MP4/MPEG-4: ~108 MB (40% reduction)
+```
+
+### Streaming Improvements
+- Faster initial load times
+- Better progressive download support
+- Reduced bandwidth usage
+- Native browser optimization
+
+### Storage Efficiency
+- More recordings fit in same storage space
+- Faster backup and transfer operations
+- Reduced storage costs over time
+
+## 🚨 Important Notes
+
+### Restart Required
+- Video format changes require camera service restart
+- Mark video format settings as "restart required" in UI
+- Provide clear user feedback about restart necessity
+
+### Browser Compatibility
+- MP4 format supported in all modern browsers
+- Better mobile device support than AVI
+- No additional plugins or codecs needed
+
+### Quality Assurance
+- Video quality maintained at 95/100 setting
+- No visual degradation compared to AVI
+- High bitrate ensures professional quality
+
+## 🔗 Related Documentation
+
+- [API Documentation](API_DOCUMENTATION.md) - Complete API reference
+- [Camera Configuration API](api/CAMERA_CONFIG_API.md) - Detailed config options
+- [Video Streaming Guide](VIDEO_STREAMING.md) - Streaming implementation
+- [MP4 Conversion Summary](../MP4_CONVERSION_SUMMARY.md) - Technical details
+
+## 📞 Support
+
+If you encounter any issues with the MP4 format update:
+
+1. **Video Playback Issues**: Check browser console for codec errors
+2. **File Size Concerns**: Verify quality settings in camera config
+3. **Streaming Problems**: Test with both MP4 and AVI files for comparison
+4. **API Integration**: Refer to updated API documentation
+
+The MP4 format provides better web compatibility and performance while maintaining the same high video quality required for the USDA vision system.
diff --git a/api/docs/PROJECT_COMPLETE.md b/api/docs/PROJECT_COMPLETE.md
new file mode 100644
index 0000000..0f4df48
--- /dev/null
+++ b/api/docs/PROJECT_COMPLETE.md
@@ -0,0 +1,212 @@
+# 🎉 USDA Vision Camera System - PROJECT COMPLETE!
+
+## ✅ Final Status: READY FOR PRODUCTION
+
+The USDA Vision Camera System has been successfully implemented, tested, and documented. All requirements have been met and the system is production-ready.
+
+## 📋 Completed Requirements
+
+### ✅ Core Functionality
+- **MQTT Integration**: Dual topic listening for machine states
+- **Automatic Recording**: Camera recording triggered by machine on/off states
+- **GigE Camera Support**: Full integration with camera SDK library
+- **Multi-threading**: Concurrent MQTT + camera monitoring + recording
+- **File Management**: Timestamp-based naming in organized directories
+
+### ✅ Advanced Features
+- **REST API**: Complete FastAPI server with all endpoints
+- **WebSocket Support**: Real-time updates for dashboard integration
+- **Time Synchronization**: Atlanta, Georgia timezone with NTP sync
+- **Storage Management**: File indexing, cleanup, and statistics
+- **Comprehensive Logging**: Rotating logs with error tracking
+- **Configuration System**: JSON-based configuration management
+
+### ✅ Documentation & Testing
+- **Complete README**: Installation, usage, API docs, troubleshooting
+- **Test Suite**: Comprehensive system testing (`test_system.py`)
+- **Time Verification**: Timezone and sync testing (`check_time.py`)
+- **Startup Scripts**: Easy deployment with `start_system.sh`
+- **Clean Repository**: Organized structure with proper .gitignore
+
+## 🏗️ Final Project Structure
+
+```
+USDA-Vision-Cameras/
+├── README.md # Complete documentation
+├── main.py # System entry point
+├── config.json # System configuration
+├── requirements.txt # Python dependencies
+├── pyproject.toml # UV package configuration
+├── .gitignore # Git ignore rules
+├── start_system.sh # Startup script
+├── setup_timezone.sh # Time sync setup
+├── test_system.py # System test suite
+├── check_time.py # Time verification
+├── test_timezone.py # Timezone testing
+├── usda_vision_system/ # Main application
+│ ├── core/ # Core functionality
+│ ├── mqtt/ # MQTT integration
+│ ├── camera/ # Camera management
+│ ├── storage/ # File management
+│ ├── api/ # REST API server
+│ └── main.py # Application coordinator
+├── camera_sdk/ # GigE camera SDK library
+├── demos/ # Demo and example code
+│ ├── cv_grab*.py # Camera SDK usage examples
+│ └── mqtt_*.py # MQTT demo scripts
+├── storage/ # Recording storage
+│ ├── camera1/ # Camera 1 recordings
+│ └── camera2/ # Camera 2 recordings
+├── tests/ # Test files and legacy tests
+├── notebooks/ # Jupyter notebooks
+└── docs/ # Documentation files
+```
+
+## 🚀 How to Deploy
+
+### 1. Clone and Setup
+```bash
+git clone https://github.com/your-username/USDA-Vision-Cameras.git
+cd USDA-Vision-Cameras
+uv sync
+```
+
+### 2. Configure System
+```bash
+# Edit config.json for your environment
+# Set MQTT broker, camera settings, storage paths
+```
+
+### 3. Setup Time Sync
+```bash
+./setup_timezone.sh
+```
+
+### 4. Test System
+```bash
+python test_system.py
+```
+
+### 5. Start System
+```bash
+./start_system.sh
+```
+
+## 🌐 API Integration
+
+### Dashboard Integration
+```javascript
+// React component example
+const systemStatus = await fetch('http://localhost:8000/system/status');
+const cameras = await fetch('http://localhost:8000/cameras');
+
+// WebSocket for real-time updates
+const ws = new WebSocket('ws://localhost:8000/ws');
+ws.onmessage = (event) => {
+ const update = JSON.parse(event.data);
+ // Handle real-time system updates
+};
+```
+
+### Manual Control
+```bash
+# Start recording manually
+curl -X POST http://localhost:8000/cameras/camera1/start-recording
+
+# Stop recording manually
+curl -X POST http://localhost:8000/cameras/camera1/stop-recording
+
+# Get system status
+curl http://localhost:8000/system/status
+```
+
+## 📊 System Capabilities
+
+### Discovered Hardware
+- **2 GigE Cameras**: Blower-Yield-Cam, Cracker-Cam
+- **Network Ready**: Cameras accessible at 192.168.1.165, 192.168.1.167
+- **MQTT Ready**: Configured for broker at 192.168.1.110
+
+### Recording Features
+- **Automatic Start/Stop**: Based on MQTT machine states
+- **Timezone Aware**: Atlanta time timestamps (EST/EDT)
+- **Organized Storage**: Separate directories per camera
+- **File Naming**: `camera1_recording_20250725_213000.avi`
+- **Manual Control**: API endpoints for manual recording
+
+### Monitoring Features
+- **Real-time Status**: Camera and machine state monitoring
+- **Health Checks**: Automatic system health verification
+- **Performance Tracking**: Recording metrics and system stats
+- **Error Handling**: Comprehensive error tracking and recovery
+
+## 🔧 Maintenance
+
+### Regular Tasks
+- **Log Monitoring**: Check `usda_vision_system.log`
+- **Storage Cleanup**: Automatic cleanup of old recordings
+- **Time Sync**: Automatic NTP synchronization
+- **Health Checks**: Built-in system monitoring
+
+### Troubleshooting
+- **Test Suite**: `python test_system.py`
+- **Time Check**: `python check_time.py`
+- **API Health**: `curl http://localhost:8000/health`
+- **Debug Mode**: `python main.py --log-level DEBUG`
+
+## 🎯 Production Readiness
+
+### ✅ All Tests Passing
+- System initialization: ✅
+- Camera discovery: ✅ (2 cameras found)
+- MQTT configuration: ✅
+- Storage setup: ✅
+- Time synchronization: ✅
+- API endpoints: ✅
+
+### ✅ Documentation Complete
+- Installation guide: ✅
+- Configuration reference: ✅
+- API documentation: ✅
+- Troubleshooting guide: ✅
+- Integration examples: ✅
+
+### ✅ Production Features
+- Error handling: ✅
+- Logging system: ✅
+- Time synchronization: ✅
+- Storage management: ✅
+- API security: ✅
+- Performance monitoring: ✅
+
+## 🚀 Next Steps
+
+The system is now ready for:
+
+1. **Production Deployment**: Deploy on target hardware
+2. **Dashboard Integration**: Connect to React + Supabase dashboard
+3. **MQTT Configuration**: Connect to production MQTT broker
+4. **Camera Calibration**: Fine-tune camera settings for production
+5. **Monitoring Setup**: Configure production monitoring and alerts
+
+## 📞 Support
+
+For ongoing support:
+- **Documentation**: Complete README.md with troubleshooting
+- **Test Suite**: Comprehensive diagnostic tools
+- **Logging**: Detailed system logs for debugging
+- **API Health**: Built-in health check endpoints
+
+---
+
+**🎊 PROJECT STATUS: COMPLETE AND PRODUCTION-READY! 🎊**
+
+The USDA Vision Camera System is fully implemented, tested, and documented. All original requirements have been met, and the system is ready for production deployment with your React dashboard integration.
+
+**Key Achievements:**
+- ✅ Dual MQTT topic monitoring
+- ✅ Automatic camera recording
+- ✅ Atlanta timezone synchronization
+- ✅ Complete REST API
+- ✅ Comprehensive documentation
+- ✅ Production-ready deployment
diff --git a/api/docs/REACT_INTEGRATION_GUIDE.md b/api/docs/REACT_INTEGRATION_GUIDE.md
new file mode 100644
index 0000000..29170f9
--- /dev/null
+++ b/api/docs/REACT_INTEGRATION_GUIDE.md
@@ -0,0 +1,276 @@
+# 🚀 React Frontend Integration Guide - MP4 Update
+
+## 🎯 Quick Summary for React Team
+
+The camera system now records in **MP4 format** instead of AVI. This provides better web compatibility and smaller file sizes.
+
+## 🔄 What You Need to Update
+
+### 1. File Extension Handling
+```javascript
+// OLD: Only checked for .avi
+const isVideoFile = (filename) => filename.endsWith('.avi');
+
+// NEW: Check for both formats
+const isVideoFile = (filename) => {
+ return filename.endsWith('.mp4') || filename.endsWith('.avi');
+};
+
+// Video MIME types
+const getVideoMimeType = (filename) => {
+ if (filename.endsWith('.mp4')) return 'video/mp4';
+ if (filename.endsWith('.avi')) return 'video/x-msvideo';
+ return 'video/mp4'; // default for new files
+};
+```
+
+### 2. Video Player Component
+```jsx
+// MP4 files work better with HTML5 video
+const VideoPlayer = ({ videoUrl, filename }) => {
+ const mimeType = getVideoMimeType(filename);
+
+ return (
+
+ );
+};
+```
+
+### 3. Camera Configuration Interface
+Add these new fields to your camera config forms:
+
+```jsx
+const CameraConfigForm = () => {
+ const [config, setConfig] = useState({
+ // ... existing fields
+ video_format: 'mp4', // 'mp4' or 'avi'
+ video_codec: 'mp4v', // 'mp4v', 'XVID', 'MJPG'
+ video_quality: 95 // 0-100
+ });
+
+ return (
+
+ );
+};
+```
+
+## 📡 API Response Changes
+
+### Camera Configuration Response
+```json
+{
+ "name": "camera1",
+ "machine_topic": "blower_separator",
+ "storage_path": "/storage/camera1",
+ "exposure_ms": 0.3,
+ "gain": 4.0,
+ "target_fps": 0,
+ "enabled": true,
+ "video_format": "mp4",
+ "video_codec": "mp4v",
+ "video_quality": 95,
+ "auto_start_recording_enabled": true,
+ "auto_recording_max_retries": 3,
+ "auto_recording_retry_delay_seconds": 2,
+
+ // ... other existing fields
+}
+```
+
+### Video File Listings
+```json
+{
+ "videos": [
+ {
+ "file_id": "camera1_recording_20250804_143022.mp4",
+ "filename": "camera1_recording_20250804_143022.mp4",
+ "format": "mp4",
+ "file_size_bytes": 31457280,
+ "created_at": "2025-08-04T14:30:22"
+ }
+ ]
+}
+```
+
+## 🎨 UI/UX Improvements
+
+### File Size Display
+```javascript
+// MP4 files are ~40% smaller
+const formatFileSize = (bytes) => {
+ const mb = bytes / (1024 * 1024);
+ return `${mb.toFixed(1)} MB`;
+};
+
+// Show format in file listings
+const FileListItem = ({ video }) => (
+ 🎥 USDA Vision Camera Live Preview
+ +
+
+
+
+
+
+ 📡 System Information
+Loading system status...
+
+ 🔗 API Endpoints
+
+
+ Live Stream: GET /cameras/{camera_name}/stream
+Start Stream: POST /cameras/{camera_name}/start-stream
+Stop Stream: POST /cameras/{camera_name}/stop-stream
+Camera Status: GET /cameras
+
+ {video.filename}
+
+ {video.format.toUpperCase()}
+
+ {formatFileSize(video.file_size_bytes)}
+
+);
+```
+
+### Format Indicators
+```css
+.format.mp4 {
+ background: #4CAF50;
+ color: white;
+ padding: 2px 6px;
+ border-radius: 3px;
+ font-size: 0.8em;
+}
+
+.format.avi {
+ background: #FF9800;
+ color: white;
+ padding: 2px 6px;
+ border-radius: 3px;
+ font-size: 0.8em;
+}
+```
+
+## ⚡ Performance Benefits
+
+### Streaming Improvements
+- **Faster Loading**: MP4 files start playing sooner
+- **Better Seeking**: More responsive video scrubbing
+- **Mobile Friendly**: Better iOS/Android compatibility
+- **Bandwidth Savings**: 40% smaller files = faster transfers
+
+### Implementation Tips
+```javascript
+// Preload video metadata for better UX
+const VideoThumbnail = ({ videoUrl }) => (
+
+);
+```
+
+## 🔧 Configuration Management
+
+### Restart Warning Component
+```jsx
+const RestartWarning = ({ show }) => {
+ if (!show) return null;
+
+ return (
+
+ ⚠️ Restart Required
+
+ );
+};
+```
+
+### Settings Validation
+```javascript
+const validateVideoSettings = (settings) => {
+ const errors = {};
+
+ if (!['mp4', 'avi'].includes(settings.video_format)) {
+ errors.video_format = 'Must be mp4 or avi';
+ }
+
+ if (!['mp4v', 'XVID', 'MJPG'].includes(settings.video_codec)) {
+ errors.video_codec = 'Invalid codec';
+ }
+
+ if (settings.video_quality < 50 || settings.video_quality > 100) {
+ errors.video_quality = 'Quality must be between 50-100';
+ }
+
+ return errors;
+};
+```
+
+## 📱 Mobile Considerations
+
+### Responsive Video Player
+```jsx
+const ResponsiveVideoPlayer = ({ videoUrl, filename }) => (
+ Video format changes require a camera service restart to take effect.
+ +
+
+
+);
+```
+
+## 🧪 Testing Checklist
+
+- [ ] Video playback works with new MP4 files
+- [ ] File extension filtering includes both .mp4 and .avi
+- [ ] Camera configuration UI shows video format options
+- [ ] Restart warning appears for video format changes
+- [ ] File size displays are updated for smaller MP4 files
+- [ ] Mobile video playback works correctly
+- [ ] Video streaming performance is improved
+- [ ] Backward compatibility with existing AVI files
+
+## 📞 Support
+
+If you encounter issues:
+
+1. **Video won't play**: Check browser console for codec errors
+2. **File size unexpected**: Verify quality settings in camera config
+3. **Streaming slow**: Compare MP4 vs AVI performance
+4. **Mobile issues**: Ensure `playsInline` attribute is set
+
+The MP4 update provides significant improvements in web compatibility and performance while maintaining full backward compatibility with existing AVI files.
diff --git a/api/docs/README.md b/api/docs/README.md
new file mode 100644
index 0000000..5ba7b70
--- /dev/null
+++ b/api/docs/README.md
@@ -0,0 +1,100 @@
+# USDA Vision Camera System - Documentation
+
+This directory contains detailed documentation for the USDA Vision Camera System.
+
+## Documentation Files
+
+### 🚀 [API_DOCUMENTATION.md](API_DOCUMENTATION.md) **⭐ NEW**
+**Complete API reference documentation** covering all endpoints, features, and recent enhancements:
+- System status and health monitoring
+- Camera management and configuration
+- Recording control with dynamic settings
+- Auto-recording management
+- MQTT and machine status
+- Storage and file management
+- Camera recovery and diagnostics
+- Live streaming capabilities
+- WebSocket real-time updates
+- Quick start examples and migration notes
+
+### ⚡ [API_QUICK_REFERENCE.md](API_QUICK_REFERENCE.md) **⭐ NEW**
+**Quick reference card** for the most commonly used API endpoints with curl examples and response formats.
+
+### 📋 [PROJECT_COMPLETE.md](PROJECT_COMPLETE.md)
+Complete project overview and final status documentation. Contains:
+- Project completion status
+- Final system architecture
+- Deployment instructions
+- Production readiness checklist
+
+### 🎥 [MP4_FORMAT_UPDATE.md](MP4_FORMAT_UPDATE.md) **⭐ NEW**
+**Frontend integration guide** for the MP4 video format update:
+- Video format changes from AVI to MP4
+- Frontend implementation checklist
+- API response updates
+- Performance benefits and browser compatibility
+
+### 🚀 [REACT_INTEGRATION_GUIDE.md](REACT_INTEGRATION_GUIDE.md) **⭐ NEW**
+**Quick reference for React developers** implementing the MP4 format changes:
+- Code examples and components
+- File handling updates
+- Configuration interface
+- Testing checklist
+
+### 📋 [CURRENT_CONFIGURATION.md](CURRENT_CONFIGURATION.md) **⭐ NEW**
+**Complete current system configuration reference**:
+- Exact config.json structure with all current values
+- Field-by-field documentation
+- Camera-specific settings comparison
+- MQTT topics and machine mappings
+
+### 🎬 [VIDEO_STREAMING.md](VIDEO_STREAMING.md) **⭐ UPDATED**
+**Complete video streaming module documentation**:
+- Comprehensive API endpoint documentation
+- Authentication and security information
+- Error handling and troubleshooting
+- Performance optimization guidelines
+
+### 🤖 [AI_AGENT_VIDEO_INTEGRATION_GUIDE.md](AI_AGENT_VIDEO_INTEGRATION_GUIDE.md) **⭐ NEW**
+**Complete integration guide for AI agents and external systems**:
+- Step-by-step integration workflow
+- Programming language examples (Python, JavaScript)
+- Error handling and debugging strategies
+- Performance optimization recommendations
+
+### 🔧 [API_CHANGES_SUMMARY.md](API_CHANGES_SUMMARY.md)
+Summary of API changes and enhancements made to the system.
+
+### 📷 [CAMERA_RECOVERY_GUIDE.md](CAMERA_RECOVERY_GUIDE.md)
+Guide for camera recovery procedures and troubleshooting camera-related issues.
+
+### 📡 [MQTT_LOGGING_GUIDE.md](MQTT_LOGGING_GUIDE.md)
+Comprehensive guide for MQTT logging configuration and troubleshooting.
+
+## Main Documentation
+
+The main system documentation is located in the root directory:
+- **[../README.md](../README.md)** - Primary system documentation with installation, configuration, and usage instructions
+
+## Additional Resources
+
+### Demo Code
+- **[../demos/](../demos/)** - Demo scripts and camera SDK examples
+
+### Test Files
+- **[../tests/](../tests/)** - Test scripts and legacy test files
+
+### Jupyter Notebooks
+- **[../notebooks/](../notebooks/)** - Interactive notebooks for system exploration and testing
+
+## Quick Links
+
+- [System Installation](../README.md#installation)
+- [Configuration Guide](../README.md#configuration)
+- [API Documentation](../README.md#api-reference)
+- [Troubleshooting](../README.md#troubleshooting)
+- [Camera SDK Examples](../demos/camera_sdk_examples/)
+
+## Support
+
+For technical support and questions, refer to the main [README.md](../README.md) troubleshooting section or check the system logs.
diff --git a/api/docs/VIDEO_STREAMING.md b/api/docs/VIDEO_STREAMING.md
new file mode 100644
index 0000000..69b9d6e
--- /dev/null
+++ b/api/docs/VIDEO_STREAMING.md
@@ -0,0 +1,601 @@
+# 🎬 Video Streaming Module
+
+The USDA Vision Camera System now includes a modular video streaming system that provides YouTube-like video playback capabilities for your React web application.
+
+## 🌟 Features
+
+- **Progressive Streaming** - True chunked streaming for web browsers (no download required)
+- **HTTP Range Request Support** - Enables seeking and progressive download with 206 Partial Content
+- **Native MP4 Support** - Direct streaming of MP4 files optimized for web playback
+- **Memory Efficient** - 8KB chunked delivery, no large file loading into memory
+- **Browser Compatible** - Works with HTML5 `