def xtest_compare_calibrator_with_multiple_interpolations(self):
# 2: Light
# 1: Laser
processor = preProcessData.DataProcessor(
"./data/Notch Filter/Data Channel 1.dat",
"./data/Notch Filter/Data Channel 2.dat")
x, y, laser_x, laser_y = processor.get_data(1)
calibrator = Calibrator(laser_x, laser_y)
x, y = calibrator.calculate_calibration()
plt.plot(x, y)
x, y, laser_x, laser_y = processor.get_data(2)
calibrator = Calibrator(laser_x, laser_y)
x, y = calibrator.calculate_calibration(2)
plt.plot(x, y)
x, y, laser_x, laser_y = processor.get_data(8)
calibrator = Calibrator(laser_x, laser_y)
x, y = calibrator.calculate_calibration(8)
plt.plot(x, y)
plt.xlabel('peak index')
plt.ylabel('delta')
plt.show()
def fromConfig(cls, config):
if 'camera' not in config:
return None
camera = PinholeCamera.fromConfig(config['camera'])
if camera:
monocular = MonocularWrapper()
if 'calibrator' in config:
calibrator = Calibrator.fromConfig(camera, monocular,
config['calibrator'])
else:
calibrator = Calibrator(camera, monocular)
if calibrator:
for key in cls.CONFIG_KEYS:
if key not in config:
return None
roi = config['roi']
velocitaCrociera = config['velocitaCrociera']
#Parametri opzionali
distanzaMinima = config[
'distanzaMinima'] if 'distanzaMinima' in config else None
distanzaLimite = config[
'distanzaLimite'] if 'distanzaLimite' in config else None
windowSize = config[
'windowSize'] if 'windowSize' in config else None
skipThreshold = config[
'skipThreshold'] if 'skipThreshold' in config else None
return cls(camera, monocular, calibrator, roi,
velocitaCrociera, distanzaMinima, distanzaLimite,
windowSize, skipThreshold)
def calculate(processor,
interp_multiplier,
ignore_calib,
plot_fkt,
correction_factor=1):
x, y, laser_x, laser_y = processor.get_data(interp_multiplier)
calibrator = Calibrator(laser_x, laser_y, interp_multiplier, plot_fkt)
delta, dt_max = calibrator.get_calibration(x)
print(len(x))
if not ignore_calib:
_x = x + delta
x = np.linspace(_x[0], _x[-1], len(_x))
y = Utils.interpolate(x, _x, y)
x = x * correction_factor
# t in seconds
t = x * dt_max
dt = t[1] - t[0]
t_max = len(t)
print(len(t))
print(1 / t_max)
l, y_trans = FourierTransformer().transform(y, dt, t_max)
# / y_trans = list(reversed(y_trans))
return l, y_trans
def main():
print(Banner("GUESS THE NUMBER APP").content)
calibrator = Calibrator(random.randint(0, 100))
prompt = Prompt()
success = False
while not success:
calibration = calibrator.calibrate(prompt.input())
print(calibration.message)
success = calibration.is_equal
def build_engine(max_batch_size, save_engine):
"""Takes an ONNX file and creates a TensorRT engine to run inference with"""
with trt.Builder(TRT_LOGGER) as builder, \
builder.create_network(1) as network,\
trt.OnnxParser(network, TRT_LOGGER) as parser:
config = builder.create_builder_config()
config.max_workspace_size = 1 << 30
# parse onnx model file
if not os.path.exists(onnx_file_path):
quit('ONNX file {} not found'.format(onnx_file_path))
print('Loading ONNX file from path {}...'.format(onnx_file_path))
with open(onnx_file_path, 'rb') as model:
print('Beginning ONNX file parsing')
parser.parse(model.read())
assert network.num_layers > 0, 'Failed to parse ONNX model. \
Please check if the ONNX model is compatible '
print('Completed parsing of ONNX file')
print('Building an engine from file {}; this may take a while...'.
format(onnx_file_path))
# build trt engine
builder.max_batch_size = max_batch_size
builder.max_workspace_size = 1 << 30 # 1GB
builder.fp16_mode = fp16_mode
if int8_mode:
config.max_workspace_size = common.GiB(1)
config.set_flag(trt.BuilderFlag.INT8)
config.int8_calibrator = Calibrator(
calibration_stream, calibration_table_path
) # 设定的东西要放到config里面 - 没有更改运行时候的文件，这里只是给自己做一下提醒
#builder.int8_mode = int8_mode
assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'
#builder.int8_calibrator = Calibrator(calibration_stream, calibration_table_path)
print('Int8 mode enabled')
#engine = builder.build_cuda_engine(network)
#engine = builder.build_engine(network,config)
profile = builder.create_optimization_profile()
profile.set_shape(
network.get_input(0).name, (1, 3, 368, 432), (8, 3, 368, 432),
(64, 3, 368, 432)) #lopps
#profile.set_shape(network.get_input(0).name, (1, 3,368, 656), (8, 3,368, 656), (64, 3,368, 656)) #openpose_coco
#profile.set_shape(network.get_input(0).name, (1, 3,432, 368), (1, 3,432, 368), (32, 3, 432, 368)) #openpose_thin
#profile.set_shape(network.get_input(0).name, (1, 3, 384, 384), (8, 3, 384, 384), (64, 3, 384, 384))#ppn-resnet50-V2-HW=384x384.onnx)
config.add_optimization_profile(profile)
engine = builder.build_engine(network, config)
if engine is None:
print('Failed to create the engine')
return None
print("Completed creating the engine")
if save_engine:
with open(engine_file_path, "wb") as f:
f.write(engine.serialize())
return engine
def CheckPinCode(self, pin):
if pin=='2502':
self.tempthreadcontrol(0)
spi.close()
self.CalibrWindow=Calibrator(self.finish_signal, self)
self.CalibrWindow.show()
else:
pass
self.Calibr.setStyleSheet(metrocss.prog_passive)
def differential_scan(self):
cmat, dist_ceofs, \
rmat, tmat, _ = Calibrator().calibration_data.load_calibrations()
while self.is_scanning:
if np.abs(self.theta) >= PI2:
break
else:
begin = time.time()
try:
image = self.camera.capture_image()
def build_engine(max_batch_size, save_engine):
"""Takes an ONNX file and creates a TensorRT engine to run inference with"""
with trt.Builder(TRT_LOGGER) as builder, \
builder.create_network(1) as network, \
trt.OnnxParser(network, TRT_LOGGER) as parser:
# parse onnx model file
if not os.path.exists(onnx_file_path):
quit('ONNX file {} not found'.format(onnx_file_path))
log.logger.info(
'Loading ONNX file from path {}...'.format(onnx_file_path))
with open(onnx_file_path, 'rb') as model:
log.logger.info('Beginning ONNX file parsing')
parser.parse(model.read())
assert network.num_layers > 0, 'Failed to parse ONNX model. \
Please check if the ONNX model is compatible '
log.logger.info('Completed parsing of ONNX file')
log.logger.info(
'Building an engine from file {}; this may take a while...'.
format(onnx_file_path))
# build trt engine
if int8_mode:
builder.max_batch_size = max_batch_size
builder.int8_mode = int8_mode
builder.max_workspace_size = 1 << 30 # 1GB
assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'
builder.int8_calibrator = Calibrator(calibration_stream,
calibration_table_path)
engine = builder.build_cuda_engine(network)
log.logger.info('Int8 mode enabled')
if fp16_mode:
builder.max_batch_size = max_batch_size
builder.max_workspace_size = 1 << 30 # 1GB
builder.fp16_mode = fp16_mode
engine = builder.build_cuda_engine(network)
log.logger.info('fp16 mode enabled')
if fp32_mode:
builder.max_batch_size = max_batch_size
builder.max_workspace_size = 1 << 30 # 1GB
engine = builder.build_cuda_engine(network)
log.logger.info('fp32 mode enabled')
if engine is None:
log.logger.error('Failed to create the engine')
return None
print("Completed creating the engine")
if save_engine:
with open(engine_file_path, "wb") as f:
f.write(engine.serialize())
return engine
def main():
test_set = '../testpics'
model_file = '../Engine/11.onnx'
# Now we create a calibrator and give it the location of our calibration data.
# We also allow it to cache calibration data for faster engine building.
engine_model_path = "models_save/panoptic_fcn_int8_7.2.2.trt"
calibration_cache = 'models_save/panoptic_fcn_int8.cache'
calib = Calibrator(test_set, cache_file=calibration_cache)
# Inference batch size can be different from calibration batch size.
batch_size = 1
engine = build_int8_engine(model_file, calib, batch_size)
with open(engine_model_path, "wb") as f:
f.write(engine.serialize())
def AnalyzeImg(self):
imglist = []
for i in range(self.screenshot_list.count()):
item = self.screenshot_list.item(i)
imglist.append(unicode(item.text()))
language = unicode(self.ocr_language.currentText())
self.calibratorthread = Calibrator(self, imglist, language)
QObject.connect(self.calibratorthread,
SIGNAL('finished(float, int, PyQt_PyObject)'),
self.threadFinished)
QObject.connect(self.calibratorthread, SIGNAL('steps(int)'),
self.updateSteps)
QObject.connect(self.calibratorthread, SIGNAL('progress(int)'),
self.updateProgress)
self.calibratorthread.execute()
def calibrate_devices():
# with Serial('/dev/ttyWHATEVER', baudrate=115200, timeout=30, xonxoff=True) as frequency_counter_port:
# frequency_counter = Tf930FrequencyCounter(frequency_counter_port)
global calibration_dir
resources = pyvisa.ResourceManager('@py')
with resources.open_resource(
'USB0::62700::60984::SDM36GBQ5R0755::0::INSTR') as resource:
frequency_counter = Sdm3065xFrequencyCounter(resource)
calibrator = CalibrationProcess(
lambda: Calibrator(CalibrationLog(calibration_dir),
frequency_counter,
lambda: Cluck2SesameDevice(lambda: Serial(
'/dev/ttyS0', baudrate=9600, timeout=30)),
vdd_volts_range=[2.7, 4.5]))
calibrator.calibrate()
def calibrate(path: str, filter: str, nrows: int, ncols: int):
calibrator = Calibrator(1)
objp = np.zeros((nrows * ncols, 3), np.float32)
objp[:, :2] = np.mgrid[0:nrows, 0:ncols].T.reshape(-1, 2)
counter = 0
image_names = glob.glob(os.path.join(path, filter))
print(image_names)
for i in range(100):
for imname in glob.glob(os.path.join(path, filter)):
counter += 1
image = cv2.imread(imname, cv2.IMREAD_GRAYSCALE)
f, corners = cv2.findChessboardCorners(image, (nrows, ncols), None)
cv2.cornerSubPix(image, corners, (11, 11), (-1, -1),
(cv2.TERM_CRITERIA_EPS +
cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001))
print(counter)
calibrator.train(objp, np.squeeze(corners.astype(np.float64)))
import sys
# import PyQt4 QtCore and QtGui modules
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from calibrator import Calibrator
if __name__ == '__main__':
# create application
app = QApplication( sys.argv )
app.setApplicationName( 'calibrator' )
# create widget
w = Calibrator()
w.setWindowTitle( 'calibrator' )
w.show()
# connection
QObject.connect( app, SIGNAL( 'lastWindowClosed()' ), app, SLOT( 'quit()' ) )
# execute application
sys.exit( app.exec_() )
#!/usr/bin/env python
from calibrator import Calibrator
import rospy
calibrator = Calibrator()
if "__main__" == __name__:
try:
calibrator.set_pattern_type("CHESS_BOARD")
calibrator.set_calibration_file("calibration_sd_kinect/")
#~ calibrator.set_calibration_file("calibration_s4/")
calibrator.perform_calibration()
calibrator.print_parameters()
except rospy.ROSInterruptException:
pass
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2020/6/15 23:06 # @Author : Wang Xin # @Email : [email protected] # @File : demo_BM.PY import cv2 from utils import * from calibrator import Calibrator from stereo_matcher import StereoMatcher import matplotlib.pyplot as plt # for not rectified images # stereo calibration calibrator = Calibrator(images_dir="./data/calibration_images", border_size=(9, 6)) calibrator.calibrate() calibrator.save("stereo_camera.json") # stereo matching matcher1 = StereoMatcher(methods="BM", is_rectified=False, camera_params_file="stereo_camera.json") imgL1 = cv2.imread("./data/calibration_images/left06.jpg", flags=0) imgR1 = cv2.imread("./data/calibration_images/right06.jpg", flags=0) print(len(imgR1.shape)) rectifiedImgL1, rectifiedImgR1 = rectifyImagePair( imgL1, imgR1, cameraParams=json_load("stereo_camera.json")) rectifiedImgPair = np.concatenate((rectifiedImgL1, rectifiedImgR1), axis=1) rectifiedImgPair[::20, :] = 0 disp1 = matcher1.predict(imgL1, imgR1)
peaks, _ = find_peaks(spectrum,
distance=3.,
prominence=np.percentile(spectrum, 20))
plt.figure(1, figsize=(8, 8))
plt.clf()
plt.plot(spectrum)
plt.vlines(peaks,
spectrum[peaks.astype('int')],
spectrum.max() * 1.1,
colors='C1')
plt.ylim(0, spectrum.max() * 1.1)
plt.xlim(0, len(spectrum))
c = Calibrator(peaks,
elements=["Xe"],
min_wavelength=3000.,
max_wavelength=9000.)
# thresh (A) :: the individual line fitting tolerance to accept as a valid fitting point
# fit_tolerance (A) :: the RMS
c.set_fit_constraints(n_pix=len(spectrum),
min_intercept=3000.,
max_intercept=5000.,
fit_tolerance=pix_scale * 0.5,
thresh=pix_scale * 1.,
polydeg=4)
pix = np.array((241., 269., 280., 294., 317., 359., 462.5, 468.4, 477., 530.3,
752., 836., 900., 912., 980.))
wave = np.array(
(4500.98, 4624.28, 4671.23, 4734.15, 4844.33, 5023.88, 5488.56, 5531.07,
def projectInterpResamp(proj, **kwargs):
generalPrint(
"Project Interp Resamp",
"Resampling / Interpolating project time files with options: {}".
format(kwargs))
# resample info is a dictionary
# {sampleRateToResample: sampleRateToResampleTo}
# this function then does this for all measurement directories of that sample rate in the project
options = parseKeywords(getDefaultOptions(proj), kwargs)
# create a data calibrator and writer instance
cal = Calibrator(proj.getCalDataPath())
if options["calibrate"]:
cal.printInfo()
writer = DataWriterInternal()
# loop over sites
for s in options["sites"]:
# print site info
proj.printSiteInfo(s)
for fs in options["freqs"]:
timeFiles = proj.getSiteTimeFilesFs(s, fs)
if len(timeFiles) == 0:
continue # nothing to process
# otherwise, resample
for tF in timeFiles:
# get the reader
reader = proj.getMeasDataReader(s, tF)
reader.printInfo()
# get the dates for the data
timeStart = reader.getStartDatetime()
timeStop = reader.getStopDatetime()
# now check the user provided dates
# don't change timeStart, timeEnd yet because that breaks the checking
if options["start"]:
startUser = datetime.strptime(options["start"],
"%Y-%m-%d %H:%M:%S")
if startUser > timeStop: # this data has nothing to contribute in the optional date range
continue
if options["stop"]:
stopUser = datetime.strptime(options["stop"],
"%Y-%m-%d %H:%M:%S")
if stopUser < timeStart: # this data has nothing to contribute in the optional date range
continue
# if the data contributes, copy in the data if relevant
if options["start"]:
timeStart = datetime.strptime(options["start"],
"%Y-%m-%d %H:%M:%S")
if options["stop"]:
timeStop = datetime.strptime(options["stop"],
"%Y-%m-%d %H:%M:%S")
# calculate the samples
sampleStart, sampleEnd = reader.time2sample(
timeStart, timeStop)
dataStartTime, dataStopTime = reader.sample2time(
sampleStart, sampleEnd
) # need to do it this way round to protect against fractional sampling
# now get the data
data = reader.getPhysicalSamples(startSample=sampleStart,
endSample=sampleEnd)
numSamples = reader.getNumSamples()
chans = reader.getChannels()
headers = reader.getHeaders()
chanHeaders, chanMap = reader.getChanHeaders()
dataFs = fs
# if calibration is on, calibrate the data
if options["calibrate"]:
generalPrint(
"Project Interp Resamp",
"Calibrating time data: site {}, time data {}".format(
s, tF))
sensors = reader.getSensors(reader.getChannels())
serials = reader.getSerials(reader.getChannels())
choppers = reader.getChoppers(reader.getChannels())
data = cal.calibrate(data, dataFs, sensors, serials,
choppers)
# Interpolation to the second - do this first
# make sure all the data starts on a full second
if options["interp"]:
if dataStartTime.microsecond != 0:
generalPrint(
"Project Interp Resamp",
"Interpolating to second: site {}, time data {} at {} Hz"
.format(s, tF, dataFs))
# the recording is not on the second - NOTE, this will fail with longer sample periods (i.e. greater than a second)
startTimeInterp, numSamplesInterp, dataInterp = interpolateToSecond(
dataFs, dataStartTime, data)
numSamples = numSamplesInterp
dataStartTime = startTimeInterp
data = dataInterp
# Check if fs belongs to options["resamp"] keys and resample if does
# resampling does not change the start time - hence dataStartTime is unchanged
if dataFs in options[
"resamp"]: # then need to resample this data
generalPrint(
"Project Interp Resamp",
"Resampling site = {}, time data {} at {} Hz to {} Hz".
format(s, tF, fs, options["resamp"][fs]))
data = resample(data, dataFs, options["resamp"][dataFs])
# update info for saving file
dataFs = options["resamp"][fs]
numSamples = data[chans[0]].size
# recall, start times stay the same with resampling - only the sample rate changes and the number of samples
# write out data - the data writer automatically deals with the end date
outPath = os.path.join(
proj.getTimeDataPathSite(s),
options["prepend"] + tF + options["postpend"])
writer.setOutPath(outPath)
writer.writeData(
headers,
chanHeaders,
data,
start_time=dataStartTime.strftime("%H:%M:%S.%f"),
start_date=dataStartTime.strftime("%Y-%m-%d"),
numSamples=numSamples,
sample_freq=dataFs,
lsb_applied=True)
writer.printInfo()
def projectSpecCalc(proj, **kwargs):
generalPrint(
"ProjectSpecCalc",
"Calculating spectra for project with options: {}".format(kwargs))
# default options
options = parseKeywords(getDefaultOptions(proj), kwargs)
# calculate the spectra
# get the reference time
datetimeRef = proj.getRefTime()
# prepare the calibrator
cal = Calibrator(proj.getCalDataPath())
if options["calibrate"]:
cal.printInfo()
# loop over sites
for s in options["sites"]:
# print site info
proj.printSiteInfo(s)
# get measurement directories for site s
timeMeas = proj.getSiteTimeFiles(s)
# loop over measurement folders and calculate spectra for each one
for meas in timeMeas:
# get measurement sample frequency
fs = proj.getMeasSampleFreq(s, meas)
# check to see if in given frequency list
if int(fs) not in options["freqs"]:
continue
# print measurement info
proj.printMeasInfo(s, meas)
# get measurement start and end times
datetimeStart = proj.getMeasStartTime(s, meas)
datetimeEnd = proj.getMeasEndTime(s, meas)
# get data, sensor info, serial info, chopper info for calibration
reader = proj.getMeasDataReader(s, meas)
# get data start and end times - these may not be equal to startDate and endDate
# there is the issue of ats data recording end time as one sample late
# hence get the actual end time
dataStartTime, dataEndTime = reader.getDataTimes(
datetimeStart, datetimeEnd)
dataChans = reader.getChannels()
if len(options["chans"]) > 0:
dataChans = options["chans"]
# alternatively, could simply do getPhysicalSamples() and get all data that way
data = reader.getPhysicalData(dataStartTime,
dataEndTime,
chans=dataChans)
if options["calibrate"]:
# do the calibration here
sensors = reader.getSensors(dataChans)
serials = reader.getSerials(dataChans)
choppers = reader.getChoppers(dataChans)
data = cal.calibrate(data, fs, sensors, serials, choppers)
# notch filter if required
for n in options["notch"]:
for c in data:
data[c] = notchFilter(data[c], fs, n, n / 5.0)
# define decimation parameters
decParams = DecimationParams(fs)
if len(options["evalfreq"]) == 0:
decParams.setDecimationParams(options["declevels"],
options["freqlevel"])
else:
decParams.setFrequencyParams(options["evalfreq"],
options["declevels"],
options["freqlevel"])
decParams.printInfo()
numLevels = decParams.getNumLevels()
# now do window parameters
winParams = WindowParams(decParams)
# winParams.printInfo()
# create the decimator
dec = Decimator(data, fs, decParams)
# dec.printInfo()
# loop through decimation levels
for iDec in xrange(0, numLevels):
# get the data for the current level
check = dec.incrementLevel()
if not check:
break # not enough data
#dec.printInfo()
data = dec.getData()
# create the windower and give it window parameters for current level
fsDec = dec.getSampleFreq()
win = Windower(datetimeRef, dataStartTime, data, fsDec,
winParams.getWindowSize(iDec),
winParams.getOverlap(iDec))
numWindows = win.getNumWindows()
# win.printInfo()
if numWindows < 2:
break # do no more decimation
# create the spectrum calculator and statistics calculators
specCalc = SpectrumCalculator(fsDec,
winParams.getWindowSize(iDec))
# get ready a file to save the spectra
specWrite = SpectrumWriter(proj.getSpecDataPathMeas(s, meas),
datetimeRef)
specWrite.openBinaryForWriting("spectra", iDec, fsDec,
winParams.getWindowSize(iDec),
winParams.getOverlap(iDec),
win.getGlobalWindowOffset(),
numWindows, dataChans)
# loop though windows, calculate spectra and save
for iW in xrange(0, numWindows):
# get the window data
winData = win.getData(iW)
# calculate spectra
f, specData = specCalc.calcFourierCoeff(winData)
# write out spectra
specWrite.writeBinary(specData, iW)
# close spectra and stat files
specWrite.closeFile()
#peaks, _ = getPeaks(spectrum, min_dist=25, thres=0.3)
from scipy.signal import find_peaks
spectrum /= spectrum.max()
peaks, _ = find_peaks(spectrum, height=0.1, distance=10, width=(0,40))
plt.plot(spectrum)
plt.vlines(peaks, 0, max(spectrum))
plt.show()
if len(peaks) == 0:
print("No peaks found, try again!")
exit(1)
c = Calibrator(peaks, atlas)
c.set_fit_constraints(min_slope=0.043,
max_slope=0.053,
min_intercept=550,
max_intercept=650,
line_fit_thresh=2)
best_p = c.match_peaks_to_atlas(c.fit(2))
if best_p is not None:
c.plot_fit(spectrum, best_p)
print("Start wavelength: ", best_p[-1])
print("Centre wavelenght: ", polyfit_value(len(spectrum)/2, best_p[::-1]))
print("Dispersion: ", best_p[-2])
def projectViewTime(proj, startDate, endDate, **kwargs):
generalPrint("ProjectViewTime",
"Showing time data with options: {}".format(kwargs))
# get options
options = parseKeywords(getDefaultOptions(proj), kwargs)
# format startDate and endDate
start = datetime.strptime("{}.000".format(startDate),
"%Y-%m-%d %H:%M:%S.%f")
end = datetime.strptime("{}.000".format(endDate), "%Y-%m-%d %H:%M:%S.%f")
# create a calibrator in case
cal = Calibrator(proj.getCalDataPath())
if options["calibrate"]:
cal.printInfo()
dataAll = {}
xAll = {}
fsAll = {}
# first need to collect the relevant data
# loop over sites
for s in options["sites"]:
# print site info
# proj.printSiteInfo(s)
# get measurement directories for site s
timeMeas = proj.getSiteTimeFiles(s)
# get the dictionary ready
dataAll[s] = {}
xAll[s] = {}
fsAll[s] = {}
# loop over measurement folders and calculate spectra for each one
for meas in timeMeas:
# get measurement sample frequency
fs = proj.getMeasSampleFreq(s, meas)
# check to see if in given frequency list
if int(fs) not in options["freqs"]:
continue
# now find recordings that are within the recording time
siteStart = proj.getMeasStartTime(s, meas)
siteEnd = proj.getMeasEndTime(s, meas)
if siteEnd < start or siteStart > end:
continue
# now get the data
reader = proj.getMeasDataReader(s, meas)
reader.printInfo()
# get the samples of the datetimes
sampleStart, sampleEnd = reader.time2sample(start, end)
# and then go back and get the times - this protects against non second sampling
# as the samples returned from time2sample are rounded
# using sample2time, we get the appropriate start and end times for those samples
readStart, readEnd = reader.sample2time(sampleStart, sampleEnd)
# get the data
# data = reader.getPhysicalData(readStart, readEnd, chans=options["chans"])
data = reader.getPhysicalData(readStart,
readEnd,
chans=options["chans"])
# if calibration is on, calibrate the data
if options["calibrate"]:
generalPrint(
"ProjectViewTime",
"Calibrating time data: site {}, time data {}".format(
s, meas))
sensors = reader.getSensors(reader.getChannels())
serials = reader.getSerials(reader.getChannels())
choppers = reader.getChoppers(reader.getChannels())
data = cal.calibrate(data, fs, sensors, serials, choppers)
# have the data, now want to calculate the x array
samples = data[options["chans"][0]].size
fsDelta = timedelta(seconds=1.0 / fs)
x = np.empty(shape=(samples), dtype=datetime)
for i in xrange(0, samples):
x[i] = readStart + timedelta(seconds=1.0 * i / fs)
# save the data
dataAll[s][meas] = data
xAll[s][meas] = x
fsAll[s][meas] = fs
# once all the data has been collected, plot it all
fig = plt.figure(figsize=options["figsize"])
plotFonts = options["plotfonts"]
# suptitle
st = fig.suptitle("Time data from {} to {}".format(
start.strftime("%Y-%m-%d %H-%M-%S"),
end.strftime("%Y-%m-%d %H-%M-%S")),
fontsize=plotFonts["suptitle"])
st.set_y(0.98)
for s in dataAll:
for meas in dataAll[s]:
# apply the filter options
if options["lpfilt"]:
dataAll[s][meas] = lpFilter(dataAll[s][meas], fsAll[s][meas],
options["lpfilt"])
if options["hpfilt"]:
dataAll[s][meas] = hpFilter(dataAll[s][meas], fsAll[s][meas],
options["hpfilt"])
if options["bpfilt"]:
dataAll[s][meas] = hpFilter(dataAll[s][meas], fsAll[s][meas],
options["bpfilt"][0],
options["bpfilt"][1])
generalPrint(
"ProjectViewTime", "Plotting {} - {} from {} to {}".format(
s, meas, xAll[s][meas][0], xAll[s][meas][-1]))
# now plot the data
for idx, chan in enumerate(options["chans"]):
plt.subplot(4, 1, idx + 1)
plotData = dataAll[s][meas][chan]
if options["normalise"]: # then normalise the data
plotData = plotData / np.linalg.norm(plotData)
plt.plot(xAll[s][meas],
plotData,
label="{} - {}".format(s, meas))
for idx, chan in enumerate(options["chans"]):
ax = plt.subplot(4, 1, idx + 1)
plt.title("Channel {}".format(chan), fontsize=plotFonts["title"])
plt.grid()
if idx == len(options["chans"]) - 1:
plt.xlabel("Time", fontsize=plotFonts["axisLabel"])
# limit the x-axis
plt.xlim([start, end])
# do the yaxis
if isElectric(chan):
plt.ylabel("mV/km", fontsize=plotFonts["axisLabel"])
if len(options["Eylim"]) > 0:
plt.ylim(options["Eylim"])
else:
if options["calibrate"]:
plt.ylabel("nT", fontsize=plotFonts["axisLabel"])
else:
plt.ylabel("mV", fontsize=plotFonts["axisLabel"])
if len(options["Hylim"]) > 0:
plt.ylim(options["Hylim"])
plt.legend(fontsize=plotFonts["legend"])
# set tick sizes
for label in (ax.get_xticklabels() + ax.get_yticklabels()):
label.set_fontsize(plotFonts["axisTicks"])
plt.tight_layout()
# shift subplots down, make room for suptitle
fig.subplots_adjust(top=0.92)
if options["save"]:
fig.savefig(
os.path.join(
proj.getImageDataPath(),
"timeData_{}_{}".format(start.strftime("%Y-%m-%d_%H-%M-%S_"),
end.strftime("%Y-%m-%d_%H-%M-%S"))))
if options["show"]:
plt.show()
plt.close("all")
return fig
#calibrate from calibrator import Calibrator calib = Calibrator() calib.CalibrateData()
'param':resultMoment['Parameter'],
'paramStd':resultMoment['Parameter_Std'],
'scatterUncert':[resultMoment['Max95%Scatter_Uncertainty'][0]],
'meanUncert':[resultMoment['Max95%Mean_Uncertainty'][0]]})
else:
# NOTE: SG Calibration
workingDirectory=r'C:\Users\Richard\Google Drive\Berkeley\Berkeley Classes\Fall 2018\ME 103\Lab 4-5\ME103\10.26.2018'
settings={'dir': workingDirectory,
'x': 'Ch1_Fz', 'y': 'Weight',
'xUnit': '[volts]', 'yUnit': '[Newton]',
'xUncert': 0.0, 'yUncert': weightUncert,
'target_file': 'strain_gauge_cal.csv', 'auto': True,
'eqn': 'p1'}
customEquation=None
botSG=Calibrator(**settings)
botSG.read_data()
discrete_fit_data_SG=decorator(botSG, botSG.discrete_fit_data, h=lambda y: -y/1000*9.81)
resultSG=discrete_fit_data_SG(customEquation)
SGData=[
['Parameter', 'Parameter_Std', 'R2', 'Max95%Scatter_Uncertainty', 'Max95%Mean_Uncertainty'],
[resultSG['param'][0], resultSG['paramStd'][0], resultSG['R2'], max(resultSG['scatterUncert']), max(resultSG['meanUncert'])],
[resultSG['param'][1], resultSG['paramStd'][1], '', '', '']
]
# NOTE: AOA Calibration
workingDirectory=r'C:\Users\Richard\Google Drive\Berkeley\Berkeley Classes\Fall 2018\ME 103\Lab 4-5\ME103\10.26.2018\Angle Attack Cali'
settings={'dir': workingDirectory,
'x': 'Ch4_a_control', 'y': 'Angle_of_Attack',
'xUnit': '[volts]', 'yUnit': '[degree]',
'xUncert': 0.0, 'yUncert': levelUncert,
def scan(self):
cmat, dist_ceofs, \
rmat, tmat, _ = Calibrator().calibration_data.load_calibrations()
def build_engine(max_batch_size, save_engine):
"""Takes an ONNX file and creates a TensorRT engine to run inference with"""
with trt.Builder(TRT_LOGGER) as builder, \
builder.create_network(1) as network,\
trt.OnnxParser(network, TRT_LOGGER) as parser:
# parse onnx model file
if not os.path.exists(onnx_file_path):
quit('ONNX file {} not found'.format(onnx_file_path))
print('Loading ONNX file from path {}...'.format(onnx_file_path))
with open(onnx_file_path, 'rb') as model:
print('Beginning ONNX file parsing')
parser.parse(model.read())
assert network.num_layers > 0, 'Failed to parse ONNX model. \
Please check if the ONNX model is compatible '
print('Completed parsing of ONNX file')
print('Building an engine from file {}; this may take a while...'.
format(onnx_file_path))
# build trt engine
builder.max_batch_size = max_batch_size
if not dynamic:
builder.max_workspace_size = 1 << 30 # 1GB
builder.fp16_mode = fp16_mode
if int8_mode:
builder.int8_mode = int8_mode
assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'
builder.int8_calibrator = Calibrator(
["input"], calibration_stream, calibration_table_path)
print('Int8 mode enabled')
engine = builder.build_cuda_engine(network)
else:
config = builder.create_builder_config()
config.max_workspace_size = 1 << 30 # 1GB
profile = builder.create_optimization_profile()
profile.set_shape(
network.get_input(0).name, (1, 3, 200, 200),
(1, 3, 608, 448), (1, 3, 1200, 1200))
# dynamic_engine fp16 set
if fp16_mode:
config.set_flag(trt.BuilderFlag.FP16)
# dynamic_engine int8 set
if int8_mode:
config.set_flag(trt.BuilderFlag.INT8)
assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'
# choose an calibration profile
# config.set_calibration_profile(profile)
config.int8_calibrator = Calibrator(["input"],
calibration_stream,
calibration_table_path)
print('Int8 mode enabled')
# choose an optimization profile
config.add_optimization_profile(profile)
engine = builder.build_engine(network, config)
# If errors happend when executing builder.build_cuda_engine(network),
# a None-Type object would be returned
if engine is None:
print('Failed to create the engine')
return None
print("Completed creating the engine")
if save_engine:
with open(engine_file_path, "wb") as f:
f.write(engine.serialize())
return engine
if __name__ == "__main__":
image_size = (image_width, image_height)
# imgLeft = downsample_image(cv2.imread("./input_images/aloeL.jpg"), 1)
# imgRight = downsample_image(cv2.imread("./input_images/aloeR.jpg"), 1)
imgLeft = downsample_image(cv2.imread("./input_images/left19.jpg"), 3)
imgRight = downsample_image(cv2.imread("./input_images/right19.jpg"), 3)
width_left, height_left = imgLeft.shape[:2]
width_right, height_right = imgRight.shape[:2]
if 0 in [width_left, height_left, width_right, height_right]:
print("Error: Can't remap image.")
calibrator = Calibrator(6, 9)
calibrator.load_parameters()
imgLeft = calibrator.undistort_image(imgLeft)
imgRight = calibrator.undistort_image(imgRight)
# cv2.imshow('Left CALIBRATED', imgLeft)
# cv2.imshow('Right CALIBRATED', imgRight)
#
# cv2.waitKey(0)
# Rectify both image
threshold = 0.65
imgLeft_r, imgRight_r = rectify_stereo_pair_uncalibrated(
imgLeft, imgRight, threshold)
stereo = SGBMTuner(imgLeft_r, imgRight_r)
def projectGetTime(proj, site, meas, **kwargs): # print project information proj.printInfo() # print site info proj.printSiteInfo(site) # print measurement info proj.printMeasInfo(site, meas) # get measurement sample frequency fs = proj.getMeasSampleFreq(site, meas) # get measurement start and end times datetimeStart = proj.getMeasStartTime(site, meas) datetimeEnd = proj.getMeasEndTime(site, meas) # get the measurement reader and chans reader = proj.getMeasDataReader(site, meas) chans = reader.getChannels() # set the default parameters decimation = [1] calibrate = False notch = [] detrend = True # apply options if "chans" in kwargs: chans = kwargs["chans"] if "start" in kwargs: datetimeStart = datetime.strptime(kwargs["start"], '%Y-%m-%d %H:%M:%S') if "stop" in kwargs: datetimeEnd = datetime.strptime(kwargs["stop"], '%Y-%m-%d %H:%M:%S') if "decimation" in kwargs: if type(kwargs["decimation"]) != type(list()): decimation = [kwargs["decimation"]] else: decimation = kwargs["decimation"] if "calibrate" in kwargs: calibrate = kwargs["calibrate"] if "detrend" in kwargs: calibrate = kwargs["detrend"] if "notch" in kwargs: notch = kwargs["notch"] # get correct data start and end times dataStartTime, dataEndTime = reader.getDataTimes(datetimeStart, datetimeEnd) # get data, sensor info, serial info, chopper info for calibration data = reader.getPhysicalData(chans, dataStartTime, dataEndTime) sensors = reader.getSensors(chans) serials = reader.getSerials(chans) choppers = reader.getChoppers(chans) if calibrate: cal = Calibrator(proj.getCalDataPath()) cal.printInfo() # calibrate data = cal.calibrate(data, fs, sensors, serials, choppers) # notch filter if required for n in notch: for c in data: data[c] = notchFilter(data[c], fs, n, n/5.0) # lists for saving the data timeData = [] timeX = [] specData = [] specX = [] sampleFreqs = [] # set fsDec fsDec = fs # now for each decimation, get data for d in decimation: # decimate data = downsampleTime(data, d, 51) fsDec = fsDec/d size = data[chans[0]].size # create spectrum calculator specCalc = SpectrumCalculator(fsDec, size) # now calculate the spectrum f, fData = specCalc.calcFourierCoeff(data) # save data if detrend: for c in list(data.keys()): data[c] = signal.detrend(data[c], type="linear") timeData.append(copy.deepcopy(data)) timeX.append([dataStartTime, dataEndTime]) specData.append(fData) specX.append(f) sampleFreqs.append(fsDec) return timeX, timeData, specX, specData
def build_engine(max_batch_size, save_engine):
"""Takes an ONNX file and creates a TensorRT engine to run inference with"""
# 1 << NetworkDefinitionCreationFlag.EXPLICIT_BATCH
with trt.Builder(TRT_LOGGER) as builder, \
builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) as network, \
trt.OnnxParser(network, TRT_LOGGER) as parser:
# parse onnx model file
if not os.path.exists(onnx_file_path):
quit('ONNX file {} not found'.format(onnx_file_path))
print('Loading ONNX file from path {}...'.format(onnx_file_path))
with open(onnx_file_path, 'rb') as model:
print('Beginning ONNX file parsing')
parser.parse(model.read())
# modify the orignal onnx network
count = 0
for i in range(network.num_layers):
net = network.get_layer(i)
if (net.type == trt.LayerType.CONVOLUTION
and 'Conv' in net.name):
count = count + 1
# network.mark_output(net.get_output(0))
f_layer.write('----1----network.num_layers:' +
str(network.num_layers) +
' .the number of the conv is:' +
str(count) + '\n')
f_layer.write(net.name + '\n')
f_layer.write(str(net.type) + '\n')
# network.unmark_output(net.get_output(0))
activate = network.add_activation(
input=net.get_output(0),
type=trt.ActivationType.CLIP) # return a layer
if (strategy == None):
print('strategy error!')
activate.beta = pow(2, strategy[count - 1] - 1) - 1
activate.alpha = -pow(2, strategy[count - 1] - 1)
activate.name = 'CLIP_%d' % i
f_layer.write(activate.name + ' beta is ' +
str(activate.beta) + ' and alpha is ' +
str(activate.alpha) + '\n')
# get the layer next to conv,and input the output of the activation layer.
net_next = network.get_layer(i + 1)
net_next.set_input(0, activate.get_output(0))
f_layer.write(net_next.name + '\n')
f_layer.write(str(net_next.type) + '\n')
net_next2 = network.get_layer(i + 2)
net_next2.set_input(0, net_next.get_output(0))
net_next2.set_input(1, activate.get_output(0))
f_layer.write(net_next2.name + '\n')
f_layer.write(str(net_next2.type) + '\n')
f_layer.write('----2----network.num_layers:' +
str(network.num_layers) + '\n')
assert network.num_layers > 0, 'Failed to parse ONNX model. \
Please check if the ONNX model is compatible '
print('Completed parsing of ONNX file')
print('Building an engine from file {}; this may take a while...'.
format(onnx_file_path))
# build trt engine
if int4_mode:
builder.max_batch_size = max_batch_size
builder.int8_mode = int4_mode
builder.max_workspace_size = 1 << 30 # 1GB
assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'
builder.int8_calibrator = Calibrator(calibration_stream,
calibration_table_path)
engine = builder.build_cuda_engine(network)
# config=builder.create_builder_config()
# config.max_workspace_size = 1 << 30 #
# config.flags = 1 << int(trt.BuilderFlag.INT8) #
# assert calibration_stream, 'Error: a calibration_stream should be provided for int8 mode'
# config.int8_calibrator = Calibrator(calibration_stream, calibration_table_path)
# engine = builder.build_engine(network, config)
print('Int4 mode enabled')
if fp16_mode:
builder.strict_type_constraints = True
builder.max_batch_size = max_batch_size
builder.max_workspace_size = 1 << 30 # 1GB
builder.fp16_mode = fp16_mode
engine = builder.build_cuda_engine(network)
print('fp16 modify mode enabled')
if fp32_mode:
builder.max_batch_size = max_batch_size
builder.max_workspace_size = 1 << 30 # 1GB
engine = builder.build_cuda_engine(network)
print('fp32 modify mode enabled')
if engine is None:
print('Failed to create the engine')
return None
print("Completed creating the engine")
if save_engine:
with open(engine_file_path, "wb") as f:
f.write(engine.serialize())
return engine
import cv2
import numpy as np
import time
import csv
from calibrator import Calibrator
from tracker import Tracker
from graph import Graph
cal = Calibrator()
eyes, lower, upper = cal.calibrate()
cap = cv2.VideoCapture(0)
prev_x = 0
prev_y = 0
data = []
while (True):
ret, frame = cap.read()
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2BGRA)
track = Tracker()
match = track.find_eyes(eyes, frame, lower, upper)
total_x = 0
total_y = 0
avg_x = 0
avg_y = 0
