Update config/app_config.py

config/app_config.py

@@ -161,6 +161,108 @@ class ProcessingConfig:
     max_model_size: int = int(os.getenv('MAX_MODEL_SIZE', '0'))
     max_model_size_bytes: int = int(os.getenv('MAX_MODEL_SIZE_BYTES', '0'))
     
+    # Temporal consistency and smoothing (COMPREHENSIVE)
+    temporal_ema_alpha: float = float(os.getenv('TEMPORAL_EMA_ALPHA', '0.7'))
+    temporal_window_size: int = int(os.getenv('TEMPORAL_WINDOW_SIZE', '5'))
+    temporal_blend_factor: float = float(os.getenv('TEMPORAL_BLEND_FACTOR', '0.5'))
+    temporal_consistency_threshold: float = float(os.getenv('TEMPORAL_CONSISTENCY_THRESHOLD', '0.8'))
+    use_temporal_smoothing: bool = os.getenv('USE_TEMPORAL_SMOOTHING', 'true').lower() == 'true'
+    temporal_buffer_frames: int = int(os.getenv('TEMPORAL_BUFFER_FRAMES', '10'))
+    
+    # Mask post-processing (COMPREHENSIVE)
+    mask_min_area: int = int(os.getenv('MASK_MIN_AREA', '100'))
+    mask_max_area: int = int(os.getenv('MASK_MAX_AREA', '0'))
+    mask_fill_holes: bool = os.getenv('MASK_FILL_HOLES', 'true').lower() == 'true'
+    mask_convex_hull: bool = os.getenv('MASK_CONVEX_HULL', 'false').lower() == 'true'
+    mask_largest_component: bool = os.getenv('MASK_LARGEST_COMPONENT', 'true').lower() == 'true'
+    mask_smooth_radius: int = int(os.getenv('MASK_SMOOTH_RADIUS', '0'))
+    mask_binary_threshold: float = float(os.getenv('MASK_BINARY_THRESHOLD', '0.5'))
+    mask_confidence_threshold: float = float(os.getenv('MASK_CONFIDENCE_THRESHOLD', '0.7'))
+    
+    # Contour processing (COMPREHENSIVE)
+    contour_approx_epsilon: float = float(os.getenv('CONTOUR_APPROX_EPSILON', '0.01'))
+    contour_min_points: int = int(os.getenv('CONTOUR_MIN_POINTS', '4'))
+    contour_max_points: int = int(os.getenv('CONTOUR_MAX_POINTS', '0'))
+    contour_smoothing: bool = os.getenv('CONTOUR_SMOOTHING', 'false').lower() == 'true'
+    contour_simplification: bool = os.getenv('CONTOUR_SIMPLIFICATION', 'false').lower() == 'true'
+    
+    # Trimap generation (COMPREHENSIVE)
+    trimap_dilation_size: int = int(os.getenv('TRIMAP_DILATION_SIZE', '10'))
+    trimap_erosion_size: int = int(os.getenv('TRIMAP_EROSION_SIZE', '5'))
+    trimap_unknown_width: int = int(os.getenv('TRIMAP_UNKNOWN_WIDTH', '20'))
+    trimap_confidence_threshold: float = float(os.getenv('TRIMAP_CONFIDENCE_THRESHOLD', '0.5'))
+    use_trimap: bool = os.getenv('USE_TRIMAP', 'false').lower() == 'true'
+    
+    # SAM2 specific parameters (COMPREHENSIVE)
+    sam2_points_per_side: int = int(os.getenv('SAM2_POINTS_PER_SIDE', '32'))
+    sam2_pred_iou_thresh: float = float(os.getenv('SAM2_PRED_IOU_THRESH', '0.88'))
+    sam2_stability_score_thresh: float = float(os.getenv('SAM2_STABILITY_SCORE_THRESH', '0.95'))
+    sam2_crop_n_layers: int = int(os.getenv('SAM2_CROP_N_LAYERS', '0'))
+    sam2_crop_n_points_downscale_factor: int = int(os.getenv('SAM2_CROP_N_POINTS_DOWNSCALE_FACTOR', '1'))
+    sam2_min_mask_region_area: int = int(os.getenv('SAM2_MIN_MASK_REGION_AREA', '0'))
+    sam2_use_m2m: bool = os.getenv('SAM2_USE_M2M', 'false').lower() == 'true'
+    sam2_multimask_output: bool = os.getenv('SAM2_MULTIMASK_OUTPUT', 'true').lower() == 'true'
+    
+    # Background processing (COMPREHENSIVE)
+    bg_blur_radius: int = int(os.getenv('BG_BLUR_RADIUS', '0'))
+    bg_blur_type: str = os.getenv('BG_BLUR_TYPE', 'gaussian')
+    bg_fill_mode: str = os.getenv('BG_FILL_MODE', 'stretch')
+    bg_color: str = os.getenv('BG_COLOR', '#000000')
+    bg_opacity: float = float(os.getenv('BG_OPACITY', '1.0'))
+    
+    # Green screen / chroma key (COMPREHENSIVE)
+    chroma_tolerance: float = float(os.getenv('CHROMA_TOLERANCE', '0.3'))
+    chroma_softness: float = float(os.getenv('CHROMA_SOFTNESS', '0.1'))
+    chroma_defringe: bool = os.getenv('CHROMA_DEFRINGE', 'true').lower() == 'true'
+    chroma_despill: bool = os.getenv('CHROMA_DESPILL', 'true').lower() == 'true'
+    chroma_key_color: str = os.getenv('CHROMA_KEY_COLOR', '#00FF00')
+    
+    # Motion detection (COMPREHENSIVE)
+    motion_detect: bool = os.getenv('MOTION_DETECT', 'false').lower() == 'true'
+    motion_threshold_percent: float = float(os.getenv('MOTION_THRESHOLD_PERCENT', '5.0'))
+    motion_blur_kernel: int = int(os.getenv('MOTION_BLUR_KERNEL', '21'))
+    motion_min_area: int = int(os.getenv('MOTION_MIN_AREA', '500'))
+    
+    # Stabilization (COMPREHENSIVE)
+    stabilize: bool = os.getenv('STABILIZE', 'false').lower() == 'true'
+    stabilize_smoothing: float = float(os.getenv('STABILIZE_SMOOTHING', '30.0'))
+    stabilize_crop_percent: float = float(os.getenv('STABILIZE_CROP_PERCENT', '0.05'))
+    
+    # Advanced processing flags (COMPREHENSIVE)
+    use_guided_filter: bool = os.getenv('USE_GUIDED_FILTER', 'false').lower() == 'true'
+    guided_filter_radius: int = int(os.getenv('GUIDED_FILTER_RADIUS', '8'))
+    guided_filter_eps: float = float(os.getenv('GUIDED_FILTER_EPS', '0.2'))
+    use_grabcut: bool = os.getenv('USE_GRABCUT', 'false').lower() == 'true'
+    grabcut_iterations: int = int(os.getenv('GRABCUT_ITERATIONS', '5'))
+    use_watershed: bool = os.getenv('USE_WATERSHED', 'false').lower() == 'true'
+    watershed_markers: int = int(os.getenv('WATERSHED_MARKERS', '10'))
+    
+    # Frame sampling (COMPREHENSIVE)
+    sample_rate: int = int(os.getenv('SAMPLE_RATE', '1'))
+    start_frame: int = int(os.getenv('START_FRAME', '0'))
+    end_frame: int = int(os.getenv('END_FRAME', '-1'))
+    process_every_nth_frame: int = int(os.getenv('PROCESS_EVERY_NTH_FRAME', '1'))
+    interpolate_frames: bool = os.getenv('INTERPOLATE_FRAMES', 'false').lower() == 'true'
+    
+    # Preview and debug (COMPREHENSIVE)
+    preview_enabled: bool = os.getenv('PREVIEW_ENABLED', 'false').lower() == 'true'
+    preview_scale: float = float(os.getenv('PREVIEW_SCALE', '0.5'))
+    debug_masks: bool = os.getenv('DEBUG_MASKS', 'false').lower() == 'true'
+    debug_contours: bool = os.getenv('DEBUG_CONTOURS', 'false').lower() == 'true'
+    save_debug_frames: bool = os.getenv('SAVE_DEBUG_FRAMES', 'false').lower() == 'true'
+    
+    # Threading and parallelization (COMPREHENSIVE)
+    num_threads: int = int(os.getenv('NUM_THREADS', '4'))
+    use_multiprocessing: bool = os.getenv('USE_MULTIPROCESSING', 'false').lower() == 'true'
+    chunk_size: int = int(os.getenv('CHUNK_SIZE', '10'))
+    prefetch_frames: int = int(os.getenv('PREFETCH_FRAMES', '5'))
+    
+    # Memory optimization (COMPREHENSIVE)
+    low_memory_mode: bool = os.getenv('LOW_MEMORY_MODE', 'false').lower() == 'true'
+    cache_frames: bool = os.getenv('CACHE_FRAMES', 'true').lower() == 'true'
+    max_cache_size_mb: int = int(os.getenv('MAX_CACHE_SIZE_MB', '1024'))
+    clear_cache_interval: int = int(os.getenv('CLEAR_CACHE_INTERVAL', '100'))
+    
     # Output settings
     output_dir: str = os.getenv('OUTPUT_DIR', 'outputs')
     output_format: str = os.getenv('OUTPUT_FORMAT', 'mp4')
@@ -343,6 +445,85 @@ def _validate_config(self):
         if self.video_codec not in valid_codecs:
             self.video_codec = 'mp4v'
         
+        # Validate temporal consistency (COMPREHENSIVE)
+        self.temporal_ema_alpha = max(0.0, min(1.0, self.temporal_ema_alpha))
+        self.temporal_window_size = max(1, min(100, self.temporal_window_size))
+        self.temporal_blend_factor = max(0.0, min(1.0, self.temporal_blend_factor))
+        self.temporal_consistency_threshold = max(0.0, min(1.0, self.temporal_consistency_threshold))
+        self.temporal_buffer_frames = max(1, min(300, self.temporal_buffer_frames))
+        
+        # Validate mask post-processing
+        self.mask_min_area = max(0, self.mask_min_area)
+        self.mask_binary_threshold = max(0.0, min(1.0, self.mask_binary_threshold))
+        self.mask_confidence_threshold = max(0.0, min(1.0, self.mask_confidence_threshold))
+        self.mask_smooth_radius = max(0, min(50, self.mask_smooth_radius))
+        
+        # Validate contour processing
+        self.contour_approx_epsilon = max(0.0, min(1.0, self.contour_approx_epsilon))
+        self.contour_min_points = max(3, self.contour_min_points)
+        
+        # Validate trimap
+        self.trimap_dilation_size = max(0, min(50, self.trimap_dilation_size))
+        self.trimap_erosion_size = max(0, min(50, self.trimap_erosion_size))
+        self.trimap_unknown_width = max(1, min(100, self.trimap_unknown_width))
+        self.trimap_confidence_threshold = max(0.0, min(1.0, self.trimap_confidence_threshold))
+        
+        # Validate SAM2 parameters
+        self.sam2_points_per_side = max(1, min(100, self.sam2_points_per_side))
+        self.sam2_pred_iou_thresh = max(0.0, min(1.0, self.sam2_pred_iou_thresh))
+        self.sam2_stability_score_thresh = max(0.0, min(1.0, self.sam2_stability_score_thresh))
+        self.sam2_crop_n_layers = max(0, min(10, self.sam2_crop_n_layers))
+        self.sam2_crop_n_points_downscale_factor = max(1, min(16, self.sam2_crop_n_points_downscale_factor))
+        self.sam2_min_mask_region_area = max(0, self.sam2_min_mask_region_area)
+        
+        # Validate background processing
+        self.bg_blur_radius = max(0, min(100, self.bg_blur_radius))
+        valid_blur_types = ['gaussian', 'box', 'median', 'bilateral']
+        if self.bg_blur_type not in valid_blur_types:
+            self.bg_blur_type = 'gaussian'
+        valid_fill_modes = ['stretch', 'fit', 'fill', 'tile']
+        if self.bg_fill_mode not in valid_fill_modes:
+            self.bg_fill_mode = 'stretch'
+        self.bg_opacity = max(0.0, min(1.0, self.bg_opacity))
+        
+        # Validate chroma key
+        self.chroma_tolerance = max(0.0, min(1.0, self.chroma_tolerance))
+        self.chroma_softness = max(0.0, min(1.0, self.chroma_softness))
+        
+        # Validate motion detection
+        self.motion_threshold_percent = max(0.0, min(100.0, self.motion_threshold_percent))
+        self.motion_blur_kernel = max(1, min(99, self.motion_blur_kernel))
+        if self.motion_blur_kernel % 2 == 0:
+            self.motion_blur_kernel += 1
+        self.motion_min_area = max(0, self.motion_min_area)
+        
+        # Validate stabilization
+        self.stabilize_smoothing = max(1.0, min(100.0, self.stabilize_smoothing))
+        self.stabilize_crop_percent = max(0.0, min(0.5, self.stabilize_crop_percent))
+        
+        # Validate guided filter
+        self.guided_filter_radius = max(1, min(50, self.guided_filter_radius))
+        self.guided_filter_eps = max(0.0, min(1.0, self.guided_filter_eps))
+        self.grabcut_iterations = max(1, min(20, self.grabcut_iterations))
+        self.watershed_markers = max(2, min(100, self.watershed_markers))
+        
+        # Validate frame sampling
+        self.sample_rate = max(1, self.sample_rate)
+        self.start_frame = max(0, self.start_frame)
+        self.process_every_nth_frame = max(1, self.process_every_nth_frame)
+        
+        # Validate preview
+        self.preview_scale = max(0.1, min(2.0, self.preview_scale))
+        
+        # Validate threading
+        self.num_threads = max(1, min(32, self.num_threads))
+        self.chunk_size = max(1, min(1000, self.chunk_size))
+        self.prefetch_frames = max(0, min(100, self.prefetch_frames))
+        
+        # Validate memory
+        self.max_cache_size_mb = max(0, self.max_cache_size_mb)
+        self.clear_cache_interval = max(1, self.clear_cache_interval)
+        
         # Validate output settings
         valid_formats = ['mp4', 'avi', 'mov', 'webm', 'mkv']
         if self.output_format not in valid_formats: