Molecule.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef Molecule_INCLUDE_ONCE
#define Molecule_INCLUDE_ONCE

#include <vlMolecule/link_config.hpp>
#include <vlMolecule/Atom.hpp>
#include <vlMolecule/Bond.hpp>
#include <vlGraphics/Geometry.hpp>
#include <vlGraphics/Actor.hpp>
#include <vlGraphics/ActorTree.hpp>
#include <vlGraphics/Text.hpp>
#include <vlCore/String.hpp>
#include <vlCore/KeyValues.hpp>

namespace vl
{
  typedef enum
  {
    MS_AtomsOnly,
    MS_BallAndStick,
    MS_Sticks,
    MS_Wireframe,
  } EMoleculeStyle;

  class VLMOLECULE_EXPORT Molecule: public Object
  {
    VL_INSTRUMENT_CLASS(vl::Molecule, Object)

  public:
    Molecule();
    ~Molecule() { reset(); }
    Molecule(const Molecule& other): Object(other) { operator=(other); }
    Molecule& operator=(const Molecule& other);

    void reset();

    void setMoleculeName(const String& name) { mMoleculeName = name; }
    const String moleculeName() const { return mMoleculeName; }

    unsigned int id() const { return mId; }
    void setId(unsigned int id) { mId = id; }

    KeyValues* tags() { return mTags.get(); }
    const KeyValues* tags() const { return mTags.get(); }

    const std::vector< ref<Atom> >& atoms() const { return mAtoms; }
    std::vector< ref<Atom> >& atoms() { return mAtoms; }

    int atomCount() const { return (int)mAtoms.size(); }
    const Atom* atom(int index) const;
    Atom* atom(int index);
    void addAtom(Atom* atom);
    void eraseAtom(Atom*atom);
    void eraseAtom(int index);
    void eraseAllAtoms();

    const std::vector< ref<Bond> >& bonds() const { return mBonds; }
    std::vector< ref<Bond> >& bonds() { return mBonds; }

    int bondCount() const { return (int)mBonds.size(); }
    const Bond* bond(int index) const;
    Bond* bond(int index);
    const Bond* bond(Atom* a1, Atom* a2) const;
    Bond* bond(Atom* a1, Atom* a2);
    void addBond(Bond* bond);
    Bond* addBond(Atom* a1, Atom* a2);
    void eraseBond(Bond*bond);
    void eraseBond(int bond);
    void eraseBond(Atom* a1, Atom* a2);
    void eraseBond(int a1, int a2);
    void eraseAllBonds();

    void computeAtomAdjacency();
    void incidentBonds(std::vector<Bond*>& inc_bonds, Atom* atom);

    const std::vector< ref<Atom> >& cycle(int i) const { return mCycles[i]; }
    std::vector< ref<Atom> >& cycle(int i) { return mCycles[i]; }

    const std::vector< std::vector< ref<Atom> > >& cycles() const { return mCycles; }
    std::vector< std::vector< ref<Atom> > >& cycles() { return mCycles; }

    void prepareForRendering();

    const ActorTree* actorTree() const { return mActorTree.get(); }
    ActorTree* actorTree() { return mActorTree.get(); }

    void setCPKAtomColors();
    void setAtomColors(const fvec4& color);

    void setCalculatedAtomRadii(float percentage=1.0f);
    void setEmpiricalAtomRadii(float percentage=1.0f);
    void setCovalentAtomRadii(float percentage=1.0f);
    void setVanDerWaalsAtomRadii(float percentage=1.0f);
    void setAtomRadii(float radius);
    void setBondRadii(float radius);

    void setAtomTypeVisible(EAtomType type, bool visible);

    void setMoleculeStyle(EMoleculeStyle style) { mMoleculeStyle = style; }
    EMoleculeStyle moleculeStyle() const { return mMoleculeStyle; }

    void setAtomDetail(int detail) { mAtomDetail = detail; }
    int atomDetail() const { return mAtomDetail; }

    void setBondDetail(int detail) { mBondDetail = detail; }
    int bondDetail() const { return mBondDetail; }

    float ringOffset() const { return mRingOffset; }
    void setRingOffset(float offset) { mRingOffset = offset; }

    void setAromaticBondsColor(const fvec4& color);
    void setAromaticRingColor(const fvec4& color) { mAromaticRingColor = color; }
    const fvec4& aromaticRingColor() const { return mAromaticRingColor; }

    float lineWidth() const { return mLineWidth; }
    bool smoothLines() const { return mSmoothLines; }

    void setLineWidth(float w) { mLineWidth = w; }
    void setSmoothLines(bool smooth) { mSmoothLines = smooth; }

    Transform* transformTree() { return mTransformTree.get(); }
    const Transform* transformTree() const { return mTransformTree.get(); }

    const Text* atomLabelTemplate() const { return mAtomLabelTemplate.get(); }
    Text* atomLabelTemplate() { return mAtomLabelTemplate.get(); }

    void setShowAtomNames(bool show) { mShowAtomNames = show; }
    bool showAtomNames() const{ return mShowAtomNames; }

    const Effect* atomLabelEffect() const { return mAtomLabelEffect.get(); }
    Effect* atomLabelEffect() { return mAtomLabelEffect.get(); }

    void setMoleculeToActorMapEnabled(bool enabled) { mMoleculeToActorMapEnabled = enabled; }
    bool isMoleculeToActorMapEnabled() const { return mMoleculeToActorMapEnabled; }

    void setActorToMoleculeMapEnabled(bool enabled) { mActorToMoleculeMapEnabled = enabled; }
    bool isActorToMoleculeMapEnabled() const { return mActorToMoleculeMapEnabled; }

    const std::map< ref<Atom>, ref<Actor> >& atomToActorMap() const { return mAtomToActorMap; }
    const std::map< ref<Actor>, ref<Atom> >& actorToAtomMap() const { return mActorToAtomMap; }
    const std::map< ref<Bond>, ref<Actor> >& bondToActorMap() const { return mBondToActorMap; }
    const std::map< ref<Actor>, ref<Bond> >& actorToBondMap() const { return mActorToBondMap; }

    std::map< ref<Atom>, ref<Actor> >& atomToActorMap() { return mAtomToActorMap; }
    std::map< ref<Actor>, ref<Atom> >& actorToAtomMap() { return mActorToAtomMap; }
    std::map< ref<Bond>, ref<Actor> >& bondToActorMap() { return mBondToActorMap; }
    std::map< ref<Actor>, ref<Bond> >& actorToBondMap() { return mActorToBondMap; }

  protected:
    void prepareAtomInsert(int bonus=100)
    {
      if (atoms().size() == atoms().capacity())
        atoms().reserve(atoms().size() + bonus);
    }
    void prepareBondInsert(int bonus=100)
    {
      if (bonds().size() == bonds().capacity())
        bonds().reserve(bonds().size() + bonus);
    }
    void wireframeStyle();
    void atomsStyle();
    void ballAndStickStyle();
    void sticksStyle();
    void generateRings();
    void generateAtomLabels();
    void generateAtomLabel(const Atom* atom, Transform* tr);

  protected:
    fvec4 mAromaticRingColor;
    ref<ActorTree> mActorTree;
    ref<Transform> mTransformTree;
    std::vector< ref<Atom> > mAtoms;
    std::vector< ref<Bond> > mBonds;
    std::vector< std::vector< ref<Atom> > > mCycles;
    std::map< ref<Atom>, ref<Actor> > mAtomToActorMap;
    std::map< ref<Actor>, ref<Atom> > mActorToAtomMap;
    std::map< ref<Bond>, ref<Actor> > mBondToActorMap;
    std::map< ref<Actor>, ref<Bond> > mActorToBondMap;
    String mMoleculeName;
    ref<KeyValues> mTags;
    ref<Text> mAtomLabelTemplate;
    ref<Effect> mAtomLabelEffect;
    unsigned int mId;
    EMoleculeStyle mMoleculeStyle;
    int mAtomDetail;
    int mBondDetail;
    float mRingOffset;
    float mLineWidth;
    bool mSmoothLines;
    bool mShowAtomNames;
    bool mMoleculeToActorMapEnabled;
    bool mActorToMoleculeMapEnabled;
  };

  VLMOLECULE_EXPORT bool loadMOL2(const String& path, std::vector< ref<Molecule> >& structures);

  VLMOLECULE_EXPORT bool loadMOL2(VirtualFile* vfile, std::vector< ref<Molecule> >& structures);
}

#endif