Ticket #778: changes_take_3.diff

src/core/atomic/atomstruct_cpp/Atom.cpp

@@ -846 +846 @@
     return _idatm_map;
 }
 
+void 
+Atom::bonds_track_change(const std::string& reason) {
+    for(std::vector<Bond*>::iterator b = _bonds.begin(); b != _bonds.end(); ++b) {
+        (*b)->track_change(reason);
+    }
+}
+
+
 bool
 Atom::has_missing_structure_pseudobond() const
 {
@@ -1112 +1120 @@
     if (alt_loc == _alt_loc || alt_loc == ' ')
         return;
     graphics_container()->set_gc_shape();
-    structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_ALT_LOC);
+    track_change(ChangeTracker::REASON_ALT_LOC);
     if (create) {
         if (_alt_loc_map.find(alt_loc) != _alt_loc_map.end()) {
             set_alt_loc(alt_loc, create=false);
@@ -1135 +1143 @@
         _Alt_loc_info &info = (*i).second;
         _serial_number = info.serial_number;
         _alt_loc = alt_loc;
-        structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_COORD);
+        track_change(ChangeTracker::REASON_COORD);
     } else {
         residue()->set_alt_loc(alt_loc);
     }
@@ -1160 +1168 @@
     (*a)[3] = u22;
     (*a)[4] = u23;
     (*a)[5] = u33;
-    structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_ANISO_U);
+    track_change(ChangeTracker::REASON_ANISO_U);
 }
 
 void
@@ -1171 +1179 @@
         (*i).second.bfactor = bfactor;
     } else
         structure()->active_coord_set()->set_bfactor(this, bfactor);
-    structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_BFACTOR);
+    track_change(ChangeTracker::REASON_BFACTOR);
 }
 
 void
@@ -1180 +1188 @@
     if (rgba == _rgba)
         return;
     graphics_container()->set_gc_color();
-    change_tracker()->add_modified(this, ChangeTracker::REASON_COLOR);
+    track_change(ChangeTracker::REASON_COLOR);
+    bonds_track_change(ChangeTracker::REASON_COLOR);
     _rgba = rgba;
 }
 
 void
 Atom::set_coord(const Coord& coord, CoordSet* cs)
-{
-    structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_COORD);
+{   
+    track_change(ChangeTracker::REASON_COORD);
+    bonds_track_change(ChangeTracker::REASON_COORD);
     if (cs == nullptr) {
         cs = structure()->active_coord_set();
         if (cs == nullptr) {
@@ -1214 +1224 @@
     if (d == _display)
         return;
     graphics_container()->set_gc_shape();
-    change_tracker()->add_modified(this, ChangeTracker::REASON_DISPLAY);
+    graphics_container()->set_gc_atom_vis();
+    graphics_container()->set_gc_bond_vis();
+    track_change(ChangeTracker::REASON_DISPLAY);
     _display = d;
 }
 
@@ -1223 +1235 @@
 {
     if (dm == _draw_mode)
         return;
+    if ( _draw_mode == DrawMode::Sphere || dm == DrawMode::Sphere )
+        graphics_container()->set_gc_bond_vis();
     graphics_container()->set_gc_shape();
-    change_tracker()->add_modified(this, ChangeTracker::REASON_DRAW_MODE);
+    track_change(ChangeTracker::REASON_DRAW_MODE);
     _draw_mode = dm;
 }
 
@@ -1234 +1248 @@
     if (h == _hide)
         return;
     graphics_container()->set_gc_shape();
-    change_tracker()->add_modified(this, ChangeTracker::REASON_HIDE);
+    graphics_container()->set_gc_atom_vis();
+    graphics_container()->set_gc_bond_vis();
+    track_change(ChangeTracker::REASON_HIDE);
     _hide = h;
 }
 
 void
 Atom::set_occupancy(float occupancy)
 {
-    structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_OCCUPANCY);
+    track_change(ChangeTracker::REASON_OCCUPANCY);
     if (_alt_loc != ' ') {
         _Alt_loc_map::iterator i = _alt_loc_map.find(_alt_loc);
         (*i).second.occupancy = occupancy;
@@ -1259 +1275 @@
         return;
 
     graphics_container()->set_gc_shape();
-    change_tracker()->add_modified(this, ChangeTracker::REASON_RADIUS);
+    track_change(ChangeTracker::REASON_RADIUS);
     _radius = r;
 }
 
@@ -1269 +1285 @@
     if (s == _selected)
         return;
     graphics_container()->set_gc_select();
-    change_tracker()->add_modified(this, ChangeTracker::REASON_SELECTED);
+    track_change(ChangeTracker::REASON_SELECTED);
+    bonds_track_change(ChangeTracker::REASON_SELECTED);
     _selected = s;
 }
 
@@ -1281 +1298 @@
         _Alt_loc_map::iterator i = _alt_loc_map.find(_alt_loc);
         (*i).second.serial_number = sn;
     }
-    structure()->change_tracker()->add_modified(this, ChangeTracker::REASON_SERIAL_NUMBER);
+    track_change(ChangeTracker::REASON_SERIAL_NUMBER);
 }
 
 std::string

src/core/atomic/atomstruct_cpp/Atom.h

@@ -109 +109 @@
     typedef std::map<unsigned char, _Alt_loc_info>  _Alt_loc_map;
     _Alt_loc_map  _alt_loc_map;
     std::vector<float>*  _aniso_u;
+    bool _changed_since_last_drawn = false; 
     Bonds  _bonds; // _bonds/_neighbors in same order
     mutable AtomType  _computed_idatm_type;
     unsigned int  _coord_index;
@@ -128 +129 @@
     mutable Rings  _rings;
     bool  _selected = false;
     int  _serial_number;
-    void  _set_structure_category(Atom::StructCat sc) const;
+    void  _set_structure_category(Atom::StructCat sc);
     Structure*  _structure;
     mutable StructCat  _structure_category;
 public:
@@ -137 +138 @@
     void  _switch_initial_element(const Element& e) { _element = &e; }
 
 public:
+    bool changed_since_last_drawn() const { return _changed_since_last_drawn; }
+    void set_changed_since_last_drawn(bool flag) { _changed_since_last_drawn = flag; }
     void  add_bond(Bond *b);
     char  alt_loc() const { return _alt_loc; }
     std::set<char>  alt_locs() const;
@@ -208 +211 @@
 
     // change tracking
     ChangeTracker*  change_tracker() const;
+    void track_change(const std::string& reason) {
+        change_tracker()->add_modified(this, reason);
+        this->set_changed_since_last_drawn(true);
+    }
+    
+    void bonds_track_change(const std::string& reason); 
+    
 
     // graphics related
     const Rgba&  color() const { return _rgba; }
@@ -243 +253 @@
 }
 
 inline void
-Atom::_set_structure_category(Atom::StructCat sc) const
+Atom::_set_structure_category(Atom::StructCat sc)
 {
     if (sc == _structure_category)
         return;
-    change_tracker()->add_modified(const_cast<Atom*>(this),
-        ChangeTracker::REASON_STRUCTURE_CATEGORY);
+    track_change(ChangeTracker::REASON_STRUCTURE_CATEGORY);
     _structure_category = sc;
 }
 
 inline void
 Atom::set_computed_idatm_type(const char* it) {
     if (!idatm_is_explicit() && _computed_idatm_type != it) {
+        track_change(ChangeTracker::REASON_IDATM_TYPE);
         change_tracker()->add_modified(this, ChangeTracker::REASON_IDATM_TYPE);
     }
     _computed_idatm_type =  it;
@@ -267 +277 @@
     if (!(_explicit_idatm_type.empty() && _computed_idatm_type == it)
     && !(*it == '\0' && _explicit_idatm_type == _computed_idatm_type)
     && !(!_explicit_idatm_type.empty() && it == _explicit_idatm_type)) {
-        change_tracker()->add_modified(this, ChangeTracker::REASON_IDATM_TYPE);
+        track_change(ChangeTracker::REASON_IDATM_TYPE);
     }
     _explicit_idatm_type = it;
 }
@@ -276 +286 @@
 Atom::set_name(const AtomName& name) {
     if (name == _name)
         return;
-    change_tracker()->add_modified(this, ChangeTracker::REASON_NAME);
+    track_change(ChangeTracker::REASON_NAME);
     _name = name;
+    _changed_since_last_drawn = true;
 }
 
 inline Atom::StructCat

src/core/atomic/atomstruct_cpp/Bond.cpp

@@ -174 +174 @@
     return psa;
 }
 
+void
+Bond::set_hide(int h) {
+    if (h == _hide)
+        return;
+    graphics_container()->set_gc_bond_vis();
+    Connection::set_hide(h);
+}
+
+void
+Bond::set_display(bool d) {
+    if (d == _display)
+        return;
+    graphics_container()->set_gc_bond_vis();
+    Connection::set_display(d);
+}
+
 }  // namespace atomstruct

src/core/atomic/atomstruct_cpp/Bond.h

@@ -46 +46 @@
     const char*  err_msg_loop() const
         { return "Can't bond an atom to itself"; }
     mutable Rings  _rings;
-
+    bool _changed_since_last_drawn = false;
+    
     static int  session_base_version(int /*version*/) { return 1; }
     static int  SESSION_NUM_INTS(int /*version*/=CURRENT_SESSION_VERSION) { return 0; }
     static int  SESSION_NUM_FLOATS(int /*version*/=CURRENT_SESSION_VERSION) { return 0; }
 public:
+    void set_hide(int h);
+    void set_display(bool d);
     virtual ~Bond() {}
     virtual bool shown() const;
     const Rings&  all_rings(bool cross_residues = false, int size_threshold = 0,
@@ -62 +65 @@
         return rings(cross_residues, 0, ignore);
     }
     static bool  polymer_bond_atoms(Atom* first, Atom* second);
+    bool changed_since_last_drawn() const { return _changed_since_last_drawn; }
+    void set_changed_since_last_drawn(bool flag) { _changed_since_last_drawn = flag; }
     Atom*  polymeric_start_atom() const;
     const Rings&  rings(bool cross_residues = false, int all_size_threshold = 0,
         std::set<const Residue*>* ignore = nullptr) const;
@@ -80 +85 @@
 
     // change tracking
     ChangeTracker*  change_tracker() const;
-    void track_change(const std::string& reason) const {
+    void track_change(const std::string& reason) {
         change_tracker()->add_modified(this, reason);
+        this->set_changed_since_last_drawn(true);
     }
 
     // graphics related

src/core/atomic/atomstruct_cpp/Connection.h

@@ -106 +106 @@
     }
 
     // change tracking
-    virtual void  track_change(const std::string& reason) const = 0;
+    virtual void  track_change(const std::string& reason) = 0;
 
     // graphics related
     const Rgba&  color() const { return _rgba; }

src/core/atomic/atomstruct_cpp/CoordSet.cpp

@@ -130 +130 @@
 void
 CoordSet::set_bfactor(const Atom *a, float val)
 {
-    _bfactor_map.insert(std::pair<const Atom *, float>(a, val));
+    //_bfactor_map.insert(std::pair<const Atom *, float>(a, val));
+    _bfactor_map[a] = val;
 }
 
 void
 CoordSet::set_occupancy(const Atom *a, float val)
 {
-    _occupancy_map.insert(std::pair<const Atom *, float>(a, val));
+    //_occupancy_map.insert_or_assign(std::pair<const Atom *, float>(a, val));
+    _occupancy_map[a] = val;
 }
 
 }  // namespace atomstruct

src/core/atomic/atomstruct_cpp/PBGroup.h

@@ -76 +76 @@
 
     void _check_destroyed_atoms(PBGroup::Pseudobonds& pbonds, const std::set<void*>& destroyed);
     void delete_pbs_check(const std::set<Pseudobond*>& pbs) const;
+    bool _changed = false;
 public:
+    bool changed() const { return _changed; }
+    void set_changed(bool flag) { _changed = flag; }
     virtual void  clear() = 0;
     virtual const Rgba&  color() const { return _color; }
     virtual const std::string&  category() const { return _category; }

src/core/atomic/atomstruct_cpp/Pseudobond.h

@@ -60 +60 @@
         { return "Can't form pseudobond to itself"; }
     const char*  err_msg_not_end() const
         { return "Atom given to other_end() not in pseudobond!"; }
+    bool _changed = false;
 public:
+    bool changed() const { return _changed; }
+    void set_changed(bool flag) { _changed = flag; }
     ChangeTracker*  change_tracker() const;
     GraphicsContainer*  graphics_container() const;
     PBGroup*  group() const { return _group; }
@@ -76 +79 @@
     }
     void  session_restore(int version, int** ints, float** floats);
     void  session_save(int** ints, float** floats) const;
-    void  track_change(const std::string& reason) const {
+    void  track_change(const std::string& reason) {
         change_tracker()->add_modified(this, reason);
+        this->set_changed(true);
     }
 };
 

src/core/atomic/atomstruct_cpp/Structure.h

@@ -65 +65 @@
       COLOR_CHANGE = (1 << 1),
       SELECT_CHANGE = (1 << 2),
       RIBBON_CHANGE = (1 << 3),
+      ATOM_VIS_CHANGE = (1 << 4),
+      BOND_VIS_CHANGE = (1 << 5)
     };
 
     GraphicsContainer(): _gc_changes(0) {}
@@ -74 +76 @@
     virtual bool  get_gc_select() const { return _gc_changes & SELECT_CHANGE; }
     virtual bool  get_gc_shape() const { return _gc_changes & SHAPE_CHANGE; }
     virtual bool  get_gc_ribbon() const { return _gc_changes & RIBBON_CHANGE; }
+    virtual bool  get_gc_atom_vis() const { return _gc_changes & ATOM_VIS_CHANGE; }
+    virtual bool  get_gc_bond_vis() const {return _gc_changes & BOND_VIS_CHANGE; }
     virtual int   get_graphics_changes() const { return _gc_changes; }
     virtual void  set_gc_color() { set_graphics_change(COLOR_CHANGE); }
     virtual void  set_gc_select() { set_graphics_change(SELECT_CHANGE); }
     virtual void  set_gc_shape() { set_graphics_change(SHAPE_CHANGE); }
     virtual void  set_gc_ribbon() { set_graphics_change(RIBBON_CHANGE); }
+    virtual void  set_gc_atom_vis() { set_graphics_change(ATOM_VIS_CHANGE); }
+    virtual void  set_gc_bond_vis() { set_graphics_change(BOND_VIS_CHANGE); }
     virtual void  set_graphics_changes(int change) { _gc_changes = change; }
     virtual void  set_graphics_change(ChangeType type) { _gc_changes |= type; }
     virtual void  clear_graphics_change(ChangeType type) { _gc_changes &= ~type; }
@@ -184 +190 @@
     static int  SESSION_NUM_MISC(int version=CURRENT_SESSION_VERSION) {
         return version > 7 ? 3 : 4;
     }
-
 public:
+    
     Structure(PyObject* logger = nullptr);
     virtual  ~Structure();
 

src/core/atomic/molarray.py

@@ -342 +342 @@
         "Return list of 2-tuples of (structure, Atoms for that structure)."
         astruct = self.structures._pointers
         return [(us, self.filter(astruct==us._c_pointer.value)) for us in self.unique_structures]
+    
+    _changed = cvec_property('atom_changed', bool, doc='Changed since last redraw')
     chain_ids = cvec_property('atom_chain_id', string, read_only = True)
     colors = cvec_property('atom_color', uint8, 4,
         doc="Returns a :mod:`numpy` Nx4 array of uint8 RGBA values. Can be set "
@@ -611 +613 @@
     def __init__(self, bond_pointers = None):
         Collection.__init__(self, bond_pointers, molobject.Bond, Bonds)
 
+
+    _changed = cvec_property('bond_changed', bool, doc='Changed since last redraw')
+    '''
+    True if the bond or the position(s) of its atoms have been changed 
+    since the last time they were drawn.
+    Returns a :mod:`numpy` array of bool. Can be set with such an array
+    (or equivalent sequence), or with a single value.
+    '''
+
     atoms = cvec_property('bond_atoms', cptr, 2, astype = _atoms_pair, read_only = True)
     '''
     Returns a two-tuple of :class:`Atoms` objects.

src/core/atomic/molc.cpp

@@ -248 +248 @@
 // -------------------------------------------------------------------------
 // atom functions
 //
+
+
+extern "C" EXPORT void atom_changed(void *atoms, size_t n, npy_bool *flags)
+{
+    Atom **a = static_cast<Atom **>(atoms);
+    error_wrap_array_get(a, n, &Atom::changed_since_last_drawn, flags);
+}
+
+extern "C" EXPORT void set_atom_changed (void *atoms, size_t n, npy_bool *flags)
+{
+    Atom **a = static_cast<Atom **>(atoms);
+    error_wrap_array_set(a, n, &Atom::set_changed_since_last_drawn, flags);
+}
+    
+
 extern "C" EXPORT void atom_bfactor(void *atoms, size_t n, float32_t *bfactors)
 {
     Atom **a = static_cast<Atom **>(atoms);
@@ -1024 +1039 @@
 // -------------------------------------------------------------------------
 // bond functions
 //
+
+extern "C" EXPORT void bond_changed(void *bonds, size_t n, npy_bool *flags)
+{
+    Bond **b = static_cast<Bond **>(bonds);
+    error_wrap_array_get(b, n, &Bond::changed_since_last_drawn, flags);
+}
+
+extern "C" EXPORT void set_bond_changed (void *bonds, size_t n, npy_bool *flags)
+{
+    Bond **b = static_cast<Bond **>(bonds);
+    error_wrap_array_set(b, n, &Bond::set_changed_since_last_drawn, flags);
+}
+
+
 extern "C" EXPORT void bond_atoms(void *bonds, size_t n, pyobject_t *atoms)
 {
     Bond **b = static_cast<Bond **>(bonds);
@@ -1224 +1253 @@
 // -------------------------------------------------------------------------
 // pseudobond functions
 //
+
+extern "C" EXPORT void pseudobond_changed(void *pbonds, size_t n, npy_bool *flags)
+{
+    Pseudobond **b = static_cast<Pseudobond **>(pbonds);
+    error_wrap_array_get(b, n, &Pseudobond::changed, flags);
+}
+
+extern "C" EXPORT void set_pseudobond_changed (void *pbonds, size_t n, npy_bool *flags)
+{
+    Pseudobond **b = static_cast<Pseudobond **>(pbonds);
+    error_wrap_array_set(b, n, &Pseudobond::set_changed, flags);
+}
+
+
+
 extern "C" EXPORT void pseudobond_atoms(void *pbonds, size_t n, pyobject_t *atoms)
 {
     Pseudobond **b = static_cast<Pseudobond **>(pbonds);
@@ -1734 +1778 @@
 // -------------------------------------------------------------------------
 // residue functions
 //
+
+//~ extern "C" EXPORT void residue_changed(void *residues, size_t n, npy_bool *flags)
+//~ {
+    //~ Residue **r = static_cast<Residue **>(residues);
+    //~ error_wrap_array_get(r, n, &Residue::changed, flags);
+//~ }
+
+//~ extern "C" EXPORT void set_residue_changed (void *residues, size_t n, npy_bool *flags)
+//~ {
+    //~ Residue **r = static_cast<Residue **>(residues);
+    //~ error_wrap_array_set(r, n, &Residue::set_changed, flags);
+//~ }
+
+
 extern "C" EXPORT void residue_atoms(void *residues, size_t n, pyobject_t *atoms)
 {
     Residue **r = static_cast<Residue **>(residues);
@@ -3211 +3269 @@
 // -------------------------------------------------------------------------
 // structure functions
 //
+
+
 extern "C" EXPORT void set_structure_color(void *mol, uint8_t *rgba)
 {
     Structure *m = static_cast<Structure *>(mol);
@@ -3303 +3363 @@
     }
 }
 
+//~ extern "C" EXPORT void structure_visible_atoms_changed(void *mols, size_t n, npy_bool *changed)
+//~ {
+    //~ Structure **m = static_cast<Structure **>(mols);
+    //~ try {
+        //~ for (size_t i = 0; i != n; ++i) {
+            //~ *changed++ = m[i]->get_gc_atom_vis();
+        //~ }
+    //~ } catch (...) {
+        //~ molc_error();
+    //~ }
+//~ }
+
+//~ extern "C" EXPORT void set_structure_visible_atoms_changed(void *mols, size_t n, npy_bool *changed)
+//~ {
+    //~ Structure **m = static_cast<Structure **>(mols);
+    //~ try {
+        //~ for (size_t i = 0; i != n; ++i) {
+            //~ if (*changed++) {
+                //~ m[i]->set_gc_atom_vis();
+            //~ } else {
+                //~ m[i]->clear_graphics_change(Structure::ChangeType::ATOM_VIS_CHANGE);
+            //~ }
+        //~ }
+    //~ } catch (...) {
+        //~ molc_error();
+    //~ }
+//~ }
+
+extern "C" EXPORT void structure_visible_atoms(void *mols, size_t n, pyobject_t *atoms)
+{
+    Structure **m = static_cast<Structure **>(mols);
+    try {
+        for (size_t i = 0; i != n; ++i) {
+            const Structure::Atoms &a = m[i]->atoms();
+            for (size_t j = 0; j != a.size(); ++j) {
+                if ( a[j]->visible() ) 
+                    *atoms++ = a[j];
+            }
+        }
+    } catch (...) {
+        molc_error();
+    }
+}
+
+
 extern "C" EXPORT void structure_ball_scale(void *mols, size_t n, float32_t *bscales)
 {
     Structure **m = static_cast<Structure **>(mols);
@@ -3334 +3439 @@
     }
 }
 
+extern "C" EXPORT void structure_num_bonds_visible(void *mols, size_t n, size_t *nbonds)
+{
+    Structure **m = static_cast<Structure **>(mols);
+    try {
+        for (size_t i = 0; i != n; ++i)
+          {
+            const Structure::Bonds &bonds = m[i]->bonds();
+            int c = 0;
+            for (auto b: bonds)
+              if (b->shown())
+                c++;
+            nbonds[i] = c;
+          }
+    } catch (...) {
+        molc_error();
+    }
+}
+
+extern "C" EXPORT void structure_visible_bonds(void *mols, size_t n, pyobject_t *bonds)
+{
+    Structure **m = static_cast<Structure **>(mols);
+    try {
+        for (size_t i = 0; i != n; ++i) {
+            const Structure::Bonds &b = m[i]->bonds();
+            for (size_t j = 0; j != b.size(); ++j) {
+                if ( b[j]->shown() ) 
+                    *bonds++ = b[j];
+            }
+        }
+    } catch (...) {
+        molc_error();
+    }
+}
+
+//~ extern "C" EXPORT void structure_visible_bonds_changed(void *mols, size_t n, npy_bool *changed)
+//~ {
+    //~ Structure **m = static_cast<Structure **>(mols);
+    //~ try {
+        //~ for (size_t i = 0; i != n; ++i) {
+            //~ *changed++ = m[i]->get_gc_bond_vis();
+        //~ }
+    //~ } catch (...) {
+        //~ molc_error();
+    //~ }
+//~ }
+
+//~ extern "C" EXPORT void set_structure_visible_bonds_changed(void *mols, size_t n, npy_bool *changed)
+//~ {
+    //~ Structure **m = static_cast<Structure **>(mols);
+    //~ try {
+        //~ for (size_t i = 0; i != n; ++i) {
+            //~ if (*changed++) {
+                //~ m[i]->set_gc_bond_vis();
+            //~ } else {
+                //~ m[i]->clear_graphics_change(Structure::ChangeType::BOND_VIS_CHANGE);
+            //~ }
+        //~ }
+    //~ } catch (...) {
+        //~ molc_error();
+    //~ }
+//~ }
+
+
+
+
+
 extern "C" EXPORT void structure_num_residues(void *mols, size_t n, size_t *nres)
 {
     Structure **m = static_cast<Structure **>(mols);

src/core/atomic/molobject.py

@@ -125 +125 @@
 
     def atomspec(self):
         return self.residue.atomspec() + '@' + self.name
-
+    
+    _changed = c_property('atom_changed', bool, doc='Changed since last redraw')
     alt_loc = c_property('atom_alt_loc', byte, doc='Alternate location indicator')
     bfactor = c_property('atom_bfactor', float32, doc = "B-factor, floating point value.")
     bonds = c_property('atom_bonds', cptr, "num_bonds", astype=_bonds, read_only=True,
@@ -378 +379 @@
     def atomspec(self):
         return a1.atomspec() + a2.atomspec()
 
+
+    _changed = c_property('bond_changed', bool, doc='Changed since last redraw')
+
     atoms = c_property('bond_atoms', cptr, 2, astype = _atom_pair, read_only = True)
     '''Two-tuple of :py:class:`Atom` objects that are the bond end points.'''
     color = c_property('bond_color', uint8, 4)
@@ -612 +616 @@
     _COLOR_CHANGE = 0x2
     _SELECT_CHANGE = 0x4
     _RIBBON_CHANGE = 0x8
-    _ALL_CHANGE = 0xf
+    _VISIBLE_ATOMS_CHANGE = 0x10
+    _VISIBLE_BONDS_CHANGE = 0x20
+    _ALL_CHANGE = 0xff
     _graphics_changed = c_property('pseudobond_group_graphics_change', int32)
 
 
@@ -1463 +1469 @@
     '''Index of the active coordinate set.'''
     atoms = c_property('structure_atoms', cptr, 'num_atoms', astype = _atoms, read_only = True)
     ''':class:`.Atoms` collection containing all atoms of the structure.'''
+    _visible_atoms = c_property('structure_visible_atoms', cptr, 'num_atoms_visible', astype = _atoms, 
+                          read_only = True)
+    ''':class:`.Atoms` containing only the visible atoms of the structure. Read only.'''
     ball_scale = c_property('structure_ball_scale', float32,
         doc = "Scales sphere radius in ball-and-stick style.")
     bonds = c_property('structure_bonds', cptr, 'num_bonds', astype = _bonds, read_only = True)
     ''':class:`.Bonds` collection containing all bonds of the structure.'''
+    _visible_bonds = c_property('structure_visible_bonds', cptr, 'num_bonds_visible', astype = _bonds, 
+                          read_only = True)
+    ''':class:`.Bonds` containing only the visible bonds of the structure. Read only.'''
     chains = c_property('structure_chains', cptr, 'num_chains', astype = _chains, read_only = True)
     ''':class:`.Chains` collection containing all chains of the structure.'''
     coordset_ids = c_property('structure_coordset_ids', int32, 'num_coordsets', read_only = True)
@@ -1477 +1489 @@
     '''Structure has lower case chain ids. Boolean'''
     num_atoms = c_property('structure_num_atoms', size_t, read_only = True)
     '''Number of atoms in structure. Read only.'''
-    num_atoms_visible = c_property('structure_num_atoms_visible', size_t, read_only = True)
+    _num_atoms_visible = c_property('structure_num_atoms_visible', size_t, read_only = True)
     '''Number of visible atoms in structure. Read only.'''
     num_bonds = c_property('structure_num_bonds', size_t, read_only = True)
     '''Number of bonds in structure. Read only.'''
+    _num_bonds_visible = c_property('structure_num_bonds_visible', size_t, read_only = True)
+    '''Number of visible atoms in structure. Read only.'''
     num_coordsets = c_property('structure_num_coordsets', size_t, read_only = True)
     '''Number of coordinate sets in structure. Read only.'''
     num_chains = c_property('structure_num_chains', size_t, read_only = True)
@@ -1786 +1800 @@
     _COLOR_CHANGE = 0x2
     _SELECT_CHANGE = 0x4
     _RIBBON_CHANGE = 0x8
-    _ALL_CHANGE = 0xf
+    _VISIBLE_ATOMS_CHANGE = 0x10
+    _VISIBLE_BONDS_CHANGE = 0x20
+    _ALL_CHANGE = 0xff
     _graphics_changed = c_property('structure_graphics_change', int32)
 
 class ChangeTracker:

src/core/atomic/structure.py

@@ -54 +54 @@
         self._ribbon_t2r = {}         # ribbon triangles-to-residue map
         self._ribbon_r2t = {}         # ribbon residue-to-triangles map
         self._ribbon_tether = []      # ribbon tethers from ribbon to floating atoms
-
+        self.atoms.radii = self.atoms.default_radii  
+        
+        # Cache objects corresponding to currently visible entities, to
+        # avoid expensive look-ups on redraws.
+        self._cached_num_atoms_visible = self._num_atoms_visible
+        self._cached_visible_atoms = self._visible_atoms
+        self._cached_num_bonds_visible = self._num_bonds_visible
+        self._cached_visible_bonds = self._visible_bonds   
+        self._cached_visible_bond_atoms = self.visible_bonds.atoms
+     
         from . import molobject
         molobject.add_to_object_map(self)
 
@@ -64 +73 @@
                 ("save_teardown", "end save session")]:
             self._ses_handlers.append(t.add_handler(trig_name,
                     lambda *args, qual=ses_func: self._ses_call(qual)))
-
+        
         self._make_drawing()
 
     def __str__(self):
@@ -257 +266 @@
         from ..colors import most_common_color
         if ribbon_displays.any():
             return most_common_color(residues.filter(ribbon_displays).ribbon_colors)
-        atoms = self.atoms
-        shown = atoms.filter(atoms.displays)
+        shown = self.visible_atoms
+        #shown = atoms.filter(atoms.displays)
         if shown:
             return most_common_color(shown.colors)
-        return most_common_color(atoms.colors)
+        return most_common_color(self.atoms.colors)
     def _set_single_color(self, color):
         self.atoms.colors = color
         self.residues.ribbon_colors = color
@@ -269 +278 @@
 
     def _make_drawing(self):
         # Create graphics
-        self._update_atom_graphics()
-        self._update_bond_graphics()
-        for pbg in self.pbg_map.values():
-            pbg._update_graphics()
-        self._create_ribbon_graphics()
+        self._update_graphics_if_needed(force_recalc = True)
+        #~ self._update_atom_graphics()
+        #~ self._update_bond_graphics()
+        #~ for pbg in self.pbg_map.values():
+            #~ pbg._update_graphics()
+        #~ self._create_ribbon_graphics()
 
     @property
     def _level_of_detail(self):
         gu = structure_graphics_updater(self.session)
         return gu.level_of_detail
+        
+    @property
+    def num_atoms_visible(self):
+        '''
+        Number of atoms currently visible in this structure. Cached for
+        performance.
+        '''
+        if self._graphics_changed & self._VISIBLE_ATOMS_CHANGE:
+            self._cached_num_atoms_visible = self._num_atoms_visible
+        return self._cached_num_atoms_visible
+    
+    @property
+    def visible_atoms(self):
+        '''
+        All currently visible atoms in this structure. Cached
+        for performance.
+        '''
+        if self._graphics_changed & self._VISIBLE_ATOMS_CHANGE:
+            self._cached_visible_atoms = self._visible_atoms
+        return self._cached_visible_atoms
+    
+    @property
+    def num_bonds_visible(self):
+        '''
+        Number of bonds currently visible in this structure. Cached
+        for performance.
+        '''
+        if self._graphics_changed & self._VISIBLE_BONDS_CHANGE:
+            self._cached_num_bonds_visible = self._num_bonds_visible
+        return self._cached_num_bonds_visible
 
+    @property
+    def visible_bonds(self):
+        '''
+        All currently visible bonds in this structure. Cached for 
+        performance.
+        '''
+        if self._graphics_changed & self._VISIBLE_BONDS_CHANGE:
+            self._cached_visible_bonds = self._visible_bonds
+        return self._cached_visible_bonds
+    
+    @property
+    def visible_bond_atoms(self):
+        '''
+        A tuple of :class:`Atoms` giving all atoms involved in 
+        currently visible bonds. Equivalent to self.visible_bonds.atoms,
+        but cached for performance.
+        '''
+        if self._graphics_changed & self._VISIBLE_BONDS_CHANGE:
+            self._cached_visible_bond_atoms = self.visible_bonds.atoms
+        return self._cached_visible_bond_atoms
+        
     def new_atoms(self):
         # TODO: Handle instead with a C++ notification that atoms added or deleted
         self._atom_bounds_needs_update = True
 
-    def _update_graphics_if_needed(self, *_):
+    def _update_graphics_if_needed(self, *_, force_recalc = False):
         gc = self._graphics_changed
-        if gc == 0:
+        if gc == 0 and not force_recalc:
             return
-
+        
+        
         if gc & self._RIBBON_CHANGE:
             self._create_ribbon_graphics()
             # Displaying ribbon can set backbone atom hide bits producing shape change.
             gc |= self._graphics_changed
 
         # Update graphics
-        self._graphics_changed = 0
         s = (gc & self._SHAPE_CHANGE)
         if gc & (self._COLOR_CHANGE | self._RIBBON_CHANGE) or s:
             self._update_ribbon_tethers()
-        self._update_graphics(gc)
+        self._update_graphics(gc, force_recalc = force_recalc)
+        self._graphics_changed = 0
         self.redraw_needed(shape_changed = s,
                            selection_changed = (gc & self._SELECT_CHANGE))
         if s:
@@ -313 +375 @@
                 if isinstance(surf, MolecularSurface):
                     surf.update_selection()
 
-    def _update_graphics(self, changes = StructureData._ALL_CHANGE):
-        self._update_atom_graphics(changes)
-        self._update_bond_graphics(changes)
+    def _update_graphics(self, changes = StructureData._ALL_CHANGE, force_recalc = False):
+        import numpy
+        atoms = self.visible_atoms
+        bonds = self.visible_bonds
+        bond_atoms = self.visible_bond_atoms
+        
+        force_atom_recalc = False
+        force_bond_recalc = False
+        
+        if force_recalc:
+            force_atom_recalc = True
+            force_bond_recalc = True
+        
+        else:
+            if changes & self._VISIBLE_ATOMS_CHANGE:
+                force_atom_recalc = True
+                self._graphics_changed ^= self._VISIBLE_ATOMS_CHANGE
+            
+            if changes & self._VISIBLE_BONDS_CHANGE:
+                force_bond_recalc = True
+                self._graphics_changed ^= self._VISIBLE_BONDS_CHANGE
+        
+        
+        if force_atom_recalc:
+            achanged = numpy.array([True]*len(atoms))
+            ch_atoms = atoms
+        else:
+            achanged = atoms._changed
+            ch_atoms = atoms[achanged]
+        
+        if force_bond_recalc:
+            bchanged = numpy.array([True]*len(bonds))
+            ch_bonds = bonds
+            ch_bond_atoms = bond_atoms
+        else:
+            bchanged = bonds._changed
+            ch_bonds = bonds[bchanged]
+            ch_bond_atoms = (ba[bchanged] for ba in bond_atoms)
+            
+        
+        half_bond_change_filter = numpy.concatenate((bchanged,bchanged))
+        
+        self._update_atom_graphics( ch_atoms, achanged, changes = changes, 
+                                    force_recalc = force_atom_recalc)
+        self._update_bond_graphics(ch_bonds, ch_bond_atoms, 
+                                    half_bond_change_filter, 
+                                    changes = changes, 
+                                    force_recalc = force_bond_recalc)
         for pbg in self.pbg_map.values():
             pbg._update_graphics(changes)
         self._update_ribbon_graphics()
+        self.redraw_needed()
 
-    def _update_atom_graphics(self, changes = StructureData._ALL_CHANGE):
-        atoms = self.atoms  # optimzation, avoid making new numpy array from C++
-        avis = atoms.visibles
+    def _update_atom_graphics(self, atoms, ch_filter, changes = StructureData._ALL_CHANGE, force_recalc = False):
+        import numpy
         p = self._atoms_drawing
+        from numpy import empty, float32, multiply
+        #ch_indices = numpy.where(ch_filter)[0]
+        
         if p is None:
-            if avis.sum() == 0:
-                return
+            #avis = atoms.visibles
+            #if avis.sum() == 0:
+            #    return
             self._atoms_drawing = p = self.new_drawing('atoms')
             self._atoms_drawing.custom_x3d = self._custom_atom_x3d
             # Update level of detail of spheres
             self._level_of_detail.set_atom_sphere_geometry(p)
+    
+        if force_recalc:
+            n = len(atoms)
+            xyzr = empty((n, 4), float32)
+            xyzr[:, :3] = atoms.coords
+            xyzr[:, 3] = self._atom_display_radii(atoms)
 
+            from ..geometry import Places
+            p.colors = atoms.colors
+            p.positions = Places(shift_and_scale=xyzr)
+            p.display_positions = numpy.array([True]*len(atoms))
+            p.selected_positions = atoms.selected if atoms.num_selected > 0 else None
+            atoms._changed = False
+            return
+        
+        
         if changes & self._SHAPE_CHANGE:
             # Set instanced sphere center position and radius
             n = len(atoms)
-            from numpy import empty, float32, multiply
             xyzr = empty((n, 4), float32)
             xyzr[:, :3] = atoms.coords
             xyzr[:, 3] = self._atom_display_radii(atoms)
-
+            
             from ..geometry import Places
-            p.positions = Places(shift_and_scale=xyzr)
-            p.display_positions = avis
+            p.positions.set_shift_and_scale(ch_filter, xyzr)
+            # So the drawing knows it needs to redraw positions
+            p.positions_changed()
+            #p.display_positions = avis
+            
 
-        if changes & (self._COLOR_CHANGE | self._SHAPE_CHANGE):
+        if changes & (self._COLOR_CHANGE): # | self._SHAPE_CHANGE):
             # Set atom colors
-            p.colors = atoms.colors
+            p.set_colors(atoms.colors, ch_filter)
 
-        if changes & (self._SELECT_CHANGE | self._SHAPE_CHANGE):
+        if changes & (self._SELECT_CHANGE ): #| self._SHAPE_CHANGE):
             # Set selected
-            p.selected_positions = atoms.selected if atoms.num_selected > 0 else None
+            vatoms = self.visible_atoms
+            p.selected_positions = vatoms.selected if vatoms.num_selected > 0 else None
+        atoms._changed = False
 
     def _custom_atom_x3d(self, stream, x3d_scene, indent, place):
         from numpy import empty, float32
         p = self._atoms_drawing
-        atoms = self.atoms
+        atoms = self.visible_atoms
         radii = self._atom_display_radii(atoms)
         tab = ' ' * indent
         for v, xyz, r, c in zip(p.display_positions, atoms.coords, radii, p.colors):
@@ -371 +501 @@
     def _atom_display_radii(self, atoms):
         return atoms.display_radii(self.ball_scale, self.bond_radius)
     
-    def _update_bond_graphics(self, changes = StructureData._ALL_CHANGE):
-        bonds = self.bonds  # optimzation, avoid making new numpy array from C++
+    def _update_bond_graphics(self, bonds, bond_atoms, 
+                                ch_filter, changes = StructureData._ALL_CHANGE, 
+                                force_recalc = False):
+        import numpy
+        #ch_indices = numpy.where(ch_filter)[0]
         p = self._bonds_drawing
         if p is None:
-            if bonds.num_shown == 0:
-                return
+            #if bonds.num_shown == 0:
+            #    return
             self._bonds_drawing = p = self.new_drawing('bonds')
             self._bonds_drawing.custom_x3d = self._custom_bond_x3d
             # Update level of detail of cylinders
             self._level_of_detail.set_bond_cylinder_geometry(p)
-
-        if changes & (self._SHAPE_CHANGE | self._SELECT_CHANGE):
-            bond_atoms = bonds.atoms
-        if changes & self._SHAPE_CHANGE:
+        
+        if force_recalc:
+            #bond_atoms = bonds.atoms
             ba1, ba2 = bond_atoms
+            p.colors = bonds.half_colors
             p.positions = _halfbond_cylinder_placements(ba1.coords, ba2.coords, bonds.radii)
             p.display_positions = _shown_bond_cylinders(bonds)
-        if changes & (self._COLOR_CHANGE | self._SHAPE_CHANGE):
-            p.colors = c = bonds.half_colors
-        if changes & (self._SELECT_CHANGE | self._SHAPE_CHANGE):
             p.selected_positions = _selected_bond_cylinders(bond_atoms)
+            bonds._changed = False
+            return
+        
+        if changes & self._SHAPE_CHANGE:
+            ba1, ba2 = bond_atoms
+            p.positions.set_opengl_matrices(ch_filter, 
+                _halfbond_cylinder_placements(ba1.coords, ba2.coords, bonds.radii)._opengl_array)
+            p.positions_changed()
+            #p.display_positions = ch_filter #_shown_bond_cylinders(bonds)
+        if changes & (self._COLOR_CHANGE): # | self._SHAPE_CHANGE):
+            p.set_colors(bonds.half_colors, ch_filter)
+        if changes & (self._SELECT_CHANGE):# | self._SHAPE_CHANGE):
+            vbonds = self.visible_bonds
+            p.selected_positions = _selected_bond_cylinders(vbonds.atoms)
+        bonds._changed = False
 
     def _custom_bond_x3d(self, stream, x3d_scene, indent, place):
         from numpy import empty, float32
         p = self._bonds_drawing
-        bonds = self.bonds
+        bonds = self.visible_bonds
         ba1, ba2 = bonds.atoms
         cyl_info = _halfbond_cylinder_x3d(ba1.coords, ba2.coords, bonds.radii)
         tab = ' ' * indent
@@ -1375 +1520 @@
 
     def _update_ribbon_graphics(self):
         # Set selected ribbons in graphics
+        if not self.ribbon_display_count:
+            return
         from .molarray import Residues
-        atoms = self.atoms
+        atoms = self.visible_atoms
         if atoms.num_selected > 0:
             residues = atoms.filter(atoms.selected).unique_residues
             from numpy import array
@@ -1423 +1570 @@
                 p.selected_triangles_mask = m
 
     def _update_ribbon_tethers(self):
+        if not self.ribbon_display_count:
+            return
         from numpy import around
         for all_atoms, tp, xyz1, tether_atoms, shape, scale in self._ribbon_tether:
             all_atoms.update_ribbon_visibility()
@@ -1450 +1599 @@
     def _atom_bounds(self):
         if not self._atom_bounds_needs_update:
             return self._cached_atom_bounds
-        a = self.atoms
-        adisp = a[a.displays]
-        xyz = adisp.coords
-        radii = adisp.radii
+        a = self.visible_atoms
+        xyz = a.coords
+        radii = a.display_radii(self.ball_scale, self.bond_radius)
         # TODO: Currently 40% of time is taken in getting atom radii because
         #       they are recomputed from element and bonds every time. Ticket #789.
         #       If that was fixed by using a precomputed radius, then it would make
@@ -1531 +1679 @@
 
         if not dp is None:
             anum = dp.nonzero()[0][anum]    # Remap index to include undisplayed positions
-        atom = self.atoms[anum]
+        atom = self.visible_atoms[anum]
 
         # Create pick object
         s = PickedAtom(atom, fmin)
@@ -1541 +1689 @@
     def _bond_first_intercept(self, mxyz1, mxyz2):
         d = self._bonds_drawing
         if d and d.display:
-            b,f = _bond_intercept(self.bonds, mxyz1, mxyz2)
+            b,f = _bond_intercept(self.visible_bonds, mxyz1, mxyz2)
             if b:
                 return PickedBond(b, f)
         return None
@@ -1603 +1751 @@
         if pmask.sum() == 0:
             return []
 
-        a = self.atoms
+        a = self.visible_atoms
         if not dp is None:
             anum = dp.nonzero()[0][pmask]    # Remap index to include undisplayed positions
             atoms = a.filter(anum)

src/core/geometry/place.py

@@ -423 +423 @@
     '''
     def __init__(self, places=None, place_array=None, shift_and_scale=None,
                  opengl_array=None):
+        import numpy
         if (place_array is not None or shift_and_scale is not None
                 or opengl_array is not None):
             pl = None
@@ -508 +509 @@
     def __setitem__(self, i, p):
         self._place_list[i] = p
 
+    def set_shift_and_scale(self, indices_or_mask, shift_and_scale_array):
+        self._shift_and_scale[indices_or_mask] = shift_and_scale_array
+    
+    def set_opengl_matrices(self, indices_or_mask, opengl_array):
+        self._opengl_array[indices_or_mask] = opengl_array
+    
     def __len__(self):
         if self._place_list is not None:
             n = len(self._place_list)

src/core/graphics/drawing.py

@@ -466 +466 @@
     def get_colors(self):
         return self._colors
 
-    def set_colors(self, rgba):
+    def set_colors(self, rgba, indices_or_mask = None):
         from numpy import ndarray, array, uint8
         c = rgba if isinstance(rgba, ndarray) else array(rgba, uint8)
-        self._colors = c
+        if indices_or_mask is None:
+            self._colors = c
+        else:
+            self._colors[indices_or_mask] = c
+            self._attribute_changes.add('_colors')
         self._opaque_color_count = opaque_count(c)
-        self.redraw_needed()
 
     colors = property(get_colors, set_colors)
     '''Color for each position used when per-vertex coloring is not