UA-.NETStandard/samples/Robotics/BinPickingCell/Assets/Cell.usda

#usda 1.0
(
    doc = """Bin-picking work cell for the OPC UA Vision guided-picking sample.

    The scene uses a branch-stable four-axis palletizer sized for this cell and
    the parallel gripper shared with IntentEnabledRobot. It adds a bin of mixed
    parts, a fixture to place them onto, and an eye-in-hand camera parented to
    the flange so the view moves with the arm. This is the worked example
    reproduced from the OPC UA Robotics-Vision Addendum: frame tree
    world -> robot_base -> flange -> gripper_tcp with camera_eih on the flange.

    Rendering contract:

    Keep the single DomeLight at intensity 1000. In the sample's original
    lighting tests, a DistantLight bright enough to show geometry washed every
    part to white, preventing selection of "the red part". Historical DomeLight
    captures measured red (220, 37, 37), green (37, 208, 49), blue (37, 73, 233).
    Re-check captured colors after lighting, material or renderer changes.

    Frame tree contract:

    - /World is the WorldFrame origin.
    - /World/Robot/Palletizer/Base is the robot_base frame.
    - /World/Robot/Palletizer/Base/J1/J2/J3/Leveling/J4/Flange is the flange
      (mechanical interface).
    - /World/Robot/Palletizer/.../Flange/Camera is the eye-in-hand camera prim
      (UsdGeomCamera) that the Vision sensor renders from.
    - /World/Robot/Palletizer/.../Flange/Gripper/Tcp is the gripper_tcp frame.

    The camera is a child of the flange with no stack reset, so it travels with
    the arm as a real eye-in-hand sensor does: rotateY = -90 turns its view axis
    onto the flange +X tool direction. The authored joint angles put the flange
    over the bin at the sample's start pose, so it opens looking into the bin.
    """
    defaultPrim = "World"
    metersPerUnit = 1
    upAxis = "Z"
)

def Xform "World"
{
    # A fixed observer for the viewport, distinct from the eye-in-hand sensor on the
    # flange. Opening the viewer on /World/Robot/.../Camera shows what the tool sees; this
    # one shows the cell working, which is what someone watching the robot wants.
    #
    # It sits on the -Y side so +X reads left to right, which is what puts the fixture on
    # the left and the bin on the right. This is deliberately a low, centred front view:
    # the table surface is nearly edge-on, its legs stay visible, and the complete wrist,
    # gripper, bin and stack can be judged against one another throughout a cycle.
    #
    # The numbers were fitted to a reference framing and then corrected against what the
    # viewer actually rendered, because the analytic placement and the rendered result did
    # not agree - the framing came out offset and over-scaled. Treat them as measured
    # rather than derived: change one and the framing has to be re-checked against a
    # capture, not just recomputed.
    def Camera "ObserverCamera"
    {
        token projection = "perspective"
        float focalLength = 31.6
        float horizontalAperture = 20.955
        float verticalAperture = 16.989
        float2 clippingRange = (0.1, 100.0)
        double3 xformOp:translate = (0.500, -5.400, 1.300)
        double xformOp:rotateX = 75.50
        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateX"]
    }

    def Xform "Lights"
    {
        def DomeLight "Sky"
        {
            float inputs:intensity = 1000
            color3f inputs:color = (1.0, 1.0, 1.0)
        }
    }

    def Xform "Robot"
    {
        def Cylinder "PedestalRiser"
        {
            uniform token axis = "Z"
            double height = 0.2000
            double radius = 0.1650
            color3f[] primvars:displayColor = [(0.16, 0.17, 0.18)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0, 0, 0.8200)
            uniform token[] xformOpOrder = ["xformOp:translate"]
        }

        def Xform "Palletizer" (
            references = @palletizer-arm.usda@</Palletizer>
        )
        {
            double3 xformOp:translate = (0, 0, 0.9200)
            uniform token[] xformOpOrder = ["xformOp:translate"]

            over "Base"
            {
                over "J1"
                {
                    double xformOp:rotateZ = 0.000
                    over "J2"
                    {
                        double xformOp:rotateY = 31.513
                        over "J3"
                        {
                            double xformOp:rotateY = -65.890
                            over "Leveling"
                            {
                                double xformOp:rotateY = 124.377
                                over "J4"
                                {
                                    double xformOp:rotateX = 90.000
                                    over "Flange"
                                    {
                                        def Xform "Gripper" (
                                            references = @palletizer-gripper.usda@</PalletizerGripper>
                                        )
                                        {
                                        }

                                        def Camera "Camera"
                                        {
                                            token projection = "perspective"
                                            float focalLength = 12.24
                                            float horizontalAperture = 14.688
                                            float verticalAperture = 12.288
                                            float2 clippingRange = (0.02, 5.0)
                                            double3 xformOp:translate = (0.0200, 0.0000, 0.1600)
                                            double xformOp:rotateY = -90
                                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateY"]
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    def Xform "Floor"
    {
        def Cube "Slab"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.36, 0.37, 0.40)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0, 0, -0.0250)
            double3 xformOp:scale = (2.4000, 1.8000, 0.0250)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }
    }

    def Xform "Bench"
    {
        def Cube "Top"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.58, 0.60, 0.60)] (
                interpolation = "constant"
            )
            # The work surface is z = 0.720. The robot base is independently raised
            # to z = 0.920 on PedestalRiser, so the wrist no longer has to fold back
            # on itself to reach parts lying close to the table.
            double3 xformOp:translate = (0, 0, 0.6850)
            double3 xformOp:scale = (1.4000, 0.9000, 0.0700)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "LegA"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.22, 0.23, 0.24)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.5800, 0.3300, 0.3250)
            double3 xformOp:scale = (0.0250, 0.0250, 0.6500)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "LegB"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.22, 0.23, 0.24)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (-0.5800, 0.3300, 0.3250)
            double3 xformOp:scale = (0.0250, 0.0250, 0.6500)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "LegC"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.22, 0.23, 0.24)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.5800, -0.3300, 0.3250)
            double3 xformOp:scale = (0.0250, 0.0250, 0.6500)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "LegD"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.22, 0.23, 0.24)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (-0.5800, -0.3300, 0.3250)
            double3 xformOp:scale = (0.0250, 0.0250, 0.6500)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }
    }

    def Xform "Bin"
    {
        def Cube "BinFloor"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.42, 0.32, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.6000, 0.0000, 0.7160)
            double3 xformOp:scale = (0.2800, 0.2400, 0.0060)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "BinWallN"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.42, 0.32, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.6000, 0.1170, 0.7330)
            double3 xformOp:scale = (0.2800, 0.0060, 0.0400)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "BinWallS"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.42, 0.32, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.6000, -0.1170, 0.7330)
            double3 xformOp:scale = (0.2800, 0.0060, 0.0400)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "BinWallE"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.42, 0.32, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.7370, 0.0000, 0.7330)
            double3 xformOp:scale = (0.0060, 0.2400, 0.0400)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cube "BinWallW"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.42, 0.32, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (0.4630, 0.0000, 0.7330)
            double3 xformOp:scale = (0.0060, 0.2400, 0.0400)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }
    }

    def Xform "Fixture"
    {
        def Cube "Base"
        {
            double size = 1
            color3f[] primvars:displayColor = [(0.20, 0.20, 0.22)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (-0.6000, 0.0000, 0.7200)
            double3 xformOp:scale = (0.1400, 0.1400, 0.0180)
            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:scale"]
        }

        def Cylinder "PegA"
        {
            uniform token axis = "Z"
            double height = 0.0400
            double radius = 0.0090
            color3f[] primvars:displayColor = [(0.95, 0.85, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (-0.6500, 0.0500, 0.7490)
            uniform token[] xformOpOrder = ["xformOp:translate"]
        }

        def Cylinder "PegB"
        {
            uniform token axis = "Z"
            double height = 0.0400
            double radius = 0.0090
            color3f[] primvars:displayColor = [(0.95, 0.85, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (-0.5500, 0.0500, 0.7490)
            uniform token[] xformOpOrder = ["xformOp:translate"]
        }

        def Cylinder "PegC"
        {
            uniform token axis = "Z"
            double height = 0.0400
            double radius = 0.0090
            color3f[] primvars:displayColor = [(0.95, 0.85, 0.20)] (
                interpolation = "constant"
            )
            double3 xformOp:translate = (-0.6000, -0.0500, 0.7490)
            uniform token[] xformOpOrder = ["xformOp:translate"]
        }
    }

    # Each part is an Xform carrying a single xformOp:transform, with its shape as a child.
    # The OpenUSD live binding drives the parent's transform, and the viewer sink authors
    # that op as a whole matrix - composing translation with a default identity rotation and
    # unit scale. Rotation and scale therefore have to live somewhere the binding does not
    # overwrite, which is the child. The composition is unchanged: the shape is scaled and
    # rotated about its own origin, then the parent translates it.
    def Xform "Parts"
    {
        def Xform "RedCube"
        {
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0.5200, -0.0800, 0.7400, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform"]

            def Cube "Shape"
            {
                double size = 0.0400
                color3f[] primvars:displayColor = [(0.90, 0.15, 0.15)] (
                    interpolation = "constant"
                )
                double xformOp:rotateZ = 20
                uniform token[] xformOpOrder = ["xformOp:rotateZ"]
            }
        }

        def Xform "GreenCylinder"
        {
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0.6700, 0.0800, 0.7350, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform"]

            def Cylinder "Shape"
            {
                uniform token axis = "Z"
                double height = 0.0300
                double radius = 0.0200
                color3f[] primvars:displayColor = [(0.15, 0.85, 0.20)] (
                    interpolation = "constant"
                )
            }
        }

        def Xform "BlueSphere"
        {
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0.6800, -0.0800, 0.7440, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform"]

            def Sphere "Shape"
            {
                double radius = 0.0240
                color3f[] primvars:displayColor = [(0.15, 0.30, 0.95)] (
                    interpolation = "constant"
                )
            }
        }

        def Xform "YellowSlab"
        {
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0.5200, 0.0600, 0.7290, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform"]

            def Cube "Shape"
            {
                double size = 1
                color3f[] primvars:displayColor = [(0.95, 0.85, 0.15)] (
                    interpolation = "constant"
                )
                double3 xformOp:scale = (0.0640, 0.0320, 0.0180)
                double xformOp:rotateZ = -15
                uniform token[] xformOpOrder = ["xformOp:rotateZ", "xformOp:scale"]
            }
        }

        def Xform "OrangeBrick"
        {
            matrix4d xformOp:transform = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0.6000, 0.0000, 0.7320, 1) )
            uniform token[] xformOpOrder = ["xformOp:transform"]

            def Cube "Shape"
            {
                double size = 1
                color3f[] primvars:displayColor = [(0.95, 0.45, 0.10)] (
                    interpolation = "constant"
                )
                double3 xformOp:scale = (0.0500, 0.0280, 0.0240)
                double xformOp:rotateZ = 40
                uniform token[] xformOpOrder = ["xformOp:rotateZ", "xformOp:scale"]
            }
        }
    }
}