Parabolic reflectors are fascinating. They concentrate incident parallel light or electromagnetic radiation in a focal point. Satellite antennas or solar stoves make use of this property. In the other direction, when a light source sits in the focal point, a parabolic mirror can be used to create a parallel cone of light.
In this project we will create the geometry description for a parabolic reflector.
We will get to know the 3D basic shape polyhedron. It is basically the three-dimensional counterpart of the 2D basic shape polygon. Creating a polyhedron is easy in theory, but quite challenging in practice. Therefore, we will proceed step by step and focus solely on this one novelty in this project.
A parabola is characterized by the fact that all points on the parabolic surface have the same distance to a reference or base surface and a focal point. Figure 11. shows this relation for a single point p of the parabolic surface and the corresponding points b on the base surface and f, the focus point. It can be seen that the points p, b and f form an isosceles triangle and therefore the distance between p and f and the distance between p and b are equal.
If we want to describe the geometry of a parabola, we need to determine the points p of the parabolic surface for a given focal point and a given base plane. If we look again at Figure 11., we see that point p lies vertically above point b. If we think of point b as part of a base surface in the X-Y plane, then we can simply take the X- and Y-coordinates of point p directly from point b. So only the Z-coordinate of p remains to be determined. Here two triangles can help us that are hidden in figure 11.. Both triangles share the angle α. The larger of the two has its hypotenuse from f to b and the adjacent f.z - b.z. The smaller triangle has as its hypotenuse the length p.z and as its adjacent exactly half the distance from f to b (because it is part of the isosceles triangle).
If we remember that cos(α) = adjacent / hypotenuse, it follows for the large triangle:
// distance between f and b
dist_fb = norm(f - b)
cos(α) = (f.z - b.z) / dist_fbFor the small triangle:
cos(α) = (dist_fb / 2) / p.zSince it is the same α in both cases, we can set the two ratios as equal and rearrange them to find the p.z we are looking for:
(f.z - b.z) / dist_fb = (dist_fb / 2) / p.z
// both sides times p.z
p.z * (f.z - b.z) / dist_fb = dist_fb / 2
// both sides divided by ((f.z - b.z) / dist_fb)
p.z = (dist_fb / 2) / ((f.z - b.z) / dist_fb)
// replace outer division by multiplikation with the inverse
p.z = (dist_fb / 2) * (dist_fb / (f.z - b.z))
// multiply out: numerator times numerator, denominator times denominator
p.z = (dist_fb * dist_fb) / (2 * (f.z - b.z))With that, we are done! We now have a compact formula to calculate a point p on the parabolic surface with respect to a focus point and a base point. Let’s capture this result in an OpenSCAD function parabola_point:
function parabola_point( focus_point, base_point ) =
let ( dist_fb = norm(focus_point - base_point) )
[
base_point.x,
base_point.y,
( dist_fb * dist_fb ) / ( 2 * (focus_point.z - base_point.z) )
];After these preparations we can start with the definition of a module parabola and calculate the points on the surface of the parabola with the help of our function parabola_point:
/*
parabola module
- focus_point, focus point as 3D-vector
- base_area, dimension of the base are as 2D-vector
- resolution, number of grid points as 2D-vector
*/
module parabola( focus_point, base_area, resolution = [10, 10] ){
function parabola_point( focus_point, base_point ) =
let ( dist_fb = norm(focus_point - base_point) )
[
base_point.x,
base_point.y,
( dist_fb * dist_fb ) / ( 2 * (focus_point.z - base_point.z) )
];
parabola_points = [
for (
y = [0 : base_area.y / resolution.y : base_area.y + 0.1],
x = [0 : base_area.x / resolution.x : base_area.x + 0.1]
)
parabola_point( focus_point, [x,y,0] )
];
}
parabola(
focus_point = [75,75,100],
base_area = [150,150]
);Our module parabola has three parameters. The parameter focus_point sets the position of the focus point of the parabola as a three-dimensional vector. The parameter base_area sets the dimension of the base surface in the form of a two-dimensional vector. Thus, we assume that our base surface is located with one corner at the origin and lies on the X-Y plane (Z = 0). The third parameter resolution sets the number of individual surfaces in the X- and Y-directions that the parabolic surface should consist of.
Inside the module we calculate the parabola_points as an array of vectors via a generative, two-dimensional for-loop. The step size of the loop variables results from the respective number of partial surfaces (resolution) and the dimension of the base surface (base_area). The addition of a tenth of a millimeter at the respective upper limits of the ranges serves to compensate for rounding errors. It does not mean that the parabola would become one tenth larger. Finally, inside the generative for loop, we use our function parabola_point to calculate each point of the parabola surface.
Since we want to create a three-dimensional body, we still need the points of the base surface itself. We can also create these with a generative for-loop. Instead of using a function like parabola_point, we can specify the three-dimensional vector of the points directly. It consists only of the X- and Y-coordinates and a constant Z-coordinate, which we set to 0:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
parabola_points = [
for (
y = [0 : base_area.y / resolution.y : base_area.y + 0.1],
x = [0 : base_area.x / resolution.x : base_area.x + 0.1]
)
parabola_point( focus_point, [x,y,0] )
];
base_points = [
for (
y = [0 : base_area.y / resolution.y : base_area.y + 0.1],
x = [0 : base_area.x / resolution.x : base_area.x + 0.1]
)
[x, y, 0]
];
}
/* ... */Now we come to a somewhat tricky part. We have to explicitly specify the individual surfaces of our geometry. Each individual surface needs four points, which have to be specified in order. This is basically like trying to trace the outer edge of the surface with a pencil all the way through without starting over. You may remember these puzzle pictures in your childhood. You were given a sheet of paper with numbered dots and then you had to connect the dots one by one to reveal the picture. We’re doing something similar now.
The points in our arrays parabola_points and base_points lie one after another as a long list. Each of these lists contains (resolution.x + 1) * (resolution.y + 1) points. Thus, you can identify each point with a number. Just like the house numbers along a street. With these “house numbers” of the points we can now describe a single surface by combining four “house numbers” in a four-dimensional vector:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
size_x = resolution.x + 1;
parabola_faces = [
for (
y = [0 : resolution.y - 1],
x = [0 : resolution.x - 1]
)
[
y * size_x + x,
y * size_x + x + 1,
(y+1) * size_x + x + 1,
(y+1) * size_x + x
]
];
}
/* ... */Since we have defined our parabola points row by row, the points in the one-dimensional array parabola_points lie accordingly row by row behind each other. The numbers of neighboring points in the X-direction always differ by 1. The numbers of neighboring points in the Y-direction, on the other hand, differ by size_x = resolution.x + 1. In other words, every size_x points in the array parabola_points a new row begins. Figure 11. shows this relationship schematically for a resolution of 5 x 5 surfaces. So in this example resolution.x = 5 and correspondingly size_x = 6. The rows thus start at 0, 6, 12, etc.
So if we want to find the number of the first point of a surface, we first have to calculate the start number of the row (y * size_x) and then add the X-position of the point (+ x). The next point of the surface is right next to it. So you only have to add 1 to the previous number (y * size_x + x + 1). The third point is one row lower (y + 1). Therefore its number is (y + 1) * size_x + x + 1. The fourth point is in the same row before the third point. So we have to subtract 1 again from the number of the third point ((y + 1) * size_x + x). If we repeat this for all surfaces, we get the desired list of parabola_surfaces.
For the surfaces of the base we can proceed in a similar way:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
size_x = resolution.x + 1;
/* ... */
size_ppoints = len( parabola_points );
base_faces = [
for (
y = [0 : resolution.y - 1],
x = [0 : resolution.x - 1]
)
[ y * size_x + x + size_ppoints,
y * size_x + x + 1 + size_ppoints,
(y+1) * size_x + x + 1 + size_ppoints,
(y+1) * size_x + x + size_ppoints]
];
}
/* ... */Since we will later append the base_points to the parabola_points, the numbers of the base points will shift by the number of parabola points. This shift is achieved by adding size_ppoints. Otherwise, nothing changes in the determination of the surfaces.
We have now defined the surfaces of the parabola and the base. What is still missing are the surfaces of the sides. Let’s start with one side:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
size_x = resolution.x + 1;
/* ... */
size_ppoints = len( parabola_points );
/* ... */
side_faces_1 = [
for ( x = [0 : resolution.x - 1] )
[ x,
x + 1,
x + 1 + size_ppoints,
x + size_ppoints ]
];
}
/* ... */For the first side we run only once along the X-direction and connect the points from the array parabola_points with their corresponding points from the array base_points in pairs. Since the numbers of the base_points start at size_ppoints, we find the corresponding additions at points 3 and 4 of the surface.
The opposite side can be described in a similar way. Here we need to shift the numbers so that we do not run along the first row, but along the last row:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
size_x = resolution.x + 1;
/* ... */
size_ppoints = len( parabola_points );
/* ... */
last_row = resolution.y * size_x;
side_faces_2 = [
for ( x = [0 : resolution.x - 1] )
[
last_row + x,
last_row + x + 1,
last_row + x + 1 + size_ppoints,
last_row + x + size_ppoints
]
];
}
/* ... */We achieve this by calculating the starting number of the last row (last_row = resolution.y * size_x;) and adding it at each point of the surface. Otherwise, everything remains the same as for side surface 1.
Now we come to the other two side faces. For these we do not have to run along the outer rows, but along the outer columns:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
size_x = resolution.x + 1;
/* ... */
size_ppoints = len( parabola_points );
/* ... */
side_faces_3 = [
for ( y = [0 : resolution.y - 1] )
[
y * size_x,
(y + 1) * size_x,
(y + 1) * size_x + size_ppoints,
y * size_x + size_ppoints
]
];
last_col = resolution.x;
side_faces_4 = [
for ( y = [0 : resolution.y - 1] )
[
last_col + y * size_x,
last_col + (y + 1) * size_x,
last_col + (y + 1) * size_x + size_ppoints,
last_col + y * size_x + size_ppoints
]
];
}
/* ... */Overall, we see the same scheme for side faces 3 and 4 as for side faces 1 and 2. Side face 4 differs from side face 3 only in that we have shifted the numbers by the starting number of the last column. While the numbers of the points along the X-direction have the distance 1, the numbers of the points along the Y-direction have the distance size_x.
Groking the logic of the numbering of the points is not easy, especially in the beginning. It helps a lot to sketch the geometry on a sheet of paper and to label it with the numbers of the points. Just as it can be seen in figure 11..
Now we have finally gathered enough information to create our geometry with the basic shape polyhedron:
module parabola( focus_point, base_area, resolution = [10, 10] ){
/* ... */
polyhedron(
points = concat( parabola_points, base_points ),
faces = concat( parabola_faces,
base_faces,
side_faces_1,
side_faces_2,
side_faces_3,
side_faces_4)
);
}
/* ... */We use the concat function to concatenate our point and surface sets and pass them as parameters points and faces to the 3D base shape polyhedron. If we now run a preview (F5) we should finally be able to see our parabola.
There are certainly use cases where you don’t want the full body below the parabola. We can adjust our module parabola in one place to provide the possibility to create only the parabola surface itself with a given thickness:
module parabola(
focus_point,
base_area,
resolution = [10, 10],
thickness = 0
){
/* ... */
base_points = [
for (
y = [0 : base_area.y / resolution.y : base_area.y + 0.1],
x = [0 : base_area.x / resolution.x : base_area.x + 0.1]
)
let ( p = parabola_point( focus_point, [x,y,0] ) )
if (thickness > 0)
[x, y, p.z - thickness]
else
[x, y, 0]
];
/* ... */
}
/* ... */For this extension we give our module parabola another parameter thickness, which gets the default value 0. Inside the module we change the calculation of the base points slightly. By means of let we calculate the current parabola point again and keep it in the variable p. Subsequently, we carry out a case distinction. If the parameter thickness is greater than zero, then we create a base point that is exactly thickness away from the parabola point p. Otherwise, if thickness is equal to 0, we create the base point as usual on the X-Y plane.
With this change, we can now create pure parabolic surfaces without a substructure (Figure 11.).
The basic 3D shape polyhedron is certainly not the first choice when you want to describe a 3D geometry with OpenSCAD. Using polyhedron requires some planning and is not free of subtle problems. For example, surfaces may not be displayed correctly. This generally has two possible causes. If the display errors only occur in the preview (F5), but not in the actual render (F6), then increasing the convexity parameter of the basic 3D shape polyhedron can help. By default this parameter has the value 1.
The second cause of errors is a bit more troublesome to fix. This is because the surfaces you have defined are only visible from one direction. If you would look from the inside of the object to the outside, you could see through the surfaces. Which side of the surfaces is visible and which is not depends on the order of the points with which we build up a surface. So a surface with the points [0, 1, 2, 3] or the points [3, 2, 1, 0] differs in whether the front or the back side is visible. A good tool to deal with such problems is to define a function flip which flips the order of the elements in a four-dimensional vector:
function flip(vec) = [ vec[3], vec[2], vec[1], vec[0] ];If the rendering of a set of surfaces is not ok, one can bring the function flip to bear on the definition of the surfaces and see if this solves the problem. This would look like this, for example:
side_faces_1 = [
for ( x = [0 : resolution.x - 1] )
flip ([
x,
x + 1,
x + 1 + size_ppoints,
x + size_ppoints
])
];All in all, you will probably use polyhedron rather rarely. However, it represents a powerful tool with which one can solve difficult modeling tasks.
The further the focal point is away from the parabolic surface, the flatter the surface will become. In such a case, try to print the parabolic surface vertically. This will make the surface of the parabola finer, as 3D printers usually have a higher resolution in the X-Y plane than in the Z-axis.
If you need a parabola with a different outer shape, e.g. round, you can easily achieve such a shape by using the Boolean operation intersection with, e.g., a cylinder.