MeshObject.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2017 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "BoundingBox.h"
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidGeometry/Rendering/ShapeInfo.h"
#include "MantidKernel/Material.h"
#include "MantidKernel/Matrix.h"
#include <map>
#include <memory>
 
namespace Mantid {
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
namespace Kernel {
class PseudoRandomNumberGenerator;
class V3D;
} // namespace Kernel
namespace Nexus {
class File;
} // namespace Nexus
 
namespace Geometry {
class CompGrp;
class GeometryHandler;
class Track;
class vtkGeometryCacheReader;
class vtkGeometryCacheWriter;
 
class MANTID_GEOMETRY_DLL MeshObject : public IObject {
public:
  MeshObject(std::vector<uint32_t> faces, std::vector<Kernel::V3D> vertices, const Kernel::Material &material);
  MeshObject(std::vector<uint32_t> &&faces, std::vector<Kernel::V3D> &&vertices, const Kernel::Material &&material);
 
  MeshObject(const MeshObject &) = delete;
  MeshObject &operator=(const MeshObject &) = delete;
  ~MeshObject() override = default;
  IObject *clone() const override { return cloneWithMaterial(m_material); }
  IObject *cloneWithMaterial(const Kernel::Material &material) const override {
    auto *copy = new MeshObject(m_triangles, m_vertices, material);
    copy->m_id = m_id;
    // the copied vertices are already turned, so the copy is baked just as far as this mesh is
    copy->m_appliedRotation = m_appliedRotation;
    return copy;
  }
 
  void setID(const std::string &id) override { m_id = id; }
  const std::string &id() const override { return m_id; }
 
  int getName() const override { return 0; }
 
  const Kernel::Material &material() const override;
  void setMaterial(const Kernel::Material &material) override;
 
  bool hasValidShape() const override;
 
  bool isValid(const Kernel::V3D &) const override; 
  bool isOnSide(const Kernel::V3D &) const override;
  int calcValidType(const Kernel::V3D &Pt, const Kernel::V3D &uVec) const;
 
  // INTERSECTION
  int interceptSurface(Geometry::Track &) const override;
  double distance(const Track &track) const override;
 
  // Solid angle - uses triangleSolidAngle unless many (>30000) triangles
  double solidAngle(const SolidAngleParams &params) const override;
  // Solid angle with a scaling of the object
  double solidAngle(const SolidAngleParams &params, const Kernel::V3D &scaleFactor) const override;
 
  double volume() const override;
 
  void getBoundingBox(double &xmax, double &ymax, double &zmax, double &xmin, double &ymin,
                      double &zmin) const override;
 
  const BoundingBox &getBoundingBox() const override;
 
  // find internal point to object
  int getPointInObject(Kernel::V3D &point) const override;
 
  std::optional<Kernel::V3D> generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
                                                   const size_t) const override;
  std::optional<Kernel::V3D> generatePointInObject(Kernel::PseudoRandomNumberGenerator &rng,
                                                   const BoundingBox &activeRegion, const size_t) const override;
 
  // Rendering member functions
  void draw() const override;
  // Initialize Drawing
  void initDraw() const override;
  // Get Geometry Handler
  std::shared_ptr<GeometryHandler> getGeometryHandler() const override;
  void setGeometryHandler(const std::shared_ptr<GeometryHandler> &h);
 
  detail::ShapeInfo::GeometryShape shape() const override;
  const detail::ShapeInfo &shapeInfo() const override;
 
  void GetObjectGeom(detail::ShapeInfo::GeometryShape &type, std::vector<Kernel::V3D> &vectors, double &innerRadius,
                     double &radius, double &height) const override;
 
  size_t numberOfVertices() const;
  std::vector<double> getVertices() const;
  const std::vector<Kernel::V3D> &getV3Ds() const;
  size_t numberOfTriangles() const;
  const std::vector<uint32_t> &getTriangles() const;
 
  void rotate(const Kernel::Matrix<double> &);
  void bakeGoniometerRotation(const Kernel::Matrix<double> &);
  void setAppliedGoniometerRotation(const Kernel::Matrix<double> &);
  const Kernel::Matrix<double> &getAppliedRotation() const override { return m_appliedRotation; }
  void translate(const Kernel::V3D &);
  void multiply(const Kernel::Matrix<double> &);
  void scale(const double scaleFactor);
  void updateGeometryHandler();
 
  void saveNexus(Nexus::File *file, const std::string &group) const;
  static std::shared_ptr<MeshObject> loadNexus(Nexus::File *file, const std::string &group,
                                               const Kernel::Material &material);
 
private:
  void initialize();
  void getIntersections(const Kernel::V3D &start, const Kernel::V3D &direction,
                        std::vector<Kernel::V3D> &intersectionPoints,
                        std::vector<Mantid::Geometry::TrackDirection> &entryExitFlags) const;
 
  bool getTriangle(const size_t index, Kernel::V3D &v1, Kernel::V3D &v2, Kernel::V3D &v3) const;
  bool searchForObject(Kernel::V3D &point) const;
 
  mutable BoundingBox m_boundingBox;
 
  const double M_TOLERANCE = 0.000001;
 
  std::shared_ptr<GeometryHandler> m_handler;
 
  // String from which object may be defined
  std::string m_string;
 
  std::string m_id;
 
  std::shared_ptr<vtkGeometryCacheReader> m_vtk_cache_reader;
  std::shared_ptr<vtkGeometryCacheWriter> m_vtk_cache_writer;
 
  std::vector<uint32_t> m_triangles;
  std::vector<Kernel::V3D> m_vertices;
  Kernel::Material m_material;
  Kernel::Matrix<double> m_appliedRotation{3, 3, true};
};
 
} // NAMESPACE Geometry
} // NAMESPACE Mantid