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);
  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);

  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