File size: 3,313 Bytes
9015f7f 1c4e22d 9015f7f d51bd78 9015f7f 1c4e22d d51bd78 1c4e22d 9015f7f 1c4e22d 9015f7f 1c4e22d 9015f7f 1c4e22d 9015f7f d51bd78 1c4e22d d51bd78 1c4e22d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 |
"""
Core Models Module - Simplified redirect to working model loader
"""
import logging
logger = logging.getLogger(__name__)
class ModelManager:
"""
Compatibility wrapper that redirects to the working ModelLoader
Provides the same interface that CoreVideoProcessor expects
"""
def __init__(self):
self._loader = None
self._device_mgr = None
self._memory_mgr = None
def _get_loader(self):
"""Lazy initialization of model loader"""
if self._loader is None:
try:
from models.loaders.model_loader import ModelLoader
from utils.hardware.device_manager import DeviceManager
from utils.system.memory_manager import MemoryManager
self._device_mgr = DeviceManager()
self._memory_mgr = MemoryManager()
self._loader = ModelLoader(self._device_mgr, self._memory_mgr)
except ImportError as e:
logger.error(f"Failed to import ModelLoader dependencies: {e}")
# Create a dummy loader that returns None for everything
class DummyLoader:
def get_sam2(self): return None
def get_matanyone(self): return None
def load_all_models(self, *args, **kwargs): return None, None
def cleanup(self): pass
self._loader = DummyLoader()
return self._loader
def load_all(self):
"""Load all models (SAM2 and MatAnyone)"""
try:
loader = self._get_loader()
sam2, matanyone = loader.load_all_models()
logger.info(f"Models loaded - SAM2: {sam2 is not None}, MatAnyone: {matanyone is not None}")
return sam2, matanyone
except Exception as e:
logger.error(f"Failed to load models: {e}")
return None, None
def get_sam2(self):
"""Get SAM2 model/predictor"""
loader = self._get_loader()
return loader.get_sam2() if hasattr(loader, 'get_sam2') else None
def get_matanyone(self):
"""Get MatAnyone model"""
loader = self._get_loader()
return loader.get_matanyone() if hasattr(loader, 'get_matanyone') else None
def cleanup(self):
"""Cleanup models and free memory"""
loader = self._get_loader()
if hasattr(loader, 'cleanup'):
loader.cleanup()
def process_frame(self, image, mask=None):
"""Process a single frame - for compatibility"""
# This method was in the old core/models.py
# We'll just return a dummy result since the actual processing
# happens in CoreVideoProcessor
logger.warning("ModelManager.process_frame called - this is deprecated")
return {
"alpha": mask if mask is not None else image[:,:,0],
"foreground": image,
"confidence": [0.5]
}
# For backward compatibility - some code might import these directly
ModelType = None # Not needed with new system
ModelFactory = ModelManager # Alias for compatibility
ModelConfig = None # Configuration now handled in model_loader.py
__all__ = ['ModelManager'] |