vtkHeatmapItem.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkHeatmapItem_h
#define vtkHeatmapItem_h

#include "vtkContextItem.h"
#include "vtkViewsInfovisModule.h" // For export macro

#include "vtkNew.h"           // For vtkNew ivars
#include "vtkSmartPointer.h"  // For vtkSmartPointer ivars
#include "vtkStdString.h"     // For get/set ivars
#include "vtkVector.h"        // For vtkVector2f ivar
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
#include <map>                // For column ranges
#include <set>                // For blank row support
#include <vector>             // For row mapping

VTK_ABI_NAMESPACE_BEGIN
class vtkBitArray;
class vtkCategoryLegend;
class vtkColorLegend;
class vtkLookupTable;
class vtkStringArray;
class vtkTable;
class vtkTooltipItem;
class vtkVariantArray;

class VTKVIEWSINFOVIS_EXPORT VTK_MARSHALAUTO vtkHeatmapItem : public vtkContextItem
{
public:
  static vtkHeatmapItem* New();
  vtkTypeMacro(vtkHeatmapItem, vtkContextItem);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void SetTable(vtkTable* table);

  vtkTable* GetTable();

  vtkStringArray* GetRowNames();


  vtkGetMacro(NameColumn, vtkStdString);
  vtkSetMacro(NameColumn, vtkStdString);

  void SetOrientation(int orientation);

  int GetOrientation();

  double GetTextAngleForOrientation(int orientation);


  vtkSetVector2Macro(Position, float);
  void SetPosition(const vtkVector2f& pos);


  vtkGetVector2Macro(Position, float);
  vtkVector2f GetPositionVector();


  vtkGetMacro(CellHeight, double);
  vtkSetMacro(CellHeight, double);


  vtkGetMacro(CellWidth, double);
  vtkSetMacro(CellWidth, double);

  virtual void GetBounds(double bounds[4]);

  void MarkRowAsBlank(const std::string& rowName);

  bool Paint(vtkContext2D* painter) override;


  vtkGetMacro(RowLabelWidth, float);
  vtkGetMacro(ColumnLabelWidth, float);

  enum
  {
    LEFT_TO_RIGHT,
    UP_TO_DOWN,
    RIGHT_TO_LEFT,
    DOWN_TO_UP
  };

  bool Hit(const vtkContextMouseEvent& mouse) override;

  bool MouseMoveEvent(const vtkContextMouseEvent& event) override;

  bool MouseDoubleClickEvent(const vtkContextMouseEvent& event) override;

  vtkGetObjectMacro(CategoryLegend, vtkCategoryLegend);
  vtkGetObjectMacro(ColorLegend, vtkColorLegend);

protected:
  vtkHeatmapItem();
  ~vtkHeatmapItem() override;

  vtkVector2f PositionVector;
  float* Position;

  virtual void RebuildBuffers();

  virtual void PaintBuffers(vtkContext2D* painter);

  virtual bool IsDirty();

  void InitializeLookupTables();

  void AccumulateProminentCategoricalDataValues(vtkIdType column);

  void GenerateContinuousDataLookupTable();

  void GenerateCategoricalDataLookupTable();

  std::string GetTooltipText(float x, float y);

  void UpdateVisibleSceneExtent(vtkContext2D* painter);

  bool LineIsVisible(double x0, double y0, double x1, double y1);

  void ComputeBounds();

  void ComputeLabelWidth(vtkContext2D* painter);

  // Setup the position, size, and orientation of this heatmap's color
  // legend based on the heatmap's current orientation.
  void PositionColorLegend(int orientation);

  // Setup the position, size, and orientation of this heatmap's
  // legends based on the heatmap's current orientation.
  void PositionLegends(int orientation);

  vtkSmartPointer<vtkTable> Table;
  vtkStringArray* RowNames;
  vtkStdString NameColumn;

private:
  vtkHeatmapItem(const vtkHeatmapItem&) = delete;
  void operator=(const vtkHeatmapItem&) = delete;

  unsigned long HeatmapBuildTime;
  vtkNew<vtkCategoryLegend> CategoryLegend;
  vtkNew<vtkColorLegend> ColorLegend;
  vtkNew<vtkTooltipItem> Tooltip;
  vtkNew<vtkLookupTable> ContinuousDataLookupTable;
  vtkNew<vtkLookupTable> CategoricalDataLookupTable;
  vtkNew<vtkLookupTable> ColorLegendLookupTable;
  vtkNew<vtkStringArray> CategoricalDataValues;
  vtkNew<vtkVariantArray> CategoryLegendValues;
  double CellWidth;
  double CellHeight;

  std::map<vtkIdType, std::pair<double, double>> ColumnRanges;
  std::vector<vtkIdType> SceneRowToTableRowMap;
  std::vector<vtkIdType> SceneColumnToTableColumnMap;
  std::set<std::string> BlankRows;

  double MinX;
  double MinY;
  double MaxX;
  double MaxY;
  double SceneBottomLeft[3];
  double SceneTopRight[3];
  float RowLabelWidth;
  float ColumnLabelWidth;

  vtkBitArray* CollapsedRowsArray;
  vtkBitArray* CollapsedColumnsArray;
  bool LegendPositionSet;
};

VTK_ABI_NAMESPACE_END
#endif