Hi Viktor,
As fred said, you generally have to separate the additive elements from the subtractive ones, so that at the top-level you're basically differencing the union of all of the additive items from the union of all of the subtractive ones.  You can't always do the differencing at a lower level and get the desired result, as you've observed.

Another thing you can consider is relativity.scad.  It makes it pretty easy to assign 'classes' to objects (at least once you 'get' the whole CSS thing, I never played with CSS myself), and provides a "differed()" which is like difference() but you tell it the positive and negative classes rather than it depending on the order they're declared.  Also makes it easy to build objects on top of other objects.  I believe the official home is here: <https://github.com/davidson16807/relativity.scad>.

In the end differed() is really just running difference(), the first object is your entire sub-tree of parts with only the positive items enabled, the second object is the entire sub-tree again with only the negative items enabled, it effectively (at least) doubles the size of your tree (really it triples it because there's a third argument for an 'unaffected' class, see the description of differed from the link above), so with complex trees the rendering time can explode especially as you layer more relativity constructs.  Provided your objects aren't too complex or you're patient, I find it to be a really handy library for lots of things, it may be overkill in this particular application, but I figured it's worth pointing out.

I hope that helps.  - Will

On 2017-02-15 08:41, Viktor Hedefalk wrote:

I don't think "negative volume" is a useful term here. I have sympathy
for the idea of reusable components as I have been thinking that way
myself. However, the "raised mounting hole" example is not an
independent component that can be attached to something else and then
there is a hole under it by magic. Instead I find it useful to think
like a real construction process: Attach the "raised mounting pad" to
the plate, then drill a hole through both using a tool. You have then
only "positive" volumes, the parts and the tool(s). The drilling is of
course done using difference() between the two.

So a "standard" procedure could be something like

a) model the parts
b) model the tools.
c) assemble the parts
d) drill ( using difference() ) holes in the assembly, using the tools.

Carsten Arnholm

I do understand this, however, I still think there is definitely room for a
simple and approachable standard way to "componentize" things with both
positive and negative volumes together in actual code. I think my concrete
use case is a very reasonable example of this. How would you go about being
DRY (don't repeat yourself) for the coordinates of each of my PCB mounting
points?

In my case, I could just define an array of x,y's for each such hole and
then use this from two places - one for the raised part and one for the
hole. I still see problems with this though. If I want to go further (which
I actually do) as to make a module for each PCB (there are three here) so I
can move them around individually, stuff get's complicated and it's really
really hard to be dry.

The thing with not having negative volumes is that it makes it impossible
to compenentize things that depend on it any deeper than one level in a
scene graph, doesn't it? At least using modules.

I'm pretty new to openscad so I'm not entirely sure what's possible.
relativity.scad seems do achieve what I need though - I haven't looked into
how it is implemented. Before seeing that I would have said that modules
becomes pretty much useless for this, but probably I could use functions
where translations for each subtree of the graph is passed as arguments
instead of using transformations and then pairs of positive and negative
volumes (already translated to absolute coords) are returned to the topmost
level doing a disjunction?

Just for reference, here the thing:

https://gist.github.com/hedefalk/74cdf38cc3cb7f855e743bc8d5c8b389

I'm now printing without complete holes (gonna use a drill bit instead :) )

Cheers,

Viktor

I'm pretty new to openscad, but not to programming
On Wed, Feb 15, 2017, 09:28 arnholm@arnholm.org wrote:

On 2017-02-15 08:41, Viktor Hedefalk wrote:

I don't think "negative volume" is a useful term here. I have sympathy
for the idea of reusable components as I have been thinking that way
myself. However, the "raised mounting hole" example is not an
independent component that can be attached to something else and then
there is a hole under it by magic. Instead I find it useful to think
like a real construction process: Attach the "raised mounting pad" to
the plate, then drill a hole through both using a tool. You have then
only "positive" volumes, the parts and the tool(s). The drilling is of
course done using difference() between the two.

So a "standard" procedure could be something like

a) model the parts
b) model the tools.
c) assemble the parts
d) drill ( using difference() ) holes in the assembly, using the tools.

Carsten Arnholm

OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org

And thanks again for the pointer to relativity.scad. I think I will use it
next time, just didn't have the time right now :)

On Wed, Feb 15, 2017 at 10:32 AM Viktor Hedefalk hedefalk@gmail.com wrote:

The way I define objects with DRY without negative volumes is to define a
module that translates its children to the hole positions. I use that to
make bosses, drill holes and place fasteners, etc. E.g. a simplified
version:

module pcb_screw_positions(type) {
holes = pcb_holes(type);

for($i = [0 : len(holes) - 1]) {
    p = pcb_coord(type, holes[$i]);
    translate([p.x, p.y, 0])
        children();

}
}

module pcb(type) {
color("green") render() difference() {
rounded_rectangle([pcb_length(type), pcb_width(type),
pcb_thickness(type)], r = pcb_radius(type), center = false);

    pcb_screw_positions(type)
        cylinder(d = pcb_hole_d(type) + eps, h = 100, center = true);
}

color("silver") render()
    pcb_screw_positions(type)
        difference() {
            translate([0, 0, -eps])
                cylinder(d = 6, h = pcb_thickness(type) + 2 * eps);

            cylinder(d = pcb_hole_d(type), h = 100, center = true);
        }

pcb_components(type);

}

module pcb_assembly(type, height, thickness) {
screw = pcb_screw(type);
washer = screw_washer(screw);
nut = screw_nut(screw);
screw_length = screw_longer_than(height + thickness +
pcb_thickness(type) + washer_thickness(washer) + nut_thickness(nut, true));

translate([0, 0, height])
    pcb(type);

pcb_screw_positions(type) {
    translate([0, 0, height + pcb_thickness(type)])
        screw(screw, screw_length);

    color("lime") render() pcb_spacer(screw, height);

    translate([0, 0, -thickness])
        vflip()
            nut_and_washer(nut, true);
}

}

module box_base(type) {
render_sheet(box_sheets(box)) difference() {
box_base_blank(type);

    foot_positions()
        drill(screw_clearance_radius(foot_screw()));

    translate([psu_x, psu_y, 0])
        rotate(-90)
            psu_screw_positions(psu)
                drill(psu_screw_hole_radius(psu));

    translate([ssr_x, ssr_y, 0])
        ssr_hole_positions(bed_ssr)
            drill(M3_clearance_radius);

    if(rpi)
        translate([rpi_x, rpi_y, 0])
            rotate(90)
                pcb_screw_positions(rpi)
                    drill(pcb_screw(rpi));

    translate([controller_x, controller_y, 0])
        rotate(90)
            pcb_screw_positions(controller)
                drill(pcb_screw(controller));
}
translate([psu_x, psu_y, sheet_thickness / 2])
    rotate(-90) {
        psu(psu);

        psu_screw_positions(psu)
            translate([0, 0, -sheet_thickness])
                vflip()
                    screw_and_washer(psu_screw_type(psu), 6, true);
    }

translate([ssr_x, ssr_y, sheet_thickness / 2])
    ssr_assembly(bed_ssr, M3_cap_screw, sheet_thickness);

if(rpi)
    translate([rpi_x, rpi_y, sheet_thickness / 2])
        rotate(90)
            pcb_assembly(rpi, rpi_z, sheet_thickness);

translate([controller_x, controller_y, sheet_thickness / 2])
    rotate(90)
        pcb_assembly(controller, controller_z, sheet_thickness);

foot_positions()
    foot_assembly(sheet_thickness(box_sheets(box)));

}

​

On 15 February 2017 at 09:32, Viktor Hedefalk hedefalk@gmail.com wrote: