setiastrosuitepro 1.6.4__py3-none-any.whl → 1.7.1.post2__py3-none-any.whl

setiastro/saspro/wimi.py

@@ -6524,509 +6524,6 @@ class WIMIDialog(QDialog):
         print(f"[MinorBodies] objects inside cone: {kept}")
         return results
 
-    def _get_astap_exe(self) -> str:
-        s = self._settings()
-        # preferred key (what SettingsDialog writes)
-        p = s.value("paths/astap", "", type=str)
-        if p:
-            return p
-        # migrate legacy key if present
-        legacy = s.value("astap/exe_path", "", type=str)
-        if legacy:
-            s.setValue("paths/astap", legacy)
-            s.remove("astap/exe_path")
-            s.sync()
-            return legacy
-        return ""
-
-    def _set_astap_exe(self, path: str) -> None:
-        s = self._settings()
-        s.setValue("paths/astap", path)
-        s.sync()
-
-    def plate_solve_image(self):
-        """
-        Attempts to plate-solve the loaded image using ASTAP,
-        first trying a seeded solve (RA, SPD, scale, binning),
-        then falling back to a blind solve if anything is missing.
-        On success, updates self.header and self.wcs.
-        """
-        if not hasattr(self, 'image_path') or not self.image_path:
-            return
-
-        # 1) Ensure ASTAP path
-        astap_exe = self._get_astap_exe()
-        if not astap_exe or not os.path.exists(astap_exe):
-            # last-resort browse if nothing in settings (keeps existing behavior)
-            filt = "Executables (*.exe);;All Files (*)" if sys.platform.startswith("win") else "Executables (*)"
-            new_path, _ = QFileDialog.getOpenFileName(self, "Select ASTAP Executable", "", filt)
-            if not new_path:
-                return
-            astap_exe = new_path
-            self._set_astap_exe(astap_exe)
-
-        # 2) Write out the normalized FITS for ASTAP
-        normalized = self.stretch_image(self.image_data.astype(np.float32))
-        try:
-            tmp_path = self.save_temp_fits_image(normalized, self.image_path)
-        except Exception as e:
-            QMessageBox.critical(self, "Plate Solve", f"Error saving temp FITS: {e}")
-            return
-
-        # 3) Seed arguments from header
-        raw_hdr = None
-        if isinstance(self.original_header, fits.Header):
-            raw_hdr = self.original_header
-        elif self.image_path.lower().endswith(('.fits','.fit')):
-            with fits.open(self.image_path, memmap=False) as hdul:
-                raw_hdr = hdul[0].header
-
-        seed_args = []
-        if isinstance(raw_hdr, fits.Header):
-            # debug-dump
-            print("🔍 Raw header contents:")
-            for k,v in raw_hdr.items():
-                print(f"    {k} = {v}")
-
-            try:
-                # RA→hours, SPD
-                ra_deg = float(raw_hdr["CRVAL1"])
-                dec_deg= float(raw_hdr["CRVAL2"])
-                ra_h    = ra_deg / 15.0
-                spd     = dec_deg + 90.0
-
-                # plate scale from CD matrix (°/px→″/px)
-                cd1 = float(raw_hdr.get("CD1_1", raw_hdr.get("CDELT1",0)))
-                cd2 = float(raw_hdr.get("CD2_1", raw_hdr.get("CDELT2",0)))
-                scale = np.hypot(cd1, cd2) * 3600.0
-
-                # apply XBINNING/YBINNING
-                bx = int(raw_hdr.get("XBINNING", 1))
-                by = int(raw_hdr.get("YBINNING", bx))
-                if bx != by:
-                    print(f"⚠️ Unequal binning: {bx}×{by}, averaging.")
-                binf = (bx+by)/2.0
-                scale *= binf
-
-                seed_args = [
-                    "-ra",    f"{ra_h:.6f}",
-                    "-spd",   f"{spd:.6f}",
-                    "-scale", f"{scale:.3f}"
-                ]
-                print(f"🔸 Seeding ASTAP: RA={ra_h:.6f}h, SPD={spd:.6f}°, scale={scale:.3f}\"/px (×{binf} bin)")
-            except Exception as e:
-                print("⚠️ Failed to build seed args, will do blind solve:", e)
-
-        # 4) Build ASTAP args
-        if seed_args:
-            args = ["-f", tmp_path] + seed_args + ["-wcs", "-sip"]
-        else:
-            args = ["-f", tmp_path, "-r", "179", "-fov", "0", "-z", "0", "-wcs", "-sip"]
-
-        print("▶️ Running ASTAP with arguments:", args)
-
-        # create and launch the process
-        process = QProcess(self)
-        process.start(astap_exe, args)
-        if not process.waitForStarted(5000):
-            #QMessageBox.critical(self, "Plate Solve", "Failed to start ASTAP process.")
-            os.remove(tmp_path)
-            
-            return None
-        if not process.waitForFinished(300000):
-            #QMessageBox.critical(self, "Plate Solve", "ASTAP process timed out.")
-            os.remove(tmp_path)
-            return None
-
-        exit_code = process.exitCode()
-        stdout = process.readAllStandardOutput().data().decode()
-        stderr = process.readAllStandardError().data().decode()
-        print("ASTAP exit code:", exit_code)
-        print("ASTAP STDOUT:\n", stdout)
-        print("ASTAP STDERR:\n", stderr)
-        
-        if exit_code != 0:
-            os.remove(tmp_path)
-            #QMessageBox.warning(self, "Plate Solve", "ASTAP failed. Falling back to blind solve.")
-            
-            return None
-
-        # --- Retrieve the initial solved header from the temporary FITS file ---
-        try:
-            with fits.open(tmp_path, memmap=False) as hdul:
-                solved_header = dict(hdul[0].header)
-            for key in ["COMMENT", "HISTORY", "END"]:
-                solved_header.pop(key, None)
-            print("Initial solved header retrieved from temporary FITS file:")
-            for key, value in solved_header.items():
-                print(f"{key} = {value}")
-        except Exception as e:
-            QMessageBox.critical(self, "Plate Solve", f"Error reading solved header: {e}")
-            os.remove(tmp_path)
-            
-            return None
-
-        # --- Check for a .wcs file and merge its header if present ---
-        wcs_path = os.path.splitext(tmp_path)[0] + ".wcs"
-        if os.path.exists(wcs_path):
-            try:
-                wcs_header = {}
-                with open(wcs_path, "r") as f:
-                    text = f.read()
-                    # Matches a FITS header keyword and its value (with an optional comment).
-                    pattern = r"(\w+)\s*=\s*('?[^/']*'?)[\s/]"
-                    for match in re.finditer(pattern, text):
-                        key = match.group(1).strip().upper()
-                        val = match.group(2).strip()
-                        if val.startswith("'") and val.endswith("'"):
-                            val = val[1:-1].strip()
-                        wcs_header[key] = val
-                wcs_header.pop("END", None)
-                print("WCS header retrieved from .wcs file:")
-                for key, value in wcs_header.items():
-                    print(f"{key} = {value}")
-                # Merge the parsed WCS header into the solved header.
-                solved_header.update(wcs_header)
-            except Exception as e:
-                print("Error reading .wcs file:", e)
-        else:
-            print("No .wcs file found; using header from temporary FITS.")
-
-        # --- If loaded from a slot, merge the original file path from slot metadata ---
-        if getattr(self, "_from_slot", False) and hasattr(self, "_slot_meta"):
-            if "file_path" not in solved_header and "file_path" in self._slot_meta:
-                solved_header["file_path"] = self._slot_meta["file_path"]
-                print("Merged file_path from slot metadata into solved header.")
-
-        # --- Add any missing required WCS keywords ---
-        required_keys = {
-            "CTYPE1": "RA---TAN",
-            "CTYPE2": "DEC--TAN",
-            "RADECSYS": "ICRS",
-            "WCSAXES": 2,
-            # CRVAL1, CRVAL2, CRPIX1, CRPIX2 are ideally provided by ASTAP.
-        }
-        for key, default in required_keys.items():
-            if key not in solved_header:
-                solved_header[key] = default
-                print(f"Added missing key {key} with default value {default}.")
-
-        # --- Convert keys that are expected to be numeric from strings to numbers ---
-        expected_numeric_keys = {
-            "CRPIX1", "CRPIX2", "CRVAL1", "CRVAL2", "CROTA1", "CROTA2",
-            "CDELT1", "CDELT2", "CD1_1", "CD1_2", "CD2_1", "CD2_2", "WCSAXES"
-        }
-        for key in expected_numeric_keys:
-            if key in solved_header:
-                try:
-                    # For keys that should be integers, you can use int(float(...)) if necessary.
-                    solved_header[key] = float(solved_header[key])
-                except ValueError:
-                    print(f"Warning: Could not convert {key} value '{solved_header[key]}' to float.")
-
-        # --- Ensure integer keywords are stored as integers ---
-        for key in ["WCSAXES", "NAXIS", "NAXIS1", "NAXIS2", "NAXIS3"]:
-            if key in solved_header:
-                try:
-                    solved_header[key] = int(float(solved_header[key]))
-                except ValueError:
-                    print(f"Warning: Could not convert {key} value '{solved_header[key]}' to int.")
-
-
-        os.remove(tmp_path)
-        print("ASTAP plate solving successful. Final solved header:")
-        for key, value in solved_header.items():
-            print(f"{key} = {value}")
-
-        # --------------------------------------------------------------------
-        # 1) Make sure A_ORDER/B_ORDER exist in pairs:
-        if "B_ORDER" in solved_header and "A_ORDER" not in solved_header:
-            solved_header["A_ORDER"] = solved_header["B_ORDER"]
-        if "A_ORDER" in solved_header and "B_ORDER" not in solved_header:
-            solved_header["B_ORDER"] = solved_header["A_ORDER"]
-
-        # 2) Convert SIP‐order keywords to ints:
-        for key in ("A_ORDER","B_ORDER","AP_ORDER","BP_ORDER"):
-            if key in solved_header:
-                solved_header[key] = int(float(solved_header[key]))
-
-        # 3) Convert every SIP coefficient to float:
-        for k in list(solved_header):
-            if re.match(r"^(?:A|B|AP|BP)_[0-9]+_[0-9]+$", k):
-                solved_header[k] = float(solved_header[k])
-
-        # --------------------------------------------------------------------
-        # 4) Now rebuild your FITS header from the dict, preserving ordering:
-        new_hdr = fits.Header()
-        for key, val in solved_header.items():
-            # skip any stray non‑FITS metadata
-            if key == "file_path":
-                continue
-            new_hdr[key] = val
-
-        # 5) Finally swap in the new header and re-init WCS (with SIP!)
-        self.header = new_hdr
-        try:
-            self.apply_wcs_header(self.header)
-            self.status_label.setText("Status: ASTAP solve succeeded.")
-        except Exception as e:
-            QMessageBox.critical(self, "Plate Solve", f"Error initializing WCS from solved header:\n{e}")
-            return
-
-        return solved_header
-
-
-    def save_temp_fits_image(self, normalized_image, image_path: str):
-        """
-        Save the normalized_image as a FITS file to a temporary file.
-        
-        If the original image is FITS, this method retrieves the stored metadata
-        from the ImageManager and passes it directly to save_image().
-        If not, it generates a minimal header.
-        
-        Returns the path to the temporary FITS file.
-        """
-        # Always save as FITS.
-        selected_format = "fits"
-        bit_depth = "32-bit floating point"
-        is_mono = (normalized_image.ndim == 2 or 
-                   (normalized_image.ndim == 3 and normalized_image.shape[2] == 1))
-        
-        # If the original image is FITS, try to get its stored metadata.
-        original_header = None
-        if image_path.lower().endswith((".fits", ".fit")):
-            if self.parent() and hasattr(self.parent(), "image_manager"):
-                # Use the metadata from the current slot.
-                _, meta = self.parent().image_manager.get_current_image_and_metadata()
-                # Assume that meta already contains a proper 'original_header'
-                # (or the entire meta is the header).
-                original_header = meta.get("original_header", None)
-            # If nothing is stored, fall back to creating a minimal header.
-            if original_header is None:
-                print("No stored FITS header found; creating a minimal header.")
-                original_header = self.create_minimal_fits_header(normalized_image, is_mono)
-        else:
-            # For non-FITS images, generate a minimal header.
-            original_header = self.create_minimal_fits_header(normalized_image, is_mono)
-        
-        # Create a temporary filename.
-        tmp_file = tempfile.NamedTemporaryFile(suffix=".fits", delete=False)
-        tmp_path = tmp_file.name
-        tmp_file.close()
-        
-        try:
-            # Call your global save_image() exactly as in AstroEditingSuite.
-            save_image(
-                img_array=normalized_image,
-                filename=tmp_path,
-                original_format=selected_format,
-                bit_depth=bit_depth,
-                original_header=original_header,
-                is_mono=is_mono
-                # (image_meta and file_meta can be omitted if not needed)
-            )
-            print(f"Temporary normalized FITS saved to: {tmp_path}")
-        except Exception as e:
-            print("Error saving temporary FITS file using save_image():", e)
-            raise e
-        return tmp_path
-
-    def create_minimal_fits_header(self, img_array, is_mono=False):
-        """
-        Creates a minimal FITS header when the original header is missing.
-        """
-
-        header = Header()
-        header['SIMPLE'] = (True, 'Standard FITS file')
-        header['BITPIX'] = -32  # 32-bit floating-point data
-        header['NAXIS'] = 2 if is_mono else 3
-        header['NAXIS1'] = img_array.shape[2] if img_array.ndim == 3 and not is_mono else img_array.shape[1]  # Image width
-        header['NAXIS2'] = img_array.shape[1] if img_array.ndim == 3 and not is_mono else img_array.shape[0]  # Image height
-        if not is_mono:
-            header['NAXIS3'] = img_array.shape[0] if img_array.ndim == 3 else 1  # Number of color channels
-        header['BZERO'] = 0.0  # No offset
-        header['BSCALE'] = 1.0  # No scaling
-        header.add_comment("Minimal FITS header generated by AstroEditingSuite.")
-
-        return header
-
-    def stretch_image(self, image):
-        """
-        Perform an unlinked linear stretch on the image.
-        Each channel is stretched independently by subtracting its own minimum,
-        recording its own median, and applying the stretch formula.
-        Returns the stretched image in [0,1].
-        """
-        was_single_channel = False  # Flag to check if image was single-channel
-
-        # If the image is 2D or has one channel, convert to 3-channel
-        if image.ndim == 2 or (image.ndim == 3 and image.shape[2] == 1):
-            was_single_channel = True
-            image = np.stack([image] * 3, axis=-1)
-
-        image = np.asarray(image, dtype=np.float32)
-        stretched_image = image.copy()  # Need copy for in-place modification
-        self.stretch_original_mins = []
-        self.stretch_original_medians = []
-        target_median = 0.02
-
-        for c in range(3):
-            channel_min = np.min(stretched_image[..., c])
-            self.stretch_original_mins.append(channel_min)
-            stretched_image[..., c] -= channel_min
-            channel_median = np.median(stretched_image[..., c])
-            self.stretch_original_medians.append(channel_median)
-            if channel_median != 0:
-                numerator = (channel_median - 1) * target_median * stretched_image[..., c]
-                denominator = (
-                    channel_median * (target_median + stretched_image[..., c] - 1)
-                    - target_median * stretched_image[..., c]
-                )
-                denominator = np.where(denominator == 0, 1e-6, denominator)
-                stretched_image[..., c] = numerator / denominator
-            else:
-                print(f"Channel {c} - Median is zero. Skipping stretch.")
-
-        stretched_image = np.clip(stretched_image, 0.0, 1.0)
-        self.was_single_channel = was_single_channel
-        return stretched_image
-
-    def unstretch_image(self, image):
-        """
-        Undo the unlinked linear stretch using stored parameters.
-        Returns the unstretched image.
-        """
-        original_mins = self.stretch_original_mins
-        original_medians = self.stretch_original_medians
-        was_single_channel = self.was_single_channel
-
-        image = np.asarray(image, dtype=np.float32)
-
-        if image.ndim == 2:
-            channel_median = np.median(image)
-            original_median = original_medians[0]
-            original_min = original_mins[0]
-            if channel_median != 0 and original_median != 0:
-                numerator = (channel_median - 1) * original_median * image
-                denominator = channel_median * (original_median + image - 1) - original_median * image
-                denominator = np.where(denominator == 0, 1e-6, denominator)
-                image = numerator / denominator
-            else:
-                print("Channel median or original median is zero. Skipping unstretch.")
-            image += original_min
-            image = np.clip(image, 0, 1)
-            return image
-
-        for c in range(3):
-            channel_median = np.median(image[..., c])
-            original_median = original_medians[c]
-            original_min = original_mins[c]
-            if channel_median != 0 and original_median != 0:
-                numerator = (channel_median - 1) * original_median * image[..., c]
-                denominator = (
-                    channel_median * (original_median + image[..., c] - 1)
-                    - original_median * image[..., c]
-                )
-                denominator = np.where(denominator == 0, 1e-6, denominator)
-                image[..., c] = numerator / denominator
-            else:
-                print(f"Channel {c} - Median or original median is zero. Skipping unstretch.")
-            image[..., c] += original_min
-
-        image = np.clip(image, 0, 1)
-        if was_single_channel and image.ndim == 3:
-            image = np.mean(image, axis=2, keepdims=True)
-        return image
-
-    def retrieve_and_apply_wcs(self, job_id):
-        """Download the wcs.fits file from Astrometry.net, extract WCS header data, and apply it."""
-        try:
-            wcs_url = f"https://nova.astrometry.net/wcs_file/{job_id}"
-            wcs_filepath = "wcs.fits"
-            max_retries = 10
-            delay = 10  # seconds
-            
-            for attempt in range(max_retries):
-                response = requests.get(wcs_url, stream=True)
-                response.raise_for_status()
-
-                with open(wcs_filepath, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        f.write(chunk)
-
-                try:
-                    with fits.open(wcs_filepath, ignore_missing_simple=True, ignore_missing_end=True) as hdul:
-                        wcs_header = hdul[0].header
-                        print("WCS header successfully retrieved.")
-                        # 🔁 use common path
-                        self.apply_wcs_header(wcs_header)
-                        return wcs_header
-                except Exception as e:
-                    print(f"Attempt {attempt + 1}: Failed to process WCS file - possibly HTML instead of FITS. Retrying in {delay} seconds...")
-                    print(f"Error: {e}")
-                    time.sleep(delay)
-            
-            print("Failed to download a valid WCS FITS file after multiple attempts.")
-            return None
-
-        except requests.exceptions.RequestException as e:
-            print(f"Error downloading WCS file: {e}")
-        except Exception as e:
-            print(f"Error processing WCS file: {e}")
-            
-        return None
-
-
-
-    def apply_wcs_header(self, wcs_header):
-        """
-        Apply a solved WCS header.  Sets self.wcs, self.pixscale (arcsec/pix),
-        self.orientation, and updates the orientation label.
-        """
-        # 1) Initialize the WCS object
-        self.wcs = WCS(wcs_header, naxis=2, relax=True)
-
-        # 2) Derive pixel scale (arcsec/pixel)
-        if 'CDELT1' in wcs_header:
-            # CDELT1 is degrees/pixel
-            self.pixscale = abs(float(wcs_header['CDELT1'])) * 3600.0
-        elif 'CD1_1' in wcs_header and 'CD2_2' in wcs_header:
-            # approximate from CD matrix determinant
-            det = (wcs_header['CD1_1'] * wcs_header['CD2_2']
-                - wcs_header['CD1_2'] * wcs_header['CD2_1'])
-            pixscale_deg = math.sqrt(abs(det))
-            self.pixscale = pixscale_deg * 3600.0
-        else:
-            self.pixscale = None
-            print("Warning: could not derive pixscale from header.")
-
-        # 3) Extract orientation (CROTA2 if present)
-        if 'CROTA2' in wcs_header:
-            self.orientation = float(wcs_header['CROTA2'])
-        else:
-            # fallback to your custom function
-            self.orientation = calculate_orientation(wcs_header)
-
-        # 4) Update the GUI label
-        if self.orientation is not None:
-            self.orientation_label.setText(f"Orientation: {self.orientation:.2f}°")
-        else:
-            self.orientation_label.setText("Orientation: N/A")
-
-        print(f" -> pixscale = {self.pixscale} arcsec/pixel")
-        print(f" -> orientation = {self.orientation}°")
-        try:
-            cr1 = wcs_header.get('CRVAL1')
-            cr2 = wcs_header.get('CRVAL2')
-            if cr1 is not None and cr2 is not None:
-                self.center_ra  = float(cr1)
-                self.center_dec = float(cr2)
-                print(f" -> center RA/Dec = {self.center_ra:.6f}, {self.center_dec:.6f}")
-        except Exception:
-            print("Warning: could not extract CRVAL1/CRVAL2")        
-
-
-
     def calculate_pixel_from_ra_dec(self, ra, dec):
         """Convert RA/Dec to pixel coordinates using the WCS data."""
         if not hasattr(self, "wcs") or self.wcs is None:
@@ -7059,117 +6556,6 @@ class WIMIDialog(QDialog):
 
         return int(round(x_val)), int(round(y_val))
 
-    def login_to_astrometry(self, api_key):
-        try:
-            response = requests.post(
-                ASTROMETRY_API_URL + "login",
-                data={'request-json': json.dumps({"apikey": api_key})}
-            )
-            response_data = response.json()
-            if response_data.get("status") == "success":
-                return response_data["session"]
-            else:
-                raise ValueError("Login failed: " + response_data.get("error", "Unknown error"))
-        except Exception as e:
-            raise Exception("Login to Astrometry.net failed: " + str(e))
-
-
-    def upload_image_to_astrometry(self, image_path, session_key):
-        try:
-            # Check if the file is XISF format
-            file_extension = os.path.splitext(image_path)[-1].lower()
-            if file_extension == ".xisf":
-                # Load the XISF image
-                xisf = XISF(image_path)
-                im_data = xisf.read_image(0)
-                
-                # Convert to a temporary TIFF file for upload
-                temp_image_path = os.path.splitext(image_path)[0] + "_converted.tif"
-                if im_data.dtype == np.float32 or im_data.dtype == np.float64:
-                    im_data = np.clip(im_data, 0, 1) * 65535
-                im_data = im_data.astype(np.uint16)
-
-                # Save as TIFF
-                if im_data.shape[-1] == 1:  # Grayscale
-                    tiff.imwrite(temp_image_path, np.squeeze(im_data, axis=-1))
-                else:  # RGB
-                    tiff.imwrite(temp_image_path, im_data)
-
-                print(f"Converted XISF file to TIFF at {temp_image_path} for upload.")
-                image_path = temp_image_path  # Use the converted file for upload
-
-            # Upload the image file
-            with open(image_path, 'rb') as image_file:
-                files = {'file': image_file}
-                data = {
-                    'request-json': json.dumps({
-                        "publicly_visible": "y",
-                        "allow_modifications": "d",
-                        "session": session_key,
-                        "allow_commercial_use": "d"
-                    })
-                }
-                response = requests.post(ASTROMETRY_API_URL + "upload", files=files, data=data)
-                response_data = response.json()
-                if response_data.get("status") == "success":
-                    return response_data["subid"]
-                else:
-                    raise ValueError("Image upload failed: " + response_data.get("error", "Unknown error"))
-
-        except Exception as e:
-            raise Exception("Image upload to Astrometry.net failed: " + str(e))
-
-        finally:
-            # Clean up temporary file if created
-            if file_extension == ".xisf" and os.path.exists(temp_image_path):
-                os.remove(temp_image_path)
-                print(f"Temporary TIFF file {temp_image_path} deleted after upload.")
-
-
-
-    def poll_submission_status(self, subid):
-        """Poll Astrometry.net to retrieve the job ID once the submission is processed."""
-        max_retries = 90  # Adjust as necessary
-        retries = 0
-        while retries < max_retries:
-            try:
-                response = requests.get(ASTROMETRY_API_URL + f"submissions/{subid}")
-                response_data = response.json()
-                jobs = response_data.get("jobs", [])
-                if jobs and jobs[0] is not None:
-                    return jobs[0]
-                else:
-                    print(f"Polling attempt {retries + 1}: Job not ready yet.")
-            except Exception as e:
-                print(f"Error while polling submission status: {e}")
-            
-            retries += 1
-            time.sleep(10)  # Wait 10 seconds between retries
-        
-        return None
-
-    def poll_calibration_data(self, job_id):
-        """Poll Astrometry.net to retrieve the calibration data once it's available."""
-        max_retries = 90  # Retry for up to 15 minutes (90 * 10 seconds)
-        retries = 0
-        while retries < max_retries:
-            try:
-                response = requests.get(ASTROMETRY_API_URL + f"jobs/{job_id}/calibration/")
-                response_data = response.json()
-                if response_data and 'ra' in response_data and 'dec' in response_data:
-                    print("Calibration data retrieved:", response_data)
-                    return response_data  # Calibration data is complete
-                else:
-                    print(f"Calibration data not available yet (Attempt {retries + 1})")
-            except Exception as e:
-                print(f"Error retrieving calibration data: {e}")
-
-            retries += 1
-            time.sleep(10)  # Wait 10 seconds between retries
-
-        return None
-
-
     #If originally a fits file update the header
     def update_fits_with_wcs(self, filepath, calibration_data):
         if not filepath.lower().endswith(('.fits', '.fit')):
@@ -7391,23 +6777,43 @@ class WIMIDialog(QDialog):
                 CIRCLE('ICRS', {ra_center}, {dec_center}, {radius_deg})
             ) = 1
         """
+
+        result = None
+        last_err = None
+
         for attempt in range(5):
             try:
                 result = Simbad.query_tap(query)
+                last_err = None
                 break
             except Exception as e:
+                last_err = e
                 if attempt < 4:
-                    time.sleep(1)
+                    time.sleep(1)  # or QThread.msleep(1000) if you want less UI freeze
                 else:
-                    QMessageBox.critical(
+                    # After 5 attempts total, stop with a helpful message
+                    err_txt = str(last_err) if last_err is not None else "Unknown error"
+                    QMessageBox.warning(
                         self,
-                        "Query Failed",
-                        f"Try again later:\n{e}"
-            )
+                        "SIMBAD network error",
+                        (
+                            "We couldn't reach SIMBAD due to a network or service error.\n\n"
+                            "We tried 5 times and then stopped.\n\n"
+                            "What to try:\n"
+                            " • Check your internet connection / VPN / firewall\n"
+                            " • Verify SIMBAD is reachable: https://simbad.cds.unistra.fr/simbad/\n"
+                            " • Then try again\n\n"
+                            f"Last error:\n{err_txt}"
+                        )
+                    )
+                    return
 
         if result is None or len(result) == 0:
-            QMessageBox.information(self, "No Results",
-                                    "No objects found in the specified area.")
+            QMessageBox.information(
+                self,
+                "No Results",
+                "No objects found in the specified area."
+            )
             return
 
         # ——— 3a) list of all “star” & binary/variable OTYPE codes ———
@@ -7912,41 +7318,6 @@ class WIMIDialog(QDialog):
             self.status_label.setText(f"Status: Blind solve failed — {res}")
 
 
-def extract_wcs_data(file_path):
-    try:
-        # Open the FITS file with minimal validation to ignore potential errors in non-essential parts
-        with fits.open(file_path, ignore_missing_simple=True, ignore_missing_end=True) as hdul:
-            header = hdul[0].header
-
-            # Extract essential WCS parameters
-            wcs_params = {}
-            keys_to_extract = [
-                'WCSAXES', 'CTYPE1', 'CTYPE2', 'EQUINOX', 'LONPOLE', 'LATPOLE',
-                'CRVAL1', 'CRVAL2', 'CRPIX1', 'CRPIX2', 'CUNIT1', 'CUNIT2',
-                'CD1_1', 'CD1_2', 'CD2_1', 'CD2_2', 'A_ORDER', 'A_0_0', 'A_0_1', 
-                'A_0_2', 'A_1_0', 'A_1_1', 'A_2_0', 'B_ORDER', 'B_0_0', 'B_0_1', 
-                'B_0_2', 'B_1_0', 'B_1_1', 'B_2_0', 'AP_ORDER', 'AP_0_0', 'AP_0_1', 
-                'AP_0_2', 'AP_1_0', 'AP_1_1', 'AP_2_0', 'BP_ORDER', 'BP_0_0', 
-                'BP_0_1', 'BP_0_2', 'BP_1_0', 'BP_1_1', 'BP_2_0'
-            ]
-            for key in keys_to_extract:
-                if key in header:
-                    wcs_params[key] = header[key]
-
-            # Manually create a minimal header with WCS information
-            wcs_header = fits.Header()
-            for key, value in wcs_params.items():
-                wcs_header[key] = value
-
-            # Initialize WCS with this custom header
-            wcs = WCS(wcs_header)
-            print("WCS successfully initialized with minimal header.")
-            return wcs
-
-    except Exception as e:
-        print(f"Error processing WCS file: {e}")
-        return None
-
 # Function to calculate comoving radial distance (in Gly)
 def calculate_comoving_distance(z):
     z = abs(z)