graxpert 3.2.0a0.dev4__py3-none-any.whl

graxpert/preferences.py

@@ -0,0 +1,139 @@
+import json
+import logging
+import os
+import shutil
+from dataclasses import asdict, dataclass, field, fields
+from datetime import datetime
+from typing import AnyStr, List
+
+import numpy as np
+
+from graxpert.app_state import AppState
+from graxpert.version import version as graxpert_version
+
+
+@dataclass
+class Prefs:
+    working_dir: AnyStr = os.getcwd()
+    width: int = None
+    height: int = None
+    background_points: List = field(default_factory=list)
+    bg_flood_selection_option: bool = False
+    bg_pts_option: int = 15
+    stretch_option: AnyStr = "No Stretch"
+    saturation: float = 1.0
+    channels_linked_option: bool = False
+    images_linked_option: bool = False
+    display_pts: bool = True
+    bg_tol_option: float = 1.0
+    interpol_type_option: AnyStr = "RBF"
+    smoothing_option: float = 0.0
+    saveas_option: AnyStr = "32 bit Tiff"
+    saveas_stretched: bool = False
+    sample_size: int = 25
+    sample_color: int = 55
+    RBF_kernel: AnyStr = "thin_plate"
+    spline_order: int = 3
+    lang: AnyStr = None
+    corr_type: AnyStr = "Subtraction"
+    scaling: float = 1.0
+    bge_ai_version: AnyStr = None
+    deconvolution_type_option: AnyStr = "Object-only"
+    deconvolution_object_ai_version: AnyStr = None
+    deconvolution_stars_ai_version: AnyStr = None
+    denoise_ai_version: AnyStr = None
+    graxpert_version: AnyStr = graxpert_version
+    deconvolution_strength: float = 0.5
+    deconvolution_psfsize: float = 5.0
+    denoise_strength: float = 0.5
+    ai_batch_size: int = 4
+    ai_gpu_acceleration: bool = True
+
+
+def app_state_2_prefs(prefs: Prefs, app_state: AppState) -> Prefs:
+    prefs.background_points = [p.tolist() for p in app_state.background_points]
+    return prefs
+
+
+def prefs_2_app_state(prefs: Prefs, app_state: AppState) -> AppState:
+    app_state.background_points = [np.array(p) for p in prefs.background_points]
+    return app_state
+
+
+def merge_json(prefs: Prefs, json) -> Prefs:
+    for f in fields(prefs):
+        if f.name in json:
+            setattr(prefs, f.name, json[f.name])
+    return prefs
+
+
+def load_preferences(prefs_filename) -> Prefs:
+    prefs = Prefs()
+    try:
+        if os.path.isfile(prefs_filename):
+            with open(prefs_filename) as f:
+                json_prefs = json.load(f)
+
+                if "ai_version" in json_prefs:
+                    logging.warning(f"Obsolete key 'ai_version' found in {prefs_filename}. Renaming it to 'bge_ai_version.")
+                    json_prefs = {"bge_ai_version" if k == "ai_version" else k: v for k, v in json_prefs.items()}
+
+                prefs = merge_json(prefs, json_prefs)
+
+                if not "graxpert_version" in json_prefs:  # reset scaling in case we start from GraXpert < 2.1.0
+                    prefs.scaling = 1.0
+        else:
+            logging.info("{} appears to be missing. it will be created after program shutdown".format(prefs_filename))
+    except:
+        logging.exception("could not load preferences.json from {}".format(prefs_filename))
+        if os.path.isfile(prefs_filename):
+            # make a backup of the old preferences file so we don't loose it
+            backup_filename = os.path.join(os.path.dirname(prefs_filename), datetime.now().strftime("%m-%d-%Y_%H-%M-%S_{}".format(os.path.basename(prefs_filename))))
+            shutil.copyfile(prefs_filename, backup_filename)
+    return prefs
+
+
+def save_preferences(prefs_filename, prefs):
+    try:
+        os.makedirs(os.path.dirname(prefs_filename), exist_ok=True)
+        with open(prefs_filename, "w") as f:
+            json.dump(asdict(prefs), f)
+    except OSError as err:
+        logging.exception("error serializing preferences")
+
+
+def app_state_2_fitsheader(prefs: Prefs, app_state: AppState, fits_header):
+    fits_header["INTP-OPT"] = prefs.interpol_type_option
+    fits_header["SMOOTH"] = prefs.smoothing_option
+    fits_header["CORRTYPE"] = prefs.corr_type
+
+    if prefs.interpol_type_option == "AI":
+        fits_header["BGAI_VER"] = prefs.bge_ai_version
+
+    if prefs.interpol_type_option != "AI":
+        fits_header["SAMPSIZE"] = prefs.sample_size
+        fits_header["RBFKRNL"] = prefs.RBF_kernel
+        fits_header["SPLNORDR"] = prefs.spline_order
+        fits_header["BG-PTS"] = str(list(map(lambda e: e.tolist(), app_state.background_points)))
+
+    return fits_header
+
+
+def fitsheader_2_app_state(prefs: Prefs, app_state: AppState, fits_header):
+    if "BG-PTS" in fits_header.keys():
+        try:
+            app_state.background_points = [np.array(p) for p in json.loads(fits_header["BG-PTS"])]
+        except:
+            logging.warning("Could not transfer background points from fits header to application state", stack_info=True)
+
+    if "INTP-OPT" in fits_header.keys():
+        prefs.interpol_type_option = fits_header["INTP-OPT"]
+        prefs.smoothing_option = fits_header["SMOOTH"]
+        prefs.corr_type = fits_header["CORRTYPE"]
+
+        if fits_header["INTP-OPT"] != "AI":
+            prefs.sample_size = fits_header["SAMPSIZE"]
+            prefs.RBF_kernel = fits_header["RBFKRNL"]
+            prefs.spline_order = fits_header["SPLNORDR"]
+
+    return app_state

graxpert/radialbasisinterpolation.py

@@ -0,0 +1,215 @@
+import sys
+if sys.version_info[0] >2:
+    unicode = str
+
+import numpy as np
+import scipy.spatial
+from scipy.special import xlogy
+import scipy.linalg
+
+
+class RadialBasisInterpolation:
+    """
+    Augmented Radial Basis function interpolation with (optional) polynomial 
+    augmentation. The construction follows [1] with code borrowed from [2] 
+    for the kernel (which they call the "function")
+    
+    Inputs
+    ------
+    X (array like)
+        (N,ndim) array or (N,) vector of build points
+        
+    f (array like)
+        (N,) vector of function values
+    
+    Options: 
+    --------
+    degree [0]
+        Use an augmented RBF. Specify the *total* degree fit if given as an 
+        integer. If given as a matrix, must be (P+1,ndim) shape. This is the 
+        degree of the augmenting polynomial.
+    
+    kernel : ['gaussian'] 
+        The radial basis kernel, based on the radius, r
+        If string:
+            'multiquadric': sqrt((r/epsilon)**2 + 1)
+            'inverse': 1.0/sqrt((r/epsilon)**2 + 1)
+            'gaussian': exp(-(r/epsilon)**2)
+            'linear': r
+            'cubic': r**3
+            'quintic': r**5
+            'thin_plate': r**2 * log(r)
+        If callable
+            must take the arguments (r,epsilon) and ignore epsilon if 
+            not needed. Tip: If epsilon is not needed, set it to
+            0 to avoid trying to optimize it
+        If integer:
+            Spline of the form: r**kernel if kernel is odd else r**kernel*log(r)
+
+    epsilon [None]
+        Adjustable parameter for some kernels.
+        
+    smooth : float, optional
+        Values greater than zero increase the smoothness of the
+        approximation.  0 is for interpolation (default). Actually set to
+        max(smooth,1e-10 * ||f||) for numerical precision
+
+    Theory:
+    ------
+    The RBF is based on a radial distance 
+    
+        r_j = ||x - x_j||                                               (1)
+    
+    with the kernel phi(r) and an optional "Agumenting" polynomial of set 
+    degree. The interpolant is of the form: [1]
+    
+        s(x) = sum_{j=1}^N c_j * phi(r_j) + sum_{k \in P} g_k * p_k     (2)
+    
+    where `P` is a polynomial index and `p_k` is the corresponding
+    polynomial (e.g. k = {1,2,0} then p_k = x*y^2*z^0).
+    
+    In order to solve for c_j and g_k we enforce 
+        (a) s(x_j) = f_j for all j (i.e. exact interpolation)
+        (b) sum_{j=1}^N c_j*p_k(x_j) = 0 for all k=1,...,N 
+    
+    That results in a matrix system:
+        ____________________________________________________   ___     ___
+       |                            |                       | |   |   |   |
+       |   phi(||x_i - x_j||) (N,N) |   p_k(x_j) (N,len(K)) | | c |   | f |
+       |                            |                       | |   | = |   | (3)
+       |----------------------------|-----------------------| |---|   |---|
+       |       p_k(x_j).T           |           0           | | g |   | 0 |
+        ----------------------------------------------------   ---     ---
+      
+    which is then solved. Given c and g, (2) can be used to solve for
+    any given x
+    
+    References:
+    ----------  
+    [1] G. B. Wright. Radial Basis Function Interpolation: Numerical and 
+        Analytical Developments. PhD thesis, University of Colorado, 2003.
+
+    [2] SciPy version 1.1.0
+        https://github.com/scipy/scipy/blob/v1.1.0/scipy/interpolate/rbf.py
+    
+    [3] S. Rippa. An algorithm for selecting a good value for the parameter 
+        c in radial basis function interpolation. Advances in Computational 
+        Mathematics, 11(2-3):193–210, 1999.
+        
+    [4] J. D. Martin and T. W. Simpson. Use of Kriging Models to Approximate 
+        Deterministic Computer Models. AIAA journal, 43(4):853–863, 2005.
+
+    """
+    def __init__(self,X,f,degree=0,
+                 epsilon=1,smooth=0,
+                 kernel='gaussian',_solve=True):
+        self.X = X = np.atleast_2d(X)
+        self.N,self.ndim = X.shape
+        self.f = f = np.ravel(f)
+        self.degree = degree
+        self.kernel = kernel
+        self.epsilon = epsilon
+        
+        
+        r = scipy.spatial.distance.cdist(X,X)
+
+        self.smooth = max(float(smooth),1e-10)
+        
+        K = self._kernel(r) + np.eye(self.N)*self.smooth*np.mean(self._kernel(r))
+        P = RadialBasisInterpolation.vandermond(X,degree=self.degree)
+        
+        # Build the matrix
+        Z = np.zeros([P.shape[1]]*2)
+        z = np.zeros(P.shape[1])
+        KP = np.block([[K   , P],
+                       [P.T , Z]])
+        b = np.hstack([f,z])
+        coef = scipy.linalg.solve(KP,b)
+        self.rbf_coef = coef[:self.N]
+        self.poly_coef = coef[self.N:]
+        
+
+    def __call__(self,X):
+        X = np.atleast_2d(X)
+        step_size = int(10*X.shape[0]/self.X.size + 1)
+        i = 0
+
+        result = np.empty(X.shape[0])
+
+        while(i < X.shape[0]):
+            start = i
+            end = np.minimum(i+step_size,X.shape[0])
+            K = self._kernel( scipy.spatial.distance.cdist(X[start:end],self.X) )
+            P = RadialBasisInterpolation.vandermond(X[start:end],degree=self.degree)
+           
+            result[start:end] = K.dot(self.rbf_coef) + P.dot(self.poly_coef)
+            i = i + step_size
+        
+        return result
+
+    def _kernel(self,r):
+        r = np.asarray(r)
+        if callable(self.kernel):
+            return self.kernel(r,self.epsilon)
+        elif isinstance(self.kernel,(int,np.integer)):
+            if np.mod(self.kernel,2) == 0:
+                return xlogy(r**self.kernel,r)
+            else:
+                return r**self.kernel
+        elif not isinstance(self.kernel,(str,unicode)):
+            raise ValueError('Kernel must be a callable with signature (r,epsilon), an integer (spline) or a valid string')
+        
+        kernel = self.kernel.lower().replace(' ','_').replace('-','_')
+        
+        if kernel in ['multiquadric']:
+            return np.sqrt((r/self.epsilon)**2 + 1)
+        elif kernel in ['inverse_multiquadric','inverse']:
+            return 1.0/np.sqrt((1.0/self.epsilon*r)**2 + 1)
+        elif kernel in ['gaussian','squared_exponential']:
+            return np.exp(-(1.0/self.epsilon*r)**2)
+        elif kernel in ['linear']:
+            return r
+        elif kernel in ['cubic']:
+            return r**3
+        elif kernel in ['quintic']:
+            return r**5
+        elif kernel in ['thin_plate']:
+            return xlogy(r**2, r)
+        else:
+            raise ValueError('Not valid kernel name')
+    
+    @staticmethod
+    def vandermond(X,degree):
+        """
+        Return a Vandermond matrix of X up to the
+        *total* order degree
+        """
+        X = np.atleast_2d(X)
+        ndim = X.shape[1]
+        index = np.asarray(RadialBasisInterpolation.total_index(degree,ndim),dtype=int)
+        V = np.ones([X.shape[0],len(index)])
+        for d in range(ndim):
+            v = np.fliplr(np.vander(X[:,d],N=degree+1))
+            V *= v[:,index[:,d]]
+        return V
+
+    
+    @staticmethod
+    def total_index(P,ndim,sort=True):
+        P = tuple([P]*ndim)
+        curr = [0]*ndim
+        ind = []
+        ind.append(tuple(curr))
+        while True:
+            for d in range(ndim):
+                if sum(curr) < P[0]:
+                    curr[d] += 1
+                    break
+                else:
+                    curr[d] = 0
+            else:
+                break
+            ind.append(tuple(curr))
+        if sort:
+            ind.sort(key=lambda a:(sum(a),(np.array(a)**2).sum(),a[::-1]))
+        return ind

graxpert/resource_utils.py

@@ -0,0 +1,35 @@
+# from appdirs import
+import os
+
+from tempfile import TemporaryDirectory
+from importlib import resources
+
+temp_resource_dir = TemporaryDirectory()
+
+def temp_cleanup():
+    temp_resource_dir.cleanup()
+
+def resource_path(relative_path):
+    base_path = os.path.join(os.path.dirname(os.path.dirname(__file__)))
+    return os.path.join(base_path, relative_path)
+
+
+def temp_resource_path(relative_path):
+    return os.path.join(temp_resource_dir.name, relative_path)
+
+
+def resource_bytestream(name, dir = 'img'):
+    return resources.files(f'graxpert.{dir}').joinpath(name).open('rb')
+
+
+def resource_image(name):
+    from PIL import Image
+    with resources.as_file(resources.files('graxpert.img').joinpath(name)) as file_path:
+        return Image.open(file_path)
+
+
+# Unfortunately tk.PhotoImage doesn't accept file-like objects, so we need to use a temporary file
+def resource_photoimage(resource_name):
+    import tkinter as tk
+    with resources.as_file(resources.files('graxpert.img').joinpath(resource_name)) as file_path:
+        return tk.PhotoImage(file=file_path)

graxpert/s3_secrets.py

@@ -0,0 +1,16 @@
+# Decompiled with PyLingual (https://pylingual.io)
+# Internal filename: /home/runner/work/GraXpert/GraXpert/graxpert/s3_secrets.py
+# Bytecode version: 3.10.0rc2 (3439)
+# Source timestamp: 2024-05-03 17:20:08 UTC (1714756808)
+
+endpoint = 'minio.schmelly.de'
+ro_access_key = 'IynFklnoqVLigqvqkBR5'
+ro_secret_key = '1250a0FYS2WlUF78aZk0yoeT5daJQkRsNiIjLlhQ'
+bucket_name = 'graxpert-ai'
+bge_bucket_name = 'graxpert-bge-ai-onnx'
+denoise_bucket_name = 'graxpert-denoise-ai-onnx'
+
+deconvolution_object_bucket_name = 'graxpert-deconv-object'
+deconvolution_stars_bucket_name = 'graxpert-deconvolution-stars'
+deconvolution_object_bucket_name = "graxpert-deconvolution-object-ai-onnx"
+deconvolution_stars_bucket_name = "graxpert-deconvolution-stars-ai-onnx"

graxpert/skyall.py

@@ -0,0 +1,152 @@
+import logging
+
+import numpy as np
+
+"""
+Find the mode of a distribution using a route based on the SKYALL as described in
+https://articles.adsabs.harvard.edu//full/1993MNRAS.265..641A/0000643.000.html
+"""
+
+def mode(distribution):
+    
+    # Find appropriate intensity range
+    
+    clip = np.logical_and(distribution > 0.0, distribution < 1.0)
+
+    median = np.median(distribution[clip])
+
+    left_of_median = np.where(distribution < median)
+    right_of_median = np.where(distribution > median)
+    
+    rms_left = np.sqrt(np.sum((distribution[left_of_median] - median)**2)/distribution.size)
+    rms_right= np.sqrt(np.sum((distribution[right_of_median] - median)**2)/distribution.size)
+    
+    rms = np.min([rms_left,rms_right])
+
+    lower_bound = np.max([0.0, median - 2*rms])
+    upper_bound = np.min([1.0, median + 2*rms])
+    
+    
+    # Set initial number of bins
+    
+    num_bins = 8
+    histo, bin_edges = np.histogram(distribution, bins=num_bins, range=(lower_bound,upper_bound), density=True)
+    
+    found = False
+    iterations = 0
+    
+    while(not found and iterations <= 20):
+        
+        max_bin = np.argmax(histo)
+        max_value = histo[max_bin]
+        
+        left_pointer = max_bin
+        right_pointer = max_bin
+        
+        while(histo[left_pointer] > max_value/1.75):
+            left_pointer = left_pointer - 1
+            if(left_pointer < 0):
+                left_pointer = 0
+                break
+            
+        while(histo[right_pointer] > max_value/1.75):
+            right_pointer = right_pointer + 1
+            if(right_pointer >= bin_edges.size - 1):
+                right_pointer = bin_edges.size - 2
+                break
+            
+        if(right_pointer - left_pointer > 5):
+            found = True
+
+        else:
+            found = False
+            num_bins = int(num_bins * 1.5)
+            histo, bin_edges = np.histogram(distribution, bins=num_bins, range=(lower_bound,upper_bound), density=True)
+            
+        iterations = iterations + 1
+
+        if(iterations > 20):
+            logging.debug("More than 20 iterations in second step of SKYALL. Return median instead.")
+            return median
+    
+    #print(bin_edges[left_pointer])
+    #print(bin_edges[right_pointer])
+    lower_bound = (bin_edges[left_pointer] + bin_edges[left_pointer+1])/2
+    upper_bound = (bin_edges[right_pointer] + bin_edges[right_pointer+1])/2
+    histo, bin_edges = np.histogram(distribution, bins=num_bins, range=(lower_bound,upper_bound), density=True)
+    
+    # Find best fit
+    
+    best_coeff = np.array([0,0,0])
+    best_err = -1
+    
+    iterations = 0
+    
+    while(iterations < 20):
+        
+        x = averaged_histo(distribution, bin_edges)
+        coeff, err, misc1, misc2, misc3 = np.polyfit(x, histo, deg=2, full=True)
+        err = err/x.size
+        
+        if(err < best_err or best_err == -1):
+            best_err = err
+            best_coeff = coeff
+            
+        if(err > 1.3*best_err and best_err != -1):
+            break
+    
+        iterations = iterations + 1
+
+        if(iterations >= 20):
+            
+            logging.debug("More than 20 iterations in third step of SKYAL. Return median instead.")
+            return median
+            
+        num_bins = int(num_bins*1.5)
+        histo, bin_edges = np.histogram(distribution, bins=num_bins, range=(lower_bound,upper_bound), density=True)
+        
+
+    
+    mode = -best_coeff[1]/2/best_coeff[0]
+    
+    # Testing
+    #plt.hist(distribution.ravel(),50,range=(0.1,0.5), density=True)
+    #plt.hist(distribution.ravel(),10,range=(bin_edges[0],bin_edges[-1]), density=True)
+    #plt.plot(np.arange(bin_edges[0],bin_edges[-1],0.01), f(np.arange(bin_edges[0],bin_edges[-1],0.01),best_coeff), color="g")
+    #plt.axvline(np.mean(distribution), color='r', label="Mean")
+    #plt.axvline(np.median(distribution), color='k', label="Median")
+    #plt.axvline(mode, color='g', label="Mode")
+    #plt.legend()
+    #plt.savefig("vergleich.jpg")
+    return mode
+        
+    
+    
+    
+def averaged_histo(distribution, bin_edges):
+    
+    x = np.zeros(bin_edges.shape[0]-1)
+    
+    for i in range(x.shape[0]):
+        idx = np.logical_and(distribution >= bin_edges[i], distribution < bin_edges[i+1])
+        
+        if(distribution[idx].shape[0] == 0):
+            x[i] = (bin_edges[i] + bin_edges[i+1])/2.0
+        else:
+            x[i] = np.mean(distribution[idx])
+        
+    return x
+
+def f(x, coeff):
+    return coeff[0]*x**2 + coeff[1]*x + coeff[2]
+
+
+
+# Testing
+# from skimage import img_as_float32, io
+#y=3100
+#x=483
+#size=25
+#im = img_as_float32(io.imread("../../milchstr.tif")[x-size:x+size,y-size:y+size,0])
+
+#mode(im)