539 lines
14 KiB
OpenSCAD
539 lines
14 KiB
OpenSCAD
|
|
include <BOSL2/std.scad>;
|
|
include <BOSL2/beziers.scad>;
|
|
include <BOSL2/rounding.scad>;
|
|
include <BOSL2/skin.scad>;
|
|
|
|
include <DotScad/src/bend.scad>;
|
|
include <DotScad/src/bend_extrude.scad>;
|
|
include <DotScad/src/ellipse_extrude.scad>;
|
|
//include <DotScad/src/rounded_extrude.scad>;
|
|
|
|
/************************************************/
|
|
/* Parameters */
|
|
/************************************************/
|
|
|
|
/* [Fin Specs] */
|
|
|
|
fin_height = 51; // 10 inches in mm
|
|
fin_width = 120; // Width at the base in mm
|
|
fin_top_withdraw = 10;
|
|
fin_back_withraw = 20;
|
|
|
|
fin_start_angle = 60; // 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_base = 114;
|
|
|
|
|
|
fin_width_tip = 5; // Width at the tip in mm
|
|
fin_thickness = 8; // 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=20;
|
|
|
|
|
|
/* [Debugging] */
|
|
|
|
// Showing all layers
|
|
show_debug_layers = false;
|
|
|
|
// Draw master profile
|
|
draw_profile = true;
|
|
|
|
// Draw Fin
|
|
build_fin = false;
|
|
|
|
/* [Rendering] */
|
|
|
|
// Rendering parts
|
|
parts="all"; // [all, top, bottom]
|
|
|
|
// Scaling
|
|
scale_factor = 1.0; // [0.1:0.1:2]
|
|
|
|
|
|
$fn=64;
|
|
/************************************************/
|
|
|
|
|
|
pt1_x = adj_ang_to_opp(fin_height,fin_sweep)+fin_base/2;
|
|
pt1_y = fin_height;
|
|
|
|
//back_point = [fin_width-7,fin_height/2];
|
|
tail_point = [fin_width-3,fin_height/5];
|
|
|
|
edge_point = [fin_width-fin_top_withdraw,fin_height-2];
|
|
counter_edge_point = [fin_width-6,fin_height-8];
|
|
|
|
/******************/
|
|
/* Profile points */
|
|
/******************/
|
|
profile_points = [
|
|
// *****************
|
|
// INITIAL POINT
|
|
// *****************
|
|
[0,0], // Point 0
|
|
[opp_ang_to_adj(fin_height/3,fin_start_angle),fin_height/3], // Handle 0
|
|
// *****************
|
|
// TOP POINT
|
|
// *****************
|
|
[pt1_x-fin_base/5,pt1_y], // Handle 1 (Start)
|
|
[pt1_x,pt1_y], // Point 1
|
|
[pt1_x+fin_base/7,pt1_y], // Handle 1 (End)
|
|
// *****************
|
|
// EDGE POINT
|
|
// *****************
|
|
handle(edge_point,140 ,4),
|
|
edge_point, // Point Edge Point
|
|
handle(edge_point,-45,4),
|
|
// *****************
|
|
// COUNTER EDGE POINT
|
|
// *****************
|
|
handle(counter_edge_point,120,4),
|
|
counter_edge_point, // Point Counter Edge
|
|
handle(counter_edge_point,-110,13),
|
|
// *****************
|
|
// TAIL Point
|
|
// *****************
|
|
handle(tail_point,115 ,10),
|
|
tail_point,
|
|
handle(tail_point,0,0),
|
|
// *****************
|
|
// END POINT
|
|
// *****************
|
|
handle([fin_base,0],60,3),
|
|
[fin_base,0] // End point
|
|
];
|
|
/*
|
|
top_point = [0,fin_height];
|
|
p1 = [fin_thickness/2,0];
|
|
p2 = [-fin_thickness/2,0];
|
|
|
|
|
|
vertical_shape=[
|
|
p1,
|
|
handle(p1,90,fin_height/1.2),
|
|
// *****************
|
|
// TOP Point
|
|
// *****************
|
|
handle(top_point,140 ,0),
|
|
top_point,
|
|
handle(top_point,140 ,0),
|
|
// *****************
|
|
// END POINT
|
|
// *****************
|
|
handle(p2,90,fin_height/1.2),
|
|
p2
|
|
];
|
|
*/
|
|
/*
|
|
lpoint=[fin_width/2,0];
|
|
rpoint=[-lpoint[0],0];
|
|
top_strength=fin_width/8;
|
|
|
|
top_shape=[
|
|
// Right
|
|
rpoint,
|
|
handle(rpoint,150,top_strength),
|
|
// Left
|
|
handle(lpoint,40,top_strength),
|
|
lpoint,
|
|
handle(lpoint,-40,top_strength),
|
|
// Final
|
|
handle(rpoint,-150,top_strength),
|
|
rpoint
|
|
];
|
|
*/
|
|
|
|
// Calculate points along the Bézier curve.
|
|
// 'N' here determines the number of points to calculate.
|
|
//N = 50; // Number of points to generate
|
|
/*
|
|
translate_path(
|
|
resample_path(profile_path,200),
|
|
-fin_width/2,
|
|
0
|
|
)
|
|
*/
|
|
profile_path = translate_path(
|
|
asCurve(profile_points),
|
|
-fin_width/2
|
|
);
|
|
//vertical_path = asCurve(vertical_shape);
|
|
//top_path = asCurve(top_shape);
|
|
|
|
|
|
//left(50) polygon(vertical_path);
|
|
//polygon(profile_path);
|
|
//left(280) polygon(top_path);
|
|
|
|
//left(100) back(70)
|
|
// resize([fin_width,fin_thickness])circle(d=fin_width);
|
|
|
|
|
|
//showDebugPath(top_path);
|
|
|
|
|
|
function asCurve(points) = bezier_curve(points/*,N=3*/,splinesteps=128);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
bezier = bezier_points(profile_points, N=50);
|
|
|
|
// Convert the Bézier curve points to a 3D path starting at z=0
|
|
path3d_bezier = path3d(bezier);
|
|
|
|
intersection(){
|
|
if (true) down(fin_thickness) linear_extrude(height=fin_thickness*2) {
|
|
polygon(profile_path);
|
|
};
|
|
left(0) yrot(90) linear_extrude(height=fin_width) {
|
|
polygon(vertical_path);
|
|
};
|
|
if (true) right(fin_width/2) xrot(-90) linear_extrude(height=fin_height) {
|
|
resize([fin_width,fin_thickness])circle(d=fin_width);
|
|
};
|
|
|
|
}
|
|
|
|
color("Red") left(300) intersection(){
|
|
left(0) yrot(90)
|
|
|
|
//bend(size = [fin_width*3, fin_height*2, fin_tickness*4], angle = 270)
|
|
linear_extrude(height=fin_width)
|
|
polygon(vertical_path);
|
|
if (true) right(fin_width/2) xrot(-90) linear_extrude(height=fin_height) {
|
|
resize([fin_width,fin_thickness])circle(d=fin_width);
|
|
};
|
|
|
|
}
|
|
|
|
color("green") left(300) back(70)
|
|
left(0) yrot(90)
|
|
//bend(size = [fin_width*3, fin_height*2, fin_tickness*4], angle = 30)
|
|
linear_extrude(height=fin_width)
|
|
//bend_extrude(size = [100, 100], thickness = 1, angle = 270)
|
|
polygon(vertical_path);
|
|
//text("A");
|
|
;
|
|
|
|
path = [for(theta=[-180:5:180]) [theta/10, 10*sin(theta)]];
|
|
*/
|
|
|
|
// https://github.com/BelfrySCAD/BOSL2/wiki/skin.scad#functionmodule-path_sweep
|
|
/*
|
|
color("Yellow") path_sweep(
|
|
vertical_path,
|
|
get_n_items(profile_path,80),
|
|
spin=0
|
|
);
|
|
*/
|
|
|
|
/*
|
|
|
|
echo ("PATH LENGTH",len(profile_path));
|
|
echo ("PATH LENGTH2",len(subdivide_path(profile_path,400)));
|
|
echo ("PATH LENGTH3",len(resample_path(profile_path,500)));
|
|
|
|
print_path_points(profile_path);
|
|
|
|
print_path_points(translate_path(profile_path,-fin_width/2,0));
|
|
*/
|
|
|
|
//if (true)
|
|
|
|
/*
|
|
circle_r = 10;
|
|
round_r = 5;
|
|
|
|
right(200) rounded_extrude(circle_r * 2, round_r)
|
|
circle(circle_r);
|
|
|
|
right(300) rounded_extrude(circle_r * 2, round_r)
|
|
polygon(resample_path(profile_path,200));
|
|
*/
|
|
|
|
//color("red")move_copies(profile_path) circle($fn=16);
|
|
|
|
|
|
|
|
|
|
/*
|
|
function get_n_items(arr, n) =
|
|
[for (i = [0 : n - 1]) if (i < len(arr)) arr[i]];
|
|
*/
|
|
|
|
function handle(point,angle,strength) = [
|
|
//point[0] + adj_ang_to_opp(strength,angle) /** xAngleFactor(angle)*/,
|
|
//point[1] + /*(angle>0 ? strength :-strength)*/ strength * yAngleFactor(angle),
|
|
point[0] + polar_to_xy(strength,angle)[0] ,
|
|
point[1] + polar_to_xy(strength,angle)[1]
|
|
];
|
|
|
|
function xAngleFactor(angle) = angle > 0 && angle < 180 ? 1 : -1;
|
|
function yAngleFactor(angle) = angle > -90 && angle < 90 ? 1 : -1;
|
|
|
|
function counterTop(x,withdraw,height) = [x-withdraw, height ];
|
|
function handleStart(x,withdraw,angle,strength) = [x+adj_ang_to_opp(strength,angle), x-withdraw +strength];
|
|
function handleEnd(x,withdraw,angle,strength) = [x-adj_ang_to_opp(strength,angle), x-withdraw -strength];
|
|
function endHandle(angle)=
|
|
angle < 90 ?
|
|
[fin_base + adj_ang_to_opp(fin_end_strength,90-angle),fin_end_strength]
|
|
:
|
|
[fin_base - adj_ang_to_opp(fin_end_strength,angle-90),fin_end_strength]
|
|
;
|
|
|
|
function backPoint() = [fin_base-(fin_back_widthdraw/100*fin_base),fin_back_height/100*fin_height];
|
|
|
|
function decrease_y(points, percentage) = [ for (p = points) [p[0], p[1] * (1 - percentage/100)]];
|
|
|
|
function pathProfile(points) = bezpath_curve(points,N=3);
|
|
|
|
function remove_last(arr) = select(arr, 0, len(arr) - 2);
|
|
|
|
|
|
// Surf Fin profile
|
|
fin_profile = pathProfile( profile_points );
|
|
//vertical_profile = pathProfile(vertical_shape);
|
|
|
|
// ****************
|
|
// * Slicing *
|
|
// ****************
|
|
|
|
layer_0 = pathProcess(addBase(fin_profile)); // Master layer with base
|
|
layer_1 = contract(layer_0,-5);
|
|
layer_2 = contract(layer_1,-4);
|
|
layer_3 = contract(layer_2,-4);
|
|
layer_4 = contract(layer_3,-2);
|
|
|
|
//echo ("layer_2",layer_2);
|
|
//echo ("layer_3",layer_3);
|
|
|
|
|
|
//layers = [layer_0,layer_1,layer_2,layer_3,layer_4];
|
|
layers = [layer_0,layer_1,layer_2,layer_3];
|
|
|
|
|
|
|
|
function pathProcess2(path) = subdivide_path(path,100);
|
|
function pathProcess(path) = path;
|
|
function contract2(path,delta) = pathProcess(offset(path,r=delta,chamfer=true));
|
|
function contract(path,delta) =
|
|
pathProcess(
|
|
offset(
|
|
deduplicate(path),
|
|
delta=delta,
|
|
chamfer=false,
|
|
same_length=true
|
|
)
|
|
);
|
|
|
|
// ****************
|
|
// * Fin Drawing *
|
|
// ****************
|
|
if (build_fin) {
|
|
scale([scale_factor, scale_factor, scale_factor]) build();
|
|
}
|
|
|
|
module build() {
|
|
union(){
|
|
difference(){
|
|
union() {
|
|
if (parts != "bottom")
|
|
//buildFinSide([layer_0,layer_1,layer_2],fin_thickness/2);
|
|
buildFinSide();
|
|
if (parts != "top")
|
|
buildFinSide(true);
|
|
//zflip()
|
|
// buildFinSide([layer_0,layer_1,layer_2],fin_thickness/2);
|
|
}
|
|
color("Red") cube([fin_base+20,base_extra_thickness+20,base_tickness+20],anchor=LEFT+BACK);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
module subtracted(anchor) {
|
|
color("Red") fwd(40) left(40) cube([fin_width+100,fin_height+100,20],anchor=anchor);
|
|
}
|
|
|
|
|
|
/**
|
|
* Build fin side
|
|
*
|
|
* @param layers - Layers path as array
|
|
* @param thickness - thickness of half fin
|
|
*/
|
|
//module buildFinSide(layers,thickness,flip=false) {
|
|
module buildFinSide(flip=false) {
|
|
|
|
|
|
mirror([0,0,flip ? 1 : 0])
|
|
color(flip ? "Gray" : "LightGray") up(fin_thickness/4) /*down(fin_thickness) */
|
|
ellipse_extrude(
|
|
fin_thickness/2,
|
|
center=true,
|
|
)
|
|
polygon(profile_path)
|
|
/*
|
|
polygon(
|
|
translate_path(
|
|
resample_path(profile_path,200),
|
|
-fin_width/2,
|
|
0
|
|
)
|
|
|
|
)*/
|
|
;
|
|
}
|
|
|
|
echo ("layerHeights(3,thickness):",layerHeights(3,base_tickness/2));
|
|
|
|
if (show_debug_layers) {
|
|
left(130) {
|
|
showDebugPath(layer_0);
|
|
showDebugPath(layer_1);
|
|
showDebugPath(layer_2);
|
|
|
|
assert(is_path(layer_3),"Layer 3 is not a path");
|
|
showDebugPath(layer_3);
|
|
//showDebugPath(layer_4);
|
|
}
|
|
left(230)
|
|
showDebugPath(vertical_profile);
|
|
//showDebugPath(layer_3);
|
|
|
|
}
|
|
if (draw_profile) {
|
|
// Draw fin profile
|
|
drawProfile( profile_points, true );
|
|
}
|
|
|
|
|
|
/**
|
|
* Displays debug information for a path by visualizing its self-crossings.
|
|
*
|
|
* @param path - The input path to analyze for self-crossings.
|
|
*
|
|
* This module:
|
|
* - Splits the path at points where it intersects itself.
|
|
* - Renders each segment of the split path with different colors for easy identification.
|
|
*/
|
|
module showDebugPath(path) {
|
|
assert(is_path(path),"Path to show is not a path");
|
|
assert(is_path_simple(path),"Path is not simple");
|
|
rainbow(split_path_at_self_crossings(path))
|
|
stroke($item, closed=false, width=0.2);
|
|
}
|
|
|
|
|
|
/**
|
|
* 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 ){
|
|
pt = [100,0];
|
|
pos = bezpath_closest_point(points, pt);
|
|
xy = bezpath_points(points,pos[0],pos[1]);
|
|
debug_bezier(points, N=3,width=0.2);
|
|
//color("red") translate(pt) sphere(r=6);
|
|
//color("blue") translate(xy) sphere(r=6);
|
|
}
|
|
|
|
/**
|
|
* Adds a base to the given path by extending it with additional points.
|
|
*
|
|
* @param path - The original path to which the base will be added.
|
|
* @return A new path with an added base.
|
|
*
|
|
* This function concatenates:
|
|
* - The original path (`pathProfile`).
|
|
* - A point `fin_base` which might represent the start or end of the base.
|
|
* - Points for additional thickness (`-base_extra_thickness`) at both ends of the base.
|
|
*/
|
|
function addBase(path) = concat(path,[[fin_base,-base_extra_thickness],[0,-base_extra_thickness]]);
|
|
|
|
|
|
/**
|
|
* Calculates heights for n layers where the first layer starts at 0 and the last at fin_thickness.
|
|
*
|
|
* @param n - Number of layers.
|
|
* @param fin_thickness - The total height to be divided.
|
|
* @return An array where each element represents the height of the top of each layer.
|
|
*/
|
|
function layerHeights(n, fin_thickness) =
|
|
let(
|
|
layer_height = fin_thickness / (n - 1)
|
|
)
|
|
[ for (i = [0 : n-1]) i * layer_height ];
|
|
|
|
|
|
/**
|
|
* Function to translate a path manually along X and Y
|
|
*/
|
|
function translate_path(path, dx=0, dy=0) =
|
|
[for (p = path) [p[0] + dx, p[1] + dy]];
|
|
|
|
|
|
|
|
// Function to print points of a path
|
|
module print_path_points(path) {
|
|
for (i = [0:len(path)-1]) {
|
|
echo(str("\t Point ", i, ": [", path[i][0], ", ", path[i][1], "]"));
|
|
}
|
|
}
|
|
|
|
echo ("**********************");
|
|
echo ("* Configuration *");
|
|
echo ("**********************");
|
|
echo ("Layers count" ,len(layers));
|
|
echo ("Base thickness" ,str(base_tickness," mm"));
|
|
echo ("Layers heights" ,layerHeights(len(layers),fin_thickness/2));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|