PMManagerDC.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2014 UJF-Grenoble 1, CNRS, TIMC-IMAG UMR 5525 (GMCAO)
 *
 * 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 PMManagerDC_H
#define PMManagerDC_H

// camitk
#include <MeshComponent.h>
#include <InterfaceGeometry.h>
#include <Geometry.h>

#include "PMComponentAPI.h"

// pml classes
class PhysicalModel;
#include <pml/Component.h>
#include <pml/MultiComponent.h>
#include <pml/StructuralComponent.h>
class Atom;
class Cell;
#include <pml/RenderingMode.h>

// CamiTK component classes
class ComponentDC;
class MultiComponentDC;
class StructuralComponentDC;
class AtomDC;
class CellDC;

class LoadsManager;
class PMManagerDCPopup;
class AtomDCWidget;

namespace std {
typedef std::pair< ::Component *, ComponentDC *> ComponentDCPair;
typedef std::map < ::Component *, ComponentDC *> ComponentDCMap;
typedef std::map < ::Component *, ComponentDC *>::iterator ComponentDCMapIterator;

typedef std::pair<Atom *, AtomDC *> AtomDCPair;
typedef std::map <Atom *, AtomDC *> AtomDCMap;
typedef std::map <Atom *, AtomDC *>::iterator AtomDCMapIterator;
}
class PHYSICALMODEL_COMPONENT_API PMManagerDC : public camitk::MeshComponent {
    Q_OBJECT
public:
    PMManagerDC(const QString &) throw(camitk::AbortException);

    PMManagerDC(PhysicalModel *, const QString &);

    virtual ~PMManagerDC();

    bool getModified() const;

    virtual void setName(const QString &);

    virtual QMenu * getPopupMenu(QWidget* parent);

    void progressOneStep();

    virtual QPixmap getIcon();

    void createPointData();

    void destroyPointData();


    PhysicalModel *getPhysicalModel();

    virtual double getBoundingRadius();

    virtual void getBounds(double bounds[6]);

    void computeBoundingRadius();

    InterfaceGeometry::RenderingModes toDCRenderingMode(::RenderingMode::Mode);

    ::RenderingMode::Mode toPMRenderingMode(camitk::InterfaceGeometry::RenderingModes);

    ComponentDC * getDC(::Component *);

    MultiComponentDC * getDC(MultiComponent *);

    StructuralComponentDC * getDC(StructuralComponent *);

    CellDC * getDC(Cell *);

    AtomDC * getDC(Atom *);

    void addMultiComponentDCPair(std::ComponentDCPair);

    void addStructuralComponentDCPair(std::ComponentDCPair);

    void addCellDCPair(std::ComponentDCPair);

    void addAtomDCPair(std::AtomDCPair);

    virtual vtkSmartPointer< vtkPointSet > getPointSet();


    QWidget *getAtomDCWidget(AtomDC *adc = NULL, QWidget *parent = NULL);

    LoadsManager * getLoadsManager();


private:

    void buildPhysicalModelDCs();

    virtual void initRepresentation();

    unsigned int nrOfDoneSteps;

    unsigned int nrOfSteps;

    PMManagerDCPopup * myPopupMenu;

    static QPixmap * myPixmap;

    std::ComponentDCMap myMCDCMap;

    std::ComponentDCMap mySCDCMap;

    std::ComponentDCMap myCDCMap;

    std::AtomDCMap myADCMap;

    AtomDCWidget * myAtomDCWidget;

    PhysicalModel * myPM;

    LoadsManager * myLoadsManager;

    double initialBoundingRadius;
};


// -------------------- getPhysicalModel --------------------
inline PhysicalModel *PMManagerDC::getPhysicalModel() {
    return myPM;
}

// -------------------- getBoundingRadius --------------------
inline double PMManagerDC::getBoundingRadius() {
    return initialBoundingRadius;
}

// -------------------- getLoadsManager --------------------
inline LoadsManager * PMManagerDC::getLoadsManager() {
    return myLoadsManager;
}

// -------------------- C / DC Map --------------------
inline ComponentDC * PMManagerDC::getDC(::Component *mc) {
    if (mc->isInstanceOf("StructuralComponent"))
        return (ComponentDC *) getDC(dynamic_cast<StructuralComponent *>(mc));
    else if (mc->isInstanceOf("MultiComponent"))
        return (ComponentDC *) getDC(dynamic_cast<MultiComponent *>(mc));
    else
        return NULL;
}

// -------------------- MC / DC Map --------------------
inline void PMManagerDC::addMultiComponentDCPair(std::ComponentDCPair p) {
    myMCDCMap.insert(p);
}

// -------------------- SC / DC Map --------------------
inline void PMManagerDC::addStructuralComponentDCPair(std::ComponentDCPair p) {
    mySCDCMap.insert(p);
}

// -------------------- Atom / DC Map --------------------
inline void PMManagerDC::addAtomDCPair(std::AtomDCPair p) {
    myADCMap.insert(p);
}

inline AtomDC * PMManagerDC::getDC(Atom *a) {
    if (!a)
        return NULL;
    std::AtomDCMapIterator result = myADCMap.find(a);
    return (result == myADCMap.end()) ? NULL : (result->second);
}


#endif