def generateReport(self):
currentTab = self.tabwidget.currentWidget()
pdf = FPDF()
pdf.add_page()
pdf.set_font('Arial', 'B', 15)
pdf.set_xy(0, 0)
pdf.cell(0, 10, 'Graph Before', ln=1, align='C')
exporter = exporters.ImageExporter(
currentTab.OriginalSignalViewer.scene())
exporter.parameters()['width'] = 500
exporter.parameters()['height'] = 250
exporter.export('GraphBefore.png')
pdf.image('GraphBefore.png', x=None, y=None, w=180, h=50)
pdf.cell(0, 10, 'Graph After', ln=1, align='C')
exporter = exporters.ImageExporter(
currentTab.EditedSignalViewer.scene())
exporter.parameters()['width'] = 500
exporter.parameters()['height'] = 250
exporter.export('GraphAfter.png')
pdf.image('GraphAfter.png', x=None, y=None, w=180, h=50)
pdf.cell(0, 10, 'spectrogram After', ln=1, align='C')
exporter = exporters.ImageExporter(
currentTab.SpectrogramViewer.scene())
exporter.parameters()['width'] = 500
exporter.parameters()['height'] = 250
exporter.export('SpectroAfter.png')
pdf.image('SpectroAfter.png', x=None, y=None, w=180, h=100)
#open dialog to save pdf file
dialog = QtWidgets.QFileDialog()
pdfFileName = dialog.getSaveFileName(None, 'select file', 'c:\\',
'pdf file (*.pdf)')
pdf.output(pdfFileName[0])
def perform_export(self, file):
"""Performs export in new layout with axes labels set
Overrides the basic functionality of SimplePlotItem.
See https://github.com/ZELLMECHANIK-DRESDEN/ShapeOut2/issues/7
"""
# Create a plot window
win = pg.GraphicsLayoutWidget(
size=(self.width() + 100, self.height() + 100),
show=True)
# fill layout
labelx, labely = get_axes_labels(self.plot_state, self.slot_states)
win.addLabel(labely, angle=-90)
explot = PipelinePlotItem()
explot.redraw(self.dslist, self.slot_states, self.plot_state)
win.addItem(explot)
win.addLabel("") # spacer to avoid cut tick labels on the right(#7)
win.nextRow()
win.addLabel(labelx, col=1)
# Update the UI (do it twice, otherwise the tick labels overlap)
QtWidgets.QApplication.processEvents(QtCore.QEventLoop.AllEvents, 300)
win.hide()
# perform actual export
suffix = file[-3:]
if suffix == "png":
exp = exporters.ImageExporter(win.scene())
# translate from screen resolution (80dpi) to 300dpi
exp.params["width"] = int(exp.params["width"] / 72 * 300)
elif suffix == "svg":
exp = exporters.SVGExporter(win.scene())
exp.export(file)
def exp_graph(self):
"""
Essa função exporta o gráfico como está na tela em forma de imagem
Returns
-------
None.
"""
global time, delta_comm, delta_meas, simulado
if simulado:
ask_dir = "Escolha o diretório onde o deseja salvar o gráfico" #string que pergunta o diretório
save = str(QFileDialog.getExistingDirectory(None,ask_dir)) #Pede ao usuário o diretório onde ele quer salvar
self.grafico.plot(time,delta_comm, symbolSize=5,symbolBrush=("#15bf48"),
pen=mkPen(color="#15bf48", width=2))
self.grafico.plot(time,delta_meas, symbolSize=5,symbolBrush=("#56fceb"),
pen=mkPen(color="#56fceb", width=2))
self.grafico.plot(time_fail,ofc_falhas, symbolSize=15,symbol='x',symbolBrush=("#fc031c"),
pen=mkPen(color="#323232", width=0.001))
exporter = exporters.ImageExporter(self.grafico.plotItem) #Exporta o objeto do gráfico
exporter.export(save+f'/graph_{int(datetime.timestamp(datetime.now()))}.png') #Salva como png o gráfico
QMessageBox.information(self,"Concluído!",f"Gráfico salvo com sucesso em: {save}")
else:
QMessageBox.warning(self,"Atenção!","O sistema ainda não foi emulado!")
def MCCLog(tmpPNG, tmpPS, plotItem):
exporter = exporters.ImageExporter(plotItem)
exporter.export(tmpPNG)
Popen("convert " + tmpPNG + " " + tmpPS, shell=True)
sleep(0.1)
printFile = "lpr -P" + 'elog_mcc' + " " + tmpPS
os.system(printFile)
def save(self, fname):
"""
"""
if fname.endswith('.svg'):
exporter = pgexporters.SVGExporter(self.pw.plotItem)
elif fname.endswith('.png'):
exporter = pgexporters.ImageExporter(self.pw.plotItem)
elif fname.endswith('.jpg'):
exporter = pgexporters.ImageExporter(self.pw.plotItem)
elif fname.endswith('.tif'):
exporter = pgexporters.ImageExporter(self.pw.plotItem)
else:
self.status.setText('Wrong filename extension')
return False
exporter.export(fname)
self.status.setText('View saved at {}'.format(fname))
def perform_export(self, file):
suffix = file[-3:]
if suffix == "png":
exp = exporters.ImageExporter(self)
# translate from screen resolution (80dpi) to 300dpi
exp.params["width"] = int(exp.params["width"] / 72 * 300)
elif suffix == "svg":
exp = exporters.SVGExporter(self)
exp.export(file)
def savefig(plot, filename, width=None):
"""Export plot to file"""
exporter = pgexp.ImageExporter(plot.img)
if width is not None:
exporter.parameters(
)['width'] = width # (note this also affects height parameter)
# save to file
exporter.export(filename)
def save_pic(self, e0, e1):
try:
exporter = ep.ImageExporter(e0.plotItem)
if exporter.parameters()['height'] < 800:
exporter.parameters()['height'] = 800
exporter.export(os.path.join(e1, 'temp%d.png'% self.graph_no))
self.graph_no += 1
self.signal_state_save.emit('Picture Saved Successfully')
except:
self.signal_state_save.emit('Picture Saved Failed')
def save_graph(self):
""" Save the image of the graph in the current folder
in .png format """
title = f"{self.currs_graph[0]}_{self.currs_graph[1]}"
export = exporters.ImageExporter(self.graph.plotItem)
export.export(f'{title}.png')
self.main_status.setText("Graph saved successfully")
def getImage(self):
"""get image of graph, used for export"""
try:
exporter = exporters.ImageExporter(self.graphWidget.plotItem)
exporter.parameters()['width'] = 600
img = exporter.export(None, True, False)
return img
except:
img = None
return img
def export_image(self):
exporter = exporters.ImageExporter(self.graph.plot_item)
file_name, _ = QtWidgets.QFileDialog.getSaveFileName(self,
"Exporter un tracer", "",
"Jpeg Files (*.jpg);; PNG Files (*.png)")
if file_name:
if QtCore.QFileInfo(file_name).suffix() == "":
file_name += ".jpg"
exporter.parameters()[
'width'] = 1600
exporter.parameters()['antialias'] = True
exporter.export(file_name)
def saveFig(self):
exp = exporters.ImageExporter(self.graphWidget.plotItem)
exp.parameters()['width'] = 1000
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName,_ = QFileDialog.getSaveFileName(self,
"QFileDialog.getSaveFileName()","Plot.png","All Files (*);;Text Files (*.png)", options=options)
if fileName !="":
exp.export(fileName)
imagen = Image.open(fileName)
imagen.show()
def SaveData(self):
"""
Save Data:
- make screenshots of plots
- save all data
- save averaged data
"""
self.statusReport("Saving....")
Wavelengths = self.currentSpectra[:, 0]
np.savetxt('FROG_AllData.txt',
self.allSpectra,
header='0Delay\t 1Loop\t Wavelength\n' +
'\t'.join(map(str, Wavelengths)),
delimiter='\t')
np.savetxt('FROG_AveragedData.txt',
self.averagedSpectra,
header='0Delay\t 1Loop\t Wavelength\n' +
'\t'.join(map(str, Wavelengths)),
delimiter='\t')
self.SaveParameters()
self.plt.enableAutoRange()
exporter4 = exporters.ImageExporter(self.plt)
exporter4.parameters()['width'] = 2000
exporter4.export('Spectra2D.png')
self.liveSpectraPlot.getPlotItem().enableAutoRange()
exporter5 = exporters.ImageExporter(self.liveSpectraPlot.plotItem)
exporter5.parameters()['width'] = 2000
exporter5.export('LastSingleSpectrum.png')
self.statusReport("Saved.")
def action_pushbutton_graph_save(self, e):
if not os.path.exists(self.dir_save):
os.mkdir(self.dir_save)
dict_list_channel = {
'001 - 032': 0,
'033 - 064': 1,
'065 - 096': 2,
'097 - 128': 3,
'129 - 160': 4,
'161 - 192': 5,
'Custom': 6
}
exporter = ep.ImageExporter(self.list_graph_show[dict_list_channel[
self.list_channel.currentItem().text()]].plotItem)
if exporter.parameters()['height'] < 800:
exporter.parameters()['height'] = 800
exporter.export(
os.path.join(self.dir_save,
'temp%d.png' % self.data_global.draw_save_global))
self.data_global.draw_save_global += 1
def print_pdf(self):
exporter = exporters.ImageExporter(self.graph.plot_item)
file_image, _ = QtWidgets.QFileDialog.getSaveFileName(self,
"Exporter un tracer", "",
"Jpeg Files (*.jpg);; PNG Files (*.png)")
exporter.parameters()[
'width'] = 1600
exporter.parameters()['antialias'] = True
exporter.export(file_image)
file_name, _ = QtWidgets.QFileDialog.getSaveFileName(
self, "Export PDF", None, "PDF files (.pdf);;All Files()"
)
if file_name:
if QtCore.QFileInfo(file_name).suffix() == "":
file_name += ".pdf"
text, _ = QtWidgets.QInputDialog.getText(self, "Titre du PDF", "Titre", QtWidgets.QLineEdit.Normal, "")
pdf = PDF(plot=file_image, data=self.mouse_tracking.dictValues, title=text, file_name=file_name)
pdf.generate_document()
def snap(self):
# Get size of plotItem and create ImageExporter
width = self.plot_widget.plotItem.size().width()
height = self.plot_widget.plotItem.size().height()
exporter = exporters.ImageExporter(self.plot_widget.plotItem)
# Set resolution, force int type, new value may not be == to old value
exporter.params.param('width'). \
setValue(int(width * 4), blockSignal=exporter.widthChanged)
exporter.params.param('height'). \
setValue(int(height * 4), blockSignal=exporter.heightChanged)
# Set filepath and export
location_suggestion = os.path.join(os.getcwd(), "plot.png")
location, _ = qtw.QFileDialog. \
getSaveFileName(self.widget(),
"Save snap",
location_suggestion,
options=qtw.QFileDialog.Options())
if location == '':
# If export is cancelled, exit gracefully
logger.debug(__name__ + ": Saving Snapshot aborted.")
return
exporter.export(location)
def copy_to_clipboard(o, exporters=[]):
"""Copy figure/item to clipboard.
Clipboard data will become invalid (and might cause a crash) when Python
kernel quits. More detail below.
Args:
o: the widget/item to be copied
On Feb 2 2017 spent a while investigating clipboard copying (PyQt4, Windows 10).
General problem of crashing on pasting, or getting black or garbage. Traced to
garbage collection of the exporter object. Seems that the QApplication.clipboard().setImage
inside ImageExporter doesn't actually make a copy - just keeps a reference. So
this function keeps a list of exporters to prevent them being collected.
"""
if isinstance(o, pg.GraphicsLayoutWidget) or isinstance(
o, GraphicsLayoutWidget):
item = o.scene()
else:
raise ValueError('Don' 't know how to deal with %s' % type(o))
exporter = pgex.ImageExporter(item)
exporter.export(copy=True)
exporters.append(exporter)
def fig_save(self):
ex = pe.ImageExporter(self.plt.scene())
filename = '第' + str(self.filename) + '张图片.png'
self.filename += 1
ex.export(fileName=filename)
self.pic_messagebox()
def export_movie(self):
""" creates a movie file based on the current selected datasets.
EXPERIMENTAL - needs avconv installed ... (first pngs are dumped, then
avconv is called to make a avi file) """
from pyqtgraph import exporters
### FIXME
# care for correct path
# care for already existing files, remove first
# care for a proper avconv command! this one is pulled form the net
# http://stackoverflow.com/questions/16315192/avconv-make-a-video-from-a-subset-on-images
# care for compatibility of the avconv produced file with ppt
# ask for path, framerate
print("exporting movie ... ")
# from http://www.pyqtgraph.org/documentation/exporting.html
# create an exporter instance, as an argument give it
# the item you wish to export
outpath = self.SaveFileDialog(
title='save movie',
default_dir=self.Main.Options.general['cwd'],
extension='*.avi')
tmpdir = os.path.join(os.path.dirname(outpath), 'movie_export')
try:
os.mkdir(tmpdir)
except OSError:
pass
print("movie will be saved to: ", outpath)
print("tmp directory folder is: ", tmpdir)
# adding a cue for the odor stimulus
frac = 0.05
rect = QtWidgets.QGraphicsRectItem(0, 0,
self.Main.Data.raw.shape[0] * frac,
self.Main.Data.raw.shape[0] * frac)
rect.setPen(pg.mkPen((0, 0, 0, 100)))
rect.setBrush(pg.mkBrush((250, 250, 250)))
self.Main.Data_Display.Frame_Visualizer.ViewBox.addItem(rect)
rect.hide()
for t in range(self.Main.Data.raw.shape[2]):
self.Main.Data_Display.Frame_Visualizer.frame = t
self.Main.Data_Display.Frame_Visualizer.update_frame()
print(t)
stimuli_frames = self.Main.Options.preprocessing['stimuli']
for stim_frames in stimuli_frames:
onset, offset = stim_frames
if (t >= onset) and (t <= offset):
rect.show()
else:
rect.hide()
exporter = exporters.ImageExporter(
self.Main.Data_Display.Frame_Visualizer.ViewBox)
exporter.export(os.path.join(tmpdir, 'frame_' + str(t) + '.png'))
# make system call
if os.name == 'posix': # make it only run on linux systems ...
import subprocess
# command = 'avconv -i '+outpath + os.path.sep + 'frame_%d.png -b:v 6400k -r 24 '+outpath + os.path.sep+'exported_movie.avi'
# command = 'avconv -r 8 -i '+outpath + os.path.sep + 'frame_%d.png -b:v 6400k -r 8 '+outpath + os.path.sep+'exported_movie.avi'
command = 'avconv -r 8 -i ' + tmpdir + os.path.sep + 'frame_%d.png -b:v 6400k ' + outpath
print(command)
# command = 'avconv -r 10 -i ./movie_export/frame_%d.png ./movie_export/output.avi'
subprocess.call(command, shell=True)
print("done")
pass
featuresc.append([chroma, record[1][2], record[1][3], record[-1]])
# Sgram images
sp.data = audiodata
sp.sampleRate = fs
sgRaw = sp.spectrogram(256, 128)
featuress.append(
[sgRaw.tolist(), record[1][2], record[1][3], record[-1]])
maxsg = np.min(sgRaw)
sg = np.abs(np.where(sgRaw == 0, 0.0, 10.0 * np.log10(sgRaw / maxsg)))
img = pg.ImageItem(sg)
imagewindow.clear()
imagewindow.setImage(np.flip(sg, 1))
exporter = pge.ImageExporter(imagewindow.view)
exporter.export(
os.path.join(dir, 'img',
str(record[-1]) + '_' + "%04d" % count + '.png'))
count += 1
with open(os.path.join(dir, 'waveletdata.json'), 'w') as outfile:
json.dump(featuresw, outfile)
with open(os.path.join(dir, 'mfccdata.json'), 'w') as outfile:
json.dump(featuresm, outfile)
with open(os.path.join(dir, 'chromadata.json'), 'w') as outfile:
json.dump(featuresc, outfile)
with open(os.path.join(dir, 'sgramdata.json'), 'w') as outfile:
json.dump(featuress, outfile)
with open(os.path.join(dir, 'audiodata.json'), 'w') as outfile:
json.dump(featuresa, outfile)
def get_Ic_Iret_and_save(folder, folder_link, chip, devices,Jc, optionalic=0):
'''
Inputs is in format: [[cards], [channel1,channel2], [Imin,Imax], [steps],
[num_sweeps]]
Chip must be the name of the chip. Devices should be in an array
Folder_link is the web link to the folder
:param Folder: Target folder for data to be saved
:param Chip: Target Chip
:param Devices: Devices on Target Chip
:return: array of Ic(pos/neg) and Iret(pos/neg)
:return: array of measurement ids (to pass to measure_Rn)
:Graph: Overlays critical points in cyan on top of raw IV curve
Called By:
-Measurement Functions
-Measure_PCM_Chip_Cold
-Measure_JJs_Ic
Calls On:
-automate_channel_IV_live
-find_max_y_change_half_sweep
-find_max_y_change
-save_data_live
-save_ic_data
-save_JJ_Measurements_Ic
'''
global app
global windows, plots, curves
global my_exporters, current_point
# get variables
print("*******************")
print(devices)
inputs = inpfunc.format_input_Ic_Ir_devices(devices, Jc)
cards = inputs[0]
channels = inputs[1]
currents = inputs[2]
steps = inputs[3]
sweeps = inputs[4]
app = QtGui.QApplication.instance()
if app is None:
app = QtGui.QApplication(sys.argv)
else:
pass
num_plots = len(devices)
print("num plots: %d" %num_plots)
# create windows, plots, and curves
curves = initialization(num_plots)
# we need two indexes, one for pairs, one for normal
index_pairs = 0
index = 0
return_measurements = [] # the array that we will return
meas_ids = [] # the array of measurment ids we will return
my_exporters = [] # array to hold exporters (hopefully solves problem of C object being deleted)
# create exporters
for i in range(0, num_plots):
exporter = exporters.ImageExporter(plots[i].scene())
my_exporters.append(exporter)
# take all the sweeps
for i in range(0,num_plots):
print("Begin Device %s sweep" %(i))
# get two channels and two current limits that are needed
my_channels = []
my_currents = []
my_channels.append(channels[index_pairs])
my_channels.append(channels[index_pairs+1])
# edit 7/19/18
my_cards = []
my_cards.append(cards[index_pairs])
my_cards.append(cards[index_pairs+1])
my_currents.append(currents[index_pairs])
my_currents.append(currents[index_pairs+1])
name = create_name(chip, devices[i]) # create the name
plots[i].setTitle(name) # set title to name
# show the grid
# bring current window to focus
windows[i].move(-900, 0) # move to other desktop, spyder had been blocking before
windows[i].setWindowState(QtCore.Qt.WindowActive)
windows[i].raise_()
# this will activate the window (yellow flashing on icon)
windows[i].activateWindow()
extra_res=0
if "S1_1.5" in devices[i].name and devices[i].design_id[0].name =="PCM3A":
extra_res=138.19 #originally 137.35
if "A3_3.9" in devices[i].name and devices[i].design_id[0].name == "PCM3A":
extra_res=138.37 #originally 138.33
if optionalic !=0: # or design ==4: # higher precision around Ic, design is SingleJJ
I,V,R = iv.automate_channel_IV_live(app, curves[index], current_point[index], my_cards, my_channels, my_currents, steps[index], sweeps[index], optionalic=optionalic,extra_res=extra_res)
#
# sweep the current device
else: # optional value was not passed in
I,V,R = iv.automate_channel_IV_live(app, curves[index], current_point[index], my_cards, my_channels, my_currents, steps[index], sweeps[index],extra_res=extra_res)
if I==0 and V==0 and R==0:
return 0,0
num_JJ = devices[i].num_JJs # get the number of JJs for this dev
print("num JJ: %s" %num_JJ)
if optionalic != 0: # or design==4:
critical_currents = iv.find_max_y_change_half_sweep(I,V, num_JJ)
elif devices[i].name == 'S1_1.5' or devices[i].name == 'A3_3.9':
critical_currents = iv.find_max_y_change(I,V, num_JJ,envelope = 50e-06)
else:
critical_currents = iv.find_max_y_change(I,V, num_JJ)
# Plotting Critical Currents
# arrays that will be saved
critical_currents_save_I = []
critical_currents_save_V = []
# setting labels
for n1 in range(0,len(critical_currents)):
if n1 < 2:
type_of_current = "I"+str(n1)
label = pg.TextItem(text="", color=(0, 0, 0), fill=(0, 255, 255), anchor=(0, -1))
else:
type_of_current = "I"+str(n1)
label = pg.TextItem(text="", color=(0, 0, 0), fill=(0, 255, 255), anchor=(0, 2))
I_c = type_of_current+':(' + '{:.2E}'.format(I[critical_currents[n1]]) + ','+ '{:.2E}'.format(V[critical_currents[n1]]) + ')'
label.setText(I_c)
label.setPos(I[critical_currents[n1]], V[critical_currents[n1]])
graph = plots[i]
graph.addItem(label)
current_toplot = critical_currents[n1]
new_curve = plots[i].plot()
new_curve.setData(I[current_toplot:current_toplot+1], V[current_toplot:current_toplot+1], symbol='o', symbolBrush='c', symbolSize=10)
critical_currents_save_I.append(I[current_toplot])
critical_currents_save_V.append(V[current_toplot])
# Saving locally
filename = (folder + name)
print(filename)
create_dir(filename)
sub_folder = "/RawData"
filename = (folder+sub_folder+name+"_Ic_raw.dat")
create_dir(filename) # function to create dir if doesn't exist
print(filename)
iv.save_data_live(I,V,R,(folder+sub_folder+name+"_Ic_raw.dat")) # save the raw data
sub_folder = "/Ic_values"
filename = (folder+sub_folder+name)
print(filename)
create_dir(filename) # function to create dir if doesn't exist
save_ic_data(critical_currents_save_I, critical_currents_save_V,(folder+sub_folder+name)) # save the important data
sub_folder = "/Graphs"
filename = (folder + sub_folder + name + "_Ic.png")
print(filename)
create_dir(filename) # function to create dir if doesn't exist
return_measurements.append(critical_currents_save_I) # append to the final return array
# Save to database
meas_id = d.save_JJ_Measurements_Ic(chip, critical_currents_save_I, folder_link, devices[i])
meas_ids.append(meas_id)
try:
my_exporters[i].export(filename) # export the graph
except:
sys.stdout = sys.__stdout__
print("Oh noooooo wrapped object was deleted\n")
# repeat
index = index + 1
index_pairs = index_pairs + 2
app.processEvents()
print("End Device %s sweep\n" %(i))
return return_measurements, meas_ids
def onClick(event):
'''
Response to a mouse click.
Draws red point on first and second click and slope between them for RN
Third click is a green point for the Imax
After the third click, the new data is written into the database if the measurement is unique.
Otherwise, a function to manually select the measurement is printed
Fourth Click clears and resets
'''
global count, slope_x, slope_y, steps, slope_labels
global curves, vbs, x, y, slope_plots, plots
global I_max_plots, I_max_x, I_max_y, label, label1, label2
global num_JJ, chip_info, chip_name, dev_name, dev_size, Rn
global filename_to_save, web_info, web_link
# finds which window is active
active_window = 0
for i in range(0, len(curves)):
if (curves[i].isActive()):
active_window = i
break
# get position and convert to scene in widget
pos = event.pos()
mousePoint = vbs[active_window].mapSceneToView(pos)
index = mousePoint.x()
# index in the data correspoding to x of click
index = math.ceil(index / steps) - 1
index = index + 10
# Now, do stuff with the clicks
if index > 0 and index < len(
y[active_window]): # make sure it's in the range
count += 1
if count == 4: # fourth click, clear all and reset
count = 0
slope_x = []
slope_y = []
I_max_x = []
I_max_y = []
slope_plots[active_window].clear()
I_max_plots[active_window].clear()
plots[active_window].removeItem(label)
plots[active_window].removeItem(label1)
plots[active_window].removeItem(label2)
elif count == 1: # first click, append to slope calc
slope_x.append(x[active_window][index])
slope_y.append(y[active_window][index])
slope_plots[active_window].setData(slope_x,
slope_y,
symbol='o',
symbolBrush='r',
pen='r')
elif count == 2: # second click, append and then calc slope
slope_x.append(x[active_window][index])
slope_y.append(y[active_window][index])
slope = (slope_y[1] - slope_y[0]) / (slope_x[1] - slope_x[0])
Rn = slope / num_JJ
# add red line top visualize
slope_plots[active_window].setData(slope_x,
slope_y,
symbol='o',
symbolBrush='r',
pen='r')
# add labels
label = pg.TextItem(text=("Slope: " + str(slope)),
color=(0, 0, 0),
fill=(255, 0, 0),
anchor=(-.5, -.5))
label1 = pg.TextItem(text=("Rn: " + str(Rn)),
color=(0, 0, 0),
fill=(255, 0, 0),
anchor=(-.5, -2))
label.setPos(x[active_window][index], y[active_window][index])
label1.setPos(x[active_window][index], y[active_window][index])
plots[active_window].addItem(label)
plots[active_window].addItem(label1)
# set instructions
plots[active_window].setTitle("Select a point for I_max")
elif count == 3: # third click, append to I_max, and save all to database
I_max_x.append(x[active_window][index])
I_max_y.append(y[active_window][index])
Imax = I_max_x[0]
# add green point to visualize
I_max_plots[active_window].setData(I_max_x,
I_max_y,
symbol='o',
symbolBrush='g')
# add label
label2 = pg.TextItem(text=("I max: " + str(Imax)),
color=(0, 0, 0),
fill=(0, 255, 0),
anchor=(-.5, -.5))
label2.setPos(x[active_window][index], y[active_window][index])
plots[active_window].addItem(label2)
plots[active_window].setTitle(chip_info)
# Save Data Here
# Overwrite the data
overwrite_Rn_Imax(chip_name, dev_name, Rn, Imax)
# save image
# if name has already been taken, i.e after first save
if re.search('.png', filename_to_save) is None:
filename_to_save = filename_to_save + "_Revised.png"
print(filename_to_save)
web_link = web_link + web_info
print("\n")
print(web_link)
exporter = exporters.ImageExporter(plots[active_window].scene())
exporter.export(filename_to_save)
print("\nImage Saved")
def save(self, path):
pg.QtGui.QApplication.processEvents()
exporter = pgex.ImageExporter(self.win.scene())
exporter.export(path) # save fig
def set_exporter(self):
self.exporter = ex.ImageExporter(self.plot.get_plot_item())
def plot_entropy(self, fname):
try:
import numpy as np
import pyqtgraph as pg
import pyqtgraph.exporters as exporters
except ImportError as e:
return
i = 0
x = []
y = []
plotted_colors = {}
for r in self.results:
x.append(r.offset)
y.append(r.entropy)
plt = pg.plot(title=fname, clear=True)
# Disable auto-ranging of the Y (entropy) axis, as it
# can cause some very un-intuitive graphs, particularly
# for files with only high-entropy data.
plt.setYRange(0, 1)
if self.show_legend and has_key(self.file_markers, fname):
plt.addLegend(size=(self.max_description_length * 10, 0))
for (offset, description) in self.file_markers[fname]:
# If this description has already been plotted at a different offset, we need to
# use the same color for the marker, but set the description to None to prevent
# duplicate entries in the graph legend.
#
# Else, get the next color and use it to mark descriptions of
# this type.
if has_key(plotted_colors, description):
color = plotted_colors[description]
description = None
else:
color = self.COLORS[i]
plotted_colors[description] = color
i += 1
if i >= len(self.COLORS):
i = 0
plt.plot(x=[offset, offset],
y=[0, 1.1],
name=description,
pen=pg.mkPen(color, width=2.5))
# Plot data points
plt.plot(x, y, pen='y')
# TODO: legend is not displayed properly when saving plots to disk
if self.save_plot:
# Save graph to CWD
out_file = os.path.join(os.getcwd(), os.path.basename(fname))
# exporters.ImageExporter is different in different versions of
# pyqtgraph
try:
exporter = exporters.ImageExporter(plt.plotItem)
except TypeError:
exporter = exporters.ImageExporter.ImageExporter(plt.plotItem)
exporter.parameters()['width'] = self.FILE_WIDTH
exporter.export(
binwalk.core.common.unique_file_name(out_file,
self.FILE_FORMAT))
else:
plt.setLabel('left', self.YLABEL, units=self.YUNITS)
plt.setLabel('bottom', self.XLABEL, units=self.XUNITS)
def logbook(userText, titleText, textText, plotItem):
curr_time = datetime.now()
timeString = curr_time.strftime("%Y-%m-%dT%H:%M:%S")
log_entry = ElementTree.Element(None)
severity = ElementTree.SubElement(log_entry, 'severity')
location = ElementTree.SubElement(log_entry, 'location')
keywords = ElementTree.SubElement(log_entry, 'keywords')
time = ElementTree.SubElement(log_entry, 'time')
isodate = ElementTree.SubElement(log_entry, 'isodate')
log_user = ElementTree.SubElement(log_entry, 'author')
category = ElementTree.SubElement(log_entry, 'category')
title = ElementTree.SubElement(log_entry, 'title')
metainfo = ElementTree.SubElement(log_entry, 'metainfo')
imageFile = ElementTree.SubElement(log_entry, 'link')
imageFile.text = timeString + '-00.ps'
thumbnail = ElementTree.SubElement(log_entry, 'file')
thumbnail.text = timeString + "-00.png"
text = ElementTree.SubElement(log_entry, 'text')
log_entry.attrib['type'] = "LOGENTRY"
category.text = "USERLOG"
location.text = "not set"
severity.text = "NONE"
keywords.text = "none"
time.text = curr_time.strftime("%H:%M:%S")
isodate.text = curr_time.strftime("%Y-%m-%d")
metainfo.text = timeString + "-00.xml"
fileName = "/tmp/" + metainfo.text
fileName = fileName.rstrip(".xml")
log_user.text = userText
title.text = titleText
text.text = textText
# If field is truly empty, ElementTree leaves off tag entirely which
# causes logbook parser to fail
if text.text == "":
text.text = " "
xmlFile = open(fileName + '.xml', "w")
rawString = ElementTree.tostring(log_entry, 'utf-8')
# Adds newline after each closing tag
parsedString = sub(r'(?=<[^/].*>)', '\n', rawString)
xmlString = parsedString[1:]
xmlFile.write(xmlString)
# Close with newline so cron job parses correctly
xmlFile.write("\n")
xmlFile.close()
exporter = exporters.ImageExporter(plotItem)
# exporter.parameters()['width'] = 550
exporter.export(fileName + '.png')
# PyQtGraph doesn't export PS files, so convert with linux
Popen('convert ' + fileName + '.png ' + fileName + '.ps', shell=True)
sleep(0.3)
Popen('convert ' + fileName + '.png -resize 500x500 ' + fileName + '.png',
shell=True)
sleep(0.35)
path = "/u1/lcls/physics/logbook/data/"
copy(fileName + '.ps', path)
copy(fileName + '.png', path)
copy(fileName + '.xml', path)
def export(self):
print('exporting')
exporter = exp.ImageExporter(self.scene())
exporter.parameters()['width'] = 420
exporter.export('example_false_color_image.png')
def get_Rn_Imax_and_save(folder, folder_link, chip, devices, meas_ids):
global slope_plots, app
global windows, plots, curves
global my_exporters
'''
:param folder: Target folder for data to be saved
:param folder_link: Web Link to Folder
:param chip: Target Chip
:param devices: Array of Target devices
:param Meas_IDs: Array of Measurement Ids
:return: return_measurements_Rn- Array of rn measurements
:return: return_measurements_Imax-array of Imax measurements
:Graphs: 1 Rn, 1 Imax for each device
Saves in database after every run
Called By:
-Measurement Functions- Measure_PCM_chip_cold
Calls On:
-sweep_current_live_Rn
-save_Rn_data
'''
# get variables
inputs = inpfunc.format_input_Rn_Imax_devices(devices)
channels = inputs[0]
num_JJ = inputs[1]
cards = inputs[2]
# arrays that will be returned
return_measurements_Rn = []
return_measurements_Imax = []
# check instance, so that it doesn't crash on exit
app = QtGui.QApplication.instance()
if app is None:
app = QtGui.QApplication(sys.argv)
else:
pass
num_plots = len(num_JJ)
# create windows, plots, curves
curves = initialization(num_plots)
x, y = lpf.create_data(curves)
slope_plots = lpf.create_slope_plots(plots)
# data collection
counter = 0
# create exporters (trying to fix problem of C object being deleted
my_exporters = []
for i in range(0, num_plots):
scene = plots[i].scene()
exporter = exporters.ImageExporter(scene)
my_exporters.append(exporter)
# loop through and plot slope
# i incremets by 2, counter by 1
for i in range(0, len(channels), 2):
# get current number of JJ and channels
num_j = num_JJ[counter]
chan1 = channels[i]
chan2 = channels[i + 1]
card1 = cards[i]
card2 = cards[i + 1]
# create steps based on device, method: Ic*16/100
dev = devices[counter]
ic_pred = d.predict_Ic(d.chip_Jc(chip), dev.JJ_radius_nom * 1e-06)
steps = (ic_pred * 16) / 100
print("-----------------")
print(steps)
# bring current window to focus
windows[counter].move(
-900, 0) # move to other desktop, spyder had been blocking before
windows[counter].setWindowState(QtCore.Qt.WindowActive)
windows[counter].raise_()
# this will activate the window (yellow flashing on icon)
windows[counter].activateWindow()
# plot, from zero, to at least V_max (num_j*2.5e-03) and stop when slope exceeds certain amount
# see iv.sweep_current_live_Rn
I, V, R, slope, slope_index = iv.sweep_current_live_Rn(
app, curves[counter], 1, 0, num_j * 4e-03, steps, card1, card2,
chan1, chan2, dev)
if slope is None:
slope = 1e-09
if I == 0 and V == 0 and R == 0:
return 0, 0
# plot the slope and get the location it was plotted
try:
slope_index_old, slope_old = plot_slope(I, V, counter, slope,
slope_index)
except:
print("\nERROR!\n")
slope_index = 0
slope = 1e-09
# set label
label = pg.TextItem(text=("Slope: " + str(slope)),
color=(0, 0, 0),
fill=(255, 0, 0),
anchor=(-.5, -.5))
label.setPos(I[slope_index], V[slope_index])
plots[counter].addItem(label)
# append to total data
x[counter] = I
y[counter] = V
# create name
name = ic.create_name(chip, devices[counter])
plots[counter].setTitle(name)
# new fig
# fig = plt.figure()
# plot differential
# Rdiff = np.diff(V)/np.diff(I)
# plt.plot(V[0:-1], Rdiff)
#Saving Locally
filename = (folder + name)
print(filename)
ic.create_dir(filename)
sub_folder = "/RawData_Rn"
filename = (folder + sub_folder + name + "_Rn_raw.dat")
ic.create_dir(filename) # function to create dir if doesn't exist
print(filename)
iv.save_data_live(
I, V, R,
(folder + sub_folder + name + "_Rn_raw.dat")) # save the raw data
# changed to here 2/15
plt.savefig(folder + sub_folder + name + '_Rn_Diff.png')
sub_folder = "/Rn_values"
filename = (folder + sub_folder + name)
print(filename)
ic.create_dir(filename) # function to create dir if doesn't exist
return_measurements_Rn.append(slope / num_JJ[counter])
try:
return_measurements_Imax.append(I[slope_index + 5])
save_Rn_data((slope / num_JJ[counter]), I[slope_index + 5],
filename)
except:
return_measurements_Imax.append(1e-09)
save_Rn_data((slope / num_JJ[counter]), 1e-09, folder + name)
sub_folder = "/Graphs"
filename = (folder + sub_folder + name + "_Rn.png")
print(filename)
ic.create_dir(filename) # function to create dir if doesn't
try:
my_exporters[counter].export(filename)
except:
print("oh noooo, wrapped object was deleted\n")
# saving to database
Rn = return_measurements_Rn[counter]
Imax = return_measurements_Imax[counter]
device = devices[counter]
d.save_JJ_Measurements_Rn(chip, Rn, Imax, meas_ids[counter], device)
counter = counter + 1
return return_measurements_Rn, return_measurements_Imax
def exportAsImage(self, filename, folder):
vb = self._plot.plotItem #.getViewBox()
exporter = pg_exp.ImageExporter(vb)
exporter.export(os.path.join(folder, "{0}.png".format(filename)))
def get_Rn_Imax(folder, chip, devices):
global slope_plots, app
global windows, plots, curves, my_exporters, figures
'''
Inputs:
Folder-Target folder for data to be saved
Chip-Target Chip
Devices-Devices on Target Chip
Outputs:
return_measurements_Rn-Array of rn measurements
return_measurements_Imax-array of Imax measurements
2 graphs for each device, one has Rn, Imax
s
Called By:
Measurement Functions- MEasure_JJs_Rn
Calls On:
sweep_current_live_Rn
save_Rn_data
'''
# get variables
inputs = inpfunc.format_input_Rn_Imax_devices(devices)
channels = inputs[0]
num_JJ = inputs[1]
cards = inputs[2]
# arrays that will be returned
return_measurements_Rn = []
return_measurements_Imax = []
# check instance, so that it doesn't crash on exit (hopefully)
app = QtGui.QApplication.instance()
if app is None:
app = QtGui.QApplication(sys.argv)
else:
pass
num_plots = len(num_JJ)
# create windows, plots, curves
curves = initialization(num_plots)
x, y = lpf.create_data(curves)
slope_plots = lpf.create_slope_plots(plots)
# data collection
counter = 0
steps = 0.00008
# create exporters (trying to fix problem of C object being deleted
my_exporters = []
for i in range(0, num_plots):
scene = plots[i].scene()
exporter = exporters.ImageExporter(scene)
my_exporters.append(exporter)
# loop through and plot slope
# i incremets by 2, counter by 1
# get current number of JJ and channels
for i in range(0, len(channels), 2):
num_j = num_JJ[counter]
chan1 = channels[i]
chan2 = channels[i + 1]
card1 = cards[i]
card2 = cards[i + 1]
dev = devices[counter]
ic_pred = d.predict_Ic(d.chip_Jc(chip), dev.JJ_radius_nom * 1e-06)
steps = (ic_pred * 16) / 100
print("-----------------")
print(steps)
# bring current window to focus
windows[counter].move(
-900, 0) # move to other desktop, spyder had been blocking before
windows[counter].setWindowState(QtCore.Qt.WindowActive)
windows[counter].raise_()
# this will activate the window (yellow flashing on icon)
windows[counter].activateWindow()
# plot, from zero, to at least V_max (num_j*2.5e-03) and stop when slope exceeds certain amount
# see iv.sweep_current_live_Rn
I, V, R, slope, slope_index = iv.sweep_current_live_Rn(
app, curves[counter], 1, 0, num_j * 2.5e-03, steps, card1, card2,
chan1, chan2, dev)
if I == 0 and V == 0 and R == 0:
return 0, 0
# plot the slope and get the location it was plotted
try:
slope_index, slope = plot_slope(I, V, counter, slope, slope_index)
except:
print("\nERROR!\n")
slope_index = 0
slope = 1e-09
# set label
label = pg.TextItem(text=("Slope: " + str(slope)),
color=(0, 0, 0),
fill=(255, 0, 0),
anchor=(-.5, -.5))
label.setPos(I[slope_index], V[slope_index])
plots[counter].addItem(label)
# append to total data
x[counter] = I
y[counter] = V
# create name
name = ic.create_name(chip, devices[counter])
plots[counter].setTitle(name)
# new fig
#fig = plt.figure()
#figures.append(fig)
# plot differential
#Rdiff = np.diff(V)/np.diff(I)
#plt.plot(V[0:-1], Rdiff)
# saving
filename = (folder + name + "_Rn.png")
ic.create_dir(filename)
print(filename)
iv.save_data_live(I, V, R, (folder + name + "_Rn_raw.dat"))
plt.savefig(folder + name + '_Rn_Diff.png')
return_measurements_Rn.append(slope / num_JJ[counter])
return_measurements_Imax.append(I[slope_index + 5])
save_Rn_data((slope / num_JJ[counter]), I[slope_index + 5],
folder + name)
try:
my_exporters[counter].export(filename)
except:
print("oh noooo, wrapped object was deleted\n")
counter += 1
return return_measurements_Rn, return_measurements_Imax
