SWSector Reference

/*
File: swSector.js
Date: 2026-03-28
Author: klp
App:  SketchWaveTNT2026-03-19-Stg7
Purpose: SWSector class for SketchWaveJS

SWSector represents a "pizza-slice" (sector) shape defined by:
  - A vertex SWPoint (the tip of the slice)
  - A radius (in user units)
  - A theta (angular size in degrees)
  - A startAngle (degrees CCW from the +x axis, where the first edge lies)
  - A rotation offset (degrees, accumulated via rotate())

Default orientation: one edge lies along the +x axis, sector opens CCW
into the first quadrant.  Set startAngle to establish a different static
starting position before rotation begins.

Animations (all independent, all composable):
  - rotate(delta): call each frame to spin the sector about its vertex.
  - breatheRadius(sinusoid, t): oscillates the radius with an SWSinusoid.
  - breatheTheta(sinusoid, t):  oscillates the angular size with an SWSinusoid.

Color cycling: mutate fillColor.h and rebuild fillColor.col before drawing.

Angle convention:
  User space (math):   angles are CCW from +x axis, y increases upward.
  p5 / screen space:   angles are CW  from +x axis, y increases downward.
  Conversion:   p5_angle = -user_angle  (negate because y is flipped).

Drawing a sector whose first edge is at totalAngle = startAngle + rotation,
spanning theta degrees CCW:
  p5 arc start = -radians(totalAngle + theta)
  p5 arc stop  = -radians(totalAngle)
  arc(cx, cy, 2r, 2r, p5Start, p5Stop, PIE)  — p5 arc is clockwise.
*/

console.log("[swSector.js] SWSector class loaded.");

class SWSector {

    constructor(vertex, radius, theta, startAngle = 0, thickness = 2,
                fillColor = undefined, strokeColor = undefined) {

        this.vertex     = vertex;
        this.radius     = radius;
        this.theta      = theta;
        this.startAngle = startAngle;
        this.rotation   = 0;
        this.thickness  = thickness;

        this.fillColor   = fillColor   ? SWColor.copy(fillColor)   : undefined;
        this.strokeColor = strokeColor ? SWColor.copy(strokeColor) : undefined;

        this.originalRadius     = radius;
        this.originalTheta      = theta;
        this.originalStartAngle = startAngle;
        this.originalRotation   = 0;
        this.originalFillColor  = fillColor ? SWColor.copy(fillColor) : undefined;

        this.shouldShowVertex = true;

        this._updateGeometry();
    }

    _updateGeometry() {
        this.theta     = Math.max(0, Math.min(360, this.theta));
        this.arcLength = (this.theta / 360) * 2 * Math.PI * this.radius;
        this.area      = (this.theta / 360) * Math.PI * this.radius * this.radius;
    }

    draw() {
        this._drawArc(this.vertex.x, this.vertex.y, this.radius);
        if (this.shouldShowVertex && this.vertex && this.vertex.draw) {
            this.vertex.draw(this.strokeColor);
        }
    }

    drawOnGrid(grid) {
        const { x: cx, y: cy } = grid.userToScreen(this.vertex.x, this.vertex.y);
        const rScreen = (grid.xScale * this.radius + grid.yScale * this.radius) / 2;
        this._drawArc(cx, cy, rScreen);
        if (this.shouldShowVertex && this.vertex && this.vertex.drawOnGrid) {
            this.vertex.drawOnGrid(grid, this.strokeColor);
        }
    }

    _drawArc(cx, cy, r) {
        const totalAngle = this.startAngle + this.rotation;
        const p5Start = -radians(totalAngle + this.theta);
        const p5Stop  = -radians(totalAngle);

        if (this.fillColor && this.fillColor.col) {
            fill(this.fillColor.col);
        } else {
            noFill();
        }
        if (this.strokeColor && this.strokeColor.col) {
            stroke(this.strokeColor.col);
        } else {
            noStroke();
        }
        strokeWeight(this.thickness);
        arc(cx, cy, 2 * r, 2 * r, p5Start, p5Stop, PIE);
        noStroke();
        noFill();
        strokeWeight(1);
    }

    rotate(deltaAngle) {
        this.rotation += deltaAngle;
    }

    breatheRadius(sinusoid, t) {
        this.radius = Math.max(0.01, sinusoid.getValue(t));
        this._updateGeometry();
    }

    breatheTheta(sinusoid, t) {
        this.theta = sinusoid.getValue(t);
        this._updateGeometry();
    }

    setFillAlpha(alpha) {
        if (this.fillColor) {
            this.fillColor.a = Math.max(0, Math.min(100, alpha));
            this.fillColor.col = color(
                this.fillColor.h, this.fillColor.s,
                this.fillColor.b, this.fillColor.a
            );
        }
    }

    setStrokeAlpha(alpha) {
        if (this.strokeColor) {
            this.strokeColor.a = Math.max(0, Math.min(100, alpha));
            this.strokeColor.col = color(
                this.strokeColor.h, this.strokeColor.s,
                this.strokeColor.b, this.strokeColor.a
            );
        }
    }

    reset() {
        this.radius     = this.originalRadius;
        this.theta      = this.originalTheta;
        this.startAngle = this.originalStartAngle;
        this.rotation   = this.originalRotation;
        if (this.originalFillColor) {
            this.fillColor = SWColor.copy(this.originalFillColor);
        }
        this._updateGeometry();
    }

    resetFillColor() {
        if (this.originalFillColor) {
            this.fillColor = SWColor.copy(this.originalFillColor);
        }
    }

    setFillColor(swColor)   { this.fillColor   = swColor ? SWColor.copy(swColor) : undefined; }
    setStrokeColor(swColor) { this.strokeColor = swColor ? SWColor.copy(swColor) : undefined; }
    setStrokeWeight(w)      { this.thickness   = w; }
    setRadius(r)            { this.radius      = r; this._updateGeometry(); }
    setTheta(degrees)       { this.theta       = degrees; this._updateGeometry(); }
    setStartAngle(degrees)  { this.startAngle  = degrees; }
    setShowVertex(show = true) { this.shouldShowVertex = show; }

    static copy(other) {
        if (!(other instanceof SWSector)) {
            throw new Error('Argument to SWSector.copy must be an SWSector instance');
        }
        const s = new SWSector(
            SWPoint.copy(other.vertex),
            other.originalRadius,
            other.originalTheta,
            other.originalStartAngle,
            other.thickness,
            other.fillColor,
            other.strokeColor
        );
        s.radius           = other.radius;
        s.theta            = other.theta;
        s.startAngle       = other.startAngle;
        s.rotation         = other.rotation;
        s.shouldShowVertex = other.shouldShowVertex;
        s._updateGeometry();
        return s;
    }

    toString() {
        return `SWSector(vertex: ${this.vertex.toString()}, ` +
               `radius: ${this.radius.toFixed(2)}, theta: ${this.theta.toFixed(1) + String.fromCharCode(176)}, ` +
               `startAngle: ${this.startAngle + String.fromCharCode(176)}, ` +
               `rotation: ${this.rotation.toFixed(1) + String.fromCharCode(176)}, ` +
               `area: ${this.area.toFixed(2)}, arcLength: ${this.arcLength.toFixed(2)})`;
    }

}//end SWSector class