openscad/BOSL2
1
0
Fork 0
mirror of https://github.com/revarbat/BOSL2.git synced 2025-01-16 13:50:23 +01:00
Code Issues Projects Releases Wiki Activity

add path.scad tests, shift tests to correct files

Browse Source 
path_extrude2d bugfix
This commit is contained in:
Adrian Mariano 2021-10-31 15:35:45 -04:00
parent 662f6c458d
commit 3a367c3faf
15 changed files with 586 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
math.scad
View File

@ -192,7 +192,7 @@ function lerp(a,b,u) =
// l = lerpn(0,1,6); // Returns: [0, 0.2, 0.4, 0.6, 0.8, 1] // l = lerpn(0,1,6); // Returns: [0, 0.2, 0.4, 0.6, 0.8, 1]
// l = lerpn(0,1,5,false); // Returns: [0, 0.2, 0.4, 0.6, 0.8] // l = lerpn(0,1,5,false); // Returns: [0, 0.2, 0.4, 0.6, 0.8]
function lerpn(a,b,n,endpoint=true) = function lerpn(a,b,n,endpoint=true) =
assert(same_shape(a,b), "Bad or inconsistent inputs to lerp") assert(same_shape(a,b), "Bad or inconsistent inputs to lerpn")
assert(is_int(n)) assert(is_int(n))
assert(is_bool(endpoint)) assert(is_bool(endpoint))
let( d = n - (endpoint? 1 : 0) ) let( d = n - (endpoint? 1 : 0) )

7
mutators.scad
View File

@ -504,8 +504,8 @@ module chain_hull()
// path_extrude2d(path, caps=false) // path_extrude2d(path, caps=false)
// trapezoid(w1=10, w2=1, h=5, anchor=BACK); // trapezoid(w1=10, w2=1, h=5, anchor=BACK);
module path_extrude2d(path, caps=false, closed=false) { module path_extrude2d(path, caps=false, closed=false) {
extra_ang = 0.1; // Extra angle for overlap of joints
assert(caps==false || closed==false, "Cannot have caps on a closed extrusion"); assert(caps==false || closed==false, "Cannot have caps on a closed extrusion");
thin = 0.01;
path = deduplicate(path); path = deduplicate(path);
for (p=pair(path,wrap=closed)) for (p=pair(path,wrap=closed))
extrude_from_to(p[0],p[1]) xflip()rot(-90)children(); extrude_from_to(p[0],p[1]) xflip()rot(-90)children();
@ -515,7 +515,8 @@ module path_extrude2d(path, caps=false, closed=false) {
if (ang!=0) if (ang!=0)
translate(t[1]) { translate(t[1]) {
frame_map(y=delt, z=UP) frame_map(y=delt, z=UP)
rotate_extrude(angle=ang) rotate(-sign(ang)*extra_ang/2)
rotate_extrude(angle=ang+sign(ang)*extra_ang)
if (ang<0) if (ang<0)
right_half(planar=true) children(); right_half(planar=true) children();
else else
@ -523,7 +524,7 @@ module path_extrude2d(path, caps=false, closed=false) {
} }
} }
if (caps) { if (false && caps) {
move_copies([path[0],last(path)]) move_copies([path[0],last(path)])
rotate_extrude() rotate_extrude()
right_half(planar=true) children(); right_half(planar=true) children();

59
paths.scad
View File

@ -290,10 +290,8 @@ function _path_self_intersections(path, closed=true, eps=EPSILON) =
isect = _general_line_intersection([a1,a2],[b1,b2],eps=eps) isect = _general_line_intersection([a1,a2],[b1,b2],eps=eps)
) )
if (isect if (isect
// && isect[1]> (i==0 && !closed? -eps: 0) // Apparently too strict
&& isect[1]>=-eps && isect[1]>=-eps
&& isect[1]<= 1+eps && isect[1]<= 1+eps
// && isect[2]> 0
&& isect[2]>= -eps && isect[2]>= -eps
&& isect[2]<= 1+eps) && isect[2]<= 1+eps)
[isect[0], i, isect[1], j, isect[2]] [isect[0], i, isect[1], j, isect[2]]
@ -390,32 +388,28 @@ function subdivide_path(path, N, refine, closed=true, exact=true, method="length
assert((is_num(N) && N>0) || is_vector(N),"Parameter N to subdivide_path must be postive number or vector") assert((is_num(N) && N>0) || is_vector(N),"Parameter N to subdivide_path must be postive number or vector")
let( let(
count = len(path) - (closed?0:1), count = len(path) - (closed?0:1),
add_guess = method=="segment"? ( add_guess = method=="segment"?
is_list(N)? ( (
assert(len(N)==count,"Vector parameter N to subdivide_path has the wrong length") is_list(N)
? assert(len(N)==count,"Vector parameter N to subdivide_path has the wrong length")
add_scalar(N,-1) add_scalar(N,-1)
) : repeat((N-len(path)) / count, count) : repeat((N-len(path)) / count, count)
) : // method=="length" )
: // method=="length"
assert(is_num(N),"Parameter N to subdivide path must be a number when method=\"length\"") assert(is_num(N),"Parameter N to subdivide path must be a number when method=\"length\"")
let( let(
path_lens = concat( path_lens = path_segment_lengths(path,closed),
[ for (i = [0:1:len(path)-2]) norm(path[i+1]-path[i]) ],
closed? [norm(path[len(path)-1]-path[0])] : []
),
add_density = (N - len(path)) / sum(path_lens) add_density = (N - len(path)) / sum(path_lens)
) )
path_lens * add_density, path_lens * add_density,
add = exact? _sum_preserving_round(add_guess) : add = exact? _sum_preserving_round(add_guess)
[for (val=add_guess) round(val)] : [for (val=add_guess) round(val)]
) concat( )
[ [
for (i=[0:1:count]) each [ for (i=[0:1:count-1])
for(j=[0:1:add[i]]) each lerpn(path[i],select(path,i+1), 1+add[i],endpoint=false),
lerp(path[i],select(path,i+1), j/(add[i]+1)) if (!closed) last(path)
] ];
],
closed? [] : [last(path)]
);
@ -465,8 +459,31 @@ function subdivide_long_segments(path, maxlen, closed=true) =
// Arguments: // Arguments:
// path = path in any dimension or a 1-region // path = path in any dimension or a 1-region
// N = Number of points in output // N = Number of points in output
// ---
// spacing = Approximate spacing desired // spacing = Approximate spacing desired
// closed = set to true if path is closed. Default: true // closed = set to true if path is closed. Default: true
// Example(2D): Subsampling lots of points from a smooth curve
// path = xscale(2,circle($fn=250, r=10));
// sampled = resample_path(path, 16);
// stroke(path);
// color("red")move_copies(sampled) circle($fn=16);
// Example(2D): Specified spacing is rounded to make a uniform sampling
// path = xscale(2,circle($fn=250, r=10));
// sampled = resample_path(path, spacing=17);
// stroke(path);
// color("red")move_copies(sampled) circle($fn=16);
// Example(2D): Notice that the corners are excluded
// path = square(20);
// sampled = resample_path(path, spacing=6);
// stroke(path,closed=true);
// color("red")move_copies(sampled) circle($fn=16);
// Example(2D): Closed set to false
// path = square(20);
// sampled = resample_path(path, spacing=6,closed=false);
// stroke(path);
// color("red")move_copies(sampled) circle($fn=16);
function resample_path(path, N, spacing, closed=true) = function resample_path(path, N, spacing, closed=true) =
let(path = force_path(path)) let(path = force_path(path))
assert(is_path(path)) assert(is_path(path))

90
tests/test_affine.scad
View File

@ -1,37 +1,6 @@
include <../std.scad> include <../std.scad>
module test_ident() {
assert(ident(3) == [[1,0,0],[0,1,0],[0,0,1]]);
assert(ident(4) == [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]);
}
test_ident();
module test_is_2d_transform() {
assert(!is_2d_transform(affine2d_identity()));
assert(!is_2d_transform(affine2d_translate([5,8])));
assert(!is_2d_transform(affine2d_scale([3,4])));
assert(!is_2d_transform(affine2d_zrot(30)));
assert(!is_2d_transform(affine2d_mirror([-1,1])));
assert(!is_2d_transform(affine2d_skew(30,15)));
assert(is_2d_transform(affine3d_identity()));
assert(is_2d_transform(affine3d_translate([30,40,0])));
assert(!is_2d_transform(affine3d_translate([30,40,50])));
assert(is_2d_transform(affine3d_scale([3,4,1])));
assert(!is_2d_transform(affine3d_xrot(30)));
assert(!is_2d_transform(affine3d_yrot(30)));
assert(is_2d_transform(affine3d_zrot(30)));
assert(is_2d_transform(affine3d_skew(sxy=2)));
assert(is_2d_transform(affine3d_skew(syx=2)));
assert(!is_2d_transform(affine3d_skew(szx=2)));
assert(!is_2d_transform(affine3d_skew(szy=2)));
}
test_is_2d_transform();
// 2D // 2D
module test_affine2d_identity() { module test_affine2d_identity() {
@ -197,64 +166,5 @@ test_affine3d_skew_yz();
//////////////////////////// ////////////////////////////
module test_apply() {
assert(approx(apply(affine3d_xrot(90),2*UP),2*FRONT));
assert(approx(apply(affine3d_yrot(90),2*UP),2*RIGHT));
assert(approx(apply(affine3d_zrot(90),2*UP),2*UP));
assert(approx(apply(affine3d_zrot(90),2*RIGHT),2*BACK));
assert(approx(apply(affine3d_zrot(90),2*BACK+2*RIGHT),2*BACK+2*LEFT));
assert(approx(apply(affine3d_xrot(135),2*BACK+2*UP),2*sqrt(2)*FWD));
assert(approx(apply(affine3d_yrot(135),2*RIGHT+2*UP),2*sqrt(2)*DOWN));
assert(approx(apply(affine3d_zrot(45),2*BACK+2*RIGHT),2*sqrt(2)*BACK));
module check_path_apply(mat,path)
assert_approx(apply(mat,path),path3d([for (p=path) mat*concat(p,1)]));
check_path_apply(xrot(45), path3d(rect(100,center=true)));
check_path_apply(yrot(45), path3d(rect(100,center=true)));
check_path_apply(zrot(45), path3d(rect(100,center=true)));
check_path_apply(rot([20,30,40])*scale([0.9,1.1,1])*move([10,20,30]), path3d(rect(100,center=true)));
module check_patch_apply(mat,patch)
assert_approx(apply(mat,patch), [for (path=patch) path3d([for (p=path) mat*concat(p,1)])]);
flat = [for (x=[-50:25:50]) [for (y=[-50:25:50]) [x,y,0]]];
check_patch_apply(xrot(45), flat);
check_patch_apply(yrot(45), flat);
check_patch_apply(zrot(45), flat);
check_patch_apply(rot([20,30,40])*scale([0.9,1.1,1])*move([10,20,30]), flat);
}
test_apply();
module test_rot_decode() {
Tlist = [
rot(37),
xrot(49),
yrot(88),
rot(37,v=[1,3,3]),
rot(41,v=[2,-3,4]),
rot(180),
xrot(180),
yrot(180),
rot(180, v=[3,2,-5], cp=[3,5,18]),
rot(0.1, v=[1,2,3]),
rot(-47,v=[3,4,5],cp=[9,3,4]),
rot(197,v=[13,4,5],cp=[9,-3,4]),
move([3,4,5]),
move([3,4,5]) * rot(a=56, v=[5,3,-3], cp=[2,3,4]),
ident(4)
];
errlist = [for(T = Tlist)
let(
parm = rot_decode(T),
restore = move(parm[3])*rot(a=parm[0],v=parm[1],cp=parm[2])
)
norm_fro(restore-T)];
assert(max(errlist)<1e-13);
}
test_rot_decode();
// vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap // vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap

111
tests/test_comparisons.scad
View File

@ -280,3 +280,114 @@ module test_approx() {
assert_equal(approx([1,[1,undef]], [1+1e-12,[1,undef]]), true); assert_equal(approx([1,[1,undef]], [1+1e-12,[1,undef]]), true);
} }
test_approx(); test_approx();
module test_group_data() {
assert_equal(group_data([1,2,0], ["A","B","C"]), [["C"],["A"],["B"]]);
assert_equal(group_data([1,3,0], ["A","B","C"]), [["C"],["A"],[],["B"]]);
assert_equal(group_data([5,3,1], ["A","B","C"]), [[],["C"],[],["B"],[],["A"]]);
assert_equal(group_data([1,3,1], ["A","B","C"]), [[],["A","C"],[],["B"]]);
}
test_group_data();
module test_compare_vals() {
assert(compare_vals(-10,0) < 0);
assert(compare_vals(10,0) > 0);
assert(compare_vals(10,10) == 0);
assert(compare_vals("abc","abcd") < 0);
assert(compare_vals("abcd","abc") > 0);
assert(compare_vals("abcd","abcd") == 0);
assert(compare_vals(false,false) == 0);
assert(compare_vals(true,false) > 0);
assert(compare_vals(false,true) < 0);
assert(compare_vals(true,true) == 0);
assert(compare_vals([2,3,4], [2,3,4,5]) < 0);
assert(compare_vals([2,3,4,5], [2,3,4,5]) == 0);
assert(compare_vals([2,3,4,5], [2,3,4]) > 0);
assert(compare_vals([2,3,4,5], [2,3,5,5]) < 0);
assert(compare_vals([[2,3,4,5]], [[2,3,5,5]]) < 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5]]) == 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4,5], [3,4,5]]) < 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5,6]]) < 0);
assert(compare_vals([[2,3,4,5],[3,4,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_vals([[2,3,4],[3,4,5,6]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_vals([[2,3,4],[3,5,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4], [3,5,5]]) < 0);
assert(compare_vals(undef, undef) == 0);
assert(compare_vals(undef, true) < 0);
assert(compare_vals(undef, 0) < 0);
assert(compare_vals(undef, "foo") < 0);
assert(compare_vals(undef, [2,3,4]) < 0);
assert(compare_vals(undef, [0:3]) < 0);
assert(compare_vals(true, undef) > 0);
assert(compare_vals(true, true) == 0);
assert(compare_vals(true, 0) < 0);
assert(compare_vals(true, "foo") < 0);
assert(compare_vals(true, [2,3,4]) < 0);
assert(compare_vals(true, [0:3]) < 0);
assert(compare_vals(0, undef) > 0);
assert(compare_vals(0, true) > 0);
assert(compare_vals(0, 0) == 0);
assert(compare_vals(0, "foo") < 0);
assert(compare_vals(0, [2,3,4]) < 0);
assert(compare_vals(0, [0:3]) < 0);
assert(compare_vals(1, undef) > 0);
assert(compare_vals(1, true) > 0);
assert(compare_vals(1, 1) == 0);
assert(compare_vals(1, "foo") < 0);
assert(compare_vals(1, [2,3,4]) < 0);
assert(compare_vals(1, [0:3]) < 0);
assert(compare_vals("foo", undef) > 0);
assert(compare_vals("foo", true) > 0);
assert(compare_vals("foo", 1) > 0);
assert(compare_vals("foo", "foo") == 0);
assert(compare_vals("foo", [2,3,4]) < 0);
assert(compare_vals("foo", [0:3]) < 0);
assert(compare_vals([2,3,4], undef) > 0);
assert(compare_vals([2,3,4], true) > 0);
assert(compare_vals([2,3,4], 1) > 0);
assert(compare_vals([2,3,4], "foo") > 0);
assert(compare_vals([2,3,4], [2,3,4]) == 0);
assert(compare_vals([2,3,4], [0:3]) < 0);
assert(compare_vals([0:3], undef) > 0);
assert(compare_vals([0:3], true) > 0);
assert(compare_vals([0:3], 1) > 0);
assert(compare_vals([0:3], "foo") > 0);
assert(compare_vals([0:3], [2,3,4]) > 0);
assert(compare_vals([0:3], [0:3]) == 0);
}
test_compare_vals();
module test_compare_lists() {
assert(compare_lists([2,3,4], [2,3,4,5]) < 0);
assert(compare_lists([2,3,4,5], [2,3,4,5]) == 0);
assert(compare_lists([2,3,4,5], [2,3,4]) > 0);
assert(compare_lists([2,3,4,5], [2,3,5,5]) < 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5]]) == 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4,5], [3,4,5]]) < 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5,6]]) < 0);
assert(compare_lists([[2,3,4,5],[3,4,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_lists([[2,3,4],[3,4,5,6]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_lists([[2,3,4],[3,5,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4], [3,5,5]]) < 0);
assert(compare_lists("cat", "bat") > 0);
assert(compare_lists(["cat"], ["bat"]) > 0);
}
test_compare_lists();

10
tests/test_drawing.scad
View File

@ -49,3 +49,13 @@ module test_arc() {
assert_approx(arc($fn=24, cp=[10,10], points=[[45,45],[-25,45]], long=true), [[45,45],[53.2421021636,34.0856928585],[58.1827254512,21.3324740498],[59.4446596304,7.71403542491],[56.9315576496,-5.72987274525],[50.8352916125,-17.9728253654],[41.6213035891,-28.0800887515],[29.9930697126,-35.2799863457],[16.8383906815,-39.0228152281],[3.16160931847,-39.0228152281],[-9.9930697126,-35.2799863457],[-21.6213035891,-28.0800887515],[-30.8352916125,-17.9728253654],[-36.9315576496,-5.72987274525],[-39.4446596304,7.71403542491],[-38.1827254512,21.3324740498],[-33.2421021636,34.0856928585],[-25,45]]); assert_approx(arc($fn=24, cp=[10,10], points=[[45,45],[-25,45]], long=true), [[45,45],[53.2421021636,34.0856928585],[58.1827254512,21.3324740498],[59.4446596304,7.71403542491],[56.9315576496,-5.72987274525],[50.8352916125,-17.9728253654],[41.6213035891,-28.0800887515],[29.9930697126,-35.2799863457],[16.8383906815,-39.0228152281],[3.16160931847,-39.0228152281],[-9.9930697126,-35.2799863457],[-21.6213035891,-28.0800887515],[-30.8352916125,-17.9728253654],[-36.9315576496,-5.72987274525],[-39.4446596304,7.71403542491],[-38.1827254512,21.3324740498],[-33.2421021636,34.0856928585],[-25,45]]);
} }
test_arc(); test_arc();
module test_dashed_stroke() {
segs = dashed_stroke([[0,0],[10,0]], dashpat=[3,2], closed=false);
assert_equal(segs,[[[0,0],[3,0]], [[5,0],[8,0]]]);
}
test_dashed_stroke();

34
tests/test_geometry.scad
View File

@ -55,6 +55,7 @@ test_ccw_polygon();
test_reverse_polygon(); test_reverse_polygon();
test_polygon_normal(); test_polygon_normal();
test_rot_decode();
//tests to migrate to other files //tests to migrate to other files
test_convex_distance(); test_convex_distance();
@ -966,4 +967,37 @@ module test_convex_collision() {
} }
*test_convex_distance(); *test_convex_distance();
module test_rot_decode() {
Tlist = [
rot(37),
xrot(49),
yrot(88),
rot(37,v=[1,3,3]),
rot(41,v=[2,-3,4]),
rot(180),
xrot(180),
yrot(180),
rot(180, v=[3,2,-5], cp=[3,5,18]),
rot(0.1, v=[1,2,3]),
rot(-47,v=[3,4,5],cp=[9,3,4]),
rot(197,v=[13,4,5],cp=[9,-3,4]),
move([3,4,5]),
move([3,4,5]) * rot(a=56, v=[5,3,-3], cp=[2,3,4]),
ident(4)
];
errlist = [for(T = Tlist)
let(
parm = rot_decode(T),
restore = move(parm[3])*rot(a=parm[0],v=parm[1],cp=parm[2])
)
norm_fro(restore-T)];
assert(max(errlist)<1e-13);
}
*test_rot_decode();
// vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap // vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap

46
tests/test_linalg.scad
View File

@ -1,5 +1,51 @@
include <../std.scad> include <../std.scad>
module test_is_matrix() {
assert(is_matrix([[2,3,4],[5,6,7],[8,9,10]]));
assert(is_matrix([[2,3],[5,6],[8,9]],3,2));
assert(is_matrix([[2,3],[5,6],[8,9]],m=3,n=2));
assert(is_matrix([[2,3,4],[5,6,7]],m=2,n=3));
assert(is_matrix([[2,3,4],[5,6,7]],2,3));
assert(is_matrix([[2,3,4],[5,6,7]],m=2));
assert(is_matrix([[2,3,4],[5,6,7]],2));
assert(is_matrix([[2,3,4],[5,6,7]],n=3));
assert(!is_matrix([[2,3,4],[5,6,7]],m=4));
assert(!is_matrix([[2,3,4],[5,6,7]],n=5));
assert(!is_matrix([[2,3],[5,6],[8,9]],m=2,n=3));
assert(!is_matrix([[2,3,4],[5,6,7]],m=3,n=2));
assert(!is_matrix([ [2,[3,4]],
[4,[5,6]]]));
assert(!is_matrix([[3,4],[undef,3]]));
assert(!is_matrix([[3,4],[3,"foo"]]));
assert(!is_matrix([[3,4],[3,3,2]]));
assert(!is_matrix([ [3,4],6]));
assert(!is_matrix(undef));
assert(!is_matrix(NAN));
assert(!is_matrix(INF));
assert(!is_matrix(-5));
assert(!is_matrix(0));
assert(!is_matrix(5));
assert(!is_matrix(""));
assert(!is_matrix("foo"));
assert(!is_matrix([3,4,5]));
assert(!is_matrix([]));
}
test_is_matrix();
module test_ident() {
assert(ident(3) == [[1,0,0],[0,1,0],[0,0,1]]);
assert(ident(4) == [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]);
}
test_ident();
module test_qr_factor() { module test_qr_factor() {
// Check that R is upper triangular // Check that R is upper triangular
function is_ut(R) = function is_ut(R) =

9
tests/test_lists.scad
View File

@ -401,15 +401,6 @@ module test_list_to_matrix() {
test_list_to_matrix(); test_list_to_matrix();
module test_group_data() {
assert_equal(group_data([1,2,0], ["A","B","C"]), [["C"],["A"],["B"]]);
assert_equal(group_data([1,3,0], ["A","B","C"]), [["C"],["A"],[],["B"]]);
assert_equal(group_data([5,3,1], ["A","B","C"]), [[],["C"],[],["B"],[],["A"]]);
assert_equal(group_data([1,3,1], ["A","B","C"]), [[],["A","C"],[],["B"]]);
}
test_group_data();
module test_flatten() { module test_flatten() {
assert(flatten([[1,2,3], [4,5,[6,7,8]]]) == [1,2,3,4,5,[6,7,8]]); assert(flatten([[1,2,3], [4,5,[6,7,8]]]) == [1,2,3,4,5,[6,7,8]]);
assert(flatten([]) == []); assert(flatten([]) == []);

171
tests/test_math.scad
View File

@ -76,40 +76,6 @@ module test_constrain() {
test_constrain(); test_constrain();
module test_is_matrix() {
assert(is_matrix([[2,3,4],[5,6,7],[8,9,10]]));
assert(is_matrix([[2,3],[5,6],[8,9]],3,2));
assert(is_matrix([[2,3],[5,6],[8,9]],m=3,n=2));
assert(is_matrix([[2,3,4],[5,6,7]],m=2,n=3));
assert(is_matrix([[2,3,4],[5,6,7]],2,3));
assert(is_matrix([[2,3,4],[5,6,7]],m=2));
assert(is_matrix([[2,3,4],[5,6,7]],2));
assert(is_matrix([[2,3,4],[5,6,7]],n=3));
assert(!is_matrix([[2,3,4],[5,6,7]],m=4));
assert(!is_matrix([[2,3,4],[5,6,7]],n=5));
assert(!is_matrix([[2,3],[5,6],[8,9]],m=2,n=3));
assert(!is_matrix([[2,3,4],[5,6,7]],m=3,n=2));
assert(!is_matrix([ [2,[3,4]],
[4,[5,6]]]));
assert(!is_matrix([[3,4],[undef,3]]));
assert(!is_matrix([[3,4],[3,"foo"]]));
assert(!is_matrix([[3,4],[3,3,2]]));
assert(!is_matrix([ [3,4],6]));
assert(!is_matrix(undef));
assert(!is_matrix(NAN));
assert(!is_matrix(INF));
assert(!is_matrix(-5));
assert(!is_matrix(0));
assert(!is_matrix(5));
assert(!is_matrix(""));
assert(!is_matrix("foo"));
assert(!is_matrix([3,4,5]));
assert(!is_matrix([]));
}
test_is_matrix();
module test_all_integer() { module test_all_integer() {
assert(!all_integer(undef)); assert(!all_integer(undef));
@ -133,37 +99,6 @@ test_all_integer();
module test_min_index() {
vals = rands(-100,100,100,seed=75);
minval = min(vals);
minidx = min_index(vals);
assert_equal(vals[minidx], minval);
assert_equal(min_index([3,4,5,6]), 0);
assert_equal(min_index([4,3,5,6]), 1);
assert_equal(min_index([4,5,3,6]), 2);
assert_equal(min_index([4,5,6,3]), 3);
assert_equal(min_index([6,5,4,3]), 3);
assert_equal(min_index([6,3,4,5]), 1);
assert_equal(min_index([-56,72,-874,5]), 2);
}
test_min_index();
module test_max_index() {
vals = rands(-100,100,100,seed=97);
maxval = max(vals);
maxidx = max_index(vals);
assert_equal(vals[maxidx], maxval);
assert_equal(max_index([3,4,5,6]), 3);
assert_equal(max_index([3,4,6,5]), 2);
assert_equal(max_index([3,6,4,5]), 1);
assert_equal(max_index([6,3,4,5]), 0);
assert_equal(max_index([5,6,4,3]), 1);
assert_equal(max_index([-56,72,-874,5]), 1);
}
test_max_index();
module test_posmod() { module test_posmod() {
assert_equal(posmod(-5,3), 1); assert_equal(posmod(-5,3), 1);
assert_equal(posmod(-4,3), 2); assert_equal(posmod(-4,3), 2);
@ -248,13 +183,6 @@ test_gaussian_rands();
module test_segs() {
assert_equal(segs(50,$fn=8), 8);
assert_equal(segs(50,$fa=2,$fs=2), 158);
}
test_segs();
module test_lerp() { module test_lerp() {
assert_equal(lerp(-20,20,0), -20); assert_equal(lerp(-20,20,0), -20);
assert_equal(lerp(-20,20,0.25), -10); assert_equal(lerp(-20,20,0.25), -10);
@ -486,105 +414,6 @@ test_convolve();
// Logic // Logic
module test_compare_vals() {
assert(compare_vals(-10,0) < 0);
assert(compare_vals(10,0) > 0);
assert(compare_vals(10,10) == 0);
assert(compare_vals("abc","abcd") < 0);
assert(compare_vals("abcd","abc") > 0);
assert(compare_vals("abcd","abcd") == 0);
assert(compare_vals(false,false) == 0);
assert(compare_vals(true,false) > 0);
assert(compare_vals(false,true) < 0);
assert(compare_vals(true,true) == 0);
assert(compare_vals([2,3,4], [2,3,4,5]) < 0);
assert(compare_vals([2,3,4,5], [2,3,4,5]) == 0);
assert(compare_vals([2,3,4,5], [2,3,4]) > 0);
assert(compare_vals([2,3,4,5], [2,3,5,5]) < 0);
assert(compare_vals([[2,3,4,5]], [[2,3,5,5]]) < 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5]]) == 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4,5], [3,4,5]]) < 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5,6]]) < 0);
assert(compare_vals([[2,3,4,5],[3,4,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_vals([[2,3,4],[3,4,5,6]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_vals([[2,3,4],[3,5,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_vals([[2,3,4],[3,4,5]], [[2,3,4], [3,5,5]]) < 0);
assert(compare_vals(undef, undef) == 0);
assert(compare_vals(undef, true) < 0);
assert(compare_vals(undef, 0) < 0);
assert(compare_vals(undef, "foo") < 0);
assert(compare_vals(undef, [2,3,4]) < 0);
assert(compare_vals(undef, [0:3]) < 0);
assert(compare_vals(true, undef) > 0);
assert(compare_vals(true, true) == 0);
assert(compare_vals(true, 0) < 0);
assert(compare_vals(true, "foo") < 0);
assert(compare_vals(true, [2,3,4]) < 0);
assert(compare_vals(true, [0:3]) < 0);
assert(compare_vals(0, undef) > 0);
assert(compare_vals(0, true) > 0);
assert(compare_vals(0, 0) == 0);
assert(compare_vals(0, "foo") < 0);
assert(compare_vals(0, [2,3,4]) < 0);
assert(compare_vals(0, [0:3]) < 0);
assert(compare_vals(1, undef) > 0);
assert(compare_vals(1, true) > 0);
assert(compare_vals(1, 1) == 0);
assert(compare_vals(1, "foo") < 0);
assert(compare_vals(1, [2,3,4]) < 0);
assert(compare_vals(1, [0:3]) < 0);
assert(compare_vals("foo", undef) > 0);
assert(compare_vals("foo", true) > 0);
assert(compare_vals("foo", 1) > 0);
assert(compare_vals("foo", "foo") == 0);
assert(compare_vals("foo", [2,3,4]) < 0);
assert(compare_vals("foo", [0:3]) < 0);
assert(compare_vals([2,3,4], undef) > 0);
assert(compare_vals([2,3,4], true) > 0);
assert(compare_vals([2,3,4], 1) > 0);
assert(compare_vals([2,3,4], "foo") > 0);
assert(compare_vals([2,3,4], [2,3,4]) == 0);
assert(compare_vals([2,3,4], [0:3]) < 0);
assert(compare_vals([0:3], undef) > 0);
assert(compare_vals([0:3], true) > 0);
assert(compare_vals([0:3], 1) > 0);
assert(compare_vals([0:3], "foo") > 0);
assert(compare_vals([0:3], [2,3,4]) > 0);
assert(compare_vals([0:3], [0:3]) == 0);
}
test_compare_vals();
module test_compare_lists() {
assert(compare_lists([2,3,4], [2,3,4,5]) < 0);
assert(compare_lists([2,3,4,5], [2,3,4,5]) == 0);
assert(compare_lists([2,3,4,5], [2,3,4]) > 0);
assert(compare_lists([2,3,4,5], [2,3,5,5]) < 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5]]) == 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4,5], [3,4,5]]) < 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4], [3,4,5,6]]) < 0);
assert(compare_lists([[2,3,4,5],[3,4,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_lists([[2,3,4],[3,4,5,6]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_lists([[2,3,4],[3,5,5]], [[2,3,4], [3,4,5]]) > 0);
assert(compare_lists([[2,3,4],[3,4,5]], [[2,3,4], [3,5,5]]) < 0);
assert(compare_lists("cat", "bat") > 0);
assert(compare_lists(["cat"], ["bat"]) > 0);
}
test_compare_lists();
module test_any() { module test_any() {
assert_equal(any([0,false,undef]), false); assert_equal(any([0,false,undef]), false);

229
tests/test_paths.scad
View File

@ -1,5 +1,6 @@
include<../std.scad> include<../std.scad>
module test_is_path() { module test_is_path() {
assert(is_path([[1,2,3],[4,5,6]])); assert(is_path([[1,2,3],[4,5,6]]));
assert(is_path([[1,2,3],[4,5,6],[7,8,9]])); assert(is_path([[1,2,3],[4,5,6],[7,8,9]]));
@ -15,6 +16,23 @@ module test_is_path() {
test_is_path(); test_is_path();
module test_is_1region() {
assert(!is_1region([[3,4],[5,6],[7,8]]));
assert(is_1region([[[3,4],[5,6],[7,8]]]));
}
test_is_1region();
module force_path() {
assert_equal(force_path([[3,4],[5,6],[7,8]]), [[3,4],[5,6],[7,8]]);
assert_equal(force_path([[[3,4],[5,6],[7,8]]]), [[3,4],[5,6],[7,8]]);
assert_equal(force_path("abc"), "abc");
assert_equal(force_path(13), 13);
}
test_is_1region();
module test_is_closed_path() { module test_is_closed_path() {
assert(!is_closed_path([[1,2,3],[4,5,6],[1,8,9]])); assert(!is_closed_path([[1,2,3],[4,5,6],[1,8,9]]));
assert(is_closed_path([[1,2,3],[4,5,6],[1,8,9],[1,2,3]])); assert(is_closed_path([[1,2,3],[4,5,6],[1,8,9],[1,2,3]]));
@ -40,7 +58,218 @@ module test_path_merge_collinear() {
path = [[-20,-20], [-10,-20], [0,-10], [10,0], [20,10], [20,20], [15,30]]; path = [[-20,-20], [-10,-20], [0,-10], [10,0], [20,10], [20,20], [15,30]];
assert(path_merge_collinear(path) == [[-20,-20], [-10,-20], [20,10], [20,20], [15,30]]); assert(path_merge_collinear(path) == [[-20,-20], [-10,-20], [20,10], [20,20], [15,30]]);
assert(path_merge_collinear([path]) == [[-20,-20], [-10,-20], [20,10], [20,20], [15,30]]); assert(path_merge_collinear([path]) == [[-20,-20], [-10,-20], [20,10], [20,20], [15,30]]);
sq=square(10);
assert_equal(path_merge_collinear(subdivide_path(square(10), refine=25),closed=true), sq);
} }
test_path_merge_collinear(); test_path_merge_collinear();
module test_path_length(){
sq = square(10);
assert_equal(path_length(sq),30);
assert_equal(path_length(sq,true),40);
c = circle($fn=1000, r=1);
assert(approx(path_length(c,closed=true), 2*PI,eps=.0001));
}
test_path_length();
module test_path_segment_lengths(){
sq = square(10);
assert_equal(path_segment_lengths(sq), [10,10,10]);
assert_equal(path_segment_lengths(sq,true), [10,10,10,10]);
c = circle($fn=1000, r=1);
assert(approx(path_segment_lengths(c,closed=true), repeat(2*PI/1000,1000),eps=1e-7));
}
test_path_segment_lengths();
module test_path_length_fractions(){
sq = square(10);
assert_approx(path_length_fractions(sq), [0,1/3, 2/3, 1]);
assert_approx(path_length_fractions(sq,true), [0,1/4, 2/4,3/4, 1]);
}
test_path_length_fractions();
module test_subdivide_path(){
assert(approx(subdivide_path(square([2,2],center=true), 12), [[1, -1], [1/3, -1], [-1/3, -1], [-1, -1], [-1, -1/3], [-1, 1/3], [-1, 1], [-1/3, 1], [1/3, 1], [1, 1], [1, 1/3], [1, -1/3]]));
assert_equal(subdivide_path(square([8,2],center=true), 12), [[4, -1], [2, -1], [0, -1], [-2, -1], [-4, -1], [-4, 0], [-4, 1], [-2, 1], [0, 1], [2, 1], [4, 1], [4, 0]]);
assert_approx(subdivide_path(square([8,2],center=true), 12, method="segment"), [[4, -1], [4/3, -1], [-4/3, -1], [-4, -1], [-4, -1/3], [-4, 1/3], [-4, 1], [-4/3, 1], [4/3, 1], [4, 1], [4, 1/3], [4, -1/3]]);
assert_approx(subdivide_path(square([2,2],center=true), 17, closed=false), [[1, -1], [0.6, -1], [0.2, -1], [-0.2, -1], [-0.6, -1], [-1, -1], [-1, -2/3], [-1, -1/3], [-1, 0], [-1, 1/3], [-1, 2/3], [-1, 1], [-0.6, 1], [-0.2, 1], [0.2, 1], [0.6, 1], [1, 1]]);
assert_approx(subdivide_path(hexagon(side=2), [2,3,4,5,6,7], method="segment"),
[[2, 0], [1.5, -0.866025403784], [1, -1.73205080757],
[0.333333333333, -1.73205080757], [-0.333333333333,
-1.73205080757], [-1, -1.73205080757], [-1.25,
-1.29903810568], [-1.5, -0.866025403784], [-1.75,
-0.433012701892], [-2, 0], [-1.8, 0.346410161514],
[-1.6, 0.692820323028], [-1.4, 1.03923048454], [-1.2,
1.38564064606], [-1, 1.73205080757], [-0.666666666667,
1.73205080757], [-0.333333333333, 1.73205080757], [0,
1.73205080757], [0.333333333333, 1.73205080757],
[0.666666666667, 1.73205080757], [1, 1.73205080757],
[1.14285714286, 1.48461497792], [1.28571428571,
1.23717914826], [1.42857142857, 0.989743318611],
[1.57142857143, 0.742307488958], [1.71428571429,
0.494871659305], [1.85714285714, 0.247435829653]]);
assert_approx(subdivide_path(pentagon(side=2), [3,4,3,4], method="segment", closed=false),
[[1.7013016167, 0], [1.30944478184, -0.539344662917],
[0.917587946981, -1.07868932583], [0.525731112119,
-1.61803398875], [0.0502028539716, -1.46352549156],
[-0.425325404176, -1.30901699437], [-0.900853662324,
-1.15450849719], [-1.37638192047, -1], [-1.37638192047,
-0.333333333333], [-1.37638192047, 0.333333333333],
[-1.37638192047, 1], [-0.900853662324, 1.15450849719],
[-0.425325404176, 1.30901699437], [0.0502028539716,
1.46352549156], [0.525731112119, 1.61803398875]]);
assert_approx(subdivide_path(pentagon(side=2), 17),
[[1.7013016167, 0], [1.30944478184,
-0.539344662917], [0.917587946981, -1.07868932583],
[0.525731112119, -1.61803398875], [0.0502028539716,
-1.46352549156], [-0.425325404176, -1.30901699437],
[-0.900853662324, -1.15450849719], [-1.37638192047,
-1], [-1.37638192047, -0.333333333333],
[-1.37638192047, 0.333333333333], [-1.37638192047,
1], [-0.900853662324, 1.15450849719],
[-0.425325404176, 1.30901699437], [0.0502028539716,
1.46352549156], [0.525731112119, 1.61803398875],
[0.917587946981, 1.07868932583], [1.30944478184,
0.539344662917]]);
assert_approx(subdivide_path(pentagon(side=2), 17, exact=false),
[[1.7013016167, 0], [1.30944478184,
-0.539344662917], [0.917587946981, -1.07868932583],
[0.525731112119, -1.61803398875], [-0.108306565411,
-1.41202265917], [-0.742344242941, -1.20601132958],
[-1.37638192047, -1], [-1.37638192047,
-0.333333333333], [-1.37638192047, 0.333333333333],
[-1.37638192047, 1], [-0.742344242941,
1.20601132958], [-0.108306565411, 1.41202265917],
[0.525731112119, 1.61803398875], [0.917587946981,
1.07868932583], [1.30944478184, 0.539344662917]]);
assert_approx(subdivide_path(pentagon(side=2), 18, exact=false),
[[1.7013016167, 0], [1.40740899056,
-0.404508497187], [1.11351636441,
-0.809016994375], [0.819623738265,
-1.21352549156], [0.525731112119, -1.61803398875],
[0.0502028539716, -1.46352549156],
[-0.425325404176, -1.30901699437],
[-0.900853662324, -1.15450849719],
[-1.37638192047, -1], [-1.37638192047, -0.5],
[-1.37638192047, 0], [-1.37638192047, 0.5],
[-1.37638192047, 1], [-0.900853662324,
1.15450849719], [-0.425325404176, 1.30901699437],
[0.0502028539716, 1.46352549156], [0.525731112119,
1.61803398875], [0.819623738265, 1.21352549156],
[1.11351636441, 0.809016994375], [1.40740899056,
0.404508497187]]);
assert_approx(subdivide_path([[0,0,0],[2,0,1],[2,3,2]], 12),
[[0, 0, 0], [2/3, 0, 1/3], [4/3, 0, 2/3], [2, 0, 1], [2, 0.75, 1.25], [2, 1.5, 1.5], [2, 2.25, 1.75], [2, 3, 2], [1.6, 2.4, 1.6], [1.2, 1.8, 1.2], [0.8, 1.2, 0.8], [0.4, 0.6, 0.4]]);
}
test_subdivide_path();
module test_subdivide_long_segments(){
path = pentagon(d=100);
spath = subdivide_long_segments(path, 10, closed=true);
assert_approx(spath,
[[50, 0], [44.2418082865, -7.92547096913], [38.4836165729,
-15.8509419383], [32.7254248594, -23.7764129074], [26.9672331458,
-31.7018838765], [21.2090414323, -39.6273548456], [15.4508497187,
-47.5528258148], [6.1338998125, -44.5255652814], [-3.18305009375,
-41.498304748], [-12.5, -38.4710442147], [-21.8169499062,
-35.4437836813], [-31.1338998125, -32.416523148], [-40.4508497187,
-29.3892626146], [-40.4508497187, -19.5928417431], [-40.4508497187,
-9.79642087154], [-40.4508497187, 0], [-40.4508497187, 9.79642087154],
[-40.4508497187, 19.5928417431], [-40.4508497187, 29.3892626146],
[-31.1338998125, 32.416523148], [-21.8169499062, 35.4437836813],
[-12.5, 38.4710442147], [-3.18305009375, 41.498304748], [6.1338998125,
44.5255652814], [15.4508497187, 47.5528258148], [21.2090414323,
39.6273548456], [26.9672331458, 31.7018838765], [32.7254248594,
23.7764129074], [38.4836165729, 15.8509419383], [44.2418082865,
7.92547096913]]);
}
test_subdivide_long_segments();
module test_resample_path(){
path = xscale(2,circle($fn=250, r=10));
sampled = resample_path(path, 16);
assert_approx(sampled,
[[20, 0], [17.1657142861, -5.13020769642],
[11.8890531315, -8.04075246881], [6.03095737128,
-9.53380030092], [1.72917236085e-14, -9.99921044204],
[-6.03095737128, -9.53380030092], [-11.8890531315,
-8.04075246881], [-17.1657142861, -5.13020769642], [-20,
-3.19176120946e-14], [-17.1657142861, 5.13020769642],
[-11.8890531315, 8.04075246881], [-6.03095737128,
9.53380030092], [-4.20219414821e-14, 9.99921044204],
[6.03095737128, 9.53380030092], [11.8890531315,
8.04075246881], [17.1657142861, 5.13020769642]]);
path2 = square(20);
assert_approx(resample_path(path2, spacing=6),
[[20, 0], [13.8461538462, 0], [7.69230769231, 0], [1.53846153846, 0],
[0, 4.61538461538], [0, 10.7692307692], [0, 16.9230769231], [3.07692307692, 20],
[9.23076923077, 20], [15.3846153846, 20], [20, 18.4615384615], [20, 12.3076923077], [20, 6.15384615385]]);
assert_equal(resample_path(path2, spacing=6,closed=false),[[20, 0], [14, 0], [8, 0], [2, 0], [0, 4], [0, 10], [0, 16], [2, 20], [8, 20], [14, 20], [20, 20]]);
assert_approx(resample_path(path, spacing=17),
[[20, 0], [8.01443073309, -9.16170407964],
[-8.01443073309, -9.16170407964], [-20,
-1.59309060367e-14], [-8.01443073309, 9.16170407964],
[8.01443073309, 9.16170407964]]);
}
test_resample_path();
module test_path_closest_point(){
path = circle(d=100,$fn=6);
pt = [20,10];
closest = path_closest_point(path, pt);
assert_approx(closest, [5, [38.1698729811, 20.4903810568]]);
}
test_path_closest_point();
module test_path_tangents(){
path = circle(r=1, $fn=200);
path_t = path_tangents(path,closed=true);
assert_approx(path_t, hstack(column(path,1), -column(path,0)));
rect = square([10,3]);
tr1 = path_tangents(rect,closed=true);
tr2 = path_tangents(rect,closed=true,uniform=false);
tr3 = path_tangents(rect,closed=false);
tr4 = path_tangents(rect,closed=false,uniform=false);
assert_approx(tr1, [[-0.957826285221, -0.287347885566], [-0.957826285221, 0.287347885566], [0.957826285221, 0.287347885566], [0.957826285221, -0.287347885566]]);
assert_approx(tr2, [[-0.707106781187, -0.707106781187], [-0.707106781187, 0.707106781187], [0.707106781187, 0.707106781187], [0.707106781187, -0.707106781187]]);
assert_approx(tr3, [[-0.99503719021, -0.099503719021], [-0.957826285221, 0.287347885566], [0.957826285221, 0.287347885566], [0.99503719021, -0.099503719021]]);
assert_approx(tr4, [[-1, 0], [-0.707106781187, 0.707106781187], [0.707106781187, 0.707106781187], [1, 0]]);
}
test_path_tangents();
module test_path_curvature(){
c8 = path3d(circle(r=8, $fn=100));
c28 = path3d(circle(r=28, $fn=100));
assert(approx(path_curvature(c8,closed=true), repeat(1/8, 100), 4e-4));
assert(approx(path_curvature(c28,closed=true), repeat(1/28, 100), 4e-4));
}
test_path_curvature();
module test_path_torsion(){
c = path3d(circle(r=1, $fn=100));
tc = path_torsion(c, closed=true);
assert(all_zero(tc));
a=3;b=7;
helix = [for(t=[0:1:20]) [a*cos(t), a*sin(t), b*t*PI/180]];
th = path_torsion(helix, closed=false);
assert(approx(th[5], b/(a*a+b*b), 1e-5));
}
test_path_torsion();
//echo(fmt_float(sampled));

7
tests/test_shapes2d.scad
View File

@ -216,11 +216,4 @@ module test_mask2d_ogee() {
test_mask2d_ogee(); test_mask2d_ogee();
module test_dashed_stroke() {
segs = dashed_stroke([[0,0],[10,0]], dashpat=[3,2], closed=false);
assert_equal(segs,[[[0,0],[3,0]], [[5,0],[8,0]]]);
}
test_dashed_stroke();
// vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap // vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap

57
tests/test_transforms.scad
View File

@ -395,4 +395,61 @@ module test_skew() {
test_skew(); test_skew();
module test_apply() {
assert(approx(apply(affine3d_xrot(90),2*UP),2*FRONT));
assert(approx(apply(affine3d_yrot(90),2*UP),2*RIGHT));
assert(approx(apply(affine3d_zrot(90),2*UP),2*UP));
assert(approx(apply(affine3d_zrot(90),2*RIGHT),2*BACK));
assert(approx(apply(affine3d_zrot(90),2*BACK+2*RIGHT),2*BACK+2*LEFT));
assert(approx(apply(affine3d_xrot(135),2*BACK+2*UP),2*sqrt(2)*FWD));
assert(approx(apply(affine3d_yrot(135),2*RIGHT+2*UP),2*sqrt(2)*DOWN));
assert(approx(apply(affine3d_zrot(45),2*BACK+2*RIGHT),2*sqrt(2)*BACK));
module check_path_apply(mat,path)
assert_approx(apply(mat,path),path3d([for (p=path) mat*concat(p,1)]));
check_path_apply(xrot(45), path3d(rect(100,center=true)));
check_path_apply(yrot(45), path3d(rect(100,center=true)));
check_path_apply(zrot(45), path3d(rect(100,center=true)));
check_path_apply(rot([20,30,40])*scale([0.9,1.1,1])*move([10,20,30]), path3d(rect(100,center=true)));
module check_patch_apply(mat,patch)
assert_approx(apply(mat,patch), [for (path=patch) path3d([for (p=path) mat*concat(p,1)])]);
flat = [for (x=[-50:25:50]) [for (y=[-50:25:50]) [x,y,0]]];
check_patch_apply(xrot(45), flat);
check_patch_apply(yrot(45), flat);
check_patch_apply(zrot(45), flat);
check_patch_apply(rot([20,30,40])*scale([0.9,1.1,1])*move([10,20,30]), flat);
}
test_apply();
module test_is_2d_transform() {
assert(!is_2d_transform(affine2d_identity()));
assert(!is_2d_transform(affine2d_translate([5,8])));
assert(!is_2d_transform(affine2d_scale([3,4])));
assert(!is_2d_transform(affine2d_zrot(30)));
assert(!is_2d_transform(affine2d_mirror([-1,1])));
assert(!is_2d_transform(affine2d_skew(30,15)));
assert(is_2d_transform(affine3d_identity()));
assert(is_2d_transform(affine3d_translate([30,40,0])));
assert(!is_2d_transform(affine3d_translate([30,40,50])));
assert(is_2d_transform(affine3d_scale([3,4,1])));
assert(!is_2d_transform(affine3d_xrot(30)));
assert(!is_2d_transform(affine3d_yrot(30)));
assert(is_2d_transform(affine3d_zrot(30)));
assert(is_2d_transform(affine3d_skew(sxy=2)));
assert(is_2d_transform(affine3d_skew(syx=2)));
assert(!is_2d_transform(affine3d_skew(szx=2)));
assert(!is_2d_transform(affine3d_skew(szy=2)));
}
test_is_2d_transform();
// vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap // vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap

9
tests/test_utility.scad
View File

@ -76,6 +76,15 @@ module test_is_def() {
test_is_def(); test_is_def();
module test_segs() {
assert_equal(segs(50,$fn=8), 8);
assert_equal(segs(50,$fa=2,$fs=2), 158);
}
test_segs();
module test_is_str() { module test_is_str() {
assert(!is_str(undef)); assert(!is_str(undef));
assert(!is_str(true)); assert(!is_str(true));

34
tests/test_vectors.scad
View File

@ -113,6 +113,40 @@ module test_v_theta() {
test_v_theta(); test_v_theta();
module test_min_index() {
vals = rands(-100,100,100,seed=75);
minval = min(vals);
minidx = min_index(vals);
assert_equal(vals[minidx], minval);
assert_equal(min_index([3,4,5,6]), 0);
assert_equal(min_index([4,3,5,6]), 1);
assert_equal(min_index([4,5,3,6]), 2);
assert_equal(min_index([4,5,6,3]), 3);
assert_equal(min_index([6,5,4,3]), 3);
assert_equal(min_index([6,3,4,5]), 1);
assert_equal(min_index([-56,72,-874,5]), 2);
}
test_min_index();
module test_max_index() {
vals = rands(-100,100,100,seed=97);
maxval = max(vals);
maxidx = max_index(vals);
assert_equal(vals[maxidx], maxval);
assert_equal(max_index([3,4,5,6]), 3);
assert_equal(max_index([3,4,6,5]), 2);
assert_equal(max_index([3,6,4,5]), 1);
assert_equal(max_index([6,3,4,5]), 0);
assert_equal(max_index([5,6,4,3]), 1);
assert_equal(max_index([-56,72,-874,5]), 1);
}
test_max_index();
module test_unit() { module test_unit() {
assert(unit([10,0,0]) == [1,0,0]); assert(unit([10,0,0]) == [1,0,0]);
assert(unit([0,10,0]) == [0,1,0]); assert(unit([0,10,0]) == [0,1,0]);