Subversion Repositories wimsdev

Rev

Rev 7308 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /*    Sketch Elements: Chemistry molecular diagram drawing tool.
  2.    
  3.     (c) 2008 Dr. Alex M. Clark
  4.    
  5.     Released as GNUware, under the Gnu Public License (GPL)
  6.    
  7.     See www.gnu.org for details.
  8. */
  9.  
  10. package WIMSchem;
  11.  
  12. import java.lang.*;
  13. import java.text.*;
  14. import java.util.*;
  15. import java.awt.geom.*;
  16.  
  17. /*
  18.     Given an input molecule, and pseudo-pixel resolution, and a way to measure text, this class provides the necessary
  19.     arrangements which precede the actual drawing of the molecule.
  20. */
  21.  
  22. public class ArrangeMolecule
  23. {
  24.     private Molecule mol;
  25.     private double scale; // pixels-per-Angstrom, or similar
  26.     private ArrangeMeasurement measure;
  27.  
  28.     public static final int SHOW_ELEMENTS=0;
  29.     public static final int SHOW_ALL_ELEMENTS=1;
  30.     public static final int SHOW_INDEXES=2;
  31.     public static final int SHOW_RINGID=3;
  32.     public static final int SHOW_PRIORITY=4;
  33.     public static final int SHOW_MAPNUM=5;
  34.    
  35.     private int elementMode; // one of SHOW_* above
  36.     private boolean showHydrogens; // if false, H's will never be shown
  37.     private double fontSize; // font size for main features, e.g. elements
  38.     private double lineSize; // width of most lines, such as bonds
  39.     private double bondSep; // size of bond separation between non-single bonds
  40.     private boolean devRounding; // if true, sometimes rounds to "pixel" boundaries to improve rendering
  41.     private boolean annotRS=false,annotEZ=false; // optional extra annotations
  42.     class APoint
  43.     {
  44.         int anum; // corresponds to molecule atom index
  45.         String text; // the primary label, or null if invisible
  46.         double fsz; // font size for label
  47.         boolean bold;
  48.         int col;
  49.         double cx,cy,rw,rh; // centre and ovaloid radius for label shape; rw,rh==0 if no label
  50.     }
  51.    
  52.     public static final int BLINE_NORMAL=1; // a line segment; may be single bond, part of a multiple bond, or dissected bond
  53.     public static final int BLINE_INCLINED=2; // an up-wedge bond
  54.     public static final int BLINE_DECLINED=3; // a down-wedge bond
  55.     public static final int BLINE_UNKNOWN=4; // a squiggly bond
  56.     public static final int BLINE_DOTTED=5; // dotted line
  57.    
  58.     class BLine
  59.     {
  60.         int bnum; // corresponds to molecule bond index
  61.         int type; // one of BLINE_*
  62.         double x1,y1,x2,y2;
  63.         double size;
  64.         int col;
  65.        
  66.         BLine() {}
  67.         BLine(int bnum,int type,double x1,double y1,double x2,double y2,double size,int col)
  68.         {
  69.             this.bnum=bnum;
  70.             this.type=type;
  71.             this.x1=x1;
  72.             this.y1=y1;
  73.             this.x2=x2;
  74.             this.y2=y2;
  75.             this.size=size;
  76.             this.col=col;
  77.         }
  78.     }
  79.    
  80.     private ArrayList<APoint> points=new ArrayList<APoint>();
  81.     private ArrayList<BLine> lines=new ArrayList<BLine>();
  82.    
  83.     // constructor: parameters are options which have no reasonable defaults
  84.    
  85.     public ArrangeMolecule(Molecule mol,ArrangeMeasurement measure)
  86.     {
  87.         this.mol=mol;
  88.         this.measure=measure;
  89.        
  90.         scale=measure.scale();
  91.         elementMode=SHOW_ELEMENTS;
  92.         showHydrogens=true;
  93.         fontSize=0.6*scale;
  94.         lineSize=0.075*scale;
  95.         bondSep=0.20*scale;
  96.         devRounding=true;
  97.     }
  98.    
  99.     // methods for using non-default display settings
  100.    
  101.     public void setShowHydrogens(boolean v) {showHydrogens=v;}
  102.     public void setElementMode(int v) {elementMode=v;}
  103.     public void setFontSizeAng(double v) {fontSize=v*scale;}
  104.     public void setFontSizeDev(double v) {fontSize=v;}
  105.     public void setLineSizeAng(double v) {lineSize=v*scale;}
  106.     public void setDevRounding(boolean v) {devRounding=v;}
  107.     public void setAnnotRS(boolean v) {annotRS=v;}
  108.     public void setAnnotEZ(boolean v) {annotEZ=v;}
  109.    
  110.     public boolean getShowHydrogens() {return showHydrogens;}
  111.     public int getElementMode() {return elementMode;}
  112.     public double getFontSizeDev() {return fontSize;}
  113.     public double getLineSizeDev() {return lineSize;}
  114.     public boolean getDevRounding() {return devRounding;}
  115.     public boolean getAnnotRS() {return annotRS;}
  116.     public boolean getAnnotEZ() {return annotEZ;}
  117.  
  118.     // the action method: call this before accessing any of the resultant data
  119.     public void arrange()
  120.     {
  121.         // fill in each of the atom centres
  122.         if( MainApplet.viewC ){elementMode = 1;}
  123.         if( MainApplet.viewH ){ showHydrogens = true;}
  124.         for (int n=1;n<=mol.numAtoms();n++)
  125.         {
  126.             APoint a=new APoint();
  127.             a.anum=n;
  128.             a.fsz=fontSize;
  129.             a.bold=mol.atomMapNum(n)>0;
  130.             a.col=0x000000;
  131.             a.cx=measure.angToX(mol.atomX(n));
  132.             a.cy=measure.angToY(mol.atomY(n));
  133.             a.rw=a.rh=0;
  134.            
  135.             if (devRounding)
  136.             {
  137.                 a.cx=Math.round(a.cx);
  138.                 a.cy=Math.round(a.cy);
  139.             }
  140.             // decide whether this atom is to have a label
  141.             switch(elementMode){
  142.              case SHOW_ELEMENTS: a.text=mol.atomExplicit(n) ? mol.atomElement(n) : null; break;
  143.              case SHOW_ALL_ELEMENTS: a.text=mol.atomElement(n); break;
  144.              case SHOW_INDEXES: a.text=String.valueOf(n);break;
  145.              case SHOW_RINGID: a.text=String.valueOf(mol.atomRingBlock(n));break;
  146.              case SHOW_PRIORITY: a.text=String.valueOf(mol.atomPriority(n));break;
  147.              case SHOW_MAPNUM: a.text=mol.atomMapNum(n)>0 ? String.valueOf(mol.atomMapNum(n)) : "";break;
  148.              default: a.text="?";break;
  149.             }
  150.             // if it has a label, then how big
  151.             if (a.text!=null)
  152.             {
  153.                 double[] wad=measure.measureText(a.text,a.fsz);
  154.                 a.rw=0.5*wad[0];
  155.                 a.rh=0.5*wad[1];
  156.             }
  157.  
  158.             points.add(a);
  159.         }
  160.        
  161.         // resolve the bonds which can be analyzed immediately
  162.         boolean[] bdbl=new boolean[mol.numBonds()]; // set to true if bond is awaiting a double bond assignment
  163.         for (int n=1;n<=mol.numBonds();n++)
  164.         {
  165.             bdbl[n-1]=mol.bondOrder(n)==2;
  166.            
  167.             double x1=pointCX(mol.bondFrom(n)-1),y1=pointCY(mol.bondFrom(n)-1);
  168.             double x2=pointCX(mol.bondTo(n)-1),y2=pointCY(mol.bondTo(n)-1);
  169.            
  170.             // for non-double bonds, can add the constituents right away
  171.             if (mol.bondOrder(n)!=2)
  172.             {
  173.                 double[] xy1=backOffAtom(mol.bondFrom(n)-1,x1,y1,x2,y2);
  174.                 double[] xy2=backOffAtom(mol.bondTo(n)-1,x2,y2,x1,y1);
  175.                 double sz=lineSize;
  176.                 if (mol.atomMapNum(mol.bondFrom(n))>0 && mol.atomMapNum(mol.bondTo(n))>0) sz*=5.0/3;
  177.  
  178.                 int ltype=BLINE_NORMAL;
  179.                 if (mol.bondType(n)==Molecule.BONDTYPE_INCLINED) ltype=BLINE_INCLINED;
  180.                 else if (mol.bondType(n)==Molecule.BONDTYPE_DECLINED) ltype=BLINE_DECLINED;
  181.                 else if (mol.bondType(n)==Molecule.BONDTYPE_UNKNOWN) ltype=BLINE_UNKNOWN;
  182.                 else if (mol.bondOrder(n)<=0) ltype=BLINE_DOTTED;
  183.  
  184.                 int bo=mol.bondOrder(n);
  185.  
  186.                 // for dotted lines, back off intersections if non-terminal
  187.                 if (bo==0)
  188.                 {
  189.                     double dx=xy2[0]-xy1[0],dy=xy2[1]-xy1[1],d=Math.sqrt(dx*dx+dy*dy);
  190.                     double ox=dx/d*bondSep,oy=dy/d*bondSep;
  191.                     if (mol.atomAdjCount(mol.bondFrom(n))>1) {xy1[0]+=ox; xy1[1]+=oy;}
  192.                     if (mol.atomAdjCount(mol.bondTo(n))>1) {xy2[0]-=ox; xy2[1]-=oy;}
  193.                 }
  194.  
  195.                 // add one, or several lines
  196.                 if (bo<=1 || mol.bondType(n)!=Molecule.BONDTYPE_NORMAL)
  197.                 {
  198.                     // just one line
  199.                     lines.add(new BLine(n,ltype,xy1[0],xy1[1],xy2[0],xy2[1],sz,0x000000));
  200.                 }
  201.                 else
  202.                 {
  203.                     double[] oxy=orthogonalDelta(xy1[0],xy1[1],xy2[0],xy2[1],bondSep);
  204.                     double v=-0.5*(bo-1);
  205.                     for (int i=0;i<bo;i++,v++)
  206.                     {
  207.                         lines.add(new BLine(n,BLINE_NORMAL,xy1[0]+v*oxy[0],xy1[1]+v*oxy[1],xy2[0]+v*oxy[0],xy2[1]+v*oxy[1],sz,0x000000));
  208.                     }
  209.                 }
  210.             }
  211.         }
  212.        
  213.         // process double bonds in rings
  214.         int[][] rings=orderedRingList();
  215.         for (int i=0;i<rings.length;i++)
  216.         {
  217.             for (int j=0;j<rings[i].length;j++)
  218.             {
  219.                 int k=mol.findBond(rings[i][j],rings[i][j<rings[i].length-1 ? j+1 : 0]);
  220.                 if (bdbl[k-1])
  221.                 {
  222.                     processDoubleBond(k,rings[i]);
  223.                     bdbl[k-1]=false;
  224.                 }
  225.             }
  226.         }
  227.        
  228.         // process all remaining double bonds
  229.         for (int i=1;i<=mol.numBonds();i++) if (bdbl[i-1]) processDoubleBond(i,priorityDoubleSubstit(i));
  230.        
  231.         // place hydrogen labels as explicit "atom centres"
  232.         int[] hcount=new int[mol.numAtoms()];
  233.         for (int n=1;n<=mol.numAtoms();n++) hcount[n-1]=pointText(n-1)==null || !showHydrogens ? 0 : mol.atomHydrogens(n);
  234.         for (int n=0;n<mol.numAtoms();n++) if (hcount[n]>0)
  235.         {
  236.             if (quadrantOpen(n,1,0) && placeHydrogen(n,hcount[n],1,0)) {hcount[n]=0; continue;}
  237.             if (quadrantOpen(n,-1,0) && placeHydrogen(n,hcount[n],-1,0)) {hcount[n]=0; continue;}
  238.             if (quadrantOpen(n,0,1) && placeHydrogen(n,hcount[n],0,1)) {hcount[n]=0; continue;}
  239.             if (quadrantOpen(n,0,-1) && placeHydrogen(n,hcount[n],0,-1)) {hcount[n]=0; continue;}
  240.         }
  241.         for (int n=0;n<mol.numAtoms();n++) if (hcount[n]>0 && placeHydrogen(n,hcount[n],1,0)) hcount[n]=0;
  242.         for (int n=0;n<mol.numAtoms();n++) if (hcount[n]>0 && placeHydrogen(n,hcount[n],-1,0)) hcount[n]=0;
  243.         for (int n=0;n<mol.numAtoms();n++) if (hcount[n]>0 && placeHydrogen(n,hcount[n],0,1)) hcount[n]=0;
  244.         for (int n=0;n<mol.numAtoms();n++) if (hcount[n]>0 && placeHydrogen(n,hcount[n],0,-1)) hcount[n]=0;
  245.         for (int n=0;n<mol.numAtoms();n++) if (hcount[n]>0) placeHydrogen(n,hcount[n],0,0);
  246.        
  247.         // now do atomic charges/radical notation
  248.         for (int n=1;n<=mol.numAtoms();n++)
  249.         {
  250.             String str="";
  251.             int chg=mol.atomCharge(n);
  252.             if (chg==-1) str="-";
  253.             else if (chg==1) str="+";
  254.             else if (chg<-1) str=String.valueOf(chg);
  255.             else if (chg>1) str="+"+String.valueOf(chg);
  256.             for (int i=mol.atomUnpaired(n);i>0;i--) str+=".";
  257.             if (str.length()==0) continue;
  258.             annotateAtom(n,str,str.length()==1 ? fontSize : 0.75*fontSize,0x000000);
  259.         }
  260.        
  261.         // add stereo annotations, if requested
  262.         if (annotRS) for (int n=1,chi;n<=mol.numAtoms();n++)
  263.             if ((chi=mol.atomChirality(n))!=Molecule.STEREO_NONE)
  264.         {
  265.             String label=chi==Molecule.STEREO_POS ? "R" : chi==Molecule.STEREO_NEG ? "S" : "R/S";
  266.             annotateAtom(n,label,0,0x0000FF);
  267.         }
  268.         if (annotEZ) for (int n=1,chi;n<=mol.numBonds();n++)
  269.             if ((chi=mol.bondStereo(n))!=Molecule.STEREO_NONE)
  270.         {
  271.             String label=chi==Molecule.STEREO_POS ? "Z" : chi==Molecule.STEREO_NEG ? "E" : "E/Z";
  272.             annotateBond(n,label,0,0x0000FF);
  273.         }
  274.     }
  275.  
  276.     // adds a label to the given atom index, which is drawn near to, but not on top of, the atom itself; font defaults to atom size
  277.     public void annotateAtom(int anum,String label,double fsz,int col)
  278.     {
  279.         if (fsz==0) fsz=fontSize;
  280.         double[] wad=measure.measureText(label,fsz);
  281.         double rw=0.5*wad[0],rh=0.5*wad[1];
  282.         double[] pxy=anchorAnnotation(pointCX(anum-1),pointCY(anum-1),rw,rh);
  283.  
  284.         APoint a=new APoint();
  285.         a.anum=0;
  286.         a.text=label;
  287.         a.fsz=fsz;
  288.         a.bold=false;
  289.         a.col=col;
  290.         a.cx=pxy[0];
  291.         a.cy=pxy[1];
  292.         a.rw=rw;
  293.         a.rh=rh;
  294.         points.add(a);
  295.     }
  296.    
  297.     // adds a label close to the centre of a bond
  298.     public void annotateBond(int bnum,String label,double fsz,int col)
  299.     {
  300.         if (fsz==0) fsz=fontSize;
  301.         double[] wad=measure.measureText(label,fsz);
  302.         double rw=0.5*wad[0],rh=0.5*wad[1];
  303.         int bfr=mol.bondFrom(bnum),bto=mol.bondTo(bnum);
  304.         double[] pxy=anchorAnnotation(0.5*(pointCX(bfr-1)+pointCX(bto-1)),0.5*(pointCY(bfr-1)+pointCY(bto-1)),rw,rh);
  305.  
  306.         APoint a=new APoint();
  307.         a.anum=0;
  308.         a.text=label;
  309.         a.fsz=fsz;
  310.         a.bold=false;
  311.         a.col=col;
  312.         a.cx=pxy[0];
  313.         a.cy=pxy[1];
  314.         a.rw=rw;
  315.         a.rh=rh;
  316.         points.add(a);
  317.     }
  318.    
  319.     // access to atom information; it is valid to assume that {atomcentre}[N-1] matches {moleculeatom}[N], if N<=mol.numAtoms()
  320.     public int numPoints() {return points.size();}
  321.     public int pointANum(int N) {return points.get(N).anum;}
  322.     public String pointText(int N) {return points.get(N).text;}
  323.     public double pointFontSize(int N) {return points.get(N).fsz;}
  324.     public boolean pointBold(int N) {return points.get(N).bold;}
  325.     public int pointCol(int N) {return points.get(N).col;}
  326.     public double pointCX(int N) {return points.get(N).cx;}
  327.     public double pointCY(int N) {return points.get(N).cy;}
  328.     public double pointRW(int N) {return points.get(N).rw;}
  329.     public double pointRH(int N) {return points.get(N).rh;}
  330.    
  331.     // access to bond information; it is NOT valid to read anything into the indices
  332.     public int numLines() {return lines.size();}
  333.     public int lineBNum(int N) {return lines.get(N).bnum;}
  334.     public int lineType(int N) {return lines.get(N).type;}
  335.     public double lineX1(int N) {return lines.get(N).x1;}
  336.     public double lineY1(int N) {return lines.get(N).y1;}
  337.     public double lineX2(int N) {return lines.get(N).x2;}
  338.     public double lineY2(int N) {return lines.get(N).y2;}
  339.     public double lineSize(int N) {return lines.get(N).size;}
  340.     public int lineCol(int N) {return lines.get(N).col;}
  341.    
  342.     // private methods
  343.    
  344.     // given that the position (X,Y) connects with atom N, and is part of a bond that connects at the other end
  345.     // with (FX,FY), considers the possibility that a new (X,Y) may need to be calculated by backing up along the line
  346.     private double[] backOffAtom(int N,double X,double Y,double FX,double FY)
  347.     {
  348.         final double EXT_RAD=1.4;
  349.         double cx=pointCX(N),cy=pointCY(N),rw=pointRW(N)*EXT_RAD,rh=pointRH(N)*EXT_RAD;
  350.         if (pointText(N)==null || rw<=0 || rh<=0) return new double[]{X,Y};
  351.        
  352.         double dx=X-cx,dy=Y-cy;
  353.         double sqX=Util.sqr(dx)/Util.sqr(rw),sqY=Util.sqr(dy)/Util.sqr(rh);
  354.         if (sqX+sqY>=1) return new double[]{X,Y}; // does not intrude on the ellipse
  355.        
  356.         // NOTE: this is slightly wrong because it assumes that lines point toward the centre, which is almost true...
  357.        
  358.         dx=FX-cx; dy=FY-cy;
  359.         sqX=Util.sqr(dx)/Util.sqr(rw); sqY=Util.sqr(dy)/Util.sqr(rh);
  360.         double d=Math.sqrt(1/(sqX+sqY));
  361.         return new double[]{X+d*(FX-X),Y+d*(FY-Y)};
  362.     }
  363.  
  364.     // produces a list of small rings, ordered in a terminal-first manner, which is to be used as the sequence for assigning sides of
  365.     // bond orders
  366.     private int[][] orderedRingList()
  367.     {
  368.         ArrayList<int[]> rings=new ArrayList<int[]>();
  369.         final int[] SIZE_ORDER={6,5,7,4,3};
  370.         for (int i=0;i<SIZE_ORDER.length;i++)
  371.         {
  372.             int[][] nring=mol.findRingSize(SIZE_ORDER[i]);
  373.             for (int j=0;j<nring.length;j++) rings.add(nring[j]);
  374.         }
  375.        
  376.         // keep adding terminal rings to the result set - or, the first ring if none
  377.         ArrayList<int[]> result=new ArrayList<int[]>();
  378.         while (rings.size()>0)
  379.         {
  380.             int which=0; // (default to first)
  381.            
  382.             for (int i=0;i<rings.size();i++)
  383.             {
  384.                 int ncon=0;
  385.                 for (int j=0;j<rings.size();j++) if (i!=j)
  386.                 {
  387.                     boolean shared=false;
  388.                     int[] r1=rings.get(i),r2=rings.get(j);
  389.                     for (int k1=0;k1<r1.length && !shared;k1++) for (int k2=0;k2<r2.length;k2++)
  390.                         if (r1[k1]==r2[k2]) {shared=true; break;}
  391.                     if (shared) ncon++;
  392.                 }
  393.                
  394.                 if (ncon<=1) {which=i; break;}
  395.             }
  396.            
  397.             result.add(rings.get(which));
  398.             rings.remove(which);
  399.         }
  400.        
  401.         //for (int n=0;n<result.size();n++) Util.writeln(Util.arrayStr(result.get(n)));
  402.        
  403.         return result.toArray(new int[result.size()][]);
  404.     }
  405.  
  406.     // convenience function which returns {ox,oy} which is orthogonal to the direction of the input vector, of magnitude D; the direction
  407.     // of {ox,oy} is to the "left" of the input vector
  408.     private double[] orthogonalDelta(double X1,double Y1,double X2,double Y2,double D)
  409.     {
  410.         double ox=Y1-Y2,oy=X2-X1;
  411.         double dsq=ox*ox+oy*oy;
  412.         double sc=dsq>0 ? D/Math.sqrt(dsq) : 1;
  413.         return new double[]{ox*sc,oy*sc};
  414.     }
  415.  
  416.     // given the guideline index of a double bond, and some information about the atoms which are on the "important side", creates the
  417.     // appropriate line segments
  418.     private void processDoubleBond(int N,int[] Priority)
  419.     {
  420.         int bf=mol.bondFrom(N),bt=mol.bondTo(N);
  421.         int[] nf=mol.atomAdjList(bf),nt=mol.atomAdjList(bt);
  422.  
  423.         double x1=pointCX(bf-1),y1=pointCY(bf-1),x2=pointCX(bt-1),y2=pointCY(bt-1);
  424.         double dx=x2-x1,dy=y2-y1,btheta=Math.atan2(dy,dx);
  425.        
  426.         // count number of priority atoms on either side of the bond vector
  427.         int countFLeft=0,countFRight=0,countTLeft=0,countTRight=0;
  428.         int idxFLeft=0,idxFRight=0,idxTLeft=0,idxTRight=0;
  429.         boolean noshift=false; // true if definitely not alkene-ish
  430.         for (int n=0;n<nf.length;n++) if (nf[n]!=bt)
  431.         {
  432.             if (mol.bondOrder(mol.findBond(bf,nf[n]))>1) {noshift=true; break;}
  433.             boolean ispri=false;
  434.             for (int i=0;i<(Priority==null ? 0 : Priority.length);i++) if (Priority[i]==nf[n]) ispri=true;
  435.             double theta=Util.angleDiff(Math.atan2(pointCY(nf[n]-1)-y1,pointCX(nf[n]-1)-x1),btheta);
  436.             if (theta>0) {if (ispri) countFLeft++; idxFLeft=nf[n];}
  437.             else {if (ispri) countFRight++; idxFRight=nf[n];}
  438.         }
  439.         for (int n=0;n<nt.length;n++) if (nt[n]!=bf)
  440.         {
  441.             if (mol.bondOrder(mol.findBond(bt,nt[n]))>1) {noshift=true; break;}
  442.             boolean ispri=false;
  443.             for (int i=0;i<(Priority==null ? 0 : Priority.length);i++) if (Priority[i]==nt[n]) ispri=true;
  444.             double theta=Util.angleDiff(Math.atan2(pointCY(nt[n]-1)-y2,pointCX(nt[n]-1)-x2),btheta);
  445.             if (theta>0) {if (ispri) countTLeft++; idxTLeft=nt[n];}
  446.             else {if (ispri) countTRight++; idxTRight=nt[n];}
  447.         }
  448.        
  449.         // decide which side the bond should be shifted to, if either
  450.         int side=0;
  451.         if (noshift || countFLeft>1 || countFRight>1 || countTLeft>1 || countTRight>1) {} // inappropriate
  452.         else if (countFLeft>0 && countFRight>0) {} // ambiguous
  453.         else if (countTLeft>0 && countTRight>0) {} // ambiguous
  454.         else if (countFLeft>0 || countTLeft>0) side=1; // left
  455.         else if (countFRight>0 || countTRight>0) side=-1; // right
  456.  
  457.         // create the bond lines
  458.  
  459.         double sz=lineSize;
  460.         if (mol.atomMapNum(bf)>0 && mol.atomMapNum(bt)>0) sz*=5.0/3;
  461.         double[] oxy=orthogonalDelta(x1,y1,x2,y2,bondSep);
  462.        
  463.  
  464.         double ax1=x1,ay1=y1,ax2=x2,ay2=y2;
  465.         double bx1=0,by1=0,bx2=0,by2=0;
  466.  
  467.         if (side==0)
  468.         {
  469.             ax1=x1+0.5*oxy[0]; ay1=y1+0.5*oxy[1]; ax2=x2+0.5*oxy[0]; ay2=y2+0.5*oxy[1];
  470.             bx1=x1-0.5*oxy[0]; by1=y1-0.5*oxy[1]; bx2=x2-0.5*oxy[0]; by2=y2-0.5*oxy[1];
  471.         }
  472.         else if (side>0)
  473.         {
  474.             bx1=x1+oxy[0]; by1=y1+oxy[1]; bx2=x2+oxy[0]; by2=y2+oxy[1];
  475.             if (nf.length>1 && pointText(bf-1)==null) {bx1+=oxy[1]; by1-=oxy[0];}
  476.             if (nt.length>1 && pointText(bt-1)==null) {bx2-=oxy[1]; by2+=oxy[0];}
  477.         }
  478.         else if (side<0)
  479.         {
  480.             bx1=x1-oxy[0]; by1=y1-oxy[1]; bx2=x2-oxy[0]; by2=y2-oxy[1];
  481.             if (nf.length>1 && pointText(bf-1)==null) {bx1+=oxy[1]; by1-=oxy[0];}
  482.             if (nt.length>1 && pointText(bt-1)==null) {bx2-=oxy[1]; by2+=oxy[0];}
  483.         }
  484.        
  485.         double[] xy1=backOffAtom(bf-1,ax1,ay1,ax2,ay2);
  486.         double[] xy2=backOffAtom(bt-1,ax2,ay2,ax1,ay1);
  487.         ax1=xy1[0]; ay1=xy1[1]; ax2=xy2[0]; ay2=xy2[1];
  488.  
  489.         xy1=backOffAtom(bf-1,bx1,by1,bx2,by2);
  490.         xy2=backOffAtom(bt-1,bx2,by2,bx1,by1);
  491.         bx1=xy1[0]; by1=xy1[1]; bx2=xy2[0]; by2=xy2[1];
  492.  
  493.         if (devRounding)
  494.         {
  495.             // round the positions, then look for pixel-sized adjustments to B to find the best offset (if any) which honours the two lines
  496.             // being parallel with distance of 'bondSep'
  497.            
  498.             ax1=Math.round(ax1); ay1=Math.round(ay1); ax2=Math.round(ax2); ay2=Math.round(ay2);
  499.             bx1=Math.round(bx1); by1=Math.round(by1); bx2=Math.round(bx2); by2=Math.round(by2);
  500.            
  501.             int dx1=0,dy1=0,dx2=0,dy2=0;
  502.             double best=1E10,bondSepSq=Util.sqr(bondSep);
  503.             final int[] RDX1={0,-1,1,0,0,0,0,0,0},RDY1={0,0,0,-1,1,0,0,0,0},RDX2={0,0,0,0,0,-1,1,0,0},RDY2={0,0,0,0,0,0,0,-1,1};
  504.             boolean orthog=(Util.dblEqual(ax1,ax2) && Util.dblEqual(bx1,bx2)) ||
  505.                            (Util.dblEqual(ay1,ay2) && Util.dblEqual(by1,by2));
  506.             if (!orthog) for (int n=0;n<9;n++)
  507.             {
  508.                 double ux1=bx1+RDX1[n],uy1=by1+RDY1[n],ux2=bx2+RDX2[n],uy2=by2+RDY2[n];
  509.                 double ox=uy1-uy2,oy=ux2-ux1;
  510.                 double[] ixy1=lineIntersection(ux1,uy1,ux1+ox,uy1+oy,ax1,ay1,ax2,ay2);
  511.                 double[] ixy2=lineIntersection(ux2,uy2,ux2+ox,uy2+oy,ax1,ay1,ax2,ay2);
  512.                 double dsq1=Util.sqr(ixy1[0]-ux1)+Util.sqr(ixy1[1]-uy1);
  513.                 double dsq2=Util.sqr(ixy2[0]-ux2)+Util.sqr(ixy2[1]-uy2);
  514.                 double score=Math.abs(dsq1-bondSepSq)+Math.abs(dsq2-bondSepSq);
  515.                 if (score<best)
  516.                 {
  517.                     best=score;
  518.                     dx1=RDX1[n];
  519.                     dy1=RDY1[n];
  520.                     dx2=RDX2[n];
  521.                     dy2=RDY2[n];
  522.                 }
  523.             }
  524.             bx1+=dx1;
  525.             by1+=dy1;
  526.             bx2+=dx2;
  527.             by2+=dy2;
  528.         }
  529.  
  530.         lines.add(new BLine(N,BLINE_NORMAL,ax1,ay1,ax2,ay2,sz,0x000000));
  531.         lines.add(new BLine(N,BLINE_NORMAL,bx1,by1,bx2,by2,sz,0x000000));
  532.  
  533.         if (side==0 && !noshift && mol.atomRingBlock(bf)==0 && mol.atomRingBlock(bt)==0)
  534.         {
  535.             if (pointText(bf-1)==null)
  536.             {
  537.                 adjustBondPosition(idxFLeft,bf,ax1,ay1);
  538.                 adjustBondPosition(idxFRight,bf,bx1,by1);
  539.             }
  540.             if (pointText(bt-1)==null)
  541.             {
  542.                 adjustBondPosition(idxTLeft,bt,ax2,ay2);
  543.                 adjustBondPosition(idxTRight,bt,bx2,by2);
  544.             }
  545.         }
  546.     }
  547.  
  548.     // returns true if, for an atom, all of its neighbours are not oriented in the given directory (180deg)
  549.     private boolean quadrantOpen(int N,int DX,int DY)
  550.     {
  551.         int[] nbr=mol.atomAdjList(N+1);
  552.         for (int n=0;n<nbr.length;n++)
  553.         {
  554.             double ox=pointCX(nbr[n]-1)-pointCX(N),oy=pointCY(nbr[n]-1)-pointCY(N);
  555.             if (DX==1 && DY==0 && ox>0) return false;
  556.             if (DX==-1 && DY==0 && ox<0) return false;
  557.             if (DX==0 && DY==1 && oy>0) return false;
  558.             if (DX==0 && DY==-1 && oy<0) return false;
  559.         }
  560.         return true;
  561.     }
  562.  
  563.     // for an atom centre, with a non-zero number of hydrogen labels required, in the direction indicated by (DX,DY), see if there is room
  564.     // to fit the label, and if there is, stick it there and return true; special case: if (DX,DY) are both zero, then search around the
  565.     // central position looking for the least bad position, and place it there; returns true if the label was placed
  566.     private boolean placeHydrogen(int N,int HCount,int DX,int DY)
  567.     {
  568.         final double KERN_CONST=1.1;
  569.    
  570.         APoint a=points.get(N);
  571.    
  572.         double[] wad=measure.measureText("H",a.fsz);
  573.        
  574.         double cx=a.cx+DX*(a.rw+0.5*wad[0])*KERN_CONST;
  575.         double cy=a.cy+DY*(a.rh+0.5*(wad[1]+wad[2]))*KERN_CONST;
  576.         double rw=0.5*wad[0],rh=0.5*wad[1];
  577.        
  578.         String nstr=HCount>1 ? String.valueOf(HCount) : null;
  579.         double nsz=0.5*a.fsz;
  580.         double[] nwad=nstr==null ? null : measure.measureText(nstr,nsz);
  581.         double nx=0,ny=0,nw=0,nh=0;
  582.         if (nstr!=null)
  583.         {
  584.             nw=0.5*nwad[0];
  585.             nh=0.5*nwad[1];
  586.         }
  587.  
  588.         // if this isn't fallback mode, stop if the position isn't free
  589.         if (DX!=0 || DY!=0)
  590.         {
  591.             if (boxOverlaps(cx-rw,cy-rh,2*rw,2*rh)) return false;
  592.             if (nstr!=null && DX==-1 && DY==0) cx-=nwad[0]*KERN_CONST;
  593.         }
  594.         else
  595.         {
  596.             double bestX=0,bestY=0,bestScore=0;
  597.             for (double th=0;th<2*Math.PI;th+=Math.PI/36) // 5 degree increments
  598.             {
  599.                 double tx=a.cx+a.rw*Math.cos(th),ty=a.cy+a.rh*Math.sin(th);
  600.                 if (tx>a.cx && tx-rw<a.cx+a.rw) tx=a.cx+a.rw+rw;
  601.                 if (tx<a.cx && tx+rw+nw*3>a.cx-a.rw) tx=a.cx-a.rw-rw-nw*2*KERN_CONST;
  602.                 if (ty>a.cy && ty-rh<a.cy+a.rh) ty=a.cy+a.rw+rw;
  603.                 if (ty<a.cy && ty+rh>a.cy-a.rh) ty=a.cy-a.rh-rh;
  604.                 double score=spatialCongestion(tx,ty)+(boxOverlaps(tx-rw,ty-rh,2*rw,2*rh) ? 1000 : 0);
  605.                 if (th==0 || score<bestScore) {bestScore=score; bestX=tx; bestY=ty;}
  606.             }
  607.             cx=bestX;
  608.             cy=bestY;
  609.         }
  610.  
  611.         if (nstr!=null)
  612.         {
  613.             nx=cx+rw+0.75*nwad[0];
  614.             ny=cy+0.75*rh;
  615.         }
  616.        
  617.         APoint ah=new APoint();
  618.         ah.anum=0;
  619.         ah.text="H";
  620.         ah.fsz=a.fsz;
  621.         ah.bold=a.bold;
  622.         ah.col=a.col;
  623.         ah.cx=cx;
  624.         ah.cy=cy;
  625.         ah.rw=rw;
  626.         ah.rh=rh;
  627.         points.add(ah);
  628.        
  629.         if (nstr!=null)
  630.         {
  631.             APoint an=new APoint();
  632.             an.anum=0;
  633.             an.text=nstr;
  634.             an.fsz=0.5*a.fsz;
  635.             an.bold=a.bold;
  636.             an.col=a.col;
  637.             an.cx=nx;
  638.             an.cy=ny;
  639.             an.rw=nw;
  640.             an.rh=nh;
  641.             points.add(an);
  642.         }
  643.        
  644.         return true;
  645.     }
  646.  
  647.     // considering a single-bond line from (bf,bt), make sure the endpoint (indicated by 'bt') is moved to the position (x,y)
  648.     private void adjustBondPosition(int bf,int bt,double x,double y)
  649.     {
  650.         for (int n=0;n<numLines();n++)
  651.         {
  652.             BLine b=lines.get(n);
  653.             if (mol.bondOrder(b.bnum)!=1 && mol.bondType(b.bnum)!=Molecule.BONDTYPE_NORMAL) continue;
  654.  
  655.             if (mol.bondFrom(b.bnum)==bf && mol.bondTo(b.bnum)==bt) {b.x2=x; b.y2=y;}
  656.             if (mol.bondFrom(b.bnum)==bt && mol.bondTo(b.bnum)==bf) {b.x1=x; b.y1=y;}
  657.         }
  658.     }
  659.  
  660.     // for the guideline index of a double bond, determines which side has weighting priority for the drawing of the bond; assumes a chain-
  661.     // like bond (though it could still be in a large ring); a null/empty/ambiguous set implies that there is no priority, and that the bond
  662.     // should not be drawn in a side-shifted manner...
  663.     private int[] priorityDoubleSubstit(int N)
  664.     {
  665.         int bf=mol.bondFrom(N),bt=mol.bondTo(N);
  666.         int[] nf=mol.atomAdjList(bf),nt=mol.atomAdjList(bt);
  667.         double x1=pointCX(bf-1),y1=pointCY(bf-1),x2=pointCX(bt-1),y2=pointCY(bt-1);
  668.         double dx=x2-x1,dy=y2-y1,btheta=Math.atan2(dy,dx);
  669.  
  670.         int idxFLeft=0,idxFRight=0,idxTLeft=0,idxTRight=0;
  671.  
  672.         for (int n=0;n<nf.length;n++) if (nf[n]!=bt)
  673.         {
  674.             double theta=Util.angleDiff(Math.atan2(pointCY(nf[n]-1)-y1,pointCX(nf[n]-1)-x1),btheta);
  675.             if (theta>0) {if (idxFLeft!=0) return null; idxFLeft=nf[n];}
  676.             else {if (idxFRight!=0) return null; idxFRight=nf[n];}
  677.         }
  678.         for (int n=0;n<nt.length;n++) if (nt[n]!=bf)
  679.         {
  680.             double theta=Util.angleDiff(Math.atan2(pointCY(nt[n]-1)-y2,pointCX(nt[n]-1)-x2),btheta);
  681.             if (theta>0) {if (idxTLeft!=0) return null; idxTLeft=nt[n];}
  682.             else {if (idxTRight!=0) return null; idxTRight=nt[n];}
  683.         }
  684.        
  685.         int sumFrom=(idxFLeft>0 ? 1 : 0)+(idxFRight>0 ? 1 : 0),sumTo=(idxTLeft>0 ? 1 : 0)+(idxTRight>0 ? 1 : 0);
  686.        
  687.         if (sumFrom==1 && sumTo==0) return new int[]{idxFLeft>0 ? idxFLeft : idxFRight};
  688.         if (sumFrom==0 && sumTo==1) return new int[]{idxTLeft>0 ? idxTLeft : idxTRight};
  689.         if (sumFrom==1 && sumTo==1)
  690.         {
  691.             // cis? if so, then side is obvious
  692.             if (idxFLeft>0 && idxTLeft>0) return new int[]{idxFLeft,idxTLeft};
  693.             if (idxFRight>0 && idxTRight>0) return new int[]{idxFRight,idxTRight};
  694.            
  695.             // trans? either is fine, so go with congestion
  696.             double[] oxy=orthogonalDelta(x1,y1,x2,y2,bondSep);
  697.             double congestLeft=spatialCongestion(0.5*(x1+x2)+oxy[0],0.5*(y1+y2)+oxy[1]);
  698.             double congestRight=spatialCongestion(0.5*(x1+x2)-oxy[0],0.5*(y1+y2)-oxy[1]);
  699.             if (congestLeft<congestRight) return new int[]{idxFLeft>0 ? idxFLeft : idxTLeft};
  700.             else return new int[]{idxFRight>0 ? idxFRight : idxTRight};
  701.         }
  702.         if (sumFrom==2 && sumTo==1)
  703.         {
  704.             // side with the majority
  705.             if (idxTLeft==0) return new int[]{idxFRight,idxTRight};
  706.             else return new int[]{idxFLeft,idxTLeft};
  707.         }
  708.         if (sumFrom==1 && sumTo==2)
  709.         {
  710.             // side with the majority
  711.             if (idxFLeft==0) return new int[]{idxFRight,idxTRight};
  712.             else return new int[]{idxFLeft,idxTLeft};
  713.         }
  714.  
  715.         return null;
  716.     }
  717.    
  718.     // for the lines L1-->L2 and L3-->L4, calculate and return the intersection; (note lines, not line segments)
  719.     private double[] lineIntersection(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4)
  720.     {
  721.         double u=((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3))
  722.                 /((y4-y3)*(x2-x1) - (x4-x3)*(y2-y1));
  723.         return new double[]{x1+u*(x2-x1),y1+u*(y2-y1)};
  724.     }
  725.    
  726.     // for a specific location, returns a measure of how "congested" it is; lower values mean that the point is generally far away
  727.     // from things
  728.     private double spatialCongestion(double x,double y)
  729.     {
  730.         double congest=0;
  731.         for (int n=0;n<numPoints();n++) congest+=1/(Util.sqr(pointCX(n)-x)+Util.sqr(pointCY(n)-y));
  732.         return congest;
  733.     }
  734.  
  735.     // returns true if the indicated box intersects with any of the currently defined atom centres or bond lines
  736.     private boolean boxOverlaps(double x,double y,double w,double h)
  737.     {
  738.         Rectangle2D.Double box=new Rectangle2D.Double(x,y,w,h);
  739.         for (int n=0;n<numPoints();n++)
  740.         {
  741.             APoint a=points.get(n);
  742.             double aw=Math.max(a.rw,1),ah=Math.max(a.rh,1);
  743.             if (box.intersects(a.cx-aw,a.cy-ah,2*aw,2*ah)) return true;
  744.         }
  745.         for (int n=0;n<numLines();n++)
  746.         {
  747.             BLine b=lines.get(n);
  748.             double dx=b.x2-b.x1,dy=b.y2-b.y1;
  749.             if (!box.intersects(Math.min(b.x1,b.x2)-1,Math.min(b.y1,b.y2)-1,Math.abs(dx)+2,Math.abs(dy)+2)) continue;
  750.             double stepsz=0.1*0.25*(w+h)/Math.sqrt(dx*dx+dy*dy);
  751.             for (double v=0.0;v<=1.0;v+=stepsz) if (box.contains(b.x1+v*dx,b.y1+v*dy)) return true;
  752.         }
  753.         return false;
  754.     }
  755.    
  756.     // for a given piece of text, tries to find a position close to that which is given, which does not overlap with anything
  757.     private double[] anchorAnnotation(double px,double py,double rw,double rh)
  758.     {
  759.         if (!boxOverlaps(px,py,rw,rh)) return new double[]{px,py}; // just in case it's blank...
  760.        
  761.         // do radial sweeps: take the best angle at the current extension, or if none, loop around with a bigger sweep
  762.         double stepext=0.25*scale,ext=stepext;
  763.         boolean lastChance=false;
  764.         while (true)
  765.         {
  766.             double bestX=0,bestY=0,bestScore=-1;
  767.             for (double th=0;th<2*Math.PI;th+=Math.PI/36) // 5 degree increments
  768.             {
  769.                 double tx=px+ext*Math.cos(th),ty=py+ext*Math.sin(th);
  770.                 if (!lastChance) if (boxOverlaps(tx-rw,ty-rh,2*rw,2*rh)) continue;
  771.                 double score=spatialCongestion(tx,ty);
  772.                 if (bestScore<0 || score<bestScore) {bestScore=score; bestX=tx; bestY=ty;}
  773.             }
  774.             if (bestScore>=0) return new double[]{bestX,bestY};
  775.            
  776.             // nothing flies, so increase the extent; if gone too far, wind it back in, and pick the best of the bad
  777.             ext+=stepext;
  778.             if (ext>3*scale) {ext=rw+rh; lastChance=true;}
  779.         }
  780.     }
  781. }
  782.  
  783.