6. Computational Couture¶

M107            // Turn off the cooling fan for the first layer (add by chatGPT)
G90         // Use absolute XYZ coordinates
M83         // Use relative extrusion
M204 P600     // Set printing acceleration at 600mm/s²
G1 Z3 F720  // Move the nozzle 3mm of Z axis at 720mm/min(=12mm/s)
G1 X100 Y100 F3000  // Move the nozzle to X=100 and Y=100 at 3000mm/min(=50mm/s)
G1 Z0.2 F720        // Move the nozzle Z=0.2 
G1 X125 Y100 E0.935 F1200
G1 X125 Y125 E0.935
G1 X100 Y125 E0.935
G1 X100 Y100 E0.935

let sizeSlider, overlapSlider;
let innerCheck, innerSizeSlider;
let lineWidthSlider, heightSlider;
let exportButton;

const MODEL_MM = 100;
const SAMPLE_PX = 2;

function setup() {
  createCanvas(600, 600);

  createP("Circle Size");
  sizeSlider = createSlider(20, 200, 100, 5);

  createP("Overlap (%)");
  overlapSlider = createSlider(0, 90, 50, 5);

  createP("Inner Circle");
  innerCheck = createCheckbox("Show inner circles", false);

  createP("Inner Circle Size (%)");
  innerSizeSlider = createSlider(10, 90, 40, 5);

  createP("Line Width (mm)");
  lineWidthSlider = createSlider(0.8, 5, 1.6, 0.2);

  createP("Height (mm)");
  heightSlider = createSlider(0.6, 5, 1.2, 0.2);

  createP("Export");
  exportButton = createButton("Export 100 x 100 mm STL");
  exportButton.mousePressed(exportSTL);
}

function settings() {
  return {
    diameter: sizeSlider.value(),
    spacing: sizeSlider.value() *
      (1 - overlapSlider.value() / 100),
    ratio: innerSizeSlider.value() / 100,
    inner: innerCheck.checked(),
    linePx: lineWidthSlider.value() * width / MODEL_MM,
    thickness: heightSlider.value()
  };
}

function draw() {
  background(255);

  const s = settings();

  stroke(30, 70, 120);
  strokeWeight(s.linePx);
  noFill();

  for (let x = -s.diameter;
       x <= width + s.diameter;
       x += s.spacing) {

    for (let y = -s.diameter;
         y <= height + s.diameter;
         y += s.spacing) {

      circle(x, y, s.diameter);

      if (s.inner) {
        circle(x, y, s.diameter * s.ratio);
      }
    }
  }
}

// Check whether a point belongs to any circle line
function isPattern(px, py, s) {
  const r = s.diameter / 2;
  const half = s.linePx / 2;
  const reach = r + half;

  const maxIndex = Math.floor(
    (width + 2 * s.diameter) / s.spacing + 1e-8
  );

  const minX = Math.max(0, Math.ceil(
    (px - reach + s.diameter) / s.spacing
  ));
  const maxX = Math.min(maxIndex, Math.floor(
    (px + reach + s.diameter) / s.spacing
  ));

  const minY = Math.max(0, Math.ceil(
    (py - reach + s.diameter) / s.spacing
  ));
  const maxY = Math.min(maxIndex, Math.floor(
    (py + reach + s.diameter) / s.spacing
  ));

  for (let ix = minX; ix <= maxX; ix++) {
    const cx = -s.diameter + ix * s.spacing;

    for (let iy = minY; iy <= maxY; iy++) {
      const cy = -s.diameter + iy * s.spacing;
      const d = Math.hypot(px - cx, py - cy);

      if (Math.abs(d - r) <= half) return true;

      if (s.inner &&
          Math.abs(d - r * s.ratio) <= half) {
        return true;
      }
    }
  }

  return false;
}

function exportSTL() {
  const s = settings();

  const nx = Math.ceil(width / SAMPLE_PX);
  const ny = Math.ceil(height / SAMPLE_PX);

  const grid = new Uint8Array(nx * ny);

  for (let j = 0; j < ny; j++) {
    for (let i = 0; i < nx; i++) {
      const px = (i + 0.5) * width / nx;
      const py = (j + 0.5) * height / ny;

      if (isPattern(px, py, s)) {
        grid[j * nx + i] = 1;
      }
    }
  }

  const dx = MODEL_MM / nx;
  const dy = MODEL_MM / ny;
  const h = s.thickness;

  const triangles = [];

  function filled(x, y) {
    return x >= 0 && y >= 0 &&
      x < nx && y < ny &&
      grid[y * nx + x] === 1;
  }

  function tri(a, b, c) {
    triangles.push([a, b, c]);
  }

  function quad(a, b, c, d) {
    tri(a, b, c);
    tri(a, c, d);
  }

  // Top and bottom surfaces
  for (let y = 0; y < ny; y++) {
    let x = 0;

    while (x < nx) {
      if (!filled(x, y)) {
        x++;
        continue;
      }

      const start = x;

      while (x < nx && filled(x, y)) x++;

      const x0 = start * dx;
      const x1 = x * dx;
      const y0 = y * dy;
      const y1 = (y + 1) * dy;

      // Top
      quad(
        [x0,y0,h], [x1,y0,h],
        [x1,y1,h], [x0,y1,h]
      );

      // Bottom
      quad(
        [x0,y1,0], [x1,y1,0],
        [x1,y0,0], [x0,y0,0]
      );
    }
  }

  // Side walls
  for (let y = 0; y < ny; y++) {
    for (let x = 0; x < nx; x++) {
      if (!filled(x,y)) continue;

      const x0 = x * dx;
      const x1 = (x+1) * dx;
      const y0 = y * dy;
      const y1 = (y+1) * dy;

      if (!filled(x-1,y)) {
        quad(
          [x0,y0,0], [x0,y0,h],
          [x0,y1,h], [x0,y1,0]
        );
      }

      if (!filled(x+1,y)) {
        quad(
          [x1,y0,0], [x1,y1,0],
          [x1,y1,h], [x1,y0,h]
        );
      }

      if (!filled(x,y-1)) {
        quad(
          [x0,y0,0], [x1,y0,0],
          [x1,y0,h], [x0,y0,h]
        );
      }

      if (!filled(x,y+1)) {
        quad(
          [x0,y1,0], [x0,y1,h],
          [x1,y1,h], [x1,y1,0]
        );
      }
    }
  }

  if (!triangles.length) {
    alert("No geometry to export.");
    return;
  }

  saveSTL(triangles);
}

function saveSTL(triangles) {
  const buffer = new ArrayBuffer(
    84 + triangles.length * 50
  );

  const view = new DataView(buffer);
  view.setUint32(80, triangles.length, true);

  let offset = 84;

  function writeFloat(n) {
    view.setFloat32(offset, n, true);
    offset += 4;
  }

  for (const t of triangles) {
    const [a,b,c] = t;

    const u = b.map((v,i) => v-a[i]);
    const v = c.map((n,i) => n-a[i]);

    let normal = [
      u[1]*v[2]-u[2]*v[1],
      u[2]*v[0]-u[0]*v[2],
      u[0]*v[1]-u[1]*v[0]
    ];

    const len = Math.hypot(...normal) || 1;
    normal = normal.map(n => n/len);

    normal.forEach(writeFloat);

    for (const p of t) {
      p.forEach(writeFloat);
    }

    view.setUint16(offset,0,true);
    offset += 2;
  }

  const blob = new Blob(
    [buffer],
    {type:"application/octet-stream"}
  );

  const url = URL.createObjectURL(blob);
  const a = document.createElement("a");

  a.href = url;
  a.download = "circle_pattern_100x100mm.stl";
  document.body.appendChild(a);
  a.click();
  a.remove();

  setTimeout(() => URL.revokeObjectURL(url),1000);
}