def __init__(self): EMImage2DWidget.__init__(self) # the single image display widget self.datatodisp=[test_image(1),test_image(2)] self.curdata=0 self.set_data(self.datatodisp[0]) timer = QtCore.QTimer(self) timer.timeout.connect(self.mytimeout) timer.start(1000)
def __init__(self, mode=0, cs=0., twod=False): QtGui.QMainWindow.__init__(self) if twod: self.twodview = EMImage2DWidget() widget = Microscope(self, None, None, self.twodview, mode, cs) else: self.imgview = EMImage2DWidget() self.pltview = EMPlot2DWidget() widget = Microscope(self, self.imgview, self.pltview, None, mode, cs) #widget = Microscope(self, None, None, None, mode, cs) #widget = Microscope(self, None, None) self.closeEvent=widget.closeEvent self.setCentralWidget(widget)
def __init__(self, options): QtWidgets.QMainWindow.__init__(self) if options.twod: self.twodview = EMImage2DWidget() widget = Microscope(self, options, None, None, self.twodview) else: self.imgview = EMImage2DWidget() self.pltview = EMPlot2DWidget() widget = Microscope(self, options, self.imgview, self.pltview, None) #widget = Microscope(self, None, None, None, mode, cs) #widget = Microscope(self, None, None) self.closeEvent=widget.closeEvent self.setCentralWidget(widget)
def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument("--label",
type=str,
help="Load previous contour segmentation.",
default="tomobox")
parser.add_argument("--gpuid",
type=str,
help="Specify the gpu to use",
default="")
parser.add_argument("--mult",
type=float,
help="multiply data by factor. useful for vpp data...",
default=1)
#parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-2)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
test = EMImage2DWidget()
drawer = EMTomobox(app, options)
drawer.show()
app.execute()
E2end(logid)
def __init__(self, application, options, datafile=None):
QtWidgets.QWidget.__init__(self)
self.imgview = EMImage2DWidget()
self.setCentralWidget(QtWidgets.QWidget())
self.gbl = QtWidgets.QGridLayout(self.centralWidget())
self.gbl.addWidget(self.imgview, 0, 0)
self.options = options
self.app = weakref.ref(application)
self.datafile = datafile
self.imgview.set_data(datafile)
#self.all_shapes=[]
#self.all_points=[]
pts = []
if options.load:
pts = np.loadtxt(options.load).tolist()
self.contour = Contour(img=self.imgview, points=pts)
self.shape_index = 0
self.imgview.shapes = {0: self.contour}
self.imgview.mouseup.connect(self.on_mouseup)
self.imgview.keypress.connect(self.key_press)
glEnable(GL_POINT_SMOOTH)
glEnable(GL_LINE_SMOOTH)
glEnable(GL_POLYGON_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def __init__(self, application, options, datafile, pks, xfs, dirs):
QtWidgets.QWidget.__init__(self)
self.imgview = EMImage2DWidget()
self.setCentralWidget(QtWidgets.QWidget())
self.gbl = QtWidgets.QGridLayout(self.centralWidget())
self.gbl.addWidget(self.imgview, 0, 0)
self.options = options
self.app = weakref.ref(application)
self.datafile = datafile
self.imgview.set_data(datafile)
#self.all_shapes=[]
#self.all_points=[]
self.boxes = Boxes(self.imgview, pks, xfs, dirs)
self.shape_index = 0
self.imgview.shapes = {0: self.boxes}
glEnable(GL_POINT_SMOOTH)
glEnable(GL_LINE_SMOOTH)
glEnable(GL_POLYGON_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def object_picked(self, object_number):
if object_number == self.current_projection: return
self.current_projection = object_number
resize_necessary = False
if self.mx_display == None:
self.mx_display = EMImage2DWidget()
# self.mx_display = EMImageMXWidget()
self.mx_display.module_closed.connect(self.on_mx_display_closed)
resize_necessary = True
if self.frc_display == None:
self.frc_display = EMPlot2DWidget()
# QtCore.QObject.connect(self.frc_display,QtCore.SIGNAL("module_closed"),self.on_frc_display_closed)
self.update_display(False)
if resize_necessary:
get_application().show_specific(self.mx_display)
self.mx_display.optimally_resize()
get_application().show_specific(self.frc_display)
# self.frc_display.optimally_resize()
else:
self.mx_display.updateGL()
self.frc_display.updateGL()
if object_number != self.special_euler:
self.special_euler = object_number
self.regen_dl()
def __init__(self, application, options, datafile=None):
QtGui.QWidget.__init__(self)
self.imgview = EMImage2DWidget()
self.setCentralWidget(QtGui.QWidget())
self.gbl = QtGui.QGridLayout(self.centralWidget())
self.gbl.addWidget(self.imgview, 0, 0)
self.options = options
self.app = weakref.ref(application)
self.datafile = datafile
self.imgview.set_data(datafile)
self.shape = [0] * 6
self.all_shapes = []
self.state = 0
self.shape_index = 0
self.origin = [0, 0]
self.imgview.shapes = {}
print("imgnum,x,y,major,minor,angle")
QtCore.QObject.connect(self.imgview, QtCore.SIGNAL("mouseup"),
self.mouseup)
QtCore.QObject.connect(self.imgview, QtCore.SIGNAL("mousemove"),
self.mousemv)
def __init__(self,application,options):
self.options=options
self.check_path(options.path)
self.get_data(0)
QtWidgets.QWidget.__init__(self)
self.imgview = EMImage2DWidget()
self.setCentralWidget(QtWidgets.QWidget())
self.gbl = QtWidgets.QGridLayout(self.centralWidget())
self.lb_name=QtWidgets.QLabel(self.tomoname)
self.lb_name.setWordWrap(True)
self.gbl.addWidget(self.lb_name, 0,0,1,2)
self.iterlst=QtWidgets.QListWidget()
self.iterlst.itemflags=Qt.ItemFlags(Qt.ItemIsSelectable)
for i in sorted(self.losses.keys()):
txt="{:d} : loss = {:.1f}".format(i, self.losses[i])
item=QtWidgets.QListWidgetItem(txt)
self.iterlst.addItem(item)
self.iterlst.currentRowChanged[int].connect(self.update_list)
self.gbl.addWidget(self.iterlst,1,0,1,2)
self.app=weakref.ref(application)
self.imgview = EMImage2DWidget()
self.boxes=Boxes(self.imgview, self.pks2d, self.dirs)
self.shape_index = 0
self.imgview.set_data(self.datafile)
self.imgview.shapes = {0:self.boxes}
self.imgview.show()
self.imgview.mouseup.connect(self.on_mouseup)
self.boxesviewer=EMImageMXWidget()
self.boxesviewer.show()
self.boxesviewer.set_mouse_mode("App")
self.boxesviewer.setWindowTitle("Landmarks")
self.boxesviewer.rzonce=True
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 __init__(self,app): # the single image display widget self.im2d = EMImage2DWidget(application=app) # get some signals from the window. self.im2d.mousedown.connect(self.down) self.im2d.mousedrag.connect(self.drag) self.im2d.mouseup.connect(self.up) #self explanatory a=test_image(size=(512,512)) self.im2d.set_data(a) self.im2d.show()
def __init__(self, rctwidget, name):
self.name = name
self.filename = None
self.rctwidget = rctwidget
self.window = EMImage2DWidget(application=self.rctwidget.parent_window)
self.boxes = EMBoxList()
self.window.set_mouse_mode(0)
self.connect_signals()
self.moving = None
self.data = None
self.win_xsize = 0
self.win_ysize = 0
self.slow = False
self.masktype = "None"
def __init__(self, app):
# the single image display widget
self.im2d = EMImage2DWidget(application=app)
# get some signals from the window.
QtCore.QObject.connect(self.im2d, QtCore.SIGNAL("mousedown"),
self.down)
QtCore.QObject.connect(self.im2d, QtCore.SIGNAL("mousedrag"),
self.drag)
QtCore.QObject.connect(self.im2d, QtCore.SIGNAL("mouseup"), self.up)
#self explanatory
a = test_image(size=(512, 512))
self.im2d.set_data(a)
self.im2d.show()
def __init__(self):
QtGui.QWidget.__init__(self)
self.setWindowTitle("Single Particle View")
self.resize(300,300)
self.gbl = QtGui.QGridLayout(self)
self.xyview = EMImage2DWidget()
self.gbl.addWidget(self.xyview,0,1)
self.xzview = EMImage2DWidget()
self.gbl.addWidget(self.xzview,1,1)
self.zyview = EMImage2DWidget()
self.gbl.addWidget(self.zyview,0,0)
self.data = None
# This puts an isosurface view in the lower left corner, but was causing a lot of segfaults, so switching to 2-D slices for now
#self.d3view = EMScene3D()
#self.d3viewdata = EMDataItem3D(test_image_3d(3), transform=Transform())
#isosurface = EMIsosurface(self.d3viewdata, transform=Transform())
#self.d3view.insertNewNode('', self.d3viewdata, parentnode=self.d3view)
#self.d3view.insertNewNode("Iso", isosurface, parentnode=self.d3viewdata )
self.d3view = EMImage2DWidget()
self.gbl.addWidget(self.d3view,1,0)
self.wfilt = ValSlider(rng=(0,50),label="Filter:",value=0.0)
self.gbl.addWidget(self.wfilt,2,0,1,2)
self.wfilt.valueChanged.connect(self.event_filter)
self.gbl.setRowStretch(2,1)
self.gbl.setRowStretch(0,5)
self.gbl.setRowStretch(1,5)
def display_validation_plots(path,
radcut,
planethres,
plotdatalabels=False,
color='#00ff00',
plotzaxiscolor=False):
from eman2_gui.emimage2d import EMImage2DWidget
from eman2_gui.emapplication import EMApp
r = []
theta = []
datap = []
zaxis = []
try:
tpdb = js_open_dict("%s/perparticletilts.json" % path)
tplist = tpdb["particletilt_list"]
maxcolorval = max(tplist, key=lambda x: x[3])[3]
for tp in tplist:
if tp[3] > planethres: # if the out of plane threshold is too much
continue
if plotdatalabels: datap.append(tp[0])
r.append(tp[1])
theta.append(math.radians(tp[2]))
# Color the Z axis out of planeness
zaxis.append(computeRGBcolor(tp[3], 0, maxcolorval))
tpdb.close()
except:
print("Couldn't load tp from DB, not showing polar plot")
data = None
try:
data = EMData("%s/contour.hdf" % path)
except:
print("Couldn't open contour plot")
if not data and not (theta and r): return
app = EMApp()
if theta and r:
plot = EMValidationPlot()
plot.set_data((theta, r), 50, radcut, datap)
# Color by Z axis if desired
if plotzaxiscolor: plot.set_scattercolor([zaxis])
plot.set_datalabelscolor(color)
plot.show()
if data:
image = EMImage2DWidget(data)
image.show()
app.exec_()
def __init__(self,
application,
apix=1.0,
voltage=300.0,
cs=4.1,
ac=10.0,
samples=256,
apply=None):
"""CTF simulation dialog
"""
try:
from eman2_gui.emimage2d import EMImage2DWidget
except:
print("Cannot import EMAN image GUI objects (EMImage2DWidget)")
sys.exit(1)
try:
from eman2_gui.emplot2d import EMPlot2DWidget
except:
print(
"Cannot import EMAN plot GUI objects (is matplotlib installed?)"
)
sys.exit(1)
self.app = weakref.ref(application)
self.df_voltage = voltage
self.df_apix = apix
self.df_cs = cs
self.df_ac = ac
self.df_samples = samples
self.img = None
if apply == None:
self.apply = None
self.applyim = None
else:
self.apply = EMData(apply, 0)
self.df_apix = self.apply["apix_x"]
print("A/pix reset to ", self.df_apix)
self.applyim = EMImage2DWidget(application=self.app())
QtGui.QWidget.__init__(self, None)
self.setWindowIcon(QtGui.QIcon(get_image_directory() + "ctf.png"))
self.data = []
self.curset = 0
self.plotmode = 0
self.guiim = EMImage2DWidget(application=self.app())
self.guiiminit = True # a flag that's used to auto resize the first time the gui's set_data function is called
self.guiplot = EMPlot2DWidget(application=self.app())
# self.guirealim=EMImage2DWidget(application=self.app()) # This will show the original particle images
self.guiim.mousedown.connect(self.imgmousedown)
self.guiim.mousedrag.connect(self.imgmousedrag)
self.guiim.mouseup.connect(self.imgmouseup)
self.guiplot.mousedown.connect(self.plotmousedown)
self.guiim.mmode = "app"
# This object is itself a widget we need to set up
self.hbl = QtGui.QHBoxLayout(self)
self.hbl.setMargin(0)
self.hbl.setSpacing(6)
self.hbl.setObjectName("hbl")
# plot list and plot mode combobox
self.vbl2 = QtGui.QVBoxLayout()
self.setlist = MyListWidget(self)
self.setlist.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
self.vbl2.addWidget(self.setlist)
self.splotmode = QtGui.QComboBox(self)
self.splotmode.addItem("Amplitude")
self.splotmode.addItem("Intensity")
self.splotmode.addItem("Int w sum")
self.splotmode.addItem("Amp w sum")
self.vbl2.addWidget(self.splotmode)
self.hbl.addLayout(self.vbl2)
# ValSliders for CTF parameters
self.vbl = QtGui.QVBoxLayout()
self.vbl.setMargin(0)
self.vbl.setSpacing(6)
self.vbl.setObjectName("vbl")
self.hbl.addLayout(self.vbl)
#self.samp = ValSlider(self,(0,5.0),"Amp:",0)
#self.vbl.addWidget(self.samp)
self.imginfo = QtGui.QLabel("Info", self)
self.vbl.addWidget(self.imginfo)
self.sdefocus = ValSlider(self, (0, 5), "Defocus:", 0, 90)
self.vbl.addWidget(self.sdefocus)
self.sbfactor = ValSlider(self, (0, 1600), "B factor:", 100, 90)
self.vbl.addWidget(self.sbfactor)
self.sdfdiff = ValSlider(self, (0, 1), "DF Diff:", 0, 90)
self.vbl.addWidget(self.sdfdiff)
self.sdfang = ValSlider(self, (0, 180), "Df Angle:", 0, 90)
self.vbl.addWidget(self.sdfang)
self.sampcont = ValSlider(self, (0, 100), "% AC", 0, 90)
self.vbl.addWidget(self.sampcont)
self.sphase = ValSlider(self, (0, 1), "Phase/pi", 0, 90)
self.vbl.addWidget(self.sphase)
self.sapix = ValSlider(self, (.2, 10), "A/Pix:", 2, 90)
self.vbl.addWidget(self.sapix)
self.svoltage = ValSlider(self, (0, 1000), "Voltage (kV):", 0, 90)
self.vbl.addWidget(self.svoltage)
self.scs = ValSlider(self, (0, 5), "Cs (mm):", 0, 90)
self.vbl.addWidget(self.scs)
self.ssamples = ValSlider(self, (32, 1024), "# Samples:", 0, 90)
self.ssamples.setIntonly(True)
self.vbl.addWidget(self.ssamples)
self.hbl_buttons = QtGui.QHBoxLayout()
self.newbut = QtGui.QPushButton("New")
self.hbl_buttons.addWidget(self.newbut)
self.vbl.addLayout(self.hbl_buttons)
self.on_new_but()
self.sdefocus.valueChanged.connect(self.newCTF)
self.sbfactor.valueChanged.connect(self.newCTF)
self.sdfdiff.valueChanged.connect(self.newCTF)
self.sdfang.valueChanged.connect(self.newCTF)
self.sapix.valueChanged.connect(self.newCTF)
self.sampcont.valueChanged.connect(self.newCTFac)
self.sphase.valueChanged.connect(self.newCTFpha)
self.svoltage.valueChanged.connect(self.newCTF)
self.scs.valueChanged.connect(self.newCTF)
self.ssamples.valueChanged.connect(self.newCTF)
self.setlist.currentRowChanged[int].connect(self.newSet)
self.setlist.keypress.connect(self.listkey)
self.splotmode.currentIndexChanged[int].connect(self.newPlotMode)
self.newbut.clicked[bool].connect(self.on_new_but)
self.resize(
720, 380
) # figured these values out by printing the width and height in resize event
E2loadappwin("e2ctfsim", "main", self)
E2loadappwin("e2ctfsim", "image", self.guiim.qt_parent)
# E2loadappwin("e2ctf","realimage",self.guirealim.qt_parent)
E2loadappwin("e2ctfsim", "plot", self.guiplot.qt_parent)
self.setWindowTitle("CTF")
def setData(self, data):
if data == None:
self.data = None
return
elif isinstance(data, str):
self.datafile = data
self.nimg = EMUtil.get_image_count(data)
self.origdata = EMData(data, 0)
if self.origdata["nz"] == 1:
if self.nimg > 20:
self.origdata = EMData.read_images(
data, list(range(0, self.nimg, old_div(self.nimg, 20)))
) # read regularly separated images from the file totalling ~20
elif self.nimg > 1:
self.origdata = EMData.read_images(data,
list(range(self.nimg)))
else:
self.origdata = [self.origdata]
else:
self.origdata = [self.origdata]
else:
self.datafile = None
if isinstance(data, EMData): self.origdata = [data]
else: self.origdata = data
self.nx = self.origdata[0]["nx"]
self.ny = self.origdata[0]["ny"]
self.nz = self.origdata[0]["nz"]
if self.apix <= 0.0: self.apix = self.origdata[0]["apix_x"]
EMProcessorWidget.parmdefault["apix"] = (0, (0.2, 10.0), self.apix,
None)
origfft = self.origdata[0].do_fft()
self.pspecorig = origfft.calc_radial_dist(old_div(self.ny, 2), 0.0,
1.0, 1)
ds = old_div(1.0, (self.apix * self.ny))
self.pspecs = [ds * i for i in range(len(self.pspecorig))]
if self.viewer != None:
for v in self.viewer:
v.close()
if self.nz == 1 or self.force2d:
if len(self.origdata) > 1:
self.viewer = [EMImageMXWidget()]
self.mfile_save_stack.setEnabled(True)
self.mfile_save_map.setEnabled(False)
else:
self.viewer = [EMImage2DWidget()]
self.mfile_save_stack.setEnabled(False)
self.mfile_save_map.setEnabled(True)
else:
self.mfile_save_stack.setEnabled(False)
self.mfile_save_map.setEnabled(True)
self.viewer = [EMScene3D()]
self.sgdata = EMDataItem3D(test_image_3d(3), transform=Transform())
self.viewer[0].insertNewNode('Data',
self.sgdata,
parentnode=self.viewer[0])
isosurface = EMIsosurface(self.sgdata, transform=Transform())
self.viewer[0].insertNewNode("Iso",
isosurface,
parentnode=self.sgdata)
volslice = EMSliceItem3D(self.sgdata, transform=Transform())
self.viewer[0].insertNewNode("Slice",
volslice,
parentnode=self.sgdata)
E2loadappwin("e2filtertool", "image", self.viewer[0].qt_parent)
self.procChange(-1)
def __init__(self,application,path=None,piter=None,threads=4):
"""application is an QApplication instance. ptclstack is the path to the file containing the particles to analyze. path is the path for ouput files"""
QtGui.QWidget.__init__(self)
self.aliimg=None # This is the unmasked alignment reference image
self.alisig=None # This is the standard deviation of the alignment reference
self.alimask=None # This is the drawn-upon version of aliimg used to generate the mask
self.alimasked=None # This is the masked alignment reference used for the actual alignments
self.roidrawmask=None # Region of interest mask drawing image
self.roimask=None # Region of interest actual mask
self.roimasked=None # Region of interest display widget
self.particles=None
self.app=weakref.ref(application)
self.path=path
self.iter=piter
self.setWindowTitle("Main Window (e2motion.py)")
# self.setWindowTitle("e2motion.py")
# Menu Bar
self.mfile=self.menuBar().addMenu("File")
self.mfileopen=self.mfile.addAction("Select Particles")
self.mfileopencls=self.mfile.addAction("Particles from Classes")
self.mfileopencls.setEnabled(False)
self.mfilequit=self.mfile.addAction("Quit")
#self.mwin=self.menuBar().addMenu("Window")
#self.mwin_boxes=self.mwin.addAction("Particles")
#self.mwin_single=self.mwin.addAction("Single Particle")
#self.mwin_average=self.mwin.addAction("Averaging")
self.setCentralWidget(QtGui.QWidget())
self.gbl = QtGui.QGridLayout(self.centralWidget())
cen=self.centralWidget()
######
# Folder parameters
self.vgb0=QtGui.QGroupBox("Particle Data")
self.gbl.addWidget(self.vgb0,0,0,1,4)
self.gbl2=QtGui.QGridLayout(self.vgb0)
self.wlpath=QtGui.QLabel("Path: {}".format(self.path))
self.gbl2.addWidget(self.wlpath,0,0)
self.gbl2.setColumnStretch(0,1)
self.wvbiter=ValBox(label="Iter:",value=self.iter)
self.wvbiter.setIntonly(True)
self.gbl2.addWidget(self.wvbiter,0,2)
self.gbl2.setColumnStretch(2,0)
self.wvsnum=ValSlider(rng=(-.2,0),label="Nptcl:",value=250)
self.wvsnum.setIntonly(True)
self.gbl2.addWidget(self.wvsnum,0,3)
self.gbl2.setColumnStretch(3,4)
self.wlnptcl=QtGui.QLabel(" ")
self.gbl2.addWidget(self.wlnptcl,0,5)
self.gbl2.setColumnStretch(5,2)
self.wbdoavg=QtGui.QPushButton("Make Avg")
self.gbl2.addWidget(self.wbdoavg,0,8)
###### Alignment Mask
# widget for editing the alignment mask
self.wlalimaskdraw=QtGui.QLabel("<big><pre>Edit</pre></big>")
self.wlalimaskdraw.setAlignment(Qt.AlignHCenter)
self.gbl.addWidget(self.wlalimaskdraw,2,1)
self.wlalimaskdraw2=QtGui.QLabel("<big><pre>A\nl\ni\ng\nn</pre></big>")
self.gbl.addWidget(self.wlalimaskdraw2,3,0)
self.w2dalimaskdraw=EMImage2DWidget()
self.gbl.addWidget(self.w2dalimaskdraw,3,1)
# Buttons for controlling mask
self.hbl1=QtGui.QHBoxLayout()
self.gbl.addLayout(self.hbl1,4,1)
self.hbl1.addStretch(5)
self.wbdrawali=QtGui.QPushButton("Draw")
self.hbl1.addWidget(self.wbdrawali)
self.wbdrawali.hide() # this functionality won't work with the current widget
self.wbautoali=QtGui.QPushButton("Auto")
self.hbl1.addWidget(self.wbautoali)
self.wbresetali=QtGui.QPushButton("Reset")
self.hbl1.addWidget(self.wbresetali)
self.hbl1.addStretch(5)
# Widget for setting alignment mask blur and base level
self.vbl1=QtGui.QVBoxLayout()
self.gbl.addLayout(self.vbl1,3,2)
self.vbl1.addStretch(5)
self.wlalimaskblur=QtGui.QLabel("Blur")
self.vbl1.addWidget(self.wlalimaskblur)
self.wsbalimaskblur=QtGui.QSpinBox()
self.wsbalimaskblur.setRange(0,25)
self.vbl1.addWidget(self.wsbalimaskblur)
self.vbl1.addSpacing(16)
self.wlalimaskbase=QtGui.QLabel("Base")
self.vbl1.addWidget(self.wlalimaskbase)
self.wsbalimaskbase=QtGui.QSpinBox()
self.wsbalimaskbase.setRange(0,100)
self.wsbalimaskbase.setValue(10)
self.vbl1.addWidget(self.wsbalimaskbase)
self.vbl1.addSpacing(16)
self.wlalimaskrot=QtGui.QLabel("Rot")
self.vbl1.addWidget(self.wlalimaskrot)
self.wsbalimaskrot=QtGui.QSpinBox()
self.wsbalimaskrot.setRange(0,360)
self.wsbalimaskrot.setValue(0)
self.vbl1.addWidget(self.wsbalimaskrot)
self.vbl1.addSpacing(16)
self.wbaligo=QtGui.QPushButton(QtCore.QChar(0x2192))
self.vbl1.addWidget(self.wbaligo)
self.vbl1.addStretch(5)
# widget for displaying the masked alignment reference
self.wlalimask=QtGui.QLabel("<big><pre>Reference</pre></big>")
self.wlalimask.setAlignment(Qt.AlignHCenter)
self.gbl.addWidget(self.wlalimask,2,3)
self.w2dalimask=EMImage2DWidget()
self.gbl.addWidget(self.w2dalimask,3,3)
self.hbl1a=QtGui.QHBoxLayout()
self.gbl.addLayout(self.hbl1a,4,3)
self.hbl1a.addStretch(5)
self.wbrecalcref=QtGui.QPushButton("Realign")
self.hbl1a.addWidget(self.wbrecalcref)
self.wbrrecalcref=QtGui.QPushButton("Rerefine")
self.hbl1a.addWidget(self.wbrrecalcref)
self.hbl1a.addStretch(5)
###### ROI Mask
# widget for editing the ROI mask
self.wlroimaskdraw=QtGui.QLabel("<big><pre>R\nO\nI</pre></big>")
self.gbl.addWidget(self.wlroimaskdraw,6,0)
self.w2droimaskdraw=EMImage2DWidget()
self.gbl.addWidget(self.w2droimaskdraw,6,1)
# Buttons for controlling mask
self.hbl2=QtGui.QHBoxLayout()
self.gbl.addLayout(self.hbl2,5,1)
self.hbl2.addStretch(5)
self.wbdrawroi=QtGui.QPushButton("Draw")
self.hbl1.addWidget(self.wbdrawroi)
self.wbdrawroi.hide() # this button won't work right for now
self.wbautoroi=QtGui.QPushButton("Auto")
self.hbl2.addWidget(self.wbautoroi)
self.wbresetroi=QtGui.QPushButton("Reset")
self.hbl2.addWidget(self.wbresetroi)
self.hbl2.addStretch(5)
# Widget for setting alignment mask blur and base level
self.vbl2=QtGui.QVBoxLayout()
self.gbl.addLayout(self.vbl2,6,2)
self.vbl2.addStretch(5)
self.wlroimaskblur=QtGui.QLabel("Blur")
self.vbl2.addWidget(self.wlroimaskblur)
self.wsbroimaskblur=QtGui.QSpinBox()
self.wsbroimaskblur.setRange(0,25)
self.vbl2.addWidget(self.wsbroimaskblur)
self.vbl2.addSpacing(16)
self.wbroigo=QtGui.QPushButton(QtCore.QChar(0x2192))
self.vbl2.addWidget(self.wbroigo)
# widget for displaying the masked ROI
self.w2droimask=EMImage2DWidget()
self.gbl.addWidget(self.w2droimask,6,3)
self.vbl2.addStretch(5)
self.wlarrow1=QtGui.QLabel(QtCore.QChar(0x2192))
self.gbl.addWidget(self.wlarrow1,4,4)
###### Results
# Widget showing lists of different result sets
self.vbl3=QtGui.QVBoxLayout()
self.gbl.addLayout(self.vbl3,3,6,5,1)
self.wllistresult=QtGui.QLabel("Results")
# self.wllistresult.setAlignment(Qt.AlignHCenter)
self.vbl3.addWidget(self.wllistresult)
self.wlistresult=QtGui.QListWidget()
self.vbl3.addWidget(self.wlistresult)
###### Parameters for processing
self.vgb1=QtGui.QGroupBox("Launch Job")
self.vbl3.addWidget(self.vgb1)
self.vbl3a=QtGui.QVBoxLayout()
self.vgb1.setLayout(self.vbl3a)
self.wvbclasses=ValBox(None,(0,256),"# Classes",32)
self.wvbclasses.setIntonly(True)
self.vbl3a.addWidget(self.wvbclasses)
self.wvbnbasis=ValBox(None,(0,64),"# PCA Vec",8)
self.wvbnbasis.setIntonly(True)
self.vbl3a.addWidget(self.wvbnbasis)
#self.wvbptclpct=ValBox(None,(0,100),"% Ptcl Incl",60)
#self.wvbptclpct.setIntonly(True)
#self.vbl3a.addWidget(self.wvbptclpct)
## fill in a default value for number of threads
#try :
#cores=num_cpus()
#except:
#cores=2
#if cores==1 : cores=2
cores=threads+1 # one thread for GUI
self.wvbcores=ValBox(None,(0,256),"# Threads",cores)
self.wvbcores.setIntonly(True)
self.vbl3a.addWidget(self.wvbcores)
self.wcbprocmode=QtGui.QComboBox()
self.wcbprocmode.addItem("PCA / k-means")
self.wcbprocmode.addItem("Average Density")
self.vbl3a.addWidget(self.wcbprocmode)
self.wpbprogress=QtGui.QProgressBar()
self.wpbprogress.setEnabled(False)
self.wpbprogress.setMinimum(0)
self.wpbprogress.setMaximum(100)
self.wpbprogress.reset()
self.vbl3a.addWidget(self.wpbprogress)
# doubles as a cancel button
self.wbcompute=QtGui.QPushButton("Compute")
self.vbl3a.addWidget(self.wbcompute)
self.wlarrow2=QtGui.QLabel(QtCore.QChar(0x2192))
self.gbl.addWidget(self.wlarrow2,4,7)
###### Output widgets
# Class-averages
self.wlclasses=QtGui.QLabel("<big><pre>Classes</pre></big>")
self.wlclasses.setAlignment(Qt.AlignHCenter)
self.gbl.addWidget(self.wlclasses,2,9)
self.w2dclasses=EMImage2DWidget()
self.gbl.addWidget(self.w2dclasses,3,9)
self.wbshowptcl=QtGui.QPushButton(QtCore.QChar(0x2193))
self.gbl.addWidget(self.wbshowptcl,4,9)
self.w2dptcl=EMImage2DWidget()
self.gbl.addWidget(self.w2dptcl,6,9)
## Buttons for controlling mask
#self.hbl1=QtGui.QHBoxLayout()
#self.gbl.addLayout(self.hbl1,2,1)
#self.hbl1.addStretch(5)
#self.wbautoali=QtGui.QPushButton("Auto")
#self.hbl1.addWidget(self.wbautoali)
#self.wbresetali=QtGui.QPushButton("Reset")
#self.hbl1.addWidget(self.wbresetali)"bdb:%s"
#self.hbl1.addStretch(5)
QtCore.QObject.connect(self.wbdrawali,QtCore.SIGNAL("clicked(bool)"),self.aliDrawMode)
QtCore.QObject.connect(self.wbautoali,QtCore.SIGNAL("clicked(bool)"),self.aliAutoPress)
QtCore.QObject.connect(self.wbresetali,QtCore.SIGNAL("clicked(bool)"),self.aliResetPress)
QtCore.QObject.connect(self.wbaligo,QtCore.SIGNAL("clicked(bool)"),self.aliGoPress)
QtCore.QObject.connect(self.wbrecalcref,QtCore.SIGNAL("clicked(bool)"),self.aliRecalcRefPress)
QtCore.QObject.connect(self.wbrrecalcref,QtCore.SIGNAL("clicked(bool)"),self.aliRRecalcRefPress)
QtCore.QObject.connect(self.wbdrawroi,QtCore.SIGNAL("clicked(bool)"),self.roiDrawMode)
QtCore.QObject.connect(self.wbautoroi,QtCore.SIGNAL("clicked(bool)"),self.roiAutoPress)
QtCore.QObject.connect(self.wbresetroi,QtCore.SIGNAL("clicked(bool)"),self.roiResetPress)
QtCore.QObject.connect(self.wbroigo,QtCore.SIGNAL("clicked(bool)"),self.roiGoPress)
QtCore.QObject.connect(self.wbcompute,QtCore.SIGNAL("clicked(bool)"),self.doCompute)
QtCore.QObject.connect(self.wbshowptcl,QtCore.SIGNAL("clicked(bool)"),self.showParticles)
QtCore.QObject.connect(self.wvbiter,QtCore.SIGNAL("valueChanged"),self.newIter)
QtCore.QObject.connect(self.wvsnum,QtCore.SIGNAL("valueChanged"),self.newThresh)
QtCore.QObject.connect(self.wbdoavg,QtCore.SIGNAL("clicked(bool)"),self.avgPress)
QtCore.QObject.connect(self.mfileopen,QtCore.SIGNAL("triggered(bool)") ,self.menuFileOpen )
# set up draw mode
insp=self.w2dalimaskdraw.get_inspector()
insp.hide()
insp.mmtab.setCurrentIndex(5)
insp.dtpenv.setText("0.0")
insp=self.w2droimaskdraw.get_inspector()
insp.hide()
insp.mmtab.setCurrentIndex(5)
insp.dtpenv.setText("0.0")
self.path=path
QtCore.QTimer.singleShot(500,self.afterStart)
def __init__(self,application,options,datafile=None):
QtWidgets.QWidget.__init__(self)
self.setMinimumSize(700,200)
#### load references first
self.reffile="info/boxrefs3d.hdf"
if os.path.isfile(self.reffile):
self.references=EMData.read_images(self.reffile)
else:
self.references=[]
self.path="tomograms/"
self.setCentralWidget(QtWidgets.QWidget())
self.gbl = QtWidgets.QGridLayout(self.centralWidget())
self.imglst=QtWidgets.QTableWidget(1, 5, self)
#self.imglst.verticalHeader().hide()
for i,w in enumerate([50,200,70,70,70]):
self.imglst.setColumnWidth(i,w)
self.imglst.setMinimumSize(450, 100)
self.gbl.addWidget(self.imglst, 0,4,10,10)
self.bt_new=QtWidgets.QPushButton("New")
self.bt_new.setToolTip("Build new neural network")
self.gbl.addWidget(self.bt_new, 0,0,1,2)
self.bt_load=QtWidgets.QPushButton("Load")
self.bt_load.setToolTip("Load neural network")
self.gbl.addWidget(self.bt_load, 1,0,1,2)
self.bt_train=QtWidgets.QPushButton("Train")
self.bt_train.setToolTip("Train neural network")
self.gbl.addWidget(self.bt_train, 2,0,1,2)
self.bt_save=QtWidgets.QPushButton("Save")
self.bt_save.setToolTip("Save neural network")
self.gbl.addWidget(self.bt_save, 3,0,1,2)
self.bt_apply=QtWidgets.QPushButton("Apply")
self.bt_apply.setToolTip("Apply neural network")
self.gbl.addWidget(self.bt_apply, 4,0,1,2)
self.bt_chgbx=QtWidgets.QPushButton("ChangeBx")
self.bt_chgbx.setToolTip("Change box size")
self.gbl.addWidget(self.bt_chgbx, 5,0,1,2)
self.bt_applyall=QtWidgets.QPushButton("ApplyAll")
self.bt_applyall.setToolTip("Apply to all tomograms")
self.gbl.addWidget(self.bt_applyall, 6,0,1,2)
self.box_display = QtWidgets.QComboBox()
self.box_display.addItem("References")
self.box_display.addItem("Particles")
self.gbl.addWidget(self.box_display, 0,2,1,1)
self.bt_new.clicked[bool].connect(self.new_nnet)
self.bt_load.clicked[bool].connect(self.load_nnet)
self.bt_train.clicked[bool].connect(self.train_nnet)
self.bt_save.clicked[bool].connect(self.save_nnet)
self.bt_apply.clicked[bool].connect(self.apply_nnet)
self.bt_chgbx.clicked[bool].connect(self.change_boxsize)
self.bt_applyall.clicked[bool].connect(self.apply_nnet_all)
self.box_display.currentIndexChanged.connect(self.do_update)
self.val_targetsize=TextBox("TargetSize", 1)
self.gbl.addWidget(self.val_targetsize, 1,2,1,1)
self.val_learnrate=TextBox("LearnRate", 1e-4)
self.gbl.addWidget(self.val_learnrate, 2,2,1,1)
self.val_ptclthr=TextBox("PtclThresh", 0.8)
self.gbl.addWidget(self.val_ptclthr, 3,2,1,1)
self.val_circlesize=TextBox("CircleSize", 24)
self.gbl.addWidget(self.val_circlesize, 4,2,1,1)
self.val_niter=TextBox("Niter", 20)
self.gbl.addWidget(self.val_niter, 5,2,1,1)
self.val_posmult=TextBox("PosMult", 1)
self.gbl.addWidget(self.val_posmult, 6,2,1,1)
self.val_lossfun = QtWidgets.QComboBox()
self.val_lossfun.addItem("Sum")
self.val_lossfun.addItem("Max")
self.gbl.addWidget(self.val_lossfun, 7,2,1,1)
self.options=options
self.app=weakref.ref(application)
self.nnet=None
global tf
tf=import_tensorflow(options.gpuid)
self.nnetsize=96
if len(self.references)==0:
self.boxsize=self.nnetsize
else:
self.boxsize=self.references[0]["boxsz"]
self.thick=9
self.datafile=""
self.data=None
if not os.path.isdir("neuralnets"):
os.mkdir("neuralnets")
self.imgview = EMImage2DWidget()
self.boxesviewer=[EMImageMXWidget(), EMImageMXWidget()]
self.boxesviewer[0].setWindowTitle("Negative")
self.boxesviewer[1].setWindowTitle("Positive")
self.ptclviewer=EMImageMXWidget()
self.ptclviewer.setWindowTitle("Particles")
for boxview in (self.boxesviewer+[self.ptclviewer]):
boxview.usetexture=False
boxview.show()
boxview.set_mouse_mode("App")
boxview.rzonce=True
self.boximages=[]
self.ptclimages=[]
for img in self.references:
self.add_boximage(img)
self.imgview.mouseup.connect(self.on_tomo_mouseup)
self.imgview.keypress.connect(self.key_press)
self.boxesviewer[0].mx_image_selected.connect(self.on_boxpos_selected)
self.boxesviewer[1].mx_image_selected.connect(self.on_boxneg_selected)
self.ptclviewer.mx_image_selected.connect(self.on_ptcl_selected)
self.imglst.cellClicked[int, int].connect(self.on_list_selected)
self.boxshapes=BoxShapes(img=self.imgview, points=[] )
self.imgview.shapes = {0:self.boxshapes}
glEnable(GL_POINT_SMOOTH)
glEnable(GL_LINE_SMOOTH );
glEnable(GL_POLYGON_SMOOTH );
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
self.trainset=[]
self.tomoinp=[]
self.segout=None
self.curinfo=None
self.update_list()
self.do_update()
def __init__(self, application, options, datafile=None):
QtWidgets.QWidget.__init__(self)
self.imgview = EMImage2DWidget()
self.setCentralWidget(QtWidgets.QWidget())
self.gbl = QtWidgets.QGridLayout(self.centralWidget())
self.lb_txt0 = QtWidgets.QLabel("ClassID")
self.gbl.addWidget(self.lb_txt0, 0, 0, 1, 1)
self.classidbox = QtWidgets.QSpinBox()
self.classidbox.setMinimum(0)
self.classidbox.setMaximum(5)
self.classidbox.setValue(0)
self.gbl.addWidget(self.classidbox, 0, 1, 1, 1)
self.lb_lines = QtWidgets.QLabel("")
self.lb_lines.setWordWrap(True)
self.gbl.addWidget(self.lb_lines, 1, 0, 1, 2)
self.bt_showimg = QtWidgets.QPushButton("Show tomogram")
self.bt_showimg.setToolTip("Show tomogram window")
self.gbl.addWidget(self.bt_showimg, 2, 0, 1, 2)
self.bt_savepdb = QtWidgets.QPushButton("Save PDB")
self.bt_savepdb.setToolTip("Save curves as PDB")
self.gbl.addWidget(self.bt_savepdb, 3, 0, 1, 2)
self.bt_clear = QtWidgets.QPushButton("Clear")
self.bt_clear.setToolTip("Clear all points")
self.gbl.addWidget(self.bt_clear, 4, 0, 1, 2)
self.bt_interp = QtWidgets.QPushButton("Interpolate")
self.bt_interp.setToolTip("Interpolate points")
self.gbl.addWidget(self.bt_interp, 5, 0, 1, 1)
self.tx_interp = QtWidgets.QLineEdit(self)
self.tx_interp.setText("20")
self.gbl.addWidget(self.tx_interp, 5, 1, 1, 1)
self.classidbox.valueChanged[int].connect(self.classid_change)
self.bt_showimg.clicked[bool].connect(self.show_tomo)
self.bt_savepdb.clicked[bool].connect(self.save_pdb)
self.bt_interp.clicked[bool].connect(self.interp_points)
self.bt_clear.clicked[bool].connect(self.clear_points)
#self.gbl.addWidget(self.imgview,0,0)
self.options = options
self.app = weakref.ref(application)
self.do_optimize = not options.nooptimize
self.datafile = datafile
self.data = EMData(datafile)
self.imgview.setWindowTitle(base_name(datafile))
self.imgview.list_idx = self.data["nz"] // 2
self.imgview.set_data(self.data)
self.imgview.show()
self.infofile = info_name(datafile)
pts = []
self.apix_scale = 1
self.tomocenter = np.zeros(3)
js = js_open_dict(self.infofile)
if "apix_unbin" in js:
apix_cur = apix = self.data["apix_x"]
apix_unbin = js["apix_unbin"]
self.apix_scale = apix_cur / apix_unbin
self.tomocenter = np.array(
[self.data["nx"], self.data["ny"], self.data["nz"]]) / 2
if js.has_key("curves") and len(js["curves"]) > 0:
pts = np.array(js["curves"]).copy()
if len(pts[0]) < 5:
pts = np.hstack([pts, np.zeros((len(pts), 1))])
pts[:, :3] = pts[:, :3] / self.apix_scale + self.tomocenter
pts = pts.tolist()
else:
pts = []
js.close()
self.contour = Contour(img=self.imgview, points=pts)
self.shape_index = 0
self.imgview.shapes = {0: self.contour}
self.imgview.mouseup.connect(self.on_mouseup)
self.imgview.keypress.connect(self.key_press)
self.update_label()
glEnable(GL_POINT_SMOOTH)
glEnable(GL_LINE_SMOOTH)
glEnable(GL_POLYGON_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def __init__(self,application,options,datafile):
QtWidgets.QWidget.__init__(self)
self.initialized=False
self.app=weakref.ref(application)
self.options=options
self.apix=options.apix
self.currentset=0
self.shrink=1#options.shrink
self.setWindowTitle("Main Window (e2spt_boxer.py)")
if options.mode=="3D":
self.boxshape="circle"
else:
self.boxshape="rect"
self.globalxf=Transform()
# Menu Bar
self.mfile=self.menuBar().addMenu("File")
#self.mfile_open=self.mfile.addAction("Open")
self.mfile_read_boxloc=self.mfile.addAction("Read Box Coord")
self.mfile_save_boxloc=self.mfile.addAction("Save Box Coord")
self.mfile_save_boxpdb=self.mfile.addAction("Save Coord as PDB")
self.mfile_save_boxes_stack=self.mfile.addAction("Save Boxes as Stack")
#self.mfile_quit=self.mfile.addAction("Quit")
self.setCentralWidget(QtWidgets.QWidget())
self.gbl = QtWidgets.QGridLayout(self.centralWidget())
# relative stretch factors
self.gbl.setColumnMinimumWidth(0,200)
self.gbl.setRowMinimumHeight(0,200)
self.gbl.setColumnStretch(0,0)
self.gbl.setColumnStretch(1,100)
self.gbl.setColumnStretch(2,0)
self.gbl.setRowStretch(1,0)
self.gbl.setRowStretch(0,100)
# 3 orthogonal restricted projection views
self.xyview = EMImage2DWidget(sizehint=(1024,1024))
self.gbl.addWidget(self.xyview,0,1)
self.xzview = EMImage2DWidget(sizehint=(1024,256))
self.gbl.addWidget(self.xzview,1,1)
self.zyview = EMImage2DWidget(sizehint=(256,1024))
self.gbl.addWidget(self.zyview,0,0)
# Select Z for xy view
self.wdepth = QtWidgets.QSlider()
self.gbl.addWidget(self.wdepth,1,2)
### Control panel area in upper left corner
self.gbl2 = QtWidgets.QGridLayout()
self.gbl.addLayout(self.gbl2,1,0)
#self.wxpos = QtWidgets.QSlider(Qt.Horizontal)
#self.gbl2.addWidget(self.wxpos,0,0)
#self.wypos = QtWidgets.QSlider(Qt.Vertical)
#self.gbl2.addWidget(self.wypos,0,3,6,1)
# box size
self.wboxsize=ValBox(label="Box Size:",value=0)
self.gbl2.addWidget(self.wboxsize,2,0)
# max or mean
#self.wmaxmean=QtWidgets.QPushButton("MaxProj")
#self.wmaxmean.setCheckable(True)
#self.gbl2.addWidget(self.wmaxmean,3,0)
# number slices
label0=QtWidgets.QLabel("Thickness")
self.gbl2.addWidget(label0,3,0)
self.wnlayers=QtWidgets.QSpinBox()
self.wnlayers.setMinimum(1)
self.wnlayers.setMaximum(256)
self.wnlayers.setValue(1)
self.gbl2.addWidget(self.wnlayers,3,1)
# Local boxes in side view
self.wlocalbox=QtWidgets.QCheckBox("Limit Side Boxes")
self.gbl2.addWidget(self.wlocalbox,4,0)
self.wlocalbox.setChecked(True)
self.button_flat = QtWidgets.QPushButton("Flatten")
self.gbl2.addWidget(self.button_flat,5,0)
self.button_reset = QtWidgets.QPushButton("Reset")
self.gbl2.addWidget(self.button_reset,5,1)
## scale factor
#self.wscale=ValSlider(rng=(.1,2),label="Sca:",value=1.0)
#self.gbl2.addWidget(self.wscale,4,0,1,2)
# 2-D filters
self.wfilt = ValSlider(rng=(0,150),label="Filt",value=0.0)
self.gbl2.addWidget(self.wfilt,6,0,1,2)
self.curbox=-1
self.boxes=[] # array of box info, each is (x,y,z,...)
self.boxesimgs=[] # z projection of each box
self.dragging=-1
##coordinate display
self.wcoords=QtWidgets.QLabel("")
self.gbl2.addWidget(self.wcoords, 1, 0, 1, 2)
self.button_flat.clicked[bool].connect(self.flatten_tomo)
self.button_reset.clicked[bool].connect(self.reset_flatten_tomo)
# file menu
#self.mfile_open.triggered[bool].connect(self.menu_file_open)
self.mfile_read_boxloc.triggered[bool].connect(self.menu_file_read_boxloc)
self.mfile_save_boxloc.triggered[bool].connect(self.menu_file_save_boxloc)
self.mfile_save_boxpdb.triggered[bool].connect(self.menu_file_save_boxpdb)
self.mfile_save_boxes_stack.triggered[bool].connect(self.save_boxes)
#self.mfile_quit.triggered[bool].connect(self.menu_file_quit)
# all other widgets
self.wdepth.valueChanged[int].connect(self.event_depth)
self.wnlayers.valueChanged[int].connect(self.event_nlayers)
self.wboxsize.valueChanged.connect(self.event_boxsize)
#self.wmaxmean.clicked[bool].connect(self.event_projmode)
#self.wscale.valueChanged.connect(self.event_scale)
self.wfilt.valueChanged.connect(self.event_filter)
self.wlocalbox.stateChanged[int].connect(self.event_localbox)
self.xyview.mousemove.connect(self.xy_move)
self.xyview.mousedown.connect(self.xy_down)
self.xyview.mousedrag.connect(self.xy_drag)
self.xyview.mouseup.connect(self.mouse_up)
self.xyview.mousewheel.connect(self.xy_wheel)
self.xyview.signal_set_scale.connect(self.event_scale)
self.xyview.origin_update.connect(self.xy_origin)
self.xzview.mousedown.connect(self.xz_down)
self.xzview.mousedrag.connect(self.xz_drag)
self.xzview.mouseup.connect(self.mouse_up)
self.xzview.mousewheel.connect(self.xz_wheel)
self.xzview.signal_set_scale.connect(self.event_scale)
self.xzview.origin_update.connect(self.xz_origin)
self.xzview.mousemove.connect(self.xz_move)
self.zyview.mousedown.connect(self.zy_down)
self.zyview.mousedrag.connect(self.zy_drag)
self.zyview.mouseup.connect(self.mouse_up)
self.zyview.mousewheel.connect(self.zy_wheel)
self.zyview.signal_set_scale.connect(self.event_scale)
self.zyview.origin_update.connect(self.zy_origin)
self.zyview.mousemove.connect(self.zy_move)
self.xyview.keypress.connect(self.key_press)
self.datafilename=datafile
self.basename=base_name(datafile)
p0=datafile.find('__')
if p0>0:
p1=datafile.rfind('.')
self.filetag=datafile[p0:p1]
if self.filetag[-1]!='_':
self.filetag+='_'
else:
self.filetag="__"
data=EMData(datafile)
self.set_data(data)
# Boxviewer subwidget (details of a single box)
#self.boxviewer=EMBoxViewer()
#self.app().attach_child(self.boxviewer)
# Boxes Viewer (z projections of all boxes)
self.boxesviewer=EMImageMXWidget()
#self.app().attach_child(self.boxesviewer)
self.boxesviewer.show()
self.boxesviewer.set_mouse_mode("App")
self.boxesviewer.setWindowTitle("Particle List")
self.boxesviewer.rzonce=True
self.setspanel=EMTomoSetsPanel(self)
self.optionviewer=EMTomoBoxerOptions(self)
self.optionviewer.add_panel(self.setspanel,"Sets")
self.optionviewer.show()
self.boxesviewer.mx_image_selected.connect(self.img_selected)
##################
#### deal with metadata in the _info.json file...
self.jsonfile=info_name(datafile)
info=js_open_dict(self.jsonfile)
#### read particle classes
self.sets={}
self.boxsize={}
if "class_list" in info:
clslst=info["class_list"]
for k in sorted(clslst.keys()):
if type(clslst[k])==dict:
self.sets[int(k)]=str(clslst[k]["name"])
self.boxsize[int(k)]=int(clslst[k]["boxsize"])
else:
self.sets[int(k)]=str(clslst[k])
self.boxsize[int(k)]=64
clr=QtGui.QColor
self.setcolors=[QtGui.QBrush(clr("blue")),QtGui.QBrush(clr("green")),QtGui.QBrush(clr("red")),QtGui.QBrush(clr("cyan")),QtGui.QBrush(clr("purple")),QtGui.QBrush(clr("orange")), QtGui.QBrush(clr("yellow")),QtGui.QBrush(clr("hotpink")),QtGui.QBrush(clr("gold"))]
self.sets_visible={}
#### read boxes
if "boxes_3d" in info:
box=info["boxes_3d"]
for i,b in enumerate(box):
#### X-center,Y-center,Z-center,method,[score,[class #]]
bdf=[0,0,0,"manual",0.0, 0]
for j,bi in enumerate(b): bdf[j]=bi
if bdf[5] not in list(self.sets.keys()):
clsi=int(bdf[5])
self.sets[clsi]="particles_{:02d}".format(clsi)
self.boxsize[clsi]=64
self.boxes.append(bdf)
###### this is the new (2018-09) metadata standard..
### now we use coordinates at full size from center of tomogram so it works for different binning and clipping
### have to make it compatible with older versions though..
if "apix_unbin" in info:
self.apix_unbin=info["apix_unbin"]
self.apix_cur=apix=data["apix_x"]
for b in self.boxes:
b[0]=b[0]/apix*self.apix_unbin+data["nx"]//2
b[1]=b[1]/apix*self.apix_unbin+data["ny"]//2
b[2]=b[2]/apix*self.apix_unbin+data["nz"]//2
for k in self.boxsize.keys():
self.boxsize[k]=int(np.round(self.boxsize[k]*self.apix_unbin/apix))
else:
self.apix_unbin=-1
info.close()
E2loadappwin("e2sptboxer","main",self)
E2loadappwin("e2sptboxer","boxes",self.boxesviewer.qt_parent)
E2loadappwin("e2sptboxer","option",self.optionviewer)
#### particle classes
if len(self.sets)==0:
self.new_set("particles_00")
self.sets_visible[list(self.sets.keys())[0]]=0
self.currentset=sorted(self.sets.keys())[0]
self.setspanel.update_sets()
self.wboxsize.setValue(self.get_boxsize())
#print(self.sets)
for i in range(len(self.boxes)):
self.update_box(i)
self.update_all()
self.initialized=True
def __init__(self, application, data):
"""Implements the CTF fitting dialog using various EMImage and EMPlot2D widgets
'data' is a list of (filename,ctf,im_1d,bg_1d,im_2d,bg_2d)
"""
try:
from eman2_gui.emimage2d import EMImage2DWidget
except:
ERROR("Cannot import EMAN image GUI objects (EMImage2DWidget)")
return
try:
from eman2_gui.emplot2d import EMPlot2DWidget
except:
ERROR(
"Cannot import EMAN plot GUI objects (is matplotlib installed?)"
)
return
self.app = weakref.ref(application)
QtGui.QWidget.__init__(self, None)
self.setWindowIcon(QtGui.QIcon(get_image_directory() + "ctf.png"))
self.data = data
self.curset = 0
self.plotmode = 0
self.guiim = EMImage2DWidget(application=self.app())
self.guiplot = EMPlot2DWidget(application=self.app())
self.guiim.mousedown.connect(self.imgmousedown)
self.guiim.mousedrag.connect(self.imgmousedrag)
self.guiim.mouseup.connect(self.imgmouseup)
self.guiplot.mousedown.connect(self.plotmousedown)
self.guiim.mmode = "app"
# This object is itself a widget we need to set up
self.hbl = QtGui.QHBoxLayout(self)
self.hbl.setMargin(0)
self.hbl.setSpacing(6)
self.hbl.setObjectName("hbl")
# plot list and plot mode combobox
self.vbl2 = QtGui.QVBoxLayout()
self.setlist = QtGui.QListWidget(self)
self.setlist.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
self.vbl2.addWidget(self.setlist)
self.splotmode = QtGui.QComboBox(self)
self.splotmode.addItem("Bgsub & fit")
self.splotmode.addItem("Ptcl & BG power")
self.splotmode.addItem("SNR")
self.splotmode.addItem("Smoothed SNR")
self.splotmode.addItem("Integrated SNR")
self.splotmode.addItem("Total CTF")
self.vbl2.addWidget(self.splotmode)
self.hbl.addLayout(self.vbl2)
# ValSliders for CTF parameters
self.vbl = QtGui.QVBoxLayout()
self.vbl.setMargin(0)
self.vbl.setSpacing(6)
self.vbl.setObjectName("vbl")
self.hbl.addLayout(self.vbl)
#self.samp = ValSlider(self,(0,5.0),"Amp:",0)
#self.vbl.addWidget(self.samp)
self.sdefocus = ValSlider(self, (0, 5), "Defocus:", 0, 90)
self.vbl.addWidget(self.sdefocus)
self.sbfactor = ValSlider(self, (0, 1600), "B factor:", 0, 90)
self.vbl.addWidget(self.sbfactor)
self.sampcont = ValSlider(self, (0, 100), "% AC", 0, 90)
self.vbl.addWidget(self.sampcont)
# self.sapix=ValSlider(self,(.2,10),"A/Pix:",2,90)
# self.vbl.addWidget(self.sapix)
self.svoltage = ValSlider(self, (0, 500), "Voltage (kV):", 0, 90)
self.vbl.addWidget(self.svoltage)
self.scs = ValSlider(self, (0, 5), "Cs (mm):", 0, 90)
self.vbl.addWidget(self.scs)
self.hbl_buttons = QtGui.QHBoxLayout()
self.saveparms = QtGui.QPushButton("Save parms")
self.recallparms = QtGui.QPushButton("Recall")
self.output = QtGui.QPushButton("Output")
self.hbl_buttons.addWidget(self.saveparms)
self.hbl_buttons.addWidget(self.recallparms)
self.hbl_buttons2 = QtGui.QHBoxLayout()
self.hbl_buttons2.addWidget(self.output)
self.vbl.addLayout(self.hbl_buttons)
self.vbl.addLayout(self.hbl_buttons2)
self.sdefocus.valueChanged.connect(self.newCTF)
self.sbfactor.valueChanged.connect(self.newCTF)
# QtCore.QObject.connect(self.sapix, QtCore.SIGNAL("valueChanged"), self.newCTF)
self.sampcont.valueChanged.connect(self.newCTF)
self.svoltage.valueChanged.connect(self.newCTF)
self.scs.valueChanged.connect(self.newCTF)
self.setlist.currentRowChanged[int].connect(self.newSet)
self.splotmode.currentIndexChanged[int].connect(self.newPlotMode)
self.saveparms.clicked[bool].connect(self.on_save_params)
self.recallparms.clicked[bool].connect(self.on_recall_params)
self.output.clicked[bool].connect(self.on_output)
self.update_data()
self.update_data()
self.resize(
460, 380
) # figured these values out by printing the width and height in resize event
self.setWindowTitle("CTF")
def __init__(self,images,voltage=None,apix=None,cs=None,ac=10.0,box=512,usefoldername=False,constbfactor=-1,fitastig=False,phaseplate=False):
"""Implements the CTF fitting dialog using various EMImage and EMPlot2D widgets
'data' is a list of (filename,ctf,im_1d,bg_1d,quality)
'parms' is [box size,ctf,box coord,set of excluded boxnums,quality,oversampling]
"""
try:
from eman2_gui.emimage2d import EMImage2DWidget
except:
print("Cannot import EMAN image GUI objects (EMImage2DWidget)")
sys.exit(1)
try:
from eman2_gui.emplot2d import EMPlot2DWidget
except:
print("Cannot import EMAN plot GUI objects (is matplotlib installed?)")
sys.exit(1)
QtWidgets.QWidget.__init__(self,None)
self.setWindowIcon(QtGui.QIcon(get_image_directory() + "ctf.png"))
self.nodir=not usefoldername
self.data=None
self.curset=0
self.calcmode=1
self.f2dmode=0
self.f2danmode=0
self.plotmode=0
self.curfilename = None
self.ringrad=1
self.xpos1=(10,0)
self.xpos2=(0,10)
# self.db = db_open_dict('bdb:mgquality')
self.defaultvoltage=voltage
self.defaultapix=apix
self.defaultcs=cs
self.defaultac=ac
self.constbfactor=constbfactor
# Per image parameters to keep track of
# for each image [box size,ctf,box coord,set of excluded boxnums,quality,oversampling]
self.parms=[]
# db_fparms=db_open_dict("bdb:e2ctf.frameparms",True)
# This little block of code deals with Z stacks of images and multiple image files,
# rewriting the name(s) with an enumeration including ;number or ,number
newimages=[]
for i in images:
n=EMUtil.get_image_count(i)
if n!=1:
for j in range(n): newimages.append(i+",%d"%j)
else:
h=EMData(i,0,True) # read header
n=h["nz"]
if n!=1:
for j in range(n): newimages.append(i+";%d"%j)
else : newimages.append(i)
images=newimages
# Now we try to restore old image information
for i in images:
try:
pd=js_open_dict(info_name(i,nodir=self.nodir))
parms=pd["ctf_frame"]
parms[4]=pd["quality"]
if box>=64 and parms[0]!=box:
parms[0]=box
parms[3]=set()
# if parms==None : raise Exception
except:
ctf = EMAN2Ctf()
ctf.from_dict({'defocus':0.0,'dfdiff':0.0,'dfang':0.0,'bfactor':200.0,'ampcont':self.defaultac,'voltage':200.0,'cs':4.1,'apix':1.0,'dsbg':-1})
if self.defaultvoltage!=None : ctf.voltage=self.defaultvoltage
if self.defaultcs!=None : ctf.cs=self.defaultcs
if self.defaultapix!=None : ctf.apix=self.defaultapix
parms=[int(box),ctf,(256,256),set(),5,1]
print("Initialize new parms for: ",base_name(i))
if self.constbfactor>0 : parms[1].bfactor=self.constbfactor
if parms[0]<64 :
parms[0]=512
parms[3]=set()
self.parms.append(parms)
self.wimage=EMImage2DWidget()
self.wimage.setWindowTitle("e2evalimage - Micrograph")
self.wfft=EMImage2DWidget()
self.wfft.setWindowTitle("e2evalimage - 2D FFT")
self.wplot=EMPlot2DWidget()
self.wplot.setWindowTitle("e2evalimage - Plot")
self.wimage.mousedown.connect(self.imgmousedown)
self.wimage.mousedrag.connect(self.imgmousedrag)
self.wimage.mouseup.connect(self.imgmouseup)
self.wfft.mousedown.connect(self.fftmousedown)
self.wfft.mousedrag.connect(self.fftmousedrag)
self.wfft.mouseup.connect(self.fftmouseup)
self.wimage.mmode="app"
self.wfft.mmode="app"
# This object is itself a widget we need to set up
self.gbl = QtWidgets.QGridLayout(self)
self.gbl.setContentsMargins(8, 8, 8, 8)
self.gbl.setSpacing(6)
# plot list and plot mode combobox
self.setlist=e2ctf.MyListWidget(self)
self.setlist.setSizePolicy(QtWidgets.QSizePolicy.Preferred,QtWidgets.QSizePolicy.Expanding)
for i in images:
self.setlist.addItem(i)
self.gbl.addWidget(self.setlist,0,0,8,2)
self.lcalcmode=QtWidgets.QLabel("Region:",self)
self.gbl.addWidget(self.lcalcmode,10,0)
self.scalcmode=QtWidgets.QComboBox(self)
self.scalcmode.addItem("Single Region")
self.scalcmode.addItem("Tiled Boxes")
self.scalcmode.setCurrentIndex(1)
self.gbl.addWidget(self.scalcmode,10,1)
self.lcalcmode=QtWidgets.QLabel("2D FFT:",self)
self.gbl.addWidget(self.lcalcmode,11,0)
self.s2dmode=QtWidgets.QComboBox(self)
self.s2dmode.addItem("Power Spectrum")
self.s2dmode.addItem("Bg Subtracted")
self.s2dmode.addItem("Background")
self.gbl.addWidget(self.s2dmode,11,1)
self.lcalcmode=QtWidgets.QLabel("Annotate:",self)
self.gbl.addWidget(self.lcalcmode,12,0)
self.s2danmode=QtWidgets.QComboBox(self)
self.s2danmode.addItem("Ctf Zeroes")
self.s2danmode.addItem("Resolution Ring")
self.s2danmode.addItem("2-D Xtal")
self.s2danmode.addItem("None")
self.gbl.addWidget(self.s2danmode,12,1)
self.lcalcmode=QtWidgets.QLabel("Plot:",self)
self.gbl.addWidget(self.lcalcmode,13,0)
self.splotmode=QtWidgets.QComboBox(self)
self.splotmode.addItem("Bgsub and Fit")
self.splotmode.addItem("Fg and Bg")
self.splotmode.addItem("Bgsub, 45 deg slices")
self.splotmode.addItem("Fg, 45 deg slices")
self.splotmode.addItem("SSNR (NOT BY PTCL !)")
self.gbl.addWidget(self.splotmode,13,1)
# ValSliders for CTF parameters
#self.samp = ValSlider(self,(0,5.0),"Amp:",0)
#self.vbl.addWidget(self.samp)
self.sdefocus=ValSlider(self,(0,5),"Defocus:",0.0,90)
self.gbl.addWidget(self.sdefocus,0,2,1,3)
self.sbfactor=ValSlider(self,(0,1600),"B factor:",200.0,90)
self.gbl.addWidget(self.sbfactor,1,2,1,3)
self.sdfdiff=ValSlider(self,(0,1),"DF Diff:",0,90)
self.gbl.addWidget(self.sdfdiff,2,2,1,3)
self.sdfang=ValSlider(self,(0,180),"Df Angle:",0,90)
self.gbl.addWidget(self.sdfang,3,2,1,3)
self.sampcont=ValSlider(self,(0,100),"% AC",10.0,90)
if self.defaultac!=None : self.sampcont.setValue(self.defaultac)
self.gbl.addWidget(self.sampcont,4,2,1,3)
self.sang45=ValSlider(self,(-22.5,22.5),"45 mode ang",0.0,90)
self.gbl.addWidget(self.sang45,5,2,1,3)
self.squality=ValSlider(self,(0,9),"Quality (0-9):",0,90)
self.squality.setIntonly(True)
self.gbl.addWidget(self.squality,6,2,1,3)
self.brefit=QtWidgets.QPushButton("Refit")
self.gbl.addWidget(self.brefit,7,2)
self.cbgadj=CheckBox(None,"CTF BG Adj",1)
self.gbl.addWidget(self.cbgadj,10,3)
self.castig=CheckBox(None,"Astig:",fitastig)
self.gbl.addWidget(self.castig,11,3)
self.cphasep=CheckBox(None,"Phaseplate:",phaseplate)
self.gbl.addWidget(self.cphasep,12,3)
# self.sapix=ValSlider(self,(.2,10),"A/Pix:",2,90)
# self.vbl.addWidget(self.sapix)
self.sapix=ValBox(self,(0,500),"A/pix:",1.0,90)
if self.defaultapix!=None : self.sapix.setValue(self.defaultapix)
self.gbl.addWidget(self.sapix,10,2)
self.svoltage=ValBox(self,(0,500),"Voltage (kV):",200,90)
if self.defaultvoltage!=None : self.svoltage.setValue(self.defaultvoltage)
self.gbl.addWidget(self.svoltage,11,2)
self.scs=ValBox(self,(0,5),"Cs (mm):",4.1,90)
if self.defaultcs!=None : self.scs.setValue(self.defaultcs)
self.gbl.addWidget(self.scs,12,2)
self.sboxsize=ValBox(self,(128,1024),"Box Size:",512,90)
self.sboxsize.intonly=True
self.gbl.addWidget(self.sboxsize,13,2)
# self.soversamp=ValBox(self,(0,500),"Oversample:",1,90)
# self.soversamp.intonly=True
# self.gbl.addWidget(self.soversamp,14,2) # disable oversampling for now, not properly integrated with save/recall mechanism, and not clear if it's really useful
# this is just a spacer
self.gbl.setColumnStretch(3,2)
self.bbox=QtWidgets.QGroupBox("Project")
self.gbl.addWidget(self.bbox,10,4,4,1)
self.bvbl=QtWidgets.QVBoxLayout()
self.bbox.setLayout(self.bvbl)
self.bimport=QtWidgets.QPushButton("Import")
self.bvbl.addWidget(self.bimport)
self.cinvert=CheckBox(None,"Invert")
self.bvbl.addWidget(self.cinvert)
self.cxray=CheckBox(None,"X-ray Pixels")
self.bvbl.addWidget(self.cxray)
self.bimport.clicked[bool].connect(self.doImport)
self.brefit.clicked[bool].connect(self.doRefit)
self.cbgadj.valueChanged.connect(self.bgAdj)
self.sdefocus.valueChanged.connect(self.newCTF)
self.sbfactor.valueChanged.connect(self.newCTF)
self.sdfdiff.valueChanged.connect(self.newCTF)
self.sdfang.valueChanged.connect(self.newCTF)
self.sapix.valueChanged.connect(self.newCTF)
self.sampcont.valueChanged.connect(self.newCTF)
self.svoltage.valueChanged.connect(self.newCTF)
self.scs.valueChanged.connect(self.newCTF)
self.sboxsize.valueChanged.connect(self.newBox)
# QtCore.QObject.connect(self.soversamp, QtCore.SIGNAL("valueChanged"), self.newBox)
self.sang45.valueChanged.connect(self.recalc_real)
self.squality.valueChanged.connect(self.newQualityFactor)
self.setlist.currentRowChanged[int].connect(self.newSet)
self.setlist.keypress.connect(self.listkey)
self.scalcmode.currentIndexChanged[int].connect(self.newCalcMode)
self.s2dmode.currentIndexChanged[int].connect(self.new2DMode)
self.s2danmode.currentIndexChanged[int].connect(self.new2DAnMode)
self.splotmode.currentIndexChanged[int].connect(self.newPlotMode)
#QtCore.QObject.connect(self.saveparms,QtCore.SIGNAL("clicked(bool)"),self.on_save_params)
#QtCore.QObject.connect(self.recallparms,QtCore.SIGNAL("clicked(bool)"),self.on_recall_params)
#QtCore.QObject.connect(self.refit,QtCore.SIGNAL("clicked(bool)"),self.on_refit)
#QtCore.QObject.connect(self.output,QtCore.SIGNAL("clicked(bool)"),self.on_output)
self.resize(720,380) # figured these values out by printing the width and height in resize event
### This section is responsible for background updates
self.busy=False
self.needupdate=True
self.needredisp=False
self.procthread=None
self.errors=None # used to communicate errors back from the reprocessing thread
self.timer=QTimer()
self.timer.timeout.connect(self.timeOut)
self.timer.start(100)
self.setWindowTitle("e2evalimage - Control Panel")
self.wimage.show()
self.wfft.show()
self.wplot.show()
E2loadappwin("e2evalimage","main",self)
E2loadappwin("e2evalimage","image",self.wimage.qt_parent)
E2loadappwin("e2evalimage","fft",self.wfft.qt_parent)
E2loadappwin("e2evalimage","plot",self.wplot.qt_parent)
def au_point_selected(self, i, event=None):
if self.readfrom:
return
if i == None:
if event != None and event.modifiers() & Qt.ShiftModifier:
if self.special_euler != None:
self.special_euler = None
if not self.init_lock: self.regen_dl()
return
# self.arc_anim_points = None
self.projection = None
if self.euler_data:
# db = db_open_dict(self.average_file)
# a = db.get(i)
# print a["nx"]
# print self.average_file,i
# self.average = EMData(self.average_file,i)
# self.average["nx"]
self.average = self.euler_data[i] #
self.projection = EMData(
self.projection_file,
self.average.get_attr("projection_image_idx"))
self.average.process_inplace("normalize.toimage",
{"to": self.projection})
try:
self.class_idx = self.average.get_attr("projection_image_idx")
print("%d (%d)" % (self.class_idx, self.average["ptcl_repr"]))
except:
self.class_idx = -1
else:
return
#if self.projection == None and self.average == None: return
first = False
if self.proj_class_viewer == None:
first = True
self.proj_class_viewer = EMImageMXWidget(
data=None, application=get_application())
# self.proj_class_viewer = EMImage2DWidget(image=None,application=get_application())
self.proj_class_viewer.module_closed.connect(
self.on_mx_view_closed)
# self.proj_class_viewer.set_mouse_mode("App" )
self.proj_class_viewer.mx_image_selected.connect(
self.on_mx_image_selected)
get_application().show_specific(self.proj_class_viewer)
self.proj_class_single = EMImage2DWidget(
image=None, application=get_application())
self.proj_class_single.module_closed.connect(
self.on_mx_view_closed)
# QtCore.QObject.connect(self.proj_class_single,QtCore.SIGNAL("mx_image_selected"), self.mx_image_selected)
get_application().show_specific(self.proj_class_single)
disp = []
if self.projection != None: disp.append(self.projection)
if self.average != None and self.projection != None:
# ok, this really should be put into its own processor
#dataf = self.projection.do_fft()
#apix=self.projection["apix_x"]
#curve = dataf.calc_radial_dist(dataf["ny"], 0, 0.5,True)
#curve=[i/(dataf["nx"]*dataf["ny"])**2 for i in curve]
#xcurve=[i/(apix*2.0*dataf["ny"]) for i in range(len(curve))]
#xyd=XYData()
#xyd.set_xy_list(xcurve,curve)
#filt=self.average.process("filter.setstrucfac",{"apix":apix,"strucfac":xyd})
#filt.process_inplace("normalize.toimage",{"to":self.average})
self.projection["apix_x"] = self.average["apix_x"]
self.projection["apix_y"] = self.average["apix_y"]
self.projection["apix_z"] = self.average["apix_z"]
filt = self.projection.process("threshold.notzero")
filt.mult(self.average)
filt.process_inplace("filter.matchto", {"to": self.projection})
disp.append(filt)
if self.average != None:
disp.append(self.average)
self.proj_class_viewer.set_data(disp)
self.proj_class_single.set_data(disp)
self.proj_class_viewer.updateGL()
self.proj_class_single.updateGL()
if self.particle_viewer != None:
self.on_mx_image_selected(None, None)
if first: self.proj_class_viewer.optimally_resize()
if i != self.special_euler:
self.special_euler = i
self.force_update = True
if not self.init_lock: self.updateGL()
def menu_add_2dwin(self):
if self.viewer == None: return
self.viewer.append(EMImage2DWidget())
self.viewer[-1].show()
self.needupdate = 1
def __init__(self,
app,
maxshift,
invert=False,
seqali=False,
tiltstep=2.0):
self.app = app
self.maxshift = maxshift
self.seqali = seqali
self.invert = invert
self.tiltstep = tiltstep
# the control panel
QtWidgets.QWidget.__init__(self, None)
self.gbl = QtWidgets.QGridLayout(self)
self.gbl.setContentsMargins(0, 0, 0, 0)
self.gbl.setSpacing(6)
self.gbl.setObjectName("hbl")
# action buttons
self.bcenalign = QtWidgets.QPushButton("Center Align")
self.bprojalign = QtWidgets.QPushButton("Proj. Realign")
self.btiltaxis = QtWidgets.QPushButton("Tilt Axis")
self.btiltaxisval = QtWidgets.QLineEdit("90.0")
self.bsavedata = QtWidgets.QPushButton("Save Data")
self.breconst = QtWidgets.QPushButton("3D Normal")
self.sbmode = QtWidgets.QSpinBox(self)
self.sbmode.setRange(0, 2)
self.sbmode.setValue(0)
self.bmagict = QtWidgets.QPushButton("3D Tomofill")
self.bmagics = QtWidgets.QPushButton("3D Sph")
self.bmagicc = QtWidgets.QPushButton("3D Cyl")
self.vslpfilt = ValSlider(self, (0, .5), "Filter", 0.5, 50)
self.gbl.addWidget(self.bcenalign, 0, 0)
self.gbl.addWidget(self.bprojalign, 0, 1)
self.gbl.addWidget(self.btiltaxis, 0, 2)
self.gbl.addWidget(self.btiltaxisval, 0, 3)
# self.gbl.addWidget(self.bsavedata,0,3)
self.gbl.addWidget(self.breconst, 1, 0)
self.gbl.addWidget(self.sbmode, 2, 0, 1, 1)
self.gbl.addWidget(self.vslpfilt, 3, 0, 1, 4)
self.gbl.addWidget(self.bmagict, 1, 1)
self.gbl.addWidget(self.bmagics, 1, 2)
self.gbl.addWidget(self.bmagicc, 1, 3)
self.bcenalign.clicked[bool].connect(self.do_cenalign)
self.bprojalign.clicked[bool].connect(self.do_projalign)
self.btiltaxis.clicked[bool].connect(self.do_tiltaxis)
self.bsavedata.clicked[bool].connect(self.do_savedata)
self.breconst.clicked[bool].connect(self.do_reconst)
self.bmagict.clicked[bool].connect(self.do_magict)
self.bmagics.clicked[bool].connect(self.do_magics)
self.bmagicc.clicked[bool].connect(self.do_magicc)
self.vslpfilt.valueChanged.connect(self.do_filter)
# the single image display widget
self.im2d = EMImage2DWidget(application=app, winid="tomotrackbox.big")
self.imboxed = EMImage2DWidget(application=app,
winid="tomotrackbox.small")
self.improj = EMImage2DWidget(application=app,
winid="tomotrackbox.proj")
self.imslice = EMImage2DWidget(application=app,
winid="tomotrackbox.3dslice")
self.imvol = EMImage3DWidget(application=app, winid="tomotrackbox.3d")
# get some signals from the window.
self.im2d.mousedown.connect(self.down)
self.im2d.mousedrag.connect(self.drag)
self.im2d.mouseup.connect(self.up)
self.im2d.signal_increment_list_data.connect(self.change_tilt)
self.imagefile = None
self.imageparm = None
self.tiltshapes = None
self.curtilt = 0
self.oldtilt = self.curtilt
self.map3d = None
self.downloc = None
self.downadjloc = None
self.show()
self.im2d.show()
def __init__(self, options):
self.path = "tomograms/"
QtWidgets.QWidget.__init__(self, None)
self.win_size = [1000, 680]
self.setMinimumSize(self.win_size[0], self.win_size[1])
# This object is itself a widget we need to set up
self.gbl = QtWidgets.QGridLayout(self)
self.gbl.setContentsMargins(8, 8, 8, 8)
self.gbl.setSpacing(6)
self.gbl.setColumnStretch(0, 4)
self.gbl.setColumnStretch(1, 1)
self.gbl.setColumnStretch(2, 1)
self.gbl.setRowStretch(0, 1)
# Micrograph list
self.imglst = QtWidgets.QTableWidget(1, 3, self)
self.imglst.verticalHeader().hide()
self.gbl.addWidget(self.imglst, 0, 0, 11, 1)
self.imglst.setColumnWidth(0, 50)
self.imglst.setColumnWidth(1, 200)
self.imglst_srtby = 0
hdr = self.imglst.horizontalHeader()
self.imglst.cellClicked[int, int].connect(self.selimg)
hdr.sectionPressed[int].connect(self.sortlst)
self.wg_thumbnail = EMImage2DWidget(parent=self)
self.wg_thumbnail.set_scale(1)
self.wg_thumbnail_width = old_div(self.size().width(), 3) * .9
self.wg_thumbnail.resize(self.wg_thumbnail_width,
self.wg_thumbnail_width)
#print self.wg_thumbnail_width
self.wg_thumbnail.setMinimumHeight(330)
self.gbl.addWidget(self.wg_thumbnail, 0, 1, 3, 2)
self.bt_show2d = QtWidgets.QPushButton("Show2D")
self.bt_show2d.setToolTip("Show 2D images")
self.gbl.addWidget(self.bt_show2d, 4, 1, 1, 2)
self.bt_runboxer = QtWidgets.QPushButton("Boxer")
self.bt_runboxer.setToolTip("Run spt_boxer")
self.gbl.addWidget(self.bt_runboxer, 5, 1)
self.bt_refresh = QtWidgets.QPushButton("Refresh")
self.bt_refresh.setToolTip("Refresh")
self.gbl.addWidget(self.bt_refresh, 5, 2)
self.bt_showtlts = QtWidgets.QPushButton("ShowTilts")
self.bt_showtlts.setToolTip("Show raw tilt series")
self.gbl.addWidget(self.bt_showtlts, 6, 1)
self.bt_plottpm = QtWidgets.QPushButton("TiltParams")
self.bt_plottpm.setToolTip("Plot tilt parameters")
self.gbl.addWidget(self.bt_plottpm, 6, 2)
self.bt_plotloss = QtWidgets.QPushButton("PlotLoss")
self.bt_plotloss.setToolTip("Plot alignment loss")
self.gbl.addWidget(self.bt_plotloss, 7, 1)
self.bt_plotctf = QtWidgets.QPushButton("PlotCtf")
self.bt_plotctf.setToolTip("Plot CTF estimation")
self.gbl.addWidget(self.bt_plotctf, 7, 2)
self.bt_show2d.clicked[bool].connect(self.show2d)
self.bt_runboxer.clicked[bool].connect(self.runboxer)
self.bt_plotloss.clicked[bool].connect(self.plot_loss)
self.bt_plottpm.clicked[bool].connect(self.plot_tltparams)
self.bt_showtlts.clicked[bool].connect(self.show_tlts)
self.bt_refresh.clicked[bool].connect(self.update_files)
self.bt_plotctf.clicked[bool].connect(self.plot_ctf)
self.wg_2dimage = EMImage2DWidget()
self.wg_2dimage.setWindowTitle("Tomo2D")
self.cur_data = None
self.wg_tltimage = EMImage2DWidget()
self.wg_tltimage.setWindowTitle("Tiltseries")
self.wg_tltimage.set_scale(.2)
self.cur_tlt = None
self.setspanel = TomoListWidget(self)
self.gbl.addWidget(self.setspanel, 8, 1, 2, 2)
self.wg_notes = QtWidgets.QLineEdit(self)
self.wg_notes.setText("Comments:")
#self.wg_notes.setStyleSheet("color: rgb(150, 150, 150);")
self.gbl.addWidget(self.wg_notes, 10, 1, 1, 2)
#self.setspanel.itemClicked[QtWidgets.QListWidgetItem].connect(self.clickset)
self.wg_notes.textChanged.connect(self.noteupdate)
self.wg_plot2d = EMPlot2DWidget()
self.update_files()
def display_validation_plots(path,
radcut,
planethres,
plotdatalabels=False,
color='#00ff00',
plotzaxiscolor=False):
# In some cases it is impossible to import PyQT4, particularly on clusters
try:
from PyQt5 import QtCore, QtGui, QtWidgets, QtOpenGL
# from eman2_gui.emshape import *
from eman2_gui.valslider import ValSlider
from eman2_gui.emplot2d import EMPolarPlot2DWidget
except:
class dummy(object):
pass
class QWidget(object):
"A dummy class for use when Qt not installed"
def __init__(self, parent):
print("Qt4 has not been loaded")
QtGui = dummy()
QtWidgets.QWidget = QWidget
from eman2_gui.emimage2d import EMImage2DWidget
from eman2_gui.emapplication import EMApp
r = []
theta = []
datap = []
zaxis = []
try:
tpdb = js_open_dict("%s/perparticletilts.json" % path)
tplist = tpdb["particletilt_list"]
maxcolorval = max(tplist, key=lambda x: x[3])[3]
for tp in tplist:
if tp[3] > planethres: # if the out of plane threshold is too much
continue
if plotdatalabels: datap.append(tp[0])
r.append(tp[1])
theta.append(math.radians(tp[2]))
# Color the Z axis out of planeness
zaxis.append(computeRGBcolor(tp[3], 0, maxcolorval))
tpdb.close()
except:
print("Couldn't load tp from DB, not showing polar plot")
data = None
try:
data = EMData("%s/contour.hdf" % path)
except:
print("Couldn't open contour plot")
if not data and not (theta and r): return
app = EMApp()
if theta and r:
plot = EMValidationPlot()
plot.set_data((theta, r), 50, radcut, datap)
# Color by Z axis if desired
if plotzaxiscolor: plot.set_scattercolor([zaxis])
plot.set_datalabelscolor(color)
plot.show()
if data:
image = EMImage2DWidget(data)
image.show()
app.exec_()
# Compute a RGB value to represent a data range. Basically convert Hue to GSB with I=0.33 and S=1.0
def computeRGBcolor(value, minval, maxval):
# Normalize from 0 to 1
normval = old_div((value - minval), (maxval - minval))
radval = normval * 2 * math.pi
if radval < 2 * math.pi / 3:
B = 0.0
R = 0.33 * (1 + old_div(math.cos(radval),
math.cos(old_div(math.pi, 3) - radval)))
G = 1.0 - R
return "#%02x%02x%02x" % (255 * R, 255 * G, 255 * B)
if radval > 2 * math.pi / 3 and radval < 4 * math.pi / 3:
hue = radval - 2 * math.pi / 3
R = 0.0
G = 0.33 * (1 + old_div(math.cos(hue),
math.cos(old_div(math.pi, 3) - hue)))
B = 1.0 - G
return "#%02x%02x%02x" % (255 * R, 255 * G, 255 * B)
if radval > 4 * math.pi / 3:
hue = radval - 4 * math.pi / 3
G = 0
B = 0.33 * (1 + old_div(math.cos(hue),
math.cos(old_div(math.pi, 3) - hue)))
R = 1.0 - B
return "#%02x%02x%02x" % (255 * R, 255 * G, 255 * B)
class EMValidationPlot(QtWidgets.QWidget):
"""Make a plot to display validation info"""
def __init__(self):
QtWidgets.QWidget.__init__(self)
box = QtWidgets.QVBoxLayout()
self.polarplot = EMPolarPlot2DWidget()
self.polarplot.setMinimumHeight(50)
self.polarplot.setMinimumWidth(50)
self.resize(480, 580)
meanAngLabel = QtWidgets.QLabel("Mean Tilt Angle")
self.meanAngle = QtWidgets.QLineEdit("")
meanAxisLabel = QtWidgets.QLabel("Mean Tilt Axis")
self.meanAxis = QtWidgets.QLineEdit("")
rmsdAngLabel = QtWidgets.QLabel("RMSD Tilt Angle")
self.rmsdAngle = QtWidgets.QLineEdit("")
rmsdAxisLabel = QtWidgets.QLabel("RMSD Tilt Axis")
self.rmsdAxis = QtWidgets.QLineEdit("")
pointsLabel = QtWidgets.QLabel("Num points")
self.points = QtWidgets.QLineEdit("")
self.pointlabel = QtWidgets.QLabel(
"Right click to pick the nearest point")
frame = QtWidgets.QFrame()
frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
frame.setMaximumHeight(100)
grid = QtWidgets.QGridLayout()
grid.addWidget(meanAngLabel, 0, 0)
grid.addWidget(self.meanAngle, 0, 1)
grid.addWidget(meanAxisLabel, 0, 2)
grid.addWidget(self.meanAxis, 0, 3)
grid.addWidget(rmsdAngLabel, 1, 0)
grid.addWidget(self.rmsdAngle, 1, 1)
grid.addWidget(rmsdAxisLabel, 1, 2)
grid.addWidget(self.rmsdAxis, 1, 3)
grid.addWidget(self.pointlabel, 2, 0, 1, 2)
grid.addWidget(pointsLabel, 2, 2)
grid.addWidget(self.points, 2, 3)
frame.setLayout(grid)
box.addWidget(self.polarplot)
box.addWidget(frame)
self.setLayout(box)
self.polarplot.clusterStats.connect(self._on_stats)
def _on_stats(self, stats):
""" Set the selected stats """
self.meanAngle.setText(str(round(stats[1], 2)))
self.meanAxis.setText(str(round(stats[0], 2)))
self.rmsdAngle.setText(str(round(stats[3], 2)))
self.rmsdAxis.setText(str(round(stats[2], 2)))
self.points.setText(str(stats[4]))
def _on_point(self, point):
""" Set the selected point"""
self.pointlabel.setText("You selected the point: %s" % str(point))
def set_data(self, data, linewidth, radcut, datapoints):
self.polarplot.set_data(data,
linewidth=linewidth,
radcut=radcut,
datapoints=datapoints)
def set_datalabelscolor(self, color):
self.polarplot.setDataLabelsColor(color)
def set_scattercolor(self, color):
self.polarplot.setScatterColor(color)
def setData(self, data):
if data == None:
self.data = None
return
elif isinstance(data, str):
self.datafile = data
self.nimg = EMUtil.get_image_count(data)
if self.dataidx >= 0 and self.dataidx < self.nimg:
ii = self.dataidx
self.nimg = 1
else:
ii = 0
hdr = EMData(data, 0, 1)
self.origdata = EMData(data, ii)
if self.origdata["nz"] == 1:
if self.nimg > 20 and hdr["ny"] > 512:
self.origdata = EMData.read_images(
data, list(range(0, self.nimg, self.nimg // 20))
) # read regularly separated images from the file totalling ~20
elif self.nimg > 100:
self.origdata = EMData.read_images(
data,
list(range(0, 72)) +
list(range(72, self.nimg, self.nimg // 100))
) # read the first 36 then regularly separated images from the file
elif self.nimg > 1:
self.origdata = EMData.read_images(data,
list(range(self.nimg)))
else:
self.origdata = [self.origdata]
else:
self.origdata = [self.origdata]
else:
self.datafile = None
if isinstance(data, EMData): self.origdata = [data]
else: self.origdata = data
self.nx = self.origdata[0]["nx"]
self.ny = self.origdata[0]["ny"]
self.nz = self.origdata[0]["nz"]
if self.apix <= 0.0: self.apix = self.origdata[0]["apix_x"]
EMProcessorWidget.parmdefault["apix"] = (0, (0.2, 10.0), self.apix,
None)
origfft = self.origdata[0].do_fft()
self.pspecorig = origfft.calc_radial_dist(old_div(self.ny, 2), 0.0,
1.0, 1)
ds = old_div(1.0, (self.apix * self.ny))
self.pspecs = [ds * i for i in range(len(self.pspecorig))]
if self.viewer != None:
for v in self.viewer:
v.close()
if self.nz == 1 or self.force2d or (self.nx > 320
and self.safemode == False):
if len(self.origdata) > 1:
self.viewer = [EMImageMXWidget()]
self.mfile_save_stack.setEnabled(True)
else:
self.viewer = [EMImage2DWidget()]
self.mfile_save_stack.setEnabled(False)
else:
self.mfile_save_stack.setEnabled(False)
self.viewer = [EMScene3D()]
self.sgdata = EMDataItem3D(test_image_3d(3), transform=Transform())
self.viewer[0].insertNewNode('Data',
self.sgdata,
parentnode=self.viewer[0])
isosurface = EMIsosurface(self.sgdata, transform=Transform())
self.viewer[0].insertNewNode("Iso",
isosurface,
parentnode=self.sgdata)
volslice = EMSliceItem3D(self.sgdata, transform=Transform())
self.viewer[0].insertNewNode("Slice",
volslice,
parentnode=self.sgdata)
if self.nz > 1: self.mfile_save_map.setEnabled(True)
else: self.mfile_save_map.setEnabled(False)
E2loadappwin("e2filtertool", "image", self.viewer[0].qt_parent)
if self.origdata[0].has_attr("source_path"):
winname = str(self.origdata[0]["source_path"])
else:
winname = "FilterTool"
self.viewer[0].setWindowTitle(winname)
self.procChange(-1)
def __init__(self, options):
self.path = "tomograms/"
QtGui.QWidget.__init__(self, None)
self.win_size = [1000, 680]
self.setMinimumSize(self.win_size[0], self.win_size[1])
# This object is itself a widget we need to set up
self.gbl = QtGui.QGridLayout(self)
self.gbl.setMargin(8)
self.gbl.setSpacing(6)
self.gbl.setColumnStretch(0, 4)
self.gbl.setColumnStretch(1, 1)
self.gbl.setColumnStretch(2, 1)
self.gbl.setRowStretch(0, 1)
# Micrograph list
self.imglst = QtGui.QTableWidget(1, 3, self)
self.imglst.verticalHeader().hide()
self.gbl.addWidget(self.imglst, 0, 0, 11, 1)
self.imglst.setColumnWidth(0, 50)
self.imglst.setColumnWidth(1, 200)
self.imglst_srtby = 0
hdr = self.imglst.horizontalHeader()
QtCore.QObject.connect(self.imglst,
QtCore.SIGNAL("cellClicked(int,int)"),
self.selimg)
QtCore.QObject.connect(hdr, QtCore.SIGNAL("sectionPressed(int)"),
self.sortlst)
self.wg_thumbnail = EMImage2DWidget(parent=self)
self.wg_thumbnail.set_scale(1)
self.wg_thumbnail_width = self.size().width() / 3 * .9
self.wg_thumbnail.resize(self.wg_thumbnail_width,
self.wg_thumbnail_width)
#print self.wg_thumbnail_width
self.wg_thumbnail.setMinimumHeight(330)
self.gbl.addWidget(self.wg_thumbnail, 0, 1, 3, 2)
self.bt_show2d = QtGui.QPushButton("Show2D")
self.bt_show2d.setToolTip("Show 2D images")
self.gbl.addWidget(self.bt_show2d, 4, 1, 1, 2)
self.bt_runboxer = QtGui.QPushButton("Boxer")
self.bt_runboxer.setToolTip("Run spt_boxer")
self.gbl.addWidget(self.bt_runboxer, 5, 1)
self.bt_refresh = QtGui.QPushButton("Refresh")
self.bt_refresh.setToolTip("Refresh")
self.gbl.addWidget(self.bt_refresh, 5, 2)
self.bt_showtlts = QtGui.QPushButton("ShowTilts")
self.bt_showtlts.setToolTip("Show raw tilt series")
self.gbl.addWidget(self.bt_showtlts, 6, 1)
self.bt_plottpm = QtGui.QPushButton("TiltParams")
self.bt_plottpm.setToolTip("Plot tilt parameters")
self.gbl.addWidget(self.bt_plottpm, 6, 2)
self.bt_plotloss = QtGui.QPushButton("PlotLoss")
self.bt_plotloss.setToolTip("Plot alignment loss")
self.gbl.addWidget(self.bt_plotloss, 7, 1)
self.bt_plotctf = QtGui.QPushButton("PlotCtf")
self.bt_plotctf.setToolTip("Plot CTF estimation")
self.gbl.addWidget(self.bt_plotctf, 7, 2)
QtCore.QObject.connect(self.bt_show2d, QtCore.SIGNAL("clicked(bool)"),
self.show2d)
QtCore.QObject.connect(self.bt_runboxer,
QtCore.SIGNAL("clicked(bool)"), self.runboxer)
QtCore.QObject.connect(self.bt_plotloss,
QtCore.SIGNAL("clicked(bool)"), self.plot_loss)
QtCore.QObject.connect(self.bt_plottpm, QtCore.SIGNAL("clicked(bool)"),
self.plot_tltparams)
QtCore.QObject.connect(self.bt_showtlts,
QtCore.SIGNAL("clicked(bool)"), self.show_tlts)
QtCore.QObject.connect(self.bt_refresh, QtCore.SIGNAL("clicked(bool)"),
self.update_files)
QtCore.QObject.connect(self.bt_plotctf, QtCore.SIGNAL("clicked(bool)"),
self.plot_ctf)
self.wg_2dimage = EMImage2DWidget()
self.wg_2dimage.setWindowTitle("Tomo2D")
self.cur_data = None
self.wg_tltimage = EMImage2DWidget()
self.wg_tltimage.setWindowTitle("Tiltseries")
self.wg_tltimage.set_scale(.2)
self.cur_tlt = None
self.setspanel = QtGui.QListWidget(self)
self.gbl.addWidget(self.setspanel, 8, 1, 2, 2)
self.itemflags = Qt.ItemFlags(Qt.ItemIsEditable) | Qt.ItemFlags(
Qt.ItemIsSelectable) | Qt.ItemFlags(
Qt.ItemIsEnabled) | Qt.ItemFlags(Qt.ItemIsUserCheckable)
self.wg_notes = QtGui.QTextEdit(self)
self.gbl.addWidget(self.wg_notes, 10, 1, 1, 2)
QtCore.QObject.connect(self.setspanel,
QtCore.SIGNAL("itemChanged(QListWidgetItem*)"),
self.clickset)
QtCore.QObject.connect(self.wg_notes, QtCore.SIGNAL("textChanged()"),
self.noteupdate)
self.wg_plot2d = EMPlot2DWidget()
self.update_files()
