StructuralComponent.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2021 Univ. Grenoble Alpes, CNRS, Grenoble INP, TIMC, 38000 Grenoble, France
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/
 
#ifndef STRUCTURALCOMPONENT_H
#define STRUCTURALCOMPONENT_H
 
#include "PhysicalModelIO.h"
 
// pml includes
#include "Component.h"
#include "Structure.h"
class Object3D;
#include "StructuralComponentProperties.h"
 
// other includes
#include <algorithm> // for the remove
#include <string>
 
//pmlschema forward declarations
namespace physicalModel {
class StructuralComponent;
}
class StructuralComponent : public Component {
public:
    StructuralComponent(PhysicalModel*);
 
    StructuralComponent(PhysicalModel* p, physicalModel::StructuralComponent xmlSC);
 
    StructuralComponent(PhysicalModel*, std::string);
 
    ~StructuralComponent() override;
 
    unsigned int getNumberOfStructures() const;
 
    void addStructure(Structure* s, bool check = true);
 
    bool addStructureIfNotIn(Structure* s);
 
    bool isStructureIn(Structure* s);
 
    virtual void removeStructure(Structure* s);
 
    virtual void deleteAllStructures();
 
    Structure* getStructure(const unsigned int) const;
 
    Structure* getStructureByName(const std::string);
 
    Structure* getStructureByIndex(const unsigned int);
 
    void xmlPrint(std::ostream&) const override;
 
    bool isInstanceOf(const char*) const override;
 
    unsigned int getNumberOfCells() const override;
 
    Cell* getCell(unsigned int) const override;
 
    StructuralComponent* getAtoms();
 
    StructuralComponentProperties* getProperties();
 
    void setColor(const StructuralComponentProperties::Color c);
    void setColor(const double r, const double b, const double g, const double a);
    void setColor(const double r, const double b, const double g);
    double* getColor() const;
    void getColor(double* r, double* g, double* b, double* a) const;
 
    StructuralComponentProperties::Color getStructuralComponentPropertiesColor() const;
 
    void setMode(const RenderingMode::Mode);
    RenderingMode::Mode getMode() const;
    bool isVisible(const RenderingMode::Mode mode) const override;
    void setVisible(const RenderingMode::Mode mode, const bool b) override;
 
    enum ComposedBy {
        NOTHING, 
        CELLS, 
        ATOMS 
    };
 
    virtual ComposedBy composedBy();
 
    bool isCompatible(Structure*);
 
    void plannedNumberOfStructures(const unsigned int);
 
    void setPhysicalModel(PhysicalModel*) override;
 
protected:
    std::vector <Structure*> structures;
 
    StructuralComponent* atomList;
 
};
 
// ------- INLINE -----------
inline void StructuralComponent::addStructure(Structure* s, bool check) {
    // add the structure in the list, only if it is compatible
    if (!check || isCompatible(s)) {
        structures.push_back(s);
        // tell the structure that it is a part of this sc
        s->addStructuralComponent(this);
    }
}
inline Structure* StructuralComponent::getStructure(const unsigned int i) const {
    if (i < structures.size()) {
        return structures[i];
    }
    else {
        return nullptr;
    }
}
inline Structure* StructuralComponent::getStructureByIndex(const unsigned int i) {
    auto it = structures.begin();
    while (it != structures.end() && (*it)->getIndex() != i) {
        it++;
    }
    if (it == structures.end()) {
        return nullptr;
    }
    else {
        return (*it);
    }
}
inline Structure* StructuralComponent::getStructureByName(const std::string n) {
    auto it = structures.begin();
    while (it != structures.end() && (*it)->getName() != n) {
        it++;
    }
    if (it == structures.end()) {
        return nullptr;
    }
    else {
        return (*it);
    }
}
inline unsigned int StructuralComponent::getNumberOfStructures() const {
    return (unsigned int) structures.size();
}
inline  void StructuralComponent::removeStructure(Structure* s) {
    if (s) {
        // remove it from the list
        auto it = std::find(structures.begin(), structures.end(), s);
        if (it != structures.end()) {
            structures.erase(it);
            // tell s that it is no more used by this structural component
            s->removeStructuralComponent(this);
        }
    }
}
inline bool StructuralComponent::isInstanceOf(const char* className) const {
    return (std::string(className) == std::string("StructuralComponent"));
}
 
inline void StructuralComponent::plannedNumberOfStructures(const unsigned int size) {
    structures.reserve(size);
}
 
inline StructuralComponentProperties* StructuralComponent::getProperties() {
    return ((StructuralComponentProperties*)properties);
}
 
#endif //STRUCTURALCOMPONENT_H