MODEL/usda-vision
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove deprecated files and scripts to streamline the codebase

Browse Source 
- Deleted unused API test files, RTSP diagnostic scripts, and development utility scripts to reduce clutter.
- Removed outdated database schema and modularization proposal documents to maintain focus on current architecture.
- Cleaned up configuration files and logging scripts that are no longer in use, enhancing project maintainability.
This commit is contained in:
salirezav
2025-11-02 10:07:59 -05:00
parent f1a9cb0c1e
commit f6a37ca1ba
50 changed files with 7057 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
camera-management-api/config.json
View File

@@ -17,7 +17,7 @@
},
"system": {
"camera_check_interval_seconds": 2,
"log_level": "DEBUG",
"log_level": "WARNING",
"log_file": "usda_vision_system.log",
"api_host": "0.0.0.0",
"api_port": 8000,

21
camera-management-api/usda_vision_system/api/server.py
View File

@@ -123,7 +123,7 @@ class APIServer:
def _setup_routes(self):
"""Setup API routes"""
# Register routes from modules
register_system_routes(
app=self.app,
@@ -299,7 +299,24 @@ class APIServer:
self._event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._event_loop)
uvicorn.run(self.app, host=self.config.system.api_host, port=self.config.system.api_port, log_level="info")
# Map our log level to uvicorn's log level
uvicorn_log_level_map = {
"DEBUG": "debug",
"INFO": "info",
"WARNING": "warning",
"ERROR": "error",
"CRITICAL": "critical"
}
config_log_level = self.config.system.log_level.upper()
uvicorn_log_level = uvicorn_log_level_map.get(config_log_level, "warning")
uvicorn.run(
self.app,
host=self.config.system.api_host,
port=self.config.system.api_port,
log_level=uvicorn_log_level,
access_log=False # Disable access logs (GET, POST, etc.) to reduce noise
)
except Exception as e:
self.logger.error(f"Error running API server: {e}")
finally:

28
camera-management-api/usda_vision_system/camera/monitor.py
View File

@@ -186,34 +186,48 @@ class CameraMonitor:
# Ensure SDK is initialized
ensure_sdk_initialized()
self.logger.info(f"Attempting to initialize camera {camera_name} for availability test...")
# Suppress output to avoid MVCAMAPI error messages during camera testing
with suppress_camera_errors():
hCamera = mvsdk.CameraInit(device_info, -1, -1)
hCamera = None
try:
with suppress_camera_errors():
hCamera = mvsdk.CameraInit(device_info, -1, -1)
self.logger.info(f"Camera {camera_name} initialized successfully, starting test capture...")
except mvsdk.CameraException as init_e:
self.logger.warning(f"CameraInit failed for {camera_name}: {init_e.message} (error_code: {init_e.error_code})")
return "error", f"Camera initialization failed: {init_e.message}", self._get_device_info_dict(device_info)
# Quick test - try to get one frame
try:
mvsdk.CameraSetTriggerMode(hCamera, 0)
mvsdk.CameraPlay(hCamera)
self.logger.info(f"Camera {camera_name} test: Attempting to capture frame with {CAMERA_TEST_CAPTURE_TIMEOUT}ms timeout...")
# Try to capture with short timeout
pRawData, FrameHead = mvsdk.CameraGetImageBuffer(hCamera, CAMERA_TEST_CAPTURE_TIMEOUT)
mvsdk.CameraReleaseImageBuffer(hCamera, pRawData)
# Success - camera is available
mvsdk.CameraUnInit(hCamera)
self.logger.info(f"Camera {camera_name} test successful - camera is available")
return "available", "Camera test successful", self._get_device_info_dict(device_info)
except mvsdk.CameraException as e:
mvsdk.CameraUnInit(hCamera)
if e.error_code == mvsdk.CAMERA_STATUS_TIME_OUT:
except mvsdk.CameraException as capture_e:
if hCamera:
mvsdk.CameraUnInit(hCamera)
self.logger.warning(f"Camera {camera_name} capture test failed: {capture_e.message} (error_code: {capture_e.error_code})")
if capture_e.error_code == mvsdk.CAMERA_STATUS_TIME_OUT:
return "available", "Camera available but slow response", self._get_device_info_dict(device_info)
else:
return "error", f"Camera test failed: {e.message}", self._get_device_info_dict(device_info)
return "error", f"Camera test failed: {capture_e.message}", self._get_device_info_dict(device_info)
except mvsdk.CameraException as e:
return "error", f"Camera initialization failed: {e.message}", self._get_device_info_dict(device_info)
self.logger.error(f"CameraException during initialization test for {camera_name}: {e.message} (error_code: {e.error_code})")
return "error", f"Camera initialization failed: {e.message}", self._get_device_info_dict(device_info) if device_info else None
except Exception as e:
self.logger.error(f"Unexpected exception during camera check for {camera_name}: {e}", exc_info=True)
return "error", f"Camera check failed: {str(e)}", None
def _get_device_info_dict(self, device_info) -> Dict[str, Any]:

2
camera-management-api/usda_vision_system/core/config.py
View File

@@ -96,7 +96,7 @@ class SystemConfig:
"""System-wide configuration"""
camera_check_interval_seconds: int = 2
log_level: str = "INFO"
log_level: str = "WARNING"
log_file: str = "usda_vision_system.log"
api_host: str = "0.0.0.0"
api_port: int = 8000

21
camera-management-api/usda_vision_system/core/logging_config.py
View File

@@ -112,23 +112,32 @@ class USDAVisionLogger:
def _setup_component_loggers(self) -> None:
"""Setup specific log levels for different components"""
# MQTT client - can be verbose
# MQTT client - reduce INFO logs
mqtt_logger = logging.getLogger('usda_vision_system.mqtt')
if self.log_level == 'DEBUG':
mqtt_logger.setLevel(logging.DEBUG)
else:
elif self.log_level == 'INFO':
mqtt_logger.setLevel(logging.INFO)
else:
mqtt_logger.setLevel(logging.WARNING)
# Camera components - important for debugging
# Camera components - reduce INFO logs, keep WARNING and above
camera_logger = logging.getLogger('usda_vision_system.camera')
camera_logger.setLevel(logging.INFO)
if self.log_level == 'DEBUG':
camera_logger.setLevel(logging.DEBUG)
elif self.log_level == 'INFO':
camera_logger.setLevel(logging.INFO)
else:
camera_logger.setLevel(logging.WARNING)
# API server - can be noisy
# API server - reduce INFO noise
api_logger = logging.getLogger('usda_vision_system.api')
if self.log_level == 'DEBUG':
api_logger.setLevel(logging.DEBUG)
else:
elif self.log_level == 'INFO':
api_logger.setLevel(logging.INFO)
else:
api_logger.setLevel(logging.WARNING)
# Uvicorn - reduce noise unless debugging
uvicorn_logger = logging.getLogger('uvicorn')

92
camera-management-api/usda_vision_system/recording/standalone_auto_recorder.py
View File

@@ -45,8 +45,21 @@ class StandaloneAutoRecorder:
# Setup logging (only if not already configured)
if not logging.getLogger().handlers:
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", handlers=[logging.FileHandler("standalone_auto_recorder.log"), logging.StreamHandler()])
# Use WARNING level by default to reduce INFO log noise
log_level = getattr(self.config.system, 'log_level', 'WARNING')
log_level_num = getattr(logging, log_level.upper(), logging.WARNING)
logging.basicConfig(
level=log_level_num,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
handlers=[
logging.FileHandler("standalone_auto_recorder.log"),
logging.StreamHandler()
]
)
self.logger = logging.getLogger(__name__)
# Ensure this logger respects the configured log level
if hasattr(self.config, 'system') and hasattr(self.config.system, 'log_level'):
self.logger.setLevel(getattr(logging, self.config.system.log_level.upper(), logging.WARNING))
# Initialize components
self.state_manager = StateManager()
@@ -59,6 +72,9 @@ class StandaloneAutoRecorder:
self.camera_recorders: Dict[str, CameraRecorder] = {}
self.active_recordings: Dict[str, str] = {} # camera_name -> filename
# Camera device cache
self._device_list: Optional[list] = None
# Machine to camera mapping
self.machine_camera_map = self._build_machine_camera_map()
@@ -257,7 +273,7 @@ class StandaloneAutoRecorder:
return None
def _find_camera_device(self, camera_name: str):
"""Simplified camera device discovery"""
"""Find camera device by matching serial number or using index mapping"""
try:
# Import camera SDK
import sys
@@ -266,23 +282,73 @@ class StandaloneAutoRecorder:
sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "camera_sdk"))
import mvsdk
# Initialize SDK
mvsdk.CameraSdkInit(1)
# Initialize SDK (only if not already initialized)
try:
mvsdk.CameraSdkInit(1)
except:
pass # SDK may already be initialized
# Enumerate cameras
device_list = mvsdk.CameraEnumerateDevice()
# For now, map by index (camera1 = index 0, camera2 = index 1)
camera_index = int(camera_name.replace("camera", "")) - 1
if 0 <= camera_index < len(device_list):
return device_list[camera_index]
# Cache device list to avoid re-enumerating
if self._device_list is None:
device_list = mvsdk.CameraEnumerateDevice()
self._device_list = device_list
self.logger.info(f"Enumerated {len(device_list)} camera device(s)")
else:
self.logger.error(f"Camera index {camera_index} not found (total: {len(device_list)})")
device_list = self._device_list
if len(device_list) == 0:
self.logger.error("No cameras detected")
return None
# Find camera config to get serial number or device_index if available
camera_config = None
for config in self.config.cameras:
if config.name == camera_name:
camera_config = config
break
# Try to match by serial number if available in device info
if camera_config:
# Check if config has device_index specified
device_index = getattr(camera_config, 'device_index', None)
if device_index is not None and 0 <= device_index < len(device_list):
self.logger.info(f"Using device_index {device_index} for {camera_name}")
return device_list[device_index]
# Try matching by serial number from camera config if available
config_serial = getattr(camera_config, 'serial_number', None)
if config_serial:
for i, dev_info in enumerate(device_list):
try:
dev_serial = getattr(dev_info, 'acSn', None) or getattr(dev_info, 'GetSn', lambda: None)()
if dev_serial and str(dev_serial) == str(config_serial):
self.logger.info(f"Matched {camera_name} to device {i} by serial number: {dev_serial}")
return dev_info
except:
continue
# Fallback to index mapping (camera1 = index 0, camera2 = index 1, etc.)
try:
camera_index = int(camera_name.replace("camera", "")) - 1
if 0 <= camera_index < len(device_list):
self.logger.info(f"Using index mapping for {camera_name} -> device {camera_index}")
return device_list[camera_index]
else:
self.logger.error(f"Camera index {camera_index} not found (total: {len(device_list)}). Available indices: 0-{len(device_list)-1}")
# If only one camera is available, use it for any camera name
if len(device_list) == 1:
self.logger.warning(f"Only 1 camera detected, using it for {camera_name}")
return device_list[0]
except ValueError:
pass
self.logger.error(f"No device found for camera {camera_name}")
return None
except Exception as e:
self.logger.error(f"Error finding camera device: {e}")
import traceback
self.logger.debug(traceback.format_exc())
return None
def start(self) -> bool: