def xyregrid(img, mask, X, Y, nx=None, ny=None):
    ''' regrid with (nx,ny) points. 
        This can also be used on QPHI coordinates
        any 2D rectangular grid.
    '''

    pixellist = np.where(mask.ravel() == 1)
    data = img.ravel()[pixellist]

    x = X.ravel()[pixellist]
    y = Y.ravel()[pixellist]
    xlist = linplist(np.min(X), np.max(X), nx)
    ylist = linplist(np.min(Y), np.max(Y), ny)
    xid, yid, pselect = partition2D(xlist, ylist, x, y)
    bid = (yid * nx + xid)

    xy = partition_avg(data[pselect], bid)
    x_new = partition_avg(x[pselect], bid)
    y_new = partition_avg(y[pselect], bid)
    mask_new = partition_avg(pselect * 0 + 1, bid)

    xytot = np.zeros((ny, nx))
    X_new = np.zeros((ny, nx))
    Y_new = np.zeros((ny, nx))
    MASK_new = np.zeros((ny, nx))

    maxid = np.max(bid)
    xytot.ravel()[:maxid + 1] = xy
    X_new.ravel()[:maxid + 1] = x_new
    Y_new.ravel()[:maxid + 1] = y_new
    MASK_new.ravel()[:maxid + 1] = mask_new

    return xytot, MASK_new, X_new, Y_new
Exemple #2
0
def deltaphicorr_qphivals(img1,
                          img2,
                          mask=None,
                          qlist=None,
                          philist=None,
                          dq=0,
                          noqs=None,
                          nophis=None,
                          x0=None,
                          y0=None,
                          interp=0):
    ''' return the qs and phis for the delta phicorrelation parameters
    '''

    if (x0 is None):
        x0 = img1.shape[1] / 2
    if (y0 is None):
        y0 = img1.shape[0] / 2
    if (mask is None):
        mask = np.ones(img1.shape)
    if (qlist is None):
        if (noqs is None):
            noqs = 800
    else:
        noqs = len(qlist) // 2
    if (philist is None):
        if (nophis is None):
            nophis = 360
    else:
        nophis = len(philist) // 2

    #   0. get pixellist and relevant data
    pxlst = np.where(mask.ravel() == 1)
    data1 = img1.ravel()[pxlst]
    data2 = img2.ravel()[pxlst]

    #   1. Make coord system and grab selected pixels (only if qlist or philist not specified)
    if (qlist is None or philist is None):
        QS, PHIS = mkpolar(img1, x0=x0, y0=y0)
        qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    #   2.  make the lists for selection (only if qlist of philist not specified)
    if (qlist is None):
        qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    else:
        qlist_m1 = qlist

    if (philist is None):
        philist_m1 = linplist(np.min(phis), np.max(phis), nophis)
    else:
        philist_m1 = philist

    qs_m1 = (qlist_m1[0::2] + qlist_m1[1::2]) / 2.
    phis_m1 = (philist_m1[0::2] + philist_m1[1::2]) / 2.

    return qs_m1, phis_m1
def xy2qphi(img, mask, X, Y, noqs=None, nophis=None):
    ''' Transform image from coordinates x,y to q,phi.
        Uses a binning scheme.
    '''
    if (mask is None):
        pxlst = np.arange(img.shape[0] * img.shape[1])
    else:
        pxlst = np.where(mask.ravel() == 1)[0]

    # make q coordinate system
    QS, PHIS = mkpolar(X=X, Y=Y)
    qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    data = img.ravel()[pxlst]

    if (noqs is None):
        noqs = (np.max(qs) - np.min(qs))

    if (nophis is None):
        nophis = 12

    # make the lists for selection
    nophis = int(nophis)
    noqs = int(noqs)
    qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    philist_m1 = linplist(np.min(phis), np.max(phis), nophis)

    # partition the grid (digitize)
    qid, pid, pselect = partition2D(qlist_m1, philist_m1, qs, phis)
    bid = (qid * nophis + pid).astype(int)

    # average the partitions
    sq = partition_avg(data[pselect], bid)
    q_new = partition_avg(qs[pselect], bid)
    phi_new = partition_avg(phis[pselect], bid)
    mask_new = partition_avg(pselect * 0 + 1, bid)

    sqtot = np.zeros((noqs, nophis))
    Q_new = np.zeros((noqs, nophis))
    PHI_new = np.zeros((noqs, nophis))
    MASK_new = np.zeros((noqs, nophis))

    maxid = np.max(bid)
    sqtot.ravel()[:maxid + 1] = sq
    Q_new.ravel()[:maxid + 1] = q_new
    PHI_new.ravel()[:maxid + 1] = phi_new
    MASK_new.ravel()[:maxid + 1] = mask_new

    return sqtot, MASK_new, Q_new, PHI_new
def qphi2xy(img, mask, Q, PHI, noxs=None, noys=None):
    ''' Transform image from coordinates x,y to q,phi.
        Uses a binning scheme.
    '''
    if (mask is None):
        pxlst = np.arange(img.shape[0] * img.shape[1])
    else:
        pxlst = np.where(mask.ravel() == 1)[0]

    X, Y = mkcartesian(Q=Q, PHI=PHI)
    x, y = X.ravel()[pxlst], Y.ravel()[pxlst]

    data = img.ravel()[pxlst]

    if (noxs is None):
        noxs = 400

    if (noys is None):
        noys = 400

    noxs = int(noxs)
    noys = int(noys)
    xlist_m1 = linplist(np.min(x), np.max(x), noxs)
    ylist_m1 = linplist(np.min(y), np.max(y), noys)

    xid, yid, pselect = partition2D(xlist_m1, ylist_m1, x, y)
    bid = (yid * noxs + xid).astype(int)

    xy = partition_avg(data[pselect], bid)
    x_new = partition_avg(x[pselect], bid)
    y_new = partition_avg(y[pselect], bid)
    mask_new = partition_avg(pselect * 0 + 1, bid)

    xytot = np.zeros((noys, noxs))
    X_new = np.zeros((noys, noxs))
    Y_new = np.zeros((noys, noxs))
    MASK_new = np.zeros((noys, noxs))

    maxid = np.max(bid)
    xytot.ravel()[:maxid + 1] = xy
    X_new.ravel()[:maxid + 1] = x_new
    Y_new.ravel()[:maxid + 1] = y_new
    MASK_new.ravel()[:maxid + 1] = mask_new

    return xytot, MASK_new, X_new, Y_new
Exemple #5
0
def circsum(img, x0=None, y0=None, mask=None, SIMG=None, noqs=None):
    ''' Compute a circular sum of the data. 
        x0 : x center
        y0 : y center
        mask : the mask
        If SIMG is not null, put the data into this image.
        noqs : the number of qs to partition into. Default is 
            the number of pixels approximately.
    '''
    dimy, dimx = img.shape
    if (mask is None):
        pxlst = np.arange(dimx * dimy)
    else:
        pxlst = np.where(mask.ravel() == 1)[0]

    if (x0 is None):
        x0 = dimx / 2
    if (y0 is None):
        y0 = dimy / 2

    QS, PHIS = mkpolar(img, x0=x0, y0=y0)
    qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    data = img.ravel()[pxlst]

    if (noqs is None):
        noqs = (np.max(qs) - np.min(qs)).astype(int)
    qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    #philist_m1 = linplist(np.min(phis),np.max(phis),1)

    qid, pselect = partition1D(qlist_m1, qs)

    sqy = partition_sum(data[pselect], qid)
    #sqx = partition_avg(qs[pselect],qid)
    sqx = (qlist_m1[0::2] + qlist_m1[1::2]) / 2.

    if (SIMG is not None):
        SIMGtmp = 0 * SIMG
        SIMGtmp = np.interp(QS, sqx, sqy)
        np.copyto(SIMG, SIMGtmp)
    return sqx, sqy
Exemple #6
0
def qphisum(img,
            x0=None,
            y0=None,
            mask=None,
            SIMG=None,
            qlist=None,
            philist=None,
            noqs=None,
            nophis=None,
            interp=None):
    ''' Compute a qphi average of the data. 
        x0 : x center
        y0 : y center
        mask : the mask
        If SIMG is not null, put the data into this image.
        noqs : the number of qs to partition into. Default is 
            the number of pixels approximately.
        interp : interpolation methods:
            None (default) : no interpolation
            1 : interpolate in phi only (loop over q's)
            ... so far no other methods
    '''
    dimy, dimx = img.shape
    if (mask is None):
        pxlst = np.arange(dimx * dimy)
    else:
        pxlst = np.where(mask.ravel() == 1)[0]

    if (x0 is None):
        x0 = dimx / 2
    if (y0 is None):
        y0 = dimy / 2
    if (qlist is None):
        if (noqs is None):
            noqs = 800
        qlist_m1 = None
    elif (len(qlist) == 1):
        noqs = qlist
        qlist_m1 = None
    else:
        qlist_m1 = np.array(qlist)
        noqs = qlist_m1.shape[0] // 2

    if (philist is None):
        if (nophis is None):
            nophis = 360
        philist_m1 = None
    elif (len(philist) == 1):
        noqs = philist
        philist_m1 = None
    else:
        philist_m1 = np.array(philist)
        nophis = philist_m1.shape[0] // 2

    QS, PHIS = mkpolar(img, x0=x0, y0=y0)
    qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    data = img.ravel()[pxlst]

    if (noqs is None):
        noqs = (np.max(qs) - np.min(qs))
    if (nophis is None):
        nophis = 12

    nophis = int(nophis)
    noqs = int(noqs)
    if (qlist_m1 is None):
        qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    if (philist_m1 is None):
        philist_m1 = linplist(np.min(phis), np.max(phis), nophis)

    qid, pid, pselect = partition2D(qlist_m1, philist_m1, qs, phis)
    bid = (qid * nophis + pid).astype(int)

    sqphi = partition_sum(data[pselect], bid)

    sqphitot = np.zeros((noqs, nophis))
    maxid = np.max(bid)
    sqphitot.ravel()[:maxid + 1] = sqphi

    phis_m1 = (philist_m1[0::2] + philist_m1[1::2]) / 2.
    qs_m1 = (qlist_m1[0::2] + qlist_m1[1::2]) / 2.

    if (interp is not None):
        sqmask = np.zeros((noqs, nophis))
        sqmask.ravel()[:maxid + 1] = partition_avg(pselect * 0 + 1, bid)
        if ((interp == 1) or (interp == 2)):
            for i in range(sqphitot.shape[0]):
                # won't work if you have numpy version < 1.10
                sqphitot[i] = fillin1d(phis_m1,
                                       sqphitot[i],
                                       sqmask[i],
                                       period=2 * np.pi)
                # best suited for phi range -pi/2 to pi/2, might need to change
                # for diff versions
        if interp == 2:
            # second interp method also uses point symmetry
            # reverse philist, and rebin
            # assume the point of reflection is about zero, if not, maybe this
            # commented code could be tried (not tested)
            # first, find the point of reflection (is it about zero, -pi or pi?)
            #avgphi = np.average(phis_m1)
            #if(avgphi > -np.pi/2. and avgphi < np.pi/2.):
            #const = 0. #do nothing
            #elif(avgphi > np.pi/2. and avgphi < 3*np.pi/2.):
            #const = np.pi
            #elif(avgphi > -3*np.pi/2. and avgphi < -np.pi/2.):
            #const = np.pi
            const = 0.
            # now reflect philist
            philist_rev = const - philist_m1[::-1]
            qidr, pidr, pselectr = partition2D(qlist_m1, philist_rev, qs, phis)
            bidr = (qidr * nophis + pidr).astype(int)
            maxidr = np.max(bidr)
            sqphitotr = np.zeros((noqs, nophis))
            sqphitotr.ravel()[:maxidr + 1] = partition_avg(
                data[pselectr], bidr)
            sqphitotr = sqphitotr[:, ::-1]
            sqmaskr = np.zeros((noqs, nophis))
            sqmaskr.ravel()[:maxidr + 1] = partition_avg(
                pselectr * 0 + 1, bidr)
            sqmaskr = sqmaskr[:, ::-1]
            # now fill in values
            # just fill in the points, don't interp
            w = np.where((sqmask == 0) * (sqmaskr == 1))
            sqphitot[w] = sqphitotr[w]

    if (SIMG is not None):
        SIMG.ravel()[pxlst[pselect]] = sqphitot.ravel()[bid]

    return sqphitot
Exemple #7
0
def deltaphiqqcorr(img1,
                   img2,
                   mask=None,
                   qlist=None,
                   philist=None,
                   noqs=None,
                   nophis=None,
                   x0=None,
                   y0=None,
                   interp=0,
                   PF=False):
    ''' The new delta phi correlations. This one returns a:
        q1,q2,dphi matrix where each element is <I(q1,phi)*I(q2,phi+dphi)>_phi
        img1, img2 : used for the correlations (set to equal if same image)
            this is a 2nd moment calc so you need two quantities
        mask : the mask for the data set
        It uses the binning scheme only in one step. It transforms the image to
            a qphi square grid. It then uses FFT's to transform to a qphi correlation.
        NOTE: This will take quite a bit of memory depending on how big your qlist is.
        '''
    if (x0 is None):
        x0 = img1.shape[1] / 2
    if (y0 is None):
        y0 = img1.shape[0] / 2
    if (mask is None):
        mask = np.ones(img1.shape)
    if (qlist is None):
        if (noqs is None):
            noqs = 800
    else:
        noqs = len(qlist) // 2
    if (philist is None):
        if (nophis is None):
            nophis = 360
    else:
        nophis = len(philist) // 2

    #   0. get pixellist and relevant data
    pxlst = np.where(mask.ravel() == 1)
    data1 = img1.ravel()[pxlst]
    data2 = img2.ravel()[pxlst]

    #   1. Make coord system and grab selected pixels (only if qlist or philist not specified)
    if (qlist is None or philist is None):
        QS, PHIS = mkpolar(img1, x0=x0, y0=y0)
        qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    #   2.  make the lists for selection (only if qlist of philist not specified)
    if (qlist is None):
        qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    else:
        qlist_m1 = qlist

    if (philist is None):
        philist_m1 = linplist(np.min(phis), np.max(phis), nophis)
    else:
        philist_m1 = philist

    qs_m1 = (qlist_m1[0::2] + qlist_m1[1::2]) / 2.
    phis_m1 = (philist_m1[0::2] + philist_m1[1::2]) / 2.

    # 3. transform image into a qphi map (and mask)
    sq1 = qphiavg(img1,
                  mask=mask,
                  x0=x0,
                  y0=y0,
                  qlist=qlist_m1,
                  philist=philist_m1,
                  interp=interp)
    sq2 = qphiavg(img2,
                  mask=mask,
                  x0=x0,
                  y0=y0,
                  qlist=qlist_m1,
                  philist=philist_m1,
                  interp=interp)
    sqmask = qphiavg(img1 * 0 + 1,
                     mask=mask,
                     x0=x0,
                     y0=y0,
                     qlist=qlist_m1,
                     philist=philist_m1,
                     interp=interp)

    # calculate the correlation (2nd moment, keep same binning as first moment)
    nx = np.arange(noqs)
    NX = np.tile(nx, (noqs, 1))
    NY = np.copy(NX.T)

    # indexing tricks, expand s(q,phi) into s(q1,q2, phi)
    sqd1 = sq1[NX, :]
    sqd2 = sq2[NY, :]
    sqmask1 = sqmask[NX, :]
    sqmask2 = sqmask[NY, :]

    # perform convolution in phi
    sqqphi = convol1d(sqd1, sqd2, axis=2)
    sqmask = convol1d(sqmask1, sqmask2, axis=2)
    w = np.where(sqmask != 0)
    sqqphi[w] /= sqmask[w]

    #    # perform convolution
    #    for i in np.arange(-noqs+1,noqs):
    #        if (PF is True):
    #            print("Iterating over slice {} of {}".format(noqs+i,2*noqs+1))
    #        # grab the slice in q
    #        w = np.where(TX-TY == i)
    #        rngbeg = np.maximum(i,0)
    #        rngend = np.minimum(noqs,noqs+i)
    #        sq1tmp = np.roll(sq1,i,axis=0)[rngbeg:rngend,:]
    #        sq2tmp = sq2[rngbeg:rngend]
    #        sqmask1 = np.roll(sqmask,i,axis=0)[rngbeg:rngend,:]
    #        sqmask2 = sqmask[rngbeg:rngend,:]
    #        sqcphi = ifft(fft(sq2tmp,axis=1)*np.conj(fft(sq1tmp,axis=1)),axis=1).real
    #        sqcphimask = ifft(fft(sqmask1,axis=1)*np.conj(fft(sqmask2,axis=1)),axis=1).real
    #        sqcphi /= sqcphimask
    #        sqcphitot[w[0],w[1],:] = sqcphi

    return sqqphi
Exemple #8
0
def deltaphiqqdiff(img1,
                   img2,
                   mask=None,
                   noqs=None,
                   nophis=None,
                   x0=None,
                   y0=None,
                   PF=False):
    ''' A delta phi difference correlation. This one returns a:
        q1,q2,dphi matrix where each element is <(I(q1,phi)-I(q2,phi+dphi))^2>_phi
        img1, img2 : used for the correlations (set to equal if same image)
            this is a 2nd moment calc so you need two quantities
        mask : the mask for the data set
        It uses the binning scheme only in one step. It transforms the image to
            a qphi square grid. It then uses FFT's to transform to a qphi correlation.
        '''
    if (x0 is None):
        x0 = img1.shape[1] / 2
    if (y0 is None):
        y0 = img1.shape[0] / 2
    if (mask is None):
        mask = np.ones(IMG.shape)
    if (noqs is None):
        noqs = 800
    if (nophis is None):
        nophis = 360

    #   0. get pixellist and relevant data
    pxlst = np.where(mask.ravel() == 1)
    data1 = img1.ravel()[pxlst]
    data2 = img2.ravel()[pxlst]

    #   1. Make coord system and grab selected pixels
    QS, PHIS = mkpolar(img1, x0=x0, y0=y0)
    qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    #   2.  make the lists for selection
    qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    philist_m1 = linplist(np.min(phis), np.max(phis), nophis)

    #   3.  partition according to the lists, 2D here, make bin id 1 dimensional
    qid, pid, pselect = partition2D(qlist_m1, philist_m1, qs, phis)
    bid = (qid * nophis + pid).astype(int)

    # the sqphi here
    sq1 = np.zeros((noqs, nophis))
    sq2 = np.zeros((noqs, nophis))
    sq_qs = np.zeros((noqs, nophis))
    sq_phis = np.zeros((noqs, nophis))
    sqmask = np.zeros((noqs, nophis))

    maxid = np.max(bid)
    sq1.ravel()[:maxid + 1] = partition_avg(data1[pselect], bid)
    sq2.ravel()[:maxid + 1] = partition_avg(data2[pselect], bid)
    sq_qs.ravel()[:maxid + 1] = partition_avg(qs[pselect], bid)
    sq_phis.ravel()[:maxid + 1] = partition_avg(phis[pselect], bid)
    sqmask.ravel()[:maxid + 1] = partition_avg(pselect * 0 + 1, bid)

    sq_qs = np.sum(sq_qs, axis=1) / np.sum(sqmask, axis=1)
    sq_phis = np.sum(sq_phis, axis=1) / np.sum(sqmask, axis=1)

    sqcphitot = np.zeros((noqs, noqs, nophis))
    tx = np.arange(noqs)
    ty = np.arange(noqs)
    TX, TY = np.meshgrid(tx, ty)

    # perform convolution
    for i in np.arange(-noqs + 1, noqs):
        if (PF is True):
            print("Iterating over slice {} of {}".format(
                noqs + i, 2 * noqs + 1))
        # grab the slice in q
        w = np.where(TX - TY == i)
        rngbeg = np.maximum(i, 0)
        rngend = np.minimum(noqs, noqs + i)
        sq1tmp = np.roll(sq1, i, axis=0)[rngbeg:rngend, :]
        sq2tmp = sq2[rngbeg:rngend]
        sqmask1 = np.roll(sqmask, i, axis=0)[rngbeg:rngend, :]
        sqmask2 = sqmask[rngbeg:rngend, :]
        sqcphi = ifft(fft(sq2tmp, axis=1) * np.conj(fft(sq1tmp, axis=1)),
                      axis=1).real
        sqcphimask = ifft(fft(sqmask1, axis=1) * np.conj(fft(sqmask2, axis=1)),
                          axis=1).real
        sqcphi /= sqcphimask
        sqcphitot[w[0], w[1], :] = sqcphi

    return sq_qs, sq_phis, sqcphitot
Exemple #9
0
def deltaphidiff(img1,
                 img2,
                 mask=None,
                 qlist=None,
                 philist=None,
                 x0=None,
                 y0=None,
                 PF=False,
                 interp=0):
    ''' The new delta phi difference correlations.
        img1, img2 : used for the correlations (set to equal if same image)
            this is a 2nd moment calc so you need two quantities
        mask : the mask for the data set
        It uses the binning scheme only in one step. It transforms the image to
            a qphi square grid. It then uses FFT's to transform to a qphi correlation.
        interp : interpolation method. 
            0 - none (default)
            1 - linear interpolation
            2 - linear interpolation and reflect about 180 degrees (if possible)
        '''
    if (x0 is None):
        x0 = img1.shape[1] / 2
    if (y0 is None):
        y0 = img1.shape[0] / 2
    if (mask is None):
        mask = np.ones(IMG.shape)
    if (qlist is None):
        noqs = 800
        qlist_m1 = None
    elif (len(qlist) == 1):
        noqs = qlist
        qlist_m1 = None
    else:
        qlist_m1 = qlist

    if (philist is None):
        nophis = 360
        philist_m1 = None
    elif (len(philist) == 1):
        noqs = philist
        philist_m1 = None
    else:
        philist_m1 = qlist

    #   0. get pixellist and relevant data
    pxlst = np.where(mask.ravel() == 1)
    data1 = img1.ravel()[pxlst]
    data2 = img2.ravel()[pxlst]

    #   1. Make coord system and grab selected pixels
    QS, PHIS = mkpolar(img1, x0=x0, y0=y0)
    qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    #   2.  make the lists for selection
    # m1 means 1st moment
    if (qlist_m1 is None):
        qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    if (philist_m1 is None):
        philist_m1 = linplist(np.min(phis), np.max(phis), nophis)

    #   3.  partition according to the lists, 2D here, make bin id 1 dimensional
    qid_m1, pid_m1, pselect_m1 = partition2D(qlist_m1, philist_m1, qs, phis)
    bid_m1 = (qid_m1 * nophis + pid_m1).astype(int)

    # the sqphi here
    sq1 = np.zeros((noqs, nophis))
    sq2 = np.zeros((noqs, nophis))
    sq_qs = np.zeros((noqs, nophis))
    sq_phis = np.zeros((noqs, nophis))
    sqmask = np.zeros((noqs, nophis))
    sqcphi = np.zeros((noqs, nophis))
    sqcphimask = np.zeros((noqs, nophis))

    #transform image into a qphi map (1st moment)
    maxid = np.max(bid_m1)
    sq1.ravel()[:maxid + 1] = partition_avg(data1[pselect_m1], bid_m1)
    sq2.ravel()[:maxid + 1] = partition_avg(data2[pselect_m1], bid_m1)
    sqmask.ravel()[:maxid + 1] = partition_avg(pselect_m1 * 0 + 1, bid_m1)

    # calculate the correlation (2nd moment, keep same binning as first moment)
    nx = np.arange(nophis)
    NX = np.tile(nx, (nophis, 1))
    NY = np.copy(NX.T)
    # in the case where img1 != img2 there should be an asymmetry,
    # but I ignore the direction and just take absolute value. It should not matter
    # as the order in which I supply img1 and img2 are not relevant
    NYX = NY - NX
    w = np.where(NYX < 0)
    NYX[w] = NYX[w] + nophis
    TAUID_m2 = NYX[np.newaxis, :, :]
    #import matplotlib.pyplot as plt
    #plt.figure(10);plt.imshow(TAUID[0])
    # m2 means 2d moment
    QID_m2 = np.arange(noqs)[:, np.newaxis, np.newaxis]
    BID_m2 = TAUID_m2 * noqs + QID_m2
    bid_m2 = BID_m2.ravel()

    # indexing tricks, expand phi dimension to a (phi, phi) dimension
    sqd1 = sq1[:, NX].ravel()
    sqd2 = sq2[:, NY].ravel()
    sqmask1 = sqmask[:, NX].ravel()
    sqmask2 = sqmask[:, NY].ravel()
    # cross multiply masks
    #sqd1 *= sqmask2
    #sqd2 *= sqmask1
    sqdiff = np.abs(sqd2 - sqd1)**2
    # test first try convolution and see that it matches with current qphi corr
    sqdiff = sqd2 * sqd1
    sqdiffmask = sqmask1 * sqmask2
    sqdiff *= sqdiffmask

    res = partition_avg(sqdiff, bid_m2)
    resmask = partition_avg(sqdiffmask, bid_m2)
    w = np.where(resmask > 1e-6)
    res[w] /= resmask[w]
    bins = np.arange(np.max(bid_m2) + 1)
    sqcphi[bins % noqs, bins // noqs] = res

    #    for i in range(dimy):
    #        for j in range(dimx):
    #            for k in range(dimx):
    #                if(PF is True):
    #                    print("iteration {}, {}, {} of {}, {}, {}".format(i,j,k,dimy,dimx,dimx))
    #                sqcphi[i,k] += np.abs(sq1[i,j] - sq2[i,(j + k)%dimx])**2*sqmask[i,j]*sqmask[i,(j+k)%dimx]
    #                sqcphimask[i,j] += sqmask[i,j]*sqmask[i,(j+k)%dimx]
    #sqcphi = ifft(fft(sq2,axis=1)*np.conj(fft(sq1,axis=1)),axis=1).real
    #sqcphimask = ifft(fft(sqmask,axis=1)*np.conj(fft(sqmask,axis=1)),axis=1).real

    return sq_qs, sq_phis, sqcphi
Exemple #10
0
def deltaphicorr(img1,
                 img2,
                 mask=None,
                 qlist=None,
                 philist=None,
                 dq=0,
                 noqs=None,
                 nophis=None,
                 x0=None,
                 y0=None,
                 interp=0):
    ''' The new delta phi correlations.
        img1, img2 : used for the correlations (set to equal if same image)
            this is a 2nd moment calc so you need two quantities
        mask : the mask for the data set
        It uses the binning scheme only in one step. It transforms the image to
            a qphi square grid. It then uses FFT's to transform to a qphi correlation.
        interp : interpolation method. 
            0 - none (default)
            1 - linear interpolation
            2 - linear interpolation and reflect about 180 degrees 
        dq : shift by q in number of bins before correlating (q-q correlations)
        '''
    if (x0 is None):
        x0 = img1.shape[1] / 2
    if (y0 is None):
        y0 = img1.shape[0] / 2
    if (mask is None):
        mask = np.ones(img1.shape)
    if (qlist is None):
        if (noqs is None):
            noqs = 800
    else:
        noqs = len(qlist) // 2
    if (philist is None):
        if (nophis is None):
            nophis = 360
    else:
        nophis = len(philist) // 2

    #   0. get pixellist and relevant data
    pxlst = np.where(mask.ravel() == 1)
    data1 = img1.ravel()[pxlst]
    data2 = img2.ravel()[pxlst]

    #   1. Make coord system and grab selected pixels (only if qlist or philist not specified)
    if (qlist is None or philist is None):
        QS, PHIS = mkpolar(img1, x0=x0, y0=y0)
        qs, phis = QS.ravel()[pxlst], PHIS.ravel()[pxlst]

    #   2.  make the lists for selection (only if qlist of philist not specified)
    if (qlist is None):
        qlist_m1 = linplist(np.min(qs), np.max(qs), noqs)
    else:
        qlist_m1 = qlist

    if (philist is None):
        philist_m1 = linplist(np.min(phis), np.max(phis), nophis)
    else:
        philist_m1 = philist

    qs_m1 = (qlist_m1[0::2] + qlist_m1[1::2]) / 2.
    phis_m1 = (philist_m1[0::2] + philist_m1[1::2]) / 2.

    # 3. transform image into a qphi map (and mask)
    sq1 = qphiavg(img1,
                  mask=mask,
                  x0=x0,
                  y0=y0,
                  qlist=qlist_m1,
                  philist=philist_m1,
                  interp=interp)
    sq2 = qphiavg(img2,
                  mask=mask,
                  x0=x0,
                  y0=y0,
                  qlist=qlist_m1,
                  philist=philist_m1,
                  interp=interp)
    sqmask = qphiavg(img1 * 0 + 1,
                     mask=mask,
                     x0=x0,
                     y0=y0,
                     qlist=qlist_m1,
                     philist=philist_m1,
                     interp=interp)

    # do a q-q delta phi correlation if requested
    if (dq != 0):
        sq2 = np.roll(sq2, -int(dq), axis=0)

    # perform convolution
    sqcphi = convol1d(
        sq1, sq2,
        axis=1)  #ifft(fft(sq2,axis=1)*np.conj(fft(sq1,axis=1)),axis=1).real
    sqcphimask = convol1d(
        sqmask, axis=1
    )  #ifft(fft(sqmask,axis=1)*np.conj(fft(sqmask,axis=1)),axis=1).real

    # say .1 not zero to account for finite errors
    if (interp == 0):
        w = np.where(sqcphimask > .1)
        sqcphi[w] /= sqcphimask[w]
    elif interp == 1 or interp == 2:
        sqcphi /= nophis
    elif interp == 3:
        # No normalization (useful for counting correlated pixels in mask)
        pass
    else:
        print(
            "Warning: reached an unexpected interp flag in qphicorr, ignoring..."
        )
        pass

    return sqcphi