# Class TransformManager

java.lang.Object
org.jmol.viewer.TransformManager

Direct Known Subclasses:
  `TransformManager4D`

public class TransformManager extends Object

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final A4`
`aaTest1`
`protected boolean`
`antialias`
`protected float`
`aperatureAngle`
`BS`
`bsFrameOffsets`
`final P3`
`camera`
`protected float`
`cameraDepth`
`protected float`
`cameraDepthSetting`
`float`
`cameraDistance`
`protected float`
`cameraDistanceFromCenter`
`protected float`
`cameraScaleFactor`
`final P3`
`cameraSetting`
`static final int`
`DEFAULT_STEREO_DEGREES`
`static final float`
`DEFAULT_VISUAL_RANGE`
`int`
`defaultMode`
`static final double`
`degreesPerRadian`
`int`
`depthValue`
`protected boolean`
`doTransform4D`
`final A4`
`fixedRotationAxis`
`final P3`
`fixedRotationCenter`
`final P3`
`fixedRotationOffset`
`final P3`
`fixedTranslation`
`protected final P3`
`fScrPtSafe`
`protected boolean`
`haveNotifiedNaN`
`int`
`height`
`final A4`
`internalRotationAxis`
`boolean`
`internalSlab`
`protected V3`
`internalTranslation`
`boolean`
`isSpinFixed`
`boolean`
`isSpinInternal`
`final M3`
`matrixRotate`
`protected final M3`
`matrixStereo`
`protected final M4`
`matrixTemp`
`protected final M3`
`matrixTemp3`
`protected final M3`
`matrixTest`
`final M4`
`matrixTransform`
`final M4`
`matrixTransformInv`
`static final int`
`MAXIMUM_ZOOM_PERCENTAGE`
`int`
`mode`
`static final int`
`MODE_NAVIGATION`
`static final int`
`MODE_PERSPECTIVE_PYMOL`
`static final int`
`MODE_STANDARD`
`float`
`modelCenterOffset`
`float`
`modelRadius`
`float`
`modelRadiusPixels`
`JmolThread`
`movetoThread`
`static final int`
`NAV_MODE_IGNORE`
//////////////////////// old TransfomManager11 ////////////////////
`static final int`
`NAV_MODE_NEWXY`
`static final int`
`NAV_MODE_NEWXYZ`
`static final int`
`NAV_MODE_NEWZ`
`static final int`
`NAV_MODE_NONE`
`static final int`
`NAV_MODE_RESET`
`static final int`
`NAV_MODE_ZOOMED`
`float`
`navFps`
`boolean`
`navigating`
`final P3`
`navigationCenter`
`float`
`navigationDepthPercent`
`final P3`
`navigationOffset`
`final P3`
`navigationShiftXY`
`float`
`navigationSlabOffset`
`int`
`navMode`
`boolean`
`navOn`
`float`
`navX`
`float`
`navY`
`float`
`navZ`
`boolean`
`perspectiveDepth`
`protected int`
`perspectiveModel`
`protected final P3`
`perspectiveOffset`
`protected final P3`
`perspectiveShiftXY`
`float`
`previousX`
`float`
`previousY`
`protected float`
`prevZoomSetting`
`protected final P3`
`ptTest1`
`protected final P3`
`ptTest2`
`protected final P3`
`ptTest3`
`float`
`referencePlaneOffset`
`protected boolean`
`scale3D`
`float`
`scaleDefaultPixelsPerAngstrom`
`int`
`screenPixelCount`
`boolean`
`slabEnabled`
`int`
`slabValue`
`float`
`spinFps`
`boolean`
`spinOn`
`JmolThread`
`spinThread`
`float`
`spinX`
`float`
`spinY`
`float`
`spinZ`
`int`
`splitFrameCurrentlyRendering`
right-hand split frame has fewer capabilities than right-hand
`protected final P3`
`untransformedPoint`
`boolean`
`vectorSpinOnly`
`protected final V3`
`vectorTemp`
`boolean`
`vibrationOn`
`int`
`vibrationPeriodMs`
`JmolThread`
`vibrationThread`
`float`
`visualRangeAngstroms`
`protected Viewer`
`vwr`
`int`
`width`
`boolean`
`windowCentered`
//////// rotation center ////////////
`int`
`zDepthPercentSetting`
`int`
`zDepthValue`
`float`
`zmPct`
zoom percent zmPct is the current displayed zoom value, AFTER rendering; may not be the same as zmPctSet, particularly if zoom is not enabled
`boolean`
`zoomEnabled`
`float`
`zoomFactor`
`boolean`
`zShadeEnabled`
`int`
`zSlabPercentSetting`
`P3`
`zSlabPoint`
`int`
`zSlabValue`

## Constructor Summary

Constructors
Constructor
Description
`TransformManager()`

## Method Summary

Modifier and Type
Method
Description
`void`
`calcCameraFactors()`
sets all camera and scale factors needed by the specific perspective model instantiated
`protected void`
`calcNavigationPoint()`
All the magic happens here.
`void`
`calcSlabAndDepthValues()`
sets slab and depth, possibly using visual range considerations for setting the slab-clipping plane.
`void`
`calcTransformMatrix()`
`void`
`centerAt(int x, int y, P3 pt)`
`float`
`defaultScaleToScreen(float radius)`
`void`
`depthToPercent(int percentDepth)`
`void`
`finalizeTransformParameters()`
`float`
`getCameraDepth()`
`P3[]`
`getCameraFactors()`
This method returns data needed by the VRML, X3D, and IDTF/U3D exporters.
`String`
`getMoveToText(float timespan, boolean addComments)`
`P3`
`getNavigationOffset()`
`float`
`getNavigationOffsetPercent(char XorY)`
`protected String`
`getNavigationState()`
`protected String`
`getNavigationText(boolean addComments)`
`float`
`getNavPtHeight()`
`boolean`
`getPerspectiveDepth()`
`float`
`getPerspectiveFactor(float z)`
calculate the perspective factor based on z
`void`
`getRotation(M3 m)`
`Quat`
`getRotationQ()`
`protected void`
`getScreenTemp(T3 ptXYZ, P3 fScrPt)`
`int`
`getSlabPercentSetting()`
`String`
`getTranslationScript()`
`float`
`getTranslationXPercent()`
`float`
`getTranslationYPercent()`
`T3`
`getVibrationPoint(Vibration v, T3 pt, float scale)`
return
`float`
`getZoomSetting()`
`void`
`homePosition(boolean resetSpin)`
`boolean`
`isInPosition(V3 axis, float degrees)`
`boolean`
`isNavigating()`
`boolean`
`isWindowCentered()`
`void`
`moveRotationCenter(P3 center, boolean toXY)`
`boolean`
`moveToPyMOL(JmolScriptEvaluator eval, float floatSecondsTotal, float[] pymolView)`
`void`
`navigateAxis(V3 rotAxis, float degrees)`
scripted entry point for navigation
`void`
`navigateList(JmolScriptEvaluator eval, Lst<Object[]> list)`
`void`
`navTranslatePercentOrTo(float seconds, float x, float y)`
seconds invalid input: '<' 0 means "to (x,y)"; >= 0 mean "to (x%, y%)"
`int`
`percentToPixels(char xyz, float percent)`
`protected void`
`resetNavigationPoint(boolean doResetSlab)`
something has arisen that requires resetting of the navigation point.
`void`
`resetRotation()`
`protected void`
`rotate3DBall(float xDeg, float yDeg, BS bsAtoms)`
`void`
`rotateAxisAngle(V3 rotAxis, float radians)`
`void`
`rotateAxisAngleRadiansFixed(float angleRadians, BS bsAtoms)`
`void`
`rotateAxisAngleRadiansInternal(float radians, BS bsAtoms, M4 m4, boolean useModelKit)`
`void`
`rotatePoint(T3 pt, T3 ptRot)`
`void`
`rotateXRadians(float angleRadians, BS bsAtoms)`
`protected void`
`rotateXYBy(float degX, float degY, BS bsAtoms)`
`void`
`rotateYRadians(float angleRadians, BS bsAtoms)`
`void`
`rotateZRadians(float angleRadians)`
`float`
`scaleToPerspective(int z, float sizeAngstroms)`
`float`
`scaleToScreen(int z, int milliAngstroms)`
`void`
`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`
`setCamera(float x, float y)`
`void`
`setCameraDepthPercent(float percent, boolean resetSlab)`
either as a percent -300, or as a float 3.0 note this percent is of zoom=100 size of model
`void`
`setCenterAt(int relativeTo, P3 pt)`
`protected void`
`setNavFps(int navFps)`
`void`
`setNavigatePt(P3 pt)`
scripted entry point for navigation
`void`
`setNavigationDepthPercent(float percent)`
sets the position of the navigation offset relative to the model (50% center; 0% rear, 100% front; can be invalid input: '<'0 or >100)
`void`
`setNavigationOffsetRelative()`
`void`
`setNavOn(boolean navOn)`
`void`
`setNavXYZ(float x, float y, float z)`
`void`
`setRotation(M3 m)`
`float`
`setRotationRadius(float angstroms, boolean doAll)`
`void`
`setSlabDepthInternal(boolean isDepth)`
set internal slab or depth from screen-based slab or depth
`void`
`setSlabRange(float value)`
`void`
`setSpinOff()`
`void`
`setSpinOn()`
`void`
`setVibrationPeriod(float period)`
sets the period of vibration -- period > 0: sets the period and turns -- period invalid input: '<' 0: sets the period but does not turn vibration on -- period = 0: sets the period to zero and turns vibration off -- period Double.NaN: uses current setting (frame change)
`void`
`setVibrationT(float t)`
`void`
`setZoomHeight(boolean zoomHeight, boolean zoomLarge)`
`void`
`slabInternal(P4 plane, boolean isDepth)`
`void`
`slabReset()`
`void`
`slabToPercent(int percentSlab)`
`void`
`stopMotion()`
`P3i`
`transformPt(T3 ptXYZ)`
RENDERERS ONLY CAUTION! returns a POINTER TO A TEMPORARY VARIABLE
`P3i`
`transformPt2D(T3 ptXyp)`
RENDERERS ONLY
`void`
`transformPt3f(T3 ptXYZ, P3 screen)`
RENDERERS ONLY
`void`
`transformPt3fSafe(T3 ptXYZ, P3 screen)`
`void`
`transformPtNoClip(T3 ptXYZ, T3 pointScreen)`
RENDERERS ONLY
`P3i`
`transformPtSafe(T3 ptXYZ)`
`void`
`transformPtScr(T3 ptXYZ, P3i pointScreen)`
RENDERERS ONLY
`void`
`transformPtScrSafe(T3 ptXYZ, P3i pointScreen)`
`void`
`transformPtScrT3(T3 ptXYZ, T3 pointScreen)`
RENDERERS ONLY
`P3i`
`transformPtVib(P3 ptXYZ, Vibration v)`
RENDERERS ONLY
`P3i`
`transformPtVibSafe(P3 ptXYZ, Vibration v)`
`void`
`translateToPercent(char type, float percent)`
`float`
`unscaleToScreen(float z, float screenDistance)`
`void`
`unTransformPoint(T3 screenPt, T3 coordPt)`
`boolean`
`xyzIsSlabbedInternal(T3 ptRef)`
`protected void`
`zoomBy(int pixels)`
standard response to user mouse vertical shift-drag
`void`
`zoomToPercent(float percentZoom)`
`int`
`zValueFromPercent(int zPercent)`

### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### vwr

protected Viewer vwr

### DEFAULT_VISUAL_RANGE

public static final float DEFAULT_VISUAL_RANGE

See Also:
  - Constant Field Values

### DEFAULT_STEREO_DEGREES

public static final int DEFAULT_STEREO_DEGREES

See Also:
  - Constant Field Values

### MODE_STANDARD

public static final int MODE_STANDARD

See Also:
  - Constant Field Values

### MODE_NAVIGATION

public static final int MODE_NAVIGATION

See Also:
  - Constant Field Values

### MODE_PERSPECTIVE_PYMOL

public static final int MODE_PERSPECTIVE_PYMOL

See Also:
  - Constant Field Values

### movetoThread

public JmolThread movetoThread

### vibrationThread

public JmolThread vibrationThread

### spinThread

public JmolThread spinThread

### degreesPerRadian

public static final double degreesPerRadian

See Also:
  - Constant Field Values

### perspectiveModel

protected int perspectiveModel

### cameraScaleFactor

protected float cameraScaleFactor

### referencePlaneOffset

public float referencePlaneOffset

### aperatureAngle

protected float aperatureAngle

### cameraDistanceFromCenter

protected float cameraDistanceFromCenter

### modelCenterOffset

public float modelCenterOffset

### modelRadius

public float modelRadius

### modelRadiusPixels

public float modelRadiusPixels

### navigationCenter

public final P3 navigationCenter

### navigationOffset

public final P3 navigationOffset

### navigationShiftXY

public final P3 navigationShiftXY

### navigationDepthPercent

public float navigationDepthPercent

### matrixTemp

protected final M4 matrixTemp

### vectorTemp

protected final V3 vectorTemp

### splitFrameCurrentlyRendering

public int splitFrameCurrentlyRendering
right-hand split frame has fewer capabilities than right-hand

### haveNotifiedNaN

protected boolean haveNotifiedNaN

### spinX

public float spinX

### spinY

public float spinY

### spinZ

public float spinZ

### spinFps

public float spinFps

### navX

public float navX

### navY

public float navY

### navZ

public float navZ

### navFps

public float navFps

### isSpinInternal

public boolean isSpinInternal

### isSpinFixed

public boolean isSpinFixed

### doTransform4D

protected boolean doTransform4D

### fixedRotationOffset

public final P3 fixedRotationOffset

### fixedRotationCenter

public final P3 fixedRotationCenter

### perspectiveOffset

protected final P3 perspectiveOffset

### perspectiveShiftXY

protected final P3 perspectiveShiftXY

### fixedRotationAxis

public final A4 fixedRotationAxis

### internalRotationAxis

public final A4 internalRotationAxis

### internalTranslation

protected V3 internalTranslation

### matrixRotate

public final M3 matrixRotate

### matrixTemp3

protected final M3 matrixTemp3

### MAXIMUM_ZOOM_PERCENTAGE

public static final int MAXIMUM_ZOOM_PERCENTAGE

See Also:
  - Constant Field Values

### fixedTranslation

public final P3 fixedTranslation

### camera

public final P3 camera

### cameraSetting

public final P3 cameraSetting

### prevZoomSetting

protected float prevZoomSetting

### previousX

public float previousX

### previousY

public float previousY

### zoomEnabled

public boolean zoomEnabled

### zmPct

public float zmPct
zoom percent zmPct is the current displayed zoom value, AFTER rendering; may not be the same as zmPctSet, particularly if zoom is not enabled

### slabEnabled

public boolean slabEnabled

### zShadeEnabled

public boolean zShadeEnabled

### internalSlab

public boolean internalSlab

### slabValue

public int slabValue

### depthValue

public int depthValue

### zSlabPercentSetting

public int zSlabPercentSetting

### zDepthPercentSetting

public int zDepthPercentSetting

### zSlabPoint

public P3 zSlabPoint

### zSlabValue

public int zSlabValue

### zDepthValue

public int zDepthValue

### perspectiveDepth

public boolean perspectiveDepth

### scale3D

protected boolean scale3D

### cameraDepth

protected float cameraDepth

### cameraDepthSetting

protected float cameraDepthSetting

### visualRangeAngstroms

public float visualRangeAngstroms

### cameraDistance

public float cameraDistance

### width

public int width

### height

public int height

### screenPixelCount

public int screenPixelCount

### scaleDefaultPixelsPerAngstrom

public float scaleDefaultPixelsPerAngstrom

### antialias

protected boolean antialias

### matrixTransform

public final M4 matrixTransform

### matrixTransformInv

public final M4 matrixTransformInv

### fScrPtSafe

protected final P3 fScrPtSafe

### navigating

public boolean navigating

### mode

public int mode

### defaultMode

public int defaultMode

### untransformedPoint

protected final P3 untransformedPoint

### ptTest1

protected final P3 ptTest1

### ptTest2

protected final P3 ptTest2

### ptTest3

protected final P3 ptTest3

### aaTest1

protected final A4 aaTest1

### matrixTest

protected final M3 matrixTest

### spinOn

public boolean spinOn

### vectorSpinOnly

public boolean vectorSpinOnly

### navOn

public boolean navOn

### vibrationOn

public boolean vibrationOn

### vibrationPeriodMs

public int vibrationPeriodMs

### matrixStereo

protected final M3 matrixStereo

### windowCentered

public boolean windowCentered
//////// rotation center ////////////

### bsFrameOffsets

public BS bsFrameOffsets

### NAV_MODE_IGNORE

public static final int NAV_MODE_IGNORE
//////////////////////// old TransfomManager11 ////////////////////

See Also:
  - Constant Field Values

### NAV_MODE_ZOOMED

public static final int NAV_MODE_ZOOMED

See Also:
  - Constant Field Values

### NAV_MODE_NONE

public static final int NAV_MODE_NONE

See Also:
  - Constant Field Values

### NAV_MODE_RESET

public static final int NAV_MODE_RESET

See Also:
  - Constant Field Values

### NAV_MODE_NEWXY

public static final int NAV_MODE_NEWXY

See Also:
  - Constant Field Values

### NAV_MODE_NEWXYZ

public static final int NAV_MODE_NEWXYZ

See Also:
  - Constant Field Values

### NAV_MODE_NEWZ

public static final int NAV_MODE_NEWZ

See Also:
  - Constant Field Values

### navMode

public int navMode

### zoomFactor

public float zoomFactor

### navigationSlabOffset

public float navigationSlabOffset

## Constructor Details

### TransformManager

public TransformManager()

## Method Details

### homePosition

public void homePosition(boolean resetSpin)

### setRotation

public void setRotation(M3 m)

### resetRotation

public void resetRotation()

### rotateXYBy

protected void rotateXYBy(float degX, float degY, BS bsAtoms)

### rotate3DBall

protected void rotate3DBall(float xDeg, float yDeg, BS bsAtoms)

### rotateXRadians

public void rotateXRadians(float angleRadians, BS bsAtoms)

### rotateYRadians

public void rotateYRadians(float angleRadians, BS bsAtoms)

### rotateZRadians

public void rotateZRadians(float angleRadians)

### rotateAxisAngle

public void rotateAxisAngle(V3 rotAxis, float radians)

### rotateAxisAngleRadiansFixed

public void rotateAxisAngleRadiansFixed(float angleRadians, BS bsAtoms)

### rotateAxisAngleRadiansInternal

public void rotateAxisAngleRadiansInternal(float radians, BS bsAtoms, M4 m4, boolean useModelKit)

### centerAt

public void centerAt(int x, int y, P3 pt)

### percentToPixels

public int percentToPixels(char xyz, float percent)

### setCamera

public void setCamera(float x, float y)

### translateToPercent

public void translateToPercent(char type, float percent)

### getTranslationXPercent

public float getTranslationXPercent()

### getTranslationYPercent

public float getTranslationYPercent()

### getTranslationScript

public String getTranslationScript()

### getRotationQ

public Quat getRotationQ()

### getRotation

public void getRotation(M3 m)

### setZoomHeight

public void setZoomHeight(boolean zoomHeight, boolean zoomLarge)

### zoomBy

protected void zoomBy(int pixels)
standard response to user mouse vertical shift-drag

Parameters:
  `pixels` -

### zoomToPercent

public void zoomToPercent(float percentZoom)

### setSlabRange

public void setSlabRange(float value)

### slabReset

public void slabReset()

### getSlabPercentSetting

public int getSlabPercentSetting()

### slabToPercent

public void slabToPercent(int percentSlab)

### depthToPercent

public void depthToPercent(int percentDepth)

### slabInternal

public void slabInternal(P4 plane, boolean isDepth)

### setSlabDepthInternal

public void setSlabDepthInternal(boolean isDepth)
set internal slab or depth from screen-based slab or depth

Parameters:
  `isDepth` -

### getCameraFactors

public P3[] getCameraFactors()
This method returns data needed by the VRML, X3D, and IDTF/U3D exporters. It also should serve as a valuable resource for anyone adapting Jmol and wanting to know how the Jmol 11+ camera business works.

Returns:
  a set of camera data

### getPerspectiveDepth

public boolean getPerspectiveDepth()

### setCameraDepthPercent

public void setCameraDepthPercent(float percent, boolean resetSlab)
either as a percent -300, or as a float 3.0 note this percent is of zoom=100 size of model

Parameters:
  `percent` -
  `resetSlab` -

### getCameraDepth

public float getCameraDepth()

### defaultScaleToScreen

public float defaultScaleToScreen(float radius)

### scaleToScreen

public float scaleToScreen(int z, int milliAngstroms)

### unscaleToScreen

public float unscaleToScreen(float z, float screenDistance)

### scaleToPerspective

public float scaleToPerspective(int z, float sizeAngstroms)

### isNavigating

public boolean isNavigating()

### finalizeTransformParameters

public void finalizeTransformParameters()

### getZoomSetting

public float getZoomSetting()

### calcSlabAndDepthValues

public void calcSlabAndDepthValues()
sets slab and depth, possibly using visual range considerations for setting the slab-clipping plane. (slab on; slab 0) superceded in navigation mode

### zValueFromPercent

public int zValueFromPercent(int zPercent)

### calcTransformMatrix

public void calcTransformMatrix()

### rotatePoint

public void rotatePoint(T3 pt, T3 ptRot)

### getScreenTemp

protected void getScreenTemp(T3 ptXYZ, P3 fScrPt)

### transformPtScr

public void transformPtScr(T3 ptXYZ, P3i pointScreen)
RENDERERS ONLY

Parameters:
  `ptXYZ` -
  `pointScreen` -

### transformPtScrSafe

public void transformPtScrSafe(T3 ptXYZ, P3i pointScreen)

### transformPtScrT3

public void transformPtScrT3(T3 ptXYZ, T3 pointScreen)
RENDERERS ONLY

Parameters:
  `ptXYZ` -
  `pointScreen` -

### transformPt3f

public void transformPt3f(T3 ptXYZ, P3 screen)
RENDERERS ONLY

Parameters:
  `ptXYZ` -
  `screen` -

### transformPt3fSafe

public void transformPt3fSafe(T3 ptXYZ, P3 screen)

### transformPtNoClip

public void transformPtNoClip(T3 ptXYZ, T3 pointScreen)
RENDERERS ONLY

Parameters:
  `ptXYZ` -
  `pointScreen` -

### transformPt

public P3i transformPt(T3 ptXYZ)
RENDERERS ONLY CAUTION! returns a POINTER TO A TEMPORARY VARIABLE

Parameters:
  `ptXYZ` -
Returns:
  POINTER TO point3iScreenTemp

### transformPtSafe

public P3i transformPtSafe(T3 ptXYZ)

### transformPtVib

public P3i transformPtVib(P3 ptXYZ, Vibration v)
RENDERERS ONLY

Parameters:
  `ptXYZ` -
  `v` -
Returns:
  POINTER TO TEMPORARY VARIABLE (caution!) point3iScreenTemp

### transformPtVibSafe

public P3i transformPtVibSafe(P3 ptXYZ, Vibration v)

### getVibrationPoint

public T3 getVibrationPoint(Vibration v, T3 pt, float scale)
return

Parameters:
  `v` -
  `pt` - temporary value; also returned
  `scale` -
Returns:
  pt

### transformPt2D

public P3i transformPt2D(T3 ptXyp)
RENDERERS ONLY

Parameters:
  `ptXyp` -
Returns:
  P3i

### xyzIsSlabbedInternal

public boolean xyzIsSlabbedInternal(T3 ptRef)

### isInPosition

public boolean isInPosition(V3 axis, float degrees)

### moveToPyMOL

public boolean moveToPyMOL(JmolScriptEvaluator eval, float floatSecondsTotal, float[] pymolView)

### setAll

public void 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)

### stopMotion

public void stopMotion()

### getMoveToText

public String getMoveToText(float timespan, boolean addComments)

### setNavXYZ

public void setNavXYZ(float x, float y, float z)

### setSpinOn

public void setSpinOn()

### setSpinOff

public void setSpinOff()

### setNavOn

public void setNavOn(boolean navOn)

### setVibrationPeriod

public void setVibrationPeriod(float period)
sets the period of vibration -- period > 0: sets the period and turns -- period invalid input: '<' 0: sets the period but does not turn vibration on -- period = 0: sets the period to zero and turns vibration off -- period Double.NaN: uses current setting (frame change)

Parameters:
  `period` -

### setVibrationT

public void setVibrationT(float t)

### isWindowCentered

public boolean isWindowCentered()

### setRotationRadius

public float setRotationRadius(float angstroms, boolean doAll)

### moveRotationCenter

public void moveRotationCenter(P3 center, boolean toXY)

### setCenterAt

public void setCenterAt(int relativeTo, P3 pt)

### setNavFps

protected void setNavFps(int navFps)

### calcCameraFactors

public void calcCameraFactors()
sets all camera and scale factors needed by the specific perspective model instantiated

### getPerspectiveFactor

public float getPerspectiveFactor(float z)
calculate the perspective factor based on z

Parameters:
  `z` -
Returns:
  perspectiveFactor

### unTransformPoint

public void unTransformPoint(T3 screenPt, T3 coordPt)

### resetNavigationPoint

protected void resetNavigationPoint(boolean doResetSlab)
something has arisen that requires resetting of the navigation point.

Parameters:
  `doResetSlab` -

### setNavigatePt

public void setNavigatePt(P3 pt)
scripted entry point for navigation

Parameters:
  `pt` -

### getNavigationOffset

public P3 getNavigationOffset()

### getNavPtHeight

public float getNavPtHeight()

### getNavigationOffsetPercent

public float getNavigationOffsetPercent(char XorY)

### getNavigationText

protected String getNavigationText(boolean addComments)

### navigateList

public void navigateList(JmolScriptEvaluator eval, Lst<Object[]> list)

### navigateAxis

public void navigateAxis(V3 rotAxis, float degrees)
scripted entry point for navigation

Parameters:
  `rotAxis` -
  `degrees` -

### setNavigationOffsetRelative

public void setNavigationOffsetRelative()

### setNavigationDepthPercent

public void setNavigationDepthPercent(float percent)
sets the position of the navigation offset relative to the model (50% center; 0% rear, 100% front; can be invalid input: '<'0 or >100)

Parameters:
  `percent` -

### navTranslatePercentOrTo

public void navTranslatePercentOrTo(float seconds, float x, float y)
seconds invalid input: '<' 0 means "to (x,y)"; >= 0 mean "to (x%, y%)"

Parameters:
  `seconds` -
  `x` -
  `y` -

### calcNavigationPoint

protected void calcNavigationPoint()
All the magic happens here. all navigation effects go through this method

### getNavigationState

protected String getNavigationState()

Returns:
  the script that defines the current navigation state