Thread: [Jmol-commits] SF.net SVN: jmol:[20757] trunk/Jmol/src/org (Page 12)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Revision: 20757
          http://sourceforge.net/p/jmol/code/20757
Author:   hansonr
Date:     2015-09-06 04:09:52 +0000 (Sun, 06 Sep 2015)
Log Message:
-----------
Jmol.___JmolVersion="14.3.16_2015.09.05"

new feature: POLYHEDRA
  -- same as POLYHEDRA BONDS {selected}
new feature: POLYHEDRA 4
  -- same as POLYHEDRA 4 BONDS {selected}  
new feature: POLYHEDRA OFFSET 1.4
  -- same as POLYHEDRA COLLAPSED faceCenterOffset 1.4
new feature: POLYHEDRA COLLAPSED 1.4
  -- same as POLYHEDRA COLLAPSED faceCenterOffset 1.4

code: Polyhedra work, including more efficient algorithms for completing set of faces

bug fix: tracking down thread-safe issue in application console
bug fix: in Java, mouse should not lose control if moved out of application

undocumented POLYHEDRA FLAT removed

Modified Paths:
--------------
    trunk/Jmol/src/org/jmol/awt/Mouse.java
    trunk/Jmol/src/org/jmol/script/ScriptExpr.java
    trunk/Jmol/src/org/jmol/script/T.java
    trunk/Jmol/src/org/jmol/scriptext/CmdExt.java
    trunk/Jmol/src/org/jmol/shapespecial/Polyhedra.java
    trunk/Jmol/src/org/jmol/shapespecial/Polyhedron.java
    trunk/Jmol/src/org/jmol/viewer/Jmol.properties
    trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/AppConsole.java
    trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/ConsoleTextArea.java

Modified: trunk/Jmol/src/org/jmol/awt/Mouse.java
===================================================================

--- trunk/Jmol/src/org/jmol/awt/Mouse.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/awt/Mouse.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -102,7 +102,7 @@
       mousePressed(time, x, y, modifiers, false);
       break;
     case Event.MOUSE_DRAG:
-      mouseDragged(time, x, y, modifiers);
+      mouseDragged(time, x, y);
       break;
     case Event.MOUSE_ENTER:
       mouseEntered(time, x, y);
@@ -157,16 +157,7 @@
 
   @Override
   public void mouseDragged(MouseEvent e) {
-    int modifiers = e.getModifiers();
-    /****************************************************************
-     * Netscape 4.* Win32 has a problem with mouseDragged if you left-drag then
-     * none of the modifiers are selected we will try to fix that here
-     ****************************************************************/
-    if ((modifiers & Event.BUTTON_MASK) == 0)
-      modifiers |= Event.MOUSE_LEFT;
-    
-    /****************************************************************/
-    mouseDragged(e.getWhen(), e.getX(), e.getY(), modifiers);
+    mouseDragged(e.getWhen(), e.getX(), e.getY());
   }
 
   @Override
@@ -308,15 +299,11 @@
 
   private void mouseEntered(long time, int x, int y) {
     wheeling = false;
-    isMouseDown = false;
-    modifiersDown = 0;
     manager.mouseEnterExit(time, x, y, false);
   }
 
   private void mouseExited(long time, int x, int y) {
     wheeling = false;
-    isMouseDown = false;
-    modifiersDown = 0;
     manager.mouseEnterExit(time, x, y, true);
   }
 
@@ -378,7 +365,7 @@
     manager.mouseAction(Event.RELEASED, time, x, y, 0, modifiers);
   }
 
-  private void mouseDragged(long time, int x, int y, int modifiers) {
+  private void mouseDragged(long time, int x, int y) {
     if (wheeling)
       return;
     if ((modifiersDown & Event.MAC_COMMAND) == Event.MAC_COMMAND)

Modified: trunk/Jmol/src/org/jmol/script/ScriptExpr.java
===================================================================
--- trunk/Jmol/src/org/jmol/script/ScriptExpr.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/script/ScriptExpr.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -2342,6 +2342,7 @@
    * these, because they must be integrated with the statement dynamically.
    * 
    * @param st0  aaToken[i]
+   * @param pt0 
    * @return a fixed token set -- with possible overrun of unused null tokens
    * 
    * @throws ScriptException

Modified: trunk/Jmol/src/org/jmol/script/T.java
===================================================================
--- trunk/Jmol/src/org/jmol/script/T.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/script/T.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -1200,7 +1200,7 @@
   public final static int filter         = misc  | 116;
   public final static int first   = misc  | 118;
   public final static int fixedtemp      = misc  | 122;
-  public final static int flat           = misc  | 124;
+//  public final static int flat           = misc  | 124; was only in Polyhedra; never documented
   public final static int fps            = misc  | 126 | expression;
   public final static int from           = misc  | 128;
   public final static int front   = misc  | 130;
@@ -1209,7 +1209,7 @@
   public final static int frontonly = misc  | 136;
   public final static int full            = misc  | 137;
   public final static int fullplane       = misc  | 138;
-  public final static int fullylit = misc  | 140;
+  public final static int fullylit        = misc  | 140;
   public final static int functionxy     = misc  | 142;
   public final static int functionxyz    = misc  | 144;
   public final static int gridpoints     = misc  | 146;
@@ -2226,7 +2226,7 @@
        "first",
        "fixed",
        "fix",
-       "flat",
+//       "flat",
        "fps",
        "from",
        "frontEdges",
@@ -3259,7 +3259,7 @@
         first,                              //        "first"
         fixed,                              //        "fixed"
         -1,                                 //        "fix"
-        flat,                               //        "flat"
+//        flat,                               //        "flat"
         fps,                                //        "fps"
         from,                               //        "from"
         frontedges,                         //        "frontEdges"

Modified: trunk/Jmol/src/org/jmol/scriptext/CmdExt.java
===================================================================
--- trunk/Jmol/src/org/jmol/scriptext/CmdExt.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/scriptext/CmdExt.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -3156,6 +3156,15 @@
 
   private boolean polyhedra() throws ScriptException {
     ScriptEval eval = e;
+    // polyhedra
+    // polyhedra on/off/delete
+    // polyhedra [type]
+    // where [type] is one of
+    //   n [opt. BONDS]
+    //   n-m [opt. BONDS]
+    //   [opt. RADIUS] x.y 
+    // polyhedra [type] [
+
     /*
      * needsGenerating:
      * 
@@ -3166,17 +3175,15 @@
      * 
      * polyhedra [at most one selection set] [type-and/or-edge or on/off/delete]
      */
-    boolean needsGenerating = false;
+    boolean haveBonds = (slen == 1);
+    boolean needsGenerating = haveBonds;
     boolean onOffDelete = false;
     boolean typeSeen = false;
     boolean edgeParameterSeen = false;
-    boolean isDesignParameter = false;
-    int lighting = 0;
+    //    int lighting = T.nada; // never implemented; fullyLit does nothing
     int nAtomSets = 0;
     e.sm.loadShape(JC.SHAPE_POLYHEDRA);
     setShapeProperty(JC.SHAPE_POLYHEDRA, "init", Boolean.TRUE);
-    String setPropertyName = "centers";
-    String decimalPropertyName = "radius_";
     float translucentLevel = Float.MAX_VALUE;
     int[] colorArgb = new int[] { Integer.MIN_VALUE };
     for (int i = 1; i < slen; ++i) {
@@ -3191,6 +3198,7 @@
       case T.unitcell:
         propertyName = "unitCell";
         propertyValue = Boolean.TRUE;
+        needsGenerating = true;
         break;
       case T.only:
         e.restrictSelected(false, false);
@@ -3199,116 +3207,132 @@
       case T.on:
       case T.delete:
       case T.off:
-        if (i + 1 != slen || needsGenerating || nAtomSets > 1 || nAtomSets == 0
-            && "to".equals(setPropertyName))
+        if (i + 1 != slen || needsGenerating || nAtomSets > 1)
           error(ScriptError.ERROR_incompatibleArguments);
         propertyName = (eval.theTok == T.off ? "off"
             : eval.theTok == T.on ? "on" : "delete");
         onOffDelete = true;
         break;
-      case T.opEQ:
-      case T.comma:
-        continue;
+      case T.integer:
+        propertyName = "nVertices";
+        propertyValue = Integer.valueOf(intParameter(i));
+        needsGenerating = true;
+        switch (tokAt(i + 1)) {
+        // wish I had not done this. Inconsistent with general syntax; only used here
+        case T.opEQ:
+        case T.comma:
+          i++;
+          break;
+        }
+        break;
       case T.bonds:
         if (nAtomSets > 0)
           invPO();
         needsGenerating = true;
         propertyName = "bonds";
+        haveBonds = true;
         break;
       case T.radius:
-        decimalPropertyName = "radius";
-        continue;
-      case T.integer:
+        i++;
+        //$FALL-THROUGH$
       case T.decimal:
-        if (nAtomSets > 0 && !isDesignParameter)
+        if (nAtomSets > 0)
           invPO();
-        if (eval.theTok == T.integer) {
-          if (decimalPropertyName == "radius_") {
-            propertyName = "nVertices";
-            propertyValue = Integer.valueOf(intParameter(i));
-            needsGenerating = true;
-            break;
-          }
-        }
-        propertyName = (decimalPropertyName == "radius_" ? "radius"
-            : decimalPropertyName);
+        propertyName = "radius";
         propertyValue = Float.valueOf(floatParameter(i));
-        decimalPropertyName = "radius_";
-        isDesignParameter = false;
         needsGenerating = true;
         break;
-      case T.bitset:
-      case T.expressionBegin:
-        if (typeSeen)
-          invPO();
-        if (++nAtomSets > 2)
-          eval.bad();
-        if ("to".equals(setPropertyName))
-          needsGenerating = true;
-        propertyName = setPropertyName;
-        setPropertyName = "to";
-        propertyValue = atomExpressionAt(i);
-        i = eval.iToken;
+      case T.offset:
+        eval.theTok = T.facecenteroffset;
+        //$FALL-THROUGH$
+      case T.facecenteroffset:
+        setShapeProperty(JC.SHAPE_POLYHEDRA, "collapsed", Boolean.TRUE);
+        //$FALL-THROUGH$
+      case T.planarparam:
+      case T.distancefactor:
+        propertyName = T.nameOf(eval.theTok);
+        switch (tokAt(i + 1)) {
+        // wish I had not done this. Inconsistent with general syntax; only used here
+        case T.opEQ:
+        case T.comma:
+          i++;
+          break;
+        }
+        propertyValue = Float.valueOf(floatParameter(++i));
         break;
       case T.to:
         if (nAtomSets > 1)
           invPO();
-        if (tokAt(i + 1) == T.bitset || tokAt(i + 1) == T.expressionBegin
+        if ((tokAt(++i) == T.bitset || tokAt(i) == T.expressionBegin)
             && !needsGenerating) {
+          // select... polyhedron .... to ....
           propertyName = "toBitSet";
-          propertyValue = atomExpressionAt(++i);
-          i = eval.iToken;
-          needsGenerating = true;
+          propertyValue = atomExpressionAt(i);
+        } else if (eval.isArrayParameter(i)) {
+          // select... polyhedron .... to [...]
+          // polyhedron {...} to [...]
+          propertyName = "toVertices";
+          propertyValue = eval.getPointArray(i, -1, false);
+        } else {
+          error(ScriptError.ERROR_insufficientArguments);
+        }
+        i = eval.iToken;
+        needsGenerating = true;
+        break;
+      case T.bitset:
+      case T.expressionBegin:
+        if (typeSeen)
+          invPO();
+        switch (++nAtomSets) {
+        case 1:
+          propertyName = "centers";
           break;
-        } else if (eval.isArrayParameter(i + 1)) {
-          propertyName = "toVertices";
-          propertyValue = eval.getPointArray(i + 1, -1, false);
-          i = eval.iToken;
+        case 2:
+          propertyName = "to";
           needsGenerating = true;
           break;
-        } else if (!needsGenerating) {
-          error(ScriptError.ERROR_insufficientArguments);
+        default:
+          eval.bad();
         }
-        setPropertyName = "to";
-        continue;
-      case T.facecenteroffset:
-      case T.planarparam:
-      case T.distancefactor:
-//        if (nAtomSets == 0)
-//          error(ScriptError.ERROR_insufficientArguments);
-        decimalPropertyName = T.nameOf(eval.theTok);
-        isDesignParameter = true;
-        continue;
+        propertyValue = atomExpressionAt(i);
+        i = eval.iToken;
+        if (i + 1 == slen)
+          needsGenerating = true;
+        break;
       case T.color:
       case T.translucent:
       case T.opaque:
         translucentLevel = getColorTrans(eval, i, true, colorArgb);
         i = eval.iToken;
         continue;
+        //      case T.flat: // removed in Jmol 14.4 -- never documented
       case T.collapsed:
-      case T.flat:
-        propertyName = "collapsed";
-        propertyValue = (eval.theTok == T.collapsed ? Boolean.TRUE
-            : Boolean.FALSE);
+        // COLLAPSED
+        // COLLAPSED [faceCenterOffset]
         if (typeSeen)
           error(ScriptError.ERROR_incompatibleArguments);
         typeSeen = true;
+        if (isFloatParameter(i + 1))
+          setShapeProperty(JC.SHAPE_POLYHEDRA, "faceCenterOffset",
+              Float.valueOf(floatParameter(++i)));
+        propertyName = "collapsed";
+        propertyValue = Boolean.TRUE;
         break;
-      case T.triangles:
-      case T.notriangles:
-        propertyName = "token";
-        propertyValue = Integer.valueOf(e.theTok);
-        break;
       case T.noedges:
       case T.edges:
       case T.frontedges:
         if (edgeParameterSeen)
           error(ScriptError.ERROR_incompatibleArguments);
-        propertyName = paramAsStr(i);
         edgeParameterSeen = true;
+        propertyName = T.nameOf(eval.iToken);
         break;
+      case T.triangles:
+      case T.notriangles:
+      case T.backlit:
+      case T.frontlit:
       case T.fullylit:
-        lighting = eval.theTok;
+        // never implemented or 
+        //        lighting = eval.theTok;
         continue;
       default:
         if (eval.isColorParam(i)) {
@@ -3322,18 +3346,21 @@
       if (onOffDelete)
         return false;
     }
-    if (!needsGenerating && !typeSeen && !edgeParameterSeen && lighting == 0)
+    if (needsGenerating) {
+      if (!typeSeen && haveBonds)
+        setShapeProperty(JC.SHAPE_POLYHEDRA, "bonds", null);
+      setShapeProperty(JC.SHAPE_POLYHEDRA, "generate", null);
+    } else if (!edgeParameterSeen) {// && lighting == T.nada)
       error(ScriptError.ERROR_insufficientArguments);
-    if (needsGenerating)
-      setShapeProperty(JC.SHAPE_POLYHEDRA, "generate", null);
+    }
     if (colorArgb[0] != Integer.MIN_VALUE)
       setShapeProperty(JC.SHAPE_POLYHEDRA, "colorThis",
           Integer.valueOf(colorArgb[0]));
     if (translucentLevel != Float.MAX_VALUE)
       eval.setShapeTranslucency(JC.SHAPE_POLYHEDRA, "", "translucentThis",
           translucentLevel, null);
-    if (lighting != 0)
-      setShapeProperty(JC.SHAPE_POLYHEDRA, "token", Integer.valueOf(lighting));
+    //    if (lighting != T.nada)
+    //      setShapeProperty(JC.SHAPE_POLYHEDRA, "token", Integer.valueOf(lighting));
     setShapeProperty(JC.SHAPE_POLYHEDRA, "init", Boolean.FALSE);
     return true;
   }

Modified: trunk/Jmol/src/org/jmol/shapespecial/Polyhedra.java
===================================================================
--- trunk/Jmol/src/org/jmol/shapespecial/Polyhedra.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/shapespecial/Polyhedra.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -56,16 +56,15 @@
 public class Polyhedra extends AtomShape {
 
   private final static float DEFAULT_DISTANCE_FACTOR = 1.85f;
-  //  private final static float DEFAULT_MANY_VERTEX_DISTANCE_FACTOR = 1.5f;
   private final static float DEFAULT_FACECENTEROFFSET = 0.25f;
   private final static int EDGES_NONE = 0;
   public final static int EDGES_ALL = 1;
   public final static int EDGES_FRONT = 2;
   private final static int MAX_VERTICES = 250;
   private final static int FACE_COUNT_MAX = MAX_VERTICES - 3;
-  private P3[] otherAtoms = new P3[MAX_VERTICES + 1];
+  private P3[] otherAtoms = new P3[MAX_VERTICES + FACE_COUNT_MAX + 1];
   private V3[] normalsT = new V3[MAX_VERTICES + 1];
-  private int[][] planesT = new int[MAX_VERTICES][3];
+  private int[][] planesT = AU.newInt2(MAX_VERTICES);
   private final static P3 randomPoint = P3.new3(3141f, 2718f, 1414f);
 
   private static final int MODE_BONDING = 1;
@@ -103,7 +102,6 @@
   private float planarParam;
   private Map<String, SV> info;
   private float distanceRef;
-  private int nBondsRef;
 
   @SuppressWarnings("unchecked")
   @Override
@@ -179,7 +177,7 @@
 
     if ("toVertices" == propertyName) {
       P3[] points = (P3[]) value;
-      nPoints = points.length;
+      nPoints = Math.min(points.length, MAX_VERTICES);
       for (int i = nPoints; --i >= 0;)
         otherAtoms[i] = points[i];
       return;
@@ -271,14 +269,15 @@
       //allow super
     }
 
-    if ("token" == propertyName) {
-      int tok = ((Integer) value).intValue();
-      if (tok == T.triangles && tok == T.notriangles) {
-      } else {
-        setLighting(tok == T.fullylit, bs);
-      }
-      return;
-    }
+//    if ("token" == propertyName) {
+//      int tok = ((Integer) value).intValue();
+//      Swit
+//      if (tok == T.triangles && tok == T.notriangles) {
+//      } else {
+//        setLighting(tok == T.fullylit, bs);
+//      }
+//      return;
+//    }
 
     if ("radius" == propertyName) {
       radius = ((Float) value).floatValue();
@@ -289,11 +288,10 @@
       int modelIndex = ((int[]) ((Object[]) value)[2])[0];
       for (int i = polyhedronCount; --i >= 0;) {
         polyhedrons[i].info = null;
-        if (polyhedrons[i].modelIndex == modelIndex) {
+        int mi = polyhedrons[i].centralAtom.mi;
+        if (mi == modelIndex) {
           polyhedronCount--;
           polyhedrons = (Polyhedron[]) AU.deleteElements(polyhedrons, i, 1);
-        } else if (polyhedrons[i].modelIndex > modelIndex) {
-          polyhedrons[i].modelIndex--;
         }
       }
       //pass on to AtomShape
@@ -310,9 +308,9 @@
         s += polyhedrons[i].getSymmetry(vwr, true) + "\n";
       return s;
     }
-    return null;  
+    return null;
   }
-  
+
   @Override
   public boolean getPropertyData(String property, Object[] data) {
     int iatom;
@@ -329,8 +327,10 @@
       return false;
     }
     if (property == "move") {
+      M4 mat = (M4) data[1];
+      if (mat == null)
+        return false;
       BS bs = (BS) data[0];
-      M4 mat = (M4) data[1];
       for (int i = polyhedronCount; --i >= 0;) {
         Polyhedron p = polyhedrons[i];
         if (bs.get(p.centralAtom.i))
@@ -391,17 +391,17 @@
     return lst;
   }
 
-  private void setLighting(boolean isFullyLit, BS bs) {
-    for (int i = polyhedronCount; --i >= 0;)
-      if (bs.get(polyhedrons[i].centralAtom.i)) {
-        short[] normixes = polyhedrons[i].getNormixes();
-        polyhedrons[i].isFullyLit = isFullyLit;
-        for (int j = normixes.length; --j >= 0;) {
-          if (normixes[j] < 0 != isFullyLit)
-            normixes[j] = (short) ~normixes[j];
-        }
-      }
-  }
+//  private void setLighting(boolean isFullyLit, BS bs) {
+//    for (int i = polyhedronCount; --i >= 0;)
+//      if (bs.get(polyhedrons[i].centralAtom.i)) {
+//        short[] normixes = polyhedrons[i].getNormixes();
+//        polyhedrons[i].isFullyLit = isFullyLit;
+//        for (int j = normixes.length; --j >= 0;) {
+//          if (normixes[j] < 0 != isFullyLit)
+//            normixes[j] = (short) ~normixes[j];
+//        }
+//      }
+//  }
 
   private BS andBitSet(BS bs) {
     BS bsCenters = new BS();
@@ -435,17 +435,19 @@
     }
   }
 
+  private int buildMode;
+
   private void buildPolyhedra() {
     boolean useBondAlgorithm = radius == 0 || bondedOnly;
-    int mode = (info != null ? MODE_INFO : nPoints > 0 ? MODE_POINTS
+    buildMode = (info != null ? MODE_INFO : nPoints > 0 ? MODE_POINTS
         : haveBitSetVertices ? MODE_BITSET : useUnitCell ? MODE_UNITCELL
             : useBondAlgorithm ? MODE_BONDING : MODE_ITERATE);
-    AtomIndexIterator iter = (mode == MODE_ITERATE ? ms
+    AtomIndexIterator iter = (buildMode == MODE_ITERATE ? ms
         .getSelectedAtomIterator(null, false, false, false, false) : null);
     for (int i = centers.nextSetBit(0); i >= 0; i = centers.nextSetBit(i + 1)) {
       Atom atom = atoms[i];
       Polyhedron p = null;
-      switch (mode) {
+      switch (buildMode) {
       case MODE_BITSET:
         bsVertices.clear(i);
         p = constructBitSetPolyhedron(atom);
@@ -529,7 +531,7 @@
         if (!bond.isCovalent())
           continue;
         Atom other = bond.getOtherAtom(atom);
-        if (bsVertices != null && !bsVertices.get(i) || radius > 0
+        if (bsVertices != null && !bsVertices.get(other.i) || radius > 0
             && other.distance(atom) > radius)
           continue;
         otherAtoms[bondCount++] = other;
@@ -537,7 +539,6 @@
           break;
       }
     }
-    nBondsRef = bondCount;
     distanceRef = 0;
     return (bondCount < 3 || bondCount >= MAX_VERTICES || nVertices > 0
         && !bsVertexCount.get(bondCount) ? null : validatePolyhedron(atom,
@@ -546,7 +547,6 @@
 
   private Polyhedron constructBitSetPolyhedron(Atom atom) {
     int otherAtomCount = 0;
-    nBondsRef = bsVertices.cardinality();
     distanceRef = 0;
     for (int i = bsVertices.nextSetBit(0); i >= 0; i = bsVertices
         .nextSetBit(i + 1))
@@ -556,12 +556,12 @@
 
   private Polyhedron constructRadiusPolyhedron(Atom atom, AtomIndexIterator iter) {
     int otherAtomCount = 0;
-    nBondsRef = 0;
     distanceRef = radius;
     while (iter.hasNext()) {
       Atom other = atoms[iter.next()];
       P3 pt = iter.getPosition();
       if (pt == null) {
+        // this will happen with standard radius atom iterator
         pt = other;
         if (bsVertices != null && !bsVertices.get(other.i)
             || atom.distance(pt) > radius)
@@ -579,62 +579,64 @@
   }
 
   private Polyhedron validatePolyhedron(Atom centralAtom, int vertexCount,
-                                        P3[] otherAtoms) {
+                                        P3[] points) {
+    boolean collapsed = isCollapsed;
+    boolean checkDist = (distanceRef != 0);
     int planeCount = 0;
-    int iCenter = vertexCount;
-    int nPoints = iCenter + 1;
-    float distMax = 0;
-    float dAverage = 0;
+    int nPoints = vertexCount + 1;
+    int ni = vertexCount - 2;
+    int nj = vertexCount - 1;
     float planarParam = (Float.isNaN(this.planarParam) ? DEFAULT_PLANAR_PARAM
         : this.planarParam);
-    P3[] points = new P3[MAX_VERTICES * 3];
-    points[iCenter] = otherAtoms[iCenter] = centralAtom;
-    for (int i = 0; i < iCenter; i++) {
-      points[i] = otherAtoms[i];
-      dAverage += points[iCenter].distance(points[i]);
-    }
-    dAverage = dAverage / iCenter;
-    boolean isOK = (dAverage == 0);
-    int nRef = iCenter;
-    int nother1 = iCenter - 1;
-    int nother2 = iCenter - 2;
     float factor = (!Float.isNaN(distanceFactor) ? distanceFactor
         : DEFAULT_DISTANCE_FACTOR);
-    BS bs = BS.newN(iCenter);
+    BS bs = BS.newN(vertexCount);
 
     // here we are assuring that at least ONE face is drawn to 
-    // all matching vertices
+    // all matching vertices -- skip this for BOND polyhedra
 
-    while (!isOK && factor < 10.0f) {
-      distMax = dAverage * factor;
-      bs.setBits(0, iCenter);
-      for (int i = 0; i < nother2; i++)
-        for (int j = i + 1; j < nother1; j++) {
-          if (points[i].distance(points[j]) > distMax)
-            continue;
-          for (int k = j + 1; k < iCenter; k++) {
-            if (points[i].distance(points[k]) > distMax
-                || points[j].distance(points[k]) > distMax)
+    points[vertexCount] = centralAtom;
+    P3 ptAve = new P3();
+    for (int i = 0; i < vertexCount; i++)
+      ptAve.add(points[i]);
+    ptAve.scale(1f / vertexCount);
+    float distMax = 0;
+    if (checkDist) {
+      float dAverage = 0;
+      for (int i = 0; i < vertexCount; i++)
+        dAverage += points[vertexCount].distance(points[i]);
+      dAverage /= vertexCount;
+      boolean isOK = (dAverage == 0);
+      while (!isOK && factor < 10.0f) {
+        distMax = dAverage * factor;
+        bs.setBits(0, vertexCount);
+        for (int i = 0; i < ni; i++)
+          for (int j = i + 1; j < nj; j++) {
+            if (points[i].distance(points[j]) > distMax)
               continue;
-            bs.clear(i);
-            bs.clear(j);
-            bs.clear(k);
+            for (int k = j + 1; k < vertexCount; k++) {
+              if (points[i].distance(points[k]) > distMax
+                  || points[j].distance(points[k]) > distMax)
+                continue;
+              bs.clear(i);
+              bs.clear(j);
+              bs.clear(k);
+            }
           }
-        }
-      isOK = true;
-      for (int i = 0; i < iCenter; i++)
-        if (bs.get(i)) {
-          isOK = false;
-          factor *= 1.05f;
-          if (Logger.debugging) {
-            Logger.debug("Polyhedra distanceFactor for " + iCenter
-                + " atoms increased to " + factor + " in order to include "
-                + otherAtoms[i]);
+        isOK = true;
+        for (int i = 0; i < vertexCount; i++)
+          if (bs.get(i)) {
+            isOK = false;
+            factor *= 1.05f;
+            if (Logger.debugging) {
+              Logger.debug("Polyhedra distanceFactor for " + vertexCount
+                  + " atoms increased to " + factor + " in order to include "
+                  + points[i]);
+            }
+            break;
           }
-          break;
-        }
+      }
     }
-
     /*  Start by defining a face to be when all three distances
      *  are < distanceFactor * (longest central) but if a vertex is missed, 
      *  then expand the range. The collapsed trick is to introduce 
@@ -652,53 +654,40 @@
      *  For these special cases, then, we define a reference point just behind the plane
      */
 
-    // produce face-centered catalog and facet-aligned catalog
-    String facesThroughCenter = "";
-    String ignoreFlat = "";
-    P3 ptRef = P3.newP(points[iCenter]);
-    for (int i = 0; i < nother2; i++)
-      for (int j = i + 1; j < nother1; j++)
-        for (int k = j + 1; k < iCenter; k++) {
-          if (isPlanar(points[i], points[j], points[k], ptRef)) {
-            facesThroughCenter += faceId(i, j, k);
-            if (isAligned(points[i], points[j], ptRef))
-              ignoreFlat += faceId(i, j, -1);
-            if (isAligned(points[j], points[k], ptRef))
-              ignoreFlat += faceId(j, k, -1);
-            if (isAligned(points[i], points[k], ptRef))
-              ignoreFlat += faceId(i, k, -1);
-          }
-        }
-    ptRef = new P3();
+    P3 ptRef = P3.newP(ptAve);
+    BS bsThroughCenter = new BS();
+    for (int pt = 0, i = 0; i < ni; i++)
+      for (int j = i + 1; j < nj; j++)
+        for (int k = j + 1; k < vertexCount; k++, pt++)
+          if (isPlanar(points[i], points[j], points[k], ptRef))
+            bsThroughCenter.set(pt);
     // this next check for distance allows for bond AND distance constraints
-    int[][] p = planesT;
+    int[][] faces = planesT;
     P4 pTemp = new P4();
     V3 nTemp = new V3();
     float offset = faceCenterOffset;
     int fmax = FACE_COUNT_MAX;
     int vmax = MAX_VERTICES;
-    P3 rpt = randomPoint;
     BS bsTemp = Normix.newVertexBitSet();
     BS bsTemp1 = new BS();
     V3[] normals = normalsT;
     Map<Object, Object> htNormMap = new Hashtable<Object, Object>();
-    BS bsFlat = new BS();
-    String facet;
+    BS bsCenterPlanes = new BS();
     V3 vTemp = vAC;
-    boolean isComplex = (iCenter >= 5);
-    boolean doAllowFlat = !isComplex && !useUnitCell;
-    boolean collapsed = isCollapsed;
-    for (int i = 0; i < nother2; i++)
-      for (int j = i + 1; j < nother1; j++) {
-        if (points[i].distance(points[j]) > distMax)
+    for (int i = 0, pt = 0; i < ni; i++)
+      for (int j = i + 1; j < nj; j++) {
+        if (checkDist && points[i].distance(points[j]) > distMax) {
+          pt += vertexCount - j - 1;
           continue;
-        for (int k = j + 1; k < iCenter; k++) {
-          if (points[i].distance(points[k]) > distMax
-              || points[j].distance(points[k]) > distMax)
+        }
+        for (int k = j + 1; k < vertexCount; k++, pt++) {
+          if (checkDist
+              && (points[i].distance(points[k]) > distMax || points[j]
+                  .distance(points[k]) > distMax))
             continue;
           if (planeCount >= fmax) {
             Logger.error("Polyhedron error: maximum face(" + fmax
-                + ") -- reduce RADIUS or DISTANCEFACTOR");
+                + ") -- reduce RADIUS");
             return null;
           }
           if (nPoints >= vmax) {
@@ -706,108 +695,76 @@
                 + ") -- reduce RADIUS");
             return null;
           }
-          boolean isFlat = (facesThroughCenter.indexOf(faceId(i, j, k)) >= 0);
-          if (isFlat && !doAllowFlat)
+          boolean isThroughCenter = bsThroughCenter.get(pt);
+          P3 rpt = (isThroughCenter ? randomPoint : ptAve);
+          V3 normal = new V3();
+          boolean isWindingOK = getNormalFromCenter(rpt, points[i], points[j],
+              points[k], !isThroughCenter, normal);
+          // the standard face:
+          normals[planeCount] = normal;
+          faces[planeCount] = new int[] { isWindingOK ? i : j, isWindingOK ? j : i,
+              k, -7 };
+          if (!checkFace(points, vertexCount, faces, normals, planeCount, pTemp, nTemp,
+              vTemp, htNormMap, planarParam, bsTemp, bsTemp1))
             continue;
-          // if center is on the face, then we need an arbitrary reference point to 
-          // define the normal
-          boolean isSpecial = collapsed;
-          V3 normal = new V3();
-          boolean isWindingOK;
-          if (isFlat) {
-            isWindingOK = getNormalFromCenter(rpt, points[i], points[j],
-                points[k], false, normal);
+          if (isThroughCenter) {
+            bsCenterPlanes.set(planeCount++);
+          } else if (collapsed) {
+            ptRef.setT(points[nPoints] = new P3());
+            points[nPoints].scaleAdd2(offset, normal, centralAtom);
+            addFacet(i, j, k, ptRef, points, normals, faces, planeCount++, nPoints,
+                isWindingOK);
+            addFacet(k, i, j, ptRef, points, normals, faces, planeCount++, nPoints,
+                isWindingOK);
+            addFacet(j, k, i, ptRef, points, normals, faces, planeCount++, nPoints,
+                isWindingOK);
+            nPoints++;
           } else {
-            isWindingOK = getNormalFromCenter(points[iCenter], points[i],
-                points[j], points[k], true, normal);
-            // the standard face:
-            p[planeCount] = new int[] { isWindingOK ? i : j,
-                isWindingOK ? j : i, k, -7 };
-            normals[planeCount] = normal;
-            if (isComplex
-                && !checkFace(points, iCenter, p, normals, planeCount, pTemp,
-                    nTemp, vTemp, htNormMap, planarParam, bsTemp, bsTemp1))
-              continue;
-//            System.out.println("draw ID \"d" + faceId(i, j, k) + "\" VECTOR "
-//                + ptRef + " " + normal + "\">" + faceId(i, j, k) + isWindingOK
-//                + "\"");
-          }
-          if (!isFlat && !isSpecial) {
             planeCount++;
-            continue;
           }
-          if (isFlat) {
-            ptRef.sub2(points[iCenter], normal);
-            nRef = iCenter;
-          } else {
-            nRef = nPoints;
-            otherAtoms[nPoints] = points[nPoints] = new P3();
-            points[nPoints++].scaleAdd2(offset, normal, points[iCenter]);
-          }
-          // facet i j k
-          if (!collapsed) {
-            facet = faceId(i, j, -1);
-            isSpecial = (ignoreFlat.indexOf(facet) < 0);
-            if (isSpecial) {
-              ignoreFlat += facet;
-              bsFlat.set(planeCount);
-            }
-          }
-          if (isSpecial) {
-            p[planeCount] = new int[] { isWindingOK ? i : j,
-                isWindingOK ? j : i, nRef, isFlat ? -15 : -6 };
-            getNormalFromCenter(points[k], points[i], points[j], ptRef, false,
-                normal);
-            normals[planeCount++] = normal;
-          }
-          // facet i k j
-          if (!collapsed) {
-            facet = faceId(i, k, -1);
-            isSpecial = (ignoreFlat.indexOf(facet) < 0);
-            if (isSpecial) {
-              ignoreFlat += facet;
-              bsFlat.set(planeCount);
-            }
-          }
-          if (isSpecial) {
-            p[planeCount] = new int[] { isWindingOK ? i : k, nRef,
-                isWindingOK ? k : i, isFlat ? -15 : -5 };
-            getNormalFromCenter(points[j], points[i], ptRef, points[k], false,
-                normal);
-            normals[planeCount++] = normal;
-          }
-          // face j k i
-          if (!collapsed) {
-            facet = faceId(j, k, -1);
-            isSpecial = (ignoreFlat.indexOf(facet) < 0);
-            if (isSpecial) {
-              ignoreFlat += facet;
-              bsFlat.set(planeCount);
-            }
-          }
-          if (isSpecial) {
-            p[planeCount] = new int[] { nRef, isWindingOK ? j : k,
-                isWindingOK ? k : j, isFlat ? -15 : -4 };
-            getNormalFromCenter(points[i], ptRef, points[j], points[k], false,
-                normal);
-            normals[planeCount++] = normal;
-          }
         }
       }
     nPoints--;
-
     if (Logger.debugging) {
       Logger
           .info("Polyhedron planeCount=" + planeCount + " nPoints=" + nPoints);
       for (int i = 0; i < planeCount; i++)
-        Logger.info("Polyhedron " + getKey(p[i], i));
+        Logger.info("Polyhedron " + PT.toJSON("face[" +i + "]", faces[i]));
     }
-    return new Polyhedron().set(centralAtom, iCenter, nPoints, planeCount,
-        otherAtoms, normals, bsFlat, p, collapsed, distanceRef);
+    return new Polyhedron().set(centralAtom, points, nPoints, vertexCount,
+        faces, planeCount, normals, bsCenterPlanes, collapsed, distanceRef);
   }
 
   /**
+   * Add one of the three "facets" that compose the planes of a "collapsed" polyhedron.
+   * A mask of -2 ensures that only the [1-2] edge is marked as an outer edge.
    * 
+   * @param i
+   * @param j
+   * @param k
+   * @param ptRef slightly out from the center; based on centerOffset parameter
+   * @param points
+   * @param normals
+   * @param faces
+   * @param planeCount
+   * @param nRef
+   * @param isWindingOK
+   */
+  private void addFacet(int i, int j, int k, P3 ptRef, P3[] points,
+                        V3[] normals, int[][] faces, int planeCount, int nRef,
+                        boolean isWindingOK) {
+    V3 normal = new V3();
+    getNormalFromCenter(points[k], ptRef, points[i], points[j], false, normal);
+    normals[planeCount] = normal;
+    faces[planeCount] = new int[] { nRef, isWindingOK ? i : j, isWindingOK ? j : i,
+        -2 };
+    //            System.out.println("draw ID \"d" + faceId(i, j, k) + "\" VECTOR "
+    //              + ptRef + " " + normal + " color blue \">" + faceId(i, j, k) + isWindingOK
+    //            + "\"");
+  }
+
+  /**
+   * 
    * @param ptCenter
    * @param ptA
    * @param ptB
@@ -828,43 +785,38 @@
   }
 
   /**
-   * Clean out oeverlapping triangles based on normals and cross products. 
-   * For now, we use normixes, which are approximations of normals. 
-   * It is not 100% guaranteed that this will work.
+   * Clean out overlapping triangles based on normals and cross products. For
+   * now, we use normixes, which are approximations of normals. It is not 100%
+   * guaranteed that this will work.
    * 
    * @param points
-   * @param ptCenter
+   * @param nPoints
    * @param planes
    * @param normals
    * @param index
    * @param pTemp
    * @param vNorm
+   * @param vTemp
    * @param htNormMap
    * @param planarParam
    * @param bsTemp
+   * @param bsPts
    * @return true if valid
    */
-  private boolean checkFace(P3[] points, int ptCenter, int[][] planes,
-                             V3[] normals, int index, P4 pTemp, V3 vNorm, V3 vTemp,
-                             Map<Object, Object> htNormMap, float planarParam,
-                             BS bsTemp, BS bsPts) {
+  private boolean checkFace(P3[] points, int nPoints, int[][] planes,
+                            V3[] normals, int index, P4 pTemp, V3 vNorm,
+                            V3 vTemp, Map<Object, Object> htNormMap,
+                            float planarParam, BS bsTemp, BS bsPts) {
     int[] p1 = planes[index];
 
     // Check here for a 3D convex hull: 
     pTemp = Measure.getPlaneThroughPoints(points[p1[0]], points[p1[1]],
         points[p1[2]], vNorm, vTemp, pTemp);
-    //    P3 ptest = P3.newP(points[p1[0]]);
-    //    ptest.add(points[p1[1]]);
-    //    ptest.add(points[p1[2]]);
-    //    ptest.scale(1/3f);
-    //    System.out.println("$draw ID p" + index +" vector " + ptest  + vNorm);
-
     // See if all vertices are OUTSIDE the the plane we are considering.      
-    for (int j = 0; j < ptCenter; j++) {
+    for (int j = 0; j < nPoints; j++) {
       vTemp.sub2(points[p1[0]], points[j]);
       float v = vTemp.dot(vNorm);
-      if (v < -0.1) {
-        //System.out.println("$draw ID p" + index + "_" + j + points[j]); 
+      if (v < -0.15) {
         return false;
       }
     }
@@ -877,14 +829,14 @@
       for (Entry<Object, Object> e : htNormMap.entrySet()) {
         Object ikey = e.getKey();
         if (ikey instanceof Integer) {
-          Integer n = (Integer)ikey;
+          Integer n = (Integer) ikey;
           if (norms[n.intValue()].dot(norm) > planarParam) {
             normix = n;
             break;
           }
         }
       }
-      htNormMap.put(normix,  Boolean.TRUE);    
+      htNormMap.put(normix, Boolean.TRUE);
     }
     bsPts.clearAll();
     for (int i = 0; i < 3; i++)
@@ -894,13 +846,13 @@
   }
 
   /**
-   * Check each edge to see that 
+   * Check each edge to see that
    * 
    * (a) it has not been used before
    * 
    * (b) it does not have vertex points on both sides of it
    * 
-   * (c) if it runs opposite another edge, then both edge masks are set properly 
+   * (c) if it runs opposite another edge, then both edge masks are set properly
    * 
    * @param htNormMap
    * @param normix
@@ -921,7 +873,6 @@
     String edge = normix + s + s1;
     if (htNormMap.containsKey(edge))
       return false;
-//    System.out.println(edge);
     //reverse maps are in
     String edge0 = normix + s1 + s;
     Object o = htNormMap.get(edge0);
@@ -956,36 +907,11 @@
     return true;
   }
 
-  private String getKey(int[] p1, int index) {
-    SB sb = new SB();
-    for (int i = 0, n = p1.length; i < n; i++)
-      if (p1[i] >= 0)
-        sb.append("_").appendI(p1[i]);
-    sb.append("_").appendI(p1[0]);
-    sb.append("_,").appendI(index).append(";");
-    return sb.toString();
-  }
-
-  private String faceId(int i, int j, int k) {
-    return "[" + i + "," + j + "," + k + "]";
-  }
-
-  private V3 align1 = new V3();
-  private V3 align2 = new V3();
-
-  private boolean isAligned(P3 pt1, P3 pt2, P3 pt3) {
-    align1.sub2(pt1, pt3);
-    align2.sub2(pt2, pt3);
-    float angle = align1.angle(align2);
-    return (angle < 0.01f || angle > 3.13f);
-  }
-
   private final V3 vAB = new V3();
   private final V3 vAC = new V3();
   private final V3 vBC = new V3();
-  
 
-  private static float minDistanceForPlanarity = 0.1f;
+  private static float MAX_DISTANCE_TO_PLANE = 0.1f;
 
   private boolean isPlanar(P3 pt1, P3 pt2, P3 pt3, P3 ptX) {
     /*
@@ -997,7 +923,7 @@
     V3 norm = new V3();
     float w = Measure.getNormalThroughPoints(pt1, pt2, pt3, norm, vAB);
     float d = Measure.distanceToPlaneV(norm, w, ptX);
-    return (Math.abs(d) < minDistanceForPlanarity);
+    return (Math.abs(d) < MAX_DISTANCE_TO_PLANE);
   }
 
   @Override
@@ -1011,7 +937,7 @@
       Polyhedron p = polyhedrons[i];
       if (ms.at[p.centralAtom.i].isDeleted())
         p.isValid = false;
-      p.visibilityFlags = (p.visible && bsModels.get(p.modelIndex)
+      p.visibilityFlags = (p.visible && bsModels.get(p.centralAtom.mi)
           && !ms.isAtomHidden(p.centralAtom.i)
           && !ms.at[p.centralAtom.i].isDeleted() ? vf : 0);
       if (p.visibilityFlags != 0)

Modified: trunk/Jmol/src/org/jmol/shapespecial/Polyhedron.java
===================================================================
--- trunk/Jmol/src/org/jmol/shapespecial/Polyhedron.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/shapespecial/Polyhedron.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -26,16 +26,16 @@
 
 public class Polyhedron {
 
-  int modelIndex;
   public Atom centralAtom;
   public P3[] vertices;
   public int[][] faces;
   int nVertices;
-  boolean collapsed = false;
+  boolean collapsed;
   private BS bsFlat;
-  
+  private float distanceRef;  
   private V3[] normals;
   private short[] normixes;
+
   public String smiles, smarts, stereoSmiles;
   private SymmetryInterface pointGroup;
   private Float volume;
@@ -45,24 +45,22 @@
   public boolean isValid = true;
   public short colixEdge = C.INHERIT_ALL;
   public int visibilityFlags = 0;
-  private float distanceRef;
 
   Polyhedron() {  
   }
   
-  Polyhedron set(Atom centralAtom, int nVertices, int nPoints, int planeCount,
-      P3[] otherAtoms, V3[] normals, BS bsFlat, int[][] planes, boolean collapsed, float distanceRef) {
+  Polyhedron set(Atom centralAtom, P3[] points, int nPoints, int vertexCount,
+      int[][] planes, int planeCount, V3[] normals, BS bsFlat, boolean collapsed, float distanceRef) {
     this.distanceRef = distanceRef;
     this.centralAtom = centralAtom;
-    modelIndex = centralAtom.mi;
-    this.nVertices = nVertices;
+    this.nVertices = vertexCount;
     this.vertices = new P3[nPoints + 1];
     this.normals = new V3[planeCount];
     this.bsFlat = bsFlat;
     this.faces = AU.newInt2(planeCount);
     for (int i = nPoints + 1; --i >= 0;)
       // includes central atom as last atom or possibly reference point
-      vertices[i] = otherAtoms[i];
+      vertices[i] = points[i];
     for (int i = planeCount; --i >= 0;)
       this.normals[i] = V3.newV(normals[i]);
     for (int i = planeCount; --i >= 0;)
@@ -85,7 +83,6 @@
       info.put("atomNumber", Integer.valueOf(centralAtom.getAtomNumber()));
       info.put("atomName", centralAtom.getInfo());
       info.put("element", centralAtom.getElementSymbol());
-      info.put("vertexCount", Integer.valueOf(nVertices));
       info.put("faceCount", Integer.valueOf(faces.length));
       info.put("volume", getVolume());
       if (smarts != null)
@@ -103,10 +100,15 @@
       info.put("bsFlat", bsFlat);
       if (collapsed)
         info.put("collapsed", Boolean.valueOf(collapsed));
-      info.put("ptRef", vertices[nVertices]);
+      info.put("distanceRef", Float.valueOf(distanceRef));
     }
+    info.put("vertexCount", Integer.valueOf(nVertices));
     info.put("atomIndex", Integer.valueOf(centralAtom.i));
-    info.put("vertices", AU.arrayCopyPt(vertices, nVertices));
+    info.put("vertices", AU.arrayCopyPt(vertices, (isAll ? nVertices : vertices.length)));
+    P3[] n = new P3[normals.length];
+    for (int i = n.length; --i >= 0;)
+      n[i] = P3.newP(normals[i]);
+    info.put("normals", n);
     info.put("faces", AU.arrayCopyII(faces, faces.length));
     int[] elemNos = new int[nVertices];
     for (int i = 0; i < nVertices; i++) {
@@ -120,12 +122,25 @@
 
   Polyhedron setInfo(Map<String, SV> info, Atom[] at) {
     try {
+      collapsed = info.containsKey("collapsed");
       centralAtom = at[info.get("atomIndex").intValue];
-      modelIndex = centralAtom.mi;
       Lst<SV> lst = info.get("vertices").getList();
-      vertices = new P3[lst.size() + 1];
-      nVertices = vertices.length - 1;
-      for (int i = nVertices; --i >= 0;)
+      SV vc = info.get("vertexCount");
+      if (vc == null) {
+        // old style
+        nVertices = lst.size();
+        vertices = new P3[nVertices + 1];
+        vertices[nVertices] = SV.ptValue(info.get("ptRef"));
+      } else {
+        nVertices = vc.intValue;
+        vertices = new P3[lst.size()];
+        vc = info.get("distanceRef");
+        if (vc != null)
+          distanceRef = vc.asFloat();
+      }
+      // note that nVertices will be smaller than lst.size()
+      // because lst will contain the central atom and any collapsed points
+      for (int i = lst.size(); --i >= 0;)
         vertices[i] = SV.ptValue(lst.get(i));
       lst = info.get("elemNos").getList();
       for (int i = nVertices; --i >= 0;) {
@@ -137,7 +152,6 @@
           vertices[i] = p;
         }
       }
-      vertices[nVertices] = SV.ptValue(info.get("ptRef"));
       lst = info.get("faces").getList();
       faces = AU.newInt2(lst.size());
       normals = new V3[faces.length];
@@ -153,7 +167,6 @@
             vertices[a[2]], normals[i], vAB);
       }
       bsFlat = SV.getBitSet(info.get("bsFlat"), false);
-      collapsed = info.containsKey("collapsed");
     } catch (Exception e) {
       return null;
     }
@@ -194,13 +207,14 @@
     V3 vAC = new V3();
     V3 vTemp = new V3();
     float v = 0;
-    for (int i = faces.length; --i >= 0;) {
-      int[] face = faces[i];
-      for (int j = face.length - 2; --j >= 0;)
-        if (face[j + 2] >= 0)
-          v += triangleVolume(face[j], face[j + 1], face[j + 2], vAB, vAC,
-              vTemp);
-    }
+    if (bsFlat.cardinality() < faces.length)
+      for (int i = faces.length; --i >= 0;) {
+        int[] face = faces[i];
+        for (int j = face.length - 2; --j >= 0;)
+          if (face[j + 2] >= 0)
+            v += triangleVolume(face[j], face[j + 1], face[j + 2], vAB, vAC,
+                vTemp);
+      }
     return Float.valueOf(v / 6);
   }
 
@@ -214,7 +228,7 @@
   }
 
   String getState(Viewer vwr) {
-    return "  var p = " + Escape.e(getInfo(vwr, false)) + ";polyhedron @p" 
+    return "polyhedron @" + Escape.e(getInfo(vwr, false)) 
         + (isFullyLit ? " fullyLit" : "") + ";"
         + (visible ? "" : "polyhedra ({"+centralAtom.i+"}) off;") + "\n";
   }

Modified: trunk/Jmol/src/org/jmol/viewer/Jmol.properties
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Jmol.properties	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/jmol/viewer/Jmol.properties	2015-09-06 04:09:52 UTC (rev 20757)
@@ -59,8 +59,24 @@
 TODO: image off  stops JSmol
 TODO: Rolf's errors in Safari due to move + zoomto
 
-Jmol.___JmolVersion="14.3.16_2015.09.04"
+Jmol.___JmolVersion="14.3.16_2015.09.05"
 
+new feature: POLYHEDRA
+  -- same as POLYHEDRA BONDS {selected}
+new feature: POLYHEDRA 4
+  -- same as POLYHEDRA 4 BONDS {selected}  
+new feature: POLYHEDRA OFFSET 1.4
+  -- same as POLYHEDRA COLLAPSED faceCenterOffset 1.4
+new feature: POLYHEDRA COLLAPSED 1.4
+  -- same as POLYHEDRA COLLAPSED faceCenterOffset 1.4
+
+code: Polyhedra work, including more efficient algorithms for completing set of faces
+
+bug fix: tracking down thread-safe issue in application console
+bug fix: in Java, mouse should not lose control if moved out of application
+
+JmolVersion="14.3.16_2015.09.04"
+
 bug fix: Mac OS does not add modifiers (left, right, ctrl, etc.) to drag operations
 
 

Modified: trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/AppConsole.java
===================================================================
--- trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/AppConsole.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/AppConsole.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -28,6 +28,7 @@
 import java.awt.Component;
 import java.awt.Container;
 import java.awt.Dimension;
+import java.awt.EventQueue;
 import java.awt.Font;
 import java.awt.Rectangle;
 import java.awt.Window;
@@ -777,7 +778,16 @@
                   : 1) : vwr.getSetHistory(up ? -1
           : 1));
       if (cmd == null) {
-        hBar.setValue(0);
+        EventQueue.invokeLater(new Runnable() {
+          @Override
+          public void run() {
+            try {
+              hBar.setValue(0);
+            } catch (Throwable e) {
+              //
+            }
+          }
+        });
         return;
       }
       boolean isError = false;
@@ -914,16 +924,20 @@
 
         pt = caretPosition.getOffset();
         consoleTextPane.setCaretPosition(pt);
-        try {
-          vBar.setValue(vBar.getMaximum());
-        } catch (Throwable e) {
-          //
-        }
-        
       } catch (Exception e) {
         e.printStackTrace();
         consoleTextPane.setCaretPosition(getLength());
       }
+      EventQueue.invokeLater(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            vBar.setValue(vBar.getMaximum());
+          } catch (Throwable e) {
+            //
+          }
+        }
+      });
     }
 
     void outputError(String strError) {

Modified: trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/ConsoleTextArea.java
===================================================================
--- trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/ConsoleTextArea.java	2015-09-05 04:19:46 UTC (rev 20756)
+++ trunk/Jmol/src/org/openscience/jmol/app/jmolpanel/console/ConsoleTextArea.java	2015-09-06 04:09:52 UTC (rev 20757)
@@ -29,10 +29,8 @@
 import java.io.InputStreamReader;
 import java.io.PrintStream;
 
-import javax.swing.JOptionPane;
 import javax.swing.JTextArea;
 
-import org.jmol.i18n.GT;
 import org.openscience.jmol.app.jmolpanel.LoopedStreams;
 
 public class ConsoleTextArea extends JTextArea {
@@ -50,46 +48,35 @@
 
     String redirect = (doRedirect ? System.getProperty("JmolConsole") : "false");
     if (redirect == null || redirect.equals("true")) {
-        // Redirect System.out & System.err.
-        
+        // Redirect System.out & System.err.        
         PrintStream ps = new PrintStream(ls.getOutputStream());
         System.setOut(ps);
         System.setErr(ps);
     }
-
     startConsoleReaderThread(ls.getInputStream());
   }    // ConsoleTextArea()
 
 
   private void startConsoleReaderThread(InputStream inStream) {
 
-    final BufferedReader br =
-      new BufferedReader(new InputStreamReader(inStream));
+    final BufferedReader br = new BufferedReader(new InputStreamReader(inStream));
     new Thread(new Runnable() {
-
-      
       @Override
       public void run() {
         Thread.currentThread().setName("ConsoleReaderThread");
-        StringBuilder sb = new StringBuilder();
         try {
           String s;
           //Document doc = getDocument();
-          s = br.readLine();
-          while (s != null) {
+          while ((s = br.readLine()) != null) {
             //boolean caretAtEnd = false;
             //caretAtEnd = (getCaretPosition() == doc.getLength());
-            sb.setLength(0);
-            append(sb.append(s).append('\n').toString());
+            append(s + "\n");
             //if (caretAtEnd) {
               //setCaretPosition(doc.getLength());
            //}
-            s = br.readLine();
           }
-        } catch (IOException e) {
-          JOptionPane.showMessageDialog(null, GT.o(GT._(
-              "Error reading from BufferedReader: {0}"), e.getMessage()));
-          System.exit(1);
+        } catch (Exception e) {
+          //
         }
       }
     }).start();

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.





Thread: [Jmol-commits] SF.net SVN: jmol:[20757] trunk/Jmol/src/org (Page 12)

An interactive viewer for three-dimensional chemical structures.

jmol-commits