diff --git a/larray_editor/arrayadapter.py b/larray_editor/arrayadapter.py
index 8cfbae9..d04e9a3 100644
--- a/larray_editor/arrayadapter.py
+++ b/larray_editor/arrayadapter.py
@@ -6,13 +6,15 @@
class LArrayDataAdapter(object):
- def __init__(self, axes_model, xlabels_model, ylabels_model, data_model,
- data=None, changes=None, current_filter=None, bg_gradient=None, bg_value=None):
+ def __init__(self, axes_model, hlabels_model, vlabels_model, data_model, data=None,
+ changes=None, current_filter=None, nb_dims_hlabels=1, bg_gradient=None, bg_value=None):
# set models
self.axes_model = axes_model
- self.xlabels_model = xlabels_model
- self.ylabels_model = ylabels_model
+ self.hlabels_model = hlabels_model
+ self.vlabels_model = vlabels_model
self.data_model = data_model
+ # set number of dims of hlabels
+ self.nb_dims_hlabels = nb_dims_hlabels
# set current filter
if current_filter is None:
current_filter = {}
@@ -31,38 +33,49 @@ def set_changes(self, changes=None):
assert isinstance(changes, dict)
self.changes = changes
+ def update_nb_dims_hlabels(self, nb_dims_hlabels):
+ self.nb_dims_hlabels = nb_dims_hlabels
+ self.update_axes_and_labels()
+
def get_axes_names(self):
return self.filtered_data.axes.display_names
def get_axes(self):
- axes = self.filtered_data.axes
+ axes_names = self.filtered_data.axes.display_names
# test self.filtered_data.size == 0 is required in case an instance built as LArray([]) is passed
# test len(axes) == 0 is required when a user filters until to get a scalar
- if self.filtered_data.size == 0 or len(axes) == 0:
+ if self.filtered_data.size == 0 or len(axes_names) == 0:
return None
+ elif len(axes_names) == 1:
+ return [axes_names]
else:
- axes_names = axes.display_names
- if len(axes_names) >= 2:
- axes_names = axes_names[:-2] + [axes_names[-2] + '\\' + axes_names[-1]]
- return [[axis_name] for axis_name in axes_names]
+ nb_dims_vlabels = len(axes_names) - self.nb_dims_hlabels
+ # axes corresponding to horizontal labels are set to the last column
+ res = [['' for c in range(nb_dims_vlabels-1)] + [axis_name] for axis_name in axes_names[nb_dims_vlabels:]]
+ # axes corresponding to vertical labels are set to the last row
+ res = res + [[axis_name for axis_name in axes_names[:nb_dims_vlabels]]]
+ return res
- def get_xlabels(self):
+ def get_labels(self):
axes = self.filtered_data.axes
if self.filtered_data.size == 0 or len(axes) == 0:
- return None
+ vlabels = None
+ hlabels = None
else:
- return [[label] for label in axes.labels[-1]]
-
- def get_ylabels(self):
- axes = self.filtered_data.axes
- if self.filtered_data.size == 0 or len(axes) == 0:
- return None
- elif len(axes) == 1:
- return [['']]
- else:
- labels = axes.labels[:-1]
- prod = Product(labels)
- return [_LazyDimLabels(prod, i) for i in range(len(labels))]
+ nb_dims_vlabels = len(axes) - self.nb_dims_hlabels
+ def get_labels_product(axes, extra_row=False):
+ if len(axes) == 0:
+ return [[' ']]
+ else:
+ # XXX: appends a fake axis instead of using _LazyNone because
+ # _LazyNone mess up with LabelsArrayModel.get_values (in which slices are used)
+ if extra_row:
+ axes.append(la.Axis([' ']))
+ prod = Product(axes.labels)
+ return [_LazyDimLabels(prod, i) for i in range(len(axes.labels))]
+ vlabels = get_labels_product(axes[:nb_dims_vlabels])
+ hlabels = get_labels_product(axes[nb_dims_vlabels:], nb_dims_vlabels > 0)
+ return vlabels, hlabels
def get_2D_data(self):
"""Returns Numpy 2D ndarray"""
@@ -109,6 +122,20 @@ def set_data(self, data, bg_value=None, current_filter=None):
self.bg_value = la.aslarray(bg_value) if bg_value is not None else None
self.update_filtered_data(current_filter, reset_minmax=True)
+ def update_axes_and_labels(self):
+ axes = self.get_axes()
+ vlabels, hlabels = self.get_labels()
+ self.axes_model.set_data(axes)
+ self.hlabels_model.set_data(hlabels)
+ self.vlabels_model.set_data(vlabels)
+
+ def update_data_2D(self, reset_minmax=False):
+ data_2D = self.get_2D_data()
+ changes_2D = self.get_changes_2D()
+ bg_value_2D = self.get_bg_value_2D(data_2D.shape)
+ self.data_model.set_data(data_2D, changes_2D, reset_minmax=reset_minmax)
+ self.data_model.set_bg_value(bg_value_2D)
+
def update_filtered_data(self, current_filter=None, reset_minmax=False):
if current_filter is not None:
assert isinstance(current_filter, dict)
@@ -116,17 +143,8 @@ def update_filtered_data(self, current_filter=None, reset_minmax=False):
self.filtered_data = self.la_data[self.current_filter]
if np.isscalar(self.filtered_data):
self.filtered_data = la.aslarray(self.filtered_data)
- axes = self.get_axes()
- xlabels = self.get_xlabels()
- ylabels = self.get_ylabels()
- data_2D = self.get_2D_data()
- changes_2D = self.get_changes_2D()
- bg_value_2D = self.get_bg_value_2D(data_2D.shape)
- self.axes_model.set_data(axes)
- self.xlabels_model.set_data(xlabels)
- self.ylabels_model.set_data(ylabels)
- self.data_model.set_data(data_2D, changes_2D, reset_minmax=reset_minmax)
- self.data_model.set_bg_value(bg_value_2D)
+ self.update_axes_and_labels()
+ self.update_data_2D(reset_minmax=reset_minmax)
def get_data(self):
return self.la_data
diff --git a/larray_editor/arraymodel.py b/larray_editor/arraymodel.py
index 96a49f8..393720f 100644
--- a/larray_editor/arraymodel.py
+++ b/larray_editor/arraymodel.py
@@ -125,7 +125,8 @@ class LabelsArrayModel(AbstractArrayModel):
font : QFont, optional
Font. Default is `Calibri` with size 11.
"""
- def __init__(self, parent=None, data=None, readonly=False, font=None):
+ def __init__(self, parent=None, data=None, readonly=False, font=None, orientation=Qt.Horizontal):
+ self.orientation = orientation
AbstractArrayModel.__init__(self, parent, data, readonly, font)
self.font.setBold(True)
@@ -136,8 +137,12 @@ def _set_data(self, data, changes=None):
QMessageBox.critical(self.dialog, "Error", "Expected list or tuple.")
data = [[]]
self._data = data
- self.total_rows = len(data[0])
- self.total_cols = len(data) if self.total_rows > 0 else 0
+ if self.orientation == Qt.Horizontal:
+ self.total_rows = len(data) if self.total_cols > 0 else 0
+ self.total_cols = len(data[0])
+ else:
+ self.total_rows = len(data[0])
+ self.total_cols = len(data) if self.total_rows > 0 else 0
self._compute_rows_cols_loaded()
def flags(self, index):
@@ -145,19 +150,26 @@ def flags(self, index):
return Qt.ItemIsEnabled
def get_value(self, index):
- i = index.row()
- j = index.column()
- # we need to inverse column and row because of the way ylabels are generated
- return str(self._data[j][i])
+ if self.orientation == Qt.Horizontal:
+ i, j = index.row(), index.column()
+ else:
+ i, j = index.column(), index.row()
+ return str(self._data[i][j])
# XXX: I wonder if we shouldn't return a 2D Numpy array of strings?
def get_values(self, left=0, top=0, right=None, bottom=None):
- if right is None:
- right = self.total_rows
- if bottom is None:
- bottom = self.total_cols
- values = [list(line[left:right]) for line in self._data[top:bottom]]
- return values
+ if self.orientation == Qt.Horizontal:
+ if right is None:
+ right = self.total_cols
+ if bottom is None:
+ bottom = self.total_rows
+ return [list(line[left:right]) for line in self._data[top:bottom]]
+ else:
+ if right is None:
+ right = self.total_rows
+ if bottom is None:
+ bottom = self.total_cols
+ return [list(line[top:bottom]) for line in self._data[left:right]]
def data(self, index, role=Qt.DisplayRole):
# print('data', index.column(), index.row(), self.rowCount(), self.columnCount(), '\n', self._data)
diff --git a/larray_editor/arraywidget.py b/larray_editor/arraywidget.py
index 5b8d7d1..291bd70 100644
--- a/larray_editor/arraywidget.py
+++ b/larray_editor/arraywidget.py
@@ -536,17 +536,17 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
self.model_axes = LabelsArrayModel(parent=self, readonly=readonly)
self.view_axes = LabelsView(parent=self, model=self.model_axes, position=(TOP, LEFT))
- self.model_xlabels = LabelsArrayModel(parent=self, readonly=readonly)
- self.view_xlabels = LabelsView(parent=self, model=self.model_xlabels, position=(TOP, RIGHT))
+ self.model_hlabels = LabelsArrayModel(parent=self, readonly=readonly)
+ self.view_hlabels = LabelsView(parent=self, model=self.model_hlabels, position=(TOP, RIGHT))
- self.model_ylabels = LabelsArrayModel(parent=self, readonly=readonly)
- self.view_ylabels = LabelsView(parent=self, model=self.model_ylabels, position=(BOTTOM, LEFT))
+ self.model_vlabels = LabelsArrayModel(parent=self, readonly=readonly, orientation=Qt.Vertical)
+ self.view_vlabels = LabelsView(parent=self, model=self.model_vlabels, position=(BOTTOM, LEFT))
self.model_data = DataArrayModel(parent=self, readonly=readonly, minvalue=minvalue, maxvalue=maxvalue)
self.view_data = DataView(parent=self, model=self.model_data, dtype=data.dtype, shape=data.shape)
- self.data_adapter = LArrayDataAdapter(axes_model=self.model_axes, xlabels_model=self.model_xlabels,
- ylabels_model=self.model_ylabels, data_model=self.model_data, data=data,
+ self.data_adapter = LArrayDataAdapter(axes_model=self.model_axes, hlabels_model=self.model_hlabels,
+ vlabels_model=self.model_vlabels, data_model=self.model_data, data=data,
bg_value=bg_value, bg_gradient=bg_gradient)
# Create vertical and horizontal scrollbars
@@ -554,15 +554,15 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
self.hscrollbar = ScrollBar(self, self.view_data.horizontalScrollBar())
# Synchronize resizing
- self.view_axes.horizontalHeader().sectionResized.connect(self.view_ylabels.updateSectionWidth)
- self.view_axes.verticalHeader().sectionResized.connect(self.view_xlabels.updateSectionHeight)
- self.view_xlabels.horizontalHeader().sectionResized.connect(self.view_data.updateSectionWidth)
- self.view_ylabels.verticalHeader().sectionResized.connect(self.view_data.updateSectionHeight)
+ self.view_axes.horizontalHeader().sectionResized.connect(self.view_vlabels.updateSectionWidth)
+ self.view_axes.verticalHeader().sectionResized.connect(self.view_hlabels.updateSectionHeight)
+ self.view_hlabels.horizontalHeader().sectionResized.connect(self.view_data.updateSectionWidth)
+ self.view_vlabels.verticalHeader().sectionResized.connect(self.view_data.updateSectionHeight)
# Synchronize auto-resizing
self.view_axes.horizontalHeader().sectionHandleDoubleClicked.connect(self.resize_axes_column_to_contents)
- self.view_xlabels.horizontalHeader().sectionHandleDoubleClicked.connect(self.resize_xlabels_column_to_contents)
+ self.view_hlabels.horizontalHeader().sectionHandleDoubleClicked.connect(self.resize_hlabels_column_to_contents)
self.view_axes.verticalHeader().sectionHandleDoubleClicked.connect(self.resize_axes_row_to_contents)
- self.view_ylabels.verticalHeader().sectionHandleDoubleClicked.connect(self.resize_ylabels_row_to_contents)
+ self.view_vlabels.verticalHeader().sectionHandleDoubleClicked.connect(self.resize_vlabels_row_to_contents)
# synchronize specific methods
self.view_axes.allSelected.connect(self.view_data.selectAll)
@@ -572,18 +572,18 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
self.view_data.signal_plot.connect(self.plot)
# Synchronize scrolling
- # data <--> xlabels
- self.view_data.horizontalScrollBar().valueChanged.connect(self.view_xlabels.horizontalScrollBar().setValue)
- self.view_xlabels.horizontalScrollBar().valueChanged.connect(self.view_data.horizontalScrollBar().setValue)
- # data <--> ylabels
- self.view_data.verticalScrollBar().valueChanged.connect(self.view_ylabels.verticalScrollBar().setValue)
- self.view_ylabels.verticalScrollBar().valueChanged.connect(self.view_data.verticalScrollBar().setValue)
+ # data <--> hlabels
+ self.view_data.horizontalScrollBar().valueChanged.connect(self.view_hlabels.horizontalScrollBar().setValue)
+ self.view_hlabels.horizontalScrollBar().valueChanged.connect(self.view_data.horizontalScrollBar().setValue)
+ # data <--> vlabels
+ self.view_data.verticalScrollBar().valueChanged.connect(self.view_vlabels.verticalScrollBar().setValue)
+ self.view_vlabels.verticalScrollBar().valueChanged.connect(self.view_data.verticalScrollBar().setValue)
# Synchronize selecting columns(rows) via hor.(vert.) header of x(y)labels view
- self.view_xlabels.horizontalHeader().sectionPressed.connect(self.view_data.selectColumn)
- self.view_xlabels.horizontalHeader().sectionEntered.connect(self.view_data.selectNewColumn)
- self.view_ylabels.verticalHeader().sectionPressed.connect(self.view_data.selectRow)
- self.view_ylabels.verticalHeader().sectionEntered.connect(self.view_data.selectNewRow)
+ self.view_hlabels.horizontalHeader().sectionPressed.connect(self.view_data.selectColumn)
+ self.view_hlabels.horizontalHeader().sectionEntered.connect(self.view_data.selectNewColumn)
+ self.view_vlabels.verticalHeader().sectionPressed.connect(self.view_data.selectRow)
+ self.view_vlabels.verticalHeader().sectionEntered.connect(self.view_data.selectNewRow)
# following lines are required to keep usual selection color
# when selecting rows/columns via headers of label views.
@@ -598,17 +598,17 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
array_frame.setFrameStyle(QFrame.StyledPanel)
# remove borders of internal tables
self.view_axes.setFrameStyle(QFrame.NoFrame)
- self.view_xlabels.setFrameStyle(QFrame.NoFrame)
- self.view_ylabels.setFrameStyle(QFrame.NoFrame)
+ self.view_hlabels.setFrameStyle(QFrame.NoFrame)
+ self.view_vlabels.setFrameStyle(QFrame.NoFrame)
self.view_data.setFrameStyle(QFrame.NoFrame)
# Set layout of table views:
- # [ axes ][xlabels]|V|
- # [ylabels][ data ]|s|
+ # [ axes ][vlabels]|V|
+ # [hlabels][ data ]|s|
# | H. scrollbar |
array_layout = QGridLayout()
array_layout.addWidget(self.view_axes, 0, 0)
- array_layout.addWidget(self.view_xlabels, 0, 1)
- array_layout.addWidget(self.view_ylabels, 1, 0)
+ array_layout.addWidget(self.view_hlabels, 0, 1)
+ array_layout.addWidget(self.view_vlabels, 1, 0)
self.view_data.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
array_layout.addWidget(self.view_data, 1, 1)
array_layout.addWidget(self.vscrollbar, 0, 2, 2, 1)
@@ -662,6 +662,13 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
btn_layout.addWidget(gradient_chooser)
self.gradient_chooser = gradient_chooser
+ label = QLabel("Horizontal Dimensions")
+ btn_layout.addWidget(label)
+ spin = QSpinBox(self)
+ spin.valueChanged.connect(self.nb_horizontal_dims_changed)
+ self.nb_horizontal_dims_spinbox = spin
+ btn_layout.addWidget(spin)
+
# Set widget layout
layout = QVBoxLayout()
layout.addLayout(self.filters_layout)
@@ -675,6 +682,8 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
# See http://doc.qt.io/qt-4.8/qt-draganddrop-fridgemagnets-dragwidget-cpp.html for an example
self.setAcceptDrops(True)
+ self._raw_data_selection = None
+
def gradient_changed(self, index):
gradient = self.gradient_chooser.itemData(index) if index > 0 else None
self.model_data.set_bg_gradient(gradient)
@@ -760,8 +769,9 @@ def set_data(self, data=None, bg_value=None):
axes = la_data.axes
display_names = axes.display_names
- # update data format and bgcolor
- self._update_digits_scientific(la_data)
+ # update data format and bgcolor + dim spinbox
+ self._update_digits_scientific_dims(la_data)
+ self.nb_horizontal_dims_spinbox.setValue(1)
# update filters
filters_layout = self.filters_layout
@@ -777,11 +787,11 @@ def set_data(self, data=None, bg_value=None):
# reset default size
self.view_axes.set_default_size()
- self.view_ylabels.set_default_size()
- self.view_xlabels.set_default_size()
+ self.view_hlabels.set_default_size()
+ self.view_vlabels.set_default_size()
self.view_data.set_default_size()
- def _update_digits_scientific(self, data):
+ def _update_digits_scientific_dims(self, data):
"""
data : LArray
"""
@@ -810,6 +820,9 @@ def _update_digits_scientific(self, data):
self.gradient_chooser.setEnabled(self.model_data.bgcolor_possible)
+ self.nb_horizontal_dims_spinbox.setMinimum(1)
+ self.nb_horizontal_dims_spinbox.setMaximum(max(1, self.data_adapter.ndim - 1))
+
def choose_scientific(self, data):
# max_digits = self.get_max_digits()
# default width can fit 8 chars
@@ -902,37 +915,37 @@ def autofit_columns(self):
self.view_axes.autofit_columns()
for column in range(self.model_axes.columnCount()):
self.resize_axes_column_to_contents(column)
- self.view_xlabels.autofit_columns()
- for column in range(self.model_xlabels.columnCount()):
- self.resize_xlabels_column_to_contents(column)
+ self.view_hlabels.autofit_columns()
+ for column in range(self.model_hlabels.columnCount()):
+ self.resize_hlabels_column_to_contents(column)
def resize_axes_column_to_contents(self, column):
# must be connected to view_axes.horizontalHeader().sectionHandleDoubleClicked signal
width = max(self.view_axes.horizontalHeader().sectionSize(column),
- self.view_ylabels.sizeHintForColumn(column))
- # no need to call resizeSection on view_ylabels (see synchronization lines in init)
+ self.view_vlabels.sizeHintForColumn(column))
+ # no need to call resizeSection on view_vlabels (see synchronization lines in init)
self.view_axes.horizontalHeader().resizeSection(column, width)
- def resize_xlabels_column_to_contents(self, column):
+ def resize_hlabels_column_to_contents(self, column):
# must be connected to view_labels.horizontalHeader().sectionHandleDoubleClicked signal
- width = max(self.view_xlabels.horizontalHeader().sectionSize(column),
+ width = max(self.view_hlabels.horizontalHeader().sectionSize(column),
self.view_data.sizeHintForColumn(column))
# no need to call resizeSection on view_data (see synchronization lines in init)
- self.view_xlabels.horizontalHeader().resizeSection(column, width)
+ self.view_hlabels.horizontalHeader().resizeSection(column, width)
def resize_axes_row_to_contents(self, row):
# must be connected to view_axes.verticalHeader().sectionHandleDoubleClicked
height = max(self.view_axes.verticalHeader().sectionSize(row),
- self.view_xlabels.sizeHintForRow(row))
- # no need to call resizeSection on view_xlabels (see synchronization lines in init)
+ self.view_hlabels.sizeHintForRow(row))
+ # no need to call resizeSection on view_hlabels (see synchronization lines in init)
self.view_axes.verticalHeader().resizeSection(row, height)
- def resize_ylabels_row_to_contents(self, row):
+ def resize_vlabels_row_to_contents(self, row):
# must be connected to view_labels.verticalHeader().sectionHandleDoubleClicked
- height = max(self.view_ylabels.verticalHeader().sectionSize(row),
+ height = max(self.view_vlabels.verticalHeader().sectionSize(row),
self.view_data.sizeHintForRow(row))
# no need to call resizeSection on view_data (see synchronization lines in init)
- self.view_ylabels.verticalHeader().resizeSection(row, height)
+ self.view_vlabels.verticalHeader().resizeSection(row, height)
@property
def dirty(self):
@@ -942,7 +955,7 @@ def dirty(self):
def accept_changes(self):
"""Accept changes"""
la_data = self.data_adapter.accept_changes()
- self._update_digits_scientific(la_data)
+ self._update_digits_scientific_dims(la_data)
def reject_changes(self):
"""Reject changes"""
@@ -967,6 +980,9 @@ def digits_changed(self, value):
self.digits = value
self.model_data.set_format(self.cell_format)
+ def nb_horizontal_dims_changed(self, value):
+ self.data_adapter.update_nb_dims_hlabels(value)
+
def create_filter_combo(self, axis):
def filter_changed(checked_items):
self.data_adapter.change_filter(axis, checked_items)
@@ -1001,17 +1017,17 @@ def _selection_data(self, headers=True, none_selects_all=True):
if not self.data_adapter.ndim:
return raw_data
# FIXME: this is extremely ad-hoc.
- # TODO: in the future (pandas-based branch) we should use to_string(data[self._selection_filter()])
+ # TODO: in the future (multi_index supported) we should use to_string(data[self._selection_filter()])
dim_headers = self.model_axes.get_values()
- xlabels = self.model_xlabels.get_values(top=col_min, bottom=col_max)
- topheaders = [[dim_header[0] for dim_header in dim_headers] + [label[0] for label in xlabels]]
+ hlabels = self.model_hlabels.get_values(left=col_min, right=col_max)
+ topheaders = [dims + labels for dims, labels in zip(dim_headers, hlabels)]
if self.data_adapter.ndim == 1:
return chain(topheaders, [chain([''], row) for row in raw_data])
else:
assert self.data_adapter.ndim > 1
- ylabels = self.model_ylabels.get_values(left=row_min, right=row_max)
+ vlabels = self.model_vlabels.get_values(top=row_min, bottom=row_max)
return chain(topheaders,
- [chain([ylabels[j][r] for j in range(len(ylabels))], row)
+ [chain([vlabels[j][r] for j in range(len(vlabels))], row)
for r, row in enumerate(raw_data)])
else:
return raw_data
@@ -1033,6 +1049,8 @@ def vrepr(v):
clipboard = QApplication.clipboard()
clipboard.setText(text)
+ self._raw_data_selection = self._selection_data(headers=False)
+
def to_excel(self):
"""View selection in Excel"""
if xw is None:
@@ -1052,22 +1070,25 @@ def paste(self):
if bounds is None:
return
row_min, row_max, col_min, col_max = bounds
- clipboard = QApplication.clipboard()
- text = str(clipboard.text())
- list_data = [line.split('\t') for line in text.splitlines()]
- try:
- # take the first cell which contains '\'
- pos_last = next(i for i, v in enumerate(list_data[0]) if '\\' in v)
- except StopIteration:
- # if there isn't any, assume 1d array
- pos_last = 0
- if pos_last:
- # ndim > 1
- list_data = [line[pos_last + 1:] for line in list_data[1:]]
- elif len(list_data) == 2 and list_data[1][0] == '':
- # ndim == 1
- list_data = [list_data[1][1:]]
- new_data = np.array(list_data)
+ # clipboard = QApplication.clipboard()
+ # text = str(clipboard.text())
+ # list_data = [line.split('\t') for line in text.splitlines()]
+ # try:
+ # # take the first cell which contains '\'
+ # pos_last = next(i for i, v in enumerate(list_data[0]) if '\\' in v)
+ # except StopIteration:
+ # # if there isn't any, assume 1d array
+ # pos_last = 0
+ # if pos_last:
+ # # ndim > 1
+ # list_data = [line[pos_last + 1:] for line in list_data[1:]]
+ # elif len(list_data) == 2 and list_data[1][0] == '':
+ # # ndim == 1
+ # list_data = [list_data[1][1:]]
+ # new_data = np.array(list_data)
+ if self._raw_data_selection is None:
+ return
+ new_data = np.array(self._raw_data_selection)
if new_data.shape[0] > 1:
row_max = row_min + new_data.shape[0]
if new_data.shape[1] > 1:
@@ -1093,12 +1114,13 @@ def plot(self):
row_min, row_max, col_min, col_max = self.view_data._selection_bounds()
dim_names = self.data_adapter.get_axes_names()
# labels
- xlabels = [label[0] for label in self.model_xlabels.get_values(top=col_min, bottom=col_max)]
- ylabels = self.model_ylabels.get_values(left=row_min, right=row_max)
- # transpose ylabels
- ylabels = [[str(ylabels[i][j]) for i in range(len(ylabels))] for j in range(len(ylabels[0]))]
- # if there is only one dimension, ylabels is empty
- if not ylabels:
+ xlabels = self.model_hlabels.get_values(left=col_min, right=col_max, bottom=self.data_adapter.nb_dims_hlabels)
+ xlabels = [[str(xlabels[i][j]) for i in range(len(xlabels))] for j in range(len(xlabels[0]))]
+ if self.data_adapter.ndim > 1:
+ ylabels = self.model_vlabels.get_values(top=row_min, bottom=row_max)
+ # transpose ylabels
+ ylabels = [[str(ylabels[i][j]) for i in range(len(ylabels))] for j in range(len(ylabels[0]))]
+ else:
ylabels = [[]]
assert data.ndim == 2
@@ -1118,7 +1140,7 @@ def plot(self):
else:
# plot each row as a line
xlabel = dim_names[-1]
- xticklabels = [str(label) for label in xlabels]
+ xticklabels = ['\n'.join(row) for row in xlabels]
xdata = np.arange(col_max - col_min)
for row in range(len(data)):
ax.plot(xdata, data[row], label=' '.join(ylabels[row]))