def openMat(self, path, dat2p0):
try:
print(f'\nExtracting {os.path.basename(path)}...')
if os.path.exists(path):
mat = dt.loadmat(path,
variableName='mudp',
sort=True,
reBarrierMarge=False if dat2p0 else True,
dat2p0=dat2p0)
else:
print("Path does not exist: ", path)
if dat2p0:
if not len(mat['mudp']['vis']['vision_AEB_info']['visAEB']
['imageIndex']):
print('Mat corrupted!')
return
else:
if not len(mat['mudp']['vis']['vision_function_info']
['imageIndex']):
print('Mat corrupted!')
return
return mat
except:
print(f'Error while loading {os.path.basename(path)}!')
return
def openMat(parent, path):
is_dat2p0 = False
var_name = None
if parent.matLoadBox.isChecked():
var_name = 'mudp'
if parent.matLoadDAT2p0.isChecked():
is_dat2p0 = True
try:
mat = dt.loadmat(path,
variableName=var_name,
sort=True,
reBarrierMarge=False,
dat2p0=is_dat2p0,
dot_dict=False)
if not is_dat2p0:
objData = mat['mudp']['vis']['vision_obstacles_info']['visObs']
for key in objData.keys():
if key in ['tlet_match', 'tlet_match_conf']:
newData = objData[key]
tempData = {}
for j in range(15):
tempData[key + '_' +
str(j + 1).zfill(2)] = newData[:, j, :]
objData[key] = tempData
return mat
except:
traceback.print_exc()
QtWidgets.QMessageBox.warning(
parent, 'Error',
'Error while loading ' + path.split(os.sep)[-1] + '!')
return
def openData(self, data):
if data and isinstance(data, dict):
return data
elif data and os.path.isfile(data):
return loadmat(data,
variableName='mudp',
reBarrierMarge=True,
sort=True)
else:
print('Cannot open data file!')
return None
def ef_CMbBevents(self):
"""
EF6: CMbB events
:return: EF gives back dict structure with data len and data itself
"""
try:
from delphiTools3 import base
dvlExt = base.loadmat(self.mat['__path__'],
variableName='dvlExt')['dvlExt']
self.visIndex = self.get_closest(
self.mat['mudp']['vis']['header']['cTime'],
dvlExt['veh']['acc']['ctimeu'] * 1000000)
self.visLen = len(self.mat['mudp']['vis']['header']['cTime'])
except:
print('error, missing structures')
return {'len': 0, 'data': []}
CMBBEvents = {
'brk_accel': dvlExt['veh']['cmbb']['brk_accel'],
'fcw_aud_warn': dvlExt['veh']['cmbb']['fcw_aud_warn'],
'fcw_denied': dvlExt['veh']['cmbb']['fcw_denied'],
'brk_decel_req': dvlExt['veh']['cmbb']['brk_decel_req'],
'cmbb_denied': dvlExt['veh']['cmbb']['cmbb_denied'],
'cmbb_denied_brk': dvlExt['veh']['cmbb']['cmbb_denied_brk'],
'cmbb_denied_prpl': dvlExt['veh']['cmbb']['cmbb_denied_prpl'],
'brk_precharge': dvlExt['veh']['cmbb']['brk_precharge']
}
data = []
for key in CMBBEvents.keys():
indexes = []
datamatrix = CMBBEvents[key]
if (key in ('brk_accel', 'brk_precharge')):
index = (np.argwhere(abs(datamatrix) >= 0.1))
for each in index:
indexes += list(each)
if indexes:
data.append([
self.groupIndexes(indexes), 'CMBBevents',
key + ' change occured ', -1
])
else:
index = (np.argwhere(datamatrix == 1))
for each in index:
indexes += list(each)
if indexes:
data.append([
self.groupIndexes(indexes), 'CMBBevents',
key + ' occured ', -1
])
return {'len': len(data), 'data': data}
def __init__(self, mat_path, ffs_path=None):
self.logname = os.path.basename(mat_path[:-4])
self.mat = dtb.loadmat(mat_path, sort=True)
if not ffs_path:
ffs_path = mat_path[:-3] + 'ffs'
self.ffs_path = ffs_path
self.signals = {'ego_vel': self.mat['mudp']['vis']['vision_vehicle_info']['vehicleVelocity'],
'ttc_accel': self.mat['mudp']['vis']['vision_obstacles_info']['visObs']['ttc_const_accel'],
'ttc_vel': self.mat['mudp']['vis']['vision_obstacles_info']['visObs']['ttc_const_vel'],
'uniqueID': self.mat['mudp']['vis']['vision_obstacles_info']['visObs']['uniqueID'],
'class': self.mat['mudp']['vis']['vision_obstacles_info']['visObs']['obstacle_class']}
self.vis_func_info = self.mat['mudp']['vis']['vision_function_info']
self.flags = [key for key in self.vis_func_info.keys() if 'VRU' in key]
self.extra_info = {'ego_vel': self.mat['mudp']['vis']['vision_vehicle_info']['vehicleVelocity'],
'grab_idx': self.mat['mudp']['vis']['vision_function_info']['imageIndex']}
self.events = self.find_events()
self.out_df = self.get_vru_aeb_data() if self.events else None
def ef_dvlExt_template(self):
"""
EF4:
:return: EF gives back dict structure with data len and data itself
"""
try:
from delphiTools3 import base
dvlExt = base.loadmat(self.mat['__path__'],
variableName='dvlExt')['dvlExt']
except:
print('error')
return {'len': 0, 'data': []}
self.mat
### EF here
data = []
return {'len': len(data), 'data': data}
def main():
parser = argparse.ArgumentParser(
description=
"Read DIDs from a .mat file. Currently supported DIDs: DE00, DE04. Checked with INST-CAN versions: v05.16."
)
parser.add_argument('input', help='Input .mat file.')
parser.add_argument(
'-ch',
dest='channel',
default='all',
help=
'INST-CAN channel. Default value: "all" (the script checks all CAN channels searching for messages with required IDs).'
)
parser.add_argument(
'-lwc',
dest='lowercase',
action='store_true',
help='Print in lowercase (e.g. "f7 f2 0a ..." instead of "F7 F2 0A ..."'
)
args = parser.parse_args()
mat = dtb.loadmat(args.input)
reader = DIDReader(uppercase=(not args.lowercase))
reader.add_did(DidDe00())
reader.add_did(DidDe04())
channels_to_check = []
if args.channel == 'all':
print(
"WARNING: all CAN channels are being checked. Please note that the results might not be correct."
)
channels_to_check = get_CAN_channels(mat)
else:
try:
channels_to_check = [int(args.channel)]
except ValueError:
raise ValueError('channel must be an integer or "all"')
for channel in channels_to_check:
print("-" * 10)
print("Checking channel " + str(channel))
reader.read_dids(mat, channel)
def openMat(path, dat2p0):
try:
print('\nExtracting {}...'.format(os.path.basename(path)))
print(path)
mat = dt.loadmat(path,
variableName='mudp',
sort=True,
reBarrierMarge=False,
dat2p0=dat2p0)
if dat2p0:
if not (len(mat['mudp']['vis']['vision_traffic_sign_info']
['tsrInfo']['imageIndex'])):
print('Mat corrupted!')
return
else:
if not len(
mat['mudp']['vis']['vision_function_info']['imageIndex']):
print('Mat corrupted!')
return
return mat
except Exception as E:
print('Error while loading {}!'.format(os.path.basename(path)), '\n',
E)
return
self.sRelDec = self.signs['signRelevantDecision']
# self.changeConfidence()
# def changeConfidence(self):
# # For better visualisation if conf==0.99 assume it's 0.5
# self.sConf[self.sConf < 0.5,:] = 0
# self.sConf[0.5 <= self.sConf <= 0.99,:] = 0.5
for row in range(len(logsData)):
# for row in range(1):
log = logsData['matPath'].iloc[row]
beg = logsData['startEvent'].iloc[row]
end = logsData['endEvent'].iloc[row]
logName = logsData['matName'].iloc[row]
log = dtb.loadmat(log, sort=True, variableName='mudp')
data = SignData(log)
print(f"***** Processing: {logName} ****")
#rozmiar obrazka w calach = A4, rodzielczosc=100dpi
#plt.figure( figsize=(8.27, 11.69), dpi=100 )
plt.figure( figsize=(9, 9) )
#tytul wykresu, zkres wspolrzednych 0,0=bottom-left 1,1=top-right
plt.suptitle( logName+f':range [{beg}:{end}]', fontsize=10, ha='left', x=0.03, y=0.97)
colorsDict = {0: 'b', 1: 'g', 2: 'r', 3: 'c',4: 'm', 5: 'y', 6: 'k', 7: 'b'}
print(len(data.sType))
for i in range(8):
#kolumna i w tablicy sType
def fromFile(self, mat_file):
self.mat = dtb.loadmat(mat_file)
def appendDetails(self):
try:
from delphiTools3 import base
self.dvlExt = base.loadmat(self.mat['__path__'],
variableName='dvlExt')['dvlExt']
except:
print('error')
self.header += [
'duration[s]', 'time_gap', 'brake_accel', 'propulsion_accel',
'fcw_sens', 'brk_assist_sens'
]
self.tselIndex = self.get_closest(
self.mat['mudp']['vis']['header']['cTime'],
self.dvlExt['tsel']['sys']['ctimeu'] * 1000000)
self.dvlvisIndex = self.get_closest(
self.mat['mudp']['vis']['header']['cTime'],
self.dvlExt['vis']['sys']['ctimeu'] * 1000000)
self.appendHeader()
errorNameList = []
for eventsDict in self.eventsDictList:
index = int(
np.where(self.visIndex == eventsDict['eventIndex'])[0][0])
columnID = eventsDict['eventColumnID']
try:
eventsDict['duration[s]'] = round(
self.dvlExt['veh']['acc']['ctimeu'][
index + eventsDict['eventDuration'] - 1] -
self.dvlExt['veh']['acc']['ctimeu'][index], 3)
except:
errorNameList.append('duration[s]')
try:
eventsDict['time_gap'] = self.dvlExt['veh']['acc']['time_gap'][
index]
except:
errorNameList.append('time_gap')
try:
eventsDict['brake_accel'] = self.dvlExt['veh']['acc'][
'brake_accel'][index]
except:
errorNameList.append('brake_accel')
try:
eventsDict['propulsion_accel'] = self.dvlExt['veh']['acc'][
'propulsion_accel'][index]
except:
errorNameList.append('propulsion_accel')
try:
eventsDict['brk_assist_sens'] = self.dvlExt['veh']['cmbb'][
'brk_assist_sens'][index]
except:
errorNameList.append('brk_assist_sens')
try:
eventsDict['fcw_sens'] = self.dvlExt['veh']['cmbb'][
'fcw_sens'][index]
except:
errorNameList.append('fcw_sens')
if (eventsDict['eventFinderID'] == 'ACCevents'):
if 'pcas' in self.dvlExt['tsel'].keys(
) and 'pcav' in self.dvlExt['tsel'].keys():
self.TselRtvDetails(eventsDict, errorNameList)
else:
self.PedsDetails(eventsDict, errorNameList)
elif (eventsDict['eventFinderID'] == 'CMBBevents'):
self.TselPcasDetails(eventsDict, errorNameList)
self.dvlVisDetails(eventsDict, errorNameList)
return list(set(errorNameList))
def ef_ACCevents(self):
"""
EF4: ACC Events
:return: EF gives back dict structure with data len and data itself
"""
try:
from delphiTools3 import base
dvlExt = base.loadmat(self.mat['__path__'],
variableName='dvlExt')['dvlExt']
self.visIndex = self.get_closest(
self.mat['mudp']['vis']['header']['cTime'],
dvlExt['veh']['acc']['ctimeu'] * 1000000)
self.visLen = len(self.mat['mudp']['vis']['header']['cTime'])
except:
print('error, missing structures')
return {'len': 0, 'data': []}
ACCEvents = {
'stop_stat': dvlExt['veh']['acc']['stop_stat'],
'stop_mode': dvlExt['veh']['acc']['stop_mode'],
'follow_mode': dvlExt['veh']['acc']['follow_mode'],
'warning': dvlExt['veh']['acc']['warning'],
'brk_req': dvlExt['veh']['acc']['brk_req'],
'cc_stat': dvlExt['veh']['acc']['cc_stat']
}
data = []
for key in ACCEvents.keys():
indexes = []
datamatrix = ACCEvents[key]
if (key in ('stop_mode', 'warning')):
for i in (1, 2, 3, 4):
indexes = []
index = (np.argwhere(datamatrix == i))
for each in index:
indexes += list(each)
if indexes:
data.append([
self.groupIndexes(indexes), 'ACCevents',
key + ' occured ', -1
])
elif (key == 'cc_stat'):
index = (np.argwhere(np.diff(datamatrix) != 0))
for each in index:
indexes += list(each)
if indexes:
data.append([
self.groupIndexes(indexes), 'ACCevents',
key + ' change occured ', -1
])
else:
index = (np.argwhere(datamatrix == 1))
for each in index:
indexes += list(each)
if indexes:
data.append([
self.groupIndexes(indexes), 'ACCevents',
key + ' occured ', -1
])
return {'len': len(data), 'data': data}
# ----------------------------- PREDICTED PATH -------------------------
# mat_name = "KR6N086_FTP112_TC8_20180710_105309_002"
# in_path = r"Z:\JIRA\Crossing"
# mat_path = os.path.join(in_path, mat_name + '.mat')
# out_path = r"F:\ADAS-1901\figures"
# mat = dtb.loadmat(mat_path, sort=True)
# plot_in_predicted_path(mat, mat_path, out_path)
matlist = glob.glob(r"E:\EuNCAP_s414\NCAP_20180917\*mat")
output_dir = os.path.join(r'E:\EuNCAP_s414\NCAP_20180917', 'plots_ped')
if not os.path.exists(output_dir):
os.makedirs(output_dir)
for matfile in matlist:
# out_path = r"F:\ADAS-1901\figures"
# mat = dtb.loadmat(os.path.join(in_path, matfile + '.mat'), sort=True)
print('-------------------------------------------------')
print(f'Processing {matfile}')
# plot_signals(mat, matfile, out_path)
try:
mat = dtb.loadmat(matfile, sort=True)
confidence_plot(mat, matfile, output_dir)
# plot_in_predicted_path(mat, matfile, output_dir)
except Exception as err:
# print(err)
traceback.print_exc()
continue
# self.changeConfidence()
# def changeConfidence(self):
# # For better visualisation if conf==0.99 assume it's 0.5
# self.sConf[self.sConf < 0.5,:] = 0
# self.sConf[0.5 <= self.sConf <= 0.99,:] = 0.5
for row in range(len(logsData)):
# for row in range(1):
log1 = logsData['matPath1'].iloc[row]
log2 = logsData['matPath2'].iloc[row]
beg = logsData['startEvent'].iloc[row]
end = logsData['endEvent'].iloc[row]
logName = logsData['matName'].iloc[row]
log1 = dtb.loadmat(log1, sort=True, variableName='mudp')
log2 = dtb.loadmat(log2, sort=True, variableName='mudp')
data1 = SignData(log1)
data2 = SignData(log2)
print(f"***** Processing: {logName} ****")
#rozmiar obrazka w calach = A4, rodzielczosc=100dpi
#plt.figure( figsize=(8.27, 11.69), dpi=100 )
plt.figure(figsize=(9, 9))
#tytul wykresu, zkres wspolrzednych 0,0=bottom-left 1,1=top-right
plt.suptitle(logName)
for i in range(8):
#kolumna i w tablicy sType
sType1 = data1.sType[:, i]
sType2 = data2.sType[:, i]
if file.endswith(".mat"):
FileList.append(os.path.join(path, file))
return FileList
data_table = []
# mat_path = os.getcwd()
# lista plików *.mat w folderze
matList = getFiles(r".")
for item in tqdm(matList):
print(f"***** Processing: {item} ****")
# tu jest ładowany cały plik *.mat do zmiennej mat
try:
mat = loadmat(item)
except Exception as e:
# w razie wyjatku dodajemny nazwe pliku do data_table
data_table.append([item, e, None])
continue
# tu z elementu mat wybieramy właściwe wartosci
vdID = mat['mudp']['vis']['vision_active_light_sensor_info'][
'activeLightSensorInfo']['activeLightSpots']['vdID']
id = mat['mudp']['vis']['vision_obstacles_info']['visObjects']['visObs'][
'id']
for coordinates, val_vdID in np.ndenumerate(vdID):
if val_vdID != 0: # jesli wartość w macierzy vdID jest różna od zera
id_l = id[
coordinates[0]] # to znajdz w macierzy id odpowiadający wiersz
def appendDetails(self):
try:
from delphiTools3 import base
self.dvlExt = base.loadmat(self.mat['__path__'],
variableName='dvlExt')['dvlExt']
except:
print('error')
mapDayNight = {0: 'day', 1: 'dusk', 2: 'night'}
mapLaneConf = {240: 0, 150: 2, 105: 1}
car_id_list = [
'KQW3213', 'KQW3211', 'KQW3215', 'KQW3210', 'KQW6524', 'KQZ7442',
'KQZ7441', 'EU64FVF', '564W756', '517W750', '516W341', '565W051',
'565W081', '565W696', '565W697', '565W698', 'AH359H', 'AH555G',
'AG628D', 'GA62099', 'GA62048', 'A0H1C9', 'STELIAN'
]
self.header += [
'severity_level', 'carID', 'day/night', 'detected_vru',
'detected_veh', 'detected_obj', 'detected_signs',
'leftlaneMarkerConf2 duration', 'leftlaneMarkerConf3 duration',
'rightlaneMarkerConf2 duration', 'rightlaneMarkerConf3 duration',
'f_ambiguousLinePatternRight duration',
'f_ambiguousLinePatternLeft duration', 'roadPredictionLeft',
'roadPredictionRight', 'activeLightSpots', 'camera_dist_lwheel_mm',
'camera_dist_rwheel_mm', 'vcs_camera_height', 'vcs_camera_lat',
'vcs_camera_long', 'f_tunnelEntryOrExit duration',
'f_constructionArea duration', 'urban_area duration',
'leftWheel_mm', 'rightWheel_mm', 'amb_air_tempMax',
'amb_air_tempMin', 'villageDetected', 'imagerTemperatureMin',
'imagerTemperatureMax', 'mipsTemperatureMin', 'mipsTemperatureMax',
'vmpTemperatureMin', 'vmpTemperatureMax', 'ddrTemperatureMin',
'ddrTemperatureMax', 'imagerChipVersion', 'imagerFuseID',
'hardwareRevision', 'vehicle_type', 'vehicle_region',
'vehicle_country', 'horizonKA', 'yawKA', 'rollAngleKA',
'cameraAlignmentValidKA', 'drivingSideKA', 'currentMarketKA',
'tsrMarketKA', 'PercentRamUsage', 'autoFixOk', 'horizon', 'yaw',
'rollAngle', 'washerFrontcmd', 'wiperFrontCmd', 'wiperSpeedInfo'
]
errorNameList = []
for eventsDict in self.eventsDictList:
index = int(
np.where(self.visIndex == eventsDict['eventIndex'])[0][0])
columnID = eventsDict['eventColumnID']
try:
eventsDict['day/night'] = \
mapDayNight[int(round(np.mean(self.mat['mudp']['vis']['vision_ahbc_info']['ahbcAvailable'])))]
except:
errorNameList.append('day/night')
try:
eventsDict['severity_level'] = \
self.mat['mudp']['vis']['vision_failsafes'][eventsDict['eventComment']][index]
except:
errorNameList.append('severity_level')
try:
eventsDict['carID'] = \
[x for x in car_id_list if x in eventsDict['logName'].upper()][0]
except:
errorNameList.append('carID')
try:
eventsDict['detected_vru'] = \
self.object_counter(index, eventsDict['eventDuration'], 4,9)
except:
errorNameList.append('detected_vru')
try:
eventsDict['detected_veh'] = \
self.object_counter(index,eventsDict['eventDuration'],1,3)
except:
errorNameList.append('detected_veh')
try:
eventsDict['detected_obj'] = \
(self.mat['mudp']['vis']['vision_obstacles_info']['visObs']['detection_status']
[index:index + eventsDict['eventDuration']] == 1).sum()
except:
errorNameList.append('detected_obj')
try:
eventsDict['detected_signs'] = \
(self.mat['mudp']['vis']['vision_traffic_sign_info']['trafficSigns']['signStatus']
[index:index + eventsDict['eventDuration']] == 2).sum()
except:
errorNameList.append('detected_signs')
try:
eventsDict['leftlaneMarkerConf2 duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['hostLeftIndividualMarker'][
'laneMarkerConf']['confLKA'][index:index+eventsDict['eventDuration']] == 105).sum()
except:
errorNameList.append('leftlaneMarkerConf2 duration')
try:
eventsDict['rightlaneMarkerConf2 duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['hostRightIndividualMarker'][
'laneMarkerConf']['confLKA'][index:index+eventsDict['eventDuration']] == 105).sum()
except:
errorNameList.append('rightlaneMarkerConf2 duration')
try:
eventsDict['leftlaneMarkerConf3 duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['hostLeftIndividualMarker'][
'laneMarkerConf']['confLKA'][index:index+eventsDict['eventDuration']] == 150).sum()
except:
errorNameList.append('leftlaneMarkerConf3 duration')
try:
eventsDict['rightlaneMarkerConf3 duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['hostRightIndividualMarker'][
'laneMarkerConf']['confLKA'][index:index+eventsDict['eventDuration']] == 150).sum()
except:
errorNameList.append('rightlaneMarkerConf3 duration')
try:
eventsDict['f_ambiguousLinePatternLeft duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['f_ambiguousLinePatternLeft'][
index:index+eventsDict['eventDuration']] == 1).sum()
except:
errorNameList.append('f_ambiguousLinePatternLeft duration')
try:
eventsDict['f_ambiguousLinePatternRight duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['f_ambiguousLinePatternRight'][
index:index+eventsDict['eventDuration']] == 1).sum()
except:
errorNameList.append('f_ambiguousLinePatternRight duration')
try:
eventsDict['roadPredictionLeft'] = \
dict(collections.Counter(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['roadPredictionLeft'][
index:index+eventsDict['eventDuration']]))
except:
errorNameList.append('roadPredictionLeft')
try:
eventsDict['roadPredictionRight'] = \
dict(collections.Counter(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['roadPredictionRight'][
index:index+eventsDict['eventDuration']]))
except:
errorNameList.append('roadPredictionRight')
try:
eventsDict['activeLightSpots'] = \
(np.unique(self.mat['mudp']['vis']['vision_active_light_sensor_info']['activeLightSpots']['id']
[index:index+eventsDict['eventDuration']]) > 0).sum()
except:
errorNameList.append('activeLightSpots')
try:
eventsDict['camera_dist_lwheel_mm'] = \
self.mat['mudp']['vfpState']['cals']['corse_sensor_cals']['camera_mounting']['camera_dist_lwheel_mm'][index]
except:
errorNameList.append('camera_dist_lwheel_mm')
try:
eventsDict['camera_dist_rwheel_mm'] = \
self.mat['mudp']['vfpState']['cals']['corse_sensor_cals']['camera_mounting']['camera_dist_rwheel_mm'][index]
except:
errorNameList.append('camera_dist_rwheel_mm')
try:
eventsDict['vcs_camera_height'] = \
self.mat['mudp']['vfpState']['cals']['corse_sensor_cals']['camera_mounting']['vcs_camera_height'][index]
except:
errorNameList.append('vcs_camera_height')
try:
eventsDict['vcs_camera_lat'] = \
self.mat['mudp']['vfpState']['cals']['corse_sensor_cals']['camera_mounting']['vcs_camera_lat'][index]
except:
errorNameList.append('vcs_camera_lat')
try:
eventsDict['vcs_camera_long'] = \
self.mat['mudp']['vfpState']['cals']['corse_sensor_cals']['camera_mounting']['vcs_camera_long'][index]
except:
errorNameList.append('vcs_camera_long')
try:
eventsDict['f_tunnelEntryOrExit duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['f_tunnelEntryOrExit']
[index:index + eventsDict['eventDuration']] != 0).sum()
except:
errorNameList.append('f_tunnelEntryOrExit duration')
try:
eventsDict['f_constructionArea duration'] = \
(self.mat['mudp']['vis']['vision_road_info']['roadMarkerInfo']['f_constructionArea']
[index:index + eventsDict['eventDuration']] != 0).sum()
except:
errorNameList.append('f_constructionArea duration')
try:
eventsDict['urban_area duration'] = \
(self.dvlExt['vis']['ahbc']['urban_area'][index:index + eventsDict['eventDuration']] != 0).sum()
except:
errorNameList.append('urban_area duration')
try:
eventsDict['leftWheel_mm'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['vehDependentParam']['leftWheel_mm'][index]
except:
errorNameList.append('leftWheel_mm')
try:
eventsDict['rightWheel_mm'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['vehDependentParam']['rightWheel_mm'][index]
except:
errorNameList.append('rightWheel_mm')
try:
eventsDict['amb_air_tempMax'] = \
max(self.dvlExt['veh']['ahbc']['amb_air_temp'])
except:
errorNameList.append('amb_air_tempMax')
try:
eventsDict['amb_air_tempMin'] = \
min(self.dvlExt['veh']['ahbc']['amb_air_temp'])
except:
errorNameList.append('amb_air_tempMin')
try:
eventsDict['villageDetected'] = \
self.mat['mudp']['vis']['vision_active_light_sensor_info']['villageDetected'][index]
except:
errorNameList.append('villageDetected')
try:
eventsDict['imagerTemperatureMin'] = \
min(self.mat['mudp']['vfpDiag']['vision_temperature_info']['imagerTemperature'])
except:
errorNameList.append('imagerTemperatureMin')
try:
eventsDict['mipsTemperatureMin'] = \
min(self.mat['mudp']['vfpDiag']['vision_temperature_info']['mipsTemperature'])
except:
errorNameList.append('mipsTemperatureMin')
try:
eventsDict['vmpTemperatureMin'] = \
min(self.mat['mudp']['vfpDiag']['vision_temperature_info']['vmpTemperature'])
except:
errorNameList.append('vmpTemperatureMin')
try:
eventsDict['ddrTemperatureMin'] = \
min(self.mat['mudp']['vfpDiag']['vision_temperature_info']['ddrTemperature'])
except:
errorNameList.append('ddrTemperatureMin')
try:
eventsDict['imagerTemperatureMax'] = \
max(self.mat['mudp']['vfpDiag']['vision_temperature_info']['imagerTemperature'])
except:
errorNameList.append('imagerTemperatureMax')
try:
eventsDict['mipsTemperatureMax'] = \
max(self.mat['mudp']['vfpDiag']['vision_temperature_info']['mipsTemperature'])
except:
errorNameList.append('mipsTemperatureMax')
try:
eventsDict['vmpTemperatureMax'] = \
max(self.mat['mudp']['vfpDiag']['vision_temperature_info']['vmpTemperature'])
except:
errorNameList.append('vmpTemperatureMax')
try:
eventsDict['ddrTemperatureMax'] = \
max(self.mat['mudp']['vfpDiag']['vision_temperature_info']['ddrTemperature'])
except:
errorNameList.append('ddrTemperaturMaxe')
try:
eventsDict['imagerChipVersion'] = \
max(self.mat['mudp']['vfpDiag']['vision_app_init_info']['imagerChipVersion'])
except:
errorNameList.append('imagerChipVersion')
try:
eventsDict['imagerFuseID'] = \
self.mat['mudp']['vfpDiag']['vision_app_init_info']['imagerFuseID'][round(index/9)]
except:
errorNameList.append('imagerFuseID')
try:
eventsDict['hardwareRevision'] = \
self.mat['mudp']['vfpDiag']['vision_app_init_info']['hardwareRevision'][round(index/9)]
except:
errorNameList.append('hardwareRevision')
try:
eventsDict['vehicle_type'] = \
self.mat['mudp']['vfpState']['cals']['delphi_sw_params']['vehicle_type'][index]
except:
errorNameList.append('vehicle_type')
try:
eventsDict['vehicle_region'] = \
self.mat['mudp']['vfpState']['cals']['delphi_sw_params']['vehicle_region'][index]
except:
errorNameList.append('vehicle_region')
try:
eventsDict['vehicle_country'] = \
self.mat['mudp']['vfpState']['cals']['delphi_sw_params']['vehicle_country'][index]
except:
errorNameList.append('vehicle_country')
try:
eventsDict['horizonKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam']['horizonKA'][index]
except:
errorNameList.append('horizonKA')
try:
eventsDict['yawKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam']['yawKA'][index]
except:
errorNameList.append('yawKA')
try:
eventsDict['rollAngleKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam']['rollAngleKA'][index]
except:
errorNameList.append('rollAngleKA')
try:
eventsDict['cameraAlignmentValidKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam'][
'cameraAlignmentValidKA'][index]
except:
errorNameList.append('cameraAlignmentValidKA')
try:
eventsDict['drivingSideKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam']['drivingSideKA'][index]
except:
errorNameList.append('drivingSideKA')
try:
eventsDict['currentMarketKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam']['currentMarketKA'][index]
except:
errorNameList.append('currentMarketKA')
try:
eventsDict['tsrMarketKA'] = \
self.mat['mudp']['vfpState']['cals']['vision_params']['driveCycleParam']['tsrMarketKA'][index]
except:
errorNameList.append('tsrMarketKA')
try:
eventsDict['PercentRamUsage'] = \
max(self.mat['mudp']['vfpDiag']['PercentRamUsage'])
except:
errorNameList.append('PercentRamUsage')
try:
eventsDict['autoFixOk'] = \
self.mat['mudp']['vis']['vision_camera_alignment_info']['autoFixOk'][index]
except:
errorNameList.append('autoFixOk')
try:
eventsDict['horizon'] = \
self.mat['mudp']['vis']['vision_camera_alignment_info']['cameraAlignment']['horizon'][index]
except:
errorNameList.append('horizon')
try:
eventsDict['yaw'] = \
self.mat['mudp']['vis']['vision_camera_alignment_info']['cameraAlignment']['yaw'][index]
except:
errorNameList.append('yaw')
try:
eventsDict['rollAngle'] = \
self.mat['mudp']['vis']['vision_camera_alignment_info']['cameraAlignment']['rollAngle'][index]
except:
errorNameList.append('rollAngle')
try:
eventsDict['washerFrontcmd'] = \
round((self.mat['mudp']['vfpState']['cmd_msg']['veh_state_info']['washerFrontcmd']
[round(index*3.7):round((index + eventsDict['eventDuration'])*3.7)] > 0).sum()/3.6)
except:
errorNameList.append('washerFrontcmd')
try:
eventsDict['wiperFrontCmd'] = \
round((self.mat['mudp']['vfpState']['cmd_msg']['veh_state_info']['wiperFrontCmd']
[round(index*3.6):round((index + eventsDict['eventDuration'])*3.6)] > 0).sum()/3.6)
except:
errorNameList.append('wiperFrontCmd')
try:
eventsDict['wiperSpeedInfo'] = \
round((self.mat['mudp']['vfpState']['cmd_msg']['veh_state_info']['wiperSpeedInfo']
[round(index*3.7):round((index + eventsDict['eventDuration'])*3.6)] > 0).sum()/3.6)
except:
errorNameList.append('rollAngle')
return list(set(errorNameList))