Functions and modules to distribute children or copies of children onto a line, a grid, or an arbitrary path. The $idx mechanism means that the "copies" of children can vary. Also includes shortcuts for mirroring.

To use, add the following lines to the beginning of your file:

include <BOSL2/std.scad>

1. Section: Adaptive Children Using $ Variables

2. Section: Translating copies of all the children

   • move_copies() – Translates copies of all children. ^{[MatList] [Trans]}
   • xcopies() – Places copies of children along the X axis. ^{[MatList] [Trans]}
   • ycopies() – Places copies of children along the Y axis. ^{[MatList] [Trans]}
   • zcopies() – Places copies of children along the Z axis. ^{[MatList] [Trans]}
   • line_copies() – Places copies of children along an arbitrary line. ^{[MatList] [Trans]}
   • grid_copies() – Places copies of children in an [X,Y] grid. ^{[MatList] [Trans]}

3. Section: Rotating copies of all children

   • rot_copies() – Rotates copies of children. ^{[MatList] [Trans]}
   • xrot_copies() – Rotates copies of children around the X axis. ^{[MatList] [Trans]}
   • yrot_copies() – Rotates copies of children around the Y axis. ^{[MatList] [Trans]}
   • zrot_copies() – Rotates copies of children around the Z axis. ^{[MatList] [Trans]}
   • arc_copies() – Distributes duplicates of children along an arc. ^{[MatList] [Trans]}
   • sphere_copies() – Distributes copies of children over the surface of a sphere. ^{[MatList] [Trans]}

4. Section: Placing copies of all children on a path

   • path_copies() – Uniformly distributes copies of children along a path. ^{[MatList] [Trans]}

5. Section: Making a copy of all children with reflection

   • xflip_copy() – Makes a copy of children mirrored across the X axis. ^{[MatList] [Trans]}
   • yflip_copy() – Makes a copy of children mirrored across the Y axis. ^{[MatList] [Trans]}
   • zflip_copy() – Makes a copy of children mirrored across the Z axis. ^{[MatList] [Trans]}
   • mirror_copy() – Makes a copy of children mirrored across a given plane. ^{[MatList] [Trans]}

6. Section: Distributing children individually along a line

   • xdistribute() – Distributes each child, individually, out along the X axis. ^[Trans]
   • ydistribute() – Distributes each child, individually, out along the Y axis. ^[Trans]
   • zdistribute() – Distributes each child, individually, out along the Z axis. ^[Trans]
   • distribute() – Distributes each child, individually, out along an arbitrary line. ^[Trans]

The distributor methods create multiple copies of their children and place them in various ways. While many models require multiple identical copies of an object, this framework is more powerful than might be immediately obvious because of $ variables. The distributors set $ variables that the children can use to change their behavior from one child to the next within a single distributor invocation. This means the copies need not be identical. The xcopies() module sets $idx to the index number of the copy, and in the examples below we use $idx, but the various distributors offer a variety of $ variables that you can use in your children. Check the "Side Effects" section for each module to learn what variables that module provides.

Two gotchas may lead to models that don't behave as expected. While if statements work to control modules, you cannot use them to make variable assignments in your child object. If you write a statement like

if (condition) { c="red";}
else {c="green";}

then the c variable is set only in the scope of the if and else clauses and is not available later on when you actually try to use it. Instead you must use the ternary operator and write:

c = condition ? "red" : "green";

The second complication is that in OpenSCAD version 2021.01 and earlier, assignments in children were executed before their parent. This means that $ variables like $idx are not available in assignments because the parent hasn't run to set them, so if you use them you will get a warning about an unknown variable. Two workarounds exist, neither of which are needed in newer versions of OpenSCAD. The workarounds solve the problem because modules execute after their parent, so the $ variables are available in modules. You can put your assignments in a let() module, or you can wrap your child in a union(). Both methods appear below.

Figure 1: This example shows how we can use $idx to produce different geometry at each index.

xcopies(n=10, spacing=10)
  text(str($idx));

Figure 2: Here the children are sometimes squares and sometimes circles as determined by the conditional if module. This use of if is OK because no variables are assigned.

xcopies(n=4, spacing=10)
  if($idx%2==0) circle(r=3,$fn=16);
  else rect(6);

Figure 3: Suppose we would like to color odd and even index copies differently. In this example we compute the color for a given child from $idx using the ternary operator. The let() module is a module that sets variables and makes them available to its children. Note that multiple assignments in let() are separated by commas, not semicolons.

xcopies(n=6, spacing=10){
    let(c = $idx % 2 == 0 ? "red" : "green")
        color(c) rect(6);
}

Figure 4: This example shows how you can change the position of children adaptively. If you want to avoid repeating your code for each case, this requires storing a transformation matrix in a variable and then applying it using multmatrix(). We wrap our code in union() to ensure that it works in OpenSCAD 2021.01.

xcopies(n=5,spacing=10)
  union()
  {
    shiftback = $idx%2==0 ? back(10) : IDENT;
    spin = zrot(180*$idx/4);
    multmatrix(shiftback*spin) stroke([[-4,0],[4,0]],endcap2="arrow2",width=3/4,color="red");
  }

Synopsis: Translates copies of all children. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: xcopies(), ycopies(), zcopies(), line_copies(), grid_copies(), rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies()

Usage:

• move_copies(a) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = move_copies(a, p=);

Usage: Get Translation Matrices

• mats = move_copies(a);

Description:

When called as a module, translates copies of all children to each given translation offset. When called as a function, with no p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
#sphere(r=10);
move_copies([[-25,-25,0], [25,-25,0], [0,0,50], [0,25,0]]) sphere(r=10);

Synopsis: Places copies of children along the X axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: move_copies(), ycopies(), zcopies(), line_copies(), grid_copies(), rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies()

Usage:

• xcopies(spacing, [n], [sp=]) CHILDREN;
• xcopies(l=, [n=], [sp=]) CHILDREN;
• xcopies(LIST) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = xcopies(spacing, [n], [sp=], p=);
• copies = xcopies(l=, [n=], [sp=], p=);
• copies = xcopies(LIST, p=);

Usage: Get Translation Matrices

• mats = xcopies(spacing, [n], [sp=]);
• mats = xcopies(l=, [n=], [sp=]);
• mats = xcopies(LIST);

Description:

When called as a module, places n copies of the children along a line on the X axis. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
xcopies(20) sphere(3);

Example 2:

include <BOSL2/std.scad>
xcopies(20, n=3) sphere(3);

Example 3:

include <BOSL2/std.scad>
xcopies(spacing=15, l=50) sphere(3);

Example 4:

include <BOSL2/std.scad>
xcopies(n=4, l=30, sp=[0,10,0]) sphere(3);

Example 5:

include <BOSL2/std.scad>
xcopies(10, n=3) {
    cube(size=[1,3,1],center=true);
    cube(size=[3,1,1],center=true);
}

Example 6:

include <BOSL2/std.scad>
xcopies([1,2,3,5,7]) sphere(d=1);

Synopsis: Places copies of children along the Y axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: move_copies(), xcopies(), zcopies(), line_copies(), grid_copies(), rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies()

Usage:

• ycopies(spacing, [n], [sp=]) CHILDREN;
• ycopies(l=, [n=], [sp=]) CHILDREN;
• ycopies(LIST) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = ycopies(spacing, [n], [sp=], p=);
• copies = ycopies(l=, [n=], [sp=], p=);
• copies = ycopies(LIST, p=);

Usage: Get Translation Matrices

• mats = ycopies(spacing, [n], [sp=]);
• mats = ycopies(l=, [n=], [sp=]);
• mats = ycopies(LIST);

Description:

When called as a module, places n copies of the children along a line on the Y axis. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
ycopies(20) sphere(3);

Example 2:

include <BOSL2/std.scad>
ycopies(20, n=3) sphere(3);

Example 3:

include <BOSL2/std.scad>
ycopies(spacing=15, l=50) sphere(3);

Example 4:

include <BOSL2/std.scad>
ycopies(n=4, l=30, sp=[10,0,0]) sphere(3);

Example 5:

include <BOSL2/std.scad>
ycopies(10, n=3) {
    cube(size=[1,3,1],center=true);
    cube(size=[3,1,1],center=true);
}

Example 6:

include <BOSL2/std.scad>
ycopies([1,2,3,5,7]) sphere(d=1);

Synopsis: Places copies of children along the Z axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: move_copies(), xcopies(), ycopies(), line_copies(), grid_copies(), rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies()

Usage:

• zcopies(spacing, [n], [sp=]) CHILDREN;
• zcopies(l=, [n=], [sp=]) CHILDREN;
• zcopies(LIST) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = zcopies(spacing, [n], [sp=], p=);
• copies = zcopies(l=, [n=], [sp=], p=);
• copies = zcopies(LIST, p=);

Usage: Get Translation Matrices

• mats = zcopies(spacing, [n], [sp=]);
• mats = zcopies(l=, [n=], [sp=]);
• mats = zcopies(LIST);

Description:

When called as a module, places n copies of the children along a line on the Z axis. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
zcopies(20) sphere(3);

Example 2:

include <BOSL2/std.scad>
zcopies(20, n=3) sphere(3);

Example 3:

include <BOSL2/std.scad>
zcopies(spacing=15, l=50) sphere(3);

Example 4:

include <BOSL2/std.scad>
zcopies(n=4, l=30, sp=[10,0,0]) sphere(3);

Example 5:

include <BOSL2/std.scad>
zcopies(10, n=3) {
    cube(size=[1,3,1],center=true);
    cube(size=[3,1,1],center=true);
}

Example 6: Cubic sphere packing

include <BOSL2/std.scad>
s = 20;
s2 = s * sin(45);
zcopies(s2,n=8)
    grid_copies([s2,s2],n=8,stagger=($idx%2)? true : "alt")
       sphere(d=s);

Example 7: Hexagonal sphere packing

include <BOSL2/std.scad>
s = 20;
xyr = adj_ang_to_hyp(s/2,30);
h = hyp_adj_to_opp(s,xyr);
zcopies(h,n=8)
    back(($idx%2)*xyr*cos(60))
        grid_copies(s,n=[12,7],stagger=($idx%2)? "alt" : true)
            sphere(d=s);

Example 8:

include <BOSL2/std.scad>
zcopies([1,2,3,5,7]) sphere(d=1);

Synopsis: Places copies of children along an arbitrary line. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: move_copies(), xcopies(), ycopies(), zcopies(), rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies()

Usage: Place n copies at a given spacing along the line

• line_copies(spacing, [n], [p1=]) CHILDREN;

Usage: Place as many copies as will fit at a given spacing

• line_copies(spacing, [l=], [p1=]) CHILDREN;

Usage: Place n copies along the length of the line

• line_copies([n=], [l=], [p1=]) CHILDREN;

Usage: Place n copies along the line from p1 to p2

• line_copies([n=], [p1=], [p2=]) CHILDREN;

Usage: Place copies at the given spacing, centered along the line from p1 to p2

• line_copies([spacing], [p1=], [p2=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = line_copies([spacing], [n], [p1=], p=);
• copies = line_copies([spacing], [l=], [p1=], p=);
• copies = line_copies([n=], [l=], [p1=], p=);
• copies = line_copies([n=], [p1=], [p2=], p=);
• copies = line_copies([spacing], [p1=], [p2=], p=);

Usage: Get Translation Matrices

• mats = line_copies([spacing], [n], [p1=]);
• mats = line_copies([spacing], [l=], [p1=]);
• mats = line_copies([n=], [l=], [p1=]);
• mats = line_copies([n=], [p1=], [p2=]);
• mats = line_copies([spacing], [p1=], [p2=]);

Description:

When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=. When called as a module, copies children() at one or more evenly spaced positions along a line. By default, the line will be centered at the origin, unless the starting point p1 is given. The line will be pointed towards RIGHT (X+) unless otherwise given as a vector in l, spacing, or p1/p2. The psotion of the copies is specified in one of several ways:

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
line_copies(10) sphere(d=1.5);

Example 2:

include <BOSL2/std.scad>
line_copies(10, n=5) sphere(d=3);

Example 3:

include <BOSL2/std.scad>
line_copies([10,5], n=5) sphere(d=3);

Example 4:

include <BOSL2/std.scad>
line_copies(spacing=10, n=6) sphere(d=3);

Example 5:

include <BOSL2/std.scad>
line_copies(spacing=[10,5], n=6) sphere(d=3);

Example 6:

include <BOSL2/std.scad>
line_copies(spacing=10, l=50) sphere(d=3);

Example 7:

include <BOSL2/std.scad>
line_copies(spacing=10, l=[50,30]) sphere(d=3);

Example 8:

include <BOSL2/std.scad>
line_copies(spacing=[10,5], l=50) sphere(d=3);

Example 9:

include <BOSL2/std.scad>
line_copies(l=50, n=4) sphere(d=3);

Example 10:

include <BOSL2/std.scad>
line_copies(l=[50,-30], n=4) sphere(d=3);

Example 11:

include <BOSL2/std.scad>
line_copies(p1=[0,0,0], p2=[5,5,20], n=6) cuboid([3,2,1]);

Example 12:

include <BOSL2/std.scad>
line_copies(p1=[0,0,0], p2=[5,5,20], spacing=6) cuboid([3,2,1]);

Example 13: All children are copied to each position

include <BOSL2/std.scad>
line_copies(l=20, n=3) {
    cube(size=[1,3,1],center=true);
    cube(size=[3,1,1],center=true);
}

Example 14: The functional form of line_copies() returns a list of transform matrices.

include <BOSL2/std.scad>
mats = line_copies([10,5],n=5);
for (m = mats) multmatrix(m)  circle(d=3);

Example 15: The functional form of line_copies() returns a list of points if given a point.

include <BOSL2/std.scad>
pts = line_copies([10,5],n=5,p=[0,0,0]);
move_copies(pts) circle(d=3);

Synopsis: Places copies of children in an [X,Y] grid. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies()

Usage:

• grid_copies(spacing, size=, [stagger=], [scale=], [inside=]) CHILDREN;
• grid_copies(n=, size=, [stagger=], [scale=], [inside=]) CHILDREN;
• grid_copies(spacing, [n], [stagger=], [scale=], [inside=]) CHILDREN;
• grid_copies(n=, inside=, [stagger], [scale]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = grid_copies(spacing, size=, [stagger=], [scale=], [inside=], p=);
• copies = grid_copies(n=, size=, [stagger=], [scale=], [inside=], p=);
• copies = grid_copies(spacing, [n], [stagger=], [scale=], [inside=], p=);
• copies = grid_copies(n=, inside=, [stagger], [scale], p=);

Usage: Get Translation Matrices

• mats = grid_copies(spacing, size=, [stagger=], [scale=], [inside=]);
• mats = grid_copies(n=, size=, [stagger=], [scale=], [inside=]);
• mats = grid_copies(spacing, [n], [stagger=], [scale=], [inside=]);
• mats = grid_copies(n=, inside=, [stagger], [scale]);

Description:

When called as a module, makes a square or hexagonal grid of copies of children, with an optional masking polygon or region. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $col is set to the integer column number for each child.
• $row is set to the integer row number for each child.
• $idx is set to a unique index for each child, progressing across rows first, from the bottom

Example 1:

include <BOSL2/std.scad>
grid_copies(size=50, spacing=10) cylinder(d=10, h=1);

Example 2:

include <BOSL2/std.scad>
grid_copies(size=50, spacing=[10,15]) cylinder(d=10, h=1);

Example 3:

include <BOSL2/std.scad>
grid_copies(spacing=10, n=[13,7], stagger=true) cylinder(d=6, h=5);

Example 4:

include <BOSL2/std.scad>
grid_copies(spacing=10, n=[13,7], stagger="alt") cylinder(d=6, h=5);

Example 5:

include <BOSL2/std.scad>
grid_copies(size=50, n=11, stagger=true) cylinder(d=5, h=1);

Example 6:

include <BOSL2/std.scad>
poly = [[-25,-25], [25,25], [-25,25], [25,-25]];
grid_copies(spacing=5, stagger=true, inside=poly)
   zrot(180/6) cylinder(d=5, h=1, $fn=6);
%polygon(poly);

Example 7: Using $row and $col

include <BOSL2/std.scad>
grid_copies(spacing=8, n=8)
    color(($row+$col)%2?"black":"red")
        cube([8,8,0.01], center=false);

Example 8: Makes a grid of hexagon pillars whose tops are all angled to reflect light at [0,0,50], if they were shiny.

include <BOSL2/std.scad>
hexregion = circle(r=50.01,$fn=6);
grid_copies(spacing=10, stagger=true, inside=hexregion)
  union() {   // Needed for OpenSCAD 2021.01 as noted above
    ref_v = (unit([0,0,50]-point3d($pos)) + UP)/2;
    half_of(v=-ref_v, cp=[0,0,5])
        zrot(180/6)
            cylinder(h=20, d=10/cos(180/6)+0.01, $fn=6);
  }

Synopsis: Rotates copies of children. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Rotation, Copiers

See Also: xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• rot_copies(rots, [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
• rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
• rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = rot_copies(rots, [cp=], [sa=], [delta=], [subrot=], p=);
• copies = rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=], p=);
• copies = rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=], p=);

Usage: Get Translation Matrices

• mats = rot_copies(rots, [cp=], [sa=], [delta=], [subrot=]);
• mats = rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=]);
• mats = rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=]);

Description:

When called as a module:

• Given a list of [X,Y,Z] rotation angles in rots, rotates copies of the children to each of those angles, regardless of axis of rotation.
• Given a list of scalar angles in rots, rotates copies of the children to each of those angles around the axis of rotation.
• If given a vector v, that becomes the axis of rotation. Default axis of rotation is UP.
• If given a count n, makes that many copies, rotated evenly around the axis.
• If given an offset delta, translates each child by that amount before rotating them into place. This makes rings.
• If given a centerpoint cp, centers the ring around that centerpoint.
• If subrot is true, each child will be rotated in place to keep the same size towards the center when making rings.
• The first (unrotated) copy will be placed at the relative starting angle sa.

When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $ang is set to the rotation angle (or XYZ rotation triplet) of each child copy, and can be used to modify each child individually.
• $idx is set to the index value of each child copy.
• $axis is set to the axis to rotate around, if rots was given as a list of angles instead of a list of [X,Y,Z] rotation angles.

Example 1:

include <BOSL2/std.scad>
#cylinder(h=20, r1=5, r2=0);
rot_copies([[45,0,0],[0,45,90],[90,-45,270]]) cylinder(h=20, r1=5, r2=0);

Example 2:

include <BOSL2/std.scad>
rot_copies([45, 90, 135], v=DOWN+BACK)
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 3:

include <BOSL2/std.scad>
rot_copies(n=6, v=DOWN+BACK)
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 4:

include <BOSL2/std.scad>
rot_copies(n=6, v=DOWN+BACK, delta=[10,0,0])
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 5:

include <BOSL2/std.scad>
rot_copies(n=6, v=UP+FWD, delta=[10,0,0], sa=45)
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 6:

include <BOSL2/std.scad>
rot_copies(n=6, v=DOWN+BACK, delta=[20,0,0], subrot=false)
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Synopsis: Rotates copies of children around the X axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Rotation, Copiers

See Also: rot_copies(), yrot_copies(), zrot_copies(), arc_copies(), sphere_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
• xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
• copies = xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);

Usage: Get Translation Matrices

• mats = xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
• mats = xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);

Description:

When called as a module:

• Given an array of angles, rotates copies of the children to each of those angles around the X axis.
• If given a count n, makes that many copies, rotated evenly around the X axis.
• If given a radius r (or diameter d), distributes children around a ring of that size around the X axis.
• If given a centerpoint cp, centers the rotation around that centerpoint.
• If subrot is true, each child will be rotated in place to keep the same size towards the center when making rings.
• The first (unrotated) copy will be placed at the relative starting angle sa.

When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $idx is set to the index value of each child copy.
• $ang is set to the rotation angle of each child copy, and can be used to modify each child individually.
• $axis is set to the axis vector rotated around.

Example 1:

include <BOSL2/std.scad>
xrot_copies([180, 270, 315])
    cylinder(h=20, r1=5, r2=0);
color("red",0.333) cylinder(h=20, r1=5, r2=0);

Example 2:

include <BOSL2/std.scad>
xrot_copies(n=6)
    cylinder(h=20, r1=5, r2=0);
color("red",0.333) cylinder(h=20, r1=5, r2=0);

Example 3:

include <BOSL2/std.scad>
xrot_copies(n=6, r=10)
    xrot(-90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) xrot(-90) cylinder(h=20, r1=5, r2=0);

Example 4:

include <BOSL2/std.scad>
xrot_copies(n=6, r=10, sa=45)
    xrot(-90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) xrot(-90) cylinder(h=20, r1=5, r2=0);

Example 5:

include <BOSL2/std.scad>
xrot_copies(n=6, r=20, subrot=false)
    xrot(-90) cylinder(h=20, r1=5, r2=0, center=true);
color("red",0.333) xrot(-90) cylinder(h=20, r1=5, r2=0, center=true);

Synopsis: Rotates copies of children around the Y axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Rotation, Copiers

See Also: rot_copies(), xrot_copies(), zrot_copies(), arc_copies(), sphere_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
• yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
• copies = yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);

Usage: Get Translation Matrices

• mats = yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
• mats = yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);

Description:

When called as a module:

• Given an array of angles, rotates copies of the children to each of those angles around the Y axis.
• If given a count n, makes that many copies, rotated evenly around the Y axis.
• If given a radius r (or diameter d), distributes children around a ring of that size around the Y axis.
• If given a centerpoint cp, centers the rotation around that centerpoint.
• If subrot is true, each child will be rotated in place to keep the same size towards the center when making rings.
• The first (unrotated) copy will be placed at the relative starting angle sa.

When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $idx is set to the index value of each child copy.
• $ang is set to the rotation angle of each child copy, and can be used to modify each child individually.
• $axis is set to the axis vector rotated around.

Example 1:

include <BOSL2/std.scad>
yrot_copies([180, 270, 315])
    cylinder(h=20, r1=5, r2=0);
color("red",0.333) cylinder(h=20, r1=5, r2=0);

Example 2:

include <BOSL2/std.scad>
yrot_copies(n=6)
    cylinder(h=20, r1=5, r2=0);
color("red",0.333) cylinder(h=20, r1=5, r2=0);

Example 3:

include <BOSL2/std.scad>
yrot_copies(n=6, r=10)
    yrot(-90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(-90) cylinder(h=20, r1=5, r2=0);

Example 4:

include <BOSL2/std.scad>
yrot_copies(n=6, r=10, sa=45)
    yrot(-90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(-90) cylinder(h=20, r1=5, r2=0);

Example 5:

include <BOSL2/std.scad>
yrot_copies(n=6, r=20, subrot=false)
    yrot(-90) cylinder(h=20, r1=5, r2=0, center=true);
color("red",0.333) yrot(-90) cylinder(h=20, r1=5, r2=0, center=true);

Synopsis: Rotates copies of children around the Z axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Rotation, Copiers

See Also: rot_copies(), xrot_copies(), yrot_copies(), arc_copies(), sphere_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
• zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
• copies = zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);

Usage: Get Translation Matrices

• mats = zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
• mats = zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);

Description:

When called as a module:

• Given an array of angles, rotates copies of the children to each of those angles around the Z axis.
• If given a count n, makes that many copies, rotated evenly around the Z axis.
• If given a radius r (or diameter d), distributes children around a ring of that size around the Z axis.
• If given a centerpoint cp, centers the rotation around that centerpoint.
• If subrot is true, each child will be rotated in place to keep the same size towards the center when making rings.
• The first (unrotated) copy will be placed at the relative starting angle sa.

When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $idx is set to the index value of each child copy.
• $ang is set to the rotation angle of each child copy, and can be used to modify each child individually.
• $axis is set to the axis vector rotated around.

Example 1:

include <BOSL2/std.scad>
zrot_copies([180, 270, 315])
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 2:

include <BOSL2/std.scad>
zrot_copies(n=6)
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 3:

include <BOSL2/std.scad>
zrot_copies(n=6, r=10)
    yrot(90) cylinder(h=20, r1=5, r2=0);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0);

Example 4:

include <BOSL2/std.scad>
zrot_copies(n=6, r=20, sa=45)
    yrot(90) cylinder(h=20, r1=5, r2=0, center=true);
color("red",0.333) yrot(90) cylinder(h=20, r1=5, r2=0, center=true);

Example 5:

include <BOSL2/std.scad>
zrot_copies(n=6, r=20, subrot=false)
    yrot(-90) cylinder(h=20, r1=5, r2=0, center=true);
color("red",0.333) yrot(-90) cylinder(h=20, r1=5, r2=0, center=true);

Synopsis: Distributes duplicates of children along an arc. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Rotation, Copiers

See Also: rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), sphere_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• arc_copies(n, r|d=, [sa=], [ea=], [rot=]) CHILDREN;
• arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = arc_copies(n, r|d=, [sa=], [ea=], [rot=], p=);
• copies = arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=], p=);

Usage: Get Translation Matrices

• mats = arc_copies(n, r|d=, [sa=], [ea=], [rot=]);
• mats = arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=]);

Description:

When called as a module, evenly distributes n duplicate children around an ovoid arc on the XY plane. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $ang is set to the rotation angle of each child copy, and can be used to modify each child individually.
• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index value of each child copy.

Example 1:

include <BOSL2/std.scad>
#cube(size=[10,3,3],center=true);
arc_copies(d=40, n=5) cube(size=[10,3,3],center=true);

Example 2:

include <BOSL2/std.scad>
#cube(size=[10,3,3],center=true);
arc_copies(d=40, n=5, sa=45, ea=225) cube(size=[10,3,3],center=true);

Example 3:

include <BOSL2/std.scad>
#cube(size=[10,3,3],center=true);
arc_copies(r=15, n=8, rot=false) cube(size=[10,3,3],center=true);

Example 4:

include <BOSL2/std.scad>
#cube(size=[10,3,3],center=true);
arc_copies(rx=20, ry=10, n=8) cube(size=[10,3,3],center=true);

Example 5: Using $idx to alternate shapes

include <BOSL2/std.scad>
arc_copies(r=50, n=19, sa=0, ea=180)
    if ($idx % 2 == 0) rect(6);
    else circle(d=6);

Synopsis: Distributes copies of children over the surface of a sphere. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Rotation, Copiers

See Also: rot_copies(), xrot_copies(), yrot_copies(), zrot_copies(), arc_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=], p=);

Usage: Get Translation Matrices

• mats = sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=]);

Description:

When called as a module, spreads children semi-evenly over the surface of a sphere or ellipsoid. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the relative post-scaled centerpoint of each child copy, and can be used to modify each child individually.
• $theta is set to the theta angle of the child from the center of the sphere.
• $phi is set to the pre-scaled phi angle of the child from the center of the sphere.
• $rad is set to the pre-scaled radial distance of the child from the center of the sphere.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
sphere_copies(n=250, d=100, cone_ang=45, scale=[3,3,1])
    cylinder(d=10, h=10, center=false);

Example 2:

include <BOSL2/std.scad>
sphere_copies(n=500, d=100, cone_ang=180)
    color(unit(point3d(v_abs($pos))))
        cylinder(d=8, h=10, center=false);

Synopsis: Uniformly distributes copies of children along a path. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Copiers

See Also: line_copies(), move_copies(), xcopies(), ycopies(), zcopies(), grid_copies(), xflip_copy(), yflip_copy(), zflip_copy(), mirror_copy()

Usage: Uniformly distribute copies

• path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=]) CHILDREN;

Usage: Place copies at specified locations

• path_copies(path, dist=, [rotate_children=], [closed=]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=], p=);
• copies = path_copies(path, dist=, [rotate_children=], [closed=], p=);

Usage: Get Translation Matrices

• mats = path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=]);
• mats = path_copies(path, dist=, [rotate_children=], [closed=]);

Description:

When called as a module:

• Place copies all of the children at points along the path based on path length. You can specify dist as
• a scalar or distance list and the children will be placed at the specified distances from the start of the path. Otherwise the children are
• placed at uniformly spaced points along the path. If you specify n but not spacing then n copies will be placed
• with one at path[0] if closed is true, or spanning the entire path from start to end if closed is false.
• If you specify spacing but not n then copies will spread out starting from one set at path[0] for closed=true or at the path center for open paths.
• If you specify sp then the copies will start at distance sp from the start of the path.

When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $pos is set to the center of each copy
• $idx is set to the index number of each copy. In the case of closed paths the first copy is at path[0] unless you give sp.
• $dir is set to the direction vector of the path at the point where the copy is placed.
• $normal is set to the direction of the normal vector to the path direction that is coplanar with the path at this point

Example 1:

include <BOSL2/std.scad>
spiral = [for(theta=[0:360*8]) theta * [cos(theta), sin(theta)]]/100;
stroke(spiral,width=.25);
color("red") path_copies(spiral, n=100) circle(r=1);

Example 2:

include <BOSL2/std.scad>
circle = regular_ngon(n=64, or=10);
stroke(circle,width=1,closed=true);
color("green") path_copies(circle, n=7, closed=true) circle(r=1+$idx/3);

Example 3:

include <BOSL2/std.scad>
heptagon = regular_ngon(n=7, or=10);
stroke(heptagon, width=1, closed=true);
color("purple") path_copies(heptagon, n=9, closed=true) rect([0.5,3],anchor=FRONT);

Example 4: Direction at the corners is the average of the two adjacent edges

include <BOSL2/std.scad>
heptagon = regular_ngon(n=7, or=10);
stroke(heptagon, width=1, closed=true);
color("purple") path_copies(heptagon, n=7, closed=true) rect([0.5,3],anchor=FRONT);

Example 5: Don't rotate the children

include <BOSL2/std.scad>
heptagon = regular_ngon(n=7, or=10);
stroke(heptagon, width=1, closed=true);
color("red") path_copies(heptagon, n=9, closed=true, rotate_children=false) rect([0.5,3],anchor=FRONT);

Example 6: Open path, specify n

include <BOSL2/std.scad>
sinwav = [for(theta=[0:360]) 5*[theta/180, sin(theta)]];
stroke(sinwav,width=.1);
color("red") path_copies(sinwav, n=5) rect([.2,1.5],anchor=FRONT);

Example 7: Open path, specify n and spacing

include <BOSL2/std.scad>
sinwav = [for(theta=[0:360]) 5*[theta/180, sin(theta)]];
stroke(sinwav,width=.1);
color("red") path_copies(sinwav, n=5, spacing=1) rect([.2,1.5],anchor=FRONT);

Example 8: Closed path, specify n and spacing, copies centered around circle[0]

include <BOSL2/std.scad>
circle = regular_ngon(n=64,or=10);
stroke(circle,width=.1,closed=true);
color("red") path_copies(circle, n=10, spacing=1, closed=true) rect([.2,1.5],anchor=FRONT);

Example 9: Open path, specify spacing

include <BOSL2/std.scad>
sinwav = [for(theta=[0:360]) 5*[theta/180, sin(theta)]];
stroke(sinwav,width=.1);
color("red") path_copies(sinwav, spacing=5) rect([.2,1.5],anchor=FRONT);

Example 10: Open path, specify sp

include <BOSL2/std.scad>
sinwav = [for(theta=[0:360]) 5*[theta/180, sin(theta)]];
stroke(sinwav,width=.1);
color("red") path_copies(sinwav, n=5, sp=18) rect([.2,1.5],anchor=FRONT);

Example 11: Open path, specify dist

include <BOSL2/std.scad>
sinwav = [for(theta=[0:360]) 5*[theta/180, sin(theta)]];
stroke(sinwav,width=.1);
color("red") path_copies(sinwav, dist=[1,4,9,16]) rect([.2,1.5],anchor=FRONT);

Example 12:

include <BOSL2/std.scad>
wedge = arc(angle=[0,100], r=10, $fn=64);
difference(){
  polygon(concat([[0,0]],wedge));
  path_copies(wedge,n=5,spacing=3) fwd(.1) rect([1,4],anchor=FRONT);
}

Example 13: 3d example, with children rotated into the plane of the path

include <BOSL2/std.scad>
tilted_circle = lift_plane([[0,0,0], [5,0,5], [0,2,3]],regular_ngon(n=64, or=12));
path_sweep(regular_ngon(n=16,or=.1),tilted_circle);
path_copies(tilted_circle, n=15,closed=true) {
   color("blue") cyl(h=3,r=.2, anchor=BOTTOM);      // z-aligned cylinder
   color("red") xcyl(h=10,r=.2, anchor=FRONT+LEFT); // x-aligned cylinder
}

Example 14: 3d example, with rotate_children set to false

include <BOSL2/std.scad>
tilted_circle = lift_plane([[0,0,0], [5,0,5], [0,2,3]], regular_ngon(n=64, or=12));
path_sweep(regular_ngon(n=16,or=.1),tilted_circle);
path_copies(tilted_circle, n=25,rotate_children=false,closed=true) {
   color("blue") cyl(h=3,r=.2, anchor=BOTTOM);       // z-aligned cylinder
   color("red") xcyl(h=10,r=.2, anchor=FRONT+LEFT);  // x-aligned cylinder
}

Synopsis: Makes a copy of children mirrored across the X axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: yflip_copy(), zflip_copy(), mirror_copy(), path_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• xflip_copy([offset], [x]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = xflip_copy([offset], [x], p=);

Usage: Get Translation Matrices

• mats = xflip_copy([offset], [x]);

Description:

When called as a module, makes a copy of the children, mirrored across the X axis. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $orig is true for the original instance of children. False for the copy.
• $idx is set to the index value of each copy.

Example 1:

include <BOSL2/std.scad>
xflip_copy() yrot(90) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) cube([0.01,15,15], center=true);

Example 2:

include <BOSL2/std.scad>
xflip_copy(offset=5) yrot(90) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) cube([0.01,15,15], center=true);

Example 3:

include <BOSL2/std.scad>
xflip_copy(x=-5) yrot(90) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) left(5) cube([0.01,15,15], center=true);

Synopsis: Makes a copy of children mirrored across the Y axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: xflip_copy(), zflip_copy(), mirror_copy(), path_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• yflip_copy([offset], [y]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = yflip_copy([offset], [y], p=);

Usage: Get Translation Matrices

• mats = yflip_copy([offset], [y]);

Description:

When called as a module, makes a copy of the children, mirrored across the Y axis. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $orig is true for the original instance of children. False for the copy.
• $idx is set to the index value of each copy.

Example 1:

include <BOSL2/std.scad>
yflip_copy() xrot(-90) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) cube([15,0.01,15], center=true);

Example 2:

include <BOSL2/std.scad>
yflip_copy(offset=5) xrot(-90) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) cube([15,0.01,15], center=true);

Example 3:

include <BOSL2/std.scad>
yflip_copy(y=-5) xrot(-90) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) fwd(5) cube([15,0.01,15], center=true);

Synopsis: Makes a copy of children mirrored across the Z axis. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: xflip_copy(), yflip_copy(), mirror_copy(), path_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• zflip_copy([offset], [z]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = zflip_copy([offset], [z], p=);

Usage: Get Translation Matrices

• mats = zflip_copy([offset], [z]);

Description:

When called as a module, makes a copy of the children, mirrored across the Z axis. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $orig is true for the original instance of children. False for the copy.
• $idx is set to the index value of each copy.

Example 1:

include <BOSL2/std.scad>
zflip_copy() cylinder(h=20, r1=4, r2=0);
color("blue",0.25) cube([15,15,0.01], center=true);

Example 2:

include <BOSL2/std.scad>
zflip_copy(offset=5) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) cube([15,15,0.01], center=true);

Example 3:

include <BOSL2/std.scad>
zflip_copy(z=-5) cylinder(h=20, r1=4, r2=0);
color("blue",0.25) down(5) cube([15,15,0.01], center=true);

Synopsis: Makes a copy of children mirrored across a given plane. ^{[MatList] [Trans]}

Topics: Transformations, Distributors, Translation, Copiers

See Also: xflip_copy(), yflip_copy(), zflip_copy(), path_copies(), move_copies(), xcopies(), ycopies(), zcopies(), line_copies(), grid_copies()

Usage:

• mirror_copy(v, [cp], [offset]) CHILDREN;

Usage: As a function to translate points, VNF, or Bezier patches

• copies = mirror_copy(v, [cp], [offset], p=);

Usage: Get Translation Matrices

• mats = mirror_copy(v, [cp], [offset]);

Description:

When called as a module, makes a copy of the children, mirrored across the given plane. When called as a function, without a p= argument, returns a list of transformation matrices, one for each copy. When called as a function, with a p= argument, returns a list of transformed copies of p=.

Arguments:

Side Effects:

• $orig is true for the original instance of children. False for the copy.
• $idx is set to the index value of each copy.

Example 1:

include <BOSL2/std.scad>
mirror_copy([1,-1,0]) zrot(-45) yrot(90) cylinder(d1=10, d2=0, h=20);
color("blue",0.25) zrot(-45) cube([0.01,15,15], center=true);

Example 2:

include <BOSL2/std.scad>
mirror_copy([1,1,0], offset=5) rot(a=90,v=[-1,1,0]) cylinder(d1=10, d2=0, h=20);
color("blue",0.25) zrot(45) cube([0.01,15,15], center=true);

Example 3:

include <BOSL2/std.scad>
mirror_copy(UP+BACK, cp=[0,-5,-5]) rot(from=UP, to=BACK+UP) cylinder(d1=10, d2=0, h=20);
color("blue",0.25) translate([0,-5,-5]) rot(from=UP, to=BACK+UP) cube([15,15,0.01], center=true);

Synopsis: Distributes each child, individually, out along the X axis. ^[Trans]

See Also: ydistribute(), zdistribute(), distribute()

Usage:

• xdistribute(spacing, [sizes]) CHILDREN;
• xdistribute(l=, [sizes=]) CHILDREN;

Description:

Spreads out the children individually along the X axis. Every child is placed at a different position, in order. This is useful for laying out groups of disparate objects where you only really care about the spacing between them.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
xdistribute(sizes=[100, 10, 30], spacing=40) {
    sphere(r=50);
    cube([10,20,30], center=true);
    cylinder(d=30, h=50, center=true);
}

Synopsis: Distributes each child, individually, out along the Y axis. ^[Trans]

See Also: xdistribute(), zdistribute(), distribute()

Usage:

• ydistribute(spacing, [sizes]) CHILDREN;
• ydistribute(l=, [sizes=]) CHILDREN;

Description:

Spreads out the children individually along the Y axis. Every child is placed at a different position, in order. This is useful for laying out groups of disparate objects where you only really care about the spacing between them.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
ydistribute(sizes=[30, 20, 100], spacing=40) {
    cylinder(d=30, h=50, center=true);
    cube([10,20,30], center=true);
    sphere(r=50);
}

Synopsis: Distributes each child, individually, out along the Z axis. ^[Trans]

See Also: xdistribute(), ydistribute(), distribute()

Usage:

• zdistribute(spacing, [sizes]) CHILDREN;
• zdistribute(l=, [sizes=]) CHILDREN;

Description:

Spreads out each individual child along the Z axis. Every child is placed at a different position, in order. This is useful for laying out groups of disparate objects where you only really care about the spacing between them.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
zdistribute(sizes=[30, 20, 100], spacing=40) {
    cylinder(d=30, h=50, center=true);
    cube([10,20,30], center=true);
    sphere(r=50);
}

Synopsis: Distributes each child, individually, out along an arbitrary line. ^[Trans]

See Also: xdistribute(), ydistribute(), zdistribute()

Usage:

• distribute(spacing, sizes, dir) CHILDREN;
• distribute(l=, [sizes=], [dir=]) CHILDREN;

Description:

Spreads out the children individually along the direction dir. Every child is placed at a different position, in order. This is useful for laying out groups of disparate objects where you only really care about the spacing between them.

Arguments:

Side Effects:

• $pos is set to the relative centerpoint of each child copy, and can be used to modify each child individually.
• $idx is set to the index number of each child being copied.

Example 1:

include <BOSL2/std.scad>
distribute(sizes=[100, 30, 50], dir=UP) {
    sphere(r=50);
    cube([10,20,30], center=true);
    cylinder(d=30, h=50, center=true);
}