Orthographic Projection

easyFREE3D to 2D ProjectionsProjectionCV: Image Formation

Implement an orthographic projection to transform a 3D point into a 2D point. This process involves projecting a 3D point onto a 2D plane using parallel lines, which is essential in computer vision and image formation.

The concept of orthographic projection is crucial in preserving the shape and size of objects in 2D representations, particularly in CAD designs and engineering drawings. Mathematically, this can be represented as a transformation from a 3D coordinate system $(X, Y, Z)$ to a 2D coordinate system $(X, Y)$ .

To achieve this, follow these steps:

Identify the 3D point to be projected.
Apply the projection formula to obtain the 2D point.

X' = X

Y' = Y

This technique is widely used in technical drawing and architecture.

Example

Input

orthographic([10, 20, 5])

Output

[10, 20]

Reasoning

The input point_3d is one 3D point $(X, Y, Z) = (10, 20, 5)$ : two coordinates across the image plane and $Z = 5$ , the depth along the viewing direction.
Orthographic projection sends every point along parallel rays straight onto the image plane, so the formula is $X' = X$ , $Y' = Y$ , with no dependence on $Z$ .
Plugging in: $X' = 10$ and $Y' = 20$ . The depth $Z = 5$ plays no part and is discarded.
The output is a 2D point with exactly two numbers, [10, 20], in the same order and units as the input's first two coordinates.
Notice that $(10, 20, 5)$ and $(10, 20, 100)$ land on the same image point: depth is lost, so sizes don't shrink with distance. Compare perspective projection, where $X' = fX/Z$ would make the farther point appear closer to the centre.

Constraints

Return [x, y] from the 3D point

Learn this in

Image FormationCV Study Plan

More from CV: Image Formation

Perspective Projection with Intrinsicsmedium Rodrigues Rotation Formulahard Compose 3D Transformationsmedium Distortion Center Offsetmedium Undistort Pointhard

Concept primer

Background Knowledge

In computer vision and graphics, a projection is a mapping from 3D coordinates $(X, Y, Z)$ to 2D image coordinates $(x, y)$ . An orthographic (parallel) projection assumes all projection rays are parallel to each other and perpendicular to the image plane, unlike perspective projection where rays converge at a camera center. This is a good approximation when the camera is far away relative to the object size or when exact shape and dimensions (not foreshortening) matter, as in CAD and engineering drawings.

Mathematically, the simplest orthographic projection onto the image (say, the $XY$ -plane) just drops the depth coordinate: $(X, Y, Z) \to (X, Y)$ . Parallel lines in 3D remain parallel after projection, and relative distances in the projected plane are preserved up to a uniform scale. More general linear orthographic projections can involve rotations and scaling, but the essence in this problem is that depth $Z$ does not affect the 2D location.

Algorithm/Approach

For this easy version, the pattern is:

Treat the input as a 3D point with coordinates $(X, Y, Z)$ .
Apply a fixed, simple linear transformation that ignores the $Z$ component.
Output the resulting 2D point $(X, Y)$ .

Conceptually, you are applying a $2 \times 3$ projection matrix

P = \begin{bmatrix}1 & 0 & 0\\ 0 & 1 & 0\end{bmatrix}

to the 3D vector $\begin{bmatrix}X \\ Y \\ Z\end{bmatrix}$ , but for this problem you can just access the first two coordinates directly.

Step-by-Step Strategy
Parse input

Read the three coordinates $X, Y, Z$ from input (often floats or doubles).

Apply orthographic projection

Compute:
$x_{$ \text{proj} $} = X$
$y_{$ \text{proj} $} = Y$
Ignore $Z$ ; it does not appear in the formulas.

Output result

Print or return the 2D point $(x_{$ \text{proj} $}, y_{$ \text{proj} $})$ in the format required by the platform.

Example in Python-like pseudocode:

def orthographic_project(point3d):
 X, Y, Z = point3d
 x_2d = X
 y_2d = Y
 return (x_2d, y_2d)

Common Pitfalls

Overthinking the math: This problem does not require perspective division, camera intrinsics, or any trigonometry. It’s just dropping the $Z$ coordinate.
Wrong coordinate order: Make sure you know in what order $X, Y, Z$ are provided, and output only the first two in the correct order.
Unnecessary type conversion issues: If the platform uses floats/doubles, keep consistent types and formatting (e.g., required number of decimal places).

Time & Space Complexity

Time complexity: $O(1)$ per point, since it’s a constant number of assignments.
Space complexity: $O(1)$ , as you only store a fixed number of scalar values (the input 3D point and output 2D point).

solution.py

Python 3.13

Test results