Point Visibility Check

easyPROBundle Adjustment for SfMSfMCV: Structure from Motion and SLAM

Implement a function to determine if a 3D point is visible from a camera, which is crucial in Structure from Motion and SLAM applications. This involves checking if the point is in front of the camera and its projection falls within the image bounds.

The concept of point visibility is rooted in projective geometry, where a 3D point $X, Y, Z$ is projected onto a 2D image plane using the camera's intrinsic matrix. For a point to be visible, it must satisfy two conditions: having a positive depth $Z_{cam} > 0$ and having its projected pixel coordinates $u, v$ within the image dimensions $0 \leq u < w$ and $0 \leq v < h$ .

Here are the steps to check point visibility:

Verify the point's depth is positive.
Project the 3D point onto the 2D image plane.
Check if the projected pixel coordinates are within the image bounds.

\begin{aligned} u &= \frac{K_{11}X + K_{13}Z}{Z} \\ v &= \frac{K_{22}Y + K_{23}Z}{Z} \end{aligned}

This technique is widely used in computer vision for tasks like bundle adjustment and triangulation.

Example

Input

is_visible([0, 0, 10], (640, 480), [[500,0,320],[0,500,240],[0,0,1]])

Output

True

Reasoning

Checking visibility of point (0, 0, 10):

Depth check: Z = 10 > 0 ✓ (in front of camera)
Projection: u = (500×0 + 320×10)/10 = 320 v = (500×0 + 240×10)/10 = 240
Bounds check: 0 ≤ 320 < 640 ✓, 0 ≤ 240 < 480 ✓ Point is visible.

Constraints

point_3d: [X, Y, Z] in camera coordinates
image_size: (width, height) in pixels
K: 3x3 intrinsic matrix
Return True if point is visible

Learn this in

Multi-View Geometry3D Computer Vision

More from CV: Structure from Motion and SLAM

Map Point Visibility Testhard Triangulation of 3D Pointsmedium PnP Pose from Correspondencesmedium Checkerboard Corner Detectionhard Range-Bearing Observationmedium

Concept primerPREVIEW

Point Visibility Check in Structure from Motion

Background Knowledge

3D-to-2D Projection in Computer Vision

In Structure from Motion (SfM), cameras capture 3D scenes and project them onto 2D image planes. This projection is governed by the camera intrinsic matrix and extrinsic parameters (rotation and translation). When a 3D point in world coordinates is transformed to camera coordinates, it undergoes a change of reference frame. The camera coordinate system places the optical center at the origin, with the Z-axis pointing along the optical axis (the direction the camera "looks"). For a point to be visible, it must exist in front of the camera—meaning its Z-coordinate in camera space must be positive. This is a fundamental constraint because cameras cannot see points behind them.

Projection and Image Bounds

Once a 3D point is confirmed to be in front of the camera, it must be projected onto the 2D image plane using the camera's intrinsic matrix. This projection converts 3D camera coordinates $(X_{cam}, Y_{cam}, Z_{cam})$ into 2D pixel coordinates $(u, v)$ via the perspective projection formula. However, the image sensor has finite dimensions—typically width $W$ and height $H$ pixels. A projected point is only observable if its pixel coordinates fall within the valid image bounds: $0 \leq u < W$ and $0 \leq v < H$ (or with appropriate boundary conventions). Points projecting outside these bounds are not captured by the sensor and thus cannot be observed.

Role in Bundle Adjustment

In SfM pipelines, visibility checks are critical during bundle adjustment—the optimization process that refines camera poses and 3D point positions. By determining which cameras should theoretically observe which points, visibility checks help construct the observation graph that drives the optimization. This filtering step prevents invalid correspondences from corrupting the adjustment and improves computational efficiency by avoiding unnecessary calculations for non-observable points.

Algorithm/Approach

The solution follows a two-stage filtering pipeline:

Depth Check: Transform the 3D point to camera coordinates and verify the Z-component is positive
Projection Check: Project the point onto the image plane and verify the resulting pixel coordinates lie within image bounds

This sequential approach is efficient because the depth check is computationally cheaper and eliminates many invalid points before the more expensive projection operation.

Step-by-Step Strategy

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.

solution.py

Python 3.13

Test results