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"

// forward declarations
class vtkTensor;
class vtkMatrix3x3;

class VTKBONE_EXPORT vtkboneTensorOfInertia : public vtkAlgorithm
{
public:
  static vtkboneTensorOfInertia *New();

  vtkTypeMacro(vtkboneTensorOfInertia,vtkAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);


  virtual int ProcessRequest(vtkInformation*,
                             vtkInformationVector**,
                             vtkInformationVector*);
 

  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(vtkTensor* MOI);

  void GetTensorOfInertiaAboutOrigin(vtkTensor* 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(
      vtkTensor* T0,
      double mass,
      double r[3],
      vtkTensor* T);


  static void TranslateTensorOfInertiaToCOM(
      vtkTensor* T,
      double mass,
      double r[3],
      vtkTensor* T0);


  static void TranslateTensorOfInertia(
      vtkTensor* T1,
      double r1[3],
      double mass,
      double r2[3],
      vtkTensor* 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);

  // Settings
  int           UseSpecificValue;
  int           UseThresholds;
  int           SpecificValue;
  double        LowerThreshold;
  double        UpperThreshold;
  
  // Results
  vtkIdType     Count;
  double        Volume;
  double        Mass;
  double        CenterOfMass[3];
  vtkTensor*    TensorOfInertiaAboutOrigin;
  vtkTensor*    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