Thread: [Jmol-commits] SF.net SVN: jmol: [5072] trunk/Jmol/src/org/jmol

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

Revision: 5072
Author:   migueljmol
Date:     2006-05-06 13:15:11 -0700 (Sat, 06 May 2006)
ViewCVS:  http://svn.sourceforge.net/jmol/?rev=5072&view=rev

Log Message:
-----------
Introduced Point3fi class which includeds members for screen coordinates. 
Atom derives from Point3fi.
At atom can now be treated like a Point3f, so there are a number of places
in the code that can probably be simplified because we don't have to
call a method to ask an atom for its Point3f. 

Modified Paths:
--------------
    trunk/Jmol/src/org/jmol/viewer/Atom.java
    trunk/Jmol/src/org/jmol/viewer/Bond.java
    trunk/Jmol/src/org/jmol/viewer/Dots.java
    trunk/Jmol/src/org/jmol/viewer/Frame.java
    trunk/Jmol/src/org/jmol/viewer/MeasuresRenderer.java
    trunk/Jmol/src/org/jmol/viewer/Monomer.java
    trunk/Jmol/src/org/jmol/viewer/NucleicMonomer.java
    trunk/Jmol/src/org/jmol/viewer/NucleicPolymer.java
    trunk/Jmol/src/org/jmol/viewer/Polyhedra.java
    trunk/Jmol/src/org/jmol/viewer/Polymer.java
    trunk/Jmol/src/org/jmol/viewer/SasNeighborFinder.java
    trunk/Jmol/src/org/jmol/viewer/Sasurface1.java
    trunk/Jmol/src/org/jmol/viewer/Sticks.java
    trunk/Jmol/src/org/jmol/viewer/VectorsRenderer.java

Added Paths:
-----------
    trunk/Jmol/src/org/jmol/vecmath/
    trunk/Jmol/src/org/jmol/vecmath/Point3fi.java
Added: trunk/Jmol/src/org/jmol/vecmath/Point3fi.java
===================================================================

--- trunk/Jmol/src/org/jmol/vecmath/Point3fi.java	                        (rev 0)
+++ trunk/Jmol/src/org/jmol/vecmath/Point3fi.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -0,0 +1,33 @@
+/* $RCSfile$
+ * $Author: egonw $
+ * $Date: 2005-11-10 10:52:44 -0500 (Thu, 10 Nov 2005) $
+ * $Revision: 4255 $
+ *
+ * Copyright (C) 2006  Miguel, Jmol Development, www.jmol.org
+ *
+ * Contact: mi...@jm...
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package org.jmol.vecmath;
+import javax.vecmath.Point3f;
+
+public class Point3fi extends Point3f {
+  public int screenX;
+  public int screenY;
+  public int screenZ;
+
+}

Modified: trunk/Jmol/src/org/jmol/viewer/Atom.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Atom.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Atom.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -26,6 +26,7 @@
 
 import org.jmol.g3d.Graphics3D;
 import org.jmol.bspt.Tuple;
+import org.jmol.vecmath.Point3fi;
 
 import java.util.Hashtable;
 import java.util.BitSet;
@@ -34,7 +35,7 @@
 import javax.vecmath.Vector3f;
 import javax.vecmath.Point3i;
 
-final class Atom implements Tuple {
+final class Atom extends Point3fi implements Tuple {
 
   final static byte VISIBLE_FLAG = 0x01;
   final static byte VIBRATION_VECTOR_FLAG = 0x02;
@@ -42,10 +43,6 @@
 
   Group group;
   int atomIndex;
-  Point3f point3f;
-  int screenX;
-  int screenY;
-  int screenZ;
   short screenDiameter;
   short modelIndex; // we want this here for the BallsRenderer
   byte elementNumber;
@@ -76,7 +73,7 @@
     this.colixAtom = viewer.getColixAtom(this);
     this.alternateLocationID = (byte)alternateLocationID;
     setMadAtom(viewer.getMadAtom());
-    this.point3f = new Point3f(x, y, z);
+    this.x = x; this.y = y; this.z = z;
     if (isHetero)
       formalChargeAndFlags |= IS_HETERO_FLAG;
 
@@ -368,9 +365,9 @@
     Vector3f[] vibrationVectors;
     if ((formalChargeAndFlags & VIBRATION_VECTOR_FLAG) == 0 ||
         (vibrationVectors = group.chain.frame.vibrationVectors) == null)
-      screen = viewer.transformPoint(point3f);
+      screen = viewer.transformPoint(this);
     else 
-      screen = viewer.transformPoint(point3f, vibrationVectors[atomIndex]);
+      screen = viewer.transformPoint(this, vibrationVectors[atomIndex]);
     screenX = screen.x;
     screenY = screen.y;
     screenZ = screen.z;
@@ -483,25 +480,25 @@
   }
 
   Point3f getPoint3f() {
-    return point3f;
+    return this;
   }
 
   float getAtomX() {
-    return point3f.x;
+    return x;
   }
 
   float getAtomY() {
-    return point3f.y;
+    return y;
   }
 
   float getAtomZ() {
-    return point3f.z;
+    return z;
   }
 
   public float getDimensionValue(int dimension) {
     return (dimension == 0
-		   ? point3f.x
-		   : (dimension == 1 ? point3f.y : point3f.z));
+		   ? x
+		   : (dimension == 1 ? y : z));
   }
 
   short getVanderwaalsMar() {
@@ -536,12 +533,12 @@
   // established bonds
   // note that this algorithm works when maximum valence == 0
   Bond getLongestBondToDiscard(Atom atomChallenger) {
-    float dist2Longest = point3f.distanceSquared(atomChallenger.point3f);
+    float dist2Longest = distanceSquared(atomChallenger);
     Bond bondLongest = null;
     for (int i = bonds.length; --i >= 0; ) {
       Bond bond = bonds[i];
       Atom atomOther = bond.atom1 != this ? bond.atom1 : bond.atom2;
-      float dist2 = point3f.distanceSquared(atomOther.point3f);
+      float dist2 = distanceSquared(atomOther);
       if (dist2 > dist2Longest) {
         bondLongest = bond;
         dist2Longest = dist2;
@@ -815,15 +812,15 @@
           strT = JmolConstants.elementSymbols[elementNumber];
           break;
         case 'x':
-          floatT = point3f.x;
+          floatT = x;
           floatIsSet = true;
           break;
         case 'y':
-          floatT = point3f.y;
+          floatT = y;
           floatIsSet = true;
           break;
         case 'z':
-          floatT = point3f.z;
+          floatT = z;
           floatIsSet = true;
           break;
         case 'X':
@@ -1052,9 +1049,9 @@
   Hashtable getPublicProperties() {
     Hashtable ht = new Hashtable();
     ht.put("element", getElementSymbol());
-    ht.put("x", new Double(point3f.x));
-    ht.put("y", new Double(point3f.y));
-    ht.put("z", new Double(point3f.z));
+    ht.put("x", new Double(x));
+    ht.put("y", new Double(y));
+    ht.put("z", new Double(z));
     ht.put("atomIndex", new Integer(atomIndex));
     ht.put("modelIndex", new Integer(modelIndex));
     ht.put("argb", new Integer(getArgb()));

Modified: trunk/Jmol/src/org/jmol/viewer/Bond.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Bond.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Bond.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -157,12 +157,12 @@
     ht.put("order", getOrderName());
     ht.put("radius", new Double(getRadius()));
     ht.put("modelIndex", new Integer(atom1.modelIndex));
-    ht.put("xA", new Double(atom1.point3f.x));
-    ht.put("yA", new Double(atom1.point3f.y));
-    ht.put("zA", new Double(atom1.point3f.z));
-    ht.put("xB", new Double(atom2.point3f.x));
-    ht.put("yB", new Double(atom2.point3f.y));
-    ht.put("zB", new Double(atom2.point3f.z));
+    ht.put("xA", new Double(atom1.x));
+    ht.put("yA", new Double(atom1.y));
+    ht.put("zA", new Double(atom1.z));
+    ht.put("xB", new Double(atom2.x));
+    ht.put("yB", new Double(atom2.y));
+    ht.put("zB", new Double(atom2.z));
     return ht;
   }
 }

Modified: trunk/Jmol/src/org/jmol/viewer/Dots.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Dots.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Dots.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -253,7 +253,7 @@
   void setAtomI(int indexI) {
     this.indexI = indexI;
     atomI = frame.atoms[indexI];
-    centerI = atomI.point3f;
+    centerI = atomI;
     radiusI = getAppropriateRadius(atomI);
     radiiIP2 = radiusI + radiusP;
     radiiIP2 *= radiiIP2;
@@ -337,7 +337,7 @@
       if (! bsSelected.get(neighbor.atomIndex))
         continue;
       float neighborRadius = getAppropriateRadius(neighbor);
-      if (centerI.distance(neighbor.point3f) >
+      if (centerI.distance(neighbor) >
           radiusI + radiusP + radiusP + neighborRadius)
         continue;
       if (neighborCount == neighbors.length) {
@@ -347,7 +347,7 @@
         neighborPlusProbeRadii2 = Util.doubleLength(neighborPlusProbeRadii2);
       }
       neighbors[neighborCount] = neighbor;
-      neighborCenters[neighborCount] = neighbor.point3f;
+      neighborCenters[neighborCount] = neighbor;
       neighborIndices[neighborCount] = neighbor.atomIndex;
       float neighborPlusProbeRadii = neighborRadius + radiusP;
       neighborPlusProbeRadii2[neighborCount] =

Modified: trunk/Jmol/src/org/jmol/viewer/Frame.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Frame.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Frame.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -691,7 +691,7 @@
   }
 
   Point3f getAtomPoint3f(int atomIndex) {
-    return atoms[atomIndex].point3f;
+    return atoms[atomIndex];
   }
 
   int getBondCount() {
@@ -861,7 +861,7 @@
     Point3f average = this.averageAtomPoint;
     average.set(0,0,0);
     for (int i = atomCount; --i >= 0; )
-      average.add(atoms[i].point3f);
+      average.add(atoms[i]);
     average.scale(1f/atomCount);
   }
 
@@ -922,7 +922,7 @@
     float maxRadius = 0;
     for (int i = atomCount; --i >= 0; ) {
       Atom atom = atoms[i];
-      float distAtom = center.distance(atom.point3f);
+      float distAtom = center.distance(atom);
       float radiusVdw = atom.getVanderwaalsRadiusFloat();
       float outerVdw = distAtom + radiusVdw;
       if (outerVdw > maxRadius)
@@ -1535,12 +1535,12 @@
 
   void convertEuclideanToFractional() {
     for (int i = atomCount; --i >= 0; )
-      matrixEuclideanToFractional.transform(atoms[i].point3f);
+      matrixEuclideanToFractional.transform(atoms[i]);
   }
 
   void convertFractionalToEuclidean() {
     for (int i = atomCount; --i >= 0; )
-      matrixFractionalToEuclidean.transform(atoms[i].point3f);
+      matrixFractionalToEuclidean.transform(atoms[i]);
   }
 
   Point3f findFractionalAdjustment() {
@@ -1562,20 +1562,20 @@
   void applyFractionalAdjustment(Point3f adjustment) {
     System.out.println("applyFractionalAdjustment(" + adjustment + ")");
     for (int i = atomCount; --i >= 0; )
-      atoms[i].point3f.sub(adjustment);
+      atoms[i].sub(adjustment);
   }
 
   void calcAtomsMinMax(Point3f pointMin, Point3f pointMax) {
     float minX, minY, minZ, maxX, maxY, maxZ;
     Point3f pointT;
-    pointT = atoms[0].point3f;
+    pointT = atoms[0];
     minX = maxX = pointT.x;
     minY = maxY = pointT.y;
     minZ = maxZ = pointT.z;
     
     for (int i = atomCount; --i > 0; ) {
       // note that the 0 element was set above
-      pointT = atoms[i].point3f;
+      pointT = atoms[i];
       float t;
       t = pointT.x;
       if (t < minX) { minX = t; }
@@ -1670,7 +1670,7 @@
   ////////////////////////////////////////////////////////////////
 
   float getDistance(int atomIndexA, int atomIndexB) {
-    return atoms[atomIndexA].point3f.distance(atoms[atomIndexB].point3f);
+    return atoms[atomIndexA].distance(atoms[atomIndexB]);
   }
 
   Vector3f vectorBA;
@@ -1681,9 +1681,9 @@
       vectorBA = new Vector3f();
       vectorBC = new Vector3f();
     }
-    Point3f pointA = atoms[atomIndexA].point3f;
-    Point3f pointB = atoms[atomIndexB].point3f;
-    Point3f pointC = atoms[atomIndexC].point3f;
+    Point3f pointA = atoms[atomIndexA];
+    Point3f pointB = atoms[atomIndexB];
+    Point3f pointC = atoms[atomIndexC];
     vectorBA.sub(pointA, pointB);
     vectorBC.sub(pointC, pointB);
     float angle = vectorBA.angle(vectorBC);
@@ -1693,10 +1693,10 @@
 
   float getTorsion(int atomIndexA, int atomIndexB,
                           int atomIndexC, int atomIndexD) {
-    return computeTorsion(atoms[atomIndexA].point3f,
-                          atoms[atomIndexB].point3f,
-                          atoms[atomIndexC].point3f,
-                          atoms[atomIndexD].point3f);
+    return computeTorsion(atoms[atomIndexA],
+                          atoms[atomIndexB],
+                          atoms[atomIndexC],
+                          atoms[atomIndexD]);
   }
 
   static float toDegrees(float angleRadians) {

Modified: trunk/Jmol/src/org/jmol/viewer/MeasuresRenderer.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/MeasuresRenderer.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/MeasuresRenderer.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -179,7 +179,7 @@
       matrixT.set(aaT);
       pointT.set(measurement.pointArc);
       matrixT.transform(pointT);
-      pointT.add(atomB.point3f);
+      pointT.add(atomB);
       Point3i screenArc = viewer.transformPoint(pointT);
       int zArc = screenArc.z - zOffset;
       if (zArc < 0) zArc = 0;
@@ -188,7 +188,7 @@
         pointT.set(measurement.pointArc);
         pointT.scale(1.1f);
         matrixT.transform(pointT);
-        pointT.add(atomB.point3f);
+        pointT.add(atomB);
         Point3i screenLabel = viewer.transformPoint(pointT);
         int zLabel = screenLabel.z - zOffset;
         paintMeasurementString(screenLabel.x, screenLabel.y, zLabel,

Modified: trunk/Jmol/src/org/jmol/viewer/Monomer.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Monomer.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Monomer.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -116,7 +116,7 @@
   final Point3f getAtomPointFromOffset(byte offset) {
     if (offset == -1)
       return null;
-    return chain.frame.atoms[firstAtomIndex + (offset & 0xFF)].point3f;
+    return chain.frame.atoms[firstAtomIndex + (offset & 0xFF)];
   }
 
   ////////////////////////////////////////////////////////////////
@@ -131,8 +131,7 @@
   }
 
   final Point3f getAtomPointFromOffsetIndex(int offsetIndex) {
-    Atom atom = getAtomFromOffsetIndex(offsetIndex);
-    return atom == null ? null : atom.point3f;
+    return getAtomFromOffsetIndex(offsetIndex);
   }
 
   final Atom getSpecialAtom(byte[] interestingIDs, byte specialAtomID) {
@@ -160,7 +159,7 @@
         int offset = offsets[i] & 0xFF;
         if (offset == 255)
           return null;
-        return chain.frame.atoms[firstAtomIndex + offset].point3f;
+        return chain.frame.atoms[firstAtomIndex + offset];
       }
     }
     return null;

Modified: trunk/Jmol/src/org/jmol/viewer/NucleicMonomer.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/NucleicMonomer.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/NucleicMonomer.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -198,7 +198,7 @@
     for (int i = 6; --i >= 0; ) {
       Atom atom = getAtomFromOffsetIndex(i + 3);
       atom.formalChargeAndFlags |= Atom.VISIBLE_FLAG;
-      ring6Points[i] = atom.point3f;
+      ring6Points[i] = atom;
     }
   }
 
@@ -209,7 +209,7 @@
       for (int i = 5; --i >= 0; ) {
         Atom atom = getAtomFromOffsetIndex(ring5OffsetIndexes[i]);
         atom.formalChargeAndFlags |= Atom.VISIBLE_FLAG;
-        ring5Points[i] = atom.point3f;
+        ring5Points[i] = atom;
       }
     return isPurine;
   }

Modified: trunk/Jmol/src/org/jmol/viewer/NucleicPolymer.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/NucleicPolymer.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/NucleicPolymer.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -63,7 +63,7 @@
         if (! otherNucleotide.isPyrimidine())
           continue;
         Atom otherN3 = otherNucleotide.getN3();
-        float dist2 = myN1.point3f.distanceSquared(otherN3.point3f);
+        float dist2 = myN1.distanceSquared(otherN3);
         if (dist2 < minDist2) {
           bestNucleotide = otherNucleotide;
           bestN3 = otherN3;

Modified: trunk/Jmol/src/org/jmol/viewer/Polyhedra.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Polyhedra.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Polyhedra.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -363,9 +363,9 @@
   Polyhedron validatePolyhedronNew(Atom centralAtom, int vertexCount,
                                    Atom[] otherAtoms) {
     int faceCount = 0;
-    Point3f centralAtomPoint = centralAtom.point3f;
+    Point3f centralAtomPoint = centralAtom;
     for (int i = vertexCount; --i >= 0;) {
-      centerVectors[i] = new Vector3f(otherAtoms[i].point3f);
+      centerVectors[i] = new Vector3f(otherAtoms[i]);
       centerVectors[i].sub(centralAtomPoint);
     }
 
@@ -384,9 +384,9 @@
           if (centerVectors[i].angle(centerVectors[k]) > centralAngleMax
               || centerVectors[j].angle(centerVectors[k]) > centralAngleMax)
             continue;
-          Point3f pointI = otherAtoms[i].point3f;
-          Point3f pointJ = otherAtoms[j].point3f;
-          Point3f pointK = otherAtoms[k].point3f;
+          Point3f pointI = otherAtoms[i];
+          Point3f pointJ = otherAtoms[j];
+          Point3f pointK = otherAtoms[k];
           getNormalFromCenter(centralAtomPoint, pointI, pointJ, pointK, false,
               normalT);
 

Modified: trunk/Jmol/src/org/jmol/viewer/Polymer.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Polymer.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Polymer.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -197,11 +197,11 @@
   }
 
   final Point3f getInitiatorPoint() {
-    return monomers[0].getInitiatorAtom().point3f;
+    return monomers[0].getInitiatorAtom();
   }
 
   final Point3f getTerminatorPoint() {
-    return monomers[monomerCount - 1].getTerminatorAtom().point3f;
+    return monomers[monomerCount - 1].getTerminatorAtom();
   }
 
   final Atom getLeadAtom(int monomerIndex) {

Modified: trunk/Jmol/src/org/jmol/viewer/SasNeighborFinder.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/SasNeighborFinder.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/SasNeighborFinder.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -85,7 +85,7 @@
       System.out.println("setAtomI:" + indexI);
     this.indexI = indexI;
     atomI = atoms[indexI];
-    centerI = atomI.point3f;
+    centerI = atomI;
     radiusI = atomI.getVanderwaalsRadiusFloat();
     radiiIP = radiusI + radiusP;
     radiiIP2 = radiiIP * radiiIP;
@@ -136,7 +136,7 @@
       if (! bsSelected.get(neighbor.atomIndex))
         continue;
       float neighborRadius = neighbor.getVanderwaalsRadiusFloat();
-      if (centerI.distance(neighbor.point3f) >
+      if (centerI.distance(neighbor) >
           radiusI + radiusP + radiusP + neighborRadius)
         continue;
       if (neighborCount == neighborAtoms.length) {
@@ -147,7 +147,7 @@
         neighborPlusProbeRadii2 = Util.doubleLength(neighborPlusProbeRadii2);
       }
       neighborAtoms[neighborCount] = neighbor;
-      neighborCenters[neighborCount] = neighbor.point3f;
+      neighborCenters[neighborCount] = neighbor;
       neighborIndexes[neighborCount] = neighbor.atomIndex;
       float radii = neighborRadius + radiusP;
       neighborPlusProbeRadii[neighborCount] = radii;

Modified: trunk/Jmol/src/org/jmol/viewer/Sasurface1.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Sasurface1.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Sasurface1.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -518,8 +518,8 @@
     }
 
     void calcVectors() {
-      Point3f centerA = frame.atoms[ixA].point3f;
-      Point3f centerB = frame.atoms[ixB].point3f;
+      Point3f centerA = frame.atoms[ixA];
+      Point3f centerB = frame.atoms[ixB];
       axisUnitVector.sub(centerB, centerA);
       axisUnitVector.normalize();
 
@@ -891,7 +891,7 @@
       int ix = isEdgeA ? ixA : ixB;
       Atom atom = frame.atoms[ix];
       calcZeroPoint(isEdgeA, zeroPointT);
-      gem.clipGeodesic(isEdgeA, atom.point3f, atom.getVanderwaalsRadiusFloat(),
+      gem.clipGeodesic(isEdgeA, atom, atom.getVanderwaalsRadiusFloat(),
                        zeroPointT, axisUnitVector, convexVertexMaps[ix]);
     }
 
@@ -919,12 +919,12 @@
     void calcClippingPlaneCenterPoints(Point3f centerPointA,
                                        Point3f centerPointB) {
       calcZeroPoint(true, zeroPointT);
-      Point3f centerA = frame.atoms[ixA].point3f;
+      Point3f centerA = frame.atoms[ixA];
       calcClippingPlaneCenter(centerA, axisUnitVector, zeroPointT,
                               centerPointA);
 
       calcZeroPoint(false, zeroPointT);
-      Point3f centerB = frame.atoms[ixB].point3f;
+      Point3f centerB = frame.atoms[ixB];
       calcClippingPlaneCenter(centerB, axisUnitVector, zeroPointT,
                               centerPointB);
     }
@@ -950,7 +950,7 @@
       int ix = isEdgeA ? ixA : ixB;
       Atom atom = frame.atoms[ix];
       float atomRadius = atom.getVanderwaalsRadiusFloat();
-      Point3f atomCenter = atom.point3f;
+      Point3f atomCenter = atom;
       gem.reset();
       calcZeroAndCenterPoints(isEdgeA, atomCenter, zeroPointT, centerPointT);
       boolean dump = false;

Modified: trunk/Jmol/src/org/jmol/viewer/Sticks.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/Sticks.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/Sticks.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -187,7 +187,7 @@
       if (! bsA.get(iA))
         continue;
       Atom atomA = atoms[iA];
-      Point3f pointA = atomA.point3f;
+      Point3f pointA = atomA;
       for (int iB = atomCount; --iB >= 0; ) {
         if (iB == iA)
           continue;
@@ -201,7 +201,7 @@
           continue;
         if (CREATE_ONLY == connectOperation && bondAB != null)
           continue;
-        float distanceSquared = pointA.distanceSquared(atomB.point3f);
+        float distanceSquared = pointA.distanceSquared(atomB);
         if (distanceSquared < minDistanceSquared ||
             distanceSquared > maxDistanceSquared)
           continue;
@@ -230,7 +230,7 @@
       if (bsA.get(atom1.atomIndex) && bsB.get(atom2.atomIndex) ||
           bsA.get(atom2.atomIndex) && bsB.get(atom1.atomIndex)) {
         if (bond.atom1.isBonded(bond.atom2)) {
-          float distanceSquared = atom1.point3f.distanceSquared(atom2.point3f);
+          float distanceSquared = atom1.distanceSquared(atom2);
           if (distanceSquared >= minDistanceSquared &&
               distanceSquared <= maxDistanceSquared)
             if (order == NULL_BOND_ORDER ||

Modified: trunk/Jmol/src/org/jmol/viewer/VectorsRenderer.java
===================================================================
--- trunk/Jmol/src/org/jmol/viewer/VectorsRenderer.java	2006-05-06 14:13:33 UTC (rev 5071)
+++ trunk/Jmol/src/org/jmol/viewer/VectorsRenderer.java	2006-05-06 20:15:11 UTC (rev 5072)
@@ -87,14 +87,14 @@
 
     // to have the vectors move when vibration is turned on
     float vectorScale = viewer.getVectorScale();
-    pointVectorEnd.scaleAdd(vectorScale, vibrationVector, atom.point3f);
+    pointVectorEnd.scaleAdd(vectorScale, vibrationVector, atom);
     viewer.transformPoint(pointVectorEnd, vibrationVector,
                           screenVectorEnd);
     diameter = (mad <= 20)
       ? mad
       : viewer.scaleToScreen(screenVectorEnd.z, mad);
     pointArrowHead.scaleAdd(vectorScale * arrowHeadBase,
-                            vibrationVector, atom.point3f);
+                            vibrationVector, atom);
     viewer.transformPoint(pointArrowHead, vibrationVector,
                           screenArrowHead);
     headWidthPixels = diameter * 3 / 2;


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: [5072] trunk/Jmol/src/org/jmol

An interactive viewer for three-dimensional chemical structures.

jmol-commits