vtkStatisticsAlgorithm.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2011 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
 
#ifndef vtkStatisticsAlgorithm_h
#define vtkStatisticsAlgorithm_h
 
#include "vtkFiltersStatisticsModule.h" // For export macro
#include "vtkStringToken.h"             // For constructor map
#include "vtkTableAlgorithm.h"
#include "vtkVariant.h" // For vtkVariant
 
#include <token/Singletons.h> // For Schwarz counter.
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDataObjectCollection;
class vtkStatisticalModel;
class vtkStdString;
class vtkStringArray;
class vtkVariantArray;
class vtkDoubleArray;
class vtkStatisticsAlgorithmPrivate;
 
class VTKFILTERSSTATISTICS_EXPORT vtkStatisticsAlgorithm : public vtkTableAlgorithm
{
public:
  vtkTypeMacro(vtkStatisticsAlgorithm, vtkTableAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum InputPorts
  {
    INPUT_DATA = 0,       
    LEARN_PARAMETERS = 1, 
    INPUT_MODEL = 2       
  };

  enum OutputIndices
  {
    OUTPUT_DATA = 0,  
    OUTPUT_MODEL = 1, 
    OUTPUT_TEST = 2   
  };

  virtual void SetLearnOptionParameterConnection(vtkAlgorithmOutput* params)
  {
    this->SetInputConnection(vtkStatisticsAlgorithm::LEARN_PARAMETERS, params);
  }

  virtual void SetLearnOptionParameters(vtkDataObject* params)
  {
    this->SetInputData(vtkStatisticsAlgorithm::LEARN_PARAMETERS, params);
  }

  virtual void SetInputModelConnection(vtkAlgorithmOutput* model)
  {
    this->SetInputConnection(vtkStatisticsAlgorithm::INPUT_MODEL, model);
  }

  virtual void SetInputModel(vtkDataObject* model)
  {
    this->SetInputData(vtkStatisticsAlgorithm::INPUT_MODEL, model);
  }

  virtual vtkStatisticalModel* GetOutputModel();


  vtkSetMacro(LearnOption, bool);
  vtkGetMacro(LearnOption, bool);
  vtkBooleanMacro(LearnOption, bool);


  vtkSetMacro(DeriveOption, bool);
  vtkGetMacro(DeriveOption, bool);
  vtkBooleanMacro(DeriveOption, bool);


  vtkSetMacro(AssessOption, bool);
  vtkGetMacro(AssessOption, bool);
  vtkBooleanMacro(AssessOption, bool);


  vtkSetMacro(TestOption, bool);
  vtkGetMacro(TestOption, bool);
  vtkBooleanMacro(TestOption, bool);


  vtkSetMacro(NumberOfPrimaryTables, vtkIdType);
  vtkGetMacro(NumberOfPrimaryTables, vtkIdType);


  virtual void SetAssessNames(vtkStringArray*);
  vtkGetObjectMacro(AssessNames, vtkStringArray);


  class AssessFunctor
  {
  public:
    virtual void operator()(vtkDoubleArray*, vtkIdType) = 0;
    virtual ~AssessFunctor() = default;
  };


  virtual int GetMaximumNumberOfColumnsPerRequest() const { return 0; }

  virtual void SetColumnStatus(const char* namCol, int status);

  virtual void ResetAllColumnStates();

  virtual int RequestSelectedColumns();

  virtual void ResetRequests();

  virtual vtkIdType GetNumberOfRequests();

  virtual vtkIdType GetNumberOfColumnsForRequest(vtkIdType request);

  virtual const char* GetColumnForRequest(vtkIdType r, vtkIdType c);
 
  virtual int GetColumnForRequest(vtkIdType r, vtkIdType c, vtkStdString& columnName);

  void AddColumn(const char* namCol);

  void AddColumnPair(const char* namColX, const char* namColY);

  virtual bool SetParameter(const char* parameter, int index, vtkVariant value);

  virtual bool Aggregate(vtkDataObjectCollection* collection, vtkStatisticalModel* model) = 0;


  bool CopyRequests(vtkStatisticsAlgorithmPrivate* requests);


  vtkSetMacro(GhostsToSkip, unsigned char);
  vtkGetMacro(GhostsToSkip, unsigned char);


  vtkSetMacro(SkipInvalidValues, bool);
  vtkGetMacro(SkipInvalidValues, bool);
  vtkBooleanMacro(SkipInvalidValues, bool);


  virtual std::string GetAlgorithmParameters() const;


  static vtkSmartPointer<vtkStatisticsAlgorithm> NewFromAlgorithmParameters(
    const std::string& algorithmParameters);

  template <typename Algorithm>
  static void RegisterAlgorithm()
  {
    vtkNew<Algorithm> alg;
    vtkStringToken className(alg->GetClassName());
    vtkStatisticsAlgorithm::GetConstructorMap()[className] = []()
    { return vtkSmartPointer<Algorithm>::New(); };
  }
 
protected:
  vtkStatisticsAlgorithm();
  ~vtkStatisticsAlgorithm() override;
 
  using AlgorithmConstructor = std::function<vtkSmartPointer<vtkStatisticsAlgorithm>()>;
  using AlgorithmConstructorMap = std::unordered_map<vtkStringToken, AlgorithmConstructor>;

  virtual bool ConfigureFromAlgorithmParameters(const std::string& algorithmParameters);

  virtual void AppendAlgorithmParameters(std::string& algorithmParameters) const;

  virtual std::size_t ConsumeNextAlgorithmParameter(
    vtkStringToken parameterName, const std::string& algorithmParameters);
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  virtual void Learn(vtkTable*, vtkTable*, vtkStatisticalModel*) = 0;

  virtual void Derive(vtkStatisticalModel*) = 0;

  virtual void Assess(vtkTable*, vtkStatisticalModel*, vtkTable*) = 0;

  void Assess(vtkTable*, vtkStatisticalModel*, vtkTable*, int);

  virtual void Test(vtkTable*, vtkStatisticalModel*, vtkTable*) = 0;

  virtual void SelectAssessFunctor(
    vtkTable* outData, vtkDataObject* inMeta, vtkStringArray* rowNames, AssessFunctor*& dfunc) = 0;

  static std::size_t ConsumeString(const std::string& source, std::string& value);


  static std::size_t ConsumeStringTuple(const std::string& source, std::vector<std::string>& tuple);
  static std::size_t ConsumeStringTuple(const std::string& source, vtkStringArray* tuple);

  static std::size_t ConsumeDouble(const std::string& source, double& value);
  static std::size_t ConsumeDoubleTuple(const std::string& source, std::vector<double>& tuple);
  static std::size_t ConsumeDoubleTuples(
    const std::string& source, std::vector<std::vector<double>>& tuple);
  static std::size_t ConsumeStringToDoublesMap(
    const std::string& source, std::map<std::string, std::vector<double>>& map);

  static std::size_t ConsumeInt(const std::string& source, int& value);

  static AlgorithmConstructorMap& GetConstructorMap();
 
  vtkIdType NumberOfPrimaryTables;
  bool LearnOption;
  bool DeriveOption;
  bool AssessOption;
  bool TestOption;
  vtkStringArray* AssessNames;
  unsigned char GhostsToSkip;
  vtkIdType NumberOfGhosts;
  bool SkipInvalidValues;
  vtkStatisticsAlgorithmPrivate* Internals;
 
private:
  vtkStatisticsAlgorithm(const vtkStatisticsAlgorithm&) = delete;
  void operator=(const vtkStatisticsAlgorithm&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif