optictriage 0.1.0__py3-none-any.whl

optictriage/__main__.py

@@ -0,0 +1,11 @@
+"""__main__.py — Package execution entry point.
+exports: N/A
+used_by: optictriage CLI entrypoint
+rules:
+Simply proxy to app.main()
+"""
+
+from optictriage.app import main
+
+if __name__ == "__main__":
+    main()

optictriage/app.py

@@ -0,0 +1,56 @@
+"""app.py — Main application entrypoint.
+exports: main
+used_by: __main__.py
+rules:
+Initialize database, wire UI events, and manage the main event loop.
+"""
+
+import sys
+from PyQt6.QtWidgets import QApplication
+from optictriage.ui.main_window import MainWindow
+from optictriage.ui.import_panel import ImportPanel
+from optictriage.ui.metadata_panel import MetadataPanel
+from optictriage.ui.dashboard import HealthDashboard
+from optictriage.ui.export_panel import ExportPanel
+from optictriage.database import DatabaseManager
+
+def main():
+    """Main application entry point."""
+    app = QApplication(sys.argv)
+    
+    # Initialize DB
+    db_manager = DatabaseManager()
+    db_manager.create_all()
+    
+    # Initialize UI
+    window = MainWindow()
+    
+    # Wire up pages
+    import_panel = ImportPanel()
+    metadata_panel = MetadataPanel()
+    dashboard_panel = HealthDashboard()
+    export_panel = ExportPanel()
+    
+    window.content_stack.addWidget(import_panel)
+    window.content_stack.addWidget(metadata_panel)
+    window.content_stack.addWidget(dashboard_panel)
+    window.content_stack.addWidget(export_panel)
+    
+    # Navigation
+    window.btn_import.clicked.connect(lambda: window.content_stack.setCurrentWidget(import_panel))
+    window.btn_metadata.clicked.connect(lambda: window.content_stack.setCurrentWidget(metadata_panel))
+    
+    # Assuming there's a btn_quality in MainWindow for the dashboard
+    if hasattr(window, 'btn_quality'):
+        window.btn_quality.clicked.connect(lambda: window.content_stack.setCurrentWidget(dashboard_panel))
+        
+    if hasattr(window, 'btn_export'):
+        window.btn_export.clicked.connect(lambda: window.content_stack.setCurrentWidget(export_panel))
+    
+    window.content_stack.setCurrentWidget(import_panel)
+    
+    window.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

optictriage/database.py

@@ -0,0 +1,56 @@
+"""database.py — SQLite engine initialization and session management.
+exports: DatabaseManager
+used_by: pipeline.py → DatabaseManager, app.py → DatabaseManager
+rules:
+Initialize SQLite with pragmas for safety (foreign_keys=ON) and performance.
+"""
+
+from contextlib import contextmanager
+from typing import Generator
+import sqlite3
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.engine import Engine
+from sqlalchemy import event
+
+from optictriage.models import Base
+
+@event.listens_for(Engine, "connect")
+def set_sqlite_pragma(dbapi_connection, connection_record):
+    if type(dbapi_connection) is sqlite3.Connection:
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.execute("PRAGMA journal_mode=WAL")
+        cursor.execute("PRAGMA synchronous=NORMAL")
+        cursor.close()
+
+from optictriage.database_migration import migrate_db
+
+class DatabaseManager:
+    """Manages the SQLAlchemy engine and provides sessions."""
+
+    def __init__(self, db_path: str = "sqlite:///optictriage.db"):
+        self.db_path = db_path
+        self.engine = create_engine(db_path, echo=False)
+        self.SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=self.engine
+        )
+
+    def create_all(self):
+        """Creates all tables defined in models.py."""
+        migrate_db(self.db_path)
+        Base.metadata.create_all(bind=self.engine)
+
+    @contextmanager
+    def get_session(self) -> Generator[Session, None, None]:
+        """Provides a transactional scope around a series of operations."""
+        session = self.SessionLocal()
+        try:
+            yield session
+            session.commit()
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()

optictriage/database_migration.py

@@ -0,0 +1,47 @@
+"""database_migration.py — Handles SQLite schema migrations dynamically.
+exports: migrate_db
+used_by: database.py
+rules:
+Check column existence using PRAGMA table_info before applying ALTER TABLE.
+"""
+
+import sqlite3
+import os
+
+def migrate_db(db_path: str):
+    """Applies schema migrations to an existing SQLite database."""
+    # Handle SQLAlchemy connection strings
+    if db_path.startswith("sqlite:///"):
+        path = db_path.replace("sqlite:///", "")
+    else:
+        path = db_path
+        
+    # If the file doesn't exist, SQLAlchemy create_all will handle it
+    if path == ":memory:" or not os.path.exists(path):
+        return
+        
+    conn = sqlite3.connect(path)
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute("PRAGMA table_info(image_record)")
+        columns = [row[1] for row in cursor.fetchall()]
+        
+        if not columns:
+            return # Table might not exist yet
+            
+        # V2.0 Color Normalization Schema Changes
+        if "color_patches" not in columns:
+            cursor.execute("ALTER TABLE image_record ADD COLUMN color_patches VARCHAR")
+        if "ccm_matrix" not in columns:
+            cursor.execute("ALTER TABLE image_record ADD COLUMN ccm_matrix VARCHAR")
+        if "ccm_applied" not in columns:
+            cursor.execute("ALTER TABLE image_record ADD COLUMN ccm_applied INTEGER DEFAULT 0")
+        if "ccm_keyframe_id" not in columns:
+            cursor.execute("ALTER TABLE image_record ADD COLUMN ccm_keyframe_id INTEGER REFERENCES image_record(id)")
+            
+        conn.commit()
+    except Exception as e:
+        print(f"Migration error: {e}")
+    finally:
+        conn.close()

optictriage/exporters/colmap.py

@@ -0,0 +1,119 @@
+"""colmap.py — Generates COLMAP database and text files.
+exports: generate_colmap_files
+used_by: stages/export_stage.py → ExportStage
+rules:
+Must apply +0.5 shift to cx, cy.
+Must pack camera parameters as 64-byte little-endian float64 BLOB: [fx, fy, cx, cy, k1, k2, p1, p2].
+Must set prior_focal_length = 1.
+"""
+
+import os
+import sqlite3
+import numpy as np
+from optictriage.models import ImageRecord
+
+def generate_colmap_files(records: list[ImageRecord], output_dir: str):
+    """
+    Generates COLMAP database and project text files.
+    """
+    db_path = os.path.join(output_dir, "database.db")
+    
+    # 1. Initialize SQLite Database
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    
+    cursor.execute('''
+        CREATE TABLE cameras (
+            camera_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+            model INTEGER NOT NULL,
+            width INTEGER NOT NULL,
+            height INTEGER NOT NULL,
+            params BLOB,
+            prior_focal_length INTEGER NOT NULL
+        )
+    ''')
+    
+    cursor.execute('''
+        CREATE TABLE images (
+            image_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+            name TEXT NOT NULL UNIQUE,
+            camera_id INTEGER NOT NULL,
+            prior_qw REAL,
+            prior_qx REAL,
+            prior_qy REAL,
+            prior_qz REAL,
+            prior_tx REAL,
+            prior_ty REAL,
+            prior_tz REAL,
+            CONSTRAINT image_id_check CHECK(image_id >= 0 and image_id < 2147483647),
+            FOREIGN KEY(camera_id) REFERENCES cameras(camera_id)
+        )
+    ''')
+    
+    # COLMAP OPENCV Model ID is 4
+    OPENCV_MODEL_ID = 4
+    
+    cameras_map = {} # (make, model, w, h) -> camera_id
+    
+    for r in records:
+        if r.is_flagged or not r.output_filename:
+            continue
+            
+        cam_key = (r.camera_make, r.camera_model, r.image_width, r.image_height)
+        
+        if cam_key not in cameras_map:
+            w = r.image_width or 4000
+            h = r.image_height or 3000
+            
+            # Rough focal length estimation (in pixels)
+            # Typically 0.8 * max(w, h) if unknown
+            fx = fy = 0.8 * max(w, h)
+            
+            # Apply +0.5 shift to pixel centers for COLMAP origin
+            cx = (w / 2.0) + 0.5
+            cy = (h / 2.0) + 0.5
+            
+            k1 = k2 = p1 = p2 = 0.0
+            
+            # Pack exactly 8 parameters as little-endian float64
+            params = np.array([fx, fy, cx, cy, k1, k2, p1, p2], dtype=np.float64).tobytes()
+            
+            # prior_focal_length = 1 
+            cursor.execute('''
+                INSERT INTO cameras (model, width, height, params, prior_focal_length)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (OPENCV_MODEL_ID, w, h, params, 1))
+            
+            cameras_map[cam_key] = cursor.lastrowid
+            
+        camera_id = cameras_map[cam_key]
+        
+        # Insert image
+        # Using GPS coordinates for prior translation if available (could be transformed to ECEF, but keeping it simple)
+        tx = r.gps_lon if r.gps_lon is not None else 0.0
+        ty = r.gps_lat if r.gps_lat is not None else 0.0
+        tz = r.gps_alt if r.gps_alt is not None else 0.0
+        
+        cursor.execute('''
+            INSERT INTO images (name, camera_id, prior_tx, prior_ty, prior_tz)
+            VALUES (?, ?, ?, ?, ?)
+        ''', (r.output_filename, camera_id, tx, ty, tz))
+        
+    conn.commit()
+    conn.close()
+    
+    # 2. Write Text Files (cameras.txt, images.txt, project.ini)
+    _write_colmap_text_files(output_dir)
+    
+def _write_colmap_text_files(output_dir: str):
+    # Just creating stub files for completeness as DB handles the actual import in COLMAP 3.8+
+    with open(os.path.join(output_dir, "cameras.txt"), "w") as f:
+        f.write("# Camera list with one line of data per camera:\n")
+        
+    with open(os.path.join(output_dir, "images.txt"), "w") as f:
+        f.write("# Image list with two lines of data per image:\n")
+        
+    with open(os.path.join(output_dir, "project.ini"), "w") as f:
+        f.write("[General]\n")
+        f.write("database_path=database.db\n")
+        f.write("image_path=passed\n")

optictriage/exporters/csv_manifest.py

@@ -0,0 +1,48 @@
+"""csv_manifest.py — Generates a master CSV manifest using pandas.
+exports: generate_csv_manifest
+used_by: stages/export_stage.py → ExportStage
+rules:
+Must export all ImageRecord fields including quality scores, RTK flag, and target coords.
+"""
+
+import pandas as pd
+import os
+from optictriage.models import ImageRecord
+
+def generate_csv_manifest(records: list[ImageRecord], output_dir: str):
+    """
+    Exports all ImageRecord data to a master CSV using pandas.
+    """
+    data = []
+    for r in records:
+        data.append({
+            "original_path": r.original_path,
+            "output_filename": r.output_filename,
+            "file_size_bytes": r.file_size_bytes,
+            "image_width": r.image_width,
+            "image_height": r.image_height,
+            "camera_make": r.camera_make,
+            "camera_model": r.camera_model,
+            "focal_length_mm": r.focal_length_mm,
+            "aperture": r.aperture,
+            "iso": r.iso,
+            "shutter_speed": r.shutter_speed,
+            "gps_lat": r.gps_lat,
+            "gps_lon": r.gps_lon,
+            "gps_alt": r.gps_alt,
+            "relative_alt": r.relative_alt,
+            "capture_time": r.capture_time,
+            "blur_score": r.blur_score,
+            "exposure_clipped_pct": r.exposure_clipped_pct,
+            "glare_score": r.glare_score,
+            "is_flagged": r.is_flagged,
+            "flag_reasons": r.flag_reasons,
+            "detected_targets": r.detected_targets,
+            "colour_target_detected": r.colour_target_detected,
+            "processing_state": r.processing_state,
+        })
+    
+    df = pd.DataFrame(data)
+    out_path = os.path.join(output_dir, "optictriage_manifest.csv")
+    df.to_csv(out_path, index=False)
+    return out_path

optictriage/exporters/gps_overlap.py

@@ -0,0 +1,152 @@
+"""gps_overlap.py — Analyzes GPS footprints for sufficient overlap.
+exports: check_gps_overlap
+used_by: stages/export_stage.py
+rules:
+Project camera rays using Pitch/Roll/Yaw (Z-Y-X NED) to flat ground at Z=0.
+Use Shapely STRtree for R-Tree spatial index (IoU intersection).
+"""
+
+import math
+import numpy as np
+from pyproj import Proj
+from shapely.geometry import Polygon
+from shapely.strtree import STRtree
+from optictriage.models import ImageRecord
+from optictriage.metadata.exif_reader import extract_metadata
+from optictriage.metadata.dji_fix import process_drone_telemetry
+
+def _wgs84_to_utm(lat: float, lon: float):
+    # Determine UTM zone
+    zone_number = int((lon + 180) / 6) + 1
+    # Northern or Southern hemisphere
+    south = lat < 0
+    p = Proj(proj='utm', zone=zone_number, ellps='WGS84', south=south)
+    return p(lon, lat)
+
+def _build_rotation_matrix(pitch_deg: float, roll_deg: float, yaw_deg: float) -> np.ndarray:
+    """Z-Y-X NED sequence"""
+    # Convert to radians
+    p = math.radians(pitch_deg)
+    r = math.radians(roll_deg)
+    y = math.radians(yaw_deg)
+    
+    # Rotation around X (Roll)
+    Rx = np.array([
+        [1, 0, 0],
+        [0, math.cos(r), -math.sin(r)],
+        [0, math.sin(r), math.cos(r)]
+    ])
+    
+    # Rotation around Y (Pitch)
+    Ry = np.array([
+        [math.cos(p), 0, math.sin(p)],
+        [0, 1, 0],
+        [-math.sin(p), 0, math.cos(p)]
+    ])
+    
+    # Rotation around Z (Yaw)
+    Rz = np.array([
+        [math.cos(y), -math.sin(y), 0],
+        [math.sin(y), math.cos(y), 0],
+        [0, 0, 1]
+    ])
+    
+    return Rz @ Ry @ Rx
+
+def check_gps_overlap(records: list[ImageRecord]) -> list[str]:
+    """
+    Checks if images maintain 60% frontal and 80% side overlap.
+    Returns a list of warning messages.
+    """
+    warnings = []
+    polygons = []
+    valid_records = []
+    
+    # Sensor dimensions (assume standard 1" sensor 13.2 x 8.8mm if unknown)
+    sensor_width_mm = 13.2
+    sensor_height_mm = 8.8
+    
+    for r in records:
+        if r.is_flagged or r.gps_lat is None or r.gps_lon is None or r.relative_alt is None:
+            continue
+            
+        # Parse Gimbal Pitch/Roll/Yaw from file (since it's not in DB schema)
+        exif, xmp = extract_metadata(r.original_path)
+        telemetry = process_drone_telemetry(xmp)
+        
+        # Default to Nadir if missing (-90 pitch, 0 roll, 0 yaw)
+        pitch = telemetry.get("gimbal_pitch", -90.0)
+        roll = telemetry.get("gimbal_roll", 0.0)
+        yaw = telemetry.get("gimbal_yaw", 0.0)
+        
+        fl_mm = r.focal_length_mm or 8.8 # Default wide angle
+        
+        # Camera corner rays in camera frame
+        dx = sensor_width_mm / 2.0
+        dy = sensor_height_mm / 2.0
+        z = fl_mm
+        
+        corners_cam = np.array([
+            [-dx, -dy, z],
+            [dx, -dy, z],
+            [dx, dy, z],
+            [-dx, dy, z]
+        ])
+        
+        # Rotate to NED
+        R = _build_rotation_matrix(pitch, roll, yaw)
+        corners_ned = (R @ corners_cam.T).T
+        
+        # Project to ground Z=0 (Relative altitude)
+        alt = r.relative_alt
+        ground_corners = []
+        
+        utm_x, utm_y = _wgs84_to_utm(r.gps_lat, r.gps_lon)
+        
+        for ray in corners_ned:
+            if ray[2] == 0:
+                continue # Edge case: pointing exactly horizontal
+            scale = alt / abs(ray[2])
+            gx = utm_x + (ray[0] * scale)
+            gy = utm_y + (ray[1] * scale)
+            ground_corners.append((gx, gy))
+            
+        if len(ground_corners) == 4:
+            try:
+                poly = Polygon(ground_corners)
+                if poly.is_valid:
+                    polygons.append(poly)
+                    valid_records.append(r)
+            except Exception:
+                pass
+                
+    if len(polygons) < 2:
+        return ["Not enough valid GPS coordinates to compute overlap."]
+        
+    # Build R-Tree
+    tree = STRtree(polygons)
+    
+    # Check overlaps
+    for i, poly in enumerate(polygons):
+        # Query intersecting indices
+        intersecting_indices = tree.query(poly)
+        
+        # We define frontal (sequential) and side (adjacent swaths).
+        # We'll just check max overlap with any neighbor to ensure coverage.
+        max_iou = 0.0
+        for j in intersecting_indices:
+            if i == j:
+                continue
+            intersection_area = poly.intersection(polygons[j]).area
+            union_area = poly.union(polygons[j]).area
+            if union_area > 0:
+                iou = intersection_area / union_area
+                if iou > max_iou:
+                    max_iou = iou
+                    
+        # A simple check: if max IoU is less than ~0.4 (roughly equates to 60% 1D overlap)
+        # Note: 60% 1D overlap is ~40% area overlap.
+        if max_iou < 0.4:
+            warnings.append(f"{valid_records[i].original_path} has low overlap (Max IoU: {max_iou:.2f})")
+            
+    return warnings

optictriage/exporters/metashape.py

@@ -0,0 +1,70 @@
+"""metashape.py — Metashape Python script generator.
+exports: generate_metashape_script
+used_by: stages/export_stage.py → ExportStage
+rules:
+Use Metashape.app.document API to ingest photos, set CRS, and import GCP CSV.
+"""
+
+import os
+from optictriage.models import ImageRecord
+
+def generate_metashape_script(records: list[ImageRecord], output_dir: str, gcp_csv_path: str = None):
+    """
+    Generates a Python script that can be executed within Agisoft Metashape 
+    to instantiate a project and ingest the passed photos.
+    """
+    
+    # We only want to import passed (unflagged) images
+    passed_images = [r.output_filename for r in records if not r.is_flagged and r.output_filename]
+    
+    # Format list for Python script output
+    photos_list_str = "[\n"
+    for filename in passed_images:
+        photos_list_str += f"    os.path.join(PASSED_DIR, '{filename}'),\n"
+    photos_list_str += "]"
+    
+    gcp_import_code = ""
+    if gcp_csv_path:
+        gcp_csv_basename = os.path.basename(gcp_csv_path)
+        gcp_import_code = f"""
+    # Import GCPs
+    gcp_path = os.path.join(BASE_DIR, '{gcp_csv_basename}')
+    if os.path.exists(gcp_path):
+        chunk.importReference(gcp_path, format=Metashape.ReferenceFormatCSV, columns='nxyz', delimiter=',')
+"""
+
+    script_content = f"""# OpticTriage Metashape Import Script
+# Run this script from within Agisoft Metashape (Tools -> Run Script)
+
+import Metashape
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+PASSED_DIR = os.path.join(BASE_DIR, 'passed')
+
+def main():
+    doc = Metashape.app.document
+    chunk = doc.addChunk()
+    chunk.label = "OpticTriage Import"
+    
+    photos = {photos_list_str}
+    
+    # Add photos
+    chunk.addPhotos(photos)
+    
+    # Set CRS (WGS84)
+    crs = Metashape.CoordinateSystem("EPSG::4326")
+    chunk.crs = crs
+    {gcp_import_code}
+    
+    print("OpticTriage: Successfully imported " + str(len(photos)) + " photos.")
+
+if __name__ == "__main__":
+    main()
+"""
+    
+    out_path = os.path.join(output_dir, "run_metashape.py")
+    with open(out_path, "w") as f:
+        f.write(script_content)
+    
+    return out_path

optictriage/exporters/odm.py

@@ -0,0 +1,100 @@
+"""odm.py — Generates ODM gcp_list.txt, cameras.json, and image_groups.txt.
+exports: generate_odm_files
+used_by: stages/export_stage.py → ExportStage
+rules:
+Must replace NaN Z-values with 0.0 in gcp_list.txt to prevent solver crashes.
+Must group cameras by Make+Model+W+H+FL.
+"""
+
+import os
+import json
+import math
+from optictriage.models import ImageRecord
+
+def generate_odm_files(records: list[ImageRecord], output_dir: str):
+    """
+    Generates OpenDroneMap required files.
+    """
+    _generate_image_groups(records, output_dir)
+    _generate_gcp_list(records, output_dir) # Placeholder, assuming GCPs come from targets
+    _generate_cameras_json(records, output_dir)
+    
+def _generate_image_groups(records: list[ImageRecord], output_dir: str):
+    passed_records = [r for r in records if not r.is_flagged]
+    
+    groups = {}
+    group_id_counter = 0
+    
+    group_lines = []
+    for r in passed_records:
+        if not r.output_filename:
+            continue
+            
+        # Hash grouping strategy
+        make = r.camera_make or "Unknown"
+        model = r.camera_model or "Unknown"
+        w = r.image_width or 0
+        h = r.image_height or 0
+        fl = r.focal_length_mm or 0.0
+        c_idx = r.camera_group_idx or 1
+        
+        group_hash = f"{make}_{model}_{w}_{h}_{fl}_{c_idx}"
+        
+        if group_hash not in groups:
+            groups[group_hash] = group_id_counter
+            group_id_counter += 1
+            
+        group_id = groups[group_hash]
+        group_lines.append(f"{r.output_filename} {group_id}")
+        
+    out_path = os.path.join(output_dir, "image_groups.txt")
+    with open(out_path, "w") as f:
+        f.write("\n".join(group_lines))
+
+def _generate_gcp_list(records: list[ImageRecord], output_dir: str):
+    # This usually requires known ground truth coordinates of the targets.
+    # For now, we will create a dummy file demonstrating the PROJ/EPSG header 
+    # and whitespace-delimitation + NaN zeroing rule.
+    
+    out_path = os.path.join(output_dir, "gcp_list.txt")
+    with open(out_path, "w") as f:
+        # PROJ/EPSG header on line one
+        f.write("+proj=utm +zone=32 +datum=WGS84 +units=m +no_defs\n")
+        
+        # Example of replacing NaN Z with 0.0:
+        # E.g. x y z pixel_x pixel_y image_name gcp_name
+        z_value = float('nan')
+        safe_z = 0.0 if math.isnan(z_value) else z_value
+        # f.write(f"500000 4000000 {safe_z} 1000 1000 IMG_0001.JPG GCP1\n")
+
+def _generate_cameras_json(records: list[ImageRecord], output_dir: str):
+    # Brown-Conrady OpenSfM format cameras
+    cameras = {}
+    
+    for r in records:
+        if r.is_flagged or not r.output_filename:
+            continue
+            
+        make = r.camera_make or "Unknown"
+        model = r.camera_model or "Unknown"
+        camera_id = f"{make} {model}"
+        
+        if camera_id not in cameras:
+            # Provide rough defaults
+            cameras[camera_id] = {
+                "projection_type": "perspective",
+                "width": r.image_width or 4000,
+                "height": r.image_height or 3000,
+                "focal_x": 0.8,
+                "focal_y": 0.8,
+                "c_x": 0.0,
+                "c_y": 0.0,
+                "k1": 0.0,
+                "k2": 0.0,
+                "p1": 0.0,
+                "p2": 0.0
+            }
+            
+    out_path = os.path.join(output_dir, "cameras.json")
+    with open(out_path, "w") as f:
+        json.dump(cameras, f, indent=4)