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
Comment transformer un circuit fonctionnel en motif génératif adapté à la technique de la marqueterie ?
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é
Développement du projet
Après les phases d’exploration initiées lors de la semaine de workshop, la finalité du projet se présentait autant dans la réalisation de la marqueterie, que dans l’application de circuit fonctionnel.
Dans un premier temps, nous avons établi de nouvelles contraintes pour la génération du motifs, portées sur un circuit dérivé à deux branches + et _. Ainsi, les LED se lient entre-elles par deux branches de cuivre marquetées. Dans le motif final, il s’agit plutôt d’une construction linéaire qui met de côté le système de branches utilisés dans le travail précédent. Ce changement relève d’observations réalisées lors de la semaine de workshop, où les motifs ne s’appliquaient pas à un circuit fonctionnel. Il a alors été question de générer de nouveaux motifs fonctionnels.
En complément aux nouvelles contraintes de connexion, la présence de 5 LED, d’une surface on/off et de la connexion à une pile. Nous avons décidé d’appliquer ces contraintes au sein de deux panneaux marquetés.
Approche à la marqueterie
Après la définition du motifs à appliquer à la marqueterie, nous sommes passés à la réalisation de la marqueterie. Pour cela, nous avons utilisé la découpe à assistance numérique du plotter. Dans un second temps, la finition appliquée aux découpes des surfaces de nos différentes essences de placage de bois et des feuilles de cuivre nous a conduit aux assemblages et à l’application des composants électroniques au sein de la marqueterie. Il s’agissait alors d’entreprendre un travail minitieux de collage et de soudure sur les deux panneaux marquetés.
