From K-3D
Algorithm
- Search for all object of type(instance)
- Apply freeze modifier to its end
- Delete all the child nodes
- Should
- There should be a black list of object types to be removed? and leave the rest?
- left only the geometry?
- Save as a new document
What about
- Exporting all documents to .obj?
Draft implementation
#python
import k3d
class DocumentFreezer:
"""
Use this class for freezing mesh objects on your document.
On creation works with two modes:
- reusing existing instances (deleting its "childs" but keeping the rest)
this is the defualt action
like this "mesh_frzr = DocumentFreezer(Document)"
is the same as
like this "mesh_frzr = DocumentFreezer(Document, "reusing")"
- creating new instances (and deleting everything else)
like this "mesh_frzr = DocumentFreezer(Document, "new")"
this is useful for importing the .k3d file in other doc.
Once the object is created, it has two running modes: freeze all, or freeze selected
- mesh_frzr.freeze_all_instances()
or
- mesh_frzr.freeze_selected_instances()
"""
def __init__(self, document, freeze_mode="reusing"):
self.doc = document
self.created_nodes = []
self.orphans = []
self.freeze_mode = freeze_mode
def freeze_all_instances(self, Change_name="Freeze Instances"):
self.freeze_instances("all", Change_name)
def freeze_selected_instances(self, Change_name="Freeze Selected Instances"):
self.freeze_instances("selected", Change_name)
def freeze_instances(self,mode="all", Change_name="Freeze Instances"):
id_msh_inst = self.get_factory_id("MeshInstance")
self.doc.start_change_set()
try:
if(mode == "all"):
for node in self.doc.nodes():
if id_msh_inst == node.factory().factory_id():
self.freeze_instance(node)
elif(mode == "selected"):
for node in self.doc.nodes():
if id_msh_inst == node.factory().factory_id() and node.selection_weight:
self.freeze_instance(node) #There is an instance selected
self.delete_garbage()
self.doc.finish_change_set(Change_name)
except: #there was an error
self.doc.cancel_change_set()
raise
def freeze_instance(self,node): #choose mode method
if(self.freeze_mode == "reusing"):
self.freeze_reusing_instance(node)
elif(self.freeze_mode == "new"):
self.freeze_new_instance(node)
def freeze_new_instance(self, node):
frozen_mesh = self.doc.new_node("FrozenMesh")
frozen_mesh.name = "Frozen "+node.name
self.doc.set_dependency(frozen_mesh.get_property("input_mesh"), node.get_property("output_mesh"))
temp_mesh = frozen_mesh.output_mesh
self.doc.set_dependency(frozen_mesh.get_property("input_mesh"), None)
frzmsh_instance = self.doc.new_node("MeshInstance")
frzmsh_instance.name = "Frozen Mesh Instance"
frzmsh_instance.gl_painter = self.doc.get_node("GL Default Painter")
frzmsh_instance.ri_painter = self.doc.get_node("RenderMan Default Painter")
self.doc.set_dependency(frzmsh_instance.get_property("input_mesh"), frozen_mesh.get_property("output_mesh"))
frzmsh_instance.input_matrix = node.output_matrix
self.created_nodes.append(frozen_mesh.__hash__())
self.created_nodes.append(frzmsh_instance.__hash__())
def freeze_reusing_instance(self, node):
frozen_mesh = self.doc.new_node("FrozenMesh")
frozen_mesh.name = "Frozen "+node.name
self.doc.set_dependency(frozen_mesh.get_property("input_mesh"), node.get_property("output_mesh"))
temp_mesh = frozen_mesh.output_mesh
self.doc.set_dependency(frozen_mesh.get_property("input_mesh"), None)
self.orphans.append(self.get_child(node).__hash__())
self.doc.set_dependency(node.get_property("input_mesh"), frozen_mesh.get_property("output_mesh"))
def get_factory_id(self, name):
temp_msh_inst = self.doc.new_node(name)
id_msh_inst = temp_msh_inst.factory().factory_id()
self.doc.delete_node(temp_msh_inst)
return id_msh_inst
def delete_all_the_rest(self):
for node in self.doc.nodes():
try:
# Did we made this node?
self.created_nodes.index(node.__hash__())
# use bisect for speed??
except:
#Not on the list
self.doc.delete_node(node)
def delete_orphans(self):
for node in self.doc.nodes():
try:
# Is an orphan?
self.orphans.index(node.__hash__())
self.delete_downstream(node)
# use bisect for speed??
except:
#Not on the list
pass
def delete_garbage(self):
if(self.freeze_mode == "reusing"):
self.delete_orphans()
elif(self.freeze_mode == "new"):
self.delete_all_the_rest()
else:
pass
def get_child(self, node):
return self.doc.get_dependency(node.get_property("input_mesh")).node()
def delete_downstream(self, node):
while( node != None ):
try:
node_tmp = self.get_child(node,doc)
self.doc.delete_node(node)
node = node_tmp
except:
self.doc.delete_node(node)
node = None
####### Example #######
mesh_frzr = DocumentFreezer(Document, "reusing")
#mesh_frzr = DocumentFreezer(Document, "new")
#mesh_frzr.freeze_all_instances()
mesh_frzr.freeze_selected_instances()
