646 lines
17 KiB
OpenSCAD
646 lines
17 KiB
OpenSCAD
|
|
include <BOSL2/std.scad>;
|
|
include <BOSL2/beziers.scad>;
|
|
include <BOSL2/rounding.scad>;
|
|
include <BOSL2/skin.scad>;
|
|
include <BOSL2/threading.scad>;
|
|
|
|
include <DotScad/src/bend.scad>;
|
|
include <DotScad/src/bend_extrude.scad>;
|
|
//include <DotScad/src/bezier_curve>;
|
|
include <DotScad/src/ellipse_extrude.scad>;
|
|
include <DotScad/src/loft.scad>;
|
|
|
|
include <scad-utils/morphology.scad>;
|
|
include <common.scad>
|
|
|
|
include <./lib/chinook.scad> // US Box
|
|
|
|
|
|
// https://github.com/BelfrySCAD/BOSL2/wiki/Tutorial-Beziers_for_Beginners
|
|
// ideas offset_stroke
|
|
|
|
/**
|
|
* Kitesurf Fins mold
|
|
*
|
|
*
|
|
*
|
|
* Requirements :
|
|
* - The plunger normaly should be twice the height of the part
|
|
*
|
|
*/
|
|
|
|
/************************************************/
|
|
/* Parameters */
|
|
/************************************************/
|
|
|
|
/* [Fin Specs] */
|
|
|
|
// Height
|
|
fin_height = 254; // 10 inches in mm
|
|
// Top Width
|
|
fin_width = 270; // Width at the top in mm
|
|
// Base Width
|
|
fin_base = 130; // Width at the base in mm
|
|
|
|
|
|
// Define top point
|
|
fin_top_withdraw = 35;
|
|
fin_edge_withdraw = 20;
|
|
|
|
fin_start_angle = 70; // Angle [Point 0 ]
|
|
fin_sweep = 25; // Sweep Angle [Point 1]
|
|
|
|
fin_edge_angle = 30;
|
|
fin_edge_strength = 30;
|
|
|
|
fin_counter_angle = 30; // counter angle [Point 2]
|
|
fin_counter_strength = 10; // Length [Point 2]
|
|
|
|
// Length at the base in mm
|
|
|
|
|
|
|
|
fin_width_tip = 5; // Width at the tip in mm
|
|
fin_thickness = 10; // Thickness of the fin in mm
|
|
|
|
fin_end_angle = 110;
|
|
fin_end_strength = 30;
|
|
|
|
// Back
|
|
fin_back_height = 30; // Percent height
|
|
fin_back_widthdraw = 20; // Percent height
|
|
fin_back_angle = 20; // back angle
|
|
fin_back_strength=30;
|
|
|
|
/* [Base Specs] */
|
|
|
|
base_tickness=8;
|
|
base_extra_thickness=40;
|
|
|
|
|
|
// ---------------------*/
|
|
/* [Mold] */
|
|
// ---------------------*/
|
|
|
|
// Mold base height
|
|
mold_base_height = 10;
|
|
mold_top_height = 5;
|
|
mold_extra_width = 15;
|
|
|
|
mold_piston_height = 10;
|
|
|
|
resin_escape_diameter = 4;
|
|
|
|
// Diameter for screw holes in mm
|
|
merge_holes_diameter = 6;
|
|
piston_depth = 5;
|
|
|
|
// ---------------------*/
|
|
/* [US Box] */
|
|
// ---------------------*/
|
|
/* [US Box] */
|
|
// Dimensions in mm
|
|
//length = 180;
|
|
//length=fin_base;
|
|
height = 25;
|
|
thick = 9.2;
|
|
mirror_vec = [1,1,0];
|
|
|
|
//screw_pos = 0.0096*1000;
|
|
screw_pos = 9.6;
|
|
//screw_dia = 0.0045*1000;
|
|
screw_dia = 4.5;
|
|
|
|
//tab_height = 0.013*1000;
|
|
tab_height = 13;
|
|
tab_length = screw_pos * 2;
|
|
tab_round = tab_height;
|
|
|
|
// real pin: d=0.0048 -> drill to fit
|
|
//pin_dia = 0.003*1000;
|
|
pin_dia = 3;
|
|
//pin_depth = 0.0164*1000;
|
|
pin_depth = 16.4;
|
|
//pin_back = 0.009*1000;
|
|
pin_back = 9;
|
|
|
|
// Thickness to cut for easier sliding (0 for no cut)
|
|
//thick_cut = 0.001*1000;
|
|
thick_cut = 1;
|
|
|
|
// ---------------------*/
|
|
/* [Debugging] */
|
|
// ---------------------*/
|
|
|
|
// Showing all layers
|
|
show_debug_layers = false;
|
|
|
|
show_curve_points = false;
|
|
|
|
// Draw master profile
|
|
draw_profile = false;
|
|
|
|
// ---------------------*/
|
|
/* [Rendering] */
|
|
// ---------------------*/
|
|
|
|
// Rendering parts
|
|
build_fin = false;
|
|
build_box = false;
|
|
render_mold = true;
|
|
render_drill_template = false;
|
|
|
|
parts = "all"; // [all, top, bottom]
|
|
|
|
|
|
mold_part = "all"; // [all, top, bottom]
|
|
// Scaling
|
|
scale_factor = 1.0; // [0.1:0.1:2]
|
|
|
|
// Printable rendering
|
|
printable = true;
|
|
|
|
$fn=64;
|
|
|
|
/*************/
|
|
/* Constants */
|
|
/*************/
|
|
/* [Hidden] */
|
|
// Define the offset value as a constant
|
|
OFFSET = 0.01;
|
|
CLEARING = 0.1;
|
|
INCH=2.54;
|
|
X=0;
|
|
Y=1;
|
|
Z=2;
|
|
|
|
/************************************************/
|
|
/* Derived variable */
|
|
|
|
mold_width = fin_height +2 * mold_extra_width;
|
|
mold_length = fin_width +2 * mold_extra_width;
|
|
mold_height = mold_base_height;
|
|
|
|
drilling_length = mold_base_height+mold_piston_height+2*OFFSET;
|
|
|
|
start = [ 0 ,0 ];
|
|
top_point = [ fin_width-fin_top_withdraw,fin_height ];
|
|
edge_point = [ fin_width ,fin_height-fin_edge_withdraw ];
|
|
counter_edge_point = [ fin_width -70 ,fin_height-100 ];
|
|
tail_point = [ fin_width -95 ,fin_height-175 ];
|
|
end_point = [ fin_base ,0 ];
|
|
|
|
|
|
|
|
/******************/
|
|
/* Profile points */
|
|
/******************/
|
|
points = flatten([
|
|
// *****************
|
|
// INITIAL POINT
|
|
// *****************
|
|
bez_begin(start,70,80),
|
|
// *****************
|
|
// TOP POINT
|
|
// *****************
|
|
bez_tang(top_point,0,80,15),
|
|
// *****************
|
|
// EDGE POINT
|
|
// *****************
|
|
bez_tang(edge_point,-90,15),
|
|
// **********************
|
|
// COUNTER EDGE POINT
|
|
// **********************
|
|
bez_tang(counter_edge_point,-120,30),
|
|
// *****************
|
|
// TAIL Point
|
|
// *****************
|
|
bez_tang(tail_point,-120,40),
|
|
// *****************
|
|
// END POINT
|
|
// *****************
|
|
bez_end(end_point,75,40),
|
|
]);
|
|
profile_curve = translate_path( addBase(asCurve(points,32)),-fin_base/2,0 );
|
|
//profile_curve = translate_path( asCurve(points,32),-fin_base/2,0 );
|
|
//profile_curve = resample_path(translate_path( asCurve(points,32),-fin_base/2,0 ),64);
|
|
|
|
assert(is_path_simple(profile_curve));
|
|
|
|
|
|
if (show_curve_points)
|
|
color("Blue")move_copies(profile_curve) circle($fn=16);
|
|
|
|
|
|
// Draw fin profile
|
|
if (draw_profile) {
|
|
//left(425) drawProfile( points, true );
|
|
|
|
|
|
layer0 = expandPath(profile_curve,-2);
|
|
layer1 = expandPath(profile_curve,-8);
|
|
layer2 = expandPath(profile_curve,-15);
|
|
layer3 = expandPath(profile_curve,-30);
|
|
layer4 = expandPath(profile_curve,-40);
|
|
|
|
back(10) showDebugPath(layer0);
|
|
|
|
|
|
left(500) {
|
|
color("Red") polygon(profile_curve);
|
|
up(10) polygon(layer0);
|
|
up(20) color("Yellow") polygon(layer1);
|
|
up(30) color("Brown") polygon(layer2);
|
|
}
|
|
|
|
layers = [profile_curve,layer0,layer1,layer2,layer3,layer4];
|
|
|
|
|
|
/*
|
|
echo ("profile_curve");
|
|
print_path_points (profile_curve);
|
|
echo ("layer0");
|
|
print_path_points (layer0);
|
|
*/
|
|
|
|
|
|
/*
|
|
left(200) {
|
|
// Turning a VNF into geometry
|
|
vnf = skin(layers,slices=0,z=layerHeights(len(layers),fin_thickness),method="fast_distance");
|
|
|
|
//vnf1 = up(50, p=vnf);
|
|
//bent1 = vnf_bend(vnf1, axis="X",r=10);
|
|
|
|
vnf2 = vnf_hull(vnf);
|
|
vnf_polyhedron(vnf2);
|
|
|
|
|
|
// Expanded
|
|
|
|
//expanded_vnf = vnf_small_offset(vnf,20);
|
|
//back(80) vnf_polyhedron(expanded_vnf);
|
|
|
|
|
|
back(380) vnf_polyhedron(vnf_sheet(vnf,-30));
|
|
|
|
|
|
//vnf_polyhedron(vnf);
|
|
//vnf_wireframe(vnf);
|
|
}
|
|
*/
|
|
//left(365) polygon( profile_curve );
|
|
|
|
//test = round_corners(polygon(profile_curve), radius=20, closed=false, $fn=72);
|
|
|
|
left (800) color ("Green") polygon(profile_curve);
|
|
|
|
left (1000) color ("Green") shell(10) polygon(profile_curve);
|
|
|
|
/*
|
|
convex_offset_extrude(
|
|
bottom = os_circle(r=5),
|
|
top=os_circle(r=5),
|
|
height=10,
|
|
offset="delta",
|
|
angle=70
|
|
)
|
|
*/
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Draws a profile based on Bezier path points with optional debug visualization.
|
|
*
|
|
* @param points - Array of points defining the Bezier path.
|
|
* @param debug - Boolean flag to enable/disable debug visualization. Defaults to true.
|
|
*
|
|
* This module:
|
|
* - Calculates the closest point on the Bezier path to a fixed point.
|
|
* - Draws the Bezier path with debug information if debug is true.
|
|
* - Optionally shows spheres at specific points for debugging (currently commented out).
|
|
*/
|
|
module drawProfile( points,debug = true ){
|
|
|
|
|
|
debugPoint (start, "Start", "Red" );
|
|
debugPoint (top_point, "Top", "Blue" );
|
|
debugPoint (edge_point, "Edge", "Brown" );
|
|
debugPoint (counter_edge_point, "Counter Edge", "Brown" );
|
|
debugPoint (tail_point, "Tail", "Yellow" );
|
|
debugPoint (end_point, "End", "Yellow" );
|
|
|
|
//pt = [100,0];
|
|
//pos = bezpath_closest_point(points, pt);
|
|
//xy = bezpath_points(points,pos[0],pos[1]);
|
|
|
|
debug_bezier(points, N=3,width=1.2);
|
|
}
|
|
|
|
// *****************
|
|
// * Fin Drawing *
|
|
// *****************
|
|
if ( build_fin )
|
|
scale([scale_factor, scale_factor, scale_factor])
|
|
buildFin( fin_thickness );
|
|
|
|
if ( build_box ) {
|
|
left(80) xflip() finfit(fin_base+20, [1,1,0]);
|
|
}
|
|
|
|
/**
|
|
* Render Mold
|
|
*/
|
|
if ( render_mold ) buildMold();
|
|
if ( render_drill_template ) buildDrillTemplate();
|
|
|
|
|
|
/**
|
|
* Build mold
|
|
*
|
|
*/
|
|
module buildMold() {
|
|
// Bottom mold
|
|
if (mold_part != "top")
|
|
difference() {
|
|
case(mold_base_height,true);
|
|
// Piston
|
|
down(piston_depth-OFFSET) fwd(20) bottomInsert();
|
|
}
|
|
// Top Mold
|
|
if (mold_part != "bottom")
|
|
up(printable ? 0 : 60) fwd(printable ? fin_height+50 : 0) down(mold_base_height) mirror([0,0,printable ? 1 : 0 ]) {
|
|
difference() {
|
|
union() {
|
|
// case
|
|
case(mold_top_height,false);
|
|
// Piston
|
|
mirror([1,0,0])
|
|
down(mold_top_height+piston_depth-OFFSET) fwd(20) topPiston();
|
|
};
|
|
resin_escape(40);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Mold Case
|
|
*
|
|
* @param height - Height of the case
|
|
* @param bottom - Is bottom or top
|
|
*/
|
|
module case( height , bottom=true ) {
|
|
difference() {
|
|
diff() cuboid( [ mold_length, mold_width, height ],
|
|
rounding=4,
|
|
edges=[bottom ? BOTTOM: TOP],
|
|
anchor=TOP ){
|
|
// Drills
|
|
align(BOTTOM,[FRONT+LEFT,FRONT+RIGHT,BACK+LEFT,BACK+RIGHT],inset=10,overlap=-OFFSET)
|
|
color("orange")
|
|
tag("remove")
|
|
drilling();
|
|
};
|
|
// Material holes
|
|
mirror([bottom ? 0:1,0,0])
|
|
back(38) left(55)
|
|
color("Red")
|
|
up(OFFSET)
|
|
rounded_triangle(radius=3, height=height+2*OFFSET);
|
|
// Length hole
|
|
fwd(32) cuboid([120,10,50],rounding=5);
|
|
// Side holes
|
|
left(67) cuboid([10,40,50],rounding=5);
|
|
right(67) cuboid([10,40,50],rounding=5);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Drill template
|
|
*
|
|
*/
|
|
module buildDrillTemplate() {
|
|
|
|
spacing = 38.5;
|
|
drill_depth = 15;
|
|
drill_diameter = 6;
|
|
template_height = 5;
|
|
|
|
p1 = 20;
|
|
p2 = p1-spacing;
|
|
|
|
mirror([0,0,printable ? 1 : 0]) difference() {
|
|
|
|
left(1) color ("Orange") cuboid([fin_width+7,15,10],rounding=3);
|
|
down(OFFSET) {
|
|
hull(){
|
|
left(28) cylinder(h=template_height+2*OFFSET,r=drill_diameter/2);
|
|
left(55) cylinder(h=template_height+2*OFFSET,r=drill_diameter/2);
|
|
}
|
|
hull(){
|
|
left(12) cylinder(h=template_height+2*OFFSET,r=drill_diameter/2);
|
|
left(-10) cylinder(h=template_height+2*OFFSET,r=drill_diameter/2);
|
|
}
|
|
hull(){
|
|
left(-27) cylinder(h=template_height+2*OFFSET,r=drill_diameter/2);
|
|
left(-53) cylinder(h=template_height+2*OFFSET,r=drill_diameter/2);
|
|
}
|
|
}
|
|
xrot(-90) buildFin(fin_thickness + 2*CLEARING );
|
|
//left(60) cylinder(h=20,r=6/2);
|
|
up(template_height+OFFSET)
|
|
{
|
|
left(p1)
|
|
cylinder(h=drill_depth+template_height,r=drill_diameter/2,orient=DOWN);
|
|
left(p2)
|
|
cylinder(h=drill_depth,r=drill_diameter/2,orient=DOWN);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// *****************
|
|
// * Bottom insert *
|
|
// *****************
|
|
module bottomInsert() {
|
|
debug=true;
|
|
layer_profile = profile_curve;
|
|
skin( [ layer_profile,expandPath(layer_profile,3) ], z=[0,piston_depth], slices=0 )
|
|
up(OFFSET)
|
|
buildFinSide(true)
|
|
;
|
|
}
|
|
|
|
// *****************
|
|
// * Top piston *
|
|
// *****************
|
|
module topPiston() {
|
|
debug=true;
|
|
layer_profile = profile_curve;
|
|
difference() {
|
|
skin( [ layer_profile,expandPath(layer_profile,3) ], z=[0,piston_depth], slices=0 );
|
|
down(OFFSET)
|
|
buildFinSide(false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build fin
|
|
*
|
|
*/
|
|
module buildFin( thickness ) {
|
|
union() {
|
|
if (parts != "bottom") buildFinSide( thickness );
|
|
if (parts != "top") buildFinSide( thickness , true );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build fin side
|
|
*
|
|
* @param flip - Define it it is top or bottom fin side
|
|
*/
|
|
module buildFinSide(thickness,flip=false) {
|
|
|
|
//profile_curve1 = subdivide_path (profile_curve,500);
|
|
|
|
//if (false)
|
|
mirror([0,0,flip ? 1 : 0])
|
|
color(flip ? "Gray" : "LightGray")
|
|
ellipse_extrude( thickness / 2 /*,height=2*/,center=false,twist=-7)
|
|
//zrot(30)
|
|
polygon( profile_curve);
|
|
}
|
|
|
|
module resin_escape(length) {
|
|
color ("Blue") cylinder(h=length, r=resin_escape_diameter/2);
|
|
}
|
|
|
|
// *****************
|
|
// * Drilling *
|
|
// *****************
|
|
module drilling(){
|
|
/*fwd(20)*/ color("Red") /*up(mold_piston_height+5)*/ up(-OFFSET)
|
|
orient(DOWN)
|
|
threaded_rod(
|
|
d=merge_holes_diameter,
|
|
l=drilling_length,
|
|
pitch=1.5,
|
|
anchor=BOTTOM,
|
|
//orient=BOTTOM
|
|
|
|
);
|
|
}
|
|
/*
|
|
echo ("bez_begin([-50,0],[0,-20])",bez_begin([-50,0],[0,-20]));
|
|
echo ("bez_begin([-50,0],[0,-20])",
|
|
|
|
|
|
flatten([
|
|
bez_begin([-50,0],[0,-20]),
|
|
bez_end([-50,0],[0,-20])
|
|
])
|
|
|
|
);
|
|
*/
|
|
echo ("bez_tang([0,0],70,80)",bez_tang(counter_edge_point,60+180,30));
|
|
echo ("point 1 ",points[8]);
|
|
echo ("point 2",points[9]);
|
|
echo ("point 3",points[10]);
|
|
|
|
function addBase(path) = concat(path,[[fin_base,-base_extra_thickness],[0,-base_extra_thickness]]);
|
|
|
|
|
|
|
|
// Function to create a parallel bezier curve offset by a given amount
|
|
function offset_bezier_points(points, offset_distance, normal=[0,0,1]) =
|
|
[for (pt = points) pt + offset_distance * normal];
|
|
|
|
// Function to create multiple parallel bezier curves
|
|
function create_patch_points(base_points, width, steps=4) =
|
|
[for (i = [0:1:steps])
|
|
let(
|
|
t = i/steps,
|
|
offset = width * t
|
|
)
|
|
offset_bezier_points(base_points, offset)
|
|
];
|
|
|
|
// Create the bezier patch VNF
|
|
function make_bezier_patch_from_curve(base_points, width, length_steps=32, width_steps=8) =
|
|
let(
|
|
// Generate parallel curves to form patch
|
|
patch_points = create_patch_points(base_points, width, width_steps),
|
|
// Generate points for each curve
|
|
curves_points = [for (curve_pts = patch_points)
|
|
bezier_points(curve_pts, length_steps)
|
|
],
|
|
// Create vertices for VNF
|
|
vertices = flatten(curves_points),
|
|
// Calculate indices for faces
|
|
indices = [
|
|
for (i=[0:1:width_steps-1], j=[0:1:length_steps-1])
|
|
let(
|
|
idx00 = i*(length_steps+1) + j,
|
|
idx10 = (i+1)*(length_steps+1) + j,
|
|
idx11 = (i+1)*(length_steps+1) + (j+1),
|
|
idx01 = i*(length_steps+1) + (j+1)
|
|
)
|
|
each [[idx00, idx10, idx11, idx01]]
|
|
]
|
|
)
|
|
[vertices, indices];
|
|
|
|
|
|
if (false) {
|
|
|
|
//vnf = bezier_vnf(profile_curve, splinesteps=10);
|
|
|
|
/*
|
|
vnf = make_bezier_patch_from_curve(points, width=10);
|
|
back (100) {
|
|
cube([20,20,20]);
|
|
vnf_polyhedron(vnf);
|
|
}
|
|
*/
|
|
/*
|
|
polygon(profile_curve);
|
|
vnf2 =vnf_from_region(polygon(profile_curve));
|
|
//vnf2 = vnf_from_polygons(profile_curve, fast=true);
|
|
vnf_polyhedron(vnf2);
|
|
*/
|
|
|
|
//curve_points = bezier_curve(points,N=3, splinesteps=32);
|
|
curve_points = bezpath_curve(points,N=3, splinesteps=32);
|
|
curve_points2 = [ for(p = curve_points) [p.x, p.y, 0]]; // Offset by 1 in Z
|
|
//echo ("curve_points",curve_points);
|
|
curve_points_offset = [ for(p = curve_points) [p.x, p.y, (p.z != undef ? p.z : 0) + 1 ]]; // Offset by 1 in Z
|
|
|
|
// Combine original and offset points to form a 2D array for a simple patch
|
|
patch_points = [
|
|
curve_points,
|
|
curve_points_offset
|
|
];
|
|
//echo ("patch_points",patch_points);
|
|
//echo ("curve_points_offset",curve_points_offset);
|
|
echo ("curve_points2",curve_points2);
|
|
echo ("length curve_points2",len(curve_points2));
|
|
|
|
//vnf_5 = bezier_vnf(patch_points, caps=false, splinesteps=10);
|
|
//vnf_5 = bezier_vnf(curve_points2, splinesteps=10);
|
|
echo ("is_bezier_patch",is_bezier_patch(curve_points));
|
|
echo ("is_bezier_patch",is_bezier_patch(curve_points2));
|
|
|
|
//vnf_5 = bezier_vnf(curve_points_offset, splinesteps=10);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|