Adding test scripts
This commit is contained in:
182
tests/show_yolo_seg.py
Normal file
182
tests/show_yolo_seg.py
Normal file
@@ -0,0 +1,182 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
show_yolo_seg.py
|
||||
|
||||
Usage:
|
||||
python show_yolo_seg.py /path/to/image.jpg /path/to/labels.txt
|
||||
|
||||
Supports:
|
||||
- Segmentation polygons: "class x1 y1 x2 y2 ... xn yn"
|
||||
- YOLO bbox lines as fallback: "class x_center y_center width height"
|
||||
Coordinates can be normalized [0..1] or absolute pixels (auto-detected).
|
||||
"""
|
||||
import sys
|
||||
import cv2
|
||||
import numpy as np
|
||||
import matplotlib.pyplot as plt
|
||||
import argparse
|
||||
from pathlib import Path
|
||||
import random
|
||||
|
||||
|
||||
def parse_label_line(line):
|
||||
parts = line.strip().split()
|
||||
if not parts:
|
||||
return None
|
||||
cls = int(float(parts[0]))
|
||||
coords = [float(x) for x in parts[1:]]
|
||||
return cls, coords
|
||||
|
||||
|
||||
def coords_are_normalized(coords):
|
||||
# If every coordinate is between 0 and 1 (inclusive-ish), assume normalized
|
||||
if not coords:
|
||||
return False
|
||||
return max(coords) <= 1.001
|
||||
|
||||
|
||||
def yolo_bbox_to_xyxy(coords, img_w, img_h):
|
||||
# coords: [xc, yc, w, h] normalized or absolute
|
||||
xc, yc, w, h = coords[:4]
|
||||
if max(coords) <= 1.001:
|
||||
xc *= img_w
|
||||
yc *= img_h
|
||||
w *= img_w
|
||||
h *= img_h
|
||||
x1 = int(round(xc - w / 2))
|
||||
y1 = int(round(yc - h / 2))
|
||||
x2 = int(round(xc + w / 2))
|
||||
y2 = int(round(yc + h / 2))
|
||||
return x1, y1, x2, y2
|
||||
|
||||
|
||||
def poly_to_pts(coords, img_w, img_h):
|
||||
# coords: [x1 y1 x2 y2 ...] either normalized or absolute
|
||||
if coords_are_normalized(coords):
|
||||
coords = [
|
||||
coords[i] * (img_w if i % 2 == 0 else img_h) for i in range(len(coords))
|
||||
]
|
||||
pts = np.array(coords, dtype=np.int32).reshape(-1, 2)
|
||||
return pts
|
||||
|
||||
|
||||
def random_color_for_class(cls):
|
||||
random.seed(cls) # deterministic per class
|
||||
return tuple(int(x) for x in np.array([random.randint(0, 255) for _ in range(3)]))
|
||||
|
||||
|
||||
def draw_annotations(img, labels, alpha=0.4, draw_bbox_for_poly=True):
|
||||
# img: BGR numpy array
|
||||
overlay = img.copy()
|
||||
h, w = img.shape[:2]
|
||||
for cls, coords in labels:
|
||||
if not coords:
|
||||
continue
|
||||
# polygon case (>=6 coordinates)
|
||||
if len(coords) >= 6:
|
||||
pts = poly_to_pts(coords, w, h)
|
||||
color = random_color_for_class(cls)
|
||||
# fill on overlay
|
||||
cv2.fillPoly(overlay, [pts], color)
|
||||
# outline on base image
|
||||
cv2.polylines(img, [pts], isClosed=True, color=color, thickness=2)
|
||||
# put class text at first point
|
||||
x, y = int(pts[0, 0]), int(pts[0, 1]) - 6
|
||||
cv2.putText(
|
||||
img,
|
||||
str(cls),
|
||||
(x, max(6, y)),
|
||||
cv2.FONT_HERSHEY_SIMPLEX,
|
||||
0.6,
|
||||
(255, 255, 255),
|
||||
2,
|
||||
cv2.LINE_AA,
|
||||
)
|
||||
if draw_bbox_for_poly:
|
||||
x, y, w_box, h_box = cv2.boundingRect(pts)
|
||||
cv2.rectangle(img, (x, y), (x + w_box, y + h_box), color, 1)
|
||||
# YOLO bbox case (4 coords)
|
||||
elif len(coords) == 4:
|
||||
x1, y1, x2, y2 = yolo_bbox_to_xyxy(coords, w, h)
|
||||
color = random_color_for_class(cls)
|
||||
cv2.rectangle(img, (x1, y1), (x2, y2), color, 2)
|
||||
cv2.putText(
|
||||
img,
|
||||
str(cls),
|
||||
(x1, max(6, y1 - 4)),
|
||||
cv2.FONT_HERSHEY_SIMPLEX,
|
||||
0.6,
|
||||
(255, 255, 255),
|
||||
2,
|
||||
cv2.LINE_AA,
|
||||
)
|
||||
else:
|
||||
# Unknown / invalid format, skip
|
||||
continue
|
||||
|
||||
# blend overlay for filled polygons
|
||||
cv2.addWeighted(overlay, alpha, img, 1 - alpha, 0, img)
|
||||
return img
|
||||
|
||||
|
||||
def load_labels_file(label_path):
|
||||
labels = []
|
||||
with open(label_path, "r") as f:
|
||||
for raw in f:
|
||||
line = raw.strip()
|
||||
if not line:
|
||||
continue
|
||||
parsed = parse_label_line(line)
|
||||
if parsed:
|
||||
labels.append(parsed)
|
||||
return labels
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Show YOLO segmentation / polygon annotations"
|
||||
)
|
||||
parser.add_argument("image", type=str, help="Path to image file")
|
||||
parser.add_argument("labels", type=str, help="Path to YOLO label file (polygons)")
|
||||
parser.add_argument(
|
||||
"--alpha", type=float, default=0.4, help="Polygon fill alpha (0..1)"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--no-bbox", action="store_true", help="Don't draw bounding boxes for polygons"
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
img_path = Path(args.image)
|
||||
lbl_path = Path(args.labels)
|
||||
|
||||
if not img_path.exists():
|
||||
print("Image not found:", img_path)
|
||||
sys.exit(1)
|
||||
if not lbl_path.exists():
|
||||
print("Label file not found:", lbl_path)
|
||||
sys.exit(1)
|
||||
|
||||
img = cv2.imread(str(img_path), cv2.IMREAD_COLOR)
|
||||
if img is None:
|
||||
print("Could not load image:", img_path)
|
||||
sys.exit(1)
|
||||
|
||||
labels = load_labels_file(str(lbl_path))
|
||||
if not labels:
|
||||
print("No labels parsed from", lbl_path)
|
||||
# continue and just show image
|
||||
out = draw_annotations(
|
||||
img.copy(), labels, alpha=args.alpha, draw_bbox_for_poly=(not args.no_bbox)
|
||||
)
|
||||
|
||||
# Convert BGR -> RGB for matplotlib display
|
||||
out_rgb = cv2.cvtColor(out, cv2.COLOR_BGR2RGB)
|
||||
plt.figure(figsize=(10, 10 * out.shape[0] / out.shape[1]))
|
||||
plt.imshow(out_rgb)
|
||||
plt.axis("off")
|
||||
plt.title(f"{img_path.name} ({lbl_path.name})")
|
||||
plt.show()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
109
tests/test_16bit_tiff_loading.py
Normal file
109
tests/test_16bit_tiff_loading.py
Normal file
@@ -0,0 +1,109 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for 16-bit TIFF loading and normalization.
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
import tifffile
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add parent directory to path to import modules
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
from src.utils.image import Image
|
||||
|
||||
|
||||
def create_test_16bit_tiff(output_path: str) -> str:
|
||||
"""Create a test 16-bit grayscale TIFF file.
|
||||
|
||||
Args:
|
||||
output_path: Path where to save the test TIFF
|
||||
|
||||
Returns:
|
||||
Path to the created TIFF file
|
||||
"""
|
||||
# Create a 16-bit grayscale test image (100x100)
|
||||
# With values ranging from 0 to 65535 (full 16-bit range)
|
||||
height, width = 100, 100
|
||||
|
||||
# Create a gradient pattern
|
||||
test_data = np.zeros((height, width), dtype=np.uint16)
|
||||
for i in range(height):
|
||||
for j in range(width):
|
||||
# Create a diagonal gradient
|
||||
test_data[i, j] = int((i + j) / (height + width - 2) * 65535)
|
||||
|
||||
# Save as TIFF
|
||||
tifffile.imwrite(output_path, test_data)
|
||||
print(f"Created test 16-bit TIFF: {output_path}")
|
||||
print(f" Shape: {test_data.shape}")
|
||||
print(f" Dtype: {test_data.dtype}")
|
||||
print(f" Min value: {test_data.min()}")
|
||||
print(f" Max value: {test_data.max()}")
|
||||
|
||||
return output_path
|
||||
|
||||
|
||||
def test_image_loading():
|
||||
"""Test loading 16-bit TIFF with the Image class."""
|
||||
print("\n=== Testing Image Loading ===")
|
||||
|
||||
# Create temporary test file
|
||||
with tempfile.NamedTemporaryFile(suffix=".tif", delete=False) as tmp:
|
||||
test_path = tmp.name
|
||||
|
||||
try:
|
||||
# Create test image
|
||||
create_test_16bit_tiff(test_path)
|
||||
|
||||
# Load with Image class
|
||||
print("\nLoading with Image class...")
|
||||
img = Image(test_path)
|
||||
|
||||
print(f"Successfully loaded image:")
|
||||
print(f" Width: {img.width}")
|
||||
print(f" Height: {img.height}")
|
||||
print(f" Channels: {img.channels}")
|
||||
print(f" Dtype: {img.dtype}")
|
||||
print(f" Format: {img.format}")
|
||||
|
||||
# Test normalization
|
||||
print("\nTesting normalization to float32 [0-1]...")
|
||||
normalized = img.to_normalized_float32()
|
||||
|
||||
print(f"Normalized image:")
|
||||
print(f" Shape: {normalized.shape}")
|
||||
print(f" Dtype: {normalized.dtype}")
|
||||
print(f" Min value: {normalized.min():.6f}")
|
||||
print(f" Max value: {normalized.max():.6f}")
|
||||
print(f" Mean value: {normalized.mean():.6f}")
|
||||
|
||||
# Verify normalization
|
||||
assert normalized.dtype == np.float32, "Dtype should be float32"
|
||||
assert (
|
||||
0.0 <= normalized.min() <= normalized.max() <= 1.0
|
||||
), "Values should be in [0, 1]"
|
||||
|
||||
print("\n✓ All tests passed!")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n✗ Test failed with error: {e}")
|
||||
import traceback
|
||||
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
finally:
|
||||
# Cleanup
|
||||
if os.path.exists(test_path):
|
||||
os.remove(test_path)
|
||||
print(f"\nCleaned up test file: {test_path}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = test_image_loading()
|
||||
sys.exit(0 if success else 1)
|
||||
150
tests/test_yolo_16bit_float32.py
Normal file
150
tests/test_yolo_16bit_float32.py
Normal file
@@ -0,0 +1,150 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for YOLO preprocessing of 16-bit TIFF images with float32 passthrough.
|
||||
Verifies that no uint8 conversion occurs and data is preserved.
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
import tifffile
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add parent directory to path to import modules
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
from src.model.yolo_wrapper import YOLOWrapper
|
||||
|
||||
|
||||
def create_test_16bit_tiff(output_path: str) -> str:
|
||||
"""Create a test 16-bit grayscale TIFF file.
|
||||
|
||||
Args:
|
||||
output_path: Path where to save the test TIFF
|
||||
|
||||
Returns:
|
||||
Path to the created TIFF file
|
||||
"""
|
||||
# Create a 16-bit grayscale test image (200x200)
|
||||
# With specific values to test precision preservation
|
||||
height, width = 200, 200
|
||||
|
||||
# Create a gradient pattern with the full 16-bit range
|
||||
test_data = np.zeros((height, width), dtype=np.uint16)
|
||||
for i in range(height):
|
||||
for j in range(width):
|
||||
# Create a diagonal gradient using full 16-bit range
|
||||
test_data[i, j] = int((i + j) / (height + width - 2) * 65535)
|
||||
|
||||
# Save as TIFF
|
||||
tifffile.imwrite(output_path, test_data)
|
||||
print(f"Created test 16-bit TIFF: {output_path}")
|
||||
print(f" Shape: {test_data.shape}")
|
||||
print(f" Dtype: {test_data.dtype}")
|
||||
print(f" Min value: {test_data.min()}")
|
||||
print(f" Max value: {test_data.max()}")
|
||||
print(
|
||||
f" Sample values: {test_data[50, 50]}, {test_data[100, 100]}, {test_data[150, 150]}"
|
||||
)
|
||||
|
||||
return output_path
|
||||
|
||||
|
||||
def test_float32_passthrough():
|
||||
"""Test that 16-bit TIFF preprocessing passes float32 directly without uint8 conversion."""
|
||||
print("\n=== Testing Float32 Passthrough (NO uint8) ===")
|
||||
|
||||
# Create temporary test file
|
||||
with tempfile.NamedTemporaryFile(suffix=".tif", delete=False) as tmp:
|
||||
test_path = tmp.name
|
||||
|
||||
try:
|
||||
# Create test image
|
||||
create_test_16bit_tiff(test_path)
|
||||
|
||||
# Create YOLOWrapper instance
|
||||
print("\nTesting YOLOWrapper._prepare_source() for float32 passthrough...")
|
||||
wrapper = YOLOWrapper()
|
||||
|
||||
# Call _prepare_source to preprocess the image
|
||||
prepared_source, cleanup_path = wrapper._prepare_source(test_path)
|
||||
|
||||
print(f"\nPreprocessing result:")
|
||||
print(f" Original path: {test_path}")
|
||||
print(f" Prepared source type: {type(prepared_source)}")
|
||||
|
||||
# Verify it returns a numpy array (not a file path)
|
||||
if isinstance(prepared_source, np.ndarray):
|
||||
print(
|
||||
f"\n✓ SUCCESS: Prepared source is a numpy array (float32 passthrough)"
|
||||
)
|
||||
print(f" Shape: {prepared_source.shape}")
|
||||
print(f" Dtype: {prepared_source.dtype}")
|
||||
print(f" Min value: {prepared_source.min():.6f}")
|
||||
print(f" Max value: {prepared_source.max():.6f}")
|
||||
print(f" Mean value: {prepared_source.mean():.6f}")
|
||||
|
||||
# Verify it's float32 in [0, 1] range
|
||||
assert (
|
||||
prepared_source.dtype == np.float32
|
||||
), f"Expected float32, got {prepared_source.dtype}"
|
||||
assert (
|
||||
0.0 <= prepared_source.min() <= prepared_source.max() <= 1.0
|
||||
), f"Expected values in [0, 1], got [{prepared_source.min()}, {prepared_source.max()}]"
|
||||
|
||||
# Verify it has 3 channels (RGB)
|
||||
assert (
|
||||
prepared_source.shape[2] == 3
|
||||
), f"Expected 3 channels (RGB), got {prepared_source.shape[2]}"
|
||||
|
||||
# Verify no quantization to 256 levels (would happen with uint8 conversion)
|
||||
unique_values = len(np.unique(prepared_source))
|
||||
print(f" Unique values: {unique_values}")
|
||||
|
||||
# With float32, we should have much more than 256 unique values
|
||||
if unique_values > 256:
|
||||
print(f"\n✓ SUCCESS: Data has {unique_values} unique values (> 256)")
|
||||
print(f" This confirms NO uint8 quantization occurred!")
|
||||
else:
|
||||
print(f"\n✗ WARNING: Data has only {unique_values} unique values")
|
||||
print(f" This might indicate uint8 quantization happened")
|
||||
|
||||
# Sample some values to show precision
|
||||
print(f"\n Sample normalized values:")
|
||||
print(f" [50, 50]: {prepared_source[50, 50, 0]:.8f}")
|
||||
print(f" [100, 100]: {prepared_source[100, 100, 0]:.8f}")
|
||||
print(f" [150, 150]: {prepared_source[150, 150, 0]:.8f}")
|
||||
|
||||
# No cleanup needed since we returned array directly
|
||||
assert (
|
||||
cleanup_path is None
|
||||
), "Cleanup path should be None for float32 pass through"
|
||||
|
||||
print("\n✓ All float32 passthrough tests passed!")
|
||||
return True
|
||||
|
||||
else:
|
||||
print(f"\n✗ FAILED: Prepared source is a file path: {prepared_source}")
|
||||
print(f" This means data was saved to disk, not passed as float32 array")
|
||||
if cleanup_path and os.path.exists(cleanup_path):
|
||||
os.remove(cleanup_path)
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n✗ Test failed with error: {e}")
|
||||
import traceback
|
||||
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
finally:
|
||||
# Cleanup
|
||||
if os.path.exists(test_path):
|
||||
os.remove(test_path)
|
||||
print(f"\nCleaned up test file: {test_path}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = test_float32_passthrough()
|
||||
sys.exit(0 if success else 1)
|
||||
126
tests/test_yolo_16bit_preprocessing.py
Normal file
126
tests/test_yolo_16bit_preprocessing.py
Normal file
@@ -0,0 +1,126 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for YOLO preprocessing of 16-bit TIFF images.
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
import tifffile
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add parent directory to path to import modules
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
from src.model.yolo_wrapper import YOLOWrapper
|
||||
from src.utils.image import Image
|
||||
from PIL import Image as PILImage
|
||||
|
||||
|
||||
def create_test_16bit_tiff(output_path: str) -> str:
|
||||
"""Create a test 16-bit grayscale TIFF file.
|
||||
|
||||
Args:
|
||||
output_path: Path where to save the test TIFF
|
||||
|
||||
Returns:
|
||||
Path to the created TIFF file
|
||||
"""
|
||||
# Create a 16-bit grayscale test image (200x200)
|
||||
# With values ranging from 0 to 65535 (full 16-bit range)
|
||||
height, width = 200, 200
|
||||
|
||||
# Create a gradient pattern
|
||||
test_data = np.zeros((height, width), dtype=np.uint16)
|
||||
for i in range(height):
|
||||
for j in range(width):
|
||||
# Create a diagonal gradient
|
||||
test_data[i, j] = int((i + j) / (height + width - 2) * 65535)
|
||||
|
||||
# Save as TIFF
|
||||
tifffile.imwrite(output_path, test_data)
|
||||
print(f"Created test 16-bit TIFF: {output_path}")
|
||||
print(f" Shape: {test_data.shape}")
|
||||
print(f" Dtype: {test_data.dtype}")
|
||||
print(f" Min value: {test_data.min()}")
|
||||
print(f" Max value: {test_data.max()}")
|
||||
|
||||
return output_path
|
||||
|
||||
|
||||
def test_yolo_preprocessing():
|
||||
"""Test YOLO preprocessing of 16-bit TIFF images."""
|
||||
print("\n=== Testing YOLO Preprocessing of 16-bit TIFF ===")
|
||||
|
||||
# Create temporary test file
|
||||
with tempfile.NamedTemporaryFile(suffix=".tif", delete=False) as tmp:
|
||||
test_path = tmp.name
|
||||
|
||||
try:
|
||||
# Create test image
|
||||
create_test_16bit_tiff(test_path)
|
||||
|
||||
# Create YOLOWrapper instance (no actual model loading needed for this test)
|
||||
print("\nTesting YOLOWrapper._prepare_source()...")
|
||||
wrapper = YOLOWrapper()
|
||||
|
||||
# Call _prepare_source to preprocess the image
|
||||
prepared_path, cleanup_path = wrapper._prepare_source(test_path)
|
||||
|
||||
print(f"\nPreprocessing complete:")
|
||||
print(f" Original path: {test_path}")
|
||||
print(f" Prepared path: {prepared_path}")
|
||||
print(f" Cleanup path: {cleanup_path}")
|
||||
|
||||
# Verify the prepared image exists
|
||||
assert os.path.exists(prepared_path), "Prepared image should exist"
|
||||
|
||||
# Load the prepared image and verify it's uint8 RGB
|
||||
prepared_img = PILImage.open(prepared_path)
|
||||
print(f"\nPrepared image properties:")
|
||||
print(f" Mode: {prepared_img.mode}")
|
||||
print(f" Size: {prepared_img.size}")
|
||||
print(f" Format: {prepared_img.format}")
|
||||
|
||||
# Convert to numpy to check values
|
||||
img_array = np.array(prepared_img)
|
||||
print(f" Shape: {img_array.shape}")
|
||||
print(f" Dtype: {img_array.dtype}")
|
||||
print(f" Min value: {img_array.min()}")
|
||||
print(f" Max value: {img_array.max()}")
|
||||
print(f" Mean value: {img_array.mean():.2f}")
|
||||
|
||||
# Verify it's RGB uint8
|
||||
assert prepared_img.mode == "RGB", "Prepared image should be RGB"
|
||||
assert img_array.dtype == np.uint8, "Prepared image should be uint8"
|
||||
assert img_array.shape[2] == 3, "Prepared image should have 3 channels"
|
||||
assert (
|
||||
0 <= img_array.min() <= img_array.max() <= 255
|
||||
), "Values should be in [0, 255]"
|
||||
|
||||
# Cleanup prepared file if needed
|
||||
if cleanup_path and os.path.exists(cleanup_path):
|
||||
os.remove(cleanup_path)
|
||||
print(f"\nCleaned up prepared image: {cleanup_path}")
|
||||
|
||||
print("\n✓ All YOLO preprocessing tests passed!")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n✗ Test failed with error: {e}")
|
||||
import traceback
|
||||
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
finally:
|
||||
# Cleanup
|
||||
if os.path.exists(test_path):
|
||||
os.remove(test_path)
|
||||
print(f"Cleaned up test file: {test_path}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = test_yolo_preprocessing()
|
||||
sys.exit(0 if success else 1)
|
||||
Reference in New Issue
Block a user