v1.1.0

- Added functionality to options to expand selection, clean entire scene.
- Added new option to move cleaned objects to the active layer
- Changed behavior to delete parents after cleanup instead of sorting things into layers
- Added a call to 3ds Max's garbage collector at the beginning of cleanup to wipe the Undo/Redo cache (this was causing hangups if you cleaned large amounts of objects one after another, or undid a cleanup and then re-did it)
- Improved exception handling to actually print a traceback
- Changed some status labels to be more useful in the event that Max freezes

Author: TicTac-93

README.md

@@ -1,4 +1,6 @@
 # Clean DWG
+##### v1.1.0
+
 A 3dsMax script that will clean up `Block/Style Parent` dummy objects in imported DWGs.
 
 Install by copying the cleanDWG folder to your 3ds Max scripts directory.
@@ -7,21 +9,19 @@ Run in 3ds Max using with the MaxScript snippet:
 
 -----
 
-This script will operate only on selected objects.  In the future, 
-I'd like to expand it to search for relatives (parents and children) of
-the current selection, but for now you ***must make sure*** that you have
-all objects in a hierarchy selected.  The recommended way to do this is
-by selecting top-level objects in the `Scene Explorer`, and then using the
-`Select Children` option.
+**Please note that while this operation *is* undoable, to prevent freezing
+it flushes the undo cache just before running.  You will not be able
+to undo previous work after cleaning up.**
+
+This script operates on selected objects, optionally expanding that selection to include
+their entire hierarchy of parents, children, etc.  You may also choose to run the script
+on every object in the scene, which in the case of large numbers of objects can be faster
+than trying to expand a selection.  While the script doesn't enforce this, it's
+recommended that you select entire object hierarchies, rather than individual objects.
 
-To use, run the script and then select the objects (remember, Parents *and* Children,)
-that you want to clean up.  Then, simply press the `Clean Block Parents`.
+To use, run the script, select any options you want, select the objects
+that you want to clean up, and then press the `Clean Block/Style Parents` button.
 Depending on the number of objects you have selected this may take a while,
 but should be fairly fast for selections with less than 10,000 objects.
-This operation *is* undoable, but don't be surprised if Max hangs up while
-undoing / redoing.
-
-In this release, the script will not delete the old `Block/Style Parent`
-objects, and instead sort them into a layer.  After that, it's
-up to the user to delete them.  This will likely be changed in a future
-release.
+Note that the "Expand Selection" option will greatly slow down the script
+when large numbers of object are selected.

cleanDWG.py

@@ -1,6 +1,6 @@
-# -----------------------
-#   Clean DWG DEV BUILD
-# -----------------------
+# ----------------------
+#   Clean DWG - v1.1.0
+# ----------------------
 
 # Destroys instances of the dialog before recreating it
 # This has to go first, before modules are reloaded or the ui var is re-declared.
@@ -26,6 +26,7 @@
 
 # Misc
 import os
+import traceback
 
 
 # --------------------
@@ -77,13 +78,14 @@ def __init__(self, ui_file, pymxs, parent=MaxPlus.GetQMaxMainWindow()):
 
         # Titling
 
-        self._window_title = 'Clean DWG - DEV BUILD'
+        self._window_title = 'Clean DWG v1.1.0'
         self.setWindowTitle(self._window_title)
 
         # ---------------------------------------------------
         #                   Widget Setup
         # ---------------------------------------------------
 
+        self._chk_layer = self.findChild(QtW.QCheckBox, 'chk_layer')
         self._chk_expand = self.findChild(QtW.QCheckBox, 'chk_expand')
         self._chk_full_scene = self.findChild(QtW.QCheckBox, 'chk_fullScene')
 
@@ -110,6 +112,7 @@ def __init__(self, ui_file, pymxs, parent=MaxPlus.GetQMaxMainWindow()):
                         '[2/4] Building list of Parents / Children...',
                         '[3/4] Making Transform Controllers unique...',
                         '[4/4] Cleaning up Parents...',
+                        'Waiting for 3ds Max to un-freeze...',
                         'Done.',
                         '%s Cleanup failed!  Check the Max Listener for details.' % self._err]
         # Set initial status label
@@ -121,44 +124,93 @@ def __init__(self, ui_file, pymxs, parent=MaxPlus.GetQMaxMainWindow()):
     # ---------------------------------------------------
     #                  Private Methods
     # ---------------------------------------------------
+    def _get_children(self, obj, input_list):
+        children = obj.children
+        for child in children:
+            # Note that since we're calling this from a list of unique hierarchy roots, we don't have to worry about
+            # checking for duplicate objects.  Crawling down the trees will only yield each object one time.
+            input_list.append(child)
+            input_list = self._get_children(child, input_list)
+        return input_list
 
     # ---------------------------------------------------
     #                  Public Methods
     # ---------------------------------------------------
-
-    # TODO: Set up options checking
-    # TODO: Add functionality for "Expand Selection" and "Clean Entire Scene" options
-
     def clean(self):
+        # UI Options
+        layer = self._chk_layer.isChecked()
+        expand = self._chk_expand.isChecked()
+        scene = self._chk_full_scene.isChecked()
+
+        # Misc Variables
         rt = self._pymxs.runtime
-        selection = []
-        parents = []
-        children = []
-
-        try:
-            with self._pymxs.undo(True, 'Clean DWG'), self._pymxs.redraw(False):
-                # It's much faster to sort the parents and children into layers, rather than deleting objects
-                # Check if these layers already exist, if they do use those.  Else, make them.
-                layer_parents = rt.LayerManager.getLayerFromName('__CLEAN DWG - PARENTS - DELETE')
-                if layer_parents == None:
-                    layer_parents = rt.LayerManager.newLayerFromName('__CLEAN DWG - PARENTS - DELETE')
-                layer_children = rt.LayerManager.getLayerFromName('__CLEAN DWG - CHILDREN - CLEANED UP')
-                if layer_children == None:
-                    layer_children = rt.LayerManager.newLayerFromName('__CLEAN DWG - CHILDREN - CLEANED UP')
-
-                layer_parents.isHidden = True
 
+        # Run 3ds Max garbage cleanup before we start.  This will wipe the Undo/Redo cache, too.
+        # Clearing the Undo cache prevents Max from hanging up when the script is used multiple times.
+        rt.gc()
+
+        with self._pymxs.undo(True, 'Clean DWG'), self._pymxs.redraw(False):
+            try:
                 # 1/4
                 # Build list of selected objects, optionally including their entire hierarchy.
                 self._lbl_status.setText(self._status[1])
                 selection = rt.getCurrentSelection()
+                rt.clearSelection()
+
+                # Clean up selected objects ONLY
+                if not expand and not scene:
+                    pass
+
+                # Expand selection to the full hierarchy of the selected objects
+                elif expand and not scene:
+                    # Expand up to roots of selected objects
+                    selection_roots = []
+                    self._bar_progress.setMaximum(len(selection)*2)
+                    self._bar_progress.setValue(0)
+                    progress = 0
+                    for x in selection:
+                        progress += 1
+                        x_root = x
+                        x_parent = x.parent
+                        while x_parent is not None:
+                            x_root = x_parent
+                            x_parent = x_root.parent
+                        if x_root not in selection_roots:
+                            selection_roots.append(x_root)
+
+                        self._bar_progress.setValue(progress)
+
+                    # Expand down to children of roots
+                    selection_ex = list(selection_roots)  # the list(...) format prevents us passing by reference
+                    progress = len(selection_roots)
+                    self._bar_progress.setMaximum(progress*2)
+                    self._bar_progress.setValue(progress)
+                    for x in selection_roots:
+                        progress += 1
+                        selection_ex = self._get_children(x, selection_ex)
+                        self._bar_progress.setValue(progress)
+
+                    selection = list(selection_ex)
+
+                # Expand selection to entire scene
+                elif scene:
+                    selection = rt.objects
+
+                # Something fishy's going on...
+                else:
+                    self._lbl_status.setText(self._status[6])
+                    print "Unknown error, please re-run the Clean DWG script."
+                    return
 
                 # 2/4
                 # Build Parent / Child lists
                 self._lbl_status.setText(self._status[2])
                 self._bar_progress.setMaximum(len(selection))
+                self._bar_progress.setValue(0)
                 progress = 0
-                self._bar_progress.setValue(progress)
+
+                parents = []
+                children = []
                 for obj in selection:
                     if rt.classOf(obj) == rt.LinkComposite:
                         parents.append(obj)
@@ -182,33 +234,58 @@ def clean(self):
                     self._bar_progress.setValue(progress)
 
                 # 4/4
-                # Unparent children and organize objects into layers
+                # Unparent children, then delete old parents.  Optionally move children to current layer.
                 self._lbl_status.setText(self._status[4])
-                self._bar_progress.setMaximum(len(children) + len(parents))
+                if layer:
+                    self._bar_progress.setMaximum(len(children)*2)
+                else:
+                    self._bar_progress.setMaximum(len(children))
                 progress = 0
                 for child in children:
                     child.name = child.parent.name
                     child.parent = None
-                    layer_children.addNode(child)
 
                     progress += 1
                     self._bar_progress.setValue(progress)
 
-                for parent in parents:
-                    layer_parents.addNode(parent)
+                if layer:
+                    # Convert the full selection and list of parents to sets, so we can exclude parents from the for-loop
+                    set_selection = set(selection)
+                    set_parents = set(parents)
+                    set_selection = set_selection.difference(set_parents)
+                    current_layer = rt.LayerManager.current
 
-                    progress += 1
+                    progress = len(set_selection)
+                    self._bar_progress.setMaximum(progress*2)
                     self._bar_progress.setValue(progress)
+                    for x in set_selection:
+                        progress += 1
+                        current_layer.addNode(x)
+
+                        self._bar_progress.setValue(progress)
+
+                rt.delete(parents)
 
                 # Done.
                 self._lbl_status.setText(self._status[5])
-                self._bar_progress.setValue(self._bar_progress.maximum())
+                self._bar_progress.setMaximum(1)
+                self._bar_progress.setValue(1)
+
+                # Print some info
+                print "Cleaned up %d Block/Style Parents" % len(parents)
+
+            except Exception:
+                traceback.print_exc()
+                self._lbl_status.setText(self._status[7])
+                self._bar_progress.setMaximum(100)
+                self._bar_progress.setValue(0)
+
+                return
+
+        # This should run after Max un-freezes
+        self._lbl_status.setText(self._status[6])
 
-        except Exception as e:
-            print e
-            self._lbl_status.setText(self._status[6])
-            self._bar_progress.setMaximum(100)
-            self._bar_progress.setValue(0)
+        return
 
 
 # --------------------
@@ -224,4 +301,4 @@ def clean(self):
 ui.show()
 
 # DEBUG
-# print "\rTest Version 4"
+# print "\rTest Version 7"