How to create assemblies with empty spacing (fillers) between parts?

[alikureishy]

I won't go into too much detail about why I need this, but I am looking to create an assembly wherein a couple of the parts are separated by empty spaces (i.e, not connected to other parts). If it was possible to create a virtual 3D part that could be used purely as a filler, but not get embedded into the final assembly's toCompound() method, that would have been ideal, but I couldn't find any way to do that (Maybe I missed something?).

To elaborate, here's an example. Let's say I'd like to add two rectangular solids -- 'a' and 'b' -- to my assembly, and make them stand straight, with some space between them (i.e, not in direct contact), as below:

One way that seems to work (though not very convenient) is by adding a 2D shape (let's call it 'spacing') with pending edges into the assembly, and then mating that spacing's vertices with parts 'a' and 'b' in such a way as to create that separation. For example:

a = cq.Workplane("XY").rect(xLen=1, yLen=2).extrude(5)
b = cq.Workplane("XY").rect(xLen=2, yLen=1).extrude(10)
spacing = cq.Workplane("XY").rect(xLen=3, yLen=2, forConstruction=True)

# Tagging a and b
a.faces("<X").tag("attach")
b.faces(">X").tag("attach")

# Tagging vertices and edges of the spacing
spacing.vertices(">X and <Y").tag("left_vertex")
spacing.vertices("<X and >Y").tag("right_vertex")
spacing.edges("|Y and >X").tag("left_side")
spacing.edges("|Y and <X").tag("right_side")

assembly = (
    cq.Assembly(a, name="a", color=cq.Color("red"))
        .add(b, name="b", color=cq.Color("green"))
        .add(spacing, name="spacing", color=cq.Color("blue"))
)

(
    assembly
    .constrain("spacing?left_vertex", "a?attach", "PointInPlane")
    .constrain("spacing?right_vertex", "b?attach", "PointInPlane")
    .constrain("a?attach", "spacing?left_side", "Axis")
    .constrain("b?attach", "spacing?right_side", "Axis")
)
assembly.solve()

This creates the assembly shown above, without including the 2D part. However, it is a convoluted process and seems more like a hack. For more complex spacing requirements, such reliance on pending 2D objects would become messy. Furthermore, I'd consider it even more messy to have to specify absolute locations (in WCS) to mimic that spacing between parts.

So:

• Are there any cleaner and more powerful/expressive mechanisms available to achieve the same thing? Maybe using 3d objects as fillers to mate with the real parts (without including the fillers into the assembly's output)?
• If I'd have to write a custom constraint, is there any documentation about how to extend constraints? Constraint extensibility, particularly in relation to its use by the assembly solver -- isn't documented anywhere, and the code isn't straightforward.

[marcus7070]

Documentation around this does need more work. #856 will be part of that. Here is an example of a dummy vertex:

a = cq.Workplane("XY").rect(xLen=1, yLen=2).extrude(5)
b = cq.Workplane("XY").rect(xLen=2, yLen=1).extrude(10)

assembly = (
    cq.Assembly(a, name="a", color=cq.Color("red"))
    .add(b, name="b", color=cq.Color("green"))
)
assembly.constrain(
    "a",
    cq.Vertex.makeVertex(3, 0, 0),
    "b",
    b.vertices("<X and <Y and <Z").val(),
    "Point",
)
assembly.constrain("a@faces@>X", "b@faces@<X", "Axis")
assembly.solve()

show_object(assembly)

Another method is to basically create an extra, temporary extrusion on your part a, tag a vertex on the tip of that extrusion, then use the method Workplane.end to rewind back to before you started the temporary extrusion.

a = (
    cq.Workplane("XY")
    .rect(xLen=1, yLen=2)
    .extrude(5)
    .faces(">X")
    .workplane()
    .box(1, 1, 3, centered=(True, True, False))
    .faces(">X")
    .tag("end_of_spacer")
    .end(4)
)

b = cq.Workplane("XY").rect(xLen=2, yLen=1).extrude(10)

assembly = (
    cq.Assembly(a, name="a", color=cq.Color("red"))
    .add(b, name="b", color=cq.Color("green"))
)
assembly.constrain(
    "a?end_of_spacer", "b@vertices@<X and <Y and <Z","Point",
)
assembly.constrain("a@faces@>X", "b@faces@<X", "Axis")
assembly.solve()

show_object(assembly)

(result looks the same as above)

[alikureishy]

Thanks for the prompt response, @marcus7070 . It was very helpful. The first approach -- of utilizing a dummy shape, relative to a subassembly's location -- works very well.

[alikureishy]

On a somewhat related note, would it also make sense to add a forConstruction parameter to Assembly's add() methods? It would serve a similar purpose as the Workplane's forConstruction parameter, but instead, would help to define part relationships at the Assembly level. Then, users could add shapes/sub-assemblies as templates for placement of other assembly parts via mate (or other) constraints.

So, the only API-level changes would be to the 2 add() methods on the Assembly class:

class Assembly(object):
...
...
...
    @overload
    def add(
        self,
        obj: "Assembly",
        loc: Optional[Location] = None,
        name: Optional[str] = None,
        color: Optional[Color] = None,
        forConstruction: bool = False,              <------ Added
    ) -> "Assembly":
        """
        Add a subassembly to the current assembly.
        :param obj: subassembly to be added
        :param loc: location of the root object (default: None, resulting in the location stored in
          the subassembly being used)
        :param name: unique name of the root object (default: None, resulting in the name stored in
          the subassembly being used)
        :param color: color of the added object (default: None, resulting in the color stored in the
          subassembly being used)
        :param forConstruction: utilize the added object only for enforcing constraints, without including it in the compound generated by the assembly (default: False)
        """
        ...

    @overload
    def add(
        self,
        obj: AssemblyObjects,
        loc: Optional[Location] = None,
        name: Optional[str] = None,
        color: Optional[Color] = None,
        forConstruction: bool = False,              <------ Added
    ) -> "Assembly":
        """
        Add a subassembly to the current assembly with explicit location and name.
        :param obj: object to be added as a subassembly
        :param loc: location of the root object (default: None, interpreted as identity
          transformation)
        :param name: unique name of the root object (default: None, resulting in an UUID being
          generated)
        :param color: color of the added object (default: None)
        :param forConstruction: utilize the added object only for enforcing constraints, without including it in the compound generated by the assembly (default: False)
        """
        ...

From an initial glance, this change would require changing a few other python files too, but does not seem to have any API-level impact elsewhere.

Thoughts?

[adam-urbanczyk]

-1, you can precisely achieve that with tagging just like @marcus7070 explained. More docs are coming, but for now you can study the assy example here: https://cadquery.readthedocs.io/en/latest/assy.html#defining-reusable-components