milxModel.h

/*=========================================================================
  The Software is copyright (c) Commonwealth Scientific and Industrial Research Organisation (CSIRO)
  ABN 41 687 119 230.
  All rights reserved.

  Licensed under the CSIRO BSD 3-Clause License
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License in the file LICENSE.md or at

  https://stash.csiro.au/projects/SMILI/repos/smili/browse/license.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
=========================================================================*/
#ifndef __MILXMODEL_H
#define __MILXMODEL_H

//VTK
#include <vtkSmartPointer.h>
#include <vtkCellArray.h>
#include <vtkPolyData.h>
#include <vtkImageData.h> //voxelise
#include <vtkPointData.h>
#include <vtkMatrix4x4.h>
#include <vtkPolyDataCollection.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkTransform.h>
#include <vtkTransformCollection.h>
#include <vtkFloatArray.h>
#include <vtkMutableUndirectedGraph.h>

#include <milxGlobal.h>

//enums
enum GlyphType {Circle = 0, Triangle, Cross, Square, Diamond};

namespace milx
{
class SMILI_EXPORT Model
{
public:
  Model();
  Model(vtkSmartPointer<vtkPolyData> model);
  virtual ~Model() {}

  void AddInput(vtkSmartPointer<vtkPolyData> model);
  inline void AddArray(vtkSmartPointer<vtkDataArray> array)
  { CurrentModel->GetPointData()->AddArray(array);  }
  void SetInput(vtkSmartPointer<vtkPolyData> model);
  inline void SetInputData(vtkSmartPointer<vtkPolyData> model)
  { SetInput(model); }
  void SetTransform(vtkSmartPointer<vtkAbstractTransform> newTransform);
  void SetGraph(vtkSmartPointer<vtkMutableUndirectedGraph> graph);
  void SetPoints(vtkSmartPointer<vtkPoints> modelPoints);
  void SetPolys(vtkSmartPointer<vtkCellArray> modelPolys);
  void SetVectors(vtkSmartPointer<vtkDataArray> modelVectors);
  void SetScalars(vtkSmartPointer<vtkDataArray> modelScalars);
  inline void SetActiveScalars(std::string nameOfArray)
  { CurrentModel->GetPointData()->SetActiveScalars(nameOfArray.c_str());  }

  inline vtkSmartPointer<vtkPolyData>& Result()
  { return CurrentModel;  }
  inline vtkSmartPointer<vtkPolyData>& PreviousResult()
  { return PreviousModel;  }
  inline vtkSmartPointer<vtkPolyData>& GetInput()
  { return InputModel;  }
  inline vtkSmartPointer<vtkPolyData>& GetOutput()
  { return Result();  }
#if VTK_MAJOR_VERSION <=5

  inline vtkAlgorithmOutput* GetProducerPort()
  { return Result()->GetProducerPort();  }
#endif

  inline vtkIdType GetNumberOfPoints()
  { return Result()->GetNumberOfPoints(); }
  inline vtkIdType GetNumberOfArrays()
  { return Result()->GetPointData()->GetNumberOfArrays(); }
  inline vtkSmartPointer<vtkTransform>& GetTransform()
  { return CurrentTransform;  }
  inline vtkSmartPointer<vtkPoints> GetPoints()
  { return Result()->GetPoints();  }
  inline vtkSmartPointer<vtkDataArray> GetScalars()
  { return Result()->GetPointData()->GetScalars();  }
  inline void GetScalarRange(double *range)
  { if(GetScalars()) Result()->GetScalarRange(range);  }
  inline vtkSmartPointer<vtkDataArray> GetVectors()
  { return Result()->GetPointData()->GetVectors();  }
  inline vtkSmartPointer<vtkDataArray> GetNormals()
  { return Result()->GetPointData()->GetNormals();  }
  inline vtkSmartPointer<vtkDataArray> GetTensors()
  { return Result()->GetPointData()->GetTensors();  }
  inline void Update()
  {
  #if VTK_MAJOR_VERSION > 5
    CurrentModel->Modified();
  #else
    CurrentModel->Update();
  #endif // VTK_MAJOR_VERSION
  }

  void Clean();
  void Triangulate();
  void MatchInformation(vtkSmartPointer<vtkPolyData> matchMesh, const bool rescale);
  void IterativeClosestPointsRegistration(vtkSmartPointer<vtkPolyData> fixedMesh, const bool similarity = false, const int maxPoints = 1024);
  void LandmarkBasedRegistration(vtkSmartPointer<vtkPolyData> fixedMesh, const bool similarity = false);
  void Decimate(const float reduceFactor);
  void QuadricDecimate(const float reduceFactor);
  void ClusterDecimate();
  void LaplacianSmoothing(const int iterations);
  void WindowedSincSmoothing(const int iterations, const float passBand = 0.1);
  void Curvature(const bool meanCurvature = true);
  void Gradient();
  void DistanceMap(vtkSmartPointer<vtkPoints> loopPoints);
  void GaussianWeightScalars(float stddev, float clampValue);
  void Rotate(const bool xAxis, const bool yAxis, const bool zAxis, const float angle, const coordinate centre);
  void Flip(const bool xAxis, const bool yAxis, const bool zAxis);
  void Clip(const coordinateType belowValue, const coordinateType aboveValue);
  void Threshold(const coordinateType belowVal, const coordinateType aboveVal, const coordinateType outsideVal);
  void Threshold(const coordinateType belowVal, const coordinateType aboveVal, const coordinateType insideVal, const coordinateType outsideVal);
  void Mask(vtkSmartPointer<vtkPolyData> maskMesh);
  void IsoSurface(vtkSmartPointer<vtkImageData> img, double minValue);
  vtkSmartPointer<vtkImageData> Voxelise(const unsigned char insideValue, double *spacing, double *bounds = NULL, const size_t padVoxels = 1);
  void DelaunayGraph3D();
  void Delaunay2DTriangulation();
  void DelaunayTriangulation();
  void Append(vtkSmartPointer<vtkPolyData> model);
  static void Scale(vtkSmartPointer<vtkPolyData> model, const coordinateType scale, const bool useCentroid = true);
  inline void Scale(const coordinateType scale, const bool useCentroid = true)
  { Scale(CurrentModel, scale, useCentroid); }

  void GenerateVertices();
  void GenerateVertexScalars();
  void GenerateVerticesAs2DGlyphs(const GlyphType glyphType);
  void GenerateTubes();
  void GeneratePointModel(const double newScale);
  inline void GenerateSpheres(const double newScale)
  { GeneratePointModel(newScale); }
  void GenerateSampledPoints(const double distance);
  void GenerateVectorField(const double newScale = 0.0, const bool useNormals = false);
  void GenerateTensorField(const double newScale = 0.0);
  void GenerateHedgehog(const double newScale = 0.0);
  void GenerateNormals(const int pointNormals = 0);
  void GenerateKMeansClustering(int numberOfClusters);
  void GenerateQuantisedPoints(float quantiseFactor);
  void GenerateCappedBoundaries();
  void GenerateRegions();
  void GenerateElevation(double x, double y, double z);
  void GenerateElevation();
  //~ void GenerateReebGraph();

  void ResetScalars();
  void FillScalars(const coordinateType value);
  static void ClearScalars(vtkSmartPointer<vtkPolyData> &mesh);
  static inline void ClearArrays(vtkSmartPointer<vtkPolyData> &mesh)
  {
  #if (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION < 8)
      mesh->GetPointData()->SetActiveScalars(NULL);
  #else
    for(int j = 0; j < mesh->GetPointData()->GetNumberOfArrays(); j ++)
      mesh->GetPointData()->RemoveArray(0);
  #endif
  }
  void RemoveScalars();
  void RemoveArrays();
        static void ScalarDifference(vtkSmartPointer<vtkPolyData> model1, vtkSmartPointer<vtkPolyData> model2, vtkSmartPointer<vtkPolyData> result);
        static void ThresholdScalars(vtkSmartPointer<vtkPolyData> model, const coordinateType aboveVal, const coordinateType belowVal, const coordinateType outsideVal);
        static void BinaryThresholdScalars(vtkSmartPointer<vtkPolyData> model, const coordinateType aboveVal, const coordinateType belowVal, const coordinateType insideVal = 1.0, const coordinateType outsideVal = 0.0);
        static void MaskScalars(vtkSmartPointer<vtkPolyData> model1, vtkSmartPointer<vtkPolyData> model2);

  static vtkSmartPointer<vtkMatrix4x4> ProcrustesAlign(vtkSmartPointer<vtkPolyData> source, vtkSmartPointer<vtkPolyData> target, bool rigid = false);

  //Batch (collection) operations
  void ConcatenateCollection(vtkSmartPointer<vtkPolyDataCollection> collection);
  void ScaleCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const coordinateType scale);
  void SmoothCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const size_t iterations);
  void LaplacianCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const size_t iterations);
  void FlipCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const bool xAxis, const bool yAxis, const bool zAxis);
  void DecimateCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const coordinateType factor);
  void SplitCollection(vtkSmartPointer<vtkPolyDataCollection> collection, vtkSmartPointer<vtkPolyDataCollection> components, std::vector< vtkSmartPointer<vtkPolyDataCollection> > &splitCollections);
  void ScalarDifferenceCollection(vtkSmartPointer<vtkPolyDataCollection> collection);
  void ScalarDifferenceCollection(vtkSmartPointer<vtkPolyDataCollection> collection1, vtkSmartPointer<vtkPolyDataCollection> collection2, vtkSmartPointer<vtkPolyDataCollection> &results);
  void ScalarThresholdCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const coordinateType aboveVal, const coordinateType belowVal);
  void ClipCollection(vtkSmartPointer<vtkPolyDataCollection> collection, const coordinateType aboveVal, const coordinateType belowVal);
  void ScalarStatisticsCollection(vtkSmartPointer<vtkPolyDataCollection> collection);
  void ScalarRemoveCollection(vtkSmartPointer<vtkPolyDataCollection> collection);
  void ScalarCopyCollection(vtkSmartPointer<vtkPolyDataCollection> collection);
  double MeanSquaredErrorCollection(vtkSmartPointer<vtkPolyDataCollection> collection);
  vtkSmartPointer<vtkPolyDataCollection> ProcrustesAlignCollection(vtkSmartPointer<vtkPolyDataCollection> collection, bool rigid = false);
  vtkSmartPointer<vtkPolyDataCollection> IterativeClosestPointsAlignCollection(vtkSmartPointer<vtkPolyDataCollection> collection, bool rigid = false, vtkSmartPointer<vtkTransformCollection> tCollection=0);

protected:
  vtkSmartPointer<vtkPolyData> InputModel; 
  vtkSmartPointer<vtkPolyData> CurrentModel; 
  vtkSmartPointer<vtkPolyData> PreviousModel; 
  vtkSmartPointer<vtkTransform> CurrentTransform; 

  bool InternalInPlaceOperation; 

  inline bool IsCurrentModel()
  {
    if(!CurrentModel)
    {
      PrintError("Input Model not set. Ignoring Operation.");
      return false;
    }

    return true;
  }
  inline void UpdateModelState(vtkSmartPointer<vtkPolyDataAlgorithm> filter)
  {
    CurrentModel = filter->GetOutput();
    PreviousModel = filter->GetPolyDataInput(0);
    if(!InputModel)
      InputModel = PreviousModel;
  }
  inline void UpdateModelStateFromModel(vtkSmartPointer<vtkPolyData> mesh)
  {
    PreviousModel = CurrentModel;
    CurrentModel = mesh;
    if(!InputModel)
      InputModel = PreviousModel;
  }

private:

};

} //end namespace milx

#endif //__MILXMODEL_H