feat(sensors): add the ideal orthographic camera model

[janickm]

What

Adds an ideal orthographic camera model (ideal-orthographic): a
distortion-free parallel projection that drops the camera-frame depth instead of
dividing by it, so a point's image location does not depend on it.

This is NCore's first non-central camera model. Its rays are parallel and
share no common origin, so a 3d direction no longer identifies a ray:
unprojection returns 6d [origin, direction] rays, matching the layout
WorldRaysReturn already uses. CameraModel.camera_ray_dim reports which
representation a model uses (3 or 6).

Why

Bird's-eye-view raster data is naturally described by a parallel projection, and
NCore had no way to express one: FTheta, pinhole and fisheye are all central
projections. Without it, consumers hand-roll their own projection alongside
NCore's camera models, which then does not participate in the shared pose,
rolling-shutter and serialization machinery.

Orthographic is a standard projection rather than a bespoke one, e.g. OpenUSD's
GfCamera::Projection {Perspective, Orthographic} and OpenGL's glOrtho.

Design notes

The ray interface is asymmetric, which keeps the change small.
camera_rays_to_image_points receives an unnormalized camera-frame point for
every model (for a central model a point and a direction coincide up to scale;
a non-central model projects the point itself). So the world_points_to_*
family and the rolling-shutter solver work unchanged, and rolling shutter
comes for free. Only unprojection needed generalizing.

Central models are provably unaffected. Per-ray origins are now carried
through the sensor pose as R @ origin + t instead of broadcasting the pose
translation. A central model's origins are zero, so the same expression
reproduces the previous broadcast exactly, with no branch. There is a regression
test asserting this for all three central models.

Two combinations are refused, because a parallel bundle makes them
ill-defined rather than merely unimplemented:

• External distortion deflects each ray individually and would not preserve
  the parallel bundle. Rejected at construction: a ray-dimensionality guard
  alone would let the pairing survive every forward projection and only surface
  on unprojection.
• Rectification against a central model has no depth-independent solution, as
  there is no common centre to pivot about. Rectifying two non-central models is
  well-defined but not implemented yet (NotImplementedError).

paraxial_pinhole_geometry() raises via the documented opt-out: an orthographic
camera's focal length is infinite, so it has no pinhole approximation and
IdealPinholeCameraModelParameters.from_source() correctly refuses it.

Naming. pixels_per_unit is the orthographic counterpart of a pinhole's
focal_length, occupying the same place in the projection but differing in
dimension: a pinhole consumes the dimensionless x/z, this consumes x
directly. Named per-unit rather than per-meter because coordinates may be
UNITLESS (e.g. SfM reconstructions). The Ideal prefix mirrors
IdealPinholeCameraModelParameters and leaves the unqualified Orthographic
family name free for a distorted telecentric sibling, avoiding a repeat of the
retired pinhole -> opencv-pinhole identifier alias.

No serialized format changed. The model registers through the existing
register_camera_model / register_camera_model_parameters hooks, and the
discriminator was already written from type().

Also in this PR

• Renamed the forward projection to camera_points_to_image_points /
  camera_points_to_pixels (old names kept as documented-deprecated
  forwarders). See below.
• ExternalDistortionModel now guards the ray representation in its public
  methods and dispatches to _impl hooks, mirroring CameraModel. See the note
  below.
• camera_ray_dim is a ClassVar, since the ray representation is a property of
  the model type rather than of an instance.
• Extracted the image-domain scale/resolution prelude that was duplicated across
  all four transform() implementations (and dropped a redundant double
  .astype(np.uint64) in the FTheta one).

Renaming camera_rays_to_image_points

Raised in review. The forward method's argument was always an unnormalized
camera-frame point, never a ray. With only central models the distinction
was unobservable, because every central projection is scale-invariant:

Model	Forward math	Magnitude
ideal / OpenCV pinhole	cam_rays[:,:2] / cam_rays[:,2:3]	cancels
FTheta / OpenCV fisheye	atan2(xy_norm, z), then delta/xy_norm * xy	cancels
ideal orthographic	cam_rays[:,:2] * pixels_per_unit	is the answer

A non-central projection has no such freedom: the point's x and y are
precisely what is being projected, so passing a normalized direction silently
yields a different image location rather than an error. That promotes the name
from merely loose to actively misleading, so it is fixed here rather than after
release:

• camera_rays_to_image_points -> camera_points_to_image_points
• camera_rays_to_pixels -> camera_points_to_pixels

Old names remain as forwarders carrying a .. deprecated:: directive, matching
the docstring-only deprecation style already used in this module (there is no
runtime warnings.warn anywhere in the repo, so none was introduced).

Note the unprojection side keeps its name: image_points_to_camera_rays
genuinely returns rays, and for a non-central model those rays are the whole
point of the 6d representation.

Note on the ExternalDistortionModel refactor

The refactor renames the two abstract methods an external distortion model
implements (distort_camera_rays / undistort_camera_rays ->
_distort_camera_rays_impl / _undistort_camera_rays_impl), so that the public
methods can hold the ray-representation guard.

Not flagged as a breaking change: there are no out-of-tree implementations of
the abstract base, and models deriving from a concrete class such as
BivariateWindshieldModel inherit the new hooks unchanged. Were an out-of-tree
subclass of the abstract base to exist, it would fail loudly at instantiation
(Can't instantiate abstract class ...) rather than silently.

Testing

• Projection: window-fraction correctness across the full extent, depth
  invariance, out-of-window validity, and that points behind the camera stay
  valid (no frustum, unlike every other model).
• 6d rays: distinct origins with a shared direction, and the
  unprojection/projection round trip.
• World rays: per-ray origins under a rotated and translated pose, for both the
  static and rolling-shutter paths; plus a regression guard that the three
  central models are bit-identical.
• Guards: distortion rejected at construction, paraxial_pinhole_geometry() and
  from_source() raising, non-central rays rejected by the distortion model,
  and both Rectificator cases.
• Serialization round trip, transform(), and factory dispatch.
• Point semantics: central projections are scale-invariant, the orthographic one
  is not, and the deprecated aliases agree with the renamed methods. The alias
  test covers the orthographic model specifically, since it is the only one
  whose result would change if an alias perturbed its argument in passing.

bazel test //... --config=no-gpu passes (36/36, Python 3.8 and 3.11),
bazel build //... is clean under the ty aspect, and bazel run //:format.check reports no violations.

Docs

New "Central and Non-Central Models" and "Ideal Orthographic Camera Model"
sections in sensor_models.rst, a "Camera Rays" section in conventions.rst
documenting the 3d/6d representations, caveats in the external-distortion and
rectification sections, and formats.rst now lists ideal-orthographic (plus
the previously missing ideal-pinhole).

[copy-pr-bot]

Auto-sync is disabled for draft pull requests in this repository. Workflows must be run manually.

Contributors can view more details about this message here.

[janickm]

should this be a class-wide or even static property?

[janickm]

Class-wide, agreed — it never depends on instance state. Now a ClassVar[int], following the precedent at types.py:1568. Verified it works on an nn.Module subclass: readable from both class and instance, doesn't land in state_dict(), survives .to(). Test added.