grey/BOSL2
1
0
Fork 0
mirror of https://github.com/BelfrySCAD/BOSL2.git synced 2025-01-01 09:49:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
BOSL2/masks.scad
Revar Desmera 42d1a45ca6 Renamed exterior fillets to rounding
2019-04-24 19:42:38 -07:00

696 lines
26 KiB
OpenSCAD
Raw Blame History

//////////////////////////////////////////////////////////////////////
// LibFile: masks.scad
// Masking shapes.
// To use, add the following lines to the beginning of your file:
// ```
// include <BOSL2/std.scad>
// ```
//////////////////////////////////////////////////////////////////////
/*
BSD 2-Clause License
Copyright (c) 2017-2019, Revar Desmera
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Section: General Masks
// Module: angle_pie_mask()
// Usage:
// angle_pie_mask(r|d, l, ang, [orient], [anchor]);
// angle_pie_mask(r1|d1, r2|d2, l, ang, [orient], [anchor]);
// Description:
// Creates a pie wedge shape that can be used to mask other shapes.
// Arguments:
// ang = angle of wedge in degrees.
// l = height of wedge.
// r = Radius of circle wedge is created from. (optional)
// r1 = Bottom radius of cone that wedge is created from. (optional)
// r2 = Upper radius of cone that wedge is created from. (optional)
// d = Diameter of circle wedge is created from. (optional)
// d1 = Bottom diameter of cone that wedge is created from. (optional)
// d2 = Upper diameter of cone that wedge is created from. (optional)
// orient = Orientation of the pie slice. Use the ORIENT_ constants from constants.h. Default: ORIENT_Z.
// anchor = Alignment of the pie slice. Use the constants from constants.h. Default: CENTER.
// Example(FR):
// angle_pie_mask(ang=30, d=100, l=20);
module angle_pie_mask(
ang=45, l=undef,
r=undef, r1=undef, r2=undef,
d=undef, d1=undef, d2=undef,
orient=ORIENT_Z, anchor=CENTER,
h=undef
) {
l = first_defined([l, h, 1]);
r1 = get_radius(r1, r, d1, d, 10);
r2 = get_radius(r2, r, d2, d, 10);
orient_and_anchor([2*r1, 2*r1, l], orient, anchor, chain=true) {
pie_slice(ang=ang, l=l+0.1, r1=r1, r2=r2, anchor=CENTER);
children();
}
}
// Module: cylinder_mask()
// Usage: Mask objects
// cylinder_mask(l, r|d, chamfer, [chamfang], [from_end], [circum], [overage], [ends_only], [orient], [anchor]);
// cylinder_mask(l, r|d, rounding, [circum], [overage], [ends_only], [orient], [anchor]);
// cylinder_mask(l, r|d, [chamfer1|rounding1], [chamfer2|rounding2], [chamfang1], [chamfang2], [from_end], [circum], [overage], [ends_only], [orient], [anchor]);
// Usage: Masking operators
// cylinder_mask(l, r|d, chamfer, [chamfang], [from_end], [circum], [overage], [ends_only], [orient], [anchor]) ...
// cylinder_mask(l, r|d, rounding, [circum], [overage], [ends_only], [orient], [anchor]) ...
// cylinder_mask(l, r|d, [chamfer1|rounding1], [chamfer2|rounding2], [chamfang1], [chamfang2], [from_end], [circum], [overage], [ends_only], [orient], [anchor]) ...
// Description:
// If passed children, bevels/chamfers and/or rounds one or both
// ends of the origin-centered cylindrical region specified. If
// passed no children, creates a mask to bevel/chamfer and/or round
// one or both ends of the cylindrical region. Difference the mask
// from the region, making sure the center of the mask object is
// anchored exactly with the center of the cylindrical region to
// be chamferred.
// Arguments:
// l = Length of the cylindrical/conical region.
// r = Radius of cylindrical region to chamfer.
// r1 = Radius of axis-negative end of the region to chamfer.
// r2 = Radius of axis-positive end of the region to chamfer.
// d = Diameter of cylindrical region to chamfer.
// d1 = Diameter of axis-negative end of the region to chamfer.
// d1 = Diameter of axis-positive end of the region to chamfer.
// chamfer = Size of the chamfers/bevels. (Default: 0.25)
// chamfer1 = Size of the chamfers/bevels for the axis-negative end of the region.
// chamfer2 = Size of the chamfers/bevels for the axis-positive end of the region.
// chamfang = Angle of chamfers/bevels in degrees from the length axis of the region. (Default: 45)
// chamfang1 = Angle of chamfer/bevel of the axis-negative end of the region, in degrees from the length axis.
// chamfang2 = Angle of chamfer/bevel of the axis-positive end of the region, in degrees from the length axis.
// rounding = The radius of the rounding on the ends of the region. Default: none.
// rounding1 = The radius of the rounding on the axis-negative end of the region.
// rounding2 = The radius of the rounding on the axis-positive end of the region.
// circum = If true, region will circumscribe the circle of the given radius/diameter.
// from_end = If true, chamfer/bevel size is measured from end of region. If false, chamfer/bevel is measured outset from the radius of the region. (Default: false)
// overage = The extra thickness of the mask. Default: `10`.
// ends_only = If true, only mask the ends and not around the middle of the cylinder.
// orient = Orientation. Use the `ORIENT_` constants from `constants.scad`. Default: `ORIENT_Z`.
// anchor = Alignment of the region. Use the constants from `constants.scad`. Default: `CENTER`.
// Example:
// difference() {
// cylinder(h=100, r1=60, r2=30, center=true);
// cylinder_mask(l=100, r1=60, r2=30, chamfer=10, from_end=true);
// }
// Example:
// cylinder_mask(l=100, r=50, chamfer1=10, rounding2=10) {
// cube([100,50,100], center=true);
// }
module cylinder_mask(
l,
r=undef, r1=undef, r2=undef,
d=undef, d1=undef, d2=undef,
chamfer=undef, chamfer1=undef, chamfer2=undef,
chamfang=undef, chamfang1=undef, chamfang2=undef,
rounding=undef, rounding1=undef, rounding2=undef,
circum=false, from_end=false,
overage=10, ends_only=false,
orient=ORIENT_Z, anchor=CENTER
) {
r1 = get_radius(r=r, d=d, r1=r1, d1=d1, dflt=1);
r2 = get_radius(r=r, d=d, r1=r2, d1=d2, dflt=1);
sides = segs(max(r1,r2));
sc = circum? 1/cos(180/sides) : 1;
vang = atan2(l, r1-r2)/2;
ang1 = first_defined([chamfang1, chamfang, vang]);
ang2 = first_defined([chamfang2, chamfang, 90-vang]);
cham1 = first_defined([chamfer1, chamfer, 0]);
cham2 = first_defined([chamfer2, chamfer, 0]);
fil1 = first_defined([rounding1, rounding, 0]);
fil2 = first_defined([rounding2, rounding, 0]);
maxd = max(r1,r2);
if ($children > 0) {
difference() {
children();
cylinder_mask(l=l, r1=sc*r1, r2=sc*r2, chamfer1=cham1, chamfer2=cham2, chamfang1=ang1, chamfang2=ang2, rounding1=fil1, rounding2=fil2, orient=orient, from_end=from_end);
}
} else {
orient_and_anchor([2*r1, 2*r1, l], orient, anchor, chain=true) {
difference() {
union() {
chlen1 = cham1 / (from_end? 1 : tan(ang1));
chlen2 = cham2 / (from_end? 1 : tan(ang2));
if (!ends_only) {
cylinder(r=maxd+overage, h=l+2*overage, center=true);
} else {
if (cham2>0) up(l/2-chlen2) cylinder(r=maxd+overage, h=chlen2+overage, center=false);
if (cham1>0) down(l/2+overage) cylinder(r=maxd+overage, h=chlen1+overage, center=false);
if (fil2>0) up(l/2-fil2) cylinder(r=maxd+overage, h=fil2+overage, center=false);
if (fil1>0) down(l/2+overage) cylinder(r=maxd+overage, h=fil1+overage, center=false);
}
}
cyl(r1=sc*r1, r2=sc*r2, l=l, chamfer1=cham1, chamfer2=cham2, chamfang1=ang1, chamfang2=ang2, from_end=from_end, rounding1=fil1, rounding2=fil2);
}
children();
}
}
}
// Section: Chamfers
// Module: chamfer_mask()
// Usage:
// chamfer_mask(l, chamfer, [orient], [anchor]);
// Description:
// Creates a shape that can be used to chamfer a 90 degree edge.
// Difference it from the object to be chamfered. The center of
// the mask object should align exactly with the edge to be chamfered.
// Arguments:
// l = Length of mask.
// chamfer = Size of chamfer
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: vertical.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: centered.
// Example:
// difference() {
// cube(50);
// #chamfer_mask(l=50, chamfer=10, orient=ORIENT_X, anchor=RIGHT);
// }
module chamfer_mask(l=1, chamfer=1, orient=ORIENT_Z, anchor=CENTER) {
orient_and_anchor([chamfer, chamfer, l], orient, anchor, chain=true) {
cylinder(d=chamfer*2, h=l+0.1, center=true, $fn=4);
children();
}
}
// Module: chamfer_mask_x()
// Usage:
// chamfer_mask_x(l, chamfer, [anchor]);
// Description:
// Creates a shape that can be used to chamfer a 90 degree edge along the X axis.
// Difference it from the object to be chamfered. The center of the mask
// object should align exactly with the edge to be chamfered.
// Arguments:
// l = Height of mask
// chamfer = size of chamfer
// anchor = Alignment of the cylinder. Use the constants from constants.h. Default: centered.
// Example:
// difference() {
// left(40) cube(80);
// #chamfer_mask_x(l=80, chamfer=20);
// }
module chamfer_mask_x(l=1.0, chamfer=1.0, anchor=CENTER) {
chamfer_mask(l=l, chamfer=chamfer, orient=ORIENT_X, anchor=anchor) children();
}
// Module: chamfer_mask_y()
// Usage:
// chamfer_mask_y(l, chamfer, [anchor]);
// Description:
// Creates a shape that can be used to chamfer a 90 degree edge along the Y axis.
// Difference it from the object to be chamfered. The center of the mask
// object should align exactly with the edge to be chamfered.
// Arguments:
// l = Height of mask
// chamfer = size of chamfer
// anchor = Alignment of the cylinder. Use the constants from constants.h. Default: centered.
// Example:
// difference() {
// fwd(40) cube(80);
// right(80) #chamfer_mask_y(l=80, chamfer=20);
// }
module chamfer_mask_y(l=1.0, chamfer=1.0, anchor=CENTER) {
chamfer_mask(l=l, chamfer=chamfer, orient=ORIENT_Y, anchor=anchor) children();
}
// Module: chamfer_mask_z()
// Usage:
// chamfer_mask_z(l, chamfer, [anchor]);
// Description:
// Creates a shape that can be used to chamfer a 90 degree edge along the Z axis.
// Difference it from the object to be chamfered. The center of the mask
// object should align exactly with the edge to be chamfered.
// Arguments:
// l = Height of mask
// chamfer = size of chamfer
// anchor = Alignment of the cylinder. Use the constants from constants.h. Default: centered.
// Example:
// difference() {
// down(40) cube(80);
// #chamfer_mask_z(l=80, chamfer=20);
// }
module chamfer_mask_z(l=1.0, chamfer=1.0, anchor=CENTER) {
chamfer_mask(l=l, chamfer=chamfer, orient=ORIENT_Z, anchor=anchor) children();
}
// Module: chamfer()
// Usage:
// chamfer(chamfer, size, [edges]) ...
// Description:
// Chamfers the edges of a cuboid region containing childrem, centered on the origin.
// Arguments:
// chamfer = Inset of the chamfer from the edge. (Default: 1)
// size = The size of the rectangular cuboid we want to chamfer.
// edges = Which edges do we want to chamfer. Recommend to use EDGE constants from constants.scad.
// Description:
// You should use `EDGE` constants from `constants.scad` with the `edge` argument.
// However, if you must handle it raw, the edge ordering is this:
// [
// [Y+Z+, Y-Z+, Y-Z-, Y+Z-],
// [X+Z+, X-Z+, X-Z-, X+Z-],
// [X+Y+, X-Y+, X-Y-, X+Y-]
// ]
// Example(FR):
// chamfer(chamfer=2, size=[20,40,30]) {
// cube(size=[20,40,30], center=true);
// }
// Example(FR):
// chamfer(chamfer=2, size=[20,40,30], edges=EDGES_TOP - EDGE_TOP_LF + EDGE_FR_RT) {
// cube(size=[20,40,30], center=true);
// }
module chamfer(chamfer=1, size=[1,1,1], edges=EDGES_ALL)
{
difference() {
children();
difference() {
cube(size, center=true);
cuboid(size+[1,1,1]*0.02, chamfer=chamfer+0.01, edges=edges, trimcorners=true);
}
}
}
// Module: chamfer_cylinder_mask()
// Usage:
// chamfer_cylinder_mask(r|d, chamfer, [ang], [from_end], [orient])
// Description:
// Create a mask that can be used to bevel/chamfer the end of a cylindrical region.
// Difference it from the end of the region to be chamferred. The center of the mask
// object should align exactly with the center of the end of the cylindrical region
// to be chamferred.
// Arguments:
// r = Radius of cylinder to chamfer.
// d = Diameter of cylinder to chamfer. Use instead of r.
// chamfer = Size of the edge chamferred, inset from edge. (Default: 0.25)
// ang = Angle of chamfer in degrees from vertical. (Default: 45)
// from_end = If true, chamfer size is measured from end of cylinder. If false, chamfer is measured outset from the radius of the cylinder. (Default: false)
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: ORIENT_Z.
// Example:
// difference() {
// cylinder(r=50, h=100, center=true);
// up(50) #chamfer_cylinder_mask(r=50, chamfer=10);
// }
module chamfer_cylinder_mask(r=1.0, d=undef, chamfer=0.25, ang=45, from_end=false, orient=ORIENT_Z)
{
r = get_radius(r=r, d=d, dflt=1);
rot(orient) cylinder_mask(l=chamfer*3, r=r, chamfer2=chamfer, chamfang2=ang, from_end=from_end, ends_only=true, anchor=DOWN) children();
}
// Module: chamfer_hole_mask()
// Usage:
// chamfer_hole_mask(r|d, chamfer, [ang], [from_end]);
// Description:
// Create a mask that can be used to bevel/chamfer the end of a cylindrical hole.
// Difference it from the hole to be chamferred. The center of the mask object
// should align exactly with the center of the end of the hole to be chamferred.
// Arguments:
// r = Radius of hole to chamfer.
// d = Diameter of hole to chamfer. Use instead of r.
// chamfer = Size of the chamfer. (Default: 0.25)
// ang = Angle of chamfer in degrees from vertical. (Default: 45)
// from_end = If true, chamfer size is measured from end of hole. If false, chamfer is measured outset from the radius of the hole. (Default: false)
// overage = The extra thickness of the mask. Default: `0.1`.
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: `ORIENT_Z`.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: `CENTER`.
// Example:
// difference() {
// cube(100, center=true);
// cylinder(d=50, h=100.1, center=true);
// up(50) #chamfer_hole_mask(d=50, chamfer=10);
// }
// Example:
// chamfer_hole_mask(d=100, chamfer=25, ang=30, overage=10);
module chamfer_hole_mask(r=undef, d=undef, chamfer=0.25, ang=45, from_end=false, overage=0.1, orient=ORIENT_Z, anchor=CENTER)
{
r = get_radius(r=r, d=d, dflt=1);
h = chamfer * (from_end? 1 : tan(90-ang));
r2 = r + chamfer * (from_end? tan(ang) : 1);
$fn = segs(r);
orient_and_anchor([2*r, 2*r, h*2], orient, anchor, size2=[2*r2, 2*r2], chain=true) {
union() {
cylinder(r=r2, h=overage, center=false);
down(h) cylinder(r1=r, r2=r2, h=h, center=false);
}
children();
}
}
// Section: Rounding
// Module: rounding_mask()
// Usage:
// rounding_mask(l|h, r, [orient], [anchor])
// Description:
// Creates a shape that can be used to round a vertical 90 degree edge.
// Difference it from the object to be rounded. The center of the mask
// object should align exactly with the edge to be rounded.
// Arguments:
// l = Length of mask.
// r = Radius of the rounding.
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: vertical.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: centered.
// Example:
// difference() {
// cube(size=100, center=false);
// #rounding_mask(l=100, r=25, orient=ORIENT_Z, anchor=UP);
// }
module rounding_mask(l=undef, r=1.0, orient=ORIENT_Z, anchor=CENTER, h=undef)
{
l = first_defined([l, h, 1]);
sides = quantup(segs(r),4);
orient_and_anchor([2*r, 2*r, l], orient, anchor, chain=true) {
linear_extrude(height=l+0.1, convexity=4, center=true) {
difference() {
square(2*r, center=true);
xspread(2*r) yspread(2*r) circle(r=r, $fn=sides);
}
}
children();
}
}
// Module: rounding_mask_x()
// Usage:
// rounding_mask_x(l, r, [anchor])
// Description:
// Creates a shape that can be used to round a 90 degree edge oriented
// along the X axis. Difference it from the object to be rounded.
// The center of the mask object should align exactly with the edge to
// be rounded.
// Arguments:
// l = Length of mask.
// r = Radius of the rounding.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: centered.
// Example:
// difference() {
// cube(size=100, center=false);
// #rounding_mask_x(l=100, r=25, anchor=RIGHT);
// }
module rounding_mask_x(l=1.0, r=1.0, anchor=CENTER) rounding_mask(l=l, r=r, orient=ORIENT_X, anchor=anchor) children();
// Module: rounding_mask_y()
// Usage:
// rounding_mask_y(l, r, [anchor])
// Description:
// Creates a shape that can be used to round a 90 degree edge oriented
// along the Y axis. Difference it from the object to be rounded.
// The center of the mask object should align exactly with the edge to
// be rounded.
// Arguments:
// l = Length of mask.
// r = Radius of the rounding.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: centered.
// Example:
// difference() {
// cube(size=100, center=false);
// right(100) #rounding_mask_y(l=100, r=25, anchor=BACK);
// }
module rounding_mask_y(l=1.0, r=1.0, anchor=CENTER) rounding_mask(l=l, r=r, orient=ORIENT_Y, anchor=anchor) children();
// Module: rounding_mask_z()
// Usage:
// rounding_mask_z(l, r, [anchor])
// Description:
// Creates a shape that can be used to round a 90 degree edge oriented
// along the Z axis. Difference it from the object to be rounded.
// The center of the mask object should align exactly with the edge to
// be rounded.
// Arguments:
// l = Length of mask.
// r = Radius of the rounding.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: centered.
// Example:
// difference() {
// cube(size=100, center=false);
// #rounding_mask_z(l=100, r=25, anchor=UP);
// }
module rounding_mask_z(l=1.0, r=1.0, anchor=CENTER) rounding_mask(l=l, r=r, orient=ORIENT_Z, anchor=anchor) children();
// Module: rounding()
// Usage:
// rounding(r, size, [edges]) ...
// Description:
// Rounds the edges of a cuboid region containing the given children.
// Arguments:
// r = Radius of the rounding. (Default: 1)
// size = The size of the rectangular cuboid we want to chamfer.
// edges = Which edges do we want to chamfer. Recommend to use EDGE constants from constants.scad.
// Description:
// You should use `EDGE` constants from `constants.scad` with the `edge` argument.
// However, if you must handle it raw, the edge ordering is this:
// [
// [Y+Z+, Y-Z+, Y-Z-, Y+Z-],
// [X+Z+, X-Z+, X-Z-, X+Z-],
// [X+Y+, X-Y+, X-Y-, X+Y-]
// ]
// Example(FR):
// rounding(r=10, size=[50,100,150], $fn=24) {
// cube(size=[50,100,150], center=true);
// }
// Example(FR,FlatSpin):
// rounding(r=10, size=[50,50,75], edges=EDGES_TOP - EDGE_TOP_LF + EDGE_FR_RT, $fn=24) {
// cube(size=[50,50,75], center=true);
// }
module rounding(r=1, size=[1,1,1], edges=EDGES_ALL)
{
difference() {
children();
difference() {
cube(size, center=true);
cuboid(size+[1,1,1]*0.01, rounding=r, edges=edges, trimcorners=true);
}
}
}
// Module: rounding_angled_edge_mask()
// Usage:
// rounding_angled_edge_mask(h, r, [ang], [orient], [anchor]);
// Description:
// Creates a vertical mask that can be used to round the edge where two
// face meet, at any arbitrary angle. Difference it from the object to
// be rounded. The center of the mask should align exactly with the
// edge to be rounded.
// Arguments:
// h = height of vertical mask.
// r = radius of the rounding.
// ang = angle that the planes meet at.
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: `ORIENT_Z`.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: `CENTER`.
// Example:
// difference() {
// angle_pie_mask(ang=70, h=50, d=100);
// #rounding_angled_edge_mask(h=51, r=20.0, ang=70, $fn=32);
// }
module rounding_angled_edge_mask(h=1.0, r=1.0, ang=90, orient=ORIENT_Z, anchor=CENTER)
{
sweep = 180-ang;
n = ceil(segs(r)*sweep/360);
x = r*sin(90-(ang/2))/sin(ang/2);
orient_and_anchor([2*x,2*r,h], orient, anchor, chain=true) {
linear_extrude(height=h, convexity=4, center=true) {
polygon(
points=concat(
[for (i = [0:n]) let (a=90+ang+i*sweep/n) [r*cos(a)+x, r*sin(a)+r]],
[for (i = [0:n]) let (a=90+i*sweep/n) [r*cos(a)+x, r*sin(a)-r]],
[
[min(-1, r*cos(270-ang)+x-1), r*sin(270-ang)-r],
[min(-1, r*cos(90+ang)+x-1), r*sin(90+ang)+r],
]
)
);
}
children();
}
}
// Module: rounding_angled_corner_mask()
// Usage:
// rounding_angled_corner_mask(r, ang, [orient], [anchor]);
// Description:
// Creates a shape that can be used to round the corner of an angle.
// Difference it from the object to be rounded. The center of the mask
// object should align exactly with the point of the corner to be rounded.
// Arguments:
// r = Radius of the rounding.
// ang = Angle between planes that you need to round the corner of.
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: `ORIENT_Z`.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: `CENTER`.
// Example:
// ang=60;
// difference() {
// angle_pie_mask(ang=ang, h=50, r=200);
// up(50/2) {
// #rounding_angled_corner_mask(r=20, ang=ang);
// zrot_copies([0, ang]) right(200/2) rounding_mask_x(l=200, r=20);
// }
// rounding_angled_edge_mask(h=51, r=20, ang=ang);
// }
module rounding_angled_corner_mask(r=1.0, ang=90, orient=ORIENT_Z, anchor=CENTER)
{
dx = r / tan(ang/2);
dx2 = dx / cos(ang/2) + 1;
fn = quantup(segs(r), 4);
orient_and_anchor([2*dx2, 2*dx2, r*2], orient, anchor, chain=true) {
difference() {
down(r) cylinder(r=dx2, h=r+1, center=false);
yflip_copy() {
translate([dx, r, -r]) {
hull() {
sphere(r=r, $fn=fn);
down(r*3) sphere(r=r, $fn=fn);
zrot_copies([0,ang]) {
right(r*3) sphere(r=r, $fn=fn);
}
}
}
}
}
children();
}
}
// Module: rounding_corner_mask()
// Usage:
// rounding_corner_mask(r, [anchor]);
// Description:
// Creates a shape that you can use to round 90 degree corners.
// Difference it from the object to be rounded. The center of the mask
// object should align exactly with the corner to be rounded.
// Arguments:
// r = Radius of corner rounding.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: `CENTER`.
// Example:
// rounding_corner_mask(r=20.0);
// Example:
// difference() {
// cube(size=[30, 50, 80], center=true);
// translate([0, 25, 40]) rounding_mask_x(l=31, r=15);
// translate([15, 0, 40]) rounding_mask_y(l=51, r=15);
// translate([15, 25, 0]) rounding_mask_z(l=81, r=15);
// translate([15, 25, 40]) #rounding_corner_mask(r=15);
// }
module rounding_corner_mask(r=1.0, anchor=CENTER)
{
orient_and_anchor([2*r, 2*r, 2*r], ORIENT_Z, anchor, chain=true) {
difference() {
cube(size=r*2, center=true);
grid3d(n=[2,2,2], spacing=r*2-0.05) {
sphere(r=r);
}
}
children();
}
}
// Module: rounding_cylinder_mask()
// Usage:
// rounding_cylinder_mask(r, rounding);
// Description:
// Create a mask that can be used to round the end of a cylinder.
// Difference it from the cylinder to be rounded. The center of the
// mask object should align exactly with the center of the end of the
// cylinder to be rounded.
// Arguments:
// r = Radius of cylinder. (Default: 1.0)
// rounding = Radius of the edge rounding. (Default: 0.25)
// Example:
// difference() {
// cylinder(r=50, h=50, center=false);
// up(50) #rounding_cylinder_mask(r=50, rounding=10);
// }
// Example:
// difference() {
// cylinder(r=50, h=100, center=false);
// up(75) rounding_cylinder_mask(r=50, rounding=10);
// }
module rounding_cylinder_mask(r=1.0, rounding=0.25)
{
cylinder_mask(l=rounding*3, r=r, rounding2=rounding, overage=rounding, ends_only=true, anchor=DOWN) children();
}
// Module: rounding_hole_mask()
// Usage:
// rounding_hole_mask(r|d, rounding);
// Description:
// Create a mask that can be used to round the edge of a circular hole.
// Difference it from the hole to be rounded. The center of the
// mask object should align exactly with the center of the end of the
// hole to be rounded.
// Arguments:
// r = Radius of hole.
// d = Diameter of hole to rounding.
// rounding = Radius of the rounding. (Default: 0.25)
// overage = The extra thickness of the mask. Default: `0.1`.
// orient = Orientation of the mask. Use the `ORIENT_` constants from `constants.h`. Default: `ORIENT_Z`.
// anchor = Alignment of the mask. Use the constants from `constants.h`. Default: `CENTER`.
// Example:
// difference() {
// cube([150,150,100], center=true);
// cylinder(r=50, h=100.1, center=true);
// up(50) #rounding_hole_mask(r=50, rounding=10);
// }
// Example:
// rounding_hole_mask(r=40, rounding=20, $fa=2, $fs=2);
module rounding_hole_mask(r=undef, d=undef, rounding=0.25, overage=0.1, orient=ORIENT_Z, anchor=CENTER)
{
r = get_radius(r=r, d=d, dflt=1);
orient_and_anchor([2*(r+rounding), 2*(r+rounding), rounding*2], orient, anchor, chain=true) {
rotate_extrude(convexity=4) {
difference() {
right(r-overage) fwd(rounding) square(rounding+overage, center=false);
right(r+rounding) fwd(rounding) circle(r=rounding);
}
}
children();
}
}
// vim: noexpandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap
Reference in a new issue View git blame Copy permalink