vtkboneApplyTestBase.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 __vtkboneApplyTestBase_h
#define __vtkboneApplyTestBase_h
 
#include "vtkboneFiniteElementModelGenerator.h"
#include "vtkboneWin32Header.h"
 
#include "vtkboneFiniteElementModel.h"   // Needed for enum definitions.
#include "vtkboneConstraint.h"   // Needed for enum definitions.
 
 
class VTKBONE_EXPORT vtkboneApplyTestBase : public vtkboneFiniteElementModelGenerator
{
public:
  static vtkboneApplyTestBase *New();
  vtkTypeMacro(vtkboneApplyTestBase, vtkboneFiniteElementModelGenerator);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  void PrintParameters(ostream& os, vtkIndent indent);
 
  enum TestAxis_t {
    TEST_AXIS_X = 0,
    TEST_AXIS_Y = 1,
    TEST_AXIS_Z = 2
  };
 
 
  vtkSetMacro(TopConstraintSpecificMaterial, int);
  vtkGetMacro(TopConstraintSpecificMaterial, int);
 
 
  vtkSetMacro(BottomConstraintSpecificMaterial, int);
  vtkGetMacro(BottomConstraintSpecificMaterial, int);
 
 
  vtkSetMacro(UnevenTopSurface, int);
  vtkGetMacro(UnevenTopSurface, int);
  vtkBooleanMacro(UnevenTopSurface, int);
 
 
  vtkSetMacro(UseTopSurfaceMaximumDepth, int);
  vtkGetMacro(UseTopSurfaceMaximumDepth, int);
  vtkBooleanMacro(UseTopSurfaceMaximumDepth, int);
 
 
  vtkSetMacro(TopSurfaceMaximumDepth, double);
  vtkGetMacro(TopSurfaceMaximumDepth, double);
  vtkBooleanMacro(TopSurfaceMaximumDepth, double);
 
 
  vtkSetMacro(UnevenBottomSurface, int);
  vtkGetMacro(UnevenBottomSurface, int);
  vtkBooleanMacro(UnevenBottomSurface, int);
 
 
  vtkSetMacro(UseBottomSurfaceMaximumDepth, int);
  vtkGetMacro(UseBottomSurfaceMaximumDepth, int);
  vtkBooleanMacro(UseBottomSurfaceMaximumDepth, int);
 
 
  vtkSetMacro(BottomSurfaceMaximumDepth, double);
  vtkGetMacro(BottomSurfaceMaximumDepth, double);
  vtkBooleanMacro(BottomSurfaceMaximumDepth, double);
 
 
  vtkSetMacro(TestAxis, int);
  vtkGetMacro(TestAxis, int);
 
  int DataFrameSense(int testFrameSense);
 
  int TestFrameSense(int dataFrameSense);
 
  int DataFramePolarity(int testFrameSense, int polarity);
 
  double TestFrameBound(double bounds[6], int testFrameSense, int polarity);
 
  int GetVoxelLocalId(int testFrameLocalId);
 
protected:
  vtkboneApplyTestBase();
  ~vtkboneApplyTestBase();
 
  virtual int RequestData(vtkInformation* request,
                          vtkInformationVector** inputVector,
                          vtkInformationVector* outputVector) override;
 
  int TopConstraintSpecificMaterial;
  int BottomConstraintSpecificMaterial;
  int UnevenTopSurface;
  int UseTopSurfaceMaximumDepth;
  double TopSurfaceMaximumDepth;
  int UnevenBottomSurface;
  int UseBottomSurfaceMaximumDepth;
  double BottomSurfaceMaximumDepth;
  int TestAxis;
 
  virtual int AddSets(vtkboneFiniteElementModel* model);
 
 
  virtual int AddDataFrameZFacesSets(vtkboneFiniteElementModel* model);
  virtual int AddDataFrameXFacesSets(vtkboneFiniteElementModel* model);
  virtual int AddDataFrameYFacesSets(vtkboneFiniteElementModel* model);
 
private:
  vtkboneApplyTestBase(const vtkboneApplyTestBase&); // Not implemented
  void operator=(const vtkboneApplyTestBase&); // Not implemented
};
 
#endif