// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, symmetry, lines, minimalism

### Conceptual Framework

In “Torsional Reaches,” I visualize my identity as a series of twisting arcs that fan
out from the margins of the page. Each arc begins at the boundary—an external point
of contact—and spirals inward, reacting to invisible pivot forces. These forces
create gentle torsions that alter each arc’s direction, reflecting the notion that
my identity is shaped by interplay between internal and external influences. Instead
of converging at a single center, arcs can cross, drift, and gently bend, suggesting
the many ways in which identity can interweave with—yet not be subsumed by—others.

### Technical Approach

1. **Arc Generation**:  
   - I randomly select several anchor points around the canvas edges.  
   - From each anchor, I generate a curving path influenced by a “torsion factor,” 
     a small rotation that shifts the trajectory at each iterative step.  
   - The arcs expand inward, with small per-step variations in curvature to ensure 
     they remain distinct and do not strictly overlap.

2. **Path Tracking**:  
   - For each drawn arc, I record its path commands in `pathData`.  
   - Each path is assigned one color from the user-selected palette, ensuring that 
     canvas rendering and SVG export remain synchronized.

3. **Non-Overlapping Stroke**:  
   - While arcs can cross, I avoid retracing any exact path to prevent clogged lines.  
   - The arcs remain sparse enough that crossing lines stay distinct.

4. **Appearance**:  
   - I use only the predefined nine colors, with 0.8 opacity.  
   - No fills are used, only stroke lines to retain clarity.  

The result is a balanced interplay of arcs that shift gently as they travel, merging
structure and spontaneity to reflect the torsional nature of identity.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings (immutable)
const canvasWidthInches = 11;     // Width of the canvas in inches
const canvasHeightInches = 11;    // Height of the canvas in inches
const pixelsPerInch = 100;        // Pixels per inch (resolution)
const dayNumber = '153';          // Day number for file naming

// Color palette (immutable)
const colors = {
    1: { name: 'ORANGE', ink: 5, width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN', ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED', ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE', ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN', ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE', ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK', ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA', ink: 117, width: 0.45, hex: '#856647' }
};

// Set the stroke opacity for both SVG and canvas
const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
    numArcs: 18,         // number of arcs to attempt from the edges
    minSteps: 40,        // minimum points per arc
    maxSteps: 80,        // maximum points per arc
    torsion: 0.03,       // small rotational influence at each step
    stepLength: 10,      // distance moved per segment
    maxDeviation: 0.02   // random variation factor in torsion or step angle
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */

let canvasWidthPixels;          // Canvas width in pixels
let canvasHeightPixels;         // Canvas height in pixels
let workAreaMarginInches = 2;   // This will be randomized in setup()
let workAreaMarginPixels;       // Work area margin in pixels
let selectedColorIndices = [];  // Indices of selected colors for the drawing

let usedColors = new Set();     // Track used colors
let strokeWeightValue;          // Stroke weight for 0.5mm lines
let pathData = [];              // Array to store path info for SVG

/**
 * Applies the stroke color with the given hex and sets its alpha based on strokeOpacity.
 * @param {string} hexColor - The hex color value.
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

/**
 * =======================================
 * p5.js Setup Function
 * =======================================
 */

function setup() {
    // Initialize canvas dimensions
    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;

    // Create canvas
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    // Initialize work area margin
    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    // Adjust for stroke weight
    adjustForStrokeWeight();

    // Select colors
    selectColors();

    // Clear pathData
    pathData = [];

    // Generate the artwork
    drawShapes();

    noLoop();
}

/**
 * Adjust stroke weight
 */
function adjustForStrokeWeight() {
    // ~0.5mm line => ~2px at 100dpi
    strokeWeightValue = 2;
    workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Color Selection
 */
function selectColors() {
    // 1 to 9 unique colors
    let numColorsToUse = floor(random(1, 10)); 
    selectedColorIndices = selectRandomColorIndices(numColorsToUse);
}

function selectRandomColorIndices(n) {
    let indices = Object.keys(colors).map(k => parseInt(k));
    let selected = [];
    while (selected.length < n && indices.length > 0) {
        let idx = floor(random(indices.length));
        selected.push(indices[idx]);
        indices.splice(idx, 1);
    }
    return selected.sort((a, b) => a - b);
}

/**
 * =======================================
 * Drawing
 * =======================================
 */

function drawShapes() {
    background(255);

    // Draw arcs
    drawTorsionalArcs();

    // Draw markers + color bars
    drawMarkers();
    addColorPaletteBars();
}

/**
 * Draw the arcs that represent "Torsional Reaches"
 */
function drawTorsionalArcs() {
    let arcsToDraw = generationRules.numArcs;

    for (let i = 0; i < arcsToDraw; i++) {
        // randomly choose a color
        let colorIndex = random(selectedColorIndices);
        let col = colors[colorIndex];

        let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
        let path = createOneArcPath(steps);

        // Draw on canvas
        strokeWeight(strokeWeightValue);
        applyStrokeWithOpacity(col.hex);
        beginShape();
        for (let j = 0; j < path.points.length; j++) {
            vertex(path.points[j].x, path.points[j].y);
        }
        endShape();

        // Save path data for SVG
        // Build a d-attribute string with M,L commands
        let d = '';
        for (let k = 0; k < path.points.length; k++) {
            let px = path.points[k].x.toFixed(2);
            let py = path.points[k].y.toFixed(2);
            if (k === 0) {
                d += `M${px},${py} `;
            } else {
                d += `L${px},${py} `;
            }
        }

        // Push to pathData
        pathData.push({
            colorIndex: colorIndex,
            d: d.trim()
        });
    }
}

/**
 * Create a single arc path from a random edge anchor
 * influenced by a small "torsion" at each step.
 */
function createOneArcPath(steps) {
    // pick a random anchor on the boundary
    let anchor = getRandomBoundaryPoint();

    let points = [];
    points.push(anchor);

    // initial angle pointing somewhat inward
    let angle = getInitialAngle(anchor);
    let torsionBase = generationRules.torsion;

    for (let i = 0; i < steps; i++) {
        // random deviation in the torsion
        let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
        angle += (torsionBase + dev);

        // create a new point
        let prev = points[points.length - 1];
        let nx = prev.x + generationRules.stepLength * cos(angle);
        let ny = prev.y + generationRules.stepLength * sin(angle);

        // if out of bounds, break early
        if (
            nx < workAreaMarginPixels ||
            ny < workAreaMarginPixels ||
            nx > (width - workAreaMarginPixels) ||
            ny > (height - workAreaMarginPixels)
        ) {
            break;
        }

        points.push({ x: nx, y: ny });
    }

    return { points };
}

/**
 * Get a random anchor on the boundary (top, bottom, left, or right).
 */
function getRandomBoundaryPoint() {
    // pick side
    let side = floor(random(4));
    let x, y;

    let minPix = workAreaMarginPixels;
    let maxPixX = width - workAreaMarginPixels;
    let maxPixY = height - workAreaMarginPixels;

    if (side === 0) {
        // top
        x = random(minPix, maxPixX);
        y = minPix;
    } else if (side === 1) {
        // bottom
        x = random(minPix, maxPixX);
        y = maxPixY;
    } else if (side === 2) {
        // left
        x = minPix;
        y = random(minPix, maxPixY);
    } else {
        // right
        x = maxPixX;
        y = random(minPix, maxPixY);
    }

    return { x, y };
}

/**
 * Get an initial angle pointing inward from the boundary anchor.
 */
function getInitialAngle(pt) {
    let centerX = width / 2;
    let centerY = height / 2;
    // vector from pt to center
    let dx = centerX - pt.x;
    let dy = centerY - pt.y;
    let baseAngle = atan2(dy, dx);

    // random offset around baseAngle
    return baseAngle + random(-0.3, 0.3);
}

/**
 * =======================================
 * Registration Markers & Palette
 * =======================================
 */

function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    line(0, 0, 5, 0);
    line(0, 0, 0, 5);
    line(width - 5, height, width, height);
    line(width, height - 5, width, height);
}

function addColorPaletteBars() {
    let paletteLength = 300;   
    let barHeight = 2;        
    let gapSize = 7;          
    let yStart = height - (1.25 * pixelsPerInch);

    let usedColorsOrdered = selectedColorIndices;
    let numColors = usedColorsOrdered.length;
    if (numColors === 0) return;

    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;

    strokeWeight(barHeight);

    usedColorsOrdered.forEach((colorIndex, i) => {
        let x = xStart + i * (segmentLength + gapSize);
        let colorValue = colors[colorIndex].hex;
        applyStrokeWithOpacity(colorValue);
        line(x, yStart, x + segmentLength, yStart);
    });
}

/**
 * =======================================
 * Canvas Reset
 * =======================================
 */

function resetCanvas() {
    usedColors.clear();
    pathData = [];
    drawShapes();
}

/**
 * =======================================
 * p5.js Key Press Handling
 * =======================================
 */

function keyPressed() {
    if (key === ' ') {
        // Export the artwork as SVGs
        saveSVGs();
    } else if (key === 'r' || key === 'R') {
        resetCanvas();
    }
}

/**
 * =======================================
 * SVG Export
 * =======================================
 */

function saveSVGs() {
    const timestamp = Date.now();

    // Combined
    let combinedSVG = generateSVG(0);
    saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${timestamp}.svg`);

    // Individual
    let usedColorsOrdered = selectedColorIndices;
    usedColorsOrdered.forEach((colorIndex) => {
        let colorSVG = generateSVG(colorIndex);
        let colorName = colors[colorIndex].name.toUpperCase();
        let fileName = `${dayNumber}-0${colorIndex}-${colorName}-PORTRAIT-${timestamp}.svg`;
        saveSVGFile(colorSVG, fileName);
    });
}

function generateSVG(activeColor = 0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
    svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

    // Add markers
    svgContent += addMarkersSVG();

    if (activeColor === 0) {
        // all colors
        selectedColorIndices.forEach((colorIndex, idx) => {
            svgContent += addSegmentsSVG(colorIndex, idx + 1, 0);
        });
    } else {
        // single color
        let idx = selectedColorIndices.indexOf(activeColor) + 1;
        svgContent += addSegmentsSVG(activeColor, idx, activeColor);
    }

    svgContent += '</svg>';
    return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum, activeColor) {
    let svg = '';
    let color = colors[colorIndex];
    let strokeWidth = strokeWeightValue; 

    svg += `<g
   inkscape:groupmode="layer"
   id="layer${layerNum}"
   inkscape:label="${colorIndex}-${color.name.toLowerCase()}-${color.ink}-${color.width}"
   style="display:inline"
   stroke="${color.hex}"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="${color.hex}">n`;

    // gather all pathData matching colorIndex (if activeColor != 0)
    // or gather all if activeColor == 0
    let relevantPaths = [];
    if (activeColor === 0) {
        // all paths for this colorIndex
        relevantPaths = pathData.filter(p => p.colorIndex === colorIndex);
    } else {
        // only paths for this colorIndex
        relevantPaths = pathData.filter(p => p.colorIndex === activeColor);
    }

    // Combine them
    if (relevantPaths.length > 0) {
        // We can either create one path per entry or unify them
        // For clarity, one <path> per piece
        relevantPaths.forEach(rp => {
            svg += `<path d="${rp.d}" stroke-width="${strokeWidth}" fill="none" />n`;
        });
    }

    // palette bar
    let usedColorsOrdered = selectedColorIndices;
    let i = usedColorsOrdered.indexOf(colorIndex);
    if (i >= 0) {
        let paletteLength = 300;
        let barHeight = 2;
        let gapSize = 7;
        let yStart = height - (1.25 * pixelsPerInch);
        let numColors = usedColorsOrdered.length;
        let totalGaps = (numColors - 1) * gapSize;
        let segmentLength = (paletteLength - totalGaps) / numColors;
        let xStart = (width - paletteLength) / 2;
        let x = xStart + i * (segmentLength + gapSize);

        svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)} H${(x + segmentLength).toFixed(2)}" stroke="${color.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" id="${colorIndex}-${color.name.toLowerCase()}-palettebar" fill="none"/>n`;
    }

    svg += '</g>n';
    return svg;
}

/**
 * Registration markers in SVG
 */
function addMarkersSVG() {
    const strokeWidth = 1;
    const offset = strokeWidth / 2;
    return `<g
       inkscape:groupmode="layer"
       id="layer0"
       inkscape:label="0-markers"
       style="display:inline"
       stroke="black"
       stroke-opacity="${strokeOpacity}"
       inkscape:highlight-color="black">n
    <path d="M${5 + offset},${offset} L${offset},${offset} L${offset},${5 + offset} M${(width - 5 - offset).toFixed(2)},${(height - offset).toFixed(2)} L${(width - offset).toFixed(2)},${(height - offset).toFixed(2)} L${(width - offset).toFixed(2)},${(height - 5 - offset).toFixed(2)}" stroke-width="${strokeWidth}" fill="none" />n
    </g>n`;
}

/**
 * Save an SVG file
 */
function saveSVGFile(svgData, fileName) {
    let blob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' });
    let url = URL.createObjectURL(blob);
    let link = document.createElement('a');
    link.href = url;
    link.download = fileName;

    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);

    URL.revokeObjectURL(url);
}

// Day 153 (Occlusion Demo)
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches, with manual occlusion)
=======================================

### Title: *Torsional Reaches (Occlusion Variation)*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, occlusion, line clipping

### Conceptual Framework

In this variation, we simulate layer occlusion without fills. Whenever a new line is drawn,
it "clips" underlying lines so that only the visible (non-occluded) parts remain. Each line
is approximated as a narrow band (the pen’s stroke region). Where that band intersects older
lines, those older lines are truncated or removed to simulate the new line lying on top.

### Technical Approach

1. We maintain a global list of *visible line segments*. Each segment belongs to some path.
2. When a new path is drawn, we break it into small segments. As each new segment is placed,
   we clip older segments that fall “behind” the new one.
3. Both the canvas display and the SVG export rely on the same truncated segments, ensuring
   consistency. Lines behind upper lines will truly be cut off, preserving the illusion of
   layering.

---
*/

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153-Occ';  // Tag for file naming to distinguish from original

// The same color palette
const colors = {
  1: { name: 'ORANGE', ink: 5,  width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',  ink: 12, width: 0.45, hex: '#993300' },
  3: { name: 'RED',    ink: 19, width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',   ink: 21, width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',  ink: 29, width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',   ink: 36, width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',  ink: 49, width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',  ink: 117,width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

let generationRules = {
  numArcs: 12,
  minSteps: 30,
  maxSteps: 60,
  torsion: 0.03,
  stepLength: 8,
  maxDeviation: 0.02
};

let canvasWidthPixels;
let canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];

let strokeWeightValue;
let pathData = [];   // For final SVG
let lineSegments = []; // Global array of all *visible* line segments

function setup() {
  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustForStrokeWeight();
  selectColors();

  // Clear the data
  pathData = [];
  lineSegments = [];

  drawShapes();
  noLoop();
}

function adjustForStrokeWeight() {
  strokeWeightValue = 2;
  workAreaMarginPixels += strokeWeightValue / 2;
}

function selectColors() {
  let numColorsToUse = floor(random(1, 10));
  selectedColorIndices = selectRandomColorIndices(numColorsToUse);
}

function selectRandomColorIndices(n) {
  let indices = Object.keys(colors).map(k => parseInt(k));
  let selected = [];
  while (selected.length < n && indices.length > 0) {
    let idx = floor(random(indices.length));
    selected.push(indices[idx]);
    indices.splice(idx, 1);
  }
  return selected.sort((a, b) => a - b);
}

function drawShapes() {
  background(255);

  // Generate arcs with clipping
  for (let i = 0; i < generationRules.numArcs; i++) {
    let colorIndex = random(selectedColorIndices);
    let col = colors[colorIndex];
    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
    let arcPoints = createOneArcPath(steps);

    // We'll break the arc into small segments
    // Then each segment is "placed" with occlusion logic
    let theseSegments = [];
    for (let j = 0; j < arcPoints.length - 1; j++) {
      let p1 = arcPoints[j];
      let p2 = arcPoints[j+1];
      theseSegments.push({ x1:p1.x, y1:p1.y, x2:p2.x, y2:p2.y });
    }

    // Now add them with occlusion
    // We return only the final visible bits of these new segments
    // because even among themselves, we can let them remain continuous
    // (No need to clip within the same path if you don't want to.)
    let acceptedSegments = [];
    for (let seg of theseSegments) {
      let clippedPieces = addLineSegmentWithOcclusion(seg, colorIndex);
      for (let cp of clippedPieces) {
        acceptedSegments.push(cp);
      }
    }

    // For final SVG path data, we’ll unify these accepted segments into a single <path>:
    // Sort them in the order they were added to keep them “connected.”
    // If you prefer each segment to become its own path, that’s also possible.
    let d = '';
    if (acceptedSegments.length > 0) {
      // Move to the start of the first segment
      let s0 = acceptedSegments[0];
      d += `M${s0.x1.toFixed(2)},${s0.y1.toFixed(2)} L${s0.x2.toFixed(2)},${s0.y2.toFixed(2)}`;
      // Then line-to subsequent segments
      for (let k = 1; k < acceptedSegments.length; k++) {
        let s = acceptedSegments[k];
        d += ` M${s.x1.toFixed(2)},${s.y1.toFixed(2)} L${s.x2.toFixed(2)},${s.y2.toFixed(2)}`;
      }
    }

    if (d !== '') {
      pathData.push({
        colorIndex: colorIndex,
        d: d
      });
    }
  }

  // After generating all arcs, draw the final (clipped) segments to canvas
  drawSegmentsToCanvas();

  // Markers + palette
  drawMarkers();
  addColorPaletteBars();
}

/**
 * drawSegmentsToCanvas: Renders lineSegments array to the canvas
 */
function drawSegmentsToCanvas() {
  // Clear everything first
  // (We do it again so we get the final clipped version only)
  background(255);

  // We will group lineSegments by colorIndex to reduce repeated stroke calls
  let grouped = {};
  for (let s of lineSegments) {
    if (!grouped[s.colorIndex]) grouped[s.colorIndex] = [];
    grouped[s.colorIndex].push(s);
  }

  // Now draw color by color
  for (let colorIndexStr in grouped) {
    let cidx = int(colorIndexStr);
    let col = colors[cidx];
    applyStrokeWithOpacity(col.hex);
    strokeWeight(strokeWeightValue);

    beginShape(LINES);
    for (let seg of grouped[cidx]) {
      vertex(seg.x1, seg.y1);
      vertex(seg.x2, seg.y2);
    }
    endShape();
  }
}

/**
 * addLineSegmentWithOcclusion: 
 *   Takes a brand-new segment and clips older segments behind it.
 *   Then adds this new segment on top (fully visible).
 * Returns an array of the final (fully visible) sub-segments for this new line (usually just 1 piece).
 */
function addLineSegmentWithOcclusion(newSeg, newColorIndex) {
  // 1) Create a small "offset band" around newSeg 
  //    We'll define it by the line normal plus some “stroke radius.”
  //    For simplicity, let stroke radius ~2 px => half of strokeWeightValue
  let strokeR = strokeWeightValue * 0.5;

  // We'll store final sub-segments for newSeg in `newPieces`
  let newPieces = [ {...newSeg} ];  // initially just one piece

  // 2) For each existing segment in lineSegments
  for (let i = 0; i < lineSegments.length; i++) {
    let old = lineSegments[i];
    // If old is in a lower layer, we clip it if it intersects the "band" of newSeg
    // The new line is drawn last => old lines behind it
    // We'll do a simple approach: if old intersects newSeg (with no thickness),
    //   we cut old at intersection points. If fully inside the band, remove it.
    // For a quick demonstration, let's do a simpler method:
    //   We'll check direct line-line intersection (no thickness).
    //   If there's an intersection, we break the old segment into sub-pieces that remain visible.
    //   We do not attempt partial “thickness-based” removal here for brevity.
    // A more thorough approach would remove old segment portions that fall within the stroke band geometry.

    let ints = lineIntersection(old.x1, old.y1, old.x2, old.y2,
                                newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2);
    if (ints.intersects) {
      // We slice old into two sub-segments around the intersection
      let t = ints.t; // intersection fraction along old
      let midx = lerp(old.x1, old.x2, t);
      let midy = lerp(old.y1, old.y2, t);
      
      let segA = { x1:old.x1, y1:old.y1, x2:midx, y2:midy, colorIndex:old.colorIndex };
      let segB = { x1:midx, y1:midy, x2:old.x2, y2:old.y2, colorIndex:old.colorIndex };

      // For simplicity, let's remove the second half (segB) so the portion behind the new line is gone.
      // Keep segA if it has length. 
      // This logic tries to mimic "the new line is on top from intersection onward."
      let lenA = dist(segA.x1, segA.y1, segA.x2, segA.y2);
      if (lenA > 0.5) {
        lineSegments[i] = segA; // keep the first portion
      } else {
        // If segA is too short, remove it entirely
        lineSegments.splice(i, 1);
        i--;
      }
      // segB is effectively removed (occluded)
    }
  }

  // 3) Actually add the new segment to lineSegments
  // The new segment is always “fully visible”
  lineSegments.push({
    x1: newSeg.x1,
    y1: newSeg.y1,
    x2: newSeg.x2,
    y2: newSeg.y2,
    colorIndex: newColorIndex
  });

  // Because we do minimal geometry, we haven't subdivided the new segment itself.
  // It's presumably always on top. 
  return newPieces;
}

/**
 * lineIntersection: returns an object with intersection info
 *  from: https://en.wikipedia.org/wiki/Line–line_intersection
 */
function lineIntersection(x1,y1, x2,y2, x3,y3, x4,y4) {
  // param approach
  const denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 0.000001) {
    return { intersects:false, t:0, u:0 };
  }
  const t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4))/denom;
  const u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2))/denom;
  // For a line segment intersection, we need 0<=t<=1 and 0<=u<=1
  let intersects = (t >=0 && t<=1 && u>=0 && u<=1);
  return { intersects, t, u };
}

/**
 * Create a path from a boundary anchor
 */
function createOneArcPath(steps) {
  let anchor = getRandomBoundaryPoint();
  let points = [ anchor ];

  let angle = getInitialAngle(anchor);
  let torsionBase = generationRules.torsion;

  for (let i = 0; i < steps; i++) {
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (torsionBase + dev);

    let prev = points[points.length - 1];
    let nx = prev.x + generationRules.stepLength*cos(angle);
    let ny = prev.y + generationRules.stepLength*sin(angle);

    if (
      nx < workAreaMarginPixels || ny < workAreaMarginPixels ||
      nx > (width - workAreaMarginPixels) ||
      ny > (height - workAreaMarginPixels)
    ) {
      break;
    }
    points.push({x:nx,y:ny});
  }
  return points;
}

function getRandomBoundaryPoint() {
  let side = floor(random(4));
  let x, y;
  let minPix = workAreaMarginPixels;
  let maxPixX = width - workAreaMarginPixels;
  let maxPixY = height - workAreaMarginPixels;

  if (side===0) {
    x = random(minPix, maxPixX); y = minPix;
  } else if (side===1) {
    x = random(minPix, maxPixX); y = maxPixY;
  } else if (side===2) {
    x = minPix; y = random(minPix, maxPixY);
  } else {
    x = maxPixX; y = random(minPix, maxPixY);
  }
  return {x, y};
}

function getInitialAngle(pt) {
  let centerX = width/2, centerY = height/2;
  let dx = centerX - pt.x;
  let dy = centerY - pt.y;
  let baseAngle = atan2(dy, dx);
  return baseAngle + random(-0.3,0.3);
}

function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255 * strokeOpacity);
  stroke(c);
}

function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0, 0, 5, 0);
  line(0, 0, 0, 5);
  line(width - 5, height, width, height);
  line(width, height - 5, width, height);
}

function addColorPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25*pixelsPerInch);

  let usedColorsOrdered = selectedColorIndices;
  let numColors = usedColorsOrdered.length;
  if (numColors===0) return;

  let totalGaps = (numColors-1)*gapSize;
  let segmentLength = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);

  usedColorsOrdered.forEach((colorIndex, i)=>{
    let x = xStart + i*(segmentLength+gapSize);
    let cVal = colors[colorIndex].hex;
    applyStrokeWithOpacity(cVal);
    line(x, yStart, x+segmentLength, yStart);
  });
}

/**
 * Key handling:
 *  - ' ' => export
 *  - 'r' => reset
 */
function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  pathData = [];
  lineSegments = [];
  drawShapes();
}

// ============ SVG Export ==============

function saveSVGs() {
  const ts = Date.now();

  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  selectedColorIndices.forEach((cidx)=>{
    let svgData = generateSVG(cidx);
    let cName = colors[cidx].name.toUpperCase();
    saveSVGFile(svgData, `${dayNumber}-0${cidx}-${cName}-PORTRAIT-${ts}.svg`);
  });
}

/**
 * generateSVG: we rely on the global "lineSegments" (the clipped set).
 */
function generateSVG(activeColor=0) {
  let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  // Add markers
  svgContent += addMarkersSVG();

  // If activeColor=0 => all colors, else only that color
  let grouped = {};
  for (let seg of lineSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  if (activeColor===0) {
    // all
    let layerNum = 1;
    for (let cidx of selectedColorIndices) {
      svgContent += addSegmentsSVG(cidx, layerNum);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    svgContent += addSegmentsSVG(activeColor, layerNum);
  }

  svgContent += '</svg>';
  return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
  let svg = '';
  let col = colors[colorIndex];
  svg += `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${col.hex}">n`;

  // Gather segments
  let segs = lineSegments.filter(s=> s.colorIndex===colorIndex);
  if (segs.length>0) {
    // We can create one <path> for all segments 
    // or separate them. Let's unify them:
    let d = '';
    for (let s of segs) {
      d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
    }
    let sw = strokeWeightValue;
    svg += `<path d="${d.trim()}" stroke-width="${sw}" fill="none" />n`;
  }

  // palette bar
  let usedColorsOrdered = selectedColorIndices;
  let i = usedColorsOrdered.indexOf(colorIndex);
  if (i >= 0) {
    let paletteLength = 300;
    let barHeight = 2;
    let gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);
    let numColors = usedColorsOrdered.length;
    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;
    let x = xStart + i * (segmentLength + gapSize);

    svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segmentLength).toFixed(2)}" stroke="${col.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
  }

  svg += '</g>n';
  return svg;
}

/**
 * Adds registration markers
 */
function addMarkersSVG() {
  const sw = 1;
  const offset = sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${5+offset},${offset}L${offset},${offset}L${offset},${5+offset}
M${(width-5-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-5-offset).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
  let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fileName;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Edge Circles with Layered Occlusion)
=======================================

### Title: *Edge Circles: Layered Apertures*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, partial circles, margins,
              layering, occlusion, geometry, lines, minimalism

### Concept

This piece arranges partial circles along the outer margins of the drawing area,
leaving the center open. Each circle’s center is placed beyond the boundaries,
so only an arc of the circle enters the page near the edges. The arcs are layered
on top of one another in a way that physically clips older arcs, creating a sense
of depth and stacked apertures around the perimeter. Each circle arc is reduced
to a series of short line segments with no fills, ensuring a pen plotter can
faithfully render the layered effect without excessive overlapping ink.

### Technical Approach

1. **Circle Generation**  
   - Randomly pick a corner (or edge) for the circle’s center, placing it outside
     the main work area.  
   - Assign a random radius so that the circle only intersects the paper’s margins
     near its outer edges, leaving the center area empty.  
   - Sample the circle at small angle increments to gather the contiguous arc that
     lies within the margins.

2. **Segment Subdivision**  
   - Each partial circle is subdivided into short, straight line segments for clarity
     and easy clipping.

3. **Line-by-Line Occlusion**  
   - Newly added segments clip older segments behind them.  
   - This clipping is done by checking line intersections and trimming or removing
     the overlapped portions of older lines.  
   - The final geometry in memory is exactly what appears on the canvas, and the SVG
     export uses that same geometry, guaranteeing the visual match.

4. **No Fills**  
   - Everything is drawn with single-stroke lines (with slight opacity).
   - The illusion of layering emerges from physically removing hidden line segments.

---
*/

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

const colors = {
  1: { name: 'ORANGE', ink: 5,  width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',  ink: 12, width: 0.45, hex: '#993300' },
  3: { name: 'RED',    ink: 19, width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',   ink: 21, width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',  ink: 29, width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',   ink: 36, width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',  ink: 49, width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',  ink: 117,width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

// We’ll generate a certain number of partial circles
// that pass inside the margin area but keep the center mostly free.
let generationRules = {
  numCircles: 12,          // how many partial circles
  angleStep: 0.1,          // angle increment in radians for sampling
  minRadius: 120,          // minimum radius for circles
  maxRadius: 300,          // maximum radius for circles
  segmentMaxLength: 5      // break arcs into line segments of ~this length
};

let canvasWidthPixels, canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];
let strokeWeightValue;
let pathData = [];         // for SVG
let lineSegments = [];     // global array of final visible line segments

function setup() {
  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  // random margin
  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustForStrokeWeight();
  selectColors();

  pathData = [];
  lineSegments = [];

  drawShapes();
  noLoop();
}

function adjustForStrokeWeight() {
  // ~0.5mm => ~2px at 100 dpi
  strokeWeightValue = 2;
  workAreaMarginPixels += strokeWeightValue / 2;
}

function selectColors() {
  // choose 1 to 9 unique colors
  let n = floor(random(1, 10));
  selectedColorIndices = selectRandomColorIndices(n);
}

function selectRandomColorIndices(n) {
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  let selected = [];
  while (selected.length < n && allIndices.length > 0) {
    let idx = floor(random(allIndices.length));
    selected.push(allIndices[idx]);
    allIndices.splice(idx, 1);
  }
  return selected.sort((a,b)=>a-b);
}

function drawShapes() {
  background(255);

  for (let i = 0; i < generationRules.numCircles; i++) {
    let colorIndex = random(selectedColorIndices);
    let col = colors[colorIndex];

    // Generate partial circle points
    let arcPoints = generatePartialCirclePoints();

    // Break them into short segments
    let segs = subdivideArcIntoSegments(arcPoints, generationRules.segmentMaxLength);

    // For each new segment, we do occlusion and then add
    let acceptedSegments = [];
    for (let seg of segs) {
      let newSegs = addLineSegmentWithOcclusion(seg, colorIndex);
      acceptedSegments.push(...newSegs);
    }

    // Build path data for this partial circle in one group
    let d = '';
    for (let s of acceptedSegments) {
      d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
    }
    if (d !== '') {
      pathData.push({ colorIndex: colorIndex, d: d.trim() });
    }
  }

  // Render final clipped geometry to canvas
  drawSegmentsToCanvas();

  // Markers + palette
  drawMarkers();
  addColorPaletteBars();
}

function generatePartialCirclePoints() {
  // pick which corner or edge to place the center
  // 0=top-left,1=top-right,2=bottom-left,3=bottom-right
  // optional: edges 4=top-edge,5=bottom-edge,6=left-edge,7=right-edge
  // for simplicity, we’ll just do corners
  let corner = floor(random(4));

  let minPix = workAreaMarginPixels;
  let maxPixX = width - workAreaMarginPixels;
  let maxPixY = height - workAreaMarginPixels;

  // pick center outside the margin
  let cx, cy;
  let extra = 50; // offset outside
  switch(corner) {
    case 0: // top-left
      cx = random(minPix - 200, minPix - 50);
      cy = random(minPix - 200, minPix - 50);
      break;
    case 1: // top-right
      cx = random(maxPixX + 50, maxPixX + 200);
      cy = random(minPix - 200, minPix - 50);
      break;
    case 2: // bottom-left
      cx = random(minPix - 200, minPix - 50);
      cy = random(maxPixY + 50, maxPixY + 200);
      break;
    case 3: // bottom-right
      cx = random(maxPixX + 50, maxPixX + 200);
      cy = random(maxPixY + 50, maxPixY + 200);
      break;
  }

  let r = random(generationRules.minRadius, generationRules.maxRadius);

  let pts = [];
  let step = generationRules.angleStep;
  // sample angles from 0..2PI
  for (let a = 0; a < TWO_PI; a += step) {
    let x = cx + r*cos(a);
    let y = cy + r*sin(a);
    // keep only if inside the margin box
    if (x >= minPix && x <= maxPixX && y >= minPix && y <= maxPixY) {
      pts.push({x, y});
    }
  }
  // If no points, return empty
  if (pts.length < 2) return pts;

  // Sort the points by angle so we can get a contiguous arc
  // We'll approximate angle with atan2(y-cy, x-cx)
  pts.sort((p1, p2)=>{
    let a1 = atan2(p1.y - cy, p1.x - cx);
    let a2 = atan2(p2.y - cy, p2.x - cx);
    return a1 - a2;
  });

  // We might have multiple arcs if it crosses corners. We'll just keep them in sorted order
  // to form one sequence. If it loops around, we can connect the endpoints if they’re close.
  // For simplicity, we won't connect them. We'll just treat them as a single array of points.

  return pts;
}

function subdivideArcIntoSegments(pts, maxLen) {
  // connect consecutive points in pts, subdividing if distance>maxLen
  let segments = [];
  for (let i=0; i<pts.length-1; i++) {
    let p1 = pts[i];
    let p2 = pts[i+1];
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    let distPts = sqrt(dx*dx + dy*dy);
    if (distPts <= maxLen) {
      segments.push({x1:p1.x, y1:p1.y, x2:p2.x, y2:p2.y});
    } else {
      // subdivide
      let nSubs = ceil(distPts/maxLen);
      let stepx = dx/nSubs;
      let stepy = dy/nSubs;
      let sx = p1.x;
      let sy = p1.y;
      for (let s=0; s<nSubs; s++) {
        let nx = sx + stepx;
        let ny = sy + stepy;
        segments.push({x1:sx, y1:sy, x2:nx, y2:ny});
        sx = nx;
        sy = ny;
      }
    }
  }
  return segments;
}

/**
 * addLineSegmentWithOcclusion:
 *   Takes a new segment and removes overlapping parts of older segments behind it.
 *   Returns the final visible sub-segments for the new line (generally just one piece).
 */
function addLineSegmentWithOcclusion(newSeg, newColorIndex) {
  // We'll do a simple intersection-based approach:
  //   If newSeg intersects an old segment, we chop the old segment at the intersection
  //   so the portion beyond that intersection is removed (occluded).
  // This is a minimal approach to layering illusions.
  // More advanced geometry can expand the stroke thickness, etc.

  // Check intersection with all older segments
  for (let i = 0; i < lineSegments.length; i++) {
    let old = lineSegments[i];
    // find intersection
    let ints = lineIntersection(
      old.x1, old.y1, old.x2, old.y2,
      newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
    );
    if (ints.intersects) {
      let t = ints.t; // fraction along old
      let midx = lerp(old.x1, old.x2, t);
      let midy = lerp(old.y1, old.y2, t);

      // We keep the portion from old.x1,y1 to mid
      // The rest is cut away (behind the new line).
      let segA = {
        x1: old.x1, y1: old.y1,
        x2: midx,   y2: midy,
        colorIndex: old.colorIndex
      };
      let lenA = dist(segA.x1, segA.y1, segA.x2, segA.y2);
      if (lenA > 0.5) {
        lineSegments[i] = segA; // keep that portion
      } else {
        // remove entirely
        lineSegments.splice(i, 1);
        i--;
      }
    }
  }

  // Now add the new segment on top
  let finalSeg = {
    x1: newSeg.x1, y1: newSeg.y1,
    x2: newSeg.x2, y2: newSeg.y2,
    colorIndex: newColorIndex
  };
  lineSegments.push(finalSeg);

  // Return it as the newly added visible piece
  return [finalSeg];
}

function lineIntersection(x1,y1, x2,y2, x3,y3, x4,y4) {
  // param approach
  const denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 0.000001) {
    return { intersects:false, t:0, u:0 };
  }
  const t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4)) / denom;
  const u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2)) / denom;
  let intersects = (t>=0 && t<=1 && u>=0 && u<=1);
  return { intersects, t, u };
}

function drawSegmentsToCanvas() {
  background(255);
  // group lineSegments by color
  let grouped = {};
  for (let seg of lineSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  for (let colorIndexStr in grouped) {
    let cidx = parseInt(colorIndexStr);
    let col = colors[cidx];
    applyStrokeWithOpacity(col.hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let seg of grouped[cidx]) {
      vertex(seg.x1, seg.y1);
      vertex(seg.x2, seg.y2);
    }
    endShape();
  }
}

function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255 * strokeOpacity);
  stroke(c);
}

function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0, 0, 5, 0);
  line(0, 0, 0, 5);
  line(width - 5, height, width, height);
  line(width, height - 5, width, height);
}

function addColorPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * pixelsPerInch);

  let usedColorsOrdered = selectedColorIndices;
  let numColors = usedColorsOrdered.length;
  if (numColors===0) return;

  let totalGaps = (numColors - 1) * gapSize;
  let segmentLength = (paletteLength - totalGaps) / numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);

  usedColorsOrdered.forEach((colorIndex, i)=>{
    let x = xStart + i*(segmentLength+gapSize);
    let cVal = colors[colorIndex].hex;
    applyStrokeWithOpacity(cVal);
    line(x, yStart, x+segmentLength, yStart);
  });
}

function keyPressed() {
  if (key === ' ') {
    saveSVGs();
  } else if (key === 'r' || key === 'R') {
    resetCanvas();
  }
}

function resetCanvas() {
  pathData = [];
  lineSegments = [];
  drawShapes();
}

function saveSVGs() {
  const ts = Date.now();
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  selectedColorIndices.forEach((cidx)=>{
    let colorSVG = generateSVG(cidx);
    let cName = colors[cidx].name.toUpperCase();
    saveSVGFile(colorSVG, `${dayNumber}-0${cidx}-${cName}-PORTRAIT-${ts}.svg`);
  });
}

function generateSVG(activeColor=0) {
  let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svgContent += addMarkersSVG();

  // group lineSegments by color
  let grouped = {};
  for (let seg of lineSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  if (activeColor===0) {
    let layerNum = 1;
    for (let cidx of selectedColorIndices) {
      svgContent += addSegmentsSVG(cidx, layerNum);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    svgContent += addSegmentsSVG(activeColor, layerNum);
  }

  svgContent += '</svg>';
  return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
  let col = colors[colorIndex];
  let svg = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${col.hex}">n`;

  let segs = lineSegments.filter(s => s.colorIndex===colorIndex);
  if (segs.length>0) {
    let d = '';
    for (let s of segs) {
      d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
    }
    svg += `<path d="${d.trim()}" stroke-width="${strokeWeightValue}" fill="none" />n`;
  }

  // palette bar
  let usedColorsOrdered = selectedColorIndices;
  let i = usedColorsOrdered.indexOf(colorIndex);
  if (i >= 0) {
    let paletteLength = 300;
    let barHeight = 2;
    let gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);
    let numColors = usedColorsOrdered.length;
    let totalGaps = (numColors - 1)*gapSize;
    let segmentLength = (paletteLength - totalGaps)/numColors;
    let xStart = (width - paletteLength)/2;
    let x = xStart + i*(segmentLength+gapSize);

    svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segmentLength).toFixed(2)}" stroke="${col.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
  }

  svg += '</g>n';
  return svg;
}

function addMarkersSVG() {
  const sw = 1;
  const offset = sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${5+offset},${offset}L${offset},${offset}L${offset},${5+offset}
M${(width-5-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-5-offset).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
  let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fileName;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Corner Arcs with Layered Occlusion)
=======================================

### Title: *Convergent Corners*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, arcs, corners, margins,
              layering, occlusion, geometry, lines, minimalism

### Concept

"Convergent Corners" arranges arcs whose centers lie just beyond the four corners (and optionally the mid-edges) of the work area. 
Each arc curves inward, leaving the center region open. When arcs overlap, the newly drawn lines physically clip older arcs, creating 
a sense of layered depth. By restricting all shapes to simple line segments (with no fills), the piece remains pen-plotter-friendly 
while producing a visually dynamic interplay of form and negative space around the edges.

### Technical Approach

1. **Corner and Edge Centers**  
   - Define up to eight “centers”: one for each corner and optionally one for each mid-edge, placed just outside the margin.  
   - Each center is assigned a radius ensuring its arc reaches into the work area but keeps the middle largely open.

2. **Partial Arc Sampling**  
   - For each center, sample a circle in small angle increments, collecting only the points that fall within the valid margin.  
   - Sort those points by angle to form a continuous partial arc that appears on the paper.

3. **Segment Subdivision**  
   - Each arc is broken into short line segments to facilitate line-by-line occlusion.  
   - No fills or clipping masks are used—only geometry.

4. **Layered Occlusion**  
   - Whenever a new segment is drawn, it intersects and clips older segments, removing the portions behind it.  
   - This yields a final geometry that truly layers arcs from oldest (lowest) to newest (topmost).

5. **Canvas and SVG Consistency**  
   - The same post-occlusion geometry is used for both on-screen display and SVG export, guaranteeing a perfect match.  
   - Each color is drawn with a single stroke at 0.8 opacity, and no overlapping paths remain once clipping is complete.

---
*/

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

// Fixed color palette
const colors = {
  1: { name: 'ORANGE', ink: 5,  width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',  ink: 12, width: 0.45, hex: '#993300' },
  3: { name: 'RED',    ink: 19, width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',   ink: 21, width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',  ink: 29, width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',   ink: 36, width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',  ink: 49, width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',  ink: 117,width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

// Generation rules for arcs from corners/edges
let generationRules = {
  angleStep: 0.08,        // angle increment (radians) for sampling each circle
  segmentMaxLen: 6,       // subdivide arcs into segments no longer than this
  cornerRadiusMin: 200,   // min radius for corner arcs
  cornerRadiusMax: 300,   // max radius for corner arcs
  edgeRadiusMin: 150,     // min radius for edge arcs
  edgeRadiusMax: 250,     // max radius for edge arcs
  cornersOnly: false,     // set to true if you only want corners (no mid-edges)
  totalArcs: 8            // total arcs to attempt (4 corners + up to 4 edges)
};

let canvasWidthPixels, canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];
let strokeWeightValue;
let pathData = [];         // for final SVG output
let lineSegments = [];     // global list of visible segments after occlusion

function setup() {
  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  // random margin
  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustForStrokeWeight();
  selectColors();

  // Clear data
  pathData = [];
  lineSegments = [];

  drawShapes();
  noLoop();
}

/**
 * Adjust stroke weight for ~0.5mm
 */
function adjustForStrokeWeight() {
  strokeWeightValue = 2; // ~0.5mm at 100 dpi
  workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Randomly select 1..9 colors
 */
function selectColors() {
  let n = floor(random(1, 10));
  selectedColorIndices = pickRandomColorIndices(n);
}

function pickRandomColorIndices(n) {
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  let selected = [];
  while (selected.length < n && allIndices.length > 0) {
    let idx = floor(random(allIndices.length));
    selected.push(allIndices[idx]);
    allIndices.splice(idx, 1);
  }
  return selected.sort((a,b)=>a-b);
}

function drawShapes() {
  background(255);

  // We'll define up to 8 "arc centers": 4 corners + 4 edges
  // Then generate arcs in random order for layering variety
  let arcCenters = buildArcCenters();
  shuffleArray(arcCenters);

  // We only draw up to generationRules.totalArcs
  let arcsToDraw = min(arcCenters.length, generationRules.totalArcs);

  for (let i=0; i<arcsToDraw; i++) {
    let colorIndex = random(selectedColorIndices);
    let col = colors[colorIndex];

    // generate partial arc points
    let pts = generateArcPoints(arcCenters[i]);

    // subdivide into short segments
    let segs = subdivideArcIntoSegments(pts, generationRules.segmentMaxLen);

    // apply occlusion, add them
    let acceptedSegments = [];
    for (let s of segs) {
      let newSegs = addLineSegmentWithOcclusion(s, colorIndex);
      acceptedSegments.push(...newSegs);
    }

    // build path data for final SVG
    let d = '';
    for (let asg of acceptedSegments) {
      d += `M${asg.x1.toFixed(2)},${asg.y1.toFixed(2)}L${asg.x2.toFixed(2)},${asg.y2.toFixed(2)} `;
    }
    if (d !== '') {
      pathData.push({ colorIndex, d: d.trim() });
    }
  }

  // draw final clipped geometry to canvas
  drawSegmentsToCanvas();

  // markers + palette
  drawMarkers();
  addColorPaletteBars();
}

/**
 * Build an array of "center specs" for arcs near corners/edges
 */
function buildArcCenters() {
  let centers = [];

  // corners
  centers.push({
    x: -100, y: -100,   // top-left outside
    r: random(generationRules.cornerRadiusMin, generationRules.cornerRadiusMax)
  });
  centers.push({
    x: width+100, y: -100,  // top-right
    r: random(generationRules.cornerRadiusMin, generationRules.cornerRadiusMax)
  });
  centers.push({
    x: -100, y: height+100, // bottom-left
    r: random(generationRules.cornerRadiusMin, generationRules.cornerRadiusMax)
  });
  centers.push({
    x: width+100, y: height+100, // bottom-right
    r: random(generationRules.cornerRadiusMin, generationRules.cornerRadiusMax)
  });

  if (!generationRules.cornersOnly) {
    // mid-edges
    centers.push({
      x: width/2, y: -100,   // top edge
      r: random(generationRules.edgeRadiusMin, generationRules.edgeRadiusMax)
    });
    centers.push({
      x: width/2, y: height+100, // bottom edge
      r: random(generationRules.edgeRadiusMin, generationRules.edgeRadiusMax)
    });
    centers.push({
      x: -100, y: height/2, // left edge
      r: random(generationRules.edgeRadiusMin, generationRules.edgeRadiusMax)
    });
    centers.push({
      x: width+100, y: height/2, // right edge
      r: random(generationRules.edgeRadiusMin, generationRules.edgeRadiusMax)
    });
  }

  return centers;
}

/**
 * Sample circle points for a center spec, only keep those inside the margin
 */
function generateArcPoints(spec) {
  let {x:cx, y:cy, r:radius} = spec;
  let minPix = workAreaMarginPixels;
  let maxPixX = width - workAreaMarginPixels;
  let maxPixY = height - workAreaMarginPixels;

  let pts = [];
  for (let a=0; a<TWO_PI; a+= generationRules.angleStep) {
    let px = cx + radius*cos(a);
    let py = cy + radius*sin(a);
    if (px>=minPix && px<=maxPixX && py>=minPix && py<=maxPixY) {
      pts.push({x:px, y:py});
    }
  }
  // sort by angle to keep a contiguous arc
  pts.sort((p1,p2)=>{
    let a1 = atan2(p1.y-cy, p1.x-cx);
    let a2 = atan2(p2.y-cy, p2.x-cx);
    return a1 - a2;
  });
  return pts;
}

/**
 * Subdivide arcs so no segment is too long
 */
function subdivideArcIntoSegments(pts, maxLen) {
  let segs = [];
  for (let i=0; i<pts.length-1; i++) {
    let p1=pts[i], p2=pts[i+1];
    let dx = p2.x - p1.x, dy = p2.y - p1.y;
    let distPts = sqrt(dx*dx + dy*dy);
    if (distPts <= maxLen) {
      segs.push({ x1:p1.x, y1:p1.y, x2:p2.x, y2:p2.y });
    } else {
      // subdiv
      let nSubs = ceil(distPts/maxLen);
      let stepx = dx/nSubs, stepy = dy/nSubs;
      let sx = p1.x, sy = p1.y;
      for (let s=0; s<nSubs; s++) {
        let nx = sx+stepx, ny = sy+stepy;
        segs.push({ x1:sx, y1:sy, x2:nx, y2:ny });
        sx=nx; sy=ny;
      }
    }
  }
  return segs;
}

/**
 * Add a new segment, clipping older segments behind it
 */
function addLineSegmentWithOcclusion(newSeg, colorIndex) {
  for (let i=0; i<lineSegments.length; i++) {
    let old = lineSegments[i];
    let ints = lineIntersection(
      old.x1, old.y1, old.x2, old.y2,
      newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
    );
    if (ints.intersects) {
      let t = ints.t;
      let midx = lerp(old.x1, old.x2, t);
      let midy = lerp(old.y1, old.y2, t);
      // keep only the portion from old.x1,y1 up to intersection
      let segA = {
        x1:old.x1, y1:old.y1,
        x2:midx,   y2:midy,
        colorIndex: old.colorIndex
      };
      let lenA = dist(segA.x1, segA.y1, segA.x2, segA.y2);
      if (lenA>0.5) {
        lineSegments[i] = segA; // keep that portion
      } else {
        lineSegments.splice(i,1);
        i--;
      }
    }
  }

  // add the new segment on top
  let finalSeg = {
    x1:newSeg.x1, y1:newSeg.y1,
    x2:newSeg.x2, y2:newSeg.y2,
    colorIndex
  };
  lineSegments.push(finalSeg);

  return [finalSeg];
}

/**
 * Intersection test (parametric)
 */
function lineIntersection(x1,y1,x2,y2, x3,y3,x4,y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom)<0.000001) {
    return { intersects:false, t:0, u:0 };
  }
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4))/denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2))/denom;
  let inter = (t>=0 && t<=1 && u>=0 && u<=1);
  return { intersects:inter, t, u };
}

/**
 * Draw final geometry to canvas
 */
function drawSegmentsToCanvas() {
  background(255);
  // group by color
  let grouped = {};
  for (let seg of lineSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  for (let cIdxStr in grouped) {
    let cIdx = parseInt(cIdxStr);
    let col = colors[cIdx];
    applyStrokeWithOpacity(col.hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let seg of grouped[cIdx]) {
      vertex(seg.x1, seg.y1);
      vertex(seg.x2, seg.y2);
    }
    endShape();
  }
}

/**
 * Basic utilities
 */
function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255*strokeOpacity);
  stroke(c);
}

/**
 * Markers + palette
 */
function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0,0,5,0);
  line(0,0,0,5);
  line(width-5,height,width,height);
  line(width,height-5,width,height);
}

function addColorPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * pixelsPerInch);

  let usedColorsOrdered = selectedColorIndices;
  let numColors = usedColorsOrdered.length;
  if (numColors===0) return;

  let totalGaps = (numColors -1)*gapSize;
  let segmentLength = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);

  usedColorsOrdered.forEach((colorIndex, i)=>{
    let cx = xStart + i*(segmentLength+gapSize);
    let cVal = colors[colorIndex].hex;
    applyStrokeWithOpacity(cVal);
    line(cx, yStart, cx+segmentLength, yStart);
  });
}

/**
 * Key handling
 */
function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  pathData = [];
  lineSegments = [];
  drawShapes();
}

/**
 * SVG Export
 */
function saveSVGs() {
  const ts = Date.now();
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  selectedColorIndices.forEach(cidx=>{
    let colorSVG = generateSVG(cidx);
    let cName = colors[cidx].name.toUpperCase();
    saveSVGFile(colorSVG, `${dayNumber}-0${cidx}-${cName}-PORTRAIT-${ts}.svg`);
  });
}

function generateSVG(activeColor=0) {
  let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svgContent += addMarkersSVG();

  // group by color
  let grouped = {};
  for (let seg of lineSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  if (activeColor===0) {
    let layerNum=1;
    for (let cidx of selectedColorIndices) {
      svgContent += addSegmentsSVG(cidx, layerNum);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    svgContent += addSegmentsSVG(activeColor, layerNum);
  }

  svgContent += '</svg>';
  return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
  let col = colors[colorIndex];
  let svg = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${col.hex}">n`;

  let segs = lineSegments.filter(s=>s.colorIndex===colorIndex);
  if (segs.length>0) {
    let d = '';
    for (let seg of segs) {
      d += `M${seg.x1.toFixed(2)},${seg.y1.toFixed(2)}L${seg.x2.toFixed(2)},${seg.y2.toFixed(2)} `;
    }
    svg += `<path d="${d.trim()}" stroke-width="${strokeWeightValue}" fill="none" />n`;
  }

  // palette bar
  let usedColorsOrdered = selectedColorIndices;
  let i = usedColorsOrdered.indexOf(colorIndex);
  if (i>=0) {
    let paletteLength=300, barHeight=2, gapSize=7;
    let yStart = height - (1.25*pixelsPerInch);
    let numColors = usedColorsOrdered.length;
    let totalGaps = (numColors-1)*gapSize;
    let segmentLength = (paletteLength - totalGaps)/numColors;
    let xStart = (width-paletteLength)/2;
    let cx = xStart + i*(segmentLength+gapSize);
    svg += `<path d="M${cx.toFixed(2)},${yStart.toFixed(2)}H${(cx+segmentLength).toFixed(2)}" stroke="${col.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
  }

  svg += '</g>n';
  return svg;
}

function addMarkersSVG() {
  const sw = 1;
  const offset = sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${5+offset},${offset}L${offset},${offset}L${offset},${5+offset}
M${(width-5-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-5-offset).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
  let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fileName;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

/**
 * Simple array shuffle
 */
function shuffleArray(arr) {
  for (let i=arr.length-1; i>0; i--) {
    let j = floor(random(i+1));
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, symmetry, lines, minimalism

### Concept

In “Torsional Reaches,” I visualize my identity as a series of twisting arcs that fan out from the margins of the page.  
Each arc begins at the boundary—an external point of contact—and spirals inward with a slight torsion, so that the paths cross and gently clip one another.  
Rather than converging at a single center, the arcs spread and overlap, creating a layered network of line segments that reveal both structure and spontaneity.  
All shapes are rendered as single‑stroke lines (with no fills), ensuring that the pen plotter can reproduce the effect exactly as seen on the canvas.

### Technical Approach

1. **Arc Generation & Segmentation**  
   - From a random boundary anchor, each arc is generated using an iterative process that applies a small, randomized torsion at every step.  
   - The continuous arc is subdivided into short line segments to allow fine‑grained control over occlusion.

2. **Layered Occlusion via Segment Clipping**  
   - A global array (“globalSegments”) is maintained to store all visible line segments.  
   - For each new segment, the code checks for intersections with previously drawn segments.  
   - When an intersection is found, the older segment is clipped (its portion beyond the intersection is removed), so that the new segment appears on top.

3. **Consistent Output**  
   - The final set of visible segments is drawn to the canvas and is used to generate the SVG export.  
   - This ensures that what you see on the screen is exactly what is exported, with the same occlusion effect and without any overlapping path redundancies.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings (immutable)
const canvasWidthInches = 11;     // Width of the canvas in inches
const canvasHeightInches = 11;    // Height of the canvas in inches
const pixelsPerInch = 100;        // Pixels per inch (resolution)
const dayNumber = '153';          // Day number for file naming

// Color palette (immutable)
const colors = {
    1: { name: 'ORANGE', ink: 5, width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN', ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED', ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE', ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN', ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE', ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK', ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA', ink: 117, width: 0.45, hex: '#856647' }
};

// Set the stroke opacity for both SVG and canvas
const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
    numArcs: 18,         // number of arcs to attempt from the edges
    minSteps: 40,        // minimum points per arc
    maxSteps: 80,        // maximum points per arc
    torsion: 0.03,       // base rotational influence at each step
    stepLength: 10,      // distance moved per segment
    maxDeviation: 0.02   // random variation factor in torsion
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */

let canvasWidthPixels;          // Canvas width in pixels
let canvasHeightPixels;         // Canvas height in pixels
let workAreaMarginInches = 2;   // This will be randomized in setup()
let workAreaMarginPixels;       // Work area margin in pixels
let selectedColorIndices = [];  // Indices of selected colors for the drawing

let strokeWeightValue;          // Stroke weight for ~0.5mm lines
let pathData = [];              // Array to store path info for SVG export

// Global array to hold all visible line segments (after occlusion)
let globalSegments = [];

/**
 * Applies the stroke color with the given hex and sets its alpha based on strokeOpacity.
 * @param {string} hexColor - The hex color value.
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

/**
 * =======================================
 * p5.js Setup Function
 * =======================================
 */

function setup() {
    // Initialize canvas dimensions
    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    // Initialize work area margin
    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    // Adjust for stroke weight
    adjustForStrokeWeight();

    // Select colors randomly
    selectColors();

    // Clear pathData and globalSegments
    pathData = [];
    globalSegments = [];

    // Generate the artwork
    drawTorsionalArcs();

    noLoop();
}

/**
 * Adjust stroke weight (approximate 0.5mm line width ~ 2px at 100dpi)
 */
function adjustForStrokeWeight() {
    strokeWeightValue = 2;
    workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Color Selection: pick 1 to 9 unique colors
 */
function selectColors() {
    let numColorsToUse = floor(random(1, 10));
    selectedColorIndices = selectRandomColorIndices(numColorsToUse);
}

function selectRandomColorIndices(n) {
    let indices = Object.keys(colors).map(k => parseInt(k));
    let selected = [];
    while (selected.length < n && indices.length > 0) {
        let idx = floor(random(indices.length));
        selected.push(indices[idx]);
        indices.splice(idx, 1);
    }
    return selected.sort((a, b) => a - b);
}

/**
 * =======================================
 * Drawing
 * =======================================
 */

function drawTorsionalArcs() {
    background(255);

    // For each arc to be drawn:
    for (let i = 0; i < generationRules.numArcs; i++) {
        // Randomly choose a color from the selected palette
        let colorIndex = random(selectedColorIndices);
        let col = colors[colorIndex];

        // Randomize the number of steps for this arc
        let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
        // Generate the arc path (an array of points)
        let arcPath = createOneArcPath(steps);

        // Break the arc into short line segments
        let segments = [];
        for (let j = 0; j < arcPath.points.length - 1; j++) {
            segments.push({
                x1: arcPath.points[j].x,
                y1: arcPath.points[j].y,
                x2: arcPath.points[j + 1].x,
                y2: arcPath.points[j + 1].y
            });
        }

        // For each new segment, apply occlusion against previously drawn segments
        let acceptedSegments = [];
        for (let seg of segments) {
            let visibleSegs = addSegmentWithOcclusion(seg, colorIndex);
            acceptedSegments.push(...visibleSegs);
        }

        // For SVG export: build a d-string from the accepted segments (order preserved)
        let d = '';
        for (let s of acceptedSegments) {
            d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
        }
        if (d !== '') {
            pathData.push({ colorIndex: colorIndex, d: d.trim() });
        }
    }

    // Draw the final (clipped) segments from globalSegments onto the canvas
    drawGlobalSegments();

    // Draw registration markers and color palette bars
    drawMarkers();
    addColorPaletteBars();
}

/**
 * Create a single arc path from a random edge anchor.
 * The arc is generated by iteratively stepping from the anchor with a base torsion and a small random deviation.
 */
function createOneArcPath(steps) {
    let anchor = getRandomBoundaryPoint();
    let points = [];
    points.push(anchor);

    // Initial angle pointing inward (toward the center)
    let angle = getInitialAngle(anchor);
    let torsionBase = generationRules.torsion;

    for (let i = 0; i < steps; i++) {
        let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
        angle += (torsionBase + dev);

        let prev = points[points.length - 1];
        let nx = prev.x + generationRules.stepLength * cos(angle);
        let ny = prev.y + generationRules.stepLength * sin(angle);

        // If the new point is out of the defined work area, break the path
        if (
            nx < workAreaMarginPixels ||
            ny < workAreaMarginPixels ||
            nx > (width - workAreaMarginPixels) ||
            ny > (height - workAreaMarginPixels)
        ) {
            break;
        }

        points.push({ x: nx, y: ny });
    }
    return { points };
}

/**
 * Get a random anchor point on the boundary (top, bottom, left, or right)
 */
function getRandomBoundaryPoint() {
    let side = floor(random(4));
    let x, y;

    let minPix = workAreaMarginPixels;
    let maxPixX = width - workAreaMarginPixels;
    let maxPixY = height - workAreaMarginPixels;

    if (side === 0) {
        // Top edge
        x = random(minPix, maxPixX);
        y = minPix;
    } else if (side === 1) {
        // Bottom edge
        x = random(minPix, maxPixX);
        y = maxPixY;
    } else if (side === 2) {
        // Left edge
        x = minPix;
        y = random(minPix, maxPixY);
    } else {
        // Right edge
        x = maxPixX;
        y = random(minPix, maxPixY);
    }

    return { x, y };
}

/**
 * Get an initial angle that points roughly from the boundary anchor toward the canvas center.
 */
function getInitialAngle(pt) {
    let centerX = width / 2;
    let centerY = height / 2;
    let dx = centerX - pt.x;
    let dy = centerY - pt.y;
    let baseAngle = atan2(dy, dx);
    return baseAngle + random(-0.3, 0.3);
}

/**
 * =======================================
 * Occlusion & Global Segments
 * =======================================
 */

/**
 * Global function that takes a new segment and clips any previously stored segments that it overlaps.
 * Then, it adds the new segment to the globalSegments array.
 * Returns an array containing the new (visible) segment (typically one piece).
 */
function addSegmentWithOcclusion(newSeg, colorIndex) {
    // For each previously stored segment, check for intersection with the new segment.
    for (let i = 0; i < globalSegments.length; i++) {
        let oldSeg = globalSegments[i];
        let inter = lineIntersection(
            oldSeg.x1, oldSeg.y1, oldSeg.x2, oldSeg.y2,
            newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
        );
        if (inter.intersects) {
            // Calculate the intersection point on the old segment.
            let t = inter.t;
            let ix = lerp(oldSeg.x1, oldSeg.x2, t);
            let iy = lerp(oldSeg.y1, oldSeg.y2, t);
            // Keep only the portion of the old segment before the intersection.
            let clippedLength = dist(oldSeg.x1, oldSeg.y1, ix, iy);
            if (clippedLength > 1) {
                globalSegments[i] = {
                    x1: oldSeg.x1,
                    y1: oldSeg.y1,
                    x2: ix,
                    y2: iy,
                    colorIndex: oldSeg.colorIndex
                };
            } else {
                // Remove the old segment if it becomes too short.
                globalSegments.splice(i, 1);
                i--;
            }
        }
    }
    // Add the new segment (always fully visible) to globalSegments.
    let finalSeg = {
        x1: newSeg.x1,
        y1: newSeg.y1,
        x2: newSeg.x2,
        y2: newSeg.y2,
        colorIndex: colorIndex
    };
    globalSegments.push(finalSeg);
    return [finalSeg];
}

/**
 * Basic line-line intersection using a parametric approach.
 * Returns an object with properties:
 *   - intersects (boolean)
 *   - t: fraction along the first segment
 *   - u: fraction along the second segment
 */
function lineIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {
    let denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
    if (abs(denom) < 0.000001) {
        return { intersects: false, t: 0, u: 0 };
    }
    let t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
    let u = ((x1 - x3) * (y1 - y2) - (y1 - y3) * (x1 - x2)) / denom;
    let inter = (t >= 0 && t <= 1 && u >= 0 && u <= 1);
    return { intersects: inter, t, u };
}

/**
 * Draw all segments stored in globalSegments onto the canvas.
 */
function drawGlobalSegments() {
    background(255);
    // Group segments by color for efficient drawing.
    let grouped = {};
    for (let seg of globalSegments) {
        if (!grouped[seg.colorIndex]) {
            grouped[seg.colorIndex] = [];
        }
        grouped[seg.colorIndex].push(seg);
    }
    // Draw each group.
    for (let key in grouped) {
        let cIdx = parseInt(key);
        let col = colors[cIdx];
        applyStrokeWithOpacity(col.hex);
        strokeWeight(strokeWeightValue);
        beginShape(LINES);
        for (let seg of grouped[cIdx]) {
            vertex(seg.x1, seg.y1);
            vertex(seg.x2, seg.y2);
        }
        endShape();
    }
}

/**
 * =======================================
 * Registration Markers & Palette Bars
 * =======================================
 */

function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    line(0, 0, 5, 0);
    line(0, 0, 0, 5);
    line(width - 5, height, width, height);
    line(width, height - 5, width, height);
}

function addColorPaletteBars() {
    let paletteLength = 300;
    let barHeight = 2;
    let gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);

    let usedColorsOrdered = selectedColorIndices;
    let numColors = usedColorsOrdered.length;
    if (numColors === 0) return;

    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;

    strokeWeight(barHeight);

    usedColorsOrdered.forEach((colorIndex, i) => {
        let x = xStart + i * (segmentLength + gapSize);
        let cVal = colors[colorIndex].hex;
        applyStrokeWithOpacity(cVal);
        line(x, yStart, x + segmentLength, yStart);
    });
}

/**
 * =======================================
 * Canvas Reset and p5.js Key Handling
 * =======================================
 */

function resetCanvas() {
    globalSegments = [];
    pathData = [];
    drawTorsionalArcs();
}

function keyPressed() {
    if (key === ' ') {
        // Export the artwork as SVG files.
        saveSVGs();
    } else if (key === 'r' || key === 'R') {
        resetCanvas();
    }
}

/**
 * =======================================
 * SVG Export
 * =======================================
 *
 * The SVG export reassembles the final geometry from globalSegments (which match the canvas).
 * It groups segments by color and uses the stored pathData (if available) for each color.
 */

function saveSVGs() {
    const timestamp = Date.now();

    // Combined SVG export.
    let combinedSVG = generateSVG(0);
    saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${timestamp}.svg`);

    // Individual SVG exports per color.
    selectedColorIndices.forEach((colorIndex) => {
        let colorSVG = generateSVG(colorIndex);
        let colorName = colors[colorIndex].name.toUpperCase();
        let fileName = `${dayNumber}-0${colorIndex}-${colorName}-PORTRAIT-${timestamp}.svg`;
        saveSVGFile(colorSVG, fileName);
    });
}

function generateSVG(activeColor = 0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
    svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

    // Add registration markers.
    svgContent += addMarkersSVG();

    // Group the globalSegments by color.
    let grouped = {};
    for (let seg of globalSegments) {
        if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
        grouped[seg.colorIndex].push(seg);
    }

    if (activeColor === 0) {
        let layerNum = 1;
        for (let cIdx of selectedColorIndices) {
            svgContent += addSegmentsSVG(cIdx, layerNum);
            layerNum++;
        }
    } else {
        let layerNum = selectedColorIndices.indexOf(activeColor) + 1;
        svgContent += addSegmentsSVG(activeColor, layerNum);
    }

    svgContent += '</svg>';
    return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
    let col = colors[colorIndex];
    let svg = `<g
   inkscape:groupmode="layer"
   id="layer${layerNum}"
   inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
   style="display:inline"
   stroke="${col.hex}"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="${col.hex}">n`;

    let segs = globalSegments.filter(s => s.colorIndex === colorIndex);
    if (segs.length > 0) {
        let d = '';
        for (let s of segs) {
            d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
        }
        svg += `<path d="${d.trim()}" stroke-width="${strokeWeightValue}" fill="none" />n`;
    }

    // Add the palette bar for this color.
    let usedColorsOrdered = selectedColorIndices;
    let i = usedColorsOrdered.indexOf(colorIndex);
    if (i >= 0) {
        let paletteLength = 300;
        let barHeight = 2;
        let gapSize = 7;
        let yStart = height - (1.25 * pixelsPerInch);
        let numColors = usedColorsOrdered.length;
        let totalGaps = (numColors - 1) * gapSize;
        let segmentLength = (paletteLength - totalGaps) / numColors;
        let xStart = (width - paletteLength) / 2;
        let x = xStart + i * (segmentLength + gapSize);
        svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x + segmentLength).toFixed(2)}" stroke="${col.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none" />n`;
    }

    svg += '</g>n';
    return svg;
}

function addMarkersSVG() {
    const sw = 1;
    const offset = sw / 2;
    return `<g
       inkscape:groupmode="layer"
       id="layer0"
       inkscape:label="0-markers"
       style="display:inline"
       stroke="black"
       stroke-opacity="${strokeOpacity}"
       inkscape:highlight-color="black">
<path d="M${5 + offset},${offset} L${offset},${offset} L${offset},${5 + offset} M${(width - 5 - offset).toFixed(2)},${(height - offset).toFixed(2)} L${(width - offset).toFixed(2)},${(height - offset).toFixed(2)} L${(width - offset).toFixed(2)},${(height - 5 - offset).toFixed(2)}" stroke-width="${sw}" fill="none" />
</g>n`;
}

function saveSVGFile(svgData, fileName) {
    let blob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' });
    let url = URL.createObjectURL(blob);
    let link = document.createElement('a');
    link.href = url;
    link.download = fileName;

    document.body.appendChild(link);
    link.click();

    document.body.removeChild(link);
    URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches (Immediate Stop at Intersections)*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, minimalism, intersection

### Concept

In this iteration of “Torsional Reaches,” each twisting arc fans out from the margins 
but halts as soon as it meets an existing arc. Rather than passing behind or in front, 
the new arc simply stops at the first intersection, suggesting how some impulses 
are cut short by prior structures. The result is a dynamic interplay of curved paths 
that appear interdependent yet remain visually distinct. No fills are used, 
and each arc is broken into short line segments that preserve the pen plotter’s clarity.

### Technical Approach

1. **Arc Generation**  
   - A random boundary anchor is chosen, from which the arc grows step by step 
     with a gentle “torsion” (rotational offset).  
   - Each step moves a fixed distance; the direction changes slightly at each iteration.

2. **Immediate Stop on Intersection**  
   - For each step, we form a line segment from the previous point to the new point.  
   - If this new segment intersects any older segment, we truncate it at the intersection 
     and end the arc immediately (no further steps).  
   - If there is no intersection, we add the full segment to the global list and continue.

3. **No Fills / Single Strokes**  
   - All lines are drawn with a single stroke color (with slight opacity).  
   - The pen plotter can faithfully replicate these paths without overlapping fills.

4. **Canvas & SVG Consistency**  
   - We store every visible segment in a global array, then render it to both canvas 
     and SVG. This ensures the exported SVG precisely matches the on-screen image.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings
const canvasWidthInches = 11;     
const canvasHeightInches = 11;    
const pixelsPerInch = 100;        
const dayNumber = '153';          

// Color palette
const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

// Stroke opacity
const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
  numArcs: 18,         // number of arcs to generate
  minSteps: 40,        // min steps per arc
  maxSteps: 80,        // max steps per arc
  torsion: 0.03,       // small rotation offset each step
  stepLength: 10,      // distance per step
  maxDeviation: 0.02   // random variation in torsion
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */
let canvasWidthPixels, canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];
let strokeWeightValue;
let pathData = [];

// The global set of final line segments
let globalSegments = [];

/**
 * =======================================
 * p5.js Setup
 * =======================================
 */
function setup() {
  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  // Random margin
  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustForStrokeWeight();
  selectColors();

  // Clear data
  pathData = [];
  globalSegments = [];

  // Generate arcs
  drawArcs();
  noLoop();
}

/**
 * Adjust stroke weight (~0.5 mm => ~2 px at 100 dpi)
 */
function adjustForStrokeWeight() {
  strokeWeightValue = 2;
  workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Select 1..9 colors
 */
function selectColors() {
  let n = floor(random(1, 10));
  selectedColorIndices = pickRandomColorIndices(n);
}

function pickRandomColorIndices(n) {
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  let chosen = [];
  while (chosen.length < n && allIndices.length > 0) {
    let idx = floor(random(allIndices.length));
    chosen.push(allIndices[idx]);
    allIndices.splice(idx, 1);
  }
  return chosen.sort((a,b)=>a-b);
}

/**
 * =======================================
 * Drawing Arcs
 * =======================================
 */
function drawArcs() {
  background(255);

  for (let i=0; i<generationRules.numArcs; i++) {
    let colorIndex = random(selectedColorIndices);
    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));

    // Build the arc from the boundary
    let newSegments = createArcSegments(steps, colorIndex);

    // For SVG: gather them into a path
    if (newSegments.length>0) {
      let d = '';
      newSegments.forEach(s=>{
        d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
      });
      pathData.push({ colorIndex, d: d.trim() });
    }
  }

  // Render final geometry
  drawGlobalSegments();

  // Markers + color bars
  drawMarkers();
  addColorPaletteBars();
}

/**
 * createArcSegments:
 *   1) pick random boundary anchor
 *   2) move step by step with torsion
 *   3) if new segment intersects an older segment, stop immediately
 *   4) otherwise, store the new segment
 */
function createArcSegments(steps, colorIndex) {
  let anchor = getRandomBoundaryPoint();
  let angle = getInitialAngle(anchor);
  let torsionBase = generationRules.torsion;

  let segments = [];
  let prev = anchor;

  for (let i=0; i<steps; i++) {
    // random dev
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (torsionBase + dev);

    let nx = prev.x + generationRules.stepLength*cos(angle);
    let ny = prev.y + generationRules.stepLength*sin(angle);

    // stop if out of bounds
    if (nx < workAreaMarginPixels || nx > (width - workAreaMarginPixels) ||
        ny < workAreaMarginPixels || ny > (height - workAreaMarginPixels)) {
      break;
    }

    // form the new segment
    let newSeg = { x1:prev.x, y1:prev.y, x2:nx, y2:ny, colorIndex };

    // check intersection with older segments
    let intersectionFound = false;
    let intersectionX = 0, intersectionY = 0;
    for (let old of globalSegments) {
      let ints = lineIntersection(
        old.x1, old.y1, old.x2, old.y2,
        newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
      );
      if (ints.intersects) {
        // We have an intersection => stop the arc
        intersectionFound = true;
        let ix = lerp(newSeg.x1, newSeg.x2, ints.u);
        let iy = lerp(newSeg.y1, newSeg.y2, ints.u);
        // create a truncated segment from prev to intersection
        let truncSeg = { 
          x1: newSeg.x1, y1: newSeg.y1,
          x2: ix,        y2: iy,
          colorIndex 
        };
        // add it to globalSegments
        globalSegments.push(truncSeg);
        segments.push(truncSeg);
        // end arc
        break;
      }
    }

    if (intersectionFound) {
      // arc stops
      break;
    } else {
      // no intersection => accept the full segment
      globalSegments.push(newSeg);
      segments.push(newSeg);
    }

    prev = {x:nx, y:ny};
  }

  return segments;
}

/**
 * Get a random anchor on the boundary
 */
function getRandomBoundaryPoint() {
  let side = floor(random(4));
  let x, y;

  let minPix = workAreaMarginPixels;
  let maxPixX = width - workAreaMarginPixels;
  let maxPixY = height - workAreaMarginPixels;

  if (side===0) {
    // top
    x = random(minPix, maxPixX); 
    y = minPix;
  } else if (side===1) {
    // bottom
    x = random(minPix, maxPixX);
    y = maxPixY;
  } else if (side===2) {
    // left
    x = minPix;
    y = random(minPix, maxPixY);
  } else {
    // right
    x = maxPixX;
    y = random(minPix, maxPixY);
  }
  return {x, y};
}

/**
 * Angle from boundary anchor toward center, plus small random offset
 */
function getInitialAngle(pt) {
  let cx = width/2, cy = height/2;
  let dx = cx - pt.x;
  let dy = cy - pt.y;
  let baseAngle = atan2(dy, dx);
  return baseAngle + random(-0.3, 0.3);
}

/**
 * lineIntersection: param-based
 */
function lineIntersection(x1,y1,x2,y2, x3,y3,x4,y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom)<0.000001) {
    return { intersects:false, t:0, u:0 };
  }
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4))/denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2))/denom;
  let inter = (t>=0 && t<=1 && u>=0 && u<=1);
  return { intersects: inter, t, u };
}

/**
 * =======================================
 * Draw final geometry from globalSegments
 * =======================================
 */
function drawGlobalSegments() {
  background(255);
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  for (let key in grouped) {
    let cIdx = parseInt(key);
    let col = colors[cIdx];
    applyStrokeWithOpacity(col.hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let s of grouped[cIdx]) {
      vertex(s.x1, s.y1);
      vertex(s.x2, s.y2);
    }
    endShape();
  }
}

/**
 * Apply stroke with opacity
 */
function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255*strokeOpacity);
  stroke(c);
}

/**
 * =======================================
 * Markers + Palette Bars
 * =======================================
 */
function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0,0,5,0);
  line(0,0,0,5);
  line(width-5,height,width,height);
  line(width,height-5,width,height);
}

function addColorPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * pixelsPerInch);

  let usedColorsOrdered = selectedColorIndices;
  let numColors = usedColorsOrdered.length;
  if (numColors===0) return;

  let totalGaps = (numColors-1)*gapSize;
  let segmentLength = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);

  usedColorsOrdered.forEach((colorIndex, i)=>{
    let x = xStart + i*(segmentLength+gapSize);
    let col = colors[colorIndex].hex;
    applyStrokeWithOpacity(col);
    line(x, yStart, x+segmentLength, yStart);
  });
}

/**
 * =======================================
 * Key Presses + Reset
 * =======================================
 */
function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  globalSegments = [];
  pathData = [];
  drawArcs();
}

/**
 * =======================================
 * SVG Export
 * =======================================
 */
function saveSVGs() {
  const ts = Date.now();
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  selectedColorIndices.forEach(cidx=>{
    let colorSVG = generateSVG(cidx);
    let cName = colors[cidx].name.toUpperCase();
    let fileName = `${dayNumber}-0${cidx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(colorSVG, fileName);
  });
}

function generateSVG(activeColor=0) {
  let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svgContent += addMarkersSVG();

  // group by color
  let grouped = {};
  for (let s of globalSegments) {
    if (!grouped[s.colorIndex]) grouped[s.colorIndex] = [];
    grouped[s.colorIndex].push(s);
  }

  if (activeColor===0) {
    let layerNum = 1;
    for (let cIdx of selectedColorIndices) {
      svgContent += addSegmentsSVG(cIdx, layerNum);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    svgContent += addSegmentsSVG(activeColor, layerNum);
  }

  svgContent += '</svg>';
  return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
  let col = colors[colorIndex];
  let svg = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${col.hex}">n`;

  let segs = globalSegments.filter(s=> s.colorIndex===colorIndex);
  if (segs.length>0) {
    let d = '';
    for (let s of segs) {
      d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
    }
    svg += `<path d="${d.trim()}" stroke-width="${strokeWeightValue}" fill="none" />n`;
  }

  // palette bar
  let usedColorsOrdered = selectedColorIndices;
  let i = usedColorsOrdered.indexOf(colorIndex);
  if (i>=0) {
    let paletteLength=300, barHeight=2, gapSize=7;
    let yStart = height - (1.25*pixelsPerInch);
    let numColors = usedColorsOrdered.length;
    let totalGaps = (numColors -1)*gapSize;
    let segmentLength = (paletteLength - totalGaps)/numColors;
    let xStart = (width-paletteLength)/2;
    let cx = xStart + i*(segmentLength+gapSize);

    svg += `<path d="M${cx.toFixed(2)},${yStart.toFixed(2)}H${(cx+segmentLength).toFixed(2)}"
 stroke="${col.hex}" stroke-opacity="${strokeOpacity}"
 stroke-width="${barHeight}" fill="none"/>n`;
  }

  svg += '</g>n';
  return svg;
}

function addMarkersSVG() {
  const sw = 1;
  const offset = sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${5+offset},${offset}L${offset},${offset}L${offset},${5+offset}
M${(width-5-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-5-offset).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
  let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fileName;

  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, symmetry, lines, minimalism

### Concept

“Torsional Reaches” presents a series of nested, curved arcs that form a continuous “frame” along 
the work area margins. The outermost layer is composed of four arcs—one on each side of the margin. 
Subsequent layers are drawn inward: each new arc begins exactly where an existing arc is located and 
stops as soon as it meets an adjacent arc. The result is a series of interlocking, gently curving lines 
that gradually recede toward the center. All lines are rendered as single strokes (with slight opacity) 
so that the pen plotter can reproduce the work exactly as seen on the canvas.

### Technical Approach

1. **Frame Generation**  
   - The work area is defined by the canvas margins.
   - For the outer layer, we generate four arcs (top, right, bottom, and left) that follow the margin.
   - For each subsequent layer, we compute an inset rectangle (by a fixed amount) and generate four new arcs 
     along its sides.  
     
2. **Exact Endpoints**  
   - Each arc is sampled as a series of points along a parameterized curve (with a slight random perturbation 
     for organic variation).
   - The endpoints of each arc are determined by the intersections (in this case, the exact corners of the inset rectangle).
     
3. **Layered Drawing & Consistent Export**  
   - The arcs from every layer are stored as a series of connected line segments. These segments are drawn on the canvas 
     and stored for SVG export so that the output exactly matches the on‑screen result.
   - No fills or clipping masks are used—only strokes—ensuring compatibility with pen plotting.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings (immutable)
const canvasWidthInches = 11;     // Canvas width in inches
const canvasHeightInches = 11;    // Canvas height in inches
const pixelsPerInch = 100;        // Resolution in pixels per inch
const dayNumber = '153';          // Day number for file naming

// Color palette (immutable)
const colors = {
    1: { name: 'ORANGE', ink: 5, width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN', ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED', ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE', ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN', ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE', ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK', ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA', ink: 117, width: 0.45, hex: '#856647' }
};

// Stroke opacity for both canvas and SVG
const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
    numArcs: 10,         // Number of layers (outer plus inner)
    noiseAmplitude: 3    // Maximum noise offset (in pixels) for each arc point
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */
let canvasWidthPixels;
let canvasHeightPixels;
let workAreaMarginInches = 2;   // This will be randomized in setup()
let workAreaMarginPixels;       // Work area margin in pixels
let selectedColorIndices = [];  // Selected colors from palette

let strokeWeightValue;          // Stroke weight (approx. 0.5mm ~ 2px)
let pathData = [];              // For SVG export (grouped by color)

// Global array for all line segments (each segment: {x1, y1, x2, y2, colorIndex})
let globalSegments = [];

/**
 * Applies stroke with the given hex color (adjusted for opacity)
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

/**
 * =======================================
 * p5.js Setup Function
 * =======================================
 */
function setup() {
    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    // Randomize margin a bit
    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    adjustForStrokeWeight();
    selectColors();

    // Clear storage arrays
    pathData = [];
    globalSegments = [];

    // Draw the nested frames of arcs
    drawNestedArcs();

    noLoop();
}

/**
 * Adjust stroke weight (0.5mm ≈ 2px at 100 dpi)
 */
function adjustForStrokeWeight() {
    strokeWeightValue = 2;
    workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Randomly select 1 to 9 unique colors from the palette.
 */
function selectColors() {
    let n = floor(random(1, 10));
    selectedColorIndices = pickRandomColorIndices(n);
}

function pickRandomColorIndices(n) {
    let allIndices = Object.keys(colors).map(k => parseInt(k));
    let chosen = [];
    while (chosen.length < n && allIndices.length > 0) {
        let idx = floor(random(allIndices.length));
        chosen.push(allIndices[idx]);
        allIndices.splice(idx, 1);
    }
    return chosen.sort((a, b) => a - b);
}

/**
 * =======================================
 * Nested Arcs Drawing
 * =======================================
 *
 * We build a series of layers. The outer layer is defined by the work area margins.
 * Each subsequent layer is an inward offset of the previous one. For each layer,
 * we generate four arcs (top, right, bottom, left) with endpoints defined by the corners
 * of the inset rectangle. A small random noise is added to each sampled point.
 */
function drawNestedArcs() {
    background(255);

    // Define the outer work area bounds.
    let leftBound = workAreaMarginPixels;
    let rightBound = width - workAreaMarginPixels;
    let topBound = workAreaMarginPixels;
    let bottomBound = height - workAreaMarginPixels;

    // Number of layers (outer plus inner)
    let numLayers = generationRules.numArcs;
    // Calculate the inset per layer (we inset equally from each side)
    let maxInset = min(width, height) - 2 * workAreaMarginPixels;
    let d = (maxInset * 0.5) / numLayers;  // We'll inset half the available width over all layers

    // For each layer, generate the four arcs.
    for (let L = 0; L < numLayers; L++) {
        // Compute the inset boundaries for this layer.
        let layerLeft = leftBound + L * d;
        let layerRight = rightBound - L * d;
        let layerTop = topBound + L * d;
        let layerBottom = bottomBound - L * d;

        // Determine the color for this layer (cycle through the selected colors).
        let colorIndex = selectedColorIndices[L % selectedColorIndices.length];

        // Generate points along each arc (we use 50 sample points per arc).
        let topPoints = [];
        for (let t = 0; t <= 1; t += 1/50) {
            let x = lerp(layerLeft, layerRight, t);
            // Top arc curves downward slightly.
            let y = layerTop + random(-generationRules.noiseAmplitude, generationRules.noiseAmplitude);
            topPoints.push({x, y});
        }
        let rightPoints = [];
        for (let t = 0; t <= 1; t += 1/50) {
            let y = lerp(layerTop, layerBottom, t);
            // Right arc curves leftward.
            let x = layerRight + random(-generationRules.noiseAmplitude, generationRules.noiseAmplitude);
            rightPoints.push({x, y});
        }
        let bottomPoints = [];
        for (let t = 0; t <= 1; t += 1/50) {
            let x = lerp(layerRight, layerLeft, t);
            // Bottom arc curves upward.
            let y = layerBottom + random(-generationRules.noiseAmplitude, generationRules.noiseAmplitude);
            bottomPoints.push({x, y});
        }
        let leftPoints = [];
        for (let t = 0; t <= 1; t += 1/50) {
            let y = lerp(layerBottom, layerTop, t);
            // Left arc curves rightward.
            let x = layerLeft + random(-generationRules.noiseAmplitude, generationRules.noiseAmplitude);
            leftPoints.push({x, y});
        }

        // For each of the four arcs, convert the points into consecutive line segments
        // and add them to globalSegments and record in pathData.
        addArcSegments(topPoints, colorIndex);
        addArcSegments(rightPoints, colorIndex);
        addArcSegments(bottomPoints, colorIndex);
        addArcSegments(leftPoints, colorIndex);
    }

    // Draw all global segments to the canvas.
    drawGlobalSegments();

    // Draw registration markers and the color palette bars.
    drawMarkers();
    addColorPaletteBars();
}

/**
 * Given an array of points (an arc), convert to line segments and add to globalSegments.
 * Also, record the path data for SVG export.
 */
function addArcSegments(points, colorIndex) {
    let d = '';
    for (let i = 0; i < points.length - 1; i++) {
        let seg = {
            x1: points[i].x,
            y1: points[i].y,
            x2: points[i+1].x,
            y2: points[i+1].y,
            colorIndex: colorIndex
        };
        globalSegments.push(seg);
        d += `M${seg.x1.toFixed(2)},${seg.y1.toFixed(2)}L${seg.x2.toFixed(2)},${seg.y2.toFixed(2)} `;
    }
    if (d !== '') {
        pathData.push({ colorIndex: colorIndex, d: d.trim() });
    }
}

/**
 * Draw all line segments stored in globalSegments.
 */
function drawGlobalSegments() {
    background(255);
    // Group segments by color.
    let grouped = {};
    for (let seg of globalSegments) {
        if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
        grouped[seg.colorIndex].push(seg);
    }
    // Draw each group.
    for (let key in grouped) {
        let cIdx = parseInt(key);
        let col = colors[cIdx];
        applyStrokeWithOpacity(col.hex);
        strokeWeight(strokeWeightValue);
        beginShape(LINES);
        for (let s of grouped[cIdx]) {
            vertex(s.x1, s.y1);
            vertex(s.x2, s.y2);
        }
        endShape();
    }
}

/**
 * =======================================
 * Registration Markers & Palette Bars
 * =======================================
 */
function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    line(0, 0, 5, 0);
    line(0, 0, 0, 5);
    line(width - 5, height, width, height);
    line(width, height - 5, width, height);
}

function addColorPaletteBars() {
    let paletteLength = 300;   
    let barHeight = 2;        
    let gapSize = 7;          
    let yStart = height - (1.25 * pixelsPerInch);

    let usedColorsOrdered = selectedColorIndices;
    let numColors = usedColorsOrdered.length;
    if (numColors === 0) return;

    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;

    strokeWeight(barHeight);
    usedColorsOrdered.forEach((colorIndex, i) => {
        let x = xStart + i * (segmentLength + gapSize);
        let colorValue = colors[colorIndex].hex;
        applyStrokeWithOpacity(colorValue);
        line(x, yStart, x + segmentLength, yStart);
    });
}

/**
 * =======================================
 * SVG Export
 * =======================================
 */
function keyPressed() {
    if (key === ' ') {
        saveSVGs();
    } else if (key === 'r' || key === 'R') {
        resetCanvas();
    }
}

function resetCanvas() {
    globalSegments = [];
    pathData = [];
    drawNestedArcs();
}

function saveSVGs() {
    const ts = Date.now();
    let combinedSVG = generateSVG(0);
    saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

    selectedColorIndices.forEach((cidx) => {
        let colorSVG = generateSVG(cidx);
        let cName = colors[cidx].name.toUpperCase();
        let fileName = `${dayNumber}-0${cidx}-${cName}-PORTRAIT-${ts}.svg`;
        saveSVGFile(colorSVG, fileName);
    });
}

function generateSVG(activeColor = 0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
    svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

    svgContent += addMarkersSVG();

    // Group globalSegments by color.
    let grouped = {};
    for (let seg of globalSegments) {
        if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
        grouped[seg.colorIndex].push(seg);
    }

    if (activeColor === 0) {
        let layerNum = 1;
        for (let cIdx of selectedColorIndices) {
            svgContent += addSegmentsSVG(cIdx, layerNum);
            layerNum++;
        }
    } else {
        let layerNum = selectedColorIndices.indexOf(activeColor) + 1;
        svgContent += addSegmentsSVG(activeColor, layerNum);
    }

    svgContent += '</svg>';
    return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
    let col = colors[colorIndex];
    let svg = `<g
   inkscape:groupmode="layer"
   id="layer${layerNum}"
   inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
   style="display:inline"
   stroke="${col.hex}"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="${col.hex}">n`;

    let segs = globalSegments.filter(s => s.colorIndex === colorIndex);
    if (segs.length > 0) {
        let d = '';
        for (let s of segs) {
            d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
        }
        svg += `<path d="${d.trim()}" stroke-width="${strokeWeightValue}" fill="none" />n`;
    }

    let usedColorsOrdered = selectedColorIndices;
    let i = usedColorsOrdered.indexOf(colorIndex);
    if (i >= 0) {
        let paletteLength = 300;
        let barHeight = 2;
        let gapSize = 7;
        let yStart = height - (1.25 * pixelsPerInch);
        let numColors = usedColorsOrdered.length;
        let totalGaps = (numColors - 1) * gapSize;
        let segmentLength = (paletteLength - totalGaps) / numColors;
        let xStart = (width - paletteLength) / 2;
        let x = xStart + i * (segmentLength + gapSize);
        svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x + segmentLength).toFixed(2)}" stroke="${col.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none" />n`;
    }

    svg += '</g>n';
    return svg;
}

function addMarkersSVG() {
    const sw = 1;
    const offset = sw / 2;
    return `<g
       inkscape:groupmode="layer"
       id="layer0"
       inkscape:label="0-markers"
       style="display:inline"
       stroke="black"
       stroke-opacity="${strokeOpacity}"
       inkscape:highlight-color="black">
<path d="M${5 + offset},${offset}L${offset},${offset}L${offset},${5 + offset}
M${(width - 5 - offset).toFixed(2)},${(height - offset).toFixed(2)}
L${(width - offset).toFixed(2)},${(height - offset).toFixed(2)}
L${(width - offset).toFixed(2)},${(height - 5 - offset).toFixed(2)}" stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
    let blob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' });
    let url = URL.createObjectURL(blob);
    let link = document.createElement('a');
    link.href = url;
    link.download = fileName;
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Nested Arc Layers)
=======================================

### Title: *Torsional Reaches: Layered Inward*

### Medium: Generative Drawing on Paper

### Keywords: generative art, arcs, layering, inward, margins, intersection, torsion, minimalism

### Concept

We begin by drawing four arcs along the margins of the work area, one for each edge. 
Subsequent arcs are placed inward: each new arc starts at a random point on an existing arc 
and continues, step by step, with a gentle “torsion” until it intersects another arc. 
This ensures that every arc’s endpoints lie on previously drawn arcs, creating a nested, 
layered effect that converges inward. By using only single-stroke lines, the piece is 
pen-plotter-friendly and visually highlights the interdependence among arcs.

### Technical Approach

1. **Margin Arcs**  
   - Draw four arcs from corner to corner (top, right, bottom, left) using a random, 
     gently curving “torsion” approach. These define the initial “outer boundary” arcs.

2. **Inward Arcs**  
   - For each additional arc:
     - Pick a random existing arc (polyline) and choose a random point along it as the start.
     - Pick an initial angle that points roughly inward, then walk in small steps 
       (applying a torsion offset) until intersecting another arc or leaving the margin. 
       The arc stops immediately upon intersection.

3. **Line Segments & SVG Export**  
   - All arcs are stored as short line segments in a global array. 
   - We draw those segments on the canvas and also export them in the exact same geometry to SVG, 
     ensuring consistency.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */

// We'll define how many arcs in total (including the 4 margin arcs).
// E.g., 4 arcs for the boundary + 12 more inward arcs => total 16.
let generationRules = {
  totalArcs: 16,       // total arcs (4 margin arcs + additional)
  torsion: 0.02,       // base torsion for the inward arcs
  stepLength: 10,      // step distance per iteration
  maxDeviation: 0.015, // random deviation around torsion
  minSteps: 30,        // min steps if not intersecting
  maxSteps: 60         // max steps if not intersecting
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */

let canvasWidthPixels, canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];
let strokeWeightValue;
let pathData = [];

// We'll store arcs as polylines of line segments in a global array.
// Each "arc" is an array of segments: [ {x1,y1, x2,y2, colorIndex}, ... ]
let allArcs = [];   // array of polylines
// We'll also store all line segments in one global list for easy intersection checks
let globalSegments = [];

/**
 * =======================================
 * p5.js Setup
 * =======================================
 */
function setup() {
  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustForStrokeWeight();
  selectColors();

  pathData = [];
  allArcs = [];
  globalSegments = [];

  drawAllArcs();
  noLoop();
}

/**
 * Adjust stroke weight (~0.5mm => ~2 px)
 */
function adjustForStrokeWeight() {
  strokeWeightValue = 2;
  workAreaMarginPixels += strokeWeightValue/2;
}

/**
 * Randomly select 1..9 colors
 */
function selectColors() {
  let n = floor(random(1, 10));
  selectedColorIndices = pickRandomColorIndices(n);
}

function pickRandomColorIndices(n) {
  let allIndices = Object.keys(colors).map(k=>parseInt(k));
  let chosen = [];
  while (chosen.length<n && allIndices.length>0) {
    let idx = floor(random(allIndices.length));
    chosen.push(allIndices[idx]);
    allIndices.splice(idx,1);
  }
  return chosen.sort((a,b)=>a-b);
}

/**
 * =======================================
 * Drawing Logic
 * =======================================
 */
function drawAllArcs() {
  background(255);

  // 1) Draw the 4 margin arcs first
  createMarginArcs();

  // 2) We have generationRules.totalArcs arcs total. 4 are used for margin arcs => rest are "inward arcs".
  let arcsRemaining = generationRules.totalArcs - 4;
  for (let i=0; i<arcsRemaining; i++) {
    // pick a color
    let colorIndex = random(selectedColorIndices);
    // create an inward arc
    let newArc = createInwardArc(colorIndex);
    if (newArc && newArc.length>0) {
      allArcs.push(newArc);
    }
  }

  // Now we have a bunch of arcs in allArcs + globalSegments
  drawGlobalSegments();

  // Markers + palette
  drawMarkers();
  addColorPaletteBars();
}

/**
 * createMarginArcs: 4 arcs (top, right, bottom, left),
 * each from corner to corner with a random "torsion" approach.
 */
function createMarginArcs() {
  // We'll define corners
  let leftX = workAreaMarginPixels;
  let rightX = width - workAreaMarginPixels;
  let topY = workAreaMarginPixels;
  let bottomY = height - workAreaMarginPixels;

  // top arc: from top-left corner to top-right corner
  let colorIndex = random(selectedColorIndices);
  let topArc = buildTorsionArc(
    {x:leftX, y:topY}, 
    {x:rightX, y:topY},
    colorIndex
  );
  allArcs.push(topArc);

  // right arc: from top-right corner to bottom-right corner
  colorIndex = random(selectedColorIndices);
  let rightArc = buildTorsionArc(
    {x:rightX, y:topY},
    {x:rightX, y:bottomY},
    colorIndex
  );
  allArcs.push(rightArc);

  // bottom arc: from bottom-right corner to bottom-left corner
  colorIndex = random(selectedColorIndices);
  let bottomArc = buildTorsionArc(
    {x:rightX, y:bottomY},
    {x:leftX, y:bottomY},
    colorIndex
  );
  allArcs.push(bottomArc);

  // left arc: from bottom-left corner to top-left corner
  colorIndex = random(selectedColorIndices);
  let leftArc = buildTorsionArc(
    {x:leftX, y:bottomY},
    {x:leftX, y:topY},
    colorIndex
  );
  allArcs.push(leftArc);
}

/**
 * createInwardArc:
 *   - pick a random existing arc
 *   - pick a random point on that arc as start
 *   - pick a random angle ~ inward
 *   - step with torsion until we intersect another arc or go out of bounds
 *   - store the resulting polyline
 */
function createInwardArc(colorIndex) {
  // pick a random arc from allArcs
  if (allArcs.length===0) return null;
  let arc = random(allArcs);
  if (arc.length===0) return null;

  // pick a random segment from that arc
  let seg = random(arc);
  // pick a random param t in [0..1] along seg
  let t = random(1);
  let startX = lerp(seg.x1, seg.x2, t);
  let startY = lerp(seg.y1, seg.y2, t);

  // approximate angle pointing "inward" => from margin center
  // or we do a more random approach
  let centerX = width/2, centerY = height/2;
  let dx = centerX - startX;
  let dy = centerY - startY;
  let baseAngle = atan2(dy, dx);
  // add a small random
  baseAngle += random(-0.5, 0.5);

  let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
  let newArc = [];
  let prev = {x:startX, y:startY};
  let angle = baseAngle;

  for (let i=0; i<steps; i++) {
    // random dev
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (generationRules.torsion + dev);

    let nx = prev.x + generationRules.stepLength*cos(angle);
    let ny = prev.y + generationRules.stepLength*sin(angle);

    // if out of bounds => stop
    if (!isInsideMargin(nx, ny)) {
      break;
    }

    // form a new segment
    let newSeg = { x1:prev.x, y1:prev.y, x2:nx, y2:ny, colorIndex };
    // check intersection with globalSegments
    let foundIntersect = false;
    for (let oldSeg of globalSegments) {
      let ints = lineIntersection(
        oldSeg.x1, oldSeg.y1, oldSeg.x2, oldSeg.y2,
        newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
      );
      if (ints.intersects) {
        // we have an intersection => the arc ends here
        let ix = lerp(newSeg.x1, newSeg.x2, ints.u);
        let iy = lerp(newSeg.y1, newSeg.y2, ints.u);

        // truncated segment
        let trunc = {
          x1:newSeg.x1, y1:newSeg.y1,
          x2:ix, y2:iy,
          colorIndex
        };
        newArc.push(trunc);
        globalSegments.push(trunc);

        foundIntersect = true;
        break;
      }
    }

    if (foundIntersect) {
      // done
      break;
    } else {
      // no intersection => accept the entire newSeg
      newArc.push(newSeg);
      globalSegments.push(newSeg);
      prev = {x:nx, y:ny};
    }
  }

  return newArc;
}

/**
 * buildTorsionArc(startPt, endPt, colorIndex):
 *   create a polyline from start to end using a torsion approach,
 *   but we specifically ensure we don't exit the margin or pass the end.
 *   We keep stepping until we are "close" to end or we intersect existing arcs.
 */
function buildTorsionArc(startPt, endPt, colorIndex) {
  let arcSegments = [];
  let totalDist = dist(startPt.x, startPt.y, endPt.x, endPt.y);
  let direction = atan2(endPt.y - startPt.y, endPt.x - startPt.x);

  // We'll do up to some # steps, or until we get close to the end
  let steps = floor(totalDist / generationRules.stepLength) + 5;
  let prev = {x:startPt.x, y:startPt.y};
  let remainingDist = dist(prev.x, prev.y, endPt.x, endPt.y);

  let torsionVal = 0.01; // smaller torsion for margin arcs
  for (let i=0; i<steps; i++) {
    let dev = random(-0.01, 0.01);
    direction += (torsionVal + dev);

    let nx = prev.x + generationRules.stepLength*cos(direction);
    let ny = prev.y + generationRules.stepLength*sin(direction);

    // if going out of bounds, break
    if (!isInsideMargin(nx, ny)) {
      break;
    }

    // check if we overshoot end
    let newDist = dist(nx, ny, endPt.x, endPt.y);
    if (newDist < generationRules.stepLength) {
      // we can just connect to the end
      let finalSeg = {
        x1:prev.x, y1:prev.y,
        x2:endPt.x, y2:endPt.y,
        colorIndex
      };
      arcSegments.push(finalSeg);
      globalSegments.push(finalSeg);
      break;
    }

    // else accept this step
    let newSeg = { x1:prev.x, y1:prev.y, x2:nx, y2:ny, colorIndex };
    // check intersection with globalSegments => stop if found
    let foundIntersect = false;
    for (let oldSeg of globalSegments) {
      let ints = lineIntersection(
        oldSeg.x1, oldSeg.y1, oldSeg.x2, oldSeg.y2,
        newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
      );
      if (ints.intersects) {
        // truncated
        let ix = lerp(newSeg.x1, newSeg.x2, ints.u);
        let iy = lerp(newSeg.y1, newSeg.y2, ints.u);
        let trunc = { x1:newSeg.x1, y1:newSeg.y1, x2:ix, y2:iy, colorIndex };
        arcSegments.push(trunc);
        globalSegments.push(trunc);
        foundIntersect = true;
        break;
      }
    }
    if (foundIntersect) {
      break;
    } else {
      // add normal
      arcSegments.push(newSeg);
      globalSegments.push(newSeg);
      prev = {x:nx, y:ny};
    }
  }

  // build pathData for this arc
  let d = '';
  for (let s of arcSegments) {
    d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
  }
  if (d !== '') {
    pathData.push({ colorIndex, d: d.trim() });
  }

  return arcSegments;
}

/**
 * isInsideMargin(x,y): checks if (x,y) is within the margin area
 */
function isInsideMargin(x, y) {
  return (
    x >= workAreaMarginPixels &&
    x <= (width - workAreaMarginPixels) &&
    y >= workAreaMarginPixels &&
    y <= (height - workAreaMarginPixels)
  );
}

/**
 * lineIntersection: param-based intersection
 */
function lineIntersection(x1,y1,x2,y2, x3,y3,x4,y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 0.000001) {
    return { intersects:false, t:0, u:0 };
  }
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4))/denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2))/denom;
  let inter = (t>=0 && t<=1 && u>=0 && u<=1);
  return { intersects:inter, t, u };
}

/**
 * Draw final geometry
 */
function drawGlobalSegments() {
  background(255);
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }
  for (let key in grouped) {
    let cIdx = parseInt(key);
    let col = colors[cIdx];
    applyStrokeWithOpacity(col.hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let s of grouped[cIdx]) {
      vertex(s.x1, s.y1);
      vertex(s.x2, s.y2);
    }
    endShape();
  }
}

/**
 * applyStrokeWithOpacity
 */
function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255 * strokeOpacity);
  stroke(c);
}

/**
 * Markers + color bars
 */
function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0,0,5,0);
  line(0,0,0,5);
  line(width-5,height,width,height);
  line(width,height-5,width,height);
}

function addColorPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25*pixelsPerInch);

  let usedColorsOrdered = selectedColorIndices;
  let numColors = usedColorsOrdered.length;
  if (numColors===0) return;

  let totalGaps = (numColors-1)*gapSize;
  let segmentLength = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);

  usedColorsOrdered.forEach((cIdx, i)=>{
    let x = xStart + i*(segmentLength+gapSize);
    let col = colors[cIdx].hex;
    applyStrokeWithOpacity(col);
    line(x, yStart, x+segmentLength, yStart);
  });
}

/**
 * Key handling
 */
function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  pathData = [];
  allArcs = [];
  globalSegments = [];
  drawAllArcs();
}

/**
 * SVG Export
 */
function saveSVGs() {
  const ts = Date.now();

  // combined
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  // per color
  selectedColorIndices.forEach((cIdx)=>{
    let cSVG = generateSVG(cIdx);
    let cName = colors[cIdx].name.toUpperCase();
    let fileName = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(cSVG, fileName);
  });
}

function generateSVG(activeColor=0) {
  let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svgContent += addMarkersSVG();

  // group by color
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  if (activeColor===0) {
    let layerNum = 1;
    for (let cIdx of selectedColorIndices) {
      svgContent += addSegmentsSVG(cIdx, layerNum);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    svgContent += addSegmentsSVG(activeColor, layerNum);
  }

  svgContent += '</svg>';
  return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum) {
  let col = colors[colorIndex];
  let svg = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${col.hex}">n`;

  let segs = globalSegments.filter(s=> s.colorIndex===colorIndex);
  if (segs.length>0) {
    let d = '';
    for (let s of segs) {
      d += `M${s.x1.toFixed(2)},${s.y1.toFixed(2)}L${s.x2.toFixed(2)},${s.y2.toFixed(2)} `;
    }
    svg += `<path d="${d.trim()}" stroke-width="${strokeWeightValue}" fill="none" />n`;
  }

  // palette bar
  let usedColorsOrdered = selectedColorIndices;
  let i = usedColorsOrdered.indexOf(colorIndex);
  if (i>=0) {
    let paletteLength=300, barHeight=2, gapSize=7;
    let yStart = height - (1.25*pixelsPerInch);
    let numColors = usedColorsOrdered.length;
    let totalGaps = (numColors -1)*gapSize;
    let segmentLength = (paletteLength - totalGaps)/numColors;
    let xStart = (width-paletteLength)/2;
    let cx = xStart + i*(segmentLength+gapSize);

    svg += `<path d="M${cx.toFixed(2)},${yStart.toFixed(2)}H${(cx+segmentLength).toFixed(2)}"
 stroke="${col.hex}" stroke-opacity="${strokeOpacity}"
 stroke-width="${barHeight}" fill="none"/>n`;
  }

  svg += '</g>n';
  return svg;
}

function addMarkersSVG() {
  const sw=1;
  const offset=sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${5+offset},${offset}L${offset},${offset}L${offset},${5+offset}
M${(width-5-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-offset).toFixed(2)}
L${(width-offset).toFixed(2)},${(height-5-offset).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
  let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fileName;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, symmetry, lines, minimalism

### Conceptual Framework

In “Torsional Reaches,” I visualize my identity as a series of twisting arcs that fan
out from the margins of the page. Each arc begins at the boundary—an external point
of contact—and spirals inward, reacting to invisible pivot forces. These forces
create gentle torsions that alter each arc’s direction, reflecting the notion that
my identity is shaped by interplay between internal and external influences. Instead
of converging at a single center, arcs can cross, drift, and gently bend, suggesting
the many ways in which identity can interweave with—yet not be subsumed by—others.

### Technical Approach

1. **Arc Generation**:  
   - I randomly select several anchor points around the canvas edges.  
   - From each anchor, I generate a curving path influenced by a “torsion factor,” 
     a small rotation that shifts the trajectory at each iterative step.  
   - The arcs expand inward, with small per-step variations in curvature to ensure 
     they remain distinct and do not strictly overlap.

2. **Path Tracking**:  
   - For each drawn arc, I record its path commands in `pathData`.  
   - Each path is assigned one color from the user-selected palette, ensuring that 
     canvas rendering and SVG export remain synchronized.

3. **Non-Overlapping Stroke**:  
   - While arcs can cross, I avoid retracing any exact path to prevent clogged lines.  
   - The arcs remain sparse enough that crossing lines stay distinct.

4. **Appearance**:  
   - I use only the predefined nine colors, with 0.8 opacity.  
   - No fills are used, only stroke lines to retain clarity.  

The result is a balanced interplay of arcs that shift gently as they travel, merging
structure and spontaneity to reflect the torsional nature of identity.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings (immutable)
const canvasWidthInches = 11;     // Width of the canvas in inches
const canvasHeightInches = 11;    // Height of the canvas in inches
const pixelsPerInch = 100;        // Pixels per inch (resolution)
const dayNumber = '153';          // Day number for file naming

// Color palette (immutable)
const colors = {
    1: { name: 'ORANGE', ink: 5, width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN', ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED', ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE', ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN', ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE', ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK', ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA', ink: 117, width: 0.45, hex: '#856647' }
};

// Set the stroke opacity for both SVG and canvas
const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
    numArcs: 18,         // number of arcs to attempt from the edges
    minSteps: 40,        // minimum points per arc
    maxSteps: 80,        // maximum points per arc
    torsion: 0.03,       // small rotational influence at each step
    stepLength: 10,      // distance moved per segment
    maxDeviation: 0.02   // random variation factor in torsion or step angle
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */

let canvasWidthPixels;          // Canvas width in pixels
let canvasHeightPixels;         // Canvas height in pixels
let workAreaMarginInches = 2;   // This will be randomized in setup()
let workAreaMarginPixels;       // Work area margin in pixels
let selectedColorIndices = [];  // Indices of selected colors for the drawing

let usedColors = new Set();     // Track used colors
let strokeWeightValue;          // Stroke weight for 0.5mm lines
let pathData = [];              // Array to store path info for SVG

/**
 * Applies the stroke color with the given hex and sets its alpha based on strokeOpacity.
 * @param {string} hexColor - The hex color value.
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

/**
 * =======================================
 * p5.js Setup Function
 * =======================================
 */

function setup() {
    // OPTIONAL: fix a random seed to get the same arrangement each time.
    // Change the number below if you want a different "locked" arrangement.
    // Or remove this line entirely if you want a new random arrangement every run.
    randomSeed(153);

    // Initialize canvas dimensions
    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    // Initialize work area margin
    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    // Adjust for stroke weight
    adjustForStrokeWeight();

    // Select colors
    selectColors();

    // Clear pathData
    pathData = [];

    // Generate the artwork
    drawShapes();

    noLoop();
}

/**
 * Adjust stroke weight
 */
function adjustForStrokeWeight() {
    // ~0.5mm line => ~2px at 100dpi
    strokeWeightValue = 2;
    workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Color Selection
 */
function selectColors() {
    // 1 to 9 unique colors
    let numColorsToUse = floor(random(1, 10)); 
    selectedColorIndices = selectRandomColorIndices(numColorsToUse);
}

function selectRandomColorIndices(n) {
    let indices = Object.keys(colors).map(k => parseInt(k));
    let selected = [];
    while (selected.length < n && indices.length > 0) {
        let idx = floor(random(indices.length));
        selected.push(indices[idx]);
        indices.splice(idx, 1);
    }
    return selected.sort((a, b) => a - b);
}

/**
 * =======================================
 * Drawing
 * =======================================
 */

function drawShapes() {
    background(255);

    // Draw arcs
    drawTorsionalArcs();

    // Draw markers + color bars
    drawMarkers();
    addColorPaletteBars();
}

/**
 * Draw the arcs that represent "Torsional Reaches"
 */
function drawTorsionalArcs() {
    let arcsToDraw = generationRules.numArcs;

    for (let i = 0; i < arcsToDraw; i++) {
        // randomly choose a color
        let colorIndex = random(selectedColorIndices);
        let col = colors[colorIndex];

        let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
        let path = createOneArcPath(steps);

        // Draw on canvas
        strokeWeight(strokeWeightValue);
        applyStrokeWithOpacity(col.hex);
        beginShape();
        for (let j = 0; j < path.points.length; j++) {
            vertex(path.points[j].x, path.points[j].y);
        }
        endShape();

        // Save path data for SVG
        // Build a d-attribute string with M,L commands
        let d = '';
        for (let k = 0; k < path.points.length; k++) {
            let px = path.points[k].x.toFixed(2);
            let py = path.points[k].y.toFixed(2);
            if (k === 0) {
                d += `M${px},${py} `;
            } else {
                d += `L${px},${py} `;
            }
        }

        // Push to pathData
        pathData.push({
            colorIndex: colorIndex,
            d: d.trim()
        });
    }
}

/**
 * Create a single arc path from a random edge anchor
 * influenced by a small "torsion" at each step.
 */
function createOneArcPath(steps) {
    // pick a random anchor on the boundary
    let anchor = getRandomBoundaryPoint();

    let points = [];
    points.push(anchor);

    // initial angle pointing somewhat inward
    let angle = getInitialAngle(anchor);
    let torsionBase = generationRules.torsion;

    for (let i = 0; i < steps; i++) {
        // random deviation in the torsion
        let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
        angle += (torsionBase + dev);

        // create a new point
        let prev = points[points.length - 1];
        let nx = prev.x + generationRules.stepLength * cos(angle);
        let ny = prev.y + generationRules.stepLength * sin(angle);

        // if out of bounds, break early
        if (
            nx < workAreaMarginPixels ||
            ny < workAreaMarginPixels ||
            nx > (width - workAreaMarginPixels) ||
            ny > (height - workAreaMarginPixels)
        ) {
            break;
        }

        points.push({ x: nx, y: ny });
    }

    return { points };
}

/**
 * Get a random anchor on the boundary (top, bottom, left, or right).
 */
function getRandomBoundaryPoint() {
    // pick side
    let side = floor(random(4));
    let x, y;

    let minPix = workAreaMarginPixels;
    let maxPixX = width - workAreaMarginPixels;
    let maxPixY = height - workAreaMarginPixels;

    if (side === 0) {
        // top
        x = random(minPix, maxPixX);
        y = minPix;
    } else if (side === 1) {
        // bottom
        x = random(minPix, maxPixX);
        y = maxPixY;
    } else if (side === 2) {
        // left
        x = minPix;
        y = random(minPix, maxPixY);
    } else {
        // right
        x = maxPixX;
        y = random(minPix, maxPixY);
    }

    return { x, y };
}

/**
 * Get an initial angle pointing inward from the boundary anchor.
 */
function getInitialAngle(pt) {
    let centerX = width / 2;
    let centerY = height / 2;
    // vector from pt to center
    let dx = centerX - pt.x;
    let dy = centerY - pt.y;
    let baseAngle = atan2(dy, dx);

    // random offset around baseAngle
    return baseAngle + random(-0.3, 0.3);
}

/**
 * =======================================
 * Registration Markers & Palette
 * =======================================
 */

function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    line(0, 0, 5, 0);
    line(0, 0, 0, 5);
    line(width - 5, height, width, height);
    line(width, height - 5, width, height);
}

function addColorPaletteBars() {
    let paletteLength = 300;   
    let barHeight = 2;        
    let gapSize = 7;          
    let yStart = height - (1.25 * pixelsPerInch);

    let usedColorsOrdered = selectedColorIndices;
    let numColors = usedColorsOrdered.length;
    if (numColors === 0) return;

    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;

    strokeWeight(barHeight);

    usedColorsOrdered.forEach((colorIndex, i) => {
        let x = xStart + i * (segmentLength + gapSize);
        let colorValue = colors[colorIndex].hex;
        applyStrokeWithOpacity(colorValue);
        line(x, yStart, x + segmentLength, yStart);
    });
}

/**
 * =======================================
 * Canvas Reset
 * =======================================
 */

function resetCanvas() {
    usedColors.clear();
    pathData = [];
    drawShapes();
}

/**
 * =======================================
 * p5.js Key Press Handling
 * =======================================
 */

function keyPressed() {
    if (key === ' ') {
        // Export the artwork as SVGs
        saveSVGs();
    } else if (key === 'r' || key === 'R') {
        resetCanvas();
    }
}

/**
 * =======================================
 * SVG Export
 * =======================================
 */

function saveSVGs() {
    const timestamp = Date.now();

    // Combined
    let combinedSVG = generateSVG(0);
    saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${timestamp}.svg`);

    // Individual
    let usedColorsOrdered = selectedColorIndices;
    usedColorsOrdered.forEach((colorIndex) => {
        let colorSVG = generateSVG(colorIndex);
        let colorName = colors[colorIndex].name.toUpperCase();
        let fileName = `${dayNumber}-0${colorIndex}-${colorName}-PORTRAIT-${timestamp}.svg`;
        saveSVGFile(colorSVG, fileName);
    });
}

function generateSVG(activeColor = 0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
    svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

    // Add markers
    svgContent += addMarkersSVG();

    if (activeColor === 0) {
        // all colors
        selectedColorIndices.forEach((colorIndex, idx) => {
            svgContent += addSegmentsSVG(colorIndex, idx + 1, 0);
        });
    } else {
        // single color
        let idx = selectedColorIndices.indexOf(activeColor) + 1;
        svgContent += addSegmentsSVG(activeColor, idx, activeColor);
    }

    svgContent += '</svg>';
    return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum, activeColor) {
    let svg = '';
    let color = colors[colorIndex];
    let strokeWidth = strokeWeightValue; 

    svg += `<g
   inkscape:groupmode="layer"
   id="layer${layerNum}"
   inkscape:label="${colorIndex}-${color.name.toLowerCase()}-${color.ink}-${color.width}"
   style="display:inline"
   stroke="${color.hex}"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="${color.hex}">n`;

    // gather all pathData matching colorIndex (if activeColor != 0)
    // or gather all if activeColor == 0
    let relevantPaths = [];
    if (activeColor === 0) {
        // all paths for this colorIndex
        relevantPaths = pathData.filter(p => p.colorIndex === colorIndex);
    } else {
        // only paths for this colorIndex
        relevantPaths = pathData.filter(p => p.colorIndex === activeColor);
    }

    // Combine them
    if (relevantPaths.length > 0) {
        // For clarity, create one <path> per entry
        relevantPaths.forEach(rp => {
            svg += `<path d="${rp.d}" stroke-width="${strokeWidth}" fill="none" />n`;
        });
    }

    // palette bar
    let usedColorsOrdered = selectedColorIndices;
    let i = usedColorsOrdered.indexOf(colorIndex);
    if (i >= 0) {
        let paletteLength = 300;
        let barHeight = 2;
        let gapSize = 7;
        let yStart = height - (1.25 * pixelsPerInch);
        let numColors = usedColorsOrdered.length;
        let totalGaps = (numColors - 1) * gapSize;
        let segmentLength = (paletteLength - totalGaps) / numColors;
        let xStart = (width - paletteLength) / 2;
        let x = xStart + i * (segmentLength + gapSize);

        svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)} H${(x + segmentLength).toFixed(2)}"
            stroke="${color.hex}" stroke-opacity="${strokeOpacity}"
            stroke-width="${barHeight}" fill="none"/>n`;
    }

    svg += '</g>n';
    return svg;
}

/**
 * Registration markers in SVG
 */
function addMarkersSVG() {
    const strokeWidth = 1;
    const offset = strokeWidth / 2;
    return `<g
       inkscape:groupmode="layer"
       id="layer0"
       inkscape:label="0-markers"
       style="display:inline"
       stroke="black"
       stroke-opacity="${strokeOpacity}"
       inkscape:highlight-color="black">n
    <path d="M${5 + offset},${offset} L${offset},${offset} L${offset},${5 + offset}
    M${(width - 5 - offset).toFixed(2)},${(height - offset).toFixed(2)}
     L${(width - offset).toFixed(2)},${(height - offset).toFixed(2)}
     L${(width - offset).toFixed(2)},${(height - 5 - offset).toFixed(2)}"
     stroke-width="${strokeWidth}" fill="none" />n
    </g>n`;
}

/**
 * Save an SVG file
 */
function saveSVGFile(svgData, fileName) {
    let blob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' });
    let url = URL.createObjectURL(blob);
    let link = document.createElement('a');
    link.href = url;
    link.download = fileName;

    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);

    URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, symmetry, lines, minimalism

### Conceptual Framework

In “Torsional Reaches,” I visualize my identity as a series of twisting arcs that fan
out from the margins of the page. Each arc begins at the boundary—an external point
of contact—and spirals inward under a gentle “torsion” force. Importantly, as an arc
progresses, if it meets an already drawn arc, it immediately stops. In this way, the
inner arcs start exactly on an existing arc and terminate upon touching another.
The result is a layered composition of arcs that interact and “occlude” one another,
all rendered as single‑stroke lines (with 0.8 opacity) so that a pen plotter can
faithfully reproduce the work.

### Technical Approach

1. **Arc Generation with Occlusion**  
   - A random anchor point is chosen along the work area boundary.
   - The arc is built step by step using a base torsion plus a small random deviation.
   - For each new segment, a check is made against all previously drawn segments.
   - If an intersection is found, the new arc is truncated at that intersection and stops.

2. **Path Tracking & Consistency**  
   - Each arc’s points are recorded and the generated line segments are stored in a
     global array.
   - The on‑canvas drawing is rendered from these segments, and the same geometry is used
     for SVG export—ensuring a perfect match.

3. **Appearance**  
   - Only the predefined nine colors (with 0.8 opacity) are used.
   - No fills are applied; only strokes are drawn to maintain clarity for pen plotting.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings
const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

// Color palette
const colors = {
    1: { name: 'ORANGE', ink: 5, width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN', ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED', ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE', ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN', ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE', ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK', ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA', ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
    numArcs: 18,         // number of arcs attempted from the edges
    minSteps: 40,        // minimum points per arc
    maxSteps: 80,        // maximum points per arc
    torsion: 0.03,       // base rotational influence per step
    stepLength: 10,      // step length in pixels
    maxDeviation: 0.02   // random deviation in torsion per step
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */
let canvasWidthPixels;
let canvasHeightPixels;
let workAreaMarginInches = 2;   // randomized in setup()
let workAreaMarginPixels;
let selectedColorIndices = [];

// We'll record all the drawn segments here for occlusion checking:
let globalSegments = [];

// For SVG export:
let pathData = [];

/**
 * Applies stroke with given hex color (adjusting opacity).
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

/**
 * =======================================
 * p5.js Setup Function
 * =======================================
 */
function setup() {
    // Uncomment to fix randomness:
    // randomSeed(153);

    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    adjustForStrokeWeight();
    selectColors();

    // Clear global arrays
    globalSegments = [];
    pathData = [];

    drawShapes();
    noLoop();
}

/**
 * Adjust stroke weight (~0.5mm ~2px at 100dpi)
 */
function adjustForStrokeWeight() {
    strokeWeightValue = 2;
    workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Randomly select 1 to 9 unique colors from the palette.
 */
function selectColors() {
    let numColorsToUse = floor(random(1, 10));
    selectedColorIndices = selectRandomColorIndices(numColorsToUse);
}

function selectRandomColorIndices(n) {
    let indices = Object.keys(colors).map(k => parseInt(k));
    let selected = [];
    while (selected.length < n && indices.length > 0) {
        let idx = floor(random(indices.length));
        selected.push(indices[idx]);
        indices.splice(idx, 1);
    }
    return selected.sort((a, b) => a - b);
}

/**
 * =======================================
 * Drawing Routine
 * =======================================
 */
function drawShapes() {
    background(255);
    // Clear global segments for occlusion
    globalSegments = [];

    // For each arc...
    let arcsToDraw = generationRules.numArcs;
    for (let i = 0; i < arcsToDraw; i++) {
        // Choose a random color from our palette
        let colorIndex = random(selectedColorIndices);
        let col = colors[colorIndex];

        // Randomly choose number of steps within bounds
        let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
        // Generate arc path with occlusion: it will stop if it intersects an earlier arc.
        let arcPath = createOneArcPath(steps);
        // Draw the arc on canvas
        strokeWeight(strokeWeightValue);
        applyStrokeWithOpacity(col.hex);
        beginShape();
        for (let j = 0; j < arcPath.points.length; j++) {
            vertex(arcPath.points[j].x, arcPath.points[j].y);
        }
        endShape();

        // Save its path for SVG export (as a string of M/L commands)
        let d = "";
        for (let k = 0; k < arcPath.points.length; k++) {
            let px = arcPath.points[k].x.toFixed(2);
            let py = arcPath.points[k].y.toFixed(2);
            if (k === 0) {
                d += `M${px},${py} `;
            } else {
                d += `L${px},${py} `;
            }
        }
        pathData.push({ colorIndex, d: d.trim() });
    }

    // Draw markers and color palette bars
    drawMarkers();
    addColorPaletteBars();
}

/**
 * Create one arc path starting from a random boundary anchor.
 * As soon as a new segment intersects any previously drawn segment (in globalSegments),
 * the arc stops growing.
 */
function createOneArcPath(steps) {
    let anchor = getRandomBoundaryPoint();
    let points = [];
    points.push(anchor);

    let angle = getInitialAngle(anchor);
    let torsionBase = generationRules.torsion;

    for (let i = 0; i < steps; i++) {
        let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
        angle += (torsionBase + dev);

        let prev = points[points.length - 1];
        let nx = prev.x + generationRules.stepLength * cos(angle);
        let ny = prev.y + generationRules.stepLength * sin(angle);

        // If the new point is outside the work area, stop.
        if (
            nx < workAreaMarginPixels ||
            ny < workAreaMarginPixels ||
            nx > (width - workAreaMarginPixels) ||
            ny > (height - workAreaMarginPixels)
        ) {
            break;
        }

        let newPoint = { x: nx, y: ny };
        let newSegment = { x1: prev.x, y1: prev.y, x2: newPoint.x, y2: newPoint.y };

        // Check for intersection with any previously drawn segment.
        let intersected = false;
        for (let seg of globalSegments) {
            let inter = lineIntersection(seg.x1, seg.y1, seg.x2, seg.y2,
                                         newSegment.x1, newSegment.y1, newSegment.x2, newSegment.y2);
            if (inter.intersects) {
                // Compute intersection point.
                let ix = lerp(newSegment.x1, newSegment.x2, inter.u);
                let iy = lerp(newSegment.y1, newSegment.y2, inter.u);
                points.push({ x: ix, y: iy });
                // Also add the truncated segment.
                globalSegments.push({ x1: prev.x, y1: prev.y, x2: ix, y2: iy });
                intersected = true;
                break;
            }
        }
        if (intersected) {
            break;
        } else {
            points.push(newPoint);
            globalSegments.push(newSegment);
        }
    }

    return { points };
}

/**
 * Get a random anchor point along the boundary (one of top, bottom, left, or right)
 */
function getRandomBoundaryPoint() {
    let side = floor(random(4));
    let x, y;
    let minPix = workAreaMarginPixels;
    let maxPixX = width - workAreaMarginPixels;
    let maxPixY = height - workAreaMarginPixels;
    if (side === 0) {       // top
        x = random(minPix, maxPixX);
        y = minPix;
    } else if (side === 1) { // bottom
        x = random(minPix, maxPixX);
        y = maxPixY;
    } else if (side === 2) { // left
        x = minPix;
        y = random(minPix, maxPixY);
    } else {                // right
        x = maxPixX;
        y = random(minPix, maxPixY);
    }
    return { x, y };
}

/**
 * Get an initial angle pointing inward from the boundary.
 */
function getInitialAngle(pt) {
    let centerX = width / 2;
    let centerY = height / 2;
    let dx = centerX - pt.x;
    let dy = centerY - pt.y;
    let baseAngle = atan2(dy, dx);
    return baseAngle + random(-0.3, 0.3);
}

/**
 * Compute line-line intersection using parametric equations.
 * Returns an object { intersects, t, u } where t is the parameter along the first line
 * and u along the second. If lines are parallel, returns intersects=false.
 */
function lineIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {
    let denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
    if (abs(denom) < 0.000001) {
        return { intersects: false, t: 0, u: 0 };
    }
    let t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
    let u = ((x1 - x3) * (y1 - y2) - (y1 - y3) * (x1 - x2)) / denom;
    let inter = (t >= 0 && t <= 1 && u >= 0 && u <= 1);
    return { intersects: inter, t, u };
}

/**
 * =======================================
 * Registration Markers & Palette Bars
 * =======================================
 */
function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    line(0, 0, 5, 0);
    line(0, 0, 0, 5);
    line(width - 5, height, width, height);
    line(width, height - 5, width, height);
}

function addColorPaletteBars() {
    let paletteLength = 300;
    let barHeight = 2;
    let gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);
    let usedColorsOrdered = selectedColorIndices;
    let numColors = usedColorsOrdered.length;
    if (numColors === 0) return;
    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;
    strokeWeight(barHeight);
    usedColorsOrdered.forEach((colorIndex, i) => {
        let x = xStart + i * (segmentLength + gapSize);
        let col = colors[colorIndex].hex;
        applyStrokeWithOpacity(col);
        line(x, yStart, x + segmentLength, yStart);
    });
}

/**
 * =======================================
 * Canvas Reset & Key Handling
 * =======================================
 */
function resetCanvas() {
    globalSegments = [];
    pathData = [];
    drawShapes();
}

function keyPressed() {
    if (key === ' ') {
        saveSVGs();
    } else if (key === 'r' || key === 'R') {
        resetCanvas();
    }
}

/**
 * =======================================
 * SVG Export
 * =======================================
 */
function saveSVGs() {
    const timestamp = Date.now();
    let combinedSVG = generateSVG(0);
    saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${timestamp}.svg`);
    selectedColorIndices.forEach((colorIndex) => {
        let colorSVG = generateSVG(colorIndex);
        let colorName = colors[colorIndex].name.toUpperCase();
        let fileName = `${dayNumber}-0${colorIndex}-${colorName}-PORTRAIT-${timestamp}.svg`;
        saveSVGFile(colorSVG, fileName);
    });
}

function generateSVG(activeColor = 0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
    svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
    svgContent += addMarkersSVG();
    if (activeColor === 0) {
        selectedColorIndices.forEach((colorIndex, idx) => {
            svgContent += addSegmentsSVG(colorIndex, idx + 1, 0);
        });
    } else {
        let idx = selectedColorIndices.indexOf(activeColor) + 1;
        svgContent += addSegmentsSVG(activeColor, idx, activeColor);
    }
    svgContent += '</svg>';
    return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum, activeColor) {
    let svg = '';
    let color = colors[colorIndex];
    let strokeWidth = strokeWeightValue;
    svg += `<g
   inkscape:groupmode="layer"
   id="layer${layerNum}"
   inkscape:label="${colorIndex}-${color.name.toLowerCase()}-${color.ink}-${color.width}"
   style="display:inline"
   stroke="${color.hex}"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="${color.hex}">n`;
    let relevantPaths = [];
    if (activeColor === 0) {
        relevantPaths = pathData.filter(p => p.colorIndex === colorIndex);
    } else {
        relevantPaths = pathData.filter(p => p.colorIndex === activeColor);
    }
    if (relevantPaths.length > 0) {
        relevantPaths.forEach(rp => {
            svg += `<path d="${rp.d}" stroke-width="${strokeWidth}" fill="none" />n`;
        });
    }
    let usedColorsOrdered = selectedColorIndices;
    let i = usedColorsOrdered.indexOf(colorIndex);
    if (i >= 0) {
        let paletteLength = 300;
        let barHeight = 2;
        let gapSize = 7;
        let yStart = height - (1.25 * pixelsPerInch);
        let numColors = usedColorsOrdered.length;
        let totalGaps = (numColors - 1) * gapSize;
        let segmentLength = (paletteLength - totalGaps) / numColors;
        let xStart = (width - paletteLength) / 2;
        let x = xStart + i * (segmentLength + gapSize);
        svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)} H${(x + segmentLength).toFixed(2)}" stroke="${color.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" id="${colorIndex}-${color.name.toLowerCase()}-palettebar" fill="none"/>n`;
    }
    svg += '</g>n';
    return svg;
}

function addMarkersSVG() {
    const sw = 1;
    const offset = sw / 2;
    return `<g
       inkscape:groupmode="layer"
       id="layer0"
       inkscape:label="0-markers"
       style="display:inline"
       stroke="black"
       stroke-opacity="${strokeOpacity}"
       inkscape:highlight-color="black">n
    <path d="M${(5 + offset).toFixed(2)},${offset.toFixed(2)} L${offset.toFixed(2)},${offset.toFixed(2)} L${offset.toFixed(2)},${(5 + offset).toFixed(2)}
    M${(width - 5 - offset).toFixed(2)},${(height - offset).toFixed(2)} L${(width - offset).toFixed(2)},${(height - offset).toFixed(2)} L${(width - offset).toFixed(2)},${(height - 5 - offset).toFixed(2)}" stroke-width="${sw}" fill="none" />n
    </g>n`;
}

function saveSVGFile(svgData, fileName) {
    let blob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' });
    let url = URL.createObjectURL(blob);
    let link = document.createElement('a');
    link.href = url;
    link.download = fileName;
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches with Polygon-Based Occlusion)
=======================================

### Title: *Torsional Reaches (Polygon Occlusion)*

### Medium: Generative Drawing on Paper

### Keywords: generative art, arcs, torsion, layering, occlusion, polygon band,
              single-stroke, pen-plotter, random

### Concept

This variation of “Torsional Reaches” implements a layered occlusion effect by approximating
each arc’s pen stroke as a thin polygon band. Whenever a new arc is added, any older arcs
that lie within this band are clipped, so the newer arc visually sits on top. This approach
uses only single-stroke lines—no fills—ensuring pen-plotter compatibility while allowing
arcs to hide or reveal one another.

### Technical Approach

1. **Arc Generation**  
   - As in “Torsional Reaches,” each arc starts from a random boundary anchor and grows inward
     under a small torsion.  
   - We store each arc as a polyline of points.

2. **Polygon “Band”**  
   - Once an arc is complete, we offset its polyline outward and inward by half the stroke width,
     forming a closed polygon approximating the pen stroke.  
   - This polygon is used to clip older arcs.

3. **Layered Occlusion**  
   - The polygon is treated as an opaque shape. Any segments from older arcs that fall inside
     this polygon are removed (“occluded”).

4. **Final Rendering & Export**  
   - We maintain a global list of the visible line segments, from bottom (oldest) to top (newest).  
   - The canvas draws these segments in order, and the same geometry is exported to SVG.

---
*/

//////////////////////////////////////////////////////
// Constants & Setup
//////////////////////////////////////////////////////

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const dpi = 100;
const dayNumber = '153';

const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

let generationRules = {
  numArcs: 12,         // how many arcs to draw
  minSteps: 30,        // min points in an arc
  maxSteps: 60,        // max points in an arc
  torsion: 0.03,       // base rotational offset
  stepLength: 10,      // distance per step
  maxDeviation: 0.02   // random dev in torsion
};

let canvasWidth, canvasHeight;
let marginInches = 2;
let marginPixels;
let strokeWeightValue;

// color selection
let selectedColorIndices = [];

// We store the final visible line segments in globalSegments
// Each segment: {x1, y1, x2, y2, colorIndex}
let globalSegments = [];

/**
 * For SVG export, we also store path data strings
 */
let pathData = [];

function setup() {
  // optional: randomSeed(153);

  canvasWidth = canvasWidthInches * dpi;
  canvasHeight = canvasHeightInches * dpi;
  createCanvas(canvasWidth, canvasHeight);

  marginInches = random(1.5, 4);
  marginPixels = marginInches * dpi;

  adjustStrokeWeight();
  pickColors();

  // Clear old data
  globalSegments = [];
  pathData = [];

  // Generate arcs
  drawArcs();

  noLoop();
}

function adjustStrokeWeight() {
  // ~0.5mm => ~2px
  strokeWeightValue = 2;
  marginPixels += strokeWeightValue / 2;
}

function pickColors() {
  let n = floor(random(1, 10));
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  shuffle(allIndices, true);
  selectedColorIndices = allIndices.slice(0, n).sort((a, b) => a - b);
}

function drawArcs() {
  background(255);

  let arcsToDraw = generationRules.numArcs;
  for (let i = 0; i < arcsToDraw; i++) {
    let colorIndex = random(selectedColorIndices);
    let col = colors[colorIndex];

    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
    let polyline = buildArcPolyline(steps);

    // Convert the polyline to line segments & add them to globalSegments
    // But first, we must do polygon-based occlusion:
    // 1) build the polygon band
    // 2) clip older segments behind it
    let bandPoly = buildArcBandPolygon(polyline, strokeWeightValue);

    // clip older segments
    for (let s = 0; s < globalSegments.length; s++) {
      let oldSeg = globalSegments[s];
      // We subdivide oldSeg if it intersects the band
      // We'll do a simpler approach: if the midpoint of oldSeg is inside band, remove it entirely
      // For a more accurate approach, you'd do linePolygon clipping
      let mx = (oldSeg.x1 + oldSeg.x2) * 0.5;
      let my = (oldSeg.y1 + oldSeg.y2) * 0.5;
      if (pointInPolygon(mx, my, bandPoly)) {
        // remove
        globalSegments.splice(s, 1);
        s--;
      }
    }

    // Now add the new arc’s line segments on top
    let arcSegments = polylineToSegments(polyline);
    for (let seg of arcSegments) {
      seg.colorIndex = colorIndex;
      globalSegments.push(seg);
    }

    // Also build a path string for SVG
    let d = '';
    for (let p = 0; p < polyline.length; p++) {
      let px = polyline[p].x.toFixed(2);
      let py = polyline[p].y.toFixed(2);
      if (p === 0) {
        d += `M${px},${py} `;
      } else {
        d += `L${px},${py} `;
      }
    }
    pathData.push({ colorIndex, d: d.trim() });
  }

  // Now draw everything
  drawGlobalSegments();
  drawMarkers();
  drawPaletteBars();
}

/**
 * Build an arc polyline with torsion
 */
function buildArcPolyline(steps) {
  let anchor = randomBoundaryPoint();
  let points = [anchor];

  let angle = getInwardAngle(anchor);
  for (let i = 0; i < steps; i++) {
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (generationRules.torsion + dev);

    let prev = points[points.length - 1];
    let nx = prev.x + generationRules.stepLength * cos(angle);
    let ny = prev.y + generationRules.stepLength * sin(angle);
    if (nx < marginPixels || nx > (width - marginPixels) ||
        ny < marginPixels || ny > (height - marginPixels)) {
      break;
    }
    points.push({ x: nx, y: ny });
  }
  return points;
}

function randomBoundaryPoint() {
  let side = floor(random(4));
  let minPix = marginPixels;
  let maxX = width - marginPixels;
  let maxY = height - marginPixels;
  if (side === 0) {
    return { x: random(minPix, maxX), y: minPix };
  } else if (side === 1) {
    return { x: random(minPix, maxX), y: maxY };
  } else if (side === 2) {
    return { x: minPix, y: random(minPix, maxY) };
  } else {
    return { x: maxX, y: random(minPix, maxY) };
  }
}

function getInwardAngle(pt) {
  let cx = width / 2;
  let cy = height / 2;
  let dx = cx - pt.x;
  let dy = cy - pt.y;
  let baseAngle = atan2(dy, dx);
  return baseAngle + random(-0.3, 0.3);
}

function polylineToSegments(pts) {
  let segs = [];
  for (let i = 0; i < pts.length - 1; i++) {
    segs.push({
      x1: pts[i].x, y1: pts[i].y,
      x2: pts[i + 1].x, y2: pts[i + 1].y
    });
  }
  return segs;
}

////////////////////////////////////////////////////////
// Build a band polygon around the arc
////////////////////////////////////////////////////////

function buildArcBandPolygon(polyline, strokeW) {
  // We'll do a naive approach: offset each segment outward & inward by strokeW/2
  // Then connect them to form a closed polygon.
  let halfW = strokeW * 0.5;
  // We build "left offset" & "right offset" polylines
  let leftOffset = [];
  let rightOffset = [];
  for (let i = 0; i < polyline.length - 1; i++) {
    let p1 = polyline[i];
    let p2 = polyline[i + 1];
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    let len = sqrt(dx * dx + dy * dy);
    if (len < 0.0001) {
      continue;
    }
    // normal
    let ndx = -dy / len;
    let ndy = dx / len;
    // left offset
    leftOffset.push({
      x: p1.x + ndx * halfW,
      y: p1.y + ndy * halfW
    });
    // right offset
    rightOffset.push({
      x: p1.x - ndx * halfW,
      y: p1.y - ndy * halfW
    });
    // on the last point, do the second side
    if (i === polyline.length - 2) {
      leftOffset.push({
        x: p2.x + ndx * halfW,
        y: p2.y + ndy * halfW
      });
      rightOffset.push({
        x: p2.x - ndx * halfW,
        y: p2.y - ndy * halfW
      });
    }
  }
  // The polygon will be leftOffset + reversed(rightOffset)
  // so it encloses the stroke
  let bandPoly = leftOffset.concat(rightOffset.reverse());
  // close it
  if (bandPoly.length > 0) {
    bandPoly.push({ x: bandPoly[0].x, y: bandPoly[0].y });
  }
  return bandPoly;
}

////////////////////////////////////////////////////////
// pointInPolygon
////////////////////////////////////////////////////////

function pointInPolygon(px, py, poly) {
  let inside = false;
  for (let i = 0; i < poly.length - 1; i++) {
    let x1 = poly[i].x, y1 = poly[i].y;
    let x2 = poly[i + 1].x, y2 = poly[i + 1].y;
    let intersect = ((y1 > py) !== (y2 > py)) &&
      (px < (x2 - x1) * (py - y1) / (y2 - y1) + x1);
    if (intersect) inside = !inside;
  }
  return inside;
}

////////////////////////////////////////////////////////
// Drawing the final line segments
////////////////////////////////////////////////////////

function drawGlobalSegments() {
  // group by color
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  // draw in the order of selectedColorIndices
  for (let cIdx of selectedColorIndices) {
    let segs = grouped[cIdx] || [];
    if (segs.length === 0) continue;
    strokeWeight(strokeWeightValue);
    applyStrokeWithOpacity(colors[cIdx].hex);
    beginShape(LINES);
    for (let seg of segs) {
      vertex(seg.x1, seg.y1);
      vertex(seg.x2, seg.y2);
    }
    endShape();
  }
}

////////////////////////////////////////////////////////
// Markers & palette
////////////////////////////////////////////////////////

function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0, 0, 5, 0);
  line(0, 0, 0, 5);
  line(width - 5, height, width, height);
  line(width, height - 5, width, height);
}

function drawPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * dpi);

  let used = selectedColorIndices;
  let numColors = used.length;
  if (numColors === 0) return;

  let totalGaps = (numColors - 1) * gapSize;
  let segmentLength = (paletteLength - totalGaps) / numColors;
  let xStart = (width - paletteLength) / 2;

  strokeWeight(barHeight);
  for (let i = 0; i < numColors; i++) {
    let cIdx = used[i];
    let col = colors[cIdx].hex;
    applyStrokeWithOpacity(col);
    let x = xStart + i * (segmentLength + gapSize);
    line(x, yStart, x + segmentLength, yStart);
  }
}

////////////////////////////////////////////////////////
// Key Press & Reset
////////////////////////////////////////////////////////

function keyPressed() {
  if (key === ' ') {
    saveSVGs();
  } else if (key === 'r' || key === 'R') {
    resetCanvas();
  }
}

function resetCanvas() {
  globalSegments = [];
  pathData = [];
  drawArcs();
}

////////////////////////////////////////////////////////
// SVG Export
////////////////////////////////////////////////////////

function saveSVGs() {
  const ts = Date.now();
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  // per color
  selectedColorIndices.forEach(cIdx => {
    let colorSVG = generateSVG(cIdx);
    let cName = colors[cIdx].name.toUpperCase();
    let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(colorSVG, fname);
  });
}

function generateSVG(activeColor=0) {
  let svg = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svg += addMarkersSVG();

  if (activeColor === 0) {
    // all colors
    let layerNum = 1;
    for (let cIdx of selectedColorIndices) {
      svg += addSegmentsSVG(cIdx, layerNum, 0);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor) + 1;
    svg += addSegmentsSVG(activeColor, layerNum, activeColor);
  }
  svg += '</svg>';
  return svg;
}

function addSegmentsSVG(colorIndex, layerNum, activeColor) {
  let c = colors[colorIndex];
  let out = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${c.name.toLowerCase()}-${c.ink}-${c.width}"
 style="display:inline"
 stroke="${c.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${c.hex}">n`;

  let relevantPaths = (activeColor === 0)
    ? pathData.filter(p => p.colorIndex === colorIndex)
    : pathData.filter(p => p.colorIndex === activeColor);

  let sw = strokeWeightValue;
  relevantPaths.forEach(rp => {
    out += `<path d="${rp.d}" stroke-width="${sw}" fill="none" />n`;
  });

  // palette bar
  let used = selectedColorIndices;
  let i = used.indexOf(colorIndex);
  if (i >= 0) {
    let paletteLength = 300;
    let barHeight = 2;
    let gapSize = 7;
    let yStart = height - (1.25 * dpi);
    let numColors = used.length;
    let totalGaps = (numColors -1)*gapSize;
    let segLen = (paletteLength - totalGaps)/numColors;
    let xStart = (width - paletteLength)/2;
    let x = xStart + i*(segLen+gapSize);
    out += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segLen).toFixed(2)}" stroke="${c.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
  }

  out += '</g>n';
  return out;
}

function addMarkersSVG() {
  const sw = 1;
  const off = sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${(5+off).toFixed(2)},${off.toFixed(2)} L${off.toFixed(2)},${off.toFixed(2)} L${off.toFixed(2)},${(5+off).toFixed(2)}
M${(width-5-off).toFixed(2)},${(height-off).toFixed(2)} L${(width-off).toFixed(2)},${(height-off).toFixed(2)} L${(width-off).toFixed(2)},${(height-5-off).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(data, fname) {
  let blob = new Blob([data], { type:'image/svg+xml;charset=utf-8' });
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fname;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, symmetry, lines, minimalism

### Conceptual Framework

In “Torsional Reaches,” I visualize my identity as a series of smoothly nested arcs that form a frame 
around the work area. The outermost layer is composed of four gently curving arcs along the margins. 
Subsequent layers are drawn inward: each new arc begins exactly where an arc from the previous layer ends 
and stops where it meets an adjacent arc. In this way, the inner arcs “touch” their neighbors and the 
pattern recedes toward the center. All lines are rendered as single‑stroke paths (with 0.8 opacity) so that 
a pen plotter can faithfully reproduce the work.

### Technical Approach

1. **Layered Frame Construction**  
   - Define the outer work‑area as the rectangle bounded by the page margins.
   - For layer 0, draw four arcs along the top, right, bottom, and left edges (with slight random perturbations).
   - For each subsequent layer, inset the rectangle by a fixed amount and redraw four arcs along its sides.
   - In this way, each new arc exactly begins where the previous layer’s arc ended and stops at the corner 
     where it touches the adjacent side.

2. **Rendering & Consistency**  
   - Each arc is built as a polyline (a sequence of {x,y} points) and stored in an array.
   - The arcs are then drawn in order (outer layers first, inner layers on top) so that the occlusion is clear.
   - The same geometry is recorded as SVG path commands to ensure that the exported file matches the canvas exactly.

---
*/

const canvasWidthInches = 11;   // Canvas width in inches
const canvasHeightInches = 11;  // Canvas height in inches
const dpi = 100;              // Pixels per inch
const dayNumber = '153';

// Predefined color palette
const colors = {
  1: { name: 'ORANGE', ink: 5, width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, width: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

// Generation rules for layered arcs
let generationRules = {
  layers: 5,           // total layers (outer + inner)
  // Amount (in pixels) to inset each subsequent layer
  insetPerLayer: 20,
  // Number of sample points per arc
  pointsPerArc: 50,
  // Maximum random offset added to each point (for organic variation)
  noiseAmt: 3
};

let canvasWidthPixels, canvasHeightPixels;
let marginInches = 2;
let marginPixels;
let strokeWeightValue;

// We'll pick a random subset of colors for the drawing
let selectedColorIndices = [];

// Store all arc polylines for SVG export
// Each arc is an array of {x,y} points.
let allArcs = [];

// Also accumulate pathData for SVG export (grouped by color)
let pathData = [];

function setup() {
  canvasWidthPixels = canvasWidthInches * dpi;
  canvasHeightPixels = canvasHeightInches * dpi;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  marginInches = random(1.5, 4);
  marginPixels = marginInches * dpi;

  adjustStrokeWeight();
  selectColors();

  // Clear global arrays
  allArcs = [];
  pathData = [];

  // Build the layered arcs
  drawLayeredArcs();

  noLoop();
}

function adjustStrokeWeight() {
  // ~0.5mm => ~2px at 100 dpi
  strokeWeightValue = 2;
  marginPixels += strokeWeightValue / 2;
}

function selectColors() {
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  shuffle(allIndices, true);
  // use between 3 and 6 colors
  let n = floor(random(3, 7));
  selectedColorIndices = allIndices.slice(0, n).sort((a, b) => a - b);
}

/**
 * Draw layered arcs.
 * The outermost layer is defined by the work-area rectangle.
 * For each subsequent layer, we inset the rectangle and draw four arcs.
 */
function drawLayeredArcs() {
  background(255);

  // Define outer work-area rectangle
  let L0 = marginPixels;
  let R0 = width - marginPixels;
  let T0 = marginPixels;
  let B0 = height - marginPixels;

  // For each layer, compute the inset rectangle and draw four arcs.
  for (let layer = 0; layer < generationRules.layers; layer++) {
    // For variety, choose a color from the selected palette (cycling through if needed)
    let colIdx = selectedColorIndices[layer % selectedColorIndices.length];
    let col = colors[colIdx];

    // Compute the inset for this layer:
    let inset = layer * generationRules.insetPerLayer;
    let L = L0 + inset;
    let R = R0 - inset;
    let T = T0 + inset;
    let B = B0 - inset;

    // Top arc: from (L, T) to (R, T)
    let topArc = sampleArc({x: L, y: T}, {x: R, y: T}, generationRules.pointsPerArc, generationRules.noiseAmt, 'vertical');
    drawArcPolyline(topArc, col.hex);
    recordPathData(topArc, colIdx);

    // Right arc: from (R, T) to (R, B)
    let rightArc = sampleArc({x: R, y: T}, {x: R, y: B}, generationRules.pointsPerArc, generationRules.noiseAmt, 'horizontal');
    drawArcPolyline(rightArc, col.hex);
    recordPathData(rightArc, colIdx);

    // Bottom arc: from (R, B) to (L, B)
    let bottomArc = sampleArc({x: R, y: B}, {x: L, y: B}, generationRules.pointsPerArc, generationRules.noiseAmt, 'vertical');
    drawArcPolyline(bottomArc, col.hex);
    recordPathData(bottomArc, colIdx);

    // Left arc: from (L, B) to (L, T)
    let leftArc = sampleArc({x: L, y: B}, {x: L, y: T}, generationRules.pointsPerArc, generationRules.noiseAmt, 'horizontal');
    drawArcPolyline(leftArc, col.hex);
    recordPathData(leftArc, colIdx);

    // Store all arcs for potential further use (if needed)
    allArcs.push(topArc, rightArc, bottomArc, leftArc);
  }

  // Draw registration markers and palette bars
  drawMarkers();
  drawPaletteBars();
}

/**
 * sampleArc:
 * Given start and end points, sample a polyline of length pointsPerArc.
 * mode: 'vertical' means perturb y; 'horizontal' means perturb x.
 */
function sampleArc(startPt, endPt, numPoints, noiseAmt, mode) {
  let pts = [];
  for (let t = 0; t <= 1; t += 1 / (numPoints - 1)) {
    let x = lerp(startPt.x, endPt.x, t);
    let y = lerp(startPt.y, endPt.y, t);
    if (mode === 'vertical') {
      y += random(-noiseAmt, noiseAmt);
    } else if (mode === 'horizontal') {
      x += random(-noiseAmt, noiseAmt);
    }
    pts.push({ x, y });
  }
  return pts;
}

/**
 * drawArcPolyline:
 * Draw the polyline (arc) with the given stroke color.
 */
function drawArcPolyline(polyline, hexColor) {
  strokeWeight(strokeWeightValue);
  applyStrokeWithOpacity(hexColor);
  beginShape();
  for (let pt of polyline) {
    vertex(pt.x, pt.y);
  }
  endShape();
}

/**
 * recordPathData:
 * Save the polyline as an SVG path string.
 */
function recordPathData(polyline, colorIndex) {
  let d = "";
  for (let i = 0; i < polyline.length; i++) {
    let px = polyline[i].x.toFixed(2);
    let py = polyline[i].y.toFixed(2);
    if (i === 0) {
      d += `M${px},${py} `;
    } else {
      d += `L${px},${py} `;
    }
  }
  pathData.push({ colorIndex, d: d.trim() });
}

/**
 * =======================================
 * Registration Markers & Palette Bars
 * =======================================
 */
function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0, 0, 5, 0);
  line(0, 0, 0, 5);
  line(width - 5, height, width, height);
  line(width, height - 5, width, height);
}

function drawPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * dpi);

  let used = selectedColorIndices;
  let numColors = used.length;
  if (numColors === 0) return;
  let totalGaps = (numColors - 1) * gapSize;
  let segLength = (paletteLength - totalGaps) / numColors;
  let xStart = (width - paletteLength) / 2;

  strokeWeight(barHeight);
  for (let i = 0; i < numColors; i++) {
    let cIdx = used[i];
    let hexColor = colors[cIdx].hex;
    applyStrokeWithOpacity(hexColor);
    let x = xStart + i * (segLength + gapSize);
    line(x, yStart, x + segLength, yStart);
  }
}

/**
 * =======================================
 * SVG Export Functions
 * =======================================
 */
function keyPressed() {
  if (key === ' ') {
    saveSVGs();
  } else if (key === 'r' || key === 'R') {
    resetCanvas();
  }
}

function resetCanvas() {
  background(255);
  allArcs = [];
  pathData = [];
  drawLayeredArcs();
}

function saveSVGs() {
  const ts = Date.now();
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);
  selectedColorIndices.forEach(cIdx => {
    let colSVG = generateSVG(cIdx);
    let cName = colors[cIdx].name.toUpperCase();
    let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(colSVG, fname);
  });
}

function generateSVG(activeColor = 0) {
  let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
  svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svgContent += addMarkersSVG();
  if (activeColor === 0) {
    selectedColorIndices.forEach((cIdx, idx) => {
      svgContent += addSegmentsSVG(cIdx, idx + 1, 0);
    });
  } else {
    let idx = selectedColorIndices.indexOf(activeColor) + 1;
    svgContent += addSegmentsSVG(activeColor, idx, activeColor);
  }
  svgContent += '</svg>';
  return svgContent;
}

function addSegmentsSVG(colorIndex, layerNum, activeColor) {
  let svg = '';
  let c = colors[colorIndex];
  let sw = strokeWeightValue;
  svg += `<g
    inkscape:groupmode="layer"
    id="layer${layerNum}"
    inkscape:label="${colorIndex}-${c.name.toLowerCase()}-${c.ink}-${c.width}"
    style="display:inline"
    stroke="${c.hex}"
    stroke-opacity="${strokeOpacity}"
    inkscape:highlight-color="${c.hex}">n`;
  let relevantPaths = (activeColor === 0)
    ? pathData.filter(p => p.colorIndex === colorIndex)
    : pathData.filter(p => p.colorIndex === activeColor);
  relevantPaths.forEach(rp => {
    svg += `<path d="${rp.d}" stroke-width="${sw}" fill="none" />n`;
  });
  // Palette bar
  let used = selectedColorIndices;
  let i = used.indexOf(colorIndex);
  if (i >= 0) {
    let paletteLength = 300, barHeight = 2, gapSize = 7;
    let yStart = height - (1.25 * dpi);
    let numColors = used.length;
    let totalGaps = (numColors - 1) * gapSize;
    let segLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;
    let x = xStart + i * (segLength + gapSize);
    svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segLength).toFixed(2)}" stroke="${c.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none" />n`;
  }
  svg += '</g>n';
  return svg;
}

function addMarkersSVG() {
  const sw = 1;
  const off = sw / 2;
  return `<g
    inkscape:groupmode="layer"
    id="layer0"
    inkscape:label="0-markers"
    style="display:inline"
    stroke="black"
    stroke-opacity="${strokeOpacity}"
    inkscape:highlight-color="black">
<path d="M${(5+off).toFixed(2)},${off.toFixed(2)} L${off.toFixed(2)},${off.toFixed(2)} L${off.toFixed(2)},${(5+off).toFixed(2)}
M${(width-5-off).toFixed(2)},${(height-off).toFixed(2)} L${(width-off).toFixed(2)},${(height-off).toFixed(2)} L${(width-off).toFixed(2)},${(height-5-off).toFixed(2)}"
     stroke-width="${sw}" fill="none" />
</g>n`;
}

function saveSVGFile(data, fname) {
  let blob = new Blob([data], { type: 'image/svg+xml;charset=utf-8' });
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fname;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

/**
 * =====================================================
 * Helper: applyStrokeWithOpacity (as required)
 * =====================================================
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches with Occlusion)
=======================================

### Title: *Torsional Reaches (Line-by-Line Occlusion)*

### Medium: Generative Drawing on Paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              identity, torsion, arcs, layering, synergy, intersection, lines, minimalism

### Conceptual Framework

This code retains the original “Torsional Reaches” aesthetic, generating arcs that
begin at the canvas boundary and spiral inward under a gentle torsion. However, it
also implements a line-by-line occlusion step so that newer arcs appear on top of
older arcs where they cross. Each new arc is subdivided into small line segments,
and any intersections with older segments cause those older segments to be truncated,
hiding them behind the new arc. The final result is the familiar swirling arcs of
“Torsional Reaches,” but with a true layered effect.

### Technical Approach

1. **Arc Generation**  
   - Same as the original “Torsional Reaches”:  
     - Random boundary anchor.  
     - Step by step, applying a small torsion plus random deviation.  
     - Stop if the next point goes out of the margin.  

2. **Line-by-Line Occlusion**  
   - Once an arc is generated, we break it into line segments.  
   - For each new segment, we compare it to **all older segments** in a global array:  
     - If there’s an intersection, the older segment is truncated at that point, removing the portion behind the intersection.  
   - This ensures the new arc visually sits on top.

3. **Canvas & SVG Consistency**  
   - The final geometry (post-clipping) is used to draw on the canvas and is exported to SVG, so they match exactly.  
   - No fills are used—only stroked lines with 0.8 opacity.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings
const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

// Color palette
const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
  numArcs: 18,         // how many arcs to generate
  minSteps: 40,        // minimum points in an arc
  maxSteps: 80,        // maximum points in an arc
  torsion: 0.03,       // base torsion each step
  stepLength: 10,      // distance in pixels
  maxDeviation: 0.02   // random deviation from torsion
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */

let canvasWidthPixels;
let canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;

let selectedColorIndices = [];  // chosen palette

// We'll store final line segments in a global array, post-clipping
// Each segment = { x1, y1, x2, y2, colorIndex }
let globalSegments = [];

// For SVG, we also keep path data strings
// Each pathData entry = { colorIndex, d: 'M..L..' }
let pathData = [];

let strokeWeightValue;

/**
 * Applies stroke color with alpha
 */
function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255 * strokeOpacity);
  stroke(c);
}

/**
 * =======================================
 * p5.js Setup
 * =======================================
 */
function setup() {
  // optional: randomSeed(153);

  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustStrokeWeight();
  pickColors();

  // Clear
  globalSegments = [];
  pathData = [];

  // Generate the arcs
  drawAllArcs();

  noLoop();
}

/**
 * Adjust stroke weight to ~0.5mm => ~2px
 */
function adjustStrokeWeight() {
  strokeWeightValue = 2;
  workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * pickColors: choose 1..9 random palette colors
 */
function pickColors() {
  let n = floor(random(1, 10));
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  shuffle(allIndices, true);
  selectedColorIndices = allIndices.slice(0, n).sort((a,b)=>a-b);
}

/**
 * =======================================
 * Arc Generation + Occlusion
 * =======================================
 */
function drawAllArcs() {
  background(255);

  for (let i = 0; i < generationRules.numArcs; i++) {
    let colorIndex = random(selectedColorIndices);
    let col = colors[colorIndex];

    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
    // Generate the arc as a polyline
    let polyline = buildArcPolyline(steps);

    // Convert polyline to small line segments
    let arcSegments = polylineToSegments(polyline);

    // Before we finalize these new segments, we clip older segments behind them
    // so the new arc is on top.
    for (let seg of arcSegments) {
      // Clip older segments behind this new segment
      clipOlderSegments(seg);
    }

    // Now add the new segments to globalSegments
    for (let seg of arcSegments) {
      seg.colorIndex = colorIndex;
      globalSegments.push(seg);
    }

    // Draw on canvas
    strokeWeight(strokeWeightValue);
    applyStrokeWithOpacity(col.hex);
    beginShape();
    for (let pt of polyline) {
      vertex(pt.x, pt.y);
    }
    endShape();

    // Build path data for SVG
    let d = '';
    for (let j = 0; j < polyline.length; j++) {
      let px = polyline[j].x.toFixed(2);
      let py = polyline[j].y.toFixed(2);
      if (j === 0) {
        d += `M${px},${py} `;
      } else {
        d += `L${px},${py} `;
      }
    }
    pathData.push({ colorIndex, d: d.trim() });
  }

  // Markers + palette
  drawMarkers();
  drawPaletteBars();
}

/**
 * buildArcPolyline: same logic as original Torsional Reaches
 */
function buildArcPolyline(steps) {
  let anchor = getRandomBoundaryPoint();
  let points = [ anchor ];

  let angle = getInwardAngle(anchor);
  for (let i = 0; i < steps; i++) {
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (generationRules.torsion + dev);

    let prev = points[points.length - 1];
    let nx = prev.x + generationRules.stepLength*cos(angle);
    let ny = prev.y + generationRules.stepLength*sin(angle);

    // if out of bounds => stop
    if (nx < workAreaMarginPixels || nx > (width - workAreaMarginPixels) ||
        ny < workAreaMarginPixels || ny > (height - workAreaMarginPixels)) {
      break;
    }
    points.push({ x:nx, y:ny });
  }
  return points;
}

/**
 * Convert polyline to line segments
 */
function polylineToSegments(pts) {
  let segs = [];
  for (let i = 0; i < pts.length - 1; i++) {
    segs.push({
      x1: pts[i].x,   y1: pts[i].y,
      x2: pts[i+1].x, y2: pts[i+1].y
    });
  }
  return segs;
}

/**
 * clipOlderSegments(newSeg):
 *   For each older segment in globalSegments, if there's an intersection,
 *   we truncate the older segment at that intersection (removing the portion
 *   behind it).
 */
function clipOlderSegments(newSeg) {
  for (let i = 0; i < globalSegments.length; i++) {
    let oldSeg = globalSegments[i];
    let ints = lineIntersection(
      oldSeg.x1, oldSeg.y1, oldSeg.x2, oldSeg.y2,
      newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
    );
    if (ints.intersects) {
      // Intersection => keep only oldSeg up to intersection
      let ix = lerp(oldSeg.x1, oldSeg.x2, ints.t);
      let iy = lerp(oldSeg.y1, oldSeg.y2, ints.t);

      // The portion from oldSeg.x1,y1 to ix,iy remains
      let segA = {
        x1: oldSeg.x1, y1: oldSeg.y1,
        x2: ix,        y2: iy,
        colorIndex: oldSeg.colorIndex
      };
      let lenA = dist(segA.x1, segA.y1, segA.x2, segA.y2);
      if (lenA > 0.5) {
        // keep it
        globalSegments[i] = segA;
      } else {
        // remove entirely
        globalSegments.splice(i, 1);
        i--;
      }
    }
  }
}

/**
 * Return a random boundary anchor (top, bottom, left, right).
 */
function getRandomBoundaryPoint() {
  let side = floor(random(4));
  let minPix = workAreaMarginPixels;
  let maxX = width - workAreaMarginPixels;
  let maxY = height - workAreaMarginPixels;
  if (side === 0) {
    return { x: random(minPix, maxX), y: minPix };
  } else if (side === 1) {
    return { x: random(minPix, maxX), y: maxY };
  } else if (side === 2) {
    return { x: minPix, y: random(minPix, maxY) };
  } else {
    return { x: maxX, y: random(minPix, maxY) };
  }
}

/**
 * Angle from boundary anchor roughly inward
 */
function getInwardAngle(pt) {
  let cx = width / 2;
  let cy = height / 2;
  let dx = cx - pt.x;
  let dy = cy - pt.y;
  let base = atan2(dy, dx);
  return base + random(-0.3, 0.3);
}

/**
 * lineIntersection: param-based
 * returns { intersects, t, u } where t is fraction along oldSeg, u along newSeg
 */
function lineIntersection(x1,y1,x2,y2, x3,y3,x4,y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 0.000001) {
    return { intersects:false, t:0, u:0 };
  }
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4))/denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2))/denom;
  let inter = (t >= 0 && t <=1 && u>=0 && u<=1);
  return { intersects: inter, t, u };
}

/**
 * =======================================
 * Draw Markers & Palette
 * =======================================
 */
function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0,0,5,0);
  line(0,0,0,5);
  line(width-5,height,width,height);
  line(width,height-5,width,height);
}

function drawPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * pixelsPerInch);

  let used = selectedColorIndices;
  let numColors = used.length;
  if (numColors===0) return;

  let totalGaps = (numColors-1)*gapSize;
  let segLen = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);
  for (let i=0; i<numColors; i++) {
    let cIdx = used[i];
    let col = colors[cIdx].hex;
    applyStrokeWithOpacity(col);
    let x = xStart + i*(segLen+gapSize);
    line(x, yStart, x+segLen, yStart);
  }
}

/**
 * =======================================
 * Key Handling & Reset
 * =======================================
 */
function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  globalSegments = [];
  pathData = [];
  drawAllArcs();
}

/**
 * =======================================
 * SVG Export
 * =======================================
 */
function saveSVGs() {
  const ts = Date.now();
  let combined = generateSVG(0);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  selectedColorIndices.forEach(cIdx=>{
    let colorSVG = generateSVG(cIdx);
    let cName = colors[cIdx].name.toUpperCase();
    let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(colorSVG, fname);
  });
}

function generateSVG(activeColor=0) {
  let svg = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svg += addMarkersSVG();

  if (activeColor===0) {
    let layerNum=1;
    for (let cIdx of selectedColorIndices) {
      svg += addSegmentsSVG(cIdx, layerNum, 0);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    svg += addSegmentsSVG(activeColor, layerNum, activeColor);
  }

  svg += '</svg>';
  return svg;
}

function addSegmentsSVG(colorIndex, layerNum, activeColor) {
  let c = colors[colorIndex];
  let out = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${c.name.toLowerCase()}-${c.ink}-${c.width}"
 style="display:inline"
 stroke="${c.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${c.hex}">n`;

  // gather path data relevant to color
  let relevant = (activeColor===0)
    ? pathData.filter(p => p.colorIndex===colorIndex)
    : pathData.filter(p => p.colorIndex===activeColor);

  let sw = strokeWeightValue;
  relevant.forEach(rp=>{
    out += `<path d="${rp.d}" stroke-width="${sw}" fill="none" />n`;
  });

  // palette bar
  let used = selectedColorIndices;
  let i = used.indexOf(colorIndex);
  if (i>=0) {
    let paletteLength=300, barHeight=2, gapSize=7;
    let yStart = height - (1.25*pixelsPerInch);
    let numColors = used.length;
    let totalGaps = (numColors-1)*gapSize;
    let segLen = (paletteLength - totalGaps)/numColors;
    let xStart = (width-paletteLength)/2;
    let x = xStart + i*(segLen+gapSize);
    out += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segLen).toFixed(2)}"
     stroke="${c.hex}" stroke-opacity="${strokeOpacity}"
     stroke-width="${barHeight}" fill="none"/>n`;
  }

  out += '</g>n';
  return out;
}

/**
 * Registration markers in SVG
 */
function addMarkersSVG() {
  const sw=1;
  const off=sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${(5+off).toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${(5+off).toFixed(2)}
       M${(width-5-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-5-off).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(svgData, fileName) {
  let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fileName;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches with Final Segments)
=======================================

### Title: *Torsional Reaches (Definitive Occlusion)*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, arcs, torsion,
              layering, intersection, final segments, pen-plotter

### Concept

In this version of “Torsional Reaches,” each arc is still generated from the page boundary inward
using a small torsion plus random deviation. However, we apply a line-by-line occlusion step so
that any older segments are truncated behind newer arcs. We store the final, visible geometry
in `globalSegments`, and **only** that geometry is drawn on the canvas and exported to SVG—ensuring
they match perfectly. No fills are used, just stroked lines with slight opacity, preserving
pen-plotter compatibility.

### Technical Approach

1. **Arc Generation**  
   - For each arc, pick a boundary anchor and generate a polyline by stepping in small increments
     with a torsion.  
   - Convert the polyline to line segments.  

2. **Line-by-Line Occlusion**  
   - Each new segment clips older segments in `globalSegments` by detecting intersections
     and truncating the older segment behind the intersection.  
   - This ensures the new arc sits on top of any older arcs it crosses.

3. **Single Final Pass**  
   - After all arcs are generated and older segments are clipped, we have a final list of
     visible segments.  
   - We draw these final segments to the canvas, then build path data from these same
     segments for SVG export. Because both canvas and SVG rely on `globalSegments`, they
     match exactly.

---
*/

////////////////////////////////////////////////////////
// Constants & Setup
////////////////////////////////////////////////////////

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const dpi = 100;
const dayNumber = '153';

// Predefined color palette
const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

// Torsional Reaches parameters + occlusion
let generationRules = {
  numArcs: 12,        // total arcs
  minSteps: 40,       // minimum points per arc
  maxSteps: 80,       // maximum points per arc
  torsion: 0.03,      // base torsion
  stepLength: 10,     // distance each step
  maxDeviation: 0.02  // random dev in torsion
};

let canvasWidth, canvasHeight;
let marginInches = 2;
let marginPixels;
let strokeWeightValue;

let selectedColorIndices = []; // chosen colors

// The final visible geometry after occlusion:
let globalSegments = []; // each segment: { x1,y1, x2,y2, colorIndex }

// For SVG, we build path data from these final segments in a single pass at the end.
let finalPathData = [];

function setup() {
  // optional: randomSeed(153);

  canvasWidth = canvasWidthInches * dpi;
  canvasHeight = canvasHeightInches * dpi;
  createCanvas(canvasWidth, canvasHeight);

  marginInches = random(1.5, 4);
  marginPixels = marginInches * dpi;

  adjustStrokeWeight();
  pickColors();

  globalSegments = [];
  finalPathData = [];

  // Generate arcs with occlusion
  generateAllArcs();

  // Now we do one final pass: draw the final geometry from globalSegments
  background(255);
  drawFinalSegments();

  // Then add markers + palette
  drawMarkers();
  drawPaletteBars();
  
  noLoop();
}

function adjustStrokeWeight() {
  strokeWeightValue = 2; // ~0.5mm => ~2px
  marginPixels += strokeWeightValue / 2;
}

function pickColors() {
  let allIndices = Object.keys(colors).map(k => parseInt(k));
  shuffle(allIndices, true);
  // pick random 1..9 colors
  let n = floor(random(1, 10));
  selectedColorIndices = allIndices.slice(0, n).sort((a,b)=>a-b);
}

////////////////////////////////////////////////////////
// Arc Generation + Occlusion
////////////////////////////////////////////////////////

function generateAllArcs() {
  for (let i = 0; i < generationRules.numArcs; i++) {
    let colorIndex = random(selectedColorIndices);
    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
    // Build the arc as a polyline
    let polyline = buildArcPolyline(steps);

    // Convert to line segments
    let newSegments = polylineToSegments(polyline);
    
    // For each new segment, clip older segments behind it
    // Then add this new segment on top
    for (let seg of newSegments) {
      clipOlderSegments(seg);
      seg.colorIndex = colorIndex;
      globalSegments.push(seg);
    }
  }
}

/**
 * buildArcPolyline: same as original Torsional Reaches
 */
function buildArcPolyline(steps) {
  let anchor = getRandomBoundaryPoint();
  let points = [ anchor ];

  let angle = getInwardAngle(anchor);
  for (let i=0; i<steps; i++) {
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (generationRules.torsion + dev);

    let prev = points[points.length-1];
    let nx = prev.x + generationRules.stepLength*cos(angle);
    let ny = prev.y + generationRules.stepLength*sin(angle);

    if (nx < marginPixels || nx > (width - marginPixels) ||
        ny < marginPixels || ny > (height - marginPixels)) {
      break;
    }
    points.push({ x:nx, y:ny });
  }
  return points;
}

/**
 * polylineToSegments
 */
function polylineToSegments(pts) {
  let segs = [];
  for (let i=0; i<pts.length-1; i++) {
    segs.push({
      x1: pts[i].x,   y1: pts[i].y,
      x2: pts[i+1].x, y2: pts[i+1].y
    });
  }
  return segs;
}

/**
 * clipOlderSegments(newSeg):
 *   For each older segment in globalSegments, if they intersect,
 *   we keep only the portion up to intersection (removing the 'behind' portion).
 */
function clipOlderSegments(newSeg) {
  for (let i=0; i<globalSegments.length; i++) {
    let old = globalSegments[i];
    let ints = lineIntersection(
      old.x1, old.y1, old.x2, old.y2,
      newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
    );
    if (ints.intersects) {
      // intersection => keep only portion up to intersection
      let ix = lerp(old.x1, old.x2, ints.t);
      let iy = lerp(old.y1, old.y2, ints.t);
      let segA = {
        x1: old.x1, y1: old.y1,
        x2: ix,     y2: iy,
        colorIndex: old.colorIndex
      };
      let lenA = dist(segA.x1, segA.y1, segA.x2, segA.y2);
      if (lenA > 0.5) {
        globalSegments[i] = segA;
      } else {
        // remove entirely
        globalSegments.splice(i, 1);
        i--;
      }
    }
  }
}

////////////////////////////////////////////////////////
// lineIntersection
////////////////////////////////////////////////////////

function lineIntersection(x1,y1,x2,y2, x3,y3,x4,y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 1e-8) {
    return { intersects:false, t:0, u:0 };
  }
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4))/denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2))/denom;
  let inter = (t>=0 && t<=1 && u>=0 && u<=1);
  return { intersects: inter, t, u };
}

////////////////////////////////////////////////////////
// getRandomBoundaryPoint + getInwardAngle
////////////////////////////////////////////////////////

function getRandomBoundaryPoint() {
  let side = floor(random(4));
  let minPix = marginPixels;
  let maxX = width - marginPixels;
  let maxY = height - marginPixels;
  if (side===0) { // top
    return { x: random(minPix, maxX), y: minPix };
  } else if (side===1) { // bottom
    return { x: random(minPix, maxX), y: maxY };
  } else if (side===2) { // left
    return { x: minPix, y: random(minPix, maxY) };
  } else { // right
    return { x: maxX, y: random(minPix, maxY) };
  }
}

function getInwardAngle(pt) {
  let cx = width/2, cy = height/2;
  let dx = cx - pt.x;
  let dy = cy - pt.y;
  let base = atan2(dy, dx);
  return base + random(-0.3, 0.3);
}

////////////////////////////////////////////////////////
// Final Draw + Markers + Palette
////////////////////////////////////////////////////////

function drawFinalSegments() {
  // group segments by color
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  // now draw in the order of color selection
  for (let cIdx of selectedColorIndices) {
    let segs = grouped[cIdx] || [];
    if (segs.length === 0) continue;
    applyStrokeWithOpacity(colors[cIdx].hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let s of segs) {
      vertex(s.x1, s.y1);
      vertex(s.x2, s.y2);
    }
    endShape();
  }
}

function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0,0,5,0);
  line(0,0,0,5);
  line(width-5,height,width,height);
  line(width,height-5,width,height);
}

function drawPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25*dpi);

  let used = selectedColorIndices;
  let numColors = used.length;
  if (numColors===0) return;

  let totalGaps = (numColors-1)*gapSize;
  let segLen = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);
  for (let i=0; i<numColors; i++) {
    let cIdx = used[i];
    applyStrokeWithOpacity(colors[cIdx].hex);
    let x = xStart + i*(segLen+gapSize);
    line(x, yStart, x+segLen, yStart);
  }
}

////////////////////////////////////////////////////////
// Key Handling & Reset
////////////////////////////////////////////////////////

function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  globalSegments = [];
  finalPathData = [];
  setup();
}

////////////////////////////////////////////////////////
// SVG Export
////////////////////////////////////////////////////////

function saveSVGs() {
  // build path data from final geometry
  // We'll group final segments by color and create path strings
  let pathMap = {};
  for (let seg of globalSegments) {
    if (!pathMap[seg.colorIndex]) pathMap[seg.colorIndex] = [];
    // We'll just do small M..L for each segment
    let d = `M${seg.x1.toFixed(2)},${seg.y1.toFixed(2)}L${seg.x2.toFixed(2)},${seg.y2.toFixed(2)}`;
    pathMap[seg.colorIndex].push(d);
  }

  const ts = Date.now();
  // combined
  let combinedSVG = buildSVG(0, pathMap);
  saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  // per color
  selectedColorIndices.forEach(cIdx=>{
    let colorSVG = buildSVG(cIdx, pathMap);
    let cName = colors[cIdx].name.toUpperCase();
    let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(colorSVG, fname);
  });
}

function buildSVG(activeColor, pathMap) {
  let svg = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svg += addMarkersSVG();

  if (activeColor===0) {
    // all
    let layerNum=1;
    for (let cIdx of selectedColorIndices) {
      svg += addSegmentsLayer(cIdx, layerNum, pathMap[cIdx] || []);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    let segStrings = pathMap[activeColor] || [];
    svg += addSegmentsLayer(activeColor, layerNum, segStrings);
  }

  svg += '</svg>';
  return svg;
}

function addSegmentsLayer(colorIndex, layerNum, segStrings) {
  let c = colors[colorIndex];
  let sw = strokeWeightValue;
  let out = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${c.name.toLowerCase()}-${c.ink}-${c.width}"
 style="display:inline"
 stroke="${c.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${c.hex}">n`;

  // add all segments
  if (segStrings.length>0) {
    let bigD = segStrings.join(' ');
    out += `<path d="${bigD}" stroke-width="${sw}" fill="none" />n`;
  }

  // palette bar
  let used = selectedColorIndices;
  let i = used.indexOf(colorIndex);
  if (i>=0) {
    let paletteLength=300, barHeight=2, gapSize=7;
    let yStart = height - (1.25*dpi);
    let numColors = used.length;
    let totalGaps = (numColors-1)*gapSize;
    let segLen = (paletteLength - totalGaps)/numColors;
    let xStart = (width - paletteLength)/2;
    let x = xStart + i*(segLen+gapSize);
    out += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segLen).toFixed(2)}" stroke="${c.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
  }

  out += '</g>n';
  return out;
}

function addMarkersSVG() {
  const sw = 1;
  const off = sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${(5+off).toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${(5+off).toFixed(2)}
       M${(width-5-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-5-off).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(data, filename) {
  let blob = new Blob([data], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = filename;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches with Occlusion & Shortest-Segment Removal)
=======================================

### Title: *Torsional Reaches (Remove Shortest Segment)*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, arcs, torsion,
              layering, intersection, lines, remove shortest segment, minimalism

### Concept

We generate arcs in the same style as “Torsional Reaches,” with each arc starting from
the boundary and curving inward under a gentle torsion. However, we also remove the single
shortest line segment from each arc and apply line-by-line occlusion so that new arcs
sit on top of older ones. We store only the final clipped segments in `globalSegments`,
then draw them once at the end, ensuring the canvas and SVG export match perfectly. 
No fills are used—just stroked lines with 0.8 opacity—maintaining pen-plotter compatibility.

### Technical Approach

1. **Arc Generation**  
   - Random boundary anchor + torsion-based stepping for each arc.  
   - Convert the resulting polyline into line segments.

2. **Remove Shortest Segment**  
   - Identify the single shortest segment among the new arc’s segments and remove it
     entirely from that arc.

3. **Line-by-Line Occlusion**  
   - Each remaining new segment truncates older segments behind it by detecting
     intersections and removing the portion behind the intersection.

4. **Single Final Pass**  
   - Once all arcs are processed, we draw the final `globalSegments` to the canvas and
     build path data from them for the SVG. Because both rely on `globalSegments`,
     the output matches exactly.

---
*/

/*----------------------------------------
    Generated with p5.js
    Day 153 - Self-Portrait
----------------------------------------*/

/**
 * =======================================
 * Constants (Immutable)
 * =======================================
 */

// Canvas settings
const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

// Color palette
const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

/**
 * =======================================
 * Generative Rules (Mutable)
 * =======================================
 */
let generationRules = {
  numArcs: 12,        // total arcs
  minSteps: 40,       // minimum points in an arc
  maxSteps: 80,       // maximum points in an arc
  torsion: 0.03,      // base torsion each step
  stepLength: 10,     // distance each step
  maxDeviation: 0.02  // random deviation from torsion
};

/**
 * =======================================
 * Global Variables
 * =======================================
 */

let canvasWidthPixels, canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let strokeWeightValue;
let selectedColorIndices = [];  // chosen color palette

// The final visible line segments after occlusion
// Each segment: { x1, y1, x2, y2, colorIndex }
let globalSegments = [];

/**
 * We'll build path data from final geometry for the SVG.
 * We'll group segments by color at the end.
 */
function setup() {
  // optional: randomSeed(153);

  canvasWidthPixels = canvasWidthInches * pixelsPerInch;
  canvasHeightPixels = canvasHeightInches * pixelsPerInch;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  workAreaMarginInches = random(1.5, 4);
  workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

  adjustStrokeWeight();
  pickColors();

  globalSegments = [];

  // Generate arcs
  generateAllArcs();

  // Now draw the final geometry
  background(255);
  drawGlobalSegments();

  // Then add markers + palette
  drawMarkers();
  drawPaletteBars();

  noLoop();
}

/**
 * Adjust stroke weight (~0.5mm => ~2px)
 */
function adjustStrokeWeight() {
  strokeWeightValue = 2;
  workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * pickColors: randomly choose 1..9 colors
 */
function pickColors() {
  let indices = Object.keys(colors).map(k => parseInt(k));
  shuffle(indices, true);
  let n = floor(random(1, 10));
  selectedColorIndices = indices.slice(0, n).sort((a, b) => a - b);
}

function generateAllArcs() {
  for (let i = 0; i < generationRules.numArcs; i++) {
    let colorIndex = random(selectedColorIndices);

    // Build arc as a polyline
    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
    let polyline = buildArcPolyline(steps);

    // Convert to segments
    let segs = polylineToSegments(polyline);

    // Remove the single shortest segment from this arc
    removeShortestSegment(segs);

    // For each new segment, clip older segments behind it, then add it on top
    for (let seg of segs) {
      clipOlderSegments(seg);
      seg.colorIndex = colorIndex;
      globalSegments.push(seg);
    }
  }
}

/**
 * Build a torsion-based arc polyline
 */
function buildArcPolyline(steps) {
  let anchor = getRandomBoundaryPoint();
  let pts = [anchor];

  let angle = getInwardAngle(anchor);
  for (let i = 0; i < steps; i++) {
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (generationRules.torsion + dev);

    let prev = pts[pts.length - 1];
    let nx = prev.x + generationRules.stepLength*cos(angle);
    let ny = prev.y + generationRules.stepLength*sin(angle);

    if (nx < workAreaMarginPixels || nx > (width - workAreaMarginPixels) ||
        ny < workAreaMarginPixels || ny > (height - workAreaMarginPixels)) {
      break;
    }
    pts.push({x:nx, y:ny});
  }
  return pts;
}

/**
 * Convert polyline to line segments
 */
function polylineToSegments(pts) {
  let segs = [];
  for (let i = 0; i < pts.length - 1; i++) {
    segs.push({
      x1: pts[i].x,   y1: pts[i].y,
      x2: pts[i+1].x, y2: pts[i+1].y
    });
  }
  return segs;
}

/**
 * Remove the single shortest segment from the arc
 */
function removeShortestSegment(arcSegments) {
  if (arcSegments.length < 1) return;
  let minLen = Infinity;
  let minIdx = -1;
  for (let i = 0; i < arcSegments.length; i++) {
    let s = arcSegments[i];
    let length = dist(s.x1, s.y1, s.x2, s.y2);
    if (length < minLen) {
      minLen = length;
      minIdx = i;
    }
  }
  if (minIdx >= 0) {
    arcSegments.splice(minIdx, 1);
  }
}

/**
 * Clip older segments behind the new segment
 */
function clipOlderSegments(newSeg) {
  for (let i = 0; i < globalSegments.length; i++) {
    let old = globalSegments[i];
    let ints = lineIntersection(
      old.x1, old.y1, old.x2, old.y2,
      newSeg.x1, newSeg.y1, newSeg.x2, newSeg.y2
    );
    if (ints.intersects) {
      let ix = lerp(old.x1, old.x2, ints.t);
      let iy = lerp(old.y1, old.y2, ints.t);
      // keep portion from old.x1,y1 to intersection
      let segA = {
        x1: old.x1, y1: old.y1,
        x2: ix,     y2: iy,
        colorIndex: old.colorIndex
      };
      let lenA = dist(segA.x1, segA.y1, segA.x2, segA.y2);
      if (lenA > 0.5) {
        globalSegments[i] = segA;
      } else {
        // remove
        globalSegments.splice(i, 1);
        i--;
      }
    }
  }
}

/**
 * Intersection test
 */
function lineIntersection(x1,y1,x2,y2, x3,y3,x4,y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 1e-8) {
    return { intersects:false, t:0, u:0 };
  }
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4)) / denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2)) / denom;
  let inter = (t>=0 && t<=1 && u>=0 && u<=1);
  return { intersects: inter, t, u };
}

/**
 * pick random boundary anchor
 */
function getRandomBoundaryPoint() {
  let side = floor(random(4));
  let minPix = workAreaMarginPixels;
  let maxX = width - workAreaMarginPixels;
  let maxY = height - workAreaMarginPixels;
  if (side === 0) { // top
    return { x: random(minPix, maxX), y: minPix };
  } else if (side === 1) { // bottom
    return { x: random(minPix, maxX), y: maxY };
  } else if (side === 2) { // left
    return { x: minPix, y: random(minPix, maxY) };
  } else { // right
    return { x: maxX, y: random(minPix, maxY) };
  }
}

/**
 * angle from boundary anchor roughly inward
 */
function getInwardAngle(pt) {
  let cx = width/2, cy = height/2;
  let dx = cx - pt.x;
  let dy = cy - pt.y;
  let base = atan2(dy, dx);
  return base + random(-0.3, 0.3);
}

////////////////////////////////////////////////////////
// Drawing final geometry from globalSegments
////////////////////////////////////////////////////////

function drawGlobalSegments() {
  // group by color
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }

  // draw in the order of selected colors
  for (let cIdx of selectedColorIndices) {
    let segs = grouped[cIdx] || [];
    if (segs.length === 0) continue;
    applyStrokeWithOpacity(colors[cIdx].hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let s of segs) {
      vertex(s.x1, s.y1);
      vertex(s.x2, s.y2);
    }
    endShape();
  }
}

/** Applies the stroke color with the given hex and sets its alpha. */
function applyStrokeWithOpacity(hexColor) {
  let c = color(hexColor);
  c.setAlpha(255 * strokeOpacity);
  stroke(c);
}

////////////////////////////////////////////////////////
// Markers + palette
////////////////////////////////////////////////////////

function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0,0,5,0);
  line(0,0,0,5);
  line(width-5,height,width,height);
  line(width,height-5,width,height);
}

function drawPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * pixelsPerInch);

  let used = selectedColorIndices;
  let numColors = used.length;
  if (numColors===0) return;

  let totalGaps = (numColors-1)*gapSize;
  let segLen = (paletteLength - totalGaps)/numColors;
  let xStart = (width - paletteLength)/2;

  strokeWeight(barHeight);
  for (let i=0; i<numColors; i++) {
    let cIdx = used[i];
    applyStrokeWithOpacity(colors[cIdx].hex);
    let x = xStart + i*(segLen+gapSize);
    line(x, yStart, x+segLen, yStart);
  }
}

////////////////////////////////////////////////////////
// Key Handling & Reset
////////////////////////////////////////////////////////

function keyPressed() {
  if (key===' ') {
    saveSVGs();
  } else if (key==='r' || key==='R') {
    resetCanvas();
  }
}

function resetCanvas() {
  globalSegments = [];
  setup();
}

////////////////////////////////////////////////////////
// SVG Export
////////////////////////////////////////////////////////

function saveSVGs() {
  // We'll gather the final geometry from globalSegments
  // group by color, build path strings
  let segMap = {};
  for (let seg of globalSegments) {
    if (!segMap[seg.colorIndex]) segMap[seg.colorIndex] = [];
    let d = `M${seg.x1.toFixed(2)},${seg.y1.toFixed(2)}L${seg.x2.toFixed(2)},${seg.y2.toFixed(2)}`;
    segMap[seg.colorIndex].push(d);
  }

  const ts = Date.now();
  // combined
  let combined = buildSVG(0, segMap);
  saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);

  // per color
  selectedColorIndices.forEach(cIdx=>{
    let single = buildSVG(cIdx, segMap);
    let cName = colors[cIdx].name.toUpperCase();
    let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(single, fname);
  });
}

function buildSVG(activeColor, segMap) {
  let svg = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svg += addMarkersSVG();

  if (activeColor===0) {
    // all
    let layerNum = 1;
    for (let cIdx of selectedColorIndices) {
      svg += addSegmentsLayer(cIdx, layerNum, segMap[cIdx] || []);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor)+1;
    let arr = segMap[activeColor] || [];
    svg += addSegmentsLayer(activeColor, layerNum, arr);
  }

  svg += '</svg>';
  return svg;
}

function addSegmentsLayer(colorIndex, layerNum, segStrings) {
  let c = colors[colorIndex];
  let out = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${c.name.toLowerCase()}-${c.ink}-${c.width}"
 style="display:inline"
 stroke="${c.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${c.hex}">n`;

  if (segStrings.length>0) {
    let bigD = segStrings.join(' ');
    out += `<path d="${bigD}" stroke-width="${strokeWeightValue}" fill="none" />n`;
  }

  // palette bar
  let used = selectedColorIndices;
  let i = used.indexOf(colorIndex);
  if (i>=0) {
    let paletteLength=300, barHeight=2, gapSize=7;
    let yStart = height - (1.25 * pixelsPerInch);
    let numColors = used.length;
    let totalGaps = (numColors - 1)*gapSize;
    let segLen = (paletteLength - totalGaps)/numColors;
    let xStart = (width - paletteLength)/2;
    let x = xStart + i*(segLen+gapSize);
    out += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segLen).toFixed(2)}"
     stroke="${c.hex}" stroke-opacity="${strokeOpacity}"
     stroke-width="2" fill="none"/>n`;
  }

  out += '</g>n';
  return out;
}

function addMarkersSVG() {
  const sw=1;
  const off=sw/2;
  return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="black"
   stroke-opacity="${strokeOpacity}"
   inkscape:highlight-color="black">
<path d="M${(5+off).toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${(5+off).toFixed(2)}
       M${(width-5-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-5-off).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(data, fname) {
  let blob = new Blob([data], {type:'image/svg+xml;charset=utf-8'});
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fname;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches – Clipped Inner Arcs)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, arcs, torsion,
              layering, occlusion, clipped endpoints, pen-plotter, minimalism

### Conceptual Framework

This work is built in layers. First, four “outer” arcs are drawn starting from the work‐area boundaries.
For each subsequent (inner) arc, its starting point is chosen from a point on an already drawn arc.
Then the inner arc is grown step by step with a gentle torsion. As soon as its new segment would intersect
any existing arc, that new segment is truncated at the intersection and the arc immediately stops.
Furthermore, from each arc the single shortest segment is removed so that gaps occur at the arc’s ends.
The final visible segments—after all clipping—are stored in a global array and drawn in one pass;
this same geometry is then used for SVG export, guaranteeing that the canvas and SVG match exactly.
All lines are drawn as single‑stroke paths (with 0.8 opacity) to ensure pen‑plotter compatibility.

### Technical Approach

1. **Outer vs. Inner Arcs**  
   - The first four arcs start from random points on the canvas boundary.
   - For inner arcs, the starting point is chosen randomly from the endpoints of existing arcs.

2. **Arc Generation & Clipping**  
   - Each arc is generated stepwise (with a fixed step length and small torsion plus random deviation).
   - If a new segment would intersect any previously drawn segment, it is truncated at the intersection and the arc stops.
   - After the arc is generated, its single shortest segment is removed (creating a gap at its start or end).

3. **Unified Final Geometry**  
   - Only the final (clipped) segments are stored in the global geometry array.
   - The canvas and SVG are both rendered from this global array so that they match exactly.

---
*/

const canvasWidthInches = 11;
const canvasHeightInches = 11;
const dpi = 100;
const dayNumber = '153';

// Color palette (immutable)
const colors = {
  1: { name: 'ORANGE',  ink: 5,   width: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN',   ink: 12,  width: 0.45, hex: '#993300' },
  3: { name: 'RED',     ink: 19,  width: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE',    ink: 21,  width: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE',  ink: 24,  width: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN',   ink: 29,  width: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE',    ink: 36,  width: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK',   ink: 49,  width: 0.45, hex: '#333333' },
  9: { name: 'SEPIA',   ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;

// Generation rules for arc creation
let generationRules = {
  numArcs: 18,        // total arcs (outer + inner)
  minSteps: 40,       // minimum points per arc
  maxSteps: 80,       // maximum points per arc
  torsion: 0.03,      // base torsion per step
  stepLength: 10,     // step length (pixels)
  maxDeviation: 0.02  // random deviation in torsion
};

let canvasWidthPixels, canvasHeightPixels;
let marginInches = 2;
let marginPixels;
let strokeWeightValue;
let selectedColorIndices = [];

// Global final visible segments: each is {x1, y1, x2, y2, colorIndex}
let globalSegments = [];

// We'll store SVG path data from the final geometry:
let finalPathData = [];

// For inner arcs, we choose starting points from previously drawn endpoints.
function getRandomExistingPoint() {
  if (globalSegments.length === 0) return null;
  let seg = random(globalSegments);
  // Choose randomly between start and end of the segment:
  return random() < 0.5 ? { x: seg.x1, y: seg.y1 } : { x: seg.x2, y: seg.y2 };
}

function setup() {
  // Optionally, uncomment to fix randomness:
  // randomSeed(153);

  canvasWidthPixels = canvasWidthInches * dpi;
  canvasHeightPixels = canvasHeightInches * dpi;
  createCanvas(canvasWidthPixels, canvasHeightPixels);

  marginInches = random(1.5, 4);
  marginPixels = marginInches * dpi;

  adjustStrokeWeight();
  pickColors();

  globalSegments = [];
  finalPathData = [];

  generateArcs();

  // After generating all arcs, draw final geometry in one pass.
  background(255);
  drawGlobalSegments();
  drawMarkers();
  drawPaletteBars();

  noLoop();
}

function adjustStrokeWeight() {
  strokeWeightValue = 2; // ~0.5mm => ~2px
  marginPixels += strokeWeightValue / 2;
}

function pickColors() {
  let indices = Object.keys(colors).map(k => parseInt(k));
  shuffle(indices, true);
  let n = floor(random(3, 7)); // use between 3 and 6 colors
  selectedColorIndices = indices.slice(0, n).sort((a, b) => a - b);
}

/**
 * Generate arcs sequentially.
 * For the first 4 arcs, use random boundary anchors.
 * For inner arcs (arc index >= 4), use a random existing point.
 */
function generateArcs() {
  for (let i = 0; i < generationRules.numArcs; i++) {
    let colorIndex = random(selectedColorIndices);
    let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
    let startPoint;
    if (i < 4) {
      startPoint = getRandomBoundaryPoint();
    } else {
      startPoint = getRandomExistingPoint();
      if (startPoint === null) {
        startPoint = getRandomBoundaryPoint();
      }
    }
    let polyline = buildArcFromPoint(startPoint, steps);
    // Convert polyline to segments
    let segs = polylineToSegments(polyline);
    // Remove the single shortest segment from this arc
    removeShortestSegment(segs);
    // For each new segment, check for intersection.
    // If an intersection is detected, truncate the segment at the intersection and stop.
    let finalPolyline = [];
    finalPolyline.push(polyline[0]);
    for (let seg of segs) {
      let intersected = false;
      let newPt = { x: seg.x2, y: seg.y2 };
      for (let old of globalSegments) {
        let inter = lineIntersection(
          old.x1, old.y1, old.x2, old.y2,
          seg.x1, seg.y1, seg.x2, seg.y2
        );
        if (inter.intersects) {
          newPt = { 
            x: lerp(seg.x1, seg.x2, inter.u),
            y: lerp(seg.y1, seg.y2, inter.u)
          };
          intersected = true;
          break;
        }
      }
      finalPolyline.push(newPt);
      if (intersected) break;
    }
    // Convert the final polyline to segments and add them to globalSegments
    let finalSegs = polylineToSegments(finalPolyline);
    for (let seg of finalSegs) {
      seg.colorIndex = colorIndex;
      globalSegments.push(seg);
    }
    // Record path data for SVG export
    let d = "";
    for (let pt of finalPolyline) {
      d += `L${pt.x.toFixed(2)},${pt.y.toFixed(2)} `;
    }
    // Replace first L with M:
    d = "M" + d.substring(1).trim();
    finalPathData.push({ colorIndex, d });
  }
}

/**
 * Build an arc polyline starting from a given point.
 * The arc grows with a base torsion plus random deviation until a stop condition.
 */
function buildArcFromPoint(startPt, steps) {
  let pts = [startPt];
  let angle = getInwardAngle(startPt);
  for (let i = 0; i < steps; i++) {
    let dev = random(-generationRules.maxDeviation, generationRules.maxDeviation);
    angle += (generationRules.torsion + dev);
    let prev = pts[pts.length - 1];
    let nx = prev.x + generationRules.stepLength * cos(angle);
    let ny = prev.y + generationRules.stepLength * sin(angle);
    if (nx < marginPixels || nx > (width - marginPixels) ||
        ny < marginPixels || ny > (height - marginPixels)) {
      break;
    }
    pts.push({ x: nx, y: ny });
  }
  return pts;
}

function polylineToSegments(pts) {
  let segs = [];
  for (let i = 0; i < pts.length - 1; i++) {
    segs.push({
      x1: pts[i].x, y1: pts[i].y,
      x2: pts[i+1].x, y2: pts[i+1].y
    });
  }
  return segs;
}

/**
 * Remove the single shortest segment from the arc.
 */
function removeShortestSegment(arcSegs) {
  if (arcSegs.length < 1) return;
  let minLen = Infinity;
  let minIdx = -1;
  for (let i = 0; i < arcSegs.length; i++) {
    let s = arcSegs[i];
    let len = dist(s.x1, s.y1, s.x2, s.y2);
    if (len < minLen) {
      minLen = len;
      minIdx = i;
    }
  }
  if (minIdx >= 0) {
    arcSegs.splice(minIdx, 1);
  }
}

/**
 * Standard line intersection test.
 * Returns {intersects, t, u} where t is the fraction along the first line.
 */
function lineIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {
  let denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
  if (abs(denom) < 1e-8) return { intersects: false, t: 0, u: 0 };
  let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4)) / denom;
  let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2)) / denom;
  return { intersects: (t >= 0 && t <= 1 && u >= 0 && u <= 1), t, u };
}

/**
 * Get a random boundary anchor point.
 */
function getRandomBoundaryPoint() {
  let side = floor(random(4));
  let minPix = marginPixels;
  let maxX = width - marginPixels;
  let maxY = height - marginPixels;
  if (side === 0) return { x: random(minPix, maxX), y: minPix };
  else if (side === 1) return { x: random(minPix, maxX), y: maxY };
  else if (side === 2) return { x: minPix, y: random(minPix, maxY) };
  else return { x: maxX, y: random(minPix, maxY) };
}

/**
 * Get an inward-pointing angle from a given point.
 */
function getInwardAngle(pt) {
  let cx = width / 2, cy = height / 2;
  let dx = cx - pt.x, dy = cy - pt.y;
  let base = atan2(dy, dx);
  return base + random(-0.3, 0.3);
}

////////////////////////////////////////////////////////
// Final Drawing: Use globalSegments for both canvas & SVG
////////////////////////////////////////////////////////

function drawGlobalSegments() {
  // Group segments by color
  let grouped = {};
  for (let seg of globalSegments) {
    if (!grouped[seg.colorIndex]) grouped[seg.colorIndex] = [];
    grouped[seg.colorIndex].push(seg);
  }
  // Draw each group in order of selectedColorIndices
  for (let cIdx of selectedColorIndices) {
    let segs = grouped[cIdx] || [];
    if (segs.length === 0) continue;
    applyStrokeWithOpacity(colors[cIdx].hex);
    strokeWeight(strokeWeightValue);
    beginShape(LINES);
    for (let s of segs) {
      vertex(s.x1, s.y1);
      vertex(s.x2, s.y2);
    }
    endShape();
  }
}

/**
 * Draw registration markers.
 */
function drawMarkers() {
  strokeWeight(1);
  applyStrokeWithOpacity('#000000');
  line(0, 0, 5, 0);
  line(0, 0, 0, 5);
  line(width - 5, height, width, height);
  line(width, height - 5, width, height);
}

/**
 * Draw color palette bars.
 */
function drawPaletteBars() {
  let paletteLength = 300;
  let barHeight = 2;
  let gapSize = 7;
  let yStart = height - (1.25 * dpi);
  let used = selectedColorIndices;
  let numColors = used.length;
  if (numColors === 0) return;
  let totalGaps = (numColors - 1) * gapSize;
  let segLen = (paletteLength - totalGaps) / numColors;
  let xStart = (width - paletteLength) / 2;
  strokeWeight(barHeight);
  for (let i = 0; i < numColors; i++) {
    let cIdx = used[i];
    applyStrokeWithOpacity(colors[cIdx].hex);
    let x = xStart + i * (segLen + gapSize);
    line(x, yStart, x + segLen, yStart);
  }
}

////////////////////////////////////////////////////////
// SVG Export
////////////////////////////////////////////////////////

function keyPressed() {
  if (key === ' ') {
    saveSVGs();
  } else if (key === 'r' || key === 'R') {
    resetCanvas();
  }
}

function resetCanvas() {
  globalSegments = [];
  finalPathData = [];
  setup();
}

function saveSVGs() {
  // Build path data from final globalSegments
  let segMap = {};
  for (let seg of globalSegments) {
    if (!segMap[seg.colorIndex]) segMap[seg.colorIndex] = [];
    let d = `M${seg.x1.toFixed(2)},${seg.y1.toFixed(2)}L${seg.x2.toFixed(2)},${seg.y2.toFixed(2)}`;
    segMap[seg.colorIndex].push(d);
  }
  const ts = Date.now();
  let combinedSVG = buildSVG(0, segMap);
  saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);
  selectedColorIndices.forEach(cIdx => {
    let colorSVG = buildSVG(cIdx, segMap);
    let cName = colors[cIdx].name.toUpperCase();
    let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
    saveSVGFile(colorSVG, fname);
  });
}

function buildSVG(activeColor, segMap) {
  let svg = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
  svg += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
  svg += addMarkersSVG();
  if (activeColor === 0) {
    let layerNum = 1;
    for (let cIdx of selectedColorIndices) {
      svg += addSegmentsSVG(cIdx, layerNum, segMap[cIdx] || []);
      layerNum++;
    }
  } else {
    let layerNum = selectedColorIndices.indexOf(activeColor) + 1;
    svg += addSegmentsSVG(activeColor, layerNum, segMap[activeColor] || []);
  }
  svg += '</svg>';
  return svg;
}

function addSegmentsSVG(colorIndex, layerNum, segStrings) {
  let c = colors[colorIndex];
  let sw = strokeWeightValue;
  let out = `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${colorIndex}-${c.name.toLowerCase()}-${c.ink}-${c.width}"
 style="display:inline"
 stroke="${c.hex}"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="${c.hex}">n`;
  if (segStrings.length > 0) {
    let bigD = segStrings.join(' ');
    out += `<path d="${bigD}" stroke-width="${sw}" fill="none" />n`;
  }
  let used = selectedColorIndices;
  let i = used.indexOf(colorIndex);
  if (i >= 0) {
    let paletteLength = 300, barHeight = 2, gapSize = 7;
    let yStart = height - (1.25 * dpi);
    let numColors = used.length;
    let totalGaps = (numColors - 1) * gapSize;
    let segLen = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;
    let x = xStart + i * (segLen + gapSize);
    out += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x + segLen).toFixed(2)}" stroke="${c.hex}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
  }
  out += '</g>n';
  return out;
}

function addMarkersSVG() {
  const sw = 1;
  const off = sw / 2;
  return `<g
 inkscape:groupmode="layer"
 id="layer0"
 inkscape:label="0-markers"
 style="display:inline"
 stroke="black"
 stroke-opacity="${strokeOpacity}"
 inkscape:highlight-color="black">
<path d="M${(5+off).toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${off.toFixed(2)}
         L${off.toFixed(2)},${(5+off).toFixed(2)}
       M${(width-5-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-off).toFixed(2)}
         L${(width-off).toFixed(2)},${(height-5-off).toFixed(2)}"
 stroke-width="${sw}" fill="none"/>
</g>n`;
}

function saveSVGFile(data, fname) {
  let blob = new Blob([data], { type: 'image/svg+xml;charset=utf-8' });
  let url = URL.createObjectURL(blob);
  let link = document.createElement('a');
  link.href = url;
  link.download = fname;
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, arcs, torsion,
              layering, intersection, minimalism, pen-plotter

### Concept

I envision my identity as a set of arcs that each emerge from an outer boundary, then terminate
immediately upon meeting another arc. These arcs reflect how individual impulses or ideas do not pass 
through or overshadow existing structures, but instead nest gently into what came before. By also removing 
the single shortest segment of each arc, a small gap appears where the arc either begins or concludes, 
symbolizing points of uncertainty or understated transitions. The arcs remain purely line-based and
slightly transparent, preserving both a pen-friendly format and the subtle interplay of overlapping strokes.

### Technical Approach

1. **Arc Generation**  
   - Each arc starts from a random point on the canvas boundary or, if enough arcs exist, 
     from a random endpoint of an already drawn arc.  
   - It grows inward, step by step, under a small “torsion” angle that changes by a random 
     deviation each step. If it tries to move outside the margin, it stops.  

2. **Immediate Termination**  
   - As soon as the arc’s new segment intersects any older segment, the arc halts at the 
     intersection point; it does not pass or hide behind.  

3. **Shortest-Segment Removal**  
   - Before finalizing each newly created arc, its single shortest line segment is removed, 
     introducing a gap.  

4. **Single Final Pass**  
   - All arcs are stored as clipped line segments in one global list.  
   - After generating every arc, we render those final, visible segments once onto the canvas.  
   - This same geometry is used for the SVG export, ensuring the canvas and SVG match perfectly.

---
*/

// ----------------------------------------------------
// Constants (Immutable Settings)
// ----------------------------------------------------
const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

const colors = {
    1: { name: 'ORANGE', ink: 5,  width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN',  ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED',    ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE',   ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN',  ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE',   ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK',  ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA',  ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;
const EPSILON = 1e-6; 

// ----------------------------------------------------
// Generative Rules (Mutable)
// ----------------------------------------------------
let generationRules = {
    numArcs: 300,
    minSteps: 40,
    maxSteps: 200,
    torsion: 0.07,
    stepLength: 20,
    maxDeviation: 0.02
};

// ----------------------------------------------------
// Global Variables
// ----------------------------------------------------
let canvasWidthPixels;
let canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];

let strokeWeightValue;
// finalPathsData holds each arc’s {colorIndex, points: [...]} 
let finalPathsData = [];
// allPreviousSegments is our global geometry after clipping
let allPreviousSegments = [];

/**
 * Applies the stroke color with the given hex and sets its alpha based on strokeOpacity.
 */
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

function setup() {
    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    adjustForStrokeWeight();
    selectColors();
    
    finalPathsData = []; 
    allPreviousSegments = [];

    generateAndDrawShapes();
    noLoop();
}

/**
 * Adjust stroke weight and margin
 */
function adjustForStrokeWeight() {
    strokeWeightValue = 2; 
    workAreaMarginPixels += strokeWeightValue / 2;
}

/**
 * Randomly select 1..9 colors
 */
function selectColors() {
    let numColorsToUse = floor(random(1, 10)); 
    selectedColorIndices = selectRandomColorIndices(numColorsToUse);
}

function selectRandomColorIndices(n) {
    let indices = Object.keys(colors).map(k => parseInt(k));
    let selected = [];
    while (selected.length < n && indices.length > 0) {
        let idx = floor(random(indices.length));
        selected.push(indices[idx]);
        indices.splice(idx, 1);
    }
    return selected.sort((a, b) => a - b);
}

/**
 * The main routine: generate arcs, store them, draw them once
 */
function generateAndDrawShapes() {
    background(255);
    generateTerminatedArcs(); 
    noFill(); 
    drawFinalArcsOnCanvas();
    drawMarkers();
    addColorPaletteBars();
}

/**
 * Convert an array of points to line segments
 */
function pointsToSegments(points) {
    const segments = [];
    if (!points || points.length < 2) return segments;
    for (let i = 0; i < points.length - 1; i++) {
        segments.push({ p1: points[i], p2: points[i + 1] });
    }
    return segments;
}

/**
 * Intersection test
 */
function lineSegmentIntersection(p1, p2, p3, p4) {
    const x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y;
    const x3 = p3.x, y3 = p3.y, x4 = p4.x, y4 = p4.y;
    const den = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
    if (Math.abs(den) < EPSILON) return null;

    const ua_num = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3));
    const ub_num = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3));
    const ua = ua_num / den;
    const ub = ub_num / den;

    if (ua >= -EPSILON && ua <= 1.0 + EPSILON && 
        ub >= -EPSILON && ub <= 1.0 + EPSILON) {
        return {
            x: x1 + ua * (x2 - x1),
            y: y1 + ua * (y2 - y1),
            param_a: ua 
        };
    }
    return null;
}

/**
 * Generate arcs that terminate on intersection
 */
function generateTerminatedArcs() {
    let arcsToDraw = generationRules.numArcs;

    for (let i = 0; i < arcsToDraw; i++) {
        let colorIndex = random(selectedColorIndices);
        let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
        let pathPoints = createAndClipOneArcPath(steps, allPreviousSegments); 

        // If after generation we have 2 or more points, remove the single shortest segment:
        let segmentsHere = pointsToSegments(pathPoints);
        if (segmentsHere.length > 0) {
            let minDist = Infinity;
            let minIdx = -1;
            for (let j = 0; j < segmentsHere.length; j++) {
                const d = dist(segmentsHere[j].p1.x, segmentsHere[j].p1.y, segmentsHere[j].p2.x, segmentsHere[j].p2.y);
                if (d < minDist) {
                    minDist = d;
                    minIdx = j;
                }
            }
            if (minIdx >= 0) {
                segmentsHere.splice(minIdx, 1);
            }
            // Rebuild the points after removing that segment:
            let rePoints = [];
            if (segmentsHere.length > 0) {
                rePoints.push(segmentsHere[0].p1);
                for (let s = 0; s < segmentsHere.length; s++) {
                    rePoints.push(segmentsHere[s].p2);
                }
            }
            if (rePoints.length > 1) {
                finalPathsData.push({
                    colorIndex: colorIndex,
                    points: rePoints
                });
                // Add these segments to allPreviousSegments
                let finalSegs = pointsToSegments(rePoints);
                allPreviousSegments.push(...finalSegs);
            }
        }
    }
}

/**
 * Build a single arc path, stopping on intersection with existing segments
 */
function createAndClipOneArcPath(steps, existingSegments) {
    let anchor = getRandomBoundaryPoint();
    let currentArcPoints = [anchor];
    let angle = getInitialAngle(anchor);

    for (let step = 0; step < steps; step++) {
        let prevPoint = currentArcPoints[currentArcPoints.length - 1];
        let nextAngle = angle + random(-generationRules.maxDeviation, generationRules.maxDeviation) + generationRules.torsion;
        let nx = prevPoint.x + generationRules.stepLength * cos(nextAngle);
        let ny = prevPoint.y + generationRules.stepLength * sin(nextAngle);

        if (nx < workAreaMarginPixels || nx > (width - workAreaMarginPixels) ||
            ny < workAreaMarginPixels || ny > (height - workAreaMarginPixels)) {
            break; 
        }
        
        let newSegment = { p1: prevPoint, p2: { x: nx, y: ny } };
        let firstIntersection = null;

        for (const seg of existingSegments) {
            let intersect = lineSegmentIntersection(newSegment.p1, newSegment.p2, seg.p1, seg.p2);
            if (intersect) {
                if (!firstIntersection || intersect.param_a < firstIntersection.param_a) {
                    firstIntersection = intersect;
                }
            }
        }

        if (firstIntersection) {
            currentArcPoints.push({ x: firstIntersection.x, y: firstIntersection.y });
            break;
        } else {
            currentArcPoints.push({ x: nx, y: ny });
            angle = nextAngle; 
        }
    }
    return currentArcPoints;
}

/**
 * Return a random boundary anchor point
 */
function getRandomBoundaryPoint() {
    let side = floor(random(4));
    let minPix = workAreaMarginPixels;
    let maxPixX = width - workAreaMarginPixels;
    let maxPixY = height - workAreaMarginPixels;

    if (side === 0) {
        return { x: random(minPix, maxPixX), y: minPix };
    } else if (side === 1) {
        return { x: random(minPix, maxPixX), y: maxPixY };
    } else if (side === 2) {
        return { x: minPix, y: random(minPix, maxPixY) };
    } else {
        return { x: maxPixX, y: random(minPix, maxPixY) };
    }
}

/**
 * Compute an angle from boundary anchor that points somewhat inward
 */
function getInitialAngle(pt) {
    let centerX = width / 2;
    let centerY = height / 2;
    let dx = centerX - pt.x;
    let dy = centerY - pt.y;
    let baseAngle = atan2(dy, dx);
    return baseAngle + random(-0.3, 0.3);
}

/**
 * Draw the arcs on canvas from finalPathsData
 */
function drawFinalArcsOnCanvas() {
    strokeWeight(strokeWeightValue);
    noFill();
    for(const pathInfo of finalPathsData) {
        applyStrokeWithOpacity(colors[pathInfo.colorIndex].hex);
        beginShape();
        for (let j = 0; j < pathInfo.points.length; j++) {
            vertex(pathInfo.points[j].x, pathInfo.points[j].y);
        }
        endShape();
    }
}

/**
 * Draw markers
 */
function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    noFill(); 
    line(0, 0, 5, 0); 
    line(0, 0, 0, 5);
    line(width - 5, height, width, height); 
    line(width, height - 5, width, height);
}

/**
 * Draw color palette for visible arcs
 */
function addColorPaletteBars() {
    let paletteLength = 300;
    let barHeight = 2;
    let gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);

    let used = [...new Set(finalPathsData.map(o => o.colorIndex))].sort((a,b)=>a-b);
    let numColors = used.length;
    if (numColors === 0) return;
    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;
    strokeWeight(barHeight);
    noFill();

    used.forEach((cIdx, i) => {
        let colorValue = colors[cIdx].hex;
        applyStrokeWithOpacity(colorValue);
        let x = xStart + i*(segmentLength+gapSize);
        line(x, yStart, x + segmentLength, yStart);
    });
}

/**
 * Reset
 */
function resetCanvas() {
    finalPathsData = []; 
    allPreviousSegments = []; 
    selectColors(); 
    generateAndDrawShapes(); 
}

/**
 * Key Handling
 */
function keyPressed() {
    if (key === ' ') {
        saveSVGs(); 
    } else if (key === 'r' || key === 'R') {
        resetCanvas(); 
    }
}

/**
 * Save SVG
 */
function saveSVGs() {
    const timestamp = Date.now();
    let combinedSVG = generateSVG(0);
    saveSVGFile(combinedSVG, `${dayNumber}-ALL-PORTRAIT-${timestamp}.svg`);

    let usedIndices = [...new Set(finalPathsData.map(o => o.colorIndex))].sort((a,b)=>a-b);
    usedIndices.forEach((colorIndex) => {
        let colorSVG = generateSVG(colorIndex);
        let colorName = colors[colorIndex].name.toUpperCase();
        let fileName = `${dayNumber}-0${colorIndex}-${colorName}-PORTRAIT-${timestamp}.svg`;
        saveSVGFile(colorSVG, fileName);
    });
}

/**
 * Generate SVG: either 0 => combined, or per color
 */
function generateSVG(activeColor = 0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
    svgContent += addMarkersSVG();

    let usedIndices = [...new Set(finalPathsData.map(o => o.colorIndex))].sort((a,b)=>a-b);
    let colorsToInclude = (activeColor === 0) ? usedIndices : [activeColor];

    selectedColorIndices.forEach((cIdx) => {
        if (!colorsToInclude.includes(cIdx)) return;
        let col = colors[cIdx];
        let layerNum = selectedColorIndices.indexOf(cIdx) + 1;
        svgContent += `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${cIdx}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 stroke-width="${strokeWeightValue}"
 fill="none"
 stroke-linecap="round"
 stroke-linejoin="round"
 inkscape:highlight-color="${col.hex}">n`;

        let arcsOfThisColor = finalPathsData.filter(p => p.colorIndex === cIdx);
        let arcsD = '';
        arcsOfThisColor.forEach(arc => {
            if (!arc.points || arc.points.length < 2) return;
            let d = '';
            for (let i = 0; i < arc.points.length; i++) {
                let px = arc.points[i].x.toFixed(2);
                let py = arc.points[i].y.toFixed(2);
                d += (i === 0) ? `M${px},${py} ` : `L${px},${py} `;
            }
            arcsD += `<path d="${d.trim()}" />n`;
        });
        svgContent += arcsD;
        svgContent += addPaletteBarSVG(cIdx, usedIndices);
        svgContent += '</g>n';
    });

    svgContent += '</svg>';
    return svgContent;
}

/**
 * Markers for the SVG
 */
function addMarkersSVG() {
    const strokeWidth = 1;
    const offset = strokeWidth / 2;
    return `<g
   inkscape:groupmode="layer"
   id="layer0"
   inkscape:label="0-markers"
   style="display:inline"
   stroke="#000000" 
   stroke-opacity="${strokeOpacity}" 
   stroke-width="${strokeWidth}"
   fill="none"
   inkscape:highlight-color="#000000">
<path d="M${(5 + offset).toFixed(2)},${offset.toFixed(2)}
         L${offset.toFixed(2)},${offset.toFixed(2)}
         L${offset.toFixed(2)},${(5 + offset).toFixed(2)}
       M${(width - 5 - offset).toFixed(2)},${(height - offset).toFixed(2)}
         L${(width - offset).toFixed(2)},${(height - offset).toFixed(2)}
         L${(width - offset).toFixed(2)},${(height - 5 - offset).toFixed(2)}" />
</g>n`;
}

/**
 * Add palette bar for this color index in SVG
 */
function addPaletteBarSVG(colorIndex, usedIndices) {
    let svg = '';
    let i = usedIndices.indexOf(colorIndex);
    if (i < 0) return '';
    let paletteLength = 300, barHeight = 2, gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);
    let numColors = usedIndices.length;
    if (numColors < 1) return '';
    let totalGaps = (numColors - 1) * gapSize;
    let segmentLength = (paletteLength - totalGaps) / numColors;
    let xStart = (width - paletteLength) / 2;
    let x = xStart + i * (segmentLength + gapSize);
    let colorValue = colors[colorIndex].hex;
    svg += `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x + segmentLength).toFixed(2)}" 
      stroke="${colorValue}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
    return svg;
}

function saveSVGFile(svgData, fileName) {
    try {
        let blob = new Blob([svgData], { type: 'image/svg+xml;charset=utf-8' });
        let url = URL.createObjectURL(blob);
        let link = document.createElement('a');
        link.href = url;
        link.download = fileName;
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
        URL.revokeObjectURL(url);
    } catch (e) {
        console.error("Error saving SVG:", e);
    }
}

// Day 153
/*

=======================================
  Day 153 Self-Portrait (Torsional Reaches)
=======================================

### Title: *Torsional Reaches*

### Medium: Generative Drawing on Paper

### Keywords: generative art, digital art, algorithmic art, arcs, torsion,
              immediate termination, layering, intersection, minimalism

### Concept

I portray my identity as arcs that each begin at the work area’s boundary and stop the
instant they touch another arc. Each arc is subtly “twisting” with a gentle torsion,
so the lines do not progress in a perfect curve. By removing no additional gaps or
segments beyond these rules, every line remains continuous until it terminates exactly
where it meets an earlier shape. No arcs cross or extend beneath another, reflecting an
idea of self-discovery that always respects preexisting boundaries rather than passing
through them. The arcs are rendered with slightly transparent strokes to highlight their
points of convergence without relying on fills—thus preserving a pen-friendly, single-line
execution.

### Technical Approach

1. **Arc Generation**  
   - An arc starts from a random boundary anchor.  
   - Each step extends inward by a fixed distance, modified by a small random torsion 
     around the base direction.  
   - If the next point would go outside the margin, or if the new segment intersects 
     any prior arc, the arc halts immediately at that intersection.

2. **No Additional Gaps**  
   - No extra segments are removed beyond the immediate halt on intersection.  
   - Each line, once started, remains continuous until it intersects something or 
     runs out of space.

3. **Single-Final Pass**  
   - The final arcs are stored as simple polylines.  
   - We draw them once on the canvas using single strokes.  
   - For the SVG export, we build path commands from these polylines so that 
     the export matches the final drawing exactly.

---
*/

// ============ Constants (Immutable) ============
const canvasWidthInches = 11;
const canvasHeightInches = 11;
const pixelsPerInch = 100;
const dayNumber = '153';

const colors = {
    1: { name: 'ORANGE', ink: 5,  width: 0.45, hex: '#ff6600' },
    2: { name: 'BROWN',  ink: 12, width: 0.45, hex: '#993300' },
    3: { name: 'RED',    ink: 19, width: 0.45, hex: '#f01e2c' },
    4: { name: 'ROSE',   ink: 21, width: 0.45, hex: '#ff00bf' },
    5: { name: 'PURPLE', ink: 24, width: 0.45, hex: '#bf00ff' },
    6: { name: 'GREEN',  ink: 29, width: 0.45, hex: '#00cc99' },
    7: { name: 'BLUE',   ink: 36, width: 0.45, hex: '#0040ff' },
    8: { name: 'BLACK',  ink: 49, width: 0.45, hex: '#333333' },
    9: { name: 'SEPIA',  ink: 117, width: 0.45, hex: '#856647' }
};

const strokeOpacity = 0.8;
const EPSILON = 1e-6; 

// ============ Mutable Generative Settings ============
let generationRules = {
    numArcs: 300,
    minSteps: 40,
    maxSteps: 200,
    torsion: 0.07,
    stepLength: 20,
    maxDeviation: 0.02
};

// ============ Global Variables ============
let canvasWidthPixels;
let canvasHeightPixels;
let workAreaMarginInches = 2;
let workAreaMarginPixels;
let selectedColorIndices = [];

let strokeWeightValue;
let finalPathsData = [];
let allSegments = [];

// ----------------------------------------------------
// Applies a stroke color with given hex and alpha
// ----------------------------------------------------
function applyStrokeWithOpacity(hexColor) {
    let c = color(hexColor);
    c.setAlpha(255 * strokeOpacity);
    stroke(c);
}

// ----------------------------------------------------
// p5.js Setup
// ----------------------------------------------------
function setup() {
    canvasWidthPixels = canvasWidthInches * pixelsPerInch;
    canvasHeightPixels = canvasHeightInches * pixelsPerInch;
    createCanvas(canvasWidthPixels, canvasHeightPixels);

    workAreaMarginInches = random(1.5, 4);
    workAreaMarginPixels = workAreaMarginInches * pixelsPerInch;

    adjustForStrokeWeight();
    selectColors();
    
    finalPathsData = []; 
    allSegments = [];

    generateAndDrawArcs();
    noLoop();
}

// ----------------------------------------------------
// Adjust stroke weight and margin
// ----------------------------------------------------
function adjustForStrokeWeight() {
    strokeWeightValue = 2; 
    workAreaMarginPixels += strokeWeightValue / 2;
}

// ----------------------------------------------------
// Pick 1..9 random colors
// ----------------------------------------------------
function selectColors() {
    let n = floor(random(1, 10)); 
    selectedColorIndices = pickRandomColorIndices(n);
}

function pickRandomColorIndices(n) {
    let indices = Object.keys(colors).map(k => parseInt(k));
    let selected = [];
    while (selected.length < n && indices.length > 0) {
        let idx = floor(random(indices.length));
        selected.push(indices[idx]);
        indices.splice(idx, 1);
    }
    return selected.sort((a, b) => a - b);
}

// ----------------------------------------------------
// Main routine: generate arcs, store them, draw
// ----------------------------------------------------
function generateAndDrawArcs() {
    background(255);
    generateTerminatingArcs(); 
    drawAllArcsToCanvas();
    drawMarkers();
    drawPaletteBars();
}

// ----------------------------------------------------
// Generate arcs that stop when they intersect an old arc
// ----------------------------------------------------
function generateTerminatingArcs() {
    for (let i = 0; i < generationRules.numArcs; i++) {
        let colorIndex = random(selectedColorIndices);
        let steps = floor(random(generationRules.minSteps, generationRules.maxSteps));
        let polyPoints = buildArcPolyline(steps);

        if (polyPoints.length > 1) {
            finalPathsData.push({
                colorIndex: colorIndex,
                points: polyPoints
            });
            // Convert to line segments & store
            let newSegs = polylineToSegments(polyPoints);
            allSegments.push(...newSegs);
        }
    }
}

// ----------------------------------------------------
// Build an arc that halts at intersection
// ----------------------------------------------------
function buildArcPolyline(steps) {
    let anchor = getRandomBoundaryAnchor();
    let points = [ anchor ];

    let angle = getInwardAngle(anchor);
    for (let step = 0; step < steps; step++) {
        let prev = points[points.length - 1];
        let nextAngle = angle + random(-generationRules.maxDeviation, generationRules.maxDeviation) + generationRules.torsion;
        let nx = prev.x + generationRules.stepLength * cos(nextAngle);
        let ny = prev.y + generationRules.stepLength * sin(nextAngle);

        // If out of margin, stop
        if (
            nx < workAreaMarginPixels || nx > (width - workAreaMarginPixels) ||
            ny < workAreaMarginPixels || ny > (height - workAreaMarginPixels)
        ) {
            break;
        }
        let nextPoint = { x: nx, y: ny };

        // Check intersection with older arcs
        let newSeg = { p1: prev, p2: nextPoint };
        let earliestIntersect = null;

        for (let s of allSegments) {
            let inter = lineIntersection(newSeg.p1, newSeg.p2, s.p1, s.p2);
            if (inter) {
                // keep earliest intersection along newSeg
                if (!earliestIntersect || inter.u < earliestIntersect.u) {
                    earliestIntersect = inter;
                }
            }
        }

        if (earliestIntersect) {
            points.push({ x: earliestIntersect.x, y: earliestIntersect.y });
            break;
        } else {
            points.push(nextPoint);
            angle = nextAngle;
        }
    }
    return points;
}

// ----------------------------------------------------
// Basic line intersection
// ----------------------------------------------------
function lineIntersection(p1, p2, p3, p4) {
    const x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y;
    const x3 = p3.x, y3 = p3.y, x4 = p4.x, y4 = p4.y;

    const denom = (x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4);
    if (abs(denom) < EPSILON) return null;

    let t = ((x1 - x3)*(y3 - y4) - (y1 - y3)*(x3 - x4)) / denom;
    let u = ((x1 - x3)*(y1 - y2) - (y1 - y3)*(x1 - x2)) / denom;
    if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
        // intersection point
        return {
            x: x1 + t*(x2 - x1),
            y: y1 + t*(y2 - y1),
            t, u
        };
    }
    return null;
}

// ----------------------------------------------------
// Convert polyline to segments
// ----------------------------------------------------
function polylineToSegments(pts) {
    const segs = [];
    for (let i = 0; i < pts.length - 1; i++) {
        segs.push({ p1: pts[i], p2: pts[i + 1] });
    }
    return segs;
}

// ----------------------------------------------------
// Return random boundary anchor
// ----------------------------------------------------
function getRandomBoundaryAnchor() {
    let side = floor(random(4));
    let minPix = workAreaMarginPixels;
    let maxX = width - workAreaMarginPixels;
    let maxY = height - workAreaMarginPixels;
    if (side === 0) return { x: random(minPix, maxX), y: minPix };
    else if (side === 1) return { x: random(minPix, maxX), y: maxY };
    else if (side === 2) return { x: minPix, y: random(minPix, maxY) };
    else return { x: maxX, y: random(minPix, maxY) };
}

// ----------------------------------------------------
// Return an angle from boundary anchor that points inward
// ----------------------------------------------------
function getInwardAngle(pt) {
    let cx = width / 2, cy = height / 2;
    let dx = cx - pt.x, dy = cy - pt.y;
    let baseAngle = atan2(dy, dx);
    return baseAngle + random(-0.3, 0.3);
}

// ----------------------------------------------------
// Draw arcs on canvas
// ----------------------------------------------------
function drawAllArcsToCanvas() {
    strokeWeight(strokeWeightValue);
    noFill();
    for (const arcObj of finalPathsData) {
        let col = colors[arcObj.colorIndex];
        applyStrokeWithOpacity(col.hex);
        beginShape();
        for (let pt of arcObj.points) {
            vertex(pt.x, pt.y);
        }
        endShape();
    }
}

// ----------------------------------------------------
// Markers & Palette
// ----------------------------------------------------
function drawMarkers() {
    strokeWeight(1);
    applyStrokeWithOpacity('#000000');
    noFill();
    line(0, 0, 5, 0);
    line(0, 0, 0, 5);
    line(width - 5, height, width, height);
    line(width, height - 5, width, height);
}

function drawPaletteBars() {
    let paletteLength = 300, barHeight = 2, gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);
    let usedColors = [...new Set(finalPathsData.map(d => d.colorIndex))].sort((a,b)=>a-b);
    let numColors = usedColors.length;
    if (numColors === 0) return;
    let totalGaps = (numColors - 1) * gapSize;
    let segLen = (paletteLength - totalGaps)/numColors;
    let xStart = (width - paletteLength)/2;
    strokeWeight(barHeight);

    usedColors.forEach((cIdx, i)=>{
        let col = colors[cIdx].hex;
        applyStrokeWithOpacity(col);
        let x = xStart + i*(segLen+gapSize);
        line(x, yStart, x+segLen, yStart);
    });
}

// ----------------------------------------------------
// Key & Reset
// ----------------------------------------------------
function keyPressed() {
    if (key === ' ') {
        saveSVGs();
    } else if (key === 'r' || key === 'R') {
        resetCanvas();
    }
}

function resetCanvas() {
    finalPathsData = [];
    allSegments = [];
    selectColors();
    generateAndDrawArcs();
}

// ----------------------------------------------------
// SVG Export
// ----------------------------------------------------
function saveSVGs() {
    const ts = Date.now();
    let combined = generateSVG(0);
    saveSVGFile(combined, `${dayNumber}-ALL-PORTRAIT-${ts}.svg`);
    let usedColors = [...new Set(finalPathsData.map(o => o.colorIndex))].sort((a,b)=>a-b);
    usedColors.forEach((cIdx)=>{
        let single = generateSVG(cIdx);
        let cName = colors[cIdx].name.toUpperCase();
        let fname = `${dayNumber}-0${cIdx}-${cName}-PORTRAIT-${ts}.svg`;
        saveSVGFile(single, fname);
    });
}

function generateSVG(activeColor=0) {
    let svgContent = `<svg version="1.1" width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg"n`;
    svgContent += `xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;
    svgContent += addMarkersSVG();

    let usedColors = [...new Set(finalPathsData.map(o => o.colorIndex))].sort((a,b)=>a-b);
    let colorsToInclude = (activeColor === 0) ? usedColors : [activeColor];
    selectedColorIndices.forEach((cIdx) => {
        if (!colorsToInclude.includes(cIdx)) return;
        let col = colors[cIdx];
        let layerNum = selectedColorIndices.indexOf(cIdx) + 1;
        svgContent += `<g
 inkscape:groupmode="layer"
 id="layer${layerNum}"
 inkscape:label="${cIdx}-${col.name.toLowerCase()}-${col.ink}-${col.width}"
 style="display:inline"
 stroke="${col.hex}"
 stroke-opacity="${strokeOpacity}"
 stroke-width="${strokeWeightValue}"
 fill="none"
 stroke-linecap="round"
 stroke-linejoin="round"
 inkscape:highlight-color="${col.hex}">n`;

        // arcs
        let arcs = finalPathsData.filter(o => o.colorIndex===cIdx);
        arcs.forEach(arc=>{
            if (!arc.points || arc.points.length<2) return;
            let d = '';
            for (let p=0; p<arc.points.length; p++){
                let px = arc.points[p].x.toFixed(2);
                let py = arc.points[p].y.toFixed(2);
                d += (p===0)? `M${px},${py}` : `L${px},${py}`;
                d += ' ';
            }
            svgContent += `<path d="${d.trim()}" />n`;
        });

        // add palette bar
        svgContent += addPaletteBarSVG(cIdx, usedColors);
        svgContent += '</g>n';
    });

    svgContent += '</svg>';
    return svgContent;
}

function addMarkersSVG() {
    const sw = 1;
    const off = sw/2;
    return `<g
       inkscape:groupmode="layer"
       id="layer0"
       inkscape:label="0-markers"
       style="display:inline"
       stroke="#000000"
       stroke-opacity="${strokeOpacity}"
       stroke-width="${sw}"
       fill="none"
       inkscape:highlight-color="#000000">
    <path d="M${(5 + off).toFixed(2)},${off.toFixed(2)}
             L${off.toFixed(2)},${off.toFixed(2)}
             L${off.toFixed(2)},${(5 + off).toFixed(2)}
           M${(width - 5 - off).toFixed(2)},${(height - off).toFixed(2)}
             L${(width - off).toFixed(2)},${(height - off).toFixed(2)}
             L${(width - off).toFixed(2)},${(height - 5 - off).toFixed(2)}" />
    </g>n`;
}

/**
 * Add the color palette bar for a single color
 */
function addPaletteBarSVG(colorIndex, usedColors) {
    let idx = usedColors.indexOf(colorIndex);
    if (idx<0) return '';
    let cVal = colors[colorIndex].hex;
    let paletteLength = 300, barHeight = 2, gapSize = 7;
    let yStart = height - (1.25 * pixelsPerInch);
    let numColors = usedColors.length;
    let totalGaps = (numColors -1)*gapSize;
    let segLen = (paletteLength - totalGaps)/numColors;
    let xStart = (width - paletteLength)/2;
    let x = xStart + idx*(segLen+gapSize);

    return `<path d="M${x.toFixed(2)},${yStart.toFixed(2)}H${(x+segLen).toFixed(2)}"
  stroke="${cVal}" stroke-opacity="${strokeOpacity}" stroke-width="${barHeight}" fill="none"/>n`;
}

function saveSVGFile(svgData, fname) {
    let blob = new Blob([svgData], {type:'image/svg+xml;charset=utf-8'});
    let url = URL.createObjectURL(blob);
    let link = document.createElement('a');
    link.href = url;
    link.download = fname;
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    URL.revokeObjectURL(url);
}