chore: clean up repository for registry publication
- Remove development documentation files (6) - Remove redundant test files (4) - Remove old archive file (node.zip) - Remove excessive GitHub workflows (4 gemini-*.yml) - Keep essential workflows (comfy-ci.yml, publish.yml) - Preserve core functionality and essential tests - Reduce repository size for end users
This commit is contained in:
limbicnation
@@ -0,0 +1,173 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for Power-of-8 scaling functionality
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add current directory to path to import nodes
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
def test_parsing():
|
||||
"""Test output size parsing"""
|
||||
print("Testing output size parsing...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
# Test valid sizes
|
||||
test_cases = [
|
||||
("ORIGINAL", None),
|
||||
("64x64", (64, 64)),
|
||||
("512x512", (512, 512)),
|
||||
("1024x1024", (1024, 1024)),
|
||||
("2048x2048", (2048, 2048))
|
||||
]
|
||||
|
||||
for input_str, expected in test_cases:
|
||||
result = node.parse_output_size(input_str)
|
||||
if result == expected:
|
||||
print(f"✅ {input_str} -> {result}")
|
||||
else:
|
||||
print(f"❌ {input_str} -> {result}, expected {expected}")
|
||||
return False
|
||||
|
||||
# Test invalid format
|
||||
try:
|
||||
node.parse_output_size("invalid")
|
||||
print("❌ Should have raised ValueError for invalid format")
|
||||
return False
|
||||
except ValueError:
|
||||
print("✅ Correctly rejected invalid format")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_scaling_calculation():
|
||||
"""Test scaling factor calculation"""
|
||||
print("Testing scaling factor calculation...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
test_cases = [
|
||||
# (current_size, target_size, expected_scale_approx)
|
||||
((64, 64), (128, 128), 2.0),
|
||||
((128, 128), (256, 256), 2.0),
|
||||
((100, 100), (512, 512), 5.12),
|
||||
((256, 256), (128, 128), 0.5),
|
||||
((512, 512), (512, 512), 1.0)
|
||||
]
|
||||
|
||||
for current, target, expected_scale in test_cases:
|
||||
result = node.calculate_scaling_factor(current, target)
|
||||
if abs(result - expected_scale) < 0.01:
|
||||
print(f"✅ {current} -> {target}: scale={result:.2f}")
|
||||
else:
|
||||
print(f"❌ {current} -> {target}: scale={result:.2f}, expected≈{expected_scale}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_input_types():
|
||||
"""Test that INPUT_TYPES includes new parameters"""
|
||||
print("Testing INPUT_TYPES configuration...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
node = TransparencyBackgroundRemover()
|
||||
inputs = node.INPUT_TYPES()
|
||||
|
||||
# Check output_size parameter
|
||||
if 'output_size' in inputs['required']:
|
||||
sizes = inputs['required']['output_size'][0]
|
||||
expected_sizes = ["ORIGINAL", "64x64", "96x96", "128x128", "256x256",
|
||||
"512x512", "768x768", "1024x1024", "1280x1280",
|
||||
"1536x1536", "1792x1792", "2048x2048"]
|
||||
|
||||
if sizes == expected_sizes:
|
||||
print("✅ output_size parameter configured correctly")
|
||||
else:
|
||||
print(f"❌ output_size sizes mismatch")
|
||||
print(f" Expected: {expected_sizes}")
|
||||
print(f" Got: {sizes}")
|
||||
return False
|
||||
else:
|
||||
print("❌ output_size parameter missing")
|
||||
return False
|
||||
|
||||
# Check scaling_method parameter
|
||||
if 'scaling_method' in inputs['required']:
|
||||
methods = inputs['required']['scaling_method'][0]
|
||||
if methods == ["NEAREST"]:
|
||||
print("✅ scaling_method parameter configured correctly")
|
||||
else:
|
||||
print(f"❌ scaling_method wrong: {methods}")
|
||||
return False
|
||||
else:
|
||||
print("❌ scaling_method parameter missing")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_power_of_8_validation():
|
||||
"""Verify all sizes are powers/multiples of 8"""
|
||||
print("Testing power-of-8 validation...")
|
||||
|
||||
sizes = [64, 96, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048]
|
||||
|
||||
for size in sizes:
|
||||
if size % 8 == 0:
|
||||
print(f"✅ {size} is multiple of 8")
|
||||
else:
|
||||
print(f"❌ {size} is NOT multiple of 8")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
def main():
|
||||
"""Run all tests"""
|
||||
print("🧪 Testing Power-of-8 Scaling Implementation")
|
||||
print("=" * 50)
|
||||
|
||||
tests = [
|
||||
test_power_of_8_validation,
|
||||
test_input_types,
|
||||
test_parsing,
|
||||
test_scaling_calculation
|
||||
]
|
||||
|
||||
passed = 0
|
||||
total = len(tests)
|
||||
|
||||
for test in tests:
|
||||
if test():
|
||||
passed += 1
|
||||
print()
|
||||
|
||||
print("=" * 50)
|
||||
print(f"Results: {passed}/{total} tests passed")
|
||||
|
||||
if passed == total:
|
||||
print("🎉 All tests PASSED!")
|
||||
return True
|
||||
else:
|
||||
print("❌ Some tests FAILED!")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = main()
|
||||
sys.exit(0 if success else 1)
|
||||
@@ -0,0 +1,225 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Standalone test script for Power-of-8 scaling functionality
|
||||
without ComfyUI dependencies.
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
|
||||
# Add current directory to path
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
# Mock ComfyUI modules for testing
|
||||
class MockFolderPaths:
|
||||
pass
|
||||
|
||||
class MockComfyUtils:
|
||||
pass
|
||||
|
||||
class MockComfy:
|
||||
utils = MockComfyUtils()
|
||||
|
||||
# Mock the imports
|
||||
sys.modules['folder_paths'] = MockFolderPaths()
|
||||
sys.modules['comfy'] = MockComfy()
|
||||
sys.modules['comfy.utils'] = MockComfyUtils()
|
||||
|
||||
def test_parsing():
|
||||
"""Test output size parsing"""
|
||||
print("Testing output size parsing...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
# Test valid sizes
|
||||
test_cases = [
|
||||
("ORIGINAL", None),
|
||||
("64x64", (64, 64)),
|
||||
("512x512", (512, 512)),
|
||||
("1024x1024", (1024, 1024)),
|
||||
("2048x2048", (2048, 2048))
|
||||
]
|
||||
|
||||
for input_str, expected in test_cases:
|
||||
result = node.parse_output_size(input_str)
|
||||
if result == expected:
|
||||
print(f"✅ {input_str} -> {result}")
|
||||
else:
|
||||
print(f"❌ {input_str} -> {result}, expected {expected}")
|
||||
return False
|
||||
|
||||
# Test invalid format
|
||||
try:
|
||||
node.parse_output_size("invalid")
|
||||
print("❌ Should have raised ValueError for invalid format")
|
||||
return False
|
||||
except ValueError:
|
||||
print("✅ Correctly rejected invalid format")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_scaling_calculation():
|
||||
"""Test scaling factor calculation"""
|
||||
print("Testing scaling factor calculation...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
test_cases = [
|
||||
# (current_size, target_size, expected_scale_approx)
|
||||
((64, 64), (128, 128), 2.0),
|
||||
((128, 128), (256, 256), 2.0),
|
||||
((100, 100), (512, 512), 5.12),
|
||||
((256, 256), (128, 128), 0.5),
|
||||
((512, 512), (512, 512), 1.0)
|
||||
]
|
||||
|
||||
for current, target, expected_scale in test_cases:
|
||||
result = node.calculate_scaling_factor(current, target)
|
||||
if abs(result - expected_scale) < 0.01:
|
||||
print(f"✅ {current} -> {target}: scale={result:.2f}")
|
||||
else:
|
||||
print(f"❌ {current} -> {target}: scale={result:.2f}, expected≈{expected_scale}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_input_types():
|
||||
"""Test that INPUT_TYPES includes new parameters"""
|
||||
print("Testing INPUT_TYPES configuration...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
node = TransparencyBackgroundRemover()
|
||||
inputs = node.INPUT_TYPES()
|
||||
|
||||
# Check output_size parameter
|
||||
if 'output_size' in inputs['required']:
|
||||
sizes = inputs['required']['output_size'][0]
|
||||
expected_sizes = ["ORIGINAL", "64x64", "96x96", "128x128", "256x256",
|
||||
"512x512", "768x768", "1024x1024", "1280x1280",
|
||||
"1536x1536", "1792x1792", "2048x2048"]
|
||||
|
||||
if sizes == expected_sizes:
|
||||
print("✅ output_size parameter configured correctly")
|
||||
else:
|
||||
print(f"❌ output_size sizes mismatch")
|
||||
print(f" Expected: {expected_sizes}")
|
||||
print(f" Got: {sizes}")
|
||||
return False
|
||||
else:
|
||||
print("❌ output_size parameter missing")
|
||||
return False
|
||||
|
||||
# Check scaling_method parameter
|
||||
if 'scaling_method' in inputs['required']:
|
||||
methods = inputs['required']['scaling_method'][0]
|
||||
expected_methods = ["NEAREST", "BILINEAR", "BICUBIC", "LANCZOS"]
|
||||
if methods == expected_methods:
|
||||
print("✅ scaling_method parameter configured correctly")
|
||||
else:
|
||||
print(f"❌ scaling_method wrong: {methods}")
|
||||
return False
|
||||
else:
|
||||
print("❌ scaling_method parameter missing")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_interpolation_methods():
|
||||
"""Test interpolation methods"""
|
||||
print("Testing interpolation methods...")
|
||||
|
||||
try:
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
|
||||
# Create test image
|
||||
test_array = np.zeros((64, 64, 3), dtype=np.uint8)
|
||||
test_array[16:48, 16:48] = [255, 0, 0] # Red square
|
||||
test_pil = Image.fromarray(test_array)
|
||||
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
# Test all interpolation methods
|
||||
methods = ["NEAREST", "BILINEAR", "BICUBIC", "LANCZOS"]
|
||||
target_size = (128, 128)
|
||||
|
||||
for method in methods:
|
||||
result = node.intelligent_scale(test_pil, target_size, method)
|
||||
if result.size == target_size:
|
||||
print(f"✅ {method} scaling works correctly")
|
||||
else:
|
||||
print(f"❌ {method} scaling failed: expected {target_size}, got {result.size}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_power_of_8_validation():
|
||||
"""Verify all sizes are powers/multiples of 8"""
|
||||
print("Testing power-of-8 validation...")
|
||||
|
||||
sizes = [64, 96, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048]
|
||||
|
||||
for size in sizes:
|
||||
if size % 8 == 0:
|
||||
print(f"✅ {size} is multiple of 8")
|
||||
else:
|
||||
print(f"❌ {size} is NOT multiple of 8")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
def main():
|
||||
"""Run all tests"""
|
||||
print("🧪 Testing Power-of-8 Scaling Implementation (Standalone)")
|
||||
print("=" * 60)
|
||||
|
||||
tests = [
|
||||
test_power_of_8_validation,
|
||||
test_input_types,
|
||||
test_parsing,
|
||||
test_scaling_calculation,
|
||||
test_interpolation_methods
|
||||
]
|
||||
|
||||
passed = 0
|
||||
total = len(tests)
|
||||
|
||||
for test in tests:
|
||||
if test():
|
||||
passed += 1
|
||||
print()
|
||||
|
||||
print("=" * 60)
|
||||
print(f"Results: {passed}/{total} tests passed")
|
||||
|
||||
if passed == total:
|
||||
print("🎉 All tests PASSED!")
|
||||
return True
|
||||
else:
|
||||
print("❌ Some tests FAILED!")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = main()
|
||||
sys.exit(0 if success else 1)
|
||||
+174
@@ -0,0 +1,174 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for NEAREST NEIGHBOR scaling functionality
|
||||
"""
|
||||
import numpy as np
|
||||
import torch
|
||||
from PIL import Image
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add current directory to path to import nodes
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from nodes import TransparencyBackgroundRemover
|
||||
|
||||
def create_test_image(width=64, height=64):
|
||||
"""Create a simple test image with distinct patterns"""
|
||||
# Create a simple pattern with clear foreground/background
|
||||
image = np.zeros((height, width, 3), dtype=np.uint8)
|
||||
|
||||
# Add background (blue)
|
||||
image[:, :] = [50, 100, 200]
|
||||
|
||||
# Add foreground object (red square in center)
|
||||
center_size = min(width, height) // 3
|
||||
start_x = (width - center_size) // 2
|
||||
start_y = (height - center_size) // 2
|
||||
image[start_y:start_y+center_size, start_x:start_x+center_size] = [200, 50, 50]
|
||||
|
||||
return image
|
||||
|
||||
def test_input_validation():
|
||||
"""Test minimum size validation"""
|
||||
print("Testing input validation...")
|
||||
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
# Test with image smaller than 64x64
|
||||
small_image = create_test_image(32, 32)
|
||||
small_tensor = torch.from_numpy(small_image).unsqueeze(0).float() / 255.0
|
||||
|
||||
try:
|
||||
node.remove_background(small_tensor)
|
||||
print("❌ FAILED: Should have raised ValueError for small image")
|
||||
return False
|
||||
except ValueError as e:
|
||||
if "64x64" in str(e):
|
||||
print("✅ PASSED: Correctly rejected small image")
|
||||
else:
|
||||
print(f"❌ FAILED: Wrong error message: {e}")
|
||||
return False
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: Unexpected error: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
def test_scaling_functionality():
|
||||
"""Test NEAREST scaling functionality"""
|
||||
print("Testing scaling functionality...")
|
||||
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
# Test with valid 64x64 image
|
||||
test_image = create_test_image(64, 64)
|
||||
test_tensor = torch.from_numpy(test_image).unsqueeze(0).float() / 255.0
|
||||
|
||||
try:
|
||||
# Test 1x scaling (no scaling)
|
||||
result_1x, mask_1x = node.remove_background(
|
||||
test_tensor,
|
||||
scale_factor=1,
|
||||
scaling_method="NEAREST"
|
||||
)
|
||||
print(f"✅ 1x scaling: {result_1x.shape}")
|
||||
|
||||
# Test 2x scaling
|
||||
result_2x, mask_2x = node.remove_background(
|
||||
test_tensor,
|
||||
scale_factor=2,
|
||||
scaling_method="NEAREST"
|
||||
)
|
||||
print(f"✅ 2x scaling: {result_2x.shape}")
|
||||
|
||||
# Verify dimensions are doubled
|
||||
expected_height = test_tensor.shape[1] * 2
|
||||
expected_width = test_tensor.shape[2] * 2
|
||||
|
||||
if result_2x.shape[1] == expected_height and result_2x.shape[2] == expected_width:
|
||||
print("✅ PASSED: 2x scaling dimensions correct")
|
||||
else:
|
||||
print(f"❌ FAILED: Expected {expected_height}x{expected_width}, got {result_2x.shape[1]}x{result_2x.shape[2]}")
|
||||
return False
|
||||
|
||||
# Test 4x scaling
|
||||
result_4x, mask_4x = node.remove_background(
|
||||
test_tensor,
|
||||
scale_factor=4,
|
||||
scaling_method="NEAREST"
|
||||
)
|
||||
print(f"✅ 4x scaling: {result_4x.shape}")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: Scaling test error: {e}")
|
||||
return False
|
||||
|
||||
def test_nearest_scale_function():
|
||||
"""Test the nearest_scale function directly"""
|
||||
print("Testing nearest_scale function...")
|
||||
|
||||
node = TransparencyBackgroundRemover()
|
||||
|
||||
# Create a small PIL image
|
||||
test_array = create_test_image(8, 8)
|
||||
test_pil = Image.fromarray(test_array)
|
||||
|
||||
try:
|
||||
# Test 1x (should return same image)
|
||||
result_1x = node.nearest_scale(test_pil, 1)
|
||||
if result_1x.size == test_pil.size:
|
||||
print("✅ 1x scaling preserves size")
|
||||
else:
|
||||
print("❌ FAILED: 1x scaling changed size")
|
||||
return False
|
||||
|
||||
# Test 2x scaling
|
||||
result_2x = node.nearest_scale(test_pil, 2)
|
||||
expected_size = (test_pil.width * 2, test_pil.height * 2)
|
||||
if result_2x.size == expected_size:
|
||||
print("✅ 2x scaling correct size")
|
||||
else:
|
||||
print(f"❌ FAILED: Expected {expected_size}, got {result_2x.size}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: nearest_scale test error: {e}")
|
||||
return False
|
||||
|
||||
def main():
|
||||
"""Run all tests"""
|
||||
print("🧪 Testing NEAREST NEIGHBOR Scaling Implementation")
|
||||
print("=" * 50)
|
||||
|
||||
tests = [
|
||||
test_input_validation,
|
||||
test_nearest_scale_function,
|
||||
test_scaling_functionality
|
||||
]
|
||||
|
||||
passed = 0
|
||||
total = len(tests)
|
||||
|
||||
for test in tests:
|
||||
if test():
|
||||
passed += 1
|
||||
print()
|
||||
|
||||
print("=" * 50)
|
||||
print(f"Results: {passed}/{total} tests passed")
|
||||
|
||||
if passed == total:
|
||||
print("🎉 All tests PASSED!")
|
||||
return True
|
||||
else:
|
||||
print("❌ Some tests FAILED!")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = main()
|
||||
sys.exit(0 if success else 1)
|
||||
@@ -0,0 +1,206 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Standalone test script for the background remover functionality
|
||||
without ComfyUI dependencies.
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
|
||||
# Add current directory to path
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
def create_test_image(width=64, height=64):
|
||||
"""Create a simple test image with distinct patterns"""
|
||||
# Create a simple pattern with clear foreground/background
|
||||
image = np.zeros((height, width, 3), dtype=np.uint8)
|
||||
|
||||
# Add background (blue)
|
||||
image[:, :] = [50, 100, 200]
|
||||
|
||||
# Add foreground object (red square in center)
|
||||
center_size = min(width, height) // 3
|
||||
start_x = (width - center_size) // 2
|
||||
start_y = (height - center_size) // 2
|
||||
image[start_y:start_y+center_size, start_x:start_x+center_size] = [200, 50, 50]
|
||||
|
||||
return image
|
||||
|
||||
def test_background_remover():
|
||||
"""Test the EnhancedPixelArtProcessor directly"""
|
||||
print("Testing EnhancedPixelArtProcessor...")
|
||||
|
||||
try:
|
||||
from background_remover import EnhancedPixelArtProcessor
|
||||
|
||||
# Create test image
|
||||
test_image = create_test_image(128, 128)
|
||||
print(f"✅ Created test image: {test_image.shape}")
|
||||
|
||||
# Initialize processor
|
||||
processor = EnhancedPixelArtProcessor(
|
||||
tolerance=30,
|
||||
edge_sensitivity=0.8,
|
||||
color_clusters=8,
|
||||
foreground_bias=0.7,
|
||||
edge_refinement=True,
|
||||
dither_handling=True,
|
||||
binary_threshold=128
|
||||
)
|
||||
print("✅ Initialized processor")
|
||||
|
||||
# Process image
|
||||
result = processor.remove_background_advanced(test_image)
|
||||
print(f"✅ Processed image: {result.shape}")
|
||||
|
||||
# Verify result has alpha channel
|
||||
if result.shape[2] == 4:
|
||||
print("✅ Result has alpha channel")
|
||||
else:
|
||||
print(f"❌ Expected 4 channels, got {result.shape[2]}")
|
||||
return False
|
||||
|
||||
# Check that some pixels are transparent
|
||||
alpha_channel = result[:, :, 3]
|
||||
transparent_pixels = np.sum(alpha_channel == 0)
|
||||
opaque_pixels = np.sum(alpha_channel == 255)
|
||||
|
||||
print(f"✅ Transparent pixels: {transparent_pixels}")
|
||||
print(f"✅ Opaque pixels: {opaque_pixels}")
|
||||
|
||||
if transparent_pixels > 0 and opaque_pixels > 0:
|
||||
print("✅ Background removal successful - has both transparent and opaque pixels")
|
||||
else:
|
||||
print("❌ Background removal may not be working correctly")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_auto_adjustment():
|
||||
"""Test auto-adjustment feature"""
|
||||
print("Testing auto-adjustment...")
|
||||
|
||||
try:
|
||||
from background_remover import EnhancedPixelArtProcessor
|
||||
|
||||
# Create test image
|
||||
test_image = create_test_image(64, 64)
|
||||
|
||||
# Initialize processor
|
||||
processor = EnhancedPixelArtProcessor()
|
||||
|
||||
# Test auto-adjustment
|
||||
adjustments = processor.auto_adjust_parameters(test_image)
|
||||
|
||||
if adjustments:
|
||||
print(f"✅ Auto-adjustments made: {adjustments}")
|
||||
else:
|
||||
print("✅ No auto-adjustments needed")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_scaling_methods():
|
||||
"""Test different scaling methods"""
|
||||
print("Testing scaling methods...")
|
||||
|
||||
try:
|
||||
# Test PIL resampling methods
|
||||
test_image = create_test_image(64, 64)
|
||||
pil_image = Image.fromarray(test_image)
|
||||
|
||||
methods = {
|
||||
"NEAREST": Image.Resampling.NEAREST,
|
||||
"BILINEAR": Image.Resampling.BILINEAR,
|
||||
"BICUBIC": Image.Resampling.BICUBIC,
|
||||
"LANCZOS": Image.Resampling.LANCZOS
|
||||
}
|
||||
|
||||
for method_name, method in methods.items():
|
||||
scaled = pil_image.resize((128, 128), method)
|
||||
print(f"✅ {method_name} scaling: {scaled.size}")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def test_performance_large_image():
|
||||
"""Test performance optimizations with large image"""
|
||||
print("Testing performance with large image...")
|
||||
|
||||
try:
|
||||
from background_remover import EnhancedPixelArtProcessor
|
||||
import time
|
||||
|
||||
# Create large test image
|
||||
large_image = create_test_image(1200, 1200)
|
||||
print(f"✅ Created large test image: {large_image.shape}")
|
||||
|
||||
# Initialize processor
|
||||
processor = EnhancedPixelArtProcessor()
|
||||
|
||||
# Process with timing
|
||||
start_time = time.time()
|
||||
result = processor.remove_background_advanced(large_image)
|
||||
processing_time = time.time() - start_time
|
||||
|
||||
print(f"✅ Processed large image in {processing_time:.3f}s")
|
||||
print(f"✅ Result shape: {result.shape}")
|
||||
|
||||
# Performance should be reasonable (< 5 seconds for 1200x1200)
|
||||
if processing_time < 5.0:
|
||||
print("✅ Performance is acceptable")
|
||||
else:
|
||||
print(f"⚠️ Performance slower than expected: {processing_time:.3f}s")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ FAILED: {e}")
|
||||
return False
|
||||
|
||||
def main():
|
||||
"""Run all standalone tests"""
|
||||
print("🧪 Running Standalone Background Remover Tests")
|
||||
print("=" * 50)
|
||||
|
||||
tests = [
|
||||
test_background_remover,
|
||||
test_auto_adjustment,
|
||||
test_scaling_methods,
|
||||
test_performance_large_image
|
||||
]
|
||||
|
||||
passed = 0
|
||||
total = len(tests)
|
||||
|
||||
for test in tests:
|
||||
print()
|
||||
if test():
|
||||
passed += 1
|
||||
print("-" * 30)
|
||||
|
||||
print()
|
||||
print("=" * 50)
|
||||
print(f"Results: {passed}/{total} tests passed")
|
||||
|
||||
if passed == total:
|
||||
print("🎉 All tests PASSED!")
|
||||
return True
|
||||
else:
|
||||
print("❌ Some tests FAILED!")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = main()
|
||||
sys.exit(0 if success else 1)
|
||||
BIN
Binary file not shown.
Reference in New Issue
Block a user