Circuit marqueté – Madeleine / Basile

Marqueterie lumineuse pensée à la manière d’un circuit imprimé

Ce projet explore la création de motifs algorithmiques à partir d’un moyen technique, l’écriture de code assistée par intelligence artificielle. Il s’agit de générer des motifs à marqueter inspirés des circuits électroniques, caractérisés par une source d’alimentation, des lignes directrices et des points de connexion situés à leurs extrémités.

À partir de cette référence, le projet propose une transcription d’un « motif numérique » vers un support tangible. L’enjeu n’est pas simplement de produire un motif décoratif, mais d’interroger la manière dont une structure fonctionnelle, ici le circuit, peut devenir un langage esthétique.

La matérialisation se fait par un travail de marqueterie, impliquant ses contraintes techniques : finesse de découpe, précision de l’assemblage, et gestion des matériaux. Ces contraintes influencent directement le dessin du motif, introduisant un dialogue entre calcul algorithmique et savoir-faire artisanal.

Contraintes :

• Nombre de sorties lumineuses
• Positionnement des cercles
• Nombre de branches entre chaque cercle
• Inspirations formelle de motifs
• Placement d’une source d’alimentation
• Épaisseur des lignes
• Dimensions de l’image

Le projet intègre également une dimension interactive, un système de lumières (LED) s’allume progressivement, point par point. L’allumage suit une logique de proximité entre les nœuds du circuit, simulant une circulation d’énergie. Chaque interaction (touche, activation) déclenche un changement de LED, créant une animation évolutive du motif.

Enfin, le projet propose une réflexion sur la multiplicité des tracés. Pour une même fonction, alimenter un circuit, il existe une diversité de chemins possibles. Cette variation permet de montrer que des systèmes aux usages identiques peuvent de générer de multiples motifs.

Objectifs du projet :

→ Définir un motif par un code algorythmique qui reprend les tracés d’un circuit imprimé
→ Découpage placage de bois avec outil numérique sans traces de contour (plotter)
→ Intégration de métal conducteur
→ Surface marquetée tactile avec réaction (capteur type interrupteur)

Logique de circulation et génération de formes – du circuit imprimé au motif algorithmique :

L’observation des motifs présents sur les circuits imprimés révèle une organisation à la fois fonctionnelle et visuelle. Ces tracés reposent sur une structure logique : une source d’alimentation initie un flux (source → capteur), relayé par des lignes directrices qui assurent la transmission, jusqu’à des points situés aux extrémités où se manifeste une réaction (comme l’allumage d’une LED). Ce système, pensé pour optimiser la circulation de l’énergie, produit malgré lui des formes graphiques singulières, faites de bifurcations, de connexions et de rythmes.

L’idée est de reprendre cette logique de construction au sein du code, en traduisant ces relations (origine, parcours, activation) en règles algorithmiques. Le motif n’est pas simplement dessiné, mais généré à partir d’un ensemble de contraintes et d’interactions, reproduisant une dynamique proche de celle des circuits. Ainsi, la programmation devient un moyen de faire émerger des formes qui conservent une cohérence structurelle tout en ouvrant vers une diversité de tracés possibles.

-> Schéma récapitulatif – éléments de référence pour la programmation du motif

-> 3 versions finales sélectionnées, ci-dessous le code de programmation pour le motif numéro 1.

Logiciel de programmation de motifs – p5js

let pts = [];
let parent = [];
let segs = [];

let rootIndex;

function setup() {
  createCanvas(600, 800);
  background(255);

  stroke(0);
  noFill();

  randomSeed(millis());

  let center = createVector(500, 750);
  pts.push(center);
  rootIndex = 0;

  pts = pts.concat([
    createVector(100, 500),
    createVector(350, 175),
    createVector(250, 50),
    createVector(400, 600),
    createVector(50, 300),
    createVector(200, 300),
    createVector(500, 300),
    createVector(300, 400),
    createVector(100, 150),
    createVector(150, 750)
  ]);

  buildTree();

  for (let i = 0; i < pts.length; i++) {
    if (parent[i] === -1) continue;

    let a = pts[i];
    let b = pts[parent[i]];

    drawTripleSafe(a, b);
  }

  fill(0);
  noStroke();

  for (let i = 0; i < pts.length; i++) {
    let p = pts[i];

    if (i === rootIndex) {
      rectMode(CENTER);
      rect(p.x, p.y, 50, 50);
    } else {
      circle(p.x, p.y, 40);
    }
  }
}

//////////////////////////////////////////////////////
// ARBRE
//////////////////////////////////////////////////////
function buildTree() {
  parent = new Array(pts.length).fill(-1);

  let root = rootIndex;
  let connected = [root];
  let remaining = [];

  for (let i = 0; i < pts.length; i++) {
    if (i !== root) remaining.push(i);
  }

  while (remaining.length > 0) {
    let options = [];

    for (let a of connected) {
      for (let b of remaining) {
        let d = dist(pts[a].x, pts[a].y, pts[b].x, pts[b].y);
        d *= random(1.0, 1.4);
        options.push({ a, b, d });
      }
    }

    options.sort((x, y) => x.d - y.d);

    let k = Math.min(3, options.length);
    let choice = options[floor(random(k))];

    parent[choice.b] = choice.a;

    connected.push(choice.b);
    remaining = remaining.filter(x => x !== choice.b);
  }
}

//////////////////////////////////////////////////////
// 3 LIGNES SANS CROISEMENT
//////////////////////////////////////////////////////
function drawTripleSafe(a, b) {
  let dir = p5.Vector.sub(b, a);
  let len = dir.mag();
  if (len === 0) return;

  dir.normalize();

  let normal = createVector(-dir.y, dir.x);

  let spacing = 50;
  let offsets = [-spacing, 0, spacing];

  for (let k = 0; k < 3; k++) {
    strokeWeight(6);

    let path = safeRoute(a, b, normal, offsets[k]);

    drawPath(path);
    register(path);
  }
}

//////////////////////////////////////////////////////
// COURBE CONTRÔLÉE (ANTI CROISEMENT)
//////////////////////////////////////////////////////
function safeRoute(a, b, normal, offset) {
  let path = [];

  let steps = 25;

  // couloir strict = base + offset fixe
  let lane = p5.Vector.mult(normal, offset);

  // contrôle de courbure limité
  let curveAmp = 10;

  let mid = p5.Vector.lerp(a, b, 0.50);

  // point de contrôle UNIQUE par ligne
  let control = mid.copy();

  // petite variation MAIS dans le couloir uniquement
  let jitter = p5.Vector.mult(normal, random(-curveAmp, curveAmp));
  control.add(lane);
  control.add(jitter);

  for (let t = 0; t <= steps; t++) {
    let n = t / steps;

    let x = bezierPoint(a.x, control.x, control.x, b.x, n);
    let y = bezierPoint(a.y, control.y, control.y, b.y, n);

    path.push(createVector(x, y));
  }

  return path;
}

//////////////////////////////////////////////////////
// dessin
//////////////////////////////////////////////////////
function drawPath(path) {
  beginShape();
  for (let p of path) {
    vertex(p.x, p.y);
  }
  endShape();
}

//////////////////////////////////////////////////////
// stockage
//////////////////////////////////////////////////////
function register(path) {
  for (let i = 0; i < path.length - 1; i++) {
    segs.psh({ a: path[i], b: path[i + 1] });
  }

-> Essais de marqueterie et d’Arduino – semaine de Workshop

-> Visualisation effet souhaité – suite à venir