Suggestions for multi layer chip CAD generation

[pruj-speed]

Hi Folks,

cadquery is a great tool and I started using it very recently. My ultimate goal is to be able to import a chip layout file typically a gds (similar to dxf in my head) and convert it to a STEP file with full topological detail. As of now I have implemented a gds import and I'm able to extrude out polygons from different layers to specified thicknesses. My next step would be to implement the extrude over non-flat topology. For example, one can imagine a semiconductor chip with a etched pattern and then a thin layer of metal gets deposited. The layer has to conform to the topology of the substrate. Then another layer will be deposited which has to conform to both the substrate topology and the new layer that has been deposited.

To illustrate the example, I have attached an image. This chip layout has four layers:

1. Substrate
2. Etch
3. Coating1
4. Coating2

I'm not sure what's the best way to implement such an operation which will extrude a polygon over a topology. Any advice appreciated!

[jmwright]

@pruj-speed I'm assuming since you said "conform to the topology", that the substrate has a 3D curvature to it and is not planar.

Potentially related issue: link

Potentially related CQ feature: link

The other core devs will probably have ideas as well.

[pruj-speed]

@jmwright I think if I can figure out how to extrude over a planar stepped structure that would be a great starting point. For now, I can approximate the topology to have no curvature. I would describe it like stapling a carpet over a staircase.

[pruj-speed]

I wonder if some inspiration can be taken from here #1193

[pruj-speed]

Key idea taken from here is to thicken a surface in one direction. Generating that surface is a challenge considering that cadquery doesnt have a built in method to split several faces against a polygon. Need to somehow implement this.

[pruj-speed]

If it's possible to project a shadow of a polygon on the topology of the solid, then in principle I should be able to thicken that shadow in one direction to generate the conformal layer. I found a similar request from another user #1674. Is there an imprint method to project a wire on a solid? Looks like something like this was discussed here. Not sure if this functionality is available for a part. #1353

[pruj-speed]

Posting here my progress today on trying to implement this carpet prototype. I dont fully understand what this code does because it was partly written by chatgpt. Having said that it is roughly the right direction.

Input solid with a blind cut

Casting a shadow of the polygon on all surfaces directly below it

import cadquery as cq
from OCP.gp import gp_Pnt
from OCP.BRepAlgoAPI import BRepAlgoAPI_Splitter
from OCP.TopTools import TopTools_ListOfShape
from OCP.TopExp import TopExp_Explorer
from OCP.TopAbs import TopAbs_FACE
from jupyter_cadquery import show

# Helper function to create TopTools_ListOfShape from a list of TopoDS_Shape
def create_toptools_list(shapes):
    toptools_list = TopTools_ListOfShape()
    for shape in shapes:
        toptools_list.Append(shape)
    return toptools_list

# Function to collect all faces from a shape
def collect_faces(shape):
    explorer = TopExp_Explorer(shape, TopAbs_FACE)
    faces = []
    while explorer.More():
        face = explorer.Current()
        faces.append(face)
        explorer.Next()
    return faces

# Step 1: Create a base cube using CadQuery
base_model = cq.Workplane("XY").box(10, 10, 10, centered=True).faces(">>Z").workplane().rect(1,5).cutBlind(-1)
base_shape = base_model.val().wrapped  # Access the underlying TopoDS_Shape

# Step 2: Define and extrude the splitting polygon using CadQuery
splitting_polygon = (
    cq.Workplane("XY")
    .polyline([
        (-2, -2),
        (2, -2),
        (2, 2),
        (-2, 2),
        (-2, -2)
    ])
    .close()
    .wire()
)
splitting_wire = splitting_polygon.val().wrapped  # Access the TopoDS_Shape

show(base_model, splitting_wire)

# Extrude the polygon to create a 3D splitting tool (prism) using CadQuery
splitting_tool = splitting_polygon.extrude(20)  # Extrude 20 units in the Z-direction
split_tool_shape = splitting_tool.val().wrapped  # Access the TopoDS_Shape

# Step 3: Collect all target faces to split
faces_to_split_shapes = collect_faces(base_shape)
faces_to_split = create_toptools_list(faces_to_split_shapes)

# Step 4: Initialize the splitter and set arguments and tools
splitter = BRepAlgoAPI_Splitter()

# Set the shapes to split
splitter.SetArguments(faces_to_split)

# Set the splitting tool(s)
splitter.SetTools(create_toptools_list([split_tool_shape]))

# # Optional configurations
splitter.SetCheckInverted(True)  # Enable checking for inverted solids
# splitter.SetGlue(True)            # Enable gluing for optimized performance

# Step 5: Perform the split operation
splitter.Build()

# Step 6: Retrieve and verify the split result
if splitter.IsDone():
    split_result = splitter.Shape()  # Get the resulting TopoDS_Shape after split
    show(split_result)  # Display both the original and split models
else:
    error_report = splitter.GetReport()
    print("Split operation failed with errors:", error_report)
    raise RuntimeError("Split operation failed.")

print(type(base_model),type(base_shape),type(splitter),type(split_result))

#cd_solid = cq.Solid(split_result)

#cd_solid.export('splitface_carpet.step')

When I read the STEP file I see a whole bunch of surface bodies

I was hoping to have a single solidbody with 19 faces. If any of the maintainers read this please advice if there is a better way to accomplish this.

[adam-urbanczyk]

Use split then as suggested in the other thread.

[adam-urbanczyk]

It is not clear though if you are after imprinting a face or fusing solids. And is this a CQ question or OCP question? You are mostly not using CQ code in your example.

[pruj-speed]

@adam-urbanczyk I want to use cadquery as much as possible. I didnt know split method existed. After your comment on the other thread and also seeing your comment here I now have the split feature working for a single face. I would need the split to propagate to all faces directly below the polygon. I havent figured that out yet.

Screenshot of what I'm trying to achieve. The splitting polygon is a triangle. This was manually done in solidworks.

Here is my current state with doing only a single split operation.

Code:

from cadquery.occ_impl.shapes import polyline, face
from cadquery.vis import show
import cadquery as cq

points = [
    (-2.5, -2.5),
    (2.5, -2.5),
    (0, 2.5)
]

# Step 1: Create the base cube
base_model = cq.Workplane("XY").box(10, 10, 10, centered=True)

# Step 2: Create a blind cut on the top face of the cube
base_model = base_model.faces(">>Z").workplane().rect(1, 7).cutBlind(-1)

box_top = base_model.faces('>>Z')

# Step 3: Create a closed wire using the polyline function
polygon_wire = polyline(*points).close()

# Step 4: Convert the wire to a face and move to box top
polygon_face = face(polygon_wire).moved(z=5)


# Step 5: Perform the split operation
result = base_model.split(polygon_face)

# Display the result for visualization
show(result)

I know I'm supposed to supply all the surfaces and somehow iteratively split them. If you have any advice would greatly appreciate it.

[pruj-speed]

I figured it out! Just need to make another solid which intersects all underlying surfaces and then split.

from cadquery.occ_impl.shapes import polyline, face, extrude
from cadquery import Vector
from cadquery.vis import show
import cadquery as cq

# Define the points of the polygon
points = [
    (-2.5, -2.5),
    (2.5, -2.5),
    (0, 2.5)
]

# Step 1: Create the base cube
base_model = cq.Workplane("XY").box(10, 10, 10, centered=True)

# Step 2: Create a blind cut on the top face of the cube
base_model = base_model.faces(">>Z").workplane().rect(1, 7).cutBlind(-1)

# Step 3: Create a closed wire using the polyline function
polygon_wire = polyline(*points).close()

# Step 4: Convert the wire to a face and move it to the top of the cube
polygon_face = face(polygon_wire).moved(cq.Location(Vector(0, 0, 5)))

# Step 5: Extrude the polygon face downward to create a splitting solid
splitting_solid = extrude(polygon_face,(0,0,-5))

# Step 6: Perform the split operation using the splitting solid
result = base_model.split(splitting_solid)

# Display the result for visualization
show(result)

Thank you for pointing me in the right direction!

[pruj-speed]

Now able to do one layer coating. Last step is multiple layers.

from cadquery.occ_impl.shapes import polyline, face, extrude, Compound
from cadquery import Vector
from cadquery.vis import show
import cadquery as cq

# Define the points of the polygon
points = [
    (-1.5, -1.5),
    (1.5, -1.5),
    (1.5, 1.5),
    (-1.5, 1.5)
]

# Step 1: Create the base cube
base_model = cq.Workplane("XY").box(10, 10, 10, centered=True)

# Step 2: Create a blind cut on the top face of the cube
base_model = base_model.faces(">>Z").workplane().rect(1, 7).cutBlind(-1)

# show(base_model)

# Step 3: Create a closed wire using the polyline function
polygon_wire = polyline(*points).close()

# Step 4: Convert the wire to a face and move it to the top of the cube
polygon_face = face(polygon_wire).moved(cq.Location(Vector(0, 0, 5)))

# Step 5: Extrude the polygon face downward to create a splitting solid
splitting_solid = extrude(polygon_face, (0, 0, -5))

# Step 6: Perform the split operation using the splitting solid
split_result = base_model.split(splitting_solid)

# Step 7: Find the intersection between the base model and the splitting solid
intersected_shape = base_model.intersect(splitting_solid)

# Step 8: Get all faces from the intersection
intersected_faces = intersected_shape.faces()

# Step 9: Filter faces located above z = 5
faces_above_z5 = []
for f in intersected_faces:
    center = f.Center()
    if center.z > 2.5:
        faces_above_z5.append(f)

# Ensure we have faces to work with
if not faces_above_z5:
    raise ValueError("No faces found above z = 2.5")

# Step 10: Fuse all relevant faces into a single face to handle overlaps
# Initialize the fused shape with the first face
fused_shape = faces_above_z5[0]

# Iterate through the remaining faces and fuse them
for face_to_fuse in faces_above_z5[1:]:
    fused_shape = fused_shape.fuse(face_to_fuse)

# Wrap the fused shape into a CadQuery Face object
fused_face = cq.Face(fused_shape.wrapped)

# show(fused_face)

# Step 11: Thicken the fused face upwards to create a new solid
# Note: 'thicken' thickens in both directions by default, but we can control the direction
# by specifying the vector direction. Here, we thicken upwards by 2 units.
thickened_solid = fused_face.thicken(0.1)  # 'both=False' ensures thickening in one direction

# show(thickened_solid)

# Step 12: Fuse the thickened solid with the base model
result_model = base_model.add(thickened_solid)

# Step 13: Display the result for visualization
show(result_model)

[pruj-speed]

Here is one way to achieve this semiconductor 3D CAD creation. There probably is a much more efficient way to do this. Sharing my hacky implementation for anyone who comes along the same path.

import cadquery as cq
from cadquery.occ_impl.shapes import polyline, face, extrude
from cadquery import Vector
from cadquery.vis import show

# Helper Function

def get_box_dimensions(polygon):
    """
    Calculates the length and width of a rectangle polygon.

    :param polygon: List of (x, y) tuples defining the rectangle.
    :return: Tuple (length, width)
    """
    xs = [point[0] for point in polygon]
    ys = [point[1] for point in polygon]
    length = max(xs) - min(xs)
    width = max(ys) - min(ys)
    return length, width

# Core Functions

def create_splitting_solid(polygon_points, z_position, depth):
    """
    Creates a splitting solid by extruding a polygon face downward.

    :param polygon_points: List of points defining the polygon.
    :param z_position: Z-coordinate where the polygon face is positioned.
    :param depth: Depth to extrude downward (positive value).
    :return: The splitting solid.
    """
    # Create a closed wire using the polyline function
    polygon_wire = polyline(*polygon_points).close()
    # Convert the wire to a face and move it to the specified z_position
    polygon_face = face(polygon_wire).moved(cq.Location(Vector(0, 0, z_position)))
    # Extrude the polygon face downward to create a splitting solid
    splitting_solid = extrude(polygon_face, (0, 0, -depth))
    return splitting_solid

def intersect_with_base_current(base_current, splitting_solid):
    """
    Finds the intersection between the base_current and the splitting solid.

    :param base_current: The current base model (substrate plus previous deposits).
    :param splitting_solid: The splitting solid.
    :return: The intersected shape.
    """
    # Find the intersection between the base_current and the splitting solid
    intersected_shape = base_current.intersect(splitting_solid)
    return intersected_shape

def extract_and_fuse_faces(intersected_shape, z_threshold):
    """
    Extracts faces from the intersected shape that are above a certain z-coordinate and fuses them.

    :param intersected_shape: The shape resulting from the intersection.
    :param z_threshold: The minimum z-coordinate for faces to be included.
    :return: The fused face.
    """
    # Get all faces from the intersection
    intersected_faces = intersected_shape.faces()
    # Filter faces located above z_threshold
    faces_above_threshold = []
    for f in intersected_faces:
        center = f.Center()
        if center.z >= z_threshold:
            faces_above_threshold.append(f)
    # Ensure we have faces to work with
    if not faces_above_threshold:
        raise ValueError(f"No faces found above z = {z_threshold}.")
    # Fuse all relevant faces into a single face
    fused_shape = faces_above_threshold[0]
    for face_to_fuse in faces_above_threshold[1:]:
        fused_shape = fused_shape.fuse(face_to_fuse)
    # Wrap the fused shape into a CadQuery Face object
    fused_face = cq.Face(fused_shape.wrapped)
    return fused_face

def thicken_face(fused_face, thickness):
    """
    Thickens the fused face upwards to create a new solid.

    :param fused_face: The fused face to thicken.
    :param thickness: Thickness to thicken upwards.
    :return: The thickened solid.
    """
    # Thicken the fused face upwards to create a new solid
    thickened_solid = fused_face.thicken(thickness)
    return thickened_solid

# Polygons Definitions

# Substrate polygon (defines the base cube)
substrate_polygon = [
    (-5, -5),
    (5, -5),
    (5, 5),
    (-5, 5)
]

# Blind cut polygon (for the top face cut)
blind_cut_polygon = [
    (-2.5, -2.5),
    (2.5, -2.5),
    (2.5, 2.5),
    (-2.5, 2.5)
]

# Blind cut polygon2 (for the top face cut)
blind_cut_plygon2 = [
    (-2, -2),
    (2, -2),
    (2, 2),
    (-2, 2)
]

# Coating1 polygon
a, b = (0.75, 4.5)
coating1_polygon = [
    (-a, -b),
    (a, -b),
    (a, b),
    (-a, b)
]

# Coating2 polygon (rotated version of Coating1)
coating2_polygon = [
    (-b, -a),
    (b, -a),
    (b, a),
    (-b, a)
]

# Layers Definitions

substrate_depth = 5
tool_depth = substrate_depth
z_threshold_global = (substrate_depth/4)

layers = [
    {
        'name': 'Substrate',
        'polygon_points': substrate_polygon,
        'z_position': 0,  # Centered at origin, so starting at -height/2
        'depth': substrate_depth,        # Height of the substrate
        'thickness': 0.0,    # No thickening needed
        'z_threshold': -2.5, # Include all faces
        'operation': 'substrate',  # Substrate operation
        'color': 'gray'
    },
    {
        'name': 'BlindCut',
        'polygon_points': blind_cut_polygon,
        'z_position': 2.5,   # Top of the substrate
        'depth': tool_depth,       # Depth of the cutting solid
        'thickness': -0.25,   # Thickness to thicken
        'z_threshold': z_threshold_global, # Faces above this z will be included
        'operation': 'etch',  # Blind cut is an etch
        'color': 'darkgray'
    },
    {
        'name': 'BlindCut2',
        'polygon_points': blind_cut_plygon2,
        'z_position': 2.5,   # Top of the substrate
        'depth': tool_depth,       # Depth of the cutting solid
        'thickness': -0.25,   # Thickness to thicken
        'z_threshold': z_threshold_global, # Faces above this z will be included
        'operation': 'etch',  # Blind cut is an etch
        'color': 'darkgray'
    },
    {
        'name': 'Coating1',
        'polygon_points': coating1_polygon,
        'z_position': 2.5,   # Top of the substrate
        'depth': tool_depth,        # Depth of cutting solid
        'thickness': 0.1,    # Thickness to thicken
        'z_threshold': z_threshold_global,  # Faces above this z will be included
        'operation': 'deposit',  # Deposit operation
        'color': 'gold'
    },
    {
        'name': 'Coating2',
        'polygon_points': coating2_polygon,
        'z_position': 2.5,
        'depth': tool_depth,
        'thickness': 0.1,
        'z_threshold': z_threshold_global,
        'operation': 'deposit',
        'color': 'goldenrod'
    },
    # Add more layers as needed
]


# Initialize the coatings list
coatings_list = []

# Initialize the assembly
assy = cq.Assembly()

# Initialize the base model and base_current
substrate = None
base_current = None

# Loop over the layers
for layer in layers:
    if layer['operation'] == 'substrate':
        # Create the substrate using the substrate_polygon
        length, width = get_box_dimensions(layer['polygon_points'])
        
        # Create the substrate box centered about Z
        substrate = cq.Workplane("XY").box(length, width, layer['depth'], centered=True)
        
        # Update base_current with the substrate
        base_current = substrate

        show(base_current)
        
        continue  # Move to the next layer

    elif layer['operation'] == 'etch':
        # Create the splitting solid
        splitting_solid = create_splitting_solid(
            polygon_points=layer['polygon_points'],
            z_position=layer['z_position'],
            depth=layer['depth']
        )
        show(base_current,splitting_solid)

        # Find the intersection with base_current
        intersected_shape = intersect_with_base_current(base_current, splitting_solid)

        # show(intersected_shape)

        # Extract and fuse faces above z_threshold
        fused_face = extract_and_fuse_faces(
            intersected_shape=intersected_shape,
            z_threshold=layer['z_threshold']
        )

        # show(fused_face)

        # Thicken the fused face upwards to create a cut_solid
        cut_solid = thicken_face(
            fused_face=fused_face,
            thickness=layer['thickness']
        )

        show(base_current,cut_solid)

        # Update the substrate by cutting the cut_solid
        substrate = substrate.cut(cut_solid)

        # Update base_current to reflect the modified substrate
        base_current = substrate

        show(base_current)

    elif layer['operation'] == 'deposit':
        # Create the splitting solid
        splitting_solid = create_splitting_solid(
            polygon_points=layer['polygon_points'],
            z_position=layer['z_position'],
            depth=layer['depth']
        )

        show(base_current, splitting_solid)

        # Find the intersection with base_current
        intersected_shape = intersect_with_base_current(base_current, splitting_solid)

        # show(base_current, intersected_shape)

        # Extract and fuse faces above z_threshold
        fused_face = extract_and_fuse_faces(
            intersected_shape=intersected_shape,
            z_threshold=layer['z_threshold']
        )

        show(fused_face)

        show(base_current, fused_face)

        # Thicken the fused face upwards to create an extrude_solid
        extrude_solid = thicken_face(
            fused_face=fused_face,
            thickness=layer['thickness']
        )

        show(base_current, extrude_solid)

        # Update base_current by unioning it with the extrude_solid
        base_current = base_current.union(extrude_solid)

        # Append the layer name and extrude_solid to coatings_list
        coatings_list.append({'name': layer['name'], 'solid': extrude_solid, 'color': layer['color']})

    else:
        raise ValueError(f"Unknown operation: {layer['operation']}")

# Create the assembly
# Add the updated substrate to the assembly (after all etches)
assy.add(substrate, name='Substrate', color=cq.Color('gray'))

# Add each coating to the assembly
for coating in coatings_list:
    assy.add(coating['solid'], name=coating['name'], color=cq.Color(coating['color']))

# Display the assembly
show(assy)

#assy.export('semiconductor_example.step')

Feel free to use, improvise.

[pruj-speed]

@adam-urbanczyk This question can be marked as answered