npm - frame.image - Versions diffs - 1.0.0 - Mend

frame.image 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,79 @@
+# Frame Image Manager
+This project is a part of the **Form Manager** suite. It provides functionality to manage and manipulate frame images effectively.
+## Features
+- Load and display frame images.
+- Apply transformations (resize, crop, rotate).
+- Export processed images in multiple formats.
+- Easy integration with other modules in the Form Manager suite.
+## Installation
+1. Clone the repository:
+  ```bash
+  git clone https://github.com/your-repo/Form-Manager.git
+  ```
+2. Navigate to the `frame.image` directory:
+  ```bash
+  cd Form-Manager/sample/frame.image
+  ```
+3. Install dependencies:
+  ```bash
+  npm install
+  ```
+## Publish
+_update package.json_
+ ```
+yarn build
+npm login
+npm publish
+```
+## Usage
+1. Import the module:
+  ```javascript
+  import { DrawCanvas } from './DrawCanvas';
+  ```
+2. Use the module in a JSX component:
+```javascript
+function App() {
+  const [show, setShow] = useState({
+    akima: true,
+    center: true,
+    polygon: false,
+    box: false,
+    points: true,
+    background: true,
+  });
+  const [dataUrl, setDataUrl] = useState<string | undefined>(undefined);
+  const width = 800;
+  const height = 600;
+  return (
+    <>
+      <DrawCanvas
+        width={width}
+        height={height}
+        imageUrl={dataUrl}
+        show={show}
+      />
+    </>
+  );
+}
+export default App;
+```

package/eslint.config.js ADDED Viewed

@@ -0,0 +1,28 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+export default tseslint.config(
+  { ignores: ['dist'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+)

package/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + TS</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,31 @@
+{
+  "name": "frame.image",
+  "version": "1.0.0",
+  "description": "A React component for drawing a frame on a canvas element.",
+  "license": "MIT",
+  "author": "Christian.Todd@rodenstock.com",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.22.0",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.0.4",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^9.22.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "globals": "^16.0.0",
+    "typescript": "~5.7.2",
+    "typescript-eslint": "^8.26.1",
+    "vite": "^6.3.1"
+  }
+}

package/public/vite.svg ADDED Viewed

@@ -0,0 +1 @@

+ <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

package/src/Akima.ts ADDED Viewed

@@ -0,0 +1,134 @@
+export function calcSplineKoef_Akima(
+  xw_ascending: number[],
+  yw: number[]
+  // koef_akima: number[][]
+): number[][] {
+  //WHauk: Konvertierung C#, Erweiterungen, Vereinfachungen (Extrapolation, Ringschluss), 2010
+  let fehler = 0;
+  const koef_akima = Array.from({ length: xw_ascending.length }, () =>
+    Array(3).fill(0)
+  );
+  const size = xw_ascending.length + 4; //erweitern der x-Werte an Anfang und Ende
+  const x = new Array(size).fill(0);
+  const y = new Array(size).fill(0);
+  const step_x = new Array(size).fill(0);
+  if (xw_ascending.length < 3) {
+    fehler = 1;
+  }
+  if (fehler == 0) {
+    for (let i = 0; i < xw_ascending.length; i++) {
+      x[2 + i] = xw_ascending[i];
+      y[2 + i] = yw[i];
+    }
+    for (let i = 0; i < xw_ascending.length - 1; i++) {
+      step_x[i + 2] = xw_ascending[i + 1] - xw_ascending[i];
+      if (step_x[i + 2] < 1e-7) {
+        fehler = 2;
+        break;
+      }
+    }
+  }
+  if (fehler == 0) {
+    //Randstützstellen
+    x[1] = x[2] - step_x[2];
+    step_x[1] = step_x[2];
+    x[0] = x[1] - step_x[1];
+    step_x[0] = step_x[1];
+    x[size - 2] = x[size - 3] + step_x[size - 4];
+    step_x[size - 3] = step_x[size - 4];
+    x[size - 1] = x[size - 2] + step_x[size - 4];
+    step_x[size - 2] = step_x[size - 3];
+    //(nicht ganz korrekt bei nicht-äquidistanten Knoten)
+    y[0] = yw[yw.length - 2];
+    y[1] = yw[yw.length - 1];
+    y[size - 2] = yw[0];
+    y[size - 1] = yw[1];
+    //Berechnen der Steigungen -> Empirische Formel nach Akima...
+    const m = new Array(size).fill(0);
+    const t = new Array(size).fill(0);
+    for (let i = 0; i < size - 1; i++) m[i] = (y[i + 1] - y[i]) / step_x[i]; //Geradensteigungen
+    for (let i = 2; i < size - 2; i++) {
+      t[i] = Math.abs(m[i + 1] - m[i]) + Math.abs(m[i - 1] - m[i - 2]); //Summe: abs(diff Steigungen links) + abs(diff Steigungen rechts)
+      if (t[i] < 1e-7) {
+        koef_akima[i - 2][0] = (m[i - 1] + m[i]) * 0.5; //Steigung: Mittelwert r/l
+      } else {
+        koef_akima[i - 2][0] =
+          (m[i - 1] * Math.abs(m[i + 1] - m[i]) +
+            m[i] * Math.abs(m[i - 1] - m[i - 2])) /
+          t[i];
+      }
+    }
+    //Berechnen der restlichen Koeffizienten
+    for (
+      let i = 2;
+      i < size - 2;
+      i++ //i < size - 2: alle Stützstellen
+    ) {
+      if (i < size - 3) {
+        koef_akima[i - 2][1] =
+          (3 * (y[i + 1] - y[i])) / (step_x[i] * step_x[i]) -
+          (2 * koef_akima[i - 2][0] + koef_akima[i - 1][0]) / step_x[i];
+        koef_akima[i - 2][2] =
+          (koef_akima[i - 2][0] + koef_akima[i - 1][0]) /
+            (step_x[i] * step_x[i]) -
+          (2 * (y[i + 1] - y[i])) / (step_x[i] * step_x[i] * step_x[i]);
+      } //letzte Stützstelle
+      else {
+        koef_akima[i - 2][1] =
+          (3 * (y[i + 1] - y[i])) / (step_x[i] * step_x[i]) -
+          (2 * koef_akima[i - 2][0] + koef_akima[i - 2 /*!*/][0]) / step_x[i];
+        koef_akima[i - 2][2] =
+          (koef_akima[i - 2][0] + koef_akima[i - 2 /*!*/][0]) /
+            (step_x[i] * step_x[i]) -
+          (2 * (y[i + 1] - y[i])) / (step_x[i] * step_x[i] * step_x[i]);
+      }
+    }
+  } //if (fehler == 0)
+  return koef_akima;
+}
+export function getSplineWert(
+  x0: number,
+  xwerte: number[],
+  ywerte: number[],
+  koef: number[][]
+): number {
+  let y0 = 0;
+  let index = xwerte.length - 1; //für Extrapolation rechts (für Notfall)
+  if (x0 < xwerte[0]) {
+    index = 0; //für Extrapolation links (für Notfall)
+  } else {
+    for (let i = 0; i < xwerte.length - 1; i++) {
+      if (x0 >= xwerte[i] && x0 < xwerte[i + 1]) {
+        index = i;
+        break;
+      }
+    }
+  }
+  y0 = koef[index][2];
+  y0 = y0 * (x0 - xwerte[index]) + koef[index][1];
+  y0 = y0 * (x0 - xwerte[index]) + koef[index][0];
+  y0 = y0 * (x0 - xwerte[index]) + ywerte[index];
+  return y0;
+}

package/src/App.css ADDED Viewed

@@ -0,0 +1,42 @@
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+.card {
+  padding: 2em;
+}
+.read-the-docs {
+  color: #888;
+}

package/src/App.tsx ADDED Viewed

@@ -0,0 +1,123 @@
+import { ChangeEvent, useRef, useState } from 'react';
+import './App.css';
+import { DrawCanvas } from './DrawCanvas';
+function App() {
+  const [show, setShow] = useState({
+    akima: true,
+    center: true,
+    polygon: false,
+    box: false,
+    points: true,
+    background: true,
+  });
+  const [dataUrl, setDataUrl] = useState<string | undefined>(undefined);
+  const fileInputRef = useRef<HTMLInputElement | null>(null);
+  const width = 800;
+  const height = 600;
+  // Event listener for mouse click
+  const handleFileChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0];
+    if (file) {
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        const url = e.target?.result as string;
+        setDataUrl(url);
+        // Handle the loaded image data URL (e.g., pass it to the DrawCanvas component)
+        console.log('Loaded image data URL:', url);
+        // drawImageOnCanvas(dataUrl);
+      };
+      reader.readAsDataURL(file);
+    }
+  };
+  function handleCheckboxChange(key: keyof typeof show) {
+    return (e: ChangeEvent<HTMLInputElement>): void => {
+      setShow((prevShow) => ({
+        ...prevShow,
+        [key]: e.target.checked,
+      }));
+    };
+  }
+  const handleCheckboxBackgroundChange = handleCheckboxChange('background');
+  const handleCheckboxCenterChange = handleCheckboxChange('center');
+  const handleCheckboxBoxChange = handleCheckboxChange('box');
+  const handleCheckboxPolygonChange = handleCheckboxChange('polygon');
+  const handleCheckboxPointsChange = handleCheckboxChange('points');
+  const handleCheckboxAkimaChange = handleCheckboxChange('akima');
+  return (
+    <>
+      <input
+        type="file"
+        ref={fileInputRef}
+        accept="image/*"
+        onChange={handleFileChange}
+      />
+      <br />
+      <label>
+        <input
+          type="checkbox"
+          defaultChecked
+          onChange={(e) => handleCheckboxCenterChange(e)}
+        />{' '}
+        Center
+      </label>
+      <label>
+        <input
+          type="checkbox"
+          defaultChecked
+          onChange={(e) => handleCheckboxBackgroundChange(e)}
+        />{' '}
+        Background
+      </label>
+      <label>
+        <input
+          type="checkbox"
+          defaultChecked
+          onChange={(e) => handleCheckboxPointsChange(e)}
+        />{' '}
+        Points
+      </label>
+      <label>
+        <input
+          type="checkbox"
+          defaultChecked
+          onChange={(e) => handleCheckboxPolygonChange(e)}
+        />{' '}
+        Polygon
+      </label>
+      <label>
+        <input
+          type="checkbox"
+          defaultChecked
+          onChange={(e) => handleCheckboxBoxChange(e)}
+        />{' '}
+        Box
+      </label>
+      <label>
+        <input
+          type="checkbox"
+          defaultChecked
+          onChange={(e) => handleCheckboxAkimaChange(e)}
+        />{' '}
+        Akima
+      </label>
+      <br />
+      <DrawCanvas
+        width={width}
+        height={height}
+        imageUrl={dataUrl}
+        show={show}
+      />
+    </>
+  );
+}
+export default App;

package/src/DrawCanvas.tsx ADDED Viewed

@@ -0,0 +1,191 @@
+import { JSX, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Point } from './Point';
+import { SortedPoints } from './SortedPoints';
+export function DrawCanvas(props: {
+  width: number;
+  height: number;
+  show: {
+    background: boolean;
+    center: boolean;
+    akima: boolean;
+    polygon: boolean;
+    box: boolean;
+    points: boolean;
+  };
+  imageUrl?: string;
+}): JSX.Element {
+  const universeCenter = useMemo(
+    () => new Point(props.width / 2, props.height / 2),
+    [props.height, props.width]
+  ); // Center of the canvas is [400,300]
+  const offset = 200;
+  const [points, setPoints] = useState<Point[]>([
+    new Point(offset, 0, universeCenter),
+    new Point(0, offset, universeCenter),
+    new Point(-offset, 0, universeCenter),
+    new Point(0, -offset, universeCenter),
+  ]); // Store points
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const drawObjects = useCallback(
+    (context: CanvasRenderingContext2D) => {
+      const sortedPoints = new SortedPoints(points, universeCenter);
+      if (props.show.center) {
+        sortedPoints.drawCenter(context);
+      }
+      if (props.show.box) {
+        sortedPoints.drawBox(context);
+      }
+      if (props.show.polygon) {
+        sortedPoints.drawPolygon(context);
+      }
+      if (props.show.points) {
+        sortedPoints.drawPoints(context);
+      }
+      if (props.show.akima) {
+        sortedPoints.drawAkima(context);
+      }
+    },
+    [
+      points,
+      props.show.akima,
+      props.show.box,
+      props.show.center,
+      props.show.points,
+      props.show.polygon,
+      universeCenter,
+    ]
+  );
+  const drawBackground = useCallback(
+    (context: CanvasRenderingContext2D) => {
+      const canvas = canvasRef.current;
+      if (canvas) {
+        if (props.imageUrl && props.show.background) {
+          const img = new Image();
+          img.onload = () => {
+            context.clearRect(0, 0, canvas.width, canvas.height);
+            // Draw the image on the canvas
+            context.drawImage(img, 0, 0, canvas.width, canvas.height);
+            // Redraw points after the background
+            drawObjects(context);
+          };
+          img.src = props.imageUrl;
+        } else {
+          context.clearRect(0, 0, canvas.width, canvas.height);
+          context.fillStyle = 'lightgrey';
+          context.fillRect(0, 0, canvas.width, canvas.height);
+          // Redraw points after the background
+          drawObjects(context);
+        }
+      }
+    },
+    [props.imageUrl, props.show.background, drawObjects] // Include points in dependencies
+  );
+  const getCurrentPoint = useCallback(
+    (canvas: HTMLCanvasElement, event: MouseEvent): Point => {
+      const rect = canvas.getBoundingClientRect();
+      const x = event.clientX - rect.left - universeCenter.X;
+      const y = universeCenter.Y - (event.clientY - rect.top);
+      return new Point(x, y, universeCenter);
+    },
+    [universeCenter]
+  );
+  // Event listener for mouse click
+  const handleMouseClick = useCallback(
+    (event: MouseEvent) => {
+      event.preventDefault();
+      const canvas = canvasRef.current;
+      if (!canvas) return;
+      const context = canvas.getContext('2d');
+      if (!context) return;
+      const point = getCurrentPoint(canvas, event);
+      // Add the new point to the list
+      setPoints((prevPoints) => [...prevPoints, point]);
+      // Draw the new point
+      context.fillStyle = 'red';
+      context.beginPath();
+      context.arc(point.X, point.Y, 5, 0, 2 * Math.PI);
+      context.fill();
+    },
+    [getCurrentPoint]
+  );
+  const handleContextMenu = useCallback(
+    (event: MouseEvent) => {
+      event.preventDefault();
+      const canvas = canvasRef.current;
+      if (!canvas) return;
+      const point = getCurrentPoint(canvas, event);
+      const minIndex = point.findMinDistPoint(points);
+      setPoints((prevPoints) =>
+        prevPoints.filter((_, index) => index !== minIndex)
+      );
+    },
+    [getCurrentPoint, points]
+  );
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (canvas) {
+      const context = canvas.getContext('2d');
+      if (context /*&& dataUrl*/) {
+        drawBackground(context);
+        // new Point(0, 0, universeCenter).draw(context, 'blue', {
+        //   text: 'origin',
+        //   offset: 5,
+        // });
+        // new Point(100, 0, universeCenter).draw(context, 'blue', {
+        //   text: '1',
+        //   offset: 5,
+        // });
+        // new Point(-100, 0, universeCenter).draw(context, 'blue', {
+        //   text: '2',
+        //   offset: 5,
+        // });
+        // new Point(0, 100, universeCenter).draw(context, 'blue', {
+        //   text: '3',
+        //   offset: 5,
+        // });
+        // new Point(0, -100, universeCenter).draw(context, 'blue', {
+        //   text: '4',
+        //   offset: 5,
+        // });
+      }
+      // Add event listener
+      canvas.addEventListener('click', handleMouseClick);
+      canvas.addEventListener('contextmenu', handleContextMenu);
+      // Cleanup event listeners and interval on component unmount
+      return () => {
+        canvas.removeEventListener('click', handleMouseClick);
+        canvas.removeEventListener('contextmenu', handleContextMenu);
+      };
+    }
+  }, [drawBackground, handleContextMenu, handleMouseClick, universeCenter]);
+  return (
+    <canvas
+      ref={canvasRef}
+      width={props.width}
+      height={props.height}
+      id="idCanvas"
+      style={{ backgroundColor: 'lightgrey' }}
+      // onClick={handleCanvasClick} // Add the click event listener
+    >
+      Your browser does not support the HTML canvas tag.
+    </canvas>
+  );
+}

package/src/Point.ts ADDED Viewed

@@ -0,0 +1,97 @@
+export class Point {
+  private x: number;
+  private y: number;
+  private xOrigin: number;
+  private yOrigin: number;
+  constructor(x: number, y: number, origin?: Point) {
+    this.xOrigin = origin ? origin.X : 0;
+    this.yOrigin = origin ? origin.Y : 0;
+    this.x = x;
+    this.y = y;
+  }
+  get X() {
+    return this.x;
+  }
+  get Y() {
+    return this.y;
+  }
+  get Origin(): Point {
+    return new Point(this.xOrigin, this.yOrigin);
+  }
+  get Radius(): number {
+    return (
+      Math.round(Math.sqrt(this.X * this.X + this.Y * this.Y) * 1000) / 1000
+    );
+  }
+  relAtan(origin: Point): number {
+    const cos = this.X - origin.X;
+    const sin = this.Y - origin.Y;
+    let atan2 = Math.atan2(sin, cos); // atan2 range is [-PI, PI]
+    if (atan2 < 0) {
+      // atan2 is negative, add 2 * Math.PI to make it positive
+      atan2 += Math.PI * 2;
+    }
+    return Math.round(atan2 * 1000) / 1000;
+  }
+  draw(
+    context: CanvasRenderingContext2D,
+    strokeStyle?: string,
+    index?: {
+      text: string;
+      offset: number;
+    }
+  ): void {
+    context.fillStyle = strokeStyle ?? 'magenta';
+    context.beginPath();
+    context.arc(
+      this.X + this.xOrigin,
+      this.yOrigin - this.Y,
+      5,
+      0,
+      2 * Math.PI
+    );
+    context.fill();
+    if (index) {
+      context.font = '12px Arial';
+      context.fillStyle = 'black';
+      context.fillText(
+        index.text,
+        this.X + this.xOrigin + index.offset,
+        this.yOrigin - this.Y - index.offset
+      ); // Adjust text position
+    }
+  }
+  drawCross(context: CanvasRenderingContext2D): void {
+    context.strokeStyle = 'red';
+    this.drawLine(context, new Point(this.X + 100, this.Y));
+  }
+  drawLine(context: CanvasRenderingContext2D, point: Point): void {
+    context.strokeStyle = 'green';
+    context.lineWidth = 2;
+    context.beginPath();
+    context.moveTo(this.X + this.xOrigin, this.yOrigin - this.Y);
+    context.lineTo(point.X + point.xOrigin, point.yOrigin - point.Y);
+    context.stroke();
+  }
+  findMinDistPoint(points: Point[]): number {
+    const minDistArray = points.map((p) => {
+      const dx = p.X - this.X;
+      const dy = p.Y - this.Y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      return dist;
+    });
+    const minDist = Math.min(...minDistArray);
+    const minIndex = minDistArray.findIndex((dist) => dist === minDist);
+    return minIndex;
+  }
+}

package/src/SortedPoints.ts ADDED Viewed

@@ -0,0 +1,219 @@
+import { calcSplineKoef_Akima, getSplineWert } from './Akima';
+import { Point } from './Point';
+export class SortedPoints {
+  private points: Point[] = [];
+  private universeCenter: Point;
+  constructor(points: Point[], universeCenter: Point) {
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    if (points.length >= 2) {
+      xMin = points.reduce((min, p) => Math.min(min, p.X), Infinity);
+      xMax = points.reduce((max, p) => Math.max(max, p.X), -Infinity);
+      yMin = points.reduce((min, p) => Math.min(min, p.Y), Infinity);
+      yMax = points.reduce((max, p) => Math.max(max, p.Y), -Infinity);
+    }
+    const center = new Point(
+      xMin + (xMax - xMin) / 2,
+      yMin + (yMax - yMin) / 2
+    );
+    this.points = points.sort((a: Point, b: Point) => {
+      return a.relAtan(center) - b.relAtan(center);
+    });
+    this.universeCenter = universeCenter;
+  }
+  get Center() {
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    if (this.points.length >= 2) {
+      xMin = this.points.reduce((min, p) => Math.min(min, p.X), Infinity);
+      xMax = this.points.reduce((max, p) => Math.max(max, p.X), -Infinity);
+      yMin = this.points.reduce((min, p) => Math.min(min, p.Y), Infinity);
+      yMax = this.points.reduce((max, p) => Math.max(max, p.Y), -Infinity);
+    }
+    const center = new Point(
+      xMin + (xMax - xMin) / 2,
+      yMin + (yMax - yMin) / 2
+    );
+    return center;
+  }
+  get NrRadii(): number {
+    return 128;
+    // return (this.points.length - 1) * 8;
+  }
+  get RadianKoeffs(): number[] {
+    return this.points.map((point) => {
+      return point.relAtan(this.Center);
+    });
+  }
+  get RadiusKoeffs(): number[] {
+    return this.points.map((point) => {
+      return point.Radius;
+    });
+  }
+  drawPoints(context: CanvasRenderingContext2D): void {
+    this.points.forEach((point, index) => {
+      point.draw(context, 'magenta', {
+        text: `${index}`,
+        offset: 10,
+      });
+      point.drawLine(
+        context,
+        new Point(this.Center.X, this.Center.Y, this.universeCenter)
+      );
+    });
+  }
+  drawCenter(context: CanvasRenderingContext2D): void {
+    if (this.points.length >= 2) {
+      const point1 = new Point(
+        this.Center.X - 50,
+        this.Center.Y,
+        this.universeCenter
+      );
+      point1.drawLine(
+        context,
+        new Point(this.Center.X + 50, this.Center.Y, this.universeCenter)
+      );
+      const point2 = new Point(
+        this.Center.X,
+        this.Center.Y - 50,
+        this.universeCenter
+      );
+      point2.drawLine(
+        context,
+        new Point(this.Center.X, this.Center.Y + 50, this.universeCenter)
+      );
+    }
+  }
+  drawBox(context: CanvasRenderingContext2D): void {
+    if (this.points.length >= 2) {
+      const xMin = this.points.reduce((min, p) => Math.min(min, p.X), Infinity);
+      const xMax = this.points.reduce(
+        (max, p) => Math.max(max, p.X),
+        -Infinity
+      );
+      const yMin = this.points.reduce((min, p) => Math.min(min, p.Y), Infinity);
+      const yMax = this.points.reduce(
+        (max, p) => Math.max(max, p.Y),
+        -Infinity
+      );
+      context.fillStyle = 'red';
+      const topLeft = new Point(xMin, yMin, this.universeCenter);
+      const bottomRight = new Point(xMax, yMax, this.universeCenter);
+      context.strokeStyle = 'blue';
+      context.lineWidth = 5;
+      const width = bottomRight.X - topLeft.X;
+      const height = topLeft.Y - bottomRight.Y;
+      context.strokeRect(
+        topLeft.X + topLeft.Origin.X,
+        topLeft.Origin.Y - topLeft.Y,
+        width,
+        height
+      );
+    }
+  }
+  drawPolygon(context: CanvasRenderingContext2D): void {
+    if (this.points.length >= 2) {
+      context.fillStyle = 'blue';
+      context.globalAlpha = 0.4; // Set transparency to 40%
+      context.beginPath();
+      context.moveTo(
+        this.points[0].Origin.X + this.points[0].X,
+        this.points[0].Origin.Y - this.points[0].Y
+      );
+      for (let i = 1; i < this.points.length; i++) {
+        context.lineTo(
+          this.points[i].Origin.X + this.points[i].X,
+          this.points[i].Origin.Y - this.points[i].Y
+        );
+      }
+      context.closePath();
+      context.fill();
+      context.globalAlpha = 1.0; // Reset transparency to default
+    }
+  }
+  private getSplineKoeff(
+    radian: number,
+    xKoef: number[],
+    yKoef: number[],
+    koef: number[][]
+  ): { x: number; y: number } {
+    const xMin = getSplineWert(radian, xKoef, yKoef, koef);
+    const sin = Math.round(Math.sin(radian) * xMin * 1000) / 1000;
+    const cos = Math.round(Math.cos(radian) * xMin * 1000) / 1000;
+    return { x: cos, y: sin };
+  }
+  drawAkima(context: CanvasRenderingContext2D): void {
+    if (this.points.length >= 2) {
+      const radianKoeffs = this.RadianKoeffs;
+      const radiusKoeffs = this.RadiusKoeffs;
+      const koef = calcSplineKoef_Akima(radianKoeffs, radiusKoeffs);
+      const akimaKoords = [];
+      const centeredAkimaKoords = [];
+      const nrRadii = this.NrRadii;
+      const positions = [];
+      // for (let i = 0; i < this.points.length; i++) {
+      //   const point = this.points[i];
+      //   const pos = point.relAtan(this.Center);
+      //   positions.push(pos);
+      // }
+      for (let i = 0; i < nrRadii; i++) {
+        const pos = ((Math.PI * 2) / nrRadii) * i;
+        positions.push(pos);
+      }
+      for (let i = 0; i < positions.length; i++) {
+        const { x, y } = this.getSplineKoeff(
+          positions[i],
+          radianKoeffs,
+          radiusKoeffs,
+          koef
+        );
+        akimaKoords.push(new Point(x, y, this.universeCenter));
+        centeredAkimaKoords.push(
+          new Point(this.Center.X + x, this.Center.Y + y, this.universeCenter)
+        );
+      }
+      // now draw the akima points
+      context.fillStyle = 'green';
+      context.globalAlpha = 0.4; // Set transparency to 40%
+      context.beginPath();
+      context.moveTo(
+        akimaKoords[0].Origin.X + akimaKoords[0].X,
+        akimaKoords[0].Origin.Y - akimaKoords[0].Y
+      );
+      const radianLength = centeredAkimaKoords.length - 1;
+      for (let i = 1; i <= radianLength; i++) {
+        const centeredPoint = akimaKoords[i];
+        context.lineTo(
+          akimaKoords[i].Origin.X + centeredPoint.X,
+          akimaKoords[i].Origin.Y - centeredPoint.Y
+        );
+      }
+      context.closePath();
+      context.fill();
+      context.globalAlpha = 1.0; // Reset transparency to default
+    }
+  }
+}

package/src/assets/react.svg ADDED Viewed

@@ -0,0 +1 @@

+ <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>

package/src/index.css ADDED Viewed

@@ -0,0 +1,68 @@
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}

package/src/main.tsx ADDED Viewed

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

package/src/vite-env.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ /// <reference types="vite/client" />

package/tsconfig.app.json ADDED Viewed

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

package/tsconfig.node.json ADDED Viewed

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})