Plot1DCanvas.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg$
// $Authors: Marc Sturm, Timo Sachsenberg, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
// OpenMS_GUI config
#include <OpenMS/VISUAL/OpenMS_GUIConfig.h>
 
// OpenMS
#include <OpenMS/VISUAL/LayerData1DBase.h>
#include <OpenMS/VISUAL/LayerDataChrom.h>
#include <OpenMS/VISUAL/PlotCanvas.h>
#include <OpenMS/VISUAL/Painter1DBase.h>
 
// QT
#include <QTextDocument>
#include <QPoint>
 
// STL
#include <vector>
#include <utility>
 
// QT
class QAction;
 
namespace OpenMS
{
  class Annotation1DItem;
  
  class Gravitator
  {
  public:
 
    using AreaXYType = PlotCanvas::GenericArea::AreaXYType;
 
    Gravitator(DIM axis)
    {
      setGravityAxis(axis);
    }
 
    Gravitator(const DimMapper<2>& unit_mapper)
    {
      setIntensityAsGravity(unit_mapper);
    }
 
    void setGravityAxis(DIM axis)
    {
      if (axis != DIM::X && axis != DIM::Y)
      {
        throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Not a valid axis for 1D plotting", String((int)axis));
      }
      gravity_axis_ = axis;
    }
 
    void setIntensityAsGravity(const DimMapper<2>& unit_mapper)
    {
      if (unit_mapper.getDim(DIM::X).getUnit() == DIM_UNIT::INT)
      {
        setGravityAxis(DIM::X);
      }
      if (unit_mapper.getDim(DIM::Y).getUnit() == DIM_UNIT::INT)
      {
        setGravityAxis(DIM::Y);
      }
      throw Exception::NotImplemented(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);      
    }
 
    DIM getGravityAxis() const
    {
      return gravity_axis_;
    }
 
    Gravitator swap() const
    {
      auto r = *this;
      r.setGravityAxis( (r.getGravityAxis() == DIM::X) ? DIM::Y : DIM::X);
      return r;
    }
 
    QPoint gravitateMin(QPoint p, const AreaXYType& area) const
    {
      if (gravity_axis_ == DIM::X)
      {
        p.rx() = area.minX();
      }
      else if (gravity_axis_ == DIM::Y)
      {
        p.ry() = area.minY();
      }
      return p;
    }
 
    QPoint gravitateWith(QPoint p, const QPoint& delta) const
    {
      if (gravity_axis_ == DIM::X)
      {
        p.rx() += delta.x();
      }
      else if (gravity_axis_ == DIM::Y)
      {
        p.ry() += delta.y();
      }
      return p;
    }
 
    template<UInt D>
    DPosition<D> gravitateWith(DPosition<D> p, const DPosition<D>& delta) const
    {
      p[(int)gravity_axis_] += delta[(int)gravity_axis_];
      return p;
    }
 
    QPoint gravitateTo(QPoint p, const QPoint& target) const
    {
      if (gravity_axis_ == DIM::X)
      {
        p.rx() = target.x();
      }
      else if (gravity_axis_ == DIM::Y)
      {
        p.ry() = target.y();
      }
      return p;
    }
    
    template<UInt D>
    DPosition<D> gravitateTo(DPosition<D> p, const DPosition<D>& target) const
    {
      p[(int)gravity_axis_] = target[(int)gravity_axis_];
      return p;
    }
 
 
    QPoint gravitateMax(QPoint p, const AreaXYType& area) const
    {
      if (gravity_axis_ == DIM::X)
      {
        p.rx() = area.maxX();
      }
      else if (gravity_axis_ == DIM::Y)
      {
        p.ry() = area.maxY();
      }
      return p;
    }
 
    QPoint gravitateZero(QPoint p) const
    {
      if (gravity_axis_ == DIM::X)
      {
        p.rx() = 0;
      }
      else if (gravity_axis_ == DIM::Y)
      {
        p.ry() = 0;
      }
      return p;
    }
 
    template<UInt D>
    DPosition<D> gravitateZero(DPosition<D> p) const
    {
      p[(int)gravity_axis_] = 0;
      return p;
    }
 
    template<UInt D>
    DPosition<D> gravitateNAN(DPosition<D> p) const
    {
      p[(int)gravity_axis_] = std::numeric_limits<float>::quiet_NaN();
      return p;
    }
 
    int gravityValue(const QPoint& p) const
    {
      if (gravity_axis_ == DIM::X)
      {
        return p.x();
      }
      else if (gravity_axis_ == DIM::Y)
      {
        return p.y();
      }
      // never reached, but make compilers happy
      return 0;
    }
    template<UInt D>
    int gravityValue(const DPosition<D>& p) const
    {
      return p[(int)gravity_axis_];
    }
 
    template<UInt D>
    auto gravityDiff(const DPosition<D>& start, const DPosition<D>& end) const
    {
      return end[(int)gravity_axis_] - start[(int)gravity_axis_];
    }
 
  private:
    DIM gravity_axis_;
  };
 
  class OPENMS_GUI_DLLAPI Plot1DCanvas :
    public PlotCanvas
  {
    Q_OBJECT
 
public:
    enum LabelMode
    {
      LM_XABSOLUTE_YABSOLUTE,
      LM_XPERCENT_YABSOLUTE,
      LM_XABSOLUTE_YPERCENT,
      LM_XPERCENT_YPERCENT
    };
 
    constexpr static double TOP_MARGIN{1.09};
 
    Plot1DCanvas(const Param& preferences, const DIM gravity_axis = DIM::Y, QWidget* parent = nullptr);
    ~Plot1DCanvas() override;
    
    const LayerData1DBase& getLayer(Size index) const;
    LayerData1DBase& getLayer(Size index);
 
    const LayerData1DBase& getCurrentLayer() const;
    LayerData1DBase& getCurrentLayer();
 
    const DimBase& getGravityDim() const;
 
    const DimBase& getNonGravityDim() const;
 
    bool addChromLayer(ExperimentSharedPtrType chrom_exp_sptr,
                       ODExperimentSharedPtrType ondisc_sptr, 
                       OSWDataSharedPtrType chrom_annotation,
                       const int index,
                       const String& filename, 
                       const String& basename,
                       const String& basename_extra);
 
    
    enum DrawModes
    {
      DM_PEAKS,         
      DM_CONNECTEDLINES 
    };
 
    DrawModes getDrawMode() const;
 
    void setDrawMode(DrawModes mode);
 
    // Docu in base class
    void showCurrentLayerPreferences() override;
 
    bool flippedLayersExist();
 
    void flipLayer(Size index);
 
    bool mirrorModeActive() const;
 
    void setMirrorModeActive(bool b);
 
    void dataToWidget(const DPosition<2>& peak, QPoint& point, bool flipped = false);
    void dataToWidget(const DPosition<2>& xy_point, DPosition<2>& point, bool flipped);
 
    void dataToWidget(double x, double y, QPoint& point, bool flipped = false);
 
    PointXYType widgetToData(const QPoint& pos);
 
    PointXYType widgetToData(double x, double y);
 
    inline void dataToWidgetDistance(double x, double y, QPoint& point)
    {
      dataToWidget_(x, y, point);
      // subtract the 'offset'
      QPoint zero;
      dataToWidget_(0, 0, zero);
      point -= zero;
    }
 
    inline PointXYType widgetToDataDistance(double x, double y)
    {
      PointXYType point = Plot1DCanvas::widgetToData(x, y); // call the 1D version, otherwise intensity&mirror modes will not be honored
      // subtract the 'offset'
      PointXYType zero = Plot1DCanvas::widgetToData(0, 0); // call the 1D version, otherwise intensity&mirror modes will not be honored
      point -= zero;
      return point;
    }
 
    virtual const RangeType& getDataRange() const override
    { 
      return overall_data_range_1d_;
    }
 
    template <class T>
    void pushIntoDataRange(T& data_point, const int layer_index)
    { // note: if this is needed for anything other than the 1D Canvas, you need to make sure to call the correct widgetToData/ etc functions --- they work a bit different, depending on Canvas
      auto xy_unit = unit_mapper_.map(data_point); // datatype to xy
      pushIntoDataRange(xy_unit, layer_index);
      unit_mapper_.fromXY(xy_unit, data_point);    // xy to datatype
    }
 
    //template<>  // specialization does not compile when declared within the class on GCC -- even though it should; but I'm not moving it outside! :)
    void pushIntoDataRange(PointXYType& xy_unit, const int layer_index)
    { // note: if this is needed for anything other than the 1D Canvas, you need to make sure to call the correct widgetToData/ etc functions --- they work a bit different, depending on Canvas
      auto p_range = unit_mapper_.fromXY(xy_unit);
      const auto all_range = getLayer(layer_index).getRange();
      p_range.pushInto(all_range);
      xy_unit = unit_mapper_.mapRange(p_range).minPosition();
    }
    
    void setTextBox(const QString& html);
 
 
    Annotation1DItem* addPeakAnnotation(const PeakIndex& peak_index, const QString& text, const QColor& color);
 
    void performAlignment(Size layer_index_1, Size layer_index_2, const Param& param);
 
    void resetAlignment();
 
    Size getAlignmentSize();
 
    double getAlignmentScore() const;
 
    std::vector<std::pair<Size, Size> > getAlignedPeaksIndices();
 
    void activateSpectrum(Size index, bool repaint = true);
 
    void setCurrentLayerPeakPenStyle(Qt::PenStyle ps);
 
    void paint(QPainter* paint_device, QPaintEvent* e);
 
    void setDrawInterestingMZs(bool enable);
 
    bool isDrawInterestingMZs() const;
 
    // Show/hide ion ladder on top right corner (Identification view)
    void setIonLadderVisible(bool show);
 
    // Returns true if ion ladder is visible
    bool isIonLadderVisible() const;
 
    const Gravitator& getGravitator() const
    {
      return gr_;
    }
 
signals:
    void showCurrentPeaksAs2D();
 
    void showCurrentPeaksAs3D();
 
    void showCurrentPeaksAsIonMobility(const MSSpectrum& spec);
 
    void showCurrentPeaksAsDIA(const Precursor& pc, const MSExperiment& exp);
 
public slots:
    // Docu in base class
    void activateLayer(Size layer_index) override;
    // Docu in base class
    void removeLayer(Size layer_index) override;
    // Docu in base class
    void updateLayer(Size i) override;
    // Docu in base class
    void horizontalScrollBarChange(int value) override;
 
protected slots:
 
    void currentLayerParamtersChanged_();
 
protected:
 
    
    void dataToWidget_(double x, double y, QPoint& point)
    {
      const auto& xy = visible_area_.getAreaXY();
      const auto h_px = height();
      const auto w_px = width();
 
      point.setX(int((x - xy.minX()) / xy.width() * w_px));
 
      if (intensity_mode_ != PlotCanvas::IM_LOG)
      {
        point.setY(int((xy.maxY() - y) / xy.height() * h_px));
      }
      else // IM_LOG
      {
        point.setY(h_px - int(std::log10((y - xy.minY()) + 1) / std::log10(xy.height() + 1) * h_px));
      }
    }
 
    void dataToWidget_(const DPosition<2>& xy, QPoint& point)
    {
      dataToWidget_(xy.getX(), xy.getY(), point);
    }
 
    QPoint dataToWidget_(const DPosition<2>& xy)
    {
      QPoint point;
      dataToWidget_(xy.getX(), xy.getY(), point);
      return point;
    }
 
    // Docu in base class
    bool finishAdding_() override;
 
    void drawCoordinates_(QPainter& painter, const PeakIndex& peak);
    void drawDeltas_(QPainter& painter, const PeakIndex& start, const PeakIndex& end);
    
    void drawAlignment_(QPainter& painter);
 
    void changeVisibleArea1D_(const UnitRange& new_area, bool repaint, bool add_to_stack);
 
    // Docu in base class
    void changeVisibleArea_(VisibleArea new_area, bool repaint = true, bool add_to_stack = false) override;
 
    void changeVisibleArea_(const AreaXYType& new_area, bool repaint = true, bool add_to_stack = false);
 
    void changeVisibleArea_(const UnitRange& new_area, bool repaint = true, bool add_to_stack = false);
 
 
    void drawHighlightedPeak_(Size layer_index, const PeakIndex& peak, QPainter& painter, bool draw_elongation = false);
 
 
    void resetZoom(bool repaint = true) override
    {
      zoomClear_();
      PlotCanvas::changeVisibleArea_(visible_area_.cloneWith(overall_data_range_1d_), repaint, true);
    }
        
    void recalculatePercentageFactor_(Size layer_index);
 
    void recalculateRanges_() override
    {
      PlotCanvas::recalculateRanges_(); // for: overall_data_range_
      // the same thing for: overall_data_range_1d_
      RangeType& layer_range_1d = overall_data_range_1d_;
      layer_range_1d.clearRanges();
 
      for (Size layer_index = 0; layer_index < getLayerCount(); ++layer_index)
      {
        layer_range_1d.extend(getLayer(layer_index).getRange1D());
      }
      // add 4% margin (2% left, 2% right) to all dimensions, except the current gravity axes's minimum (usually intensity)
      layer_range_1d.scaleBy(1.04);
 
      // set minimum intensity to 0 (avoid negative intensities and show full height of peaks in case their common minimum is large)
      auto& gravity_range = getGravityDim().map(layer_range_1d);
      gravity_range.setMin(0);
      
      // make sure that each dimension is not a single point (axis widget won't like that)
      // (this needs to be the last command to ensure this property holds when leaving the function!)
      layer_range_1d.minSpanIfSingular(1);
    }
 
    // Docu in base class
    void updateScrollbars_() override;
    // Docu in base class
    void intensityModeChange_() override;
    
    
    RangeAllType correctGravityAxisOfVisibleArea_(UnitRange area);
    
    void paintEvent(QPaintEvent* e) override;
    void mousePressEvent(QMouseEvent* e) override;
    void mouseReleaseEvent(QMouseEvent* e) override;
    void mouseMoveEvent(QMouseEvent* e) override;
    void keyPressEvent(QKeyEvent* e) override;
    void contextMenuEvent(QContextMenuEvent* e) override;
 
    // docu in base class
    void zoomForward_() override;
    // docu in base class
    void zoom_(int x, int y, bool zoom_in) override;
    // docu in base class
    void translateLeft_(Qt::KeyboardModifiers m) override;
    // docu in base class
    void translateRight_(Qt::KeyboardModifiers m) override;
    // docu in base class
    void translateForward_() override;
    // docu in base class
    void translateBackward_() override;
 
    // docu in base class
    void paintGridLines_(QPainter& painter) override;
 
    PeakIndex findPeakAtPosition_(QPoint);
 
    void addUserLabelAnnotation_(const QPoint& screen_position);
    void addLabelAnnotation_(const QPoint& screen_position, const QString& label_text);
    void addUserPeakAnnotation_(PeakIndex near_peak);
 
    void ensureAnnotationsWithinDataRange_();
 
    friend class Painter1DChrom;
    friend class Painter1DPeak;
    friend class Painter1DIonMobility;
 
 
    RangeType overall_data_range_1d_;
 
    std::vector<DrawModes> draw_modes_;
    std::vector<Qt::PenStyle> peak_penstyle_;
 
    QPoint measurement_start_point_px_;
    bool mirror_mode_ = false;
    bool moving_annotations_ = false;
    bool show_alignment_ = false;
    Size alignment_layer_1_;
    Size alignment_layer_2_;
    std::vector<std::pair<double, double> > aligned_peaks_mz_delta_;
    std::vector<std::pair<Size, Size> > aligned_peaks_indices_;
    double alignment_score_ = 0.0;
    bool ion_ladder_visible_ = true;
    bool draw_interesting_MZs_ = false;
    QTextDocument text_box_content_;
    Gravitator gr_;
  };
 
 
 
 
} // namespace OpenMS