def PExtract (inFFT, inArray, outArray, err):
"""
Extract a Real array from one padded for FFTs
Any blanked values are replaces with zeroes
returns outArray
* inFFT = Gives size of FFT used
* inArray = Python FArray with FFT results.
* outArray = Python FArray describing results
* err = Python Obit Error/message stack
"""
################################################################
# Checks
if not FFT.PIsA(inFFT):
raise TypeError("inFFT MUST be a Python Obit FFT")
if not FArray.PIsA(inArray):
print("Actually ",inArray.__class__)
raise TypeError("inArray MUST be a Python Obit FArray")
if not FArray.PIsA(outArray):
print("Actually ",outArray.__class__)
raise TypeError("outArray MUST be a Python Obit FArray")
if not OErr.OErrIsA(err):
raise TypeError("err MUST be an OErr")
#
# FFT info
FFTrank = FFT.PGetRank(inFFT)
FFTdim = FFT.PGetDim(inFFT)
# Target Array info
ArrayNdim = outArray.Ndim
ArrayNaxis = outArray.Naxis
# Get window to extract
cen = [FFTdim[0]//2, FFTdim[1]//2];
blc = [0,0]; trc=[0,0]
blc[0] = cen[0] - ArrayNaxis[0] // 2; trc[0] = cen[0] - 1 + ArrayNaxis[0] // 2
blc[1] = cen[1] - ArrayNaxis[1] // 2; trc[1] = cen[1] - 1 + ArrayNaxis[1] // 2
# Make sure to fill output array
if ((trc[0]-blc[0]+1)<ArrayNaxis[0]):
trc[0] = blc[0] + ArrayNaxis[0] - 1
if ((trc[1]-blc[1]+1)<ArrayNaxis[1]):
trc[1] = blc[1] + ArrayNaxis[1] - 1
# Extract
out = FArray.PSubArr(inArray, blc, trc, err)
return out
def PCreateFFTArray(inFFT):
"""
Create a half plane CArray suitable for the output of FFTing an image
returns Python CArray object of suitable size (2D)
* inFFT = FFT to be applied
"""
################################################################
# Checks
if not FFT.PIsA(inFFT):
raise TypeError("inFFT MUST be a Python Obit FFT")
#
# FFT info
FFTrank = FFT.PGetRank(inFFT)
FFTdim = FFT.PGetDim(inFFT)
naxis = FFTdim[0:2]
naxis[0] = 1 + naxis[0]//2
out = CArray.CArray ("Temp CArray for FFT", naxis)
return out
def PPadArray (inFFT, inArray, outArray):
"""
Zero Pads an array as needed for an FFT
Any blanked values are replaced with zeroes
* inFFT = Gives size of FFT needed
* inArray = Python FArray to be padded.
* outArray = Python FArray containing inArray but zero filled.
Must previously exist.
"""
################################################################
# Checks
if not FFT.PIsA(inFFT):
raise TypeError("inFFT MUST be a Python Obit FFT")
if not FArray.PIsA(inArray):
print("Actually ",inArray.__class__)
raise TypeError("inArray MUST be a Python Obit FArray")
if not FArray.PIsA(outArray):
print("Actually ",outArray.__class__)
raise TypeError("outArray MUST be a Python Obit FArray")
#
# FFT info
FFTrank = FFT.PGetRank(inFFT)
FFTdim = FFT.PGetDim(inFFT)
# Array info
ArrayNdim = inArray.Ndim
ArrayNaxis = inArray.Naxis
# Zero fill output
FArray.PFill(outArray, 0.0)
# Insert inArray into outArray - center as well as possible
pos1 = [FFTdim[0]//2, FFTdim[1]//2]
pos2 = [ArrayNaxis[0]//2, ArrayNaxis[1]//2]
FArray.PShiftAdd (outArray, pos1, inArray, pos2, 1.0, outArray)
# Replace any blanks with zeroes
FArray.PDeblank(outArray, 0.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
