---

DrawMolItem.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2011 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: DrawMolItem.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.171 $      $Date: 2012/03/07 21:32:48 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * Child Displayable component of a molecule; this is responsible for doing
 * the actual drawing of a molecule.  It contains an atom color, atom
 * selection, and atom representation object to specify how this component
 * should look.
 *
 ***************************************************************************/
#ifndef DRAWMOLITEM_H
#define DRAWMOLITEM_H

#include "config.h"         // to force recompilation on config changes
#include "Displayable.h"
#include "DispCmds.h"
#include "AtomColor.h"
#include "AtomRep.h"
#include "AtomSel.h"
#include "PickMode.h"
#include "BaseMolecule.h"
#include "VolumeTexture.h"

class DrawMolecule;         

#ifdef VMDSURF
#include "Surf.h"
#endif

#ifdef VMDMSMS
#include "MSMSInterface.h"
#endif

#include "QuickSurf.h"

class DrawMolItem : public Displayable {
public:
  AtomColor *atomColor;     
  AtomRep *atomRep;         
  AtomSel *atomSel;         
  int repNumber;            
  char commentBuffer[1024]; 

  char *name;               

private:
  DrawMolecule *mol;        
  float *avg;               
  int avgsize;              

 
  char *framesel;           


  int structwarningcount;   

  int emitstructwarning(void); 


  DispCmdBeginRepGeomGroup cmdBeginRepGeomGroup;
  DispCmdColorIndex      cmdColorIndex;
  DispCmdComment         cmdCommentX;
  DispCmdCylinder        cmdCylinder;
  DispCmdLine            cmdLine;
  DispCmdLineType        cmdLineType;
  DispCmdLineWidth       cmdLineWidth;
  DispCmdPickPoint       pickPoint;
  DispCmdPointArray      cmdPointArray;
  DispCmdSphere          cmdSphere;
  DispCmdSphereRes       cmdSphres;
  DispCmdSphereType      cmdSphtype;
  DispCmdSphereArray     cmdSphereArray;
  DispCmdSquare          cmdSquare;
  DispCmdTriangle        cmdTriangle;
  DispCmdTriMesh         cmdTriMesh;
  DispCmdVolSlice        cmdVolSlice;
  DispCmdWireMesh        cmdWireMesh;

  struct ColorLookup {
    int num;
    int max;
    int *idlist;
    ColorLookup() {
      num = 0;
      max = 0;
      idlist = 0;
    }
    ~ColorLookup() {
      free(idlist);
    }
    void append(int id) {
      if (max == 0) {
        idlist = (int *)malloc(8*sizeof(int)); 
        max = 8;
      }
      if (num == max) {
        idlist = (int *)realloc(idlist, 2*num*sizeof(int));
        max = 2*num;
      }
      idlist[num++] = id;
    }
  };
 
  ColorLookup *colorlookups;      
  static void update_lookups(AtomColor *, AtomSel *, ColorLookup *);

  void update_pbc_transformations();

#ifdef VMDSURF
  Surf surf;                   
#endif

#ifdef VMDMSMS
  MSMSInterface msms;          
#endif

  int waveftype;               
  int wavefspin;               
  int wavefexcitation;         
  int gridorbid;               
  float orbgridspacing;        
  int orbgridisdensity;        
  VolumetricData *orbvol;      

  // cached volume texture information to avoid unnecessary updates
  int voltexVolid;
  int voltexColorMethod;
  float voltexDataMin, voltexDataMax;

  // encapsulate data for color by volume used by this rep
  VolumeTexture volumeTexture;

  // Auxiliary data structure for rendering tubes.
  // Since the control points are based on fixed atom indices, we can
  // find all those indices once, cache them, then just look up the
  // coordinates when it's time to draw a frame.  Should speed up
  // animation, as well as perhaps make it easier to add better-looking
  // tube reps later.
 
  // TubeIndexList holds a set of control point indices.
  typedef ResizeArray<int> TubeIndexList;

  ResizeArray<TubeIndexList *> *tubearray;

  void generate_tubearray();

  // commands to draw different representations for a given selection 
  void draw_solid_spheres(float *, int res, float radscale, float fixrad);
  void draw_residue_beads(float *, int res, float radscale);
  void draw_dotted_spheres(float *, float srad, int sres); 
  void draw_lines(float *, int thickness, float cutoff);   
  void draw_cpk_licorice(float *, int, float, int, float, int, int, float cutoff); 

#ifdef VMDPOLYHEDRA
  void draw_polyhedra(float *, float); 
#endif
  void draw_points(float *, float);                   
  void draw_bonds(float *, float brad, int bres, float cutoff);             

  void make_connection(float *prev, float *start, float *end, float *next,
                       float radius, int resolution, int is_cyl);

  void draw_spline_curve(int num, float *coords, int *idx,
                         int use_cyl, float b_rad, int b_res);

  void draw_spline_ribbon(int num, float *coords, float *perps,
                          int *idx, int use_cyl, float b_rad,
                          int b_res);

  void draw_spline_new(int num, const float *coords, 
                       const float *perps, const int *idx, 
                       const float *cpwidths, const float *cpheights, 
                       int numscalefactors, int b_res, int cyclic);

  void draw_ribbon_from_points(int numpoints, const float *points, 
                  const float *perps, const int *cols, int numpanels,
                  const float *heights, const float *widths, 
                  int numscalefactors);

  void draw_tube(float *, float radius, int res);   
  void draw_ribbons(float *, float brad, int bres, float thickness); 
  void draw_ribbons_new(float *, float, int, int, float);  


  int draw_protein_ribbons_old(float *, int, float, float, int);
  int draw_protein_ribbons_new(float *, int, float, float, int);
  int draw_nucleic_ribbons(float *, int, float, float, int, int, int);
  int draw_nucleotide_cylinders(float *, int, float, float, int);
  int draw_base_sugar_rings(float *, int, float, float, int);
  int draw_cartoon_ribbons(float *, int, float, float, int, int);

  void draw_structure(float *, float brad, int bres, int linethickness); 

  void draw_alpha_helix_cylinders(ResizeArray<float> &x,
                                  ResizeArray<float> &y,
                                  ResizeArray<float> &z,
                                  ResizeArray<int> &atom_on, int *color,
                                  float bond_rad, int bond_res,
                                  float *res_start, float *res_end);

  void draw_beta_sheet(ResizeArray<float> &x, ResizeArray<float> &y,
                       ResizeArray<float> &z, ResizeArray<int> &atom_on, 
                       int *color, float ribbon_width,
                       float *res_start, float *res_end);

  void draw_trace(float *pos, float brad, int bres, int linethickness); 
  void draw_dot_surface(float *pos, float srad, int sres, int method); 
  void draw_msms(float *pos, int draw_wireframe, int allatoms, float radius, float density); 
  void draw_quicksurf(float *pos, int quality, float radius, float isovalue, float spacing); 
  void draw_surface(float *pos, int draw_wireframe, float radius); 
  void draw_hbonds(float *, float maxangle, int thickness, float cutoff); 
  void draw_dynamic_bonds(float *, float brad, int bres, float cutoff); 

  // Drawing functions for volumetric and isosurface data 
  void draw_volslice(int volid, float slice, int axis, int texmode); 

  void updateVolumeTexture();

  void draw_isosurface(int, float, int, int, int, int); 
  void draw_volume_field_lines(int volid, float seedval, float minlen, float maxlen, float thickness); 

  void draw_orbital(int, int, int, int, int, float, int, int, float, int, int); 

  // helper functions for volume rendering
  void draw_volume_box_solid(const VolumetricData *);
  void draw_volume_box_lines(const VolumetricData *);
  void draw_volume_slice(const VolumetricData *, int, float, int);
  void draw_volume_texture(const VolumetricData *, int);
  void draw_volume_isosurface_points(const VolumetricData *, float, int, int);
  void draw_volume_isosurface_lit_points(const VolumetricData *, float, int, int);
  void draw_volume_isosurface_trimesh(const VolumetricData *, float, int, const float *voltex=NULL);
  void draw_volume_isosurface_lines(const VolumetricData *, float, int, int);
  int  draw_volume_get_colorid(void);
  void prepare_volume_texture(const VolumetricData *v, int method);
  int calcseeds_gradient_magnitude(const VolumetricData *v, ResizeArray<float> *seeds, float seedmin, float seedmax);


#ifdef VMDWITHCARBS

  // functions for rendering small rings using the PaperChain algorithm
  void draw_rings_paperchain(float *framepos, float bipyramid_height, int maxringsize);
  void paperchain_get_ring_color(SmallRing &ring, float *framepos, float *rgb);
  void paperchain_draw_ring(SmallRing &ring, float *framepos, float bipyramid_height);
  
  // functions for rendering small rings using the Twister algorithm
  void draw_rings_twister(float *framepos, int start_end_centroid, int hide_shared_links, int rib_steps, float rib_width, float rib_height, int maxringsize, int maxpathlength);
  void twister_draw_path(LinkagePath &path, float *framepos, int start_end_centroid, int rib_steps, float rib_width, float rib_height);
  void twister_draw_ribbon_extensions(ResizeArray<float> &vertices, ResizeArray<float> &colors,
                                      ResizeArray<float> &normals, ResizeArray<int> &facets,
                                      float centroid[3], float normal[3], float right[3], float rib_point[3],
                                      float rib_height, float rib_width,
                                      float top_color[3], float bottom_color[3]);
  void twister_draw_hexagon(ResizeArray<float> &vertices, ResizeArray<float> &colors, ResizeArray<float> &normals,
                                      ResizeArray<int> &facets, float centroid[3], float normal[3],
                                      float first_atom[3], float rib_height, float rib_width,
                                      float top_color[3], float bottom_color[3]);
  
  // utility functions for Twister and Paper Chain
  void get_ring_centroid_and_normal(float *centroid, float *normal, SmallRing &ring, float *framepos);
  bool smallring_selected(SmallRing &ring);
  bool linkagepath_selected(LinkagePath &path);
#endif

  void create_cmdlist(void);            
  void do_create_cmdlist();             

public:
  enum RegenChoices {NO_REGEN = 0, MOL_REGEN = 1, SEL_REGEN = 2,
                     REP_REGEN = 4, COL_REGEN = 8};

private:
  int needRegenerate;                   
  int update_pbc;                       
  int update_ss;                        
  int update_ts;                        
  int update_traj;                      
  void place_picks(float *pos);         

protected:
  virtual void do_color_changed(int);
  virtual void do_color_rgb_changed(int);
  virtual void do_color_scale_changed();

public:
  // constructor: name, parent molecule, and atom drawing methods
  DrawMolItem(const char *, DrawMolecule *, AtomColor *, AtomRep *, AtomSel *);
  virtual ~DrawMolItem(void);
  
  int change_color(AtomColor *);        
  int change_rep(AtomRep *);            
  int change_sel(const char *);         
  void force_recalc(int);               
  int atom_displayed(int);              
  int representation_index(void);       

  int set_smoothing(int n) {           
    if (n >= 0) {
      avgsize = n; 
      return TRUE;
    }
    return FALSE;
  }
  int get_smoothing() const {           
    return avgsize;
  }

  void set_drawframes(const char *frames);
  const char *get_drawframes() const { return framesel; }
   
  void set_pbc(int);
  int get_pbc() const;

  void set_pbc_images(int);
  int get_pbc_images() const;

  void change_pbc() { update_pbc = 1; }

  void change_ss() { update_ss = 1; }

  void change_ts() { update_ts = 1; }

  void change_traj() { update_traj = 1; }

  //
  // public virtual routines
  //
  virtual void prepare();               

  virtual int pickable_on();


  virtual void pick_start(PickMode *p, DisplayDevice *d,
                          int btn, int tag, const int *cell, int dim, 
                          const float *pos) {
    p->pick_molecule_start(mol, d, btn, tag, cell, dim, pos);
  }

  virtual void pick_move(PickMode *p, DisplayDevice *d,
                          int tag, int dim, const float *pos) {
    p->pick_molecule_move (mol, d, tag, dim, pos);
  }

  virtual void pick_end(PickMode *p, DisplayDevice *d) {
    p->pick_molecule_end  (mol, d);
  }

protected:
  float spline_basis[4][4];          
};

#endif

---