vtkboneTensorOfInertia.h

Go to the documentation of this file.

/*=========================================================================
 
  Copyright 2010-2016, Numerics88 Solutions Ltd.
  http://www.numerics88.com/
 
  Copyright (c) Eric Nodwell and Steven K. Boyd
  See Copyright.txt 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 __vtkboneTensorOfInertia_h
#define __vtkboneTensorOfInertia_h
 
#include "vtkAlgorithm.h"
#include "vtkImageData.h"
#include "vtkUnstructuredGrid.h"
#include "vtkboneWin32Header.h"
#include "vtkboneTensor.h"
 
// forward declarations
class vtkMatrix3x3;
 
class VTKBONE_EXPORT vtkboneTensorOfInertia : public vtkAlgorithm
{
public:
  static vtkboneTensorOfInertia *New();
 
  vtkTypeMacro(vtkboneTensorOfInertia,vtkAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual int ProcessRequest(vtkInformation*,
                             vtkInformationVector**,
                             vtkInformationVector*) override;
 
 
  void SetInputData(vtkDataObject *);
  void SetInputData(int, vtkDataObject*);
 
 
  vtkSetMacro(UseSpecificValue, int);
  vtkGetMacro(UseSpecificValue, int);
  vtkBooleanMacro(UseSpecificValue,int);
 
 
  void SetSpecificValue (int v) {this->SpecificValue=v; this->UseSpecificValue=1;}
  vtkGetMacro(SpecificValue, int);
 
 
  vtkSetMacro(UseThresholds, int);
  vtkGetMacro(UseThresholds, int);
  vtkBooleanMacro(UseThresholds,int);
 
 
  void SetLowerThreshold (double v) {this->LowerThreshold=v; this->UseThresholds=1;}
  vtkGetMacro(LowerThreshold, double);
 
 
  void SetUpperThreshold (double v) {this->UpperThreshold=v; this->UseThresholds=1;}
  vtkGetMacro(UpperThreshold, double);
 
 
  vtkGetMacro(Count, vtkIdType);
 
 
  vtkGetMacro(Volume, double);
 
 
  vtkGetMacro(Mass, double);
 
 
  vtkGetVector3Macro(CenterOfMass, double);
  double GetCenterOfMassX() {return this->CenterOfMass[0];}
  double GetCenterOfMassY() {return this->CenterOfMass[1];}
  double GetCenterOfMassZ() {return this->CenterOfMass[2];}
 
  void GetTensorOfInertia(vtkboneTensor* MOI);
 
  void GetTensorOfInertiaAboutOrigin(vtkboneTensor* MOI);
 
  void GetEigenvectors(vtkMatrix3x3* A);
 
 
  vtkGetVector3Macro(PrincipalAxisClosestToX, double);
  vtkGetVector3Macro(PrincipalAxisClosestToY, double);
  vtkGetVector3Macro(PrincipalAxisClosestToZ, double);
 
 
  vtkGetVector3Macro(PrincipalMoments, double);
  double GetPrincipalMoment0()
    {return this->PrincipalMoments[0];}
  double GetPrincipalMoment1()
    {return this->PrincipalMoments[1];}
  double GetPrincipalMoment2()
    {return this->PrincipalMoments[2];}
 
 
  static void TranslateTensorOfInertiaFromCOM(
      vtkboneTensor* T0,
      double mass,
      double r[3],
      vtkboneTensor* T);
 
 
  static void TranslateTensorOfInertiaToCOM(
      vtkboneTensor* T,
      double mass,
      double r[3],
      vtkboneTensor* T0);
 
 
  static void TranslateTensorOfInertia(
      vtkboneTensor* T1,
      double r1[3],
      double mass,
      double r2[3],
      vtkboneTensor* T2);
 
protected:
  vtkboneTensorOfInertia();
  ~vtkboneTensorOfInertia();
 
  virtual int RequestData(vtkInformation* request,
                          vtkInformationVector** inputVector,
                          vtkInformationVector* outputVector);
 
  virtual int ProcessImage(vtkImageData* image);
 
  virtual int ProcessUnstructuredGrid(vtkUnstructuredGrid* grid);
 
  virtual int FillInputPortInformation(int port, vtkInformation* info) override;
 
  // Settings
  int           UseSpecificValue;
  int           UseThresholds;
  int           SpecificValue;
  double        LowerThreshold;
  double        UpperThreshold;
 
  // Results
  vtkIdType       Count;
  double          Volume;
  double          Mass;
  double          CenterOfMass[3];
  vtkboneTensor*  TensorOfInertiaAboutOrigin;
  vtkboneTensor*  TensorOfInertia;
  vtkMatrix3x3*   Eigenvectors;
  double          PrincipalMoments[3];
  double          PrincipalAxisClosestToX[3];
  double        PrincipalAxisClosestToY[3];
  double        PrincipalAxisClosestToZ[3];
 
private:
  vtkboneTensorOfInertia(const vtkboneTensorOfInertia&);  // Not implemented.
  void operator=(const vtkboneTensorOfInertia&);  // Not implemented.
};
 
#endif