There are a function f(x, y) and a given region in the xy-plane. If we can create and print a model, we'll be able to touch the function physically. Will mathematical functions be interesting?
It's not difficult when modeling is based on programming. There are several ways to do that. Which way would be best depends on what your requirement is.
The simplest way
Placing a small cube at every point [x, y, f(x, y)] is the simplest way. If every cube is small enough, all cubes will compose the function graph. The code is easy to understand as well.
function f(x, y) = (pow(y,2)/pow(2, 2))-(pow(x,2)/pow(2, 2));
min_value = -3;
max_value = 3;
resolution = 0.5;
thickness = 1;
for(x = [min_value:resolution:max_value]) {
for(y = [min_value:resolution:max_value]) {
translate([x, y, f(x, y)])
linear_extrude(thickness, center = true)
square(resolution, center = true);
}
}
In the above code, resolution determines what the next x or y is. A smaller resolution creates a smoother graph but takes more time to render. The exported model file is larger, too. The figure below using resolution = 0.01. It takes more than one minute to show the preview on my computer.
It's a trade-off between resolution and smoothness for a model. Even in the way introduced later, you also have to balance these two opposing qualities. When creating a smoother graph, however, the above way costs more indeed.
Introducing polyhedron
If you want a smoother graph but a relatively lower cost, try the built-in polyhdedron module. In the document “Line“, we talked about the polygon module which can create a multiple sided shape from a list of x, y coordinates. You may think the polyhdedron module is a 3D version of the polygon module. The polyhdedron module can be used to create any regular or irregular shape.
Even the polyhdedron module is like a 3D version of the polygon module, it's more complex than using the polygon module. Simply put, you have to know and index every vertex of the polyhedron. The official document of polyhedron gives a simple example.
To generate cube([10, 7, 5]), you have to index it's eight vertices. Then, figure out the indices used by each face. OpenSCAD requires a clockwise order.
After that, invoke polyhedron with the vertices and the vector of faces.
CubePoints = [
[ 0, 0, 0 ], //0
[ 10, 0, 0 ], //1
[ 10, 7, 0 ], //2
[ 0, 7, 0 ], //3
[ 0, 0, 5 ], //4
[ 10, 0, 5 ], //5
[ 10, 7, 5 ], //6
[ 0, 7, 5 ]]; //7
CubeFaces = [
[0,1,2,3], // bottom
[4,5,1,0], // front
[7,6,5,4], // top
[5,6,2,1], // right
[6,7,3,2], // back
[7,4,0,3]]; // left
polyhedron( CubePoints, CubeFaces );
A simple example, right? What will happen if we change the z value of the vertex 6 from 5 to 7?
CubePoints = [
[ 0, 0, 0 ], //0
[ 10, 0, 0 ], //1
[ 10, 7, 0 ], //2
[ 0, 7, 0 ], //3
[ 0, 0, 5 ], //4
[ 10, 0, 5 ], //5
[ 10, 7, 7 ], //6
[ 0, 7, 5 ]]; //7
CubeFaces = [
[0,1,2,3], // bottom
[4,5,1,0], // front
[7,6,5,4], // top
[5,6,2,1], // right
[6,7,3,2], // back
[7,4,0,3]]; // left
polyhedron( CubePoints, CubeFaces );
The vertices indexed from 4 to 7 are not on the same face. OpenSCAD will try to slice the rectangle into triangles automatically in this situation because three points must compose a face. (That's why you need a three-legged stool on the uneven ground.) There's no warning message when you render the model.
However, multiple polyhedron operations may generate a warning message. (It seems that OpenSCAD will merge some calculation.)
PolySet has nonplanar faces. Attempting alternate construction
For example:
points = [
[0, 0, 1], [1, 0, 2],
[1, 1, 4], [0, 1, 1],
[0, 0, 2], [1, 0, 3],
[1, 1, 5], [0, 1, 2]
];
points2 = [
[1, 0, 2], [2, 0, 2],
[2, 1, 0], [1, 1, 4],
[1, 0, 3], [2, 0, 3],
[2, 1, 1], [1, 1, 5],
];
faces = [
[0,1,2,3], // bottom
[4,5,1,0], // front
[7,6,5,4], // top
[5,6,2,1], // right
[6,7,3,2], // back
[7,4,0,3] // left
];
polyhedron(points, faces);
polyhedron(points2, faces);
If you delete one of the polyhedron operation in the above code and render, "PolySet has nonplanar faces" won't appear; however, rendering both causes the message. To avoid this problem, we may try to slice a face into triangles by ourselves.
Slicing a face into triangles
For function graphs, it's easy to slice a face into triangles because we are increasing the value of x, y constantly. For example, given the points below.
For any point, we may take its right and upper-right points to compose a triangle.
And, we may take its upper and upper-right points to compose a triangle, too.
Now, we slice a rectangle into two triangles. We can continue this process until slicing all rectangles.
For all [x, y, f(x, y)] points, we group them into groups of three. For each f(x, y) of a triangle, we can use f(x, y) - thickness to create a bottom face. After that, we can use the polyhedron module to draw it.
Follow the same process for all triangles, you can create a function graph.
points = [
[[0, 0, 1], [1, 0, 2], [2, 0, 2], [3, 0, 3]],
[[0, 1, 1], [1, 1, 4], [2, 1, 0], [3, 1, 3]],
[[0, 2, 1], [1, 2, 3], [2, 2, 1], [3, 2, 3]],
[[0, 3, 1], [1, 3, 3], [2, 3, 1], [3, 3, 3]]
];
thickness = 1;
faces = [
[2, 1, 0],
[3, 4, 5],
[0, 1, 4, 3],
[1, 2, 5, 4],
[2, 0, 3, 5]
];
z_offset = [0, 0, -thickness];
for(yi = [0:len(points) - 2]) {
for(xi = [0:len(points[yi]) - 2]) {
tri1_top = [
points[yi][xi],
points[yi][xi + 1],
points[yi + 1][xi + 1]
];
tri1_bottom = [
tri1_top[0] + z_offset,
tri1_top[1] + z_offset,
tri1_top[2] + z_offset
];
tri2_top = [
points[yi][xi],
points[yi + 1][xi + 1],
points[yi + 1][xi]
];
tri2_bottom = [
tri2_top[0] + z_offset,
tri2_top[1] + z_offset,
tri2_top[2] + z_offset
];
polyhedron(
points = concat(tri1_top, tri1_bottom),
faces = faces
);
polyhedron(
points = concat(tri2_top, tri2_bottom),
faces = faces
);
}
}
The built-in concat module returns a vector containing the arguments of the given vectors. The preview is as below.
The code below also shows to use a mathematical function to draw a graph.
function f(x, y) = (pow(y,2)/pow(2, 2))-(pow(x,2)/pow(2, 2));
min_value = -3;
max_value = 3;
resolution = 0.5;
thickness = 1;
points = [
for(y = [min_value:resolution:max_value])
[
for(x = [min_value:resolution:max_value])
[x, y, f(x, y)]
]
];
faces = [
[2, 1, 0],
[3, 4, 5],
[0, 1, 4, 3],
[1, 2, 5, 4],
[2, 0, 3, 5]
];
z_offset = [0, 0, -thickness];
for(yi = [0:len(points) - 2]) {
for(xi = [0:len(points[yi]) - 2]) {
tri1_top = [
points[yi][xi],
points[yi][xi + 1],
points[yi + 1][xi + 1]
];
tri1_bottom = [
tri1_top[0] + z_offset,
tri1_top[1] + z_offset,
tri1_top[2] + z_offset
];
tri2_top = [
points[yi][xi],
points[yi + 1][xi + 1],
points[yi + 1][xi]
];
tri2_bottom = [
tri2_top[0] + z_offset,
tri2_top[1] + z_offset,
tri2_top[2] + z_offset
];
polyhedron(
points = concat(tri1_top, tri1_bottom),
faces = faces
);
polyhedron(
points = concat(tri2_top, tri2_bottom),
faces = faces
);
}
}
It's smoother than the previous graph created by cubes, right? And, the rendering speed is fast, too.
You may try to improve this example. For example, if you want to draw the mesh of a function graph, how can you do?
In my example code, we slice each rectangle from the bottom-left to the upper-right. How about providing an option to slice from the upper-left to the bottom-right?
