📦 Add Experimental Region Support, Add SAD Script

App.py

@@ -1,38 +1,51 @@
 from spandrel import ModelLoader
 import torch
 from pathlib import Path
-from PIL import Image
 import gradio as App
-import numpy as np
-import subprocess
 import logging
 import spaces
 import time
-import os
-import gc
-import io
 import cv2
+import os
 
 from gradio import themes
 from rich.console import Console
 from rich.logging import RichHandler
 
+from Scripts.SAD import GetDifferenceRectangles
+
 # ============================== #
 #          Core Settings         #
 # ============================== #
 
-Theme = themes.Citrus(primary_hue='blue', radius_size=themes.sizes.radius_xxl)
+Theme = themes.Citrus(
+	primary_hue='blue',
+	secondary_hue='blue',
+	radius_size=themes.sizes.radius_xxl
+).set(
+	link_text_color='blue'
+)
 ModelDir = Path('./Models')
 TempDir = Path('./Temp')
 os.environ['GRADIO_TEMP_DIR'] = str(TempDir)
 ModelFileType = '.pth'
 
 # ============================== #
-#        Enhanced Logging        #
+#            Logging             #
 # ============================== #
 
-logging.basicConfig(level=logging.INFO, format='%(message)s', datefmt='[%X]',
-					handlers=[RichHandler(console=Console(), rich_tracebacks=True)])
+logging.basicConfig(
+	level=logging.INFO,
+	format='%(message)s',
+	datefmt='[%X]',
+	handlers=[RichHandler(
+		console=Console(),
+		rich_tracebacks=True,
+		omit_repeated_times=False,
+		markup=True,
+		show_path=False,
+	)],
+)
 Logger = logging.getLogger('Video2x')
 logging.getLogger('httpx').setLevel(logging.WARNING)
 
@@ -43,16 +56,16 @@ logging.getLogger('httpx').setLevel(logging.WARNING)
 @spaces.GPU
 def GetDeviceName():
 	Device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-	Logger.info(f'⚙️ Using device: {Device}')
+	Logger.info(f'🧪 Using device: {str(Device).upper()}')
 	return Device
 
 Device = GetDeviceName()
 
 # ============================== #
-#      Optimized Functions       #
+#       Utility Functions        #
 # ============================== #
 
-def FormatTimeEstimate(Seconds):
+def HumanizeSeconds(Seconds):
 	Hours = int(Seconds // 3600)
 	Minutes = int((Seconds % 3600) // 60)
 	Seconds = int(Seconds % 60)
@@ -64,179 +77,156 @@ def FormatTimeEstimate(Seconds):
 	else:
 		return f'{Seconds}s'
 
-def ListModels():
-	Models = sorted([File.name for File in ModelDir.glob('*' + ModelFileType) if File.is_file()])
-	Logger.info(f'📚 Found {len(Models)} Models In Directory')
-	return Models
-
-def LoadModel(ModelName):
-	if Device.type == 'cuda':
-		torch.cuda.empty_cache()
-	Logger.info(f'🔄 Loading model: {ModelName} onto {Device}')
-	Model = ModelLoader().load_from_file(ModelDir / (ModelName + ModelFileType)).to(Device).eval() # Use .to(Device)
-	Logger.info('✅ Model Loaded Successfully')
-	return Model
-
-@spaces.GPU
-def ProcessSingleFrame(OriginalImage, Model, TileGridSize):
-	if TileGridSize > 1:
-		Logger.info(f'🧩 Processing With Tile Grid {TileGridSize}x{TileGridSize}')
-		Width, Height = OriginalImage.size
-		TileWidth, TileHeight = Width // TileGridSize, Height // TileGridSize
-		UpscaledTilesGrid = []
-
-		for Row in range(TileGridSize):
-			CurrentRowTiles = []
-			for Col in range(TileGridSize):
-				Tile = OriginalImage.crop((Col * TileWidth, Row * TileHeight,
-										  (Col + 1) * TileWidth, (Row + 1) * TileHeight))
-				TileTensor = torch.from_numpy(np.array(Tile)).permute(2, 0, 1).unsqueeze(0).float().to(Device) / 255.0
-
-				with torch.no_grad():
-					UpscaledTileTensor = Model(TileTensor)
-
-				UpscaledTileNumpy = UpscaledTileTensor.squeeze(0).permute(1, 2, 0).cpu().numpy()
-				CurrentRowTiles.append(Image.fromarray(np.uint8(UpscaledTileNumpy.clip(0.0, 1.0) * 255.0), mode='RGB'))
-				del TileTensor, UpscaledTileTensor, UpscaledTileNumpy
-			UpscaledTilesGrid.append(CurrentRowTiles)
-
-		FirstTileWidth, FirstTileHeight = UpscaledTilesGrid[0][0].size
-		UpscaledImage = Image.new('RGB', (FirstTileWidth * TileGridSize, FirstTileHeight * TileGridSize))
-
-		for Row in range(TileGridSize):
-			for Col in range(TileGridSize):
-				UpscaledImage.paste(UpscaledTilesGrid[Row][Col], (Col * FirstTileWidth, Row * FirstTileHeight))
-	else:
-		TorchImage = torch.from_numpy(np.array(OriginalImage)).permute(2, 0, 1).unsqueeze(0).float().to(Device) / 255.0
-		with torch.no_grad():
-			ResultTensor = Model(TorchImage)
-		ResultNumpy = ResultTensor.squeeze(0).permute(1, 2, 0).cpu().numpy()
-		UpscaledImage = Image.fromarray(np.uint8(ResultNumpy.clip(0.0, 1.0) * 255.0), mode='RGB')
-		del TorchImage, ResultTensor, ResultNumpy
+def HumanizedBytes(Size):
+	Units = ['B', 'KB', 'MB', 'GB', 'TB']
+	Index = 0
+	while Size >= 1024 and Index < len(Units) - 1:
+		Size /= 1024.0
+		Index += 1
+	return f'{Size:.2f} {Units[Index]}'
 
-	return UpscaledImage
+# ============================== #
+#     Main Processing Logic      #
+# ============================== #
 
 @spaces.GPU
-def Process(VideoInputPath, ModelName, FrameRateValue, TileGridSize, FileType, Progress=App.Progress()):
-	# First yield should match the order of outputs in the click function
-	yield None, App.update(interactive=False, value=None)
-
-	if not VideoInputPath or not ModelName or not FileType:
-		Logger.error('⛔ Missing Inputs!')
-		return None, None
-
-	VideoPath = Path(VideoInputPath)
-	OutputVideoPath = VideoPath.parent / f'{VideoPath.stem}_{Path(ModelName).stem}{"_Tiled" + str(TileGridSize) if TileGridSize > 1 else ""}{FileType}'
-
-	# Load model
-	Progress(0.0, '🔄 Loading Model')
-	Model = LoadModel(ModelName)
-
-	# Extract video info
-	Logger.info(f'🎬 Extracting Video Information From {VideoPath.name}')
-	VideoCapture = cv2.VideoCapture(str(VideoPath))
-	FrameCount = int(VideoCapture.get(cv2.CAP_PROP_FRAME_COUNT))
-
-	if not FrameRateValue:
-		FrameRateValue = VideoCapture.get(cv2.CAP_PROP_FPS)
-
-	Logger.info(f'🎞️ Processing {FrameCount} Frames At {FrameRateValue} FPS')
-
-	# In-memory frames processing
-	FrameBuffer = []
-	AllFrames = []
-
-	# Time tracking variables
-	StartTime = time.time()
-	FrameProcessingTime = None
-
-	for FrameIndex in range(FrameCount):
-		FrameStartTime = time.time()
-
-		Success, Frame = VideoCapture.read()
-		if not Success:
-			Logger.warning(f'⚠️ Failed To Read Frame {FrameIndex}')
-			continue
+class Upscaler:
+	def __init__(self):
+		pass
 
-		# Convert from BGR to RGB
-		OriginalImage = Image.fromarray(cv2.cvtColor(Frame, cv2.COLOR_BGR2RGB))
-		UpscaledImage = ProcessSingleFrame(OriginalImage, Model, TileGridSize)
-
-		# Store for preview
-		ResizedOriginalImage = OriginalImage.resize(UpscaledImage.size, Image.Resampling.LANCZOS)
-		AllFrames.append((ResizedOriginalImage, UpscaledImage.copy()))
-
-		# Save to buffer for video output
-		ImageBytes = io.BytesIO()
-		UpscaledImage.save(ImageBytes, format='PNG')
-		FrameBuffer.append(ImageBytes.getvalue())
-
-		# Calculate time estimates
-		CurrentFrameTime = time.time() - FrameStartTime
-
-		if FrameIndex == 0:
-			FrameProcessingTime = CurrentFrameTime
-			Logger.info(f'⏱️ First Frame Took {FrameProcessingTime:.2f}s To Process')
-
-		# Calculate remaining time based on average processing time so far
-		ElapsedTime = time.time() - StartTime
-		AverageTimePerFrame = ElapsedTime / (FrameIndex + 1)
-		RemainingFrames = FrameCount - (FrameIndex + 1)
-		EstimatedRemainingTime = RemainingFrames * AverageTimePerFrame
-
-		# Format time estimates for display
-		RemainingTimeFormatted = FormatTimeEstimate(EstimatedRemainingTime)
-
-		Progress(
-			(FrameIndex + 1) / FrameCount,
-			f'🔄 Frame {FrameIndex+1}/{FrameCount} | ETA: {RemainingTimeFormatted}'
+	def ListModels(self):
+		Models = sorted(
+			[File.name for File in ModelDir.glob('*' + ModelFileType) if File.is_file()]
 		)
+		Logger.info(f'📚 Found {len(Models)} Models In Directory')
+		return Models
 
-		del OriginalImage, UpscaledImage, ImageBytes
-		gc.collect()
-
-	VideoCapture.release()
-
-	# Write frames to temporary files for ffmpeg
-	Logger.info('💾 Preparing Frames For Video Encoding')
-	os.makedirs(TempDir, exist_ok=True)
-
-	for Index, FrameData in enumerate(FrameBuffer):
-		with open(f'{TempDir}/Frame_{Index:06d}.png', 'wb') as f:
-			f.write(FrameData)
-
-	# Create video
-	Progress(1.0, '🎥 Encoding Video')
-	Logger.info('🎥 Encoding Final Video')
-	FfmpegCmd = f'ffmpeg -y -framerate {FrameRateValue} -i "{TempDir}/Frame_%06d.png" -c:v libx264 -pix_fmt yuv420p "{OutputVideoPath}" -hide_banner -loglevel error'
-	subprocess.run(FfmpegCmd, shell=True, check=True)
-
-	# Clean up
-	for File in Path(TempDir).glob('Frame_*.png'):
-		File.unlink()
-
-	Logger.info(f'🎉 Video Saved To: {OutputVideoPath}')
-
-	# Update UI - return values directly in the order specified in the click function
-	FirstFrame = AllFrames[0] if AllFrames else None
-	DownloadValue = App.update(interactive=True, value=str(OutputVideoPath))
-	yield FirstFrame, DownloadValue
-
-	# Release resources
-	del Model, FrameBuffer, AllFrames
-	Progress(1.0, '🧹 Cleaning Up Resources')
-	gc.collect()
-	if Device.type == 'cuda':
+	def LoadModel(self, ModelName):
 		torch.cuda.empty_cache()
-		Logger.info('🧹 CUDA Memory Cleaned Up')
-	Logger.info('🧹 Model Unloaded')
-	Progress(1.0, '📦 Done!')
+		Model = (
+			ModelLoader()
+			.load_from_file(ModelDir / (ModelName + ModelFileType))
+			.to(Device)
+			.eval()
+		)
+		Logger.info(f'🤖 Loaded Model {ModelName} Onto {str(Device).upper()}')
+		return Model
+
+	def UnloadModel(self):
+		if Device.type == 'cuda':
+			torch.cuda.empty_cache()
+		Logger.info('🤖 Model Unloaded Successfully')
+
+	def CleanUp(self):
+		self.UnloadModel()
+		Logger.info('🧹 Temporary Files Cleaned Up')
+
+	def Process(self, InputVideo, InputModel, InputUseRegions, InputThreshold, InputMinPercentage, InputMaxRectangles, InputPadding, Progress=App.Progress()):
+		if not InputVideo:
+			Logger.warning('❌ No Video Provided')
+			App.Warning('❌ No Video Provided')
+			return None, None
+
+		Progress(0, desc='⚙️ Loading Model')
+		Model = self.LoadModel(InputModel)
+
+		Logger.info(f'📼 Processing Video: {Path(InputVideo).name}')
+		Progress(0, desc='📼 Processing Video')
+		Video = cv2.VideoCapture(InputVideo)
+
+		FrameRate = Video.get(cv2.CAP_PROP_FPS)
+		FrameCount = int(Video.get(cv2.CAP_PROP_FRAME_COUNT))
+		Width = int(Video.get(cv2.CAP_PROP_FRAME_WIDTH))
+		Height = int(Video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+		Logger.info(f'📏 Video Properties: {FrameCount} Frames, {FrameRate} FPS, {Width}x{Height}')
+
+		PerFrameProgress = 1 / FrameCount
+		FrameProgress = 0.0
+		StartTime = time.time()
+		Times = []
+
+		while True:
+			Ret, Frame = Video.read()
+			if not Ret:
+				break
+
+			FrameRgb = cv2.cvtColor(Frame, cv2.COLOR_BGR2RGB)
+			FrameForTorch = FrameRgb.transpose(2, 0, 1)
+			FrameForTorch = torch.from_numpy(FrameForTorch).unsqueeze(0).to(Device).float() / 255.0
+
+			RetNext, NextFrame = Video.read()
+			if not RetNext:
+				NextFrame = Frame
+
+			DiffResult = GetDifferenceRectangles(
+				Frame,
+				NextFrame,
+				Threshold=InputThreshold,
+				Rows=12,
+				Columns=20,
+				Padding=InputPadding
+
+			)
+			SimilarityPercentage = DiffResult['SimilarPercentage']
+			Rectangles = DiffResult['Rectangles']
+
+			if SimilarityPercentage > InputMinPercentage and len(Rectangles) < InputMaxRectangles and InputUseRegions:
+				Logger.info(f'🟩 Frame {int(Video.get(cv2.CAP_PROP_POS_FRAMES))}: {SimilarityPercentage:.2f}% Similar, {len(Rectangles)} Regions To Upscale')
+				Cols = DiffResult['Columns']
+				Rows = DiffResult['Rows']
+				FrameHeight, FrameWidth = Frame.shape[:2]
+				SegmentWidth = FrameWidth // Cols
+				SegmentHeight = FrameHeight // Rows
+				for X, Y, W, H in Rectangles:
+					X1 = X * SegmentWidth
+					Y1 = Y * SegmentHeight
+					X2 = FrameWidth if X + W == Cols else X1 + W * SegmentWidth
+					Y2 = FrameHeight if Y + H == Rows else Y1 + H * SegmentHeight
+
+					Region = Frame[Y1:Y2, X1:X2]
+					RegionRgb = cv2.cvtColor(Region, cv2.COLOR_BGR2RGB)
+					RegionTorch = torch.from_numpy(RegionRgb.transpose(2, 0, 1)).unsqueeze(0).to(Device).float() / 255.0
+					UpscaledRegion = Model(RegionTorch)[0].cpu().numpy().transpose(1, 2, 0) * 255.0 # type: ignore
+					UpscaledRegion = cv2.cvtColor(UpscaledRegion.astype('uint8'), cv2.COLOR_RGB2BGR)
+					RegionHeight, RegionWidth = Region.shape[:2]
+					UpscaledRegion = cv2.resize(UpscaledRegion, (RegionWidth, RegionHeight), interpolation=cv2.INTER_CUBIC)
+					Frame[Y1:Y2, X1:X2] = UpscaledRegion
+				OutputFrame = Frame
+			else:
+				Logger.info(f'🟥 Frame {int(Video.get(cv2.CAP_PROP_POS_FRAMES))}: {SimilarityPercentage:.2f}% Similar, Upscaling Full Frame')
+				OutputFrame = Model(FrameForTorch)[0].cpu().numpy().transpose(1, 2, 0) * 255.0 # type: ignore
+				OutputFrame = cv2.cvtColor(OutputFrame.astype('uint8'), cv2.COLOR_RGB2BGR)
+				OutputFrame = cv2.resize(OutputFrame, (Width, Height), interpolation=cv2.INTER_CUBIC)
+
+			CurrentFrameNumber = int(Video.get(cv2.CAP_PROP_POS_FRAMES))
+			if Times:
+				AverageTime = sum(Times) / len(Times)
+				Eta = HumanizeSeconds((FrameCount - CurrentFrameNumber) * AverageTime)
+			else:
+				Eta = None
+
+			Progress(FrameProgress, desc=f'📦 Processed Frame {len(Times)+1}/{FrameCount} - {Eta}')
+			Logger.info(f'📦 Processed Frame {len(Times)+1}/{FrameCount} - {Eta}')
+
+			cv2.imwrite(f'{TempDir}/Upscaled_Frame_{CurrentFrameNumber:05d}.png', OutputFrame)
+
+			DeltaTime = time.time() - StartTime
+			Times.append(DeltaTime)
+			StartTime = time.time()
+			FrameProgress += PerFrameProgress
+
+		Progress(1, desc='📦 Cleaning Up')
+		self.CleanUp()
+		return InputVideo, InputVideo
 
 # ============================== #
 #          Streamlined UI        #
 # ============================== #
 
-with App.Blocks(title='Video Upscaler', theme=Theme, delete_cache=(60, 600)) as Interface:
+with App.Blocks(
+	title='Video Upscaler', theme=Theme, delete_cache=(-1, 1800)
+) as Interface:
 	App.Markdown('# 🎞️ Video Upscaler')
 	App.Markdown('''
 			  Space created by [Hyphonical](https://huggingface.co/Hyphonical), this space uses several models from [styler00dollar/VSGAN-tensorrt-docker](https://github.com/styler00dollar/VSGAN-tensorrt-docker/releases/tag/models)
@@ -245,38 +235,112 @@ with App.Blocks(title='Video Upscaler', theme=Theme, delete_cache=(60, 600)) as
 			  ''')
 
 	with App.Row():
-		with App.Column(scale=1):
+		with App.Column():
 			with App.Group():
-				InputVideo = App.Video(label='Input Video', sources=['upload'], height=300)
-				ModelList = ListModels()
+				with App.Accordion(label='📜 Instructions', open=False):
+					App.Markdown('''
+						### How To Use The Video Upscaler
+						1.  **Upload A Video:** Begin by uploading your video file using the 'Input Video' section.
+						2.  **Select A Model:** Choose an appropriate upscaling model from the 'Select Model' dropdown menu.
+						3.  **Adjust Settings (Optional):**
+						Modify the 'Frame Rate' slider if you want to change the output video's frame rate.
+						Adjust the 'Tile Grid Size' for memory optimization. Larger models might require a higher grid size, but processing could be slower.
+						4.  **Start Processing:** Click the '🚀 Upscale Video' button to begin the upscaling process.
+						5.  **Download The Result:** Once the process is complete, download the upscaled video using the '💾 Download Video' button.
+						> Tip: If you get a CUDA out of memory error, try increasing the Tile Grid Size. This will split the image into smaller tiles for processing, which can help reduce memory usage.
+					''')
+				InputVideo = App.Video(
+					label='Input Video', sources=['upload'], height=300
+				)
+				ModelList = Upscaler().ListModels()
 				ModelNames = [Path(Model).stem for Model in ModelList]
-				InputModel = App.Dropdown(choices=ModelNames, label='Select Model', value=ModelNames[0] if ModelNames else None)
-				with App.Row():
-					InputFrameRate = App.Slider(label='Frame Rate', minimum=1, maximum=60, value=23.976, step=0.001)
-					InputTileGridSize = App.Slider(label='Tile Grid Size', minimum=1, maximum=6, value=1, step=1, show_reset_button=False)
-				InputFileType = App.Dropdown(choices=['.mp4', '.mkv'], label='Output File Type', value='.mkv', interactive=True)
+				InputModel = App.Dropdown(
+					choices=ModelNames,
+					label='Select Model',
+					value=ModelNames[0],
+				)
+				with App.Accordion(label='⚙️ Advanced Settings', open=False):
+					with App.Group():
+						InputUseRegions = App.Checkbox(
+							label='Use Regions',
+							value=False,
+							info='Use regions to upscale only the different parts of the video (⚡️ Experimental, Faster)',
+							interactive=True
+						)
+						InputThreshold = App.Slider(
+							label='Threshold',
+							value=5,
+							minimum=0,
+							maximum=20,
+							step=0.5,
+							info='Threshold for the SAD algorithm to detect different regions',
+							interactive=False
+						)
+						InputPadding = App.Slider(
+							label='Padding',
+							value=1,
+							minimum=0,
+							maximum=5,
+							step=1,
+							info='Extra padding to include neighboring pixels in the SAD algorithm',
+							interactive=False
+						)
+						InputMinPercentage = App.Slider(
+							label='Min Percentage',
+							value=70,
+							minimum=0,
+							maximum=100,
+							step=1,
+							info='Minimum percentage of similarity to consider upscaling the full frame',
+							interactive=False
+						)
+						InputMaxRectangles = App.Slider(
+							label='Max Rectangles',
+							value=8,
+							minimum=1,
+							maximum=10,
+							step=1,
+							info='Maximum number of rectangles to consider upscaling the full frame',
+							interactive=False
+						)
 			SubmitButton = App.Button('🚀 Upscale Video')
 
-		with App.Column(scale=1, show_progress=True):
-			OutputSlider = App.ImageSlider(label='Output Preview', value=None, height=300)
-			DownloadOutput = App.DownloadButton(label='💾 Download Video', interactive=False)
-			with App.Accordion(label='📜 Instructions', open=False):
-				App.Markdown('''
-				### How To Use The Video Upscaler
-
-				1.  **Upload A Video:** Begin by uploading your video file using the 'Input Video' section.
-				2.  **Select A Model:** Choose an appropriate upscaling model from the 'Select Model' dropdown menu.
-				3.  **Adjust Settings (Optional):**
-				Modify the 'Frame Rate' slider if you want to change the output video's frame rate.
-				Adjust the 'Tile Grid Size' for memory optimization. Larger models might require a higher grid size, but processing could be slower.
-				4.  **Start Processing:** Click the '🚀 Upscale Video' button to begin the upscaling process.
-				5.  **Download The Result:** Once the process is complete, download the upscaled video using the '💾 Download Video' button.
-
-				> Tip: If you get a CUDA out of memory error, try increasing the Tile Grid Size. This will split the image into smaller tiles for processing, which can help reduce memory usage.
-				''')
-
-	SubmitButton.click(fn=Process, inputs=[InputVideo, InputModel, InputFrameRate, InputTileGridSize, InputFileType],
-					 outputs=[OutputSlider, DownloadOutput])
+		with App.Column(show_progress=True):
+			with App.Group():
+				OutputVideo = App.Video(
+					label='Output Video', height=300, interactive=False, format=None
+				)
+			OutputDownload = App.DownloadButton(
+				label='💾 Download Video', interactive=False
+			)
+
+	def ToggleRegionInputs(UseRegions):
+		return (
+			App.update(interactive=UseRegions),
+			App.update(interactive=UseRegions),
+			App.update(interactive=UseRegions),
+			App.update(interactive=UseRegions),
+		)
+
+	InputUseRegions.change(
+		fn=ToggleRegionInputs,
+		inputs=[InputUseRegions],
+		outputs=[InputThreshold, InputMinPercentage, InputMaxRectangles, InputPadding],
+	)
+
+	SubmitButton.click(
+		fn=Upscaler().Process,
+		inputs=[
+			InputVideo,
+			InputModel,
+			InputUseRegions,
+			InputThreshold,
+			InputMinPercentage,
+			InputMaxRectangles,
+			InputPadding
+		],
+		outputs=[OutputVideo, OutputDownload],
+	)
 
 if __name__ == '__main__':
 	os.makedirs(ModelDir, exist_ok=True)

Diff.py

@@ -1,151 +0,0 @@
-import numpy as np
-import cv2
-import time
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-Logger = logging.getLogger(__name__)
-
-def MergeBoxes(Boxes, Padding=5):
-    if len(Boxes) <= 1:
-        return Boxes
-    MergedOccurred = True
-    while MergedOccurred:
-        MergedOccurred = False
-        NewBoxes = []
-        Boxes.sort(key=lambda b: b[0])
-        Used = [False] * len(Boxes)
-        for Index in range(len(Boxes)):
-            if Used[Index]:
-                continue
-            CurrentBox = list(Boxes[Index])
-            Used[Index] = True
-            for J in range(Index + 1, len(Boxes)):
-                if Used[J]:
-                    continue
-                NextBox = Boxes[J]
-                OverlapX = max(CurrentBox[0], NextBox[0]) <= min(CurrentBox[0] + CurrentBox[2], NextBox[0] + NextBox[2]) + Padding
-                OverlapY = max(CurrentBox[1], NextBox[1]) <= min(CurrentBox[1] + CurrentBox[3], NextBox[1] + NextBox[3]) + Padding
-                if OverlapX and OverlapY:
-                    NewX = min(CurrentBox[0], NextBox[0])
-                    NewY = min(CurrentBox[1], NextBox[1])
-                    NewW = max(CurrentBox[0] + CurrentBox[2], NextBox[0] + NextBox[2]) - NewX
-                    NewH = max(CurrentBox[1] + CurrentBox[3], NextBox[1] + NextBox[3]) - NewY
-                    CurrentBox = [NewX, NewY, NewW, NewH]
-                    Used[J] = True
-                    MergedOccurred = True
-            NewBoxes.append(tuple(CurrentBox))
-        Boxes = NewBoxes
-    return Boxes
-
-def GetChangeMask(Image1, Image2, Threshold=25, MinArea=100):
-    if Image1.shape != Image2.shape:
-        Logger.warning(f'Image shapes differ: {Image1.shape} vs {Image2.shape}. Resizing Image2.')
-        Image2 = cv2.resize(Image2, (Image1.shape[1], Image1.shape[0]))
-
-    Gray1 = cv2.cvtColor(Image1, cv2.COLOR_BGR2GRAY)
-    Gray2 = cv2.cvtColor(Image2, cv2.COLOR_BGR2GRAY)
-    Blur1 = cv2.GaussianBlur(Gray1, (5, 5), 0)
-    Blur2 = cv2.GaussianBlur(Gray2, (5, 5), 0)
-    DiffFrame = cv2.absdiff(Blur1, Blur2)
-    _, ThresholdCalc = cv2.threshold(DiffFrame, Threshold, 255, cv2.THRESH_BINARY)
-    Kernel = np.ones((5, 5), np.uint8)
-    DilatedThreshold = cv2.dilate(ThresholdCalc, Kernel, iterations=2)
-
-    Contours, _ = cv2.findContours(DilatedThreshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    OutputMask = np.zeros_like(DilatedThreshold)
-    ValidContours = 0
-    if Contours:
-        for Contour in Contours:
-            if cv2.contourArea(Contour) > MinArea:
-                cv2.drawContours(OutputMask, [Contour], -1, 255, -1) # type: ignore
-                ValidContours +=1
-    Logger.info(f'GetChangeMask: Found {len(Contours)} raw contours, kept {ValidContours} after MinArea filter ({MinArea}).')
-    return OutputMask
-
-def VisualizeDifferences(Image1Path, Image2Path, OutputPath, Threshold=25, MinArea=100, OutlineColor=(0, 255, 0), FillColor=(0, 180, 0), FillAlpha=0.3):
-    Logger.info(f'🎨 Visualizing differences between {Image1Path} and {Image2Path}')
-    Image1 = cv2.imread(Image1Path)
-    Image2 = cv2.imread(Image2Path)
-
-    if Image1 is None or Image2 is None:
-        Logger.error(f'❌ Error loading images for visualization: {Image1Path} or {Image2Path}')
-        return
-
-    if Image1.shape != Image2.shape:
-        Logger.warning(f'⚠️ Image shapes differ: {Image1.shape} vs {Image2.shape}. Resizing Image2 for visualization.')
-        Image2 = cv2.resize(Image2, (Image1.shape[1], Image1.shape[0]))
-
-    ChangedMask = GetChangeMask(Image1, Image2, Threshold, MinArea)
-    OutputImage = Image2.copy()
-    Overlay = OutputImage.copy()
-
-    # Apply fill color to changed areas
-    Overlay[ChangedMask == 255] = FillColor
-    cv2.addWeighted(Overlay, FillAlpha, OutputImage, 1 - FillAlpha, 0, OutputImage)
-
-    # Find contours of the changed areas to draw outlines
-    Contours, _ = cv2.findContours(ChangedMask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    cv2.drawContours(OutputImage, Contours, -1, OutlineColor, 2)
-    Logger.info(f'🎨 Drew {len(Contours)} difference regions.')
-
-    try:
-        cv2.imwrite(OutputPath, OutputImage)
-        Logger.info(f'💾 Saved difference visualization to {OutputPath}')
-    except Exception as E:
-        Logger.error(f'❌ Failed to save visualization {OutputPath}: {E}')
-
-# --- Function to be used in App.py for upscaling ---
-def GetChangedRegions(Image1, Image2, Threshold=25, Padding=10, MinArea=100, MergePadding=5):
-    StartTime = time.time()
-    Logger.info('🔄 Comparing images...')
-
-    if Image1 is None or Image2 is None:
-        Logger.error('❌ Cannot compare None images.')
-        return []
-
-    if Image1.shape != Image2.shape:
-        Logger.warning(f'⚠️ Image shapes differ: {Image1.shape} vs {Image2.shape}. Resizing Image2.')
-        Image2 = cv2.resize(Image2, (Image1.shape[1], Image1.shape[0]))
-
-    Gray1 = cv2.cvtColor(Image1, cv2.COLOR_BGR2GRAY)
-    Gray2 = cv2.cvtColor(Image2, cv2.COLOR_BGR2GRAY)
-    Blur1 = cv2.GaussianBlur(Gray1, (5, 5), 0)
-    Blur2 = cv2.GaussianBlur(Gray2, (5, 5), 0)
-    DiffFrame = cv2.absdiff(Blur1, Blur2)
-    _, ThresholdCalc = cv2.threshold(DiffFrame, Threshold, 255, cv2.THRESH_BINARY)
-    Kernel = np.ones((5, 5), np.uint8)
-    DilatedThreshold = cv2.dilate(ThresholdCalc, Kernel, iterations=2)
-    Contours, _ = cv2.findContours(DilatedThreshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    Logger.info(f'🔎 Found {len(Contours)} raw contours.')
-
-    BoundingBoxes = []
-    if Contours:
-        ValidContours = 0
-        for Contour in Contours:
-            ContourArea = cv2.contourArea(Contour)
-            if ContourArea > MinArea:
-                ValidContours += 1
-                X, Y, W, H = cv2.boundingRect(Contour)
-                PaddedX = max(0, X - Padding)
-                PaddedY = max(0, Y - Padding)
-                MaxW = Image1.shape[1] - PaddedX
-                MaxH = Image1.shape[0] - PaddedY
-                PaddedW = min(W + (Padding * 2), MaxW)
-                PaddedH = min(H + (Padding * 2), MaxH)
-                BoundingBoxes.append((PaddedX, PaddedY, PaddedW, PaddedH))
-        Logger.info(f'📊 Filtered {ValidContours} contours based on MinArea ({MinArea}).')
-
-    InitialBoxCount = len(BoundingBoxes)
-    MergedBoundingBoxes = MergeBoxes(BoundingBoxes, MergePadding)
-    EndTime = time.time()
-    if MergedBoundingBoxes:
-        Logger.info(f'📦 Merged {InitialBoxCount} boxes into {len(MergedBoundingBoxes)} regions.')
-    else:
-        Logger.info('❌ No significant changed regions found after filtering and merging.')
-    Logger.info(f'⏱️ Region finding took {EndTime - StartTime:.3f}s')
-    return MergedBoundingBoxes
-
-# Example call for the new visualization function
-VisualizeDifferences(r'C:\Users\joris\Pictures\frame_01660.png', r'C:\Users\joris\Pictures\frame_01661.png', './Diff.png', 25, 100, (0, 255, 0), (0, 180, 0), 0.3)

Models/1x_Anime1080Fixer_SuperUltraCompact.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dca070132d022f8c82036aa687e45d552e8c583be7cdb81094cb835638df6e29
+size 183907

Scripts/SAD.py

@@ -0,0 +1,120 @@
+import numpy as np
+import cv2
+
+# Segmented Absolute Difference (SAD)
+# Compares two frames, highlights differences in segments, and returns rectangles of changed areas
+
+def HighlightDifferences(BaseFrame: np.ndarray, NextFrame: np.ndarray, Columns: int = 20, Rows: int = 12, Threshold: float = 10, Padding: int = 1):
+    FrameHeight, FrameWidth = BaseFrame.shape[:2]
+    SegmentWidth = FrameWidth // Columns
+    SegmentHeight = FrameHeight // Rows
+    HighlightedFrame = BaseFrame.copy()
+    TotalSegments = 0
+    SimilarSegments = 0
+    DifferentSegments = 0
+    DifferentSegmentMask = np.zeros((Rows, Columns), dtype=bool)
+    for Row in range(Rows):
+        for Col in range(Columns):
+            Y = Row * SegmentHeight
+            X = Col * SegmentWidth
+            Y2 = FrameHeight if Row == Rows - 1 else Y + SegmentHeight
+            X2 = FrameWidth if Col == Columns - 1 else X + SegmentWidth
+            TotalSegments += 1
+            SegmentBase = BaseFrame[Y:Y2, X:X2]
+            SegmentNext = NextFrame[Y:Y2, X:X2]
+            GreyBase = cv2.cvtColor(SegmentBase, cv2.COLOR_BGR2GRAY)
+            GreyNext = cv2.cvtColor(SegmentNext, cv2.COLOR_BGR2GRAY)
+            BlurredBase = cv2.GaussianBlur(GreyBase, (5, 5), 0)
+            BlurredNext = cv2.GaussianBlur(GreyNext, (5, 5), 0)
+            AbsDiff = cv2.absdiff(BlurredBase, BlurredNext)
+            MeanDiff = np.mean(AbsDiff) # type: ignore
+            if MeanDiff > Threshold:
+                DifferentSegments += 1
+                DifferentSegmentMask[Row, Col] = True
+            else:
+                SimilarSegments += 1
+    PaddedMask = DifferentSegmentMask.copy()
+    for Row in range(Rows):
+        for Col in range(Columns):
+            if DifferentSegmentMask[Row, Col]:
+                for PR in range(max(0, Row - Padding), min(Rows, Row + Padding + 1)):
+                    for PC in range(max(0, Col - Padding), min(Columns, Col + Padding + 1)):
+                        PaddedMask[PR, PC] = True
+    for Row in range(Rows):
+        for Col in range(Columns):
+            Y = Row * SegmentHeight
+            X = Col * SegmentWidth
+            Y2 = FrameHeight if Row == Rows - 1 else Y + SegmentHeight
+            X2 = FrameWidth if Col == Columns - 1 else X + SegmentWidth
+            SegmentBase = BaseFrame[Y:Y2, X:X2]
+            if PaddedMask[Row, Col]:
+                HighlightedFrame[Y:Y2, X:X2] = cv2.addWeighted(
+                    HighlightedFrame[Y:Y2, X:X2], 0.5,
+                    np.full_like(SegmentBase, (0, 0, 255)), 0.2, 0
+                )
+            else:
+                HighlightedFrame[Y:Y2, X:X2] = cv2.addWeighted(
+                    HighlightedFrame[Y:Y2, X:X2], 0.5,
+                    np.full_like(SegmentBase, (0, 255, 0)), 0.2, 0
+                )
+    SimilarityPercentage = (SimilarSegments / TotalSegments) * 100
+    TileCoords = []
+    for Row in range(Rows):
+        for Col in range(Columns):
+            if PaddedMask[Row, Col]:
+                TileCoords.append((Col, Row))
+    return HighlightedFrame, DifferentSegments, SimilarityPercentage, TileCoords
+
+def GetRectanglesFromTiles(TileMask: np.ndarray, MinDifferentRatio: float = 0.8):
+    Height, Width = TileMask.shape
+    Visited = np.zeros_like(TileMask, dtype=bool)
+    Rectangles = []
+    for Y in range(Height):
+        for X in range(Width):
+            if TileMask[Y, X] and not Visited[Y, X]:
+                W = 1
+                H = 1
+                Expand = True
+                while Expand:
+                    Expand = False
+                    if X + W < Width:
+                        NewCol = TileMask[Y:Y+H, X+W] & ~Visited[Y:Y+H, X+W]
+                        if np.any(NewCol):
+                            NewRect = TileMask[Y:Y+H, X:X+W+1] & ~Visited[Y:Y+H, X:X+W+1]
+                            Total = NewRect.size
+                            Diff = np.count_nonzero(NewRect)
+                            Ratio = Diff / Total
+                            if Ratio >= MinDifferentRatio and not np.any(Visited[Y:Y+H, X+W]):
+                                W += 1
+                                Expand = True
+                    if Y + H < Height:
+                        NewRow = TileMask[Y+H, X:X+W] & ~Visited[Y+H, X:X+W]
+                        if np.any(NewRow):
+                            NewRect = TileMask[Y:Y+H+1, X:X+W] & ~Visited[Y:Y+H+1, X:X+W]
+                            Total = NewRect.size
+                            Diff = np.count_nonzero(NewRect)
+                            Ratio = Diff / Total
+                            if Ratio >= MinDifferentRatio and not np.any(Visited[Y+H, X:X+W]):
+                                H += 1
+                                Expand = True
+                Visited[Y:Y+H, X:X+W] = True
+                Rectangles.append((X, Y, W, H))
+    return Rectangles
+
+def GetDifferenceRectangles(BaseFrame, NextFrame, Columns=20, Rows=12, Threshold=5, Padding=1):
+    HighlightedFrame, DifferentSegments, SimilarPercentage, TileCoords = HighlightDifferences(
+        BaseFrame, NextFrame, Columns=Columns, Rows=Rows, Threshold=Threshold, Padding=Padding
+    )
+    TileMask = np.zeros((Rows, Columns), dtype=bool)
+    for Col, Row in TileCoords:
+        if Row < TileMask.shape[0] and Col < TileMask.shape[1]:
+            TileMask[Row, Col] = True
+    Rectangles = GetRectanglesFromTiles(TileMask, MinDifferentRatio=0.7)
+    return {
+        'HighlightedFrame': HighlightedFrame,
+        'Rectangles': Rectangles,
+        'SimilarPercentage': SimilarPercentage,
+        'TileCoords': TileCoords,
+        'Columns': Columns,
+        'Rows': Rows
+    }