Heart chain with text is one of my hot things. (I also designed Text heart chain which can coil up hearts.)

There are two small rings between hearts. The rings don't overlap so you can print it in place. Before creating these hearts, what should you prepare for such a simple ring? Different people have different thoughts. As for me, it's better to define a module which can draw an arc according to given angles.

Sector

Before defining an arc module, it's better to have a module which can draw a sector. If the built-in circle module can provide an angles parameter, implementing this requirement will be easy. Unfortunately, OpenSCAD doesn't provide it, so it's time to do it yourself.

In Circle, we learned about that you can use triangles to construct a circle. Seriously speaking, this creates a regular polygon. When it comes to the polygon, we know that the built-in polygon module can create a multi-sided shape. If we can calculate every vertex's coordinate of the sector, the polygon module will be able to create a sector, right?

radius = 10;
angles = [45, 135];
points = [
    for(a = [angles[0]:1:angles[1]]) [radius * cos(a), radius * sin(a)]
];
polygon(concat([[0, 0]], points));

As you see, we are right. We draw a sector from 45 to 135 degrees.

I have more to take into consideration. The sector module should provide a $fn parameter, maybe $fa and $fs as well, to be consistent with the circle module. Then, the users of the sector module can use angles to create a sector which looks like being cut from a circle with the given $fn. For example, we can use 0 and 135 degrees to cut a sector from a circle of $fn = 12.

Do you see that? Because $fn is 12, the length of the leftmost side is smaller than others. I deliberately use $fn = 12 to highlight this condition. You can create a circle and difference the unwanted part to obtain the sector.

According to the above idea, we may write a rough implementation.

radius = 20;
angles = [45, 135];
fn = 12;

module sector(radius, angles, fn = 24) {
    step = -360 / fn;

    points = concat([[0, 0]],
        [for(a = [angles[0] : step : angles[1] - 360]) 
            [radius * cos(a), radius * sin(a)]
        ],
        [[radius * cos(angles[1]), radius * sin(angles[1])]]
    );

    difference() {
        circle(radius, $fn = fn);
        #polygon(points);
    }
}

sector(radius, angles, fn);

But, the result is not what we want.

Oh, no! The differenced part is not large enough to cover the edge of the circle. You can create a larger polygon to solve this problem, however, how large should it be? Twice the radius of the circle is surely enough. If you want to have fun with precision, let's do some calculations.

The figure below shows the worst case. One leg of the yellow triangle intersects the base of the red triangle at the middle.

So, the polygon can cover the yellow circle if the radius of the red circle is r derived below.

a = 180 / fn;
r = radius / cos(a);

The modified version of the sector module is here.

radius = 20;
angles = [45, 135];
fn = 24;

module sector(radius, angles, fn = 24) {
    r = radius / cos(180 / fn);
    step = -360 / fn;

    points = concat([[0, 0]],
        [for(a = [angles[0] : step : angles[1] - 360]) 
            [r * cos(a), r * sin(a)]
        ],
        [[r * cos(angles[1]), r * sin(angles[1])]]
    );

    difference() {
        circle(radius, $fn = fn);
        polygon(points);
    }
}

sector(radius, angles, fn);  

We get a sector now.

Arc

Once the sector module is ready, defining an arc module is easy. Just difference a smaller sector from a bigger sector.

radius = 20;
angles = [45, 290];
width = 2;
fn = 24;

module sector(radius, angles, fn = 24) {
    r = radius / cos(180 / fn);
    step = -360 / fn;

    points = concat([[0, 0]],
        [for(a = [angles[0] : step : angles[1] - 360]) 
            [r * cos(a), r * sin(a)]
        ],
        [[r * cos(angles[1]), r * sin(angles[1])]]
    );

    difference() {
        circle(radius, $fn = fn);
        polygon(points);
    }
}

module arc(radius, angles, width = 1, fn = 24) {
    difference() {
        sector(radius + width, angles, fn);
        sector(radius, angles, fn);
    }
} 

linear_extrude(1) arc(radius, angles, width);

We obtain an arc.

Some of my things on Thingiverse needed sectors and arcs. The implementations of sector and arc in them are different from here. That is because they are my early works, some considerations were still immature when designing them.

Writing documents always gives me opportunities to think more about those things. Are there other considerations? Are there better designs?

Writing is not only about writing.