# Uses of Class
javajs.util.P3

Packages that use P3
Package
Description
javajs.img
javajs.util
jspecview.java
jspecview.js2d
org.jmol.adapter.readers.cif
org.jmol.adapter.readers.pdb
org.jmol.adapter.smarter
org.jmol.api
org.jmol.atomdata
org.jmol.awt
org.jmol.awtjs2d
org.jmol.bspt
Provides Binary Space Partitioning Functionality to spacially separate data structures in n-dimensions
org.jmol.dssx
org.jmol.export
org.jmol.g3d
Provides a software implementation of complete 3D graphics engine for rendering molecules and associated shapes.
org.jmol.geodesic
org.jmol.jvxl.api
org.jmol.jvxl.calc
org.jmol.jvxl.data
org.jmol.jvxl.readers
org.jmol.modelkit
org.jmol.modelset
org.jmol.modelsetbio
org.jmol.multitouch
org.jmol.quantum
org.jmol.render
org.jmol.renderbio
org.jmol.renderspecial
org.jmol.script
org.jmol.scriptext
org.jmol.shape
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
org.openscience.jvxl.simplewriter

## Uses of P3 in javajs.img

Methods in javajs.img that return P3
Modifier and Type
Method
Description
`P3`
GifEncoder.`labToXyz(P3 lab, P3 xyz)`
`P3`
GifEncoder.`rgbToXyz(P3 rgb, P3 xyz)`
`protected P3`
GifEncoder.`toLABnorm(int rgb)`
////////////////////// CIE Lab / XYZ / sRGB conversion methods /////////
`protected P3`
GifEncoder.`toRGB(P3 lab)`
`P3`
GifEncoder.`xyzToLab(P3 xyz, P3 lab)`
`P3`
GifEncoder.`xyzToRgb(P3 xyz, P3 rgb)`
Methods in javajs.img with parameters of type P3
Modifier and Type
Method
Description
`P3`
GifEncoder.`labToXyz(P3 lab, P3 xyz)`
`P3`
GifEncoder.`rgbToXyz(P3 rgb, P3 xyz)`
`protected P3`
GifEncoder.`toRGB(P3 lab)`
`P3`
GifEncoder.`xyzToLab(P3 xyz, P3 lab)`
`P3`
GifEncoder.`xyzToRgb(P3 xyz, P3 rgb)`

## Uses of P3 in javajs.util

Subclasses of P3 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.
Methods in javajs.util that return P3
Modifier and Type
Method
Description
`static final P3`
CU.`colorPtFromInt(int color, P3 pt)`
`static final P3`
CU.`colorPtFromString(String colorName)`
`static P3[]`
Measure.`getBestLineThroughPoints(P3[] points, int nPoints)`
Get the endpoints of the best line through N points, where N >= 2
`static P3[]`
Measure.`getCenterAndPoints(Lst<P3> vPts)`
from a list of points, create an array that includes the center point as the first point.
`static P3`
Measure.`getIntersection(P3 pt1, V3 v, P4 plane, P3 ptRet, V3 tempNorm, V3 vTemp)`
Calculate the intersection of a line with a plane.
`static P3[]`
Measure.`getProjectedLineSegment(P3[] points, int nPoints, P3 ptA, V3 unitVector, V3 vTemp)`
`static P3`
P3.`getUnlikely()`
`static P3`
CU.`hslToRGB(P3 hsl)`
Convert HSL (hue/saturation/luninance) values to RGB
`static P3`
P3.`new3(float x, float y, float z)`
`static P3`
P3.`newA(float[] a)`
`static P3`
P3.`newP(T3 t)`
`static P3`
CU.`rgbToHSL(P3 rgb, boolean doRound)`
Convert RGB values to HSL (hue/saturation/lightness)
Methods in javajs.util that return types with arguments of type P3
Modifier and Type
Method
Description
`static Lst<P3>`
Measure.`getLatticePoints(Lst<P3> cpts, int h, int k, int l)`
Based on a set of centering points, creates a list of lattice points in place.
`static Lst<P3>`
Measure.`getPointsOnPlane(P3[] pts, P4 plane)`
Based on a set of centering points, returns the list of points on a given plane.
`static Lst<P3>`
Measure.`transformPoints(Lst<P3> vPts, M4 m4, P3 center)`
Methods in javajs.util with parameters of type P3
Modifier and Type
Method
Description
`static void`
Measure.`calcAveragePoint(P3 pointA, P3 pointB, P3 pointC)`
`static void`
Measure.`calcAveragePointN(P3[] points, int nPoints, P3 averagePoint)`
`static void`
Measure.`calcBestAxisThroughPoints(P3[] points, int nPoints, P3 axisA, V3 axisUnitVector, V3 vectorProjection, int nTriesMax)`
`static float`
Measure.`calcBestPlaneThroughPoints(P3[] points, int nPoints, P4 plane)`
Calculate the best ax + by + cz + d = 0 plane through a number of points using a three-step check for the best plane based on normal distance.
`static float`
Measure.`calcPlaneForMode(P3[] points, int nPoints, P4 plane, char mode)`
Compact calculation of the best pane using a simple method discussed at https://stackoverflow.com/questions/12299540/plane-fitting-to-4-or-more-xyz-points (A^T A)^-1 A^T B run three times to ensure that at least one is not perpendicular.
`static Quat`
Measure.`calculateQuaternionRotation(P3[][] centerAndPoints, float[] retStddev)`
Closed-form solution of absolute orientation requiring 1:1 mapping of positions.
`static final P3`
CU.`colorPtFromInt(int color, P3 pt)`
`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.
`static float`
Measure.`directedDistanceToPlane(P3 pt, P4 plane, P3 ptref)`
`static float`
Measure.`distanceToPlaneD(P4 plane, float d, P3 pt)`
`static float`
Measure.`distanceToPlaneV(V3 norm, float w, P3 pt)`
`static float`
Measure.`findAxis(P3[] points, int nPoints, P3 axisA, V3 axisUnitVector, V3 vectorProjection)`
`static P3[]`
Measure.`getBestLineThroughPoints(P3[] points, int nPoints)`
Get the endpoints of the best line through N points, where N >= 2
`static void`
Measure.`getBisectingPlane(P3 pointA, V3 vAB, T3 ptTemp, V3 vTemp, P4 plane)`
`static P3`
Measure.`getIntersection(P3 pt1, V3 v, P4 plane, P3 ptRet, V3 tempNorm, V3 vTemp)`
Calculate the intersection of a line with a plane.
`static boolean`
Measure.`getNormalFromCenter(P3 ptCenter, P3 ptA, P3 ptB, P3 ptC, boolean isOutward, V3 normal, V3 vTemp)`
`static void`
Measure.`getNormalToLine(P3 pointA, P3 pointB, V3 vNormNorm)`
`static Lst<P3>`
Measure.`getPointsOnPlane(P3[] pts, P4 plane)`
Based on a set of centering points, returns the list of points on a given plane.
`static P3[]`
Measure.`getProjectedLineSegment(P3[] points, int nPoints, P3 ptA, V3 unitVector, V3 vTemp)`
`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).
`static float`
Measure.`getRmsd(P3[][] centerAndPoints, Quat q)`
`static float`
Measure.`getTransformMatrix4(Lst<P3> ptsA, Lst<P3> ptsB, M4 m, P3 centerA)`
Fills a 4x4 matrix with rotation-translation of mapped points A to B.
`static P3`
CU.`hslToRGB(P3 hsl)`
Convert HSL (hue/saturation/luninance) values to RGB
`static boolean`
Measure.`isInTetrahedron(P3 pt, P3 ptA, P3 ptB, P3 ptC, P3 ptD, P4 plane, V3 vTemp, V3 vTemp2, boolean fullyEnclosed)`
`static boolean`
Measure.`isInTriangle(P3 p, P3 a, P3 b, P3 c, V3 v0, V3 v1, V3 v2)`
`static float`
Measure.`projectOntoAxis(P3 pt, P3 ptA, V3 axisUnitVector, V3 vectorProjection)`
project point onto a line containing ptA and having axis unitVector axisUnitVector, returning the result in point and a vector from ptA to pt in vectorProjection
`static P3`
CU.`rgbToHSL(P3 rgb, boolean doRound)`
Convert RGB values to HSL (hue/saturation/lightness)
`static Lst<P3>`
Measure.`transformPoints(Lst<P3> vPts, M4 m4, P3 center)`
Method parameters in javajs.util with type arguments of type P3
Modifier and Type
Method
Description
`static P3[]`
Measure.`getCenterAndPoints(Lst<P3> vPts)`
from a list of points, create an array that includes the center point as the first point.
`static Lst<P3>`
Measure.`getLatticePoints(Lst<P3> cpts, int h, int k, int l)`
Based on a set of centering points, creates a list of lattice points in place.
`static float`
Measure.`getTransformMatrix4(Lst<P3> ptsA, Lst<P3> ptsB, M4 m, P3 centerA)`
Fills a 4x4 matrix with rotation-translation of mapped points A to B.
`static Lst<P3>`
Measure.`transformPoints(Lst<P3> vPts, M4 m4, P3 center)`

## Uses of P3 in jspecview.java

Methods in jspecview.java with parameters of type P3
Modifier and Type
Method
Description
`void`
AwtPlatform.`convertPointFromScreen(Object display, P3 ptTemp)`
// Display

## Uses of P3 in jspecview.js2d

Methods in jspecview.js2d with parameters of type P3
Modifier and Type
Method
Description
`void`
JsPlatform.`convertPointFromScreen(Object canvas, P3 ptTemp)`

## Uses of P3 in org.jmol.adapter.readers.cif

Methods in org.jmol.adapter.readers.cif with parameters of type P3
Modifier and Type
Method
Description
`org.jmol.adapter.readers.cif.TopoCifParser.TNode`
TopoCifParser.`findNode(String nodeID, int op, P3 trans)`
Called from TLink and TAtom to find a node with the given symmetry.
`void`
MSRdr.`setMinMax0(P3 minXYZ, P3 maxXYZ)`

## Uses of P3 in org.jmol.adapter.readers.pdb

Methods in org.jmol.adapter.readers.pdb with parameters of type P3
Modifier and Type
Method
Description
`Object[]`
JmolDataReader.`getJmolDataFrameProperties(ScriptEval e, int tok, int[] propToks, String[] props, BS bs, P3 minXYZ, P3 maxXYZ, String format, boolean isPdbFormat)`
`BS`
JmolDataReader.`getPlotSpinSet(Viewer vwr, BS bs, int modelIndex, P3 minXYZ, P3 maxXYZ)`
remove non-spin atoms and atoms with duplicated spin and set min/max XYZ for the plot

## Uses of P3 in org.jmol.adapter.smarter

Subclasses of P3 in org.jmol.adapter.smarter
Modifier and Type
Class
Description
`class`
`Atom`
Fields in org.jmol.adapter.smarter declared as P3
Modifier and Type
Field
Description
`protected P3`
AtomSetCollectionReader.`fileOffset`
`protected P3`
AtomSetCollectionReader.`fileScaling`
`protected P3`
AtomSetCollectionReader.`ptSupercell`
`protected P3`
AtomSetCollectionReader.`unitCellOffset`
Methods in org.jmol.adapter.smarter with parameters of type P3
Modifier and Type
Method
Description
`protected int`
AtomSetCollectionReader.`cloneLastAtomSet(int ac, P3[] pts)`
`int`
AtomSetCollection.`cloneLastAtomSetFromPoints(int ac, P3[] pts)`
`Atom`
Atom.`copyTo(P3 pt, AtomSetCollection asc)`
`void`
AtomSetCollectionReader.`fixFloatPt(P3 pt, float prec)`
`static boolean`
XtalSymmetry.`isWithinSupercell(int ndims, P3 pt, float minX, float maxX, float minY, float maxY, float minZ, float maxZ, float slop)`
`V3[]`
XtalSymmetry.FileSymmetry.`rotateAxes(int iop, V3[] axes, P3 ptTemp, M3 mTemp)`
`void`
MSInterface.`setMinMax0(P3 minXYZ0, P3 maxXYZ0)`
`void`
XtalSymmetry.FileSymmetry.`twelfthify(P3 pt)`

## Uses of P3 in org.jmol.api

Methods in org.jmol.api that return P3
Modifier and Type
Method
Description
`abstract P3`
JmolViewer.`getBoundBoxCenter()`
`P3[]`
SymmetryInterface.`getCanonicalCopy(float scale, boolean allow2D)`
`P3`
SymmetryInterface.`getCartesianOffset()`
`P3[]`
JmolAnnotationParser.`getDSSRFrame(Map<String,Object> dssrNT)`
`P3`
SymmetryInterface.`getFractionalOffset(boolean onlyIfFractional)`
`P3`
SymmetryInterface.`getFractionalOrigin()`
`P3[]`
JmolEnvCalc.`getPoints()`
`P3`
AtomIndexIterator.`getPosition()`
`P3`
SymmetryInterface.`getUnitCellCenter()`
`P3[]`
SymmetryInterface.`getUnitCellVectors()`
`P3[]`
SymmetryInterface.`getUnitCellVerticesNoOffset()`
`P3`
JmolAdapterAtomIterator.`getXYZ()`
`P3`
SymmetryInterface.`toSupercell(P3 fpt)`
Methods in org.jmol.api that return types with arguments of type P3
Modifier and Type
Method
Description
`Lst<P3>`
SymmetryInterface.`generateCrystalClass(P3 pt0)`
`Lst<P3>`
SymmetryInterface.`getLatticeCentering()`
Methods in org.jmol.api with parameters of type P3
Modifier and Type
Method
Description
`BS`
JmolScriptManager.`addHydrogensInline(BS bsAtoms, Lst<Atom> vConnections, P3[] pts, Map<String,Object> htParams)`
`void`
SymmetryInterface.`adjustRangeMinMax(T3[] oabc, float packingRange, P3i minXYZ, P3i maxXYZ, P3 rmin, P3 rmax, P3i newMin, P3i newMax)`
`boolean`
SymmetryInterface.`checkPeriodic(P3 pt, float packing, float packing2)`
`void`
GenericPlatform.`convertPointFromScreen(Object display, P3 ptTemp)`
`void`
JmolRendererInterface.`drawBond(P3 atomA, P3 atomB, short colixA, short colixB, byte endcaps, short mad, int bondOrder)`
`void`
JmolRendererInterface.`drawDashedLineBits(int run, int rise, P3 screenA, P3 screenB)`
`boolean`
JmolRendererInterface.`drawEllipse(P3 ptAtom, P3 ptX, P3 ptY, boolean fillArc, boolean wireframeOnly)`
`void`
JmolRendererInterface.`drawHermite4(int tension, P3 s0, P3 s1, P3 s2, P3 s3)`
`void`
JmolRendererInterface.`drawHermite7(boolean fill, boolean border, int tension, P3 s0, P3 s1, P3 s2, P3 s3, P3 s4, P3 s5, P3 s6, P3 s7, int aspectRatio, short colixBack)`
`void`
JmolRendererInterface.`drawLineAB(P3 pointA, P3 pointB)`
`void`
JmolRendererInterface.`drawLineBits(short colixA, short colixB, P3 pointA, P3 pointB)`
`void`
JmolRendererInterface.`fillConeScreen3f(byte endcap, int screenDiameter, P3 screenBase, P3 screenTip, boolean isBarb)`
`void`
JmolRendererInterface.`fillCylinderBits(byte endcaps, int diameter, P3 screenA, P3 screenB)`
`void`
JmolRendererInterface.`fillCylinderBits2(short colixA, short colixB, byte endcaps, int diameter, P3 screenA, P3 screenB)`
`void`
JmolRendererInterface.`fillCylinderScreen3I(byte endcaps, int diameter, P3 s0f, P3 s1f, P3 pt0f, P3 pt1f, float radius)`
`void`
JmolRendererInterface.`fillEllipsoid(P3 center, P3[] points, int x, int y, int z, int diameter, M3 mToEllipsoidal, double[] coef, M4 mDeriv, int selectedOctant, P3[] octantPoints)`
`void`
JmolRendererInterface.`fillHermite(int tension, int diameterBeg, int diameterMid, int diameterEnd, P3 s0, P3 s1, P3 s2, P3 s3)`
`void`
JmolRendererInterface.`fillQuadrilateral(P3 screenA, P3 screenB, P3 screenC, P3 screenD, boolean isSolid)`
`void`
JmolRendererInterface.`fillSphereBits(int diameter, P3 center)`
fills a solid sphere
`void`
JmolRendererInterface.`fillTriangle3CNBits(P3 pA, short colixA, short nA, P3 pB, short colixB, short nB, P3 pC, short colixC, short nC, boolean twoSided)`
`void`
JmolRendererInterface.`fillTriangle3f(P3 screenA, P3 screenB, P3 screenC, boolean setNoisy)`
`void`
JmolRendererInterface.`fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA, T3 ptB, T3 ptC, boolean doShade)`
`void`
JmolRendererInterface.`fillTriangleTwoSided(short normix, P3 a, P3 b, P3 c)`
`Lst<P3>`
SymmetryInterface.`generateCrystalClass(P3 pt0)`
`float`
SymmetryInterface.`getCellWeight(P3 pt)`
`int[]`
SymmetryInterface.`getInvariantSymops(P3 p3, int[] v0)`
`int`
SymmetryInterface.`getSiteMultiplicity(P3 a)`
`Object`
SymmetryInterface.`getSymmetryInfoAtom(ModelSet ms, int iatom, String xyz, int op, P3 translation, P3 pt, P3 pt2, String id, int type, float scaleFactor, int nth, int options, int[] oplist)`
`M4`
SymmetryInterface.`getTransform(P3 fracA, P3 fracB, boolean debug)`
`Object`
SymmetryInterface.`getWyckoffPosition(P3 pt, String letter)`
`boolean`
SymmetryInterface.`isWithinUnitCell(P3 pt, float x, float y, float z, float packing)`
`void`
SymmetryInterface.`newSpaceGroupPoint(P3 pt, int i, M4 o, int transX, int transY, int transZ, P3 retPoint)`
`String`
SmilesMatcherInterface.`polyhedronToSmiles(Node center, int[][] faces, int atomCount, P3[] points, int flags, String details)`
`void`
JmolRendererInterface.`renderCrossHairs(int[] minMax, int screenWidth, int screenHeight, P3 navigationOffset, float navigationDepthPercent)`
`void`
SymmetryInterface.`setFinalOperations(int dim, String name, P3[] atoms, int iAtomFirst, int noSymmetryCount, boolean doNormalize, String filterSymop)`
`String`
SymmetryInterface.`staticToRationalXYZ(P3 fPt, String sep)`
`P3`
SymmetryInterface.`toSupercell(P3 fpt)`

## Uses of P3 in org.jmol.atomdata

Fields in org.jmol.atomdata declared as P3
Modifier and Type
Field
Description
`P3[][]`
AtomData.`hAtoms`
`P3[]`
AtomData.`xyz`

## Uses of P3 in org.jmol.awt

Methods in org.jmol.awt with parameters of type P3
Modifier and Type
Method
Description
`void`
Platform.`convertPointFromScreen(Object display, P3 ptTemp)`
// Display

## Uses of P3 in org.jmol.awtjs2d

Methods in org.jmol.awtjs2d with parameters of type P3
Modifier and Type
Method
Description
`void`
Platform.`convertPointFromScreen(Object canvas, P3 ptTemp)`

## Uses of P3 in org.jmol.bspt

Methods in org.jmol.bspt with parameters of type P3
Modifier and Type
Method
Description
`void`
Bspf.`addTuple(int bsptIndex, P3 tuple)`
`void`
Bspf.`initialize(int modelIndex, P3[] atoms, BS modelAtomBitSet)`
`static int`
PointIterator.`withinDistPoints(float distance, P3 pt, P3[] ap3, P3[] ap31, BS bsSelected, Object[] ret)`
carry out various functions of the within() script function

## Uses of P3 in org.jmol.dssx

Methods in org.jmol.dssx that return P3
Modifier and Type
Method
Description
`P3[]`
AnnotationParser.`getDSSRFrame(Map<String,Object> dssrNT)`
`P3[]`
DSSR1.`getDSSRFrame(Map<String,Object> nt)`

## Uses of P3 in org.jmol.export

Fields in org.jmol.export declared as P3
Modifier and Type
Field
Description
`protected P3`
___Exporter.`cameraPosition`
`protected final P3`
___Exporter.`center`
`protected P3`
___Exporter.`fixedRotationCenter`
`protected P3`
___Exporter.`referenceCenter`
`protected final P3`
___Exporter.`tempP1`
`protected final P3`
___Exporter.`tempP2`
`protected final P3`
___Exporter.`tempP3`
`protected P3`
_VrmlExporter.`tempQ1`
`protected P3`
_VrmlExporter.`tempQ2`
`protected P3`
_VrmlExporter.`tempQ3`
Methods in org.jmol.export that return P3
Modifier and Type
Method
Description
`protected P3`
__CartesianExporter.`getCameraPosition()`
`protected P3`
__CartesianExporter.`getModelCenter()`
Methods in org.jmol.export with parameters of type P3
Modifier and Type
Method
Description
`void`
Export3D.`drawBond(P3 atomA, P3 atomB, short colixA, short colixB, byte endcaps, short mad, int bondOrder)`
`void`
Export3D.`drawDashedLineBits(int run, int rise, P3 pointA, P3 pointB)`
`boolean`
Export3D.`drawEllipse(P3 ptAtom, P3 ptX, P3 ptY, boolean fillArc, boolean wireframeOnly)`
`void`
Export3D.`drawHermite4(int tension, P3 s0, P3 s1, P3 s2, P3 s3)`
`void`
Export3D.`drawHermite7(boolean fill, boolean border, int tension, P3 s0, P3 s1, P3 s2, P3 s3, P3 s4, P3 s5, P3 s6, P3 s7, int aspectRatio, short colixBack)`
`void`
Export3D.`drawLineAB(P3 pointA, P3 pointB)`
`void`
Export3D.`drawLineBits(short colixA, short colixB, P3 pointA, P3 pointB)`
`void`
Export3D.`drawLineBits(P3 screenA, P3 screenB, short colixA, short colixB)`
`void`
Export3D.`fillConeScreen3f(byte endcap, int screenDiameter, P3 pointBase, P3 screenTip, boolean isBarb)`
`protected void`
_TachyonExporter.`fillConicalCylinder(P3 screenA, P3 screenB, int madBond, short colix, byte endcaps)`
`void`
Export3D.`fillCylinderBits(byte endcaps, int diameter, P3 pointA, P3 pointB)`
`void`
Export3D.`fillCylinderBits2(short colixA, short colixB, byte endcaps, int mad, P3 screenA, P3 screenB)`
`void`
Export3D.`fillCylinderScreen3I(byte endcaps, int diameter, P3 pointA, P3 pointB, P3 pt0f, P3 pt1f, float radius)`
`void`
Export3D.`fillEllipsoid(P3 center, P3[] points, int x, int y, int z, int diameter, M3 mToEllipsoidal, double[] coef, M4 mDeriv, int selectedOctant, P3[] octantPoints)`
`void`
Export3D.`fillHermite(int tension, int diameterBeg, int diameterMid, int diameterEnd, P3 s0, P3 s1, P3 s2, P3 s3)`
`void`
Export3D.`fillQuadrilateral(P3 pointA, P3 pointB, P3 pointC, P3 pointD, boolean isSolid)`
`void`
Export3D.`fillSphereBits(int diameter, P3 center)`
fills a solid sphere
`void`
Export3D.`fillTriangle3CNBits(P3 pA, short colixA, short nA, P3 pB, short colixB, short nB, P3 pC, short colixC, short nC, boolean twoSided)`
`void`
Export3D.`fillTriangle3f(P3 pointA, P3 pointB, P3 pointC, boolean setNoisy)`
`void`
Export3D.`fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA0, T3 ptB0, T3 ptC0, boolean doShade)`
`void`
Export3D.`fillTriangleTwoSided(short normix, P3 a, P3 b, P3 c)`
`protected static MeshSurface`
___Exporter.`getConeMesh(P3 centerBase, M3 matRotateScale, short colix)`
`protected M3`
___Exporter.`getRotationMatrix(P3 pt1, P3 pt2, float radius)`
`protected M3`
___Exporter.`getRotationMatrix(P3 pt1, P3 ptZ, float radius, P3 ptX, P3 ptY)`
`protected abstract void`
__CartesianExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
_IdtfExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
_MayaExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
_ObjExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
_StlExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
_VrmlExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
_X3dExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected void`
JSExporter.`outputCircle(P3 pt1, P3 pt2, float radius, short colix, boolean doFill)`
`protected abstract void`
__CartesianExporter.`outputCone(P3 ptBase, P3 ptTip, float radius, short colix)`
`protected void`
_IdtfExporter.`outputCone(P3 ptBase, P3 ptTip, float radius, short colix)`
`protected void`
_MayaExporter.`outputCone(P3 ptBase, P3 ptTip, float radius, short colix)`
`protected void`
_ObjExporter.`outputCone(P3 ptBase, P3 ptTip, float radius, short colix)`
`protected void`
_PovrayExporter.`outputCone(P3 screenBase, P3 screenTip, float radius, short colix, boolean isBarb)`
`protected void`
_TachyonExporter.`outputCone(P3 screenBase, P3 screenTip, float radius, short colix, boolean isBarb)`
`protected void`
_VrmlExporter.`outputCone(P3 ptBase, P3 ptTip, float radius, short colix)`
`protected void`
JSExporter.`outputCone(P3 ptBase, P3 ptTip, float radius, short colix)`
`protected abstract boolean`
__CartesianExporter.`outputCylinder(P3 ptCenter, P3 pt1, P3 pt2, short colix1, byte endcaps, float radius, P3 ptX, P3 ptY, boolean checkRadius)`
`protected boolean`
_IdtfExporter.`outputCylinder(P3 ptCenter, P3 pt1, P3 pt2, short colix, byte endcaps, float radius, P3 ptX, P3 ptY, boolean checkRadius)`
`protected boolean`
_MayaExporter.`outputCylinder(P3 ptCenter, P3 pt1, P3 pt2, short colix, byte endcaps, float radius, P3 ptX, P3 ptY, boolean checkRadius)`
`protected boolean`
_ObjExporter.`outputCylinder(P3 ptCenter, P3 pt1, P3 pt2, short colix, byte endcaps, float radius, P3 ptX, P3 ptY, boolean checkRadius)`
`protected void`
_PovrayExporter.`outputCylinder(P3 screenA, P3 screenB, float radius, short colix, boolean withCaps)`
`protected void`
_TachyonExporter.`outputCylinder(P3 screenA, P3 screenB, float radius, short colix, boolean withCaps)`
`protected boolean`
_VrmlExporter.`outputCylinder(P3 ptCenter, P3 pt1, P3 pt2, short colix, byte endcaps, float radius, P3 ptX, P3 ptY, boolean checkRadius)`
`protected boolean`
JSExporter.`outputCylinder(P3 ptCenter, P3 pt1, P3 pt2, short colix, byte endcaps, float radius, P3 ptX, P3 ptY, boolean checkRadius)`
`protected void`
_PovrayExporter.`outputCylinderConical(P3 screenA, P3 screenB, float radius1, float radius2, short colix)`
`protected void`
_TachyonExporter.`outputCylinderConical(P3 screenA, P3 screenB, float radius1, float radius2, short colix)`
`protected abstract void`
__CartesianExporter.`outputEllipsoid(P3 center, P3[] points, short colix)`
`protected void`
_IdtfExporter.`outputEllipsoid(P3 center, P3[] points, short colix)`
`protected void`
_MayaExporter.`outputEllipsoid(P3 center, P3[] points, short colix)`
`protected void`
_ObjExporter.`outputEllipsoid(P3 center, P3[] points, short colix)`
`protected void`
_PovrayExporter.`outputEllipsoid(P3 center, float radius, double[] coef, short colix)`
`protected void`
_TachyonExporter.`outputEllipsoid(P3 center, float radius, double[] coef, short colix)`
`protected void`
_VrmlExporter.`outputEllipsoid(P3 ptCenter, P3[] points, short colix)`
`protected void`
JSExporter.`outputEllipsoid(P3 center, P3[] points, short colix)`
`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`
_VrmlExporter.`outputQuaternionFrame(P3 ptCenter, P3 ptX, P3 ptY, P3 ptZ, float xScale, float yScale, float zScale)`
`protected void`
__CartesianExporter.`outputSolidPlate(P3 tempP1, P3 tempP2, P3 tempP3, short colix)`
`protected void`
_VrmlExporter.`outputSolidPlate(P3 tempP1, P3 tempP2, P3 tempP3, short colix)`
`protected abstract void`
__CartesianExporter.`outputSphere(P3 ptCenter, float f, short colix, boolean checkRadius)`
`protected void`
_IdtfExporter.`outputSphere(P3 center, float radius, short colix, boolean checkRadius)`
`protected void`
_MayaExporter.`outputSphere(P3 pt, float radius, short colix, boolean checkRadius)`
`protected void`
_ObjExporter.`outputSphere(P3 center, float radius, short colix, boolean checkRadius)`
`protected void`
_VrmlExporter.`outputSphere(P3 ptCenter, float radius, short colix, boolean checkRadius)`
`protected void`
JSExporter.`outputSphere(P3 ptCenter, float radius, short colix, boolean checkRadius)`
`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.`outputTextPixel(P3 pt, int argb)`
`protected void`
_IdtfExporter.`outputTextPixel(P3 pt, int argb)`
`protected void`
_MayaExporter.`outputTextPixel(P3 pt, int argb)`
`protected void`
_ObjExporter.`outputTextPixel(P3 pt, int argb)`
`protected void`
_VrmlExporter.`outputTextPixel(P3 pt, int argb)`
`protected void`
_X3dExporter.`outputTextPixel(P3 pt, int argb)`
`protected void`
JSExporter.`outputTextPixel(P3 pt, int argb)`
`protected void`
_VrmlExporter.`outputTransRot(P3 pt1, P3 pt2, int x, int y, int z)`
`void`
Export3D.`renderCrossHairs(int[] minMax, int screenWidth, int screenHeight, P3 navigationOffset, float navigationDepthPercent)`

## Uses of P3 in org.jmol.g3d

Methods in org.jmol.g3d with parameters of type P3
Modifier and Type
Method
Description
`void`
Graphics3D.`drawBond(P3 atomA, P3 atomB, short colixA, short colixB, byte endcaps, short mad, int bondOrder)`
`void`
Graphics3D.`drawDashedLineBits(int run, int rise, P3 pointA, P3 pointB)`
`boolean`
Graphics3D.`drawEllipse(P3 ptAtom, P3 ptX, P3 ptY, boolean fillArc, boolean wireframeOnly)`
`void`
Graphics3D.`drawHermite4(int tension, P3 s0, P3 s1, P3 s2, P3 s3)`
`void`
Graphics3D.`drawHermite7(boolean fill, boolean border, int tension, P3 s0, P3 s1, P3 s2, P3 s3, P3 s4, P3 s5, P3 s6, P3 s7, int aspectRatio, short colixBack)`
`void`
Graphics3D.`drawLineAB(P3 pointA, P3 pointB)`
`void`
Graphics3D.`drawLineBits(short colixA, short colixB, P3 pointA, P3 pointB)`
`void`
Graphics3D.`fillConeScreen3f(byte endcap, int screenDiameter, P3 screenBase, P3 screenTip, boolean isBarb)`
`void`
Graphics3D.`fillCylinderBits(byte endcaps, int diameter, P3 screenA, P3 screenB)`
`void`
Graphics3D.`fillCylinderBits2(short colixA, short colixB, byte endcaps, int diameter, P3 screenA, P3 screenB)`
`void`
Graphics3D.`fillCylinderScreen3I(byte endcaps, int diameter, P3 screenA, P3 screenB, P3 pt0f, P3 pt1f, float radius)`
`void`
Graphics3D.`fillEllipsoid(P3 center, P3[] points, int x, int y, int z, int diameter, M3 mToEllipsoidal, double[] coef, M4 mDeriv, int selectedOctant, P3[] octantPoints)`
`void`
Graphics3D.`fillHermite(int tension, int diameterBeg, int diameterMid, int diameterEnd, P3 s0, P3 s1, P3 s2, P3 s3)`
`void`
Graphics3D.`fillQuadrilateral(P3 screenA, P3 screenB, P3 screenC, P3 screenD, boolean isSolid)`
`void`
Graphics3D.`fillSphereBits(int diameter, P3 center)`
fills a solid sphere
`void`
Graphics3D.`fillTriangle3CNBits(P3 screenA, short colixA, short normixA, P3 screenB, short colixB, short normixB, P3 screenC, short colixC, short normixC, boolean twoSided)`
`void`
Graphics3D.`fillTriangle3f(P3 screenA, P3 screenB, P3 screenC, boolean isSolid)`
`void`
Graphics3D.`fillTriangle3i(P3 screenA, P3 screenB, P3 screenC, T3 ptA, T3 ptB, T3 ptC, boolean doShade)`
`void`
Graphics3D.`fillTriangleTwoSided(short normix, P3 screenA, P3 screenB, P3 screenC)`
`void`
Graphics3D.`renderCrossHairs(int[] minMax, int screenWidth, int screenHeight, P3 navOffset, float navDepth)`
`void`
HermiteRenderer.`renderHermiteRibbon(boolean fill, boolean border, int tension, P3 p0, P3 p1, P3 p2, P3 p3, P3 p4, P3 p5, P3 p6, P3 p7, int aspectRatio, int fillType)`
`void`
HermiteRenderer.`renderHermiteRope(boolean fill, int tension, int diameterBeg, int diameterMid, int diameterEnd, P3 p0, P3 p1, P3 p2, P3 p3)`

## Uses of P3 in org.jmol.geodesic

Methods in org.jmol.geodesic that return P3
Modifier and Type
Method
Description
`P3[]`
EnvelopeCalculation.`getPoints()`

## Uses of P3 in org.jmol.jvxl.api

Methods in org.jmol.jvxl.api that return P3
Modifier and Type
Method
Description
`P3[]`
MeshDataServer.`calculateGeodesicSurface(BS bsSelected, float envelopeRadius)`

## Uses of P3 in org.jmol.jvxl.calc

Fields in org.jmol.jvxl.calc declared as P3
Modifier and Type
Field
Description
`protected final P3`
MarchingCubes.`pointA`
`protected final P3`
MarchingCubes.`pt0`
Methods in org.jmol.jvxl.calc with parameters of type P3
Modifier and Type
Method
Description
`int`
MarchingSquares.`addContourVertex(P3 vertexXYZ, float value)`
`void`
MarchingCubes.`calcVertexPoint(int x, int y, int z, int vertex, P3 pt)`

## Uses of P3 in org.jmol.jvxl.data

Fields in org.jmol.jvxl.data declared as P3
Modifier and Type
Field
Description
`P3[]`
JvxlData.`boundingBox`
`P3`
JvxlData.`fixedLattice`
`P3`
JvxlData.`mapLattice`
`final P3`
VolumeData.`volumetricOrigin`
Methods in org.jmol.jvxl.data with parameters of type P3
Modifier and Type
Method
Description
`float`
VolumeData.`calculateFractionalPoint(float cutoff, P3 pointA, P3 pointB, float valueA, float valueB, P3 pt)`
`void`
VolumeData.`getPoint(int ipt, P3 pt)`
`void`
JvxlData.`setSurfaceInfo(P4 thePlane, P3 mapLattice, int nSurfaceInts, String surfaceData)`
`void`
JvxlData.`setSurfaceInfoFromBitSetPts(BS bs, P4 thePlane, P3 mapLattice)`

## Uses of P3 in org.jmol.jvxl.readers

Fields in org.jmol.jvxl.readers declared as P3
Modifier and Type
Field
Description
`P3[]`
Parameters.`boundingBox`
`protected P3[]`
VolumeFileReader.`boundingBox`
`protected P3[]`
VolumeFileReader.`boundingBox`
`protected P3[]`
VolumeFileReader.`boundingBox`
`protected P3`
SurfaceReader.`center`
`P3`
Parameters.`mapLattice`
`P3`
Parameters.`origin`
`P3`
Parameters.`points`
`P3[]`
Parameters.`probes`
`protected final P3`
SurfaceReader.`ptTemp`
////////////// MarchingReader Interface Methods ///////////////////
`P3`
Parameters.`steps`
`protected P3`
SurfaceReader.`volumetricOrigin`
`protected P3`
SurfaceReader.`xyzMax`
`protected P3`
SurfaceReader.`xyzMin`
Methods in org.jmol.jvxl.readers that return P3
Modifier and Type
Method
Description
`P3`
XmlReader.`getXmlPoint(String data, String key)`
`P3[]`
JvxlXmlReader.`jvxlDecodeVertexData(String data, boolean asArray)`
decode vertex data found within <jvxlVertexData> element as created by jvxlEncodeVertexData (see above)

## Uses of P3 in org.jmol.modelkit

Methods in org.jmol.modelkit with parameters of type P3
Modifier and Type
Method
Description
`int`
ModelKit.`checkMovedAtoms(BS bsFixed, BS bsAtoms, P3[] apos0)`
Something has changed atom positions.
`void`
ModelKit.`clickAssignAtom(int atomIndex, String element, P3 ptNew)`
From Mouse or handleAtomOrBondBicked
`int`
ModelKit.`cmdAssignAddAtoms(String type, P3[] pts, BS bsAtoms, float packing, String cmd)`
MODELKIT ADD @3 ...
`void`
ModelKit.`cmdAssignAtom(BS bs, P3 pt, String type, String cmd)`
A versatile method that allows changing element, setting charge, setting position, adding or deleting an atom via MODELKIT ASSIGN ATOM
`int`
ModelKit.`cmdAssignMoveAtoms(BS bsSelected, int iatom, P3 p, P3[] pts, boolean allowProjection, boolean isMolecule, boolean isCommand)`
`int`
ModelKit.`cmdRotateAtoms(BS bsAtoms, P3[] points, float endDegrees)`
`void`
ModelKit.`drawAxes(P3[] points, String id, String swidth)`
`String`
ModelKit.`drawSymmetry(String thisId, boolean isSymop, int iatom, String xyz, int iSym, P3 trans, P3 center, P3 target, int intScale, int nth, int options, int[] opList, boolean isModelkit)`
`int`
ModelKit.`moveMinConstrained(int iatom, P3 p, BS bsAtoms)`

## Uses of P3 in org.jmol.modelset

Subclasses of P3 in org.jmol.modelset
Modifier and Type
Class
Description
`class`
`Atom`
Fields in org.jmol.modelset declared as P3
Modifier and Type
Field
Description
`P3`
Text.`pointerPt`
`P3`
TickInfo.`reference`
`P3`
Measurement.`renderArc`
`P3`
TickInfo.`scale`
`P3`
TickInfo.`ticks`
`P3[]`
ModelSet.`translations`
`P3[]`
Model.`uvw`
`P3[]`
Model.`uvw0`
`P3`
Text.`xyz`
Methods in org.jmol.modelset that return P3
Modifier and Type
Method
Description
`P3[][]`
AtomCollection.`calculateHydrogens(BS bs, int[] nTotal, Lst<Atom> vConnect, int flags)`
get a list of potential H atom positions based on elemental valence and formal charge
`P3[]`
AtomCollection.`calculateSurface(BS bsSelected, float envelopeRadius)`
`P3`
ModelSet.`getAtomSetCenter(BS bs)`
`P3`
ModelSet.`getAverageAtomPoint()`
`P3`
ModelSet.`getBoundBoxCenter(int modelIndex)`
`P3[][]`
ModelSet.`getCenterAndPoints(Lst<Object[]> vAtomSets, boolean addCenters)`
`P3`
Atom.`getFractionalCoordPt(boolean fixJavaFloat, boolean ignoreOffset, P3 pt)`
`P3[]`
ModelSet.`getFrameOffsets(BS bsAtoms, boolean isFull)`
`P3`
AtomIteratorWithinModel.`getPosition()`
`P3`
ModelSet.`getTranslation(int iModel)`
`P3`
Atom.`getXYZ()`
`P3[]`
ModelSet.`saveAtomPositions()`
Methods in org.jmol.modelset that return types with arguments of type P3
Modifier and Type
Method
Description
`Lst<P3>`
AtomCollection.`generateCrystalClass(int atomIndex, P3 pt)`
`Lst<P3>`
AtomCollection.`getAtomPointVector(BS bs)`
Methods in org.jmol.modelset with parameters of type P3
Modifier and Type
Method
Description
`Atom`
ModelSet.`addAtom(int modelIndex, Group group, int atomicAndIsotopeNumber, String atomName, String atomType, int atomSerial, int atomSeqID, int atomSite, P3 xyz, float radius, V3 vib, int formalCharge, float partialCharge, float occupancy, float bfactor, Lst<Object> tensors, boolean isHetero, boolean isNegDisorder, byte specialAtomID, BS atomSymmetry, float bondRadius)`
`BS`
ModelSet.`addHydrogens(Lst<Atom> vConnections, P3[] pts)`
these are hydrogens that are being added due to a load 2D command and are therefore not to be flagged as NEW
`float`
Atom.`atomPropertyFloat(Viewer vwr, int tokWhat, P3 ptTemp)`
called by isosurface and int comparator via atomProperty() and also by getBitsetProperty()
`T3`
Atom.`atomPropertyTuple(Viewer vwr, int tok, P3 ptTemp)`
`float`
ModelSet.`calcRotationRadius(int modelIndex, P3 center, boolean useBoundBox)`
`String`
ModelSet.`calculatePointGroup(BS bsAtoms, P3 center)`
////// atom and shape selecting /////////
`String`
LabelToken.`formatLabel(Viewer vwr, Atom atom, String strFormat, P3 ptTemp)`
///////// label formatting for atoms, bonds, and measurements ///////////
`static String`
LabelToken.`formatLabelAtomArray(Viewer vwr, Atom atom, LabelToken[] tokens, char chAtom, int[] indices, P3 ptTemp)`
returns a formatted string based on the precompiled label tokens
`static String`
LabelToken.`formatLabelBond(Viewer vwr, Bond bond, LabelToken[] tokens, Map<String,Object> values, int[] indices, P3 ptTemp)`
`Lst<P3>`
AtomCollection.`generateCrystalClass(int atomIndex, P3 pt)`
`void`
AtomCollection.`getAtomIdentityInfo(int i, Map<String,Object> info, P3 ptTemp)`
`String`
AtomCollection.`getAtomInfo(int i, String format, P3 ptTemp)`
`Object`
ModelSet.`getBoundBoxOrientation(int type, BS bsAtoms, P3[] points)`
`void`
Trajectory.`getFractional(Atom a, P3 ptTemp)`
`P3`
Atom.`getFractionalCoordPt(boolean fixJavaFloat, boolean ignoreOffset, P3 pt)`
`Map<String,Object>`
Group.`getGroupInfo(int igroup, P3 ptTemp)`
`String`
Atom.`getIdentityXYZ(P3 pt, int mode)`
`Lst<Object>`
ModelSet.`getModulationList(BS bs, char type, P3 t456)`
`String`
ModelSet.`getPointGroupAsString(BS bsAtoms, String type, int index, float scale, P3[] pts, P3 center, String id)`
`void`
ModelSet.`getPointTransf(int i, Atom a, Quat q, P3 pTemp)`
pick up the appropriate value for this atom
`void`
Text.`getPymolScreenOffset(P3 atomPt, P3i screen, int zSlab, P3 pTemp, float sppa)`
PyMOL will use 1 here for pymolOffset[0] for relative, 0 or absolute.
`Object`
ModelSet.`getUnitCellPointsWithin(float distance, BS bs, P3 pt, boolean asMap)`
`void`
ModelSet.`invertSelected(P3 pt, P4 plane, int iAtom, BS bsAtoms)`
Carries out a stereochemical inversion through a point, across a plane, or at a chirality center.
`void`
ModelSet.`morphAtoms(BS bsAtoms, P3[][] points, int ipt, float f, P3 ptemp)`
`void`
ModelSet.`moveAtoms(M4 m4, M3 mNew, M3 rotation, V3 translation, BS bs, P3 center, boolean isInternal, boolean translationOnly)`
`void`
ModelSet.`restoreAtomPositions(P3[] apos0)`
`Atom`
Atom.`setAtom(int modelIndex, int atomIndex, P3 xyz, float radius, BS atomSymmetry, int atomSite, short atomicAndIsotopeNumber, int formalCharge, boolean isHetero, boolean isNegDisorder)`
`void`
Atom.`setFractionalCoordPt(P3 pt, P3 ptNew, boolean asAbsolute)`
`void`
ModelSet.`setModulation(BS bs, boolean isOn, P3 qtOffset, boolean isQ)`
Sets the modulation for all atoms in bs.
`void`
Text.`setXYZ(P3 xyz, boolean doAdjust)`
Constructors in org.jmol.modelset with parameters of type P3
Modifier
Constructor
Description
``
`TickInfo(P3 ticks)`

## Uses of P3 in org.jmol.modelsetbio

Fields in org.jmol.modelsetbio declared as P3
Modifier and Type
Field
Description
`protected P3`
ProteinStructure.`axisA`
`protected P3`
ProteinStructure.`axisB`
`protected P3[]`
BioPolymer.`controlPoints`
`P3[]`
NucleicMonomer.`dssrBox`
`P3[]`
NucleicMonomer.`dssrFrame`
`protected P3[]`
BioPolymer.`leadMidpoints`
`protected P3[]`
BioPolymer.`leadPoints`
`protected P3`
AlphaMonomer.`nitrogenHydrogenPoint`
Methods in org.jmol.modelsetbio that return P3
Modifier and Type
Method
Description
`final P3`
AlphaMonomer.`getAtomPoint(byte specialAtomID)`
`P3`
ProteinStructure.`getAxisEndPoint()`
`P3`
ProteinStructure.`getAxisStartPoint()`
`protected P3`
AlphaPolymer.`getControlPoint(int i, V3 v)`
`protected P3`
BioPolymer.`getControlPoint(int i, V3 v)`
`P3[]`
BioPolymer.`getControlPoints(boolean isTraceAlpha, float sheetSmoothing, boolean invalidate)`
`P3[]`
NucleicMonomer.`getDSSRFrame(Viewer vwr)`
`P3[]`
BioPolymer.`getLeadMidpoints()`
`protected P3`
AlphaMonomer.`getQuaternionFrameCenterAlpha(char qType)`
`P3[]`
ProteinStructure.`getSegments()`
`protected final P3`
Monomer.`getSpecialAtomPoint(byte[] interestingIDs, byte specialAtomID)`
Methods in org.jmol.modelsetbio with parameters of type P3
Modifier and Type
Method
Description
`void`
NucleicMonomer.`getBaseRing6Points(P3[] pts)`
`boolean`
NucleicMonomer.`getEdgePoints(P3[] pts)`
`Map<String,Object>`
Monomer.`getMyInfo(P3 ptTemp)`
`boolean`
AminoMonomer.`getNHPoint(P3 aminoHydrogenPoint, V3 vNH, boolean jmolHPoint, boolean dsspIgnoreHydrogens)`
`void`
NucleicMonomer.`getRiboseRing5Points(P3[] pts)`
`boolean`
NucleicMonomer.`maybeGetBaseRing5Points(P3[] pts)`
`void`
Sheet.`setBox(float w, float h, P3 pt, V3 vW, V3 vH, P3 ptC, float scale)`

## Uses of P3 in org.jmol.multitouch

Fields in org.jmol.multitouch declared as P3
Modifier and Type
Field
Description
`protected P3`
JmolMultiTouchClientAdapter.`ptTemp`
Methods in org.jmol.multitouch with parameters of type P3
Modifier and Type
Method
Description
`void`
ActionManagerMT.`processMultitouchEvent(int groupID, int eventType, int touchID, int iData, P3 pt, long time)`
`void`
JmolMultiTouchClient.`processMultitouchEvent(int groupID, int eventType, int touchID, int iData, P3 pt, long time)`

## Uses of P3 in org.jmol.quantum

Methods in org.jmol.quantum with parameters of type P3
Modifier and Type
Method
Description
`void`
MepCalculation.`calculate(VolumeData volumeData, BS bsSelected, P3[] xyz, Atom[] atoms, float[] potentials, int calcType)`
`float`
MepCalculation.`getValueAtPoint(P3 pt)`
`void`
MepCalculation.`setup(int calcType, float[] potentials, P3[] atomCoordAngstroms, BS bsSelected)`

## Uses of P3 in org.jmol.render

Fields in org.jmol.render declared as P3
Modifier and Type
Field
Description
`protected P3`
MeshRenderer.`latticeOffset`
`protected final P3[]`
CageRenderer.`p3Screens`
`protected final P3[]`
CageRenderer.`p3Screens`
`protected final P3[]`
CageRenderer.`p3Screens`
`protected P3[]`
MeshRenderer.`p3Screens`
`protected final P3`
FontLineShapeRenderer.`pointT`
`protected final P3`
FontLineShapeRenderer.`pointT2`
`protected final P3`
FontLineShapeRenderer.`pointT3`
`protected P3`
CageRenderer.`pt`
`protected P3`
CageRenderer.`pt`
`protected P3`
CageRenderer.`pt`
`protected P3`
FontLineShapeRenderer.`pt0`
`protected P3`
FontLineShapeRenderer.`pt1`
`protected final P3`
MeshRenderer.`pt1f`
`protected final P3`
MeshRenderer.`pt2f`
`protected P3`
LabelsRenderer.`pTemp`
`protected P3`
FontLineShapeRenderer.`tickA`
`protected P3`
FontLineShapeRenderer.`tickAs`
`protected P3`
FontLineShapeRenderer.`tickB`
`protected P3`
FontLineShapeRenderer.`tickBs`
`protected P3[]`
CageRenderer.`vvert`
`protected P3[]`
CageRenderer.`vvert`
`protected P3[]`
CageRenderer.`vvert`
Methods in org.jmol.render with parameters of type P3
Modifier and Type
Method
Description
`protected void`
FontLineShapeRenderer.`renderLine(P3 p0, P3 p1, int diameter, boolean drawTicks)`
`protected void`
UccageRenderer.`setPeriodicity(P3[] vertices, float scale)`

## Uses of P3 in org.jmol.renderbio

Fields in org.jmol.renderbio declared as P3
Modifier and Type
Field
Description
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPoints`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
BioShapeRenderer.`controlPointScreens`
`protected P3[]`
RocketsRenderer.`cordMidPoints`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonBottomScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
`protected P3[]`
BioShapeRenderer.`ribbonTopScreens`
Methods in org.jmol.renderbio with parameters of type P3
Modifier and Type
Method
Description
`void`
RocketsRenderer.`adjustStrut(P3[] segments, int start, int end, int offset)`

## Uses of P3 in org.jmol.renderspecial

Fields in org.jmol.renderspecial declared as P3
Modifier and Type
Field
Description
`protected P3`
DrawRenderer.`pt0`
`protected P3`
DrawRenderer.`pt1`
`protected P3`
DrawRenderer.`pt2`

## Uses of P3 in org.jmol.script

Fields in org.jmol.script declared as P3
Modifier and Type
Field
Description
`P3`
ScriptParam.`fractionalPoint`
set in getPointOrPlane
Methods in org.jmol.script that return P3
Modifier and Type
Method
Description
`P3`
ScriptParam.`atomCenterOrCoordinateParameter(int i, Object[] ret)`
`P3`
ScriptParam.`centerParameter(int i, Object[] ret)`
`protected P3`
ScriptParam.`centerParameterForModel(int i, int modelIndex, Object[] ret)`
`P3[]`
ScriptEval.`getObjectBoundingBox(String id)`
`protected P3`
ScriptEval.`getObjectCenter(String axisID, int index, int modelIndex)`
`P3`
ScriptParam.`getPoint3f(int i, boolean allowFractional, boolean throwE)`
Get an {x,y,z} value, possibly fractional, with option to throw an error.
`P3[]`
ScriptParam.`getPointArray(int i, int nPoints, boolean allowNull, boolean throwException)`
may return null values in some cases
`P3`
ScriptMathProcessor.`ptValue(SV x, BS bsRestrict)`
`static P3`
SV.`ptValue(SV x)`
`P3`
ScriptParam.`xypParameter(int index)`
Methods in org.jmol.script that return types with arguments of type P3
Modifier and Type
Method
Description
`Lst<P3>`
ScriptParam.`getPointOrCenterVector(T t)`
`Lst<P3>`
ScriptParam.`getPointVector(T t, int i)`
`static Lst<P3>`
ScriptParam.`transformPoints(Lst<P3> vPts, M4 m4, P3 center)`
Methods in org.jmol.script with parameters of type P3
Modifier and Type
Method
Description
`BS`
ScriptManager.`addHydrogensInline(BS bsAtoms, Lst<Atom> vConnections, P3[] pts, Map<String,Object> htParams)`
Add hydrogens to a model
`boolean`
ScriptMathProcessor.`addXPt(P3 pt)`
`static double`
ScriptParam.`getTransformMatrix4(Lst<P3> ptsA, Lst<P3> ptsB, M4 m, P3 centerA)`
Fills a 4x4 matrix with rotation-translation of mapped points A to B.
`static Lst<P3>`
ScriptParam.`transformPoints(Lst<P3> vPts, M4 m4, P3 center)`
Method parameters in org.jmol.script with type arguments of type P3
Modifier and Type
Method
Description
`P4`
ScriptParam.`getHklPlane(T3 pt, float offset, Lst<P3> pts)`
`static double`
ScriptParam.`getTransformMatrix4(Lst<P3> ptsA, Lst<P3> ptsB, M4 m, P3 centerA)`
Fills a 4x4 matrix with rotation-translation of mapped points A to B.
`P4`
ScriptParam.`hklParameter(int i, Lst<P3> pts, boolean allowOffset)`
`static Lst<P3>`
ScriptParam.`transformPoints(Lst<P3> vPts, M4 m4, P3 center)`

## Uses of P3 in org.jmol.scriptext

Methods in org.jmol.scriptext that return P3
Modifier and Type
Method
Description
`protected P3[]`
ScriptExt.`bsToArray(BS bs)`
`protected P3`
ScriptExt.`centerParameter(int i)`
`protected P3[]`
ScriptExt.`getAllPoints(int index, int nmin)`
`protected P3`
ScriptExt.`getPoint3f(int i, boolean allowFractional)`
Methods in org.jmol.scriptext with parameters of type P3
Modifier and Type
Method
Description
`float`
SmilesExt.`getSmilesCorrelation(BS bsA, BS bsB, String smiles, Lst<P3> ptsA, Lst<P3> ptsB, M4 m4, Lst<BS> vReturn, boolean asMap, int[][] mapSet, P3 center, boolean bestMap, int flags)`
The major interface to org.jmol.smiles, this method allows for a wide variety of correlation functionality.
Method parameters in org.jmol.scriptext with type arguments of type P3
Modifier and Type
Method
Description
`float`
SmilesExt.`getSmilesCorrelation(BS bsA, BS bsB, String smiles, Lst<P3> ptsA, Lst<P3> ptsB, M4 m4, Lst<BS> vReturn, boolean asMap, int[][] mapSet, P3 center, boolean bestMap, int flags)`
The major interface to org.jmol.smiles, this method allows for a wide variety of correlation functionality.

## Uses of P3 in org.jmol.shape

Fields in org.jmol.shape declared as P3
Modifier and Type
Field
Description
`final P3[]`
Axes.`axisPoints`
[x, y, z, -x, -y, -z] or [a, b, c, -a, -b, -c]
`P3`
Axes.`axisXY`
`P3`
Axes.`fixedOrigin`
`final P3`
Axes.`fixedOriginUC`
`P3`
Mesh.`lattice`
`final P3`
Axes.`originPoint`
`P3`
Mesh.`ptCenter`
Fields in org.jmol.shape with type parameters of type P3
Modifier and Type
Field
Description
`protected Lst<P3>`
MeshCollection.`displayWithinPoints`
Methods in org.jmol.shape that return P3
Modifier and Type
Method
Description
`P3`
Axes.`getAxisPoint(int i, boolean actual, P3 ptTemp)`
axisPoints are offset cartesian values.
`P3[]`
Mesh.`getBoundingBox()`
`P3[]`
Mesh.`getOffsetVertices(P4 thePlane)`
Methods in org.jmol.shape with parameters of type P3
Modifier and Type
Method
Description
`void`
Shape.`checkBoundsMinMax(P3 pointMin, P3 pointMax)`
`P3`
Axes.`getAxisPoint(int i, boolean actual, P3 ptTemp)`
axisPoints are offset cartesian values.
Method parameters in org.jmol.shape with type arguments of type P3
Modifier and Type
Method
Description
`static boolean`
Mesh.`checkWithin(T3 pti, Lst<P3> withinPoints, float withinDistance2, boolean isWithinNot)`
`void`
Mesh.`setShowWithin(Lst<P3> showWithinPoints, float showWithinDistance2, boolean isWithinNot)`

## Uses of P3 in org.jmol.shapespecial

Fields in org.jmol.shapespecial declared as P3
Modifier and Type
Field
Description
`P3`
Dipole.`center`
`P3`
Ellipsoid.`center`
`P3`
Polyhedron.`center`
`P3`
Dipole.`offsetPt`
`P3`
Dipole.`origin`
`P3[]`
Polyhedron.`vertices`
Methods in org.jmol.shapespecial that return P3
Modifier and Type
Method
Description
`static P3`
Draw.`randomPoint()`
Methods in org.jmol.shapespecial with parameters of type P3
Modifier and Type
Method
Description
`void`
Ellipsoid.`setCenter(P3 center)`
`void`
Dipole.`setOffsetPt(P3 pt)`

## Uses of P3 in org.jmol.shapesurface

Methods in org.jmol.shapesurface that return P3
Modifier and Type
Method
Description
`P3[]`
Isosurface.`calculateGeodesicSurface(BS bsSelected, float envelopeRadius)`
`P3[]`
IsosurfaceMesh.`getBoundingBox()`
Methods in org.jmol.shapesurface with parameters of type P3
Modifier and Type
Method
Description
`void`
IsosurfaceMesh.`setBoundingBox(P3[] pts)`

## Uses of P3 in org.jmol.smiles

Subclasses of P3 in org.jmol.smiles
Modifier and Type
Class
Description
`class`
`SmilesAtom`
This class represents an atom in a `SmilesMolecule`.
Fields in org.jmol.smiles declared as P3
Modifier and Type
Field
Description
`P3`
SmilesGenerator.`polySmilesCenter`
Methods in org.jmol.smiles that return P3
Modifier and Type
Method
Description
`P3`
SmilesAtom.`getXYZ()`
Methods in org.jmol.smiles with parameters of type P3
Modifier and Type
Method
Description
`String`
SmilesMatcher.`polyhedronToSmiles(Node center, int[][] faces, int atomCount, P3[] points, int flags, String details)`
Generate a topological SMILES string from a set of faces

## Uses of P3 in org.jmol.symmetry

Fields in org.jmol.symmetry declared as P3
Modifier and Type
Field
Description
`protected P3[]`
WyckoffFinder.`centerings`
Methods in org.jmol.symmetry that return P3
Modifier and Type
Method
Description
`P3[]`
Symmetry.`getCanonicalCopy(float scale, boolean withOffset)`
`P3[]`
UnitCell.`getCanonicalCopyTrimmed(P3 frac, float scale)`
`P3`
Symmetry.`getCartesianOffset()`
`P3`
UnitCell.`getCenter(int periodicity)`
Takes into account subperiodic groups using BoxInfo.unitCubePoints P3.new3(0, 0, 0), // 0 P3.new3(0, 0, 1), // 1 c P3.new3(0, 1, 0), // 2 b P3.new3(0, 1, 1), // 3 bc P3.new3(1, 0, 0), // 4 a P3.new3(1, 0, 1), // 5 ac P3.new3(1, 1, 0), // 6 ab P3.new3(1, 1, 1), // 7 }; abc
`P3`
Symmetry.`getFractionalOffset(boolean onlyIfFractional)`
determine if an offset cell is a unit translation, so that the space group can be continued
`P3`
Symmetry.`getFractionalOrigin()`
`P3`
SymmetryOperation.`getOpPoint()`
`P3`
SymmetryOperation.`getOpPoint2()`
`P3`
UnitCellIterator.`getPosition()`
`P3`
Symmetry.`getUnitCellCenter()`
`P3[]`
Symmetry.`getUnitCellVectors()`
`P3[]`
Symmetry.`getUnitCellVerticesNoOffset()`
`P3`
Symmetry.`toSupercell(P3 fpt)`
Methods in org.jmol.symmetry that return types with arguments of type P3
Modifier and Type
Method
Description
`Lst<P3>`
Symmetry.`generateCrystalClass(P3 pt00)`
`Lst<P3>`
Symmetry.`getLatticeCentering()`
`static Lst<P3>`
SymmetryOperation.`getLatticeCentering(SymmetryOperation[] ops)`
Methods in org.jmol.symmetry with parameters of type P3
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)`
`boolean`
Symmetry.`checkPeriodic(P3 pt, float packing, float packing2)`
`Symmetry`
SpaceGroupFinder.`checkSupercell(Viewer vwr, Symmetry uc, BS bsPoints, int abc, P3 scaling)`
Look for a supercell and adjust lattice down if necessary.
`Lst<P3>`
Symmetry.`generateCrystalClass(P3 pt00)`
`P3[]`
UnitCell.`getCanonicalCopyTrimmed(P3 frac, float scale)`
`float`
Symmetry.`getCellWeight(P3 pt)`
`int[]`
Symmetry.`getInvariantSymops(P3 pt, int[] v0)`
`int`
Symmetry.`getSiteMultiplicity(P3 pt)`
`Object`
Symmetry.`getSymmetryInfoAtom(ModelSet modelSet, int iatom, String xyz, int op, P3 translation, P3 pt, P3 pt2, String id, int type, float scaleFactor, int nth, int options, int[] opList)`
`M4`
Symmetry.`getTransform(P3 fracA, P3 fracB, boolean best)`
`M4`
SymmetryDesc.`getTransform(UnitCell uc, SymmetryOperation[] ops, P3 fracA, P3 fracB, boolean best)`
`Object`
Symmetry.`getWyckoffPosition(P3 p, String letter)`
`boolean`
Symmetry.`isWithinUnitCell(P3 pt, float x, float y, float z, float packing)`
`void`
Symmetry.`newSpaceGroupPoint(P3 pt, int i, M4 o, int transX, int transY, int transZ, P3 retPoint)`
`static void`
SymmetryOperation.`normalizeOperationToCentroid(int dim, M4 m, P3[] fracPts, int i0, int n)`
Adjust the translation for this operator so that it moves the center of mass of the full set of atoms into the cell.
`V3[]`
SymmetryOperation.`rotateAxes(V3[] vectors, UnitCell unitcell, P3 ptTemp, M3 mTemp)`
`void`
Symmetry.`setFinalOperations(int dim, String name, P3[] atoms, int iAtomFirst, int noSymmetryCount, boolean doNormalize, String filterSymop)`
`static void`
UnitCell.`setSymmetryMinMax(P3 c, P3 rmin, P3 rmax)`
`String`
Symmetry.`staticToRationalXYZ(P3 fPt, String sep)`
`P3`
Symmetry.`toSupercell(P3 fpt)`

## Uses of P3 in org.jmol.util

Subclasses of P3 in org.jmol.util
Modifier and Type
Class
Description
`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)
Fields in org.jmol.util declared as P3
Modifier and Type
Field
Description
`final P3`
BoxInfo.`bbCorner0`
`final P3`
BoxInfo.`bbCorner1`
`protected P3`
BZone.`center`
`P3`
MeshSurface.`offset`
`P3`
ContactPair.`pt`
`static final P3[]`
BoxInfo.`unitCubePoints`
Methods in org.jmol.util that return P3
Modifier and Type
Method
Description
`P3[]`
Vibration.`addTracePt(int n, Point3fi ptNew)`
`P3[]`
TempArray.`allocTempPoints(int size)`
`P3`
BoxInfo.`getBoundBoxCenter()`
`P3[]`
BoxInfo.`getBoundBoxPoints(boolean isAll)`
Return basic info on boundbox in the form of an array.
`static final P3[]`
BoxInfo.`getCanonicalCopy(P3[] boxPoints, float scale)`
Change points references to canonical form used in Triangulator, while also scaling.
`P3`
SimpleUnitCell.`getFractionalOrigin()`
Get the fractional origin for the UccageRenderer.
`static final P3[]`
BoxInfo.`getVerticesFromOABC(T3[] oabc)`
`P3`
Node.`getXYZ()`
`P3`
SimpleNode.`getXYZ()`
`P3[]`
Triangulator.`intersectLine(P3[] points, int nPoints, P3 ptA, V3 unitVector)`
`static final P3[]`
BoxInfo.`toOABC(P3[] bbVertices, T3 offset)`
Delivers [center a b c] for generation of unit cells from a boundbox
`P3`
SimpleUnitCell.`toSupercell(P3 fpt)`
convenience return only after changing fpt
Methods in org.jmol.util that return types with arguments of type P3
Modifier and Type
Method
Description
`protected static Lst<P3>`
BZone.`within(float radius, P3 center, Lst<P3> pts)`
Methods in org.jmol.util with parameters of type P3
Modifier and Type
Method
Description
`static void`
BoxInfo.`addPointXYZ(float x, float y, float z, P3 xyzMin, P3 xyzMax, float margin)`
`void`
BZone.`createBZ(Viewer vwr, int n, Object[] array, boolean isK, String id, float scale, float foffset, P3 offset)`
Create a Brillouin zone.
`void`
BZone.`drawHKL(Viewer vwr, String id, P4 plane, P3[] pts)`
`void`
GData.`drawQuadrilateralBits(JmolRendererInterface jmolRenderer, short colix, P3 screenA, P3 screenB, P3 screenC, P3 screenD)`
`static String`
Escape.`drawQuat(Quat q, String prefix, String id, P3 ptCenter, float scale)`
`void`
GData.`drawTriangleBits(JmolRendererInterface renderer, P3 screenA, short colixA, P3 screenB, short colixB, P3 screenC, short colixC, int check)`
`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
`void`
TempArray.`freeTempPoints(P3[] tempPoints)`
`static P4[]`
BoxInfo.`getBoxFacesFromOABC(P3[] oabc)`
`static final P3[]`
BoxInfo.`getCanonicalCopy(P3[] boxPoints, float scale)`
Change points references to canonical form used in Triangulator, while also scaling.
`static int`
SimpleUnitCell.`getCellRange(T3 fset, P3[] cellRange)`
`void`
MeshSlicer.`getIntersection(float distance, P4 plane, P3[] ptCenters, Lst<P3[]> vData, float[] fData, BS bsSource, MeshSurface meshSurface, boolean andCap, boolean doClean, int tokType, boolean isGhost)`
`static void`
SimpleUnitCell.`ijkToPoint3f(int nnn, P3 cell, int offset, int kcode)`
Expanded cell notation: 111 - 1000 --> center 5,5,5; range 0 to 9 or -5 to +4 1000000 - 1999999 --> center 50,50,50; range 0 to 99 or -50 to +49 1000000000 - 1999999999 --> center 500, 500, 500; range 0 to 999 or -500 to +499 for example, a 3x3x3 block of 27 cells: {444 666 1} or {1494949 1515151 1} or {1499499499 1501501501 1}
`P3[]`
Triangulator.`intersectLine(P3[] points, int nPoints, P3 ptA, V3 unitVector)`
`boolean`
BoxInfo.`isWithin(P3 pt)`
`static void`
BoxInfo.`scaleBox(P3[] pts, float scale)`
`void`
MeshSurface.`setBoundingBox(P3[] boundBoxPoints)`
`void`
MeshSurface.`setBox(P3 xyzMin, P3 xyzMax)`
`ModulationSet`
ModulationSet.`setMod(String id, P3 r00, P3 r0, int d, Lst<Modulation> mods, M3 gammaE, Matrix[] factors, SymmetryInterface symmetry, int nOps, int iop, Vibration v, boolean isCommensurate)`
A collection of modulations for a specific atom.
`protected void`
MeshSlicer.`slabBrillouin(P3[] unitCellPoints)`
"slabs" an isosurface into the first Brillouin zone moving points as necessary.
`protected void`
MeshSurface.`slabBrillouin(P3[] unitCellVectors)`
`static final P3[]`
BoxInfo.`toOABC(P3[] bbVertices, T3 offset)`
Delivers [center a b c] for generation of unit cells from a boundbox
`P3`
SimpleUnitCell.`toSupercell(P3 fpt)`
convenience return only after changing fpt
`int[][]`
MeshCapper.`triangulateFaces(int[][] faces, P3[] vertices, int[][] faceTriangles)`
generic entry for a set of faces
`int[][]`
MeshCapper.`triangulatePolygon(P3[] points, int nPoints)`
generic entry for a polygon
`void`
SimpleUnitCell.`twelfthify(P3 pt)`
`protected static Lst<P3>`
BZone.`within(float radius, P3 center, Lst<P3> pts)`
Method parameters in org.jmol.util with type arguments of type P3
Modifier and Type
Method
Description
`protected static Lst<P3>`
BZone.`within(float radius, P3 center, Lst<P3> pts)`

## Uses of P3 in org.jmol.viewer

Fields in org.jmol.viewer declared as P3
Modifier and Type
Field
Description
`final P3`
TransformManager.`camera`
`final P3`
TransformManager.`cameraSetting`
`final P3`
TransformManager.`fixedRotationCenter`
`final P3`
TransformManager.`fixedRotationOffset`
`final P3`
TransformManager.`fixedTranslation`
`protected final P3`
TransformManager.`fScrPtSafe`
`final P3`
TransformManager.`navigationCenter`
`final P3`
TransformManager.`navigationOffset`
`final P3`
TransformManager.`navigationShiftXY`
`protected final P3`
TransformManager.`perspectiveOffset`
`protected final P3`
TransformManager.`perspectiveShiftXY`
`protected final P3`
TransformManager.`ptTest1`
`protected final P3`
TransformManager.`ptTest2`
`protected final P3`
TransformManager.`ptTest3`
`protected final P3`
TransformManager.`untransformedPoint`
`P3`
TransformManager.`zSlabPoint`
Methods in org.jmol.viewer that return P3
Modifier and Type
Method
Description
`P3[]`
Viewer.`allocTempPoints(int size)`
`P3[]`
Viewer.`calculateSurface(BS bsSelected, float envelopeRadius)`
`P3[]`
Viewer.`getAdditionalHydrogens(BS bsAtoms, Lst<Atom> vConnections, int flags)`
`P3`
Viewer.`getBoundBoxCenter()`
`P3[]`
TransformManager.`getCameraFactors()`
This method returns data needed by the VRML, X3D, and IDTF/U3D exporters.
`P3[][]`
Viewer.`getCenterAndPoints(Lst<Object[]> atomSets, boolean addCenter)`
`P3`
Viewer.`getColorPointForPropertyValue(float val)`
`P3`
Viewer.`getDefaultLattice()`
`P3`
TransformManager.`getNavigationOffset()`
`P3`
Viewer.`getUnitCellCenter()`
Methods in org.jmol.viewer with parameters of type P3
Modifier and Type
Method
Description
`BS`
Viewer.`addHydrogensInline(BS bsAtoms, Lst<Atom> vConnections, P3[] pts, Map<String,Object> htParams)`
`void`
Viewer.`addUnitCellOffset(P3 pt)`
`void`
TransformManager.`centerAt(int x, int y, P3 pt)`
`void`
Viewer.`freeTempPoints(P3[] tempPoints)`
`BS`
Viewer.`getAtomsNearPt(float distance, P3 coord, BS bs)`
`Object`
Viewer.`getOrientation(int type, String name, BS bs, P3[] points)`
`protected void`
TransformManager.`getScreenTemp(T3 ptXYZ, P3 fScrPt)`
`protected void`
TransformManager4D.`getScreenTemp(T3 ptXYZ, P3 fScrPt)`
`Object`
Viewer.`getSymmetryInfo(int iatom, String xyz, int iOp, P3 translation, P3 pt1, P3 pt2, int type, String desc, float scaleFactor, int nth, int options, int[] opList)`
A general method for retrieving symmetry information with full capability of the symop() scripting function.
`void`
Viewer.`invertAtomCoord(P3 pt, P4 plane, BS bs, int ringAtomIndex, boolean isClick)`
`void`
Viewer.`invertSelected(P3 pt, P4 plane, int iAtom, BS bsAtoms)`
`void`
Viewer.`moveAtoms(M4 m4, M3 mNew, M3 rotation, V3 translation, P3 center, boolean isInternal, BS bsAtoms, boolean translationOnly, boolean useModelKit)`
`int`
Viewer.`moveAtomWithHydrogens(int atomIndex, int deltaX, int deltaY, int deltaZ, P3 ptNew, BS bsAtoms)`
`void`
TransformManager.`moveRotationCenter(P3 center, boolean toXY)`
`void`
Viewer.`moveTo(JmolScriptEvaluator eval, float floatSecondsTotal, P3 center, V3 rotAxis, float degrees, M3 rotationMatrix, float zoom, float xTrans, float yTrans, float rotationRadius, P3 navCenter, float xNav, float yNav, float navDepth, float cameraDepth, float cameraX, float cameraY)`
`void`
Viewer.`navigatePt(P3 center)`
`void`
ActionManager.`processMultitouchEvent(int groupID, int eventType, int touchID, int iData, P3 pt, long time)`
Specific to ActionManagerMT -- for processing SparshUI gestures
`boolean`
Viewer.`rotateAboutPointsInternal(JmolScriptEvaluator eval, P3 point1, P3 point2, float degreesPerSecond, float endDegrees, boolean isSpin, BS bsSelected, V3 translation, Lst<P3> finalPoints, float[] dihedralList, M3 vectorMatrix, M4 m4, boolean useModelKit, P3[][] centerAndPoints)`
`boolean`
Viewer.`rotateAxisAngleAtCenter(JmolScriptEvaluator eval, P3 rotCenter, V3 rotAxis, float degreesPerSecond, float endDegrees, boolean isSpin, BS bsSelected)`
`void`
TransformManager.`setAll(P3 center, M3 m, P3 navCenter, float zoom, float xTrans, float yTrans, float rotationRadius, float pixelScale, float navDepth, float xNav, float yNav, float cameraDepth, float cameraX, float cameraY)`
`void`
TransformManager.`setCenterAt(int relativeTo, P3 pt)`
`void`
Viewer.`setDefaultLattice(P3 p)`
`void`
Viewer.`setModulation(BS bs, boolean isOn, P3 t1, boolean isQ)`
`void`
TransformManager.`setNavigatePt(P3 pt)`
scripted entry point for navigation
`void`
Viewer.`setNewRotationCenter(P3 center)`
`void`
Viewer.`toUnitCell(P3 pt, P3 offset)`
Returns the relative to origin without regard to offset created using the UNITCELL command.
`void`
TransformManager.`transformPt3f(T3 ptXYZ, P3 screen)`
RENDERERS ONLY
`void`
TransformManager.`transformPt3fSafe(T3 ptXYZ, P3 screen)`
`P3i`
TransformManager.`transformPtVib(P3 ptXYZ, Vibration v)`
RENDERERS ONLY
`P3i`
TransformManager.`transformPtVibSafe(P3 ptXYZ, Vibration v)`
Method parameters in org.jmol.viewer with type arguments of type P3
Modifier and Type
Method
Description
`boolean`
Viewer.`rotateAboutPointsInternal(JmolScriptEvaluator eval, P3 point1, P3 point2, float degreesPerSecond, float endDegrees, boolean isSpin, BS bsSelected, V3 translation, Lst<P3> finalPoints, float[] dihedralList, M3 vectorMatrix, M4 m4, boolean useModelKit, P3[][] centerAndPoints)`

## Uses of P3 in org.openscience.jvxl.simplewriter

Methods in org.openscience.jvxl.simplewriter with parameters of type P3
Modifier and Type
Method
Description
`protected int`
SimpleMarchingCubes.`newVertex(P3 pointA, V3 edgeVector, float f)`
Method parameters in org.openscience.jvxl.simplewriter with type arguments of type P3
Modifier and Type
Method
Description
`static String`
ASimpleJvxlWriter.`jvxlGetData(VoxelDataCreator vdc, Parameters params, VolumeData volumeData, String[] title, Lst<P3> surfacePointsReturn, float[] areaVolumeReturn)`
Constructor parameters in org.openscience.jvxl.simplewriter with type arguments of type P3
Modifier
Constructor
Description
``
`SimpleMarchingCubes(VoxelDataCreator vdc, VolumeData volumeData, Parameters params, JvxlData jvxlData, Lst<P3> surfacePointsReturn, float[] areaVolumeReturn)`