GeometryHandler.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2008 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
 
#include "MantidGeometry/DllConfig.h"
#include "MantidGeometry/Rendering/RenderingMesh.h"
#include "MantidGeometry/Rendering/ShapeInfo.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/V3D.h"
 
#include <memory>
#include <vector>
 
namespace Mantid {
 
namespace Geometry {
class IObjComponent;
class CSGObject;
class MeshObject2D;
class MeshObject;
namespace detail {
class Renderer;
class GeometryTriangulator;
 
template <typename Adaptee> std::unique_ptr<Geometry::RenderingMesh> makeRenderingMesh(const Adaptee &adaptee) {
 
  // Local class adapter
  class Adapter : public Geometry::RenderingMesh {
  private:
    // Not owned but can be guraranteed not null
    const Adaptee &m_adaptee;
 
  public:
    Adapter(const Adaptee &adaptee) : m_adaptee(adaptee) {}
    size_t numberOfVertices() const override { return m_adaptee.numberOfVertices(); }
    size_t numberOfTriangles() const override { return m_adaptee.numberOfTriangles(); }
    std::vector<double> getVertices() const override { return m_adaptee.getVertices(); }
    std::vector<uint32_t> getTriangles() const override { return m_adaptee.getTriangles(); }
    virtual ~Adapter() = default;
  };
  return std::make_unique<Adapter>(adaptee);
}
} // namespace detail
 
class MANTID_GEOMETRY_DLL GeometryHandler {
private:
  static Kernel::Logger &PLog; 
 
protected:
  std::shared_ptr<detail::ShapeInfo> m_shapeInfo;
  std::unique_ptr<detail::GeometryTriangulator> m_triangulator;
  IObjComponent *m_objComp = nullptr; 
  CSGObject *m_csgObj = nullptr;      
public:
  GeometryHandler(IObjComponent *comp);                   
  GeometryHandler(const std::shared_ptr<CSGObject> &obj); 
  GeometryHandler(CSGObject *obj);                        
  GeometryHandler(const MeshObject &obj);
  GeometryHandler &operator=(const MeshObject &obj);
  GeometryHandler(const MeshObject2D &obj);
  GeometryHandler &operator=(const MeshObject2D &obj);
  GeometryHandler(const GeometryHandler &handler);
  GeometryHandler &operator=(GeometryHandler handler);
  std::shared_ptr<GeometryHandler> clone() const;
  ~GeometryHandler();
  void render() const;     
  void initialize() const; 
  bool canTriangulate() const { return !(m_triangulator == nullptr); }
  size_t numberOfTriangles() const;
  size_t numberOfPoints() const;
 
  bool hasShapeInfo() const { return !(m_shapeInfo == nullptr); }
  const detail::ShapeInfo &shapeInfo() const { return *m_shapeInfo; }
  const std::vector<double> &getTriangleVertices() const;
  const std::vector<uint32_t> &getTriangleFaces() const;
  void setGeometryCache(size_t nPts, size_t nFaces, std::vector<double> &&pts, std::vector<uint32_t> &&faces);
  void GetObjectGeom(detail::ShapeInfo::GeometryShape &type, std::vector<Kernel::V3D> &vector, double &innerRadius,
                     double &radius, double &height) const;
  void setShapeInfo(detail::ShapeInfo &&shapeInfo);
};
 
} // NAMESPACE Geometry
} // NAMESPACE Mantid