RealSpaceBuilder Class Reference

Inheritance diagram for RealSpaceBuilder:

Collaboration diagram for RealSpaceBuilder:

Public Member Functions
	RealSpaceBuilder (QWidget *parent=nullptr)
	~RealSpaceBuilder ()
void	populate (RealSpaceModel *model, const SessionItem &item, const SceneGeometry &sceneGeometry, const RealSpace::Camera::Position &cameraPosition=RealSpace::Camera::Position(RealSpace::Vector3D(0, -200, 120), RealSpace::Vector3D(0, 0, 0), RealSpace::Vector3D::_z))
void	populateLayer (RealSpaceModel *model, const SessionItem &layerItem, const SceneGeometry &sceneGeometry, const QVector3D &origin={}, const bool isTopLayer=false)
void	populateLayout (RealSpaceModel *model, const SessionItem &layoutItem, const SceneGeometry &sceneGeometry, const QVector3D &origin={})
void	populateMultiLayer (RealSpaceModel *model, const SessionItem &item, const SceneGeometry &sceneGeometry, const QVector3D &origin={})
void	populateParticleFromParticle3DContainer (RealSpaceModel *model, const Particle3DContainer &particle3DContainer, const QVector3D &lattice_position={}) const
void	populateParticleFromParticleItem (RealSpaceModel *model, const SessionItem &particleItem) const

Detailed Description

Definition at line 28 of file RealSpaceBuilder.h.

Constructor & Destructor Documentation

RealSpaceBuilder()

RealSpaceBuilder::RealSpaceBuilder

(

QWidget *

parent = nullptr

)

Definition at line 44 of file RealSpaceBuilder.cpp.

: QWidget(parent) {}

~RealSpaceBuilder()

RealSpaceBuilder::~RealSpaceBuilder ( )

default

Member Function Documentation

populate()

void RealSpaceBuilder::populate	(	RealSpaceModel *	model,
		const SessionItem &	item,
		const SceneGeometry &	sceneGeometry,
		const RealSpace::Camera::Position &	cameraPosition = RealSpace::Camera::Position(RealSpace::Vector3D(0, -200, 120),                                                   RealSpace::Vector3D(0, 0, 0),                                                        RealSpace::Vector3D::_z)
	)

Definition at line 48 of file RealSpaceBuilder.cpp.

{
    // default value of cameraPosition is in RealSpaceBuilder.h
 
    model->defCamPos = cameraPosition;
 
    if (item.modelType() == "MultiLayer")
        populateMultiLayer(model, item, sceneGeometry);
 
    else if (item.modelType() == "Layer")
        populateLayer(model, item, sceneGeometry);
 
    else if (item.modelType() == "ParticleLayout")
        populateLayout(model, item, sceneGeometry);
 
    else if (item.modelType() == "Particle")
        populateParticleFromParticleItem(model, item);
 
    else if (item.modelType() == "ParticleComposition")
        populateParticleFromParticleItem(model, item);
 
    else if (item.modelType() == "ParticleCoreShell")
        populateParticleFromParticleItem(model, item);
 
    else if (item.modelType() == "ParticleDistribution")
        populateParticleFromParticleItem(model, item);
 
    else if (item.modelType() == "MesoCrystal")
        populateParticleFromParticleItem(model, item);
}

References RealSpace::Model::defCamPos, SessionItem::modelType(), populateLayer(), populateLayout(), populateMultiLayer(), and populateParticleFromParticleItem().

Referenced by RealSpaceCanvas::updateScene().

Here is the call graph for this function:

populateLayer()

void RealSpaceBuilder::populateLayer	(	RealSpaceModel *	model,
		const SessionItem &	layerItem,
		const SceneGeometry &	sceneGeometry,
		const QVector3D &	origin = {},
		const bool	isTopLayer = false
	)

Definition at line 99 of file RealSpaceBuilder.cpp.

{
    auto layer = TransformTo3D::createLayer(layerItem, sceneGeometry, origin);
    if (layer && !isTopLayer)
        model->addBlend(layer.release());
 
    for (auto layout : layerItem.getItems(LayerItem::T_LAYOUTS))
        populateLayout(model, *layout, sceneGeometry, origin);
}

References RealSpace::Model::addBlend(), TransformTo3D::createLayer(), SessionItem::getItems(), populateLayout(), and LayerItem::T_LAYOUTS.

Referenced by populate(), and populateMultiLayer().

Here is the call graph for this function:

populateLayout()

void RealSpaceBuilder::populateLayout	(	RealSpaceModel *	model,
		const SessionItem &	layoutItem,
		const SceneGeometry &	sceneGeometry,
		const QVector3D &	origin = {}
	)

Definition at line 111 of file RealSpaceBuilder.cpp.

{
    ASSERT(layoutItem.modelType() == "ParticleLayout");
 
    // If there is no particle to populate
    if (!layoutItem.getItem(ParticleLayoutItem::T_PARTICLES))
        return;
 
    double layer_size = sceneGeometry.layer_size();
    double total_density = layoutItem.getItemValue(ParticleLayoutItem::P_TOTAL_DENSITY).toDouble();
 
    auto particle3DContainer_vector =
        RealSpaceBuilderUtils::particle3DContainerVector(layoutItem, origin);
 
    auto interference = GetInterferenceFunction(layoutItem);
 
    RealSpacePositionBuilder pos_builder;
    interference->accept(&pos_builder);
    std::vector<std::vector<double>> lattice_positions =
        pos_builder.generatePositions(layer_size, total_density);
    RealSpaceBuilderUtils::populateParticlesAtLatticePositions(
        lattice_positions, particle3DContainer_vector, model, sceneGeometry, this);
}

References ASSERT, RealSpacePositionBuilder::generatePositions(), SessionItem::getItem(), SessionItem::getItemValue(), SceneGeometry::layer_size(), SessionItem::modelType(), ParticleLayoutItem::P_TOTAL_DENSITY, RealSpaceBuilderUtils::particle3DContainerVector(), RealSpaceBuilderUtils::populateParticlesAtLatticePositions(), and ParticleLayoutItem::T_PARTICLES.

Referenced by populate(), and populateLayer().

Here is the call graph for this function:

populateMultiLayer()

void RealSpaceBuilder::populateMultiLayer	(	RealSpaceModel *	model,
		const SessionItem &	item,
		const SceneGeometry &	sceneGeometry,
		const QVector3D &	origin = {}
	)

Definition at line 81 of file RealSpaceBuilder.cpp.

{
    double total_height(0.0);
    int index(0);
    for (auto layer : item.getItems(MultiLayerItem::T_LAYERS)) {
 
        bool isTopLayer = index == 0;
        populateLayer(model, *layer, sceneGeometry,
                      QVector3D(0, 0, static_cast<float>(-total_height)), isTopLayer);
 
        if (index != 0)
            total_height += TransformTo3D::visualLayerThickness(*layer, sceneGeometry);
 
        ++index;
    }
}

References SessionItem::getItems(), populateLayer(), MultiLayerItem::T_LAYERS, and TransformTo3D::visualLayerThickness().

Referenced by populate().

Here is the call graph for this function:

populateParticleFromParticle3DContainer()

void RealSpaceBuilder::populateParticleFromParticle3DContainer	(	RealSpaceModel *	model,
		const Particle3DContainer &	particle3DContainer,
		const QVector3D &	lattice_position = {}
	)		const

Definition at line 179 of file RealSpaceBuilder.cpp.

{
    if (particle3DContainer.containerSize()) {
        for (size_t i = 0; i < particle3DContainer.containerSize(); ++i) {
            auto particle3D = particle3DContainer.createParticle(i);
            particle3D->addTranslation(lattice_position);
            if (particle3D) {
                if (!particle3DContainer.particle3DBlend(i))
                    model->add(particle3D.release());
                else
                    model->addBlend(particle3D.release()); // use addBlend() for transparent object
            }
        }
    }
}

References RealSpace::Model::add(), RealSpace::Model::addBlend(), Particle3DContainer::containerSize(), Particle3DContainer::createParticle(), and Particle3DContainer::particle3DBlend().

Referenced by populateParticleFromParticleItem(), and RealSpaceBuilderUtils::populateParticlesAtLatticePositions().

Here is the call graph for this function:

populateParticleFromParticleItem()

void RealSpaceBuilder::populateParticleFromParticleItem	(	RealSpaceModel *	model,
		const SessionItem &	particleItem
	)		const

Definition at line 136 of file RealSpaceBuilder.cpp.

{
    Particle3DContainer particle3DContainer;
    if (particleItem.modelType() == "Particle") {
        auto pItem = dynamic_cast<const ParticleItem*>(&particleItem);
        auto particle = pItem->createParticle();
        particle3DContainer = RealSpaceBuilderUtils::singleParticle3DContainer(*particle);
    } else if (particleItem.modelType() == "ParticleCoreShell") {
        auto particleCoreShellItem = dynamic_cast<const ParticleCoreShellItem*>(&particleItem);
        // If there is no CORE or SHELL to populate inside ParticleCoreShellItem
        if (!particleCoreShellItem->getItem(ParticleCoreShellItem::T_CORE)
            || !particleCoreShellItem->getItem(ParticleCoreShellItem::T_SHELL))
            return;
        auto particleCoreShell = particleCoreShellItem->createParticleCoreShell();
        particle3DContainer =
            RealSpaceBuilderUtils::particleCoreShell3DContainer(*particleCoreShell);
    } else if (particleItem.modelType() == "ParticleComposition") {
        auto particleCompositionItem = dynamic_cast<const ParticleCompositionItem*>(&particleItem);
        // If there is no particle to populate inside ParticleCompositionItem
        if (!particleCompositionItem->getItem(ParticleCompositionItem::T_PARTICLES))
            return;
        auto particleComposition = particleCompositionItem->createParticleComposition();
        particle3DContainer =
            RealSpaceBuilderUtils::particleComposition3DContainer(*particleComposition);
    } else if (particleItem.modelType() == "ParticleDistribution") {
        auto particleDistributionItem =
            dynamic_cast<const ParticleDistributionItem*>(&particleItem);
        // If there is no particle to populate inside ParticleDistributionItem
        if (!particleDistributionItem->getItem(ParticleDistributionItem::T_PARTICLES))
            return;
        // show nothing when ParticleDistributionItem is selected
    } else if (particleItem.modelType() == "MesoCrystal") {
        auto mesoCrystalItem = dynamic_cast<const MesoCrystalItem*>(&particleItem);
        // If there is no particle to populate inside MesoCrystalItem
        if (!mesoCrystalItem->getItem(MesoCrystalItem::T_BASIS_PARTICLE))
            return;
        particle3DContainer = RealSpaceBuilderUtils::mesoCrystal3DContainer(*mesoCrystalItem);
    }
 
    populateParticleFromParticle3DContainer(model, particle3DContainer);
}

References ParticleItem::createParticle(), ParticleCompositionItem::createParticleComposition(), ParticleCoreShellItem::createParticleCoreShell(), RealSpaceBuilderUtils::mesoCrystal3DContainer(), SessionItem::modelType(), RealSpaceBuilderUtils::particleComposition3DContainer(), RealSpaceBuilderUtils::particleCoreShell3DContainer(), populateParticleFromParticle3DContainer(), RealSpaceBuilderUtils::singleParticle3DContainer(), MesoCrystalItem::T_BASIS_PARTICLE, ParticleCoreShellItem::T_CORE, ParticleCompositionItem::T_PARTICLES, ParticleDistributionItem::T_PARTICLES, and ParticleCoreShellItem::T_SHELL.

Referenced by populate().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• /home/www/ba/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilder.h
• /home/www/ba/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilder.cpp