add continuous highlighting

Author: greglandrum

Code/GraphMol/MolDraw2D/MolDraw2D.cpp

@@ -48,6 +48,70 @@ namespace RDKit {
     }
     drawMolecule(mol,highlight_atoms,&highlight_bonds,highlight_atom_map);
   }
+
+  void MolDraw2D::doContinuousHighlighting( const ROMol &mol ,
+                                            const vector<int> *highlight_atoms ,
+                                            const vector<int> *highlight_bonds ,
+                                            const map<int,DrawColour> *highlight_atom_map,
+                                            const map<int,DrawColour> *highlight_bond_map ) {
+    int orig_lw=lineWidth();
+    bool orig_fp=fillPolys();
+    ROMol::VERTEX_ITER this_at , end_at;
+    if(highlight_bonds){
+      boost::tie( this_at , end_at ) = mol.getVertices();
+      while( this_at != end_at ) {
+        int this_idx = mol[*this_at]->getIdx();
+        ROMol::OEDGE_ITER nbr , end_nbr;
+        boost::tie( nbr , end_nbr ) = mol.getAtomBonds( mol[*this_at].get() );
+        while( nbr != end_nbr ) {
+          const BOND_SPTR bond = mol[*nbr];
+          ++nbr;
+          int nbr_idx = bond->getOtherAtomIdx( this_idx );
+          if( nbr_idx < static_cast<int>( at_cds_.size() ) && nbr_idx > this_idx ) {
+            if(std::find(highlight_bonds->begin(),highlight_bonds->end(),bond->getIdx()) != highlight_bonds->end()){
+              DrawColour col=drawOptions().highlightColour;
+              if(highlight_bond_map &&
+                 highlight_bond_map->find(bond->getIdx())!=highlight_bond_map->end()){
+                col = highlight_bond_map->find(bond->getIdx())->second;
+              }
+              setLineWidth(orig_lw*8);
+              pair<float,float> at1_cds = at_cds_[this_idx];
+              pair<float,float> at2_cds = at_cds_[nbr_idx];
+              drawLine( at1_cds , at2_cds , col , col);
+            }
+          }
+        }
+        ++this_at;
+      }
+    }
+    if(highlight_atoms){
+      boost::tie( this_at , end_at ) = mol.getVertices();
+      while( this_at != end_at ) {
+        int this_idx = mol[*this_at]->getIdx();
+        if(std::find(highlight_atoms->begin(),highlight_atoms->end(),this_idx) != highlight_atoms->end()){
+          DrawColour col=drawOptions().highlightColour;
+          if(highlight_atom_map &&
+             highlight_atom_map->find(this_idx)!=highlight_atom_map->end()){
+            col = highlight_atom_map->find(this_idx)->second;
+          }
+          std::pair<double,double> p1=at_cds_[this_idx];
+          std::pair<double,double> p2=at_cds_[this_idx];
+          p1.first -= 0.4;
+          p1.second -= 0.4;
+          p2.first += 0.4;
+          p2.second += 0.4;
+          setColour(col);
+          setFillPolys(true);
+          setLineWidth(1);
+          drawEllipse(p1,p2);
+        }
+        ++this_at;
+      }
+    }
+    setLineWidth(orig_lw);
+    setFillPolys(orig_fp);
+  }
+
   void MolDraw2D::drawMolecule( const ROMol &mol ,
                                 const vector<int> *highlight_atoms ,
                                 const vector<int> *highlight_bonds ,
@@ -59,7 +123,14 @@ namespace RDKit {
     calculateScale();
     setFontSize( font_size_ );
 
-    if(drawOptions().circleAtoms && highlight_atoms){
+    if(drawOptions().continuousHighlight){
+      // if we're doing continuous highlighting, start by drawing the highlights
+      doContinuousHighlighting(mol,highlight_atoms,highlight_bonds,
+                               highlight_atom_map,highlight_bond_map);
+      // at this point we shouldn't be doing any more higlighting, so blow out those variables:
+      highlight_bonds=NULL;
+      highlight_atoms=NULL;
+    } else if(drawOptions().circleAtoms && highlight_atoms){
       ROMol::VERTEX_ITER this_at , end_at;
       boost::tie( this_at , end_at ) = mol.getVertices();
       setFillPolys(false);
@@ -414,7 +485,7 @@ namespace RDKit {
        std::find(highlight_bonds->begin(),highlight_bonds->end(),bond->getIdx()) != highlight_bonds->end()){
       highlight_bond=true;
     }
-    
+
     DrawColour col1,col2;
     int orig_lw=lineWidth();
     if( !highlight_bond ){
@@ -427,7 +498,11 @@ namespace RDKit {
       } else {
         col1 = col2 = drawOptions().highlightColour;
       }
-      setLineWidth(orig_lw*2);
+      if( drawOptions().continuousHighlight ){
+        setLineWidth(orig_lw*8);
+      } else {
+        setLineWidth(orig_lw*2);
+      }
     }
 
 

Code/GraphMol/MolDraw2D/MolDraw2D.h

@@ -40,12 +40,14 @@ namespace RDKit {
     bool circleAtoms;           // draws circles under highlighted atoms
     DrawColour highlightColour; // default highlight color
     std::map<int,std::string> *atomLabels; // replacement labels for atoms
+    bool continuousHighlight;   // highlight by drawing an outline *underneath* the molecule
 
     MolDrawOptions() :
       dummiesAreAttachments(false),
       circleAtoms(true),
       highlightColour(1,0,0),
-      atomLabels(NULL)
+      atomLabels(NULL),
+      continuousHighlight(false)
     {};
   };
 
@@ -207,6 +209,13 @@ namespace RDKit {
     // adds LaTeX-like annotation for super- and sub-script.
     std::pair<std::string,OrientType> getAtomSymbolAndOrientation( const Atom &atom ,
                                                                    const std::pair<float,float> &nbr_sum );
+
+    virtual void doContinuousHighlighting( const ROMol &mol ,
+                                           const std::vector<int> *highlight_atoms,
+                                           const std::vector<int> *highlight_bonds,
+                                           const std::map<int,DrawColour> *highlight_atom_map,
+                                           const std::map<int,DrawColour> *highlight_bond_map );
+
   };
 
 }

Code/GraphMol/MolDraw2D/test1.cpp

@@ -281,6 +281,48 @@ void test3(){
     }
     delete m;
   }
+  {
+    std::string smiles="Cc1c(C(=O)NCCO)[n+](=O)c2ccccc2n1[O-]";
+    std::string nameBase="test3_4";
+    ROMol *m = SmilesToMol(smiles);
+    TEST_ASSERT(m);
+    RDDepict::compute2DCoords(*m);
+    WedgeMolBonds(*m,&(m->getConformer()));
+    static const int ha[] = {11,12,13,14,15,16,3};
+    std::vector<int> highlight_atoms(ha, ha+sizeof(ha)/sizeof(int));
+    std::map<int,DrawColour> highlight_colors;
+    highlight_colors[12]=DrawColour(.5,.5,1);
+    highlight_colors[13]=DrawColour(.5,1,.5);
+    MolDrawOptions options;
+    options.circleAtoms=true;
+    options.highlightColour=DrawColour(1,.5,.5);
+    options.continuousHighlight=true;
+    
+#ifdef RDK_CAIRO_BUILD
+    {
+      cairo_surface_t *surface =
+        cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300);
+      cairo_t *cr = cairo_create (surface);
+
+      MolDraw2DCairo drawer(300,300,cr);
+      drawer.drawOptions() = options;
+      drawer.drawMolecule(*m,&highlight_atoms,&highlight_colors);
+      drawer.finishDrawing();
+      cairo_destroy (cr);
+      cairo_surface_write_to_png (surface, (nameBase+".png").c_str());
+      cairo_surface_destroy (surface);
+    }
+#endif    
+    {
+      std::ofstream outs((nameBase+".svg").c_str());
+      MolDraw2DSVG drawer(300,300,outs);
+      drawer.drawOptions() = options;
+      drawer.drawMolecule(*m,&highlight_atoms,&highlight_colors);
+      drawer.finishDrawing();
+      outs.flush();
+    }
+    delete m;
+  }
   std::cout << " Done" << std::endl;
 }