Detect pixels that will be occluded when warping between views.
When warping from left to right view, occlusions occur when:
Multiple source pixels map to the same target location (the frontmost wins)
A target location receives no source pixels (disocclusion/hole)
We detect occlusions by counting how many source pixels map to each target. When multiple pixels compete for the same target, the one that gets occluded (typically the one further from the camera) is marked.
This function returns a mask indicating which source pixels are occluded.
Example
Input
detect_occlusions([[0, 0, 2, 0]], 1)
Output
[[0, 1, 0, 0]]
Reasoning
Analyzing pixel mappings (left to right with disparity [0,0,2,0]):
Pixel 0: maps to 0+0=0
Pixel 1: maps to 1+0=1
Pixel 2: maps to 2+2=4 (out of bounds, or wraps)
Pixel 3: maps to 3+0=3
Wait - with d=2 at index 2, in direction 1:
target = src + direction × disparity = 2 + 1×2 = 4 (out of bounds)
Let me reconsider: If pixel 2 has disparity 2 and moves right,
it occludes pixel 1 in the target. Pixel 1 is marked occluded.
Constraints
disparity: 2D disparity map
direction: 1 for left-to-right, -1 for right-to-left
Occlusion Detection in View Warping: Background & Strategy
Background Knowledge
View Warping and Depth-Based Projection
View warping is a fundamental technique in image-based rendering where pixels from one viewpoint are projected to another viewpoint using depth information. When you warp from a left view to a right view, each source pixel is transformed to a target location based on its 3D position (typically derived from disparity or depth maps). This transformation is mathematically defined by the camera intrinsics, extrinsics, and the depth value at each pixel. The key insight is that this warping is a many-to-one mapping: multiple source pixels can project to the same target location, and some target locations may receive no source pixels at all.
Occlusion vs. Disocclusion
Two distinct phenomena occur during warping. Occlusion happens when multiple source pixels map to the same target location—only the frontmost pixel (closest to the camera) should be visible, while others are hidden behind it. Disocclusion (or "holes") occurs when a target location receives no source pixels, revealing previously hidden regions. This problem focuses on detecting occlusions: identifying which source pixels are hidden by closer pixels in the target view. The occluded pixels are typically those with larger depth values (further from the camera) competing for the same target location.
Visibility and Depth Ordering
The core principle is that visibility is determined by depth ordering. When two pixels project to the same target location, the one with smaller depth (closer to camera) is visible, and the one with larger depth is occluded. By tracking how many pixels map to each target location and comparing their depths, you can determine which source pixels are hidden. This requires careful handling of floating-point coordinates (since warping produces non-integer target locations) and depth comparisons.
Algorithm/Approach
The general approach follows a forward warping with visibility tracking pattern:
Project each source pixel to the target view using the depth map and camera transformation
Accumulate depth information at each target location (track which source pixels map there and their depths)
Determine visibility by comparing depths at each target location—keep only the frontmost pixel
Mark occluded pixels as those that projected to a target location but were not the frontmost
This is essentially a depth-based visibility test performed in the target view space.
Step-by-Step Strategy
Step 1: Initialize Data Structures
Create an output mask initialized to False (no occlusions detected yet)
Create a depth buffer for the target view, initialized to infinity (or a large value)
Optionally, create a source index buffer to track which source pixel is currently frontmost at each target location
PRO
Continue the full explanation
You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.
PRO
Editor locked
The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.