Call a Function from rarray.eachpoint(my_func)

[DeBalog]

I would like to call my_func from rarray.eachpoint. This is my code with error:

import cadquery as cq

def my_func (pnt):
    return cq.Workplane('XY').transformed(offset=pnt.toTuple()) \
        .circle(5) \
        .extrude(40)

# Create a base object with a defined workplane
base = cq.Workplane("XY")
res = base.box(100, 100, 1.2)

res = (
    res.rarray(10, 10, 5, 10, center=True)
      # .eachpoint(lambda loc: my_func(cq.Workplane("XY").move(loc.toTuple()[0]))))
      .eachpoint(my_func)
      )

show_object (res)

[lorenzncode]

Here is an example where the cylinders are combined with the base and where a z offset is applied before calling eachpoint.

def my_func(loc):
    return cq.Workplane("XY").circle(5).extrude(40).val().move(loc)


# Create a base object with a defined workplane
base = cq.Workplane("XY")
res = base.box(100, 100, 1.2)
res = res.workplane(offset=1.2 / 2)
res = res.rarray(10, 10, 5, 10, center=True).eachpoint(my_func, combine=True)

[lorenzncode]

Equivalent result using Sketch:

base = cq.Workplane("XY")
res = base.box(100, 100, 1.2)
res = res.faces(">Z").workplane()

sk1 = cq.Sketch().rarray(10, 10, 5, 10).circle(5)
res = res.placeSketch(sk1).extrude(40)

[DeBalog]

Thank you very much for your kind support.

I deliberately outsourced the construction to a function in order to divide my code into manageable sections. The construction of the object is now in the sondenhalter() function.

I now have two problems with this function:

1. This function makes both a cut() and a union() on the base figure res. It seems that the cut is not completely received due to the parameter Combine=True in eachpoint, as the cuts are missing in the res object.
2. The last line of the probe holder function contains many repetitions of val().move(loc). I would like to avoid these.

# avoid repetitions
return sockelhalter.val().move(loc) - sockel.val().move(loc) + auflage.val().move(loc)

What does an implementation look like in which a workplane is created at the loc point to perform the cut and union operators there?

import cadquery as cq

def rotx(shape, angle):
    # Rotiert das gegebene Shape um die z-Achse mit dem Ursprung als Rotationspunkt
    return shape.rotate((0, 0, 0), (1, 0, 0), angle)
cq.Workplane.rotx = rotx

def roty(shape, angle):
    # Rotiert das gegebene Shape um die z-Achse mit dem Ursprung als Rotationspunkt
    return shape.rotate((0, 0, 0), (0, 1, 0), angle)
cq.Workplane.roty = roty

def rotz(shape, angle):
    # Rotiert das gegebene Shape um die z-Achse mit dem Ursprung als Rotationspunkt
    return shape.rotate((0, 0, 0), (0, 0, 1), angle)
cq.Workplane.rotz = rotz


t = .5 # Toleranz
sockel_d_raw = 13  # Diameter
sockel_d = sockel_d_raw + t

sockel_h_raw = 5.33  # Height
sockel_h = sockel_h_raw + t

sonde_h = 18

wall_bottom=1.2


# Parameter
triangle_base = 13  # Länge der Hypotenuse
triangle_h = 4 

def sondenhalter (loc):
    """
    an dem Center des Workplanes wird die Figur eingesezt dann verschoben
    """
    
    base = cq.Workplane("XY")
    sockel_r = sockel_d / 2
    one_layer = .25 # die Druckhöhe eines Asudrucks
    
    sockel = ( 
        base.circle(sockel_r).extrude(sockel_h).rotx (90) 
        .translate((0, 0, sockel_r + one_layer - wall_bottom))
        )
    
    sockelhalter = (
        base.box (sockel_d + 3.5*t, sockel_h + 2*t, sockel_r, 
                  centered = (True, False, False))
        .translate ((0, -sockel_h - 2*t, 0))
        )
    
    # Punkte des Dreiecks
    p1 = (0, 0)  # Ursprung
    p2 = (triangle_base, 0)  # Ende der Hypotenuse auf der x-Achse
    p3 = (triangle_base/2, triangle_h)  # Spitze des Dreiecks

    # Dreieckskontur
    auflage = base.polyline([p1, p2, p3, p1]).close()

    # Optional: Extrusion, wenn ein 3D-Körper gewünscht ist
    auflage = auflage.extrude(3).translate((-triangle_base/2, 0, 0))


    auflage = auflage.edges("|Z").fillet(.4)

    # auflage = base.box (sockel_d, 6, 4, centered = (True, True, False))
    # auflage = auflage.intersect (auflage.rotz(45).translate((4,0,0)))
    # auflage = auflage.intersect (auflage.rotz(-45).translate((-4,0,0)))
    # auflage = auflage.translate((0, 3, 0))

    # Combine the objects
    return sockelhalter.val().move(loc) - sockel.val().move(loc) + auflage.val().move(loc)
        

# Create a base object with a defined workplane
base = cq.Workplane("XY")
res = base.box(50, 60, wall_bottom, centered= (True, True, False)).translate ((0,0,-wall_bottom))

res = res.rarray(sockel_d + 5*t, sonde_h + 4*t, 3, 3, center=True) \
    .eachpoint(sondenhalter, combine=True)

show_object (res)

[lorenzncode]

I see you are using the master branch. That's good - so I won't worry sharing code that does not work with 2.4.0. The following examples also requires master (free function usage, move and eachpoint enhancements, invoke, etc.)

the cuts are missing in the res object.

Yes, here in this simplified example it's solved with a separate cut (eachpoint with combine="s"):

import cadquery as cq
from cadquery.occ_impl.shapes import *

box1 = box(10, 4, 4)
cyl1 = cylinder(6, 3).move(0, -1, 2, rx=-90)

# res1 = box1 - cyl1  # cut not needed here; to visualize only

res = (
    cq.Workplane("XY")
    .box(30, 20, 0.5)
    .faces(">Z")
    .workplane()
    .rarray(15, 10, 2, 2)
    .eachpoint(box1, combine="a")  # additive mode
    .rarray(15, 10, 2, 2)
    .eachpoint(cyl1, combine="s")  # subtractive mode
)

Or you might try with invoke:

import cadquery as cq
from cadquery.occ_impl.shapes import *


def myfunc(wp):
    box1 = box(10, 4, 4)
    cyl1 = cylinder(6, 3).move(0, 2, 2, rx=90)

    part1 = wp.eachpoint(lambda loc: box1.moved(loc))
    part2 = wp.eachpoint(lambda loc: cyl1.moved(loc))

    res = wp.solids() + part1 - part2

    return res


res = cq.Workplane().box(30, 20, 0.5)
res = res.faces(">Z").workplane().rarray(15, 10, 2, 2).invoke(myfunc)

[DeBalog]

In the end, I implemented it completely differently: I set the current position in the loop and then call the function to draw. The parameters were the workplane and the current figure. The function itself creats a copy of the workplane with the current position. Then it made the necessary changes there and in the last step combins them with the passed figure and returned the result.

That is one strength of CQ: It can receive shapes as parameters in a function and also deliver them.

[DeBalog]

Tank's for your help.