def up(self, event, lc):
if self.downloc != None:
dx = abs(lc[0] - self.downloc[0])
dy = abs(lc[1] - self.downloc[1])
dx = max(dx, dy) # Make box square
dx = old_div(good_size(dx * 2), 2) # use only good sizes
dy = dx
s = EMShape([
"rectpoint", .7, .2, 0, self.downloc[0] - dx,
self.downloc[1] - dy, self.downloc[0] + dx,
self.downloc[1] + dy, 1
])
self.im2d.del_shape("box")
if hypot(lc[0] - self.downloc[0], lc[1] - self.downloc[1]) > 5:
self.tiltshapes = [None for i in range(self.imageparm["nz"])]
self.find_boxes(s)
self.update_tilt()
self.downloc = None
elif self.downadjloc != None:
dx = (lc[0] - self.downadjloc[0][0])
dy = (lc[1] - self.downadjloc[0][1])
s = self.tiltshapes[self.curtilt].getShape()[:]
s[4] = self.downadjloc[1][0] + dx
s[5] = self.downadjloc[1][1] + dy
s[6] = self.downadjloc[1][2] + dx
s[7] = self.downadjloc[1][3] + dy
self.tiltshapes[self.curtilt] = EMShape(s)
self.im2d.add_shape("finalbox", self.tiltshapes[self.curtilt])
self.im2d.del_shape("box")
self.update_tilt()
self.update_stack()
self.downadjloc = None
def drag(self, event, lc):
if self.downloc != None:
dx = abs(lc[0] - self.downloc[0])
dy = abs(lc[1] - self.downloc[1])
dx = max(dx, dy) # Make box square
dx = old_div(good_size(dx * 2), 2) # use only good sizes
dy = dx
s = EMShape([
"rectpoint", 0, .7, 0, self.downloc[0] - dx,
self.downloc[1] - dy, self.downloc[0] + dx,
self.downloc[1] + dy, 1
])
self.im2d.add_shape("box", s)
s = EMShape([
"scrlabel", .7, .7, 0, 20.0, 20.0,
"%d (%d x %d)" % (self.curtilt, dx * 2, dy * 2), 200.0, 1
])
self.im2d.add_shape("tilt", s)
elif self.downadjloc != None:
dx = (lc[0] - self.downadjloc[0][0])
dy = (lc[1] - self.downadjloc[0][1])
s = self.tiltshapes[self.curtilt].getShape()[:]
s[4] = self.downadjloc[1][0] + dx
s[5] = self.downadjloc[1][1] + dy
s[6] = self.downadjloc[1][2] + dx
s[7] = self.downadjloc[1][3] + dy
self.im2d.add_shape("box", EMShape(s))
self.im2d.updateGL()
def update_view(self):
shps={}
for i,s in enumerate(self.all_shapes):
shp=["ellipse",1,0,0]+s[1:]+[2]+[s[0]]
shps[i]=EMShape(shp)
shps[len(self.all_shapes)]=EMShape(["ellipse",1,0,0]+self.shape[1:]+[2]+[self.shape[0]])
self.imgview.shapes=shps
self.imgview.shapechange=1
self.imgview.updateGL()
def get_label(self, text, size, box_size):
label = EMShape([
"label", 1, 1, 1, self.x - old_div(box_size, 2),
self.y + old_div(box_size, 2) + 10,
str(text), size, 2.0
])
return label
def update_tilt(self):
if self.imagefile == None: return
self.curimg = EMData(
self.imagefile, 0, False,
Region(0, 0, self.curtilt, self.imageparm["nx"],
self.imageparm["ny"], 1))
if self.invert: self.curimg.mult(-1.0)
self.im2d.set_data(self.curimg)
s = EMShape(
["scrlabel", .7, .3, 0, 20.0, 20.0,
"%d" % self.curtilt, 200.0, 1])
self.im2d.add_shape("tilt", s)
if self.tiltshapes[self.curtilt] != None:
self.im2d.add_shape("finalbox", self.tiltshapes[self.curtilt])
s0 = self.tiltshapes[self.oldtilt].getShape()
s1 = self.tiltshapes[self.curtilt].getShape()
dx = s0[4] - s1[4]
dy = s0[5] - s1[5]
self.im2d.set_origin(self.im2d.origin[0] - dx,
self.im2d.origin[1] - dy)
self.oldtilt = self.curtilt
self.im2d.updateGL()
def get_label(self, text, size, box_size):
label = EMShape([
"label", 1, 1, 1, self.x - box_size / 2,
self.y + box_size / 2 + 10,
str(text), size, 2.0
])
return label
def up(self, event, lc):
s = EMShape([
"line", .7, .2, 0, self.downloc[0], self.downloc[1], lc[0], lc[1],
1
])
self.im2d.del_shape("mine")
self.im2d.add_shape("done", s)
self.im2d.updateGL()
def xy_move(self,event): if self.optionviewer.erasercheckbox.isChecked(): x,y=self.xyview.scr_to_img((event.x(),event.y())) #print x,y self.xyview.eraser_shape=EMShape(["circle",1,1,1,x,y,self.eraser_width(),2]) self.xyview.shapechange=1 self.xyview.update() else: self.xyview.eraser_shape=None
def mouse_move(self,event,view): if self.optionviewer.erasercheckbox.isChecked(): self.xyview.eraser_shape=self.xzview.eraser_shape=self.zyview.eraser_shape=None x,y=view.scr_to_img((event.x(),event.y())) view.eraser_shape=EMShape(["circle",1,1,1,x,y,self.eraser_width(),2]) view.shapechange=1 view.update() else: view.eraser_shape=None
def paint_mask(self, v1x, v1y, v2x, v2y, v3x, v3y, v4x, v4y):
if self.masktype == "None":
self.boxes.add_mask(None)
elif self.masktype == "LineMask":
self.boxes.add_mask(
EMShape([
"linemask", 1, 0, 0, v1x, v1y, v2x, v2y, v3x, v3y, v4x,
v4y, 4.0
]))
elif self.masktype == "SolidMask":
# 10 is used to prevent aliasing
self.boxes.add_mask(
EMShape([
"mask", 0, 0, 0, -10, -10, v1x, v1y, self.win_xsize + 10,
-10, v2x, v2y, self.win_xsize + 10, self.win_ysize + 10,
v3x, v3y, -10, self.win_ysize + 10, v4x, v4y
]))
else:
self.boxes.add_mask(None)
def get_shape(self, shape_string, box_size):
if self.type in EMBox.BOX_COLORS:
r, g, b = EMBox.BOX_COLORS[self.type]
else:
r, g, b = 1.0, 0.42, 0.71 # hot pink, apparently ;)
shape = EMShape([
shape_string, r, g, b, self.x - old_div(box_size, 2),
self.y - old_div(box_size, 2), self.x + old_div(box_size, 2),
self.y + old_div(box_size, 2), 2.0
])
return shape
def update_box(self,n,quiet=False):
"""After adjusting a box, call this"""
# print "upd ",n,quiet
try:
box=self.boxes[n]
except IndexError:
return
bs2=self.get_boxsize(box[5])//2
color=self.setcolors[box[5]%len(self.setcolors)].getRgbF()
if self.options.mode=="3D":
self.xyview.add_shape(n,EMShape(["circle",color[0],color[1],color[2],box[0],box[1],bs2,2]))
self.xzview.add_shape(n,EMShape(["circle",color[0],color[1],color[2],box[0],box[2],bs2,2]))
self.zyview.add_shape(n,EMShape(("circle",color[0],color[1],color[2],box[2],box[1],bs2,2)))
else:
self.xyview.add_shape(n,EMShape(["rect",color[0],color[1],color[2],
box[0]-bs2,box[1]-bs2,box[0]+bs2,box[1]+bs2,2]))
self.xzview.add_shape(n,EMShape(["rect",color[0],color[1],color[2],
box[0]-bs2,box[2]-1,box[0]+bs2,box[2]+1,2]))
self.zyview.add_shape(n,EMShape(["rect",color[0],color[1],color[2],
box[2]-1,box[1]-bs2,box[2]+1,box[1]+bs2,2]))
if self.depth()!=box[2]:
self.wdepth.setValue(box[2])
else:
self.xyview.update()
if self.initialized: self.update_sides()
# For speed, we turn off updates while dragging a box around. Quiet is set until the mouse-up
if not quiet:
# Get the cube from the original data (normalized)
proj=self.get_cube(box[0], box[1], box[2], centerslice=True, boxsz=self.get_boxsize(box[5]))
proj.process_inplace("normalize")
for i in range(len(self.boxesimgs),n+1):
self.boxesimgs.append(None)
self.boxesimgs[n]=proj
mm=[m for im,m in enumerate(self.boxesimgs) if self.boxes[im][5] in self.sets_visible]
if self.initialized: self.SaveJson()
if self.initialized:
self.update_boximgs()
if n!=self.curbox:
self.boxesviewer.set_selected((n,),True)
self.curbox=n
self.update_coords()
def xy_drag(self,event): x,y=self.xyview.scr_to_img((event.x(),event.y())) x,y=int(x),int(y) if self.optionviewer.erasercheckbox.isChecked(): self.del_region_xy(x,y) self.xyview.eraser_shape=EMShape(["circle",1,1,1,x,y,self.eraser_width(),2]) self.xyview.shapechange=1 self.xyview.update() return if self.xydown==None : return dx=x-self.xydown[1] dy=y-self.xydown[2] self.boxes[self.xydown[0]][0]=dx+self.xydown[3] self.boxes[self.xydown[0]][1]=dy+self.xydown[4] self.update_box(self.curbox,True)
def update_box_shape(self,n, box):
bs2=self.get_boxsize(box[5])//2
if n==self.curbox:
lw=3
else:
lw=2
color=self.setcolors[box[5]%len(self.setcolors)].color().getRgbF()
if self.options.mode=="3D":
self.xyview.add_shape(n,EMShape(["circle",color[0],color[1],color[2],box[0],box[1],bs2,lw]))
self.xzview.add_shape(n,EMShape(["circle",color[0],color[1],color[2],box[0],box[2],bs2,lw]))
self.zyview.add_shape(n,EMShape(("circle",color[0],color[1],color[2],box[2],box[1],bs2,lw)))
else:
self.xyview.add_shape(n,EMShape(["rect",color[0],color[1],color[2],
box[0]-bs2,box[1]-bs2,box[0]+bs2,box[1]+bs2,2]))
self.xzview.add_shape(n,EMShape(["rect",color[0],color[1],color[2],
box[0]-bs2,box[2]-1,box[0]+bs2,box[2]+1,2]))
self.zyview.add_shape(n,EMShape(["rect",color[0],color[1],color[2],
box[2]-1,box[1]-bs2,box[2]+1,box[1]+bs2,2]))
def __init__(self, img, app):
EMImage2DWidget.__init__(self, img, application=app)
self.sx = img["nx"]
self.sy = img["ny"]
self.set_scale(.3)
minxy = min(self.sx, self.sy)
self.bar_len = minxy * .1
self.bar_ypos = -self.sy * .2
self.bar_thick = 20
self.bar_xpos = self.sx / 2
self.bar = EMShape()
self.barspeed = 0.02 * minxy
self.score = 0
self.score_label = EMShape()
self.ball = EMShape()
self.ball_rad = 20
self.ball_pos = np.array(
[self.bar_xpos, self.bar_ypos + self.bar_thick + self.ball_rad])
self.ball_speed = minxy * .01
self.set_shapes({0: self.bar, 1: self.ball, 2: self.score_label})
self.game_started = False
self.data.mult(-1)
#self.data.process_inplace("filter.lowpass.gauss",{"cutoff_abs":.05})
#self.data.process_inplace("normalize")
#self.data.process_inplace("threshold.belowtozero",{"minval":1})
#print self.data["mean_nonzero"],self.sx,self.sy
self.data.div(self.data["mean_nonzero"] * self.sx * self.sy)
self.data.mult(1000)
self.auto_contrast()
self.data_grad = self.data.process("math.gradient.direction")
self.del_msk = self.data.copy()
self.del_msk.to_one()
self.update_bar()
self.update_score()
self.update_ball()
print("break bricks..")
def drag(self, event, lc):
s = EMShape([
"line", 0, .7, 0, self.downloc[0], self.downloc[1], lc[0], lc[1], 1
])
self.im2d.add_shape("mine", s)
self.im2d.updateGL()
def find_boxes(self, mainshape):
"""Starting with a user selected box at the current tilt, search for the same shape in the entire
tilt series"""
if self.imagefile == None: return
self.tiltshapes[self.curtilt] = mainshape
lref = None
for i in range(self.curtilt + 1, self.imageparm["nz"]):
refshape = self.tiltshapes[i - 1].getShape()
# Read the reference at the user specified size, then pad it a bit
ref = EMData(
self.imagefile, 0, False,
Region(refshape[4], refshape[5], i - 1,
refshape[6] - refshape[4], refshape[7] - refshape[5],
1))
ref.process_inplace("threshold.clampminmax.nsigma",
{"nsigma": 4.0})
ref.process_inplace("filter.lowpass.gauss", {"cutoff_abs": .1})
ref.process_inplace("normalize.edgemean")
ref = ref.get_clip(
Region(-self.maxshift, -self.maxshift,
ref["nx"] + self.maxshift * 2,
ref["ny"] + self.maxshift * 2))
if lref != None and self.seqali: ref.add(lref)
ref.process_inplace(
"normalize.edgemean") # older images contribute less
lref = ref
# when we read the alignment target, we pad with actual image data since the object will have moved
trg = EMData(
self.imagefile, 0, False,
Region(refshape[4] - self.maxshift,
refshape[5] - self.maxshift, i,
refshape[6] - refshape[4] + self.maxshift * 2,
refshape[7] - refshape[5] + self.maxshift * 2, 1))
trg.process_inplace("threshold.clampminmax.nsigma",
{"nsigma": 4.0})
trg.process_inplace("filter.lowpass.gauss", {"cutoff_abs": .1})
trg.process_inplace("normalize.edgemean")
aln = ref.align(
"translational", trg, {
"intonly": 1,
"maxshift": old_div(self.maxshift * 4, 5),
"masked": 1
})
ref.write_image("dbug.hdf", -1)
trg.write_image("dbug.hdf", -1)
aln.write_image("dbug.hdf", -1)
trans = aln["xform.align2d"].get_trans()
# if i==self.curtilt+3 : display((ref,trg,aln,ref.calc_ccf(trg)))
self.tiltshapes[i] = EMShape([
"rectpoint", .7, .2, 0, refshape[4] + trans[0],
refshape[5] + trans[1], refshape[6] + trans[0],
refshape[7] + trans[1], 1
])
print(i, trans[0], trans[1])
lref = None
for i in range(self.curtilt - 1, -1, -1):
refshape = self.tiltshapes[i + 1].getShape()
# Read the reference at the user specified size, then pad it a bit
ref = EMData(
self.imagefile, 0, False,
Region(refshape[4], refshape[5], i + 1,
refshape[6] - refshape[4], refshape[7] - refshape[5],
1))
ref.process_inplace("filter.lowpass.gauss", {"cutoff_abs": .1})
ref.process_inplace("normalize.edgemean")
ref = ref.get_clip(
Region(-self.maxshift, -self.maxshift,
ref["nx"] + self.maxshift * 2,
ref["ny"] + self.maxshift * 2))
if lref != None and self.seqali: ref.add(lref)
ref.process_inplace("normalize.edgemean")
lref = ref
# when we read the alignment target, we pad with actual image data since the object will have moved
trg = EMData(
self.imagefile, 0, False,
Region(refshape[4] - self.maxshift,
refshape[5] - self.maxshift, i,
refshape[6] - refshape[4] + self.maxshift * 2,
refshape[7] - refshape[5] + self.maxshift * 2, 1))
trg.process_inplace("filter.lowpass.gauss", {"cutoff_abs": .1})
trg.process_inplace("normalize.edgemean")
aln = ref.align(
"translational", trg, {
"intonly": 1,
"maxshift": old_div(self.maxshift * 4, 5),
"masked": 1
})
trans = aln["xform.align2d"].get_trans()
if i == self.curtilt + 3:
display((ref, trg, aln, ref.calc_ccf(trg)))
self.tiltshapes[i] = EMShape([
"rectpoint", .7, .2, 0, refshape[4] + trans[0],
refshape[5] + trans[1], refshape[6] + trans[0],
refshape[7] + trans[1], 1
])
print(i, trans[0], trans[1])
self.update_stack()
class EMBreakBrick(EMImage2DWidget):
def __init__(self, img, app):
EMImage2DWidget.__init__(self, img, application=app)
self.sx = img["nx"]
self.sy = img["ny"]
self.set_scale(.3)
minxy = min(self.sx, self.sy)
self.bar_len = minxy * .1
self.bar_ypos = -self.sy * .2
self.bar_thick = 20
self.bar_xpos = self.sx / 2
self.bar = EMShape()
self.barspeed = 0.02 * minxy
self.score = 0
self.score_label = EMShape()
self.ball = EMShape()
self.ball_rad = 20
self.ball_pos = np.array(
[self.bar_xpos, self.bar_ypos + self.bar_thick + self.ball_rad])
self.ball_speed = minxy * .01
self.set_shapes({0: self.bar, 1: self.ball, 2: self.score_label})
self.game_started = False
self.data.mult(-1)
#self.data.process_inplace("filter.lowpass.gauss",{"cutoff_abs":.05})
#self.data.process_inplace("normalize")
#self.data.process_inplace("threshold.belowtozero",{"minval":1})
#print self.data["mean_nonzero"],self.sx,self.sy
self.data.div(self.data["mean_nonzero"] * self.sx * self.sy)
self.data.mult(1000)
self.auto_contrast()
self.data_grad = self.data.process("math.gradient.direction")
self.del_msk = self.data.copy()
self.del_msk.to_one()
self.update_bar()
self.update_score()
self.update_ball()
print("break bricks..")
def update_score(self):
self.score_label.setShape([
"label", 1, 1, 1, -self.sx * .1, self.sy * 1.1,
"{:.02f}".format(self.score), 100, 5
])
self.update_shapes({2: self.score_label})
self.updateGL()
def update_bar(self):
self.bar.setShape([
"line", 1, 1, 1, self.bar_xpos - self.bar_len, self.bar_ypos,
self.bar_xpos + self.bar_len, self.bar_ypos, self.bar_thick
])
self.update_shapes({0: self.bar})
self.updateGL()
if not self.game_started:
self.ball_pos = np.array([
self.bar_xpos, self.bar_ypos + self.bar_thick + self.ball_rad
])
self.update_ball()
def update_ball(self):
self.ball.setShape([
"circle", 1, 1, 1, self.ball_pos[0], self.ball_pos[1],
self.ball_rad, 2
])
#self.set_shapes({1:self.ball})
self.update_shapes({1: self.ball})
self.updateGL()
def start_game(self):
print("Start~")
self.ball_ori = 45. / 180. * np.pi
self.ball_vec = np.array([
self.ball_speed * np.cos(self.ball_ori),
self.ball_speed * np.sin(self.ball_ori)
])
self.game_timer = QTimer()
self.game_timer.timeout.connect(self.time_update)
self.game_timer.start(30)
self.game_started = True
def time_update(self):
#print "timer~~"
self.ball_move()
self.update_ball()
def ball_move(self):
newpos = self.ball_pos + self.ball_vec
if newpos[0] > self.sx or newpos[0] < 0: self.ball_vec[0] *= -1
elif newpos[1] > self.sy: self.ball_vec[1] *= -1
elif abs(newpos[1] - self.bar_ypos) < self.bar_thick and abs(
newpos[0] - self.bar_xpos) < self.bar_len:
self.ball_vec[1] *= -1
elif newpos[1] < self.bar_ypos - 200:
print("Lose...")
self.game_timer.stop()
else:
p = newpos.astype(int)
if p[1] < 0 or p[0] < 0 or p[0] > self.sx or p[1] > self.sy:
val = 0
else:
val = self.data.get_value_at(p[0], p[1])
if val > 0:
grad = self.data_grad.get_value_at(p[0], p[1])
#print val, grad
newori = (grad * 2 - self.ball_ori) % (np.pi * 2)
oridiff = abs(newori - self.ball_ori) * 180. / np.pi
if oridiff > 180: oridiff = oridiff - 180
#print self.ball_ori*180./np.pi,newori*180./np.pi,oridiff
if oridiff < 30:
#print "???"
newori += .5 * np.pi * np.sign(newori - self.ball_ori)
self.ball_ori = newori
self.ball_vec = np.array([
self.ball_speed * np.cos(self.ball_ori),
self.ball_speed * np.sin(self.ball_ori)
])
self.del_msk.to_one()
self.del_msk.process_inplace(
"mask.soft", {
"dx": p[0] - self.sx / 2,
"dy": p[1] - self.sy / 2,
"outer_radius": 30
})
delimg = self.data * self.del_msk
delval = delimg["mean"] * self.sx * self.sy
self.score += delval
self.update_score()
self.data.sub(delimg)
#self.data_grad=self.data.process("math.gradient.direction")
self.force_display_update()
self.ball_pos += self.ball_vec
def keyPressEvent(self, event):
if event.key() == Qt.Key_Right:
if self.bar_xpos + self.bar_len < self.sx:
self.bar_xpos += self.barspeed
self.update_bar()
elif event.key() == Qt.Key_Left:
if self.bar_xpos - self.bar_len > 0:
self.bar_xpos -= self.barspeed
self.update_bar()
elif event.key() == Qt.Key_Space:
if not self.game_started:
self.start_game()
def draw_wave(self):
sz=512-1 ### length of x-axis
xdivz=2e-3 ### x/z scale ratio
mpix=4e-8 ### pixel to meter
wavelen=2e-12/mpix ### wave length
wid=8 ### width of the slits
w2=4 ### position of the slits
#raw=np.zeros(sz) ### input signal
#raw[sz/2-wid-w2+1:sz/2+wid-w2+1]=1
#raw[sz/2-wid+w2:sz/2+wid+w2]=1
#raw[sz/2-wid+1:sz/2+wid]=1
raw0=np.zeros(sz) ### input signal
ni=self.options.ninput
dx=30/ni
for i in range(ni):
x=dx*i-15*(ni>1)
raw0+=np.exp(-(np.arange(sz, dtype="float32")-(sz/2)+x)**2/5)
#raw0+=np.exp(-(np.arange(sz, dtype=float)-sz/2-7.5)**2/5)
#raw0+=np.exp(-(np.arange(sz, dtype=float)-sz/2+7.5)**2/5)
#raw=np.exp(-1j*raw0*1)#*(np.exp(-raw0*.1))
#raw=raw0.copy()
raw=self.gauss_edge(sz, cl=.2, gw=.1)
raw*=np.exp(-1j*raw0*1)
#self.pltwindow.set_data([np.arange(sz)-sz/2, raw], "raw", linetype=0)
#return
#print wavelen
#print raw-raw[::-1]
#raw=raw*0+1
#### load lens info
mult=400 ### size multiplier from GL lens diagram to wave image
l=np.array(self.lens)[3:]
### use relative distance between lens instead of absolute positions
lens_gl=np.array([[l[i,0]-l[i+1,0], l[i,1]] for i in range(len(l)-1)])
lens=mult*lens_gl
#lens[:,0]=np.round(lens[:,0]) ### round z position
#lens[-1][0]+=10
ix=(np.arange(sz, dtype=float)-old_div(sz,2))*xdivz ## indices along x direction
ix_mat=(ix-ix[:,None])**2
cs=self.cs * mult ## spherical abberation
alldata=[]
for parallel in [False]: ### compute parallel beam when true
#### start wave propagation
imgs=[]
#### from scattering point to the first lens
zmax=np.round((self.lens[2][0]-l[0,0])*mult) ### z position of the first lens
#iz=np.arange(1,zmax)[:,None,None] ## indices along z direction
iz=(np.arange(1, int(zmax)+1, dtype=float)/int(zmax)*zmax)[:,None,None]
## zmax x sz x sz matrix
dst=np.sqrt(ix_mat +iz**2)
#print dst
#print ix.shape, iz.shape, dst.shape, raw.shape, (ix-ix[:,None]).shape
#pmult=1e-3
if parallel:
cpx=np.exp(-1j*2*np.pi*(iz+np.zeros((sz, sz)))/wavelen)*np.mean(raw)*(old_div(1,iz**2))
else:
cpx=raw[:,None]*np.exp(-1j*2*np.pi*dst/wavelen)*(old_div(1,dst**2))
img=np.sum(cpx, axis=1)
imgs.append(img)
shapes=[]
vz= np.sum(lens[:,0])-len(lens) ### to track z position
#print img.shape
for il,ln in enumerate(lens):
#break
f=ln[1]
proj=imgs[-1][-1] ### projection of wave on lens
fv=lens_gl[il][1]
if (fv<-3 and fv>-4): ### aperture
ap=fv+4
clip=old_div(int((1-ap)*sz),2)
msk=self.gauss_edge(sz, cl=old_div((1-ap),2.))
proj_ps=proj.copy()*msk
shapes.append(EMShape(("rect",.5, .5, 1, 0, vz-2, clip, vz+2, 2)))
shapes.append(EMShape(("rect",.5, .5, 1, sz-clip, vz-2, sz, vz+2, 2)))
elif fv==-5: ### phase plate
msk=self.gauss_edge(sz, cl=old_div(.1,2.))
phaseplate=self.gauss_edge(sz, cl=.49, gw=.1, gs=.01)
phaseplate=-phaseplate*np.pi/2.
proj_ps=proj.copy()*msk*np.exp(-1j*phaseplate)
shapes.append(EMShape(("rect",.8, .5, 1, 0, vz, sz, vz, 2)))
else: ### lens
ps=old_div(((ix)**2),(f*2))*(2*np.pi/wavelen) ### phase shift
ps+=cs*(ix**4)/4.
proj_ps=proj*np.exp(-1j*(-ps)) ### projection after phase
shapes.append(EMShape(("rect",1, .5, .5, 0, vz-2, sz, vz+2, 2)))
zmax=ln[0]
#iz=np.arange(1,zmax, dtype=float)[:,None,None] ## indices along z direction
iz=(np.arange(1, int(zmax)+1, dtype=float)/int(zmax)*zmax)[:,None,None]
dst=np.sqrt(ix_mat +iz**2)
cpx1=proj_ps[:,None]*np.exp(-1j*2*np.pi*dst/wavelen)*(old_div(1,dst**2))
img=np.sum(cpx1, axis=1)
imgs.append(img)
vz-=zmax-1
#print [m.shape for m in imgs]
final=np.vstack(imgs)
final/=np.sum(abs(final),axis=1)[:,None]
img=final[::-1,:].copy()
#img/=np.max(img)
alldata.append(img)
#print img.shape
#nrm=(np.sum(abs(alldata[0]), axis=1)+np.sum(abs(alldata[1]), axis=1))/sz
#for i in [0,1]: alldata[i]/=nrm[:,None]
self.imgwindow.shapes={ i:shapes[i] for i in range(len(shapes)) }
self.imgwindow.shapechange=1
#self.imgwindow.set_data([from_numpy(abs(d)*np.sin(np.angle(d))) for d in alldata])
self.imgwindow.set_data([
from_numpy(abs(alldata[0]).astype("float32")),
from_numpy(np.cos(np.angle(alldata[0])).astype("float32")) ])
if self.pltwindow:
a0=alldata[0][0,:]
#a1=alldata[1][0,:]
r0=(np.arange(sz)-old_div(sz,2))*abs(self.mag)
if self.wavesign<0: r0=r0[::-1]
clip=np.where(abs(r0)<old_div(sz,2))[0]
if len(clip)>0:
c=clip[0]
rawplot=[r0[c:-c], raw0[c:-c]]
else:
rawplot=[r0, raw0]
#rawplot=[np.arange(sz)-sz/2, raw0]
self.pltwindow.set_data([np.arange(sz)-old_div(sz,2), old_div(abs(a0),np.max(abs(a0)))], "scatter", linetype=0)
self.pltwindow.set_data(rawplot, "raw", linetype=0)
#self.pltwindow.set_data([np.arange(sz)-sz/2, abs(alldata[1][0,:])], "parallel", linetype=0)
#self.pltwindow.set_data([np.arange(sz)-sz/2,
#abs(a0/abs(a0)+a1/abs(a1))], "contrast", linetype=0)
#self.pltwindow.set_data([np.arange(sz)-sz/2, np.sin(np.angle(a0))], "phase_scatter", linetype=0)
#self.pltwindow.set_data([np.arange(sz)-sz/2, np.sin(np.angle(a1))], "phase_parallel", linetype=0)
aa=abs(a0)
if self.wavesign>0:
bd=np.where(raw0>.01)[0]
else:
bd=np.where(raw0[::-1]>.01)[0]
bd=[bd[0], bd[-1]]
pad=int((bd[1]-bd[0])*1.)
bd=[bd[0]-pad, bd[1]+pad]
bd=[int((b-old_div(sz,2))*abs(self.mag)+old_div(sz,2)) for b in bd]
bd[0]=max(0,bd[0])
bd[1]=min(sz-1, bd[1])
#print bd
aa-=old_div((aa[bd[0]]+aa[bd[1]]),2.)
#print bd
aa[:bd[0]]=0
aa[bd[1]-1:]=0
aa/=np.max(abs(aa))
a0ft=np.real(np.fft.fftshift(np.fft.fft(np.fft.fftshift((aa)))))
#rawft=np.real(np.fft.fftshift(np.fft.fft(np.fft.fftshift(a0))))
rawft=np.abs(np.fft.fftshift(np.fft.fft(np.fft.fftshift(-raw0))))
a0ft/=np.max(a0ft)
#a0ft[sz/2]=1
rawft/=np.max(rawft)
rf=rawft.copy()
rf[abs(rf)<1e-3]=1
ctf=old_div(a0ft,rf)
ctf[abs(rawft)<1e-3]=0
ftidx=np.fft.fftfreq(len(a0))
#print self.mag
#self.pltwindow.set_data([np.arange(sz)-sz/2, aa], "scatter_msk", linetype=0)
#self.pltwindow.set_data([r0[c:-c], a0ft[c:-c]], "scatter_fft", linetype=0)
#self.pltwindow.set_data([np.arange(sz)-sz/2, rawft], "raw_fft", linetype=0)
#self.pltwindow.set_data([np.arange(sz)-sz/2, ctf], "ctf", linetype=0)
#contrast=np.sin(np.angle(a0+a1))
#contrast=(np.angle(a0)-np.angle(a1))*180/np.pi
#self.pltwindow.set_data([np.arange(sz)-sz/2, contrast], "phase_contrast", linetype=0)
return img
