towards PPSurf model, checking UI

app.py

@@ -4,91 +4,136 @@ from __future__ import annotations
 
 import os
 import datetime
+import subprocess
 
 import gradio as gr
 import spaces
 
 
 @spaces.GPU(duration=60 * 3)
-def run_on_gpu(input_shape, text, seed, guidance_scale):
-    print('Starting inference at {}'.format(datetime.datetime.now()))
-    from model import Model
-    model = Model()
-    res_generator = model.run(shape_path=input_shape, text=text, seed=seed, guidance_scale=guidance_scale)
+def run_on_gpu(input_shape):
+    print('Started inference at {}'.format(datetime.datetime.now()))
+    call_base = ['python', 'ppsurf/pps.py', 'rec']
+    call_args = ['pps.py',
+                 'rec',
+                 'data/{}'.format(input_shape),
+                 'results/rec/{}'.format(input_shape),
+                 ]
+    res = subprocess.check_output(call_base + call_args)
     print('Finished inference at {}'.format(datetime.datetime.now()))
-    return list(res_generator)
 
+    return res
 
 
 def main():
-    DESCRIPTION = '''# [TEXTure](https://github.com/TEXTurePaper/TEXTurePaper)
+    description = '''# [PPSurf](https://github.com/cg-tuwien/ppsurf)
     
-    - This demo only accepts as input `.obj` files with less than 100,000 faces.
-    - Inference takes about 10 minutes on a T4 GPU.
+    Supported file formats: PLY, STL, OBJ and other mesh files, XYZ as whitespace-separated text file, 
+    NPY and NPZ (key='arr_0'), LAS and LAZ (version 1.0-1.4), COPC and CRS.
+    Best results for 50k-250k points. 
+    
+    This method is meant for scans of single and few objects. 
+    Quality for scenes and landscapes will be lower.
+    
+    Inference takes about 2 minutes.
     '''
+
+    def convert_to_ply(input_point_cloud_upload: gr.File):
+        print('inputs:', input_point_cloud_upload.value)
+        input_shape = input_point_cloud_upload.value[0]
+        if not input_shape.endswith('.ply'):
+            # load file
+            from ppsurf.source.occupancy_data_module import OccupancyDataModule
+            pts_np = OccupancyDataModule.load_pts(input_shape)
+
+            # convert to ply
+            import trimesh
+            mesh = trimesh.Trimesh(vertices=pts_np[:, :3])
+            input_shape = input_shape + '.ply'
+            mesh.export(input_shape)
+
+        # show in viewer
+        input_tabs.selected = 'pc_viewer'
+        input_point_cloud_viewer.value = input_shape
+
     if (SPACE_ID := os.getenv('SPACE_ID')) is not None:
-        DESCRIPTION += (f'\n<p>For faster inference without waiting in queue, '
+        description += (f'\n<p>For faster inference without waiting in queue, '
                         f'you may duplicate the space and upgrade to GPU in settings. '
                         f'<a href="https://huggingface.co/spaces/{SPACE_ID}?duplicate=true">'
                         f'<img style="display: inline; margin-top: 0em; margin-bottom: 0em" '
                         f'src="https://bit.ly/3gLdBN6" alt="Duplicate Space" /></a></p>')
 
     with gr.Blocks(css='style.css') as demo:
-        gr.Markdown(DESCRIPTION)
+        gr.Markdown(description)
         with gr.Row():
             with gr.Column():
-                input_shape = gr.Model3D(label='Input 3D mesh')
-                text = gr.Text(label='Text')
-                seed = gr.Slider(label='Seed',
-                                 minimum=0,
-                                 maximum=100000,
-                                 value=3,
-                                 step=1)
-                guidance_scale = gr.Slider(label='Guidance scale',
-                                           minimum=0,
-                                           maximum=50,
-                                           value=7.5,
-                                           step=0.1)
-                run_button = gr.Button('Run')
+                with gr.Tabs() as input_tabs:
+                    with gr.TabItem(label='Input Point Cloud Upload', id='pc_upload'):
+                        input_point_cloud_upload = gr.File(
+                            show_label=False, file_count='single')
+                        input_point_cloud_upload.upload(fn=convert_to_ply,
+                        inputs=[
+                            input_point_cloud_upload,
+                        ],
+                        outputs=[
+                            # input_point_cloud_viewer,  # not available here
+                        ])
+                        # input_point_cloud_upload.attach_load_event(convert_to_ply, every=None)
+                    with gr.TabItem(label='Input Point Cloud Viewer', id='pc_viewer'):
+                        input_point_cloud_viewer = gr.Model3D(show_label=False)
+                gen_resolution_global = gr.Slider(
+                    label='Grid Resolution (larger for more details)',
+                    minimum=17, maximum=513, value=129, step=2)
+                padding_factor = gr.Slider(
+                    label='Padding Factor (larger if object is cut off at boundaries)',
+                    minimum=0, maximum=1.0, value=0.05, step=1)
+                gen_subsample_manifold_iter = gr.Slider(
+                    label='Subsample Manifold Iterations (larger for larger point clouds)',
+                    minimum=3, maximum=30, value=10, step=1)
+                gen_refine_iter = gr.Slider(
+                    label='Edge Refinement Iterations (larger for more details)',
+                    minimum=3, maximum=30, value=10, step=1)
+                # run_button = gr.Button('Run')
             with gr.Column():
                 progress_text = gr.Text(label='Progress')
                 with gr.Tabs():
-                    with gr.TabItem(label='Images from each viewpoint'):
-                        viewpoint_images = gr.Gallery(show_label=False, columns=4)
-                    with gr.TabItem(label='Result 3D model'):
+                    with gr.TabItem(label='Reconstructed 3D model'):
                         result_3d_model = gr.Model3D(show_label=False)
                     with gr.TabItem(label='Output mesh file'):
                         output_file = gr.File(show_label=False)
+        # with gr.Row():
+        #     examples = [
+        #         ['shapes/dragon1.obj', 'a photo of a dragon', 0, 7.5],
+        #         ['shapes/dragon2.obj', 'a photo of a dragon', 0, 7.5],
+        #         ['shapes/eagle.obj', 'a photo of an eagle', 0, 7.5],
+        #         ['shapes/napoleon.obj', 'a photo of Napoleon Bonaparte', 3, 7.5],
+        #         ['shapes/nascar.obj', 'A next gen nascar', 2, 10],
+        #     ]
+        #     gr.Examples(examples=examples,
+        #                 inputs=[
+        #                     input_point_cloud_viewer,
+        #                     text,
+        #                     seed,
+        #                     guidance_scale,
+        #                 ],
+        #                 outputs=[
+        #                     result_3d_model,
+        #                     output_file,
+        #                 ],
+        #                 cache_examples=False)
+
         with gr.Row():
-            examples = [
-                ['shapes/dragon1.obj', 'a photo of a dragon', 0, 7.5],
-                ['shapes/dragon2.obj', 'a photo of a dragon', 0, 7.5],
-                ['shapes/eagle.obj', 'a photo of an eagle', 0, 7.5],
-                ['shapes/napoleon.obj', 'a photo of Napoleon Bonaparte', 3, 7.5],
-                ['shapes/nascar.obj', 'A next gen nascar', 2, 10],
-            ]
-            gr.Examples(examples=examples,
-                        inputs=[
-                            input_shape,
-                            text,
-                            seed,
-                            guidance_scale,
-                        ],
-                        outputs=[
-                            result_3d_model,
-                            output_file,
-                        ],
-                        cache_examples=False)
+            run_button = gr.Button('=> Run PPSurf =>')
 
         run_button.click(fn=run_on_gpu,
                          inputs=[
-                             input_shape,
-                             text,
-                             seed,
-                             guidance_scale,
+                             input_point_cloud_viewer,
+                             gen_resolution_global,
+                             padding_factor,
+                             gen_subsample_manifold_iter,
+                             gen_refine_iter,
                          ],
                          outputs=[
-                             viewpoint_images,
                              result_3d_model,
                              output_file,
                              progress_text,

model.py

@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-import datetime
-import pathlib
-import shlex
-import subprocess
-import sys
-from typing import Generator, Optional
-
-import gradio as gr
-import trimesh
-
-sys.path.append('TEXTurePaper')
-
-from src.configs.train_config import GuideConfig, LogConfig, TrainConfig
-from src.training.trainer import TEXTure
-
-
-class Model:
-    def __init__(self):
-        self.max_num_faces = 100000
-
-    def load_config(self, shape_path: str, text: str, seed: int,
-                    guidance_scale: float) -> TrainConfig:
-        text += ', {} view'
-
-        log = LogConfig(exp_name=self.gen_exp_name())
-        guide = GuideConfig(text=text)
-        guide.background_img = 'TEXTurePaper/textures/brick_wall.png'
-        guide.shape_path = 'TEXTurePaper/shapes/spot_triangulated.obj'
-        config = TrainConfig(log=log, guide=guide)
-
-        config.guide.shape_path = shape_path
-        config.optim.seed = seed
-        config.guide.guidance_scale = guidance_scale
-        return config
-
-    def gen_exp_name(self) -> str:
-        now = datetime.datetime.now()
-        return now.strftime('%Y-%m-%d-%H-%M-%S')
-
-    def check_num_faces(self, path: str) -> bool:
-        with open(path) as f:
-            lines = [line for line in f.readlines() if line.startswith('f')]
-        return len(lines) <= self.max_num_faces
-
-    def zip_results(self, exp_dir: pathlib.Path) -> str:
-        mesh_dir = exp_dir / 'mesh'
-        out_path = f'{exp_dir.name}.zip'
-        subprocess.run(shlex.split(f'zip -r {out_path} {mesh_dir}'))
-        return out_path
-
-    def run(
-        self, shape_path: str, text: str, seed: int, guidance_scale: float
-    ) -> Generator[tuple[list[str], Optional[str], Optional[str], str], None, None]:
-        if not shape_path.endswith('.obj'):
-            raise gr.Error('The input file is not .obj file.')
-        if not self.check_num_faces(shape_path):
-            raise gr.Error('The number of faces is over 100,000.')
-
-        config = self.load_config(shape_path, text, seed, guidance_scale)
-        trainer = TEXTure(config)
-
-        trainer.mesh_model.train()
-
-        total_steps = len(trainer.dataloaders['train'])
-        for step, data in enumerate(trainer.dataloaders['train'], start=1):
-            trainer.paint_step += 1
-            trainer.paint_viewpoint(data)
-            trainer.evaluate(trainer.dataloaders['val'],
-                             trainer.eval_renders_path)
-            trainer.mesh_model.train()
-
-            sample_image_dir = config.log.exp_dir / 'vis' / 'eval'
-            sample_image_paths = sorted(
-                sample_image_dir.glob(f'step_{trainer.paint_step:05d}_*.jpg'))
-            sample_image_paths = [
-                path.as_posix() for path in sample_image_paths
-            ]
-            yield sample_image_paths, None, None, f'{step}/{total_steps}'
-
-        trainer.mesh_model.change_default_to_median()
-
-        save_dir = trainer.exp_path / 'mesh'
-        save_dir.mkdir(exist_ok=True, parents=True)
-        trainer.mesh_model.export_mesh(save_dir)
-        model_path = save_dir / 'mesh.obj'
-        mesh = trimesh.load(model_path)
-        mesh_path = save_dir / 'mesh.glb'
-        mesh.export(mesh_path, file_type='glb')
-
-        zip_path = self.zip_results(config.log.exp_dir)
-        yield sample_image_paths, mesh_path.as_posix(), zip_path, 'Done!'