# Uses of Class
javajs.util.T3

Packages that use T3
Package
Description
javajs.util
org.jmol.adapter.smarter
org.jmol.adapter.writers
org.jmol.api
org.jmol.atomdata
org.jmol.bspt
Provides Binary Space Partitioning Functionality to spacially separate data structures in n-dimensions
org.jmol.export
org.jmol.g3d
Provides a software implementation of complete 3D graphics engine for rendering molecules and associated shapes.
org.jmol.jvxl.api
org.jmol.jvxl.data
org.jmol.jvxl.readers
org.jmol.modelkit
org.jmol.modelset
org.jmol.quantum
org.jmol.render
org.jmol.script
org.jmol.shape
org.jmol.shapecgo
org.jmol.shapespecial
org.jmol.shapesurface
org.jmol.smiles
Jmol SMILES, Jmol SMARTS, Jmol bioSMILES, and Jmol bioSMARTS
org.jmol.symmetry
org.jmol.util
org.jmol.viewer

## Uses of T3 in javajs.util

Subclasses of T3 in javajs.util
Modifier and Type
Class
Description
`class`
`A4`
A 4 element axis angle represented by single precision floating point x,y,z,angle components.
`class`
`P3`
A 3 element point that is represented by single precision floating point x,y,z coordinates.
`class`
`P4`
A 4 element point that is represented by single precision floating point x,y,z,w coordinates.
`class`
`T4`
A generic 4 element tuple that is represented by single precision floating point x,y,z and w coordinates.
`class`
`V3`
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`
T3.`putP(T3 t)`
`T3`
M4.`rotTrans2(T3 point, T3 pointOut)`
Transforms the point parameter with this Matrix4f and places the result into pointOut.
`T3`
T3.`setP(T3 t)`
`T3`
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`
CU.`colorPtToFFRGB(T3 pt)`
`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`
T3.`distanceSquared(T3 p1)`
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`
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.
`T3`
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`
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).
`T3`
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`
`Atom`
Fields in org.jmol.adapter.smarter declared as T3
Modifier and Type
Field
Description
`T3`
AtomSetCollectionReader.`paramsLattice`
Methods in org.jmol.adapter.smarter that return T3
Modifier and Type
Method
Description
`T3`
XtalSymmetry.`getOverallSpan()`
Methods in org.jmol.adapter.smarter with parameters of type T3
Modifier and Type
Method
Description
`String`
XtalSymmetry.FileSymmetry.`fcoord(T3 p)`
`void`
XtalSymmetry.FileSymmetry.`toUnitCellRnd(T3 pt, T3 offset)`

## Uses of T3 in org.jmol.adapter.writers

Methods in org.jmol.adapter.writers with parameters of type T3
Modifier and Type
Method
Description
`protected void`
CIFWriter.`append3(SB sb, T3 a)`

## Uses of T3 in org.jmol.api

Methods in org.jmol.api that return T3
Modifier and Type
Method
Description
`T3`
JmolModulationSet.`getModPoint(boolean asEnabled)`
`T3`
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`
SymmetryInterface.`adjustRangeMinMax(T3[] oabc, float packingRange, P3i minXYZ, P3i maxXYZ, P3 rmin, P3 rmax, P3i newMin, P3i newMax)`
`void`
JmolRendererInterface.`fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA, T3 ptB, T3 ptC, boolean doShade)`
`Object`
SymmetryInterface.`findSpaceGroup(BS atoms, String xyzList, float[] unitCellParams, T3 origin, T3[] oabc, int flags)`
`Object`
JmolModulationSet.`getModulation(char type, T3 t456, boolean occ100)`
`SymmetryInterface`
SymmetryInterface.`getUnitCell(T3[] oabc, 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`
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.`toCartesianSpin(T3 v)`
`void`
SymmetryInterface.`toFractional(T3 pt, boolean ignoreOffset)`
`void`
SymmetryInterface.`toFractionalSpin(T3 v)`
`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
`T3`
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
`int`
ModelKit.`cmdFillOABC(T3[] oabc, float packing, String cmd)`
`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`
`Atom`
Methods in org.jmol.modelset that return T3
Modifier and Type
Method
Description
`T3`
Atom.`atomPropertyTuple(Viewer vwr, int tok, P3 ptTemp)`
Methods in org.jmol.modelset with parameters of type T3
Modifier and Type
Method
Description
`BS`
ModelSet.`getAtomsWithin(float distance, T3 coord, BS bsResult, int modelIndex)`
`String`
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)`
`Vibration`
AtomCollection.`setAtomVibrationVector(int atomIndex, T3 vib)`
`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)`
`SymmetryInterface`
ModelSet.`setModelCagePts(int iModel, T3[] originABC, String name)`
`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
`T3`
ScriptParam.`checkHKL(T3 pt)`
Note - this check does not allow a 0 for h, k, or l.
`T3`
ScriptParam.`getFractionalPoint(int i)`
Could return a P4 for large 1100100100 type indicators
`T3`
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
`T3`
ScriptParam.`checkHKL(T3 pt)`
Note - this check does not allow a 0 for h, k, or l.
`P4`
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)`
////////// VertexDataServer interface methods ////////////////
`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`
`SmilesAtom`
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(Viewer vwr, SimpleUnitCell uc, Object def, M4 retMatrix)`
`T3`
Symmetry.`getUnitCellMultiplier()`
`T3[]`
Symmetry.`getV0abc(Object def, M4 retMatrix)`
Methods in org.jmol.symmetry with parameters of type T3
Modifier and Type
Method
Description
`void`
Symmetry.`adjustRangeMinMax(T3[] oabc, float packingRange, P3i minXYZ, P3i maxXYZ, P3 rmin, P3 rmax, P3i newMin, P3i newMax)`
`void`
UnitCell.`adjustRangeMinMax(T3[] oabc, float packingRange, P3i minXYZ, P3i maxXYZ, P3 rmin, P3 rmax, P3i newMin, P3i newMax)`
`static String`
SymmetryOperation.`fcoord(T3 p, String sep)`
Get string version of fraction
`Object`
Symmetry.`findSpaceGroup(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)`
note = this method will return 'n' for SG 161 do an operator's odd 1/2 -1/2 1/2 glide (but only for additional operations, not the basic set but ITA says "tetragonal and cubic only" in Table ITA1969 4.1.6
`SymmetryInterface`
Symmetry.`getUnitCell(T3[] oabc, boolean setRelative, String name)`
`String`
SymmetryOperation.`getxyzTrans(T3 t)`
`void`
SymmetryOperation.`rotateSpin(T3 vib)`
`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)`
`SymmetryInterface`
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.`toCartesianSpin(T3 v)`
`void`
UnitCell.`toCartesianSpin(T3 v)`
`void`
Symmetry.`toFractional(T3 pt, boolean ignoreOffset)`
`void`
Symmetry.`toFractionalSpin(T3 v)`
`void`
UnitCell.`toFractionalSpin(T3 v)`
`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`
`ModulationSet`
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`
`Point3fi`
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) associated symmetry operation (generating equivalent atoms in UnitCell.java)
`class`
`Vibration`
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
`T3`
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)`
`T3`
ModulationSet.`setCalcPoint(T3 pt, T3 t456, float vibScale, float scale)`
get updated value for offset vector and for occupancy
`T3`
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`
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
`Object`
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)`
`Lst<Object>`
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.
`static MeshSurface`
MeshSurface.`newMesh(boolean isAlt, T3[] vertices, int vertexCount, int[][] polygonIndexes, T3[] normals, int nNormals)`
`static Point3fi`
Point3fi.`newPF(T3 p, int i)`
`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)`
`T3`
ModulationSet.`setCalcPoint(T3 pt, T3 t456, float vibScale, float scale)`
get updated value for offset vector and for occupancy
`T3`
Vibration.`setCalcPoint(T3 pt, T3 t456, float scale, float modulationScale)`
`Tensor`
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 M3d or M4d to origin and three vectors -- a, b, c.
`T3`
TransformManager.`getVibrationPoint(Vibration v, T3 pt, float scale)`
return
Methods in org.jmol.viewer with parameters of type T3
Modifier and Type
Method
Description
`Object`
Viewer.`findSpaceGroup(SymmetryInterface sym, BS bsAtoms, String xyzList, float[] unitCellParams, T3 origin, T3[] oabc, int flags)`
`protected void`
TransformManager.`getScreenTemp(T3 ptXYZ, P3 fScrPt)`
`protected void`
TransformManager4D.`getScreenTemp(T3 ptXYZ, P3 fScrPt)`
`T3`
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)`
`P3i`
TransformManager.`transformPt(T3 ptXYZ)`
RENDERERS ONLY CAUTION! returns a POINTER TO A TEMPORARY VARIABLE
`P3i`
TransformManager.`transformPt2D(T3 ptXyp)`
RENDERERS ONLY
`void`
TransformManager.`transformPt3f(T3 ptXYZ, P3 screen)`
RENDERERS ONLY
`void`
TransformManager.`transformPt3fSafe(T3 ptXYZ, P3 screen)`
`void`
TransformManager.`transformPtNoClip(T3 ptXYZ, T3 pointScreen)`
RENDERERS ONLY
`P3i`
TransformManager.`transformPtSafe(T3 ptXYZ)`
`void`
TransformManager.`transformPtScr(T3 ptXYZ, P3i pointScreen)`
RENDERERS ONLY
`void`
TransformManager.`transformPtScrSafe(T3 ptXYZ, P3i pointScreen)`
`void`
TransformManager.`transformPtScrT3(T3 ptXYZ, T3 pointScreen)`
RENDERERS ONLY
`void`
TransformManager.`unTransformPoint(T3 screenPt, T3 coordPt)`
`boolean`
TransformManager.`xyzIsSlabbedInternal(T3 ptRef)`