Merge branch 'master' of https://github.com/briidee3/ray-optics-metamaterials into weblate-weblate-ray-optics-simulation-main

Author: ricktu288

ai-tools/knowledge/objects.md

@@ -299,6 +299,10 @@ A glass with the shape of piecewise defined parametric curve. The `pieces` prope
 
 In user provided scene created using the visual editor, this object may appear outside a module, and a similar object with `CustomGlass` type may also be used instead whose equation is defined in a relative coordinate system where `p1` and `p2` are $(-1,0)$ and $(1,0)$, respectively. However, when you write JSON code by yourself, please always use the `ParamGlass` type and put it inside a module.
 
+### Cubic Bezier Glass
+
+A glass with a shape defined by boundaries composed of cubic Bezier curves. The `points` property is an array of arrays of 2D points with length 3. Point 1 is the first anchor point, points 2 and 3 are the control points, and point 1 of the next curve in the series composing a loop of curves which represents a lens is the second control point of the curve.
+
 ## Ideal Objects
 
 ### Ideal Lens

locales/en/main.json

@@ -119,6 +119,11 @@
       "title": "Parametric Curve",
       "description": "Glass with the shape defined by custom parametric equations."
     },
+    "CurveGlass": {
+      "title": "Cubic Bezier curves",
+      "description": "Glass bounded by cubic Bezier curves.",
+      "instruction": "Click to create a segment, click on the starting point when finish drawing. Click and drag the boxes to manipulate the control points, changing the curve."
+    },
     "CircleGrinGlass": {
       "title": "GRIN Circle",
       "description": "Glass with a custom refractive index function n(x,y) and a circular boundary."
@@ -133,6 +138,11 @@
       "title": "GRIN Parametric Curve",
       "description": "Gradient-index glass with boundary defined by custom parametric equations."
     },
+    "CurveGrinGlass": {
+      "title": "GRIN Cubic Bezier curves",
+      "description": "Gradient-index glass bounded by cubic Bezier curves.",
+      "instruction": "Click to create a segment, click on the starting point when finish drawing. Click and drag the boxes to manipulate the control points, changing the curve."
+    },
     "otherGrinGlass": {
       "title": "Gradient-index glass",
       "description": "Material with a custom refractive index function n(x,y)."

locales/en/simulator.json

@@ -210,6 +210,14 @@
         "notPositivelyOriented": "Curve is not positively oriented."
       }
     },
+    "CurveGlass": {
+      "refIndex": "Refractive index",
+      "refIndexInfo": {
+        "relative": "Relative if inside another glass",
+        "effective": "If this object is to be simulated with (absolute) refractive index n₁, but is placed inside another glass with refractive index n₀, then you should set the refractive index to n₁/n₀ here. In more complicated cases that several glasses overlap together, the effective refractive index of the overlapping region equals the product of the refractive indices of individual ones."
+      },
+      "cauchyCoeff": "Cauchy coefficient"
+    },
     "BaseGrinGlass": {
       "refIndexFnInfo": {
         "lambda": "To simulate chromatic dispersion, use parameter {{lambda}} for the vacuum wavelength in nanometers.",
@@ -248,6 +256,12 @@
         "functions": "This numerical tolerance is used in the function 'isOnBoundary' inside the 'ParamCurveObjMixin.js' file."
       }
     },
+    "CurveGrinGlass": {
+      "epsInfo": {
+        "units": "Units - [length].",
+        "functions": "This numerical tolerance is used in the function 'isOnBoundary' inside the 'ParamCurveObjMixin.js' file."
+      }
+    },
     "Aperture": {
       "diameter": "Diameter"
     },

package-lock.json

@@ -10,6 +10,7 @@
     "@popperjs/core": "2.11.8",
     "@vue/runtime-dom": "^3.5.13",
     "ace-builds": "^1.36.0",
+    "bezier-js": "^6.1.4",
     "bootstrap": "5.1.3",
     "canvas2svg": "github:gliffy/canvas2svg",
     "copy-webpack-plugin": "^12.0.2",

package.json

@@ -178,6 +178,13 @@
         :verticalOffset="0"
         :layout="layout"
       />
+      <ToolItem
+        id="CurveGlass"
+        :title="$t('main:tools.CurveGlass.title') + '<sup>Beta</sup>'"
+        :popoverContent="$t('main:meta.parentheses', {main: $t('main:tools.CurveGlass.description'), sub: $t('main:tools.CurveGlass.instruction')})"
+        :verticalOffset="0"
+        :layout="layout"
+      />
       <ToolItem
         id="CircleGrinGlass"
         :title="$t('main:tools.CircleGrinGlass.title')"
@@ -199,6 +206,13 @@
         :verticalOffset="0"
         :layout="layout"
       />
+      <ToolItem
+        id="CurveGrinGlass"
+        :title="$t('main:tools.CurveGrinGlass.title') + '<sup>Beta</sup>'"
+        :popoverContent="$t('main:meta.parentheses', {main: $t('main:tools.CurveGrinGlass.description'), sub: $t('main:tools.CurveGrinGlass.instruction')})"
+        :verticalOffset="0"
+        :layout="layout"
+      />
     </MoreToolsCollapsible>
   </ToolsCategory>
 

src/app/components/toolbar/ToolsList.vue

@@ -15,6 +15,7 @@
  */
 
 import geometry from './geometry.js';
+import Bezier from 'bezier-js';
 
 /**
  * The Mouse class encapsulates the state of the mouse within the scene.
@@ -88,6 +89,15 @@ class Mouse {
     return d_per < this.getClickExtent() * this.getClickExtent() && d_par >= 0 && d_par <= geometry.segmentLengthSquared(segment);
   }
 
+  /**
+   * Determines if the mouse is currently over a given curve.
+   * @param {Bezier} curve - The curve to check against the mouse position.
+   * @returns {boolean} True if the mouse is on the given curve, false otherwise.
+   */
+  isOnCurve(curve) {
+    return curve.project(this.pos).d ** 2 < this.getClickExtent(true) * this.getClickExtent(true);
+  }
+
   /**
    * Determines if the mouse is currently over a given line.
    * @param {geometry.line} line - The line to check against the mouse position.

src/core/Mouse.js

@@ -137,6 +137,16 @@ const geometry = {
     return ret;
   },
 
+  /**
+   * Calculate the intersections of a line and a curve.
+   * @param {Line} l1
+   * @param {Bezier} c1
+   * @return {Point[]}
+   */
+  lineCurveIntersections: function (l1, c1) {
+    return c1.intersects(l1);
+  },
+
 
   /**
    * Test if a point on the extension of a ray is actually on the ray.
@@ -159,6 +169,60 @@ const geometry = {
     return (p1.x - s1.p1.x) * (s1.p2.x - s1.p1.x) + (p1.y - s1.p1.y) * (s1.p2.y - s1.p1.y) >= 0 && (p1.x - s1.p2.x) * (s1.p1.x - s1.p2.x) + (p1.y - s1.p2.y) * (s1.p1.y - s1.p2.y) >= 0;
   },
 
+  /**
+   * Test if a point on the extension of a curve is actually on the curve.
+   * @param {Point} p1
+   * @param {Bezier} curve
+   * @return {Boolean}
+   */
+  intersectionIsOnCurve: function (p1, curve, threshold) {
+    var d_proj = curve.project(geometry.point(p1.x, p1.y)).d;
+   
+    return Math.pow(d_proj, 2) < threshold;
+  },
+
+  /**
+   * Scale the ray based on the bounding box of the curve.
+   * @param {Line} r1
+   * @param {Bezier} curve
+   * @return {Line} - Returns the vector pointing from r1.p1 to the farthest point on the curve's bounding box.
+   */
+  scaleRayForCurve: function (r1, curve) {
+    var bbox = curve.bbox();
+
+    // Offset each line from 0,0 by r1.p1
+    bbox.x.min -= r1.p1.x;
+    bbox.x.max -= r1.p1.x;
+    bbox.y.min -= r1.p1.y;
+    bbox.y.max -= r1.p1.y;
+
+    // Get vector (as a point) pointing from r1.p1 to r1.p2
+    var v1 = geometry.point(r1.p2.x - r1.p1.x, r1.p2.y - r1.p1.y);
+
+    // Figure out which bounding box corner is farthest from r1.p1 based on what quadrant v1 is in after offsetting by p1
+    var farthest = { x: Infinity, y: Infinity };
+    if (Math.abs(bbox.x.min) > Math.abs(bbox.x.max)) {
+      farthest.x = bbox.x.min;
+    } else {
+      farthest.x = bbox.x.max;
+    }
+    if (Math.abs(bbox.y.min) > Math.abs(bbox.y.max)) {
+      farthest.y = bbox.y.min;
+    } else {
+      farthest.y = bbox.y.max;
+    }
+
+    // Get distance between p1 and farthest point
+    var dist = Math.sqrt(farthest.x ** 2 + farthest.y ** 2);
+    
+    // Normalize v1 then scale it by dist
+    var len_v1 = Math.sqrt(v1.x ** 2 + v1.y ** 2);
+    v1.x = (v1.x / len_v1) * dist * 1.001;
+    v1.y = (v1.y / len_v1) * dist * 1.001;
+
+    return geometry.line(r1.p1, geometry.point(v1.x + r1.p1.x, v1.y + r1.p1.y));
+  },
+
   /**
    * Calculate the length of a line segment.
    * @param {Line} seg
@@ -252,6 +316,30 @@ const geometry = {
     var dx = l1.p2.x - l1.p1.x;
     var dy = l1.p2.y - l1.p1.y;
     return geometry.line(p1, geometry.point(p1.x + dx, p1.y + dy));
+  },
+
+  /**
+   * Normalize the given point as if it were a vector.
+   * @param {Point} p1
+   * @return {Point}
+   */
+  normalizeVec: function(p1) {
+    var len = geometry.distance(geometry.point(0, 0), p1);
+
+    return geometry.point(p1.x / len, p1.y / len);
+  },
+
+  /**
+   * Rotate the given point as if it were a vector by the given angle in radians.
+   * @param {Point} p1
+   * @return {Point}
+   */
+  rotateVec: function(p1, angle) {
+    // Rotate by the rotation matrix
+    return {
+      x: p1.x * Math.cos(angle) - p1.y * Math.sin(angle),
+      y: p1.x * Math.sin(angle) + p1.y * Math.cos(angle)
+    }
   }
 };
 

src/core/geometry.js

@@ -43,11 +43,13 @@ export const CircleGlass = require('./sceneObjs/glass/CircleGlass.js').default;
 export const Glass = require('./sceneObjs/glass/Glass.js').default;
 export const CustomGlass = require('./sceneObjs/glass/CustomGlass.js').default;
 export const ParamGlass = require('./sceneObjs/glass/ParamGlass.js').default;
+export const CurveGlass = require('./sceneObjs/glass/CurveGlass.js').default;
 export const IdealLens = require('./sceneObjs/glass/IdealLens.js').default;
 export const SphericalLens = require('./sceneObjs/glass/SphericalLens.js').default;
 export const CircleGrinGlass = require('./sceneObjs/glass/CircleGrinGlass.js').default;
 export const GrinGlass = require('./sceneObjs/glass/GrinGlass.js').default;
 export const ParamGrinGlass = require('./sceneObjs/glass/ParamGrinGlass.js').default;
+export const CurveGrinGlass = require('./sceneObjs/glass/CurveGrinGlass.js').default;
 export const Blocker = require('./sceneObjs/blocker/Blocker.js').default;
 export const CircleBlocker = require('./sceneObjs/blocker/CircleBlocker.js').default;
 export const Aperture = require('./sceneObjs/blocker/Aperture.js').default;

src/core/sceneObjs.js

@@ -71,11 +71,12 @@ class BaseGlass extends BaseSceneObj {
       ctx.globalAlpha = 1;
       return;
     }
-    if (n >= 1) {
-      var alpha = Math.log(n) / Math.log(1.5) * 0.2;
+    const mod_neg = n <= -1 ? -1 : 1;
+    if (n >= 1 || mod_neg === -1) {
+      var alpha = Math.log(n * mod_neg) / Math.log(1.5) * 0.2;
       if (allowColorSubtraction) {
         ctx.globalCompositeOperation = 'lighter';
-        ctx.fillStyle = "rgb(" + Math.round(alpha * this.scene.theme.glass.color.r * 255) + "," + Math.round(alpha * this.scene.theme.glass.color.g * 255) + "," + Math.round(alpha * this.scene.theme.glass.color.b * 255) + ")";
+        ctx.fillStyle = mod_neg < 0 ? "rgb(" + Math.round(alpha * this.scene.theme.glass.color.r * 0.75 * 255) + "," + Math.round(alpha * this.scene.theme.glass.color.g * 255) + "," + Math.round(alpha * this.scene.theme.glass.color.b * 0.75 * 255) + ")" : "rgb(" + Math.round(alpha * this.scene.theme.glass.color.r * 255) + "," + Math.round(alpha * this.scene.theme.glass.color.g * 255) + "," + Math.round(alpha * this.scene.theme.glass.color.b * 255) + ")";
       } else {
         ctx.globalAlpha = alpha;
         ctx.fillStyle = "rgb(" + Math.round(this.scene.theme.glass.color.r * 255) + "," + Math.round(this.scene.theme.glass.color.g * 255) + "," + Math.round(this.scene.theme.glass.color.b * 255) + ")";
@@ -85,7 +86,7 @@ class BaseGlass extends BaseSceneObj {
       ctx.globalCompositeOperation = 'source-over';
 
     } else {
-      var alpha = Math.log(1 / n) / Math.log(1.5) * 0.2;
+      var alpha = Math.log(1 / (n * mod_neg)) / Math.log(1.5) * 0.2;
       if (allowColorSubtraction) {
         // Subtract the gray color.
         // Use a trick to make the color become red (indicating nonphysical) if the total refractive index is lower than one.
@@ -167,6 +168,13 @@ class BaseGlass extends BaseSceneObj {
       }
     }
 
+    // Negative modifier for working with negative indices of refraction
+    var mod_neg = false;
+    if (n1 < 0) {
+      n1 = -n1;     // Flip n1 for compatibility with the following equations
+      mod_neg = true;
+    }
+
     var normal_len = Math.sqrt(normal.x * normal.x + normal.y * normal.y);
     var normal_x = normal.x / normal_len;
     var normal_y = normal.y / normal_len;
@@ -225,6 +233,16 @@ class BaseGlass extends BaseSceneObj {
       }
 
       // Handle the refracted ray
+
+      // Handle negative refractive index
+      if (mod_neg) {
+        // Restore n1
+        n1 = -n1;
+
+        // Flip sign of cos2
+        cos2 = Math.cos(2 * Math.PI - Math.acos(cos2));
+      }
+
       ray.p1 = incidentPoint;
       ray.p2 = geometry.point(incidentPoint.x + n1 * ray_x + (n1 * cos1 - cos2) * normal_x, incidentPoint.y + n1 * ray_y + (n1 * cos1 - cos2) * normal_y);
       ray.brightness_s = ray.brightness_s * (1 - R_s);