entity.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library 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 for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
#ifndef OST_GFX_ENTITY_HH
#define OST_GFX_ENTITY_HH
 
/*
  Author: Ansgar Philippsen, Marco Biasini
*/
#include <vector>
 
#include <boost/ptr_container/ptr_map.hpp>
 
#include <ost/geom/geom.hh>
 
#include <ost/mol/query_view_wrapper.hh>
#include <ost/gfx/render_options/render_options.hh>
#include <ost/gfx/color_ops/color_op.hh>
#include <ost/gfx/color_ops/by_element_color_op.hh>
#include <ost/gfx/color_ops/by_chain_color_op.hh>
#include <ost/gfx/color_ops/uniform_color_op.hh>
#include <ost/gfx/color_ops/gradient_level_color_op.hh>
#include <ost/gfx/color_ops/entity_view_color_op.hh>
#include <ost/gfx/color_ops/map_handle_color_op.hh>
 
#include <ost/gfx/impl/entity_renderer.hh>
 
#include "gradient.hh"
#include "entity_fw.hh"
#include "impl/backbone_trace.hh"
#include "impl/entity_detail.hh"
 
namespace ost { namespace gfx {
 
typedef std::vector<RenderMode::Type> RenderModeTypes;
 
class DLLEXPORT_OST_GFX Entity: public GfxObj {
 
public:
  Entity(const String& name,
         const mol::EntityHandle& eh,
         const mol::Query& q=mol::Query(),
         mol::QueryFlags f=0);
 
  Entity(const String& name,
         RenderMode::Type m,
         const mol::EntityHandle& eh,
         const mol::Query& q=mol::Query(),
         mol::QueryFlags f=0);
 
  Entity(const String& name,
         const mol::EntityView& ev);
 
  Entity(const String& name,
         RenderMode::Type m,
         const mol::EntityView& ev);
  virtual ~Entity();
 
  virtual geom::AlignedCuboid GetBoundingBox(bool use_tf=false) const;
 
  // ProcessLimits uses the default implementation of bounding box
  
  virtual void CustomRenderGL(RenderPass pass);
 
  virtual void RefreshVA();
  
  virtual bool OnSelect(const geom::Line3& l, geom::Vec3& result, float zlim,
                        bool pick_flag);
 
  mol::AtomHandle PickAtom(const geom::Line3& line, Real line_width=0.5);
  
 
  mol::BondHandle PickBond(const geom::Line3& line, Real line_width=0.5);
 
 
  virtual void OnRenderModeChange();
  
  const String GetRenderModeName(RenderMode::Type mode);
 
  void SetEnableRenderMode(RenderMode::Type mode, bool enable);
 
  bool IsRenderModeEnabled(RenderMode::Type mode);
 
  RenderModeTypes GetNotEmptyRenderModes();
 
  void SetRenderMode(RenderMode::Type mode, const mol::EntityView& view, 
                     bool keep=false);
  void SetRenderMode(RenderMode::Type mode, const String& selection, 
                     bool keep=false);
  virtual void SetRenderMode(RenderMode::Type mode);  
  
  mol::EntityView GetRenderView(RenderMode::Type mode);
 
  virtual void SetVisible(const mol::EntityView& view, bool visible);
 
  virtual void SetVisible(const String& sel, bool visible);
  virtual void OptionsChanged(RenderMode::Type mode);
 
  virtual void SetOpacity(float f);
  virtual float GetOpacity() const {return opacity_;}
  virtual void SetOutlineWidth(float f);
  virtual void SetOutlineExpandFactor(float f);
  virtual void SetOutlineExpandColor(const Color& c);
  virtual void SetClipOffset(float f);
 
  void Reset(const mol::EntityHandle& eh);
  void Reset(const mol::EntityHandle& eh, const mol::Query& q);
  void Reset(const mol::EntityHandle& eh, const mol::Query& q, mol::QueryFlags flags);
  void Reset(const mol::EntityView& ev);
  /*
    the naming here is misleading - this method WON'T be called upon FlagRebuild
  */
  void Rebuild();
 
  void UpdatePositions();
 
  void UpdateView();
 
  void SetColor(const Color& col, const String& selection=String(""));
 
  // \brief detail coloring
  void SetDetailColor(const Color& col, const String& selection=String(""));
  
  void SetColorForAtom(const Color& col, 
                       const mol::AtomHandle& atom);
 
  void ColorByElement();
  
  void ColorByElement(const String& selection);
 
  void ColorByChain();
 
  void ColorByChain(const String& selection);
 
  mol::EntityView GetView() const;
 
  void SetQuery(const mol::Query& q);
 
  mol::QueryViewWrapper GetQueryView() const;
  void SetQueryView(const mol::QueryViewWrapper& qv);
 
  mol::EntityHandle GetEntity() const;
 
  // turn blur on or off (experimental feature)
  void SetBlur(bool f);
  // set atom positions as n-1 for blur (experimental feature)
  void BlurSnapshot();
  // blur transparency falloffs (experimental feature)
  void SetBlurFactors(float bf1,float bf2);
 
  void SetSelection(const mol::EntityView& view);
  
  mol::EntityView GetSelection() const;
  
  // GfxObj property interface
  virtual void ColorBy(const mol::EntityView& ev, 
                       const String& prop,
                       const Gradient& g, float minv, float maxv);
 
  // GfxObj property interface
  virtual void ColorBy(const img::MapHandle& mh,
                       const String& prop,
                       const Gradient& g,float minv, float maxv);
 
  // map property to color gradient from minv to maxv
  void ColorBy(const String& prop, 
               const Gradient& gradient,
               float minv,float maxv,
               mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
  // temporarily here, will be moved to py interface
  void ColorBy(const String& prop, 
               const Gradient& gradient,
               float minv,float maxv,
               bool clamp);
 
  // temporary, should be incorporated with ColorBy
  void DetailColorBy(const String& prop, 
                     const Gradient& gradient,
                     float minv,float maxv,
                     mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
  // convenience
  void ColorBy(const String& prop, 
               const Gradient& gradient,
               mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
  // convenience
  void ColorBy(const String& prop,
               const Gradient& gradient,
               const String& selection);
 
  // convenience
  void ColorBy(const String& prop, 
               const Color& c1, const Color& c2, 
               float min, float max,
               mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
  // convenience
  void ColorBy(const String& prop, 
               const Color& c1, const Color& c2,
               mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
 
  void RadiusBy(const String& prop,
                float rmin, float rmax, 
                float vmin, float vmax,
                mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
  void RadiusBy(const String& prop,
                float rmin, float rmax,
                mol::Prop::Level hint=mol::Prop::UNSPECIFIED);
 
  void ResetRadiusBy();
 
  void Apply(const gfx::ByElementColorOp& op, bool store=true);
  void Apply(const gfx::ByChainColorOp& op, bool store=true);
  void Apply(const gfx::UniformColorOp& op, bool store=true);
  void Apply(const gfx::GradientLevelColorOp& op, bool store=true);
  void Apply(const gfx::EntityViewColorOp& op, bool store=true);
  void Apply(const gfx::MapHandleColorOp& op, bool store=true);
 
  void CleanColorOps();
  void ReapplyColorOps();
  
  RenderOptionsPtr GetOptions(RenderMode::Type render_mode);
  void SetOptions(RenderMode::Type render_mode, 
                  RenderOptionsPtr& render_options);
  void ApplyOptions(RenderMode::Type render_mode,
                          RenderOptionsPtr& render_options);
  bool HasSelection() const;
 
  void SetSeqHack(bool b);
  bool GetSeqHack() const;
  
  virtual void Export(Exporter* ex);
 
protected:
 
  virtual void CustomPreRenderGL(bool flag);
  virtual void CustomRenderPov(PovState& pov);
  void UpdateSelection();
  bool UpdateIfNeeded() const;
  void CacheBoundingBox() const;
  impl::EntityRenderer* GetOrCreateRenderer(RenderMode::Type);
private:
  mol::QueryViewWrapper         qv_;
                                
  mutable mol::EntityView       cached_view_;
  mutable bool                  update_view_;
  
  mutable geom::AlignedCuboid   bbox_;
  mol::EntityView               sel_;
  bool                          sel_update_;
  mutable impl::BackboneTrace   trace_;
                           
  void init(RenderMode::Type);
 
  void set_static_max_rad();
  void do_update_view() const;
  
  typedef boost::ptr_map<RenderMode::Type, impl::EntityRenderer> RendererMap;
  mutable RendererMap renderer_;
 
  float opacity_;
  bool blur_;
  float blurf1_;
  float blurf2_;
  mutable bool needs_update_;
};
 
 
 
 
 
 
}} // ns
 
#endif