예제 #1
0
    def _find_shift(self, order=3):
        """
        Find the best shift between image1 and image2.
        Expects _load_data() to have been run first to initialize things.
        order is the order of the spline used for shifting in the correlation step.
        """
        # Mask pixels around the edges of the image.
        # We don't have inverse-variances because sdssproc isn't run, so we can't do
        # smarter masking, like bad pixel smoothing, cosmic rays, etc.
        # It is important to mask out the ends of the array, because of
        # spline-induced oddities there.
        subimg1 = self.bigimg1[self.region].copy()
        subimg2 = self.bigimg2[self.region].copy()
        mask = np.ones(subimg1.shape, dtype='f8')
        mask[:10, :] = 0
        mask[-10:, :] = 0
        mask[:, :10] = 0
        mask[:, -10:] = 0

        # Compute linear correlation coefficients
        # Calculate the maximum product of the two images when shifting by steps of dx.
        dx = 0.05
        nshift = int(np.ceil(2 * self.maxshift / dx))
        xshift = -self.maxshift + dx * np.arange(nshift, dtype='f8')
        self.xshift = xshift  # save for plotting

        def calc_shift(xs, img1, img2, mask):
            shifted = interpolation.shift(img2, [xs, 0],
                                          order=order,
                                          prefilter=False)
            return (img1 * shifted * mask).sum()

        self.coeff = np.zeros(nshift, dtype='f8')
        filtered1 = interpolation.spline_filter(subimg1)
        filtered2 = interpolation.spline_filter(subimg2)
        for i in range(nshift):
            # self.coeff[i] = (subimg1 * interpolation.shift(subimg2,
            #                                                [xshift[i], 0],
            #                                                order=order) * mask).sum()
            # self.coeff[i] = (filtered1 * interpolation.shift(filtered2,
            #                                                  [xshift[i], 0],
            #                                                  order=order,
            #                                                  prefilter=False) * mask).sum()
            self.coeff[i] = calc_shift(xshift[i], filtered1, filtered2, mask)

        ibest = self.coeff.argmax()
        self.ibest = ibest  # save for plotting
        self.xoffset = xshift[ibest]
        # If the sequence is actually R-L, instead of L-R,
        # then the offset acctually goes the other way.
        if self.hartpos1 == 'right':
            self.xoffset = -self.xoffset
예제 #2
0
def add_filter(pic):
    ''' add random filter to the picture '''
    val = val = random.randint(1, 2)
    if val == 1:
        s = random.uniform(0.8, 1.2)
        pic = gaussian_filter(pic, sigma=s)
    elif val == 2:
        pic = spline_filter(pic)
    return pic
예제 #3
0
파일: utils.py 프로젝트: jefemagril/fermipy
def create_radial_spline(psf, fn, sigma, egy, dtheta, psf_scale_fn):

    from scipy.ndimage.interpolation import spline_filter

    z = create_kernel_function_lookup(
        psf, fn, sigma, egy, dtheta, psf_scale_fn)
    sp = []
    for i in range(z.shape[0]):
        sp += [spline_filter(z[i], order=2)]
    return sp
예제 #4
0
def create_radial_spline(psf, fn, sigma, egy, dtheta, psf_scale_fn):

    from scipy.ndimage.interpolation import spline_filter

    z = create_kernel_function_lookup(psf, fn, sigma, egy, dtheta,
                                      psf_scale_fn)
    sp = []
    for i in range(z.shape[0]):
        sp += [spline_filter(z[i], order=2)]
    return sp
예제 #5
0
 def setBeamCube(self, beam):
     """Initializes beam cube. Beam is a 2D (or 3D) cube."""
     # init cube
     self._beam = beam.copy()
     self._beam_ampl = abs(beam)
     self._beam_real = beam.real
     self._beam_imag = beam.imag
     # replace with pre-filtered arrays if needed
     if beam.ndim > 2 and self._spline_order > 1:
         if not self._hier_interpol:
             self._beam_real = interpolation.spline_filter(
                 beam.real, order=self._spline_order)
             self._beam_imag = interpolation.spline_filter(
                 beam.imag, order=self._spline_order)
             self._beam_ampl = interpolation.spline_filter(
                 self._beam_ampl, order=self._spline_order)
         else:
             # prefilter per frequency plane in per-frequency mode
             for i in range(beam.shape[2]):
                 self._beam_real[..., i] = interpolation.spline_filter(
                     beam.real[..., i], order=self._spline_order)
                 self._beam_imag[..., i] = interpolation.spline_filter(
                     beam.imag[..., i], order=self._spline_order)
                 self._beam_ampl[..., i] = interpolation.spline_filter(
                     self._beam_ampl[..., i], order=self._spline_order)
예제 #6
0
    def __init__(self,
                 scale_list,
                 values,
                 extrapolate=False,
                 num_extrapolate=2,
                 delta=1e-4):
        shape = values.shape
        ndim = len(shape)

        # error checking
        if ndim < 3:
            raise ValueError('Data must have 3 or more dimensions.')
        elif ndim != len(scale_list):
            raise ValueError('input and output dimension mismatch.')

        self._scale_list = scale_list
        self._max = values.shape
        self._ext = num_extrapolate

        # linearly extrapolate given values
        self._extfun = LinearInterpolator([(0, 1)] * ndim,
                                          values,
                                          extrapolate=True)
        self._extrapolate = extrapolate
        swp_values = []
        ext_xi_shape = []
        delta_list = []
        for (offset, scale), n in zip(scale_list, shape):
            swp_values.append(np.arange(-num_extrapolate, n + num_extrapolate))
            ext_xi_shape.append(n + 2 * num_extrapolate)
            delta_list.append(scale * delta)

        ext_xi_shape.append(ndim)
        xi = np.empty(ext_xi_shape)
        xmat_list = np.meshgrid(*swp_values, indexing='ij', copy=False)
        for idx, xmat in enumerate(xmat_list):
            xi[..., idx] = xmat

        values_ext = self._extfun(xi)
        self._filt_values = imag_interp.spline_filter(values_ext)
        DiffFunction.__init__(self, ndim, delta_list=delta_list)
    def __init__(self,
                 scale_list,
                 values,
                 extrapolate=False,
                 num_extrapolate=3,
                 delta=1e-4):
        shape = values.shape
        ndim = len(shape)

        # error checking
        if ndim < 3:
            raise ValueError('Data must have 3 or more dimensions.')
        elif ndim != len(scale_list):
            raise ValueError('input and output dimension mismatch.')

        self._scale_list = scale_list
        self._max = [n - 1 + num_extrapolate for n in shape]
        self._extrapolate = extrapolate
        self._ext = num_extrapolate

        # linearly extrapolate given values
        ext_points = [
            np.arange(num_extrapolate, n + num_extrapolate) for n in shape
        ]
        points, delta_list = _scales_to_points(scale_list, values, delta)
        input_ranges = [(pvec[0], pvec[-1]) for pvec in points]
        self._extfun = LinearInterpolator(ext_points,
                                          values, [delta] * ndim,
                                          extrapolate=True)

        xi_ext = np.stack(np.meshgrid(*(np.arange(0, n + 2 * num_extrapolate)
                                        for n in shape),
                                      indexing='ij',
                                      copy=False),
                          axis=-1)

        values_ext = self._extfun(xi_ext)
        self._filt_values = imag_interp.spline_filter(values_ext)

        DiffFunction.__init__(self, input_ranges, delta_list=delta_list)
예제 #8
0
    def __init__(self, data, pix_ref, shape_out, rebin):

        self._data = data
        self._data_spline = []
        for i in range(data.shape[0]):
            self._data_spline += [spline_filter(self._data[i], order=2)]

        self._axes = []
        for i in range(data.ndim):
            self._axes += [np.arange(0, data.shape[i], dtype=float)]

        #self._coords = np.meshgrid(*self._axes[1:], indexing='ij')
        self._rebin = rebin

        # Shape of global output array
        self._shape_out = shape_out

        self._shape = np.array(self.data.shape)
        for i in range(1, self.data.ndim):
            self._shape[i] = int(self._shape[i] / self.rebin)
        self._shape = tuple(self._shape)

        # Reference pixel coordinates
        self._pix_ref = pix_ref
예제 #9
0
    def __init__(self, data, pix_ref, shape_out, rebin):

        self._data = data
        self._data_spline = []
        for i in range(data.shape[0]):
            self._data_spline += [spline_filter(self._data[i], order=2)]

        self._axes = []
        for i in range(data.ndim):
            self._axes += [np.arange(0, data.shape[i], dtype=float)]

        #self._coords = np.meshgrid(*self._axes[1:], indexing='ij')
        self._rebin = rebin

        # Shape of global output array
        self._shape_out = shape_out

        self._shape = np.array(self.data.shape)
        for i in range(1, self.data.ndim):
            self._shape[i] = int(self._shape[i] / self.rebin)
        self._shape = tuple(self._shape)

        # Reference pixel coordinates
        self._pix_ref = pix_ref
 def setBeamCube (self,beam):
   """Initializes beam cube. Beam is a 2D (or 3D) cube.""";
   # init cube 
   self._beam = beam.copy();
   self._beam_ampl = abs(beam);
   self._beam_real = beam.real;
   self._beam_imag = beam.imag;
   # replace with pre-filtered arrays if needed 
   if beam.ndim > 2 and self._spline_order > 1:
     if not self._hier_interpol:
       self._beam_real = interpolation.spline_filter(beam.real,order=self._spline_order);
       self._beam_imag = interpolation.spline_filter(beam.imag,order=self._spline_order);
       self._beam_ampl = interpolation.spline_filter(self._beam_ampl,order=self._spline_order);
     else:
       # prefilter per frequency plane in per-frequency mode
       for i in range(beam.shape[2]):
         self._beam_real[...,i] = interpolation.spline_filter(beam.real[...,i],order=self._spline_order);
         self._beam_imag[...,i] = interpolation.spline_filter(beam.imag[...,i],order=self._spline_order);
         self._beam_ampl[...,i] = interpolation.spline_filter(self._beam_ampl[...,i],order=self._spline_order);
예제 #11
0
def spline_filter(grid,order=3):
    filtered = grid.copy()
    sciest.spline_filter(grid,order,filtered)
    return filtered
예제 #12
0
    def draw(self, painter, xmap, ymap, rect):
        """Implements QwtPlotItem.draw(), to render the image on the given painter."""
        xp1, xp2, xdp, xs1, xs2, xds = xinfo = xmap.p1(), xmap.p2(
        ), xmap.pDist(), xmap.s1(), xmap.s2(), xmap.sDist()
        yp1, yp2, ydp, ys1, ys2, yds = yinfo = ymap.p1(), ymap.p2(
        ), ymap.pDist(), ymap.s1(), ymap.s2(), ymap.sDist()
        dprint(5, "draw:", rect, xinfo, yinfo)
        self._current_rect = QRectF(QPointF(xs2, ys1), QSizeF(xds, yds))
        self._current_rect_pix = QRect(
            QPoint(*self.lmToPix(xs1, ys1)),
            QPoint(*self.lmToPix(xs2, ys2))).intersected(
                self._bounding_rect_pix)
        dprint(5, "draw:", self._current_rect_pix)
        # put together tuple describing current mapping
        mapping = xinfo, yinfo
        # if mapping has changed w.r.t. cache (i.e. zoom has changed), discard all cached QImages
        if mapping != self._cache_mapping:
            dprint(2, "does not match cached mapping, cache is:",
                   self._cache_mapping)
            dprint(2, "and we have:", mapping)
            self.clearDisplayCache()
            self._cache_mapping = mapping
        t0 = time.time()
        # check cached QImage for current image key.
        qimg = self._cache_qimage.get(self._image_key)
        if qimg:
            dprint(5, "QImage found in cache, reusing")
        # else regenerate image
        else:
            # check for cached intensity-mapped data
            if self._cache_imap is not None:
                dprint(5, "intensity-mapped data found in cache, reusing")
            else:
                if self._cache_interp is not None:
                    dprint(5, "interpolated data found in cache, reusing")
                else:
                    image = self._image.transpose(
                    ) if self._data_fortran_order else self._image
                    spline_order = 2
                    xsamp = abs(xmap.sDist() / xmap.pDist()) / abs(self._dl)
                    ysamp = abs(ymap.sDist() / ymap.pDist()) / abs(self._dm)
                    if max(xsamp, ysamp) < .33 or min(xsamp, ysamp) > 2:
                        spline_order = 1
                    dprint(2,
                           "regenerating drawing cache, sampling factors are",
                           xsamp, ysamp, "spline order is", spline_order)
                    self._cache_imap = None
                    if self._prefilter is None and spline_order > 1:
                        self._prefilter = interpolation.spline_filter(
                            image, order=spline_order)
                        dprint(2, "spline prefiltering took",
                               time.time() - t0, "secs")
                        t0 = time.time()
                    # make arrays of plot coordinates
                    # xp[0],yp[0] corresponds to pixel 0,0, where 0,0 is the upper-left corner of the plot
                    # the maps are in a funny order (w.r.t. meaning of p1/p2/s1/s2), so the indices here are determined empirically
                    # We also adjust by half-pixel, to get the world coordinate of the pixel _center_
                    xp = xmap.s1() - (xmap.sDist() / xmap.pDist()) * (
                        0.5 + numpy.arange(int(xmap.pDist())))
                    yp = ymap.s2() - (ymap.sDist() / ymap.pDist()) * (
                        0.5 + numpy.arange(int(ymap.pDist())))
                    # now convert plot coordinates into fractional image pixel coordinates
                    xi = self._x0 + (xp - self._l0) / self._dl
                    yi = self._y0 + (yp - self._m0) / self._dm
                    # interpolate image data
                    ###        # old code for nearest-neighbour interpolation
                    ###        # superceded by interpolation below (we simply round pixel coordinates to go to NN when oversampling)
                    ###        xi = xi.round().astype(int);
                    ###        oob_x = (xi<0)|(xi>=self._nx);
                    ###        xi[oob_x] = 0;
                    ###        yi = yi.round().astype(int);
                    ###        oob_y = (yi<0)|(yi>=self._ny);
                    ###        yi[oob_y] = 0;
                    ###        idx = (xi[:,numpy.newaxis]*self._ny + yi[numpy.newaxis,:]).ravel();
                    ###        interp_image = self._image.ravel()[idx].reshape((len(xi),len(yi)));
                    ###        interp_image[oob_x,:] = 0;
                    ###        interp_image[:,oob_y] = 0;
                    ###        self._qimage_cache = self.colormap.colorize(interp_image,self._img_range);
                    ###        self._qimage_cache_attrs = (rect,xinfo,yinfo);

                    # if either axis is oversampled by a factor of 3 or more, switch to nearest-neighbour interpolation by rounding pixel values
                    if xsamp < .33:
                        xi = xi.round()
                    if ysamp < .33:
                        yi = yi.round()
                    # make [2,nx,ny] array of interpolation coordinates
                    xy = numpy.zeros((2, len(xi), len(yi)))
                    xy[0, :, :] = xi[:, numpy.newaxis]
                    xy[1, :, :] = yi[numpy.newaxis, :]
                    # interpolate. Use NAN for out of range pixels...
                    # for fortran order, tranpose axes for extra speed (flip XY around then)
                    if self._data_fortran_order:
                        xy = xy[-1::-1, ...]
                    if spline_order > 1:
                        interp_image = interpolation.map_coordinates(
                            self._prefilter,
                            xy,
                            order=spline_order,
                            cval=numpy.nan,
                            prefilter=False)
                    else:
                        interp_image = interpolation.map_coordinates(
                            image, xy, order=spline_order, cval=numpy.nan)
                    # ...and put a mask on them (Colormap.colorize() will make these transparent).
                    mask = ~numpy.isfinite(interp_image)
                    self._cache_interp = numpy.ma.masked_array(
                        interp_image, mask)
                    dprint(2, "interpolation took",
                           time.time() - t0, "secs")
                    t0 = time.time()
                # ok, we have interpolated data in _cache_interp
                self._cache_imap = self.imap.remap(self._cache_interp)
                dprint(2, "intensity mapping took",
                       time.time() - t0, "secs")
                t0 = time.time()
            # ok, we have intensity-mapped data in _cache_imap
            qimg = self.colormap.colorize(self._cache_imap)
            dprint(2, "colorizing took",
                   time.time() - t0, "secs")
            t0 = time.time()
            # cache the qimage
            self._cache_qimage[self._image_key] = qimg.copy()
        # now draw the image
        t0 = time.time()
        painter.drawImage(xp1, yp2, qimg)
        dprint(2, "drawing took",
               time.time() - t0, "secs")
예제 #13
0
    def __init__(self,
                 cubefile,
                 convert_cube_content=False,
                 convert_to_rs=False,
                 PBC=True,
                 shift='edge',
                 order=3,
                 verbose=False,
                 precalc_weights=True):

        self.cubefile = cubefile

        # read the cube file
        # convert means density in e / A**3
        full_output = read_cube(cubefile,
                                full_output=True,
                                convert=convert_cube_content)

        # conveniently map dict content to instance variables:
        #       self.atoms
        #       self.cube_data
        #       self.voxdim
        #       self.origin
        self.__dict__.update(full_output)

        if verbose:
            print(get_cube_info(self.cubefile))

        self.convert_cube_content = convert_cube_content
        self.convert_to_rs = convert_to_rs

        # hard coded conversion factor
        self.A2au = 1. / Bohr

        # PBC treatment of the interpolation function
        self.PBC = PBC

        if self.PBC:
            self.mode = 'wrap'
        else:
            self.mode = 'constant'

        self.Q, self.Qinv = self._create_trafo_matrices(self.voxdim)

        # get the number of voxels
        self.Nx, self.Ny, self.Nz = self.cube_data.shape

        # get the cell
        self.cell = self.atoms.get_cell()

        # shifting the values
        shift = shift.lower()

        if shift == 'edge':
            self.shift = 0.0
        else:
            self.shift = 0.5

        # save spline order
        self.order = order

        # pre-calculate the spline weights (one-time process)
        # instead of doing this with every call to map_coordinates.
        # Acc. to Joe Kington's mail here:
        # http://scipy-user.10969.n7.nabble.com/SciPy-User-3D-spline-interpolation-very-very-slow-UPDATE-td19702.html
        if precalc_weights:
            self._cube_data = spline_filter(self.cube_data, order=self.order)
            # flag for map_coordinates
            self._prefilter = False
        else:
            self._cube_data = self.cube_data
            self._prefilter = True
예제 #14
0
 def read(self, filenames):
     freqs = []
     for ifreq, (filename_real, filename_imag) in enumerate(filenames):
         """Reads beam patterns from FITS files. If only one file is supplied, assumes a real-only beam.
   If two files are supplied, uses them for the real and imaginary parts.
   If 2N files are supplied, treats them as a frequency cube"""
         ff_re = pyfits.open(filename_real)[0]
         # form up complex beam
         beam = numpy.zeros(ff_re.data.shape, complex)
         beam.real = ff_re.data
         # add imaginary part
         if filename_imag:
             im_data = pyfits.open(filename_imag)[0].data
             if im_data.shape != ff_re.data.shape:
                 raise TypeError, "shape mismatch between FITS files %s and %s" % (
                     filename_real, filename_imag)
             beam.imag = im_data
         # change order of axis, since FITS has first axis last
         beam = beam.transpose()
         # figure out axes
         axes = FITSAxes(ff_re.header)
         used_axes = [axes.iaxis(x) for x in "L", "M", "FREQ"]
         if any([x < 0 for x in used_axes]):
             raise TypeError, "FITS file %s missing L, M or FREQ axis"
         laxis, maxis, freqaxis = used_axes
         # check the other axes
         other_axes = sorted(set(range(axes.ndim())) - set(used_axes))
         if any([axes.naxis(i) > 1 for i in other_axes]):
             raise TypeError, "FITS file %s has other non-trivial axes besides L/M" % filename_real
         # setup frequency grid
         freqgrid = axes.grid(freqaxis)
         if len(freqgrid) > 1:
             raise TypeError, "FITS file %s has >1 frequency points"
         if freqs and freqgrid[0] < freqs[-1]:
             raise TypeError, "FITS file %s has lower frequency than previous file -- monotonically increasing frequencies are expected"
         freqs.append(freqgrid[0])
         # check if it matches previous image
         if not ifreq:
             baseshape = beam.shape
             self._axes = axes
             # setup 3D beam cube
             beamcube = numpy.zeros(
                 (axes.naxis(laxis), axes.naxis(maxis), len(filenames)),
                 complex)
             # setup conversion functions
             self._lToPixel = Kittens.utils.curry(axes.toPixel, laxis)
             self._mToPixel = Kittens.utils.curry(axes.toPixel, maxis)
             for ax in laxis, maxis:
                 dprint(
                     1, "%s axis unit is %s" %
                     (self._axes.type(ax), self._axes.unit(ax)))
                 if not self._axes.unit(ax) or self._axes.unit(
                         ax).upper() == "DEG":
                     self._axes.setUnitScale(ax, DEG)
         else:
             if baseshape != beam.shape:
                 raise TypeError, "FITS file %s has differing dimensions" % filename_real
         beam = beam.transpose(used_axes + other_axes)
         beam = beam.reshape(beam.shape[:len(used_axes)])
         beamcube[:, :, ifreq] = beam[:, :, 0]
     # done reading the beam cube
     dprint(1, "beam array has shape", beamcube.shape)
     dprint(2, "l grid is", self._axes.grid(laxis))
     dprint(2, "m grid is", self._axes.grid(maxis))
     dprint(2, "freq grid is", freqs)
     self._freqaxis = freqs
     self._freq_interpolator = interpolate.interp1d(freqs,
                                                    range(len(freqs)),
                                                    'linear')
     # prefilter beam for interpolator
     self._beam = beamcube
     self._beam_ampl = numpy.abs(
         beamcube) if self.ampl_interpolation else None
     if self._spline_order > 1:
         self._beam_real = interpolation.spline_filter(
             beamcube.real, order=self._spline_order)
         self._beam_imag = interpolation.spline_filter(
             beamcube.imag, order=self._spline_order)
         if self._beam_ampl:
             self._beam_ampl = interpolation.spline_filter(
                 self._beam_ampl, order=self._spline_order)
     else:
         self._beam_real = beamcube.real
         self._beam_imag = beamcube.imag
예제 #15
0
    def read(self, filename_real, filename_imag=None):
        """Reads beam patterns from FITS files. If only one file is supplied, assumes a real-only beam.
    If two files are supplied, uses them for the real and imaginary parts.
    If 2N files are supplied, treats them as a frequency cube"""
        ff_re = pyfits.open(filename_real)[0]
        # form up complex beam
        beam = numpy.zeros(ff_re.data.shape, complex)
        beam.real = ff_re.data
        beam_ampl = None
        # add imaginary part
        if filename_imag:
            im_data = pyfits.open(filename_imag)[0].data
            if im_data.shape != ff_re.data.shape:
                raise TypeError, "shape mismatch between FITS files %s and %s" % (
                    filename_real, filename_imag)
            beam.imag = im_data
            if self.ampl_interpolation:
                beam_ampl = numpy.abs(beam)
        # change order of axis, since FITS has first axis last
        beam = beam.transpose()
        if not beam_ampl is None:
            beam_ampl = beam_ampl.transpose()
        # figure out axes
        self._axes = axes = FITSAxes(ff_re.header)
        # find L/M axes
        laxis = axes.iaxis(self._l_axis)
        maxis = axes.iaxis(self._m_axis)
        if laxis < 0 or maxis < 0:
            raise TypeError, "FITS file %s missing %s or %s axis" % (
                filename_real, self._l_axis, self._m_axis)
        # setup conversion functions
        self._lToPixel = Kittens.utils.curry(axes.toPixel,
                                             laxis,
                                             sign=self._l_axis_sign)
        self._mToPixel = Kittens.utils.curry(axes.toPixel,
                                             maxis,
                                             sign=self._m_axis_sign)
        # find frequency grid. self._freqToPixel will be None if no frequency axis
        freqaxis = axes.iaxis('FREQ')
        if freqaxis >= 0 and axes.naxis(freqaxis) > 1:
            dprint(1, "FREQ axis has %d points" % axes.naxis(freqaxis))
            self._freqgrid = axes.grid(freqaxis)
            self._freqToPixel = Kittens.utils.curry(axes.toPixel, freqaxis)
            used_axes = [laxis, maxis, freqaxis]
        else:
            self._freqToPixel = None
            used_axes = [laxis, maxis]
        # used_axes is either (l,m,freq) or (l,m)
        # other_axes is all that remains, and they had better be all trivial
        other_axes = sorted(set(range(axes.ndim())) - set(used_axes))
        if any([axes.naxis(i) > 1 for i in other_axes]):
            raise TypeError, "FITS file %s has other non-trivial axes besides L/M" % filename_real
        # setup units
        for ax in laxis, maxis:
            dprint(1, "%s axis unit is %s" % (axes.type(ax), axes.unit(ax)))
            if not axes.unit(ax) or axes.unit(ax).upper() == "DEG":
                axes.setUnitScale(ax, DEG)
        # transpose array into L,M order and reshape
        dprint(1, "beam array has shape", beam.shape)
        beam = beam.transpose(used_axes + other_axes)
        beam = beam.reshape(beam.shape[:len(used_axes)])
        if not beam_ampl is None:
            beam_ampl = beam_ampl.transpose(used_axes + other_axes)
            beam_ampl = beam_ampl.reshape(beam_ampl.shape[:len(used_axes)])

        dprint(1, "beam array has shape", beam.shape)
        dprint(2, "l grid is", axes.grid(laxis))
        dprint(2, "m grid is", axes.grid(maxis))
        if self._freqToPixel:
            dprint(2, "freq grid is", axes.grid(freqaxis))
        # prefilter beam for interpolator
        self._beam = beam
        if self._spline_order > 1:
            self._beam_real = interpolation.spline_filter(
                beam.real, order=self._spline_order)
            self._beam_imag = interpolation.spline_filter(
                beam.imag, order=self._spline_order)
            if not beam_ampl is None:
                self._beam_ampl = interpolation.spline_filter(
                    beam_ampl, order=self._spline_order)
            else:
                self._beam_ampl = beam_ampl
        else:
            self._beam_real = beam.real
            self._beam_imag = beam.imag
            self._beam_ampl = beam_ampl
예제 #16
0
 def calc_splinecoeffs(self):
     self.u_coeffs = spline_filter(self.u)
     self.v_coeffs = spline_filter(self.v)
     self.p0 = self.grid[:, 0, 0, 0]
     self.inv_dp = 1. / (self.grid[:, 1, 1, 1] - self.p0)
예제 #17
0
 def calc_splinecoeffs(self):
     self.u_coeffs = spline_filter(self.u)
     self.v_coeffs = spline_filter(self.v)
     self.p0 = self.grid[:,0,0,0]
     self.inv_dp = 1. / (self.grid[:,1,1,1] - self.p0)
    def smoothPlot(self):
        if not self.plotted_ticket is None:
            try:
                if self.filter==0 or 2<=self.filter<=5:
                    congruence.checkStrictlyPositiveNumber(self.filter_sigma_h, "Sigma/Size H")
                    congruence.checkStrictlyPositiveNumber(self.filter_sigma_v, "Sigma/Size V")

                if self.filter == 1: congruence.checkStrictlyPositiveNumber(self.filter_spline_order, "Spline Order")

                ticket = self.plotted_ticket.copy()

                mask = numpy.where(self.plotted_ticket["histogram"] <= self.plotted_ticket["histogram"].max()*self.masking_level)

                histogram = ticket["histogram"]
                h_coord = ticket["bin_h_center"]
                v_coord = ticket["bin_v_center"]

                norm = histogram.sum()

                pixel_area = (h_coord[1]-h_coord[0])*(v_coord[1]-v_coord[0])

                filter_mode = self.cb_filter_mode.currentText()

                if self.filter == 0:
                    histogram = filters.gaussian_filter(histogram, sigma=(self.filter_sigma_h, self.filter_sigma_v), mode=filter_mode, cval=self.filter_cval)
                elif self.filter == 1:
                    histogram = interpolation.spline_filter(histogram, order=int(self.filter_spline_order))
                elif self.filter == 2:
                    histogram = filters.uniform_filter(histogram, size=(int(self.filter_sigma_h), int(self.filter_sigma_v)), mode=filter_mode, cval=self.filter_cval)
                elif self.filter == 3:
                    histogram = numpy.real(numpy.fft.ifft2(fourier.fourier_gaussian(numpy.fft.fft2(histogram), sigma=(self.filter_sigma_h, self.filter_sigma_v))))
                elif self.filter == 4:
                    histogram = numpy.real(numpy.fft.ifft2(fourier.fourier_ellipsoid(numpy.fft.fft2(histogram), size=(self.filter_sigma_h, self.filter_sigma_v))))
                elif self.filter == 5:
                    histogram = numpy.real(numpy.fft.ifft2(fourier.fourier_uniform(numpy.fft.fft2(histogram), size=(self.filter_sigma_h, self.filter_sigma_v))))
                elif self.filter == 6:
                    histogram = self.apply_fill_holes(histogram)

                histogram[mask] = 0.0

                norm /= histogram.sum()

                ticket["histogram"] = histogram*norm
                
                if self.plot_canvas is None:
                    self.plot_canvas = PowerPlotXYWidget()
                    self.image_box.layout().addWidget(self.plot_canvas)

                cumulated_power_plot = numpy.sum(histogram)*pixel_area

                energy_min=0.0
                energy_max=0.0
                energy_step=0.0

                self.plot_canvas.cumulated_power_plot = cumulated_power_plot
                self.plot_canvas.plot_power_density_ticket(ticket,
                                                           ticket["h_label"],
                                                           ticket["v_label"],
                                                           cumulated_total_power=0.0,
                                                           energy_min=energy_min,
                                                           energy_max=energy_max,
                                                           energy_step=energy_step)

                self.plotted_ticket = ticket
            except Exception as e:
                QMessageBox.critical(self, "Error", str(e), QMessageBox.Ok)

                if self.IS_DEVELOP: raise e
예제 #19
0
def zoom(input, zoom, output=None, order=3, mode='constant', cval=0.0,
         prefilter=True):
    """
    Zoom an array.

    The array is zoomed using spline interpolation of the requested order.

    Parameters
    ----------
    input : ndarray
        The input array.
    zoom : float or sequence, optional
        The zoom factor along the axes. If a float, `zoom` is the same for each
        axis. If a sequence, `zoom` should contain one value for each axis.
    output : ndarray or dtype, optional
        The array in which to place the output, or the dtype of the returned
        array.
    order : int, optional
        The order of the spline interpolation, default is 3.
        The order has to be in the range 0-5.
    mode : str, optional
        Points outside the boundaries of the input are filled according
        to the given mode ('constant', 'nearest', 'reflect' or 'wrap').
        Default is 'constant'.
    cval : scalar, optional
        Value used for points outside the boundaries of the input if
        ``mode='constant'``. Default is 0.0
    prefilter : bool, optional
        The parameter prefilter determines if the input is pre-filtered with
        `spline_filter` before interpolation (necessary for spline
        interpolation of order > 1).  If False, it is assumed that the input is
        already filtered. Default is True.

    Returns
    -------
    return_value : ndarray or None
        The zoomed input. If `output` is given as a parameter, None is
        returned.

    """
    if order < 0 or order > 5:
        raise RuntimeError('spline order not supported')
    input = numpy.asarray(input)
    if numpy.iscomplexobj(input):
        raise TypeError('Complex type not supported')
    if input.ndim < 1:
        raise RuntimeError('input and output rank must be > 0')
    mode = _extend_mode_to_code(mode)
    if prefilter and order > 1:
        filtered = spline_filter(input, order, output = numpy.float64)
    else:
        filtered = input
    zoom = _ni_support._normalize_sequence(zoom, input.ndim)
    output_shape = tuple([int(ii * jj) for ii, jj in zip(input.shape, zoom)])

    zoom_div = numpy.array(output_shape, float)
    zoom = (numpy.array(input.shape)) / zoom_div

    # Zooming to non-finite values in unpredictable, so just choose
    # zoom factor 1 instead
    zoom[~numpy.isfinite(zoom)] = 1

    output, return_value = _ni_support._get_output(output, input,
                                                   shape=output_shape)
    zoom = numpy.asarray(zoom, dtype = numpy.float64)
    zoom = numpy.ascontiguousarray(zoom)
    _nd_image.zoom_shift(filtered, zoom, None, output, order, mode, cval)
    return return_value
 def read (self,filenames):
   freqs = [];
   for ifreq,(filename_real,filename_imag) in enumerate(filenames):
     """Reads beam patterns from FITS files. If only one file is supplied, assumes a real-only beam.
     If two files are supplied, uses them for the real and imaginary parts.
     If 2N files are supplied, treats them as a frequency cube"""
     ff_re = pyfits.open(filename_real)[0];
     # form up complex beam
     beam = numpy.zeros(ff_re.data.shape,complex);
     beam.real = ff_re.data;
     # add imaginary part
     if filename_imag:
       im_data = pyfits.open(filename_imag)[0].data;
       if im_data.shape != ff_re.data.shape:
         raise TypeError,"shape mismatch between FITS files %s and %s"%(filename_real,filename_imag);
       beam.imag = im_data;
     # change order of axis, since FITS has first axis last
     beam = beam.transpose();
     # figure out axes
     axes = FITSAxes(ff_re.header);
     used_axes = [ axes.iaxis(x) for x in "L","M","FREQ" ];
     if any([x<0 for x in used_axes]):
       raise TypeError,"FITS file %s missing L, M or FREQ axis";
     laxis,maxis,freqaxis = used_axes;
     # check the other axes
     other_axes = sorted(set(range(axes.ndim())) - set(used_axes));
     if any([axes.naxis(i)>1 for i in other_axes]):
       raise TypeError,"FITS file %s has other non-trivial axes besides L/M"%filename_real;
     # setup frequency grid
     freqgrid = axes.grid(freqaxis);
     if len(freqgrid) > 1:
       raise TypeError,"FITS file %s has >1 frequency points";
     if freqs and freqgrid[0] < freqs[-1]:
       raise TypeError,"FITS file %s has lower frequency than previous file -- monotonically increasing frequencies are expected";
     freqs.append(freqgrid[0]);
     # check if it matches previous image
     if not ifreq:
       baseshape = beam.shape;
       self._axes = axes;
       # setup 3D beam cube
       beamcube = numpy.zeros((axes.naxis(laxis),axes.naxis(maxis),len(filenames)),complex);
       # setup conversion functions
       self._lToPixel = Kittens.utils.curry(axes.toPixel,laxis);
       self._mToPixel = Kittens.utils.curry(axes.toPixel,maxis);
       for ax in laxis,maxis:
         dprint(1,"%s axis unit is %s"%(self._axes.type(ax),self._axes.unit(ax)));
         if not self._axes.unit(ax) or self._axes.unit(ax).upper() == "DEG":
           self._axes.setUnitScale(ax,DEG);
     else:
       if baseshape != beam.shape:
         raise TypeError,"FITS file %s has differing dimensions"%filename_real;
     beam = beam.transpose(used_axes+other_axes);
     beam = beam.reshape(beam.shape[:len(used_axes)]);
     beamcube[:,:,ifreq] = beam[:,:,0];
   # done reading the beam cube
   dprint(1,"beam array has shape",beamcube.shape);
   dprint(2,"l grid is",self._axes.grid(laxis));
   dprint(2,"m grid is",self._axes.grid(maxis));
   dprint(2,"freq grid is",freqs);
   self._freqaxis = freqs;
   self._freq_interpolator = interpolate.interp1d(freqs,range(len(freqs)),'linear');
   # prefilter beam for interpolator
   self._beam = beamcube;
   self._beam_ampl = numpy.abs(beamcube) if self.ampl_interpolation else None;
   if self._spline_order > 1:
     self._beam_real = interpolation.spline_filter(beamcube.real,order=self._spline_order);
     self._beam_imag = interpolation.spline_filter(beamcube.imag,order=self._spline_order);
     if self._beam_ampl:
       self._beam_ampl = interpolation.spline_filter(self._beam_ampl,order=self._spline_order);
   else:
     self._beam_real = beamcube.real;
     self._beam_imag = beamcube.imag;
  def read (self,filename_real,filename_imag=None):
    """Reads beam patterns from FITS files. If only one file is supplied, assumes a real-only beam.
    If two files are supplied, uses them for the real and imaginary parts.
    If 2N files are supplied, treats them as a frequency cube"""
    ff_re = pyfits.open(filename_real)[0];
    # form up complex beam
    beam = numpy.zeros(ff_re.data.shape,complex);
    beam.real = ff_re.data;
    beam_ampl = None
    # add imaginary part
    if filename_imag:
      im_data = pyfits.open(filename_imag)[0].data;
      if im_data.shape != ff_re.data.shape:
        raise TypeError,"shape mismatch between FITS files %s and %s"%(filename_real,filename_imag);
      beam.imag = im_data;
      if self.ampl_interpolation:
        beam_ampl = numpy.abs(beam)
    # change order of axis, since FITS has first axis last
    beam = beam.transpose();
    if not beam_ampl is None:
      beam_ampl = beam_ampl.transpose()
    # figure out axes
    self._axes = axes = FITSAxes(ff_re.header);
    # find L/M axes
    laxis = axes.iaxis('L');
    maxis = axes.iaxis('M');
    if laxis<0 or maxis<0:
      raise TypeError,"FITS file %s missing L or M axis"%filename_real;
    # setup conversion functions
    self._lToPixel = Kittens.utils.curry(axes.toPixel,laxis);
    self._mToPixel = Kittens.utils.curry(axes.toPixel,maxis);
    # find frequency grid. self._freqToPixel will be None if no frequency axis
    freqaxis = axes.iaxis('FREQ');
    if freqaxis >= 0 and axes.naxis(freqaxis) > 1:
      dprint(1,"FREQ axis has %d points"%axes.naxis(freqaxis));
      self._freqgrid = axes.grid(freqaxis);
      self._freqToPixel = Kittens.utils.curry(axes.toPixel,freqaxis);
      used_axes = [laxis,maxis,freqaxis];
    else:
      self._freqToPixel = None;
      used_axes = [laxis,maxis];
    # used_axes is either (l,m,freq) or (l,m)
    # other_axes is all that remains, and they had better be all trivial
    other_axes = sorted(set(range(axes.ndim())) - set(used_axes));
    if any([axes.naxis(i)>1 for i in other_axes]):
      raise TypeError,"FITS file %s has other non-trivial axes besides L/M"%filename_real;
    # setup units
    for ax in laxis,maxis:
      dprint(1,"%s axis unit is %s"%(axes.type(ax),axes.unit(ax)));
      if not axes.unit(ax) or axes.unit(ax).upper() == "DEG":
        axes.setUnitScale(ax,DEG);
    # transpose array into L,M order and reshape
    dprint(1,"beam array has shape",beam.shape);
    beam = beam.transpose(used_axes+other_axes);
    beam = beam.reshape(beam.shape[:len(used_axes)]);
    if not beam_ampl is None:
      beam_ampl = beam_ampl.transpose(used_axes+other_axes)
      beam_ampl = beam_ampl.reshape(beam_ampl.shape[:len(used_axes)]);

    dprint(1,"beam array has shape",beam.shape);
    dprint(2,"l grid is",axes.grid(laxis));
    dprint(2,"m grid is",axes.grid(maxis));
    if self._freqToPixel:
      dprint(2,"freq grid is",axes.grid(freqaxis));
    # prefilter beam for interpolator
    self._beam = beam;
    if self._spline_order > 1:
      self._beam_real = interpolation.spline_filter(beam.real,order=self._spline_order);
      self._beam_imag = interpolation.spline_filter(beam.imag,order=self._spline_order);
      if not beam_ampl is None:
        self._beam_ampl = interpolation.spline_filter(beam_ampl,order=self._spline_order);
      else:
        self._beam_ampl = beam_ampl
    else:
      self._beam_real = beam.real;
      self._beam_imag = beam.imag;
      self._beam_ampl = beam_ampl
예제 #22
0
  def draw (self,painter,xmap,ymap,rect):
    """Implements QwtPlotItem.draw(), to render the image on the given painter.""";
    xp1,xp2,xdp,xs1,xs2,xds = xinfo = xmap.p1(),xmap.p2(),xmap.pDist(),xmap.s1(),xmap.s2(),xmap.sDist();
    yp1,yp2,ydp,ys1,ys2,yds = yinfo = ymap.p1(),ymap.p2(),ymap.pDist(),ymap.s1(),ymap.s2(),ymap.sDist();
    dprint(5,"draw:",rect,xinfo,yinfo);
    self._current_rect = QRectF(QPointF(xs2,ys1),QSizeF(xds,yds));
    self._current_rect_pix = QRect(QPoint(*self.lmToPix(xs1,ys1)),QPoint(*self.lmToPix(xs2,ys2))).intersected(self._bounding_rect_pix);
    dprint(5,"draw:",self._current_rect_pix);
    # put together tuple describing current mapping
    mapping = xinfo,yinfo;
    # if mapping has changed w.r.t. cache (i.e. zoom has changed), discard all cached QImages
    if mapping != self._cache_mapping:
      dprint(2,"does not match cached mapping, cache is:",self._cache_mapping);
      dprint(2,"and we have:",mapping);
      self.clearDisplayCache();
      self._cache_mapping = mapping;
    t0 = time.time();
    # check cached QImage for current image key.
    qimg = self._cache_qimage.get(self._image_key);
    if qimg:
      dprint(5,"QImage found in cache, reusing");
    # else regenerate image
    else:
      # check for cached intensity-mapped data
      if self._cache_imap is not None:
        dprint(5,"intensity-mapped data found in cache, reusing");
      else:
        if self._cache_interp is not None:
          dprint(5,"interpolated data found in cache, reusing");
        else:
          image = self._image.transpose() if self._data_fortran_order else self._image;
          spline_order = 2;
          xsamp = abs(xmap.sDist()/xmap.pDist())/abs(self._dl);
          ysamp = abs(ymap.sDist()/ymap.pDist())/abs(self._dm);
          if max(xsamp,ysamp) < .33 or min(xsamp,ysamp) > 2:
            spline_order = 1;
          dprint(2,"regenerating drawing cache, sampling factors are",xsamp,ysamp,"spline order is",spline_order);
          self._cache_imap = None;
          if self._prefilter is None and spline_order>1:
            self._prefilter = interpolation.spline_filter(image,order=spline_order);
            dprint(2,"spline prefiltering took",time.time()-t0,"secs"); t0 = time.time();
          # make arrays of plot coordinates
          # xp[0],yp[0] corresponds to pixel 0,0, where 0,0 is the upper-left corner of the plot
          # the maps are in a funny order (w.r.t. meaning of p1/p2/s1/s2), so the indices here are determined empirically
          # We also adjust by half-pixel, to get the world coordinate of the pixel _center_
          xp = xmap.s1() - (xmap.sDist()/xmap.pDist())*(0.5+numpy.arange(int(xmap.pDist())));
          yp = ymap.s2() - (ymap.sDist()/ymap.pDist())*(0.5+numpy.arange(int(ymap.pDist())));
          # now convert plot coordinates into fractional image pixel coordinates
          xi = self._x0 + (xp - self._l0)/self._dl;
          yi = self._y0 + (yp - self._m0)/self._dm;
          # interpolate image data
          ###        # old code for nearest-neighbour interpolation
          ###        # superceded by interpolation below (we simply round pixel coordinates to go to NN when oversampling)
          ###        xi = xi.round().astype(int);
          ###        oob_x = (xi<0)|(xi>=self._nx);
          ###        xi[oob_x] = 0;
          ###        yi = yi.round().astype(int);
          ###        oob_y = (yi<0)|(yi>=self._ny);
          ###        yi[oob_y] = 0;
          ###        idx = (xi[:,numpy.newaxis]*self._ny + yi[numpy.newaxis,:]).ravel();
          ###        interp_image = self._image.ravel()[idx].reshape((len(xi),len(yi)));
          ###        interp_image[oob_x,:] = 0;
          ###        interp_image[:,oob_y] = 0;
          ###        self._qimage_cache = self.colormap.colorize(interp_image,self._img_range);
          ###        self._qimage_cache_attrs = (rect,xinfo,yinfo);

          # if either axis is oversampled by a factor of 3 or more, switch to nearest-neighbour interpolation by rounding pixel values
          if xsamp < .33:
            xi = xi.round();
          if ysamp < .33:
            yi = yi.round();
          # make [2,nx,ny] array of interpolation coordinates
          xy = numpy.zeros((2,len(xi),len(yi)));
          xy[0,:,:] = xi[:,numpy.newaxis];
          xy[1,:,:] = yi[numpy.newaxis,:];
          # interpolate. Use NAN for out of range pixels...
          # for fortran order, tranpose axes for extra speed (flip XY around then)
          if self._data_fortran_order:
            xy = xy[-1::-1,...];
          if spline_order > 1:
            interp_image = interpolation.map_coordinates(self._prefilter,xy,order=spline_order,cval=numpy.nan,prefilter=False);
          else:
            interp_image = interpolation.map_coordinates(image,xy,order=spline_order,cval=numpy.nan);
          # ...and put a mask on them (Colormap.colorize() will make these transparent).
          mask = ~numpy.isfinite(interp_image);
          self._cache_interp = numpy.ma.masked_array(interp_image,mask);
          dprint(2,"interpolation took",time.time()-t0,"secs"); t0 = time.time();
        # ok, we have interpolated data in _cache_interp
        self._cache_imap = self.imap.remap(self._cache_interp);
        dprint(2,"intensity mapping took",time.time()-t0,"secs"); t0 = time.time();
      # ok, we have intensity-mapped data in _cache_imap
      qimg = self.colormap.colorize(self._cache_imap);
      dprint(2,"colorizing took",time.time()-t0,"secs"); t0 = time.time();
      # cache the qimage
      self._cache_qimage[self._image_key] = qimg.copy();
    # now draw the image
    t0 = time.time();
    painter.drawImage(xp1,yp2,qimg);
    dprint(2,"drawing took",time.time()-t0,"secs");