Uses of Class
javajs.util.T3

Packages that use T3
Package
Description
 
 
 
 
Provides Binary Space Partitioning Functionality to spacially separate data structures in n-dimensions
 
Provides a software implementation of complete 3D graphics engine for rendering molecules and associated shapes.
 
 
 
 
 
 
 
 
 
 
 
 
Jmol SMILES, Jmol SMARTS, Jmol bioSMILES, and Jmol bioSMARTS
 
 
 
  • Uses of T3 in javajs.util

    Subclasses of T3 in javajs.util
    Modifier and Type
    Class
    Description
    class 
    A 4 element axis angle represented by single precision floating point x,y,z,angle components.
    class 
    A 3 element point that is represented by single precision floating point x,y,z coordinates.
    class 
    A 4 element point that is represented by single precision floating point x,y,z,w coordinates.
    class 
    A generic 4 element tuple that is represented by single precision floating point x,y,z and w coordinates.
    class 
    A 3-element vector that is represented by single precision floating point x,y,z coordinates.
    Methods in javajs.util that return T3
    Modifier and Type
    Method
    Description
    static T3[]
    AU.arrayCopyPt(T3[] array, int newLength)
     
    static T3[]
    Measure.computeHelicalAxis(P3 a, P3 b, Quat dq)
    This method calculates measures relating to two points in space with related quaternion frame difference.
    T3.putP(T3 t)
     
    M4.rotTrans2(T3 point, T3 pointOut)
    Transforms the point parameter with this Matrix4f and places the result into pointOut.
    T3.setP(T3 t)
     
    Quat.transform2(T3 pt, T3 ptNew)
     
    Methods in javajs.util with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    M4.add(T3 pt)
    add to translation
    final void
    T3.add(T3 t1)
    Sets the value of this tuple to the vector sum of itself and tuple t1.
    final void
    T3.add2(T3 t1, T3 t2)
    Sets the value of this tuple to the vector sum of tuples t1 and t2.
    static T3[]
    AU.arrayCopyPt(T3[] array, int newLength)
     
    void
    T3.ave(T3 a, T3 b)
    average of two tuples
    static void
    Measure.calcNormalizedNormal(T3 pointA, T3 pointB, T3 pointC, T3 vNormNorm, T3 vAB)
    note that if vAB or vAC is dispensible, vNormNorm can be one of them
    static int
     
    static float
    Measure.computeAngle(T3 pointA, T3 pointB, T3 pointC, V3 vectorBA, V3 vectorBC, boolean asDegrees)
     
    static float
    Measure.computeAngleABC(T3 pointA, T3 pointB, T3 pointC, boolean asDegrees)
     
    static float
    Measure.computeTorsion(T3 p1, T3 p2, T3 p3, T3 p4, boolean asDegrees)
     
    final void
    T3.cross(T3 v1, T3 v2)
    Sets this tuple to be the vector cross product of vectors v1 and v2.
    final float
    T3.distance(T3 p1)
    Returns the distance between this point and point p1.
    final float
    Computes the square of the distance between this point and point p1.
    static float
    Measure.distanceToPlane(P4 plane, T3 pt)
     
    final float
    T3.dot(T3 v)
    Vector dot product.
    static void
    PT.fixPtFloats(T3 pt, float f)
     
    static void
    Measure.getBisectingPlane(P3 pointA, V3 vAB, T3 ptTemp, V3 vTemp, P4 plane)
     
    void
    M3.getColumnV(int column, T3 v)
    Copies the matrix values in the specified column into the vector parameter.
    static float
    Measure.getDirectedNormalThroughPoints(T3 pointA, T3 pointB, T3 pointC, T3 ptRef, V3 vNorm, V3 vAB)
     
    static float
    Measure.getNormalThroughPoints(T3 pointA, T3 pointB, T3 pointC, T3 vNorm, T3 vTemp)
     
    static float
    Measure.getPlaneProjection(T3 pt, P4 plane, T3 retPtProj, V3 retNorm)
    Project a point onto a plane, also returning the normal vector and the directed distance to the plane.
    static void
    Measure.getPlaneThroughPoint(T3 pt, V3 normal, P4 plane)
     
    static P4
    Measure.getPlaneThroughPoints(T3 pointA, T3 pointB, T3 pointC, V3 vNorm, V3 vAB, P4 plane)
     
    static final Quat
    Quat.getQuaternionFrame(P3 center, T3 x, T3 xy)
    returns a quaternion frame based on three points (center, x, and any point in xy plane) or two vectors (vA, vB).
    void
    M4.getTranslation(T3 trans)
    Retrieves the translational components of this matrix.
    static M4
    M4.newMV(M3 m1, T3 t)
    Constructs and initializes a Matrix4f from the rotation matrix and translation.
    static P3
    P3.newP(T3 t)
     
    static Matrix
    Matrix.newT(T3 r, boolean asColumn)
     
    static V3
    V3.newV(T3 t)
     
    static Quat
    Quat.newVA(T3 v, float theta)
     
    static V3
    V3.newVsub(T3 t1, T3 t2)
     
    T3.putP(T3 t)
     
    void
    M34.rotate(T3 t)
     
    void
    M34.rotate2(T3 t, T3 result)
    Transform the vector vec using this Matrix3f and place the result into vecOut.
    void
    M4.rotTrans(T3 point)
    Transforms the point parameter with this Matrix4f and places the result back into point.
    M4.rotTrans2(T3 point, T3 pointOut)
    Transforms the point parameter with this Matrix4f and places the result into pointOut.
    final void
    T3.scaleAdd2(float s, T3 t1, T3 t2)
    Sets the value of this tuple to the scalar multiplication of tuple t1 and then adds tuple t2 (this = s*t1 + t2).
    final void
    T3.scaleT(T3 p)
    {x*p.x, y*p.y, z*p.z) used for three-way scaling
    void
    M3.setColumnV(int column, T3 v)
    Sets the specified column of this matrix3d to the vector provided.
    void
    M4.setMV(M3 m1, T3 t)
    Initializes a Matrix4f from the rotation matrix and translation.
    T3.setP(T3 t)
     
    void
    M3.setRowV(int row, T3 v)
    Sets the specified row of this matrix3d to the Vector provided.
    final void
    T3.setT(T3 t1)
    Sets the value of this tuple to the value of the Tuple3f argument.
    void
    Quat.setTA(T3 pt, float theta)
    q = (cos(theta/2), sin(theta/2) * n)
    void
    M4.setTranslation(T3 trans)
    Modifies the translational components of this matrix to the values of the Vector3f argument; the other values of this matrix are not modified.
    final void
    T3.sub(T3 t1)
    Sets the value of this tuple to the vector difference of itself and tuple t1 (this = this - t1).
    final void
    T3.sub2(T3 t1, T3 t2)
    Sets the value of this tuple to the vector difference of tuple t1 and t2 (this = t1 - t2).
    Quat.transform2(T3 pt, T3 ptNew)
     
  • Uses of T3 in org.jmol.adapter.smarter

    Subclasses of T3 in org.jmol.adapter.smarter
    Modifier and Type
    Class
    Description
    class 
     
    Fields in org.jmol.adapter.smarter declared as T3
    Modifier and Type
    Field
    Description
    AtomSetCollectionReader.paramsLattice
     
    Methods in org.jmol.adapter.smarter that return T3
    Modifier and Type
    Method
    Description
    XtalSymmetry.getOverallSpan()
     
    Methods in org.jmol.adapter.smarter with parameters of type T3
    Modifier and Type
    Method
    Description
    XtalSymmetry.FileSymmetry.fcoord(T3 p)
     
    void
    XtalSymmetry.FileSymmetry.toUnitCellRnd(T3 pt, T3 offset)
     
  • Uses of T3 in org.jmol.api

    Methods in org.jmol.api that return T3
    Modifier and Type
    Method
    Description
    JmolModulationSet.getModPoint(boolean asEnabled)
     
    SymmetryInterface.getUnitCellMultiplier()
     
    T3[]
    SymmetryInterface.getV0abc(Object def, M4 m)
     
    Methods in org.jmol.api with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    JmolModulationSet.addTo(T3 a, float scale)
     
    void
    JmolRendererInterface.fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA, T3 ptB, T3 ptC, boolean doShade)
     
    SymmetryInterface.findSpaceGroup(Viewer vwr, BS atoms, String xyzList, float[] unitCellParams, T3 origin, T3[] oabc, int flags)
     
    JmolModulationSet.getModulation(char type, T3 t456, boolean occ100)
     
    SymmetryInterface.getUnitCell(T3[] points, boolean setRelative, String name)
     
    void
    AtomIndexIterator.setCenter(T3 center, float distance)
     
    void
    AtomIndexIterator.setModel(ModelSet modelSet, int modelIndex, int zeroBase, int atomIndex, T3 center, float distance, RadiusData rd)
     
    void
    JmolModulationSet.setModTQ(T3 a, boolean isOn, T3 qtOffset, boolean isQ, float scale)
     
    void
    SymmetryInterface.setOffsetPt(T3 pt)
     
    SymmetryInterface.setPointGroup(Viewer vwr, SymmetryInterface pointGroupPrevious, T3 center, T3[] atomset, BS bsAtoms, boolean haveVibration, float distanceTolerance, float linearTolerance, int maxAtoms, boolean localEnvOnly)
     
    void
    SymmetryInterface.toCartesian(T3 pt, boolean ignoreOffset)
     
    void
    SymmetryInterface.toFractional(T3 pt, boolean ignoreOffset)
     
    boolean
    SymmetryInterface.toFromPrimitive(boolean toPrimitive, char type, T3[] oabc, M3 primitiveToCrystal)
     
    void
    SymmetryInterface.toUnitCell(T3 pt, T3 offset)
     
    void
    SymmetryInterface.unitize(T3 ptFrac)
     
  • Uses of T3 in org.jmol.atomdata

    Methods in org.jmol.atomdata with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    AtomDataServer.setIteratorForPoint(AtomIndexIterator iter, int modelIndex, T3 pt, float maxDistance)
     
  • Uses of T3 in org.jmol.bspt

    Methods in org.jmol.bspt that return T3
    Modifier and Type
    Method
    Description
    CubeIterator.nextElement()
    normal iterator method
    Methods in org.jmol.bspt with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    Bspt.addTuple(T3 tuple)
    Iterate through all of your data points, calling addTuple
    void
    CubeIterator.initialize(T3 center, float radius, boolean hemisphereOnly)
    initialize to return all points within the sphere defined by center and radius
  • Uses of T3 in org.jmol.export

    Methods in org.jmol.export with parameters of type T3
    Modifier and Type
    Method
    Description
    protected abstract void
    ___Exporter.fillTriangle(short colix, T3 ptA0, T3 ptB0, T3 ptC0, boolean twoSided)
     
    protected void
    __CartesianExporter.fillTriangle(short colix, T3 ptA, T3 ptB, T3 ptC, boolean twoSided)
     
    void
    Export3D.fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA0, T3 ptB0, T3 ptC0, boolean doShade)
     
    protected int
    __CartesianExporter.getCoordinateMap(T3[] vertices, int[] coordMap, BS bsValid)
     
    protected int[]
    __CartesianExporter.getNormalMap(T3[] normals, int nNormals, BS bsValid, Lst<String> vNormals)
     
    protected String
    ___Exporter.getTriad(T3 t)
     
    protected String
    _PovrayExporter.getTriad(T3 pt)
     
    protected String
    ___Exporter.getTriadC(T3 t)
     
    protected void
    JSExporter.jsSurface(Object applet, T3[] vertices, T3[] normals, int[][] indices, int nVertices, int nPolygons, int nFaces, BS bsPolygons, int faceVertexMax, int color, int[] vertexColors, int[] polygonColors)
     
    protected abstract void
    ___Exporter.output(T3 pt)
     
    protected void
    _IdtfExporter.output(T3 pt)
     
    protected void
    _MayaExporter.output(T3 pt)
     
    protected void
    _ObjExporter.output(T3 pt)
     
    protected void
    _PovrayExporter.output(T3 pt)
     
    protected void
    _TachyonExporter.output(T3 pt)
     
    protected void
    _VrmlExporter.output(T3 pt)
     
    protected void
    JSExporter.output(T3 pt)
     
    protected void
    _StlExporter.outputAttrPt(String attr, T3 pt)
     
    protected void
    _VrmlExporter.outputAttrPt(String attr, T3 pt)
     
    protected void
    _X3dExporter.outputAttrPt(String attr, T3 pt)
     
    protected void
    _StlExporter.outputGeometry(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, BS bsPolygons, int faceVertexMax, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _VrmlExporter.outputGeometry(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, BS bsPolygons, int faceVertexMax, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _X3dExporter.outputGeometry(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, BS bsPolygons, int faceVertexMax, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    ___Exporter.outputSurface(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _IdtfExporter.outputSurface(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _MayaExporter.outputSurface(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _PovrayExporter.outputSurface(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _TachyonExporter.outputSurface(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    _VrmlExporter.outputSurface(T3[] vertices, T3[] normals, short[] colixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected void
    JSExporter.outputSurface(T3[] vertices, T3[] normals, short[] vertexColixes, int[][] indices, short[] polygonColixes, int nVertices, int nPolygons, int nTriangles, BS bsPolygons, int faceVertexMax, short colix, Lst<Short> colorList, Map<Short,Integer> htColixes, P3 offset)
     
    protected abstract void
    __CartesianExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    _IdtfExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    _MayaExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    _ObjExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    _PovrayExporter.outputTriangle(T3 ptA, T3 ptB, T3 ptC, short colix)
     
    protected void
    _TachyonExporter.outputTriangle(T3 ptA, T3 ptB, T3 ptC, short colix)
     
    protected void
    _VrmlExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    _X3dExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    JSExporter.outputTriangle(T3 pt1, T3 pt2, T3 pt3, short colix)
     
    protected void
    ___Exporter.outputVertex(T3 pt, T3 offset)
     
    protected void
    ___Exporter.outputVertices(T3[] vertices, int nVertices, T3 offset)
     
    protected static String
    ___Exporter.round(T3 pt)
     
    protected void
    __CartesianExporter.setSphereMatrix(T3 center, float rx, float ry, float rz, A4 a, M4 sphereMatrix)
     
    protected static void
    ___Exporter.setTempVertex(T3 pt, T3 offset, T3 ptTemp)
     
  • Uses of T3 in org.jmol.g3d

    Methods in org.jmol.g3d with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    Graphics3D.fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA, T3 ptB, T3 ptC, boolean doShade)
     
  • Uses of T3 in org.jmol.jvxl.api

    Methods in org.jmol.jvxl.api with parameters of type T3
    Modifier and Type
    Method
    Description
    int
    VertexDataServer.addVertexCopy(T3 vertexXYZ, float value, int assocVertex, boolean asCopy)
    addVertexCopy is used by the Marching Squares algorithm to uniquely identify a new vertex when an edge is crossed in the 2D plane.
    int
    VertexDataServer.getSurfacePointIndexAndFraction(float cutoff, boolean isCutoffAbsolute, int x, int y, int z, P3i offset, int vertexA, int vertexB, float valueA, float valueB, T3 pointA, V3 edgeVector, boolean isContourType, float[] fReturn)
    getSurfacePointIndex is used by the Marching Cubes algorithm and must return a unique integer identifier for a vertex created by the Marching Cube algorithm when it finds an edge.
  • Uses of T3 in org.jmol.jvxl.data

    Methods in org.jmol.jvxl.data with parameters of type T3
    Modifier and Type
    Method
    Description
    int
    MeshData.addVertexCopy(T3 vertex, float value, int assocVertex, boolean asCopy)
     
    float
    VolumeData.distancePointToPlane(T3 pt)
     
    float
    VolumeData.distanceToMappingPlane(T3 pt)
     
    float
    VolumeData.lookupInterpolatedVoxelValue(T3 point, boolean getSource)
     
    static void
    JvxlCoder.set3dContourVector(Lst<Object> v, int[][] polygonIndexes, T3[] vertices)
    Interpret fractional data in terms of actual vertex positions and create the elements of a Vector in Vector[] vContours starting at the CONTOUR_POINTS position.
    void
    VolumeData.voxelPtToXYZ(int x, int y, int z, T3 pt)
     
  • Uses of T3 in org.jmol.jvxl.readers

    Methods in org.jmol.jvxl.readers with parameters of type T3
    Modifier and Type
    Method
    Description
    protected int
    SurfaceReader.addVC(T3 vertexXYZ, float value, int assocVertex, boolean asCopy)
     
    int
    SurfaceReader.addVertexCopy(T3 vertexXYZ, float value, int assocVertex, boolean asCopy)
     
    protected float
    SurfaceReader.getSPF(float cutoff, boolean isCutoffAbsolute, float valueA, float valueB, T3 pointA, V3 edgeVector, int x, int y, int z, int vA, int vB, float[] fReturn, T3 ptReturn)
     
    protected float
    JvxlXmlReader.getSurfacePointAndFraction(float cutoff, boolean isCutoffAbsolute, float valueA, float valueB, T3 pointA, V3 edgeVector, int x, int y, int z, int vA, int vB, float[] fReturn, T3 ptReturn)
     
    protected float
    SurfaceReader.getSurfacePointAndFraction(float cutoff, boolean isCutoffAbsolute, float valueA, float valueB, T3 pointA, V3 edgeVector, int x, int y, int z, int vA, int vB, float[] fReturn, T3 ptReturn)
     
    int
    SurfaceReader.getSurfacePointIndexAndFraction(float cutoff, boolean isCutoffAbsolute, int x, int y, int z, P3i offset, int vA, int vB, float valueA, float valueB, T3 pointA, V3 edgeVector, boolean isContourType, float[] fReturn)
     
    float
    SurfaceReader.getValueAtPoint(T3 pt, boolean getSource)
     
    protected void
    SurfaceReader.setBBox(T3 pt, float margin)
     
    protected void
    SurfaceReader.setVectorAnisotropy(T3 v)
     
    protected void
    SurfaceReader.setVertexAnisotropy(T3 pt)
     
  • Uses of T3 in org.jmol.modelkit

    Methods in org.jmol.modelkit with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    ModelKit.drawUnitCell(String id, T3 ucLattice, String swidth)
     
    boolean
    ModelKit.transformAtomsToUnitCell(SymmetryInterface sym, T3[] oabc, String ucname)
    Transform the atoms to fractional coordinate, set the unit cell to a new cell, and then transform them back to Cartesians.
  • Uses of T3 in org.jmol.modelset

    Subclasses of T3 in org.jmol.modelset
    Modifier and Type
    Class
    Description
    class 
     
    Methods in org.jmol.modelset that return T3
    Modifier and Type
    Method
    Description
    Atom.atomPropertyTuple(Viewer vwr, int tok, P3 ptTemp)
     
    Methods in org.jmol.modelset with parameters of type T3
    Modifier and Type
    Method
    Description
    ModelSet.getAtomsWithin(float distance, T3 coord, BS bsResult, int modelIndex)
     
    AtomCollection.getHybridizationAndAxes(int atomIndex, int atomicNumber, V3 z, V3 x, String lcaoTypeRaw, boolean hybridizationCompatible, boolean doAlignZ, boolean isQuick, T3 ref)
     
    void
    ModelSet.setAtomCoordsRelative(T3 offset, BS bs)
     
    void
    ModelSet.setBoundBox(T3 pt1, T3 pt2, boolean byCorner, float scale)
     
    void
    AtomIteratorWithinModel.setCenter(T3 center, float distance)
     
    void
    AtomIteratorWithinModelSet.setCenter(T3 center, float distance)
     
    protected void
    AtomIteratorWithinModel.setCenter2(T3 center, float distance)
     
    void
    ModelSet.setIteratorForPoint(AtomIndexIterator iterator, int modelIndex, T3 pt, float distance)
     
    void
    AtomIteratorWithinModel.setModel(ModelSet modelSet, int modelIndex, int firstModelAtom, int atomIndex, T3 center, float distance, RadiusData rd)
     
    ModelSet.setModelCagePts(int iModel, T3[] originABC, String name)
     
    void
    AtomCollection.setVibrationVector(int atomIndex, T3 vib)
     
    void
    ModelSet.translateModel(int iModel, T3 pt)
    move atoms by vector pt; used for co-centering with FRAME ALIGN {atoms} TRUE
  • Uses of T3 in org.jmol.quantum

    Fields in org.jmol.quantum declared as T3
    Modifier and Type
    Field
    Description
    protected T3[]
    QuantumCalculation.points
     
    Methods in org.jmol.quantum with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    MOCalculation.initialize(int nX, int nY, int nZ, T3[] points)
     
    protected void
    QuantumCalculation.initialize(int nX, int nY, int nZ, T3[] points)
     
    protected void
    QuantumCalculation.initialize0(int nX, int nY, int nZ, T3[] points)
     
    float
    QuantumCalculation.processPt(T3 pt)
     
    boolean
    MOCalculation.setupCalculation(Map<String,Object> moData, boolean isSlaters, VolumeData volumeData, BS bsSelected, T3[] xyz, Atom[] atoms, int firstAtomOffset, int[][] dfCoefMaps, float[] moCoefficients, float[] linearCombination, boolean isSquaredLinear, float[][] coefs, T3[] points)
     
    boolean
    NciCalculation.setupCalculation(VolumeData volumeData, BS bsSelected, BS bsExcluded, BS[] bsMolecules, T3[] atomCoordAngstroms, int firstAtomOffset, boolean isReducedDensity, T3[] points, float[] parameters, int testFlags)
     
    protected void
    QuantumCalculation.setupCoordinates(float[] originXYZ, float[] stepsXYZ, BS bsSelected, T3[] xyz, Atom[] atoms, T3[] points, boolean renumber)
     
    protected void
    QuantumCalculation.setXYZBohr(T3[] points)
     
  • Uses of T3 in org.jmol.render

    Fields in org.jmol.render declared as T3
    Modifier and Type
    Field
    Description
    protected T3[]
    MeshRenderer.vertices
     
    Methods in org.jmol.render with parameters of type T3
    Modifier and Type
    Method
    Description
    protected void
    MeshRenderer.drawEdge(int iA, int iB, boolean fill, T3 vA, T3 vB, P3i sA, P3i sB)
     
  • Uses of T3 in org.jmol.script

    Methods in org.jmol.script that return T3
    Modifier and Type
    Method
    Description
    ScriptParam.checkHKL(T3 pt)
    Note - this check does not allow a 0 for h, k, or l.
    ScriptParam.getFractionalPoint(int i)
    Could return a P4 for large 1100100100 type indicators
    ScriptParam.getPointOrPlane(int index, int mode)
    Get the point or plane at an index
    Methods in org.jmol.script with parameters of type T3
    Modifier and Type
    Method
    Description
    ScriptParam.checkHKL(T3 pt)
    Note - this check does not allow a 0 for h, k, or l.
    ScriptParam.getHklPlane(T3 pt, float offset, Lst<P3> pts)
     
    static M4
    ScriptMathProcessor.getMatrix4f(M3 matRotate, T3 vTranslate)
     
  • Uses of T3 in org.jmol.shape

    Fields in org.jmol.shape declared as T3
    Modifier and Type
    Field
    Description
    protected T3
    MeshCollection.pickedPt
     
    Methods in org.jmol.shape with parameters of type T3
    Modifier and Type
    Method
    Description
    static boolean
    Mesh.checkWithin(T3 pti, Lst<P3> withinPoints, float withinDistance2, boolean isWithinNot)
     
    protected int
    Shape.coordinateInRange(int x, int y, T3 vertex, int dmin2, P3i ptXY)
     
    V3[]
    Mesh.getNormals(T3[] vertices, P4 plane)
     
    protected Map<String,Object>
    MeshCollection.getPickedPoint(T3 v, int modelIndex)
     
    void
    Mesh.initialize(int lighting, T3[] vertices, P4 plane)
     
    void
    Mesh.rotateTranslate(Quat q, T3 offset, boolean isAbsolute)
     
    protected void
    MeshCollection.setStatusPicked(int flag, T3 v, Map<String,Object> map)
     
    protected void
    Mesh.sumVertexNormals(T3[] vertices, V3[] normals)
     
    protected static void
    Mesh.sumVertexNormals2(Mesh m, T3[] vertices, V3[] normals)
     
  • Uses of T3 in org.jmol.shapecgo

    Methods in org.jmol.shapecgo with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    CGOMesh.getPoint(int i, T3 pt)
     
  • Uses of T3 in org.jmol.shapespecial

    Methods in org.jmol.shapespecial with parameters of type T3
    Modifier and Type
    Method
    Description
    static boolean
    Draw.is2DPoint(T3 pt)
     
  • Uses of T3 in org.jmol.shapesurface

    Methods in org.jmol.shapesurface that return T3
    Modifier and Type
    Method
    Description
    T3[]
    IsosurfaceMesh.getValidVertices(BS bs)
     
    Methods in org.jmol.shapesurface with parameters of type T3
    Modifier and Type
    Method
    Description
    static void
    IsosurfaceMesh.addContourPoints(Lst<Object> v, BS bsContour, int i, SB fData, T3[] vertices, float[] vertexValues, int iA, int iB, int iC, float value)
     
    int
    Isosurface.addVertexCopy(T3 vertexXYZ, float value, int assocVertex, boolean asCopy)
     
    int
    Isosurface.getSurfacePointIndexAndFraction(float cutoff, boolean isCutoffAbsolute, int x, int y, int z, P3i offset, int vA, int vB, float valueA, float valueB, T3 pointA, V3 edgeVector, boolean isContourType, float[] fReturn)
     
    protected void
    IsosurfaceMesh.sumVertexNormals(T3[] vertices, V3[] vectorSums)
     
  • Uses of T3 in org.jmol.smiles

    Subclasses of T3 in org.jmol.smiles
    Modifier and Type
    Class
    Description
    class 
    This class represents an atom in a SmilesMolecule.
    Methods in org.jmol.smiles with parameters of type T3
    Modifier and Type
    Method
    Description
    static float
    SmilesMeasure.setTorsionData(T3 pt1a, T3 pt1, T3 pt2, T3 pt2a, org.jmol.smiles.VTemp v, boolean withDihedral)
    calculate temporary points
  • Uses of T3 in org.jmol.symmetry

    Methods in org.jmol.symmetry that return T3
    Modifier and Type
    Method
    Description
    T3[]
    UnitCell.getConventionalUnitCell(String latticeType, M3 primitiveToCrystal)
    return a conventional lattice from a primitive
    static T3[]
    UnitCell.getMatrixAndUnitCell(SimpleUnitCell uc, Object def, M4 retMatrix)
     
     
    T3[]
    Symmetry.getV0abc(Object def, M4 retMatrix)
     
    Methods in org.jmol.symmetry with parameters of type T3
    Modifier and Type
    Method
    Description
    static String
    SymmetryOperation.fcoord(T3 p, String sep)
    Get string version of fraction
    Symmetry.findSpaceGroup(Viewer vwr, BS atoms, String xyzList, float[] unitCellParams, T3 origin, T3[] oabc, int flags)
     
    static UnitCell
    UnitCell.fromOABC(T3[] oabc, boolean setRelative)
    A special constructor for spacially defined unit cells.
    static char
    SymmetryOperation.getGlideFromTrans(T3 ftrans, T3 ax1)
     
    Symmetry.getUnitCell(T3[] oabc, boolean setRelative, String name)
     
    SymmetryOperation.getxyzTrans(T3 t)
     
    void
    UnitCellIterator.setCenter(T3 center, float distance)
     
    void
    UnitCellIterator.setModel(ModelSet modelSet, int modelIndex, int zeroBase, int atomIndex, T3 center, float distance, RadiusData rd)
     
    void
    Symmetry.setOffsetPt(T3 pt)
     
    Symmetry.setPointGroup(Viewer vwr, SymmetryInterface siLast, T3 center, T3[] atomset, BS bsAtoms, boolean haveVibration, float distanceTolerance, float linearTolerance, int maxAtoms, boolean localEnvOnly)
     
    void
    Symmetry.toCartesian(T3 pt, boolean ignoreOffset)
     
    void
    Symmetry.toFractional(T3 pt, boolean ignoreOffset)
     
    boolean
    Symmetry.toFromPrimitive(boolean toPrimitive, char type, T3[] oabc, M3 primitiveToCrystal)
     
    void
    Symmetry.toUnitCell(T3 pt, T3 offset)
     
    final void
    UnitCell.toUnitCellRnd(T3 pt, T3 offset)
    when offset is null, use the current cell, otherwise use the original unit cell
    void
    Symmetry.unitize(T3 ptFrac)
     
  • Uses of T3 in org.jmol.util

    Subclasses of T3 in org.jmol.util
    Modifier and Type
    Class
    Description
    class 
    A class to group a set of modulations for an atom as a "vibration" Extends V3 so that it will be a displacement, and its value will be an occupancy
    class 
    the Point3fi class allows storage of critical information involving an atom, picked bond, or measurement point, including: xyz position screen position screen radius (-1 for a simple point) index (for atoms or for an associated bond that has be picked) associated modelIndex (for measurement points)
    class 
    A class to allow for more complex vibrations and associated phenomena, such as modulated crystals.
    Fields in org.jmol.util declared as T3
    Modifier and Type
    Field
    Description
    T3[]
    MeshSurface.altVertices
     
    T3[]
    MeshSurface.normals
     
    T3[]
    MeshSurface.vs
    vertices
    Methods in org.jmol.util that return T3
    Modifier and Type
    Method
    Description
    ModulationSet.getModPoint(boolean asEnabled)
     
    static T3[]
    SimpleUnitCell.getReciprocal(T3[] abc, T3[] ret, float scale)
    Generate the reciprocal unit cell, scaled as desired
    T3[]
    MeshSurface.getVertices()
     
    static T3[]
    SimpleUnitCell.setAbc(String abcabg, float[] params, T3[] ucnew)
    set cell vectors by string.
    static T3[]
    SimpleUnitCell.setAbcFromParams(float[] params, T3[] ucnew)
     
    ModulationSet.setCalcPoint(T3 pt, T3 t456, float vibScale, float scale)
    get updated value for offset vector and for occupancy
    Vibration.setCalcPoint(T3 pt, T3 t456, float scale, float modulationScale)
     
    Methods in org.jmol.util with parameters of type T3
    Modifier and Type
    Method
    Description
    void
    BoxInfo.addBoundBoxPoint(T3 pt)
     
    static void
    BoxInfo.addPoint(T3 pt, T3 xyzMin, T3 xyzMax, float margin)
     
    void
    ModulationSet.addTo(T3 a, float scale)
     
    int
    MeshSurface.addV(T3 vertex, boolean asCopy)
     
    int
    MeshSurface.addVCVal(T3 vertex, float value, boolean asCopy)
     
    ModulationSet.calculate(T3 tuv, boolean isQ)
    Calculate r_I internal d-space coordinate of an atom.
    static String
    Escape.eAP(T3[] plist)
     
    static String
    Escape.eP(T3 xyz)
    must be its own, because of the possibility of being null
    static Object
    Escape.escapeHelical(String id, int tokType, P3 a, P3 b, T3[] pts)
    Jmol-specific post-processing of the array data returned by Measure.computeHelicalAxis
    static String
    SimpleUnitCell.escapeMultiplier(T3 pt)
    Generally the multiplier is just {ijk ijk scale}, but when we have 1iiijjjkkk 1iiijjjkkk scale, floats lose kkk due to Java float precision issues so we use P4 {1iiijjjkkk 1iiijjjkkk scale, 1kkkkkk}
    static int
    SimpleUnitCell.getCellRange(T3 fset, P3[] cellRange)
     
    static void
    GData.getHermiteList(int tension, T3 p0, T3 p1, T3 p2, T3 p3, T3 p4, T3[] list, int index0, int n, boolean isPt)
    Used by Navigator, BioShapeRenderer, and DrawRenderer
    ModulationSet.getModulation(char type, T3 tuv, boolean occ100)
     
    static T3[]
    SimpleUnitCell.getReciprocal(T3[] abc, T3[] ret, float scale)
    Generate the reciprocal unit cell, scaled as desired
    static final P3[]
    BoxInfo.getVerticesFromOABC(T3[] oabc)
     
    Triangulator.intersectPlane(P4 plane, T3[] vertices, int flags)
    a generic cell - plane intersector -- used for finding the plane through a not static so as to allow JavaScript to not load it as core.
    MeshSurface.newMesh(boolean isAlt, T3[] vertices, int vertexCount, int[][] polygonIndexes, T3[] normals, int nNormals)
     
    static P4
    SimpleUnitCell.ptToIJK(T3 pt, int scale)
    Convert user's {3 2 1} to {1500500500, 1503502501, 0 or 1, 1500501}
    static T3[]
    SimpleUnitCell.setAbc(String abcabg, float[] params, T3[] ucnew)
    set cell vectors by string.
    static T3[]
    SimpleUnitCell.setAbcFromParams(float[] params, T3[] ucnew)
     
    void
    BoxInfo.setBoundBox(T3 pt1, T3 pt2, boolean byCorner, float scale)
     
    void
    BoxInfo.setBoundBoxFromOABC(T3[] points)
     
    ModulationSet.setCalcPoint(T3 pt, T3 t456, float vibScale, float scale)
    get updated value for offset vector and for occupancy
    Vibration.setCalcPoint(T3 pt, T3 t456, float scale, float modulationScale)
     
    Tensor.setFromEigenVectors(T3[] eigenVectors, float[] eigenValues, String type, String id, Tensor t)
    Standard constructor for charge and iso.
    void
    ModulationSet.setModTQ(T3 a, boolean isOn, T3 qtOffset, boolean isQ, float scale)
    Set modulation "t" value, which sets which unit cell in sequence we are looking at; d=1 only.
    void
    ModulationSet.setXYZ(T3 v)
     
    void
    Vibration.setXYZ(T3 vib)
     
    final void
    SimpleUnitCell.toCartesian(T3 pt, boolean ignoreOffset)
     
    final void
    SimpleUnitCell.toFractional(T3 pt, boolean ignoreOffset)
     
    static final P3[]
    BoxInfo.toOABC(P3[] bbVertices, T3 offset)
    Delivers [center a b c] for generation of unit cells from a boundbox
    void
    SimpleUnitCell.unitizeDim(int dimension, T3 pt)
    Used for just about everything; via UnitCell including SpaceGroup.getSiteMultiplicity, Symmetry.getInvariantSymops, Symmetry.removeDuplicates, Symmetry.unitize, Symmetry.toUnitCell, SymmetryDesc.getTransform.
    static void
    SimpleUnitCell.unitizeDimRnd(int dimension, T3 pt, float slop)
    Only used for getting equivalent points and checking for duplicates.
  • Uses of T3 in org.jmol.viewer

    Methods in org.jmol.viewer that return T3
    Modifier and Type
    Method
    Description
    T3[]
    Viewer.getV0abc(int iModel, Object def)
    convert string abc;offset or M3 or M4 to origin and three vectors -- a, b, c.
    TransformManager.getVibrationPoint(Vibration v, T3 pt, float scale)
    return
    Methods in org.jmol.viewer with parameters of type T3
    Modifier and Type
    Method
    Description
    Viewer.findSpaceGroup(SymmetryInterface sym, BS bsAtoms, String xyzList, float[] unitCellParams, T3 origin, T3[] oabc, int flags)
     
    protected void
    TransformManager.getScreenTemp(T3 ptXYZ)
     
    protected void
    TransformManager4D.getScreenTemp(T3 ptXYZ)
     
    TransformManager.getVibrationPoint(Vibration v, T3 pt, float scale)
    return
    void
    Viewer.hoverOnPt(int x, int y, String text, String id, T3 pt)
    Hover over an arbitrary point.
    void
    TransformManager.rotatePoint(T3 pt, T3 ptRot)
     
    void
    Viewer.setAtomCoordsRelative(T3 offset, BS bs)
     
    void
    Viewer.setIteratorForPoint(AtomIndexIterator iterator, int modelIndex, T3 pt, float distance)
     
    void
    Viewer.startSpinningAxis(T3 pt1, T3 pt2, boolean isClockwise)
     
    void
    Viewer.toCartesian(T3 pt, boolean ignoreOffset)
    absolute or relative to origin of UNITCELL {x y z}
    void
    Viewer.toCartesianUC(SymmetryInterface unitCell, T3 pt, boolean ignoreOffset)
     
    void
    Viewer.toFractional(T3 pt, boolean ignoreOffset)
     
    void
    Viewer.toFractionalUC(SymmetryInterface unitCell, T3 pt, boolean ignoreOffset)
     
    TransformManager.transformPt(T3 ptXYZ)
    CAUTION! returns a POINTER TO A TEMPORARY VARIABLE
    TransformManager.transformPt2D(T3 ptXyp)
     
    void
    TransformManager.transformPt2Df(T3 v, P3 pt)
     
    void
    TransformManager.transformPt3f(T3 ptXYZ, P3 screen)
     
    void
    TransformManager.transformPtNoClip(T3 ptXYZ, T3 pointScreen)
     
    void
    TransformManager.transformPtScr(T3 ptXYZ, P3i pointScreen)
     
    void
    TransformManager.transformPtScrT3(T3 ptXYZ, T3 pointScreen)
     
    void
    TransformManager.transformPtScrT32D(T3 v, P3 pt)
     
    void
    TransformManager.unTransformPoint(T3 screenPt, T3 coordPt)
     
    boolean
    TransformManager.xyzIsSlabbedInternal(T3 ptRef)