Python API: Frames with subframes examle
Jump to navigation
Jump to search
3 in 1 examples for subframes
Note: The example is designed for using from commandline, outside of the Pixet program.
# device/acquisitions in framemode: Frames with subframes
# (c) 2021 Pavel hudecek, Advacam
#
# This example have frame mode acquisitions:
# 1. use one frame with SFRs after acquisition
# 2. use multiple frames with SFRs after acquisitions sequence (with some processing tests)
# 3. use multiple frames with SFRs while acquisitions sequence is running
#
# Init the device, sensor refresh, acquisitions, using the frames
# Tested on MiniPix Tpx3 CdTe
import pypixet
import code, os, ctypes
from testFrames import *
try: # create dirrectory for flie output
os.makedirs("out-files")
except FileExistsError:
pass # already exists
print("pixet core init...")
pypixet.start()
pixet=pypixet.pixet
print("TPX3 devices:")
devices = pixet.devicesByType(pixet.PX_DEVTYPE_TPX3)
# devices = pixet.devices()
# if no physival devices present, virtual device "FileDevice 0" found
if len(devices)<1:
print(" No devices connected")
pixet.exitPixet()
exit()
if devices[0].fullName()=="FileDevice 0":
print(" No devices connected")
pixet.exitPixet()
exit()
devCnt = len(devices)
for n in range(devCnt):
dev = devices[n]
print(" ", n, dev.fullName(), dev.width(), dev.height(), dev.chipCount(), dev.chipIDs(), dev.sensorType(0))
print("Selected device index: 0")
# get first Timepix3 device:
dev = devices[0]
parsNotSupp = False
pars = dev.parameters() # different devices has different sets of parameters
try:
print("FirmwareCpu:", pars.get("FirmwareCpu").getString())
print("Chip Temp:", pars.get("TemperatureChip").getDouble(), end='')
print(", CPU Temp:", pars.get("TemperatureCpu").getDouble())
except:
parsNotSupp = True
try:
print("FirmwareCpu:", pars.get("FirmwareCpu").getString())
except:
print()
#for p in pars.params():
# print(p.name(), "-\t", p.description())
print("==================================================================")
print("dev.loadConfigFromDevice", dev.loadConfigFromDevice())
# (Minipix, no Advapix)
opm = pixet.PX_TPX3_OPM_TOATOT
#opm = pixet.PX_TPX3_OPM_EVENT_ITOT # good for imaging / not usable for data-driven
#opm = pixet.PX_TPX3_OPM_TOA
#opm = pixet.PX_TPX3_OPM_TOT_NOTOA
print("mode set:", opm)
# set Timepix3 operation mode: (src_gen\ipixetw.cpp)
dev.setOperationMode(opm)
# Sensor refresh - sequential changing of bias
# First do the sensor refresh: Clean the chip for free charges.
# In data-driven/callbacks mode, some chips can sometimes stop producing data
# in first measurement, if not refreshed before.
# Depending on the chip condition, default settings may work or not.
# Refresh process can be programmed by device.setSensorRefresh("refresh string")
# or possible to several repeat default refresh sequence.
# Alternatively can be used dummy measurement.
#print("doSensorRefresh start")
#dev.doSensorRefresh()
#print("doSensorRefresh end")
def acqSimple(time): # =============================================================================
print("acqSimple", time, "-----------------")
print("dev.doSimpleAcquisition - start")
# count, time, fileType, fileName
# count>1: frame data is available only from last frame
rc = dev.doSimpleAcquisition(1, time, pixet.PX_FTYPE_AUTODETECT, "")
print("dev.doSimpleAcquisition - end", rc)
print("acqFrameCount", dev.acqFrameCount())
#frame = dev.lastAcqFrameRefInc()
frame = dev.acqFrameRefInc(0)
print(" frame.frameCount:", frame.frameCount(), "subFrameCount", frame.subFrameCount())
data = frame.data() # medipix3 compatible data: simple list of pixel values
# on Tpx3 in combined modes (OPM_EVENT_ITOT or OPM_TOATOT), there is only processing artefacts
# Proper data from comfined modes:
# - is in the subframes (see SFRs example)
# - can be saved by frame.save (save multiply files with sfr names in filename)
print(" type data:", type(data), ", len:", len(data))
frame.save("out-files\\fr.pmf", pixet.PX_FTYPE_AUTODETECT, 0)
print(" Main frame preview:")
testFrameUni(frame, " ")
if frame.subFrameCount()>0:
f0=frame.subFrames()[0]
print(" SubFrame0:")
testFrameUni(f0, " ")
f0.save("out-files\\f0.pbf", pixet.PX_FTYPE_AUTODETECT, 0)
#f0.destroy()
if frame.subFrameCount()>1:
f1=frame.subFrames()[1]
print(" SubFrame1:")
testFrameUni(f1, " ")
f1.save("out-files\\f1.pbf", pixet.PX_FTYPE_AUTODETECT, 0)
#f1.destroy()
frame.destroy()
print("")
# def acqSimple
def testTheFrameSFR(frame, save): # ================================================================
print("Frame idx:", n, "sfrs:", frame.subFrameCount(), " - - - - - - - - - - - - - - -")
frame.incRefCount()
print(" dataFormat", frame.dataFormat(), "dataID", frame.dataID(), "isIgnoringMasked", frame.isIgnoringMasked())
if frame.subFrameCount()>0:
for sfr in frame.subFrames():
print(" Subframe:", sfr.frameName())
print(" metaDataCount", frame.metaDataCount())
for mdn in frame.metaDataNames():
try:
print(" ", mdn, frame.metaData(mdn).data())
except:
print(" (metadata view error)")
print(" min", sfr.min(), 'minNonZero', sfr.minNonZero(), 'max', sfr.max(), 'mean', sfr.mean(), 'median', sfr.median(), 'sum', sfr.sum(), 'stdDev', sfr.stdDev())
sfr.multiplyWithValue(1.123456)
print(" dataFormat", sfr.dataFormat(), "dataID", sfr.dataID(), "isIgnoringMasked", sfr.isIgnoringMasked())
if sfr.frameName()=="ToT":
dev.calibrateFrame(sfr)
print(" min", sfr.min(), 'max', sfr.max(), 'mean', sfr.mean(), 'median', sfr.median(), 'sum', sfr.sum())
data = sfr.data()
print(" data sample:")
print(" ", end="");
for i in range(256*120+100, 256*120+110):
print(data[n], end=" ")
print()
sfr.save("out-files\\test-{}-sfr-".format(n)+sfr.frameName()+".png", pixet.PX_FTYPE_AUTODETECT, 0)
sfr.save("out-files\\test-{}-sfr-".format(n)+sfr.frameName()+".txt", pixet.PX_FTYPE_AUTODETECT, 0)
sfr.destroy()
else:
print(" min", frame.min(), 'minNonZero', frame.minNonZero(), 'max', frame.max(), 'mean', frame.mean(), 'median', frame.median(), 'sum', frame.sum())
data = frame.data()
print(" data sample:")
for i in range(256*120+100, 256*120+110):
print(" ", data[n], end="")
print()
frame.save("out-files\\test-{}-frame.png".format(n), pixet.PX_FTYPE_AUTODETECT, 0)
frame.save("out-files\\test-{}-frame.txt".format(n), pixet.PX_FTYPE_AUTODETECT, 0)
#def testTheFrameSFR(frame):
def acqSimpleSFRs(count, time): # ==================================================================
print("acqSimpleSFRs", count, time, "-----------------")
print("dev.doSimpleAcquisition - start")
# count, time, fileType, fileName
rc = dev.doSimpleAcquisition(count, time, pixet.PX_FTYPE_AUTODETECT, "")
print("dev.doSimpleAcquisition - end", rc)
print("acqFrameCount", dev.acqFrameCount())
for n in range(dev.acqFrameCount()):
frame = dev.acqFrameRefInc(n)
testTheFrameSFR(frame, True)
frame.destroy()
# for n in range(dev.acqFrameCount())
print("")
# def acqSimple2
# acqCallbackExample ===============================================================================
# Note: Parameter (val) in majority of callbacks is the finished measurement count.
# In the Acq Failed, (val) is error code form the Pixet core.
tics = ctypes.c_int64()
freq = ctypes.c_int64()
def callbackAMS(val): # Acq meas started (val) is meas. count. In this example is 0 (no finished frames).
#get ticks on the internal ~2-10 MHz QPC clock
ctypes.windll.Kernel32.QueryPerformanceCounter(ctypes.byref(tics))
#get the actual freq. of the internal ~2-10 MHz QPC clock
ctypes.windll.Kernel32.QueryPerformanceFrequency(ctypes.byref(freq))
# sys time code details can be found:
# https://stackoverflow.com/questions/38319606/how-can-i-get-millisecond-and-microsecond-resolution-timestamps-in-python
t_s = tics.value/freq.value
callbackAMS.secStart = t_s
print("clb *** Acq meas started", val)
print(" Sys time:", t_s, "sec, resolution:", 1e9/freq.value, "ns")
callbackAMS.secStart = 0
def callbackFin(val): # Acq finished (val) is number of finished measurements.
ctypes.windll.Kernel32.QueryPerformanceCounter(ctypes.byref(tics))
t_s = tics.value/freq.value
print("clb *** Acq finished", val)
print(" Sys time from start:", t_s - callbackAMS.secStart, "s")
print(" Shutter start:", dev.getShutterStartTime(), "s, Shutter end:", dev.getShutterEndTime())
frame = dev.lastAcqFrameRefInc()
testTheFrameSFR(frame, False)
#print(" dev.calibrateFrame:", dev.calibrateFrame(frame))
#print(" frame.dataID:", frame.dataID())
#print(" frame.frameCount:", frame.frameCount())
data = frame.data() # medipix3 compatible data: simple list of pixel values
# on Tpx3 in combined modes (OPM_EVENT_ITOT or OPM_TOATOT), this is only first data (EVENT or TOA)
# This data is saved to simple image formats
if val==1:
print(" type frame:", type(frame))
print(" frame.metaDataCount:", frame.metaDataCount())
print(" frame.metaDataNames:", frame.metaDataNames())
print(" type data:", type(data), ", len:", len(data))
#print(" data min:", min(data), ", avg:", sum(data)/len(data), ", max:", max(data))
fnam = "out-files\\frames-callback{}".format(val)
print(" fnam:", "\""+fnam+"\"")
frame.save(fnam+".png", pixet.PX_FTYPE_AUTODETECT, 0)
frame.save(fnam+".txt", pixet.PX_FTYPE_AUTODETECT, 0)
#testFrameUni(frame, " ")
frame.destroy()
# def callbackFin
def callbackFail(val): # Acq failed (val) is error code form the Pixet core.
print("clb *** Acq failed", val)
print(" ", dev.lastError())
def callbackDSCh (val): # Device status changed
print("clb *** Dev status changed", val)
print(" Status:", dev.deviceStatus())
print(" StatusText:", dev.deviceStatusText())
def callbackACQ_SERIE_STARTED(val):
print ("clb *** ACQ_SERIE_STARTED", val)
def callbackACQ_SERIE_FINISHED(val):
print ("clb *** ACQ_SERIE_FINISHED", val)
def callbackACQ_MEAS_FINISHED(val):
print ("clb *** ACQ_MEAS_FINISHED", val)
def callbackACQ_SWTRG_READY(val):
print ("clb *** ACQ_SWTRG_READY", val)
def acqCallbackExample(count, time): # =============================================================
print("acqCallbackExample", count, time, "--------------------------")
print("registerEvent")
# registerEvent(name, (reserved), CallFunc)
# (only PX_EVENT_ACQ_FINISHED is necessary)
dev.registerEvent(pixet.PX_EVENT_ACQ_MEAS_STARTED, 0, callbackAMS)
dev.registerEvent(pixet.PX_EVENT_ACQ_FINISHED, 0, callbackFin)
dev.registerEvent(pixet.PX_EVENT_ACQ_FAILED, 0, callbackFail)
dev.registerEvent(pixet.PX_EVENT_DEV_STATUS_CHANGED, 0, callbackDSCh)
#dev.registerEvent(pixet.PX_EVENT_, 0, callback)
dev.registerEvent(pixet.PX_EVENT_ACQ_SERIE_STARTED , 0, callbackACQ_SERIE_STARTED)
dev.registerEvent(pixet.PX_EVENT_ACQ_SERIE_FINISHED, 0, callbackACQ_SERIE_FINISHED)
dev.registerEvent(pixet.PX_EVENT_ACQ_MEAS_FINISHED, 0, callbackACQ_MEAS_FINISHED)
dev.registerEvent(pixet.PX_EVENT_ACQ_SWTRG_READY, 0, callbackACQ_SWTRG_READY)
print("doAdvancedAcquisition start")
#doAdvancedAcquisition(count, time, type, mode, fileType, fileFlags, filePath)
rc = dev.doAdvancedAcquisition(count, time, pixet.PX_ACQTYPE_FRAMES, pixet.PX_ACQMODE_NORMAL, pixet.PX_FTYPE_NONE, 0, "")
print("doAdvancedAcquisition end", rc)
#print("doSimpleAcquisition start")
#dev.doSimpleAcquisition(count, time, pixet.PX_FTYPE_NONE, "")
#print("doSimpleAcquisition end")
print("unregisterEvent")
dev.unregisterEvent(pixet.PX_EVENT_ACQ_MEAS_STARTED, 0, callbackAMS)
dev.unregisterEvent(pixet.PX_EVENT_ACQ_FINISHED, 0, callbackFin)
dev.unregisterEvent(pixet.PX_EVENT_ACQ_FAILED, 0, callbackFail)
dev.unregisterEvent(pixet.PX_EVENT_DEV_STATUS_CHANGED, 0, callbackDSCh)
print()
# def acqCallbackExample
print("==================================================================")
print("examples:") # ===============================================================================
print()
testTime = 2
acqSimple(testTime) #(time)
acqSimpleSFRs(3, testTime) #(count, time)
acqCallbackExample(5, testTime) #(count, time)
print("All examples complete")
print("==================================================================") # ======================
if not parsNotSupp:
pars = dev.parameters()
print("Chip Temp:", pars.get("TemperatureChip").getDouble(), end='')
print(", CPU Temp:", pars.get("TemperatureCpu").getDouble())
print("pixet core exit...")
pixet.exitPixet()
pypixet.exit()