<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Gaussian Curvature Comparison</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }
    body {
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
      background: transparent;
      color: #1e293b;
      padding: 6px;
    }

    /* Math typography styling */
    .m-var {
      font-family: "Cambria Math", "Latin Modern Math", "Times New Roman", serif;
      font-style: italic;
    }
    .m-frac {
      display: inline-flex;
      flex-direction: column;
      vertical-align: middle;
      text-align: center;
      font-size: 0.88em;
      line-height: 1.05;
      margin: 0 2px;
    }
    .m-num {
      border-bottom: 1.2px solid currentColor;
      padding-bottom: 1px;
    }
    .m-den {
      padding-top: 1px;
    }
    .m-row {
      display: block;
      margin: 2px 0;
    }

    /* Toggle Header */
    .toggle-bar {
      display: flex;
      justify-content: center;
      gap: 6px;
      margin-bottom: 10px;
      flex-wrap: wrap;
    }
    .toggle-btn {
      background: #f8fafc;
      border: 1px solid #cbd5e1;
      border-radius: 18px;
      padding: 5px 12px;
      font-size: 12px;
      font-weight: 600;
      color: #475569;
      cursor: pointer;
      transition: background 0.2s, color 0.2s, border-color 0.2s, box-shadow 0.2s;
    }
    .toggle-btn:hover {
      background: #f1f5f9;
      border-color: #94a3b8;
    }
    .toggle-btn.active {
      background: #0284c7;
      color: #ffffff;
      border-color: #0284c7;
      box-shadow: 0 2px 6px rgba(2, 132, 199, 0.3);
    }

    /* 3-Column Grid */
    .grid {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 10px;
      width: 100%;
    }
    @media (max-width: 540px) {
      .grid {
        grid-template-columns: 1fr;
        gap: 12px;
      }
    }

    .col-card {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 10px 8px;
      display: flex;
      flex-direction: column;
      align-items: center;
      text-align: center;
      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.04);
    }
    .surface-title {
      font-size: 14px;
      font-weight: 700;
      color: #0f172a;
    }
    .badge {
      display: inline-block;
      font-size: 11.5px;
      font-weight: 700;
      padding: 2px 8px;
      border-radius: 10px;
      margin-top: 3px;
      margin-bottom: 6px;
    }
    .badge-zero {
      background: #ecfdf5;
      color: #059669;
      border: 1px solid #a7f3d0;
    }
    .badge-pos {
      background: #eff6ff;
      color: #2563eb;
      border: 1px solid #bfdbfe;
    }
    .badge-neg {
      background: #faf5ff;
      color: #7c3aed;
      border: 1px solid #ddd6fe;
    }

    /* SVG Canvas */
    .svg-wrap {
      width: 100%;
      max-width: 170px;
      height: 130px;
      margin: 2px 0 6px;
      position: relative;
    }
    .svg-wrap svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }

    /* Curves */
    .curve-k1 {
      stroke: #ea580c;
      stroke-width: 3.5;
      fill: none;
      stroke-linecap: round;
      transition: opacity 0.25s ease, stroke-width 0.25s ease;
    }
    .curve-k2 {
      stroke: #0284c7;
      stroke-width: 3.5;
      fill: none;
      stroke-linecap: round;
      transition: opacity 0.25s ease, stroke-width 0.25s ease;
    }
    .curve-dimmed {
      opacity: 0.15 !important;
      stroke-width: 2 !important;
    }
    .curve-highlighted {
      opacity: 1 !important;
      stroke-width: 4 !important;
    }
    .pt-p {
      fill: #0f172a;
      stroke: #ffffff;
      stroke-width: 2;
    }

    /* Formula Box */
    .math-box {
      width: 100%;
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 6px;
      padding: 6px 4px;
      font-size: 12px;
      line-height: 1.35;
      color: #334155;
      margin-top: auto;
    }
    .math-res {
      font-weight: 700;
      color: #0f172a;
    }

    /* Legend */
    .legend {
      display: flex;
      justify-content: center;
      gap: 16px;
      margin-top: 8px;
      font-size: 11.5px;
      font-weight: 600;
      color: #475569;
    }
    .legend-item {
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .legend-line {
      width: 16px;
      height: 3.5px;
      border-radius: 2px;
    }
  </style>
</head>
<body>

  
  <div class="toggle-bar">
    <button class="toggle-btn active" id="btn-both" onclick="setMode('both')">
      Both Slices (<span class="m-var">K</span> = <span class="m-var">κ</span><sub>1</sub> · <span class="m-var">κ</span><sub>2</sub>)
    </button>
    <button class="toggle-btn" id="btn-k1" onclick="setMode('k1')">
      Slice <span class="m-var">κ</span><sub>1</sub>
    </button>
    <button class="toggle-btn" id="btn-k2" onclick="setMode('k2')">
      Slice <span class="m-var">κ</span><sub>2</sub>
    </button>
  </div>

  <div class="grid">
    
    <div class="col-card">
      <div class="surface-title">Cylinder</div>
      <div class="badge badge-zero">Zero: <span class="m-var">K</span> = 0</div>
      
      <div class="svg-wrap">
        <svg viewBox="0 0 200 160">
          <defs>
            <linearGradient id="cylGrad" x1="0%" y1="0%" x2="0%" y2="100%">
              <stop offset="0%" stop-color="#cbd5e1" stop-opacity="0.4"/>
              <stop offset="45%" stop-color="#f8fafc" stop-opacity="0.9"/>
              <stop offset="90%" stop-color="#94a3b8" stop-opacity="0.6"/>
            </linearGradient>
          </defs>

          
          <path d="M 40,40 L 160,40 A 18,45 0 0,1 160,130 L 40,130 A 18,45 0 0,1 40,40 Z" fill="url(#cylGrad)" stroke="#94a3b8" stroke-width="1.5"/>
          
          
          <path d="M 40,40 A 18,45 0 0,1 40,130" fill="none" stroke="#cbd5e1" stroke-dasharray="3,3" stroke-width="1.2"/>
          <path d="M 40,40 A 18,45 0 0,0 40,130" fill="none" stroke="#94a3b8" stroke-width="1.5"/>

          
          <ellipse cx="160" cy="85" rx="18" ry="45" fill="#f1f5f9" fill-opacity="0.7" stroke="#94a3b8" stroke-width="1.5"/>

          
          <line x1="40" y1="40" x2="160" y2="40" stroke="#cbd5e1" stroke-width="1"/>
          <line x1="40" y1="130" x2="160" y2="130" stroke="#cbd5e1" stroke-width="1"/>

          
          <path id="cyl-k1" class="curve-k1" d="M 100,40 A 18,45 0 0,1 100,130"/>

          
          <line id="cyl-k2" class="curve-k2" x1="40" y1="85" x2="160" y2="85"/>

          
          <circle cx="118" cy="85" r="4.5" class="pt-p"/>
          <text x="124" y="78" font-size="11" font-weight="700" fill="#0f172a">P</text>
        </svg>
      </div>

      <div class="math-box">
        <div class="m-row">
          <span class="m-var">κ</span><sub>1</sub> = <span class="m-frac"><span class="m-num">1</span><span class="m-den"><span class="m-var">R</span></span></span>, &nbsp;<span class="m-var">κ</span><sub>2</sub> = 0
        </div>
        <div class="m-row math-res">
          <span class="m-var">K</span> = <span class="m-frac"><span class="m-num">1</span><span class="m-den"><span class="m-var">R</span></span></span> · 0 = 0
        </div>
      </div>
    </div>

    
    <div class="col-card">
      <div class="surface-title">Sphere</div>
      <div class="badge badge-pos">Positive: <span class="m-var">K</span> &gt; 0</div>
      
      <div class="svg-wrap">
        <svg viewBox="0 0 200 160">
          <defs>
            <radialGradient id="sphGrad" cx="35%" cy="35%" r="65%">
              <stop offset="0%" stop-color="#ffffff"/>
              <stop offset="55%" stop-color="#e2e8f0"/>
              <stop offset="100%" stop-color="#94a3b8"/>
            </radialGradient>
          </defs>

          
          <circle cx="100" cy="80" r="54" fill="url(#sphGrad)" stroke="#94a3b8" stroke-width="1.5"/>

          
          <path d="M 46,80 A 54,20 0 0,1 154,80" fill="none" stroke="#cbd5e1" stroke-dasharray="3,3" stroke-width="1"/>
          <path d="M 100,26 A 22,54 0 0,0 100,134" fill="none" stroke="#cbd5e1" stroke-dasharray="3,3" stroke-width="1"/>

          
          <path id="sph-k1" class="curve-k1" d="M 46,80 A 54,20 0 0,0 154,80"/>

          
          <path id="sph-k2" class="curve-k2" d="M 100,26 A 22,54 0 0,1 100,134"/>

          
          <circle cx="122" cy="80" r="4.5" class="pt-p"/>
          <text x="127" y="74" font-size="11" font-weight="700" fill="#0f172a">P</text>
        </svg>
      </div>

      <div class="math-box">
        <div class="m-row">
          <span class="m-var">κ</span><sub>1</sub> = <span class="m-frac"><span class="m-num">1</span><span class="m-den"><span class="m-var">R</span></span></span>, &nbsp;<span class="m-var">κ</span><sub>2</sub> = <span class="m-frac"><span class="m-num">1</span><span class="m-den"><span class="m-var">R</span></span></span>
        </div>
        <div class="m-row math-res">
          <span class="m-var">K</span> = <span class="m-frac"><span class="m-num">1</span><span class="m-den"><span class="m-var">R</span><sup>2</sup></span></span> &gt; 0
        </div>
      </div>
    </div>

    
    <div class="col-card">
      <div class="surface-title">Saddle</div>
      <div class="badge badge-neg">Negative: <span class="m-var">K</span> &lt; 0</div>
      
      <div class="svg-wrap">
        <svg viewBox="0 0 200 160">
          <defs>
            <linearGradient id="sadGrad" x1="0%" y1="0%" x2="100%" y2="100%">
              <stop offset="0%" stop-color="#f8fafc"/>
              <stop offset="50%" stop-color="#e2e8f0"/>
              <stop offset="100%" stop-color="#cbd5e1"/>
            </linearGradient>
          </defs>

          
          <path d="M 40,45 Q 100,95 160,45 Q 170,115 135,135 Q 100,95 65,135 Q 30,115 40,45 Z" fill="url(#sadGrad)" stroke="#94a3b8" stroke-width="1.5"/>

          
          <path d="M 52,70 Q 100,105 148,70" fill="none" stroke="#cbd5e1" stroke-width="1" stroke-dasharray="2,2"/>
          <path d="M 58,100 Q 100,115 142,100" fill="none" stroke="#cbd5e1" stroke-width="1" stroke-dasharray="2,2"/>

          
          <path id="sad-k1" class="curve-k1" d="M 46,55 Q 100,110 154,55"/>

          
          <path id="sad-k2" class="curve-k2" d="M 72,130 Q 100,75 128,130"/>

          
          <circle cx="100" cy="85" r="4.5" class="pt-p"/>
          <text x="105" y="80" font-size="11" font-weight="700" fill="#0f172a">P</text>
        </svg>
      </div>

      <div class="math-box">
        <div class="m-row">
          <span class="m-var">κ</span><sub>1</sub> &gt; 0, &nbsp;<span class="m-var">κ</span><sub>2</sub> &lt; 0
        </div>
        <div class="m-row math-res">
          <span class="m-var">K</span> = (+) · (−) &lt; 0
        </div>
      </div>
    </div>
  </div>

  
  <div class="legend">
    <div class="legend-item">
      <div class="legend-line" style="background:#ea580c;"></div>
      <span>Slice <span class="m-var">κ</span><sub>1</sub> (Principal 1)</span>
    </div>
    <div class="legend-item">
      <div class="legend-line" style="background:#0284c7;"></div>
      <span>Slice <span class="m-var">κ</span><sub>2</sub> (Principal 2)</span>
    </div>
  </div>

  <script>
    function setMode(mode) {
      const btnBoth = document.getElementById('btn-both');
      const btnK1 = document.getElementById('btn-k1');
      const btnK2 = document.getElementById('btn-k2');

      btnBoth.classList.toggle('active', mode === 'both');
      btnK1.classList.toggle('active', mode === 'k1');
      btnK2.classList.toggle('active', mode === 'k2');

      const k1Curves = [document.getElementById('cyl-k1'), document.getElementById('sph-k1'), document.getElementById('sad-k1')];
      const k2Curves = [document.getElementById('cyl-k2'), document.getElementById('sph-k2'), document.getElementById('sad-k2')];

      if (mode === 'both') {
        k1Curves.forEach(el => { el.setAttribute('class', 'curve-k1'); });
        k2Curves.forEach(el => { el.setAttribute('class', 'curve-k2'); });
      } else if (mode === 'k1') {
        k1Curves.forEach(el => { el.setAttribute('class', 'curve-k1 curve-highlighted'); });
        k2Curves.forEach(el => { el.setAttribute('class', 'curve-k2 curve-dimmed'); });
      } else if (mode === 'k2') {
        k1Curves.forEach(el => { el.setAttribute('class', 'curve-k1 curve-dimmed'); });
        k2Curves.forEach(el => { el.setAttribute('class', 'curve-k2 curve-highlighted'); });
      }
    }
  </script>
</body>
</html>

Geometry of the Sphere, Great Circles, and Gaussian Curvature

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Theorema Egregium: Bending vs. Flattening</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    html, body {
      width: 100%;
      height: 100%;
      background: transparent;
      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
      color: #0f172a;
      overflow: hidden;
    }
    body {
      display: flex;
      flex-direction: column;
      padding: 6px 10px;
      gap: 4px;
    }
    .section {
      flex: 1;
      display: flex;
      flex-direction: column;
      min-height: 0;
      position: relative;
    }
    .divider {
      height: 1px;
      background: #e2e8f0;
      margin: 1px 0;
      flex-shrink: 0;
    }
    .header-row {
      display: flex;
      justify-content: space-between;
      align-items: center;
      flex-wrap: wrap;
      gap: 3px 6px;
      margin-bottom: 2px;
      flex-shrink: 0;
    }
    .title-group {
      display: flex;
      align-items: center;
      gap: 6px;
    }
    .section-title {
      font-size: 13px;
      font-weight: 700;
      color: #0f172a;
      letter-spacing: -0.01em;
    }
    .formula-display {
      font-family: ui-monospace, 'SF Mono', Menlo, Consolas, monospace;
      font-size: 11.5px;
      font-weight: 600;
      color: #1e293b;
      background: rgba(241, 245, 249, 0.9);
      padding: 2px 6px;
      border-radius: 4px;
      border: 1px solid #cbd5e1;
      white-space: normal;
      word-break: break-word;
    }
    .formula-display b {
      color: #0f172a;
    }
    .canvas-wrapper {
      flex: 1;
      position: relative;
      width: 100%;
      min-height: 110px;
    }
    canvas {
      position: absolute;
      left: 0;
      top: 0;
      width: 100%;
      height: 100%;
      display: block;
    }
    .controls-row {
      display: flex;
      align-items: center;
      gap: 8px;
      padding: 2px 0 1px 0;
      flex-shrink: 0;
    }
    .slider-label {
      font-size: 12px;
      font-weight: 700;
      color: #334155;
      white-space: nowrap;
    }
    .range-input {
      flex: 1;
      height: 6px;
      -webkit-appearance: none;
      appearance: none;
      background: #e2e8f0;
      border-radius: 3px;
      outline: none;
      cursor: pointer;
    }
    .range-input::-webkit-slider-thumb {
      -webkit-appearance: none;
      appearance: none;
      width: 16px;
      height: 16px;
      border-radius: 50%;
      background: #0284c7;
      cursor: pointer;
      box-shadow: 0 1px 3px rgba(0,0,0,0.3);
    }
    .range-input::-moz-range-thumb {
      width: 16px;
      height: 16px;
      border-radius: 50%;
      background: #0284c7;
      border: none;
      cursor: pointer;
      box-shadow: 0 1px 3px rgba(0,0,0,0.3);
    }
    #bottomSlider::-webkit-slider-thumb {
      background: #ea580c;
    }
    #bottomSlider::-moz-range-thumb {
      background: #ea580c;
    }
    .badge {
      display: inline-flex;
      align-items: center;
      padding: 2px 7px;
      border-radius: 12px;
      font-size: 11px;
      font-weight: 700;
      font-family: ui-monospace, monospace;
      white-space: nowrap;
      flex-shrink: 0;
    }
    .badge-blue {
      background: #e0f2fe;
      color: #0369a1;
      border: 1px solid #bae6fd;
    }
    .badge-neutral {
      background: #f1f5f9;
      color: #475569;
      border: 1px solid #cbd5e1;
    }
    .badge-danger {
      background: #fee2e2;
      color: #991b1b;
      border: 1px solid #fca5a5;
    }
    
    @media (max-width: 480px) {
      .controls-row {
        display: grid;
        grid-template-columns: auto 1fr;
        grid-template-areas: 
          "label badge"
          "slider slider";
        row-gap: 3px;
        column-gap: 6px;
        align-items: center;
      }
      .slider-label { 
        grid-area: label; 
        font-size: 11.5px; 
      }
      .badge { 
        grid-area: badge; 
        justify-self: end; 
        font-size: 10.5px;
        padding: 1px 6px;
      }
      .range-input { 
        grid-area: slider; 
        width: 100%; 
        margin: 1px 0; 
      }
      .formula-display { 
        font-size: 10.5px; 
        padding: 1px 5px; 
      }
      .section-title { 
        font-size: 12px; 
      }
    }
  </style>
</head>
<body>

  
  <div class="section">
    <div class="header-row">
      <div class="title-group">
        <span class="section-title">Plane → Cylinder (Isometric Bend)</span>
      </div>
      <div id="topFormula" class="formula-display">
        κ₁ · κ₂ = 0.00 · 0.00 = <b>K: 0.00</b>
      </div>
    </div>

    <div class="canvas-wrapper">
      <canvas id="topCanvas"></canvas>
    </div>

    <div class="controls-row">
      <span class="slider-label">Bend Surface:</span>
      <input type="range" id="topSlider" class="range-input" min="0" max="1" step="0.005" value="0">
      <span class="badge badge-blue">Strain: 0.0% (No stretch)</span>
    </div>
  </div>

  <div class="divider"></div>

  
  <div class="section">
    <div class="header-row">
      <div class="title-group">
        <span class="section-title">Hemisphere → Flattening (K = +0.25)</span>
      </div>
      <div id="bottomFormula" class="formula-display">
        K = 1/R² = <b>+0.25</b> (Cannot flatten without distortion)
      </div>
    </div>

    <div class="canvas-wrapper">
      <canvas id="bottomCanvas"></canvas>
    </div>

    <div class="controls-row">
      <span class="slider-label">Press Flat:</span>
      <input type="range" id="bottomSlider" class="range-input" min="0" max="1" step="0.005" value="0">
      <span id="bottomBadge" class="badge badge-neutral">Tension: 0%</span>
    </div>
  </div>

  <script>
    const topCanvas = document.getElementById('topCanvas');
    const bottomCanvas = document.getElementById('bottomCanvas');
    const topSlider = document.getElementById('topSlider');
    const bottomSlider = document.getElementById('bottomSlider');
    const topFormula = document.getElementById('topFormula');
    const bottomFormula = document.getElementById('bottomFormula');
    const bottomBadge = document.getElementById('bottomBadge');

    function resizeCanvas(canvas) {
      const rect = canvas.parentElement.getBoundingClientRect();
      const dpr = window.devicePixelRatio || 1;
      const w = Math.floor(rect.width);
      const h = Math.floor(rect.height);
      if (w === 0 || h === 0) return null;

      if (canvas.width !== Math.floor(w * dpr) || canvas.height !== Math.floor(h * dpr)) {
        canvas.width = Math.floor(w * dpr);
        canvas.height = Math.floor(h * dpr);
      }
      const ctx = canvas.getContext('2d');
      ctx.resetTransform();
      ctx.scale(dpr, dpr);
      return { ctx, width: w, height: h };
    }

    function projectIso(x, y, z, cx, cy, scale) {
      const angleX = Math.PI / 6;
      const isoX = (x - z * 0.85) * Math.cos(angleX) * scale + cx;
      const isoY = (x + z * 0.85) * Math.sin(angleX) * scale * 0.5 - y * scale + cy;
      return { x: isoX, y: isoY, depth: -(x * 0.2 + z * 0.9) };
    }

    function drawTop() {
      const info = resizeCanvas(topCanvas);
      if (!info) return;
      const { ctx, width, height } = info;
      ctx.clearRect(0, 0, width, height);

      const bend = parseFloat(topSlider.value);
      const k1 = bend * 1.5;
      topFormula.innerHTML = `κ₁ · κ₂ = ${k1.toFixed(2)} · 0.00 = <b>K: 0.00</b>`;

      const cx = width * 0.5;
      const cy = height * 0.58;
      const scale = Math.min(width * 0.038, height * 0.055, 16);

      const uSteps = 24;
      const vSteps = 12;
      const W = 20;
      const L = 16;

      const grid = [];
      for (let i = 0; i <= uSteps; i++) {
        grid[i] = [];
        const u = (i / uSteps - 0.5) * W;
        for (let j = 0; j <= vSteps; j++) {
          const v = (j / vSteps - 0.5) * L;
          let x, y, z;
          if (bend < 0.001) {
            x = u;
            y = 0;
            z = v;
          } else {
            const maxAngle = Math.PI * 0.85 * bend;
            const angle = (u / (W * 0.5)) * maxAngle;
            const R = (W * 0.5) / maxAngle;
            x = R * Math.sin(angle);
            y = R * (1 - Math.cos(angle)) * 0.9;
            z = v;
          }
          grid[i][j] = projectIso(x, y, z, cx, cy, scale);
        }
      }

      // Draw quads
      for (let i = 0; i < uSteps; i++) {
        for (let j = 0; j < vSteps; j++) {
          const p1 = grid[i][j];
          const p2 = grid[i + 1][j];
          const p3 = grid[i + 1][j + 1];
          const p4 = grid[i][j + 1];

          ctx.beginPath();
          ctx.moveTo(p1.x, p1.y);
          ctx.lineTo(p2.x, p2.y);
          ctx.lineTo(p3.x, p3.y);
          ctx.lineTo(p4.x, p4.y);
          ctx.closePath();

          const normU = Math.abs(i / uSteps - 0.5) * 2;
          const brightness = 238 + Math.round(normU * 15);
          ctx.fillStyle = `rgb(${brightness - 30}, ${brightness - 10}, 255)`;
          ctx.fill();

          ctx.strokeStyle = 'rgba(2, 132, 199, 0.35)';
          ctx.lineWidth = 0.8;
          ctx.stroke();
        }
      }

      // Principal curvature lines & indicators
      const midI = Math.floor(uSteps / 2);
      const midJ = Math.floor(vSteps / 2);

      // κ2 = 0 axis (Straight generator along length)
      const pTop = grid[midI][0];
      const pBot = grid[midI][vSteps];
      ctx.beginPath();
      ctx.moveTo(pTop.x, pTop.y);
      ctx.lineTo(pBot.x, pBot.y);
      ctx.strokeStyle = '#0369a1';
      ctx.lineWidth = 2.5;
      ctx.stroke();

      // Axis label
      ctx.fillStyle = '#0f172a';
      ctx.font = 'bold 10.5px -apple-system, BlinkMacSystemFont, sans-serif';
      ctx.fillText('κ₂ = 0 (axis stays straight)', Math.max(8, pBot.x - 75), Math.min(height - 4, pBot.y + 14));

      // κ1 curve indicator if bent
      if (bend > 0.08) {
        ctx.beginPath();
        for (let i = 0; i <= uSteps; i++) {
          const pt = grid[i][midJ];
          if (i === 0) ctx.moveTo(pt.x, pt.y);
          else ctx.lineTo(pt.x, pt.y);
        }
        ctx.strokeStyle = '#2563eb';
        ctx.lineWidth = 2;
        ctx.setLineDash([3, 3]);
        ctx.stroke();
        ctx.setLineDash([]);
        
        const ptRight = grid[uSteps][midJ];
        ctx.fillStyle = '#1d4ed8';
        ctx.fillText(`κ₁ = ${k1.toFixed(2)}`, Math.min(width - 48, ptRight.x + 4), ptRight.y + 4);
      }
    }

    function drawBottom() {
      const info = resizeCanvas(bottomCanvas);
      if (!info) return;
      const { ctx, width, height } = info;
      ctx.clearRect(0, 0, width, height);

      const flat = parseFloat(bottomSlider.value);
      const strainPercent = Math.round(flat * 57);

      if (flat > 0.05) {
        bottomBadge.className = 'badge badge-danger';
        bottomBadge.textContent = `Tension / Tearing: +${strainPercent}%`;
        bottomFormula.innerHTML = `K = +0.25 → Attempting K=0 causes <b>Strain: +${strainPercent}%</b>`;
      } else {
        bottomBadge.className = 'badge badge-neutral';
        bottomBadge.textContent = `Tension: 0%`;
        bottomFormula.innerHTML = `K = 1/R² = <b>+0.25</b> (Cannot flatten without distortion)`;
      }

      const cx = width * 0.5;
      const cy = height * 0.62;
      const scale = Math.min(width * 0.038, height * 0.055, 16);

      const latSteps = 10;
      const lonSteps = 22;
      const R = 11.5;

      const grid = [];
      for (let i = 0; i <= latSteps; i++) {
        grid[i] = [];
        const phi = (i / latSteps) * (Math.PI * 0.5);
        const curR = R * Math.cos(phi) * (1 + flat * 0.48 * Math.cos(phi));
        const curY = (R * Math.sin(phi)) * (1 - flat * 0.92);

        for (let j = 0; j <= lonSteps; j++) {
          const theta = (j / lonSteps) * Math.PI * 2;
          const x = curR * Math.cos(theta);
          const z = curR * Math.sin(theta);
          grid[i][j] = projectIso(x, curY, z, cx, cy, scale);
        }
      }

      // Draw quads sorted from back to front
      const quads = [];
      for (let i = 0; i < latSteps; i++) {
        for (let j = 0; j < lonSteps; j++) {
          const p1 = grid[i][j];
          const p2 = grid[i + 1][j];
          const p3 = grid[i + 1][j + 1];
          const p4 = grid[i][j + 1];
          const avgDepth = (p1.depth + p2.depth + p3.depth + p4.depth) / 4;
          quads.push({ p1, p2, p3, p4, avgDepth, i, j });
        }
      }
      quads.sort((a, b) => a.avgDepth - b.avgDepth);

      for (const q of quads) {
        ctx.beginPath();
        ctx.moveTo(q.p1.x, q.p1.y);
        ctx.lineTo(q.p2.x, q.p2.y);
        ctx.lineTo(q.p3.x, q.p3.y);
        ctx.lineTo(q.p4.x, q.p4.y);
        ctx.closePath();

        const rCol = Math.min(255, Math.floor(245 + flat * 10));
        const gCol = Math.max(70, Math.floor(140 - flat * 70 + (q.i / latSteps) * 30));
        const bCol = Math.max(20, Math.floor(35 - flat * 25));
        ctx.fillStyle = `rgb(${rCol}, ${gCol}, ${bCol})`;
        ctx.fill();

        ctx.strokeStyle = `rgba(180, 83, 9, ${0.4 + flat * 0.3})`;
        ctx.lineWidth = 0.8;
        ctx.stroke();
      }

      // Rim tension arrows / tear vectors when flattening
      if (flat > 0.08) {
        const arrowCount = 10;
        ctx.lineWidth = 1.8;
        for (let k = 0; k < arrowCount; k++) {
          const idx = Math.floor((k / arrowCount) * lonSteps);
          const p = grid[0][idx];
          const angle = (k / arrowCount) * Math.PI * 2;
          const nx = Math.cos(angle);
          const nz = Math.sin(angle);
          const stretchMag = 4.2 * flat;
          const target = projectIso(
            (R * (1 + flat * 0.48) + stretchMag) * nx,
            0,
            (R * (1 + flat * 0.48) + stretchMag) * nz,
            cx, cy, scale
          );

          ctx.strokeStyle = '#dc2626';
          ctx.fillStyle = '#dc2626';
          ctx.beginPath();
          ctx.moveTo(p.x, p.y);
          ctx.lineTo(target.x, target.y);
          ctx.stroke();

          // Arrowhead
          const headLen = 4;
          const dx = target.x - p.x;
          const dy = target.y - p.y;
          const mag = Math.hypot(dx, dy) || 1;
          const ux = dx / mag;
          const uy = dy / mag;
          ctx.beginPath();
          ctx.moveTo(target.x, target.y);
          ctx.lineTo(target.x - ux * headLen + uy * 2.5, target.y - uy * headLen - ux * 2.5);
          ctx.lineTo(target.x - ux * headLen - uy * 2.5, target.y - uy * headLen + ux * 2.5);
          ctx.closePath();
          ctx.fill();
        }

        // Strain warning label
        ctx.fillStyle = '#991b1b';
        ctx.font = 'bold 10.5px -apple-system, BlinkMacSystemFont, sans-serif';
        ctx.fillText('Circumferential tension (Rims tear to flatten)', 8, height - 6);
      }
    }

    function render() {
      drawTop();
      drawBottom();
    }

    topSlider.addEventListener('input', drawTop);
    bottomSlider.addEventListener('input', drawBottom);

    const resizeObserver = new ResizeObserver(() => {
      requestAnimationFrame(render);
    });
    resizeObserver.observe(document.body);

    window.addEventListener('resize', render);
    window.addEventListener('DOMContentLoaded', render);
    setTimeout(render, 50);
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Octant Spherical Triangle</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      color: #1e293b;
      background: #ffffff;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      padding: 10px;
      min-height: 100vh;
    }
    .layout {
      width: 100%;
      max-width: 620px;
      display: flex;
      flex-direction: column;
      gap: 10px;
    }
    .main-stage {
      display: flex;
      flex-wrap: wrap;
      align-items: center;
      justify-content: center;
      gap: 14px;
      width: 100%;
    }
    .globe-box {
      flex: 1 1 250px;
      max-width: 295px;
      display: flex;
      justify-content: center;
      align-items: center;
      position: relative;
    }
    svg {
      width: 100%;
      height: auto;
      display: block;
    }
    .data-panel {
      flex: 1 1 270px;
      display: flex;
      flex-direction: column;
      gap: 8px;
    }
    .calc-card {
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 8px 12px;
      display: flex;
      flex-direction: column;
      gap: 3px;
    }
    .calc-card.highlight {
      background: #f0fdf4;
      border-color: #86efac;
    }
    .calc-header {
      font-size: 11px;
      font-weight: 700;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      color: #64748b;
    }
    .calc-card.highlight .calc-header {
      color: #16a34a;
    }
    .calc-body {
      font-size: 13.5px;
      font-weight: 500;
      color: #0f172a;
      display: flex;
      align-items: center;
      flex-wrap: wrap;
      gap: 3px;
      min-height: 26px;
      line-height: 1.2;
    }
    .math-var {
      font-family: "Cambria Math", "Times New Roman", Georgia, serif;
      font-style: italic;
    }
    .frac {
      display: inline-flex;
      flex-direction: column;
      vertical-align: middle;
      text-align: center;
      padding: 0 2px;
      font-size: 0.92em;
      line-height: 1;
    }
    .frac .num {
      border-bottom: 1.5px solid currentColor;
      padding-bottom: 1px;
    }
    .frac .den {
      padding-top: 1px;
    }
    .paren {
      font-size: 1.2em;
      font-weight: 300;
      vertical-align: -1px;
      line-height: 1;
    }
  </style>
</head>
<body>

<div class="layout">
  <div class="main-stage">
    
    <div class="globe-box">
      <svg viewBox="0 0 295 270" aria-label="Spherical triangle octant diagram">
        <defs>
          
          <radialGradient id="sphereGrad" cx="35%" cy="30%" r="70%">
            <stop offset="0%" stop-color="#ffffff" />
            <stop offset="60%" stop-color="#f1f5f9" />
            <stop offset="100%" stop-color="#cbd5e1" />
          </radialGradient>
          
          <radialGradient id="octantGrad" cx="35%" cy="40%" r="65%">
            <stop offset="0%" stop-color="#38bdf8" stop-opacity="0.85" />
            <stop offset="100%" stop-color="#0284c7" stop-opacity="0.9" />
          </radialGradient>

          <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
            <feDropShadow dx="0" dy="2" stdDeviation="3" flood-color="#0284c7" flood-opacity="0.25"/>
          </filter>
        </defs>

        
        <circle cx="140" cy="140" r="90" fill="url(#sphereGrad)" stroke="#94a3b8" stroke-width="1.5" />

        
        <ellipse cx="140" cy="140" rx="90" ry="28" fill="none" stroke="#cbd5e1" stroke-width="1" stroke-dasharray="3,3" />
        <ellipse cx="140" cy="140" rx="28" ry="90" fill="none" stroke="#cbd5e1" stroke-width="1" stroke-dasharray="3,3" />

        
        <path d="M 140 50 
                 L 140 168 
                 A 90 28 0 0 0 230 140 
                 A 90 90 0 0 0 140 50 Z" 
              fill="url(#octantGrad)" 
              filter="url(#glow)" />

        
        <path d="M 50 140 A 90 28 0 0 0 230 140" fill="none" stroke="#64748b" stroke-width="1.5" stroke-dasharray="4 2" />
        
        
        <line x1="140" y1="50" x2="140" y2="168" stroke="#0369a1" stroke-width="2.5" />
        
        
        <path d="M 140 50 A 90 90 0 0 1 230 140" fill="none" stroke="#0369a1" stroke-width="2.5" />
        
        
        <path d="M 140 168 A 90 28 0 0 0 230 140" fill="none" stroke="#0369a1" stroke-width="2.5" />

        
        <path d="M 140 63 L 149 61 L 149 50" fill="none" stroke="#ffffff" stroke-width="2" />
        
        
        <path d="M 140 156 L 148 153 L 148 166" fill="none" stroke="#ffffff" stroke-width="2" />

        
        <path d="M 219 140 L 217 131 L 227 129" fill="none" stroke="#ffffff" stroke-width="2" />

        
        <circle cx="140" cy="50" r="4" fill="#0f172a" stroke="#ffffff" stroke-width="1.8" />
        <circle cx="140" cy="168" r="4" fill="#0f172a" stroke="#ffffff" stroke-width="1.8" />
        <circle cx="230" cy="140" r="4" fill="#0f172a" stroke="#ffffff" stroke-width="1.8" />

        
        <line x1="140" y1="50" x2="94" y2="28" stroke="#0284c7" stroke-width="1.2" stroke-dasharray="2 2" />
        <rect x="26" y="16" width="68" height="22" rx="4" fill="#0f172a" />
        <text x="60" y="31" font-size="10.5" font-weight="700" fill="#ffffff" text-anchor="middle">90° (Pole)</text>

        
        <line x1="140" y1="168" x2="94" y2="202" stroke="#0284c7" stroke-width="1.2" stroke-dasharray="2 2" />
        <rect x="20" y="191" width="74" height="22" rx="4" fill="#0f172a" />
        <text x="57" y="206" font-size="10.5" font-weight="700" fill="#ffffff" text-anchor="middle">90° (Eq 0°)</text>

        
        <line x1="230" y1="140" x2="248" y2="98" stroke="#0284c7" stroke-width="1.2" stroke-dasharray="2 2" />
        <rect x="214" y="78" width="76" height="22" rx="4" fill="#0f172a" />
        <text x="252" y="93" font-size="10.5" font-weight="700" fill="#ffffff" text-anchor="middle">90° (Eq 90°)</text>

        
        <rect x="156" y="110" width="56" height="20" rx="4" fill="rgba(255,255,255,0.92)" stroke="#e2e8f0" stroke-width="1" />
        <text x="184" y="124" font-size="10.5" font-weight="800" fill="#0369a1" text-anchor="middle">⅛ Sphere</text>
      </svg>
    </div>

    
    <div class="data-panel">
      
      <div class="calc-card">
        <div class="calc-header">Angle Sum</div>
        <div class="calc-body">
          90° + 90° + 90° = 270°
        </div>
      </div>

      
      <div class="calc-card">
        <div class="calc-header">Angular Excess (E)</div>
        <div class="calc-body">
          <span class="math-var">E</span>&nbsp;=&nbsp;270° − 180° = 90° =&nbsp;
          <span class="frac"><span class="num">π</span><span class="den">2</span></span>&nbsp;rad
        </div>
      </div>

      
      <div class="calc-card">
        <div class="calc-header">Octant Area</div>
        <div class="calc-body">
          Area =&nbsp;
          <span class="frac"><span class="num">1</span><span class="den">8</span></span>
          <span class="paren">(</span>4π<span class="math-var">R</span><sup>2</sup><span class="paren">)</span>
          &nbsp;=&nbsp;
          <span class="frac"><span class="num">π<span class="math-var">R</span><sup>2</sup></span><span class="den">2</span></span>
        </div>
      </div>

      
      <div class="calc-card highlight">
        <div class="calc-header">Check: E = K × Area</div>
        <div class="calc-body">
          <span class="math-var">E</span>&nbsp;=&nbsp;<span class="math-var">K</span> · Area =&nbsp;
          <span class="paren">(</span><span class="frac"><span class="num">1</span><span class="den"><span class="math-var">R</span><sup>2</sup></span></span><span class="paren">)</span>
          <span class="paren">(</span><span class="frac"><span class="num">π<span class="math-var">R</span><sup>2</sup></span><span class="den">2</span></span><span class="paren">)</span>
          &nbsp;=&nbsp;
          <span class="frac"><span class="num">π</span><span class="den">2</span></span>
        </div>
      </div>
    </div>
  </div>
</div>

</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Gaussian Curvature & Flattening</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      width: 100%;
      min-height: 100%;
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e2945;
      background: #ffffff;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 12px 10px;
      user-select: none;
    }

    .panels {
      display: flex;
      width: 100%;
      max-width: 640px;
      gap: 12px;
      justify-content: center;
    }

    .panel-box {
      flex: 1;
      display: flex;
      flex-direction: column;
      align-items: center;
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 10px 8px;
      min-width: 0;
    }

    .canvas-container {
      width: 100%;
      position: relative;
      aspect-ratio: 1.1;
      max-height: 220px;
    }

    canvas {
      width: 100%;
      height: 100%;
      display: block;
    }

    .panel-label {
      text-align: center;
      margin-top: 6px;
      font-size: 13px;
      font-weight: 700;
      line-height: 1.3;
      color: #1e2945;
    }

    .sub-label {
      display: inline-block;
      font-size: 11px;
      font-weight: 600;
      padding: 2px 8px;
      border-radius: 12px;
      margin-top: 4px;
    }

    .sphere-sub {
      background: #fee2e2;
      color: #b91c1c;
    }

    .cyl-sub {
      background: #e0f2fe;
      color: #0369a1;
    }

    .controls {
      display: flex;
      gap: 8px;
      width: 100%;
      max-width: 480px;
      margin-top: 10px;
      justify-content: center;
    }

    .btn {
      flex: 1;
      padding: 8px 12px;
      font-size: 13px;
      font-weight: 600;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      background: #ffffff;
      color: #1e2945;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.05);
      transition: background 0.2s, border-color 0.2s, box-shadow 0.2s;
    }

    .btn.active {
      background: #22b7ff;
      color: #ffffff;
      border-color: #22b7ff;
      box-shadow: 0 2px 6px rgba(34,183,255,0.35);
    }
  </style>
</head>
<body>

  <div class="panels">
    
    <div class="panel-box">
      <div class="canvas-container">
        <canvas id="sphereCanvas"></canvas>
      </div>
      <div class="panel-label">
        Positive Curvature
        <br>
        <span class="sub-label sphere-sub">Tears &amp; Distorts</span>
      </div>
    </div>

    
    <div class="panel-box">
      <div class="canvas-container">
        <canvas id="cylCanvas"></canvas>
      </div>
      <div class="panel-label">
        Zero Curvature
        <br>
        <span class="sub-label cyl-sub">Flattens Perfectly</span>
      </div>
    </div>
  </div>

  <div class="controls">
    <button id="btnState1" class="btn active">Original Shape</button>
    <button id="btnState2" class="btn">Flattened Surface</button>
  </div>

  <script>
    const sphereCanvas = document.getElementById('sphereCanvas');
    const cylCanvas = document.getElementById('cylCanvas');
    const ctxSphere = sphereCanvas.getContext('2d');
    const ctxCyl = cylCanvas.getContext('2d');

    const btn1 = document.getElementById('btnState1');
    const btn2 = document.getElementById('btnState2');

    let currentT = 0; // 0 = 3D shape, 1 = flattened
    let targetT = 0;
    let animReq = null;

    function resizeCanvases() {
      const dpr = window.devicePixelRatio || 1;
      [sphereCanvas, cylCanvas].forEach(c => {
        const rect = c.getBoundingClientRect();
        c.width = rect.width * dpr;
        c.height = rect.height * dpr;
      });
      render();
    }

    window.addEventListener('resize', resizeCanvases);

    function drawTabletop(ctx, w, h) {
      const cy = h * 0.72;
      const rx = w * 0.44;
      const ry = h * 0.18;

      ctx.save();
      const grad = ctx.createLinearGradient(0, cy - ry, 0, cy + ry);
      grad.addColorStop(0, '#f1f5f9');
      grad.addColorStop(1, '#cbd5e1');

      ctx.beginPath();
      ctx.ellipse(w * 0.5, cy, rx, ry, 0, 0, Math.PI * 2);
      ctx.fillStyle = grad;
      ctx.fill();
      ctx.strokeStyle = '#94a3b8';
      ctx.lineWidth = 1.5;
      ctx.stroke();

      // subtle grid lines on tabletop
      ctx.strokeStyle = 'rgba(148, 163, 184, 0.4)';
      ctx.lineWidth = 1;
      ctx.beginPath();
      ctx.moveTo(w * 0.2, cy);
      ctx.lineTo(w * 0.8, cy);
      ctx.moveTo(w * 0.5, cy - ry * 0.75);
      ctx.lineTo(w * 0.5, cy + ry * 0.75);
      ctx.stroke();
      ctx.restore();
    }

    function renderSphere(t) {
      const w = sphereCanvas.width;
      const h = sphereCanvas.height;
      ctxSphere.clearRect(0, 0, w, h);
      drawTabletop(ctxSphere, w, h);

      const cx = w * 0.5;
      const tableY = h * 0.72;
      
      // Interpolate dome height and radius
      const domeHeight = (h * 0.38) * (1 - t * 0.82);
      const baseRx = (w * 0.24) * (1 + t * 0.52);
      const baseRy = (h * 0.11) * (1 + t * 0.48);
      const domeTopY = tableY - domeHeight;

      ctxSphere.save();

      // Shadow underneath
      ctxSphere.beginPath();
      ctxSphere.ellipse(cx, tableY, baseRx * 0.95, baseRy * 0.9, 0, 0, Math.PI * 2);
      ctxSphere.fillStyle = `rgba(0, 0, 0, ${0.1 + t * 0.12})`;
      ctxSphere.fill();

      // Draw Orange Peel Dome
      ctxSphere.beginPath();
      ctxSphere.moveTo(cx - baseRx, tableY);
      // Top curve
      ctxSphere.bezierCurveTo(
        cx - baseRx, domeTopY,
        cx + baseRx, domeTopY,
        cx + baseRx, tableY
      );
      // Bottom rim curve (front)
      ctxSphere.bezierCurveTo(
        cx + baseRx * 0.55, tableY + baseRy,
        cx - baseRx * 0.55, tableY + baseRy,
        cx - baseRx, tableY
      );
      ctxSphere.closePath();

      const peelGrad = ctxSphere.createRadialGradient(
        cx - baseRx * 0.2, domeTopY + domeHeight * 0.3, baseRx * 0.1,
        cx, tableY, baseRx * 1.1
      );
      peelGrad.addColorStop(0, '#ffa433');
      peelGrad.addColorStop(0.5, '#ff7a00');
      peelGrad.addColorStop(1, '#d95a00');

      ctxSphere.fillStyle = peelGrad;
      ctxSphere.fill();
      ctxSphere.strokeStyle = '#b84600';
      ctxSphere.lineWidth = 1.5;
      ctxSphere.stroke();

      // Pores / texture dots
      ctxSphere.fillStyle = 'rgba(255, 255, 255, 0.25)';
      const dots = [
        [-0.3, 0.4], [0.1, 0.3], [-0.1, 0.6], [0.35, 0.5], 
        [0.0, 0.15], [-0.4, 0.7], [0.25, 0.75]
      ];
      dots.forEach(([dx, dy]) => {
        const px = cx + dx * baseRx;
        const py = domeTopY + dy * domeHeight + (tableY - domeTopY - domeHeight);
        ctxSphere.beginPath();
        ctxSphere.arc(px, py, w * 0.007, 0, Math.PI * 2);
        ctxSphere.fill();
      });

      // Tear Cracks & Central Buckling Wrinkles when flattened (t > 0.15)
      if (t > 0.05) {
        const crackAlpha = Math.min(1, (t - 0.05) / 0.7);
        ctxSphere.strokeStyle = `rgba(185, 28, 28, ${crackAlpha})`;
        ctxSphere.lineWidth = 2.5 * (w / 300);
        ctxSphere.lineCap = 'round';
        ctxSphere.lineJoin = 'round';

        // 4 radial tears on rim opening up as it stretches
        const tearOffsets = [
          [-baseRx * 0.95, 0, -baseRx * 0.55, -baseRy * 0.15],
          [baseRx * 0.95, 0, baseRx * 0.55, -baseRy * 0.15],
          [-baseRx * 0.35, baseRy * 0.9, -baseRx * 0.18, baseRy * 0.2],
          [baseRx * 0.35, baseRy * 0.9, baseRx * 0.18, baseRy * 0.2]
        ];

        tearOffsets.forEach(([x1, y1, x2, y2]) => {
          ctxSphere.beginPath();
          ctxSphere.moveTo(cx + x1, tableY + y1);
          // Zigzag tear path
          const mx = cx + (x1 + x2) * 0.5 + (Math.random() > 0.5 ? 2 : -2);
          const my = tableY + (y1 + y2) * 0.5;
          ctxSphere.lineTo(mx, my);
          ctxSphere.lineTo(cx + x2, tableY + y2);
          ctxSphere.stroke();
        });

        // Center buckling wrinkles
        ctxSphere.strokeStyle = `rgba(120, 30, 0, ${crackAlpha * 0.85})`;
        ctxSphere.lineWidth = 1.8 * (w / 300);
        ctxSphere.beginPath();
        ctxSphere.arc(cx - baseRx * 0.12, tableY - domeHeight * 0.2, baseRx * 0.18, 0.2, Math.PI * 0.9);
        ctxSphere.stroke();

        ctxSphere.beginPath();
        ctxSphere.arc(cx + baseRx * 0.14, tableY - domeHeight * 0.1, baseRx * 0.15, Math.PI * 1.1, Math.PI * 1.9);
        ctxSphere.stroke();
      }

      ctxSphere.restore();
    }

    function renderCylinder(t) {
      const w = cylCanvas.width;
      const h = cylCanvas.height;
      ctxCyl.clearRect(0, 0, w, h);
      drawTabletop(ctxCyl, w, h);

      const cx = w * 0.5;
      const tableY = h * 0.72;

      ctxCyl.save();

      // When t = 0: Rolled Cylinder standing/resting on tabletop
      // When t = 1: Completely flat smooth rectangular sheet
      
      const flatW = w * 0.68;
      const flatH = h * 0.22;
      const cylRadius = (w * 0.16) * (1 - t * 0.9);
      const cylHeight = (h * 0.36) * (1 - t) + flatH * t;
      const flatHalfW = (w * 0.16 + (flatW * 0.5 - w * 0.16) * t);

      // Shadow
      ctxCyl.beginPath();
      ctxCyl.ellipse(cx, tableY, flatHalfW, h * 0.09 * (1 + t * 0.3), 0, 0, Math.PI * 2);
      ctxCyl.fillStyle = `rgba(0, 0, 0, ${0.12 + t * 0.08})`;
      ctxCyl.fill();

      if (t < 0.95) {
        // Drawing transitioning cylinder roll
        const curlH = (h * 0.34) * (1 - t);
        const topY = tableY - curlH;
        const curRx = Math.max(flatHalfW, w * 0.16);

        // Cylinder Body Fill
        ctxCyl.beginPath();
        ctxCyl.ellipse(cx, topY, curRx, cylRadius * 0.4, 0, Math.PI, 0); // top back
        ctxCyl.lineTo(cx + curRx, tableY);
        ctxCyl.ellipse(cx, tableY, curRx, cylRadius * 0.4, 0, 0, Math.PI); // bottom front
        ctxCyl.lineTo(cx - curRx, topY);
        ctxCyl.closePath();

        const sheetGrad = ctxCyl.createLinearGradient(cx - curRx, 0, cx + curRx, 0);
        sheetGrad.addColorStop(0, '#0284c7');
        sheetGrad.addColorStop(0.3, '#38bdf8');
        sheetGrad.addColorStop(0.7, '#7dd3fc');
        sheetGrad.addColorStop(1, '#0284c7');

        ctxCyl.fillStyle = sheetGrad;
        ctxCyl.fill();
        ctxCyl.strokeStyle = '#0369a1';
        ctxCyl.lineWidth = 1.5;
        ctxCyl.stroke();

        // Top open rim ellipse
        ctxCyl.beginPath();
        ctxCyl.ellipse(cx, topY, curRx, cylRadius * 0.4, 0, 0, Math.PI * 2);
        ctxCyl.fillStyle = '#bae6fd';
        ctxCyl.fill();
        ctxCyl.strokeStyle = '#0284c7';
        ctxCyl.stroke();

        // Smooth unrolling curl lines
        if (t > 0.05) {
          ctxCyl.strokeStyle = 'rgba(255, 255, 255, 0.6)';
          ctxCyl.lineWidth = 1.5;
          ctxCyl.beginPath();
          ctxCyl.moveTo(cx - curRx * 0.6, topY);
          ctxCyl.lineTo(cx - curRx * 0.6, tableY);
          ctxCyl.moveTo(cx + curRx * 0.4, topY);
          ctxCyl.lineTo(cx + curRx * 0.4, tableY);
          ctxCyl.stroke();
        }
      } else {
        // Perfectly flat pristine rectangular sheet
        const sheetX = cx - flatW * 0.5;
        const sheetY = tableY - flatH * 0.5;

        // Isometric perspective flat quad
        ctxCyl.beginPath();
        ctxCyl.moveTo(sheetX + flatW * 0.1, sheetY - flatH * 0.4);
        ctxCyl.lineTo(sheetX + flatW * 0.9, sheetY - flatH * 0.4);
        ctxCyl.lineTo(sheetX + flatW, sheetY + flatH * 0.6);
        ctxCyl.lineTo(sheetX, sheetY + flatH * 0.6);
        ctxCyl.closePath();

        const flatGrad = ctxCyl.createLinearGradient(sheetX, sheetY, sheetX + flatW, sheetY + flatH);
        flatGrad.addColorStop(0, '#38bdf8');
        flatGrad.addColorStop(1, '#0284c7');
        ctxCyl.fillStyle = flatGrad;
        ctxCyl.fill();
        ctxCyl.strokeStyle = '#0369a1';
        ctxCyl.lineWidth = 2;
        ctxCyl.stroke();

        // Flawless grid lines on the flat sheet showing zero distortion
        ctxCyl.strokeStyle = 'rgba(255, 255, 255, 0.5)';
        ctxCyl.lineWidth = 1.2;
        for (let i = 1; i <= 3; i++) {
          const fx = sheetX + (flatW * (i / 4));
          ctxCyl.beginPath();
          ctxCyl.moveTo(fx + flatW * 0.075, sheetY - flatH * 0.4);
          ctxCyl.lineTo(fx, sheetY + flatH * 0.6);
          ctxCyl.stroke();
        }
      }

      ctxCyl.restore();
    }

    function render() {
      renderSphere(currentT);
      renderCylinder(currentT);
    }

    function animate() {
      const diff = targetT - currentT;
      if (Math.abs(diff) > 0.005) {
        currentT += diff * 0.12;
        render();
        animReq = requestAnimationFrame(animate);
      } else {
        currentT = targetT;
        render();
        animReq = null;
      }
    }

    function setTarget(val) {
      targetT = val;
      if (!animReq) {
        animReq = requestAnimationFrame(animate);
      }
    }

    btn1.addEventListener('click', () => {
      btn1.classList.add('active');
      btn2.classList.remove('active');
      setTarget(0);
    });

    btn2.addEventListener('click', () => {
      btn2.classList.add('active');
      btn1.classList.remove('active');
      setTarget(1);
    });

    // Initial setup
    resizeCanvases();
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
  <title>Geodesic vs Latitude Path</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      -webkit-user-select: none;
      user-select: none;
    }
    html, body {
      width: 100%;
      height: 100%;
      overflow: hidden;
      background: #f8fafc;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    }
    #diagram-container {
      width: 100%;
      height: 100%;
      max-height: 560px;
      position: relative;
      touch-action: none;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
    }
    canvas {
      width: 100%;
      height: 100%;
      display: block;
      cursor: grab;
    }
    canvas:active {
      cursor: grabbing;
    }
    .hud {
      position: absolute;
      top: 10px;
      left: 10px;
      right: 10px;
      display: flex;
      flex-wrap: wrap;
      gap: 6px;
      pointer-events: none;
      z-index: 10;
    }
    .legend-row {
      display: flex;
      align-items: center;
      gap: 7px;
      background: rgba(255, 255, 255, 0.92);
      backdrop-filter: blur(4px);
      padding: 4px 9px;
      border-radius: 6px;
      font-size: 11px;
      font-weight: 600;
      color: #1e293b;
      box-shadow: 0 1px 3px rgba(0,0,0,0.08);
    }
    .indicator {
      width: 14px;
      height: 3.5px;
      border-radius: 2px;
      flex-shrink: 0;
    }
    .ind-geodesic {
      background: #0284c7;
      box-shadow: 0 0 5px #38bdf8;
    }
    .ind-parallel {
      background: #dc2626;
      border-top: 2px dashed #dc2626;
      height: 0;
    }
    .ind-equator {
      background: #06b6d4;
      box-shadow: 0 0 4px #22d3ee;
    }
    .stats-card {
      position: absolute;
      bottom: 34px;
      left: 10px;
      background: rgba(255, 255, 255, 0.9);
      backdrop-filter: blur(4px);
      padding: 6px 10px;
      border-radius: 8px;
      font-size: 11px;
      color: #334155;
      pointer-events: none;
      box-shadow: 0 1px 4px rgba(0,0,0,0.06);
      line-height: 1.35;
      z-index: 10;
    }
    .stats-card span {
      font-weight: 700;
    }
    .stats-card .geo { color: #0284c7; }
    .stats-card .lat { color: #dc2626; }
    .hint {
      position: absolute;
      bottom: 8px;
      left: 50%;
      transform: translateX(-50%);
      background: rgba(15, 23, 42, 0.82);
      color: #f8fafc;
      font-size: 10.5px;
      font-weight: 500;
      padding: 3px 12px;
      border-radius: 14px;
      pointer-events: none;
      letter-spacing: 0.2px;
      white-space: nowrap;
      z-index: 10;
    }
  </style>
</head>
<body>
  <div id="diagram-container">
    <div class="hud">
      <div class="legend-row">
        <div class="indicator ind-geodesic"></div>
        <span>Great Circle (Geodesic / Shortest)</span>
      </div>
      <div class="legend-row">
        <div class="indicator ind-parallel"></div>
        <span>Small Circle (Latitude Path / Longer)</span>
      </div>
      <div class="legend-row">
        <div class="indicator ind-equator"></div>
        <span>Equator</span>
      </div>
    </div>

    <div class="stats-card">
      <div>NYC → London:</div>
      <div class="geo">Great Circle: ~5,570 km</div>
      <div class="lat">Latitude Path: ~5,890 km (+320 km)</div>
    </div>

    <canvas id="globeCanvas"></canvas>
    <div class="hint">Drag to rotate 3D globe ↺</div>
  </div>

  <script>
    const canvas = document.getElementById('globeCanvas');
    const ctx = canvas.getContext('2d');
    const container = document.getElementById('diagram-container');

    // Globe state
    let rotX = 0.42;  // Pitch (tilt up/down to see Northern Atlantic)
    let rotY = 1.15;  // Yaw (spin around Earth axis)
    let targetRotX = rotX;
    let targetRotY = rotY;
    let isDragging = false;
    let prevMouseX = 0;
    let prevMouseY = 0;
    let width = 0;
    let height = 0;
    let radius = 120;
    let centerX = 0;
    let centerY = 0;

    // Coordinate conversions
    const DEG2RAD = Math.PI / 180;
    const RAD2DEG = 180 / Math.PI;

    function latLonToVec3(latDeg, lonDeg) {
      const phi = latDeg * DEG2RAD;
      const theta = lonDeg * DEG2RAD;
      return {
        x: Math.cos(phi) * Math.sin(theta),
        y: Math.sin(phi),
        z: Math.cos(phi) * Math.cos(theta)
      };
    }

    function rotatePoint(v, rx, ry) {
      // 1. Rotate around Y (lon/spin)
      const cosY = Math.cos(ry);
      const sinY = Math.sin(ry);
      const x1 = v.x * cosY + v.z * sinY;
      const y1 = v.y;
      const z1 = -v.x * sinY + v.z * cosY;

      // 2. Rotate around X (lat/pitch)
      const cosX = Math.cos(rx);
      const sinX = Math.sin(rx);
      const x2 = x1;
      const y2 = y1 * cosX - z1 * sinX;
      const z2 = y1 * sinX + z1 * cosX;

      return { x: x2, y: y2, z: z2 };
    }

    function project(p3d) {
      return {
        x: centerX + p3d.x * radius,
        y: centerY - p3d.y * radius,
        z: p3d.z
      };
    }

    function resize() {
      const rect = container.getBoundingClientRect();
      const dpr = Math.min(window.devicePixelRatio || 1, 2);
      width = rect.width;
      height = rect.height;
      canvas.width = width * dpr;
      canvas.height = height * dpr;
      ctx.setTransform(dpr, 0, 0, dpr, 0, 0);

      centerX = width / 2;
      // Slight vertical offset to center globe comfortably between legends
      centerY = height / 2 + 10;
      radius = Math.min(width, height) * 0.38;
      radius = Math.max(90, Math.min(radius, 190));
    }

    window.addEventListener('resize', resize);
    resize();

    // Slerp for Great Circle Path
    function slerp(v0, v1, t) {
      let dot = v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
      dot = Math.max(-1, Math.min(1, dot));
      const theta = Math.acos(dot) * t;
      // Relative vector
      const rx = v1.x - v0.x * dot;
      const ry = v1.y - v0.y * dot;
      const rz = v1.z - v0.z * dot;
      const rLen = Math.hypot(rx, ry, rz);
      if (rLen < 1e-6) return { ...v0 };
      const nx = rx / rLen;
      const ny = ry / rLen;
      const nz = rz / rLen;
      return {
        x: v0.x * Math.cos(theta) + nx * Math.sin(theta),
        y: v0.y * Math.cos(theta) + ny * Math.sin(theta),
        z: v0.z * Math.cos(theta) + nz * Math.sin(theta)
      };
    }

    // Coordinates of New York and London
    const NY = { lat: 40.71, lon: -74.00, name: 'New York' };
    const LON = { lat: 51.50, lon: -0.12, name: 'London' };

    const vNY = latLonToVec3(NY.lat, NY.lon);
    const vLON = latLonToVec3(LON.lat, LON.lon);

    // Pre-calculate paths
    const STEPS = 80;
    const geodesicPoints = [];
    for (let i = 0; i <= STEPS; i++) {
      geodesicPoints.push(slerp(vNY, vLON, i / STEPS));
    }

    const latitudePathPoints = [];
    for (let i = 0; i <= STEPS; i++) {
      const t = i / STEPS;
      // Linear interpolation along latitude / longitude (rhumb-like path)
      const lat = NY.lat + (LON.lat - NY.lat) * t;
      const lon = NY.lon + (LON.lon - NY.lon) * t;
      latitudePathPoints.push(latLonToVec3(lat, lon));
    }

    // Draw multi-segment 3D curve with front/back hemisphere handling
    function draw3DPolyline(points, isFrontHemisphere, style) {
      ctx.save();
      ctx.strokeStyle = style.color;
      ctx.lineWidth = style.width;
      if (style.dash) ctx.setLineDash(style.dash);
      if (style.glow) {
        ctx.shadowColor = style.glow;
        ctx.shadowBlur = style.glowBlur || 8;
      }

      let inPath = false;
      ctx.beginPath();
      for (let i = 0; i < points.length; i++) {
        const pRot = rotatePoint(points[i], rotX, rotY);
        const isFront = pRot.z >= -0.01;
        const shouldDraw = isFrontHemisphere ? isFront : !isFront;

        const proj = project(pRot);

        if (shouldDraw) {
          if (!inPath) {
            ctx.moveTo(proj.x, proj.y);
            inPath = true;
          } else {
            ctx.lineTo(proj.x, proj.y);
          }
        } else {
          inPath = false;
        }
      }
      ctx.stroke();
      ctx.restore();
    }

    // Render loop
    function render() {
      ctx.clearRect(0, 0, width, height);

      // Smooth rotation dampening
      rotX += (targetRotX - rotX) * 0.12;
      rotY += (targetRotY - rotY) * 0.12;

      // Slow gentle auto-spin when idle
      if (!isDragging) {
        targetRotY += 0.0012;
      }

      // 1. Draw Globe Base Glow & Shadow
      const globeGrad = ctx.createRadialGradient(
        centerX - radius * 0.35, centerY - radius * 0.35, radius * 0.1,
        centerX, centerY, radius
      );
      globeGrad.addColorStop(0, '#ffffff');
      globeGrad.addColorStop(0.5, '#e0f2fe');
      globeGrad.addColorStop(0.85, '#bae6fd');
      globeGrad.addColorStop(1, '#7dd3fc');

      // Outer Atmosphere Glow
      const glowGrad = ctx.createRadialGradient(
        centerX, centerY, radius * 0.95,
        centerX, centerY, radius * 1.15
      );
      glowGrad.addColorStop(0, 'rgba(56, 189, 248, 0.25)');
      glowGrad.addColorStop(1, 'rgba(56, 189, 248, 0)');

      ctx.fillStyle = glowGrad;
      ctx.beginPath();
      ctx.arc(centerX, centerY, radius * 1.15, 0, Math.PI * 2);
      ctx.fill();

      // Backside Graticule Grid (faint)
      drawGraticule(false);

      // Sphere Body Fill (Semi-transparent 3D look)
      ctx.save();
      ctx.fillStyle = globeGrad;
      ctx.globalAlpha = 0.88;
      ctx.beginPath();
      ctx.arc(centerX, centerY, radius, 0, Math.PI * 2);
      ctx.fill();

      // Inner sphere specular highlight rim
      ctx.strokeStyle = 'rgba(255, 255, 255, 0.7)';
      ctx.lineWidth = 2;
      ctx.stroke();
      ctx.restore();

      // North-South Axis
      drawAxis();

      // Frontside Graticule Grid
      drawGraticule(true);

      // Equator (Glowing Cyan Line)
      drawEquator();

      // Paths on Front & Back
      // 1. Small circle / Latitude path (Red dashed)
      draw3DPolyline(latitudePathPoints, true, {
        color: '#dc2626',
        width: 2.5,
        dash: [5, 4]
      });

      // 2. Great Circle Path (Solid vibrant blue with glow)
      draw3DPolyline(geodesicPoints, true, {
        color: '#0284c7',
        width: 3.8,
        glow: '#38bdf8',
        glowBlur: 10
      });

      // City Markers & Annotations
      drawCityPin(vNY, NY.name, '#0284c7', 'left');
      drawCityPin(vLON, LON.name, '#0284c7', 'right');

      requestAnimationFrame(render);
    }

    function drawGraticule(isFront) {
      // Parallels (every 30 deg)
      for (let lat = -60; lat <= 60; lat += 30) {
        if (lat === 0) continue; // Equator drawn separately
        const pts = [];
        for (let lon = 0; lon <= 360; lon += 6) {
          pts.push(latLonToVec3(lat, lon));
        }
        draw3DPolyline(pts, isFront, {
          color: isFront ? 'rgba(148, 163, 184, 0.45)' : 'rgba(203, 213, 225, 0.25)',
          width: 1
        });
      }

      // Meridians (every 30 deg)
      for (let lon = 0; lon < 360; lon += 30) {
        const pts = [];
        for (let lat = -90; lat <= 90; lat += 6) {
          pts.push(latLonToVec3(lat, lon));
        }
        draw3DPolyline(pts, isFront, {
          color: isFront ? 'rgba(148, 163, 184, 0.45)' : 'rgba(203, 213, 225, 0.25)',
          width: 1
        });
      }
    }

    function drawEquator() {
      const eqPts = [];
      for (let lon = 0; lon <= 360; lon += 4) {
        eqPts.push(latLonToVec3(0, lon));
      }
      draw3DPolyline(eqPts, true, {
        color: '#06b6d4',
        width: 2.4,
        glow: '#22d3ee',
        glowBlur: 8
      });
      draw3DPolyline(eqPts, false, {
        color: 'rgba(6, 182, 212, 0.25)',
        width: 1.2
      });
    }

    function drawAxis() {
      const pN = rotatePoint({ x: 0, y: 1.25, z: 0 }, rotX, rotY);
      const pS = rotatePoint({ x: 0, y: -1.25, z: 0 }, rotX, rotY);
      const projN = project(pN);
      const projS = project(pS);

      ctx.save();
      ctx.strokeStyle = '#94a3b8';
      ctx.lineWidth = 1.2;
      ctx.setLineDash([4, 4]);
      ctx.beginPath();
      ctx.moveTo(projN.x, projN.y);
      ctx.lineTo(projS.x, projS.y);
      ctx.stroke();

      // Pole labels
      if (pN.z > -0.2) {
        ctx.fillStyle = '#64748b';
        ctx.font = '9px system-ui, sans-serif';
        ctx.textAlign = 'center';
        ctx.fillText('N. Pole', projN.x, projN.y - 6);
      }
      ctx.restore();
    }

    function drawCityPin(vec, label, color, align) {
      const rot = rotatePoint(vec, rotX, rotY);
      const proj = project(rot);

      const alpha = Math.max(0.15, Math.min(1, (rot.z + 0.3) / 0.8));
      ctx.save();
      ctx.globalAlpha = alpha;

      // Glow circle
      ctx.beginPath();
      ctx.arc(proj.x, proj.y, 7, 0, Math.PI * 2);
      ctx.fillStyle = 'rgba(56, 189, 248, 0.35)';
      ctx.fill();

      // Solid pin core
      ctx.beginPath();
      ctx.arc(proj.x, proj.y, 4, 0, Math.PI * 2);
      ctx.fillStyle = '#ffffff';
      ctx.fill();
      ctx.strokeStyle = color;
      ctx.lineWidth = 2.5;
      ctx.stroke();

      // Label with background card
      if (rot.z > -0.1) {
        ctx.font = 'bold 11px system-ui, sans-serif';
        const textWidth = ctx.measureText(label).width;
        const boxX = align === 'left' ? proj.x - textWidth - 14 : proj.x + 10;
        const boxY = proj.y - 10;

        ctx.fillStyle = 'rgba(255, 255, 255, 0.9)';
        ctx.beginPath();
        ctx.roundRect ? ctx.roundRect(boxX, boxY, textWidth + 8, 18, 4) : ctx.rect(boxX, boxY, textWidth + 8, 18);
        ctx.fill();
        ctx.strokeStyle = 'rgba(148, 163, 184, 0.4)';
        ctx.lineWidth = 1;
        ctx.stroke();

        ctx.fillStyle = '#0f172a';
        ctx.textAlign = 'left';
        ctx.textBaseline = 'middle';
        ctx.fillText(label, boxX + 4, boxY + 9);
      }

      ctx.restore();
    }

    // Interaction Handlers
    function onPointerDown(e) {
      isDragging = true;
      const clientX = e.touches ? e.touches[0].clientX : e.clientX;
      const clientY = e.touches ? e.touches[0].clientY : e.clientY;
      prevMouseX = clientX;
      prevMouseY = clientY;
    }

    function onPointerMove(e) {
      if (!isDragging) return;
      const clientX = e.touches ? e.touches[0].clientX : e.clientX;
      const clientY = e.touches ? e.touches[0].clientY : e.clientY;

      const dx = clientX - prevMouseX;
      const dy = clientY - prevMouseY;
      prevMouseX = clientX;
      prevMouseY = clientY;

      targetRotY += dx * 0.008;
      targetRotX += dy * 0.008;

      // Limit pitch to prevent flipping upside down
      targetRotX = Math.max(-1.25, Math.min(1.25, targetRotX));
    }

    function onPointerUp() {
      isDragging = false;
    }

    canvas.addEventListener('mousedown', onPointerDown);
    window.addEventListener('mousemove', onPointerMove);
    window.addEventListener('mouseup', onPointerUp);

    canvas.addEventListener('touchstart', onPointerDown, { passive: true });
    window.addEventListener('touchmove', onPointerMove, { passive: true });
    window.addEventListener('touchend', onPointerUp);

    render();
  </script>
</body>
</html>

OGM.10.TRG.3

Aligned learning resources

Related diagrams