Add examples

app.py

@@ -95,22 +95,23 @@ def main():
 
         return ply_out_path
 
-    with gr.Blocks() as demo:
+    css = """
+        h1 {
+            text-align: center;
+            display:block;
+        }
+        """
+
+    with gr.Blocks(css=css) as demo:
         gr.Markdown(
             """
+            # Splatter Image
 
-            # Splatter Image Demo
-            [Splatter Image](https://github.com/szymanowiczs/splatter-image) (CVPR 2024) is a fast, super cheap to train method for object 3D reconstruction from a single image. 
+            **Splatter Image (CVPR 2024)** [[code](https://github.com/szymanowiczs/splatter-image), [project page](https://szymanowiczs.github.io/splatter-image)] is a fast, super cheap-to-train method for object 3D reconstruction from a single image. 
             The model used in the demo was trained on **Objaverse-LVIS on 2 A6000 GPUs for 3.5 days**.
-            On NVIDIA V100 GPU, reconstruction can be done at 38FPS and rendering at 588FPS.
-            Upload an image of an object to see how the Splatter Image does.
-            
-            **Comments:**
-            1. The first example you upload should take about 4.5 seconds (with preprocessing, saving and overhead), the following take about 1.5s.
-            2. The model does not work well on photos of humans.
-            3. The 3D viewer shows a .ply mesh extracted from a mix of 3D Gaussians. Artefacts might show - see video for more faithful results.
-            4. Best results are achieved on the datasets described in the [repository](https://github.com/szymanowiczs/splatter-image) using that code. This demo is experimental.
-            5. Our model might not be better than some state-of-the-art methods, but it is of comparable quality and is **much** cheaper to train and run.
+            Locally, on an NVIDIA V100 GPU, reconstruction (forward pass of the network) can be done at 38FPS and rendering (with Gaussian Splatting) at 588FPS.
+            Upload an image of an object or click on one of the provided examples to see how the Splatter Image does.
+            For best results clone the [main repository](https://github.com/szymanowiczs/splatter-image) and run the demo locally.
             """
             )
         with gr.Row(variant="panel"):
@@ -131,6 +132,26 @@ def main():
                         )
                 with gr.Row():
                     submit = gr.Button("Generate", elem_id="generate", variant="primary")
+
+                with gr.Row(variant="panel"): 
+                    gr.Examples(
+                        examples=[
+                            './demo_examples/01_bigmac.png',
+                            './demo_examples/02_hydrant.jpg',
+                            './demo_examples/03_spyro.png',
+                            './demo_examples/04_lysol.png',
+                            './demo_examples/05_pinapple_bottle.png',
+                            './demo_examples/06_unsplash_broccoli.png',
+                            './demo_examples/07_objaverse_backpack.png',
+                            './demo_examples/08_unsplash_chocolatecake.png',
+                            './demo_examples/09_realfusion_cherry.png',
+                            './demo_examples/10_triposr_teapot.png'
+                        ],
+                        inputs=[input_image],
+                        cache_examples=False,
+                        label="Examples",
+                        examples_per_page=20,
+                    )
             with gr.Column():
                 with gr.Row():
                     with gr.Tab("Reconstruction"):
@@ -140,6 +161,31 @@ def main():
                             interactive=False
                         )
 
+        gr.Markdown(
+        """
+            ## Comments:
+            1. If you run the demo online, the first example you upload should take about 4.5 seconds (with preprocessing, saving and overhead), the following take about 1.5s.
+            2. The 3D viewer shows a .ply mesh extracted from a mix of 3D Gaussians. This is only an approximations and artefacts might show.
+            3. Known limitations include:
+            - sphere-like artefacts on the object and white halo around it: this is due to how the .ply mesh is extracted and limitations of the Gradio viewer
+            - see-through parts of objects, especially on the back: this is due to the model performing less well on more complicated shapes
+            - back of objects are blurry: this is a model limiation due to it being deterministic
+            4. Our model is of comparable quality to state-of-the-art methods, and is **much** cheaper to train and run.
+
+            ## How does it work?
+
+            Splatter Image formulates 3D reconstruction as an image-to-image translation task. It maps the input image to another image, 
+            in which every pixel represents one 3D Gaussian and the channels of the output represent parameters of these Gaussians, including their shapes, colours and locations.
+            The resulting image thus represents a set of Gaussians (almost like a point cloud) which reconstruct the shape and colour of the object.
+            The method is very cheap: the reconstruction amounts to a single forward pass of a neural network with only 2D operators (2D convolutions and attention).
+            The rendering is also very fast, due to using Gaussian Splatting.
+            Combined, this results in very cheap training and high-quality results.
+            For more results see the [project page](https://szymanowiczs.github.io/splatter-image) and the [CVPR article](https://arxiv.org/abs/2312.13150).
+            """
+        )
+
+
+
         submit.click(fn=check_input_image, inputs=[input_image]).success(
             fn=preprocess,
             inputs=[input_image, preprocess_background],