+
-
diff --git a/desktop/src/app/atlas/atlas.component.html b/desktop/src/app/atlas/atlas.component.html
index c88559119..fb934282c 100644
--- a/desktop/src/app/atlas/atlas.component.html
+++ b/desktop/src/app/atlas/atlas.component.html
@@ -80,7 +80,7 @@
Position Angle
{{ moon.phase.current.posAngle }}°
-
diff --git a/desktop/src/shared/types/alignment.types.ts b/desktop/src/shared/types/alignment.types.ts
index e8af9ab96..732117d77 100644
--- a/desktop/src/shared/types/alignment.types.ts
+++ b/desktop/src/shared/types/alignment.types.ts
@@ -34,7 +34,6 @@ export interface TPPAStart {
capture: CameraStartCapture
plateSolver: PlateSolverRequest
startFromCurrentPosition: boolean
- compensateRefraction: boolean
stopTrackingWhenDone: boolean
stepDirection: GuideDirection
stepDuration: number
@@ -78,7 +77,6 @@ export const DEFAULT_TPPA_START: TPPAStart = {
plateSolver: DEFAULT_PLATE_SOLVER_REQUEST,
startFromCurrentPosition: true,
stepDirection: 'EAST',
- compensateRefraction: true,
stopTrackingWhenDone: true,
stepDuration: 5,
}
@@ -128,7 +126,6 @@ export function tppaStartWithDefault(request?: Partial
, source: TPPAS
request.plateSolver = plateSolverRequestWithDefault(request.plateSolver, source.plateSolver)
request.startFromCurrentPosition ??= source.startFromCurrentPosition
request.stepDirection ||= source.stepDirection
- request.compensateRefraction ??= source.compensateRefraction
request.stopTrackingWhenDone ??= source.stopTrackingWhenDone
request.stepDuration ??= source.stepDuration
return request as TPPAStart
diff --git a/gradle.properties b/gradle.properties
index 4eb978215..dd39acccf 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,5 @@
org.gradle.caching=true
org.gradle.parallel=true
org.gradle.jvmargs=-XX:MaxMetaspaceSize=1024m -Xmx2048m
+org.gradle.configuration-cache=true
version.code=0.1.0
diff --git a/nebulosa-alignment/build.gradle.kts b/nebulosa-alignment/build.gradle.kts
index cb6b362b6..05312bb2c 100644
--- a/nebulosa-alignment/build.gradle.kts
+++ b/nebulosa-alignment/build.gradle.kts
@@ -8,6 +8,7 @@ dependencies {
api(project(":nebulosa-time"))
api(project(":nebulosa-platesolver"))
implementation(project(":nebulosa-log"))
+ testImplementation(project(":nebulosa-nova"))
testImplementation(project(":nebulosa-test"))
}
diff --git a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/PolarErrorDetermination.kt b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/PolarErrorDetermination.kt
index 8eef232d3..f155186b2 100644
--- a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/PolarErrorDetermination.kt
+++ b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/PolarErrorDetermination.kt
@@ -12,6 +12,8 @@ import nebulosa.time.UTC
import kotlin.math.abs
import kotlin.math.hypot
+// https://bitbucket.org/Isbeorn/nina.plugin.polaralignment/src/master/PolarAlignment/TPAPAVM.cs
+
internal data class PolarErrorDetermination(
@JvmField val initialReferenceFrame: PlateSolution,
@JvmField val firstPosition: Position,
@@ -67,28 +69,27 @@ internal data class PolarErrorDetermination(
fun update(
time: InstantOfTime,
initialAzimuthError: Angle, initialAltitudeError: Angle,
- referenceFrame: PlateSolution, compensateRefraction: Boolean = false
+ referenceFrame: PlateSolution,
): DoubleArray {
currentReferenceFrame = referenceFrame
val centerX = referenceFrame.widthInPixels / 2.0
val centerY = referenceFrame.heightInPixels / 2.0
- val originPixel =
- doubleArrayOf(initialReferenceFrame.rightAscension, initialReferenceFrame.declination).stenographicProjection(referenceFrame)
+ val originPixel = doubleArrayOf(initialReferenceFrame.rightAscension, initialReferenceFrame.declination).stenographicProjection(referenceFrame)
val pointShift = doubleArrayOf(centerX - originPixel[0], centerY - originPixel[1])
originPixel[0] += pointShift[0] * 2.0
originPixel[1] += pointShift[1] * 2.0
- val destinationAltAz = destinationCoordinates(-initialAzimuthError, -initialAltitudeError, time, compensateRefraction)
+ val destinationAltAz = destinationCoordinates(-initialAzimuthError, -initialAltitudeError, time)
val destinationPixel = doubleArrayOf(destinationAltAz[0], destinationAltAz[1]).stenographicProjection(referenceFrame)
destinationPixel[0] += pointShift[0] * 2.0
destinationPixel[1] += pointShift[1] * 2.0
// Azimuth.
- val originalAzimuthAltAz = destinationCoordinates(-initialAzimuthError, 0.0, time, compensateRefraction)
+ val originalAzimuthAltAz = destinationCoordinates(-initialAzimuthError, 0.0, time)
val originalAzimuthPixel = doubleArrayOf(originalAzimuthAltAz[0], originalAzimuthAltAz[1]).stenographicProjection(referenceFrame)
originalAzimuthPixel[0] += pointShift[0] * 2.0
@@ -102,7 +103,7 @@ internal data class PolarErrorDetermination(
val originalAzimuthDistance = hypot(originalAzimuthPixel[0] - originPixel[0], originalAzimuthPixel[1] - originPixel[1])
// Altitude.
- val originalAltitudeAltAz = destinationCoordinates(0.0, -initialAltitudeError, time, compensateRefraction)
+ val originalAltitudeAltAz = destinationCoordinates(0.0, -initialAltitudeError, time)
val originalAltitudePixel = doubleArrayOf(originalAltitudeAltAz[0], originalAltitudeAltAz[1]).stenographicProjection(referenceFrame)
originalAltitudePixel[0] += pointShift[0] * 2.0
@@ -119,19 +120,16 @@ internal data class PolarErrorDetermination(
// Azimuth.
val originalAzimuthDirection = doubleArrayOf(destinationPixel[0] - originalAltitudePixel[0], destinationPixel[1] - originalAltitudePixel[1])
- val correctedAzimuthDirection =
- doubleArrayOf(destinationPixel[0] - correctedAltitudePixel[0], destinationPixel[1] - correctedAltitudePixel[1])
+ val correctedAzimuthDirection = doubleArrayOf(destinationPixel[0] - correctedAltitudePixel[0], destinationPixel[1] - correctedAltitudePixel[1])
// When dot product is positive, the angle between both vectors is smaller than 90°.
- val azimuthSameDirection =
- (originalAzimuthDirection[0] * correctedAzimuthDirection[0] + originalAzimuthDirection[1] * correctedAzimuthDirection[1]) > 0
+ val azimuthSameDirection = (originalAzimuthDirection[0] * correctedAzimuthDirection[0] + originalAzimuthDirection[1] * correctedAzimuthDirection[1]) > 0
val azSign = if (azimuthSameDirection) 1 else -1
// Altitude.
val originalAltitudeDirection = doubleArrayOf(destinationPixel[0] - originalAzimuthPixel[0], destinationPixel[1] - originalAzimuthPixel[1])
val correctedAltitudeDirection = doubleArrayOf(destinationPixel[0] - correctedAzimuthPixel[0], destinationPixel[1] - correctedAzimuthPixel[1])
// When dot product is positive, the angle between both vectors is smaller than 90°.
- val altitudeSameDirection =
- (originalAltitudeDirection[0] * correctedAltitudeDirection[0] + originalAltitudeDirection[1] * correctedAltitudeDirection[1]) > 0
+ val altitudeSameDirection = (originalAltitudeDirection[0] * correctedAltitudeDirection[0] + originalAltitudeDirection[1] * correctedAltitudeDirection[1]) > 0
val altSign = if (altitudeSameDirection) 1 else -1
// Error determination.
@@ -141,14 +139,14 @@ internal data class PolarErrorDetermination(
return doubleArrayOf(currentAzimuthError, currentAltitudeError)
}
- fun destinationCoordinates(azimuth: Angle, altitude: Angle, time: InstantOfTime = UTC.now(), compensateRefraction: Boolean = false): DoubleArray {
+ fun destinationCoordinates(azimuth: Angle, altitude: Angle, time: InstantOfTime = UTC.now()): DoubleArray {
val (_, _, _, rightAscension, declination) = initialReferenceFrame
- val position = Position(rightAscension, declination, longitude, latitude, time, compensateRefraction)
+ val position = Position(rightAscension, declination, longitude, latitude, time)
// First rotate by azimuth, then from the point at azimuth rotate further by altitude to get to the final position
val azDest = Vector3D.rotateByRodrigues(position.vector, Vector3D.Z, azimuth)
val rotatedAltAxis = Vector3D.rotateByRodrigues(Vector3D.Y, Vector3D.Z, azimuth)
val finalDest = Vector3D.rotateByRodrigues(azDest, rotatedAltAxis, altitude) // Combination of first az then applied alt.
- return Position(finalDest, longitude, latitude).topocentric.transform(time, compensateRefraction)
+ return Position(finalDest, longitude, latitude).topocentric.transform(time)
}
companion object {
diff --git a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Position.kt b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Position.kt
index 246f2e359..e8458fb94 100644
--- a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Position.kt
+++ b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Position.kt
@@ -11,6 +11,8 @@ import nebulosa.time.InstantOfTime
import kotlin.math.cos
import kotlin.math.sin
+// https://bitbucket.org/Isbeorn/nina.plugin.polaralignment/src/master/PolarAlignment/TPAPAVM.cs
+
internal data class Position(
@JvmField val topocentric: Topocentric,
@JvmField val vector: Vector3D,
@@ -22,15 +24,11 @@ internal data class Position(
rightAscension: Angle, declination: Angle,
longitude: Angle, latitude: Angle,
time: InstantOfTime,
- compensateRefraction: Boolean = false,
): Position {
// SOFA.CelestialToTopocentric.
val dut1 = IERS.delta(time)
val (xp, yp) = IERS.pmAngles(time)
- val pressure = if (compensateRefraction) ONE_ATM else 0.0
- // @formatter:off
- val (b) = eraAtco13(rightAscension, declination, 0.0, 0.0, 0.0, 0.0, time.utc.whole, time.utc.fraction, dut1, longitude, latitude, 0.0, xp, yp, pressure, 15.0, 0.5, 0.55)
- // @formatter:on
+ val (b) = eraAtco13(rightAscension, declination, 0.0, 0.0, 0.0, 0.0, time.utc.whole, time.utc.fraction, dut1, longitude, latitude, 0.0, xp, yp, ONE_ATM, 15.0, 0.5, 0.55)
val topocentric = Topocentric(b[0], PIOVERTWO - b[1], longitude, latitude)
// val vector = CartesianCoordinate.of(-b[0], b[1], 1.0)
val theta = -topocentric.azimuth
diff --git a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt
index c7b3550a3..ab948cbc5 100644
--- a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt
+++ b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/ThreePointPolarAlignment.kt
@@ -9,6 +9,9 @@ import nebulosa.platesolver.PlateSolverException
import nebulosa.time.UTC
import nebulosa.util.Resettable
import java.nio.file.Path
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.tan
/**
* Three Point Polar Alignment almost anywhere in the sky.
@@ -52,7 +55,6 @@ data class ThreePointPolarAlignment(
fun align(
path: Path,
rightAscension: Angle, declination: Angle, radius: Angle = DEFAULT_RADIUS,
- compensateRefraction: Boolean = false,
): ThreePointPolarAlignmentResult {
val solution = try {
solver.solve(path, null, rightAscension, declination, radius)
@@ -69,14 +71,13 @@ data class ThreePointPolarAlignment(
when (state) {
State.CONTINUOUS_SOLVE -> {
- val (azimuth, altitude) = polarErrorDetermination
- .update(time, initialAzimuthError, initialAltitudeError, solution, compensateRefraction)
+ val (azimuth, altitude) = polarErrorDetermination.update(time, initialAzimuthError, initialAltitudeError, solution)
currentAzimuthError = azimuth
currentAltitudeError = altitude
return Measured(solution.rightAscension, solution.declination, azimuth, altitude)
}
State.THIRD_POSITION -> {
- val position = solution.position(time, compensateRefraction)
+ val position = solution.position(time)
polarErrorDetermination = PolarErrorDetermination(solution, firstPosition, secondPosition, position, longitude, latitude)
val (azimuth, altitude) = polarErrorDetermination.compute()
state = State.CONTINUOUS_SOLVE
@@ -85,11 +86,11 @@ data class ThreePointPolarAlignment(
return Measured(solution.rightAscension, solution.declination, azimuth, altitude)
}
State.SECOND_POSITION -> {
- secondPosition = solution.position(time, compensateRefraction)
+ secondPosition = solution.position(time)
state = State.THIRD_POSITION
}
State.FIRST_POSITION -> {
- firstPosition = solution.position(time, compensateRefraction)
+ firstPosition = solution.position(time)
state = State.SECOND_POSITION
}
}
@@ -102,12 +103,44 @@ data class ThreePointPolarAlignment(
state = State.FIRST_POSITION
}
- private fun PlateSolution.position(time: UTC, compensateRefraction: Boolean): Position {
- return Position(rightAscension, declination, longitude, latitude, time, compensateRefraction)
+ private fun PlateSolution.position(time: UTC): Position {
+ return Position(rightAscension, declination, longitude, latitude, time)
}
companion object {
const val DEFAULT_RADIUS: Angle = 5 * DEG2RAD
+
+ /**
+ * Returns the RA/DEC polar alignment error in radians, given
+ * the [hourAngle] and [declination] of current target,
+ * the [latitude] of current observation site and
+ * the [azimuthError], [altitudeError] alignment errors.
+ */
+ fun computePAE(
+ hourAngle: Angle, declination: Angle, latitude: Angle,
+ azimuthError: Angle, altitudeError: Angle
+ ): DoubleArray {
+ // Source: https://sourceforge.net/p/sky-simulator/code/ci/default/tree/sky_annotation.pas
+ // Polar error calculation based on two celestial reference points and the error of the telescope mount at these point(s).
+ // Based on formulas from Ralph Pass documented at https://rppass.com/align.pdf.
+ // They are based on the book “Telescope Control’ by Trueblood and Genet, p.111
+ // Ralph added sin(latitude) term in the equation for the error in RA.
+
+ // For one reference image the difference in RA and DEC caused by the misalignment of the polar axis, formula (3):
+ // delta_ra:= de * TAN(dec)*SIN(h) + da * (sin(lat)- COS(lat)*(TAN(dec1)*COS(h_1))
+ // delta_dec:=de * COS(h) + da * COS(lat)*SIN(h))}
+ // raJnow0:=raJnow0-dRa;
+ // decJnow0:=decJnow0+dDec;
+
+ val cosHA = cos(hourAngle)
+ val sinHA = sin(hourAngle)
+ val tanDEC = tan(declination)
+ val cosLat = cos(latitude)
+ val sinLat = sin(latitude)
+ val dRA = altitudeError * tanDEC * sinHA + azimuthError * (sinLat - cosLat * tanDEC * cosHA)
+ val dDEC = -altitudeError * cosHA + azimuthError * cosLat * sinHA
+ return doubleArrayOf(dRA, dDEC)
+ }
}
}
diff --git a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Topocentric.kt b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Topocentric.kt
index 5d753983c..95cbdf1ef 100644
--- a/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Topocentric.kt
+++ b/nebulosa-alignment/src/main/kotlin/nebulosa/alignment/polar/point/three/Topocentric.kt
@@ -13,12 +13,11 @@ data class Topocentric(
@JvmField val longitude: Angle, @JvmField val latitude: Angle,
) {
- fun transform(time: InstantOfTime = UTC.now(), compensateRefraction: Boolean = false): DoubleArray {
+ fun transform(time: InstantOfTime = UTC.now()): DoubleArray {
val dut1 = IERS.delta(time)
val (xp, yp) = IERS.pmAngles(time)
- val pressure = if (compensateRefraction) ONE_ATM else 0.0
val zd = PIOVERTWO - altitude // zenith distance
- return eraAtoc13('A', azimuth, zd, time.utc.whole, time.utc.fraction, dut1, longitude, latitude, 0.0, xp, yp, pressure, 15.0, 0.5, 0.55)
+ return eraAtoc13('A', azimuth, zd, time.utc.whole, time.utc.fraction, dut1, longitude, latitude, 0.0, xp, yp, ONE_ATM, 15.0, 0.5, 0.55)
}
}
diff --git a/nebulosa-alignment/src/test/kotlin/ThreePointPolarAlignmentTest.kt b/nebulosa-alignment/src/test/kotlin/ThreePointPolarAlignmentTest.kt
index deed0bab5..708fca853 100644
--- a/nebulosa-alignment/src/test/kotlin/ThreePointPolarAlignmentTest.kt
+++ b/nebulosa-alignment/src/test/kotlin/ThreePointPolarAlignmentTest.kt
@@ -1,30 +1,29 @@
import io.kotest.matchers.doubles.plusOrMinus
-import io.kotest.matchers.doubles.shouldBeExactly
import io.kotest.matchers.shouldBe
import nebulosa.alignment.polar.point.three.PolarErrorDetermination
import nebulosa.alignment.polar.point.three.PolarErrorDetermination.Companion.stenographicProjection
import nebulosa.alignment.polar.point.three.Position
-import nebulosa.math.arcsec
-import nebulosa.math.deg
-import nebulosa.math.hours
-import nebulosa.math.toArcsec
+import nebulosa.alignment.polar.point.three.ThreePointPolarAlignment
+import nebulosa.erfa.SphericalCoordinate
+import nebulosa.math.*
+import nebulosa.nova.position.Geoid
+import nebulosa.nova.position.ICRF
import nebulosa.platesolver.PlateSolution
import nebulosa.time.TimeYMDHMS
import nebulosa.time.UTC
+import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test
+import kotlin.random.Random
class ThreePointPolarAlignmentTest {
- // Based on logs generated by N.I.N.A. using Telescope Simulator for .NET and Sky Simulator (ASCOM).
- // https://sourceforge.net/projects/sky-simulator/
-
@Test
fun position() {
val a = Position("04:14:08".hours, "-05 26 10".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 59, 13.3739)))
val b = Position(a.vector, LNG, SLAT)
- a.topocentric.azimuth shouldBeExactly b.topocentric.azimuth
- a.topocentric.altitude shouldBeExactly b.topocentric.altitude
+ a.topocentric.azimuth shouldBe (b.topocentric.azimuth plusOrMinus 1e-14)
+ a.topocentric.altitude shouldBe (b.topocentric.altitude plusOrMinus 1e-14)
}
@Test
@@ -37,64 +36,197 @@ class ThreePointPolarAlignmentTest {
@Test
fun destinationCoordinates() {
- val position1 = Position("05:35:18".hours, "-05 23 26".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 58, 42.4979)))
- val position2 = Position("04:54:45".hours, "-05 24 50".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 58, 58.1655)))
- val position3 = Position("04:14:08".hours, "-05 26 10".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 59, 13.3739)))
- val initialFrame = PlateSolution(true, 0.0, 1.0.arcsec, "04:14:08".hours, "-05 26 10".deg, 1280.0, 1024.0)
+ val now = UTC(TimeYMDHMS(2024, 2, 10, 22, 58, 42.4979))
+ val position1 = Position("05 35 18".hours, "-05 23 26".deg, LNG, SLAT, now)
+ val position2 = Position("04 54 45".hours, "-05 24 50".deg, LNG, SLAT, now)
+ val position3 = Position("04 14 08".hours, "-05 26 10".deg, LNG, SLAT, now)
+ val initialFrame = PlateSolution(true, 0.0, 1.0.arcsec, "04 14 08".hours, "-05 26 10".deg, 1280.0, 1024.0)
val pe = PolarErrorDetermination(initialFrame, position1, position2, position3, LNG, SLAT)
- with(pe.destinationCoordinates(0.0, 0.0)) {
- this[0] shouldBe ("04:14:08".hours plusOrMinus 1e-14)
- this[1] shouldBe ("-05 26 10".deg plusOrMinus 1e-14)
+ with(pe.destinationCoordinates(0.0, 0.0, now)) {
+ this[0] shouldBe ("04 14 08".hours plusOrMinus 1e-11)
+ this[1] shouldBe ("-05 26 10".deg plusOrMinus 1e-11)
}
}
@Test
fun perfectlyAligned() {
- val position1 = Position("05:35:18".hours, "-05 23 26".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 58, 42.4979)))
- val position2 = Position("04:54:45".hours, "-05 24 50".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 58, 58.1655)))
- val position3 = Position("04:14:08".hours, "-05 26 10".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 10, 22, 59, 13.3739)))
- val initialFrame = PlateSolution(true, 0.0, 1.0.arcsec, "04:14:08".hours, "-05 26 10".deg, 1280.0, 1024.0)
- val pe = PolarErrorDetermination(initialFrame, position1, position2, position3, LNG, SLAT)
- val (az, alt) = pe.compute()
-
- // Calculated Error: Az: -00° 00' 04", Alt: -00° 00' 07", Tot: 00° 00' 08"
- az.toArcsec shouldBe (-4.0 plusOrMinus 2.5)
- alt.toArcsec shouldBe (-7.0 plusOrMinus 2.5)
+ with(computePAE(LNG, SLAT, 0.arcmin, 0.arcmin).first) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (0.0 plusOrMinus 30.0) // refraction error
+ }
}
@Test
fun badSouthernPolarAligned() {
- val position1 = Position("05:35:29".hours, "-05 23 44".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 11, 1, 2, 28.0693)))
- val position2 = Position("04:54:48".hours, "-05 23 16".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 11, 1, 2, 43.0120)))
- val position3 = Position("04:14:05".hours, "-05 22 47".deg, LNG, SLAT, UTC(TimeYMDHMS(2024, 2, 11, 1, 2, 57.8800)))
- val initialFrame = PlateSolution(true, 0.0, 1.0.arcsec, "04:14:05".hours, "-05 22 47".deg, 1280.0, 1024.0)
- val pe = PolarErrorDetermination(initialFrame, position1, position2, position3, LNG, SLAT)
- val (az, alt) = pe.compute()
+ with(computePAE(LNG, SLAT, 8.arcmin, 8.arcmin).first) {
+ this[0].toArcsec shouldBe (480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, SLAT, (-8).arcmin, 8.arcmin).first) {
+ this[0].toArcsec shouldBe (-480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, SLAT, (-8).arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (-480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, SLAT, 8.arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, SLAT, 8.arcmin, 0.arcmin).first) {
+ this[0].toArcsec shouldBe (480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (0.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, SLAT, (-8).arcmin, 0.arcmin).first) {
+ this[0].toArcsec shouldBe (-480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (0.0 plusOrMinus 30.0)
+ }
- // Calculated Error: Az: 00° 10' 10", Alt: 00° 04' 41", Tot: 00° 11' 11"
- az.toArcsec shouldBe (610.0 plusOrMinus 7.0)
- alt.toArcsec shouldBe (281.0 plusOrMinus 7.0)
+ with(computePAE(LNG, SLAT, 0.arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, SLAT, 0.arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
}
@Test
fun badNorthernPolarAligned() {
- val position1 = Position("05:35:35".hours, "-05 32 31".deg, LNG, NLAT, UTC(TimeYMDHMS(2024, 2, 11, 1, 19, 31.1390)))
- val position2 = Position("04:54:49".hours, "-05 34 43".deg, LNG, NLAT, UTC(TimeYMDHMS(2024, 2, 11, 1, 19, 46.2383)))
- val position3 = Position("04:13:55".hours, "-05 36 32".deg, LNG, NLAT, UTC(TimeYMDHMS(2024, 2, 11, 1, 20, 1.6394)))
- val initialFrame = PlateSolution(true, 0.0, 1.0.arcsec, "04:13:55".hours, "-05 36 32".deg, 1280.0, 1024.0)
- val pe = PolarErrorDetermination(initialFrame, position1, position2, position3, LNG, NLAT)
- val (az, alt) = pe.compute()
-
- // Calculated Error: Az: -00° 09' 58", Alt: 00° 04' 51", Tot: 00° 11' 05"
- az.toArcsec shouldBe (-598.0 plusOrMinus 7.0)
- alt.toArcsec shouldBe (291.0 plusOrMinus 7.0)
+ with(computePAE(LNG, NLAT, 8.arcmin, 8.arcmin).first) {
+ this[0].toArcsec shouldBe (480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, (-8).arcmin, 8.arcmin).first) {
+ this[0].toArcsec shouldBe (-480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, (-8).arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (-480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, 8.arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, 8.arcmin, 0.arcmin).first) {
+ this[0].toArcsec shouldBe (480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (0.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, (-8).arcmin, 0.arcmin).first) {
+ this[0].toArcsec shouldBe (-480.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (0.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, 0.arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ with(computePAE(LNG, NLAT, 0.arcmin, (-8).arcmin).first) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+ }
+
+ @Test
+ fun tooBadPolarAlignment() {
+ with(computePAE(LNG, SLAT, 1.0.deg, 1.0.deg).first) {
+ this[0].toArcsec shouldBe (3600.0 plusOrMinus 30.0)
+ this[1].toArcsec shouldBe (3600.0 plusOrMinus 90.0)
+ }
+ }
+
+ @Test
+ @Disabled
+ fun updateWithoutSeeing() {
+ val (pae, ped) = computePAE(LNG, NLAT, 0.arcmin, (-8).arcmin)
+
+ with(pae) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ val rightAscension = ped.currentReferenceFrame.rightAscension
+ val declination = ped.currentReferenceFrame.declination
+ val referenceFrame = PlateSolution(true, 0.0, 1.0.arcsec, rightAscension, declination, 1280.0, 1024.0)
+
+ repeat(500) {
+ with(ped.update(PAE_TIME, pae[0], pae[1], referenceFrame)) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+ }
+ }
+
+ @Test
+ @Disabled
+ fun updateWithSeeing() {
+ val (pae, ped) = computePAE(LNG, NLAT, 0.arcmin, (-8).arcmin)
+
+ with(pae) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 6.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 30.0)
+ }
+
+ val currentReferenceFrame = ped.currentReferenceFrame
+ val (initialAzimuthError, initialAltitudeError) = pae
+
+ repeat(500) {
+ val seeing = Random.nextDouble(-1.0, 1.0).arcsec
+ val rightAscension = currentReferenceFrame.rightAscension + seeing
+ val declination = currentReferenceFrame.declination + seeing
+ val referenceFrame = PlateSolution(true, 0.0, 1.0.arcsec, rightAscension, declination, 1280.0, 1024.0)
+
+ with(ped.update(PAE_TIME, initialAzimuthError, initialAltitudeError, referenceFrame)) {
+ this[0].toArcsec shouldBe (0.0 plusOrMinus 65.0)
+ this[1].toArcsec shouldBe (-480.0 plusOrMinus 65.0)
+ }
+ }
}
companion object {
- @JvmStatic private val SLAT = "-023".deg
- @JvmStatic private val NLAT = "+023".deg
- @JvmStatic private val LNG = "-045".deg
+ private val SLAT = (-22.0).deg
+ private val NLAT = 22.0.deg
+ private val LNG = (-45.5).deg
+
+ private val PAE_TIME = UTC(TimeYMDHMS(2024, 10, 20, 12, 0, 0.0))
+
+ private fun computePAE(longitude: Angle, latitude: Angle, azimuthError: Angle, altitudeError: Angle): Pair {
+ val location = Geoid.IERS2010.lonLat(longitude, latitude)
+ val rightAscension = location.lstAt(PAE_TIME) // zenith
+ val declination = latitude
+
+ fun computePosition(raOffset: Angle): Pair {
+ val (dRA, dDEC) = ThreePointPolarAlignment.computePAE(-raOffset, declination, latitude, azimuthError, altitudeError)
+ val solver = ICRF.equatorial(rightAscension + raOffset + dRA, declination + dDEC, time = PAE_TIME, epoch = PAE_TIME, center = location).equatorial()
+ val position = Position(solver.longitude, solver.latitude, longitude, latitude, PAE_TIME)
+ return position to solver
+ }
+
+ val (position1) = computePosition((-1.0).hours)
+ val (position2) = computePosition(0.0.hours)
+ val (position3, solver3) = computePosition(1.0.hours)
+
+ val initialFrame = PlateSolution(true, 0.0, 1.0.arcsec, solver3.longitude, solver3.latitude, 1280.0, 1024.0)
+ val pe = PolarErrorDetermination(initialFrame, position1, position2, position3, longitude, latitude)
+
+ return pe.compute() to pe
+ }
}
}
diff --git a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
index 093de41be..5f94fcb5b 100644
--- a/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
+++ b/nebulosa-alpaca-indi/src/main/kotlin/nebulosa/alpaca/indi/device/cameras/ASCOMCamera.kt
@@ -17,6 +17,7 @@ import nebulosa.indi.device.filterwheel.FilterWheel
import nebulosa.indi.device.focuser.Focuser
import nebulosa.indi.device.guider.GuideOutputPulsingChanged
import nebulosa.indi.device.mount.Mount
+import nebulosa.indi.device.rotator.Rotator
import nebulosa.indi.protocol.INDIProtocol
import nebulosa.indi.protocol.PropertyState
import nebulosa.log.d
@@ -26,6 +27,7 @@ import nebulosa.log.loggerFor
import nebulosa.math.AngleFormatter
import nebulosa.math.format
import nebulosa.math.normalized
+import nebulosa.math.toDegrees
import nebulosa.nova.position.Geoid
import nebulosa.nova.position.ICRF
import nebulosa.time.CurrentTime
@@ -678,6 +680,9 @@ data class ASCOMCamera(
header.add(FitsKeyword.OBJCTDEC, raDec.latitude.format(DEC_FORMAT))
header.add(FitsKeyword.RA, raDec.longitude.normalized.format(RA_FORMAT))
header.add(FitsKeyword.DEC, raDec.latitude.format(DEC_FORMAT))
+ val altAz = icrf.horizontal()
+ header.add(FitsKeyword.OBJCTAZ, altAz.longitude.toDegrees)
+ header.add(FitsKeyword.OBJCTALT, altAz.latitude.toDegrees)
// header.add(FitsKeyword.PIERSIDE, it.pierSide.name)
header.add(FitsKeyword.EQUINOX, 2000)
}
@@ -694,6 +699,12 @@ data class ASCOMCamera(
header.add(FitsKeyword.FILTER, it.names.getOrNull(it.position) ?: "Filter #${it.position}")
}
+ val rotator = snoopedDevices.firstOrNull { it is Rotator } as? Rotator
+
+ rotator?.also {
+ header.add(FitsKeyword.ROTATANG, rotator.angle.toDegrees)
+ }
+
fitsKeywords.forEach(header::add)
val hdu = BasicImageHdu(width, height, numberOfChannels, header, data)
diff --git a/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt b/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt
index 1f55cd377..0387c9361 100644
--- a/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt
+++ b/nebulosa-astap/src/main/kotlin/nebulosa/astap/platesolver/AstapPlateSolver.kt
@@ -1,9 +1,11 @@
package nebulosa.astap.platesolver
+import nebulosa.commandline.CommandLine
import nebulosa.fits.FitsHeader
import nebulosa.fits.FitsKeyword
import nebulosa.image.Image
import nebulosa.log.di
+import nebulosa.log.e
import nebulosa.log.i
import nebulosa.log.loggerFor
import nebulosa.math.Angle
@@ -13,15 +15,13 @@ import nebulosa.math.toHours
import nebulosa.platesolver.PlateSolution
import nebulosa.platesolver.PlateSolver
import nebulosa.platesolver.PlateSolverException
-import org.apache.commons.exec.CommandLine
-import org.apache.commons.exec.DefaultExecutor
-import org.apache.commons.exec.ExecuteWatchdog
import java.nio.file.Files
import java.nio.file.Path
-import java.nio.file.Paths
import java.time.Duration
import java.util.*
-import kotlin.io.path.deleteRecursively
+import java.util.concurrent.TimeUnit
+import kotlin.io.path.deleteIfExists
+import kotlin.io.path.exists
import kotlin.io.path.inputStream
import kotlin.math.ceil
@@ -37,40 +37,44 @@ data class AstapPlateSolver(private val executablePath: Path) : PlateSolver {
): PlateSolution {
requireNotNull(path) { "path is required" }
- val basePath = Files.createTempDirectory("astap")
- val baseName = UUID.randomUUID().toString()
- val outFile = Paths.get("$basePath", baseName)
+ val outFile = Files.createTempFile("astap-", ".ini")
- val commandline = CommandLine.parse("$executablePath")
- .addArgument("-o").addArgument("$outFile")
- .addArgument("-z").addArgument("$downsampleFactor")
- .addArgument("-fov").addArgument("0") // auto
+ val commands = mutableListOf(
+ "$executablePath",
+ "-o", "$outFile",
+ "-z", "$downsampleFactor",
+ "-fov", "0", // auto
+ )
if (radius.toDegrees >= 0.1 && centerRA.isFinite() && centerDEC.isFinite()) {
- commandline.addArgument("-ra").addArgument("${centerRA.toHours}")
- commandline.addArgument("-spd").addArgument("${centerDEC.toDegrees + 90.0}")
- commandline.addArgument("-r").addArgument("${ceil(radius.toDegrees)}")
+ commands.add("-ra")
+ commands.add("${centerRA.toHours}")
+ commands.add("-spd")
+ commands.add("${centerDEC.toDegrees + 90.0}")
+ commands.add("-r")
+ commands.add("${ceil(radius.toDegrees)}")
} else {
- commandline.addArgument("-r").addArgument("180.0")
+ commands.add("-r")
+ commands.add("180.0")
}
- commandline.addArgument("-f").addArgument("$path")
+ commands.add("-f")
+ commands.add("$path")
- LOG.di("astap solving. command={}", commandline)
-
- val executor = DefaultExecutor.builder()
- .setWorkingDirectory(path.parent.toFile())
- .get()
+ val commandLine = CommandLine(commands, path.parent)
try {
- executor.watchdog = ExecuteWatchdog.builder()
- .setTimeout(timeout.takeIf { it.toSeconds() > 0 } ?: Duration.ofMinutes(5))
- .get()
+ val result = commandLine.execute(timeout = if (timeout.toSeconds() > 0) timeout.toSeconds() else 5 * 60L, unit = TimeUnit.SECONDS)
- LOG.di("astap exited. code={}", executor.execute(commandline))
+ if (result.isSuccess) {
+ LOG.di("astap exited. code={}", result.exitCode)
+ } else {
+ LOG.e("astap failed. code={}", result.exitCode, result.exception)
+ throw PlateSolverException(result.exitCode.messageFromExitCode())
+ }
val ini = Properties()
- Paths.get("$basePath", "$baseName.ini").inputStream().use(ini::load)
+ outFile.takeIf { it.exists() }?.inputStream()?.use(ini::load)
val solved = ini.getProperty("PLTSOLVD").trim() == "T"
@@ -125,12 +129,22 @@ data class AstapPlateSolver(private val executablePath: Path) : PlateSolver {
throw PlateSolverException(message)
}
} finally {
- basePath.deleteRecursively()
+ outFile.deleteIfExists()
}
}
companion object {
@JvmStatic private val LOG = loggerFor()
+
+ private fun Int.messageFromExitCode() = when (this) {
+ 1 -> "no solution found"
+ 2 -> "not enough stars detected"
+ 16 -> "error reading image file"
+ 32 -> "no star database found"
+ 33 -> "error reading star database"
+ 34 -> "error updating input file"
+ else -> "plate solving failed"
+ }
}
}
diff --git a/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt b/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
index 842e28b54..2da26b000 100644
--- a/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
+++ b/nebulosa-astap/src/main/kotlin/nebulosa/astap/stardetector/AstapStarDetector.kt
@@ -2,13 +2,12 @@ package nebulosa.astap.stardetector
import de.siegmar.fastcsv.reader.CommentStrategy
import de.siegmar.fastcsv.reader.CsvReader
-import nebulosa.log.d
+import nebulosa.commandline.CommandLine
+import nebulosa.log.di
import nebulosa.log.e
import nebulosa.log.loggerFor
import nebulosa.stardetector.StarDetector
import nebulosa.stardetector.StarPoint
-import org.apache.commons.exec.CommandLine
-import org.apache.commons.exec.DefaultExecutor
import java.io.InputStreamReader
import java.nio.file.Path
import kotlin.io.path.deleteIfExists
@@ -30,19 +29,20 @@ data class AstapStarDetector(
) : StarPoint
override fun detect(input: Path): List {
- val commandline = CommandLine.parse("$executablePath")
- .addArgument("-f").addArgument("$input")
- .addArgument("-z").addArgument("0")
- .addArgument("-extract").addArgument("$minSNR")
+ val commands = mutableListOf(
+ "$executablePath",
+ "-f", "$input",
+ "-z", "0",
+ "-extract", "$minSNR"
+ )
- try {
- val executor = DefaultExecutor.builder()
- .setWorkingDirectory(input.parent.toFile())
- .get()
+ val commandline = CommandLine(commands, input.parent)
+ val result = commandline.execute()
- LOG.d("astap exited. code={}", executor.execute(commandline))
- } catch (e: Throwable) {
- LOG.e("astap failed", e)
+ if (result.isSuccess) {
+ LOG.di("astap exited. code={}", result.exitCode)
+ } else {
+ LOG.e("astap failed. code={}", result.exitCode)
return emptyList()
}
diff --git a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt
index 387f44202..0b648c210 100644
--- a/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt
+++ b/nebulosa-astrometrynet/src/main/kotlin/nebulosa/astrometrynet/platesolver/LocalAstrometryNetPlateSolver.kt
@@ -1,16 +1,15 @@
package nebulosa.astrometrynet.platesolver
+import nebulosa.commandline.CommandLine
+import nebulosa.commandline.CommandLineHandler
import nebulosa.commandline.CommandLineListener
-import nebulosa.commandline.CommandLineListenerHandler
import nebulosa.image.Image
import nebulosa.log.di
+import nebulosa.log.e
import nebulosa.log.loggerFor
import nebulosa.math.*
import nebulosa.platesolver.PlateSolution
import nebulosa.platesolver.PlateSolver
-import org.apache.commons.exec.CommandLine
-import org.apache.commons.exec.DefaultExecutor
-import org.apache.commons.exec.ExecuteWatchdog
import java.nio.file.Files
import java.nio.file.Path
import java.time.Duration
@@ -32,43 +31,47 @@ data class LocalAstrometryNetPlateSolver(private val executablePath: Path) : Pla
val outFolder = Files.createTempDirectory("localplatesolver")
- val commandLine = CommandLine.parse("$executablePath")
- .addArgument("--out").addArgument(UUID.randomUUID().toString())
- .addArgument("--overwrite")
- .addArgument("--dir").addArgument("$outFolder")
- .addArgument("--cpulimit").addArgument(timeout.takeIf { it.toSeconds() > 0 }?.toSeconds()?.toString() ?: "300")
- .addArgument("--scale-units").addArgument("degwidth")
- .addArgument("--guess-scale")
- .addArgument("--crpix-center")
- .addArgument("--downsample").addArgument("$downsampleFactor")
- .addArgument("--no-verify")
- .addArgument("--no-plots")
- // .addArgument("--resort")
+ val commands = mutableListOf(
+ "$executablePath",
+ "--out", UUID.randomUUID().toString(),
+ "--overwrite",
+ "--dir", "$outFolder",
+ "--cpulimit", timeout.takeIf { it.toSeconds() > 0 }?.toSeconds()?.toString() ?: "300",
+ "--scale-units", "degwidth",
+ "--guess-scale",
+ "--crpix-center",
+ "--downsample", "$downsampleFactor",
+ "--no-verify",
+ "--no-plots",
+ // "--resort"
+ )
if (radius.toDegrees >= 0.1 && centerRA.isFinite() && centerDEC.isFinite()) {
- commandLine.addArgument("--ra").addArgument("${centerRA.toDegrees}")
- .addArgument("--dec").addArgument("${centerDEC.toDegrees}")
- .addArgument("--radius").addArgument("${radius.toDegrees}")
+ commands.add("--ra")
+ commands.add("${centerRA.toDegrees}")
+ commands.add("--dec")
+ commands.add("${centerDEC.toDegrees}")
+ commands.add("--radius")
+ commands.add("${radius.toDegrees}")
}
- val solution = PlateSolutionLineReader()
- val handler = CommandLineListenerHandler()
-
- val executor = DefaultExecutor.builder()
- .setWorkingDirectory(path.parent.toFile())
- .setExecuteStreamHandler(handler)
- .get()
-
- executor.watchdog = ExecuteWatchdog.builder()
- .setTimeout(timeout.takeIf { it.toSeconds() > 0 } ?: Duration.ofMinutes(5))
- .get()
+ commands.add("$path")
- commandLine.addArgument("$path")
+ val solution = PlateSolutionLineReader()
+ val commandLine = CommandLine(commands, path.parent)
return try {
+ val handler = CommandLineHandler()
handler.registerCommandLineListener(solution)
- LOG.di("astrometry.net exited. code={}", executor.execute(commandLine, handler))
- solution.get()
+ val result = commandLine.execute(handler)
+
+ if (result.isSuccess) {
+ LOG.di("astrometry.net exited. code={}", result.exitCode)
+ solution.get()
+ } else {
+ LOG.e("astrometry.net failed. code={}", result.exitCode, result.exception)
+ PlateSolution.NO_SOLUTION
+ }
} finally {
outFolder.deleteRecursively()
}
diff --git a/nebulosa-commandline/build.gradle.kts b/nebulosa-commandline/build.gradle.kts
index c4b71f106..24ca9524d 100644
--- a/nebulosa-commandline/build.gradle.kts
+++ b/nebulosa-commandline/build.gradle.kts
@@ -4,7 +4,6 @@ plugins {
}
dependencies {
- api(libs.apache.exec)
implementation(project(":nebulosa-log"))
testImplementation(project(":nebulosa-test"))
}
diff --git a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLine.kt b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLine.kt
new file mode 100644
index 000000000..0e099b329
--- /dev/null
+++ b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLine.kt
@@ -0,0 +1,71 @@
+package nebulosa.commandline
+
+import nebulosa.log.di
+import nebulosa.log.loggerFor
+import java.nio.file.Path
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+data class CommandLine(
+ private val commands: Iterable,
+ private val workingDirectory: Path? = null,
+ private val environment: Map = emptyMap(),
+) {
+
+ @Volatile private var process: Process? = null
+
+ fun execute(handler: CommandLineHandler? = null, timeout: Long = 0L, unit: TimeUnit = TimeUnit.MILLISECONDS): CommandLineResult {
+ val commands = commands.filter { !it.isNullOrEmpty() }.toTypedArray()
+
+ with(ProcessBuilder(*commands).directory(workingDirectory?.toFile()).also { it.environment().putAll(environment) }.start()) {
+ LOG.di("executing command: {}. pid={}", commands, pid())
+
+ process = this
+
+ handler?.setProcessErrorStream(errorStream)
+ handler?.setProcessOutputStream(inputStream)
+ handler?.setProcessInputStream(outputStream)
+ handler?.start(this)
+
+ try {
+ if (timeout > 0L) {
+ if (!waitFor(timeout, unit)) {
+ val exception = TimeoutException("the command took more than $timeout $unit to execute")
+ handler?.onProcessFailed(exception)
+ return CommandLineResult(Int.MIN_VALUE, exception)
+ }
+ } else {
+ waitFor()
+ }
+
+ val exitCode = exitValue()
+ handler?.onProcessComplete(exitCode)
+ return CommandLineResult(exitCode, null)
+ } catch (e: Throwable) {
+ if (e is InterruptedException) {
+ Thread.currentThread().interrupt()
+ }
+
+ handler?.onProcessFailed(e)
+
+ if (isAlive) {
+ destroyForcibly()
+ waitFor()
+ }
+
+ return CommandLineResult(exitValue(), e)
+ } finally {
+ handler?.stop()
+
+ if (isAlive) {
+ destroyForcibly()
+ }
+ }
+ }
+ }
+
+ companion object {
+
+ @JvmStatic private val LOG = loggerFor()
+ }
+}
diff --git a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineHandler.kt b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineHandler.kt
new file mode 100644
index 000000000..f2821bb02
--- /dev/null
+++ b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineHandler.kt
@@ -0,0 +1,111 @@
+package nebulosa.commandline
+
+import java.io.BufferedReader
+import java.io.BufferedWriter
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+
+class CommandLineHandler(
+ private val hasError: Boolean = true,
+ private val hasInput: Boolean = true,
+) {
+
+ private val listeners = ConcurrentHashMap.newKeySet(1)
+ private val running = AtomicBoolean()
+
+ @Volatile private var errorStream: BufferedReader? = null
+ @Volatile private var inputStream: BufferedWriter? = null
+ @Volatile private var outputStream: BufferedReader? = null
+ @Volatile private var errorThread: Thread? = null
+ @Volatile private var outputThread: Thread? = null
+ @Volatile private var process: Process? = null
+
+ val isRunning
+ get() = running.get()
+
+ fun registerCommandLineListener(listener: CommandLineListener) {
+ listeners.add(listener)
+ }
+
+ fun unregisterCommandLineListener(listener: CommandLineListener) {
+ listeners.remove(listener)
+ }
+
+ internal fun setProcessErrorStream(stream: InputStream) {
+ errorStream = stream.bufferedReader()
+ }
+
+ internal fun setProcessInputStream(stream: OutputStream) {
+ inputStream = stream.bufferedWriter()
+ }
+
+ internal fun setProcessOutputStream(stream: InputStream) {
+ outputStream = stream.bufferedReader()
+ }
+
+ @Synchronized
+ internal fun start(process: Process) {
+ if (!running.get()) {
+ if (hasError) {
+ errorThread?.interrupt()
+ errorThread = LineReaderThread(errorStream!!, listeners)
+ errorThread!!.start()
+ }
+
+ if (hasInput) {
+ outputThread?.interrupt()
+ outputThread = LineReaderThread(outputStream!!, listeners)
+ outputThread!!.start()
+ }
+
+ val pid = process.pid()
+ listeners.forEach { it.onStarted(pid) }
+ this.process = process
+
+ running.set(true)
+ }
+ }
+
+ internal fun stop() {
+ errorThread?.interrupt()
+ errorThread?.join()
+ errorThread = null
+
+ outputThread?.interrupt()
+ outputThread?.join()
+ outputThread = null
+
+ running.set(false)
+ }
+
+ internal fun onProcessFailed(e: Throwable) {
+ listeners.forEach { it.onExited(-1, e) }
+ }
+
+ internal fun onProcessComplete(exitValue: Int) {
+ listeners.forEach { it.onExited(exitValue, null) }
+ }
+
+ fun write(text: String) {
+ while (!running.get()) {
+ Thread.sleep(100)
+ }
+
+ val stream = inputStream ?: return
+
+ stream.write(text)
+ stream.newLine()
+ stream.flush()
+ }
+
+ fun kill() {
+ val process = process ?: return
+
+ if (process.isAlive) {
+ process.destroyForcibly()
+ process.waitFor()
+ }
+ }
+}
diff --git a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListener.kt b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListener.kt
index c1258cc07..dee979616 100644
--- a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListener.kt
+++ b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListener.kt
@@ -2,7 +2,7 @@ package nebulosa.commandline
interface CommandLineListener {
- fun onStarted() = Unit
+ fun onStarted(pid: Long) = Unit
fun onLineRead(line: String) = Unit
diff --git a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListenerHandler.kt b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListenerHandler.kt
deleted file mode 100644
index f745e2787..000000000
--- a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineListenerHandler.kt
+++ /dev/null
@@ -1,78 +0,0 @@
-package nebulosa.commandline
-
-import org.apache.commons.exec.ExecuteException
-import org.apache.commons.exec.ExecuteResultHandler
-import org.apache.commons.exec.ExecuteStreamHandler
-import java.io.BufferedReader
-import java.io.BufferedWriter
-import java.io.InputStream
-import java.io.OutputStream
-import java.util.concurrent.ConcurrentHashMap
-
-class CommandLineListenerHandler : ExecuteResultHandler, ExecuteStreamHandler {
-
- private val listeners = ConcurrentHashMap.newKeySet(1)
-
- @Volatile private var errorStream: BufferedReader? = null
- @Volatile private var inputStream: BufferedWriter? = null
- @Volatile private var outputStream: BufferedReader? = null
- @Volatile private var errorThread: Thread? = null
- @Volatile private var outputThread: Thread? = null
-
- fun registerCommandLineListener(listener: CommandLineListener) {
- listeners.add(listener)
- }
-
- fun unregisterCommandLineListener(listener: CommandLineListener) {
- listeners.remove(listener)
- }
-
- override fun setProcessErrorStream(stream: InputStream) {
- errorStream = stream.bufferedReader()
- }
-
- override fun setProcessInputStream(stream: OutputStream) {
- inputStream = stream.bufferedWriter()
- }
-
- override fun setProcessOutputStream(stream: InputStream) {
- outputStream = stream.bufferedReader()
- }
-
- override fun start() {
- errorThread?.interrupt()
- errorThread = LineReaderThread(errorStream!!, listeners)
- errorThread!!.start()
-
- outputThread?.interrupt()
- outputThread = LineReaderThread(outputStream!!, listeners)
- outputThread!!.start()
-
- listeners.forEach { it.onStarted() }
- }
-
- override fun stop() {
- errorThread?.interrupt()
- errorThread = null
-
- outputThread?.interrupt()
- outputThread = null
- }
-
- override fun onProcessFailed(e: ExecuteException) {
- listeners.forEach { it.onExited(-1, e) }
- }
-
- override fun onProcessComplete(exitValue: Int) {
- listeners.forEach { it.onExited(exitValue, null) }
- }
-
- @Synchronized
- fun write(text: String) {
- with(inputStream ?: return) {
- write(text)
- newLine()
- flush()
- }
- }
-}
diff --git a/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineResult.kt b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineResult.kt
new file mode 100644
index 000000000..b81bc75de
--- /dev/null
+++ b/nebulosa-commandline/src/main/kotlin/nebulosa/commandline/CommandLineResult.kt
@@ -0,0 +1,13 @@
+package nebulosa.commandline
+
+data class CommandLineResult(
+ @JvmField val exitCode: Int,
+ @JvmField val exception: Throwable?,
+) {
+
+ inline val isSuccess
+ get() = exception == null
+
+ inline val isFailure
+ get() = exception != null
+}
diff --git a/nebulosa-commandline/src/test/kotlin/CommandLineTest.kt b/nebulosa-commandline/src/test/kotlin/CommandLineTest.kt
new file mode 100644
index 000000000..c8767d1a8
--- /dev/null
+++ b/nebulosa-commandline/src/test/kotlin/CommandLineTest.kt
@@ -0,0 +1,111 @@
+import io.kotest.matchers.collections.shouldContainAll
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.ints.shouldBeExactly
+import io.kotest.matchers.longs.shouldBeGreaterThanOrEqual
+import io.kotest.matchers.longs.shouldBeLessThan
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.types.shouldBeInstanceOf
+import nebulosa.commandline.CommandLine
+import nebulosa.commandline.CommandLineHandler
+import nebulosa.commandline.CommandLineListener
+import nebulosa.test.NonGitHubOnly
+import org.junit.jupiter.api.Test
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+import kotlin.concurrent.thread
+import kotlin.io.path.Path
+import kotlin.system.measureTimeMillis
+
+@NonGitHubOnly
+class CommandLineTest {
+
+ @Test
+ fun execute() {
+ val lines = ArrayList()
+ val handler = CommandLineHandler()
+ handler.registerCommandLineListener(object : CommandLineListener {
+
+ override fun onLineRead(line: String) {
+ lines.add(line)
+ }
+ })
+
+ val cmd = CommandLine(listOf("ls"))
+ cmd.execute(handler).exitCode shouldBeExactly 0
+ lines shouldHaveSize 3 shouldContainAll listOf("build", "build.gradle.kts", "src")
+ }
+
+ @Test
+ fun executeWithWorkingDirectory() {
+ val lines = ArrayList()
+ val handler = CommandLineHandler()
+ handler.registerCommandLineListener(object : CommandLineListener {
+
+ override fun onLineRead(line: String) {
+ lines.add(line)
+ }
+ })
+
+ val cmd = CommandLine(listOf("ls"), workingDirectory = Path("../"))
+ cmd.execute(handler).exitCode shouldBeExactly 0
+ lines shouldHaveSize 81 shouldContainAll listOf("README.md")
+ }
+
+ @Test
+ fun executeWithEnvironment() {
+ val lines = ArrayList()
+ val handler = CommandLineHandler()
+ handler.registerCommandLineListener(object : CommandLineListener {
+
+ override fun onLineRead(line: String) {
+ lines.add(line)
+ }
+ })
+
+ val cmd = CommandLine(listOf("/bin/bash", "-c", "echo \$TEST"), environment = mapOf("TEST" to "123456"))
+ cmd.execute(handler).exitCode shouldBeExactly 0
+ lines shouldHaveSize 1 shouldContainAll listOf("123456")
+ }
+
+ @Test
+ fun executeWithTimeout() {
+ var e: Throwable? = null
+ val handler = CommandLineHandler(false, false)
+ handler.registerCommandLineListener(object : CommandLineListener {
+
+ override fun onExited(exitCode: Int, exception: Throwable?) {
+ e = exception
+ }
+ })
+
+ val cmd = CommandLine(listOf("sleep", "5"))
+ cmd.execute(handler, 2, TimeUnit.SECONDS).exception.shouldNotBeNull().shouldBeInstanceOf()
+ e.shouldNotBeNull().shouldBeInstanceOf()
+ }
+
+ @Test
+ fun executeWithWrite() {
+ val lines = ArrayList()
+ val handler = CommandLineHandler()
+ handler.registerCommandLineListener(object : CommandLineListener {
+
+ override fun onLineRead(line: String) {
+ lines.add(line)
+ }
+ })
+
+ val cmd = CommandLine(listOf("/bin/bash", "-c", "read text && echo \$text"))
+ thread { handler.write("1234567890") }
+ cmd.execute(handler).exitCode shouldBeExactly 0
+
+ lines shouldHaveSize 1 shouldContainAll listOf("1234567890")
+ }
+
+ @Test
+ fun kill() {
+ val handler = CommandLineHandler()
+ val cmd = CommandLine(listOf("sleep", "5"))
+ thread { Thread.sleep(1000); handler.kill() }
+ measureTimeMillis { cmd.execute(handler) } shouldBeGreaterThanOrEqual 1000 shouldBeLessThan 5000
+ }
+}
diff --git a/nebulosa-erfa/src/test/kotlin/ErfaTest.kt b/nebulosa-erfa/src/test/kotlin/ErfaTest.kt
index a2201277a..48b809ca4 100644
--- a/nebulosa-erfa/src/test/kotlin/ErfaTest.kt
+++ b/nebulosa-erfa/src/test/kotlin/ErfaTest.kt
@@ -100,10 +100,17 @@ class ErfaTest {
@Test
fun eraP2s() {
- val (theta, phi, r) = eraP2s(100.0.au, (-50.0).au, 25.0.au)
- theta shouldBe (-0.4636476090008061162 plusOrMinus 1e-12)
- phi shouldBe (0.2199879773954594463 plusOrMinus 1e-12)
- r shouldBe (114.5643923738960002 plusOrMinus 1e-9)
+ with(eraP2s(100.0.au, (-50.0).au, 25.0.au)) {
+ theta shouldBe (-0.4636476090008061162 plusOrMinus 1e-12)
+ phi shouldBe (0.2199879773954594463 plusOrMinus 1e-12)
+ distance shouldBe (114.5643923738960002 plusOrMinus 1e-9)
+ }
+
+ with(eraP2s(0.83016799, -0.46250588, -0.31130278)) {
+ theta shouldBe (5.774889651418495 - TAU plusOrMinus 1e-8)
+ phi shouldBe (-0.31656362869021987 plusOrMinus 1e-8)
+ distance shouldBe (1.0 plusOrMinus 1e-8)
+ }
}
@Test
diff --git a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDeviceProtocolHandler.kt b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDeviceProtocolHandler.kt
index b16af722b..3605c3159 100644
--- a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDeviceProtocolHandler.kt
+++ b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/INDIDeviceProtocolHandler.kt
@@ -273,7 +273,7 @@ abstract class INDIDeviceProtocolHandler : AbstractINDIDeviceProvider(), Message
if (device.isEmpty()) {
val text = "[%s]: %s\n".format(message.timestamp, message.message)
fireOnEventReceived(DeviceMessageReceived(null, text))
- } else if (message.name.isNotEmpty()) {
+ } else {
device.forEach { it.handleMessage(message) }
}
@@ -299,6 +299,8 @@ abstract class INDIDeviceProtocolHandler : AbstractINDIDeviceProvider(), Message
}
}
+ LOG.d("message received: {}", message)
+
return
}
}
diff --git a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt
index fb428f4e0..fd3f09a1c 100644
--- a/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt
+++ b/nebulosa-indi-client/src/main/kotlin/nebulosa/indi/client/device/camera/INDICamera.kt
@@ -74,6 +74,7 @@ internal open class INDICamera(
@Volatile final override var hasThermometer = false
@Volatile final override var temperature = 0.0
+ @Suppress("LeakingThis")
private val guideOutput = INDIGuideOutputHandler(this)
final override val canPulseGuide
@@ -86,7 +87,7 @@ internal open class INDICamera(
private set
override fun handleMessage(message: INDIProtocol) {
- val isGuider = message.name[0] == 'G'
+ val isGuider = message.name.isNotEmpty() && message.name[0] == 'G'
val isGuideHead = this is GuideHead
when (message) {
diff --git a/nebulosa-io/src/test/kotlin/RandomAccessFileTest.kt b/nebulosa-io/src/test/kotlin/RandomAccessFileTest.kt
index a516a32f9..aee4dccc2 100644
--- a/nebulosa-io/src/test/kotlin/RandomAccessFileTest.kt
+++ b/nebulosa-io/src/test/kotlin/RandomAccessFileTest.kt
@@ -6,8 +6,8 @@ class RandomAccessFileTest : AbstractSeekableSinkAndSourceTest() {
private val file = tempPath("raf-", ".dat")
- override val sink = file.seekableSink()
- override val source = file.seekableSource()
+ override val sink = file.seekableSink().autoClose()
+ override val source = file.seekableSource().autoClose()
init {
file.writeBytes(ByteArray(8))
diff --git a/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt b/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt
index eb05d3f08..325766aa1 100644
--- a/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt
+++ b/nebulosa-math/src/main/kotlin/nebulosa/math/AngleFormatter.kt
@@ -42,7 +42,7 @@ data class AngleFormatter(
val s1 = if (separators.size > 1) separators[1] else if (!hasSeconds && s0.trim() == ":") "" else s0
val k = if (secondsDecimalPlaces == 0) 1 else 0
val d = if (c >= 59.0) BigDecimal.valueOf(c).setScale(secondsDecimalPlaces, RoundingMode.DOWN).toDouble() else c
- val seconds = if (hasSeconds) secondsFormat.ifBlank { "%0${secondsDecimalPlaces + 3 - k}.${secondsDecimalPlaces}f" }.format(locale, d)
+ val seconds = if (hasSeconds) secondsFormat.ifBlank { "%0${secondsDecimalPlaces + 3 - k}.${secondsDecimalPlaces}f" }.format(locale, abs(d))
else ""
val s2 = if (separators.size > 2) separators[2] else ""
val format0 = if (isHours) hoursFormat else degreesFormat
diff --git a/nebulosa-nova/src/main/kotlin/nebulosa/nova/position/ICRF.kt b/nebulosa-nova/src/main/kotlin/nebulosa/nova/position/ICRF.kt
index 093948fea..3f19fe470 100644
--- a/nebulosa-nova/src/main/kotlin/nebulosa/nova/position/ICRF.kt
+++ b/nebulosa-nova/src/main/kotlin/nebulosa/nova/position/ICRF.kt
@@ -115,7 +115,7 @@ open class ICRF protected constructor(
require(center is GeographicPosition) { "the center must be a GeographicPosition" }
val r = ITRS.rotationAt(time)
- val (sublongitude, dec, distance) = r * position
+ val (sublongitude, dec, distance) = SphericalCoordinate.of(r * position)
val ha = (center.longitude - sublongitude).normalized
@@ -312,7 +312,7 @@ open class ICRF protected constructor(
@JvmStatic
fun equatorial(
rightAscension: Angle, declination: Angle,
- distance: Distance = ONE_GIGAPARSEC,
+ distance: Distance = 1.0.au,
time: InstantOfTime = CurrentTime,
epoch: InstantOfTime? = null,
center: Number = Int.MIN_VALUE,
diff --git a/nebulosa-nova/src/test/kotlin/FixedStarTest.kt b/nebulosa-nova/src/test/kotlin/FixedStarTest.kt
index 4d73846d4..4c929017e 100644
--- a/nebulosa-nova/src/test/kotlin/FixedStarTest.kt
+++ b/nebulosa-nova/src/test/kotlin/FixedStarTest.kt
@@ -5,8 +5,7 @@ import nebulosa.math.*
import nebulosa.nova.astrometry.FixedStar
import nebulosa.nova.astrometry.VSOP87E
import nebulosa.nova.position.Barycentric
-import nebulosa.test.concat
-import nebulosa.test.dataDirectory
+import nebulosa.test.download
import nebulosa.time.IERS
import nebulosa.time.IERSA
import nebulosa.time.TimeYMDHMS
@@ -72,13 +71,13 @@ class FixedStarTest {
companion object {
- @JvmStatic private val IERSA = IERSA()
-
@JvmStatic
@BeforeAll
fun loadIERS() {
- dataDirectory.concat("finals2000A.all").inputStream().use(IERSA::load)
- IERS.attach(IERSA)
+ val iersa = IERSA()
+ val finals2000A = download("https://maia.usno.navy.mil/ser7/finals2000A.all")
+ finals2000A.inputStream().use(iersa::load)
+ IERS.attach(iersa)
}
}
}
diff --git a/nebulosa-nova/src/test/kotlin/GeographicPositionTest.kt b/nebulosa-nova/src/test/kotlin/GeographicPositionTest.kt
index 62d5ddb9b..27b7c2458 100644
--- a/nebulosa-nova/src/test/kotlin/GeographicPositionTest.kt
+++ b/nebulosa-nova/src/test/kotlin/GeographicPositionTest.kt
@@ -4,8 +4,7 @@ import nebulosa.math.deg
import nebulosa.math.formatHMS
import nebulosa.math.m
import nebulosa.nova.position.Geoid
-import nebulosa.test.concat
-import nebulosa.test.dataDirectory
+import nebulosa.test.download
import nebulosa.time.IERS
import nebulosa.time.IERSA
import nebulosa.time.TimeYMDHMS
@@ -41,7 +40,8 @@ class GeographicPositionTest {
@BeforeAll
fun loadIERS() {
val iersa = IERSA()
- dataDirectory.concat("finals2000A.all").inputStream().use(iersa::load)
+ val finals2000A = download("https://maia.usno.navy.mil/ser7/finals2000A.all")
+ finals2000A.inputStream().use(iersa::load)
IERS.attach(iersa)
}
}
diff --git a/nebulosa-nova/src/test/kotlin/ICRFTest.kt b/nebulosa-nova/src/test/kotlin/ICRFTest.kt
index 955b5ece0..41698eb71 100644
--- a/nebulosa-nova/src/test/kotlin/ICRFTest.kt
+++ b/nebulosa-nova/src/test/kotlin/ICRFTest.kt
@@ -3,8 +3,7 @@ import io.kotest.matchers.shouldBe
import nebulosa.math.*
import nebulosa.nova.position.Geoid
import nebulosa.nova.position.ICRF
-import nebulosa.test.concat
-import nebulosa.test.dataDirectory
+import nebulosa.test.download
import nebulosa.time.IERS
import nebulosa.time.IERSA
import nebulosa.time.TT
@@ -52,13 +51,25 @@ class ICRFTest {
azAlt.latitude.toDegrees shouldBe (44.3538 plusOrMinus 1e-1)
}
+ @Test
+ fun hourAngle() {
+ val time = TimeYMDHMS(2024, 10, 20, 12)
+ val site = Geoid.IERS2010.lonLat((-45.0).deg, (-22.0).deg)
+ val icrf = ICRF.equatorial(12.0.hours, (-18.0).deg, time = time, center = site)
+ val (ha, dec, distance) = icrf.hourAngle()
+ ha.toHours shouldBe (24.0 - 1.0584536120036618 plusOrMinus 1e-4)
+ dec.toDegrees shouldBe (-18.137759871296097 plusOrMinus 1e-3)
+ distance shouldBe (1.0 plusOrMinus 1e-4)
+ }
+
companion object {
@JvmStatic
@BeforeAll
fun loadIERS() {
val iersa = IERSA()
- dataDirectory.concat("finals2000A.all").inputStream().use(iersa::load)
+ val finals2000A = download("https://maia.usno.navy.mil/ser7/finals2000A.all")
+ finals2000A.inputStream().use(iersa::load)
IERS.attach(iersa)
}
}
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt
index 95d5ffecd..8a4e32b7b 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/AbstractPixInsightScript.kt
@@ -6,14 +6,11 @@ import nebulosa.json.PathModule
import nebulosa.log.di
import nebulosa.log.loggerFor
import org.apache.commons.codec.binary.Hex
-import org.apache.commons.exec.DefaultExecutor
import java.nio.file.Path
import kotlin.io.path.readText
abstract class AbstractPixInsightScript : PixInsightScript {
- @Volatile private var executor: DefaultExecutor? = null
-
override val name = this::class.simpleName!!
companion object {
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt
index 8ff5b6e8a..a00c53734 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/script/PixInsightScriptRunner.kt
@@ -1,14 +1,12 @@
package nebulosa.pixinsight.script
+import nebulosa.commandline.CommandLine
+import nebulosa.commandline.CommandLineHandler
import nebulosa.commandline.CommandLineListener
-import nebulosa.commandline.CommandLineListenerHandler
import nebulosa.log.d
import nebulosa.log.de
import nebulosa.log.di
import nebulosa.log.loggerFor
-import org.apache.commons.exec.CommandLine
-import org.apache.commons.exec.DefaultExecutor
-import org.apache.commons.exec.ExecuteWatchdog
import java.nio.file.Path
import java.util.concurrent.CancellationException
import java.util.concurrent.CompletableFuture
@@ -16,32 +14,25 @@ import java.util.concurrent.CompletableFuture
data class PixInsightScriptRunner(private val executablePath: Path) {
fun run(script: PixInsightScript): CompletableFuture {
- val commandLine = CommandLine.parse("$executablePath")
- script.arguments.forEach(commandLine::addArgument)
- DEFAULT_ARGS.forEach(commandLine::addArgument)
+ val commands = mutableListOf("$executablePath")
+ script.arguments.forEach(commands::add)
+ DEFAULT_ARGS.forEach(commands::add)
- LOG.d("running {} script: {}", script.name, commandLine)
+ LOG.d("running {} script", script.name)
- val handler = CommandLineListenerHandler()
+ val handler = CommandLineHandler()
+ val commandLine = CommandLine(commands)
val completable = CompletableFuture()
- val executor = DefaultExecutor.builder()
- .setExecuteStreamHandler(handler)
- .get()
-
- executor.watchdog = ExecuteWatchdog.builder()
- .setTimeout(ExecuteWatchdog.INFINITE_TIMEOUT_DURATION)
- .get()
-
completable.whenComplete { o, e ->
- if (e is CancellationException) executor.watchdog.destroyProcess()
+ if (e is CancellationException) handler.kill()
if (o != null) LOG.di("{} completed. output={}", script.name, o)
else LOG.de("{} completed with exception", script.name, e)
}
handler.registerCommandLineListener(object : CommandLineListener {
- override fun onStarted() {
+ override fun onStarted(pid: Long) {
script.processOnStart(completable)
}
@@ -58,7 +49,7 @@ data class PixInsightScriptRunner(private val executablePath: Path) {
}
})
- executor.execute(commandLine, handler)
+ commandLine.execute(handler)
return completable
}
diff --git a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stardetector/PixInsightStarDetector.kt b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stardetector/PixInsightStarDetector.kt
index 0459a5537..8ce6d6164 100644
--- a/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stardetector/PixInsightStarDetector.kt
+++ b/nebulosa-pixinsight/src/main/kotlin/nebulosa/pixinsight/stardetector/PixInsightStarDetector.kt
@@ -1,6 +1,7 @@
package nebulosa.pixinsight.stardetector
import nebulosa.pixinsight.script.PixInsightDetectStars
+import nebulosa.pixinsight.script.PixInsightScript
import nebulosa.pixinsight.script.PixInsightScriptRunner
import nebulosa.stardetector.StarDetector
import nebulosa.stardetector.StarPoint
@@ -9,9 +10,9 @@ import java.time.Duration
data class PixInsightStarDetector(
private val runner: PixInsightScriptRunner,
- private val slot: Int,
private val minSNR: Double = 0.0,
private val timeout: Duration = Duration.ZERO,
+ private val slot: Int = PixInsightScript.UNSPECIFIED_SLOT,
) : StarDetector {
override fun detect(input: Path): List {
diff --git a/nebulosa-pixinsight/src/test/kotlin/PixInsightStarDetectorTest.kt b/nebulosa-pixinsight/src/test/kotlin/PixInsightStarDetectorTest.kt
index 40fb96d0f..bc8cc81ec 100644
--- a/nebulosa-pixinsight/src/test/kotlin/PixInsightStarDetectorTest.kt
+++ b/nebulosa-pixinsight/src/test/kotlin/PixInsightStarDetectorTest.kt
@@ -10,7 +10,7 @@ class PixInsightStarDetectorTest {
@Test
fun detectStars() {
- val detectedStars = PixInsightStarDetector(RUNNER, 0).detect(NGC3344_MONO_8_FITS)
+ val detectedStars = PixInsightStarDetector(RUNNER).detect(NGC3344_MONO_8_FITS)
detectedStars shouldHaveSize 15
}
}
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt
index ef18cc01a..4f5c346c0 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/command/SirilCommandLine.kt
@@ -1,37 +1,24 @@
package nebulosa.siril.command
+import nebulosa.commandline.CommandLine
+import nebulosa.commandline.CommandLineHandler
import nebulosa.commandline.CommandLineListener
-import nebulosa.commandline.CommandLineListenerHandler
import nebulosa.log.di
import nebulosa.log.loggerFor
import nebulosa.util.concurrency.cancellation.CancellationListener
import nebulosa.util.concurrency.cancellation.CancellationSource
-import org.apache.commons.exec.CommandLine
-import org.apache.commons.exec.DefaultExecutor
-import org.apache.commons.exec.ExecuteWatchdog
import java.nio.file.Path
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.atomic.AtomicBoolean
class SirilCommandLine(executablePath: Path) : Runnable, CancellationListener, AutoCloseable {
- private val handler = CommandLineListenerHandler()
-
- private val executor = DefaultExecutor.builder()
- .setExecuteStreamHandler(handler)
- .get()
-
- private val commandLine = CommandLine.parse("$executablePath")
- .addArgument("-s").addArgument("-")
-
- @Volatile private var started = false
-
- init {
- executor.watchdog = ExecuteWatchdog.builder()
- .setTimeout(ExecuteWatchdog.INFINITE_TIMEOUT_DURATION)
- .get()
- }
+ private val handler = CommandLineHandler()
+ private val commandLine = CommandLine(listOf("$executablePath", "-s", "-"))
+ private val started = AtomicBoolean()
val isRunning
- get() = started && executor.watchdog.isWatching
+ get() = started.get()
fun registerCommandLineListener(listener: CommandLineListener) {
handler.registerCommandLineListener(listener)
@@ -42,15 +29,14 @@ class SirilCommandLine(executablePath: Path) : Runnable, CancellationListener, A
}
override fun run() {
- if (!isRunning) {
- started = true
- executor.execute(commandLine, handler)
+ if (started.compareAndSet(false, true)) {
+ CompletableFuture.runAsync { commandLine.execute(handler) }
execute(Requires)
}
}
internal fun write(command: String) {
- if (isRunning) {
+ if (started.get()) {
LOG.di(command)
handler.write(command)
}
@@ -66,10 +52,7 @@ class SirilCommandLine(executablePath: Path) : Runnable, CancellationListener, A
override fun close() {
execute(Exit)
-
- if (isRunning) {
- executor.watchdog.destroyProcess()
- }
+ handler.kill()
}
companion object {
diff --git a/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt b/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt
index 4b8230301..81324bb46 100644
--- a/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt
+++ b/nebulosa-siril/src/main/kotlin/nebulosa/siril/livestacker/SirilLiveStacker.kt
@@ -35,7 +35,7 @@ data class SirilLiveStacker(
@Synchronized
override fun start() {
- if (!commandLine.isRunning) {
+ if (!isRunning) {
commandLine.registerCommandLineListener(this)
commandLine.run()
@@ -53,7 +53,7 @@ data class SirilLiveStacker(
@Synchronized
override fun add(path: Path, referencePath: Path?): Path? {
- if (commandLine.isRunning && commandLine.execute(LiveStack(path))) {
+ if (isRunning && commandLine.execute(LiveStack(path))) {
stackedPath = Path.of("$workingDirectory", "live_stack_00001.fit")
}
diff --git a/nebulosa-test/src/main/kotlin/nebulosa/test/AbstractTest.kt b/nebulosa-test/src/main/kotlin/nebulosa/test/AbstractTest.kt
index de32a5719..0c5211b64 100644
--- a/nebulosa-test/src/main/kotlin/nebulosa/test/AbstractTest.kt
+++ b/nebulosa-test/src/main/kotlin/nebulosa/test/AbstractTest.kt
@@ -13,13 +13,17 @@ abstract class AbstractTest {
private val deletablePaths = ArrayList(2)
@AfterEach
- fun closeResourcesAfterEach() {
+ open fun afterEach() {
+ closeResourcesAfterEach()
+ deletePathsAfterEach()
+ }
+
+ private fun closeResourcesAfterEach() {
autoCloseables.forEach(AutoCloseable::close)
autoCloseables.clear()
}
- @AfterEach
- fun deletePathsAfterEach() {
+ private fun deletePathsAfterEach() {
deletablePaths.forEach { it.deleteRecursivelyOrIfExists() }
deletablePaths.clear()
}
diff --git a/nebulosa-time/src/test/kotlin/IERSTest.kt b/nebulosa-time/src/test/kotlin/IERSTest.kt
index a91e6019e..36f6745c0 100644
--- a/nebulosa-time/src/test/kotlin/IERSTest.kt
+++ b/nebulosa-time/src/test/kotlin/IERSTest.kt
@@ -1,7 +1,6 @@
import io.kotest.matchers.doubles.plusOrMinus
import io.kotest.matchers.shouldBe
-import nebulosa.test.concat
-import nebulosa.test.dataDirectory
+import nebulosa.test.download
import nebulosa.time.*
import org.junit.jupiter.api.Test
import kotlin.io.path.inputStream
@@ -18,7 +17,7 @@ class IERSTest {
}
with(UTC(TimeYMDHMS(2026, 1, 1, 12, 0, 0.0)).ut1) {
whole shouldBe (2461042.0 plusOrMinus 1E-18)
- fraction shouldBe (4.693171296595673e-07 plusOrMinus 1E-18)
+ fraction shouldBe (1.1488645833633137E-6 plusOrMinus 1E-18)
}
with(UTC(TimeYMDHMS(1964, 1, 1, 12, 0, 0.0)).ut1) {
whole shouldBe (2438396.0 plusOrMinus 1E-18)
@@ -36,7 +35,7 @@ class IERSTest {
}
with(UTC(TimeYMDHMS(2026, 1, 1, 12, 0, 0.0)).ut1) {
whole shouldBe (2461042.0 plusOrMinus 1E-18)
- fraction shouldBe (1.442650463262399e-07 plusOrMinus 1E-18)
+ fraction shouldBe (6.586666666966254E-7 plusOrMinus 1E-18)
}
with(UTC(TimeYMDHMS(1964, 1, 1, 12, 0, 0.0)).ut1) {
whole shouldBe (2438396.0 plusOrMinus 1E-18)
@@ -55,7 +54,7 @@ class IERSTest {
}
with(UTC(TimeYMDHMS(2026, 1, 1, 12, 0, 0.0)).ut1) {
whole shouldBe (2461042.0 plusOrMinus 1E-18)
- fraction shouldBe (4.693171296595673e-07 plusOrMinus 1E-18)
+ fraction shouldBe (1.1488645833633137E-6 plusOrMinus 1E-18)
}
with(UTC(TimeYMDHMS(1964, 1, 1, 12, 0, 0.0)).ut1) {
whole shouldBe (2438396.0 plusOrMinus 1E-18)
@@ -69,8 +68,11 @@ class IERSTest {
@JvmStatic private val IERSB = IERSB()
init {
- dataDirectory.concat("finals2000A.all").inputStream().use(IERSA::load)
- dataDirectory.concat("eopc04.1962-now.txt").inputStream().use(IERSB::load)
+ val finals2000A = download("https://maia.usno.navy.mil/ser7/finals2000A.all")
+ val eopc04 = download("https://hpiers.obspm.fr/iers/eop/eopc04/eopc04.1962-now")
+
+ finals2000A.inputStream().use(IERSA::load)
+ eopc04.inputStream().use(IERSB::load)
}
}
}
diff --git a/nebulosa-time/src/test/kotlin/SystemClockTest.kt b/nebulosa-time/src/test/kotlin/SystemClockTest.kt
index d52ad0b4e..3b06cb7dc 100644
--- a/nebulosa-time/src/test/kotlin/SystemClockTest.kt
+++ b/nebulosa-time/src/test/kotlin/SystemClockTest.kt
@@ -11,12 +11,12 @@ class SystemClockTest {
@Test
fun systemDefault() {
- ChronoUnit.MICROS.between(LocalDateTime.now(SystemClock), LocalDateTime.now()) shouldBeLessThanOrEqual 10000L
+ ChronoUnit.MICROS.between(LocalDateTime.now(SystemClock), LocalDateTime.now()) shouldBeLessThanOrEqual 20000L
SystemClock.zone shouldBeSameInstanceAs ZoneId.systemDefault()
TimeZone.setDefault(TimeZone.getTimeZone("America/Manaus"))
- ChronoUnit.MICROS.between(LocalDateTime.now(SystemClock), LocalDateTime.now()) shouldBeLessThanOrEqual 10000L
+ ChronoUnit.MICROS.between(LocalDateTime.now(SystemClock), LocalDateTime.now()) shouldBeLessThanOrEqual 20000L
SystemClock.zone shouldBeSameInstanceAs ZoneId.systemDefault()
}
}
diff --git a/nebulosa-time/src/test/kotlin/TimeTest.kt b/nebulosa-time/src/test/kotlin/TimeTest.kt
index c654c5d15..2f06e13fa 100644
--- a/nebulosa-time/src/test/kotlin/TimeTest.kt
+++ b/nebulosa-time/src/test/kotlin/TimeTest.kt
@@ -2,8 +2,7 @@ import io.kotest.matchers.doubles.plusOrMinus
import io.kotest.matchers.doubles.shouldBeExactly
import io.kotest.matchers.ints.shouldBeExactly
import io.kotest.matchers.shouldBe
-import nebulosa.test.concat
-import nebulosa.test.dataDirectory
+import nebulosa.test.download
import nebulosa.time.*
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Test
@@ -145,7 +144,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
- fraction shouldBe (-0.49999989822685187 plusOrMinus 1E-14)
+ fraction shouldBe (-0.49999989822685187 plusOrMinus 1E-8)
}
with(time.tai) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
@@ -179,7 +178,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24980371005787044 plusOrMinus 1E-14)
+ fraction shouldBe (0.24980371005787044 plusOrMinus 1E-6)
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -277,7 +276,7 @@ class TimeTest {
with(time.utc) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
- fraction shouldBe (0.4999998982268517 plusOrMinus 1E-14)
+ fraction shouldBe (0.4999998982268517 plusOrMinus 1E-8)
}
with(time.ut1) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
@@ -285,23 +284,23 @@ class TimeTest {
}
with(time.tai) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
- fraction shouldBe (-0.4995718610324076 plusOrMinus 1E-14)
+ fraction shouldBe (-0.4995718610324076 plusOrMinus 1E-8)
}
with(time.tt) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
- fraction shouldBe (-0.4991993610324076 plusOrMinus 1E-14)
+ fraction shouldBe (-0.4991993610324076 plusOrMinus 1E-8)
}
with(time.tcg) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
- fraction shouldBe (-0.4991873975486568 plusOrMinus 1E-14)
+ fraction shouldBe (-0.4991873975486568 plusOrMinus 1E-8)
}
with(time.tdb) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
- fraction shouldBe (-0.49919936241219065 plusOrMinus 1E-14)
+ fraction shouldBe (-0.49919936241219065 plusOrMinus 1E-8)
}
with(time.tcb) {
whole shouldBe (2460311.0 plusOrMinus 1E-14)
- fraction shouldBe (-0.49893319941994874 plusOrMinus 1E-14)
+ fraction shouldBe (-0.49893319941994874 plusOrMinus 1E-8)
}
}
@@ -311,7 +310,7 @@ class TimeTest {
with(time.utc) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24980277142361115 plusOrMinus 1E-14)
+ fraction shouldBe (0.24980277142361115 plusOrMinus 1E-6)
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -319,23 +318,23 @@ class TimeTest {
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.25023101216435195 plusOrMinus 1E-14)
+ fraction shouldBe (0.25023101216435195 plusOrMinus 1E-6)
}
with(time.tt) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.25060351216435195 plusOrMinus 1E-14)
+ fraction shouldBe (0.25060351216435195 plusOrMinus 1E-6)
}
with(time.tcg) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.2506159849288422 plusOrMinus 1E-14)
+ fraction shouldBe (0.2506159849288422 plusOrMinus 1E-6)
}
with(time.tdb) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.25060351113353413 plusOrMinus 1E-14)
+ fraction shouldBe (0.25060351113353413 plusOrMinus 1E-6)
}
with(time.tcb) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.2508810045461 plusOrMinus 1E-14)
+ fraction shouldBe (0.2508810045461 plusOrMinus 1E-6)
}
}
@@ -417,7 +416,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
- fraction shouldBe (0.4995718610330666 plusOrMinus 1E-14)
+ fraction shouldBe (0.4995718610330666 plusOrMinus 1E-8)
}
with(time.tai) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
@@ -451,7 +450,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24937546931712967 plusOrMinus 1E-14)
+ fraction shouldBe (0.24937546931712967 plusOrMinus 1E-6)
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -553,7 +552,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
- fraction shouldBe (0.49919936103364004 plusOrMinus 1E-14)
+ fraction shouldBe (0.49919936103364004 plusOrMinus 1E-8)
}
with(time.tai) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
@@ -587,7 +586,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24900296931712967 plusOrMinus 1E-14)
+ fraction shouldBe (0.24900296931712967 plusOrMinus 1E-6)
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -689,7 +688,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
- fraction shouldBe (0.4989331994384845 plusOrMinus 1E-14)
+ fraction shouldBe (0.4989331994384845 plusOrMinus 1E-8)
}
with(time.tai) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
@@ -723,7 +722,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24872547695244512 plusOrMinus 1E-14)
+ fraction shouldBe (0.24872547695244512 plusOrMinus 1E-6)
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -825,7 +824,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
- fraction shouldBe (0.49918739755047403 plusOrMinus 1E-14)
+ fraction shouldBe (0.49918739755047403 plusOrMinus 1E-8)
}
with(time.tai) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
@@ -859,7 +858,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24899049655320588 plusOrMinus 1E-14)
+ fraction shouldBe (0.24899049655320588 plusOrMinus 1E-6)
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -961,7 +960,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
- fraction shouldBe (0.4991993624136878 plusOrMinus 1E-14)
+ fraction shouldBe (0.4991993624136878 plusOrMinus 1E-8)
}
with(time.tai) {
whole shouldBe (2460310.0 plusOrMinus 1E-14)
@@ -995,7 +994,7 @@ class TimeTest {
}
with(time.ut1) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
- fraction shouldBe (0.24900297034820923 plusOrMinus 1E-14)
+ fraction shouldBe (0.24900297034820923 plusOrMinus 1E-6)
}
with(time.tai) {
whole shouldBe (2461041.0 plusOrMinus 1E-14)
@@ -1025,9 +1024,13 @@ class TimeTest {
@BeforeAll
fun loadIERS() {
val iersa = IERSA()
+ val finals2000A = download("https://maia.usno.navy.mil/ser7/finals2000A.all")
+ finals2000A.inputStream().use(iersa::load)
+
val iersb = IERSB()
- dataDirectory.concat("finals2000A.all").inputStream().use(iersa::load)
- dataDirectory.concat("eopc04.1962-now.txt").inputStream().use(iersb::load)
+ val eopc04 = download("https://hpiers.obspm.fr/iers/eop/eopc04/eopc04.1962-now")
+ eopc04.inputStream().use(iersb::load)
+
IERS.attach(IERSAB(iersa, iersb))
}
}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 0805f61a9..b9a953ec9 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -5,7 +5,6 @@ enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
buildCache {
local {
directory = File(rootDir, ".cache")
- removeUnusedEntriesAfterDays = 30
}
}
@@ -32,7 +31,6 @@ dependencyResolutionManagement {
library("apache-collections", "org.apache.commons:commons-collections4:4.4")
library("apache-math", "org.apache.commons:commons-math3:3.6.1")
library("apache-numbers-complex", "org.apache.commons:commons-numbers-complex:1.2")
- library("apache-exec", "org.apache.commons:commons-exec:1.4.0")
library("oshi", "com.github.oshi:oshi-core:6.6.5")
library("jna", "net.java.dev.jna:jna:5.15.0")
library("javalin", "io.javalin:javalin:6.3.0")