standardColorProcessor.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: standardColorProcessor.h,v 1.32.18.2 2007/03/28 13:51:48 amoll Exp $
//

#ifndef BALL_VIEW_MODELS_STANDARDCOLORPROCESSOR_H
#define BALL_VIEW_MODELS_STANDARDCOLORPROCESSOR_H

#ifndef BALL_VIEW_MODELS_COLORPROCESSOR_H
# include <BALL/VIEW/MODELS/colorProcessor.h>
#endif

#ifndef BALL_VIEW_DATATYPTE_COLORMAP_H
# include <BALL/VIEW/DATATYPE/colorMap.h>
#endif

#ifndef BALL_KERNEL_RESIDUE_H
# include<BALL/KERNEL/residue.h>
#endif

#ifndef BALL_KERNEL_CHAIN_H
# include<BALL/KERNEL/chain.h>
#endif

#ifndef BALL_KERNEL_MOLECULE_H
# include<BALL/KERNEL/molecule.h>
#endif

#ifndef BALL_KERNEL_SECONDARYSTRUCTURE_H
# include<BALL/KERNEL/secondaryStructure.h>
#endif


namespace BALL
{
  namespace VIEW
  {

    class BALL_VIEW_EXPORT ElementColorProcessor
      : public ColorProcessor
    {
      public:

      BALL_CREATE(ElementColorProcessor)
      
      

      ElementColorProcessor();

      void setTransparency(Size value);

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);

      HashMap<Position, ColorRGBA>& getColorMap() { return color_map_;}
      
      const HashMap<Position, ColorRGBA>& getColorMap() const { return color_map_;}

      protected: 

      HashMap<Position, ColorRGBA> color_map_;
    };


    class BALL_VIEW_EXPORT ResidueNumberColorProcessor
      : public ColorProcessor
    {
      public:

        BALL_CREATE(ResidueNumberColorProcessor)

        
        ResidueNumberColorProcessor();

        virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);

        void setFirstColor(const ColorRGBA& color) { first_color_ = color;}

        void setMiddleColor(const ColorRGBA& color) { middle_color_ = color;}

        void setLastColor(const ColorRGBA& color) { last_color_ = color;}

        const ColorRGBA& getFirstColor() const { return first_color_;}

        const ColorRGBA& getMiddleColor() const { return middle_color_;}

        const ColorRGBA& getLastColor() const { return last_color_;}

        virtual bool start();

      protected:
        bool canUseMeshShortcut_(const Composite& composite);

        GeometricObjectList list_;
        ColorRGBA first_color_, middle_color_, last_color_;
        ColorMap table_;
        Residue dummy_residue_;
        HashMap<const Residue*, Position> residue_map_;
    };

    class BALL_VIEW_EXPORT PositionColorProcessor
      : public ColorProcessor
    {
      public:

      BALL_CREATE(PositionColorProcessor)

      
      PositionColorProcessor();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);

      void setColors(const vector<ColorRGBA>& colors) { colors_ = colors;}

      vector<ColorRGBA>& getColors() { return colors_;}

      const vector<ColorRGBA>& getColors() const { return colors_;}

      bool start();

      protected:

      virtual const Composite* getAncestor_(const Composite&) { return 0;}

      virtual bool isOK_(const Composite&) { return false;}

      vector<ColorRGBA>                     colors_;
      HashMap<const Composite*, Position>   composite_to_position_;
    };


    class BALL_VIEW_EXPORT ChainColorProcessor
      : public PositionColorProcessor
    {
      public:

      BALL_CREATE(ChainColorProcessor)

      
      ChainColorProcessor();

      protected:

      virtual const Composite* getAncestor_(const Composite& composite) 
        { return composite.getAncestor(dummy_chain_);}

      virtual bool isOK_(const Composite& composite) { return RTTI::isKindOf<Chain>(composite);}
      bool canUseMeshShortcut_(const Composite& composite);

      Chain   dummy_chain_;
    };


    class BALL_VIEW_EXPORT MoleculeColorProcessor
      : public PositionColorProcessor
    {
      public:

      BALL_CREATE(MoleculeColorProcessor)

      
      MoleculeColorProcessor();

      protected:

      virtual const Composite* getAncestor_(const Composite& composite) 
        { return composite.getAncestor(dummy_molecule_);}

      virtual bool isOK_(const Composite& composite) { return RTTI::isKindOf<Molecule>(composite);}
      bool canUseMeshShortcut_(const Composite& composite);

      Molecule  dummy_molecule_;
    };


    class BALL_VIEW_EXPORT ResidueNameColorProcessor
      : public ColorProcessor
    {
      public:

      BALL_CREATE(ResidueNameColorProcessor)
      
      
      ResidueNameColorProcessor();

      void setTransparency(Size value);

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);
      
      StringHashMap<ColorRGBA>& getColorMap() { return color_map_;}
      
      const StringHashMap<ColorRGBA>& getColorMap() const { return color_map_;}

      protected:  
        StringHashMap<ColorRGBA> color_map_;
        Residue                  dummy_residue;
        bool canUseMeshShortcut_(const Composite& composite);
    };

      
    class BALL_VIEW_EXPORT AtomChargeColorProcessor
      : public InterpolateColorProcessor
    {
      public:

      BALL_CREATE(AtomChargeColorProcessor)
      
      
      AtomChargeColorProcessor();

      AtomChargeColorProcessor(const AtomChargeColorProcessor& color_Processor);

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);
    };


    class BALL_VIEW_EXPORT AtomDistanceColorProcessor
      :  public ColorProcessor
    {
      public:

      BALL_CREATE(AtomDistanceColorProcessor)
      
      
      AtomDistanceColorProcessor();

      AtomDistanceColorProcessor(const AtomDistanceColorProcessor& color_Processor);

      void setDistance(float distance) { distance_ = distance;}

      float getDistance() const;

      void setNullDistanceColor(const ColorRGBA& color);

      const ColorRGBA& getNullDistanceColor() const;

      void setMaxDistanceColor(const ColorRGBA& color);

      const ColorRGBA& getMaxDistanceColor() const;

      void calculateDistances();

      virtual void addAtom(const Atom& atom);

      virtual bool finish();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);

      bool showSelected() { return show_selection_;}

      void setShowSelected(bool state) { show_selection_ = state;}
      
      virtual Processor::Result operator() (GeometricObject*& object);

      private:

      void colorGeometricObject_(GeometricObject& object);

      //_ Colorize the mesh with the computed grid.
      virtual void colorMeshFromGrid_(Mesh& mesh);

      typedef HashMap<const Atom*, float> AtomDistanceHashMap;

      AtomDistanceHashMap atom_2_distance_;
      GeometricObjectList list_;

      float       distance_;
      bool        show_selection_;

      ColorRGBA   null_distance_color_;
      ColorRGBA   full_distance_color_;
    };


    class BALL_VIEW_EXPORT CustomColorProcessor
      : public ColorProcessor
    {
      public:

        BALL_CREATE(CustomColorProcessor)

        CustomColorProcessor()
          : ColorProcessor()
        {}

        bool canUseMeshShortcut_(const Composite&) { return true;}
    };


    class BALL_VIEW_EXPORT TemperatureFactorColorProcessor
      : public InterpolateColorProcessor
    {
      public:

      BALL_CREATE(TemperatureFactorColorProcessor)

      
      TemperatureFactorColorProcessor();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);
    };

    
    class BALL_VIEW_EXPORT OccupancyColorProcessor
      : public InterpolateColorProcessor
    {
      public:

      BALL_CREATE(OccupancyColorProcessor)

      
      OccupancyColorProcessor();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);
    };

    class BALL_VIEW_EXPORT ForceColorProcessor
      : public InterpolateColorProcessor
    {
      public:

      BALL_CREATE(ForceColorProcessor)

      
      ForceColorProcessor();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);
    };


    class BALL_VIEW_EXPORT SecondaryStructureColorProcessor
      : public ColorProcessor
    {
      public:

      BALL_CREATE(SecondaryStructureColorProcessor)

      
      SecondaryStructureColorProcessor();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);

      void setHelixColor(const ColorRGBA& color);

      void setCoilColor(const ColorRGBA& color);

      void setStrandColor(const ColorRGBA& color);

      void setTurnColor(const ColorRGBA& color);

      const ColorRGBA& getHelixColor() const;

      const ColorRGBA& getCoilColor() const;

      const ColorRGBA& getStrandColor() const;

      const ColorRGBA& getTurnColor() const;

      virtual void setTransparency(Size t);

      private:

      bool canUseMeshShortcut_(const Composite& composite);

      ColorRGBA helix_color_,
                coil_color_,
                strand_color_,
                turn_color_;

      SecondaryStructure dummy_ss_;
    };
      
  
    class BALL_VIEW_EXPORT ResidueTypeColorProcessor
      : public ColorProcessor
    {
      public:

      BALL_CREATE(ResidueTypeColorProcessor)

      
      ResidueTypeColorProcessor();

      virtual void getColor(const Composite& composite, ColorRGBA& color_to_be_set);

      void setBasicColor(const ColorRGBA& color);

      void setAcidicColor(const ColorRGBA& color);

      void setPolarColor(const ColorRGBA& color);

      void setHydrophobicColor(const ColorRGBA& color);

      void setAromaticColor(const ColorRGBA& color);

      void setOtherColor(const ColorRGBA& color);

      const ColorRGBA& getBasicColor() const;

      const ColorRGBA& getAcidicColor() const;

      const ColorRGBA& getPolarColor() const;

      const ColorRGBA& getHydrophobicColor() const;

      const ColorRGBA& getAromaticColor() const;

      const ColorRGBA& getOtherColor() const;

      virtual void setTransparency(Size t);

      private:

      bool canUseMeshShortcut_(const Composite& composite);

      ColorRGBA basic_color_,
                acidic_color_,
                polar_color_,
                hydrophobic_color_,
                aromatic_color_,
                other_color_;

      Residue   dummy_residue_;
    };
      
# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/VIEW/MODELS/standardColorProcessor.iC>
# endif

} } // namespaces

#endif // BALL_VIEW_MODELS_STANDARDCOLORPROCESSOR_H