@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/publish.bat

@@ -0,0 +1,62 @@
+@echo off
+REM Define the source and destination directories
+set SOURCE_DIR=C:\Users\USER\Desktop\webgl\globeNew\my-app\src\webglobeplugins
+set DEST_DIR=C:\Users\USER\Desktop\npmpub\webglobeplugins
+
+REM --- Start: Prepare and Compile Package for Publishing ---
+
+REM Check if the destination directory exists and clean it if it does
+if exist "%DEST_DIR%" (
+    echo Cleaning temporary publication directory: "%DEST_DIR%"
+    rd /s /q "%DEST_DIR%"
+)
+
+REM Create the temporary destination directory if it doesn't exist
+if not exist "%DEST_DIR%" (
+    echo Creating temporary publication directory: "%DEST_DIR%"
+    mkdir "%DEST_DIR%"
+)
+
+REM Copy the entire package folder (including package.json, tsconfig.json, source files)
+REM to the temporary destination. /E copies directories and subdirectories, /I assumes DEST_DIR is a directory.
+REM /Y suppresses prompts to confirm overwriting existing files.
+echo Copying source files to temporary publication directory...
+xcopy /E /I /Y "%SOURCE_DIR%" "%DEST_DIR%\"
+
+REM Change to the temporary publication directory (this is the package root)
+cd /d "%DEST_DIR%"
+
+REM Install dependencies (this is crucial for TypeScript to be available for compilation)
+REM Using 'call' ensures that control returns to the batch script after npm finishes.
+echo Installing package dependencies for compilation...
+call npm install
+
+REM Compile TypeScript files into JavaScript
+REM This assumes you have a "build" script in your package.json (e.g., "build": "tsc")
+REM The compiled output (e.g., JS files) will typically go into a 'dist' folder inside %DEST_DIR%.
+echo Compiling TypeScript files...
+call npm run build
+REM If there is an error during the build, exit the script
+if %errorlevel% neq 0 (
+    echo Build failed. Exiting script.
+    exit /b %errorlevel%
+)
+REM --- End: Prepare and Compile Package for Publishing ---
+
+REM COPY PACKAGE JSON TO DIST
+xcopy /Y "%DEST_DIR%\package.json" "%DEST_DIR%\dist\"
+
+
+
+REM Run npm publish from the package root directory (%DEST_DIR%).
+REM Because package.json's "files" is set to ["dist"], only the compiled output will be published.
+echo Running npm publish from the compiled package root...
+cd /d "%DEST_DIR%\dist"
+npm publish
+
+REM Return to the original directory
+cd /d "%SOURCE_DIR%"
+
+echo Folder copied, compiled, and npm publish executed successfully.
+
+set /p exitkey= "Press any key to continue..."

package/range-tools-on-terrain/bearing-line/adapters.ts

@@ -0,0 +1,154 @@
+import { BearingLineInput, ImplicitBearingLineInput } from './types';
+
+
+import { LineInput } from "../../semiplugins/lightweight/line-plugin";
+import { PieceOfPiePluginInput } from "../../semiplugins/lightweight/piece-of-pie-plugin";
+import { CircleInput } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { ArcInput } from "../../semiplugins/shape-on-terrain/arc-plugin";
+import { Globe, Color } from "../../types";
+
+
+const radian = (degree: number) => degree * Math.PI / 180;
+
+const calculateStartAngle = (long: number, lat: number, endLong: number, endLat: number) => {
+    const dLat = (integralSec(endLat) - integralSec(lat)); // Because lines are strectes toward poles.
+    const dLong = endLong - long;
+    let angle = -Math.atan2(dLat, dLong);
+    return angle;
+}
+
+const integralSec = (angle: number) => {
+    return Math.log(Math.tan(angle / 2 + Math.PI / 4));
+}
+
+
+export const flatLinesInputAdapter = (bearingLine: ImplicitBearingLineInput): LineInput => {
+    const { long, lat, endLong, endLat, rgba } = bearingLine;
+    return {
+        key: bearingLine.key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        color: rgba as Color,
+    };
+}
+
+
+
+export const flatLinesBearingInputAdapter = (bearingLine: ImplicitBearingLineInput): LineInput => {
+    const { long, lat, rgba, key, bearingLat = 0, bearingLong = 0, msl } = bearingLine;
+    return {
+        key: key,
+        start: [long, lat],
+        end: [bearingLong, bearingLat],
+        color: rgba as Color,
+    };
+}
+
+
+
+export const bearingLineToCircleInputAdapter = (globe: Globe) => (bearingLine: ImplicitBearingLineInput): CircleInput => {
+    const { long, lat, endLong, endLat, rgba, altitude = 0,
+        msl = null } = bearingLine;
+
+    if (bearingLine.radius === undefined || bearingLine.radius === null) {
+        const radius = globe.Math.GetDist2D(long, lat, endLong, endLat);
+        bearingLine.radius = radius;
+    }
+    return {
+        key: bearingLine.key,
+        center: [long, lat],
+        radius: bearingLine.radius,
+        height: altitude,
+        color: rgba,
+        msl
+    };
+}
+
+
+
+export const bearingLineToArcInputAdapter = (bearingLine: ImplicitBearingLineInput): ArcInput => {
+    const { long, lat, endLong, endLat, rgba, altitude = 0, msl } = bearingLine;
+    return {
+        key: bearingLine.key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        height: altitude,
+        color: rgba as Color,
+        msl: msl
+    };
+}
+
+
+
+export const bearingLineToBearingArcInputAdapter = (globe: Globe, bearingLine: ImplicitBearingLineInput): ArcInput => {
+    const { long, lat, bearingAngle, rgba, altitude = 0, key, msl } = bearingLine;
+
+    if (bearingLine.radius === undefined || bearingLine.radius === null) {
+        throw new Error("Bearing line radius is not defined. Please calculate it before converting to ArcInput.");
+    }
+
+    const { long: endLong, lat: endLat } = globe.Math.FindPointByPolar(long, lat, bearingLine.radius, bearingAngle);
+
+    bearingLine.bearingLong = endLong;
+    bearingLine.bearingLat = endLat;
+
+    return {
+        key: key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        height: altitude,
+        color: rgba as Color,
+        msl,
+    };
+}
+
+
+
+export const bearingLineToPieceOfPieInputAdapter = (globe: Globe, item: ImplicitBearingLineInput): PieceOfPiePluginInput => {
+    const lat = radian(item.lat)
+    const long = radian(item.long)
+    const endLat = radian(item.endLat)
+    const endLong = radian(item.endLong)
+    const altitude = (item.altitude ?? 0);
+    const radius = item.radius ? item.radius * 0.2 : 10;
+    // @ts-ignore 
+    const { long: bearingLong, lat: bearingLat } = globe.Math.FindPointByPolar(item.long, item.lat, item.radius, item.bearingAngle)
+    const startAngle2d = calculateStartAngle(long, lat, endLong, endLat);
+    const bearingAngle2d = calculateStartAngle(long, lat, radian(bearingLong), radian(bearingLat))
+    let tailAngle2d = bearingAngle2d - startAngle2d;
+    if (tailAngle2d > 0) {
+        tailAngle2d -= Math.PI * 2;
+    }
+    const bearingAngle = radian(item.bearingAngle - 90);
+    const startAngleReal = globe.Math.GetAzimuthAngle(item.long, item.lat, item.endLong, item.endLat) //startAngle2d * 180 / Math.PI;
+    const startAngle3d = radian(startAngleReal - 90);
+    let tailAngle3d = bearingAngle - startAngle3d;
+    if (tailAngle3d > 0) {
+        tailAngle3d -= Math.PI * 2;
+    }
+    return {
+        key: item.key,
+        center: [item.long, item.lat],
+        radius: radius,
+        altitude: altitude + 230,
+        color: item.rgba,
+        startAngle2D: startAngle2d * 180 / Math.PI,
+        coverAngle2D: tailAngle2d * 180 / Math.PI,
+        startAngle3D: startAngle3d * 180 / Math.PI,
+        coverAngle3D: tailAngle3d * 180 / Math.PI,
+        fillingMode: item.pieFillingMode ?? 1,
+    };
+}
+
+
+
+export const pieceOfPieOpacityAdaptor = (lod: number, tiltAngle: number): number => {
+    const lodThreshold = 7.5;
+    const lodFactor = Math.exp(-Math.max(0, lod - lodThreshold));
+    tiltAngle += 5;
+    const tiltFactor = Math.min(1, 1 / Math.tan(radian(tiltAngle)));
+    const opacity = Math.max(Math.min(lodFactor * tiltFactor, 1), 0);
+    return opacity < 0.1 ? 0 : opacity; // Ensure opacity is not less than 0.1
+}
+
+