def _display(self, position):
self.tree.setSortingEnabled(False)
self.tree.clear()
df = self.df.iloc[max(0, position * 10 -
50):max(0, position * 10 + 100)]
if df["timestamps"].dtype.kind == "M":
timestamps = (pd.Index(
df["timestamps"]).tz_localize("UTC").tz_convert(LOCAL_TIMEZONE)
)
else:
timestamps = df["timestamps"]
timestamps = timestamps.astype(str)
items = [df.index.astype(str), timestamps]
for i, name in enumerate(df.columns[1:], 1):
column = df[name]
kind = column.dtype.kind
if kind in "ui":
if self.format == "hex":
items.append(pd.Series(csv_int2hex(column)).values)
elif self.format == "bin":
items.append(pd.Series(csv_int2bin(column)).values)
else:
items.append(column.astype(str))
elif kind == "f":
items.append(column.astype(str))
elif kind == "S":
try:
items.append(npchar.decode(column, "utf-8"))
except:
items.append(npchar.decode(column, "latin-1"))
elif kind == "O":
items.append(column)
else:
items.append(column)
if position == 0:
self.tree.verticalScrollBar().setSliderPosition(0)
elif position == self.tree_scroll.maximum():
self.tree.verticalScrollBar().setSliderPosition(
self.tree.verticalScrollBar().maximum())
column_types = ["u", *[df[name].dtype.kind for name in df.columns]]
as_hex = [False] + self.as_hex
items = [
TabularTreeItem(column_types, as_hex, row) for row in zip(*items)
]
self.tree.addTopLevelItems(items)
self.tree.setSortingEnabled(
self.sort.checkState() == QtCore.Qt.Checked)
def __init__(self, signals=None, start=0, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self.signals_descr = {}
self.start = start
if signals is None:
self.signals = pd.DataFrame()
else:
dropped = {}
for name_ in signals.columns:
col = signals[name_]
if col.dtype.kind == 'O':
# dropped[name_] = pd.Series(csv_bytearray2hex(col), index=signals.index)
self.signals_descr[name_] = 1
elif col.dtype.kind == 'S':
try:
dropped[name_] = pd.Series(npchar.decode(col, 'utf-8'),
index=signals.index)
except:
dropped[name_] = pd.Series(npchar.decode(
col, 'latin-1'),
index=signals.index)
self.signals_descr[name_] = 0
else:
self.signals_descr[name_] = 0
signals = signals.drop(columns=list(dropped))
for name, s in dropped.items():
signals[name] = s
self.signals = signals
self._original_index = self.signals.index.values
self.build(self.signals, True)
self.add_filter_btn.clicked.connect(self.add_filter)
self.apply_filters_btn.clicked.connect(self.apply_filters)
self.sort.stateChanged.connect(self.sorting_changed)
self.time_as_date.stateChanged.connect(self.time_as_date_changed)
self.remove_prefix.stateChanged.connect(self.remove_prefix_changed)
self.tree.header().sortIndicatorChanged.connect(self._sort)
prefixes = set()
for name in self.signals.columns:
if '.' in name:
prefixes.add(f'{name.split(".")[0]}.')
self.prefix.insertItems(0, sorted(prefixes))
self.prefix.setEnabled(False)
self.tree_scroll.valueChanged.connect(self._display)
self.tree.verticalScrollBar().valueChanged.connect(self._scroll_tree)
def _display(self, position):
self.tree.setSortingEnabled(False)
self.tree.clear()
df = self.df.iloc[max(0, position * 10 -
50):max(0, position * 10 + 100)]
if df.index.dtype.kind == "M":
index = df.index.tz_localize("UTC").tz_convert(LOCAL_TIMEZONE)
else:
index = df.index
items = [
index.astype(str),
]
for i, name in enumerate(df.columns):
column = df[name]
kind = column.dtype.kind
if self.as_hex[i]:
items.append(
pd.Series(csv_int2hex(column.astype("<u4"))).values)
else:
if kind in "uif":
items.append(column.astype(str))
elif kind == "S":
try:
items.append(npchar.decode(column, "utf-8"))
except:
items.append(npchar.decode(column, "latin-1"))
elif kind == "O":
try:
items.append(
pd.Series(csv_bytearray2hex(df[name])).values)
except:
items.append(pd.Series(df[name]).values)
else:
items.append(column)
if position == 0:
self.tree.verticalScrollBar().setSliderPosition(0)
elif position == self.tree_scroll.maximum():
self.tree.verticalScrollBar().setSliderPosition(
self.tree.verticalScrollBar().maximum())
items = [QtWidgets.QTreeWidgetItem(row) for row in zip(*items)]
self.tree.addTopLevelItems(items)
self.tree.setSortingEnabled(
self.sort.checkState() == QtCore.Qt.Checked)
def _display(self, position):
self.tree.setSortingEnabled(False)
self.tree.clear()
df = self.df.iloc[max(0, position * 10 -
50):max(0, position * 10 + 100)]
if df.index.dtype.kind == 'M':
index = df.index.tz_localize('UTC').tz_convert(LOCAL_TIMEZONE)
else:
index = df.index
items = [
index.astype(str),
]
for name in df:
column = df[name]
kind = column.dtype.kind
if name.endswith('CAN_DataFrame.ID'):
items.append(
pd.Series(csv_int2hex(df[name].astype('<u4'))).values)
else:
if kind in 'uif':
items.append(column.astype(str))
elif kind == 'S':
try:
items.append(npchar.decode(column, 'utf-8'))
except:
items.append(npchar.decode(column, 'latin-1'))
elif kind == 'O':
items.append(pd.Series(csv_bytearray2hex(df[name])).values)
else:
items.append(column)
if position == 0:
self.tree.verticalScrollBar().setSliderPosition(0)
elif position == self.tree_scroll.maximum():
self.tree.verticalScrollBar().setSliderPosition(
self.tree.verticalScrollBar().maximum())
items = [QtWidgets.QTreeWidgetItem(row) for row in zip(*items)]
self.tree.addTopLevelItems(items)
self.tree.setSortingEnabled(
self.sort.checkState() == QtCore.Qt.Checked)
def build(self, df):
self.tree.setSortingEnabled(False)
self.tree.clear()
dropped = {}
for name_ in df.columns:
if name_.endswith('CAN_DataFrame.ID'):
dropped[name_] = pd.Series(csv_int2hex(
df[name_].astype('<u4')),
index=df.index)
df = df.drop(columns=list(dropped))
for name, s in dropped.items():
df[name] = s
names = [df.index.name, *df.columns]
self.tree.setColumnCount(len(names))
self.tree.setHeaderLabels(names)
if df.index.dtype.kind == 'M':
index = df.index.tz_localize('UTC').tz_convert(LOCAL_TIMEZONE)
else:
index = df.index
items = [
index.astype(str),
]
for name in df:
column = df[name]
kind = column.dtype.kind
if kind in 'uif':
items.append(column.astype(str))
elif kind == 'S':
try:
items.append(npchar.decode(column, 'utf-8'))
except:
items.append(npchar.decode(column, 'latin-1'))
else:
items.append(column)
items = [TreeItem(row) for row in zip(*items)]
self.tree.addTopLevelItems(items)
def __init__(self, signals=None, start=0, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self.signals_descr = {}
self.start = start
if signals is None:
self.signals = pd.DataFrame()
else:
dropped = {}
for name_ in signals.columns:
col = signals[name_]
if col.dtype.kind == 'O':
dropped[name_] = pd.Series(csv_bytearray2hex(col),
index=signals.index)
self.signals_descr[name_] = 1
elif col.dtype.kind == 'S':
try:
dropped[name_] = pd.Series(npchar.decode(col, 'utf-8'),
index=signals.index)
except:
dropped[name_] = pd.Series(npchar.decode(
col, 'latin-1'),
index=signals.index)
self.signals_descr[name_] = 0
else:
self.signals_descr[name_] = 0
signals = signals.drop(columns=list(dropped))
for name, s in dropped.items():
signals[name] = s
self.signals = signals
self._original_index = self.signals.index.values
self.build(self.signals)
self.add_filter_btn.clicked.connect(self.add_filter)
self.apply_filters_btn.clicked.connect(self.apply_filters)
self.sort.stateChanged.connect(self.sorting_changed)
self.time_as_date.stateChanged.connect(self.time_as_date_changed)
def accept(self):
self.filename = self.selectedFiles()[0]
self.f_enc = self.encoding()
self.p_wid.clear()
try:
dat_str = np.genfromtxt(self.filename,delimiter=",",dtype=np.str)
self.p_wid.dat_str = def_c.decode(dat_str,encoding=self.f_enc)
self.p_wid.LiE_selectfile.setText(self.filename)
self.p_wid.update_csv_str()
return QgsEncodingFileDialog.accept(self)
except:
msg = u"ファイルの文字コードが\n\r%sではありません" % self.f_enc
QMessageBox.warning(self,u"インポートエラー",msg)
def __getitem__(self, k):
"""
@brief get a target from the database
@param k name of target group or array
@return the returned value depends on the type of the target:
- An existing hdf5 group will return an instance of hdf5_wrapper
- An existing array will return an numpy ndarray
- If the target is not present in the datastructure and the
database is open in read/write mode, the wrapper will create a
new group and return an hdf5_wrapper
- Otherwise, this will throw an error
"""
if (k not in self.target):
if (self.mode in ['w', 'a']):
self.target.create_group(k)
else:
raise ValueError('Entry does not exist in database: %s' % (k))
tmp = self.target[k]
if isinstance(tmp, h5py._hl.group.Group):
return hdf5_wrapper(target=tmp, mode=self.mode)
elif isinstance(tmp, h5py._hl.dataset.Dataset):
tmp = np.array(tmp)
# Decode any string types
if (tmp.dtype.kind in ['S', 'U', 'O']):
tmp = decode(tmp)
# Convert any 0-length arrays to native types
if not tmp.shape:
tmp = tmp[()]
return tmp
else:
return tmp
def __init__(self, signals=None, start=0, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self.signals_descr = {}
self.start = start
if signals is None:
self.signals = pd.DataFrame()
else:
dropped = {}
for name_ in signals.columns:
col = signals[name_]
if col.dtype.kind == "O":
# dropped[name_] = pd.Series(csv_bytearray2hex(col), index=signals.index)
self.signals_descr[name_] = 1
elif col.dtype.kind == "S":
try:
dropped[name_] = pd.Series(npchar.decode(col, "utf-8"),
index=signals.index)
except:
dropped[name_] = pd.Series(npchar.decode(
col, "latin-1"),
index=signals.index)
self.signals_descr[name_] = 0
else:
self.signals_descr[name_] = 0
signals = signals.drop(columns=list(dropped))
for name, s in dropped.items():
signals[name] = s
self.signals = signals
self.as_hex = [
name.endswith((
"CAN_DataFrame.ID",
"FLX_Frame.ID",
"FlexRay_DataFrame.ID",
"LIN_Frame.ID",
"MOST_DataFrame.ID",
"ETH_Frame.ID",
)) for name in self.signals.columns
]
self._original_index = self.signals.index.values
self.build(self.signals, True)
self.add_filter_btn.clicked.connect(self.add_filter)
self.apply_filters_btn.clicked.connect(self.apply_filters)
self.sort.stateChanged.connect(self.sorting_changed)
self.time_as_date.stateChanged.connect(self.time_as_date_changed)
self.remove_prefix.stateChanged.connect(self.remove_prefix_changed)
self.tree.header().sortIndicatorChanged.connect(self._sort)
prefixes = set()
for name in self.signals.columns:
while "." in name:
name = name.rsplit(".", 1)[0]
prefixes.add(f"{name}.")
self.prefix.insertItems(0, sorted(prefixes))
self.prefix.setEnabled(False)
self.prefix.currentIndexChanged.connect(self.prefix_changed)
self.tree_scroll.valueChanged.connect(self._display)
self.tree.verticalScrollBar().valueChanged.connect(self._scroll_tree)
def __init__(self, signals=None, start=0, format="phys", *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self.tree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.tree.customContextMenuRequested.connect(self.open_menu)
self.signals_descr = {}
self.start = start
self.pattern = {}
self.format = format
self.format_selection.setCurrentText(format)
if signals is None:
self.signals = pd.DataFrame()
else:
index = pd.Series(np.arange(len(signals), dtype="u8"),
index=signals.index)
signals["Index"] = index
signals["timestamps"] = signals.index
signals.set_index(index, inplace=True)
dropped = {}
for name_ in signals.columns:
col = signals[name_]
if col.dtype.kind == "O":
if (name_.endswith(".DataBytes") and name_.replace(
".DataBytes", ".DataLength") in signals):
dropped[name_] = pd.Series(
csv_bytearray2hex(
col,
signals[name_.replace(".DataBytes",
".DataLength")]),
index=signals.index,
)
else:
dropped[name_] = pd.Series(csv_bytearray2hex(col),
index=signals.index)
self.signals_descr[name_] = 0
elif col.dtype.kind == "S":
try:
dropped[name_] = pd.Series(npchar.decode(col, "utf-8"),
index=signals.index)
except:
dropped[name_] = pd.Series(npchar.decode(
col, "latin-1"),
index=signals.index)
self.signals_descr[name_] = 0
else:
self.signals_descr[name_] = 0
signals = signals.drop(columns=["Index", *list(dropped)])
for name, s in dropped.items():
signals[name] = s
names = list(signals.columns)
names = [
"timestamps",
*[
name
for name in names if name.endswith((".ID", ".DataBytes"))
],
*[
name for name in names if name != "timestamps"
and not name.endswith((".ID", ".DataBytes"))
],
]
self.signals = signals[names]
self.as_hex = [
name.endswith((
"CAN_DataFrame.ID",
"FLX_Frame.ID",
"FLX_DataFrame.ID",
"LIN_Frame.ID",
"MOST_DataFrame.ID",
"ETH_Frame.ID",
)) for name in self.signals.columns
]
self._original_timestamps = signals["timestamps"]
self.build(self.signals, True)
self.add_filter_btn.clicked.connect(self.add_filter)
self.apply_filters_btn.clicked.connect(self.apply_filters)
self.sort.stateChanged.connect(self.sorting_changed)
self.time_as_date.stateChanged.connect(self.time_as_date_changed)
self.remove_prefix.stateChanged.connect(self.remove_prefix_changed)
self.tree.header().sortIndicatorChanged.connect(self._sort)
prefixes = set()
for name in self.signals.columns:
while "." in name:
name = name.rsplit(".", 1)[0]
prefixes.add(f"{name}.")
self.filters.minimal_menu = True
self.prefix.insertItems(0, sorted(prefixes, key=lambda x:
(-len(x), x)))
self.prefix.setEnabled(False)
self.prefix.currentIndexChanged.connect(self.prefix_changed)
if prefixes:
self.remove_prefix.setCheckState(QtCore.Qt.Checked)
self.tree_scroll.valueChanged.connect(self._display)
self.tree.verticalScrollBar().valueChanged.connect(self._scroll_tree)
self.tree.currentItemChanged.connect(self._scroll_tree)
self.format_selection.currentTextChanged.connect(self.set_format)
self._settings = QtCore.QSettings()
integer_mode = self._settings.value("tabular_format", "phys")
self.format_selection.setCurrentText(integer_mode)
def __init__(self, signals=None, start=0, format="phys", *args, **kwargs):
super().__init__(*args, **kwargs)
self.signals_descr = {}
self.start = start
self.pattern = {}
self.format = format
self.format_selection.setCurrentText(format)
if signals is None:
self.signals = pd.DataFrame()
else:
index = pd.Series(np.arange(len(signals), dtype="u8"), index=signals.index)
signals["Index"] = index
signals["timestamps"] = signals.index
signals.set_index(index, inplace=True)
dropped = {}
for name_ in signals.columns:
col = signals[name_]
if col.dtype.kind == "O":
if name_.endswith("DataBytes"):
try:
sizes = signals[name_.replace("DataBytes", "DataLength")]
except:
sizes = None
dropped[name_] = pd.Series(
csv_bytearray2hex(
col,
sizes,
),
index=signals.index,
)
elif name_.endswith("Data Bytes"):
try:
sizes = signals[name_.replace("Data Bytes", "Data Length")]
except:
sizes = None
dropped[name_] = pd.Series(
csv_bytearray2hex(
col,
sizes,
),
index=signals.index,
)
elif col.dtype.name != 'category':
try:
dropped[name_] = pd.Series(
csv_bytearray2hex(col), index=signals.index
)
except:
pass
self.signals_descr[name_] = 0
elif col.dtype.kind == "S":
try:
dropped[name_] = pd.Series(
npchar.decode(col, "utf-8"), index=signals.index
)
except:
dropped[name_] = pd.Series(
npchar.decode(col, "latin-1"), index=signals.index
)
self.signals_descr[name_] = 0
else:
self.signals_descr[name_] = 0
signals = signals.drop(columns=["Index", *list(dropped)])
for name, s in dropped.items():
signals[name] = s
names = list(signals.columns)
names = [
"timestamps",
*[name for name in names if name.endswith((".ID", ".DataBytes"))],
*[
name
for name in names
if name != "timestamps" and not name.endswith((".ID", ".DataBytes"))
],
]
self.signals = signals[names]
self._original_timestamps = signals["timestamps"]
self.build(self.signals, True)
prefixes = set()
for name in self.signals.columns:
while "." in name:
name = name.rsplit(".", 1)[0]
prefixes.add(f"{name}.")
self.filters.minimal_menu = True
self.prefix.insertItems(0, sorted(prefixes, key=lambda x: (-len(x), x)))
self.prefix.setEnabled(False)
self.prefix.currentIndexChanged.connect(self.prefix_changed)
if prefixes:
self.remove_prefix.setCheckState(QtCore.Qt.Checked)
self._settings = QtCore.QSettings()
integer_mode = self._settings.value("tabular_format", "phys")
self.format_selection.setCurrentText(integer_mode)
def display(self, pos):
if self.pass_display:
self.current_pos = pos
return
if not self.repeat_display:
self.tree_scroll.setMaximum(
self.tree.verticalScrollBar().maximum())
self.tree_scroll.setMinimum(
self.tree.verticalScrollBar().minimum())
self.tree.verticalScrollBar().setValue(self.tree_scroll.value())
return
if pos >= self.max_pos:
pos = self.max_pos - 1
if pos <= 0:
pos = 0
self.tree.clear()
df_first_index = self.pos_array[pos][4]
df_last_index = self.pos_array[pos][5]
df = self.signals.iloc[df_first_index:df_last_index + 1]
if df.index.dtype.kind == "M":
index = df.index.tz_localize("UTC").tz_convert(LOCAL_TIMEZONE)
else:
index = df.index
items = [
index.astype(str),
]
for i, name in enumerate(df.columns):
column = df[name]
kind = column.dtype.kind
if self.as_hex[i - 1]:
items.append(
pd.Series(csv_int2hex(column.astype("<u4"))).values)
else:
if kind in "uif":
items.append(column.astype(str))
elif kind == "S":
try:
items.append(npchar.decode(column, "utf-8"))
except:
items.append(npchar.decode(column, "latin-1"))
elif kind == "O":
try:
items.append(
pd.Series(csv_bytearray2hex(df[name])).values)
except:
items.append(pd.Series(df[name]).values)
else:
items.append(column)
items = [QtWidgets.QTreeWidgetItem(row) for row in zip(*items)]
self.tree.addTopLevelItems(items)
self.tree.setSortingEnabled(
self.sort.checkState() == QtCore.Qt.Checked)
del [[df]]
gc.collect()
self.current_pos = pos
if self.tree_scroll.maximum() != self.tree_scroll.value():
pass
else:
self.tree.verticalScrollBar().setValue(
self.tree.verticalScrollBar().maximum())
if self.tree_scroll.minimum() != self.tree_scroll.value():
pass
else:
if self.with_scroll:
self.tree.verticalScrollBar().setValue(1)
else:
self.tree.verticalScrollBar().setValue(0)
if self.size <= self.view_count * 5:
self.repeat_display = False
if self.size <= self.view_count:
self.tree_scroll.setMaximum(0)
self.tree_scroll.setMinimum(0)
self.with_scroll = False
