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