#include <basecolormapplotwidget.h>

Inheritance diagram for pappso::BaseColorMapPlotWidget:

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.
virtual void	setColorMapPlotConfig (const ColorMapPlotConfig &color_map_config)
virtual const ColorMapPlotConfig &	getColorMapPlotConfig ()
const ColorMapPlotConfig *	getOrigColorMapPlotConfig ()
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
virtual void	zAxisFilterHighPassPercentage (double threshold_percentage)
virtual void	zAxisDataResetToOriginal ()
Enums::DataKind	xAxisDataKind () const
Enums::DataKind	yAxisDataKind () const
Enums::AxisScale	axisScale (Enums::Axis axis) const
Enums::AxisScale	xAxisScale () const
Enums::AxisScale	yAxisScale () const
Enums::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.
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.
virtual void	restorePreviousAxesRangeHistory ()
	Go up one history element in the axis history.
virtual void	restoreAxesRangeHistory (std::size_t index)
	Get the axis histories at index `index` and update the plot ranges.
virtual void	keyPressEvent (QKeyEvent *event)
	KEYBOARD-related EVENTS.
virtual void	keyReleaseEvent (QKeyEvent *event)
	Handle specific key codes and trigger respective actions.
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.
virtual void	mouseReleaseHandler (QMouseEvent *event)
virtual void	mouseReleaseHandlerLeftButton ()
virtual void	mouseReleaseHandlerRightButton ()
virtual void	mouseWheelHandler (QWheelEvent *event)
virtual void	mouseMoveHandler (QMouseEvent *event)
	KEYBOARD-related EVENTS.
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.
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.
virtual QCPRange	getRangeY (bool &found_range, int index) const
QCPRange	getRange (Enums::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.
virtual void	axisReframe ()
virtual void	axisZoom ()
virtual void	axisPan ()
virtual void	replotWithAxesRanges (QCPRange xAxisRange, QCPRange yAxisRange, Enums::Axis axis)
virtual void	replotWithAxisRangeX (double lower, double upper)
virtual void	replotWithAxisRangeY (double lower, double upper)
virtual void	hideAllPlotItems ()
	PLOTTING / REPLOTTING functions.
virtual void	showTracers ()
	Show the traces (vertical and horizontal).
virtual void	hideTracers ()
	Hide the traces (vertical and horizontal).
virtual void	drawXScopeSpanFeatures ()
virtual void	drawYScopeSpanFeatures ()
virtual void	calculateDragDeltas ()
virtual bool	isVerticalDisplacementAboveThreshold ()
virtual void	drawSelectionRectangleAndPrepareZoom (bool as_line_segment=false, bool for_integration=false)
virtual void	updateIntegrationScopeDrawing (bool as_line_segment=false, bool for_integration=false)
virtual void	resetSelectionRectangle ()
virtual void	hideSelectionRectangle (bool reset_values=false)
virtual bool	isSelectionRectangleVisible ()
virtual SelectionDrawingLines	whatIsVisibleOfTheSelectionRectangle ()
virtual void	setFocus ()
	PLOT ITEMS : TRACER TEXT ITEMS...
virtual void	redrawPlotBackground (QWidget *focusedPlotWidget)
	Redraw the background of the `focusedPlotWidget` plot widget.
virtual void	updateContextXandYAxisRanges ()
virtual const BasePlotContext &	getContext () const

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

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	mousePressEventSignal (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	updateIntegrationScope (bool for_integration=false)
virtual void	updateIntegrationScopeRect (bool for_integration=false)
virtual void	updateIntegrationScopeHorizontalRhomb (bool for_integration=false)
virtual void	updateIntegrationScopeVerticalRhomb (bool for_integration=false)
virtual void	updateIntegrationScopeRhomb (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.

                                                              : BasePlotWidget(parent, "x", "y")
{
  // Do not call createAllAncillaryItems() in this base class because all the
  // items will have been created *before* the addition of plots and then the
  // rendering order will hide them to the viewer, since the rendering order is
  // according to the order in which the items have been created.
  //
  // The fact that the ancillary items are created before trace plots is not a
  // problem because the trace plots are sparse and do not effectively hide the
  // data.
  //
  // But, in the color map plot widgets, we cannot afford to create the
  // ancillary items *before* the plot itself because then, the rendering of the
  // plot (created after) would screen off the ancillary items (created before).
  //
  // So, the createAllAncillaryItems() function needs to be called in the
  // derived classes at the most appropriate moment in the setting up of the
  // widget.
  //
  // In the present case, the function needs to be called right after addition
  // of the color map plot.
}

References pappso::BasePlotWidget::BasePlotWidget().

Referenced by pappso::DriftSpecMassSpecColorMapPlotWidget::DriftSpecMassSpecColorMapPlotWidget(), pappso::TicXicChromDriftSpecColorMapPlotWidget::TicXicChromDriftSpecColorMapPlotWidget(), and pappso::TicXicChromMassSpecColorMapPlotWidget::TicXicChromMassSpecColorMapPlotWidget().

◆ 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.

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

References pappso::BasePlotWidget::BasePlotWidget().

◆ ~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 102 of file basecolormapplotwidget.cpp.

{
  if(mpa_origColorMapData != nullptr)
    delete mpa_origColorMapData;
 
  if(mpa_origColorMapPlotConfig != nullptr)
    delete 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 282 of file basecolormapplotwidget.cpp.

{
  qDebug();
  if(!color.isValid())
    throw PappsoException(QString("The color to be used for the plot graph is invalid."));
 
  QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
 
  color_map_p->setLayer("plotsLayer");
 
  // Do not forget to copy the config!
  m_colorMapPlotConfig = color_map_plot_config;
 
  // Immediately create a copy of the original data for backup.
  mpa_origColorMapPlotConfig = new ColorMapPlotConfig(color_map_plot_config);
 
  qDebug();
#if 0
      // This is the code on the QCustomPlot documentation and it works fine.
      QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
 
      color_map_p->data()->setSize(50, 50);
      color_map_p->data()->setRange(QCPRange(0, 2), QCPRange(0, 2));
      for(int x = 0; x < 50; ++x)
        for(int y = 0; y < 50; ++y)
          color_map_p->data()->setCell(x, y, qCos(x / 10.0) + qSin(y / 10.0));
      color_map_p->setGradient(QCPColorGradient::gpPolar);
      color_map_p->rescaleDataRange(true);
      rescaleAxes();
      replot();
#endif
 
  // Only now can afford to call createAllAncillaryItems() in this derived class
  // because the color map has been created already. The rendering order will
  // thus not hide the ancillary items, since they have been created after the
  // color map plot (since the rendering order is according to the
  // order in which the items have been created). See contructor note.
  createAllAncillaryItems();
 
  qDebug();
  // Connect the signal of selection change so that we can re-emit it for the
  // widget that is using *this widget.
 
  connect(
    color_map_p,
    static_cast<void (QCPAbstractPlottable::*)(bool)>(&QCPAbstractPlottable::selectionChanged),
    [this, color_map_p]() {
      emit plottableSelectionChangedSignal(color_map_p, color_map_p->selected());
    });
 
  // qDebug() << "Configuring the color map with this config:"
  //<< color_map_plot_config.toString();
 
  color_map_p->data()->setSize(color_map_plot_config.keyCellCount,
                               color_map_plot_config.mzCellCount);
 
  color_map_p->data()->setRange(
    QCPRange(color_map_plot_config.minKeyValue, color_map_plot_config.maxKeyValue),
    QCPRange(color_map_plot_config.minMzValue, color_map_plot_config.maxMzValue));
  color_map_p->data()->fill(0.0);
  // double max_intensity = 0;
  qDebug();
  // We have now to fill the color map.
  std::size_t number_of_scans = tims_frame.getTotalNumberOfScans();
  for(std::size_t i = 0; i < number_of_scans; i++)
    {
      std::vector<quint32> tof_index_vector       = tims_frame.getScanTofIndexList(i);
      std::vector<quint32> intensity_index_vector = tims_frame.getScanIntensityList(i);
 
 
      // The first value is the key and the second value is the MapTrace into
      // which we need to iterated and for each point (double mz, double
      // intensity) create a map cell.
 
      double dt_or_rt_key      = i;
      std::size_t vector_index = 0;
      for(quint32 mzindex : tof_index_vector)
        {
          double mz        = mzindex;
          double intensity = intensity_index_vector.at(vector_index);
          // max_intensity    = std::max(max_intensity, intensity);
          // We are filling dynamically the color map. If a cell had already
          // something in, then we need to take that into account. This is
          // because we let QCustomPlot handle the fuzzy transition between
          // color map plot cells.
 
          double prev_intensity = color_map_p->data()->data(dt_or_rt_key, mz);
          double new_intensity  = prev_intensity + intensity;
 
          // qDebug() << "mz=" << mz << " int=" << intensity;
 
          // Record the min/max cell intensity value (origM(in/ax)ZValue). We
          // will need that later. Also update the lastM(in/ax)ZValue because
          // when doing this kind of data conversion it is assume that the user
          // actually changes the data.
          m_colorMapPlotConfig.setOrigAndLastMinZValue(
            std::min(m_colorMapPlotConfig.origMinZValue, new_intensity));
 
          m_colorMapPlotConfig.setOrigAndLastMaxZValue(
            std::max(m_colorMapPlotConfig.origMaxZValue, new_intensity));
 
          // qDebug() << "Setting tri-point:" << dt_or_rt_key << "," << mz <<
          // ","
          //<< new_intensity;
 
          color_map_p->data()->setCell(dt_or_rt_key, mz, new_intensity);
 
          // qDebug() << "dt_or_rt_key=" << dt_or_rt_key << " mz=" << mz
          //         << " new_intensity=" << new_intensity;
 
          vector_index++;
        }
    }
 
  // At this point we have finished filling-up the color map.
 
  // The gpThermal is certainly one of the best.
 
  color_map_p->setGradient(QCPColorGradient::gpThermal);
 
  color_map_p->data()->recalculateDataBounds();
  color_map_p->rescaleDataRange(true);
 
  color_map_p->rescaleAxes();
  resetAxesRangeHistory();
 
  // The pen of the color map itself is of no use. Instead the user will see the
  // color of the axes' labels.
 
  qDebug();
  QPen pen = xAxis->basePen();
  pen.setColor(color);
 
  xAxis->setBasePen(pen);
  xAxis->setLabelColor(color);
  xAxis->setTickLabelColor(color);
 
  yAxis->setBasePen(pen);
  yAxis->setLabelColor(color);
  yAxis->setTickLabelColor(color);
 
  // And now set the color map's pen to the same color, even if we do not use
  // it, we need it for coloring the plots that might be integrated from this
  // color map.
 
  color_map_p->setPen(pen);
 
  // Copy the original color map's data into a backup copy.
 
  mpa_origColorMapData = new QCPColorMapData(*(color_map_p->data()));
 
  color_map_p->setInterpolate(false);
  color_map_p->setTightBoundary(false);
 
  replot();
 
 
  qDebug() << color_map_p->data()->keyRange();
  qDebug() << color_map_p->data()->valueRange();
  qDebug() << color_map_p->data()->dataBounds();
  qDebug();
  return color_map_p;
}

References pappso::BasePlotWidget::createAllAncillaryItems(), pappso::TimsFrame::getScanIntensityList(), pappso::TimsFrame::getScanTofIndexList(), 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::ColorMapPlotConfig::mzCellCount, pappso::BasePlotWidget::plottableSelectionChangedSignal(), pappso::BasePlotWidget::resetAxesRangeHistory(), 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 134 of file basecolormapplotwidget.cpp.

{
  // qDebug() << "Adding color map with config:" <<
  // color_map_plot_config.toString();
 
  if(!color.isValid())
    throw PappsoException(QString("The color to be used for the plot graph is invalid."));
 
  QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
 
  color_map_p->setLayer("plotsLayer");
 
  // Do not forget to copy the config!
  m_colorMapPlotConfig = color_map_plot_config;
 
  // Immediately create a copy of the original data for backup.
  mpa_origColorMapPlotConfig = new ColorMapPlotConfig(color_map_plot_config);
 
#if 0
      // This is the code on the QCustomPlot documentation and it works fine.
      QCPColorMap *color_map_p = new QCPColorMap(xAxis, yAxis);
 
      color_map_p->data()->setSize(50, 50);
      color_map_p->data()->setRange(QCPRange(0, 2), QCPRange(0, 2));
      for(int x = 0; x < 50; ++x)
        for(int y = 0; y < 50; ++y)
          color_map_p->data()->setCell(x, y, qCos(x / 10.0) + qSin(y / 10.0));
      color_map_p->setGradient(QCPColorGradient::gpPolar);
      color_map_p->rescaleDataRange(true);
      rescaleAxes();
      replot();
#endif
 
  // Only now can afford to call createAllAncillaryItems() in this derived class
  // because the color map has been created already. The rendering order will
  // thus not hide the ancillary items, since they have been created after the
  // color map plot (since the rendering order is according to the
  // order in which the items have been created). See contructor note.
  createAllAncillaryItems();
 
  // Connect the signal of selection change so that we can re-emit it for the
  // widget that is using *this widget.
 
  connect(
    color_map_p,
    static_cast<void (QCPAbstractPlottable::*)(bool)>(&QCPAbstractPlottable::selectionChanged),
    [this, color_map_p]() {
      emit plottableSelectionChangedSignal(color_map_p, color_map_p->selected());
    });
 
  // qDebug() << "Configuring the color map with this config:"
  //<< color_map_plot_config.toString();
 
  color_map_p->data()->setSize(color_map_plot_config.keyCellCount,
                               color_map_plot_config.mzCellCount);
 
  color_map_p->data()->setRange(
    QCPRange(color_map_plot_config.minKeyValue, color_map_plot_config.maxKeyValue),
    QCPRange(color_map_plot_config.minMzValue, color_map_plot_config.maxMzValue));
  color_map_p->data()->fill(0.0);
 
  // We have now to fill the color map.
 
  for(auto &&pair : *double_map_trace_map_sp)
    {
 
      // The first value is the key and the second value is the MapTrace into
      // which we need to iterated and for each point (double mz, double
      // intensity) create a map cell.
 
      double dt_or_rt_key = pair.first;
      MapTrace map_trace  = pair.second;
 
      for(auto &&data_point_pair : map_trace)
        {
          double mz        = data_point_pair.first;
          double intensity = data_point_pair.second;
 
          // We are filling dynamically the color map. If a cell had already
          // something in, then we need to take that into account. This is
          // because we let QCustomPlot handle the fuzzy transition between
          // color map plot cells.
 
          double prev_intensity = color_map_p->data()->data(dt_or_rt_key, mz);
          double new_intensity  = prev_intensity + intensity;
 
          // Record the min/max cell intensity value (origM(in/ax)ZValue). We
          // will need that later. Also update the lastM(in/ax)ZValue because
          // when doing this kind of data conversion it is assume that the user
          // actually changes the data.
          m_colorMapPlotConfig.setOrigAndLastMinZValue(
            std::min(m_colorMapPlotConfig.origMinZValue, new_intensity));
 
          m_colorMapPlotConfig.setOrigAndLastMaxZValue(
            std::max(m_colorMapPlotConfig.origMaxZValue, new_intensity));
 
          // qDebug() << "Setting tri-point:" << dt_or_rt_key << "," << mz <<
          // ","
          //<< new_intensity;
 
          color_map_p->data()->setData(dt_or_rt_key, mz, new_intensity);
        }
    }
 
  // At this point we have finished filling-up the color map.
 
  // The gpThermal is certainly one of the best.
 
  color_map_p->setGradient(QCPColorGradient::gpThermal);
 
  color_map_p->rescaleDataRange(true);
 
  color_map_p->rescaleAxes();
  resetAxesRangeHistory();
 
  // The pen of the color map itself is of no use. Instead the user will see the
  // color of the axes' labels.
 
  QPen pen = xAxis->basePen();
  pen.setColor(color);
 
  xAxis->setBasePen(pen);
  xAxis->setLabelColor(color);
  xAxis->setTickLabelColor(color);
 
  yAxis->setBasePen(pen);
  yAxis->setLabelColor(color);
  yAxis->setTickLabelColor(color);
 
  // And now set the color map's pen to the same color, even if we do not use
  // it, we need it for coloring the plots that might be integrated from this
  // color map.
 
  color_map_p->setPen(pen);
 
  // Copy the original color map's data into a backup copy.
 
  mpa_origColorMapData = new QCPColorMapData(*(color_map_p->data()));
 
  replot();
 
  return color_map_p;
}

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::ColorMapPlotConfig::mzCellCount, pappso::BasePlotWidget::plottableSelectionChangedSignal(), pappso::BasePlotWidget::resetAxesRangeHistory(), pappso::x, and pappso::y.

◆ axisScale()

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

Definition at line 1001 of file basecolormapplotwidget.cpp.

{
  if(axis == Enums::Axis::x)
    return m_colorMapPlotConfig.xAxisScale;
  else if(axis == Enums::Axis::y)
    return m_colorMapPlotConfig.yAxisScale;
  else if(axis == Enums::Axis::z)
    return m_colorMapPlotConfig.zAxisScale;
  else
    throw PappsoException(
      QString("basecolormapplotwidget.cpp: The axis cannot be different than "
              "x, y or z."));
 
  return Enums::AxisScale::unset;
}

References m_colorMapPlotConfig, pappso::Enums::unset, pappso::Enums::x, pappso::Enums::y, and pappso::Enums::z.

◆ currentXaxisRangeIndices()

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

Definition at line 1081 of file basecolormapplotwidget.cpp.

{
  // We want to limit the ranges to the visible data range in the plot widget.
 
  QCPColorMap *color_map_p  = static_cast<QCPColorMap *>(plottable(0));
  QCPColorMapData *map_data = color_map_p->data();
 
  bool found_range = false;
 
  // Get the full data set DT values range because if the context contains no
  // values for the currently displayed ranges, then we fall back to them;
  QCPRange full_data_range = color_map_p->getKeyRange(found_range);
 
  if(!found_range)
    {
      qDebug() << "The range was not found";
      return;
    }
 
  // qDebug() << "Full key data range:" << full_data_range.lower << "-"
  //<< full_data_range.upper;
 
  // But what we actually want is the currently visible axes ranges. And these
  // are stored in the context.
 
  double visible_data_range_lower = m_context.m_xRange.lower;
  double visible_data_range_upper = m_context.m_xRange.upper;
 
  // qDebug() << "Visible key data range:" << visible_data_range_lower << "-"
  //<< visible_data_range_upper;
 
  // Note that if there has been *no* panning, rescale, nothing, with the color
  // map, then the context has no idea of the ranges. So we need to check that.
  // If that is the case, then we use the full key range as the full plot is
  // displayed full scale upon its first showing.
 
  if(!visible_data_range_lower || !visible_data_range_upper)
    {
      visible_data_range_lower = full_data_range.lower;
      visible_data_range_upper = full_data_range.upper;
    }
 
  // qDebug() << "Visible key range:" << visible_data_range_lower << "-"
  //<< visible_data_range_upper;
 
  // And now convert the double value ranges into cell indices, which is what we
  // are being asked for.
 
  map_data->coordToCell(visible_data_range_lower, 0, &lower, nullptr);
  map_data->coordToCell(visible_data_range_upper, 0, &upper, nullptr);
 
  // qDebug() << "Cell indices for currently visible key range:" << lower << "-"
  //<< upper;
}

References pappso::BasePlotWidget::m_context.

Referenced by dataTo3ColString(), and dataToMatrixString().

◆ currentYaxisRangeIndices()

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

Definition at line 1138 of file basecolormapplotwidget.cpp.

{
  // We want to limit the ranges to the visible data range in the plot widget.
 
  QCPColorMap *color_map_p  = static_cast<QCPColorMap *>(plottable(0));
  QCPColorMapData *map_data = color_map_p->data();
 
  bool found_range = false;
 
  // Get the full data set MZ values range because if the context contains no
  // values for the currently displayed ranges, then we fall back to them;
  QCPRange full_data_range = color_map_p->getValueRange(found_range);
 
  if(!found_range)
    {
      qDebug() << "The range was not found";
      return;
    }
 
  // qDebug() << "Full value data range:" << full_data_range.lower << "-"
  //<< full_data_range.upper;
 
  // But what we actually want is the currently visible axes ranges. And these
  // are stored in the context.
 
  double visible_data_range_lower = m_context.m_yRange.lower;
  double visible_data_range_upper = m_context.m_yRange.upper;
 
  // qDebug() << "Visible value data range:" << visible_data_range_lower << "-"
  //<< visible_data_range_upper;
 
  // Note that if there has been *no* panning, rescale, nothing, with the color
  // map, then the context has no idea of the ranges. So we need to check that.
  // If that is the case, then we use the full key range as the full plot is
  // displayed full scale upon its first showing.
 
  if(!visible_data_range_lower || !visible_data_range_upper)
    {
      visible_data_range_lower = full_data_range.lower;
      visible_data_range_upper = full_data_range.upper;
    }
 
  // qDebug() << "Final visible value data range:" << visible_data_range_lower
  //<< "-" << visible_data_range_upper;
 
  // And now convert the double value ranges into cell indices, which is what we
  // are being asked for.
 
  map_data->coordToCell(0, visible_data_range_lower, nullptr, &lower);
  map_data->coordToCell(0, visible_data_range_upper, nullptr, &upper);
 
  // qDebug() << "Cell indices for currently visible value range:" << lower <<
  // "-"
  //<< upper;
}

References pappso::BasePlotWidget::m_context.

Referenced by dataTo3ColString(), and dataToMatrixString().

◆ dataTo3ColString()

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

Definition at line 1196 of file basecolormapplotwidget.cpp.

{
  // We want to export the data to a string in the x y z format, with
  // x=key (cell's x coordinate)
  // y=value (cell's y coordinate)
  // z=intensity (cell value)
 
  QCPColorMap *color_map_p  = static_cast<QCPColorMap *>(plottable(0));
  QCPColorMapData *map_data = color_map_p->data();
 
  int key_index_lower_range;
  int key_index_upper_range;
  currentXaxisRangeIndices(key_index_lower_range, key_index_upper_range);
 
  // qDebug() << "Cell indices for currently visible key range:"
  //<< key_index_lower_range << "-" << key_index_upper_range;
 
  int value_index_lower_range;
  int value_index_upper_range;
  currentYaxisRangeIndices(value_index_lower_range, value_index_upper_range);
 
  // qDebug() << "Cell indices for currently visible value range:"
  //<< value_index_lower_range << "-" << value_index_upper_range;
 
  data_string.clear();
  QString debug_string;
 
  // Iterate in the matrix' key axis (DT, for example)
  for(int key_iter = key_index_lower_range; key_iter < key_index_upper_range; ++key_iter)
    {
      // Iterate in the matrix' value axis (MZ, for example)
      for(int value_iter = value_index_lower_range; value_iter < value_index_upper_range;
          ++value_iter)
        {
          // This would be the DT value (x axis)
          double key;
 
          // This would be the MZ value (y axis)
          double value;
 
          map_data->cellToCoord(key_iter, value_iter, &key, &value);
 
          data_string += QString("%1 %2 %3\n")
                           .arg(key, 0, 'f', 6, ' ')
                           .arg(value, 0, 'f', 6, ' ')
                           // The intensity without decimals
                           .arg(map_data->cell(key_iter, value_iter), 0, 'f', 0, ' ');
        }
    }
 
  // qDebug() << "The completed data string has size: " << data_string.size();
}

References currentXaxisRangeIndices(), and currentYaxisRangeIndices().

◆ dataToMatrixString()

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

Definition at line 1251 of file basecolormapplotwidget.cpp.

{
  // We want to export the data in the form of a matrix, exactly as the data
  // appear within the colormap, unless the color is replaced with the intensity
  // value.
 
  // We want to limit the export to the visible data range in the plot widget.
 
  QCPColorMap *color_map_p  = static_cast<QCPColorMap *>(plottable(0));
  QCPColorMapData *map_data = color_map_p->data();
 
  int key_index_lower_range;
  int key_index_upper_range;
  currentXaxisRangeIndices(key_index_lower_range, key_index_upper_range);
 
  // qDebug() << "Cell indices for currently visible key range:"
  //<< key_index_lower_range << "-" << key_index_upper_range;
 
  int value_index_lower_range;
  int value_index_upper_range;
  currentYaxisRangeIndices(value_index_lower_range, value_index_upper_range);
 
  // qDebug() << "Cell indices for currently visible value range:"
  //<< value_index_lower_range << "-" << value_index_upper_range;
 
  data_string.clear();
 
  // At this point, we can write the header of the key data (that is the dt
  // key values).
 
  for(int key_iter = key_index_lower_range; key_iter < key_index_upper_range; ++key_iter)
    {
      double current_key_value;
      map_data->cellToCoord(key_iter, 0, &current_key_value, nullptr);
 
      data_string += QString("%1 ").arg(current_key_value, 0, 'f', 6, ' ');
    }
 
  // Finally call the newline
  data_string += "\n";
 
  // Now fill in the matrix, from top to down, that is from higher m/z values to
  // lower values.
 
  // The matrix we are exporting looks like this:
 
  //       |
  //       |
  //       |
  //       |
  //       |
  //       |
  //  m/z  |
  //       |
  //       |
  //       |
  //       |
  //       |______________________________
  //                      dt
 
  // Because we want the matrix to be presented the same, we need to fill in the
  // matrix from top to bottom starting from higher m/z values.
 
  for(int value_iter = value_index_upper_range; value_iter >= value_index_lower_range; --value_iter)
    {
 
      for(int key_iter = key_index_lower_range; key_iter < key_index_upper_range; ++key_iter)
        {
          double intensity = map_data->cell(key_iter, value_iter);
 
          // Only to report debug messages
          double key_double;
          double value_double;
          map_data->cellToCoord(key_iter, value_iter, &key_double, &value_double);
 
          // qDebug() << "Currently iterated cell: " << key_iter << ","
          //<< value_iter << "with values:" << key_double << ","
          //<< value_double << "with intensity:" << intensity;
 
          // The intensity without decimals
          if(detailed)
            data_string += QString("%1/%2/%3 ")
                             .arg(key_double, 0, 'f', 6, ' ')
                             .arg(value_double, 0, 'f', 6, ' ')
                             .arg(intensity);
          else
            data_string += QString("%1 ").arg(intensity, 0, 'f', 0, ' ');
        }
 
      data_string += "\n";
    }
 
  // qDebug().noquote() << "The matrix: " << data_string;
  // qDebug() << "The completed data string has size: " <<
  // data_string.size();
 
  data_string += "\n";
}

References currentXaxisRangeIndices(), and currentYaxisRangeIndices().

◆ getColorMapPlotConfig()

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

virtual

Definition at line 127 of file basecolormapplotwidget.cpp.

{
  return m_colorMapPlotConfig;
}

References m_colorMapPlotConfig.

◆ getOrigColorMapPlotConfig()

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

Definition at line 120 of file basecolormapplotwidget.cpp.

{
  return mpa_origColorMapPlotConfig;
}

References mpa_origColorMapPlotConfig.

◆ getPlottingColor()

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

overridevirtual

Reimplemented from pappso::BasePlotWidget.

Definition at line 1071 of file basecolormapplotwidget.cpp.

{
  Q_UNUSED(index);
 
  QPen pen = xAxis->basePen();
  return pen.color();
}

◆ setColorMapPlotConfig()

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

virtual

Definition at line 113 of file basecolormapplotwidget.cpp.

{
  m_colorMapPlotConfig = color_map_config;
}

References m_colorMapPlotConfig.

◆ setPlottingColor()

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

overridevirtual

Reimplemented from pappso::BasePlotWidget.

Definition at line 1040 of file basecolormapplotwidget.cpp.

{
  Q_UNUSED(plottable_p);
 
  // The pen of the color map itself is of no use. Instead the user will see the
  // color of the axes' labels.
 
  QPen pen = xAxis->basePen();
  pen.setColor(new_color);
 
  xAxis->setBasePen(pen);
  xAxis->setLabelColor(new_color);
  xAxis->setTickLabelColor(new_color);
 
  yAxis->setBasePen(pen);
  yAxis->setLabelColor(new_color);
  yAxis->setTickLabelColor(new_color);
 
  // And now set the color map's pen to the same color, even if we do not use
  // it, we need it for coloring the plots that might be integrated from this
  // color map.
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
 
  color_map_p->setPen(pen);
 
  replot();
}

◆ transposeAxes()

void pappso::BaseColorMapPlotWidget::transposeAxes ( )

virtual

Definition at line 449 of file basecolormapplotwidget.cpp.

{
  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()" ;
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
 
  QCPColorMapData *origData = color_map_p->data();
 
  int keySize   = origData->keySize();
  int valueSize = origData->valueSize();
 
  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
  //<< "Orig data size:" << keySize << valueSize;
 
  QCPRange keyRange   = origData->keyRange();
  QCPRange valueRange = origData->valueRange();
 
  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
  //<< "Value at cell 80,650:" << origData->cell(80,650);
 
  // Transposed map.
  QCPColorMapData *newData = new QCPColorMapData(valueSize, keySize, valueRange, keyRange);
 
  for(int iter = 0; iter < keySize; ++iter)
    {
      for(int jter = 0; jter < valueSize; ++jter)
        {
          double cellData = origData->cell(iter, jter);
 
          newData->setCell(jter, iter, cellData);
        }
    }
 
  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
  //<< "New data size:" << newData->keySize() << newData->valueSize();
 
  // At this point the transposition has been done.
 
  color_map_p->data()->clear();
  color_map_p->rescaleDataRange(true);
 
  // Now we need to invert the labels and data kinds.
 
  Enums::DataKind temp_data_kind     = m_colorMapPlotConfig.xAxisDataKind;
  m_colorMapPlotConfig.xAxisDataKind = m_colorMapPlotConfig.yAxisDataKind;
  m_colorMapPlotConfig.yAxisDataKind = temp_data_kind;
 
  QString temp_axis_label = xAxis->label();
  xAxis->setLabel(yAxis->label());
  yAxis->setLabel(temp_axis_label);
 
  // Will take ownership of the newData.
  color_map_p->setData(newData);
 
  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()"
  //<< "Value at cell 80,650:" << newData->cell(80,650)
  //<< "Value at cell 650, 80:" << newData->cell(650,80);
 
  // QCPAxis *p_keyAxis = mp_colorMap->keyAxis();
  // QCPAxis *p_valueAxis = mp_colorMap->valueAxis();
 
  // mp_colorMap->setKeyAxis(p_valueAxis);
  // mp_colorMap->setValueAxis(p_keyAxis);
 
  color_map_p->rescaleAxes();
 
  replot();
}

References m_colorMapPlotConfig.

◆ xAxisDataKind()

Enums::DataKind pappso::BaseColorMapPlotWidget::xAxisDataKind ( ) const

Definition at line 987 of file basecolormapplotwidget.cpp.

{
  return m_colorMapPlotConfig.xAxisDataKind;
}

References m_colorMapPlotConfig.

◆ xAxisScale()

Enums::AxisScale pappso::BaseColorMapPlotWidget::xAxisScale ( ) const

Definition at line 1019 of file basecolormapplotwidget.cpp.

{
  return m_colorMapPlotConfig.xAxisScale;
}

References m_colorMapPlotConfig.

◆ yAxisDataKind()

Enums::DataKind pappso::BaseColorMapPlotWidget::yAxisDataKind ( ) const

Definition at line 994 of file basecolormapplotwidget.cpp.

{
  return m_colorMapPlotConfig.yAxisDataKind;
}

References m_colorMapPlotConfig.

◆ yAxisScale()

Enums::AxisScale pappso::BaseColorMapPlotWidget::yAxisScale ( ) const

Definition at line 1026 of file basecolormapplotwidget.cpp.

{
  return m_colorMapPlotConfig.yAxisScale;
}

References m_colorMapPlotConfig.

◆ zAxisDataResetToOriginal()

void pappso::BaseColorMapPlotWidget::zAxisDataResetToOriginal ( )

virtual

Definition at line 951 of file basecolormapplotwidget.cpp.

{
  // The user might have changed to the axis scale to log10, for example.
  // While doing this, the original data were still available in
  // mpa_origColorMapData,with mpa_origColorMapPlotConfig. We need to reset the
  // current data to the original data.
  //
  // Same thing for filters that might have been applied to the data.
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
  color_map_p->data()->clear();
 
  if(mpa_origColorMapData == nullptr)
    throw(PappsoException("Not possible that the mpa_origColorMapData pointer be null."));
 
  // We do no want that the color_map_p takes ownership of the data, because
  // these must remain there always, so pass true, to say that we want to copy
  // the data not transfer the pointer.
  color_map_p->setData(mpa_origColorMapData, true);
 
  color_map_p->data()->recalculateDataBounds();
  color_map_p->rescaleDataRange(true);
 
  // We should not do this, as the user might have zoomed to a region of
  // interest.
  // color_map_p->rescaleAxes();
 
  // Reset the current plot config to what it was originally. The member
  // m_colorMapPlotConfig.zAxisScale  is now Enums::AxisScale::orig.
  m_colorMapPlotConfig = *mpa_origColorMapPlotConfig;
 
  replot();
}

References m_colorMapPlotConfig, mpa_origColorMapData, and mpa_origColorMapPlotConfig.

◆ zAxisFilterHighPassPercentage()

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

virtual

Definition at line 842 of file basecolormapplotwidget.cpp.

{
  // This filter allows all the value greater than a threshold to remain
  // unchanged. Instead, all the values below the threshold will be reset to
  // that threshold value.
  //
  // The effect of this filter is to reduce the low-intensity signal: reduce
  // noise.
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
 
  QCPColorMapData *map_data = color_map_p->data();
 
  int keySize   = map_data->keySize();
  int valueSize = map_data->valueSize();
 
  QCPRange keyRange   = map_data->keyRange();
  QCPRange valueRange = map_data->valueRange();
 
  double minZValue = m_colorMapPlotConfig.lastMinZValue;
  double maxZValue = m_colorMapPlotConfig.lastMaxZValue;
 
  double amplitude = maxZValue - minZValue;
 
  double amplitude_fraction = amplitude * threshold_percentage / 100;
 
  double threshold = minZValue + amplitude_fraction;
 
  // qDebug() << "Before filtering minZValue:" << minZValue
  //<< "maxZValue:" << maxZValue << "fraction:" << fraction
  //<< "threshold:" << threshold
  //<< "new threshold percentage:" << new_threshold_percentage;
 
  // Make a copy of the current config so that we can modify
  // the xxxZvalue values.
  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
 
  // But we need to reset these two values to be able to update them using
  // std::min() and std::max() below.
  new_color_map_plot_config.lastMinZValue = std::numeric_limits<double>::max();
  new_color_map_plot_config.lastMaxZValue = std::numeric_limits<double>::min();
 
  // Filtered
  QCPColorMapData *new_map_data = new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
 
  for(int iter = 0; iter < keySize; ++iter)
    {
      for(int jter = 0; jter < valueSize; ++jter)
        {
          double cell_data = map_data->cell(iter, jter);
 
          double new_cell_data = 0;
 
          if(cell_data > threshold)
            // Keep the value, we are in high-pass
            new_cell_data = cell_data;
          else
            new_cell_data = threshold;
 
          // Store the new values here.
          new_color_map_plot_config.lastMinZValue =
            //(new_cell_data < new_color_map_plot_config.minZValue
            //? new_cell_data
            //: new_color_map_plot_config.minZValue);
            std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
 
          new_color_map_plot_config.lastMaxZValue =
            //(new_cell_data > new_color_map_plot_config.maxZValue
            //? new_cell_data
            //: new_color_map_plot_config.maxZValue);
            std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
 
          // qDebug() << "cell_data:" << cell_data
          //<< "new_cell_data:" << new_cell_data
          //<< "new_color_map_plot_config.minZValue:"
          //<< new_color_map_plot_config.minZValue
          //<< "new_color_map_plot_config.maxZValue:"
          //<< new_color_map_plot_config.maxZValue;
 
          new_map_data->setCell(iter, jter, new_cell_data);
        }
    }
 
  color_map_p->data()->clear();
 
  // Will take ownership of the new_map_data.
  color_map_p->setData(new_map_data);
 
  color_map_p->data()->recalculateDataBounds();
  color_map_p->rescaleDataRange(true);
 
 
  // At this point the new color map data have taken their place, we can update
  // the config. This, way any new filtering can take advantage of the new
  // values and compute the threshold correctly.
  m_colorMapPlotConfig = new_color_map_plot_config;
 
  // qDebug() << "Member colormap plot config is now, after filter was applied:"
  //<< m_colorMapPlotConfig.toString();
 
  // We should not do this, as the user might have zoomed to a region of
  // interest.
  // color_map_p->rescaleAxes();
 
  replot();
}

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

◆ zAxisFilterLowPassPercentage()

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

virtual

Definition at line 637 of file basecolormapplotwidget.cpp.

{
  // This filter allows all the values smaller than a threshold to remain
  // unchanged. Instead, all the values above the threshold will be reset to
  // that threshold.
  //
  // The effect of this filter is to enhance the high-intensity signal.
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
 
  QCPColorMapData *map_data = color_map_p->data();
 
  int keySize   = map_data->keySize();
  int valueSize = map_data->valueSize();
 
  QCPRange keyRange   = map_data->keyRange();
  QCPRange valueRange = map_data->valueRange();
 
  double minZValue = m_colorMapPlotConfig.lastMinZValue;
  double maxZValue = m_colorMapPlotConfig.lastMaxZValue;
 
  double amplitude = maxZValue - minZValue;
 
  double amplitude_fraction = amplitude * threshold_percentage / 100;
 
  double threshold = minZValue + amplitude_fraction;
 
  // qDebug() << "Before filtering minZValue:" << minZValue
  //<< "maxZValue:" << maxZValue << "fraction:" << fraction
  //<< "threshold:" << threshold
  //<< "new threshold percentage:" << new_threshold_percentage;
 
  // Make a copy of the current config so that we can modify
  // the xxxZvalue values.
  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
 
  // But we need to reset these two values to be able to update them using
  // std::min() and std::max() below.
  new_color_map_plot_config.lastMinZValue = std::numeric_limits<double>::max();
  new_color_map_plot_config.lastMaxZValue = std::numeric_limits<double>::min();
 
  // Filtered
  QCPColorMapData *new_map_data = new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
 
  for(int iter = 0; iter < keySize; ++iter)
    {
      for(int jter = 0; jter < valueSize; ++jter)
        {
          double cell_data = map_data->cell(iter, jter);
 
          double new_cell_data = 0;
 
          if(cell_data < threshold)
            // Keep the value, we are in low-pass
            new_cell_data = cell_data;
          else
            new_cell_data = threshold;
 
          // Store the new values here.
          new_color_map_plot_config.lastMinZValue =
            //(new_cell_data < new_color_map_plot_config.minZValue
            //? new_cell_data
            //: new_color_map_plot_config.minZValue);
            std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
 
          new_color_map_plot_config.lastMaxZValue =
            //(new_cell_data > new_color_map_plot_config.maxZValue
            //? new_cell_data
            //: new_color_map_plot_config.maxZValue);
            std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
 
          // qDebug() << "cell_data:" << cell_data
          //<< "new_cell_data:" << new_cell_data
          //<< "new_color_map_plot_config.minZValue:"
          //<< new_color_map_plot_config.minZValue
          //<< "new_color_map_plot_config.maxZValue:"
          //<< new_color_map_plot_config.maxZValue;
 
          new_map_data->setCell(iter, jter, new_cell_data);
        }
    }
 
  color_map_p->data()->clear();
 
  // Will take ownership of the new_map_data.
  color_map_p->setData(new_map_data);
 
  color_map_p->data()->recalculateDataBounds();
  color_map_p->rescaleDataRange(true);
 
 
  // At this point the new color map data have taken their place, we can update
  // the config. This, way any new filtering can take advantage of the new
  // values and compute the threshold correctly.
  m_colorMapPlotConfig = new_color_map_plot_config;
 
  // qDebug() << "Member colormap plot config is now, after filter was applied:"
  //<< m_colorMapPlotConfig.toString();
 
  // We should not do this, as the user might have zoomed to a region of
  // interest.
  // color_map_p->rescaleAxes();
 
  replot();
}

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 745 of file basecolormapplotwidget.cpp.

{
 
  // This filter allows all the values smaller than a threshold to remain
  // unchanged. Instead, all the values above the threshold will be reset to
  // that threshold.
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
 
  QCPColorMapData *map_data = color_map_p->data();
 
  int keySize   = map_data->keySize();
  int valueSize = map_data->valueSize();
 
  QCPRange keyRange   = map_data->keyRange();
  QCPRange valueRange = map_data->valueRange();
 
  // qDebug() << "Before filtering minZValue:" << minZValue
  //<< "maxZValue:" << maxZValue << "fraction:" << fraction
  //<< "threshold:" << threshold
  //<< "new threshold percentage:" << new_threshold_percentage;
 
  // Make a copy of the current config so that we can modify
  // the xxxZvalue values.
  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
 
  // But we need to reset these two values to be able to update them using
  // std::min() and std::max() below.
  new_color_map_plot_config.lastMinZValue = std::numeric_limits<double>::max();
  new_color_map_plot_config.lastMaxZValue = std::numeric_limits<double>::min();
 
  // Filtered
  QCPColorMapData *new_map_data = new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
 
  for(int iter = 0; iter < keySize; ++iter)
    {
      for(int jter = 0; jter < valueSize; ++jter)
        {
          double cell_data = map_data->cell(iter, jter);
 
          double new_cell_data = 0;
 
          if(cell_data < threshold)
            // Keep the value, we are in low-pass
            new_cell_data = cell_data;
          else
            new_cell_data = threshold;
 
          // Store the new values here.
          new_color_map_plot_config.lastMinZValue =
            //(new_cell_data < new_color_map_plot_config.minZValue
            //? new_cell_data
            //: new_color_map_plot_config.minZValue);
            std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
 
          new_color_map_plot_config.lastMaxZValue =
            //(new_cell_data > new_color_map_plot_config.maxZValue
            //? new_cell_data
            //: new_color_map_plot_config.maxZValue);
            std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
 
          // qDebug() << "cell_data:" << cell_data
          //<< "new_cell_data:" << new_cell_data
          //<< "new_color_map_plot_config.minZValue:"
          //<< new_color_map_plot_config.minZValue
          //<< "new_color_map_plot_config.maxZValue:"
          //<< new_color_map_plot_config.maxZValue;
 
          new_map_data->setCell(iter, jter, new_cell_data);
        }
    }
 
  color_map_p->data()->clear();
 
  // Will take ownership of the new_map_data.
  color_map_p->setData(new_map_data);
 
  color_map_p->data()->recalculateDataBounds();
  color_map_p->rescaleDataRange(true);
 
 
  // At this point the new color map data have taken their place, we can update
  // the config. This, way any new filtering can take advantage of the new
  // values and compute the threshold correctly.
  m_colorMapPlotConfig = new_color_map_plot_config;
 
  // qDebug() << "Member colormap plot config is now, after filter was applied:"
  //<< m_colorMapPlotConfig.toString();
 
  // We should not do this, as the user might have zoomed to a region of
  // interest.
  // color_map_p->rescaleAxes();
 
  replot();
}

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

◆ zAxisScale()

Enums::AxisScale pappso::BaseColorMapPlotWidget::zAxisScale ( ) const

Definition at line 1033 of file basecolormapplotwidget.cpp.

{
  return m_colorMapPlotConfig.zAxisScale;
}

References m_colorMapPlotConfig.

◆ zAxisScaleToLog10()

void pappso::BaseColorMapPlotWidget::zAxisScaleToLog10 ( )

virtual

Definition at line 520 of file basecolormapplotwidget.cpp.

{
  // The user wants to rescale the intensity values of the color map according
  // to: new_int = log10(orig_int).
 
  // qDebug() << __FILE__ << __LINE__ << __FUNCTION__ << "()" ;
 
  if(m_colorMapPlotConfig.zAxisScale == Enums::AxisScale::log10)
    {
      qDebug() << "Asking to change z axis scale to log10 while it is already "
                  "like so.";
 
      return;
    }
 
  // qDebug() << "m_colorMapPlotConfig:" << m_colorMapPlotConfig.toString();
 
  QCPColorMap *color_map_p = static_cast<QCPColorMap *>(plottable(0));
 
  QCPColorMapData *map_data = color_map_p->data();
 
  int keySize   = map_data->keySize();
  int valueSize = map_data->valueSize();
 
  QCPRange keyRange   = map_data->keyRange();
  QCPRange valueRange = map_data->valueRange();
 
  // Make a copy of the current config so that we can modify
  // the xxxZvalue values.
  ColorMapPlotConfig new_color_map_plot_config(m_colorMapPlotConfig);
 
  // But we need to reset these two values to be able to update them using
  // std::min() and std::max() below.
  new_color_map_plot_config.setOrigAndLastMinZValue(std::numeric_limits<double>::max());
 
  new_color_map_plot_config.setOrigAndLastMaxZValue(std::numeric_limits<double>::min());
 
  // qDebug() << "new_color_map_plot_config"
  //<< new_color_map_plot_config.toString();
 
  // Log-ified heat map.
  QCPColorMapData *new_map_data = new QCPColorMapData(keySize, valueSize, keyRange, valueRange);
 
  // qDebug() << "Starting iteration in the color map.";
 
  for(int iter = 0; iter < keySize; ++iter)
    {
      for(int jter = 0; jter < valueSize; ++jter)
        {
          double cell_data = map_data->cell(iter, jter);
 
          double new_cell_data = 0;
 
          if(!cell_data)
            // The log10 would be -inf, but then we'd have a huge data range and
            // the color map would look totally blue... that is like 0 intensity
            // all over.
            new_cell_data = -1;
          else
            new_cell_data = std::log10(cell_data);
 
          // Store the new values here. Should we change the last or orig or
          // both ?
          new_color_map_plot_config.lastMinZValue =
            //(new_cell_data < new_color_map_plot_config.minZValue
            //? new_cell_data
            //: new_color_map_plot_config.minZValue);
            std::min(new_color_map_plot_config.lastMinZValue, new_cell_data);
 
          new_color_map_plot_config.lastMaxZValue =
            //(new_cell_data > new_color_map_plot_config.maxZValue
            //? new_cell_data
            //: new_color_map_plot_config.maxZValue);
            std::max(new_color_map_plot_config.lastMaxZValue, new_cell_data);
 
          // qDebug() << "cell_data:" << cell_data
          //<< "new_cell_data:" << new_cell_data
          //<< "new_color_map_plot_config.minZValue:"
          //<< new_color_map_plot_config.minZValue
          //<< "new_color_map_plot_config.maxZValue:"
          //<< new_color_map_plot_config.maxZValue;
 
          new_map_data->setCell(iter, jter, new_cell_data);
        }
    }
 
  // qDebug() << "Finished iteration in the color map.";
 
  color_map_p->data()->clear();
 
  // Will take ownership of the new_map_data.
  color_map_p->setData(new_map_data);
 
  color_map_p->data()->recalculateDataBounds();
  color_map_p->rescaleDataRange(true);
 
  // At this point the new color map data have taken their place, we can update
  // the config. This, way any new filtering can take advantage of the new
  // values and compute the threshold correctly.
  m_colorMapPlotConfig = new_color_map_plot_config;
 
  // Now we need to document the change.
  m_colorMapPlotConfig.zAxisScale = Enums::AxisScale::log10;
 
  // qDebug() << "new_color_map_plot_config"
  //<< new_color_map_plot_config.toString();
 
  // qDebug() << "m_colorMapPlotConfig:" << m_colorMapPlotConfig.toString();
 
  // We should not do this, as the user might have zoomed to a region of
  // interest.
  // color_map_p->rescaleAxes();
 
  replot();
}

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

Member Data Documentation

◆ m_colorMapPlotConfig

ColorMapPlotConfig pappso::BaseColorMapPlotWidget::m_colorMapPlotConfig

protected

Definition at line 127 of file basecolormapplotwidget.h.

Referenced by addColorMap(), addColorMap(), axisScale(), getColorMapPlotConfig(), setColorMapPlotConfig(), transposeAxes(), xAxisDataKind(), xAxisScale(), yAxisDataKind(), yAxisScale(), zAxisDataResetToOriginal(), zAxisFilterHighPassPercentage(), zAxisFilterLowPassPercentage(), zAxisFilterLowPassThreshold(), zAxisScale(), and zAxisScaleToLog10().

◆ mpa_origColorMapData

QCPColorMapData* pappso::BaseColorMapPlotWidget::mpa_origColorMapData = nullptr

protected

Definition at line 125 of file basecolormapplotwidget.h.

Referenced by ~BaseColorMapPlotWidget(), addColorMap(), addColorMap(), and zAxisDataResetToOriginal().

◆ mpa_origColorMapPlotConfig

ColorMapPlotConfig* pappso::BaseColorMapPlotWidget::mpa_origColorMapPlotConfig = nullptr

protected

Definition at line 128 of file basecolormapplotwidget.h.

Referenced by ~BaseColorMapPlotWidget(), addColorMap(), addColorMap(), getOrigColorMapPlotConfig(), and zAxisDataResetToOriginal().

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

pappsomspp/gui/plotwidget/basecolormapplotwidget.h
pappsomspp/gui/plotwidget/basecolormapplotwidget.cpp

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BaseColorMapPlotWidget() [1/2]

◆ BaseColorMapPlotWidget() [2/2]

◆ ~BaseColorMapPlotWidget()

Member Function Documentation

◆ addColorMap() [1/2]

◆ addColorMap() [2/2]

◆ axisScale()

◆ currentXaxisRangeIndices()

◆ currentYaxisRangeIndices()

◆ dataTo3ColString()

◆ dataToMatrixString()

◆ getColorMapPlotConfig()

◆ getOrigColorMapPlotConfig()

◆ getPlottingColor()

◆ setColorMapPlotConfig()

◆ setPlottingColor()

◆ transposeAxes()

◆ xAxisDataKind()

◆ xAxisScale()

◆ yAxisDataKind()

◆ yAxisScale()

◆ zAxisDataResetToOriginal()

◆ zAxisFilterHighPassPercentage()

◆ zAxisFilterLowPassPercentage()

◆ zAxisFilterLowPassThreshold()

◆ zAxisScale()

◆ zAxisScaleToLog10()

Member Data Documentation

◆ m_colorMapPlotConfig

◆ mpa_origColorMapData

◆ mpa_origColorMapPlotConfig