Gist of im_scale.py

gistfile1.py

import numpy
import math

def sky_median_sig_clip(input_arr, sig_fract, percent_fract, max_iter=100):
    """Estimating sky value for a given number of iterations

    @type input_arr: numpy array
    @param input_arr: image data array
    @type sig_fract: float
    @param sig_fract: fraction of sigma clipping
    @type percent_fract: float
    @param percent_fract: convergence fraction
    @type max_iter: max. of iterations
    @rtype: tuple
    @return: (sky value, number of iteration)

    """
    work_arr = numpy.ravel(input_arr)
    old_sky = numpy.median(work_arr)
    sig = work_arr.std()
    upper_limit = old_sky + sig_fract * sig
    lower_limit = old_sky - sig_fract * sig
    indices = numpy.where((work_arr < upper_limit) & (work_arr > lower_limit))
    work_arr = work_arr[indices]
    new_sky = numpy.median(work_arr)
    iteration = 0
    while (math.fabs(old_sky - new_sky)/new_sky) > percent_fract and (iteration
            < max_iter):
            iteration += 1
            old_sky = new_sky
            sig = work_arr.std()
            upper_limit = old_sky + sig_fract * sig
            lower_limit = old_sky - sig_fract * sig
            indices = numpy.where((work_arr < upper_limit) & (work_arr >
                lower_limit))
            work_arr = work_arr[indices]
            new_sky = numpy.median(work_arr)
    return (new_sky, iteration)


def sky_mean_sig_clip(input_arr, sig_fract, percent_fract, max_iter=100):
    """Estimating sky value for a given number of iterations

    @type input_arr: numpy array
    @param input_arr: image data array
    @type sig_fract: float
    @param sig_fract: fraction of sigma clipping
    @type percent_fract: float
    @param percent_fract: convergence fraction
    @type max_iter: max. of iterations
    @rtype: tuple
    @return: (sky value, number of iteration)

    """

    work_arr = numpy.ravel(input_arr)
    old_sky = numpy.mean(work_arr)
    sig = work_arr.std()
    upper_limit = old_sky + sig_fract * sig
    lower_limit = old_sky - sig_fract * sig
    indices = numpy.where((work_arr < upper_limit) & (work_arr > lower_limit))
    work_arr = work_arr[indices]
    new_sky = numpy.mean(work_arr)
    iteration = 0
    while ((math.fabs(old_sky - new_sky)/new_sky) > percent_fract) and \
        (iteration < max_iter):
            iteration += 1
            old_sky = new_sky
            sig = work_arr.std()
            upper_limit = old_sky + sig_fract * sig
            lower_limit = old_sky - sig_fract * sig
            indices = numpy.where((work_arr < upper_limit) & (work_arr >
                lower_limit))
            work_arr = work_arr[indices]
            new_sky = numpy.mean(work_arr)
    return (new_sky, iteration)


def linear(inputArray, scale_min=None, scale_max=None):
    """Performs linear scaling of the input numpy array.

    @type inputArray: numpy array
    @param inputArray: image data array
    @type scale_min: float
    @param scale_min: minimum data value
    @type scale_max: float
    @param scale_max: maximum data value
    @rtype: numpy array
    @return: image data array

    """
    print("img_scale : linear")
    imageData=numpy.array(inputArray, copy=True)

    if scale_min == None:
            scale_min = imageData.min()
    if scale_max == None:
            scale_max = imageData.max()

    imageData = imageData.clip(min=scale_min, max=scale_max)
    imageData = (imageData -scale_min) / (scale_max - scale_min)
    indices = numpy.where(imageData < 0)
    imageData[indices] = 0.0
    indices = numpy.where(imageData > 1)
    imageData[indices] = 1.0

    return imageData


def sqrt(inputArray, scale_min=None, scale_max=None):
    """Performs sqrt scaling of the input numpy array.

    @type inputArray: numpy array
    @param inputArray: image data array
    @type scale_min: float
    @param scale_min: minimum data value
    @type scale_max: float
    @param scale_max: maximum data value
    @rtype: numpy array
    @return: image data array

    """

    print("img_scale : sqrt")
    imageData=numpy.array(inputArray, copy=True)

    if scale_min == None:
            scale_min = imageData.min()
    if scale_max == None:
            scale_max = imageData.max()

    imageData = imageData.clip(min=scale_min, max=scale_max)
    imageData = imageData - scale_min
    indices = numpy.where(imageData < 0)
    imageData[indices] = 0.0
    imageData = numpy.sqrt(imageData)
    imageData = imageData / math.sqrt(scale_max - scale_min)

    return imageData


def log(inputArray, scale_min=None, scale_max=None):
    """Performs log10 scaling of the input numpy array.

    @type inputArray: numpy array
    @param inputArray: image data array
    @type scale_min: float
    @param scale_min: minimum data value
    @type scale_max: float
    @param scale_max: maximum data value
    @rtype: numpy array
    @return: image data array

    """

    print("img_scale : log")
    imageData=numpy.array(inputArray, copy=True)

    if scale_min == None:
            scale_min = imageData.min()
    if scale_max == None:
            scale_max = imageData.max()
    factor = math.log10(scale_max - scale_min)
    indices0 = numpy.where(imageData < scale_min)
    indices1 = numpy.where((imageData >= scale_min) & (imageData <= scale_max))
    indices2 = numpy.where(imageData > scale_max)
    imageData[indices0] = 0.0
    imageData[indices2] = 1.0
    try :
            imageData[indices1] = numpy.log10(imageData[indices1])/factor
    except :
            print("Error on math.log10 for ", (imageData[i][j] - scale_min))

    return imageData


def asinh(inputArray, scale_min=None, scale_max=None, non_linear=2.0):
    """Performs asinh scaling of the input numpy array.

    @type inputArray: numpy array
    @param inputArray: image data array
    @type scale_min: float
    @param scale_min: minimum data value
    @type scale_max: float
    @param scale_max: maximum data value
    @type non_linear: float
    @param non_linear: non-linearity factor
    @rtype: numpy array
    @return: image data array

    """

    print("img_scale : asinh")
    imageData=numpy.array(inputArray, copy=True)

    if scale_min == None:
            scale_min = imageData.min()
    if scale_max == None:
            scale_max = imageData.max()
    factor = numpy.arcsinh((scale_max - scale_min)/non_linear)
    indices0 = numpy.where(imageData < scale_min)
    indices1 = numpy.where((imageData >= scale_min) & (imageData <= scale_max))
    indices2 = numpy.where(imageData > scale_max)
    imageData[indices0] = 0.0
    imageData[indices2] = 1.0
    imageData[indices1] = numpy.arcsinh((imageData[indices1] - \
    scale_min)/non_linear)/factor

    return imageData