Cat guard for plant pots

// A round grid that lies on the soil of a plant pot to keep cats out. Split into loose
// segments so it fits around an existing plant, with cone spikes underneath to pin it
// into the soil. Everything is drawn in 2D from circles and strokes and extruded once;
// rounding is one offset pass over the finished drawing, as a final polish.

/* [Size] */
// Outer diameter of the guard. Match it to the inside of the pot.
diameter = 200; // [80:5:400]
// Diameter of the hole in the middle, around the stem.
hole_d = 40; // [10:2:200]
// Thickness of the plate.
thickness = 3; // [2:0.5:6]
// Width of the bars.
bar_w = 3; // [2:0.5:8]

/* [Grid] */
// Concentric rings, counting the rim around the hole and the outer rim.
rings = 4; // [2:1:10]
// even: rings at equal distance. square: geometric, so every cell keeps the same shape.
ring_spacing = "square"; // [even, square]
// Spokes per segment: one edge spoke plus the spokes inside the segment.
spokes_per_segment = 4; // [1:1:10]
// Add a spoke between every pair from this ring outward (0 = outer rim). 0 turns it off.
outer_spokes_from = 2; // [0:1:9]
// Degrees a spoke turns between hole and rim. Zero gives straight spokes.
swirl = 30; // [-120:5:120]

/* [Split] */
// Number of segments the guard is cut into.
segments = 4; // [2, 3, 4]
// Width of the cut between the two edge spokes of neighbouring segments.
gap = 1; // [0.5:0.1:3]
// parallel: edge spokes shifted beside the cut, constant gap. radial: pointing at the centre.
edge_mode = "parallel"; // [parallel, radial]
// The whole guard, or one segment flipped into print orientation.
part = "all"; // [all, one]

/* [Spikes] */
// Length of the spikes below the plate. Zero removes them.
spike_len = 25; // [0:1:60]
// Diameter of a spike at its base.
spike_w = 4; // [2:0.5:10]
// A spike on every n-th ring, counted from the outer rim inward.
spike_ring_step = 2; // [1:1:5]
// A spike on every n-th spoke, counted from the edge spoke of each segment.
spike_spoke_step = 2; // [1:1:6]

/* [Polish] */
// Radius the bar corners are rounded to. Zero keeps them sharp.
round_r = 0.5; // [0:0.25:2]

/* [Quality] */
// Facets on the rings. More is smoother and slower.
smoothness = 96; // [32:16:192]

/* [Colour] */
// Display only, the STL carries no colour.
color_grid = "ForestGreen"; // [ForestGreen, Silver, Gainsboro, White, DimGray, Black, SlateGray, FireBrick, SteelBlue, Goldenrod]

/* [Hidden] */
hole = min(hole_d, diameter - 4 * bar_w - 10);
r_out = diameter / 2 - bar_w / 2;   // centre line of the outer rim
r_in = hole / 2 + bar_w / 2;         // centre line of the rim around the hole
spokes = segments * spokes_per_segment;
seg_a = 360 / segments;
edge_off = (gap + bar_w) / 2;                       // sideways shift of a parallel edge spoke
delta = asin(min(0.9, (gap + bar_w) / (2 * r_in))); // rotation of a radial edge spoke
split_ring = min(outer_spokes_from, rings - 1);
steps = swirl == 0 ? 1 : 24;
r_polish = min(round_r, bar_w / 2 - 0.3, gap / 2 - 0.1);

// Ring i, with 0 the outer rim and rings-1 the rim around the hole.
function ring_r(i) = ring_spacing == "square"
  ? r_out * pow(r_in / r_out, i / (rings - 1))
  : r_out - i * (r_out - r_in) / (rings - 1);
// Spoke j: its base angle, and whether it lies on a cut.
function spoke_a(j) = j * 360 / spokes;
function on_cut(j) = j % spokes_per_segment == 0;
// Sides a spoke is drawn on: two bars beside a cut, one bar elsewhere.
function spoke_sides(j) = on_cut(j) ? [-1, 1] : [0];

// ---- Paths ----
// A spoke of base angle a follows theta(a, r): straight, or turning by swirl from hole to rim.
function tt(r) = max(0, min(1, (r - r_in) / (r_out - r_in)));
function theta(a, r) = a + swirl * tt(r);
function dtheta(r) = (r > r_in && r < r_out) ? swirl * PI / 180 / (r_out - r_in) : 0;
function tangent_a(a, r) = theta(a, r) + atan(r * dtheta(r));
function polar(r, a) = r * [cos(a), sin(a)];
function nrm(a, r) = let(f = tangent_a(a, r)) [-sin(f), cos(f)];
// Point on spoke a, side s (-1, 0, 1), at radius r.
function pt(a, s, r) = edge_mode == "radial"
  ? polar(r, theta(a + s * delta, r))
  : polar(r, theta(a, r)) + s * edge_off * nrm(a, r);
function path(a, s, r0, r1, n) = [for (k = [0 : n]) pt(a, s, r0 + (r1 - r0) * k / n)];
function reverse(v) = [for (i = [len(v) - 1 : -1 : 0]) v[i]];

// A stroke of width w along a list of points.
module stroke(pts, w) {
  for (k = [0 : len(pts) - 2])
    hull() {
      translate(pts[k]) circle(d = w, $fn = 16);
      translate(pts[k + 1]) circle(d = w, $fn = 16);
    }
}

// The polish: a closing pass rounds the concave corners, an opening pass the convex ones.
module polish2d(r) {
  if (r > 0)
    offset(r = r, $fn = 24) offset(r = -2 * r, $fn = 24) offset(r = r, $fn = 24) children();
  else
    children();
}

// ---- Grid pattern ----
// Rings, the spokes inside the segments and the extra outer spokes. The edge spokes are
// added after the cuts, see body2d.
module grid_core2d() {
  for (i = [0 : rings - 1])
    difference() {
      circle(r = ring_r(i) + bar_w / 2, $fn = smoothness);
      circle(r = ring_r(i) - bar_w / 2, $fn = smoothness);
    }
  for (j = [0 : spokes - 1])
    if (!on_cut(j))
      stroke(path(spoke_a(j), 0, r_in, r_out, steps), bar_w);
  if (outer_spokes_from > 0)
    for (j = [0 : spokes - 1])
      stroke(path(spoke_a(j) + 180 / spokes, 0, ring_r(split_ring), r_out, steps), bar_w);
}

module edge_spokes2d() {
  for (j = [0 : spokes - 1], s = spoke_sides(j))
    if (s != 0)
      stroke(path(spoke_a(j), s, r_in, r_out, steps), bar_w);
}

// Width of the cut at radius r: the gap, or the wedge between two radial edge spokes.
function cut_w(r) = (edge_mode == "radial" ? max(gap, 2 * r * sin(delta) - bar_w * cos(delta)) : gap) + 0.4;

module cuts2d() {
  R = diameter / 2 + 5;
  n = 24;
  for (k = [0 : segments - 1]) {
    a = spoke_a(k * spokes_per_segment);
    for (m = [0 : n - 1])
      hull() {
        translate(pt(a, 0, R * m / n)) circle(d = cut_w(R * m / n), $fn = 16);
        translate(pt(a, 0, R * (m + 1) / n)) circle(d = cut_w(R * (m + 1) / n), $fn = 16);
      }
  }
}

// ---- Plate ----
module body2d() {
  polish2d(r_polish)
    union() {
      difference() { grid_core2d(); cuts2d(); }
      edge_spokes2d();
    }
}

// One segment: the wedge between cut 0 and cut 1, following the cut paths.
module wedge2d() {
  R = diameter / 2 + 8;
  a0 = spoke_a(0);
  a1 = spoke_a(spokes_per_segment);
  polygon(concat(
    [[0, 0]],
    path(a0, 0, 0.5, R, 24),
    [for (a = [theta(a0, R) : 2 : theta(a1, R)]) polar(R, a)],
    reverse(path(a1, 0, 0.5, R, 24))));
}

module plate() {
  linear_extrude(height = thickness)
    if (part == "one") intersection() { body2d(); wedge2d(); }
    else body2d();
}

// ---- Spikes ----
// Plain cones hanging below the plate at ring/spoke crossings, clipped to the outer
// diameter so nothing sticks out past the rim.
module spike() {
  translate([0, 0, 0.5]) mirror([0, 0, 1])
    cylinder(h = spike_len + 0.5, d1 = spike_w, d2 = 0.6, $fn = 24);
}

module spikes() {
  if (spike_len > 0)
    intersection() {
      for (i = [0 : rings - 1], j = [0 : spokes - 1], s = spoke_sides(j))
        if (i % spike_ring_step == 0 && j % spike_spoke_step == 0)
          translate(pt(spoke_a(j), s, ring_r(i))) spike();
      translate([0, 0, -spike_len - 1])
        linear_extrude(height = spike_len + 2)
          if (part == "one") intersection() { circle(d = diameter, $fn = smoothness); wedge2d(); }
          else circle(d = diameter, $fn = smoothness);
    }
}

// ---- Layout ----
if (part == "one") {
  // Flipped onto its plate side, spikes up: the print orientation.
  color(color_grid) rotate(-seg_a / 2) translate([0, 0, thickness]) mirror([0, 0, 1]) {
    plate();
    spikes();
  }
} else {
  color(color_grid) { plate(); spikes(); }
}