intermediate seam fix algorithm

DAPModel.mlpackage/Data/com.apple.CoreML/model.mlmodel

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5696ae403e0a1861cc444ab08f34fbb5581c928ea244c2fca2a03fe395e0378e
-size 402224
+oid sha256:9c4d8be6cd9706f04b67b096824b2ca80f1ebfc99bc99650ba234122d52741d4
+size 402181

DAPModel.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8117c7e3129387f5219184f5e2d3a5c7c946c6f7905d39737a895dc29d6177c9
-size 1344013056
+oid sha256:076cab651f9e9f84120e924c5720f228b9c3d73afa615f03f8471040909a4002
+size 1338508032

DAPModel.mlpackage/Manifest.json

@@ -1,18 +1,18 @@
 {
     "fileFormatVersion": "1.0.0",
     "itemInfoEntries": {
-        "47133C03-7196-4F41-A4BA-71E0277FD33B": {
-            "author": "com.apple.CoreML",
-            "description": "CoreML Model Specification",
-            "name": "model.mlmodel",
-            "path": "com.apple.CoreML/model.mlmodel"
-        },
-        "BDE59133-8A31-4AEB-B879-19F2D41BD3A9": {
+        "509E05FC-B781-4EA5-A00E-7F81D58BD1E4": {
             "author": "com.apple.CoreML",
             "description": "CoreML Model Weights",
             "name": "weights",
             "path": "com.apple.CoreML/weights"
+        },
+        "5AA90D09-387D-4A76-B4A4-1520C0177479": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
         }
     },
-    "rootModelIdentifier": "47133C03-7196-4F41-A4BA-71E0277FD33B"
+    "rootModelIdentifier": "5AA90D09-387D-4A76-B4A4-1520C0177479"
 }

DepthPredictor.swift

@@ -18,60 +18,104 @@ import CoreImage
 import CoreGraphics
 import AppKit
 
-// MARK: - Colormap LUTs
+// MARK: - Colormap LUTs (computed once, cached)
 
-/// Precomputed jet colormap lookup table (256 entries)
-func jetColormapLUT() -> [(r: UInt8, g: UInt8, b: UInt8)] {
-    var lut: [(r: UInt8, g: UInt8, b: UInt8)] = []
-    lut.reserveCapacity(256)
-    for i in 0...255 {
-        let t = Float(i) / 255.0
-        var r: Float, g: Float, b: Float
+/// Packed RGB colormap entry — stored contiguously for cache-friendly LUT access.
+struct RGB {
+    let r: UInt8
+    let g: UInt8
+    let b: UInt8
+}
 
+/// Precomputed jet colormap lookup table (256 entries, built once).
+let jetLUT: [RGB] = {
+    (0...255).map { i in
+        let t = Float(i) / 255.0
+        let r, g, b: Float
         if t < 1.0 / 3.0 {
             r = 0; g = 0
-            b = 0.5 + 0.5 * (t / (1.0 / 3.0))
+            b = 0.5 + 0.5 * (t * 3.0)
         } else if t < 2.0 / 3.0 {
+            let u = (t - 1.0 / 3.0) * 3.0
             r = 0
-            g = 0.5 + 0.5 * ((t - 1.0 / 3.0) / (1.0 / 3.0))
-            b = 1.0 - (t - 1.0 / 3.0) / (1.0 / 3.0) * 0.5
+            g = 0.5 + 0.5 * u
+            b = 1.0 - u * 0.5
         } else {
-            r = 0.5 + 0.5 * ((t - 2.0 / 3.0) / (1.0 / 3.0))
-            g = 1.0 - (t - 2.0 / 3.0) / (1.0 / 3.0) * 0.5
+            let u = (t - 2.0 / 3.0) * 3.0
+            r = 0.5 + 0.5 * u
+            g = 1.0 - u * 0.5
             b = 0
         }
-
-        lut.append((
+        return RGB(
             r: UInt8(round(max(0, min(1, r)) * 255)),
             g: UInt8(round(max(0, min(1, g)) * 255)),
             b: UInt8(round(max(0, min(1, b)) * 255))
-        ))
+        )
     }
-    return lut
-}
+}()
 
-/// Turbo colormap (Google's perceptually-uniform alternative to jet)
-func turboColormapLUT() -> [(r: UInt8, g: UInt8, b: UInt8)] {
-    func turboChannel(_ t: Float, _ c: [Float]) -> Float {
+/// Turbo colormap (Google's perceptually-uniform alternative to jet, built once).
+let turboLUT: [RGB] = {
+    func channel(_ t: Float, _ c: (Float, Float, Float, Float, Float, Float)) -> Float {
         let t2 = t * t, t3 = t2 * t, t4 = t3 * t, t5 = t4 * t
-        return max(0, min(1, c[0] * t5 + c[1] * t4 + c[2] * t3 + c[3] * t2 + c[4] * t + c[5]))
+        return max(0, min(1, c.0 * t5 + c.1 * t4 + c.2 * t3 + c.3 * t2 + c.4 * t + c.5))
+    }
+    let rC = (-6.3733615 as Float, 15.04266179 as Float, -13.85162213 as Float,
+               5.08578778 as Float, -0.83861766 as Float, 0.16457028 as Float)
+    let gC = ( 2.25531523 as Float, -11.37426878 as Float, 21.82122831 as Float,
+             -18.71443039 as Float,   6.26060447 as Float, -0.68049933 as Float)
+    let bC = (-4.13513668 as Float,   6.56872416 as Float,  4.79961124 as Float,
+              -4.01387798 as Float,   1.33503302 as Float,  0.0088154  as Float)
+    return (0...255).map { i in
+        let t = Float(i) / 255.0
+        return RGB(
+            r: UInt8(round(channel(t, rC) * 255)),
+            g: UInt8(round(channel(t, gC) * 255)),
+            b: UInt8(round(channel(t, bC) * 255))
+        )
+    }
+}()
+
+// MARK: - MLMultiArray Helpers
+
+/// Provides direct, strided read access to an MLMultiArray's Float32 data
+/// without copying. The caller must keep the source MLMultiArray alive for
+/// the lifetime of this wrapper.
+struct DepthArrayView {
+    let ptr: UnsafeMutablePointer<Float32>
+    let width: Int
+    let height: Int
+    let rowStride: Int  // stride between rows in Float32 units
+
+    init(_ multiArray: MLMultiArray) {
+        width = multiArray.shape[3].intValue
+        height = multiArray.shape[2].intValue
+        rowStride = multiArray.strides[2].intValue
+        ptr = multiArray.dataPointer.bindMemory(to: Float32.self, capacity: height * rowStride)
     }
 
-    let rC: [Float] = [-6.3733615, 15.04266179, -13.85162213, 5.08578778, -0.83861766, 0.16457028]
-    let gC: [Float] = [2.25531523, -11.37426878, 21.82122831, -18.71443039, 6.26060447, -0.68049933]
-    let bC: [Float] = [-4.13513668, 6.56872416, 4.79961124, -4.01387798, 1.33503302, 0.0088154]
+    /// Read a single value at (row, col).
+    @inline(__always)
+    func value(row: Int, col: Int) -> Float32 {
+        ptr[row * rowStride + col]
+    }
 
-    var lut: [(r: UInt8, g: UInt8, b: UInt8)] = []
-    lut.reserveCapacity(256)
-    for i in 0...255 {
-        let t = Float(i) / 255.0
-        lut.append((
-            r: UInt8(round(turboChannel(t, rC) * 255)),
-            g: UInt8(round(turboChannel(t, gC) * 255)),
-            b: UInt8(round(turboChannel(t, bC) * 255))
-        ))
+    /// Compute min/max across all values (skipping non-positive).
+    func minMax() -> (min: Float32, max: Float32) {
+        var lo: Float32 = .greatestFiniteMagnitude
+        var hi: Float32 = -.greatestFiniteMagnitude
+        for row in 0..<height {
+            let base = row * rowStride
+            for col in 0..<width {
+                let v = ptr[base + col]
+                if v > 0 {
+                    if v < lo { lo = v }
+                    if v > hi { hi = v }
+                }
+            }
+        }
+        return (lo, hi)
     }
-    return lut
 }
 
 // MARK: - Depth Result
@@ -84,19 +128,8 @@ struct DepthResult {
     var width: Int { multiArray.shape[3].intValue }
     var height: Int { multiArray.shape[2].intValue }
 
-    /// Get all depth values as a flat Float32 array (row-major).
-    func getDepthValues() -> [Float32] {
-        let h = height, w = width
-        let planeStride = multiArray.strides[2].intValue
-        let ptr = multiArray.dataPointer.bindMemory(to: Float32.self, capacity: h * w)
-        var values = [Float32](repeating: 0, count: h * w)
-        for row in 0..<h {
-            let src = ptr.advanced(by: row * planeStride)
-            let dst = values.withUnsafeMutableBufferPointer { $0.baseAddress!.advanced(by: row * w) }
-            memcpy(dst, src, w * MemoryLayout<Float32>.stride)
-        }
-        return values
-    }
+    /// Zero-copy view into the underlying depth data.
+    var view: DepthArrayView { DepthArrayView(multiArray) }
 }
 
 // MARK: - Depth Predictor
@@ -115,11 +148,33 @@ final class DepthPredictor {
         setupModel(modelURL: modelURL, computeUnits: computeUnits)
     }
 
-    // MARK: - Inference
+    // MARK: Inference
 
     /// Predict depth from a CGImage. Completion receives a ``DepthResult`` with
     /// both a renderable CIImage and the raw Float32 depth multi-array.
-    func predictDepth(from cgImage: CGImage, completion: @escaping (DepthResult?) -> Void) {
+    ///
+    /// - Parameter fixSeam: When true, runs dual-inference seam fix: infers depth
+    ///   on both the original and a half-shifted copy, then patches the seam region
+    ///   from the shifted result into the original to eliminate edge artifacts.
+    /// - Parameter debugDir: When provided, intermediate depth maps are saved here
+    ///   for debugging (depth_original.png, depth_shifted.png, depth_stitched.png).
+    func predictDepth(
+        from cgImage: CGImage,
+        fixSeam: Bool = true,
+        debugDir: URL? = nil,
+        completion: @escaping (DepthResult?) -> Void
+    ) {
+        if fixSeam {
+            fixSeamWithDualInference(on: cgImage, debugDir: debugDir, completion: completion)
+        } else {
+            runSingleInference(on: cgImage) { result in
+                completion(result)
+            }
+        }
+    }
+
+    /// Run a single pass of depth inference on a CGImage.
+    private func runSingleInference(on cgImage: CGImage, completion: @escaping (DepthResult?) -> Void) {
         guard let visionModel else {
             print("[DepthPredictor] Model not loaded")
             completion(nil)
@@ -159,16 +214,173 @@ final class DepthPredictor {
         }
     }
 
-    // MARK: - Colormap
+    /// Fix the left/right seam by running depth inference on both the original
+    /// and a half-shifted copy, then stitching the shifted seam region into the
+    /// original depth map.
+    ///
+    /// Strategy (mirrors the Python approach):
+    /// 1. Run depth inference on the original equirectangular image.
+    /// 2. Roll the image left by half its width so the seam moves to the center.
+    /// 3. Run depth inference on the shifted image — the center of this result
+    ///    covers what was the original seam, artifact-free.
+    /// 4. Roll the original depth left by half (matching the shifted coordinate
+    ///    space), paste a strip from the shifted depth over the center, then
+    ///    roll the result back to the original orientation.
+    ///
+    /// - Parameter patchHalfWidth: Half-width of the strip (in depth-map pixels)
+    ///   to paste from the shifted depth. The total patch width is 2× this value.
+    ///   Defaults to 25 px, which works well for 1024-wide depth outputs. Scale
+    ///   proportionally for other resolutions.
+    private func fixSeamWithDualInference(
+        on cgImage: CGImage,
+        debugDir: URL?,
+        patchHalfWidth: Int = 25,
+        completion: @escaping (DepthResult?) -> Void
+    ) {
+        let imageWidth = cgImage.width
+        let half = imageWidth / 2
+
+        // Shift the source image left by half — the seam moves to the center
+        guard let shiftedImage = DepthPredictor.shiftImageHorizontally(cgImage, by: half) else {
+            print("[DepthPredictor] Failed to shift image for seam fix")
+            completion(nil)
+            return
+        }
+
+        // Debug: save shifted input
+        if let debugDir {
+            try? DepthPredictor.saveImage(
+                CIImage(cgImage: shiftedImage),
+                to: debugDir.appendingPathComponent("input_shifted.png")
+            )
+        }
+
+        // 1. Infer depth on the original image
+        runSingleInference(on: cgImage) { [weak self] originalDepth in
+            guard let self, let originalDepth else {
+                completion(nil)
+                return
+            }
+
+            if let debugDir {
+                try? DepthPredictor.saveDepthAsGrayscale(
+                    originalDepth,
+                    to: debugDir.appendingPathComponent("depth_original.png")
+                )
+            }
+
+            // 2. Infer depth on the shifted image
+            self.runSingleInference(on: shiftedImage) { shiftedDepth in
+                guard let shiftedDepth else {
+                    completion(nil)
+                    return
+                }
+
+                let w = originalDepth.width
+                let h = originalDepth.height
+
+                if let debugDir {
+                    try? DepthPredictor.saveDepthAsGrayscale(
+                        shiftedDepth,
+                        to: debugDir.appendingPathComponent("depth_shifted.png")
+                    )
+                }
+
+                // 3. Stitch: roll original depth, patch center, roll back
+                guard let stitched = self.stitchSeamFromShiftedDepth(
+                    original: originalDepth.multiArray,
+                    shifted: shiftedDepth.multiArray,
+                    width: w,
+                    height: h,
+                    depthHalf: w / 2,
+                    patchHalfWidth: patchHalfWidth
+                ) else {
+                    completion(nil)
+                    return
+                }
+
+                let ciImage = self.multiArrayToCIImage(stitched) ?? originalDepth.ciImage
+
+                if let debugDir {
+                    let stitchedResult = DepthResult(ciImage: ciImage, multiArray: stitched)
+                    try? DepthPredictor.saveDepthAsGrayscale(
+                        stitchedResult,
+                        to: debugDir.appendingPathComponent("depth_stitched.png")
+                    )
+                }
+
+                completion(DepthResult(ciImage: ciImage, multiArray: stitched))
+            }
+        }
+    }
+
+    /// Stitch the seam region using a single output buffer — no intermediate copies.
+    ///
+    /// For each output pixel (row, col), we determine whether it falls in the
+    /// patch zone (the strip around the original seam at column `depthHalf`).
+    /// If so, we read from the shifted depth at the corresponding shifted
+    /// column; otherwise we read from the original depth at `col` directly.
+    ///
+    /// This replaces the prior 3-step roll→patch→unroll with 4 temporary arrays.
+    private func stitchSeamFromShiftedDepth(
+        original: MLMultiArray,
+        shifted: MLMultiArray,
+        width: Int,
+        height: Int,
+        depthHalf: Int,
+        patchHalfWidth: Int
+    ) -> MLMultiArray? {
+        let origView = DepthArrayView(original)
+        let shiftView = DepthArrayView(shifted)
+
+        // Patch zone in the *shifted* coordinate space is centered at width/2
+        let centerX = width / 2
+        let dx = min(patchHalfWidth, centerX)
+        let patchLeft = centerX - dx
+        let patchRight = centerX + dx  // exclusive
+
+        // Create output MLMultiArray
+        let output: MLMultiArray
+        do {
+            output = try MLMultiArray(shape: original.shape.map { $0 }, dataType: original.dataType)
+        } catch {
+            print("[DepthPredictor] Failed to create MLMultiArray for stitch: \(error)")
+            return nil
+        }
+
+        let outStride = output.strides[2].intValue
+        let outPtr = output.dataPointer.bindMemory(to: Float32.self, capacity: width * height)
+
+        for row in 0..<height {
+            let outBase = row * outStride
+            for col in 0..<width {
+                // Map this output col into the shifted coordinate space:
+                // shifting left by depthHalf means shiftedCol = (col + depthHalf) % width
+                let shiftedCol = (col + depthHalf) % width
+
+                if shiftedCol >= patchLeft && shiftedCol < patchRight {
+                    // This pixel is in the patch zone — use shifted depth
+                    outPtr[outBase + col] = shiftView.value(row: row, col: shiftedCol)
+                } else {
+                    // Outside patch — use original depth (identity mapping)
+                    outPtr[outBase + col] = origView.value(row: row, col: col)
+                }
+            }
+        }
+
+        return output
+    }
+
+    // MARK: Colormap
 
     /// Apply a jet colormap to depth values -> 8-bit RGB CIImage.
     func applyJetColormap(to depth: DepthResult) -> CIImage? {
-        applyColormap(to: depth, lut: jetColormapLUT())
+        applyColormap(to: depth, lut: jetLUT)
     }
 
     /// Apply a turbo colormap to depth values -> 8-bit RGB CIImage.
     func applyTurboColormap(to depth: DepthResult) -> CIImage? {
-        applyColormap(to: depth, lut: turboColormapLUT())
+        applyColormap(to: depth, lut: turboLUT)
     }
 
     /// Apply a grayscale visualization with optional contrast.
@@ -182,48 +394,41 @@ final class DepthPredictor {
         return filter.outputImage ?? ciImage
     }
 
-    private func applyColormap(to depth: DepthResult, lut: [(r: UInt8, g: UInt8, b: UInt8)]) -> CIImage? {
-        let values = depth.getDepthValues()
-        let width = depth.width
-        let height = depth.height
-
-        // Find min/max for normalization
-        var minDepth = Float.greatestFiniteMagnitude
-        var maxDepth: Float32 = -Float.greatestFiniteMagnitude
-        for i in 0..<values.count {
-            let v = values[i]
-            if v > 0 {
-                minDepth = min(minDepth, v)
-                maxDepth = max(maxDepth, v)
-            }
-        }
+    /// Apply a colormap LUT to depth values, reading directly from the
+    /// MLMultiArray without copying into an intermediate Swift array.
+    private func applyColormap(to depth: DepthResult, lut: [RGB]) -> CIImage? {
+        let dv = depth.view
+        let (minDepth, maxDepth) = dv.minMax()
         let range = maxDepth - minDepth
-        let invRange = range > 0 ? 1.0 / range : 1.0
+        let invRange: Float32 = range > 0 ? 1.0 / range : 1.0
 
-        // Map to RGBA output buffer
-        let outputBufferSize = width * height * 4
+        let outputBufferSize = dv.width * dv.height * 4
         guard let outputBuffer = malloc(outputBufferSize) else { return nil }
         defer { free(outputBuffer) }
 
         let outPtr = outputBuffer.bindMemory(to: UInt8.self, capacity: outputBufferSize)
-        for i in 0..<values.count {
-            let normalized = max(0, min(1, (values[i] - minDepth) * invRange))
-            let index = min(Int(normalized * 255), 255)
-            let color = lut[index]
-            outPtr[i * 4 + 0] = color.r
-            outPtr[i * 4 + 1] = color.g
-            outPtr[i * 4 + 2] = color.b
-            outPtr[i * 4 + 3] = 255
+        for row in 0..<dv.height {
+            let rowBase = row * dv.rowStride
+            let outRowBase = row * dv.width * 4
+            for col in 0..<dv.width {
+                let normalized = max(0, min(1, (dv.ptr[rowBase + col] - minDepth) * invRange))
+                let index = min(Int(normalized * 255), 255)
+                let color = lut[index]
+                let px = outRowBase + col * 4
+                outPtr[px]     = color.r
+                outPtr[px + 1] = color.g
+                outPtr[px + 2] = color.b
+                outPtr[px + 3] = 255
+            }
         }
 
-        // Create CGImage from RGBA buffer
         let colorSpace = CGColorSpaceCreateDeviceRGB()
         guard let bitmapContext = CGContext(
             data: outPtr,
-            width: width,
-            height: height,
+            width: dv.width,
+            height: dv.height,
             bitsPerComponent: 8,
-            bytesPerRow: width * 4,
+            bytesPerRow: dv.width * 4,
             space: colorSpace,
             bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue
         ) else { return nil }
@@ -232,49 +437,44 @@ final class DepthPredictor {
         return CIImage(cgImage: cgImage)
     }
 
-    // MARK: - Save
+    // MARK: Save
 
     /// Save depth values as a 16-bit grayscale PNG (normalized to [0, 65535]).
+    /// Reads directly from the MLMultiArray — no intermediate Float32 copy.
     static func saveDepthAsGrayscale(_ depth: DepthResult, to path: URL) throws {
-        let values = depth.getDepthValues()
-        let width = depth.width
-        let height = depth.height
-
-        // Find min/max
-        var minDepth = Float.greatestFiniteMagnitude
-        var maxDepth: Float32 = -Float.greatestFiniteMagnitude
-        for v in values {
-            if v > 0 {
-                minDepth = min(minDepth, v)
-                maxDepth = max(maxDepth, v)
-            }
-        }
+        let dv = depth.view
+        let (minDepth, maxDepth) = dv.minMax()
         let range = maxDepth - minDepth
-        let invRange = range > 0 ? 1.0 / range : 1.0
+        let invRange: Float32 = range > 0 ? 1.0 / range : 1.0
 
         // Create 16-bit grayscale buffer (big-endian)
-        let bufferSize = width * height * 2
+        let bufferSize = dv.width * dv.height * 2
         guard let buffer = malloc(bufferSize) else {
             throw NSError(domain: "DepthPredictor", code: 7,
                          userInfo: [NSLocalizedDescriptionKey: "Failed to allocate buffer"])
         }
         defer { free(buffer) }
 
-        let ptr = buffer.bindMemory(to: UInt8.self, capacity: bufferSize)
-        for i in 0..<values.count {
-            let normalized = (values[i] - minDepth) * invRange
-            let value = UInt16(max(0, min(65535, normalized * 65535)))
-            ptr[i * 2 + 0] = UInt8(value >> 8)
-            ptr[i * 2 + 1] = UInt8(value & 0xFF)
+        let outPtr = buffer.bindMemory(to: UInt8.self, capacity: bufferSize)
+        for row in 0..<dv.height {
+            let rowBase = row * dv.rowStride
+            let outRowBase = row * dv.width * 2
+            for col in 0..<dv.width {
+                let normalized = (dv.ptr[rowBase + col] - minDepth) * invRange
+                let value = UInt16(max(0, min(65535, normalized * 65535)))
+                let px = outRowBase + col * 2
+                outPtr[px]     = UInt8(value >> 8)
+                outPtr[px + 1] = UInt8(value & 0xFF)
+            }
         }
 
         let colorSpace = CGColorSpaceCreateDeviceGray()
         guard let bitmapContext = CGContext(
-            data: ptr,
-            width: width,
-            height: height,
+            data: outPtr,
+            width: dv.width,
+            height: dv.height,
             bitsPerComponent: 16,
-            bytesPerRow: width * 2,
+            bytesPerRow: dv.width * 2,
             space: colorSpace,
             bitmapInfo: CGImageAlphaInfo.none.rawValue | CGBitmapInfo.byteOrder16Big.rawValue
         ) else {
@@ -303,7 +503,7 @@ final class DepthPredictor {
         try pngData.write(to: path)
     }
 
-    // MARK: - Private
+    // MARK: Private
 
     private func setupModel(modelURL: URL, computeUnits: MLComputeUnits) {
         do {
@@ -386,17 +586,65 @@ final class DepthPredictor {
         guard let destination = CVPixelBufferGetBaseAddress(buffer) else { return nil }
 
         let planeStride = multiArray.strides[2].intValue
+        let srcBase = multiArray.dataPointer.bindMemory(to: Float32.self, capacity: height * planeStride)
+        let rowBytes = width * MemoryLayout<Float32>.stride
         for h in 0..<height {
-            let srcRow = multiArray.dataPointer.bindMemory(to: Float32.self, capacity: width * height)
-                .advanced(by: h * planeStride)
-            let dstRow = destination.advanced(by: h * width * MemoryLayout<Float32>.stride)
-            memcpy(dstRow, srcRow, width * MemoryLayout<Float32>.stride)
+            let srcRow = srcBase.advanced(by: h * planeStride)
+            let dstRow = destination.advanced(by: h * rowBytes)
+            memcpy(dstRow, srcRow, rowBytes)
         }
 
         return CIImage(cvPixelBuffer: buffer)
     }
 }
 
+// MARK: - Image Shifting
+
+extension DepthPredictor {
+    /// Horizontally roll a CGImage by `offset` pixels (positive = shift left, wrapping around).
+    ///
+    /// Draws the source image twice into a CGContext with horizontal translations
+    /// so the pixels wrap around correctly.
+    static func shiftImageHorizontally(_ cgImage: CGImage, by offset: Int) -> CGImage? {
+        let w = cgImage.width
+        let h = cgImage.height
+        let actualOffset = offset % w
+        guard actualOffset > 0 else { return cgImage }
+
+        let colorSpace = cgImage.colorSpace ?? CGColorSpaceCreateDeviceRGB()
+
+        // Try with the source bitmapInfo first, fall back to explicit RGBA
+        var bitmapInfoRaw: UInt32 = cgImage.bitmapInfo.rawValue
+        var ctx: CGContext?
+
+        ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8,
+                        bytesPerRow: 0, space: colorSpace, bitmapInfo: bitmapInfoRaw)
+        if ctx == nil {
+            bitmapInfoRaw = CGBitmapInfo.byteOrder32Little.rawValue | CGImageAlphaInfo.noneSkipLast.rawValue
+            ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8,
+                            bytesPerRow: 0, space: colorSpace, bitmapInfo: bitmapInfoRaw)
+        }
+
+        guard let context = ctx else {
+            print("[DepthPredictor] shiftImageHorizontally: CGContext creation failed (source bitmapInfo=0x\(String(cgImage.bitmapInfo.rawValue, radix: 16)))")
+            return nil
+        }
+
+        // Draw source shifted left by actualOffset (wraps: right portion appears on left)
+        context.translateBy(x: -CGFloat(actualOffset), y: 0)
+        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: w, height: h))
+        // Draw again at +w to fill the wrap-around on the right
+        context.translateBy(x: CGFloat(w), y: 0)
+        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: w, height: h))
+
+        guard let result = context.makeImage() else {
+            print("[DepthPredictor] shiftImageHorizontally: makeImage() returned nil")
+            return nil
+        }
+        return result
+    }
+}
+
 // MARK: - Image Loading
 
 extension DepthPredictor {
@@ -434,6 +682,8 @@ struct CommandLineArgs {
     let imagePath: URL
     let outputPath: URL
     let colormap: String  // "grayscale", "jet", "turbo"
+    let fixSeam: Bool
+    let debugSeamDir: URL?  // directory for intermediate seam-fix outputs
 
     static func parse() -> CommandLineArgs? {
         let args = CommandLine.arguments
@@ -442,6 +692,8 @@ struct CommandLineArgs {
         var imagePath: URL?
         var outputPath: URL?
         var colormap = "grayscale"
+        var fixSeam = true
+        var debugSeamDir: URL?
 
         var i = 1
         while i < args.count {
@@ -464,6 +716,16 @@ struct CommandLineArgs {
                 i += 1
                 if i < args.count { colormap = args[i].lowercased() }
 
+            case "-f", "--fix-seam":
+                fixSeam = true
+
+            case "--no-fix-seam":
+                fixSeam = false
+
+            case "--debug-seam":
+                i += 1
+                if i < args.count { debugSeamDir = URL(fileURLWithPath: args[i]) }
+
             case "-h", "--help":
                 printUsage()
                 return nil
@@ -496,7 +758,9 @@ struct CommandLineArgs {
             modelPath: m,
             imagePath: image,
             outputPath: output,
-            colormap: colormap
+            colormap: colormap,
+            fixSeam: fixSeam,
+            debugSeamDir: debugSeamDir
         )
     }
 
@@ -519,6 +783,10 @@ struct CommandLineArgs {
           -c, --colormap STYLE     Colormap: grayscale (default), jet, turbo
                                    grayscale = 16-bit depth values
                                    jet/turbo  = 8-bit colorized visualization
+          -f, --fix-seam           Fix left/right seam artifact via dual-inference stitch (default: on)
+              --no-fix-seam        Disable seam fixing
+              --debug-seam DIR     Save intermediate seam-fix outputs to DIR/
+                                   (depth_original.png, depth_shifted.png, depth_stitched.png)
           -h, --help               Show this help message
 
         Examples:
@@ -528,8 +796,8 @@ struct CommandLineArgs {
           # Colorized with jet colormap
           \(execName) -m DAPModel.mlpackage -i panorama.jpg -o depth.png -c jet
 
-          # Turbo colormap
-          \(execName) -m DAPModel.mlpackage -i panorama.jpg -o depth.png -c turbo
+          # Debug seam fix intermediates
+          \(execName) -m DAPModel.mlpackage -i panorama.jpg -o depth.png --debug-seam /tmp/seam_debug
 
         The model is automatically compiled on first use and cached for subsequent runs.
         """)
@@ -559,12 +827,18 @@ func main() {
         print("  Image size: \(cgImage.width)x\(cgImage.height)")
 
         // Run inference (async -> sync via semaphore)
+        let seamDebugDir: URL? = args.debugSeamDir
+        if let debugDir = seamDebugDir {
+            try FileManager.default.createDirectory(at: debugDir, withIntermediateDirectories: true)
+            print("Seam debug outputs will be saved to \(debugDir.path)")
+        }
+
         print("Running inference...")
         let startTime = CFAbsoluteTimeGetCurrent()
 
         var depthResult: DepthResult?
         let semaphore = DispatchSemaphore(value: 0)
-        predictor.predictDepth(from: cgImage) { result in
+        predictor.predictDepth(from: cgImage, fixSeam: args.fixSeam, debugDir: seamDebugDir) { result in
             depthResult = result
             semaphore.signal()
         }
@@ -614,4 +888,4 @@ func main() {
     }
 }
 
-main()
+main()

PanoramaSplat.swift

@@ -19,7 +19,7 @@ import CoreImage
 import CoreGraphics
 import AppKit
 
-// MARK: - Command Line Arguments
+// - Command Line Arguments
 
 struct CLIArgs {
     let modelPath: URL
@@ -79,7 +79,7 @@ struct CLIArgs {
     }
 }
 
-// MARK: - CoreML Depth Inference
+// - CoreML Depth Inference
 
 func compileModelIfNeeded(at url: URL) throws -> URL {
     let ext = url.pathExtension.lowercased()
@@ -147,7 +147,7 @@ func runDepthInference(modelURL: URL, image: CGImage) throws -> (depths: [Float3
     return (depths, w, h)
 }
 
-// MARK: - Image Pixel Loading
+// Image Pixel Loading
 
 /// Load image as RGBA pixels resized to target dimensions.
 func loadImagePixels(_ image: CGImage, targetW: Int, targetH: Int) -> [UInt8] {
@@ -174,7 +174,7 @@ func loadImagePixels(_ image: CGImage, targetW: Int, targetH: Int) -> [UInt8] {
     return pixels
 }
 
-// MARK: - Equirectangular to 3D Projection
+// Equirectangular to 3D Projection
 
 func equiToSphereDirection(u: Float, v: Float, width: Int, height: Int) -> (x: Float, y: Float, z: Float) {
     let lon = (u / Float(width) - 0.5) * 2.0 * Float.pi
@@ -183,7 +183,7 @@ func equiToSphereDirection(u: Float, v: Float, width: Int, height: Int) -> (x: F
     return (cosLat * cos(lon), sin(lat), cosLat * sin(lon))
 }
 
-// MARK: - PLY Export (binary_little_endian, matches Sharp format)
+// - PLY Export (binary_little_endian, matches Sharp format)
 
 func writePLY(gaussians: [(x: Float, y: Float, z: Float,
                             f0: Float, f1: Float, f2: Float,
@@ -276,7 +276,7 @@ func writePLY(gaussians: [(x: Float, y: Float, z: Float,
     try data.write(to: url, options: .atomic)
 }
 
-// MARK: - Depth Map Seam Fix
+// - Depth Map Seam Fix
 
 /// Equirectangular panoramas wrap at the left/right edges, which creates a
 /// seam artifact in the depth prediction.  Fix by:
@@ -320,7 +320,7 @@ func fixDepthSeam(_ depths: [Float32], width: Int, height: Int, band: Int = 32)
     return result
 }
 
-// MARK: - Main Pipeline
+// - Main Pipeline
 
 func main() {
     guard let args = CLIArgs.parse() else { exit(1) }

export_and_validate_coreml.py

@@ -7,7 +7,7 @@ compatible with Vision framework and the included DepthPredictor.swift.
 
 Usage:
     python export_and_validate_coreml.py
-    python export_and_validate_coreml.py --height 512 --width 1024
+    python export_and_validate_coreml.py --height 768 --width 1536
 """
 
 import os
@@ -192,8 +192,8 @@ def save_comparison_viz(depth_pt, depth_cl, metrics, output_dir):
 def main():
     parser = ArgumentParser(description="Export DAP to CoreML and validate against PyTorch")
     parser.add_argument("--image", default=os.path.join(os.path.dirname(__file__), "test", "test.png"))
-    parser.add_argument("--height", type=int, default=512)
-    parser.add_argument("--width", type=int, default=1024)
+    parser.add_argument("--height", type=int, default=768)
+    parser.add_argument("--width", type=int, default=1536)
     parser.add_argument("--model_type", choices=["vits", "vitb", "vitl", "vitg"], default="vitl")
     parser.add_argument("--weights", default=os.path.join(os.path.dirname(__file__), "model.pth"))
     parser.add_argument("--output", default=os.path.join(os.path.dirname(__file__), "DAPModel.mlpackage"))

test_output/pytorch_depth.npy

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:10c5b39aa3f1220448efd33e9b3655c2f3c642a5a4fa1d2e25f76e37dfffce93
-size 8388736
+oid sha256:a66437ea7424bcaac987f906dc805c856647d71832c6bebbe76482b8220b1aa5
+size 4718720