Using 1 as prime number in hashgrid hash correlates noise pattern

[Speierers]

As shown in the images below, it seems that using 1 as prime numbers in the hash function of the HashGrid is correlating the noise pattern along the X axis. I suggest we remove 1 from the list of prime numbers.

Here an example reconstructing a 2D texture using the HashGrid.

With indexing_prime=1:

Without indexing_prime=1:

[DoeringChristian]

Hi,

The first prime being a 1 is intentional. This improves memory lookup performance. When looking up the value in one cell, the hashgrid is linearly interpolating between the neighboring vertices. When the first prime is 1, then this means that the values along the first dimension are contiguous in memory, and therefore are cached.
This image shows how a grid lookup profits from this correlation.

This also corresponds to the default behavior of tinycudann (see here). And is also mentioned in the InstantNGP paper

Notably, to achieve (pseudo-)independence, only
𝑑 − 1 of the 𝑑 dimensions must be permuted, so we choose 𝜋1 := 1
for better cache coherence, 𝜋2 = 2 654 435 761, and 𝜋3 = 805 459 861.

InstantNGP page 4

That being said, we could add an option to the hashgrid to switch between different prime configurations.
For now you can also inherit from the hashgrid, and just overwrite the hash function.

class PrimeHashGrid(nn.HashGridEncoding):
    def __init__(
        self,
        dtype: type[dr.ArrayBase],
        dimension: int,
        *,
        n_levels: int = 16,
        n_features_per_level: int = 2,
        hashmap_size: int = 524288,
        base_resolution: int = 16,
        per_level_scale: float = 2,
        align_corners: bool = False,
        torchngp_compat: bool = False,
        smooth_weight_gradients: bool = False,
        smooth_weight_lambda: float = 1,
        init_scale: float = 0.0001,
        rng: dr.random.Generator | None = None,
    ) -> None:
        super().__init__(
            dtype,
            dimension,
            n_levels=n_levels,
            n_features_per_level=n_features_per_level,
            hashmap_size=hashmap_size,
            base_resolution=base_resolution,
            per_level_scale=per_level_scale,
            align_corners=align_corners,
            torchngp_compat=torchngp_compat,
            smooth_weight_gradients=smooth_weight_gradients,
            smooth_weight_lambda=smooth_weight_lambda,
            init_scale=init_scale,
            rng=rng,
        )

    def hash(self, key):
        # Prime numbers used to hash the simplex vertices and calculate the lookup
        # index. These are equivalent to ones used for coherent hashing in tiny-cuda-nn.
        indexing_primes = [
            self.UInt32(2654435761),
            self.UInt32(805459861),
            self.UInt32(3674653429),
            self.UInt32(2097192037),
            self.UInt32(1434869437),
            self.UInt32(2165219737),
        ]
        index = self.UInt32(0)
        for d in range(0, self.dimension):
            index ^= key[d] * indexing_primes[d]

        return index

Kind regards
Christian