3D Gaussian splat .ply not uploading

Cesium ion
1

Getting this error message when trying to upload a .ply 3DGS dataset to Cesium Ion?

point_cloud.ply

POST with passive cookie authorization must include a valid x-cesium-csrf header.

suggestions?

Thanks!

2

Hi,

This error could be caused by the application being stuck in a bad state. I would suggest trying incognito mode and see if the upload succeeds. Also a hard refresh for the application might help in this case too.

Please try the two and let us know if you are still having any issues.

Thanks,
Ankit

3

thank you, I tried in incognito mode and uploading the .ply worked, however, under my assets is shows up with another error for asset id: 4489108

5

Glad you were able to get it uploaded.

I see that asset 489108 has failed. I have reached out to our team to get more details about what could have caused this and have them investigate further.

6

thank you, the .ply I uploaded was just something captured using an xgrids scanner, then uploaded to supersplat and cropped, and then resaved again as a .ply

7

has there been any solution found for why the ply files are not working? The method I described above was just what I used for uploading, but the data didnā€™t work and returned that asset id error

9

Thanks for your patience. Our team is still investigating this issue at this time. We hope to have some additional information soon.

10

Our team has determined that this was caused by an invalid point that was set to all NaN values in the file. We are looking at updating our tiler to ignore these points. In the mean time the work around would be to edit the file to filter out any NaN points before uploading to Cesium ion. Please let us know if that helps you or if you have other issues.

11

thank you for your help! Iā€™m not sure how to edit the file to remove any NaN points? Are these considered points that are on the outskirts of the main gaussian splat cluster?

12

The NaN points (short for Not a Number) are invalid data values. They are likely caused by doing an invalid operation (such as dividing by zero). I will ask our team if they have any recommedations for how to filter out these points.

14

Interestingly, dragging-and-dropping a PLY file with NaN or ā€œinfinityā€ positions into https://superspl.at/editor loads the data and shows it, and apparently already ignores these ā€œinvalidā€ points. However, when exporting that data again, the result will still contain them (so apparently, they are only removed for the visualization, but are still contained in the data)

More generally: Iā€™m not aware of any tool that is dedicatedly focussed on this. However, such a cleanup operation should be fairly trivial to implement with every (generic) PLY reader/writer library.

Not a recommendation:
Only a hint: I just created a snippet

/*
 * www.javagl.de - JSplat
 *
 * Copyright 2026 Marco Hutter - http://www.javagl.de
 */
package de.javagl.jsplat.examples;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import de.javagl.jsplat.MutableSplat;
import de.javagl.jsplat.Splat;
import de.javagl.jsplat.io.ply.PlySplatReader;
import de.javagl.jsplat.io.ply.PlySplatWriter;
import de.javagl.jsplat.io.ply.PlySplatWriter.PlyFormat;

public class SplatFilteringExample
{
    public static void main(String[] args) throws IOException
    {
        run("./data/invalid.ply", "./data/filtered.ply");
    }

    private static void run(String inputFileName, String outputFileName)
        throws IOException
    {
        PlySplatReader r = new PlySplatReader();
        List<MutableSplat> splats =
            r.readList(new FileInputStream(inputFileName));
        List<MutableSplat> filtered = filter(splats);
        PlySplatWriter w = new PlySplatWriter(PlyFormat.BINARY_LITTLE_ENDIAN);
        w.writeList(filtered, new FileOutputStream(outputFileName));
    }

    private static <T extends Splat> List<T> filter(List<T> splats)
    {
        Predicate<T> f = s ->
        {
            if (!Float.isFinite(s.getPositionX()))
            {
                return false;
            }
            if (!Float.isFinite(s.getPositionY()))
            {
                return false;
            }
            if (!Float.isFinite(s.getPositionZ()))
            {
                return false;
            }
            return true;
        };
        List<T> filtered =
            splats.stream().filter(f).collect(Collectors.toList());
        int numRemoved = splats.size() - filtered.size();
        System.out.println(
            "Removed " + numRemoved + " of " + splats.size() + " splats");
        return filtered;
    }
}

This is actually not specific for PLY, but it is based on GitHub - javagl/JSplat: Java libraries for Gaussian splats Ā· GitHub , and removes all splats with NaN- or infinite positions from a PLY file.

A similar functionality could be implemented in other environments.

(If the PLY file is not excessively large and can somehow be shared, I could run that cleanup pass on that)

15

thanks for looking into this! I have a sample .ply dataset that I have been trying to import into Cesium Ion, Iā€™ll dm you with the link to the file so I can test it before jumping into a much larger 3DGS dataset. Iā€™m not familiar enough with how to code a tool to remove NaN points, but if these can be filtered out automatically upon upload, that would remove a huge hurdle to getting 3DGS datasets to stream via Cesium

16

I had a short look at the data set that you provided. There is literally only a single splat (out of 6.3 million splats!) that contains NaN for its position, scale, and rotation. Apart from that, the data set should be perfectly fine.

I agree that such cases should be handled more gracefully, and internally raised the issue that the upload should simply ignore these points (and maybe warn the user, saying something like ā€œIgnored X of Y points due to invalid valuesā€ or so).

Until this is addressed, implemented, and rolled out, maybe there is another solution: You can apparently use splat-transform to filter out NaN values.

The process would be as follows:

This should write the point_cloud-filtered.ply file, without the invalid values. This file can then be uploaded to Cesium ion.

Note: Right now, it will not be possible to render the result in CesiumJS, because of Regression in splats from PLY in 1.135 Ā· Issue #13041 Ā· CesiumGS/cesium Ā· GitHub . But there is a pending pull request at Fix: Gaussian splat orientation and modelMatrix transform application by danielzhong Ā· Pull Request #13245 Ā· CesiumGS/cesium Ā· GitHub that will hopefully be part of the next release.