libpappsomspp
Library for mass spectrometry
pappso::BaseColorMapPlotWidget Class Reference

#include <basecolormapplotwidget.h>

Inheritance diagram for pappso::BaseColorMapPlotWidget:
pappso::BasePlotWidget pappso::DriftSpecMassSpecColorMapPlotWidget pappso::TicXicChromDriftSpecColorMapPlotWidget pappso::TicXicChromMassSpecColorMapPlotWidget

Public Member Functions

 BaseColorMapPlotWidget (QWidget *parent)
 
 BaseColorMapPlotWidget (QWidget *parent, const QString &x_axis_label, const QString &y_axis_label)
 
virtual ~BaseColorMapPlotWidget ()
 Destruct this BaseColorMapPlotWidget instance. More...
 
virtual void setColorMapPlotConfig (const ColorMapPlotConfig &color_map_config)
 
virtual const ColorMapPlotConfiggetColorMapPlotConfig ()
 
const ColorMapPlotConfiggetOrigColorMapPlotConfig ()
 
virtual QCPColorMap * addColorMap (std::shared_ptr< std::map< double, MapTrace >> double_map_trace_map_sp, const ColorMapPlotConfig color_map_plot_config, const QColor &color)
 
virtual QCPColorMap * addColorMap (const TimsFrame &tims_frame, const ColorMapPlotConfig color_map_plot_config, const QColor &color)
 
virtual void transposeAxes ()
 
virtual void zAxisScaleToLog10 ()
 
virtual void zAxisFilterLowPassPercentage (double threshold_percentage)
 
virtual void zAxisFilterLowPassThreshold (double threshold)
 fix maximum value for the intensity More...
 
virtual void zAxisFilterHighPassPercentage (double threshold_percentage)
 
virtual void zAxisDataResetToOriginal ()
 
DataKind xAxisDataKind () const
 
DataKind yAxisDataKind () const
 
AxisScale axisScale (Axis axis) const
 
AxisScale xAxisScale () const
 
AxisScale yAxisScale () const
 
AxisScale zAxisScale () const
 
virtual void setPlottingColor (QCPAbstractPlottable *plottable_p, const QColor &new_color) override
 
virtual QColor getPlottingColor (int index=0) const override
 
void dataTo3ColString (QString &data_string)
 
void dataToMatrixString (QString &data_string, bool detailed=false)
 
void currentXaxisRangeIndices (int &lower, int &upper)
 
void currentYaxisRangeIndices (int &lower, int &upper)
 
- Public Member Functions inherited from pappso::BasePlotWidget
 BasePlotWidget (QWidget *parent)
 
 BasePlotWidget (QWidget *parent, const QString &x_axis_label, const QString &y_axis_label)
 
virtual ~BasePlotWidget ()
 Destruct this BasePlotWidget instance. More...
 
virtual bool setupWidget ()
 
virtual void setPen (const QPen &pen)
 
virtual const QPen & getPen () const
 
virtual void setPlottingColor (int index, const QColor &new_color)
 
virtual QColor getPlottingColor (QCPAbstractPlottable *plottable_p) const
 
virtual void setAxisLabelX (const QString &label)
 
virtual void setAxisLabelY (const QString &label)
 
virtual void resetAxesRangeHistory ()
 
virtual void updateAxesRangeHistory ()
 Create new axis range history items and append them to the history. More...
 
virtual void restorePreviousAxesRangeHistory ()
 Go up one history element in the axis history. More...
 
virtual void restoreAxesRangeHistory (std::size_t index)
 Get the axis histories at index index and update the plot ranges. More...
 
virtual void keyPressEvent (QKeyEvent *event)
 KEYBOARD-related EVENTS. More...
 
virtual void keyReleaseEvent (QKeyEvent *event)
 Handle specific key codes and trigger respective actions. More...
 
virtual void spaceKeyReleaseEvent (QKeyEvent *event)
 
virtual void directionKeyPressEvent (QKeyEvent *event)
 
virtual void directionKeyReleaseEvent (QKeyEvent *event)
 
virtual void mousePseudoButtonKeyPressEvent (QKeyEvent *event)
 
virtual void mousePseudoButtonKeyReleaseEvent (QKeyEvent *event)
 
virtual void mousePressHandler (QMouseEvent *event)
 KEYBOARD-related EVENTS. More...
 
virtual void mouseReleaseHandler (QMouseEvent *event)
 
virtual void mouseReleaseHandlerLeftButton ()
 
virtual void mouseReleaseHandlerRightButton ()
 
virtual void mouseWheelHandler (QWheelEvent *event)
 
virtual void mouseMoveHandler (QMouseEvent *event)
 KEYBOARD-related EVENTS. More...
 
virtual void mouseMoveHandlerNotDraggingCursor ()
 
virtual void mouseMoveHandlerDraggingCursor ()
 
virtual void mouseMoveHandlerLeftButtonDraggingCursor ()
 
virtual void mouseMoveHandlerRightButtonDraggingCursor ()
 
virtual void axisDoubleClickHandler (QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event)
 
bool isClickOntoXAxis (const QPointF &mousePoint)
 
bool isClickOntoYAxis (const QPointF &mousePoint)
 
int dragDirection ()
 MOUSE-related EVENTS. More...
 
virtual void moveMouseCursorGraphCoordToGlobal (QPointF plot_coordinates)
 
virtual void moveMouseCursorPixelCoordToGlobal (QPointF local_coordinates)
 
virtual void horizontalMoveMouseCursorCountPixels (int pixel_count)
 
virtual QPointF horizontalGetGraphCoordNewPointCountPixels (int pixel_count)
 
virtual void verticalMoveMouseCursorCountPixels (int pixel_count)
 
virtual QPointF verticalGetGraphCoordNewPointCountPixels (int pixel_count)
 
virtual QCPRange getRangeX (bool &found_range, int index) const
 MOUSE MOVEMENTS mouse/keyboard-triggered. More...
 
virtual QCPRange getRangeY (bool &found_range, int index) const
 
QCPRange getRange (Axis axis, RangeType range_type, bool &found_range) const
 
virtual QCPRange getInnermostRangeX (bool &found_range) const
 
virtual QCPRange getOutermostRangeX (bool &found_range) const
 
virtual QCPRange getInnermostRangeY (bool &found_range) const
 
virtual QCPRange getOutermostRangeY (bool &found_range) const
 
void yMinMaxOnXAxisCurrentRange (double &min, double &max, QCPAbstractPlottable *plottable_p=nullptr)
 
void yMinMaxOnXAxisCurrentRange (double &min, double &max, int index)
 
virtual void axisRescale ()
 RANGE-related functions. More...
 
virtual void axisReframe ()
 
virtual void axisZoom ()
 
virtual void axisPan ()
 
virtual void replotWithAxesRanges (QCPRange xAxisRange, QCPRange yAxisRange, Axis axis)
 
virtual void replotWithAxisRangeX (double lower, double upper)
 
virtual void replotWithAxisRangeY (double lower, double upper)
 
virtual void hideAllPlotItems ()
 PLOTTING / REPLOTTING functions. More...
 
virtual void showTracers ()
 Show the traces (vertical and horizontal). More...
 
virtual void hideTracers ()
 Hide the traces (vertical and horizontal). More...
 
virtual void drawXDeltaFeatures ()
 
virtual void drawYDeltaFeatures ()
 
virtual void calculateDragDeltas ()
 
virtual bool isVerticalDisplacementAboveThreshold ()
 
virtual void drawSelectionRectangleAndPrepareZoom (bool as_line_segment=false, bool for_integration=false)
 
virtual void updateSelectionRectangle (bool as_line_segment=false, bool for_integration=false)
 
virtual void resetSelectionRectangle ()
 
virtual void hideSelectionRectangle (bool reset_values=false)
 
virtual bool isSelectionRectangleVisible ()
 
virtual PolygonType whatIsVisibleOfTheSelectionRectangle ()
 
virtual void setFocus ()
 PLOT ITEMS : TRACER TEXT ITEMS... More...
 
virtual void redrawPlotBackground (QWidget *focusedPlotWidget)
 Redraw the background of the focusedPlotWidget plot widget. More...
 
virtual void updateContextXandYAxisRanges ()
 
virtual const BasePlotContextgetContext () const
 

Protected Attributes

QCPColorMapData * mpa_origColorMapData = nullptr
 
ColorMapPlotConfig m_colorMapPlotConfig
 
ColorMapPlotConfigmpa_origColorMapPlotConfig = nullptr
 
- Protected Attributes inherited from pappso::BasePlotWidget
QString m_name = "NOT_SET"
 Name of the plot widget. More...
 
QString m_desc = "NOT_SET"
 Description of the plot widget. More...
 
QString m_fileName
 The name of the data file from which the mass data were read. More...
 
QString m_axisLabelX
 
QString m_axisLabelY
 
BasePlotContext m_context
 
int m_leftMousePseudoButtonKey = Qt::Key_Less
 
int m_rightMousePseudoButtonKey = Qt::Key_Greater
 
QCPItemLine * mp_selectionRectangeLine1 = nullptr
 Rectangle defining the borders of zoomed-in/out data. More...
 
QCPItemLine * mp_selectionRectangeLine2 = nullptr
 
QCPItemLine * mp_selectionRectangeLine3 = nullptr
 
QCPItemLine * mp_selectionRectangeLine4 = nullptr
 
QCPItemText * mp_xDeltaTextItem = nullptr
 Text describing the x-axis delta value during a drag operation. More...
 
QCPItemText * mp_yDeltaTextItem = nullptr
 
bool m_shouldTracersBeVisible = true
 Tells if the tracers should be visible. More...
 
QCPItemLine * mp_hPosTracerItem = nullptr
 Horizontal position tracer. More...
 
QCPItemLine * mp_vPosTracerItem = nullptr
 Vertical position tracer. More...
 
QCPItemLine * mp_vStartTracerItem = nullptr
 Vertical selection start tracer (typically in green). More...
 
QCPItemLine * mp_vEndTracerItem = nullptr
 Vertical selection end tracer (typically in red). More...
 
std::size_t m_lastAxisRangeHistoryIndex = 0
 Index of the last axis range history item. More...
 
std::vector< QCPRange * > m_xAxisRangeHistory
 List of x axis ranges occurring during the panning zooming actions. More...
 
std::vector< QCPRange * > m_yAxisRangeHistory
 List of y axis ranges occurring during the panning zooming actions. More...
 
int m_mouseMoveHandlerSkipAmount = 10
 How many mouse move events must be skipped *‍/. More...
 
int m_mouseMoveHandlerSkipCount = 0
 Counter to handle the "fat data" mouse move event handling. More...
 
QColor m_unfocusedColor = QColor("lightgray")
 Color used for the background of unfocused plot. More...
 
QBrush m_unfocusedBrush = QBrush(m_unfocusedColor)
 Color used for the background of unfocused plot. More...
 
QColor m_focusedColor = QColor(Qt::transparent)
 Color used for the background of focused plot. More...
 
QBrush m_focusedBrush = QBrush(m_focusedColor)
 Color used for the background of focused plot. More...
 
QPen m_pen
 Pen used to draw the graph and textual elements in the plot widget. More...
 

Additional Inherited Members

- Signals inherited from pappso::BasePlotWidget
void setFocusSignal ()
 
void lastCursorHoveredPointSignal (const QPointF &pointf)
 
void plotRangesChangedSignal (const BasePlotContext &context)
 
void xAxisMeasurementSignal (const BasePlotContext &context, bool with_delta)
 
void keyPressEventSignal (const BasePlotContext &context)
 
void keyReleaseEventSignal (const BasePlotContext &context)
 
void mouseReleaseEventSignal (const BasePlotContext &context)
 
void mouseWheelEventSignal (const BasePlotContext &context)
 
void plottableSelectionChangedSignal (QCPAbstractPlottable *plottable_p, bool selected)
 
void integrationRequestedSignal (const BasePlotContext &context)
 
void plottableDestructionRequestedSignal (BasePlotWidget *base_plot_widget_p, QCPAbstractPlottable *plottable_p, const BasePlotContext &context)
 
- Protected Member Functions inherited from pappso::BasePlotWidget
virtual void createAllAncillaryItems ()
 
virtual void update1DSelectionRectangle (bool for_integration=false)
 
virtual void update2DSelectionRectangleSquare (bool for_integration=false)
 
virtual void update2DSelectionRectangleSkewed (bool for_integration=false)
 
virtual QString allLayerNamesToString () const
 
virtual QString layerableLayerName (QCPLayerable *layerable_p) const
 
virtual int layerableLayerIndex (QCPLayerable *layerable_p) const
 

Detailed Description

Definition at line 63 of file basecolormapplotwidget.h.

Constructor & Destructor Documentation

◆ BaseColorMapPlotWidget() [1/2]

pappso::BaseColorMapPlotWidget::BaseColorMapPlotWidget ( QWidget *  parent)
explicit

Definition at line 71 of file basecolormapplotwidget.cpp.

72  : BasePlotWidget(parent, "x", "y")
73 {
74  // Do not call createAllAncillaryItems() in this base class because all the
75  // items will have been created *before* the addition of plots and then the
76  // rendering order will hide them to the viewer, since the rendering order is
77  // according to the order in which the items have been created.
78  //
79  // The fact that the ancillary items are created before trace plots is not a
80  // problem because the trace plots are sparse and do not effectively hide the
81  // data.
82  //
83  // But, in the color map plot widgets, we cannot afford to create the
84  // ancillary items *before* the plot itself because then, the rendering of the
85  // plot (created after) would screen off the ancillary items (created before).
86  //
87  // So, the createAllAncillaryItems() function needs to be called in the
88  // derived classes at the most appropriate moment in the setting up of the
89  // widget.
90  //
91  // In the present case, the function needs to be called right after addition
92  // of the color map plot.
93 }
BasePlotWidget(QWidget *parent)

◆ BaseColorMapPlotWidget() [2/2]

pappso::BaseColorMapPlotWidget::BaseColorMapPlotWidget ( QWidget *  parent,
const QString &  x_axis_label,
const QString &  y_axis_label 
)
explicit

Definition at line 44 of file basecolormapplotwidget.cpp.

47  : BasePlotWidget(parent, x_axis_label, y_axis_label)
48 {
49  // Do not call createAllAncillaryItems() in this base class because all the
50  // items will have been created *before* the addition of plots and then the
51  // rendering order will hide them to the viewer, since the rendering order is
52  // according to the order in which the items have been created.
53  //
54  // The fact that the ancillary items are created before trace plots is not a
55  // problem because the trace plots are sparse and do not effectively hide the
56  // data.
57  //
58  // But, in the color map plot widgets, we cannot afford to create the
59  // ancillary items *before* the plot itself because then, the rendering of the
60  // plot (created after) would screen off the ancillary items (created before).
61  //
62  // So, the createAllAncillaryItems() function needs to be called in the
63  // derived classes at the most appropriate moment in the setting up of the
64  // widget.
65  //
66  // In the present case, the function needs to be called right after addition
67  // of the color map plot.
68 }

◆ ~BaseColorMapPlotWidget()

pappso::BaseColorMapPlotWidget::~BaseColorMapPlotWidget ( )
virtual

Destruct this BaseColorMapPlotWidget instance.

The destruction involves clearing the history, deleting all the axis range history items for x and y axes.

Definition at line 103 of file basecolormapplotwidget.cpp.

104 {
105  if(mpa_origColorMapData != nullptr)
106  delete mpa_origColorMapData;
107 
108  if(mpa_origColorMapPlotConfig != nullptr)
110 }
ColorMapPlotConfig * mpa_origColorMapPlotConfig

References mpa_origColorMapData, and mpa_origColorMapPlotConfig.

Member Function Documentation

◆ addColorMap() [1/2]

QCPColorMap * pappso::BaseColorMapPlotWidget::addColorMap ( const TimsFrame tims_frame,
const ColorMapPlotConfig  color_map_plot_config,
const QColor &  color 
)
virtual

Definition at line 287 of file basecolormapplotwidget.cpp.

291 {
292  qDebug();
293  if(!color.isValid())
294  throw PappsoException(
295  QString("The color to be used for the plot graph is invalid."));
296 
297  QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
298 
299  color_map_p->setLayer("plotsLayer");
300 
301  // Do not forget to copy the config!
302  m_colorMapPlotConfig = color_map_plot_config;
303 
304  // Immediately create a copy of the original data for backup.
305  mpa_origColorMapPlotConfig = new ColorMapPlotConfig(color_map_plot_config);
306 
307  qDebug();
308 #if 0
309  // This is the code on the QCustomPlot documentation and it works fine.
310  QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
311 
312  color_map_p->data()->setSize(50, 50);
313  color_map_p->data()->setRange(QCPRange(0, 2), QCPRange(0, 2));
314  for(int x = 0; x < 50; ++x)
315  for(int y = 0; y < 50; ++y)
316  color_map_p->data()->setCell(x, y, qCos(x / 10.0) + qSin(y / 10.0));
317  color_map_p->setGradient(QCPColorGradient::gpPolar);
318  color_map_p->rescaleDataRange(true);
319  rescaleAxes();
320  replot();
321 #endif
322 
323  // Only now can afford to call createAllAncillaryItems() in this derived class
324  // because the color map has been created already. The rendering order will
325  // thus not hide the ancillary items, since they have been created after the
326  // color map plot (since the rendering order is according to the
327  // order in which the items have been created). See contructor note.
329 
330  qDebug();
331  // Connect the signal of selection change so that we can re-emit it for the
332  // widget that is using *this widget.
333 
334  connect(color_map_p,
335  static_cast<void (QCPAbstractPlottable::*)(bool)>(
336  &QCPAbstractPlottable::selectionChanged),
337  [this, color_map_p]() {
338  emit plottableSelectionChangedSignal(color_map_p,
339  color_map_p->selected());
340  });
341 
342  // qDebug() << "Configuring the color map with this config:"
343  //<< color_map_plot_config.toString();
344 
345  color_map_p->data()->setSize(color_map_plot_config.keyCellCount,
346  color_map_plot_config.mzCellCount);
347 
348  color_map_p->data()->setRange(QCPRange(color_map_plot_config.minKeyValue,
349  color_map_plot_config.maxKeyValue),
350  QCPRange(color_map_plot_config.minMzValue,
351  color_map_plot_config.maxMzValue));
352  color_map_p->data()->fill(0.0);
353  // double max_intensity = 0;
354  qDebug();
355  // We have now to fill the color map.
356  std::size_t number_of_scans = tims_frame.getTotalNumberOfScans();
357  for(std::size_t i = 0; i < number_of_scans; i++)
358  {
359  std::vector<quint32> mz_index_vector = tims_frame.getScanIndexList(i);
360  std::vector<quint32> intensity_index_vector =
361  tims_frame.getScanIntensities(i);
362 
363 
364  // The first value is the key and the second value is the MapTrace into
365  // which we need to iterated and for each point (double mz, double
366  // intensity) create a map cell.
367 
368  double dt_or_rt_key = i;
369  std::size_t vector_index = 0;
370  for(quint32 mzindex : mz_index_vector)
371  {
372  double mz = mzindex;
373  double intensity = intensity_index_vector.at(vector_index);
374  // max_intensity = std::max(max_intensity, intensity);
375  // We are filling dynamically the color map. If a cell had already
376  // something in, then we need to take that into account. This is
377  // because we let QCustomPlot handle the fuzzy transition between
378  // color map plot cells.
379 
380  double prev_intensity = color_map_p->data()->data(dt_or_rt_key, mz);
381  double new_intensity = prev_intensity + intensity;
382 
383  // qDebug() << "mz=" << mz << " int=" << intensity;
384 
385  // Record the min/max cell intensity value (origM(in/ax)ZValue). We
386  // will need that later. Also update the lastM(in/ax)ZValue because
387  // when doing this kind of data conversion it is assume that the user
388  // actually changes the data.
390  std::min(m_colorMapPlotConfig.origMinZValue, new_intensity));
391 
393  std::max(m_colorMapPlotConfig.origMaxZValue, new_intensity));
394 
395  // qDebug() << "Setting tri-point:" << dt_or_rt_key << "," << mz <<
396  // ","
397  //<< new_intensity;
398 
399  color_map_p->data()->setCell(dt_or_rt_key, mz, new_intensity);
400 
401  // qDebug() << "dt_or_rt_key=" << dt_or_rt_key << " mz=" << mz
402  // << " new_intensity=" << new_intensity;
403 
404  vector_index++;
405  }
406  }
407 
408  // At this point we have finished filling-up the color map.
409 
410  // The gpThermal is certainly one of the best.
411 
412  color_map_p->setGradient(QCPColorGradient::gpThermal);
413 
414  color_map_p->data()->recalculateDataBounds();
415  color_map_p->rescaleDataRange(true);
416 
417  color_map_p->rescaleAxes();
419 
420  // The pen of the color map itself is of no use. Instead the user will see the
421  // color of the axes' labels.
422 
423  qDebug();
424  QPen pen = xAxis->basePen();
425  pen.setColor(color);
426 
427  xAxis->setBasePen(pen);
428  xAxis->setLabelColor(color);
429  xAxis->setTickLabelColor(color);
430 
431  yAxis->setBasePen(pen);
432  yAxis->setLabelColor(color);
433  yAxis->setTickLabelColor(color);
434 
435  // And now set the color map's pen to the same color, even if we do not use
436  // it, we need it for coloring the plots that might be integrated from this
437  // color map.
438 
439  color_map_p->setPen(pen);
440 
441  // Copy the original color map's data into a backup copy.
442 
443  mpa_origColorMapData = new QCPColorMapData(*(color_map_p->data()));
444 
445  color_map_p->setInterpolate(false);
446  color_map_p->setTightBoundary(false);
447 
448  replot();
449 
450 
451  qDebug() << color_map_p->data()->keyRange();
452  qDebug() << color_map_p->data()->valueRange();
453  qDebug() << color_map_p->data()->dataBounds();
454  qDebug();
455  return color_map_p;
456 }
virtual void createAllAncillaryItems()
virtual void resetAxesRangeHistory()
void plottableSelectionChangedSignal(QCPAbstractPlottable *plottable_p, bool selected)
void setOrigAndLastMaxZValue(double value)
void setOrigAndLastMinZValue(double value)

References pappso::BasePlotWidget::createAllAncillaryItems(), pappso::TimsFrame::getScanIndexList(), pappso::TimsFrame::getScanIntensities(), pappso::TimsFrameBase::getTotalNumberOfScans(), pappso::ColorMapPlotConfig::keyCellCount, m_colorMapPlotConfig, pappso::ColorMapPlotConfig::maxKeyValue, pappso::ColorMapPlotConfig::maxMzValue, pappso::ColorMapPlotConfig::minKeyValue, pappso::ColorMapPlotConfig::minMzValue, mpa_origColorMapData, mpa_origColorMapPlotConfig, pappso::mz, pappso::ColorMapPlotConfig::mzCellCount, pappso::ColorMapPlotConfig::origMaxZValue, pappso::ColorMapPlotConfig::origMinZValue, pappso::BasePlotWidget::plottableSelectionChangedSignal(), pappso::BasePlotWidget::resetAxesRangeHistory(), pappso::ColorMapPlotConfig::setOrigAndLastMaxZValue(), pappso::ColorMapPlotConfig::setOrigAndLastMinZValue(), pappso::x, and pappso::y.

◆ addColorMap() [2/2]

QCPColorMap * pappso::BaseColorMapPlotWidget::addColorMap ( std::shared_ptr< std::map< double, MapTrace >>  double_map_trace_map_sp,
const ColorMapPlotConfig  color_map_plot_config,
const QColor &  color 
)
virtual

Definition at line 136 of file basecolormapplotwidget.cpp.

140 {
141  // qDebug() << "Adding color map with config:" <<
142  // color_map_plot_config.toString();
143 
144  if(!color.isValid())
145  throw PappsoException(
146  QString("The color to be used for the plot graph is invalid."));
147 
148  QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
149 
150  color_map_p->setLayer("plotsLayer");
151 
152  // Do not forget to copy the config!
153  m_colorMapPlotConfig = color_map_plot_config;
154 
155  // Immediately create a copy of the original data for backup.
156  mpa_origColorMapPlotConfig = new ColorMapPlotConfig(color_map_plot_config);
157 
158 #if 0
159  // This is the code on the QCustomPlot documentation and it works fine.
160  QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
161 
162  color_map_p->data()->setSize(50, 50);
163  color_map_p->data()->setRange(QCPRange(0, 2), QCPRange(0, 2));
164  for(int x = 0; x < 50; ++x)
165  for(int y = 0; y < 50; ++y)
166  color_map_p->data()->setCell(x, y, qCos(x / 10.0) + qSin(y / 10.0));
167  color_map_p->setGradient(QCPColorGradient::gpPolar);
168  color_map_p->rescaleDataRange(true);
169  rescaleAxes();
170  replot();
171 #endif
172 
173  // Only now can afford to call createAllAncillaryItems() in this derived class
174  // because the color map has been created already. The rendering order will
175  // thus not hide the ancillary items, since they have been created after the
176  // color map plot (since the rendering order is according to the
177  // order in which the items have been created). See contructor note.
179 
180  // Connect the signal of selection change so that we can re-emit it for the
181  // widget that is using *this widget.
182 
183  connect(color_map_p,
184  static_cast<void (QCPAbstractPlottable::*)(bool)>(
185  &QCPAbstractPlottable::selectionChanged),
186  [this, color_map_p]() {
187  emit plottableSelectionChangedSignal(color_map_p,
188  color_map_p->selected());
189  });
190 
191  // qDebug() << "Configuring the color map with this config:"
192  //<< color_map_plot_config.toString();
193 
194  color_map_p->data()->setSize(color_map_plot_config.keyCellCount,
195  color_map_plot_config.mzCellCount);
196 
197  color_map_p->data()->setRange(QCPRange(color_map_plot_config.minKeyValue,
198  color_map_plot_config.maxKeyValue),
199  QCPRange(color_map_plot_config.minMzValue,
200  color_map_plot_config.maxMzValue));
201  color_map_p->data()->fill(0.0);
202 
203  // We have now to fill the color map.
204 
205  for(auto &&pair : *double_map_trace_map_sp)
206  {
207 
208  // The first value is the key and the second value is the MapTrace into
209  // which we need to iterated and for each point (double mz, double
210  // intensity) create a map cell.
211 
212  double dt_or_rt_key = pair.first;
213  MapTrace map_trace = pair.second;
214 
215  for(auto &&data_point_pair : map_trace)
216  {
217  double mz = data_point_pair.first;
218  double intensity = data_point_pair.second;
219 
220  // We are filling dynamically the color map. If a cell had already
221  // something in, then we need to take that into account. This is
222  // because we let QCustomPlot handle the fuzzy transition between
223  // color map plot cells.
224 
225  double prev_intensity = color_map_p->data()->data(dt_or_rt_key, mz);
226  double new_intensity = prev_intensity + intensity;
227 
228  // Record the min/max cell intensity value (origM(in/ax)ZValue). We
229  // will need that later. Also update the lastM(in/ax)ZValue because
230  // when doing this kind of data conversion it is assume that the user
231  // actually changes the data.
233  std::min(m_colorMapPlotConfig.origMinZValue, new_intensity));
234 
236  std::max(m_colorMapPlotConfig.origMaxZValue, new_intensity));
237 
238  // qDebug() << "Setting tri-point:" << dt_or_rt_key << "," << mz <<
239  // ","
240  //<< new_intensity;
241 
242  color_map_p->data()->setData(dt_or_rt_key, mz, new_intensity);
243  }
244  }
245 
246  // At this point we have finished filling-up the color map.
247 
248  // The gpThermal is certainly one of the best.
249 
250  color_map_p->setGradient(QCPColorGradient::gpThermal);
251 
252  color_map_p->rescaleDataRange(true);
253 
254  color_map_p->rescaleAxes();
256 
257  // The pen of the color map itself is of no use. Instead the user will see the
258  // color of the axes' labels.
259 
260  QPen pen = xAxis->basePen();
261  pen.setColor(color);
262 
263  xAxis->setBasePen(pen);
264  xAxis->setLabelColor(color);
265  xAxis->setTickLabelColor(color);
266 
267  yAxis->setBasePen(pen);
268  yAxis->setLabelColor(color);
269  yAxis->setTickLabelColor(color);
270 
271  // And now set the color map's pen to the same color, even if we do not use
272  // it, we need it for coloring the plots that might be integrated from this
273  // color map.
274 
275  color_map_p->setPen(pen);
276 
277  // Copy the original color map's data into a backup copy.
278 
279  mpa_origColorMapData = new QCPColorMapData(*(color_map_p->data()));
280 
281  replot();
282 
283  return color_map_p;
284 }

References pappso::BasePlotWidget::createAllAncillaryItems(), pappso::ColorMapPlotConfig::keyCellCount, m_colorMapPlotConfig, pappso::ColorMapPlotConfig::maxKeyValue, pappso::ColorMapPlotConfig::maxMzValue, pappso::ColorMapPlotConfig::minKeyValue, pappso::ColorMapPlotConfig::minMzValue, mpa_origColorMapData, mpa_origColorMapPlotConfig, pappso::mz, pappso::ColorMapPlotConfig::mzCellCount, pappso::ColorMapPlotConfig::origMaxZValue, pappso::ColorMapPlotConfig::origMinZValue, pappso::BasePlotWidget::plottableSelectionChangedSignal(), pappso::BasePlotWidget::resetAxesRangeHistory(), pappso::ColorMapPlotConfig::setOrigAndLastMaxZValue(), pappso::ColorMapPlotConfig::setOrigAndLastMinZValue(), pappso::x, and pappso::y.

◆ axisScale()

AxisScale pappso::BaseColorMapPlotWidget::axisScale ( Axis  axis) const

Definition at line 1021 of file basecolormapplotwidget.cpp.

1022 {
1023  if(axis == Axis::x)
1025  else if(axis == Axis::y)
1027  else if(axis == Axis::z)
1029  else
1030  throw PappsoException(
1031  QString("basecolormapplotwidget.cpp: The axis cannot be different than "
1032  "x, y or z."));
1033 
1034  return AxisScale::unset;
1035 }

References m_colorMapPlotConfig, pappso::unset, pappso::x, pappso::ColorMapPlotConfig::xAxisScale, pappso::y, pappso::ColorMapPlotConfig::yAxisScale, pappso::z, and pappso::ColorMapPlotConfig::zAxisScale.

◆ currentXaxisRangeIndices()

void pappso::BaseColorMapPlotWidget::currentXaxisRangeIndices ( int &  lower,
int &  upper 
)

Definition at line 1102 of file basecolormapplotwidget.cpp.

1103 {
1104  // We want to limit the ranges to the visible data range in the plot widget.
1105 
1106  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
1107  QCPColorMapData *map_data = color_map_p->data();
1108 
1109  bool found_range = false;
1110 
1111  // Get the full data set DT values range because if the context contains no
1112  // values for the currently displayed ranges, then we fall back to them;
1113  QCPRange full_data_range = color_map_p->getKeyRange(found_range);
1114 
1115  if(!found_range)
1116  {
1117  qDebug() << "The range was not found";
1118  return;
1119  }
1120 
1121  // qDebug() << "Full key data range:" << full_data_range.lower << "-"
1122  //<< full_data_range.upper;
1123 
1124  // But what we actually want is the currently visible axes ranges. And these
1125  // are stored in the context.
1126 
1127  double visible_data_range_lower = m_context.m_xRange.lower;
1128  double visible_data_range_upper = m_context.m_xRange.upper;
1129 
1130  // qDebug() << "Visible key data range:" << visible_data_range_lower << "-"
1131  //<< visible_data_range_upper;
1132 
1133  // Note that if there has been *no* panning, rescale, nothing, with the color
1134  // map, then the context has no idea of the ranges. So we need to check that.
1135  // If that is the case, then we use the full key range as the full plot is
1136  // displayed full scale upon its first showing.
1137 
1138  if(!visible_data_range_lower || !visible_data_range_upper)
1139  {
1140  visible_data_range_lower = full_data_range.lower;
1141  visible_data_range_upper = full_data_range.upper;
1142  }
1143 
1144  // qDebug() << "Visible key range:" << visible_data_range_lower << "-"
1145  //<< visible_data_range_upper;
1146 
1147  // And now convert the double value ranges into cell indices, which is what we
1148  // are being asked for.
1149 
1150  map_data->coordToCell(visible_data_range_lower, 0, &lower, nullptr);
1151  map_data->coordToCell(visible_data_range_upper, 0, &upper, nullptr);
1152 
1153  // qDebug() << "Cell indices for currently visible key range:" << lower << "-"
1154  //<< upper;
1155 }
BasePlotContext m_context

References pappso::BasePlotWidget::m_context, and pappso::BasePlotContext::m_xRange.

Referenced by dataTo3ColString(), and dataToMatrixString().

◆ currentYaxisRangeIndices()

void pappso::BaseColorMapPlotWidget::currentYaxisRangeIndices ( int &  lower,
int &  upper 
)

Definition at line 1159 of file basecolormapplotwidget.cpp.

1160 {
1161  // We want to limit the ranges to the visible data range in the plot widget.
1162 
1163  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
1164  QCPColorMapData *map_data = color_map_p->data();
1165 
1166  bool found_range = false;
1167 
1168  // Get the full data set MZ values range because if the context contains no
1169  // values for the currently displayed ranges, then we fall back to them;
1170  QCPRange full_data_range = color_map_p->getValueRange(found_range);
1171 
1172  if(!found_range)
1173  {
1174  qDebug() << "The range was not found";
1175  return;
1176  }
1177 
1178  // qDebug() << "Full value data range:" << full_data_range.lower << "-"
1179  //<< full_data_range.upper;
1180 
1181  // But what we actually want is the currently visible axes ranges. And these
1182  // are stored in the context.
1183 
1184  double visible_data_range_lower = m_context.m_yRange.lower;
1185  double visible_data_range_upper = m_context.m_yRange.upper;
1186 
1187  // qDebug() << "Visible value data range:" << visible_data_range_lower << "-"
1188  //<< visible_data_range_upper;
1189 
1190  // Note that if there has been *no* panning, rescale, nothing, with the color
1191  // map, then the context has no idea of the ranges. So we need to check that.
1192  // If that is the case, then we use the full key range as the full plot is
1193  // displayed full scale upon its first showing.
1194 
1195  if(!visible_data_range_lower || !visible_data_range_upper)
1196  {
1197  visible_data_range_lower = full_data_range.lower;
1198  visible_data_range_upper = full_data_range.upper;
1199  }
1200 
1201  // qDebug() << "Final visible value data range:" << visible_data_range_lower
1202  //<< "-" << visible_data_range_upper;
1203 
1204  // And now convert the double value ranges into cell indices, which is what we
1205  // are being asked for.
1206 
1207  map_data->coordToCell(0, visible_data_range_lower, nullptr, &lower);
1208  map_data->coordToCell(0, visible_data_range_upper, nullptr, &upper);
1209 
1210  // qDebug() << "Cell indices for currently visible value range:" << lower <<
1211  // "-"
1212  //<< upper;
1213 }

References pappso::BasePlotWidget::m_context, and pappso::BasePlotContext::m_yRange.

Referenced by dataTo3ColString(), and dataToMatrixString().

◆ dataTo3ColString()

void pappso::BaseColorMapPlotWidget::dataTo3ColString ( QString &  data_string)

Definition at line 1217 of file basecolormapplotwidget.cpp.

1218 {
1219  // We want to export the data to a string in the x y z format, with
1220  // x=key (cell's x coordinate)
1221  // y=value (cell's y coordinate)
1222  // z=intensity (cell value)
1223 
1224  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
1225  QCPColorMapData *map_data = color_map_p->data();
1226 
1227  int key_index_lower_range;
1228  int key_index_upper_range;
1229  currentXaxisRangeIndices(key_index_lower_range, key_index_upper_range);
1230 
1231  // qDebug() << "Cell indices for currently visible key range:"
1232  //<< key_index_lower_range << "-" << key_index_upper_range;
1233 
1234  int value_index_lower_range;
1235  int value_index_upper_range;
1236  currentYaxisRangeIndices(value_index_lower_range, value_index_upper_range);
1237 
1238  // qDebug() << "Cell indices for currently visible value range:"
1239  //<< value_index_lower_range << "-" << value_index_upper_range;
1240 
1241  data_string.clear();
1242  QString debug_string;
1243 
1244  // Iterate in the matrix' key axis (DT, for example)
1245  for(int key_iter = key_index_lower_range; key_iter < key_index_upper_range;
1246  ++key_iter)
1247  {
1248  // Iterate in the matrix' value axis (MZ, for example)
1249  for(int value_iter = value_index_lower_range;
1250  value_iter < value_index_upper_range;
1251  ++value_iter)
1252  {
1253  // This would be the DT value (x axis)
1254  double key;
1255 
1256  // This would be the MZ value (y axis)
1257  double value;
1258 
1259  map_data->cellToCoord(key_iter, value_iter, &key, &value);
1260 
1261  data_string +=
1262  QString("%1 %2 %3\n")
1263  .arg(key, 0, 'f', 6, ' ')
1264  .arg(value, 0, 'f', 6, ' ')
1265  // The intensity without decimals
1266  .arg(map_data->cell(key_iter, value_iter), 0, 'f', 0, ' ');
1267  }
1268  }
1269 
1270  // qDebug() << "The completed data string has size: " << data_string.size();
1271 }
void currentYaxisRangeIndices(int &lower, int &upper)
void currentXaxisRangeIndices(int &lower, int &upper)

References currentXaxisRangeIndices(), and currentYaxisRangeIndices().

◆ dataToMatrixString()

void pappso::BaseColorMapPlotWidget::dataToMatrixString ( QString &  data_string,
bool  detailed = false 
)

Definition at line 1275 of file basecolormapplotwidget.cpp.

1276 {
1277  // We want to export the data in the form of a matrix, exactly as the data
1278  // appear within the colormap, unless the color is replaced with the intensity
1279  // value.
1280 
1281  // We want to limit the export to the visible data range in the plot widget.
1282 
1283  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
1284  QCPColorMapData *map_data = color_map_p->data();
1285 
1286  int key_index_lower_range;
1287  int key_index_upper_range;
1288  currentXaxisRangeIndices(key_index_lower_range, key_index_upper_range);
1289 
1290  // qDebug() << "Cell indices for currently visible key range:"
1291  //<< key_index_lower_range << "-" << key_index_upper_range;
1292 
1293  int value_index_lower_range;
1294  int value_index_upper_range;
1295  currentYaxisRangeIndices(value_index_lower_range, value_index_upper_range);
1296 
1297  // qDebug() << "Cell indices for currently visible value range:"
1298  //<< value_index_lower_range << "-" << value_index_upper_range;
1299 
1300  data_string.clear();
1301 
1302  // At this point, we can write the header of the key data (that is the dt
1303  // key values).
1304 
1305  for(int key_iter = key_index_lower_range; key_iter < key_index_upper_range;
1306  ++key_iter)
1307  {
1308  double current_key_value;
1309  map_data->cellToCoord(key_iter, 0, &current_key_value, nullptr);
1310 
1311  data_string += QString("%1 ").arg(current_key_value, 0, 'f', 6, ' ');
1312  }
1313 
1314  // Finally call the newline
1315  data_string += "\n";
1316 
1317  // Now fill in the matrix, from top to down, that is from higher m/z values to
1318  // lower values.
1319 
1320  // The matrix we are exporting looks like this:
1321 
1322  // |
1323  // |
1324  // |
1325  // |
1326  // |
1327  // |
1328  // m/z |
1329  // |
1330  // |
1331  // |
1332  // |
1333  // |______________________________
1334  // dt
1335 
1336  // Because we want the matrix to be presented the same, we need to fill in the
1337  // matrix from top to bottom starting from higher m/z values.
1338 
1339  for(int value_iter = value_index_upper_range;
1340  value_iter >= value_index_lower_range;
1341  --value_iter)
1342  {
1343 
1344  for(int key_iter = key_index_lower_range;
1345  key_iter < key_index_upper_range;
1346  ++key_iter)
1347  {
1348  double intensity = map_data->cell(key_iter, value_iter);
1349 
1350  // Only to report debug messages
1351  double key_double;
1352  double value_double;
1353  map_data->cellToCoord(
1354  key_iter, value_iter, &key_double, &value_double);
1355 
1356  // qDebug() << "Currently iterated cell: " << key_iter << ","
1357  //<< value_iter << "with values:" << key_double << ","
1358  //<< value_double << "with intensity:" << intensity;
1359 
1360  // The intensity without decimals
1361  if(detailed)
1362  data_string += QString("%1/%2/%3 ")
1363  .arg(key_double, 0, 'f', 6, ' ')
1364  .arg(value_double, 0, 'f', 6, ' ')
1365  .arg(intensity);
1366  else
1367  data_string += QString("%1 ").arg(intensity, 0, 'f', 0, ' ');
1368  }
1369 
1370  data_string += "\n";
1371  }
1372 
1373  // qDebug().noquote() << "The matrix: " << data_string;
1374  // qDebug() << "The completed data string has size: " <<
1375  // data_string.size();
1376 
1377  data_string += "\n";
1378 }

References currentXaxisRangeIndices(), and currentYaxisRangeIndices().

◆ getColorMapPlotConfig()

const ColorMapPlotConfig & pappso::BaseColorMapPlotWidget::getColorMapPlotConfig ( )
virtual

Definition at line 129 of file basecolormapplotwidget.cpp.

130 {
131  return m_colorMapPlotConfig;
132 }

References m_colorMapPlotConfig.

◆ getOrigColorMapPlotConfig()

const ColorMapPlotConfig * pappso::BaseColorMapPlotWidget::getOrigColorMapPlotConfig ( )

Definition at line 122 of file basecolormapplotwidget.cpp.

123 {
125 }

References mpa_origColorMapPlotConfig.

◆ getPlottingColor()

QColor pappso::BaseColorMapPlotWidget::getPlottingColor ( int  index = 0) const
overridevirtual

Reimplemented from pappso::BasePlotWidget.

Definition at line 1092 of file basecolormapplotwidget.cpp.

1093 {
1094  Q_UNUSED(index);
1095 
1096  QPen pen = xAxis->basePen();
1097  return pen.color();
1098 }

◆ setColorMapPlotConfig()

void pappso::BaseColorMapPlotWidget::setColorMapPlotConfig ( const ColorMapPlotConfig color_map_config)
virtual

Definition at line 114 of file basecolormapplotwidget.cpp.

116 {
117  m_colorMapPlotConfig = color_map_config;
118 }

References m_colorMapPlotConfig.

◆ setPlottingColor()

void pappso::BaseColorMapPlotWidget::setPlottingColor ( QCPAbstractPlottable *  plottable_p,
const QColor &  new_color 
)
overridevirtual

Reimplemented from pappso::BasePlotWidget.

Definition at line 1060 of file basecolormapplotwidget.cpp.

1062 {
1063  Q_UNUSED(plottable_p);
1064 
1065  // The pen of the color map itself is of no use. Instead the user will see the
1066  // color of the axes' labels.
1067 
1068  QPen pen = xAxis->basePen();
1069  pen.setColor(new_color);
1070 
1071  xAxis->setBasePen(pen);
1072  xAxis->setLabelColor(new_color);
1073  xAxis->setTickLabelColor(new_color);
1074 
1075  yAxis->setBasePen(pen);
1076  yAxis->setLabelColor(new_color);
1077  yAxis->setTickLabelColor(new_color);
1078 
1079  // And now set the color map's pen to the same color, even if we do not use
1080  // it, we need it for coloring the plots that might be integrated from this
1081  // color map.
1082 
1083  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
1084 
1085  color_map_p->setPen(pen);
1086 
1087  replot();
1088 }

◆ transposeAxes()

void pappso::BaseColorMapPlotWidget::transposeAxes ( )
virtual

Definition at line 459 of file basecolormapplotwidget.cpp.

460 {
461  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()" ;
462 
463  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
464 
465  QCPColorMapData *origData = color_map_p->data();
466 
467  int keySize = origData->keySize();
468  int valueSize = origData->valueSize();
469 
470  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
471  //<< "Orig data size:" << keySize << valueSize;
472 
473  QCPRange keyRange = origData->keyRange();
474  QCPRange valueRange = origData->valueRange();
475 
476  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
477  //<< "Value at cell 80,650:" << origData->cell(80,650);
478 
479  // Transposed map.
480  QCPColorMapData *newData =
481  new QCPColorMapData(valueSize, keySize, valueRange, keyRange);
482 
483  for(int iter = 0; iter < keySize; ++iter)
484  {
485  for(int jter = 0; jter < valueSize; ++jter)
486  {
487  double cellData = origData->cell(iter, jter);
488 
489  newData->setCell(jter, iter, cellData);
490  }
491  }
492 
493  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
494  //<< "New data size:" << newData->keySize() << newData->valueSize();
495 
496  // At this point the transposition has been done.
497 
498  color_map_p->data()->clear();
499  color_map_p->rescaleDataRange(true);
500 
501  // Now we need to invert the labels and data kinds.
502 
505  m_colorMapPlotConfig.yAxisDataKind = temp_data_kind;
506 
507  QString temp_axis_label = xAxis->label();
508  xAxis->setLabel(yAxis->label());
509  yAxis->setLabel(temp_axis_label);
510 
511  // Will take ownership of the newData.
512  color_map_p->setData(newData);
513 
514  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
515  //<< "Value at cell 80,650:" << newData->cell(80,650)
516  //<< "Value at cell 650, 80:" << newData->cell(650,80);
517 
518  // QCPAxis *p_keyAxis = mp_colorMap->keyAxis();
519  // QCPAxis *p_valueAxis = mp_colorMap->valueAxis();
520 
521  // mp_colorMap->setKeyAxis(p_valueAxis);
522  // mp_colorMap->setValueAxis(p_keyAxis);
523 
524  color_map_p->rescaleAxes();
525 
526  replot();
527 }
DataKind
Definition: types.h:172

References m_colorMapPlotConfig, pappso::ColorMapPlotConfig::xAxisDataKind, and pappso::ColorMapPlotConfig::yAxisDataKind.

◆ xAxisDataKind()

DataKind pappso::BaseColorMapPlotWidget::xAxisDataKind ( ) const

Definition at line 1007 of file basecolormapplotwidget.cpp.

1008 {
1010 }

References m_colorMapPlotConfig, and pappso::ColorMapPlotConfig::xAxisDataKind.

◆ xAxisScale()

AxisScale pappso::BaseColorMapPlotWidget::xAxisScale ( ) const

Definition at line 1039 of file basecolormapplotwidget.cpp.

1040 {
1042 }

References m_colorMapPlotConfig, and pappso::ColorMapPlotConfig::xAxisScale.

◆ yAxisDataKind()

DataKind pappso::BaseColorMapPlotWidget::yAxisDataKind ( ) const

Definition at line 1014 of file basecolormapplotwidget.cpp.

1015 {
1017 }

References m_colorMapPlotConfig, and pappso::ColorMapPlotConfig::yAxisDataKind.

◆ yAxisScale()

AxisScale pappso::BaseColorMapPlotWidget::yAxisScale ( ) const

Definition at line 1046 of file basecolormapplotwidget.cpp.

1047 {
1049 }

References m_colorMapPlotConfig, and pappso::ColorMapPlotConfig::yAxisScale.

◆ zAxisDataResetToOriginal()

void pappso::BaseColorMapPlotWidget::zAxisDataResetToOriginal ( )
virtual

Definition at line 970 of file basecolormapplotwidget.cpp.

971 {
972  // The user might have changed to the axis scale to log10, for example.
973  // While doing this, the original data were still available in
974  // mpa_origColorMapData,with mpa_origColorMapPlotConfig. We need to reset the
975  // current data to the original data.
976  //
977  // Same thing for filters that might have been applied to the data.
978 
979  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
980  color_map_p->data()->clear();
981 
982  if(mpa_origColorMapData == nullptr)
983  throw(PappsoException(
984  "Not possible that the mpa_origColorMapData pointer be null."));
985 
986  // We do no want that the color_map_p takes ownership of the data, because
987  // these must remain there always, so pass true, to say that we want to copy
988  // the data not transfer the pointer.
989  color_map_p->setData(mpa_origColorMapData, true);
990 
991  color_map_p->data()->recalculateDataBounds();
992  color_map_p->rescaleDataRange(true);
993 
994  // We should not do this, as the user might have zoomed to a region of
995  // interest.
996  // color_map_p->rescaleAxes();
997 
998  // Reset the current plot config to what it was originally. The member
999  // m_colorMapPlotConfig.zAxisScale is now AxisScale::orig.
1001 
1002  replot();
1003 }

References m_colorMapPlotConfig, mpa_origColorMapData, and mpa_origColorMapPlotConfig.

◆ zAxisFilterHighPassPercentage()

void pappso::BaseColorMapPlotWidget::zAxisFilterHighPassPercentage ( double  threshold_percentage)
virtual

Definition at line 859 of file basecolormapplotwidget.cpp.

861 {
862  // This filter allows all the value greater than a threshold to remain
863  // unchanged. Instead, all the values below the threshold will be reset to
864  // that threshold value.
865  //
866  // The effect of this filter is to reduce the low-intensity signal: reduce
867  // noise.
868 
869  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
870 
871  QCPColorMapData *map_data = color_map_p->data();
872 
873  int keySize = map_data->keySize();
874  int valueSize = map_data->valueSize();
875 
876  QCPRange keyRange = map_data->keyRange();
877  QCPRange valueRange = map_data->valueRange();
878 
879  double minZValue = m_colorMapPlotConfig.lastMinZValue;
880  double maxZValue = m_colorMapPlotConfig.lastMaxZValue;
881 
882  double amplitude = maxZValue - minZValue;
883 
884  double amplitude_fraction = amplitude * threshold_percentage / 100;
885 
886  double threshold = minZValue + amplitude_fraction;
887 
888  // qDebug() << "Before filtering minZValue:" << minZValue
889  //<< "maxZValue:" << maxZValue << "fraction:" << fraction
890  //<< "threshold:" << threshold
891  //<< "new threshold percentage:" << new_threshold_percentage;
892 
893  // Make a copy of the current config so that we can modify
894  // the xxxZvalue values.
895  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
896 
897  // But we need to reset these two values to be able to update them using
898  // std::min() and std::max() below.
899  new_color_map_plot_config.lastMinZValue = std::numeric_limits<double>::max();
900  new_color_map_plot_config.lastMaxZValue = std::numeric_limits<double>::min();
901 
902  // Filtered
903  QCPColorMapData *new_map_data =
904  new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
905 
906  for(int iter = 0; iter < keySize; ++iter)
907  {
908  for(int jter = 0; jter < valueSize; ++jter)
909  {
910  double cell_data = map_data->cell(iter, jter);
911 
912  double new_cell_data = 0;
913 
914  if(cell_data > threshold)
915  // Keep the value, we are in high-pass
916  new_cell_data = cell_data;
917  else
918  new_cell_data = threshold;
919 
920  // Store the new values here.
921  new_color_map_plot_config.lastMinZValue =
922  //(new_cell_data < new_color_map_plot_config.minZValue
923  //? new_cell_data
924  //: new_color_map_plot_config.minZValue);
925  std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
926 
927  new_color_map_plot_config.lastMaxZValue =
928  //(new_cell_data > new_color_map_plot_config.maxZValue
929  //? new_cell_data
930  //: new_color_map_plot_config.maxZValue);
931  std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
932 
933  // qDebug() << "cell_data:" << cell_data
934  //<< "new_cell_data:" << new_cell_data
935  //<< "new_color_map_plot_config.minZValue:"
936  //<< new_color_map_plot_config.minZValue
937  //<< "new_color_map_plot_config.maxZValue:"
938  //<< new_color_map_plot_config.maxZValue;
939 
940  new_map_data->setCell(iter, jter, new_cell_data);
941  }
942  }
943 
944  color_map_p->data()->clear();
945 
946  // Will take ownership of the new_map_data.
947  color_map_p->setData(new_map_data);
948 
949  color_map_p->data()->recalculateDataBounds();
950  color_map_p->rescaleDataRange(true);
951 
952 
953  // At this point the new color map data have taken their place, we can update
954  // the config. This, way any new filtering can take advantage of the new
955  // values and compute the threshold correctly.
956  m_colorMapPlotConfig = new_color_map_plot_config;
957 
958  // qDebug() << "Member colormap plot config is now, after filter was applied:"
959  //<< m_colorMapPlotConfig.toString();
960 
961  // We should not do this, as the user might have zoomed to a region of
962  // interest.
963  // color_map_p->rescaleAxes();
964 
965  replot();
966 }

References pappso::ColorMapPlotConfig::lastMaxZValue, pappso::ColorMapPlotConfig::lastMinZValue, and m_colorMapPlotConfig.

◆ zAxisFilterLowPassPercentage()

void pappso::BaseColorMapPlotWidget::zAxisFilterLowPassPercentage ( double  threshold_percentage)
virtual

Definition at line 651 of file basecolormapplotwidget.cpp.

653 {
654  // This filter allows all the values smaller than a threshold to remain
655  // unchanged. Instead, all the values above the threshold will be reset to
656  // that threshold.
657  //
658  // The effect of this filter is to enhance the high-intensity signal.
659 
660  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
661 
662  QCPColorMapData *map_data = color_map_p->data();
663 
664  int keySize = map_data->keySize();
665  int valueSize = map_data->valueSize();
666 
667  QCPRange keyRange = map_data->keyRange();
668  QCPRange valueRange = map_data->valueRange();
669 
670  double minZValue = m_colorMapPlotConfig.lastMinZValue;
671  double maxZValue = m_colorMapPlotConfig.lastMaxZValue;
672 
673  double amplitude = maxZValue - minZValue;
674 
675  double amplitude_fraction = amplitude * threshold_percentage / 100;
676 
677  double threshold = minZValue + amplitude_fraction;
678 
679  // qDebug() << "Before filtering minZValue:" << minZValue
680  //<< "maxZValue:" << maxZValue << "fraction:" << fraction
681  //<< "threshold:" << threshold
682  //<< "new threshold percentage:" << new_threshold_percentage;
683 
684  // Make a copy of the current config so that we can modify
685  // the xxxZvalue values.
686  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
687 
688  // But we need to reset these two values to be able to update them using
689  // std::min() and std::max() below.
690  new_color_map_plot_config.lastMinZValue = std::numeric_limits<double>::max();
691  new_color_map_plot_config.lastMaxZValue = std::numeric_limits<double>::min();
692 
693  // Filtered
694  QCPColorMapData *new_map_data =
695  new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
696 
697  for(int iter = 0; iter < keySize; ++iter)
698  {
699  for(int jter = 0; jter < valueSize; ++jter)
700  {
701  double cell_data = map_data->cell(iter, jter);
702 
703  double new_cell_data = 0;
704 
705  if(cell_data < threshold)
706  // Keep the value, we are in low-pass
707  new_cell_data = cell_data;
708  else
709  new_cell_data = threshold;
710 
711  // Store the new values here.
712  new_color_map_plot_config.lastMinZValue =
713  //(new_cell_data < new_color_map_plot_config.minZValue
714  //? new_cell_data
715  //: new_color_map_plot_config.minZValue);
716  std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
717 
718  new_color_map_plot_config.lastMaxZValue =
719  //(new_cell_data > new_color_map_plot_config.maxZValue
720  //? new_cell_data
721  //: new_color_map_plot_config.maxZValue);
722  std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
723 
724  // qDebug() << "cell_data:" << cell_data
725  //<< "new_cell_data:" << new_cell_data
726  //<< "new_color_map_plot_config.minZValue:"
727  //<< new_color_map_plot_config.minZValue
728  //<< "new_color_map_plot_config.maxZValue:"
729  //<< new_color_map_plot_config.maxZValue;
730 
731  new_map_data->setCell(iter, jter, new_cell_data);
732  }
733  }
734 
735  color_map_p->data()->clear();
736 
737  // Will take ownership of the new_map_data.
738  color_map_p->setData(new_map_data);
739 
740  color_map_p->data()->recalculateDataBounds();
741  color_map_p->rescaleDataRange(true);
742 
743 
744  // At this point the new color map data have taken their place, we can update
745  // the config. This, way any new filtering can take advantage of the new
746  // values and compute the threshold correctly.
747  m_colorMapPlotConfig = new_color_map_plot_config;
748 
749  // qDebug() << "Member colormap plot config is now, after filter was applied:"
750  //<< m_colorMapPlotConfig.toString();
751 
752  // We should not do this, as the user might have zoomed to a region of
753  // interest.
754  // color_map_p->rescaleAxes();
755 
756  replot();
757 }

References pappso::ColorMapPlotConfig::lastMaxZValue, pappso::ColorMapPlotConfig::lastMinZValue, and m_colorMapPlotConfig.

◆ zAxisFilterLowPassThreshold()

void pappso::BaseColorMapPlotWidget::zAxisFilterLowPassThreshold ( double  threshold)
virtual

fix maximum value for the intensity

Definition at line 761 of file basecolormapplotwidget.cpp.

762 {
763 
764  // This filter allows all the values smaller than a threshold to remain
765  // unchanged. Instead, all the values above the threshold will be reset to
766  // that threshold.
767 
768  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
769 
770  QCPColorMapData *map_data = color_map_p->data();
771 
772  int keySize = map_data->keySize();
773  int valueSize = map_data->valueSize();
774 
775  QCPRange keyRange = map_data->keyRange();
776  QCPRange valueRange = map_data->valueRange();
777 
778  // qDebug() << "Before filtering minZValue:" << minZValue
779  //<< "maxZValue:" << maxZValue << "fraction:" << fraction
780  //<< "threshold:" << threshold
781  //<< "new threshold percentage:" << new_threshold_percentage;
782 
783  // Make a copy of the current config so that we can modify
784  // the xxxZvalue values.
785  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
786 
787  // But we need to reset these two values to be able to update them using
788  // std::min() and std::max() below.
789  new_color_map_plot_config.lastMinZValue = std::numeric_limits<double>::max();
790  new_color_map_plot_config.lastMaxZValue = std::numeric_limits<double>::min();
791 
792  // Filtered
793  QCPColorMapData *new_map_data =
794  new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
795 
796  for(int iter = 0; iter < keySize; ++iter)
797  {
798  for(int jter = 0; jter < valueSize; ++jter)
799  {
800  double cell_data = map_data->cell(iter, jter);
801 
802  double new_cell_data = 0;
803 
804  if(cell_data < threshold)
805  // Keep the value, we are in low-pass
806  new_cell_data = cell_data;
807  else
808  new_cell_data = threshold;
809 
810  // Store the new values here.
811  new_color_map_plot_config.lastMinZValue =
812  //(new_cell_data < new_color_map_plot_config.minZValue
813  //? new_cell_data
814  //: new_color_map_plot_config.minZValue);
815  std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
816 
817  new_color_map_plot_config.lastMaxZValue =
818  //(new_cell_data > new_color_map_plot_config.maxZValue
819  //? new_cell_data
820  //: new_color_map_plot_config.maxZValue);
821  std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
822 
823  // qDebug() << "cell_data:" << cell_data
824  //<< "new_cell_data:" << new_cell_data
825  //<< "new_color_map_plot_config.minZValue:"
826  //<< new_color_map_plot_config.minZValue
827  //<< "new_color_map_plot_config.maxZValue:"
828  //<< new_color_map_plot_config.maxZValue;
829 
830  new_map_data->setCell(iter, jter, new_cell_data);
831  }
832  }
833 
834  color_map_p->data()->clear();
835 
836  // Will take ownership of the new_map_data.
837  color_map_p->setData(new_map_data);
838 
839  color_map_p->data()->recalculateDataBounds();
840  color_map_p->rescaleDataRange(true);
841 
842 
843  // At this point the new color map data have taken their place, we can update
844  // the config. This, way any new filtering can take advantage of the new
845  // values and compute the threshold correctly.
846  m_colorMapPlotConfig = new_color_map_plot_config;
847 
848  // qDebug() << "Member colormap plot config is now, after filter was applied:"
849  //<< m_colorMapPlotConfig.toString();
850 
851  // We should not do this, as the user might have zoomed to a region of
852  // interest.
853  // color_map_p->rescaleAxes();
854 
855  replot();
856 }

References pappso::ColorMapPlotConfig::lastMaxZValue, pappso::ColorMapPlotConfig::lastMinZValue, and m_colorMapPlotConfig.

◆ zAxisScale()

AxisScale pappso::BaseColorMapPlotWidget::zAxisScale ( ) const

Definition at line 1053 of file basecolormapplotwidget.cpp.

1054 {
1056 }

References m_colorMapPlotConfig, and pappso::ColorMapPlotConfig::zAxisScale.

◆ zAxisScaleToLog10()

void pappso::BaseColorMapPlotWidget::zAxisScaleToLog10 ( )
virtual

Definition at line 531 of file basecolormapplotwidget.cpp.

532 {
533  // The user wants to rescale the intensity values of the color map according
534  // to: new_int = log10(orig_int).
535 
536  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()" ;
537 
539  {
540  qDebug() << "Asking to change z axis scale to log10 while it is already "
541  "like so.";
542 
543  return;
544  }
545 
546  // qDebug() << "m_colorMapPlotConfig:" << m_colorMapPlotConfig.toString();
547 
548  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
549 
550  QCPColorMapData *map_data = color_map_p->data();
551 
552  int keySize = map_data->keySize();
553  int valueSize = map_data->valueSize();
554 
555  QCPRange keyRange = map_data->keyRange();
556  QCPRange valueRange = map_data->valueRange();
557 
558  // Make a copy of the current config so that we can modify
559  // the xxxZvalue values.
560  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
561 
562  // But we need to reset these two values to be able to update them using
563  // std::min() and std::max() below.
564  new_color_map_plot_config.setOrigAndLastMinZValue(
565  std::numeric_limits<double>::max());
566 
567  new_color_map_plot_config.setOrigAndLastMaxZValue(
568  std::numeric_limits<double>::min());
569 
570  // qDebug() << "new_color_map_plot_config"
571  //<< new_color_map_plot_config.toString();
572 
573  // Log-ified heat map.
574  QCPColorMapData *new_map_data =
575  new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
576 
577  // qDebug() << "Starting iteration in the color map.";
578 
579  for(int iter = 0; iter < keySize; ++iter)
580  {
581  for(int jter = 0; jter < valueSize; ++jter)
582  {
583  double cell_data = map_data->cell(iter, jter);
584 
585  double new_cell_data = 0;
586 
587  if(!cell_data)
588  // The log10 would be -inf, but then we'd have a huge data range and
589  // the color map would look totally blue... that is like 0 intensity
590  // all over.
591  new_cell_data = -1;
592  else
593  new_cell_data = std::log10(cell_data);
594 
595  // Store the new values here. Should we change the last or orig or
596  // both ?
597  new_color_map_plot_config.lastMinZValue =
598  //(new_cell_data < new_color_map_plot_config.minZValue
599  //? new_cell_data
600  //: new_color_map_plot_config.minZValue);
601  std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
602 
603  new_color_map_plot_config.lastMaxZValue =
604  //(new_cell_data > new_color_map_plot_config.maxZValue
605  //? new_cell_data
606  //: new_color_map_plot_config.maxZValue);
607  std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
608 
609  // qDebug() << "cell_data:" << cell_data
610  //<< "new_cell_data:" << new_cell_data
611  //<< "new_color_map_plot_config.minZValue:"
612  //<< new_color_map_plot_config.minZValue
613  //<< "new_color_map_plot_config.maxZValue:"
614  //<< new_color_map_plot_config.maxZValue;
615 
616  new_map_data->setCell(iter, jter, new_cell_data);
617  }
618  }
619 
620  // qDebug() << "Finished iteration in the color map.";
621 
622  color_map_p->data()->clear();
623 
624  // Will take ownership of the new_map_data.
625  color_map_p->setData(new_map_data);
626 
627  color_map_p->data()->recalculateDataBounds();
628  color_map_p->rescaleDataRange(true);
629 
630  // At this point the new color map data have taken their place, we can update
631  // the config. This, way any new filtering can take advantage of the new
632  // values and compute the threshold correctly.
633  m_colorMapPlotConfig = new_color_map_plot_config;
634 
635  // Now we need to document the change.
637 
638  // qDebug() << "new_color_map_plot_config"
639  //<< new_color_map_plot_config.toString();
640 
641  // qDebug() << "m_colorMapPlotConfig:" << m_colorMapPlotConfig.toString();
642 
643  // We should not do this, as the user might have zoomed to a region of
644  // interest.
645  // color_map_p->rescaleAxes();
646 
647  replot();
648 }

References pappso::ColorMapPlotConfig::lastMaxZValue, pappso::ColorMapPlotConfig::lastMinZValue, pappso::log10, m_colorMapPlotConfig, pappso::ColorMapPlotConfig::setOrigAndLastMaxZValue(), pappso::ColorMapPlotConfig::setOrigAndLastMinZValue(), and pappso::ColorMapPlotConfig::zAxisScale.

Member Data Documentation

◆ m_colorMapPlotConfig

◆ mpa_origColorMapData

QCPColorMapData* pappso::BaseColorMapPlotWidget::mpa_origColorMapData = nullptr
protected

◆ mpa_origColorMapPlotConfig

ColorMapPlotConfig* pappso::BaseColorMapPlotWidget::mpa_origColorMapPlotConfig = nullptr
protected

The documentation for this class was generated from the following files: