Added an option to decimate pointcloud sequences

Author: ChristopherRemde

Converter/Sequence_Converter.py

@@ -3,6 +3,7 @@
 import pymeshlab as ml
 import numpy as np
 from threading import Lock
+import threading
 from multiprocessing.pool import ThreadPool
 import Sequence_Metadata
 from PIL import Image
@@ -28,13 +29,15 @@ class SequenceConverter:
     convertToASTC = False
     convertToSRGB = False
 
+    decimatePointcloud = False
+    decimatePercentage = 0
+
     maxThreads = 8
-    activeThreadLock = Lock()
     loadMeshLock = Lock()
     activeThreads = 0
 
 
-    def start_conversion(self, model_paths_list, image_paths_list, input_path, output_path, resource_Path, processFinishedCB, threadCount, convertDDS, convertASTC, convertSRGB):       
+    def start_conversion(self, model_paths_list, image_paths_list, input_path, output_path, resource_Path, processFinishedCB, threadCount, convertDDS, convertASTC, convertSRGB, decimatePointcloud, decimatePercentage):       
 
         self.metaData = Sequence_Metadata.MetaData()
         self.terminateProcessing = False
@@ -47,6 +50,8 @@ def start_conversion(self, model_paths_list, image_paths_list, input_path, outpu
         self.convertToDDS = convertDDS
         self.convertToASTC = convertASTC
         self.convertToSRGB = convertSRGB
+        self.decimatePointcloud = decimatePointcloud
+        self.decimatePercentage = decimatePercentage
 
         modelCount = len(model_paths_list)
         self.metaData.headerSizes = [None] * modelCount
@@ -117,7 +122,7 @@ def convert_model(self, file):
 
         ms = ml.MeshSet()
 
-        self.loadMeshLock.acquire()
+        self.loadMeshLock.acquire() # If we don't lock the mesh loading process, crashes might occur
 
         try:
             ms.load_new_mesh(inputfile)
@@ -197,15 +202,18 @@ def convert_model(self, file):
         #to PLY with our very stringent structure. This is needed because we want to keep the
         #work on the Unity side as low as possible, so we basically want to load the data from disk into the memory
         #without needing to change anything
-
         with open(outputfile, 'wb') as f:
 
+            #If pointcloud decimation is enabled, calculate how many points were going to write
+            if(self.decimatePointcloud):
+                vertexCount = int(len(vertices) * (self.decimatePercentage / 100))
+
             #constructing the ascii header
             header = "ply" + "\n"
             header += "format binary_little_endian 1.0" + "\n"
             header += "comment Exported for use in Unity Geometry Streaming Plugin" + "\n"
 
-            header += "element vertex " + str(len(vertices)) + "\n"
+            header += "element vertex " + str(vertexCount) + "\n"
             header += "property float x" + "\n" 
             header += "property float y" + "\n"
             header += "property float z" + "\n"
@@ -230,9 +238,7 @@ def convert_model(self, file):
 
             f.write(headerASCII)
 
-
             #Constructing the mesh data, as binary array
-
             if(is_pointcloud == True):
 
                 verticePositionsBytes = np.frombuffer(vertices.tobytes(), dtype=np.uint8)
@@ -248,6 +254,11 @@ def convert_model(self, file):
                 #Interweave arrays, so that each row contains position + color
                 body = np.concatenate((verticePositionsBytes, verticeColorsBytes), axis = 1)
 
+                #Decimate n random elements to reduce points (if enabled)
+                if(self.decimatePointcloud):
+                    np.random.shuffle(body)
+                    body = body[0:vertexCount]
+
                 #Flatten the array into a 1D array
                 body.ravel()
 
@@ -284,7 +295,7 @@ def convert_model(self, file):
 
         self.metaData.set_metadata_Model(vertexCount, indiceCount, headerSize, bounds, geoType, has_UVs, listIndex)
 
-        self.convert_model_finished(False, "")    
+        self.convert_model_finished(False, "") 
 
 
     def convert_model_finished(self, error, errorText):

Converter/Sequence_Converter_UI.py

@@ -19,6 +19,8 @@ class ConverterUI:
     progress_bar_ID = 0
     thread_count_ID = 0
     srgb_check_ID = 0
+    pointcloud_decimation_ID = 0
+    decimation_percentage_ID = 0
 
     ### +++++++++++++++++++++++++  PACKAGE INTO SINGLE EXECUTABLE ++++++++++++++++++++++++++++++++++
     #Use this prompt in the terminal to package this script into a single executable for your system
@@ -45,6 +47,8 @@ class ConverterUI:
     generateDDS = True
     generateASTC = True
     convertToSRGB = False
+    decimatePointcloud = False
+    decimatePercentage = 100
 
     validModelTypes = ["obj", "3ds", "fbx", "glb", "gltf", "obj", "ply", "ptx", "stl", "xyz", "pts"]
     validImageTypes = ["jpg", "jpeg", "png", "bmp", "tga"]
@@ -83,6 +87,14 @@ def set_ASTC_enabled_cb(self, sender, app_data):
     def set_SRGB_enabled_cb(self, sender, app_data):
         self.convertToSRGB = app_data
 
+    def set_Decimation_enabled_cb(self, sender, app_data):
+        self.decimatePointcloud = app_data
+        self.write_config_bool("decimatePointcloud", app_data)
+
+    def set_Decimation_percentage_cb(self, sender, app_data):
+        self.decimatePercentage = app_data
+        self.write_settings_string("decimatePercentage", str(app_data))
+
     def start_conversion_cb(self):
 
         if(self.isRunning):
@@ -108,7 +120,7 @@ def start_conversion_cb(self):
 
         self.totalFileCount =  len(self.modelPathList) + len(self.imagePathList)
         self.processedFileCount = 0
-        self.converter.start_conversion(self.modelPathList, self.imagePathList, self.inputSequencePath, self.get_output_path(), self.resourcesPath, self.single_conversion_finished_cb, dpg.get_value(self.thread_count_ID), self.generateDDS, self.generateASTC, self.convertToSRGB)
+        self.converter.start_conversion(self.modelPathList, self.imagePathList, self.inputSequencePath, self.get_output_path(), self.resourcesPath, self.single_conversion_finished_cb, dpg.get_value(self.thread_count_ID), self.generateDDS, self.generateASTC, self.convertToSRGB, self.decimatePointcloud, self.decimatePercentage)
 
         self.info_text_set("Converting...")
         self.set_progressbar(0)
@@ -163,7 +175,7 @@ def set_input_files(self, new_input_path):
             self.set_proposed_output_files(new_input_path)
 
             self.inputPathValid = True
-            self.write_config_string("input", new_input_path)
+            self.write_path_string("input", new_input_path)
 
         else:
             self.info_text_clear()
@@ -240,19 +252,27 @@ def load_config(self):
             self.config['Paths']['input'] = ""
             self.config['Settings']['DDS'] = "true"
             self.config['Settings']['ASTC'] = "true"
+            self.config['Settings']['decimatePointcloud'] = "false"
+            self.config['Settings']['decimatePercentage'] = "100"
             self.save_config()
 
         self.config.read(self.configPath)
 
-    def read_config_string(self, key):
+    def read_path_string(self, key):
         return self.config['Paths'][key]
 
+    def read_settings_string(self, key):
+        return self.config['Settings'][key]
+    
     def read_config_bool(self, key):
         return self.config['Settings'].getboolean(key)
 
-    def write_config_string(self, key, value):
+    def write_path_string(self, key, value):
         self.config['Paths'][key] = value
 
+    def write_settings_string(self, key, value):
+        self.config['Settings'][key] = value
+
     def write_config_bool(self, key, value):
         self.config['Settings'][key] = str(value)
 
@@ -342,10 +362,12 @@ def RunUI(self):
         self.load_config()
         self.generateDDS = self.read_config_bool("DDS")
         self.generateASTC = self.read_config_bool("ASTC")
+        self.decimatePointcloud = self.read_config_bool("decimatePointcloud")
+        self.decimatePercentage = int(self.read_settings_string("decimatePercentage"))
 
         dpg.create_context()
         dpg.configure_app(manual_callback_management=True)
-        dpg.create_viewport(height=450, width=500, title="Geometry Sequence Converter")
+        dpg.create_viewport(height=480, width=500, title="Geometry Sequence Converter")
         dpg.setup_dearpygui()
 
         with dpg.window(label="Geometry Sequence Converter", tag="main_window", min_size= [500, 500]):
@@ -361,9 +383,15 @@ def RunUI(self):
 
             dpg.add_checkbox(label="Generate textures for desktop devices (DDS)", default_value=self.generateDDS, callback=self.set_DDS_enabled_cb)
             dpg.add_checkbox(label="Generate textures mobile devices (ASTC)", default_value=self.generateASTC, callback=self.set_ASTC_enabled_cb)
-            self.srgb_check_ID = dpg.add_checkbox(label="Convert to SRGB profile", default_value=self.generateASTC, callback=self.set_SRGB_enabled_cb)
+            self.srgb_check_ID = dpg.add_checkbox(label="Convert to SRGB profile", default_value=self.convertToSRGB, callback=self.set_SRGB_enabled_cb)
 
-            dpg.add_spacer(height=30)
+            dpg.add_spacer(height=5)
+
+            self.pointcloud_decimation_ID = dpg.add_checkbox(label="Decimate Pointcloud", default_value=self.decimatePointcloud, callback=self.set_Decimation_enabled_cb)
+            dpg.add_same_line()
+            self.decimation_percentage_ID = dpg.add_input_int(label=" %", default_value=self.decimatePercentage, min_value=0, max_value=100, width=80, callback=self.set_Decimation_percentage_cb)
+
+            #dpg.add_spacer(height=5)
 
             self.text_error_log_ID = dpg.add_text("", color=[255, 0, 0], wrap=450)
             self.text_info_log_ID = dpg.add_text("", color=[255, 255, 255], wrap=450)
@@ -380,7 +408,7 @@ def RunUI(self):
         dpg.show_viewport()
         dpg.set_primary_window("main_window", True)
 
-        self.set_input_files(self.read_config_string("input"))
+        self.set_input_files(self.read_path_string("input"))
 
         while dpg.is_dearpygui_running():
             dpg.render_dearpygui_frame()