colorProcessor.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: colorProcessor.h,v 1.32.18.1 2007/03/25 21:26:06 oliver Exp $
//

#ifndef BALL_VIEW_MODELS_COLORPROCESSOR_H
#define BALL_VIEW_MODELS_COLORPROCESSOR_H

#ifndef BALL_CONCEPT_PROCESSOR_H
# include <BALL/CONCEPT/processor.h>
#endif

#ifndef BALL_VIEW_KERNEL_GEOMETRICOBJECT_H
# include <BALL/VIEW/KERNEL/geometricObject.h>
#endif

#ifndef BALL_DATATYPE_HASHGRID_H
# include <BALL/DATATYPE/hashGrid.h>
#endif

#ifndef BALL_DATATYPE_LIST_H
# include <BALL/DATATYPE/list.h>
#endif

#ifndef BALL_VIEW_KERNEL_COMMON_H
# include <BALL/VIEW/KERNEL/common.h>
#endif

namespace BALL
{
  class Atom;

  namespace VIEW
  {
    class Mesh;
        
class BALL_VIEW_EXPORT ColorProcessor
  : public UnaryProcessor<GeometricObject*>
{
  public:

  BALL_CREATE(ColorProcessor)
  
  
  typedef HashSet<const Composite*>  CompositeSet;

  typedef HashGrid3<const Atom*>  AtomGrid;

  typedef HashGridBox3<const Atom*> AtomBox;

  ColorProcessor();

  ColorProcessor(const ColorProcessor& color_calculator);

  virtual ~ColorProcessor();

  virtual void clear();

  void set(const ColorProcessor& color_calculator);

  virtual bool start();

  const ColorProcessor&  operator = (const ColorProcessor& color_calculator);

  bool updateAlwaysNeeded() { return update_always_needed_;};

  void setDefaultColor(const ColorRGBA& color);

  const ColorRGBA& getDefaultColor() const
    {return default_color_;}

  virtual Processor::Result operator() (GeometricObject*& object);

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

  Size getTransparency() const
    { return transparency_;}

  virtual void setTransparency(Size value);

  void setComposites(const List<const Composite*>* composites);

  const List<const Composite*>* getComposites()
    { return composites_;}

  void clearAtomGrid();

  void setAdditionalGridDistance(float distance)
    { additional_grid_distance_ = distance;}

  float getAdditionalGridDistance() const
    { return additional_grid_distance_;}

  void setMinGridSpacing(float spacing) {min_spacing_ = spacing;}

  AtomGrid& getAtomGrid() 
    { return atom_grid_;}

  virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;

  void setModelType(ModelType type) {model_type_ = type;}

  //_ Create the threedimensional grid from the CompositeSet, or a given Composite 
  virtual void createAtomGrid(const Composite* from_mesh = 0);

  const Atom* getClosestItem(const Vector3& v) const;

  protected:

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

  //_
  virtual bool canUseMeshShortcut_(const Composite&) { return false;}

  bool        update_always_needed_;
  //_ a color that will be used if no other color can be calculated.
  ColorRGBA   default_color_;
  //_ for speedup, we dont have to set transparency each time we color a geometric object
  ColorRGBA   selection_color_;
  Size        transparency_;

  const       List<const Composite*>* composites_;

  AtomGrid    atom_grid_;
  ModelType   model_type_;
  const Composite*  last_composite_of_grid_;
  float       additional_grid_distance_;
  float       min_spacing_;
};


class BALL_VIEW_EXPORT InterpolateColorProcessor
  : public ColorProcessor
{
  public: 

  enum Mode
  {
    USE_OUTSIDE_COLOR = 0,

    DEFAULT_COLOR_FOR_OUTSIDE_COLORS,

    NO_OUTSIDE_COLORS
  };
    

  BALL_CREATE(InterpolateColorProcessor)

  
  InterpolateColorProcessor();
  
  InterpolateColorProcessor(const InterpolateColorProcessor& pro);

  virtual bool start();

  void setMode(Mode mode) { mode_ = mode;}

  Mode getMode() const { return mode_;}

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

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

  void setMinColor(const ColorRGBA& color);

  void setMaxColor(const ColorRGBA& color);

  const ColorRGBA& getMinColor() const;
  
  const ColorRGBA& getMaxColor() const;

  void setMaxValue(float value) {max_value_ = value;}

  float getMaxValue() const { return max_value_;}

  void setMinValue(float value) { min_value_ = value;}

  float getMinValue() const { return min_value_;}

  virtual void interpolateColor(float value, ColorRGBA& color_to_be_set);

  protected:

  // out of range colors
  ColorRGBA min_color_,
            max_color_;

  // standard colors
  vector<ColorRGBA> colors_;

  Mode      mode_;

  float     max_value_;
  float     min_value_;
  
  // value distance between two colors
  float     x_;
};

} } // namespaces

#endif // BALL_VIEW_MODELS_COLORPROCESSOR_H

---