[api][desktop]: Remove Stacker

api/src/main/kotlin/nebulosa/api/Nebulosa.kt

@@ -11,7 +11,7 @@ import io.javalin.Javalin
 import io.javalin.http.Context
 import io.javalin.http.HttpStatus.BAD_REQUEST
 import io.javalin.json.JavalinJackson
-import nebulosa.api.converters.modules.DeviceModule
+import nebulosa.api.converters.DeviceModule
 import nebulosa.api.core.ErrorResponse
 import nebulosa.api.inject.*
 import nebulosa.json.PathModule

api/src/main/kotlin/nebulosa/api/cameras/CameraLiveStackingManager.kt

@@ -1,8 +1,8 @@
 package nebulosa.api.cameras
 
 import nebulosa.api.calibration.CalibrationFrameProvider
+import nebulosa.api.image.ImageFilterType
 import nebulosa.api.livestacker.LiveStackingRequest
-import nebulosa.api.stacker.StackerGroupType
 import nebulosa.fits.*
 import nebulosa.image.format.ImageHdu
 import nebulosa.livestacker.LiveStacker
@@ -20,7 +20,7 @@ data class CameraLiveStackingManager(
     private val calibrationFrameProvider: CalibrationFrameProvider? = null,
 ) : AutoCloseable {
 
-    private val liveStackers = EnumMap<StackerGroupType, LiveStacker>(StackerGroupType::class.java)
+    private val liveStackers = EnumMap<ImageFilterType, LiveStacker>(ImageFilterType::class.java)
     private val workingDirectories = HashSet<Path>()
 
     @Volatile private var referencePath: Path? = null
@@ -29,7 +29,7 @@ data class CameraLiveStackingManager(
     fun start(request: CameraStartCaptureRequest, path: Path): Boolean {
         if (request.stackerGroupType in liveStackers) {
             return true
-        } else if (request.stackerGroupType != StackerGroupType.NONE && request.liveStacking.enabled) {
+        } else if (request.stackerGroupType != ImageFilterType.NONE && request.liveStacking.enabled) {
             try {
                 val workingDirectory = Files.createTempDirectory("ls-${request.stackerGroupType}-")
                 workingDirectories.add(workingDirectory)
@@ -50,7 +50,7 @@ data class CameraLiveStackingManager(
 
     @Synchronized
     fun stack(request: CameraStartCaptureRequest, path: Path?): Path? {
-        if (path == null || request.stackerGroupType == StackerGroupType.NONE) return null
+        if (path == null || request.stackerGroupType == ImageFilterType.NONE) return null
 
         val stackerGroupType = request.stackerGroupType
         val liveStacker = liveStackers[stackerGroupType] ?: return null
@@ -65,10 +65,10 @@ data class CameraLiveStackingManager(
             }
 
             val combinedPath = Path.of("${path.parent}", "STACKED.fits")
-            val luminancePath = liveStackers[StackerGroupType.LUMINANCE]?.stackedPath
-            val redPath = liveStackers[StackerGroupType.RED]?.stackedPath
-            val greenPath = liveStackers[StackerGroupType.GREEN]?.stackedPath
-            val bluePath = liveStackers[StackerGroupType.BLUE]?.stackedPath
+            val luminancePath = liveStackers[ImageFilterType.LUMINANCE]?.stackedPath
+            val redPath = liveStackers[ImageFilterType.RED]?.stackedPath
+            val greenPath = liveStackers[ImageFilterType.GREEN]?.stackedPath
+            val bluePath = liveStackers[ImageFilterType.BLUE]?.stackedPath
 
             if (stackerGroupType.isLRGB && (luminancePath != null || redPath != null || greenPath != null || bluePath != null)) {
                 if (stacker.combineLRGB(combinedPath, luminancePath, redPath, greenPath, bluePath)) {
@@ -77,7 +77,7 @@ data class CameraLiveStackingManager(
             } else if (luminancePath != null) {
                 stacker.align(luminancePath, stackedPath, stackedPath)
 
-                if (stacker.combineLuminance(combinedPath, luminancePath, stackedPath, stackerGroupType == StackerGroupType.MONO)) {
+                if (stacker.combineLuminance(combinedPath, luminancePath, stackedPath, stackerGroupType == ImageFilterType.MONO)) {
                     stackedPath = combinedPath
                 }
             }

api/src/main/kotlin/nebulosa/api/cameras/CameraStartCaptureRequest.kt

@@ -2,8 +2,8 @@ package nebulosa.api.cameras
 
 import nebulosa.api.converters.time.DurationUnit
 import nebulosa.api.guiding.DitherAfterExposureRequest
+import nebulosa.api.image.ImageFilterType
 import nebulosa.api.livestacker.LiveStackingRequest
-import nebulosa.api.stacker.StackerGroupType
 import nebulosa.api.validators.*
 import nebulosa.indi.device.camera.FrameType
 import java.nio.file.Path
@@ -35,7 +35,7 @@ data class CameraStartCaptureRequest(
     @JvmField val dither: DitherAfterExposureRequest = DitherAfterExposureRequest.DISABLED,
     // Stacking.
     @JvmField val liveStacking: LiveStackingRequest = LiveStackingRequest.DISABLED,
-    @JvmField val stackerGroupType: StackerGroupType = StackerGroupType.MONO,
+    @JvmField val stackerGroupType: ImageFilterType = ImageFilterType.MONO,
     // Filter Wheel.
     @JvmField val filterPosition: Int = 0,
     @JvmField val shutterPosition: Int = 0,

api/src/main/kotlin/nebulosa/api/converters/modules/DeviceModule.kt → api/src/main/kotlin/nebulosa/api/converters/DeviceModule.kt

@@ -1,4 +1,4 @@
-package nebulosa.api.converters.modules
+package nebulosa.api.converters
 
 import com.fasterxml.jackson.databind.module.SimpleDeserializers
 import com.fasterxml.jackson.databind.module.SimpleModule

api/src/main/kotlin/nebulosa/api/stacker/AnalyzedTarget.kt → api/src/main/kotlin/nebulosa/api/image/ImageAnalyzed.kt

@@ -1,23 +1,23 @@
-package nebulosa.api.stacker
+package nebulosa.api.image
 
 import nebulosa.fits.*
 import nebulosa.image.format.ReadableHeader
 import nebulosa.indi.device.camera.FrameType
 import nebulosa.indi.device.camera.FrameType.Companion.frameType
 
-data class AnalyzedTarget(
+data class ImageAnalyzed(
     @JvmField val width: Int,
     @JvmField val height: Int,
     @JvmField val binX: Int,
     @JvmField val binY: Int,
     @JvmField val gain: Double,
     @JvmField val exposureTime: Long,
     @JvmField val type: FrameType,
-    @JvmField val group: StackerGroupType,
+    @JvmField val filter: ImageFilterType,
 ) {
 
     constructor(header: ReadableHeader) : this(
         header.width, header.height, header.binX, header.binY, header.gain, header.exposureTimeInMicroseconds,
-        header.frameType ?: FrameType.LIGHT, StackerGroupType.from(header)
+        header.frameType ?: FrameType.LIGHT, ImageFilterType.from(header)
     )
 }

api/src/main/kotlin/nebulosa/api/image/ImageController.kt

@@ -22,6 +22,7 @@ class ImageController(
         app.post("image", ::openImage)
         app.delete("image", ::closeImage)
         app.put("image/save-as", ::saveImageAs)
+        app.put("image/analyze", ::analyze)
         app.put("image/annotations", ::annotations)
         app.get("image/coordinate-interpolation", ::coordinateInterpolation)
         app.get("image/histogram", ::histogram)
@@ -47,6 +48,11 @@ class ImageController(
         imageService.saveImageAs(path, save)
     }
 
+    private fun analyze(ctx: Context) {
+        val path = ctx.queryParam("path").notNull().path().exists()
+        imageService.analyze(path)?.also(ctx::json)
+    }
+
     private fun annotations(ctx: Context) {
         val path = ctx.queryParam("path").notNull().path().exists()
         val request = ctx.bodyAsClass<AnnotateImageRequest>()

api/src/main/kotlin/nebulosa/api/stacker/StackerGroupType.kt → api/src/main/kotlin/nebulosa/api/image/ImageFilterType.kt

@@ -1,10 +1,10 @@
-package nebulosa.api.stacker
+package nebulosa.api.image
 
 import nebulosa.fits.filter
 import nebulosa.fits.naxis
 import nebulosa.image.format.ReadableHeader
 
-enum class StackerGroupType {
+enum class ImageFilterType {
     NONE,
     LUMINANCE,
     RED,

api/src/main/kotlin/nebulosa/api/image/ImageService.kt

@@ -13,6 +13,7 @@ import nebulosa.image.Image
 import nebulosa.image.algorithms.computation.Histogram
 import nebulosa.image.algorithms.computation.Statistics
 import nebulosa.image.algorithms.transformation.*
+import nebulosa.image.format.ImageHdu
 import nebulosa.image.format.ImageModifier
 import nebulosa.indi.device.camera.Camera
 import nebulosa.log.*
@@ -31,6 +32,8 @@ import nebulosa.time.UTC
 import nebulosa.wcs.WCS
 import nebulosa.wcs.WCSException
 import nebulosa.xisf.XisfFormat
+import nebulosa.xisf.isXisf
+import nebulosa.xisf.xisf
 import okio.sink
 import java.net.URI
 import java.nio.file.Path
@@ -39,6 +42,8 @@ import java.util.*
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ExecutorService
 import javax.imageio.ImageIO
+import kotlin.io.path.exists
+import kotlin.io.path.isRegularFile
 import kotlin.io.path.outputStream
 import kotlin.math.roundToInt
 
@@ -299,6 +304,17 @@ class ImageService(
         }
     }
 
+    fun analyze(path: Path): ImageAnalyzed? {
+        if (!path.exists() || !path.isRegularFile()) return null
+
+        val image = if (path.isFits()) path.fits()
+        else if (path.isXisf()) path.xisf()
+        else return null
+
+        return image.use { it.firstOrNull { hdu -> hdu is ImageHdu }?.header }
+            ?.let(::ImageAnalyzed)
+    }
+
     fun frame(
         rightAscension: Angle, declination: Angle,
         width: Int, height: Int, fov: Angle,

api/src/main/kotlin/nebulosa/api/inject/Inject.kt

@@ -65,8 +65,6 @@ import nebulosa.api.rotators.RotatorService
 import nebulosa.api.sequencer.SequencerController
 import nebulosa.api.sequencer.SequencerExecutor
 import nebulosa.api.sequencer.SequencerService
-import nebulosa.api.stacker.StackerController
-import nebulosa.api.stacker.StackerService
 import nebulosa.api.stardetector.StarDetectionController
 import nebulosa.api.stardetector.StarDetectionService
 import nebulosa.api.wheels.WheelController
@@ -303,7 +301,6 @@ fun servicesModule() = module {
     single { AutoFocusExecutor(get(), get(), get()) }
     single { AutoFocusService(get()) }
     single { LiveStackingService() }
-    single { StackerService(get()) }
     single { FramingService(get(), get()) }
     single { INDIService(get()) }
     single { DARVExecutor(get(), get(), get()) }
@@ -341,7 +338,6 @@ fun controllersModule() = module(true) {
     single { StarDetectionController(get(), get()) }
     single { AutoFocusController(get(), get(), get()) }
     single { LiveStackingController(get(), get(), get()) }
-    single { StackerController(get(), get()) }
     single { FramingController(get(), get(), get()) }
     single { INDIController(get(), get(), get()) }
     single { PolarAlignmentController(get(), get(), get()) }