def CreateMask(self):
self.ComputeNoiseMap()
self.MakeMask()
if self.ds9Mask!="":
self.MaskSelectedDS9()
ExternalAndMask=self.options.ExternalMask
if ExternalAndMask is not None and ExternalAndMask is not "":
from DDFacet.Imager import ClassCasaImage
CleanMaskImageName=ExternalAndMask
print>>log,"Use mask image %s"%CleanMaskImageName
CleanMaskImage = np.bool8(ClassCasaImage.FileToArray(CleanMaskImageName,False))[0,0]
self.ImMask=(self.ImMask & CleanMaskImage)
if self.UseIslands:
# Make island list
self.BuildIslandList()
self.FilterIslands()
self.IslandsToMask()
# self.plot()
nx,ny=self.ImMask.shape
ImWrite=self.ImMask.reshape((1,1,nx,ny))
PutDataInNewImage(self.FitsFile,self.FitsFile+"."+self.OutName,np.float32(ImWrite))
def test():
FitsFile="/media/tasse/data/DDFacet/Test/MultiFreqs3.restored.fits"
Conv=ClassMakeMask(FitsFile=FitsFile,Th=5.,Box=(50,10))
Conv.ComputeNoiseMap()
Conv.FindIslands()
nx,ny=Conv.ImIsland.shape
ImWrite=Conv.ImIsland.reshape((1,1,nx,ny))
PutDataInNewImage(FitsFile,FitsFile+".mask",np.float32(ImWrite))
def CreateMask(self):
self.ComputeNoiseMap()
self.MakeMask()
if self.ds9Mask != "":
self.MaskSelectedDS9()
if self.UseIslands:
# Make island list
self.BuildIslandList()
self.FilterIslands()
self.IslandsToMask()
#self.plot()
nx, ny = self.ImMask.shape
ImWrite = self.ImMask.reshape((1, 1, nx, ny))
PutDataInNewImage(self.FitsFile, self.FitsFile + "." + self.OutName,
np.float32(ImWrite))
def ComputeNoiseMap(self):
print>>log, "Compute noise map..."
Boost=self.Boost
Acopy=self.Restored[0,0,0::Boost,0::Boost].copy()
SBox=(self.box[0]/Boost,self.box[1]/Boost)
# MeanAbs=scipy.ndimage.filters.mean_filter(np.abs(Acopy),SBox)
# Acopy[Acopy>0]=MeanAbs[Acopy>0]
# Noise=np.sqrt(scipy.ndimage.filters.median_filter(np.abs(Acopy)**2,SBox))
x=np.linspace(-10,10,1000)
f=0.5*(1.+scipy.special.erf(x/np.sqrt(2.)))
n=SBox[0]*SBox[1]
F=1.-(1.-f)**n
ratio=np.abs(np.interp(0.5,F,x))
Noise=-scipy.ndimage.filters.minimum_filter(Acopy,SBox)/ratio
Noise[Noise<0]=1e-10
# indxy=(Acopy>5.*Noise)
# Acopy[indxy]=5*Noise[indxy]
# Noise=np.sqrt(scipy.ndimage.filters.median_filter(np.abs(Acopy)**2,SBox))
# indxy=(Acopy>5.*Noise)
# Acopy[indxy]=5*Noise[indxy]
# Noise=np.sqrt(scipy.ndimage.filters.median_filter(np.abs(Acopy)**2,SBox))
#NoiseMed=np.median(Noise)
#Noise[Noise<NoiseMed]=NoiseMed
self.Noise=np.zeros_like(self.Restored[0,0])
for i in range(Boost):
for j in range(Boost):
s00,s01=Noise.shape
s10,s11=self.Noise[i::Boost,j::Boost].shape
s0,s1=min(s00,s10),min(s10,s11)
self.Noise[i::Boost,j::Boost][0:s0,0:s1]=Noise[:,:][0:s0,0:s1]
ind=np.where(self.Noise==0.)
self.Noise[ind]=1e-10
if self.options.OutMaskExtended:
GD=None
MaskExtended=(self.Noise<0.1*np.median(self.Noise))
OutMaskExtended=self.options.OutMaskExtended
nx=MaskExtended.shape[-1]
CurrentNegMask=np.logical_not(MaskExtended).reshape((1,1,nx,nx))
PSFServer=None
IdSharedMem=None
DicoDirty=None
IslandDistanceMachine=DDFacet.Imager.SSD.ClassIslandDistanceMachine.ClassIslandDistanceMachine(GD,
CurrentNegMask,
PSFServer,
DicoDirty,
IdSharedMem=IdSharedMem)
ListIslands=IslandDistanceMachine.SearchIslands(None,Image=self.Restored)
ListIslands=IslandDistanceMachine.ConvexifyIsland(ListIslands)#,PolygonFile="%s.pickle"%OutMaskExtended)
ListPolygons=IslandDistanceMachine.ListPolygons
MaskOut=np.zeros_like(CurrentNegMask)
N=0
for Island in ListIslands:
x,y=np.array(Island).T
#if x.size<=10: continue
MaskOut[0,0,x,y]=1
#ff,pol,_,_dec,ra=self.CasaIm.toworld((0,0,0,0))
ListPolygonsRADEC=[]
for Polygon in ListPolygons:
xx,yy=Polygon.T
ThisPolygon=[]
for iP in range(xx.shape[0]):
xcc,ycc =xx[iP],yy[iP]
ff,pol,dec,ra=self.CasaIm.toworld((0,0,xcc,ycc))
ThisPolygon.append((ra,dec))
ListPolygonsRADEC.append(np.array(ThisPolygon))
FName="%s.pickle"%OutMaskExtended
print>>log,"Saving %s"%FName
MyPickle.Save(ListPolygonsRADEC,FName)
REGName="%s.reg"%OutMaskExtended
RM=ModRegFile.PolygonNpToReg(ListPolygonsRADEC,REGName)
RM.makeRegPolyREG()
# TestArray=np.zeros_like(CurrentNegMask)
# nx=TestArray.shape[-1]
# xx,yy=20,100
# TestArray[0,0,xx,yy]=1
# PutDataInNewImage(self.FitsFile,"TestCoord.fits",np.float32(TestArray))
# ff,pol,dec,ra=self.CasaIm.toworld((0,0,xx,yy))
# pp=[[xx,yy],[yy,xx],
# [nx/2-xx,yy],[nx/2+xx,yy],
# [nx/2-yy,xx],[nx/2+yy,xx]]
# for isol in range(len(pp)):
# xx,yy=pp[isol]
# ff,pol,dec,ra=self.CasaIm.toworld((0,0,xx,yy))
# sRA =rad2hmsdms(ra,Type="ra").replace(" ",":")
# sDEC =rad2hmsdms(dec,Type="dec").replace(" ",":")
# stop
MaskOut=np.zeros_like(CurrentNegMask)
N=0
for Island in ListIslands:
x,y=np.array(Island).T
if x.size<=10: continue
MaskOut[0,0,x,y]=1
N+=1
print>>log,"Number of large enough islands %i"%N
MaskExtended=MaskOut
os.system("rm -rf %s"%OutMaskExtended)
os.system("rm -rf %s.fits"%OutMaskExtended)
PutDataInNewImage(self.FitsFile,OutMaskExtended,np.float32(MaskExtended))
NoiseMed=np.median(self.Noise)
self.Noise[self.Noise<NoiseMed]=NoiseMed
nx=self.Noise.shape[-1]
if self.options.ConvNoise:
print>>log,"Convolve..."
NoiseMap,G=ModFFTW.ConvolveGaussianWrapper(self.Noise.reshape((1,1,nx,nx)),Sig=4*SBox[0])
NoiseMap/=np.sum(G)
self.Noise=NoiseMap[0,0]
if self.OutNameNoiseMap!="":
#print>>log, "Save noise map as %s"%self.OutNameNoiseMap
#self.CasaIm.saveas(self.OutNameNoiseMap)
#CasaNoise=image(self.OutNameNoiseMap)
#CasaNoise.putdata(self.Noise)
#CasaNoise.tofits(self.OutNameNoiseMap+".fits")
#del(CasaNoise)
os.system("rm -rf %s"%self.OutNameNoiseMap)
#os.system("rm -rf %s"%self.OutNameNoiseMap+".fits")
PutDataInNewImage(self.FitsFile,self.OutNameNoiseMap,np.float32(self.Noise))
os.system("rm -rf %s.mean"%self.OutNameNoiseMap)
PutDataInNewImage(self.FitsFile,self.OutNameNoiseMap+".mean",np.float32(np.zeros_like(self.Noise)))
def giveBrightFaintMask(self):
print>>log,"Build facetted bright/faint mask..."
GD=None
Mask=self.ImMask
nx=Mask.shape[-1]
CurrentNegMask=np.logical_not(Mask).reshape((1,1,nx,nx))
PSFServer=None
IdSharedMem=None
DicoDirty=None
IslandDistanceMachine=DDFacet.Imager.SSD.ClassIslandDistanceMachine.ClassIslandDistanceMachine(GD,
CurrentNegMask,
PSFServer,
DicoDirty,
IdSharedMem=IdSharedMem)
ListIslands=IslandDistanceMachine.SearchIslands(None,Image=self.Restored)
ListIslands=IslandDistanceMachine.ConvexifyIsland(ListIslands)#,PolygonFile="%s.pickle"%OutMaskExtended)
Mask=np.zeros((nx,nx),np.float32)
for Island in ListIslands:
x,y=np.array(Island).T
Mask[x,y]=1
OutTest="%s.convex_mask"%self.FitsFile
os.system("rm -rf %s"%OutTest)
os.system("rm -rf %s.fits"%OutTest)
ImWrite=Mask.reshape((1,1,nx,nx))
PutDataInNewImage(self.FitsFile,OutTest,np.float32(ImWrite))
ListPolygons=IslandDistanceMachine.ListPolygons
BaseImageName=self.FitsFile.split(".app.")[0]
if self.options.BaseImageName: BaseImageName=self.options.BaseImageName
D=DDFacet.Other.MyPickle.Load("%s.DicoFacet"%BaseImageName)
#LSol=[D[iFacet]["iSol"][0] for iFacet in D.keys()]
DicoDir={}
for iFacet in D.keys():
iSol=D[iFacet]["iSol"][0]
if not iSol in DicoDir.keys():
DicoDir[iSol]=[iFacet]
else:
DicoDir[iSol].append(iFacet)
MaskBright=np.zeros((nx,nx),np.float32)
MaskFaint=np.zeros((nx,nx),np.float32)
for iSol in DicoDir.keys():
print>>log,"===================== Processing direction %2.2i/%2.2i ====================="%(iSol,len(DicoDir))
ThisFacetMask=np.zeros_like(Mask)-1
for iFacet in DicoDir[iSol]:
PolyGon=D[iFacet]["Polygon"]
l,m=PolyGon.T
x,y=((l/self.incr_rad+nx/2)), ((m/self.incr_rad+nx/2))
poly2=np.array([x,y]).T
x0,x1=x.min(),x.max()
y0,y1=y.min(),y.max()
xx,yy=np.mgrid[x0:x1:(x1-x0+1)*1j,y0:y1:(y1-y0+1)*1j]
xx=np.int16(xx)
yy=np.int16(yy)
pp=np.zeros((poly2.shape[0]+1,2),dtype=poly2.dtype)
pp[0:-1,:]=poly2[:,:]
pp[-1,:]=poly2[0,:]
#ListPolygons.append(pp)
mpath = Path(pp)
p_grid=np.zeros((xx.size,2),np.int16)
p_grid[:,0]=xx.ravel()
p_grid[:,1]=yy.ravel()
mask_flat = mpath.contains_points(p_grid)
IslandOut=np.array([xx.ravel()[mask_flat],yy.ravel()[mask_flat]])
x,y=IslandOut
ThisFacetMask[x,y]=1
#raFacet, decFacet = self.CoordMachine.lm2radec(np.array([lmShift[0]]),
# np.array([lmShift[1]]))
ThisFacetMask=ThisFacetMask[::-1,:].T
ThisFacetMask= (np.abs(Mask - ThisFacetMask)<1e-6)
IslandDistanceMachine=DDFacet.Imager.SSD.ClassIslandDistanceMachine.ClassIslandDistanceMachine(GD,
1-ThisFacetMask.reshape((1,1,nx,nx)),
PSFServer,
DicoDirty,
IdSharedMem=IdSharedMem)
ListIslands=IslandDistanceMachine.SearchIslands(None,Image=self.Restored)
ListIslands=IslandDistanceMachine.ConvexifyIsland(ListIslands)
DFlux=np.zeros((len(ListIslands),),np.float32)
for iIsland,Island in enumerate(ListIslands):
x,y=np.array(Island).T
DFlux[iIsland]=np.sum(self.Restored[0,0,x,y])
iIsland_bright=np.argmax(DFlux)
for iIsland,Island in enumerate(ListIslands):
x,y=np.array(Island).T
if iIsland==iIsland_bright:
MaskBright[x,y]=1
else:
MaskFaint[x,y]=1
OutTest="%s.bright_mask"%self.FitsFile
os.system("rm -rf %s"%OutTest)
os.system("rm -rf %s.fits"%OutTest)
ImWrite=MaskBright.reshape((1,1,nx,nx))
PutDataInNewImage(self.FitsFile,"%s.fits"%OutTest,np.float32(ImWrite))
OutTest="%s.faint_mask"%self.FitsFile
os.system("rm -rf %s"%OutTest)
os.system("rm -rf %s.fits"%OutTest)
ImWrite=MaskFaint.reshape((1,1,nx,nx))
PutDataInNewImage(self.FitsFile,"%s.fits"%OutTest,np.float32(ImWrite))