gsplat 1.0.0

data/lib/gsplat/backend/ruby/accumulate.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Brute-force Numo alpha compositor used as a rasterization reference.
+    module RubyAccumulate
+      ALPHA_CLAMP = 0.999
+      ALPHA_SKIP = 1.0 / 255.0
+      TRANSMITTANCE_STOP = 1e-4
+
+      module_function
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def forward(means2d, conics, opacities, colors, backgrounds, width, height)
+        # rubocop:enable Metrics/ParameterLists
+        inputs = validate_inputs(means2d, conics, opacities, colors, backgrounds, width, height)
+        means2d, conics, opacities, colors, backgrounds = inputs
+        camera_count, gaussian_count = means2d.shape[0...2]
+        channel_count = colors.shape[-1]
+        pixel_count = width * height
+        pixels_x, pixels_y = pixel_coordinates(means2d.class, width, height)
+        render_colors = means2d.class.zeros(camera_count, pixel_count, channel_count)
+        render_alphas = means2d.class.zeros(camera_count, pixel_count)
+        last_ids = Numo::Int32.zeros(camera_count, pixel_count)
+        camera_count.times do |camera_index|
+          composited, transmittance, camera_last_ids = composite_camera(
+            means2d[camera_index, true, true],
+            conics[camera_index, true, true],
+            opacities[camera_index, true],
+            colors[camera_index, true, true],
+            pixels_x,
+            pixels_y,
+            gaussian_count
+          )
+          if backgrounds
+            composited += transmittance.reshape(pixel_count, 1) *
+                          backgrounds[camera_index, true].reshape(1, channel_count)
+          end
+          render_colors[camera_index, true, true] = composited
+          render_alphas[camera_index, true] = 1 - transmittance
+          last_ids[camera_index, true] = camera_last_ids + (camera_index * gaussian_count)
+        end
+        [
+          render_colors.reshape(camera_count, height, width, channel_count),
+          render_alphas.reshape(camera_count, height, width, 1),
+          last_ids.reshape(camera_count, height, width)
+        ]
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity
+      def validate_inputs(means2d, conics, opacities, colors, backgrounds, width, height)
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity
+        unless means2d.is_a?(Numo::NArray) && [Numo::SFloat, Numo::DFloat].include?(means2d.class)
+          raise ArgumentError, "means2d must be Numo::SFloat or Numo::DFloat"
+        end
+
+        valid_means = means2d.ndim == 3 && means2d.shape[-1] == 2
+        raise ShapeError, "expected means2d [C,N,2], got #{means2d.shape.inspect}" unless valid_means
+
+        leading_shape = means2d.shape[0...2]
+        conics = means2d.class.cast(conics)
+        opacities = means2d.class.cast(opacities)
+        colors = means2d.class.cast(colors)
+        valid = conics.shape == leading_shape + [3] &&
+                opacities.shape == leading_shape &&
+                colors.ndim == 3 && colors.shape[0...2] == leading_shape
+        unless valid
+          raise ShapeError,
+                "expected conics [C,N,3], opacities [C,N], and colors [C,N,D], " \
+                "got #{conics.shape.inspect}, #{opacities.shape.inspect}, and #{colors.shape.inspect}"
+        end
+        backgrounds = validate_backgrounds(means2d.class, backgrounds, means2d.shape[0], colors.shape[-1])
+        valid_size = width.is_a?(Integer) && width.positive? && height.is_a?(Integer) && height.positive?
+        raise ArgumentError, "width and height must be positive integers" unless valid_size
+
+        [means2d, conics, opacities, colors, backgrounds]
+      end
+      private_class_method :validate_inputs
+
+      def validate_backgrounds(type, backgrounds, camera_count, channel_count)
+        return nil unless backgrounds
+
+        value = type.cast(backgrounds)
+        expected = [camera_count, channel_count]
+        unless value.shape == expected
+          raise ShapeError, "expected backgrounds #{expected.inspect}, got #{value.shape.inspect}"
+        end
+
+        value
+      end
+      private_class_method :validate_backgrounds
+
+      def pixel_coordinates(type, width, height)
+        x_values = Array.new(height) { (0...width).map { |column| column + 0.5 } }.flatten
+        y_values = (0...height).flat_map { |row| Array.new(width, row + 0.5) }
+        [type.cast(x_values), type.cast(y_values)]
+      end
+      private_class_method :pixel_coordinates
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def composite_camera(means2d, conics, opacities, colors, pixels_x, pixels_y, gaussian_count)
+        # rubocop:enable Metrics/ParameterLists
+        pixel_count = pixels_x.size
+        channel_count = colors.shape[-1]
+        transmittance = means2d.class.ones(pixel_count)
+        composited = means2d.class.zeros(pixel_count, channel_count)
+        last_ids = Numo::Int32.zeros(pixel_count)
+        active = Numo::Bit.ones(pixel_count)
+        gaussian_count.times do |gaussian_index|
+          delta_x = means2d[gaussian_index, 0] - pixels_x
+          delta_y = means2d[gaussian_index, 1] - pixels_y
+          sigma = (0.5 * (
+            (conics[gaussian_index, 0] * (delta_x**2)) +
+            (conics[gaussian_index, 2] * (delta_y**2))
+          )) + (conics[gaussian_index, 1] * delta_x * delta_y)
+          alpha = opacities[gaussian_index] * Numo::NMath.exp(-sigma)
+          above_clamp = alpha.gt(ALPHA_CLAMP)
+          alpha[above_clamp] = ALPHA_CLAMP if above_clamp.any?
+          candidate = active & sigma.ge(0) & alpha.ge(ALPHA_SKIP)
+          next_transmittance = transmittance * (1 - alpha)
+          accepted = candidate & next_transmittance.gt(TRANSMITTANCE_STOP)
+          contribution = means2d.class.zeros(pixel_count)
+          contribution[accepted] = (alpha * transmittance)[accepted] if accepted.any?
+          composited += contribution.reshape(pixel_count, 1) *
+                        colors[gaussian_index, true].reshape(1, channel_count)
+          transmittance[accepted] = next_transmittance[accepted] if accepted.any?
+          last_ids[accepted] = gaussian_index if accepted.any?
+          terminating = candidate & next_transmittance.le(TRANSMITTANCE_STOP)
+          active[terminating] = 0 if terminating.any?
+          break unless active.any?
+        end
+        [composited, transmittance, last_ids]
+      end
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :composite_camera
+    end
+  end
+end

data/lib/gsplat/backend/ruby/accumulate_backward.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Brute-force compositor VJP routed through the one-tile reverse kernel.
+    module RubyAccumulateBackward
+      module_function
+
+      # rubocop:disable Metrics/ParameterLists
+      def backward(means2d, conics, opacities, colors, backgrounds, width, height,
+                   render_alphas, last_ids, grad_render_colors, grad_render_alphas)
+        # rubocop:enable Metrics/ParameterLists
+        camera_count, gaussian_count = means2d.shape[0...2]
+        offsets = Numo::Int32.zeros(camera_count, 1, 1)
+        camera_count.times { |camera_index| offsets[camera_index, 0, 0] = camera_index * gaussian_count }
+        flatten_ids = Numo::Int32.new(camera_count * gaussian_count).seq
+        gradients, = RubyRasterizeToPixelsBackward.backward(
+          means2d,
+          conics,
+          colors,
+          opacities,
+          backgrounds,
+          nil,
+          width,
+          height,
+          [width, height].max,
+          offsets,
+          flatten_ids,
+          render_alphas,
+          last_ids,
+          grad_render_colors,
+          grad_render_alphas,
+          absgrad: false
+        )
+        grad_means, grad_conics, grad_colors, grad_opacities, grad_backgrounds = gradients
+        [grad_means, grad_conics, grad_opacities, grad_colors, grad_backgrounds]
+      end
+    end
+  end
+end

data/lib/gsplat/backend/ruby/eval3d_rasterizer.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # World-space Gaussian evaluator used by 3DGUT-style rendering.
+    module RubyEval3dRasterizer
+      ALPHA_CLAMP = 0.99
+      ALPHA_SKIP = 1.0 / 255
+      TRANSMITTANCE_STOP = 1e-4
+
+      module_function
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def forward(means, quats, scales, colors, opacities, backgrounds, viewmats:, intrinsics:,
+                  width:, height:, tile_size:, offsets:, flatten_ids:, camera_model:,
+                  use_hit_distance: false, return_normals: false)
+        # rubocop:enable Metrics/AbcSize, Metrics/ParameterLists
+        values = validate_inputs(
+          means, quats, scales, colors, opacities, backgrounds, viewmats, intrinsics,
+          width, height, offsets, flatten_ids, camera_model
+        )
+        means, quats, scales, colors, opacities, backgrounds, viewmats, intrinsics = values
+        camera_count, gaussian_count, channels = colors.shape
+        rendered = means.class.zeros(camera_count, height, width, channels)
+        alphas = means.class.zeros(camera_count, height, width, 1)
+        rendered_normals = means.class.zeros(camera_count, height, width, 3)
+        rotations = Math::Quaternion.to_rotmat(quats)
+        camera_count.times do |camera|
+          frame = camera_frame(viewmats[camera, true, true])
+          height.times do |row|
+            width.times do |column|
+              tile_x = column / tile_size
+              tile_y = row / tile_size
+              range = intersection_range(offsets, flatten_ids, camera, tile_x, tile_y)
+              ray = ray_for_pixel(frame, intrinsics[camera, true, true], column, row)
+              pixel, transmittance, pixel_normal = composite_pixel(
+                means, rotations, scales, colors, opacities, flatten_ids, range,
+                camera, gaussian_count, ray, use_hit_distance, return_normals
+              )
+              pixel += backgrounds[camera, true] * transmittance if backgrounds
+              rendered[camera, row, column, true] = pixel
+              alphas[camera, row, column, 0] = 1 - transmittance
+              rendered_normals[camera, row, column, true] = pixel_normal
+            end
+          end
+        end
+        [rendered, alphas, rendered_normals]
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity
+      def validate_inputs(means, quats, scales, colors, opacities, backgrounds, viewmats,
+                          intrinsics, width, height, offsets, flatten_ids, camera_model)
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/PerceivedComplexity
+        unless camera_model == "pinhole"
+          raise ArgumentError, "hit-distance rendering currently requires pinhole camera_model"
+        end
+
+        type = means.class
+        quats = type.cast(quats)
+        scales = type.cast(scales)
+        colors = type.cast(colors)
+        opacities = type.cast(opacities)
+        viewmats = type.cast(viewmats)
+        intrinsics = type.cast(intrinsics)
+        camera_count = viewmats.shape[0]
+        gaussian_count = means.shape[0]
+        valid = means.shape == [gaussian_count, 3] &&
+                quats.shape == [gaussian_count, 4] &&
+                scales.shape == [gaussian_count, 3] &&
+                colors.ndim == 3 && colors.shape[0...2] == [camera_count, gaussian_count] &&
+                opacities.shape == [camera_count, gaussian_count] &&
+                intrinsics.shape == [camera_count, 3, 3]
+        raise ShapeError, "invalid world-space rasterization inputs" unless valid
+        raise ArgumentError, "scales must be positive" unless scales.gt(0).all?
+
+        backgrounds = type.cast(backgrounds) if backgrounds
+        if backgrounds && backgrounds.shape != [camera_count, colors.shape[-1]]
+          raise ShapeError, "expected backgrounds [#{camera_count},#{colors.shape[-1]}]"
+        end
+        raise ArgumentError, "width and height must be positive" unless width.positive? && height.positive?
+        raise ShapeError, "expected offsets [C,TH,TW]" unless offsets.shape[0] == camera_count
+        raise ShapeError, "expected flatten_ids [M]" unless flatten_ids.ndim == 1
+
+        [means, quats, scales, colors, opacities, backgrounds, viewmats, intrinsics]
+      end
+      private_class_method :validate_inputs
+
+      def camera_frame(viewmat)
+        rotation = viewmat[0...3, 0...3]
+        translation = viewmat[0...3, 3]
+        [-translation.dot(rotation), rotation]
+      end
+      private_class_method :camera_frame
+
+      def ray_for_pixel(frame, intrinsics, column, row)
+        origin, rotation = frame
+        camera_direction = origin.class[
+          (column + 0.5 - intrinsics[0, 2]) / intrinsics[0, 0],
+          (row + 0.5 - intrinsics[1, 2]) / intrinsics[1, 1],
+          1.0
+        ]
+        direction = camera_direction.dot(rotation)
+        [origin, direction / ::Math.sqrt((direction**2).sum)]
+      end
+      private_class_method :ray_for_pixel
+
+      def intersection_range(offsets, flatten_ids, camera, tile_x, tile_y)
+        tile_height, tile_width = offsets.shape[-2..]
+        flat = (((camera * tile_height) + tile_y) * tile_width) + tile_x
+        start_index = offsets[flat].to_i
+        end_index = flat + 1 < offsets.size ? offsets[flat + 1].to_i : flatten_ids.size
+        start_index...end_index
+      end
+      private_class_method :intersection_range
+
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      def composite_pixel(means, rotations, scales, colors, opacities, flatten_ids, range,
+                          camera, gaussian_count, ray, use_hit_distance, return_normals)
+        # rubocop:enable Metrics/AbcSize, Metrics/ParameterLists
+        pixel = means.class.zeros(colors.shape[-1])
+        pixel_normal = means.class.zeros(3)
+        transmittance = 1.0
+        range.each do |intersection|
+          flat_id = flatten_ids[intersection].to_i
+          gaussian = flat_id % gaussian_count
+          gray_distance, hit_distance = ray_gaussian(
+            ray, means[gaussian, true], rotations[gaussian, true, true], scales[gaussian, true]
+          )
+          next unless gray_distance
+
+          opacity = opacities[camera, gaussian].to_f
+          alpha = [opacity * ::Math.exp(-0.5 * gray_distance), ALPHA_CLAMP].min
+          next if alpha < ALPHA_SKIP
+
+          next_transmittance = transmittance * (1 - alpha)
+          break if next_transmittance <= TRANSMITTANCE_STOP
+
+          weight = alpha * transmittance
+          feature = colors[camera, gaussian, true].dup
+          feature[feature.size - 1] = hit_distance if use_hit_distance
+          pixel += feature * weight
+          if return_normals
+            normal = rotations[gaussian, true, 2].dup
+            normal *= -1 if (normal * ray[1]).sum.positive?
+            pixel_normal += normal * weight
+          end
+          transmittance = next_transmittance
+        end
+        [pixel, transmittance, pixel_normal]
+      end
+      private_class_method :composite_pixel
+
+      # rubocop:disable Metrics/AbcSize
+      def ray_gaussian(ray, mean, rotation, scale)
+        origin, direction = ray
+        local_origin = (origin - mean).dot(rotation) / scale
+        local_direction = direction.dot(rotation) / scale
+        local_direction /= ::Math.sqrt((local_direction**2).sum)
+        hit_t = -(local_direction * local_origin).sum
+        return [nil, nil] if hit_t.negative?
+
+        cross = local_direction.class[
+          (local_direction[1] * local_origin[2]) - (local_direction[2] * local_origin[1]),
+          (local_direction[2] * local_origin[0]) - (local_direction[0] * local_origin[2]),
+          (local_direction[0] * local_origin[1]) - (local_direction[1] * local_origin[0])
+        ]
+        gray_distance = (cross**2).sum.to_f
+        hit_vector = scale * local_direction * hit_t
+        [gray_distance, ::Math.sqrt((hit_vector**2).sum)]
+      end
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :ray_gaussian
+    end
+  end
+end

data/lib/gsplat/backend/ruby/isect_tiles.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Gsplat
+  module Backend
+    # Numo/Ruby tile intersection enumeration and offset encoding.
+    module RubyIsectTiles
+      TILE_KEY_LOW_BITS = 32
+
+      module_function
+
+      # rubocop:disable Metrics/ParameterLists
+      def forward(means2d, radii, depths, tile_size, tile_width, tile_height, sort:)
+        # rubocop:enable Metrics/ParameterLists
+        means2d, radii, depths = validate_inputs(
+          means2d,
+          radii,
+          depths,
+          tile_size,
+          tile_width,
+          tile_height
+        )
+        camera_count, gaussian_count = means2d.shape[0...2]
+        bounds, tiles_per_gauss = tile_bounds(
+          means2d,
+          radii,
+          tile_size,
+          tile_width,
+          tile_height
+        )
+        intersection_count = tiles_per_gauss.sum.to_i
+        isect_ids = Numo::Int64.zeros(intersection_count)
+        flatten_ids = Numo::Int32.zeros(intersection_count)
+        tile_bits = tile_n_bits(tile_width, tile_height)
+        validate_key_width!(camera_count, tile_bits)
+        write_intersections!(
+          isect_ids,
+          flatten_ids,
+          bounds,
+          tiles_per_gauss,
+          depths,
+          gaussian_count,
+          tile_width,
+          tile_bits
+        )
+        if sort && intersection_count.positive?
+          keys = isect_ids.to_a
+          order = (0...intersection_count).sort_by { |index| [keys[index], index] }
+          isect_ids = isect_ids[order].dup
+          flatten_ids = flatten_ids[order].dup
+        end
+        [tiles_per_gauss, isect_ids, flatten_ids]
+      end
+
+      def offset_encode(isect_ids, camera_count, tile_width, tile_height)
+        validate_grid!(camera_count, tile_width, tile_height)
+        raise ShapeError, "expected isect_ids [M]" unless isect_ids.is_a?(Numo::NArray) && isect_ids.ndim == 1
+
+        keys = Numo::Int64.cast(isect_ids)
+        counts = Numo::Int64.zeros(camera_count, tile_height, tile_width)
+        tile_bits = tile_n_bits(tile_width, tile_height)
+        tile_mask = (1 << tile_bits) - 1
+        keys.each do |key|
+          upper = key >> TILE_KEY_LOW_BITS
+          camera_id = upper >> tile_bits
+          tile_id = upper & tile_mask
+          validate_decoded_key!(camera_id, tile_id, camera_count, tile_width, tile_height)
+          counts[camera_id, tile_id / tile_width, tile_id % tile_width] += 1
+        end
+        offsets = Numo::Int32.zeros(camera_count, tile_height, tile_width)
+        running = 0
+        counts.size.times do |index|
+          offsets[index] = running
+          running += counts[index]
+        end
+        offsets
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def validate_inputs(means2d, radii, depths, tile_size, tile_width, tile_height)
+        # rubocop:enable Metrics/ParameterLists
+        unless means2d.is_a?(Numo::NArray) && [Numo::SFloat, Numo::DFloat].include?(means2d.class)
+          raise ArgumentError, "means2d must be Numo::SFloat or Numo::DFloat"
+        end
+
+        valid_means = means2d.ndim == 3 && means2d.shape[-1] == 2
+        raise ShapeError, "expected means2d [C,N,2], got #{means2d.shape.inspect}" unless valid_means
+
+        leading_shape = means2d.shape[0...2]
+        valid_radii = [leading_shape, leading_shape + [2]].include?(radii.shape)
+        unless valid_radii && depths.shape == leading_shape
+          raise ShapeError,
+                "expected radii [C,N] or [C,N,2] and depths #{leading_shape.inspect}, " \
+                "got #{radii.shape.inspect} and #{depths.shape.inspect}"
+        end
+        validate_grid!(means2d.shape[0], tile_width, tile_height)
+        valid_tile_size = tile_size.is_a?(Integer) && tile_size.positive?
+        raise ArgumentError, "tile_size must be a positive integer" unless valid_tile_size
+
+        [means2d, means2d.class.cast(radii), means2d.class.cast(depths)]
+      end
+      private_class_method :validate_inputs
+
+      def validate_grid!(camera_count, tile_width, tile_height)
+        values = [camera_count, tile_width, tile_height]
+        return if values.all? { |value| value.is_a?(Integer) && value.positive? }
+
+        raise ArgumentError, "camera count and tile dimensions must be positive integers"
+      end
+      private_class_method :validate_grid!
+
+      # rubocop:disable Metrics/AbcSize
+      def tile_bounds(means2d, radii, tile_size, tile_width, tile_height)
+        camera_count, gaussian_count = means2d.shape[0...2]
+        bounds = Numo::Int32.zeros(camera_count, gaussian_count, 4)
+        counts = Numo::Int32.zeros(camera_count, gaussian_count)
+        elliptical = radii.ndim == 3
+        camera_count.times do |camera_index|
+          gaussian_count.times do |gaussian_index|
+            if elliptical
+              radius_x = radii[camera_index, gaussian_index, 0].to_f
+              radius_y = radii[camera_index, gaussian_index, 1].to_f
+            else
+              radius_x = radii[camera_index, gaussian_index].to_f
+              radius_y = radius_x
+            end
+            next unless radius_x.positive? && radius_y.positive?
+
+            mean_x = means2d[camera_index, gaussian_index, 0].to_f
+            mean_y = means2d[camera_index, gaussian_index, 1].to_f
+            min_x = clamp_tile(((mean_x - radius_x) / tile_size).floor, tile_width)
+            max_x = clamp_tile(((mean_x + radius_x) / tile_size).ceil, tile_width)
+            min_y = clamp_tile(((mean_y - radius_y) / tile_size).floor, tile_height)
+            max_y = clamp_tile(((mean_y + radius_y) / tile_size).ceil, tile_height)
+            bounds[camera_index, gaussian_index, true] = [min_x, min_y, max_x, max_y]
+            counts[camera_index, gaussian_index] = (max_x - min_x) * (max_y - min_y)
+          end
+        end
+        [bounds, counts]
+      end
+      # rubocop:enable Metrics/AbcSize
+      private_class_method :tile_bounds
+
+      def clamp_tile(value, maximum)
+        value.clamp(0, maximum)
+      end
+      private_class_method :clamp_tile
+
+      # rubocop:disable Metrics/ParameterLists
+      def write_intersections!(keys, flatten_ids, bounds, counts, depths, gaussian_count, tile_width, tile_bits)
+        # rubocop:enable Metrics/ParameterLists
+        write_index = 0
+        counts.shape[0].times do |camera_index|
+          gaussian_count.times do |gaussian_index|
+            next if counts[camera_index, gaussian_index].zero?
+
+            min_x, min_y, max_x, max_y = bounds[camera_index, gaussian_index, true].to_a
+            upper_camera = camera_index << tile_bits
+            depth_bits = float32_bits(depths[camera_index, gaussian_index])
+            (min_y...max_y).each do |tile_y|
+              (min_x...max_x).each do |tile_x|
+                tile_id = (tile_y * tile_width) + tile_x
+                keys[write_index] = ((upper_camera | tile_id) << TILE_KEY_LOW_BITS) | depth_bits
+                flatten_ids[write_index] = (camera_index * gaussian_count) + gaussian_index
+                write_index += 1
+              end
+            end
+          end
+        end
+      end
+      private_class_method :write_intersections!
+
+      def float32_bits(value)
+        [value.to_f].pack("g").unpack1("N")
+      end
+      private_class_method :float32_bits
+
+      def tile_n_bits(tile_width, tile_height)
+        tile_count = tile_width * tile_height
+        tile_count == 1 ? 0 : ::Math.log2(tile_count).ceil
+      end
+      private_class_method :tile_n_bits
+
+      def validate_key_width!(camera_count, tile_bits)
+        return if (camera_count - 1).bit_length + tile_bits <= TILE_KEY_LOW_BITS
+
+        raise ArgumentError, "camera and tile ids exceed the 64-bit intersection key layout"
+      end
+      private_class_method :validate_key_width!
+
+      def validate_decoded_key!(camera_id, tile_id, camera_count, tile_width, tile_height)
+        return if camera_id.between?(0, camera_count - 1) && tile_id.between?(0, (tile_width * tile_height) - 1)
+
+        raise Gsplat::Error, "intersection key contains an out-of-range camera or tile id"
+      end
+      private_class_method :validate_decoded_key!
+    end
+  end
+end