Пример #1
0
def PMakeBeamMask(inImage, inFFT, err):
    """
    Make uv plane weighting array
    
    Creates an FArray the size of a plane in inImage, FFT,
    takes real part and normalizes the central value to one
    Resulting array is returned.

    * inImage  = Python Image whose FArray is to be converted to a weight mask
    * inFFT    = Python Obit fortward FFT object
    * err      = Python Obit Error/message stack
    """
    ################################################################
    # Checks
    if not Image.PIsA(inImage):
        print "Actually ", inImage.__class__
        raise TypeError, "inImage MUST be a Python Obit Image"
    if not FFT.PIsA(inFFT):
        print "Actually ", inFFT.__class__
        raise TypeError, "inFFT MUST be a Python Obit FFT"
    #
    # Make copy of data array
    inArray = inImage.FArray
    outArray = FArray.PClone(inArray, err)
    #OErr.printErrMsg(err, "Error duplicating FArray for "+Image.PGetName(inImage))

    # Add model
    PCreateModel(inImage, outArray)

    # Pad for FFT
    FFTdim = FFT.PGetDim(inFFT)
    FFTArray = FArray.PClone(inArray, err)
    naxis = FFTdim[0:2]  # Make output big enough for FFT
    FFTArray = FArray.FArray("FFT array", naxis)
    PPadArray(inFFT, outArray, FFTArray)
    del outArray  # Cleanup

    # Swaparoonie
    FArray.PCenter2D(FFTArray)

    # FFT
    uvArray = PCreateFFTArray(inFFT)
    PFFTR2C(inFFT, FFTArray, uvArray)
    del FFTArray  # Cleanup

    # Extract Real part
    naxis = CArray.PGetNaxis(uvArray)[0:2]
    maskArray = FArray.FArray("Mask array for " + Image.PGetName(inImage),
                              naxis)
    CArray.PReal(uvArray, maskArray)
    del uvArray  # Cleanup

    # Normalize
    pos = [0, 1 + naxis[1] / 2]
    peak = FArray.PMax(maskArray, pos)
    norm = 1.0 / peak
    FArray.PSMul(maskArray, norm)

    return maskArray
Пример #2
0
def PConvBeam(CCTab, Beam, Template, err):
    """ Convolve a set of Clean components with a beam image

    CCTab      CC Table, following parameters on infoList member
       "BComp" OBIT_int (1,1,1) Start CC to use, 1-rel [def 1 ]
       "EComp" OBIT_int (1,1,1) Highest CC to use, 1-rel [def to end ]
    Beam       Beam Image to convolve with CCs
    Template   Template FArray for output array
    err        Obit Error stack
    Returns an ObitFArray whose size is that of Template, spacing is that of Beam
        with the CCs in CCTab convolved with Beam and the (0,0) position is
        (nx/2,ny/2) (0-rel)
    """
    ################################################################
    # Checks
    if not Table.PIsA(CCTab):
        raise TypeError, "CCTab MUST be a Python Obit Table"
    if not OErr.OErrIsA(err):
        raise TypeError, "err MUST be a Python ObitErr"
    #
    out = FArray.FArray("Convolved CCs")
    if err.isErr:  # existing error?
        return out
    out.me = Obit.OTFUtilConvBeam(CCTab.me, Beam.me, Template.me, err.me)
    return out
Пример #3
0
def PBigger (naxis, inImage, outImage, err):
    """
    Increases the size of an image and zero pads
    
    Any blanked values are replaced with zeroes

    * naxis    = dimension array of desired output
    * inImage  = Python Obit Image to be padded.
    * outImage = Python Obit Image for output
      Must previously exist
    * err      = Python Obit Error/message stack
    """
    ################################################################
    # Checks
    if not Image.PIsA(inImage):
        print("Actually ",inImage.__class__)
        raise TypeError("inImage MUST be a Python Obit Image")
    if not Image.PIsA(outImage):
        print("Actually ",outImage.__class__)
        raise TypeError("outImage MUST be a Python Obit Image")
    if not OErr.OErrIsA(err):
        raise TypeError("err MUST be an OErr")
    #
    # Read input, Copy Descriptor
    inImage.Open(Image.READONLY, err)
    inImage.Read(err)
    desc = inImage.Desc
    inImage.Close(err)
    #OErr.printErrMsg(err, "Error reading input image "+Image.PGetName(inImage))
    
    # Get data arrays
    inArray = inImage.FArray
    outArray = FArray.FArray("Padded array", naxis)

    # Copy/pad/deblank array
    FArray.PPad(inArray, outArray, 1.0)

    # Reset output image size of first two axes
    naxis = outArray.Naxis                    # output size
    descDict = desc.Dict                      # Input Python dict object
    dim   = descDict["inaxes"]                # input size
    crpix = descDict["crpix"]
    # Update reference pixel, pixel shift an integral number
    pixOff = [naxis[0]//2-dim[0]//2, naxis[1]//2-dim[1]//2]
    crpix[0] = crpix[0] + pixOff[0]
    crpix[1] = crpix[1] + pixOff[1]
    # Update size
    dim[0] = naxis[0];
    dim[1] = naxis[1]
    descDict["inaxes"] = dim   
    descDict["bitpix"] = -32  # output floating
    desc = outImage.Desc    # Replace descriptor on output
    desc.Dict = descDict

    # Write output image
    outImage.Open(Image.WRITEONLY, err)
    outImage.WriteFA(outArray, err)
    outImage.Close(err)
    outImage.FArray = outArray  # Now attach array to image to
Пример #4
0
def PImPix(inPixHistFDR):
    """ Return the Image Pixel FArray

    returns Image Pixel FArray
    inPixHistFDR  = Python PixHistFDR object
    """
    ################################################################
    # Checks
    if not PIsA(inPixHistFDR):
        raise TypeError("inPixHistFDR MUST be a Python Obit PixHistFDR")
    #
    out = FArray.FArray("ImPix")
    out.me = Obit.FArrayUnref(out.me)
    out.me = Obit.PixHistFDRGetImPix(inPixHistFDR.me)
    return out
Пример #5
0
def PDifHist(inPixHistFDR):
    """ Return the differential pixel histogram

    returns differential pixel histogram
    inPixHistFDR  = Python PixHistFDR object
    """
    ################################################################
    # Checks
    if not PIsA(inPixHistFDR):
        raise TypeError("inPixHistFDR MUST be a Python Obit PixHistFDR")
    #
    out = FArray.FArray("DifHist")
    out.me = Obit.FArrayUnref(out.me)
    out.me = Obit.PixHistFDRGetHisto(inPixHistFDR.me)
    return out
Пример #6
0
def PIntHist(inPixHistFDR):
    """ Return the integrated pixel histogram

    returns integrated pixel histogram
    inPixHistFDR  = Python PixHistFDR object
    """
    ################################################################
    # Checks
    if not PIsA(inPixHistFDR):
        raise TypeError("inPixHistFDR MUST be a Python Obit PixHistFDR")
    #
    out = FArray.FArray("IntHist")
    out.me = Obit.FArrayUnref(out.me)
    out.me = Obit.PixHistFDRGetIntHisto(inPixHistFDR.me)
    return out
Пример #7
0
def PGetFArray(inFI):
    """
    Get Associated FArray reference
    
    return FArray (data being interpolated) reference 
    * inFI    = Python Obit input FInterpolate
    """
    ################################################################
    # Checks
    if not PIsA(inFI):
        raise TypeError("inFI MUST be a Python Obit FInterpolate")
    #
    out = FArray.FArray("None")
    out.me = Obit.FInterpolateGetFArray(inFI.me)
    return out
Пример #8
0
def PDifHist(inPixHistFDR):
    """ Return the differential pixel histogram

    returns differential pixel histogram
    inPixHistFDR  = Python PixHistFDR object
    """
    ################################################################
    # Checks
    if not PIsA(inPixHistFDR):
        raise TypeError, "inPixHistFDR MUST be a Python Obit PixHistFDR"
    #
    sm = inPixHistFDR.cast(myClass)  # cast pointer
    out = FArray.FArray("DifHist")
    out.me = Obit.FArrayUnref(out.me)
    out.me = Obit.PixHistFDRGetHisto(sm)
    return out
Пример #9
0
def PImPix(inPixHistFDR):
    """ Return the Image Pixel FArray

    returns Image Pixel FArray
    inPixHistFDR  = Python PixHistFDR object
    """
    ################################################################
    # Checks
    if not PIsA(inPixHistFDR):
        raise TypeError, "inPixHistFDR MUST be a Python Obit PixHistFDR"
    #
    sm = inPixHistFDR.cast(myClass)  # cast pointer
    out = FArray.FArray("ImPix")
    out.me = Obit.FArrayUnref(out.me)
    out.me = Obit.PixHistFDRGetImPix(sm)
    return out
Пример #10
0
def PMakeF(Cin):
    """
    Make an FArray with the same geometry as a CArray
    
    return FArray size of CArray

    * Cin = input Python CArray
    """
    ################################################################
    # Checks
    if not PIsA(Cin):
        print("Actually ", iCn.__class__)
        raise TypeError("Cin MUST be a Python Obit CArray")
    outFA = FArray.FArray("None")
    outFA.me = Obit.CArrayMakeF(Cin.me)
    return outFA
Пример #11
0
def PGetFArray(inImageMF):
    """
    Return FArray used to buffer Image data
    
    returns FArray with image pixel data
    * inImageMF   = Python Image object
    """
    ################################################################
    if inImageMF.myClass == 'AIPSImage':
        raise TypeError("Function unavailable for " + inImage.myClass)
    # Checks
    if not inImageMF.ImageMFIsA():
        raise TypeError("inImageMF MUST be a Python Obit Image")
    #
    out = FArray.FArray("None")
    out.me = Obit.ImageMFGetFArray(inImageMF.me)
    return out
Пример #12
0
def PUVGaus(naxis, cells, maprot, maj, min, pa):
    """
    Create a Gaussian UV tapering image corresponding to an image plane Gaussian
    
    Returns an FArray with a Gaussian taper, as [u,v]

    * naxis  = dimension as [nx,ny]
    * cells  = cell spacing in x and y in units of maj,min (asec)
    * maprot = Map rotation (deg)
    * maj    = Major axis of Gaussian in image plane (same units as cells)
    * min    = Minor axis of Gaussian in image plane (same units as cells)
    * pa     = Position angle of Gaussian in image plane, from N thru E, (deg)
    """
    ################################################################
    # Create output
    outFA = FArray.FArray("UVpix", naxis)
    outFA.me = Obit.FArrayUtilUVGaus(naxis, cells, maprot, maj, min, pa)
    return outFA
Пример #13
0
def PGetFArray(inImageMF):
    """
    Return FArray used to buffer Image data
    
    returns FArray with image pixel data

    * inImageMF   = Python Image object
    """
    ################################################################
    if ('myClass' in inImageMF.__dict__) and (inImageMF.myClass
                                              == 'AIPSImage'):
        raise TypeError("Function unavailable for " + inImageMF.myClass)
    inCast = inImageMF.cast('ObitImageMF')
    # Checks
    if not PIsA(inImageMF):
        raise TypeError("inImageMF MUST be a Python Obit ImageMF")
    #
    out = FArray.FArray("None")
    out.me = Obit.ImageMFGetFArray(inImageMF.me)
    return out
Пример #14
0
def PGaus(inImage, Beam):
    """
    Create an ObitFArray containing a unit area Gaussian in the center
    
    returns  Python FArray object with normalized Gaussian

    * inImage  = Obit Image with geometry
    * Beam     = [maj, min, PA] defining eliptical Gaussian
      size in image cell units or pixels if none given
    """
    ################################################################
    # Checks
    if not Image.PIsA(inImage):
        print "Actually ", inImage.__class__
        raise TypeError, "inImage MUST be a Python Obit Image"
    if len(Beam) < 3:
        raise TypeError, "Beam MUST have 3 elements"
    #
    outFA = FArray.FArray("None")
    outFA.me = Obit.ConvUtilGaus(inImage.me, Beam[0], Beam[1], Beam[2])
    return outFA
Пример #15
0
def PConvolve(inFA1, inFA2, err):
    """
    Return the convolution of two 2-D arrays
    
    inFA1 and inFA2 must be compatible size and should not contain magic value blanks.
    Convolved array returned.

    * inFA1   = First array
    * inFA2   = Second array
    * err     = Python Obit Error/message stack
    """
    ################################################################
    # Checks
    if not FArray.PIsA(inFA1):
        raise TypeError, "inFA1 MUST be a Python Obit FArray"
    if not FArray.PIsA(inFA2):
        raise TypeError, "inFA2 MUST be a Python Obit FArray"
    #
    outFA = FArray.FArray("None")
    outFA.me = Obit.FArrayUtilConvolve(inFA1.me, inFA2.me, err.me)
    return outFA
Пример #16
0
imagDict["crpix"][0] = nx / 2 + 1
imagDict["crpix"][1] = ny / 2 + 1
imagDict["bitpix"] = -32
imagDict["bunit"] = "JY/BEAM"
imagDict["beamMin"] = beamsize
imagDict["beamMaj"] = beamsize
imagDict["beamPA"] = 0.0
# Update descriptor
outImage.Desc.Dict = imagDict

#
Image.PFullInstantiate(outImage, 2, err)
OErr.printErrMsg(err, "Error creating image")

# Create FArray for image
data = FArray.FArray("Image Data", [nx, ny])

# Add Gaussian
FWHM = beamsize / abs(xCells)  # beam size in pixels
FArray.PCGauss2D(data, [nx / 2, ny / 2], FWHM)

# Write output
Image.PWritePlane(outImage, data, err)

# Say something
print "Wrote beam with size", beamsize * 3600.0, "to", outFile

# Shutdown Obit
OErr.printErr(err)
del ObitSys
Пример #17
0
def PImageFFT(inImage, outAImage, outPImage, err):
    """
    FFTs an Image
    
    FFT inImage and write as real and imaginary as full plane (hermetian) 

    * inImage   = input Obit Python Image 1
      Any BLC and/or TRC set will be honored
    * outAImage = output Obit Python Amplitude image of FFT
      must be defined but not instantiated
    * outPImage = output Obit Python Phase (deg) image of FFT
      must be defined but not instantiated
    * err       = Python Obit Error/message stack
    """
    ################################################################
    # Checks
    if not Image.PIsA(inImage):
        raise TypeError("inImage MUST be a Python Obit Image")
    if not Image.PIsA(outAImage):
        raise TypeError("outAImage MUST be a Python Obit Image")
    if not Image.PIsA(outPImage):
        raise TypeError("outPImage MUST be a Python Obit Image")
    if not err.IsA():
        raise TypeError("err MUST be an OErr")
    #
    # Clone output images
    inImage.Clone(outAImage, err)
    inImage.Clone(outPImage, err)
    OErr.printErrMsg(err, "Error initializing images")

    # Size of FFT
    inImage.Open(Image.READONLY, err)
    inImage.Read(err)
    OErr.printErrMsg(err, "Error reading input")
    inHead = inImage.Desc.Dict
    FFTdim = [
        FFT.PSuggestSize(inHead["inaxes"][0]),
        FFT.PSuggestSize(inHead["inaxes"][1])
    ]

    # Create float arrays for FFT size
    inFArray = FArray.FArray("inF", naxis=FFTdim)
    outFArray = FArray.FArray("outF", naxis=FFTdim)

    # Create FFT for full complex FFT
    FFTfor = FFT.FFT("FFT", 1, 1, 2, FFTdim)

    # Create complex arrays for FFT size
    inCArray = CArray.CArray("inC", naxis=FFTdim)
    outCArray = CArray.CArray("outC", naxis=FFTdim)

    #Loop over planes
    nplane = inImage.Desc.Dict['inaxes'][2]
    for iax in range(1, nplane + 1):
        inImage.GetPlane(None, [iax, 1, 1, 1, 1], err)
        OErr.printErrMsg(err, "Error reading input")
        # Pad input into work FArray
        FArray.PPad(inImage.FArray, inFArray, 1.0)
        # and God said "The center of an FFT will be at the corners"
        FArray.PCenter2D(inFArray)
        # Zero output FArray and use as imaginary part
        FArray.PFill(outFArray, 0.0)
        # Copy input to scratch CArray
        CArray.PComplex(inFArray, outFArray, inCArray)

        # FFT
        FFT.PC2C(FFTfor, inCArray, outCArray)

        # Extract amplitude, write
        CArray.PAmp(outCArray, outFArray)
        # and God said "The center of an FFT will be at the corners"
        FArray.PCenter2D(outFArray)
        outAImage.FArray = FeatherUtil.PExtract(FFTfor, outFArray,
                                                outAImage.FArray, err)
        OErr.printErrMsg(err, "Error extracting output amplitude plane")
        outAImage.PutPlane(outAImage.FArray, [iax, 1, 1, 1, 1], err)

        # Extract phase, write
        CArray.PPhase(outCArray, outFArray)
        # To degrees
        FArray.PSMul(outFArray, 57.2956)
        # and God said "The center of an FFT will be at the corners"
        FArray.PCenter2D(outFArray)
        outPImage.FArray = FeatherUtil.PExtract(FFTfor, outFArray,
                                                outPImage.FArray, err)
        OErr.printErrMsg(err, "Error extracting output phase plane")
        outPImage.PutPlane(outPImage.FArray, [iax, 1, 1, 1, 1], err)
        # Error?
        OErr.printErrMsg(err, "Error writing output phase image")
        # end loop over planes

    # Fix headers
    outAImage.Open(Image.READWRITE, err)
    FFTHeaderUpdate(outAImage, FFTdim, err)
    outAImage.Close(err)
    OErr.printErrMsg(err, "Error writing output amplitude image")

    outPImage.Open(Image.READWRITE, err)
    FFTHeaderUpdate(outPImage, FFTdim, err)
    outPImage.Close(err)
    OErr.printErrMsg(err, "Error writing output phase image")

    # get any BLC, TRC for history
    info = inImage.List.Dict
    blc = [1, 1, 1, 1, 1, 1, 1]
    if 'BLC' in info:
        blc = info["BLC"][2]
    trc = [0, 0, 0, 0, 0, 0, 0]
    if 'TRC' in info:
        trc = info["TRC"][2]

    # Write history
    i = 0
    imtype = ("Amplitude", "Phase")
    for outImage in (outAImage, outPImage):
        inHistory = History.History("history", inImage.List, err)
        outHistory = History.History("history", outImage.List, err)
        # Copy History
        # FITS? - copy header
        if ("FileType" in info) and (info["FileType"][2][0] == 0):
            History.PCopyHeader(inHistory, outHistory, err)
        #Not needed History.PCopy(inHistory, outHistory, err)
        # Add this programs history
        outHistory.Open(History.READWRITE, err)
        outHistory.TimeStamp(" Start Obit PImageFFT", err)
        outHistory.TimeStamp(OSystem.PGetPgmName() + " BLC = " + str(blc), err)
        outHistory.TimeStamp(OSystem.PGetPgmName() + " TRC = " + str(trc), err)
        outHistory.TimeStamp(OSystem.PGetPgmName() + " type = " + imtype[i],
                             err)
        i += 1
        outHistory.Close(err)
Пример #18
0
        outRow['IF FREQ'][i * inNIF +
                          j] = rrr['IF FREQ'][j] + inRefFreq - outRefFreq
        outRow['SIDEBAND'][i * inNIF + j] = rrr['SIDEBAND'][j]
        outRow['CH WIDTH'][i * inNIF + j] = rrr['CH WIDTH'][j]
        outRow['TOTAL BANDWIDTH'][i * inNIF + j] = rrr['TOTAL BANDWIDTH'][j]
    xfq.Close(err)
    del xfq, rrr

outFQ.WriteRow(1, outRow, err)
outFQ.Close(err)
OErr.printErrMsg(err, message='Error creating output FQ Table')
# Cleanup
del outRow

# Work arrays
work = FArray.FArray('work',
                     [ncell, ncell])  # work array for interpolated image
work2 = FArray.FArray('work2',
                      [ncell, ncell])  # work array for interpolated image
accWI = FArray.FArray('accWI', [ncell, ncell])  # Sum wt * image
accW = FArray.FArray('accW', [ncell, ncell])  # Sum wt

# Pixel array images
XPixIm = Image.Image("XPixIm")
YPixIm = Image.Image("YPixIm")
outIm.List.set('BLC', [1, 1, 1, 1, 1, 1, 1])
outIm.List.set('TRC', [0, 0, 1, 1, 1, 1, 1])
outIm.Open(Image.READWRITE, err)
outIm.Close(err)
Image.PCloneMem(outIm, XPixIm, err)
Image.PCloneMem(outIm, YPixIm, err)
outIm.List.set('TRC', [0, 0, 0, 0, 1, 1, 1])
Пример #19
0
import OErr, OSystem, Image, InfoList, FArray

err = OErr.OErr()
ObitSys = OSystem.OSystem("Python", 1, 103, 1, ["None"], 1, ["../PythonData/"],
                          1, 0, err)
OErr.printErrMsg(err, "Error with Obit startup")

# for debugging
#OErr.Bomb()

list = InfoList.InfoList()
dim = [1, 0, 0, 0, 0]
InfoList.PPutLong(list, "longItem", dim, [321], err)
x = InfoList.PGet(list, "longItem")

x = FArray.FArray("MyFArray", [30, 50])
FArray.PSetVal(x, [25, 25], 3.1415926)
pos = [-1, -1]
result = FArray.PMax(x, pos)
print "FArray max is", result, "should be 3.1415926"
result = FArray.PMin(x, pos)
print "FArray min is", result, "should be 0"

file = "testPcube.fits"
disk = 1
image = Image.newPFImage("myImage", file, disk, True, err)
OErr.printErr(err)
Image.POpen(image, 1, err)
OErr.printErr(err)
Image.PRead(image, err)
OErr.printErr(err)
Пример #20
0
def PMakeMaster(template, size, SumWtImage, SumWt2, err):
    """
    Create a pair of images to accumulation of partial products
    
    Create an image to contain the Sum of the input Images times the
    weights, and another for the sum of the weights squared.
    The descriptive material is from image template

    * template   = Image with position etc, to be copied
    * size       = output image size in pixels, e.g. [200,200]
    * SumWtImage = First output image, must be defined (i.e. files named)
      but not fully created.
    * SumWt2     = Second output image, like SumWtImage
    * err        = Python Obit Error/message stack
    
    """
    ################################################################
    # Checks
    if not Image.PIsA(template):
        print "Actually ",template.__class__
        raise TypeError,"template MUST be a Python Obit Image"
    if not Image.PIsA(SumWtImage):
        print "Actually ",SumWtImage.__class__
        raise TypeError,"SumWtImage MUST be a Python Obit Image"
    if not Image.PIsA(SumWt2):
        print "Actually ",SumWt2.__class__
        raise TypeError,"SumWt2 MUST be a Python Obit Image"
    if not OErr.OErrIsA(err):
        raise TypeError,"err MUST be an OErr"
    #
    # Get image info from template
    Image.POpen (template, 1, err)
    Image.PRead (template, err)
    desc = Image.PGetDesc(template)
    descDict = ImageDesc.PGetDict(desc)  # Python dict object
    listDict = template.Desc.List.Dict
    Image.PClose (template, err)
    #OErr.printErrMsg(err, "Error reading input image "+Image.PGetName(template))
    #
    # Create zero filled array for data
    outArray = FArray.FArray("Initial array", size)
    #
    # Modify the descriptor for output.
    naxis = size[0:3]
    # Update reference pixel, pixel shift an integral number
    dim = descDict["inaxes"]
    pixOff = [naxis[0]/2-dim[0]/2, naxis[1]/2-dim[1]/2]
    crpix = descDict["crpix"]
    crpix[0] = crpix[0] + pixOff[0]
    crpix[1] = crpix[1] + pixOff[1]
    # Update size
    dim[0] = naxis[0];
    dim[1] = naxis[1]
    #print "debug dim",dim
    descDict["inaxes"] = dim   
    descDict["bitpix"] = -32  # output floating
    #
    # Do SumWtImage
    desc   = Image.PGetDesc(SumWtImage)
    InfoList.PSetDict(desc.List, listDict)  # Copy list stuff
    ImageDesc.PSetDict(desc, descDict) # set output descriptor
    # Write output image
    Image.POpen(SumWtImage, 2, err)
    nplane = template.Desc.Dict["inaxes"][2]
    for iplane in range(1,(nplane+1)):
        plane = [iplane,1,1,1,1]
        SumWtImage.PutPlane(outArray, plane, err)
    Image.PClose(SumWtImage, err)
    #OErr.printErrMsg(err, "Error writing image for "+Image.PGetName(SumWtImage))
    #
    # Do SumWt2Image
    desc = Image.PGetDesc(SumWt2) 
    InfoList.PSetDict(desc.List, listDict)  # Copy list stuff
    ImageDesc.PSetDict(desc, descDict) # set output descriptor
    # Write output image
    Image.POpen(SumWt2, 2, err)
    for iplane in range(1,(nplane+1)):
        plane = [iplane,1,1,1,1]
        SumWt2.PutPlane(outArray, plane, err)
    Image.PClose(SumWt2, err)
    #OErr.printErrMsg(err, "Error writing image for "+Image.PGetName(SumWt2))
    # Write history - sorta
    inHistory  = History.History("history", template.List, err)
    outHistory = History.History("history", SumWtImage.List, err)
    # Copy History
    History.PCopy(inHistory, outHistory, err)
    outHistory.Open(History.READWRITE, err)
    outHistory.TimeStamp(" Start Obit PMakeMaster",err)
    outHistory.Close(err)
Пример #21
0
def PPad (inFFT, inImage, outImage, err):
    """
    Zero Pads an image as needed for an FFT
    
    Any blanked values are replaced with zeroes

    * inFFT    = Gives size of FFT needed
    * inImage  = Python Obit Image to be padded.
    * outImage = Python Obit Image for output
      Must previously exist
    * err      = Python Obit Error/message stack
    """
    ################################################################
    # Checks
    if not FFT.PIsA(inFFT):
        raise TypeError("inFFT MUST be a Python Obit FFT")
    if not Image.PIsA(inImage):
        print("Actually ",inImage.__class__)
        raise TypeError("inImage MUST be a Python Obit Image")
    if not Image.PIsA(outImage):
        print("Actually ",outImage.__class__)
        raise TypeError("outImage MUST be a Python Obit Image")
    if not OErr.OErrIsA(err):
        raise TypeError("err MUST be an OErr")
    #
    # Read input, Copy Descriptor
    inImage.Open(Image.READONLY, err)
    inImage.Read(err)
    desc = inImage.Desc
    inImage.Close(err)
    #OErr.printErrMsg(err, "Error reading input image "+Image.PGetName(inImage))
    
    # FFT info
    FFTrank = FFT.PGetRank(inFFT)
    FFTdim  = FFT.PGetDim(inFFT)

    # Get data arrays
    inArray = inImage.FArray
    naxis = FFTdim[0:2]   # Make output big enough for FFT
    outArray = FArray.FArray("Padded array", naxis)

    # Copy/pad/deblank array
    # debugPPadArray (inFFT, inArray, outArray)
    FArray.PPad(inArray, outArray, 1.0)

    # Reset output image size of first two axes
    naxis = outArray.Naxis                    # output size
    descDict = desc.Dict                      # Input Python dict object
    dim   = descDict["inaxes"]                # input size
    crpix = descDict["crpix"]
    # Update reference pixel, pixel shift an integral number
    pixOff = [naxis[0]//2-dim[0]//2, naxis[1]//2-dim[1]//2]
    crpix[0] = crpix[0] + pixOff[0]
    crpix[1] = crpix[1] + pixOff[1]
    # Update size
    dim[0] = naxis[0];
    dim[1] = naxis[1]
    descDict["inaxes"] = dim   
    descDict["bitpix"] = -32  # output floating
    desc = outImage.Desc    # Replace descriptor on output
    desc.Dict = descDict

    # Write output image
    outImage.Open(Image.WRITEONLY, err)
    outImage.WriteFA(outArray, err)
    outImage.Close(err)
    outImage.FArray = outArray  # Now attach array to image to
Пример #22
0
def RestorePeel(peelMod, CCVer, image, err):
    """
    Restore CCs from one image onto another
    
    If images are ImageMF then multiple planes restored.
    * peelMod   Image with CC table (as Image)
    * CCver     CC version on peelMod to restore
    * image     Output Image to which components to be added
    * err       Python Obit Error/message stack
    * nThreads  number of threads to use
    """
    ################################################################
    import Obit, Image, ImageDesc, SkyGeom, Table, History, OErr
    import UV, UVDesc, OSystem, UVSelfCal, FArray
    # Checks
    if not Image.PIsA(peelMod):
        raise TypeError("uv MUST be a Python Obit Image")
    if not Image.PIsA(image):
        raise TypeError("imp MUST be a Python Obit Image")

    ph = peelMod.Desc.Dict
    ih = image.Desc.Dict  # Descriptors
    ph_x = ph['crval'][0]
    ph_y = ph['crval'][1]
    ph_rot = ph['crota'][1]
    ph_dx = ph['cdelt'][0]
    ph_dy = ph['cdelt'][1]
    ph_type = ph['ctype'][0][4:]
    ph_ref_x = ph['crpix'][0]
    ph_ref_y = ph['crpix'][1]
    ih_x = ih['crval'][0]
    ih_y = ih['crval'][1]
    ih_rot = ih['crota'][1]
    ih_dx = ih['cdelt'][0]
    ih_dy = ih['cdelt'][1]
    ih_type = ih['ctype'][0][4:]
    ih_ref_x = ih['crpix'][0]
    ih_ref_y = ih['crpix'][1]
    bmaj = ih['beamMaj']
    bmin = ih['beamMin']
    bpa = ih['beamPA']
    bmaj /= abs(ih_dx)
    bmin /= abs(ih_dx)  # Beam in pixels (square grid)

    #Beam to insert
    beam = FArray.FArray('beam', naxis=[21, 21])
    bx = 10.
    by = 10.
    FArray.PEGauss2D(beam, 1.0, [bx, by], [bmaj, bmin, bpa])

    cctab = peelMod.NewTable(Table.READONLY, 'AIPS CC', CCVer, err)  # CC Table
    cctab.Open(Table.READONLY, err)
    OErr.printErr(err)

    # First plane
    image.GetPlane(None, [1, 1, 1, 1, 1], err)
    imArr = image.FArray
    ncc = cctab.Desc.Dict['nrow']  # Number of CCs
    for irow in range(1, ncc + 1):
        row = cctab.ReadRow(irow, err)
        flux = row['FLUX'][0]
        dx = row['DELTAX'][0]
        dy = row['DELTAY'][0]
        dz = row['DELTAZ'][0]
        [ierr, ra, dec] = SkyGeom.PWorldPosLM(dx, dy, ph_x, ph_y, ph_dx, ph_dy,
                                              ph_rot, ph_type)
        # output pixel
        [ierr, xpix,
         ypix] = SkyGeom.PXYpix(ra, dec, ih_x, ih_y, ih_ref_x, ih_ref_y, ih_dx,
                                ih_dy, ih_rot, ih_type)
        # Need beam if correct location
        tbx = xpix - int(xpix + 0.5)
        tby = ypix - int(ypix + 0.5)
        FArray.PFill(beam, 0.0)
        FArray.PEGauss2D(beam, 1.0, [bx + tbx, by + tby], [bmaj, bmin, bpa])
        # Add
        FArray.PShiftAdd(
            imArr,
            [int(xpix + 0.5) - 1, int(ypix + 0.5) - 1], beam,
            [int(bx + 0.5), int(by + 0.5)], flux, imArr)
    # end loop
    image.PutPlane(None, [1, 1, 1, 1, 1], err)  # rewrite

    # MFImage Planes
    if ih['ctype'][2] == 'SPECLNMF ':
        nterm = image.Desc.List.Dict['NTERM'][2][0]
        nspec = image.Desc.List.Dict['NSPEC'][2][0]
        for ip in range(nterm + 1, nterm + nspec + 1):
            image.GetPlane(None, [ip, 1, 1, 1, 1], err)
            imArr = image.FArray
            for irow in range(1, ncc + 1):
                row = cctab.ReadRow(irow, err)
                flux = row['PARMS'][3 + ip - nterm]
                dx = row['DELTAX'][0]
                dy = row['DELTAY'][0]
                dz = row['DELTAZ'][0]
                [ierr, ra,
                 dec] = SkyGeom.PWorldPosLM(dx, dy, ph_x, ph_y, ph_dx, ph_dy,
                                            ph_rot, ph_type)
                # output pixel
                [ierr, xpix, ypix] = SkyGeom.PXYpix(ra, dec, ih_x, ih_y,
                                                    ih_ref_x, ih_ref_y, ih_dx,
                                                    ih_dy, ih_rot, ih_type)
                # Need beam in correct location
                tbx = xpix - int(xpix + 0.5)
                tby = ypix - int(ypix + 0.5)
                FArray.PFill(beam, 0.0)
                FArray.PEGauss2D(beam, 1.0, [bx + tbx, by + tby],
                                 [bmaj, bmin, bpa])
                # Add
                FArray.PShiftAdd(imArr,
                                 [int(xpix + 0.5) - 1,
                                  int(ypix + 0.5) - 1], beam,
                                 [int(bx + 0.5), int(by + 0.5)], flux, imArr)
            # end loop
            image.PutPlane(None, [ip, 1, 1, 1, 1], err)  # rewrite
    # end plane loop
    # end MFImage Planes
    # History
    x = image
    y = peelMod
    hi = x.History(3, err)
    hi.Open(3, err)
    hi.TimeStamp('Restore Peel', err)
    if x.FileType == 'FITS':
        hiCard = y.FileName.strip() + '.' + str(y.Disk)
    else:
        hiCard = y.Aname.strip() + '.' + y.Aclass.strip() + '.' + str(
            y.Aseq) + '.' + str(y.Disk)

    hi.WriteRec(-1, "RestorePeel / file=" + hiCard, err)
    hi.Close(err)
Пример #23
0
inImage  = Image.newPFImage(inFile, inFile, inDisk, True, err)
outAImage  = Image.newPFImage(outAFile, outAFile, outADisk, False, err)
inImage.Clone(outAImage,err)
outPImage  = Image.newPFImage(outPFile, outPFile, outPDisk, False, err)
inImage.Clone(outPImage,err)
OErr.printErrMsg(err, "Error initializing images")

# Size of FFT
inImage.Open(Image.READONLY, err)
inImage.Read(err)
OErr.printErrMsg(err, "Error reading input")
inHead = inImage.Desc.Dict
FFTdim = [FFT.PSuggestSize(inHead["inaxes"][0]), FFT.PSuggestSize(inHead["inaxes"][1])]

# Create float arrays for FFT size
inFArray  = FArray.FArray("inF", naxis=FFTdim)
outFArray = FArray.FArray("outF", naxis=FFTdim)

# Pad input into work FArray
FArray.PPad(inImage.FArray, inFArray, 1.0)
# and God said "The center of an FFT will be at the corners"
FArray.PCenter2D(inFArray)
# Zero output FArray and use as imaginary part
FArray.PFill(outFArray, 0.0)

# Create FFT for full complex FFT
FFTfor = FFT.FFT("FFT", 1, 1, 2, FFTdim)

# Create complex arrays for FFT size
inCArray  = CArray.CArray("inC", naxis=FFTdim)
outCArray = CArray.CArray("outC", naxis=FFTdim)