Add support for urdf_plus

Author: nuofan

.gitignore

@@ -1 +1,2 @@
 .DS_Store
+.vscode

Add-IN/ACDC4Robot/commands/ACDC4Robot/acdc4robot.py

@@ -11,6 +11,8 @@
 from . import constants
 from ...core import write
 from ...core import utils
+from ...core.robot import Robot
+from ...core.urdf_plus import URDF_PLUS
 import time
 
 def get_link_joint_list(design: adsk.fusion.Design):
@@ -244,6 +246,16 @@ def run():
                 time.sleep(0.1)
                 ui.messageBox("Finished exporting MJCF for MuJoCo.", msg_box_title)
 
+        elif rdf == "URDF+":
+            robot = Robot(design)
+            urdf_plus = URDF_PLUS(robot)
+            urdf_plus_path = save_folder + "/{}.urdf".format(robot.get_robot_name())
+            urdf_plus.write_file(urdf_plus_path)
+            stl_list: list[Link] = robot.get_links()
+            export_stl(design, save_folder, stl_list)
+            time.sleep(0.1)
+            ui.messageBox("Finished exporting URDF+.", msg_box_title)
+        
     except:
         if ui:
             ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))

Add-IN/ACDC4Robot/commands/ACDC4Robot/entry.py

@@ -87,6 +87,7 @@ def command_created(args: adsk.core.CommandCreatedEventArgs):
     rdf_items.add("URDF", False)
     rdf_items.add("SDFormat", False)
     rdf_items.add("MJCF", False)
+    rdf_items.add("URDF+", False)
 
     # create a drop down command input to choose simulation environment
     sim_env_input = inputs.addDropDownCommandInput("simulation_env", "Simulation Environment", adsk.core.DropDownStyles.LabeledIconDropDownStyle)

Add-IN/ACDC4Robot/core/link.py

@@ -65,7 +65,6 @@ def get_parent_joint(self) -> adsk.fusion.Joint:
 
         Return:
             j: parent_joints
-        
         """
         # TODO: in closed loop mechanism, there exits one assembly method that
         # make one link have two parent joint, write a instruction or fix this bug

Add-IN/ACDC4Robot/core/robot.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+from typing import List, Tuple
+import adsk, adsk.fusion, adsk.core
+from .link import Link
+from .joint import Joint
+
+class Robot():
+    """
+    Store robot link joint information into a bigraph structure
+    """
+
+    def __init__(self, robot: adsk.fusion.Design):
+        self.robot = robot
+        self.rootComp = robot.rootComponent
+        self.name = self.get_robot_name()
+        self.nodes = self.get_links()
+        self.edges = self.get_joints()
+        self.loop_joints, self.tree_joints = self.seperate_joints(self.edges)
+
+    def get_robot_name(self, ) -> str:
+        """
+        Robot name is the root component name
+        """
+        robot_name = self.rootComp.name.split()[0]
+        return robot_name
+
+    def get_links(self, ) -> List[Link]:
+        link_list = []
+        occs: adsk.fusion.OccurrenceList = self.rootComp.allOccurrences
+
+        # try to solve the nested components problem
+        # but still not fully tested
+        for occ in occs:
+            # TODO: it seems use occ.joints.count will make it usable with occurrences? Test it
+            if occ.component.joints.count > 0:
+                # textPalette.writeText(str(occ.fullPathName))
+                continue
+            else:
+                # Only occurrence contains zero joint and has zero childOccurrences 
+                # can be seen as a link
+                if occ.childOccurrences.count > 0:
+                    # textPalette.writeText(str(occ.fullPathName))
+                    # textPalette.writeText(str(occ.childOccurrences.count))
+                    continue
+                else:
+                    # textPalette.writeText(str(occ.fullPathName))
+                    # textPalette.writeText(str(occ.childOccurrences.count))
+                    if occ.isLightBulbOn:
+                        # only the occurrence light bulb on that the occurrence will be exported
+                        link_list.append(Link(occ)) # add link objects into link_list
+
+        return link_list
+    
+    def get_joints(self, ) -> List[Joint]:
+        joint_list = []
+
+        for joint in self.rootComp.allJoints:
+            joint_list.append(Joint(joint)) # add joint objects into joint_list
+        
+        return joint_list
+
+    def get_loop_joints(self,) -> List[Joint]:
+        return self.loop_joints
+    
+    def get_tree_joints(self, ) -> List[Joint]:
+        return self.tree_joints
+    
+
+    def get_graph(self, ):
+        pass
+
+    def seperate_joints(self, joint_list: List[Joint]) -> Tuple[List[Joint], List[Joint]]:
+        """
+        Seperate robot joints into two parts: loop joints, tree joints
+        
+        Returns:
+        loop_joints: List[Joint]
+            joints construct closed loop
+            it should be noted by user explicitly by name it with prefix "loop"
+        tree_joints: List[Joint]
+            edges connects nodes(links) like a spanning tree
+        """
+        loop_joints = []
+        tree_joints = []
+        for joint in joint_list:
+            if joint.name.startswith("loop"):
+                loop_joints.append(joint)
+            else:
+                tree_joints.append(joint)
+        return loop_joints, tree_joints
+
+    def is_connected_graph(self, ):
+        pass