vtkWordCloud.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkWordCloud.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 vtkWordCloud_h
#define vtkWordCloud_h
 
#include "vtkImageAlgorithm.h"
#include "vtkImageData.h"         // For ImageData
#include "vtkInfovisCoreModule.h" // For export macro
#include "vtkSmartPointer.h"      // For SmartPointer
 
#include <array>      // For stl array
#include <functional> // for function
#include <set>        // for stl multiset
#include <string>     // For stl string
#include <vector>     // For stl vector
 
class VTKINFOVISCORE_EXPORT vtkWordCloud : public vtkImageAlgorithm
{
public:
  vtkTypeMacro(vtkWordCloud, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkWordCloud* New();
 
  // Typedefs
  using ColorDistributionContainer = std::array<double, 2>;
  using OffsetDistributionContainer = std::array<int, 2>;
  using OrientationDistributionContainer = std::array<double, 2>;
  using OrientationsContainer = std::vector<double>;
  using PairType = std::tuple<std::string, std::string>;
  using ReplacementPairsContainer = std::vector<PairType>;
  using SizesContainer = std::array<int, 2>;
  using StopWordsContainer = std::set<std::string>;
  using StringContainer = std::vector<std::string>;
 
 
  virtual SizesContainer GetAdjustedSizes() { return AdjustedSizes; }
 
#define SetStdContainerMacro(name, container)                                                      \
  virtual void Set##name(container arg)                                                            \
  {                                                                                                \
    bool changed = false;                                                                          \
    if (arg.size() != name.size())                                                                 \
    {                                                                                              \
      changed = true;                                                                              \
    }                                                                                              \
    else                                                                                           \
    {                                                                                              \
      auto a = arg.begin();                                                                        \
      for (auto r : name)                                                                          \
      {                                                                                            \
        if (*a != r)                                                                               \
        {                                                                                          \
          changed = true;                                                                          \
        }                                                                                          \
        a++;                                                                                       \
      }                                                                                            \
    }                                                                                              \
    if (changed)                                                                                   \
    {                                                                                              \
      name = arg;                                                                                  \
      this->Modified();                                                                            \
    }                                                                                              \
  }
 
 
  virtual void SetBackgroundColorName(std::string arg)
  {
    if (arg != BackgroundColorName)
    {
      this->Modified();
      BackgroundColorName = arg;
    }
  }
  virtual std::string GetBackgroundColorName() { return BackgroundColorName; }
 
 
  virtual void SetBWMask(bool arg)
  {
    if (BWMask != arg)
    {
      this->Modified();
      BWMask = arg;
    }
  }
  virtual bool GetBWMask() { return BWMask; }
 
 
  virtual void SetColorSchemeName(std::string arg)
  {
    if (ColorSchemeName != arg)
    {
      this->Modified();
      ColorSchemeName = arg;
    }
  }
  virtual std::string GetColorSchemeName() { return ColorSchemeName; }
 
 
  vtkSetMacro(DPI, int);
  vtkGetMacro(DPI, int);
 
 
  virtual void SetFileName(VTK_FILEPATH std::string arg)
  {
    if (FileName != arg)
    {
      this->Modified();
      FileName = arg;
    }
  }
  virtual std::string GetFileName() { return FileName; }
 
 
  virtual void SetFontFileName(VTK_FILEPATH std::string arg)
  {
    if (FontFileName != arg)
    {
      this->Modified();
      FontFileName = arg;
    }
  }
  virtual std::string GetFontFileName() { return FontFileName; }
 
 
  vtkSetMacro(Gap, int);
  vtkGetMacro(Gap, int);
 
 
  virtual void SetMaskColorName(std::string arg)
  {
    if (MaskColorName != arg)
    {
      this->Modified();
      MaskColorName = arg;
    }
  }
  virtual std::string GetMaskColorName() { return MaskColorName; }
 
 
  virtual void SetMaskFileName(VTK_FILEPATH std::string arg)
  {
    if (MaskFileName != arg)
    {
      this->Modified();
      MaskFileName = arg;
    }
  }
  virtual std::string GetMaskFileName() { return MaskFileName; }
 
 
  vtkSetMacro(MaxFontSize, int);
  vtkGetMacro(MaxFontSize, int);
 
 
  vtkSetMacro(MinFontSize, int);
  vtkGetMacro(MinFontSize, int);
 
 
  vtkSetMacro(MinFrequency, int);
  vtkGetMacro(MinFrequency, int);
 
 
  vtkSetMacro(FontMultiplier, int);
  vtkGetMacro(FontMultiplier, int);
 
 
  SetStdContainerMacro(ColorDistribution, ColorDistributionContainer);
  virtual ColorDistributionContainer GetColorDistribution() { return ColorDistribution; }
 
 
  SetStdContainerMacro(OffsetDistribution, OffsetDistributionContainer);
  virtual OffsetDistributionContainer GetOffsetDistribution() { return OffsetDistribution; }
 
 
  SetStdContainerMacro(OrientationDistribution, OrientationDistributionContainer);
  virtual OrientationDistributionContainer GetOrientationDistribution()
  {
    return OrientationDistribution;
  }
 
 
  SetStdContainerMacro(Orientations, OrientationsContainer);
  void AddOrientation(double arg)
  {
    Orientations.push_back(arg);
    this->Modified();
  }
  virtual OrientationsContainer GetOrientations() { return Orientations; }
 
 
  SetStdContainerMacro(ReplacementPairs, ReplacementPairsContainer);
  void AddReplacementPair(PairType arg)
  {
    ReplacementPairs.push_back(arg);
    this->Modified();
  }
 
  virtual ReplacementPairsContainer GetReplacementPairs() { return ReplacementPairs; }
 
 
  SetStdContainerMacro(Sizes, SizesContainer);
  virtual SizesContainer GetSizes() { return Sizes; }
 
 
  SetStdContainerMacro(StopWords, StopWordsContainer);
  void AddStopWord(std::string word)
  {
    StopWords.insert(word);
    this->Modified();
  }
  void ClearStopWords()
  {
    StopWords.clear();
    this->Modified();
  }
  virtual StopWordsContainer GetStopWords() { return StopWords; }
 
 
  virtual void SetStopListFileName(VTK_FILEPATH std::string arg)
  {
    if (StopListFileName != arg)
    {
      this->Modified();
      StopListFileName = arg;
    }
  }
  virtual std::string GetStopListFileName() { return StopListFileName; }
 
 
  virtual void SetTitle(std::string arg)
  {
    if (Title != arg)
    {
      this->Modified();
      Title = arg;
    }
  }
  virtual std::string GetTitle() { return Title; }
 
 
  virtual void SetWordColorName(std::string arg)
  {
    if (WordColorName != arg)
    {
      this->Modified();
      WordColorName = arg;
    }
  }
  virtual std::string GetWordColorName() { return WordColorName; }
 
  virtual std::vector<std::string>& GetKeptWords() { return KeptWords; }
 
 
  virtual std::vector<std::string>& GetSkippedWords() { return SkippedWords; }
 
 
  virtual std::vector<std::string>& GetStoppedWords() { return StoppedWords; }
 
protected:
  vtkWordCloud();
  ~vtkWordCloud() override = default;
 
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  vtkSmartPointer<vtkImageData> ImageData;
  int WholeExtent[6];
 
  SizesContainer AdjustedSizes;
  std::string BackgroundColorName;
  bool BWMask;
  ColorDistributionContainer ColorDistribution;
  std::string ColorSchemeName;
  int DPI;
  std::string FileName;
  std::string FontFileName;
  int FontMultiplier;
  int Gap;
  std::string MaskColorName;
  std::string MaskFileName;
  int MaxFontSize;
  int MinFontSize;
  int MinFrequency;
  OffsetDistributionContainer OffsetDistribution;
  OrientationDistributionContainer OrientationDistribution;
  OrientationsContainer Orientations;
  ReplacementPairsContainer ReplacementPairs;
  SizesContainer Sizes;
  StopWordsContainer StopWords;
  std::string StopListFileName;
  std::string Title;
  std::string WordColorName;
 
  std::vector<std::string> KeptWords;
  std::vector<std::string> SkippedWords;
  std::vector<std::string> StoppedWords;
 
private:
  vtkWordCloud(const vtkWordCloud&) = delete;
  void operator=(const vtkWordCloud&) = delete;
 
  // Declaring the type of Predicate that accepts 2 pairs and returns a bool
  typedef std::function<bool(std::pair<std::string, int>, std::pair<std::string, int>)> Comparator;
 
  std::multiset<std::pair<std::string, int>, Comparator> FindWordsSortedByFrequency(
    std::string&, vtkWordCloud*);
  struct ExtentOffset
  {
    ExtentOffset(int _x = 0.0, int _y = 0.0)
      : x(_x)
      , y(_y)
    {
    }
    int x, y;
  };
};
#endif
 
//  LocalWords:  vtkNamedColors SetMaskColorName