dox/Views/Infovis/vtkHeatmapItem.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkHeatmapItem.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef __vtkHeatmapItem_h
#define __vtkHeatmapItem_h

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

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

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

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

  virtual void SetTable(vtkTable *table);

  vtkTable * GetTable();

  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(std::string rowName);

  virtual bool Paint(vtkContext2D *painter);


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

  //BTX


  enum
    {
    LEFT_TO_RIGHT,
    UP_TO_DOWN,
    RIGHT_TO_LEFT,
    DOWN_TO_UP
    };

  virtual bool Hit(const vtkContextMouseEvent &mouse);

  virtual bool MouseMoveEvent(const vtkContextMouseEvent &event);

  virtual bool MouseDoubleClickEvent(const vtkContextMouseEvent &event);

  //ETX

protected:
  vtkHeatmapItem();
  ~vtkHeatmapItem();

  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;

private:
  vtkHeatmapItem(const vtkHeatmapItem&); // Not implemented
  void operator=(const vtkHeatmapItem&); // Not implemented

  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;
};

#endif