TransformTo3D.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Realspace/TransformTo3D.cpp
//! @brief     Implements namespace GUI::View::TransformTo3D
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/View/Realspace/TransformTo3D.h"
#include "GUI/Model/Sample/FormFactorItems.h"
#include "GUI/Model/Sample/LayerItem.h"
#include "GUI/Model/Sample/MultiLayerItem.h"
#include "GUI/Model/Sample/ParticleItem.h"
#include "GUI/View/Realspace/RealSpaceCanvas.h"
#include "Sample/HardParticle/HardParticles.h"
 
 
double GUI::View::TransformTo3D::visualLayerThickness(const LayerItem& layerItem,
                                                      const SceneGeometry& sceneGeometry)
{
    double thickness(0.0);
    if (layerItem.isTopLayer() || layerItem.isBottomLayer())
        thickness = sceneGeometry.topOrBottomLayerThickness;
    else
        thickness = layerItem.thickness();
 
    return thickness == 0.0 ? sceneGeometry.layerMinimumThickness : thickness;
}
 
std::unique_ptr<GUI::RealSpace::Layer>
GUI::View::TransformTo3D::createLayer(const LayerItem& layerItem,
                                      const SceneGeometry& sceneGeometry, const QVector3D& origin)
{
    double thickness = GUI::View::TransformTo3D::visualLayerThickness(layerItem, sceneGeometry);
 
    double s2 = sceneGeometry.layerSize;
    auto ztop = static_cast<double>(origin.z());
    double zbottom = static_cast<double>(origin.z()) - thickness;
 
    std::unique_ptr<GUI::RealSpace::Layer> result =
        std::make_unique<GUI::RealSpace::Layer>(GUI::RealSpace::VectorRange(
            GUI::RealSpace::Range(static_cast<float>(-s2), static_cast<float>(+s2)),
            GUI::RealSpace::Range(static_cast<float>(-s2), static_cast<float>(+s2)),
            GUI::RealSpace::Range(static_cast<float>(ztop), static_cast<float>(zbottom))));
 
    QColor color = layerItem.materialColor();
    color.setAlphaF(.3);
 
    result->color = color;
 
    return result;
}
 
std::unique_ptr<GUI::RealSpace::Particles::Particle>
GUI::View::TransformTo3D::createParticlefromFormfactor(const IFormFactor* ff)
{
    if (const auto* ff_Pyramid2 = dynamic_cast<const Pyramid2*>(ff)) {
        double length = ff_Pyramid2->length();
        double width = ff_Pyramid2->width();
        double height = ff_Pyramid2->height();
        double alpha = ff_Pyramid2->alpha();
        return std::make_unique<GUI::RealSpace::Particles::Pyramid2>(length, width, height, alpha);
    }
    if (const auto* ff_BarGauss = dynamic_cast<const BarGauss*>(ff)) {
        double length = ff_BarGauss->length();
        double width = ff_BarGauss->width();
        double height = ff_BarGauss->height();
        return std::make_unique<GUI::RealSpace::Particles::BarGauss>(length, width, height);
    }
    if (const auto* ff_BarLorentz = dynamic_cast<const BarLorentz*>(ff)) {
        double length = ff_BarLorentz->length();
        double width = ff_BarLorentz->width();
        double height = ff_BarLorentz->height();
        return std::make_unique<GUI::RealSpace::Particles::BarLorentz>(length, width, height);
    }
    if (const auto* ff_Box = dynamic_cast<const Box*>(ff)) {
        double length = ff_Box->length();
        double width = ff_Box->width();
        double height = ff_Box->height();
        return std::make_unique<GUI::RealSpace::Particles::Box>(length, width, height);
    }
    if (const auto* ff_Cone = dynamic_cast<const Cone*>(ff)) {
        double radius = ff_Cone->radius();
        double height = ff_Cone->height();
        double alpha = ff_Cone->alpha();
        return std::make_unique<GUI::RealSpace::Particles::Cone>(radius, height, alpha);
    }
    if (const auto* ff_Pyramid6 = dynamic_cast<const Pyramid6*>(ff)) {
        double baseedge = ff_Pyramid6->baseEdge();
        double height = ff_Pyramid6->height();
        double alpha = ff_Pyramid6->alpha();
        return std::make_unique<GUI::RealSpace::Particles::Pyramid6>(baseedge, height, alpha);
    }
    if (const auto* ff_Bipyramid4 = dynamic_cast<const Bipyramid4*>(ff)) {
        double length = ff_Bipyramid4->length();
        double height = ff_Bipyramid4->height();
        double height_ratio = ff_Bipyramid4->heightRatio();
        double alpha = ff_Bipyramid4->alpha();
        return std::make_unique<GUI::RealSpace::Particles::Bipyramid4>(length, height, height_ratio,
                                                                       alpha);
    }
    if (const auto* ff_Cylinder = dynamic_cast<const Cylinder*>(ff)) {
        double radius = ff_Cylinder->radius();
        double height = ff_Cylinder->height();
        return std::make_unique<GUI::RealSpace::Particles::Cylinder>(radius, height);
    }
    if (const auto* ff_Dodecahedron = dynamic_cast<const Dodecahedron*>(ff)) {
        double edge = ff_Dodecahedron->edge();
        return std::make_unique<GUI::RealSpace::Particles::Dodecahedron>(edge);
    }
    if (const auto* ff_EllipsoidalCylinder = dynamic_cast<const EllipsoidalCylinder*>(ff)) {
        double radius_x = ff_EllipsoidalCylinder->radiusX();
        double radius_y = ff_EllipsoidalCylinder->radiusY();
        double height = ff_EllipsoidalCylinder->height();
        return std::make_unique<GUI::RealSpace::Particles::EllipsoidalCylinder>(radius_x, radius_y,
                                                                                height);
    }
    if (const auto* ff_Sphere = dynamic_cast<const Sphere*>(ff)) {
        double radius = ff_Sphere->radius();
        return std::make_unique<GUI::RealSpace::Particles::Sphere>(radius);
    }
    if (const auto* ff_Spheroid = dynamic_cast<const Spheroid*>(ff)) {
        double radius = ff_Spheroid->radius();
        double height = ff_Spheroid->height();
        return std::make_unique<GUI::RealSpace::Particles::Spheroid>(radius, height);
    }
    if (const auto* ff_HemiEllipsoid = dynamic_cast<const HemiEllipsoid*>(ff)) {
        double radius_x = ff_HemiEllipsoid->radiusX();
        double radius_y = ff_HemiEllipsoid->radiusY();
        double height = ff_HemiEllipsoid->height();
        return std::make_unique<GUI::RealSpace::Particles::HemiEllipsoid>(radius_x, radius_y,
                                                                          height);
    }
    if (const auto* ff_Icosahedron = dynamic_cast<const Icosahedron*>(ff)) {
        double edge = ff_Icosahedron->edge();
        return std::make_unique<GUI::RealSpace::Particles::Icosahedron>(edge);
    }
    if (const auto* ff_Prism3 = dynamic_cast<const Prism3*>(ff)) {
        double baseedge = ff_Prism3->baseEdge();
        double height = ff_Prism3->height();
        return std::make_unique<GUI::RealSpace::Particles::Prism3>(baseedge, height);
    }
    if (const auto* ff_Prism6 = dynamic_cast<const Prism6*>(ff)) {
        double baseedge = ff_Prism6->baseEdge();
        double height = ff_Prism6->height();
        return std::make_unique<GUI::RealSpace::Particles::Prism6>(baseedge, height);
    }
    if (const auto* ff_Pyramid4 = dynamic_cast<const Pyramid4*>(ff)) {
        double baseedge = ff_Pyramid4->baseEdge();
        double height = ff_Pyramid4->height();
        double alpha = ff_Pyramid4->alpha();
        return std::make_unique<GUI::RealSpace::Particles::Pyramid4>(baseedge, height, alpha);
    }
    if (const auto* ff_CosineRippleBox = dynamic_cast<const CosineRippleBox*>(ff)) {
        double length = ff_CosineRippleBox->length();
        double width = ff_CosineRippleBox->width();
        double height = ff_CosineRippleBox->height();
        return std::make_unique<GUI::RealSpace::Particles::CosineRippleBox>(length, width, height);
    }
    if (const auto* ff_CosineRippleGauss = dynamic_cast<const CosineRippleGauss*>(ff)) {
        double length = ff_CosineRippleGauss->length();
        double width = ff_CosineRippleGauss->width();
        double height = ff_CosineRippleGauss->height();
        return std::make_unique<GUI::RealSpace::Particles::CosineRippleGauss>(length, width,
                                                                              height);
    }
    if (const auto* ff_CosineRippleLorentz = dynamic_cast<const CosineRippleLorentz*>(ff)) {
        double length = ff_CosineRippleLorentz->length();
        double width = ff_CosineRippleLorentz->width();
        double height = ff_CosineRippleLorentz->height();
        return std::make_unique<GUI::RealSpace::Particles::CosineRippleLorentz>(length, width,
                                                                                height);
    }
    if (const auto* ff_SawtoothRippleBox = dynamic_cast<const SawtoothRippleBox*>(ff)) {
        double length = ff_SawtoothRippleBox->length();
        double width = ff_SawtoothRippleBox->width();
        double height = ff_SawtoothRippleBox->height();
        return std::make_unique<GUI::RealSpace::Particles::SawtoothRippleBox>(length, width,
                                                                              height);
    }
    if (const auto* ff_SawtoothRippleGauss = dynamic_cast<const SawtoothRippleGauss*>(ff)) {
        double length = ff_SawtoothRippleGauss->length();
        double width = ff_SawtoothRippleGauss->width();
        double height = ff_SawtoothRippleGauss->height();
        return std::make_unique<GUI::RealSpace::Particles::SawtoothRippleGauss>(length, width,
                                                                                height);
    }
    if (const auto* ff_SawtoothRippleLorentz = dynamic_cast<const SawtoothRippleLorentz*>(ff)) {
        double length = ff_SawtoothRippleLorentz->length();
        double width = ff_SawtoothRippleLorentz->width();
        double height = ff_SawtoothRippleLorentz->height();
        return std::make_unique<GUI::RealSpace::Particles::SawtoothRippleLorentz>(length, width,
                                                                                  height);
    }
    if (const auto* ff_Pyramid3 = dynamic_cast<const Pyramid3*>(ff)) {
        double baseedge = ff_Pyramid3->baseEdge();
        double height = ff_Pyramid3->height();
        double alpha = ff_Pyramid3->alpha();
        return std::make_unique<GUI::RealSpace::Particles::Pyramid3>(baseedge, height, alpha);
    }
    if (const auto* ff_TruncatedCube = dynamic_cast<const TruncatedCube*>(ff)) {
        double length = ff_TruncatedCube->length();
        double removed_length = ff_TruncatedCube->removedLength();
        return std::make_unique<GUI::RealSpace::Particles::TruncatedCube>(length, removed_length);
    }
    if (const auto* ff_TruncatedSphere = dynamic_cast<const TruncatedSphere*>(ff)) {
        double radius = ff_TruncatedSphere->radius();
        double height = ff_TruncatedSphere->height();
        double deltaH = ff_TruncatedSphere->removedTop();
        return std::make_unique<GUI::RealSpace::Particles::TruncatedSphere>(radius, height, deltaH);
    }
    if (const auto* ff_TruncatedSpheroid = dynamic_cast<const TruncatedSpheroid*>(ff)) {
        double radius = ff_TruncatedSpheroid->radius();
        double height = ff_TruncatedSpheroid->height();
        double hfc = ff_TruncatedSpheroid->heightFlattening();
        double deltaH = ff_TruncatedSpheroid->removedTop();
        return std::make_unique<GUI::RealSpace::Particles::TruncatedSpheroid>(radius, height, hfc,
                                                                              deltaH);
    }
    if (const auto* ff_CantellatedCube = dynamic_cast<const CantellatedCube*>(ff)) {
        double length = ff_CantellatedCube->length();
        double removed_length = ff_CantellatedCube->removedLength();
        return std::make_unique<GUI::RealSpace::Particles::CantellatedCube>(length, removed_length);
    }
    if (const auto* ff_HorizontalCylinder = dynamic_cast<const HorizontalCylinder*>(ff)) {
        double radius = ff_HorizontalCylinder->radius();
        double length = ff_HorizontalCylinder->length();
        double slice_bottom = ff_HorizontalCylinder->slice_bottom();
        double slice_top = ff_HorizontalCylinder->slice_top();
        return std::make_unique<GUI::RealSpace::Particles::HorizontalCylinder>(
            radius, length, slice_bottom, slice_top);
    }
    if (const auto* ff_PlatonicOctahedron = dynamic_cast<const PlatonicOctahedron*>(ff)) {
        double edge = ff_PlatonicOctahedron->edge();
        return std::make_unique<GUI::RealSpace::Particles::PlatonicOctahedron>(edge);
    }
    if (const auto* ff_PlatonicTetrahedron = dynamic_cast<const PlatonicTetrahedron*>(ff)) {
        double edge = ff_PlatonicTetrahedron->edge();
        return std::make_unique<GUI::RealSpace::Particles::PlatonicTetrahedron>(edge);
    }
    return {};
}