def test_cut_arrays(self):
print("MDF cut big array files")
for input_file in Path(TestMDF.tempdir_array.name).iterdir():
for whence in (0, 1):
print(input_file, whence)
outfile1 = MDF(input_file)
outfile1.configure(read_fragment_size=8000)
outfile1 = outfile1.cut(
stop=105.5, whence=whence, include_ends=False).save(
Path(TestMDF.tempdir.name) / "tmp1", overwrite=True)
outfile2 = MDF(input_file)
outfile2.configure(read_fragment_size=8000)
outfile2 = outfile2.cut(start=105.5,
stop=201.5,
whence=whence,
include_ends=False).save(
Path(TestMDF.tempdir.name) /
"tmp2",
overwrite=True)
outfile3 = MDF(input_file)
outfile3.configure(read_fragment_size=8000)
outfile3 = outfile3.cut(
start=201.5, whence=whence, include_ends=False).save(
Path(TestMDF.tempdir.name) / "tmp3", overwrite=True)
outfile = MDF.concatenate(
[outfile1, outfile2, outfile3],
MDF(input_file).version).save(Path(TestMDF.tempdir.name) /
"tmp_cut",
overwrite=True)
equal = True
with MDF(outfile) as mdf:
mdf.configure(read_fragment_size=8000)
for i, group in enumerate(mdf.groups):
if i == 0:
samples = [
np.ones((cycles, 2, 3), dtype=np.uint64),
np.ones((cycles, 2), dtype=np.uint64),
np.ones((cycles, 3), dtype=np.uint64),
]
for j in range(1, 20):
types = [
("Channel_{}".format(j), "(2, 3)<u8"),
("channel_{}_axis_1".format(j),
"(2, )<u8"),
("channel_{}_axis_2".format(j),
"(3, )<u8"),
]
types = np.dtype(types)
vals = mdf.get(
"Channel_{}".format(j),
group=i,
samples_only=True,
)[0]
target = [arr * j for arr in samples]
target = np.core.records.fromarrays(
target, dtype=types)
if not np.array_equal(vals, target):
equal = False
print(
i,
j,
len(target),
len(vals),
vals,
target,
sep="\n\n",
)
1 / 0
elif i == 1:
samples = np.ones((cycles, 2, 3), dtype=np.uint64)
axis_0 = np.ones((cycles, 2), dtype=np.uint64)
axis_1 = np.ones((cycles, 3), dtype=np.uint64)
for j in range(1, 20):
types = [("Channel_{}".format(j), "(2, 3)<u8")]
types = np.dtype(types)
vals = mdf.get(
"Channel_{}".format(j),
group=i,
samples_only=True,
)[0]
target = [samples * j]
target = np.core.records.fromarrays(
target, dtype=types)
if not np.array_equal(vals, target):
equal = False
1 / 0
elif i == 2:
samples = [
np.ones(cycles, dtype=np.uint8),
np.ones(cycles, dtype=np.uint16),
np.ones(cycles, dtype=np.uint32),
np.ones(cycles, dtype=np.uint64),
np.ones(cycles, dtype=np.int8),
np.ones(cycles, dtype=np.int16),
np.ones(cycles, dtype=np.int32),
np.ones(cycles, dtype=np.int64),
]
for j in range(1, 20):
types = [
("struct_{}_channel_0".format(j),
np.uint8),
("struct_{}_channel_1".format(j),
np.uint16),
("struct_{}_channel_2".format(j),
np.uint32),
("struct_{}_channel_3".format(j),
np.uint64),
("struct_{}_channel_4".format(j), np.int8),
("struct_{}_channel_5".format(j),
np.int16),
("struct_{}_channel_6".format(j),
np.int32),
("struct_{}_channel_7".format(j),
np.int64),
]
types = np.dtype(types)
vals = mdf.get(
"Channel_{}".format(j),
group=i,
samples_only=True,
)[0]
target = [arr * j for arr in samples]
target = np.core.records.fromarrays(
target, dtype=types)
if not np.array_equal(vals, target):
equal = False
1 / 0
self.assertTrue(equal)
def open_mdf3():
os.chdir(path)
with Timer('asammdf {} mdfv3'.format(asammdf_version)):
x = MDF(r'test.mdf')
from asammdf import MDF, Signal
import numpy as np
cycles = 100
sigs = []
mdf = MDF()
t = np.arange(cycles, dtype=np.float64)
# no conversion
sig = Signal(
np.ones(cycles, dtype=np.uint64),
t,
name="Channel_no_conversion",
unit="s",
conversion=None,
comment="Unsigned 64 bit channel {}",
)
sigs.append(sig)
# linear
conversion = {
"a": 2,
"b": -0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name="Channel_linear_conversion",
unit="Nm",
def convert_v3_v4():
os.chdir(path)
with MDF(r'test.mdf') as x:
with Timer('asammdf {} v3 to v4'.format(asammdf_version)):
y = x.convert('4.10')
def convert_v4_v3():
os.chdir(path)
with MDF(r'test.mf4') as x:
with Timer('asammdf {} v4 to v3'.format(asammdf_version)):
y = x.convert('3.30')
y.close()
def test_cut(self):
print("MDF cut big files tests")
t = np.arange(cycles, dtype=np.float64)
for mdfname in os.listdir('tmpdir'):
for memory in MEMORY:
input_file = os.path.join('tmpdir', mdfname)
for whence in (0, 1):
print(input_file, memory)
outfile0 = MDF(input_file, memory=memory)
outfile0.configure(read_fragment_size=8000)
outfile0 = outfile0.cut(stop=-1,
whence=whence).save('tmp0',
overwrite=True)
outfile1 = MDF(input_file, memory=memory)
outfile1.configure(read_fragment_size=8000)
outfile1 = outfile1.cut(stop=105,
whence=whence).save('tmp1',
overwrite=True)
outfile2 = MDF(input_file, memory=memory)
outfile2.configure(read_fragment_size=8000)
outfile2 = outfile2.cut(start=105.1,
stop=201,
whence=whence).save('tmp2',
overwrite=True)
outfile3 = MDF(input_file, memory=memory)
outfile3.configure(read_fragment_size=8000)
outfile3 = outfile3.cut(start=201.1,
whence=whence).save('tmp3',
overwrite=True)
outfile4 = MDF(input_file, memory=memory)
outfile4.configure(read_fragment_size=8000)
outfile4 = outfile4.cut(start=7000,
whence=whence).save('tmp4',
overwrite=True)
outfile = MDF.merge(
[outfile0, outfile1, outfile2, outfile3, outfile4],
MDF(input_file, memory='minimum').version,
memory=memory,
).save('tmp_cut', overwrite=True)
with MDF(outfile) as mdf:
for i, group in enumerate(mdf.groups):
if i == 0:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
cond = np.array_equal(vals, v * (j - 1))
if not cond:
print(i, j, vals, v * (j - 1),
len(vals), len(v))
self.assertTrue(cond)
elif i == 1:
v = np.ones(cycles, dtype=np.int64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
cond = np.array_equal(
vals,
v * (j - 1) - 0.5)
if not cond:
print(vals,
v * (j - 1) - 0.5, len(vals),
len(v))
self.assertTrue(cond)
elif i == 2:
v = np.arange(cycles, dtype=np.int64) / 100.0
form = '{} * sin(v)'
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
f = form.format(j - 1)
cond = np.array_equal(
vals, numexpr.evaluate(f))
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 3:
v = np.ones(cycles, dtype=np.int64)
form = '({} * v -0.5) / 1'
for j in range(1, 20):
f = form.format(j - 1)
vals = mdf.get(group=i,
index=j,
samples_only=True)
cond = np.array_equal(
vals, numexpr.evaluate(f))
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 4:
for j in range(1, 20):
target = np.array([
'Channel {} sample {}'.format(
j, k).encode('ascii')
for k in range(cycles)
])
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 5:
v = np.ones(cycles, dtype=np.dtype('(8,)u1'))
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 6:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
cleanup_files()
def open_mdf4_nodata():
os.chdir(path)
with Timer('asammdf {} nodata mdfv4'.format(asammdf_version)):
x = MDF(r'test.mf4', load_measured_data=False)
def open_mdf4(output, fmt):
with Timer('Open file', f'asammdf {asammdf_version} mdfv4', fmt) as timer:
MDF(r'test.mf4')
output.send([timer.output, timer.error])
def save_mdf4(output, fmt):
x = MDF(r'test.mf4')
with Timer('Save file', f'asammdf {asammdf_version} mdfv4', fmt) as timer:
x.save(r'x.mf4', overwrite=True)
output.send([timer.output, timer.error])
def main(text_output, fmt):
if os.path.dirname(__file__):
os.chdir(os.path.dirname(__file__))
for version in ('3.30', '4.10'):
generate_test_files(version)
mdf = MDF('test.mdf', 'minimum')
v3_size = os.path.getsize('test.mdf') // 1024 // 1024
v3_groups = len(mdf.groups)
v3_channels = sum(len(gp['channels']) for gp in mdf.groups)
v3_version = mdf.version
mdf = MDF('test.mf4', 'minimum')
v4_size = os.path.getsize('test.mf4') // 1024 // 1024
v4_groups = len(mdf.groups)
v4_channels = sum(len(gp['channels']) for gp in mdf.groups)
v4_version = mdf.version
listen, send = multiprocessing.Pipe()
output = MyList()
errors = []
installed_ram = round(psutil.virtual_memory().total / 1024 / 1024 / 1024)
output.append('\n\nBenchmark environment\n')
output.append('* {}'.format(sys.version))
output.append('* {}'.format(platform.platform()))
output.append('* {}'.format(platform.processor()))
output.append('* numpy {}'.format(np.__version__))
output.append('* {}GB installed RAM\n'.format(installed_ram))
output.append('Notations used in the results\n')
output.append(('* compress = mdfreader mdf object created with '
'compression=blosc'))
output.append(('* nodata = mdfreader mdf object read with '
'no_data_loading=True'))
output.append('\nFiles used for benchmark:\n')
output.append('* mdf version {}'.format(v3_version))
output.append(' * {} MB file size'.format(v3_size))
output.append(' * {} groups'.format(v3_groups))
output.append(' * {} channels'.format(v3_channels))
output.append('* mdf version {}'.format(v4_version))
output.append(' * {} MB file size'.format(v4_size))
output.append(' * {} groups'.format(v4_groups))
output.append(' * {} channels\n\n'.format(v4_channels))
OPEN, SAVE, GET, CONVERT, MERGE, FILTER, CUT = 1, 0, 0, 0, 0, 0, 0
tests = (
# open_mdf3,
# open_reader3,
# open_reader3_compression,
# open_reader3_nodata,
open_mdf4,
# open_reader4,
# open_reader4_compression,
open_reader4_nodata,
)
if tests and OPEN:
output.extend(table_header('Open file', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
save_mdf3,
save_reader3,
save_reader3_nodata,
save_reader3_compression,
save_mdf4,
save_reader4,
save_reader4_nodata,
save_reader4_compression,
)
if tests and SAVE:
output.extend(table_header('Save file', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
get_all_mdf3,
get_all_reader3,
get_all_reader3_nodata,
get_all_reader3_compression,
get_all_mdf4,
get_all_reader4,
get_all_reader4_compression,
get_all_reader4_nodata,
)
if tests and GET:
output.extend(table_header('Get all channels (36424 calls)', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
convert_v3_v4,
convert_v4_v3,
)
if tests and CONVERT:
output.extend(table_header('Convert file', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
merge_v3,
merge_reader_v3,
merge_reader_v3_compress,
merge_reader_v3_nodata,
merge_v4,
merge_reader_v4,
merge_reader_v4_nodata,
merge_reader_v4_compress,
)
if tests and MERGE:
output.extend(table_header('Merge 3 files', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
filter_asam,
filter_reader4,
filter_reader4_compression,
filter_reader4_nodata,
)
if tests and FILTER:
output.extend(table_header('Filter 200 channels', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
cut_asam,
cut_reader4,
cut_reader4_compression,
cut_reader4_nodata,
)
if tests and CUT:
output.extend(table_header('Cut file from 20% to 80%', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
errors = [err for err in errors if err]
if errors:
print('\n\nERRORS\n', '\n'.join(errors))
if text_output:
arch = 'x86' if platform.architecture()[0] == '32bit' else 'x64'
file = '{}_asammdf_{}_mdfreader_{}.{}'.format(arch, asammdf_version,
mdfreader_version, fmt)
with open(file, 'w') as out:
out.write('\n'.join(output))
for file in ('x.mdf', 'x.mf4'):
if PYVERSION >= 3:
try:
os.remove(file)
except FileNotFoundError:
pass
else:
try:
os.remove(file)
except IOError:
pass
return graph_
#def read_df():
dfs = {}
for datFile in datFiles:
baseName = os.path.basename(datFile)[:-4]
KS_filename = baseName + '_KS.xlsx'
KS_filepath = os.path.join(folderPath, KS_filename)
xlsx_KS_file = pd.ExcelFile(KS_filepath)
df_KS = xlsx_KS_file.parse('Sheet1')
df_KS.drop(([0]),axis=0,inplace=True)
sl_no = list(range(1,12))
df_KS['sl_no'] = sl_no
df_KS.set_index(df_KS['sl_no'])
mdf = MDF(datFile)
allSignals = list(mdf.channels_db.keys())
measuredSignals = []
#remove signals with CPP in it
for signal in allSignals:
if not(("CCP" in signal) or ("_sword" in signal) or "$" in signal):
measuredSignals.append(signal)
#creating an empty list of important signals
impSignals = ['cps_n_engine', 'egr_b_operate_valve',
'egr_T_exhaust_temperature', 'egr_T_oil_temperature',
'egr_T_limiting_temp_low', 'egr_T_limiting_temp_high',
'egr_P_exhaustp','egr_P_intakep_min','egr_P_intakep']
df = mdf.to_dataframe(
channels=impSignals,
raster= 'egr_b_operate_valve',
time_from_zero=True,
def generate_test_file(tmpdir, version="4.10"):
mdf = MDF(version=version)
if version <= "3.30":
filename = Path(tmpdir) / f"big_test_{version}.mdf"
else:
filename = Path(tmpdir) / f"big_test_{version}.mf4"
if filename.exists():
return filename
t = np.arange(cycles, dtype=np.float64)
cls = v4b.ChannelConversion if version >= "4.00" else v3b.ChannelConversion
# no conversion
sigs = []
for i in range(channels_count):
sig = Signal(
np.ones(cycles, dtype=np.uint64) * i,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Unsigned int 16bit channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# linear
sigs = []
for i in range(channels_count):
conversion = {
"conversion_type": v4c.CONVERSION_TYPE_LIN
if version >= "4.00"
else v3c.CONVERSION_TYPE_LINEAR,
"a": float(i),
"b": -0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=cls(**conversion),
comment="Signed 16bit channel {} with linear conversion".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# algebraic
sigs = []
for i in range(channels_count):
conversion = {
"conversion_type": v4c.CONVERSION_TYPE_ALG
if version >= "4.00"
else v3c.CONVERSION_TYPE_FORMULA,
"formula": "{} * sin(X)".format(i),
}
sig = Signal(
np.arange(cycles, dtype=np.int32) / 100.0,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=cls(**conversion),
comment="Sinus channel {} with algebraic conversion".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# rational
sigs = []
for i in range(channels_count):
conversion = {
"conversion_type": v4c.CONVERSION_TYPE_RAT
if version >= "4.00"
else v3c.CONVERSION_TYPE_RAT,
"P1": 0,
"P2": i,
"P3": -0.5,
"P4": 0,
"P5": 0,
"P6": 1,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=cls(**conversion),
comment="Channel {} with rational conversion".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# string
sigs = []
encoding = "latin-1" if version < "4.00" else "utf-8"
for i in range(channels_count):
sig = [
"Channel {} sample {}".format(i, j).encode(encoding) for j in range(cycles)
]
sig = Signal(
np.array(sig),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
comment="String channel {}".format(i),
raw=True,
encoding=encoding,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# byte array
sigs = []
ones = np.ones(cycles, dtype=np.dtype("(8,)u1"))
for i in range(channels_count):
sig = Signal(
ones * i,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
comment="Byte array channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# value to text
sigs = []
ones = np.ones(cycles, dtype=np.uint64)
conversion = {
"raw": np.arange(255, dtype=np.float64),
"phys": np.array(["Value {}".format(i).encode("ascii") for i in range(255)]),
"conversion_type": v4c.CONVERSION_TYPE_TABX
if version >= "4.00"
else v3c.CONVERSION_TYPE_TABX,
"links_nr": 260,
"ref_param_nr": 255,
}
for i in range(255):
conversion["val_{}".format(i)] = conversion[
"param_val_{}".format(i)
] = conversion["raw"][i]
conversion["text_{}".format(i)] = conversion["phys"][i]
conversion["text_{}".format(255)] = "Default"
for i in range(channels_count):
sig = Signal(
ones * i,
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
comment="Value to text channel {}".format(i),
conversion=cls(**conversion),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
name = mdf.save(filename, overwrite=True)
mdf.close()
def generate_arrays_test_file(tmpdir):
version = "4.10"
mdf = MDF(version=version)
filename = Path(tmpdir) / f"arrays_test_{version}.mf4"
if filename.exists():
return filename
t = np.arange(cycles, dtype=np.float64)
# lookup tabel with axis
sigs = []
for i in range(array_channels_count):
samples = [
np.ones((cycles, 2, 3), dtype=np.uint64) * i,
np.ones((cycles, 2), dtype=np.uint64) * i,
np.ones((cycles, 3), dtype=np.uint64) * i,
]
types = [
("Channel_{}".format(i), "(2, 3)<u8"),
("channel_{}_axis_1".format(i), "(2, )<u8"),
("channel_{}_axis_2".format(i), "(3, )<u8"),
]
sig = Signal(
np.core.records.fromarrays(samples, dtype=np.dtype(types)),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Array channel {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# lookup tabel with default axis
sigs = []
for i in range(array_channels_count):
samples = [np.ones((cycles, 2, 3), dtype=np.uint64) * i]
types = [("Channel_{}".format(i), "(2, 3)<u8")]
sig = Signal(
np.core.records.fromarrays(samples, dtype=np.dtype(types)),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Array channel {} with default axis".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# structure channel composition
sigs = []
for i in range(array_channels_count):
samples = [
np.ones(cycles, dtype=np.uint8) * i,
np.ones(cycles, dtype=np.uint16) * i,
np.ones(cycles, dtype=np.uint32) * i,
np.ones(cycles, dtype=np.uint64) * i,
np.ones(cycles, dtype=np.int8) * i,
np.ones(cycles, dtype=np.int16) * i,
np.ones(cycles, dtype=np.int32) * i,
np.ones(cycles, dtype=np.int64) * i,
]
types = [
("struct_{}_channel_0".format(i), np.uint8),
("struct_{}_channel_1".format(i), np.uint16),
("struct_{}_channel_2".format(i), np.uint32),
("struct_{}_channel_3".format(i), np.uint64),
("struct_{}_channel_4".format(i), np.int8),
("struct_{}_channel_5".format(i), np.int16),
("struct_{}_channel_6".format(i), np.int32),
("struct_{}_channel_7".format(i), np.int64),
]
sig = Signal(
np.core.records.fromarrays(samples, dtype=np.dtype(types)),
t,
name="Channel_{}".format(i),
unit="unit_{}".format(i),
conversion=None,
comment="Structure channel composition {}".format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
name = mdf.save(filename, overwrite=True)
mdf.close()
def test_read(self):
print("MDF read big files")
for input_file in Path(TestMDF.tempdir_general.name).iterdir():
print(input_file)
equal = True
for inp in (input_file, BytesIO(input_file.read_bytes())):
with MDF(inp) as mdf:
for i, group in enumerate(mdf.groups):
if i == 0:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)[0]
if not np.array_equal(vals, v * (j - 1)):
equal = False
elif i == 1:
v = np.ones(cycles, dtype=np.int64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)[0]
if not np.array_equal(vals, v * (j - 1) - 0.5):
equal = False
elif i == 2:
v = np.arange(cycles, dtype=np.int64) / 100.0
form = "{} * sin(v)"
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)[0]
f = form.format(j - 1)
if not np.array_equal(vals,
numexpr.evaluate(f)):
equal = False
elif i == 3:
v = np.ones(cycles, dtype=np.int64)
form = "({} * v -0.5) / 1"
for j in range(1, 20):
f = form.format(j - 1)
vals = mdf.get(group=i,
index=j,
samples_only=True)[0]
if not np.array_equal(vals,
numexpr.evaluate(f)):
equal = False
elif i == 4:
for j in range(1, 20):
target = np.array([
"Channel {} sample {}".format(
j, k).encode("ascii")
for k in range(cycles)
])
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)[0]
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 5:
v = np.ones(cycles, dtype=np.dtype("(8,)u1"))
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)[0]
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 6:
for j in range(1, 20):
target = np.array(
[b'Value %d' % j for _ in range(cycles)])
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)[0]
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
self.assertTrue(equal)
def test_read_arrays(self):
print("MDF read big array files")
for mdfname in os.listdir('tmpdir_array'):
for memory in MEMORY:
input_file = os.path.join('tmpdir_array', mdfname)
print(input_file, memory)
equal = True
with MDF(input_file, memory=memory) as mdf:
mdf.configure(read_fragment_size=8000)
for i, group in enumerate(mdf.groups):
if i == 0:
samples = [
np.ones((cycles, 2, 3), dtype=np.uint64),
np.ones((cycles, 2), dtype=np.uint64),
np.ones((cycles, 3), dtype=np.uint64),
]
for j in range(1, 20):
types = [
('Channel_{}'.format(j), '(2, 3)<u8'),
('channel_{}_axis_1'.format(j),
'(2, )<u8'),
('channel_{}_axis_2'.format(j),
'(3, )<u8'),
]
types = np.dtype(types)
vals = mdf.get('Channel_{}'.format(j),
group=i,
samples_only=True)
target = [arr * j for arr in samples]
target = np.core.records.fromarrays(
target,
dtype=types,
)
if not np.array_equal(vals, target):
equal = False
elif i == 1:
samples = np.ones((cycles, 2, 3), dtype=np.uint64)
axis_0 = np.ones((cycles, 2), dtype=np.uint64)
axis_1 = np.ones((cycles, 3), dtype=np.uint64)
for j in range(1, 20):
types = [
('Channel_{}'.format(j), '(2, 3)<u8'),
]
types = np.dtype(types)
vals = mdf.get('Channel_{}'.format(j),
group=i,
samples_only=True)
target = [
samples * j,
]
target = np.core.records.fromarrays(
target,
dtype=types,
)
if not np.array_equal(vals, target):
equal = False
elif i == 2:
samples = [
np.ones(cycles, dtype=np.uint8),
np.ones(cycles, dtype=np.uint16),
np.ones(cycles, dtype=np.uint32),
np.ones(cycles, dtype=np.uint64),
np.ones(cycles, dtype=np.int8),
np.ones(cycles, dtype=np.int16),
np.ones(cycles, dtype=np.int32),
np.ones(cycles, dtype=np.int64),
]
for j in range(1, 20):
types = [
('struct_{}_channel_0'.format(j),
np.uint8),
('struct_{}_channel_1'.format(j),
np.uint16),
('struct_{}_channel_2'.format(j),
np.uint32),
('struct_{}_channel_3'.format(j),
np.uint64),
('struct_{}_channel_4'.format(j), np.int8),
('struct_{}_channel_5'.format(j),
np.int16),
('struct_{}_channel_6'.format(j),
np.int32),
('struct_{}_channel_7'.format(j),
np.int64),
]
types = np.dtype(types)
vals = mdf.get('Channel_{}'.format(j),
group=i,
samples_only=True)
target = [arr * j for arr in samples]
target = np.core.records.fromarrays(
target,
dtype=types,
)
if not np.array_equal(vals, target):
equal = False
self.assertTrue(equal)
cleanup_files()
name='Uint8_Signal',
unit='u1')
# int32
s_int32 = Signal(samples=np.array([-20, -10, 0, 10, 20], dtype=np.int32),
timestamps=timestamps,
name='Int32_Signal',
unit='i4')
# float64
s_float64 = Signal(samples=np.array([-20, -10, 0, 10, 20], dtype=np.int32),
timestamps=timestamps,
name='Float64_Signal',
unit='f8')
# create empty MDf version 4.00 file
mdf4 = MDF(version='4.00')
# append the 3 signals to the new file
signals = [s_uint8, s_int32, s_float64]
mdf4.append(signals, 'Created by Python')
# save new file
mdf4.save('my_new_file.mf4')
# convert new file to mdf version 3.10 with load_measured_data=False
mdf3 = mdf4.convert(to='3.10', load_measured_data=False)
print(mdf3.version)
# prints >>> 3.10
# get the float signal
sig = mdf3.get('Float64_Signal')
def test_convert(self):
print("MDF convert big files tests")
t = np.arange(cycles, dtype=np.float64)
for out in ('3.30', '4.10'):
for mdfname in os.listdir('tmpdir'):
for memory in MEMORY:
input_file = os.path.join('tmpdir', mdfname)
print(input_file, memory, out)
with MDF(input_file, memory=memory) as mdf:
mdf.configure(read_fragment_size=8000)
outfile = mdf.convert(out, memory=memory).save(
'tmp_convert_{}_{}'.format(out, memory),
overwrite=True,
)
equal = True
with MDF(outfile) as mdf:
mdf.configure(read_fragment_size=8000)
for i, group in enumerate(mdf.groups):
if i == 0:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
if not np.array_equal(vals, v * (j - 1)):
equal = False
elif i == 1:
v = np.ones(cycles, dtype=np.int64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
if not np.array_equal(
vals,
v * (j - 1) - 0.5):
equal = False
elif i == 2:
v = np.arange(cycles, dtype=np.int64) / 100.0
form = '{} * sin(v)'
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
f = form.format(j - 1)
if not np.array_equal(
vals, numexpr.evaluate(f)):
equal = False
elif i == 3:
v = np.ones(cycles, dtype=np.int64)
form = '({} * v -0.5) / 1'
for j in range(1, 20):
f = form.format(j - 1)
vals = mdf.get(group=i,
index=j,
samples_only=True)
if not np.array_equal(
vals, numexpr.evaluate(f)):
equal = False
elif i == 4:
for j in range(1, 20):
target = np.array([
'Channel {} sample {}'.format(
j, k).encode('ascii')
for k in range(cycles)
])
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 5:
v = np.ones(cycles, dtype=np.dtype('(8,)u1'))
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 6:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
self.assertTrue(equal)
cleanup_files()
class Window_test(QtWidgets.QMainWindow):
def __init__(self):
super(Window_test, self).__init__()
uic.loadUi("version_2.ui", self)
self.condition_combox.addItems(["step", "range", ">"])
self.condition_combox.setItemText(0, "step")
self.condition_combox_2.addItems(["step", "range", ">"])
self.condition_combox_2.setItemText(0, "step")
self.condition_combox.activated[str].connect(self.condition_select)
self.condition_combox_2.activated[str].connect(self.condition_select)
self.file_open_button.clicked.connect(self.openfiles)
self.lower_range.setText("0")
self.upper_range.setText("0")
self.lower_range_2.setText("0")
self.upper_range_2.setText("0")
# self.export_csv_button.clicked.connect(self.delete_all_signals)
self.export_csv_button.clicked.connect(self.to_csv)
self.all_signals.itemDoubleClicked[QtWidgets.QListWidgetItem].connect(
self.select_signal)
self.selected_sig = set() # 选中的信号，不可重复选
self.selected_signals.itemDoubleClicked.connect(self.deselect_signal)
self.all_signals.addItem("hello")
self.add_condition_combox.addItem("")
self.add_condition_combox.setItemText(0, "信号")
self.add_condition_combox_2.addItem("")
self.add_condition_combox_2.setItemText(0, "信号")
# 等价于 self.add_condition_combox.addItem("信号")
self.checkbox_1.stateChanged.connect(self.check)
self.checkbox_2.stateChanged.connect(self.check)
self.check_flag_1 = 0
self.check_flag_2 = 0
self.show()
def openfiles(self):
# 打开单个mdf文件
self.all_signals.clear()
filename, filetype = QtWidgets.QFileDialog.getOpenFileName()
if filename == "":
return
elif filename[-3:] not in ["dat", "mdf", "DAT", "MDF"]:
QtWidgets.QMessageBox.about(self, "Message", "文件类型错误")
return
self.mdf_file = MDF(filename, memory="minimum")
channel_list = list(self.mdf_file.channels_db.keys())
channel_list.remove("time")
channel_list.sort()
self.all_signals.addItems(channel_list)
def check(self, state):
# checkbox选中才出现信号选项
source = self.sender()
try:
self.mdf_file
except:
if self.checkbox_1.checkState() == 2: # 0 表示未选中， 2表示选中
QtWidgets.QMessageBox.about(self, "Message", "请先打开mdf文件")
self.checkbox_1.setCheckState(0)
self.checkbox_2.setCheckState(0)
return
channel_list = list(self.mdf_file.channels_db.keys())
channel_list.remove("time")
channel_list.sort()
if source == self.checkbox_1 and state == QtCore.Qt.Checked:
self.add_condition_combox.addItems(channel_list)
self.check_flag_1 = 1
if source == self.checkbox_2 and state == QtCore.Qt.Checked:
self.add_condition_combox_2.addItems(channel_list)
self.check_flag_2 = 1
def select_signal(self, item):
# print(item.text()) # QtWidgets.QListWidgetItem.text()
# Adding the same QListWidgetItem multiple times to a QListWidget will result in undefined behavior.
if item.text() not in self.selected_sig:
self.selected_signals.addItem(item.text())
self.selected_sig.add(item.text())
def deselect_signal(self):
text = self.selected_signals.takeItem(
self.selected_signals.currentRow())
self.selected_sig.remove(text.text())
def delete_all_signals(self):
self.selected_signals.clear()
def condition_select(self, item):
source = self.sender()
if source == self.condition_combox:
if item in ["step", "range"]:
self.upper_range.show()
self.label_2.show()
elif item in [">", "="]:
self.upper_range.hide()
self.label_2.hide()
else:
pass
if source == self.condition_combox_2:
if item in ["step", "range"]:
self.upper_range_2.show()
self.label_3.show()
elif item in [">", "="]:
self.upper_range_2.hide()
self.label_3.hide()
else:
pass
else:
pass
def to_csv(self):
condition = self.condition_combox.currentText()
condition_2 = self.condition_combox_2.currentText()
condition_channels = []
condition_channels_2 = []
end_indexes_1 = []
start_indexes_1 = []
end_indexes_2 = []
start_indexes_2 = []
if self.check_flag_1 == 1:
if condition == "step":
if not (self.lower_range.text().isdigit()
and self.upper_range.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range = float(self.lower_range.text())
upper_range = float(self.upper_range.text())
print("___________")
condition_channels.append(
self.add_condition_combox.currentText())
signal_samples = self.mdf_file.select(
condition_channels)[0].samples
print("-------------")
start_flag = 0
end_flag = 0
for i, signal_sample in enumerate(signal_samples):
if signal_sample == lower_range and start_flag == 0:
start_indexes_1.append(i)
start_flag = 1
if signal_sample == upper_range and start_flag == 1:
start_flag = 0
end_flag = 1
if signal_sample != upper_range and end_flag == 1:
end_flag = 0
end_indexes_1.append(i)
if signal_sample == upper_range and start_flag == 1 and i == len(
signal_samples) - 1:
end_indexes_1.append(i + 1)
elif condition == "range":
if not (self.lower_range.text().isdigit()
and self.upper_range.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range = float(self.lower_range.text())
upper_range = float(self.upper_range.text())
print("___________")
condition_channels.append(
self.add_condition_combox.currentText())
signal_samples = self.mdf_file.select(
condition_channels)[0].samples
print("-------------")
start_flag = 0
for i, signal_sample in enumerate(signal_samples):
if upper_range > signal_sample > lower_range and start_flag == 0:
start_indexes_1.append(i)
start_flag = 1
if (signal_sample > upper_range or
signal_sample < lower_range) and start_flag == 1:
start_flag = 0
end_indexes_1.append(i)
if upper_range > signal_sample > lower_range and start_flag == 1 and i == len(
signal_samples) - 1:
end_indexes_1.append(i + 1)
elif condition == ">":
if not self.lower_range.text().isdigit():
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range = float(self.lower_range.text())
condition_channels.append(
self.add_condition_combox.currentText())
signal_samples = self.mdf_file.select(
condition_channels)[0].samples
print("-------------")
start_flag = 0
for i, signal_sample in enumerate(signal_samples):
if signal_sample > lower_range and start_flag == 0:
start_indexes_1.append(i)
start_flag = 1
if signal_sample < lower_range and start_flag == 1:
start_flag = 0
end_indexes_1.append(i)
if signal_sample > lower_range and start_flag == 1 and i == len(
signal_samples) - 1:
end_indexes_1.append(i + 1)
else:
pass
if self.check_flag_2 == 1:
if condition_2 == "step":
if not (self.lower_range_2.text().isdigit()
and self.upper_range_2.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range_2 = float(self.lower_range_2.text())
upper_range_2 = float(self.upper_range_2.text())
print("___________")
condition_channels_2.append(
self.add_condition_combox_2.currentText())
signal_samples_2 = self.mdf_file.select(
condition_channels_2)[0].samples
print("-------------")
start_flag = 0
end_flag = 0
for i, signal_sample in enumerate(signal_samples_2):
if signal_sample == lower_range_2 and start_flag == 0:
start_indexes_2.append(i)
start_flag = 1
if signal_sample == upper_range_2 and start_flag == 1:
start_flag = 0
end_flag = 1
if signal_sample != upper_range_2 and end_flag == 1:
end_flag = 0
end_indexes_2.append(i)
if signal_sample == upper_range_2 and start_flag == 1 and i == len(
signal_samples_2) - 1:
end_indexes_2.append(i + 1)
elif condition_2 == "range":
if not (self.lower_range_2.text().isdigit()
and self.upper_range_2.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range_2 = float(self.lower_range_2.text())
upper_range_2 = float(self.upper_range_2.text())
print("___________")
condition_channels_2.append(
self.add_condition_combox_2.currentText())
signal_samples_2 = self.mdf_file.select(
condition_channels_2)[0].samples
print("-------------")
start_flag = 0
for i, signal_sample in enumerate(signal_samples_2):
if upper_range_2 > signal_sample > lower_range_2 and start_flag == 0:
start_indexes_2.append(i)
start_flag = 1
if (signal_sample > upper_range_2 or
signal_sample < lower_range_2) and start_flag == 1:
start_flag = 0
end_indexes_2.append(i)
if upper_range_2 > signal_sample > lower_range_2 and start_flag == 1 and i == len(
signal_samples_2) - 1:
end_indexes_2.append(i + 1)
elif condition_2 == ">":
if not self.lower_range_2.text().isdigit():
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range_2 = float(self.lower_range_2.text())
condition_channels_2.append(
self.add_condition_combox_2.currentText())
signal_samples_2 = self.mdf_file.select(
condition_channels_2)[0].samples
print("-------------")
start_flag = 0
for i, signal_sample in enumerate(signal_samples_2):
if signal_sample > lower_range_2 and start_flag == 0:
start_indexes_2.append(i)
start_flag = 1
if signal_sample < lower_range_2 and start_flag == 1:
start_flag = 0
end_indexes_2.append(i)
if signal_sample > lower_range_2 and start_flag == 1 and i == len(
signal_samples_2) - 1:
end_indexes_2.append(i + 1)
else:
pass
print(start_indexes_1, start_indexes_2, sep="\n")
print(end_indexes_1, end_indexes_2, sep="\n")
if self.check_flag_1 == 1 and self.check_flag_2 == 0:
count = self.selected_signals.count()
items = []
data_dict = {"timestamps": []}
for i in range(count):
items.append(self.selected_signals.item(i).text())
selected_signals = self.mdf_file.select(items)
timestamps = self.mdf_file.select(condition_channels)[0].timestamps
for idx, signal in enumerate(selected_signals):
data_dict[signal.name] = []
for i, j in zip(start_indexes_1, end_indexes_1):
try:
data_dict[signal.name] += signal.interp(
timestamps[i:j]).samples.tolist()
if idx == 0:
data_dict["timestamps"] += timestamps[i:j].tolist()
except:
print("error")
print(data_dict)
self.write_csv(data_dict)
elif self.check_flag_1 == 1 and self.check_flag_2 == 1:
# 先把两个索引扩展开，把中间的数填上，并把它变成集合，最后取两个集合交集
index_1 = set()
index_2 = set()
for i, j in zip(start_indexes_1, end_indexes_1):
for n in range(i, j + 1):
index_1.add(n)
for i, j in zip(start_indexes_2, end_indexes_2):
for n in range(i, j + 1):
index_2.add(n)
indexes = index_1 and index_2
# 获取需要导出的信号名
count = self.selected_signals.count()
items = []
data_dict = {"timestamps": []}
for i in range(count):
items.append(self.selected_signals.item(i).text())
selected_signals = self.mdf_file.select(items)
timestamps = self.mdf_file.select(condition_channels)[0].timestamps
# 把相应信号及其采样值做成字典，信号名作为键，采样值的列表作为值
for idx, signal in enumerate(selected_signals):
data_dict[signal.name] = []
for i in indexes:
# data_dict.update({signal.name: signal.samples[i:j]})
try:
data_dict[signal.name].append(
signal.interp(timestamps[i]).samples)
if idx == 0:
data_dict["timestamps"].append(timestamps[i])
except:
print("error")
print(data_dict)
self.write_csv(data_dict)
else:
QtWidgets.QMessageBox.about(self, "Message", "请按顺序勾选复选框")
return
def write_csv(self, data_dict):
print("writing to csv..\n")
df = pd.DataFrame(data=data_dict)
timestamps = df['timestamps']
df.drop(labels=['timestamps'], axis=1, inplace=True)
df.insert(0, 'timestamps', timestamps)
f_name = str(datetime.now()).split(".")[0].replace(":", "_",
2) + ".csv"
f = open(f_name, "w")
f.close()
df.to_csv(f_name, index=False)
print("finished")
def test_cut_arrays(self):
print("MDF cut big array files")
for mdfname in os.listdir('tmpdir_array'):
for memory in MEMORY:
for whence in (0, 1):
input_file = os.path.join('tmpdir_array', mdfname)
print(input_file, memory, whence)
outfile1 = MDF(input_file, memory=memory)
outfile1.configure(read_fragment_size=8000)
outfile1 = outfile1.cut(stop=105,
whence=whence).save('tmp1',
overwrite=True)
outfile2 = MDF(input_file, memory=memory)
outfile2.configure(read_fragment_size=8000)
outfile2 = outfile2.cut(start=105, stop=201,
whence=whence).save('tmp2',
overwrite=True)
outfile3 = MDF(input_file, memory=memory)
outfile3.configure(read_fragment_size=8000)
outfile3 = outfile3.cut(start=201,
whence=whence).save('tmp3',
overwrite=True)
outfile = MDF.merge(
[outfile1, outfile2, outfile3],
MDF(input_file, memory='minimum').version,
memory=memory,
).save('tmp_cut', overwrite=True)
equal = True
with MDF(input_file, memory=memory) as mdf:
mdf.configure(read_fragment_size=8000)
for i, group in enumerate(mdf.groups):
if i == 0:
samples = [
np.ones((cycles, 2, 3), dtype=np.uint64),
np.ones((cycles, 2), dtype=np.uint64),
np.ones((cycles, 3), dtype=np.uint64),
]
for j in range(1, 20):
types = [
('Channel_{}'.format(j), '(2, 3)<u8'),
('channel_{}_axis_1'.format(j),
'(2, )<u8'),
('channel_{}_axis_2'.format(j),
'(3, )<u8'),
]
types = np.dtype(types)
vals = mdf.get('Channel_{}'.format(j),
group=i,
samples_only=True)
target = [arr * j for arr in samples]
target = np.core.records.fromarrays(
target,
dtype=types,
)
if not np.array_equal(vals, target):
equal = False
elif i == 1:
samples = np.ones((cycles, 2, 3),
dtype=np.uint64)
axis_0 = np.ones((cycles, 2), dtype=np.uint64)
axis_1 = np.ones((cycles, 3), dtype=np.uint64)
for j in range(1, 20):
types = [
('Channel_{}'.format(j), '(2, 3)<u8'),
]
types = np.dtype(types)
vals = mdf.get('Channel_{}'.format(j),
group=i,
samples_only=True)
target = [
samples * j,
]
target = np.core.records.fromarrays(
target,
dtype=types,
)
if not np.array_equal(vals, target):
equal = False
elif i == 2:
samples = [
np.ones(cycles, dtype=np.uint8),
np.ones(cycles, dtype=np.uint16),
np.ones(cycles, dtype=np.uint32),
np.ones(cycles, dtype=np.uint64),
np.ones(cycles, dtype=np.int8),
np.ones(cycles, dtype=np.int16),
np.ones(cycles, dtype=np.int32),
np.ones(cycles, dtype=np.int64),
]
for j in range(1, 20):
types = [
('struct_{}_channel_0'.format(j),
np.uint8),
('struct_{}_channel_1'.format(j),
np.uint16),
('struct_{}_channel_2'.format(j),
np.uint32),
('struct_{}_channel_3'.format(j),
np.uint64),
('struct_{}_channel_4'.format(j),
np.int8),
('struct_{}_channel_5'.format(j),
np.int16),
('struct_{}_channel_6'.format(j),
np.int32),
('struct_{}_channel_7'.format(j),
np.int64),
]
types = np.dtype(types)
vals = mdf.get('Channel_{}'.format(j),
group=i,
samples_only=True)
target = [arr * j for arr in samples]
target = np.core.records.fromarrays(
target,
dtype=types,
)
if not np.array_equal(vals, target):
equal = False
self.assertTrue(equal)
cleanup_files()
class Ui_Form(QtWidgets.QWidget):
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(599, 468)
self.file_open_button = QtWidgets.QPushButton(Form)
self.file_open_button.setGeometry(QtCore.QRect(60, 20, 75, 23))
self.file_open_button.setObjectName("file_open_button")
self.file_open_button.clicked.connect(self.openfiles)
self.condition_combox = QtWidgets.QComboBox(Form)
self.condition_combox.setGeometry(QtCore.QRect(290, 70, 70, 20))
self.condition_combox.setObjectName("condition_combox")
self.condition_combox.addItems(["step", "range", ">", "="])
self.condition_combox.activated[str].connect(self.condition_select)
self.lower_range = QtWidgets.QLineEdit(Form)
self.lower_range.setGeometry(QtCore.QRect(372, 70, 61, 20))
self.lower_range.setObjectName("lower_range")
self.lower_range.setText("0")
self.upper_range = QtWidgets.QLineEdit(Form)
self.upper_range.setGeometry(QtCore.QRect(460, 70, 61, 20))
self.upper_range.setObjectName("upper_range")
self.upper_range.setText("0")
self.label_2 = QtWidgets.QLabel(Form)
self.label_2.setGeometry(QtCore.QRect(440, 70, 16, 16))
self.label_2.setObjectName("label_2")
self.add_condition_combox = QtWidgets.QComboBox(Form)
self.add_condition_combox.setGeometry(QtCore.QRect(50, 70, 200, 23))
self.add_condition_combox.setObjectName("add_condition_combox")
self.add_condition_combox.addItem("")
self.export_csv_button = QtWidgets.QPushButton(Form)
self.export_csv_button.setGeometry(QtCore.QRect(270, 410, 75, 23))
self.export_csv_button.setObjectName("export_csv_button")
# self.export_csv_button.clicked.connect(self.delete_all_signals)
self.export_csv_button.clicked.connect(self.to_csv)
self.all_signals = QtWidgets.QListWidget(Form)
self.all_signals.setGeometry(QtCore.QRect(10, 150, 256, 192))
self.all_signals.setObjectName("all_signals")
self.all_signals.itemDoubleClicked[QtWidgets.QListWidgetItem].connect(
self.select_signal)
self.selected_sig = set() # 选中的信号，不可重复选
self.selected_signals = QtWidgets.QListWidget(Form)
self.selected_signals.setGeometry(QtCore.QRect(320, 150, 256, 192))
self.selected_signals.setObjectName("selected_signals")
self.selected_signals.itemDoubleClicked.connect(self.deselect_signal)
self.all_signals.addItem("hello")
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Form"))
self.file_open_button.setText(_translate("Form", "打开MDF"))
# self.condition_combox.setItemText(0, _translate("Form", "step"))
self.add_condition_combox.setItemText(0, _translate("Form", "信号"))
self.label_2.setText(_translate("Form", "-"))
self.export_csv_button.setText(_translate("Form", "导出csv"))
def openfiles(self):
# 打开单个mdf文件
self.all_signals.clear()
filename, filetype = QtWidgets.QFileDialog.getOpenFileName()
if filename[-3:] not in ["dat", "mdf", "DAT", "MDF"]:
QtWidgets.QMessageBox.about(self, "Message", "文件类型错误")
return
self.mdf_file = MDF(filename, memory="minimum")
channel_list = list(self.mdf_file.channels_db.keys())
channel_list.remove("time")
channel_list.sort()
self.add_condition_combox.addItems(channel_list)
self.all_signals.addItems(channel_list)
# 打开多个mdf文件
# filenames, filetype= QtWidgets.QFileDialog.getOpenFileNames()
# for filename in filenames:
# file = MDF(filename, memory="minimum")
# channel_list = list(file.channels_db.keys())
# channel_list.remove("time") # 多个文件时间可能不同，因此该程序肯定有问题，不管。
# channel_list.sort()
# self.data += file.select(channel_list)
# for channel in channel_list:
# self.all_signals.addItem(channel)
# 打开一个文件夹下的所有mdf文件。但具体是否可行未知,或者把上面程序多运行几遍
# dir = os.listdir(QtWidgets.QFileDialog.getExistingDirectory())
# mdf_files = [mdf_file for mdf_file in dir if mdf_file[-3:] in ["dat", "mdf", "DAT", "MDF"]]
# mdf = MDF()
# mdf.stack(mdf_files, memory='minimum')
# signals = mdf.iter_channels() # generator that yields a Signal for each non-master channel
# for signal in signals:
# self.all_signals.addItem(signal)
def select_signal(self, item):
# print(item.text()) # QtWidgets.QListWidgetItem.text()
# Adding the same QListWidgetItem multiple times to a QListWidget will result in undefined behavior.
if item.text() not in self.selected_sig:
self.selected_signals.addItem(item.text())
self.selected_sig.add(item.text())
def deselect_signal(self):
self.selected_signals.takeItem(self.selected_signals.currentRow())
def delete_all_signals(self):
self.selected_signals.clear()
def condition_select(self, item):
if item in ["step", "range"]:
self.upper_range.show()
self.label_2.show()
elif item in [">", "="]:
self.upper_range.hide()
self.label_2.hide()
else:
pass
def to_csv(self):
condition = self.condition_combox.currentText()
channels = [] # 条件信号
if not (self.lower_range.text().isdigit()
and self.upper_range.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围错误")
return
lower_range = float(self.lower_range.text())
upper_range = float(self.upper_range.text())
if condition == "step":
signal_samples = self.mdf_file.select(
self.add_condition_combox.currentText()).samples
signal_time = self.mdf_file.select(
self.add_condition_combox.currentText()).time
print(signal_samples)
print(signal_time)
elif condition == "range":
print(self.lower_range.text())
print(self.upper_range.text())
elif condition == ">":
print(">")
start_time = []
channels.append(self.add_condition_combox.currentText())
try:
signal_samples = self.mdf_file.select(channels)[0].samples
signal_time = self.mdf_file.select(channels)[0].timestamps
except:
print("信号错误")
for i, signal_sample in enumerate(signal_samples):
if signal_sample > lower_range:
start_time.append(i)
elif condition == "=":
print("=")
else:
pass
count = self.selected_signals.count()
items = []
data_dict = {}
for i in range(count):
items.append(self.selected_signals.item(i).text())
signals = self.mdf_file.select(items) # 当存在空数据时，会出错
try:
for signal in signals:
for i in start_time:
data_dict.update({signal.name: signal.samples[i]})
print(data_dict)
for i in start_time:
data_dict.update({"timestamps": signals[0].timestamps[i]})
print(data_dict)
df = pd.DataFrame(data=data_dict)
print("-" * 20)
df.to_csv("11.csv", index=False)
except:
print("write error")
def save_mdf4_nodata():
os.chdir(path)
x = MDF(r'test.mf4', load_measured_data=False)
with Timer('asammdf {} nodata mdfv4'.format(asammdf_version)):
x.save(r'x.mf4', overwrite=True)
def generate_test_files(version='4.10'):
cycles = 3000
channels_count = 2000
mdf = MDF(version=version, memory='minimum')
if version <= '3.30':
filename = r'test.mdf'
else:
filename = r'test.mf4'
if os.path.exists(filename):
return filename
t = np.arange(cycles, dtype=np.float64)
cls = v4b.ChannelConversion if version >= '4.00' else v3b.ChannelConversion
# no conversion
sigs = []
for i in range(channels_count):
sig = Signal(
np.ones(cycles, dtype=np.uint64) * i,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=None,
comment='Unsigned int 16bit channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# linear
sigs = []
for i in range(channels_count):
conversion = {
'conversion_type':
v4c.CONVERSION_TYPE_LIN
if version >= '4.00' else v3c.CONVERSION_TYPE_LINEAR,
'a':
float(i),
'b':
-0.5,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=cls(**conversion),
comment='Signed 16bit channel {} with linear conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# algebraic
sigs = []
for i in range(channels_count):
conversion = {
'conversion_type':
v4c.CONVERSION_TYPE_ALG
if version >= '4.00' else v3c.CONVERSION_TYPE_FORMULA,
'formula':
'{} * sin(X)'.format(i),
}
sig = Signal(
np.arange(cycles, dtype=np.int32) / 100.0,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=cls(**conversion),
comment='Sinus channel {} with algebraic conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# rational
sigs = []
for i in range(channels_count):
conversion = {
'conversion_type':
v4c.CONVERSION_TYPE_RAT
if version >= '4.00' else v3c.CONVERSION_TYPE_RAT,
'P1':
0,
'P2':
i,
'P3':
-0.5,
'P4':
0,
'P5':
0,
'P6':
1,
}
sig = Signal(
np.ones(cycles, dtype=np.int64),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
conversion=cls(**conversion),
comment='Channel {} with rational conversion'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# string
sigs = []
for i in range(channels_count):
sig = [
'Channel {} sample {}'.format(i, j).encode('ascii')
for j in range(cycles)
]
sig = Signal(
np.array(sig),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
comment='String channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# byte array
sigs = []
ones = np.ones(cycles, dtype=np.dtype('(8,)u1'))
for i in range(channels_count):
sig = Signal(
ones * (i % 255),
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
comment='Byte array channel {}'.format(i),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
# value to text
sigs = []
ones = np.ones(cycles, dtype=np.uint64)
conversion = {
'raw':
np.arange(255, dtype=np.float64),
'phys':
np.array(['Value {}'.format(i).encode('ascii') for i in range(255)]),
'conversion_type':
v4c.CONVERSION_TYPE_TABX
if version >= '4.00' else v3c.CONVERSION_TYPE_TABX,
'links_nr':
260,
'ref_param_nr':
255,
}
for i in range(255):
conversion['val_{}'.format(i)] = conversion['param_val_{}'.format(
i)] = conversion['raw'][i]
conversion['text_{}'.format(i)] = conversion['phys'][i]
conversion['text_{}'.format(255)] = 'Default'
for i in range(channels_count):
sig = Signal(
ones * i,
t,
name='Channel_{}'.format(i),
unit='unit_{}'.format(i),
comment='Value to text channel {}'.format(i),
conversion=cls(**conversion),
raw=True,
)
sigs.append(sig)
mdf.append(sigs, common_timebase=True)
mdf.save(filename, overwrite=True)
def convert_v3_v4_nodata():
os.chdir(path)
with MDF(r'test.mdf', load_measured_data=False) as x:
with Timer('asammdf {} v3 to v4 nodata'.format(asammdf_version)):
y = x.convert(to='4.10', load_measured_data=False)
y.close()
def main(text_output, fmt):
if os.path.dirname(__file__):
os.chdir(os.path.dirname(__file__))
for version in ('3.30', '4.10'):
generate_test_files(version)
mdf = MDF('test.mdf', 'minimum')
v3_size = os.path.getsize('test.mdf') // 1024 // 1024
v3_groups = len(mdf.groups)
v3_channels = sum(len(gp['channels']) for gp in mdf.groups)
v3_version = mdf.version
mdf = MDF('test.mf4', 'minimum')
v4_size = os.path.getsize('test.mf4') // 1024 // 1024
v4_groups = len(mdf.groups)
v4_channels = sum(len(gp['channels']) for gp in mdf.groups)
v4_version = mdf.version
listen, send = multiprocessing.Pipe()
output = MyList()
errors = []
installed_ram = round(psutil.virtual_memory().total / 1024 / 1024 / 1024)
output.append('\n\nBenchmark environment\n')
output.append('* {}'.format(sys.version))
output.append('* {}'.format(platform.platform()))
output.append('* {}'.format(platform.processor()))
output.append('* {}GB installed RAM\n'.format(installed_ram))
output.append('Notations used in the results\n')
output.append(('* full = asammdf MDF object created with '
'memory=full '
'(everything loaded into RAM)'))
output.append(('* low = asammdf MDF object created with '
'memory=low '
'(raw channel data not loaded into RAM, '
'but metadata loaded to RAM)'))
output.append(('* minimum = asammdf MDF object created with '
'memory=full '
'(lowest possible RAM usage)'))
output.append(('* compress = mdfreader mdf object created with '
'compression=blosc'))
output.append(('* noDataLoading = mdfreader mdf object read with '
'noDataLoading=True'))
output.append('\nFiles used for benchmark:\n')
output.append('* mdf version {}'.format(v3_version))
output.append(' * {} MB file size'.format(v3_size))
output.append(' * {} groups'.format(v3_groups))
output.append(' * {} channels'.format(v3_channels))
output.append('* mdf version {}'.format(v4_version))
output.append(' * {} MB file size'.format(v4_size))
output.append(' * {} groups'.format(v4_groups))
output.append(' * {} channels\n\n'.format(v4_channels))
tests = (
partial(open_mdf3, memory='full'),
partial(open_mdf3, memory='low'),
partial(open_mdf3, memory='minimum'),
# open_reader3,
# open_reader3_compression,
# open_reader3_nodata,
partial(open_mdf4, memory='full'),
partial(open_mdf4, memory='low'),
partial(open_mdf4, memory='minimum'),
# open_reader4,
# open_reader4_compression,
# open_reader4_nodata,
)
if tests:
output.extend(table_header('Open file', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
partial(save_mdf3, memory='full'),
partial(save_mdf3, memory='low'),
partial(save_mdf3, memory='minimum'),
# save_reader3,
# save_reader3_nodata,
# save_reader3_compression,
partial(save_mdf4, memory='full'),
partial(save_mdf4, memory='low'),
partial(save_mdf4, memory='minimum'),
# save_reader4,
# save_reader4_nodata,
# save_reader4_compression,
)
if tests:
output.extend(table_header('Save file', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
# partial(get_all_mdf3, memory='full'),
# partial(get_all_mdf3, memory='low'),
# partial(get_all_mdf3, memory='minimum'),
# get_all_reader3,
# get_all_reader3_nodata,
# get_all_reader3_compression,
#
# partial(get_all_mdf4, memory='full'),
# partial(get_all_mdf4, memory='low'),
# partial(get_all_mdf4, memory='minimum'),
#
# get_all_reader4,
# get_all_reader4_compression,
# get_all_reader4_nodata,
)
if tests:
output.extend(table_header('Get all channels (36424 calls)', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
partial(convert_v3_v4, memory='full'),
partial(convert_v3_v4, memory='low'),
partial(convert_v3_v4, memory='minimum'),
partial(convert_v4_v3, memory='full'),
partial(convert_v4_v3, memory='low'),
partial(convert_v4_v3, memory='minimum'),
)
if tests:
output.extend(table_header('Convert file', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
tests = (
partial(merge_v3, memory='full'),
partial(merge_v3, memory='low'),
partial(merge_v3, memory='minimum'),
# merge_reader_v3,
# merge_reader_v3_compress,
# merge_reader_v3_nodata,
partial(merge_v4, memory='full'),
partial(merge_v4, memory='low'),
partial(merge_v4, memory='minimum'),
# merge_reader_v4,
# merge_reader_v4_nodata,
# merge_reader_v4_compress,
)
if tests:
output.extend(table_header('Merge 3 files', fmt))
for func in tests:
thr = multiprocessing.Process(target=func, args=(send, fmt))
thr.start()
thr.join()
result, err = listen.recv()
output.append(result)
errors.append(err)
output.extend(table_end(fmt))
errors = [err for err in errors if err]
if errors:
print('\n\nERRORS\n', '\n'.join(errors))
if text_output:
arch = 'x86' if platform.architecture()[0] == '32bit' else 'x64'
file = '{}_asammdf_{}_mdfreader_{}.{}'.format(arch, asammdf_version,
mdfreader_version, fmt)
with open(file, 'w') as out:
out.write('\n'.join(output))
for file in ('x.mdf', 'x.mf4'):
if PYVERSION >= 3:
try:
os.remove(file)
except FileNotFoundError:
pass
else:
try:
os.remove(file)
except IOError:
pass
def convert_v4_v3_nodata():
os.chdir(path)
with MDF(r'test.mf4', load_measured_data=False) as x:
with Timer('asammdf {} v4 to v3 nodata'.format(asammdf_version)):
y = x.convert('3.30', load_measured_data=False)
y.close()
name='Uint8_Signal',
unit='u1')
# int32
s_int32 = Signal(samples=np.array([-20, -10, 0, 10, 20], dtype=np.int32),
timestamps=timestamps,
name='Int32_Signal',
unit='i4')
# float64
s_float64 = Signal(samples=np.array([-20, -10, 0, 10, 20], dtype=np.int32),
timestamps=timestamps,
name='Float64_Signal',
unit='f8')
# create empty MDf version 4.00 file
mdf4 = MDF(version='4.00')
# append the 3 signals to the new file
signals = [s_uint8, s_int32, s_float64]
mdf4.append(signals, 'Created by Python')
# save new file
mdf4.save('my_new_file.mf4')
# convert new file to mdf version 3.10 with compression of raw channel data
mdf3 = mdf4.convert(to='3.10', compression=True)
print(mdf3.version)
# prints >>> 3.10
# get the float signal
sig = mdf3.get('Float64_Signal')
def save_mdf3():
os.chdir(path)
x = MDF(r'test.mdf')
with Timer('asammdf {} mdfv3'.format(asammdf_version)):
x.save(r'x.mdf', overwrite=True)
def test_read(self):
print("MDF read big files")
for mdfname in os.listdir('tmpdir'):
for memory in MEMORY:
input_file = os.path.join('tmpdir', mdfname)
print(input_file, memory)
equal = True
with MDF(input_file, memory=memory) as mdf:
for i, group in enumerate(mdf.groups):
if i == 0:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
if not np.array_equal(vals, v * (j - 1)):
equal = False
elif i == 1:
v = np.ones(cycles, dtype=np.int64)
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
if not np.array_equal(vals, v * (j - 1) - 0.5):
equal = False
elif i == 2:
v = np.arange(cycles, dtype=np.int64) / 100.0
form = '{} * sin(v)'
for j in range(1, 20):
vals = mdf.get(group=i,
index=j,
samples_only=True)
f = form.format(j - 1)
if not np.array_equal(vals,
numexpr.evaluate(f)):
equal = False
elif i == 3:
v = np.ones(cycles, dtype=np.int64)
form = '({} * v -0.5) / 1'
for j in range(1, 20):
f = form.format(j - 1)
vals = mdf.get(group=i,
index=j,
samples_only=True)
if not np.array_equal(vals,
numexpr.evaluate(f)):
equal = False
elif i == 4:
for j in range(1, 20):
target = np.array([
'Channel {} sample {}'.format(
j, k).encode('ascii')
for k in range(cycles)
])
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 5:
v = np.ones(cycles, dtype=np.dtype('(8,)u1'))
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
elif i == 6:
v = np.ones(cycles, dtype=np.uint64)
for j in range(1, 20):
target = v * j
vals = mdf.get(group=i,
index=j + 1,
samples_only=True)
cond = np.array_equal(vals, target)
if not cond:
print(i, j, vals, target, len(vals),
len(target))
self.assertTrue(cond)
self.assertTrue(equal)
cleanup_files()
def to_csv(self):
data_dict = {"timestamps": [], "filename": []}
if self.check_flag_1 == 1 and self.check_flag_2 == 0:
data_dict["duration"] = []
for filename in self.filenames:
condition = self.condition_combox.currentText()
condition_2 = self.condition_combox_2.currentText()
condition_channels = []
condition_channels_2 = []
end_indexes_1 = []
start_indexes_1 = []
end_indexes_2 = []
start_indexes_2 = []
if self.check_flag_1 == 1:
if condition == "step":
if not (self.lower_range.text().isdigit()
and self.upper_range.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range = float(self.lower_range.text())
upper_range = float(self.upper_range.text())
condition_channels.append(self.lineEdit.text())
mdf = MDF(filename, "minimum")
signal_samples = mdf.select(condition_channels)[0].samples
self.statusBar().showMessage("处理第一个筛选条件")
for i in range(len(signal_samples) - 1):
if signal_samples[i] == lower_range and signal_samples[
i + 1] == upper_range:
start_indexes_1.append(i)
end_indexes_1.append(i + 1)
# for i, signal_sample in enumerate(signal_samples):
# if signal_sample == lower_range and start_flag == 0:
# start_indexes_1.append(i)
# start_flag = 1
# if signal_sample == upper_range and start_flag == 1:
# start_flag = 0
# end_flag = 1
# if signal_sample != upper_range and end_flag == 1:
# end_flag = 0
# end_indexes_1.append(i)
# if signal_sample == upper_range and start_flag ==1 and i == len(signal_samples)-1:
# end_indexes_1.append(i+1)
elif condition == "range":
if not (self.lower_range.text().isdigit()
and self.upper_range.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range = float(self.lower_range.text())
upper_range = float(self.upper_range.text())
condition_channels.append(self.lineEdit.text())
mdf = MDF(filename, "minimum")
signal_samples = mdf.select(condition_channels)[0].samples
self.statusBar().showMessage("处理第一个筛选条件")
start_flag = 0
for i, signal_sample in enumerate(signal_samples):
if upper_range >= signal_sample >= lower_range and start_flag == 0:
start_indexes_1.append(i)
start_flag = 1
if (signal_sample > upper_range or signal_sample <
lower_range) and start_flag == 1:
start_flag = 0
end_indexes_1.append(i)
if upper_range > signal_sample > lower_range and start_flag == 1 and i == len(
signal_samples) - 1:
end_indexes_1.append(i + 1)
elif condition == ">":
if not self.lower_range.text().isdigit():
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range = float(self.lower_range.text())
condition_channels.append(self.lineEdit.text())
mdf = MDF(filename, "minimum")
signal_samples = mdf.select(condition_channels)[0].samples
self.statusBar().showMessage("处理第一个筛选条件")
start_flag = 0
for i, signal_sample in enumerate(signal_samples):
if signal_sample > lower_range and start_flag == 0:
start_indexes_1.append(i)
start_flag = 1
if signal_sample < lower_range and start_flag == 1:
start_flag = 0
end_indexes_1.append(i)
if signal_sample > lower_range and start_flag == 1 and i == len(
signal_samples) - 1:
end_indexes_1.append(i + 1)
elif condition == "<":
if not self.upper_range.text().isdigit():
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
upper_range = float(self.upper_range.text())
condition_channels.append(self.lineEdit.text())
mdf = MDF(filename, "minimum")
signal_samples = mdf.select(condition_channels)[0].samples
self.statusBar().showMessage("处理第一个筛选条件")
start_flag = 0
for i, signal_sample in enumerate(signal_samples):
if signal_sample < upper_range and start_flag == 0:
start_indexes_1.append(i)
start_flag = 1
if signal_sample > upper_range and start_flag == 1:
start_flag = 0
end_indexes_1.append(i)
if signal_sample < upper_range and start_flag == 1 and i == len(
signal_samples) - 1:
end_indexes_1.append(i + 1)
else:
pass
if self.check_flag_2 == 1:
if condition_2 == "step":
if not (self.lower_range_2.text().isdigit()
and self.upper_range_2.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range_2 = float(self.lower_range_2.text())
upper_range_2 = float(self.upper_range_2.text())
condition_channels_2.append(self.lineEdit_2.text())
mdf = MDF(filename, "minimum")
signal_samples_2 = mdf.select(
condition_channels_2)[0].samples
self.statusBar().showMessage("处理第二个筛选条件")
for i in range(len(signal_samples_2) - 1):
if signal_samples_2[
i] == lower_range_2 and signal_samples_2[
i + 1] == upper_range_2:
start_indexes_2.append(i)
end_indexes_2.append(i + 1)
elif condition_2 == "range":
if not (self.lower_range_2.text().isdigit()
and self.upper_range_2.text().isdigit()):
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range_2 = float(self.lower_range_2.text())
upper_range_2 = float(self.upper_range_2.text())
condition_channels_2.append(self.lineEdit_2.text())
mdf = MDF(filename, "minimum")
signal_samples_2 = mdf.select(
condition_channels_2)[0].samples
self.statusBar().showMessage("处理第二个筛选条件")
start_flag = 0
for i, signal_sample in enumerate(signal_samples_2):
if upper_range_2 >= signal_sample >= lower_range_2 and start_flag == 0:
start_indexes_2.append(i)
start_flag = 1
if (signal_sample > upper_range_2 or signal_sample <
lower_range_2) and start_flag == 1:
start_flag = 0
end_indexes_2.append(i)
if upper_range_2 > signal_sample > lower_range_2 and start_flag == 1 and i == len(
signal_samples_2) - 1:
end_indexes_2.append(i + 1)
elif condition_2 == ">":
if not self.lower_range_2.text().isdigit():
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
lower_range_2 = float(self.lower_range_2.text())
condition_channels_2.append(self.lineEdit_2.text())
mdf = MDF(filename, "minimum")
signal_samples_2 = mdf.select(
condition_channels_2)[0].samples
self.statusBar().showMessage("处理第二个筛选条件")
start_flag = 0
for i, signal_sample in enumerate(signal_samples_2):
if signal_sample > lower_range_2 and start_flag == 0:
start_indexes_2.append(i)
start_flag = 1
if signal_sample < lower_range_2 and start_flag == 1:
start_flag = 0
end_indexes_2.append(i)
if signal_sample > lower_range_2 and start_flag == 1 and i == len(
signal_samples_2) - 1:
end_indexes_2.append(i + 1)
elif condition_2 == "<":
if not self.upper_range_2.text().isdigit():
QtWidgets.QMessageBox.about(self, "Message", "范围必须是数字")
return
upper_range_2 = float(self.upper_range_2.text())
condition_channels_2.append(self.lineEdit_2.text())
mdf = MDF(filename, "minimum")
signal_samples_2 = mdf.select(
condition_channels_2)[0].samples
self.statusBar().showMessage("处理第二个筛选条件")
start_flag = 0
for i, signal_sample in enumerate(signal_samples_2):
if signal_sample > upper_range_2 and start_flag == 0:
start_indexes_2.append(i)
start_flag = 1
if signal_sample < upper_range_2 and start_flag == 1:
start_flag = 0
end_indexes_2.append(i)
if signal_sample > upper_range_2 and start_flag == 1 and i == len(
signal_samples_2) - 1:
end_indexes_2.append(i + 1)
else:
pass
if self.check_flag_1 == 1 and self.check_flag_2 == 0:
self.statusBar().showMessage("getting selected signal")
mdf = MDF(filename, "minimum")
timestamps = mdf.select(condition_channels)[0].timestamps
count = self.selected_signals.count()
for i in range(count):
signal_name = self.selected_signals.item(i).text()
selected_signal = mdf.select(
[signal_name])[0] # mdf的select方法参数必须为list
if self.selected_signals.item(
i).text() not in data_dict.keys():
data_dict[self.selected_signals.item(i).text()] = []
for k, j in zip(start_indexes_1, end_indexes_1):
try:
data_dict[self.selected_signals.item(
i).text()] += selected_signal.interp(
timestamps[k:j]).samples.tolist()
except:
self.statusBar().showMessage("error")
for i, j in zip(start_indexes_1, end_indexes_1):
try:
data_dict["timestamps"] += timestamps[i:j].tolist()
duration = timestamps[
j - 1].tolist() - timestamps[i].tolist()
for _ in range(i, j):
data_dict["filename"].append(filename)
data_dict["duration"].append(duration)
except:
self.statusBar().showMessage("error")
elif self.check_flag_1 == 1 and self.check_flag_2 == 1:
self.statusBar().showMessage("生成最终索引")
# 先把两个索引扩展开，把中间的数填上，并把它变成集合，最后取两个集合交集
index_1 = set()
index_2 = set()
for i, j in zip(start_indexes_1, end_indexes_1):
for n in range(i, j):
index_1.add(n)
for i, j in zip(start_indexes_2, end_indexes_2):
for n in range(i, j):
index_2.add(n)
indexes = index_1 & index_2
mdf = MDF(filename, "minimum")
timestamps = mdf.select(condition_channels)[0].timestamps
# 获取需要导出的信号名
self.statusBar().showMessage("提取数据中...")
count = self.selected_signals.count()
for i in range(count):
signal_name = self.selected_signals.item(i).text()
selected_signal = mdf.select([signal_name])[0]
if self.selected_signals.item(
i).text() not in data_dict.keys():
data_dict[self.selected_signals.item(i).text()] = []
# 把相应信号及其采样值做成字典，信号名作为键，采样值的列表作为值
for k in indexes:
try:
# data_dict[self.selected_signals.item(i).text()].append(selected_signal.interp([timestamps[k]]).samples.tolist())
data_dict[self.selected_signals.item(
i).text()] += selected_signal.interp(
[timestamps[k]]).samples.tolist()
except:
# print("k=", k)
self.statusBar().showMessage("error？？")
for i in indexes:
try:
data_dict["timestamps"].append(timestamps[i])
data_dict["filename"].append(filename)
except:
# print("i=", i)
self.statusBar().showMessage("error")
else:
QtWidgets.QMessageBox.about(self, "Message", "请按顺序勾选复选框")
print(self.check_flag_1, self.check_flag_2)
return
self.write_csv(data_dict)
def test_wrong_header_version(self):
mdf = BytesIO(
b'MDF AAAA amdf500d\x00\x00\x00\x00\x9f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
)
with self.assertRaises(MdfException):
MDF(mdf)
