ObjComponent.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidGeometry/Instrument/ObjComponent.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/ComponentVisitor.h"
#include "MantidGeometry/Objects/BoundingBox.h"
#include "MantidGeometry/Objects/CSGObject.h"
#include "MantidGeometry/Objects/IObject.h"
#include "MantidGeometry/Objects/Track.h"
#include "MantidGeometry/Rendering/GeometryHandler.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Material.h"
#include <cfloat>
#include <utility>
 
namespace Mantid::Geometry {
using Kernel::Quat;
using Kernel::V3D;
 
ObjComponent::ObjComponent(const IComponent *base, const ParameterMap *map) : Component(base, map), m_shape() {}
 
ObjComponent::ObjComponent(const std::string &name, IComponent *parent)
    : IObjComponent(), Component(name, parent), m_shape() {}
 
ObjComponent::ObjComponent(const std::string &name, std::shared_ptr<const IObject> shape, IComponent *parent)
    : IObjComponent(), Component(name, parent), m_shape(std::move(shape)) {}
 
const IObject_const_sptr ObjComponent::shape() const {
  if (m_map) {
    auto base = dynamic_cast<const ObjComponent *>(m_base);
    if (!base) {
      throw std::logic_error("Failed to cast base component to ObjComponent");
    }
    return base->m_shape;
  } else
    return m_shape;
}
 
void ObjComponent::setShape(std::shared_ptr<const IObject> newShape) {
  if (m_map)
    throw std::runtime_error("ObjComponent::setShape - Cannot change the shape "
                             "of a parameterized object");
  else
    m_shape = std::move(newShape);
}
 
const Kernel::Material ObjComponent::material() const { return m_shape->material(); }
 
bool ObjComponent::isValid(const V3D &point) const {
  // If the form of this component is not defined, just treat as a point
  if (!shape())
    return (this->getPos() == point);
 
  // Otherwise pass through the shifted point to the IObject::isValid method
  V3D scaleFactor = this->getScaleFactor();
  return shape()->isValid(factorOutComponentPosition(point) / scaleFactor) != 0;
}
 
bool ObjComponent::isOnSide(const V3D &point) const {
  // If the form of this component is not defined, just treat as a point
  if (!shape())
    return (this->getPos() == point);
  // Otherwise pass through the shifted point to the IObject::isOnSide method
  V3D scaleFactor = this->getScaleFactor();
  return shape()->isOnSide(factorOutComponentPosition(point) / scaleFactor) != 0;
}
 
int ObjComponent::interceptSurface(Track &track) const {
  // If the form of this component is not defined, throw NullPointerException
  if (!shape())
    throw Kernel::Exception::NullPointerException("ObjComponent::interceptSurface", "shape");
 
  // TODO: If scaling parameters are ever enabled, would they need need to be
  // used here?
  const V3D trkStart = factorOutComponentPosition(track.startPoint());
  const V3D trkDirection = takeOutRotation(track.direction());
 
  Track probeTrack(trkStart, trkDirection);
  const int intercepts = shape()->interceptSurface(probeTrack);
 
  Track::LType::const_iterator it;
  for (it = probeTrack.cbegin(); it != probeTrack.cend(); ++it) {
    V3D in = it->entryPoint;
    this->getRotation().rotate(in);
    // use the scale factor
    in *= getScaleFactor();
    in += this->getPos();
    V3D out = it->exitPoint;
    this->getRotation().rotate(out);
    // use the scale factor
    out *= getScaleFactor();
    out += this->getPos();
    track.addLink(in, out, out.distance(track.startPoint()), *(this->shape()), this->getComponentID());
  }
 
  return intercepts;
}
 
double ObjComponent::solidAngle(const Geometry::SolidAngleParams &params) const {
  if (m_map) {
    if (hasComponentInfo()) {
      return m_map->componentInfo().solidAngle(index(), params);
    }
  }
  // If the form of this component is not defined, throw NullPointerException
  if (!shape())
    throw Kernel::Exception::NullPointerException("ObjComponent::solidAngle", "shape");
  // Otherwise pass through the shifted point to the Object::solidAngle method
  V3D scaleFactor = this->getScaleFactor();
  // This is the observer position in the shape's coordinate system.
  const auto paramsWithFactoredOutComponentPosition =
      params.copyWithNewObserver(factorOutComponentPosition(params.observer()));
  if ((scaleFactor - V3D(1.0, 1.0, 1.0)).norm() < 1e-12)
    return shape()->solidAngle(paramsWithFactoredOutComponentPosition);
  else {
    // This function will scale the object shape when calculating the solid
    // angle.
    return shape()->solidAngle(paramsWithFactoredOutComponentPosition, scaleFactor);
  }
}
 
void ObjComponent::getBoundingBox(BoundingBox &absoluteBB) const {
  if (m_map) {
    if (hasComponentInfo()) {
      absoluteBB = m_map->componentInfo().boundingBox(index(), &absoluteBB);
      return;
    }
  }
  // Start with the box in the shape's coordinates
  const IObject_const_sptr s = shape();
  if (!s) {
    absoluteBB.nullify();
    return;
  }
  const BoundingBox &shapeBox = s->getBoundingBox();
  if (shapeBox.isNull()) {
    absoluteBB.nullify();
    return;
  }
  std::vector<V3D> Coord_system;
  if (!absoluteBB.isAxisAligned()) { // copy coordinate system (it is better
                                     // then copying the whole BB later)
    Coord_system.assign(absoluteBB.getCoordSystem().begin(), absoluteBB.getCoordSystem().end());
  }
  absoluteBB = BoundingBox(shapeBox);
  // modify in place for speed
  V3D scaleFactor = getScaleFactor();
  // Scale
  absoluteBB.xMin() *= scaleFactor.X();
  absoluteBB.xMax() *= scaleFactor.X();
  absoluteBB.yMin() *= scaleFactor.Y();
  absoluteBB.yMax() *= scaleFactor.Y();
  absoluteBB.zMin() *= scaleFactor.Z();
  absoluteBB.zMax() *= scaleFactor.Z();
  // Rotate
  (this->getRotation())
      .rotateBB(absoluteBB.xMin(), absoluteBB.yMin(), absoluteBB.zMin(), absoluteBB.xMax(), absoluteBB.yMax(),
                absoluteBB.zMax());
 
  // Shift
  const V3D localPos = this->getPos();
  absoluteBB.xMin() += localPos.X();
  absoluteBB.xMax() += localPos.X();
  absoluteBB.yMin() += localPos.Y();
  absoluteBB.yMax() += localPos.Y();
  absoluteBB.zMin() += localPos.Z();
  absoluteBB.zMax() += localPos.Z();
 
  if (!Coord_system.empty()) {
    absoluteBB.realign(&Coord_system);
  }
}
 
double ObjComponent::getHeight() const {
  const BoundingBox &bbox = shape()->getBoundingBox();
  return (bbox.yMax() - bbox.yMin()) / getScaleFactor().Y();
}
 
double ObjComponent::getWidth() const {
  const BoundingBox &bbox = shape()->getBoundingBox();
  return (bbox.xMax() - bbox.xMin()) / getScaleFactor().X();
}
 
double ObjComponent::getDepth() const {
  const BoundingBox &bbox = shape()->getBoundingBox();
  return (bbox.zMax() - bbox.zMin()) / getScaleFactor().Z();
}
 
int ObjComponent::getPointInObject(V3D &point) const {
  // If the form of this component is not defined, throw NullPointerException
  if (!shape())
    throw Kernel::Exception::NullPointerException("ObjComponent::getPointInObject", "shape");
  // Call the Object::getPointInObject method, which may give a point in Object
  // coordinates
  int result = shape()->getPointInObject(point);
  // transform point back to component space
  if (result) {
    // Scale up
    V3D scaleFactor = this->getScaleFactor();
    point *= scaleFactor;
    Quat Rotate = this->getRotation();
    Rotate.rotate(point);
    point += this->getPos();
  }
  return result;
}
 
const V3D ObjComponent::factorOutComponentPosition(const V3D &point) const {
  // First subtract the component's position, then undo the rotation
  return takeOutRotation(point - this->getPos());
}
 
const V3D ObjComponent::takeOutRotation(V3D point) const {
  // Get the total rotation of this component and calculate the inverse (reverse
  // rotation)
  Quat unRotate = this->getRotation();
  unRotate.inverse();
  // Now rotate our point by the angle calculated above
  unRotate.rotate(point);
 
  // Can not Consider scaling factor here as this transform used by solidAngle
  // as well
  // as IsValid etc. While this would work for latter, breaks former
 
  return point;
}
 
void ObjComponent::draw() const {
  if (Handle() == nullptr)
    return;
  // Render the ObjComponent and then render the object
  Handle()->render();
}
 
void ObjComponent::drawObject() const {
  if (shape() != nullptr)
    shape()->draw();
}
 
void ObjComponent::initDraw() const {
  if (Handle() == nullptr)
    return;
  // Render the ObjComponent and then render the object
  if (shape() != nullptr)
    shape()->initDraw();
  Handle()->initialize();
}
 
size_t ObjComponent::registerContents(class ComponentVisitor &componentVisitor) const {
  if (this->shape() != nullptr && this->shape()->isFiniteGeometry())
    return componentVisitor.registerGenericObjComponent(*this);
  else
    return componentVisitor.registerInfiniteObjComponent(*this);
}
 
} // namespace Mantid::Geometry