spatialmath

package
v0.0.9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 9, 2022 License: AGPL-3.0 Imports: 11 Imported by: 26

Documentation

Overview

Package spatialmath defines spatial mathematical operations. Poses represent a position in 6 degrees of freedom, i.e. a position and an orientation. Positions are represented as r3 Vectors, while Orientations are an interface able to be represented many different ways. This package provides various Orientation implementations as well as the ability to perform a variety of useful operations on Poses and Orientations.

Index

Constants

View Source 
const (
	NoOrientationType            = OrientationType("")
	OrientationVectorDegreesType = OrientationType("ov_degrees")
	OrientationVectorRadiansType = OrientationType("ov_radians")
	EulerAnglesType              = OrientationType("euler_angles")
	AxisAnglesType               = OrientationType("axis_angles")
	QuaternionType               = OrientationType("quaternion")
)

The set of allowed representations for orientation.

View Source 
const Epsilon = 1e-8

Epsilon represents the acceptable discrepancy between two floats representing spatial coordinates wherin the coordinates should be considered equivalent.

Variables

This section is empty.

Functions

func Flip 

func Flip(q quat.Number) quat.Number

Flip will multiply a quaternion by -1, returning a quaternion representing the same orientation but in the opposing octant.

func MatToEuler 

func MatToEuler(mat mgl64.Mat4) []float64

MatToEuler Converts a 4x4 matrix to Euler angles. Euler angles are terrible, don't use them.

func Norm 

func Norm(q quat.Number) float64

Norm returns the norm of the quaternion, i.e. the sqrt of the sum of the squares of the imaginary parts.

func Normalize 

func Normalize(q quat.Number) quat.Number

Normalize a quaternion, returning its, versor (unit quaternion).

func OffsetBy 

func OffsetBy(a, b *commonpb.Pose) *commonpb.Pose

OffsetBy takes two offsets and computes the final position.

func OrientationAlmostEqual 

func OrientationAlmostEqual(o1, o2 Orientation) bool

OrientationAlmostEqual will return a bool describing whether 2 poses have approximately the same orientation.

func PoseAlmostCoincident 

func PoseAlmostCoincident(a, b Pose) bool

PoseAlmostCoincident will return a bool describing whether 2 poses approximately are at the same 3D coordinate location. This uses the same epsilon as the default value for the Viam IK solver.

func PoseAlmostCoincidentEps 

func PoseAlmostCoincidentEps(a, b Pose, epsilon float64) bool

PoseAlmostCoincidentEps will return a bool describing whether 2 poses approximately are at the same 3D coordinate location. This uses a passed in epsilon value.

func PoseAlmostEqual 

func PoseAlmostEqual(a, b Pose) bool

PoseAlmostEqual will return a bool describing whether 2 poses are approximately the same.

func PoseMap 

func PoseMap(p Pose) (map[string]interface{}, error)

PoseMap encodes the orientation interface to something serializable and human readable.

func PoseToProtobuf 

func PoseToProtobuf(p Pose) *commonpb.Pose

PoseToProtobuf converts a pose to the pose format protobuf expects (which is as OrientationVectorDegrees).

func QuatToR3AA 

func QuatToR3AA(q quat.Number) r3.Vector

QuatToR3AA converts a quat to an R3 axis angle in the same way the C++ Eigen library does. https://eigen.tuxfamily.org/dox/AngleAxis_8h_source.html

func QuaternionAlmostEqual 

func QuaternionAlmostEqual(a, b quat.Number, tol float64) bool

QuaternionAlmostEqual is an equality test for all the float components of a quaternion. Quaternions have double coverage, q == -q, and this function will *not* account for this. Use OrientationAlmostEqual unless you're certain this is what you want.

func R3VectorAlmostEqual 

func R3VectorAlmostEqual(a, b r3.Vector, epsilon float64) bool

R3VectorAlmostEqual compares two r3.Vector objects and returns if the all elementwise differences are less than epsilon.

func ResetPoseDQTransalation 

func ResetPoseDQTransalation(p Pose, v r3.Vector)

ResetPoseDQTransalation takes a Pose that must be a dualQuaternion and reset's it's translation.

Types

type AngularVelocity 

type AngularVelocity r3.Vector

AngularVelocity contains angular velocity in deg/s across x/y/z axes.

type AxisConfig 

type AxisConfig r3VectorConfig

AxisConfig represents the configuration format representing an axis.

func NewAxisConfig 

func NewAxisConfig(axis R4AA) *AxisConfig

NewAxisConfig constructs a config from an R4AA.

func (AxisConfig) ParseConfig 

func (a AxisConfig) ParseConfig() R4AA

ParseConfig converts an AxisConfig into an R4AA object.

type EulerAngles 

type EulerAngles struct {
	Roll  float64 `json:"roll"`  // phi, X
	Pitch float64 `json:"pitch"` // theta, Y
	Yaw   float64 `json:"yaw"`   // psi, Z
}

EulerAngles are three angles (in radians) used to represent the rotation of an object in 3D Euclidean space The Tait–Bryan angle formalism is used, with rotations around three distinct axes in the z-y′-x″ sequence.

func NewEulerAngles 

func NewEulerAngles() *EulerAngles

NewEulerAngles creates an empty EulerAngles struct.

func QuatToEulerAngles 

func QuatToEulerAngles(q quat.Number) *EulerAngles

QuatToEulerAngles converts a quaternion to the euler angle representation. Algorithm from Wikipedia. https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Quaternion_to_Euler_angles_conversion

func (*EulerAngles) AxisAngles 

func (ea *EulerAngles) AxisAngles() *R4AA

AxisAngles returns the orientation in axis angle representation.

func (*EulerAngles) EulerAngles 

func (ea *EulerAngles) EulerAngles() *EulerAngles

EulerAngles returns orientation in Euler angle representation.

func (*EulerAngles) OrientationVectorDegrees 

func (ea *EulerAngles) OrientationVectorDegrees() *OrientationVectorDegrees

OrientationVectorDegrees returns orientation as an orientation vector (in degrees).

func (*EulerAngles) OrientationVectorRadians 

func (ea *EulerAngles) OrientationVectorRadians() *OrientationVector

OrientationVectorRadians returns orientation as an orientation vector (in radians).

func (*EulerAngles) Quaternion 

func (ea *EulerAngles) Quaternion() quat.Number

Quaternion returns orientation in quaternion representation.

func (*EulerAngles) RotationMatrix 

func (ea *EulerAngles) RotationMatrix() *RotationMatrix

RotationMatrix returns the orientation in rotation matrix representation.

type Geometry 

type Geometry interface {
	Pose() Pose
	Vertices() []r3.Vector
	AlmostEqual(Geometry) bool
	Transform(Pose) Geometry
	ToProtobuf() *commonpb.Geometry
	CollidesWith(Geometry) (bool, error)
	DistanceFrom(Geometry) (float64, error)
	EncompassedBy(Geometry) (bool, error)
}

Geometry is an entry point with which to access all types of collision geometries.

func NewBox 

func NewBox(pose Pose, dims r3.Vector) (Geometry, error)

NewBox instantiates a new box Geometry.

func NewGeometryFromProto 

func NewGeometryFromProto(geometry *commonpb.Geometry) (Geometry, error)

NewGeometryFromProto instatiates a new Geometry from a protobuf Geometry message.

func NewPoint 

func NewPoint(pt r3.Vector) Geometry

NewPoint instantiates a new point Geometry.

func NewSphere 

func NewSphere(pt r3.Vector, radius float64) (Geometry, error)

NewSphere instantiates a new sphere Geometry.

type GeometryConfig 

type GeometryConfig struct {
	Type string `json:"type"`

	// parameters used for defining a box's rectangular cross section
	X float64 `json:"x"`
	Y float64 `json:"y"`
	Z float64 `json:"z"`

	// parameters used for defining a sphere, its radius
	R float64 `json:"r"`

	// define an offset to position the geometry
	TranslationOffset TranslationConfig `json:"translation"`
	OrientationOffset OrientationConfig `json:"orientation"`
}

GeometryConfig specifies the format of geometries specified through the configuration file.

func NewGeometryConfig 

func NewGeometryConfig(offset Pose) (*GeometryConfig, error)

NewGeometryConfig creates a config for a Geometry from an offset Pose.

func (*GeometryConfig) ParseConfig 

func (config *GeometryConfig) ParseConfig() (GeometryCreator, error)

ParseConfig converts a GeometryConfig into the correct GeometryCreator type, as specified in its Type field.

type GeometryCreator 

type GeometryCreator interface {
	NewGeometry(Pose) Geometry
	json.Marshaler
}

GeometryCreator provides a common way to instantiate Geometries.

func NewBoxCreator 

func NewBoxCreator(dims r3.Vector, offset Pose) (GeometryCreator, error)

NewBoxCreator instantiates a BoxCreator class, which allows instantiating boxes given only a pose which is applied at the specified offset from the pose. These boxes have dimensions given by the provided halfSize vector.

func NewPointCreator 

func NewPointCreator(offset Pose) GeometryCreator

NewPointCreator instantiates a PointCreator class, which allows instantiating point geometries given only a pose which is applied at the specified offset from the pose. These pointers have dimensions given by the provided halfSize vector.

func NewSphereCreator 

func NewSphereCreator(radius float64, offset Pose) (GeometryCreator, error)

NewSphereCreator instantiates a SphereCreator class, which allows instantiating spheres given only a pose which is applied at the specified offset from the pose. These spheres have a radius specified by the radius argument.

type Orientation 

type Orientation interface {
	OrientationVectorRadians() *OrientationVector
	OrientationVectorDegrees() *OrientationVectorDegrees
	AxisAngles() *R4AA
	Quaternion() quat.Number
	EulerAngles() *EulerAngles
	RotationMatrix() *RotationMatrix
}

Orientation is an interface used to express the different parameterizations of the orientation of a rigid object or a frame of reference in 3D Euclidean space.

func NewZeroOrientation 

func NewZeroOrientation() Orientation

NewZeroOrientation returns an orientatation which signifies no rotation.

func OrientationBetween 

func OrientationBetween(o1, o2 Orientation) Orientation

OrientationBetween returns the orientation representing the difference between the two given orientations.

func OrientationInverse 

func OrientationInverse(o Orientation) Orientation

OrientationInverse returns the orientation representing the inverse of the given orientation.

type OrientationConfig 

type OrientationConfig struct {
	Type  string          `json:"type"`
	Value json.RawMessage `json:"value"`
}

OrientationConfig holds the underlying type of orientation, and the value.

func NewOrientationConfig 

func NewOrientationConfig(o Orientation) (*OrientationConfig, error)

NewOrientationConfig encodes the orientation interface to something serializable and human readable.

func (*OrientationConfig) ParseConfig 

func (config *OrientationConfig) ParseConfig() (Orientation, error)

ParseConfig will use the Type in OrientationConfig and convert into the correct struct that implements Orientation.

type OrientationType 

type OrientationType string

OrientationType defines what orientation representations are known.

type OrientationVector 

type OrientationVector struct {
	Theta float64 `json:"th"`
	OX    float64 `json:"x"`
	OY    float64 `json:"y"`
	OZ    float64 `json:"z"`
}

OrientationVector containing ox, oy, oz, theta represents an orientation vector Structured similarly to an angle axis, an orientation vector works differently. Rather than representing an orientation with an arbitrary axis and a rotation around it from an origin, an orientation vector represents orientation such that the ox/oy/oz components represent the point on the cartesian unit sphere at which your end effector is pointing from the origin, and that unit vector forms an axis around which theta rotates. This means that incrementing/decrementing theta will perform an in-line rotation of the end effector. Theta is defined as rotation between two planes: the plane defined by the origin, the point (0,0,1), and the rx,ry,rz point, and the plane defined by the origin, the rx,ry,rz point, and the new local Z axis. So if theta is kept at zero as the north/south pole is circled, the Roll will correct itself to remain in-line.

func NewOrientationVector 

func NewOrientationVector() *OrientationVector

NewOrientationVector Creates a zero-initialized OrientationVector.

func QuatToOV 

func QuatToOV(q quat.Number) *OrientationVector

QuatToOV converts a quaternion to an orientation vector.

func (*OrientationVector) AxisAngles 

func (ov *OrientationVector) AxisAngles() *R4AA

AxisAngles returns the orientation in axis angle representation.

func (*OrientationVector) Degrees 

func (ov *OrientationVector) Degrees() *OrientationVectorDegrees

Degrees converts the OrientationVector to an OrientationVectorDegrees.

func (*OrientationVector) EulerAngles 

func (ov *OrientationVector) EulerAngles() *EulerAngles

EulerAngles returns orientation in Euler angle representation.

func (*OrientationVector) IsValid 

func (ov *OrientationVector) IsValid() error

IsValid returns an error if configuration is invalid.

func (*OrientationVector) Normalize 

func (ov *OrientationVector) Normalize()

Normalize scales the x, y, and z components of an Orientation Vector to be on the unit sphere.

func (*OrientationVector) OrientationVectorDegrees 

func (ov *OrientationVector) OrientationVectorDegrees() *OrientationVectorDegrees

OrientationVectorDegrees returns orientation as an orientation vector (in degrees).

func (*OrientationVector) OrientationVectorRadians 

func (ov *OrientationVector) OrientationVectorRadians() *OrientationVector

OrientationVectorRadians returns orientation as an orientation vector (in radians).

func (*OrientationVector) Quaternion 

func (ov *OrientationVector) Quaternion() quat.Number

Quaternion returns orientation in quaternion representation.

func (*OrientationVector) RotationMatrix 

func (ov *OrientationVector) RotationMatrix() *RotationMatrix

RotationMatrix returns the orientation in rotation matrix representation.

func (*OrientationVector) ToQuat 

func (ov *OrientationVector) ToQuat() quat.Number

ToQuat converts an orientation vector to a quaternion.

type OrientationVectorDegrees 

type OrientationVectorDegrees struct {
	Theta float64 `json:"th"`
	OX    float64 `json:"x"`
	OY    float64 `json:"y"`
	OZ    float64 `json:"z"`
}

OrientationVectorDegrees is the orientation vector between two objects, but expressed in degrees rather than radians. Because protobuf Pose is in degrees, this is necessary.

func NewOrientationVectorDegrees 

func NewOrientationVectorDegrees() *OrientationVectorDegrees

NewOrientationVectorDegrees Creates a zero-initialized OrientationVectorDegrees.

func QuatToOVD 

func QuatToOVD(q quat.Number) *OrientationVectorDegrees

QuatToOVD converts a quaternion to an orientation vector in degrees.

func (*OrientationVectorDegrees) AxisAngles 

func (ovd *OrientationVectorDegrees) AxisAngles() *R4AA

AxisAngles returns the orientation in axis angle representation.

func (*OrientationVectorDegrees) EulerAngles 

func (ovd *OrientationVectorDegrees) EulerAngles() *EulerAngles

EulerAngles returns orientation in Euler angle representation.

func (*OrientationVectorDegrees) IsValid 

func (ovd *OrientationVectorDegrees) IsValid() error

IsValid returns an error if configuration is invalid.

func (*OrientationVectorDegrees) Normalize 

func (ovd *OrientationVectorDegrees) Normalize()

Normalize scales the x, y, and z components of an Orientation Vector to be on the unit sphere.

func (*OrientationVectorDegrees) OrientationVectorDegrees 

func (ovd *OrientationVectorDegrees) OrientationVectorDegrees() *OrientationVectorDegrees

OrientationVectorDegrees returns orientation as an orientation vector (in degrees).

func (*OrientationVectorDegrees) OrientationVectorRadians 

func (ovd *OrientationVectorDegrees) OrientationVectorRadians() *OrientationVector

OrientationVectorRadians returns orientation as an orientation vector (in radians).

func (*OrientationVectorDegrees) Quaternion 

func (ovd *OrientationVectorDegrees) Quaternion() quat.Number

Quaternion returns orientation in quaternion representation.

func (*OrientationVectorDegrees) Radians 

func (ovd *OrientationVectorDegrees) Radians() *OrientationVector

Radians converts a OrientationVectorDegrees to an OrientationVector.

func (*OrientationVectorDegrees) RotationMatrix 

func (ovd *OrientationVectorDegrees) RotationMatrix() *RotationMatrix

RotationMatrix returns the orientation in rotation matrix representation.

func (*OrientationVectorDegrees) ToQuat 

func (ovd *OrientationVectorDegrees) ToQuat() quat.Number

ToQuat converts an orientation vector in degrees to a quaternion.

type Pose 

type Pose interface {
	Point() r3.Vector
	Orientation() Orientation
}

Pose represents a 6dof pose, position and orientation, with respect to the origin. The Point() method returns the position in (x,y,z) mm coordinates, and the Orientation() method returns an Orientation object, which has methods to parametrize the rotation in multiple different representations.

func Compose 

func Compose(a, b Pose) Pose

Compose treats Poses as functions A(x) and B(x), and produces a new function C(x) = A(B(x)). It converts the poses to dual quaternions and multiplies them together, normalizes the transform and returns a new Pose. Composition does not commute in general, i.e. you cannot guarantee ABx == BAx.

func Interpolate 

func Interpolate(p1, p2 Pose, by float64) Pose

Interpolate will return a new Pose that has been interpolated the set amount between two poses. Note that position and orientation are interpolated separately, then the two are combined. Note that slerp(q1, q2) != slerp(q2, q1) p1 and p2 are the two poses to interpolate between, by is a float representing the amount to interpolate between them. by == 0 will return p1, by == 1 will return p2, and by == 0.5 will return the pose halfway between them.

func NewPoseFromDH 

func NewPoseFromDH(a, d, alpha float64) Pose

NewPoseFromDH creates a new pose from denavit hartenberg parameters.

func NewPoseFromOrientation 

func NewPoseFromOrientation(point r3.Vector, o Orientation) Pose

NewPoseFromOrientation takes in a position and orientation and returns a Pose.

func NewPoseFromPoint 

func NewPoseFromPoint(point r3.Vector) Pose

NewPoseFromPoint takes in a cartesian (x,y,z) and stores it as a vector. It will have the same orientation as the frame it is in.

func NewPoseFromProtobuf 

func NewPoseFromProtobuf(pos *commonpb.Pose) Pose

NewPoseFromProtobuf creates a new pose from a protobuf pose.

func NewZeroPose 

func NewZeroPose() Pose

NewZeroPose returns a pose at (0,0,0) with same orientation as whatever frame it is placed in.

func PoseBetween 

func PoseBetween(a, b Pose) Pose

PoseBetween returns the difference between two dualQuaternions, that is, the dq which if multiplied by one will give the other.

func PoseDelta 

func PoseDelta(a, b Pose) Pose

PoseDelta returns the difference between two dualQuaternion. We use quaternion/angle axis for this because distances are well-defined.

func PoseInverse 

func PoseInverse(p Pose) Pose

PoseInverse will return the inverse of a pose. So if a given pose p is the pose of A relative to B, PoseInverse(p) will give the pose of B relative to A.

type Quaternion 

type Quaternion quat.Number

Quaternion is an orientation in quaternion representation.

func (*Quaternion) AxisAngles 

func (q *Quaternion) AxisAngles() *R4AA

AxisAngles returns the orientation in axis angle representation.

func (*Quaternion) EulerAngles 

func (q *Quaternion) EulerAngles() *EulerAngles

EulerAngles returns orientation in Euler angle representation.

func (*Quaternion) MarshalJSON 

func (q *Quaternion) MarshalJSON() ([]byte, error)

MarshalJSON marshals to W, X, Y, Z json.

func (*Quaternion) OrientationVectorDegrees 

func (q *Quaternion) OrientationVectorDegrees() *OrientationVectorDegrees

OrientationVectorDegrees returns orientation as an orientation vector (in degrees).

func (*Quaternion) OrientationVectorRadians 

func (q *Quaternion) OrientationVectorRadians() *OrientationVector

OrientationVectorRadians returns orientation as an orientation vector (in radians).

func (*Quaternion) Quaternion 

func (q *Quaternion) Quaternion() quat.Number

Quaternion returns orientation in quaternion representation.

func (*Quaternion) RotationMatrix 

func (q *Quaternion) RotationMatrix() *RotationMatrix

RotationMatrix returns the orientation in rotation matrix representation.

type R4AA 

type R4AA struct {
	Theta float64 `json:"th"`
	RX    float64 `json:"x"`
	RY    float64 `json:"y"`
	RZ    float64 `json:"z"`
}

R4AA represents an R4 axis angle.

func NewR4AA 

func NewR4AA() *R4AA

NewR4AA creates an empty R4AA struct.

func QuatToR4AA 

func QuatToR4AA(q quat.Number) *R4AA

QuatToR4AA converts a quat to an R4 axis angle in the same way the C++ Eigen library does. https://eigen.tuxfamily.org/dox/AngleAxis_8h_source.html

func R3ToR4 

func R3ToR4(aa r3.Vector) *R4AA

R3ToR4 converts an R3 angle axis to R4.

func (*R4AA) AxisAngles 

func (r4 *R4AA) AxisAngles() *R4AA

AxisAngles returns the orientation in axis angle representation.

func (*R4AA) EulerAngles 

func (r4 *R4AA) EulerAngles() *EulerAngles

EulerAngles returns orientation in Euler angle representation.

func (*R4AA) Normalize 

func (r4 *R4AA) Normalize()

Normalize scales the x, y, and z components of a R4 axis angle to be on the unit sphere.

func (*R4AA) OrientationVectorDegrees 

func (r4 *R4AA) OrientationVectorDegrees() *OrientationVectorDegrees

OrientationVectorDegrees returns orientation as an orientation vector (in degrees).

func (*R4AA) OrientationVectorRadians 

func (r4 *R4AA) OrientationVectorRadians() *OrientationVector

OrientationVectorRadians returns orientation as an orientation vector (in radians).

func (*R4AA) Quaternion 

func (r4 *R4AA) Quaternion() quat.Number

Quaternion returns orientation in quaternion representation.

func (*R4AA) RotationMatrix 

func (r4 *R4AA) RotationMatrix() *RotationMatrix

RotationMatrix returns the orientation in rotation matrix representation.

func (*R4AA) ToQuat 

func (r4 *R4AA) ToQuat() quat.Number

ToQuat converts an R4 axis angle to a unit quaternion See: https://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm1

func (*R4AA) ToR3 

func (r4 *R4AA) ToR3() r3.Vector

ToR3 converts an R4 angle axis to R3.

type RotationMatrix 

type RotationMatrix struct {
	// contains filtered or unexported fields
}

RotationMatrix is a 3x3 matrix in row major order. m[3*r + c] is the element in the r'th row and c'th column.

func NewRotationMatrix 

func NewRotationMatrix(m []float64) (*RotationMatrix, error)

NewRotationMatrix creates the rotation matrix from a slice of floats.

func QuatToRotationMatrix 

func QuatToRotationMatrix(q quat.Number) *RotationMatrix

QuatToRotationMatrix converts a quat to a Rotation Matrix reference: https://github.com/go-gl/mathgl/blob/592312d8590acb0686c14740dcf60e2f32d9c618/mgl64/quat.go#L168

func (*RotationMatrix) At 

func (rm *RotationMatrix) At(row, col int) float64

At returns the float corresponding to the element at the specified location.

func (*RotationMatrix) AxisAngles 

func (rm *RotationMatrix) AxisAngles() *R4AA

AxisAngles returns the orientation in axis angle representation.

func (*RotationMatrix) Col 

func (rm *RotationMatrix) Col(col int) r3.Vector

Col returns the a 3 element vector corresponding to the specified col.

func (*RotationMatrix) EulerAngles 

func (rm *RotationMatrix) EulerAngles() *EulerAngles

EulerAngles returns orientation in Euler angle representation.

func (*RotationMatrix) Mul 

func (rm *RotationMatrix) Mul(v r3.Vector) r3.Vector

Mul returns the product of the rotation Matrix with an r3 Vector.

func (*RotationMatrix) OrientationVectorDegrees 

func (rm *RotationMatrix) OrientationVectorDegrees() *OrientationVectorDegrees

OrientationVectorDegrees returns orientation as an orientation vector (in degrees).

func (*RotationMatrix) OrientationVectorRadians 

func (rm *RotationMatrix) OrientationVectorRadians() *OrientationVector

OrientationVectorRadians returns orientation as an orientation vector (in radians).

func (*RotationMatrix) Quaternion 

func (rm *RotationMatrix) Quaternion() quat.Number

Quaternion returns orientation in quaternion representation. reference: http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm

func (*RotationMatrix) RotationMatrix 

func (rm *RotationMatrix) RotationMatrix() *RotationMatrix

RotationMatrix returns the orientation in rotation matrix representation.

func (*RotationMatrix) Row 

func (rm *RotationMatrix) Row(row int) r3.Vector

Row returns the a 3 element vector corresponding to the specified row.

type TranslationConfig 

type TranslationConfig r3VectorConfig

TranslationConfig represents the configuration format representing a translation between two objects - it is always in millimeters.

func NewTranslationConfig 

func NewTranslationConfig(translation r3.Vector) *TranslationConfig

NewTranslationConfig constructs a config from a r3.Vector.

func (*TranslationConfig) ParseConfig 

func (t *TranslationConfig) ParseConfig() r3.Vector

ParseConfig converts a TranslationConfig into a r3.Vector.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.