This document discusses Swift and transformations. It begins by introducing typed transforms in Swift using protocols like AngleProtocol. It defines operations like addition and subtraction for angle types that conform to AngleProtocol. It also defines conversions between radians and degrees. Next, it discusses 2D points using a Point2DProtocol. It implements operations like addition and subtraction for point types. It then discusses affine transforms for points using a CGAffineTransform type. It shows how to apply transforms to points and concatenate multiple transforms. Finally, it provides an example of drawing a house shape to a graphics context after applying various coordinate space transforms.

1. Swift
by Ray Fix for iOSDC

2. Ray Fix
Photo by Renato Sanchez Lozada on Unsplash
iOSDC

3. RayWenderlich.com
Ray Ray Wenderlich 😉

4. REVOLVE

5. REVOLVE

6. Swift

7. Swift Python R

8. •
• Swift

9. •
• Swift

10. •
• Swift

11. WWDC 2017 — fox2
https://developer.apple.com/videos/play/wwdc2017/604/

12. WWDC 2017 — fox2
https://developer.apple.com/videos/play/wwdc2017/604/

13. WWDC 2017 — ARKit
https://developer.apple.com/videos/play/wwdc2017/602/

14. WWDC 2017 — ARKit
https://developer.apple.com/videos/play/wwdc2017/602/

15. Fall 2017 — ARFaceAnchor
https://developer.apple.com/documentation/arkit/arfaceanchor?changes=latest_beta

16. I❤Swift

17. I❤Swift
https://github.com/rayfix/TypedTransforms

20. degrees radians

21. protocol AngleProtocol {
}
associatedtype TT

22. protocol AngleProtocol {
}
associatedtype T

23. protocol AngleProtocol {
}
associatedtype Real

24. protocol AngleProtocol {
}
associatedtype Real : FloatingPoint

25. AngleProtocol
protocol AngleProtocol {
associatedtype Real: FloatingPoint
init(radians: Real)
var radians: Real { set get }
}

26. (1)
extension AngleProtocol {
}

27. (1)
extension AngleProtocol {
}
static func +(lhs: Self, rhs: Self) -> Self {
return Self(radians: lhs.radians + rhs.radians)
}

28. (1)
extension AngleProtocol {
}
static func +=(lhs: inout Self, rhs: Self) {
lhs = lhs + rhs
}
static func +(lhs: Self, rhs: Self) -> Self {
return Self(radians: lhs.radians + rhs.radians)
}

29. (2)
extension AngleProtocol {
}

30. (2)
extension AngleProtocol {
}
static prefix func -(angle: Self) -> Self {
return Self(radians: -angle.radians)
}

31. (2)
extension AngleProtocol {
}
static prefix func -(angle: Self) -> Self {
return Self(radians: -angle.radians)
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}

32. (2)
extension AngleProtocol {
}
static prefix func -(angle: Self) -> Self {
return Self(radians: -angle.radians)
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}
static func -=(lhs: inout Self, rhs: Self) {
lhs = lhs - rhs
}

33. (3)
extension AngleProtocol {
}

34. (3)
extension AngleProtocol {
}
static func *(multiple: Real, angle: Self) -> Self {
return Self(radians: multiple * angle.radians)
}

35. (3)
extension AngleProtocol {
}
static func *(multiple: Real, angle: Self) -> Self {
return Self(radians: multiple * angle.radians)
}
static func *(angle: Self, multiple: Real) -> Self {
return multiple * angle
}

36. (3)
extension AngleProtocol {
}
static func *(multiple: Real, angle: Self) -> Self {
return Self(radians: multiple * angle.radians)
}
static func *(angle: Self, multiple: Real) -> Self {
return multiple * angle
}
static func /(angle: Self, divisor: Real) -> Self {
return angle * (1/divisor)
}

37. extension AngleProtocol: Hashable, Comparable {
} Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

38. extension AngleProtocol: Hashable, Comparable {
}
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs.radians == rhs.radians
}
Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

39. extension AngleProtocol: Hashable, Comparable {
}
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs.radians == rhs.radians
}
var hashValue: Int {
return radians.hashValue
}
Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

40. extension AngleProtocol: Hashable, Comparable {
}
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs.radians == rhs.radians
}
var hashValue: Int {
return radians.hashValue
}
static func <(lhs: Self, rhs: Self) -> Bool {
return lhs.radians < rhs.radians
}
Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

41. protocol AngleDegreesConvertible: AngleProtocol {
init(degrees: Real)
var degrees: Real { set get }
static var radiansToDegrees: Real { get }
}

42. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}

43. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}
radiansToDegrees

44. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}
radiansToDegrees
radiansToDegreesradians

45. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}
radiansToDegrees
radiansToDegrees degrees

46. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

47. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

48. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
Inverse Transform

49. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
ToDegreesradians
Inverse Transform

50. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
ToDegrees radians
Inverse Transform
Radiansdegrees

51. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

52. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

53. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
init(degrees: Real) {
let degreesToRadians = 1 / Self.radiansToDegrees
self.init(radians: degrees * degreesToRadians)
}

54. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
init(degrees: Real) {
let degreesToRadians = 1 / Self.radiansToDegrees
self.init(radians: degrees * degreesToRadians)
}

55. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
init(degrees: Real) {
let degreesToRadians = 1 / Self.radiansToDegrees
self.init(radians: degrees * degreesToRadians)
}

56. var degrees: Real {
set(newDegrees) {
let degreesToRadians = 1 / Self.radiansToDegrees
radians = newDegrees * degreesToRadians
}
}
(3)

57. var degrees: Real {
set(newDegrees) {
let degreesToRadians = 1 / Self.radiansToDegrees
radians = newDegrees * degreesToRadians
}
}
(3)

58. var degrees: Real {
set(newDegrees) {
let degreesToRadians = 1 / Self.radiansToDegrees
radians = newDegrees * degreesToRadians
}
}
(3)

59. To
🐶
🐕
🐩 😸
🐈
😽

60. To
🐶
🐕
🐩 😸
🐈
😽
To
🐶
🐕
🐩😸
🐈
😽

61. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
FloatingPoint

62. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
FloatingPoint

63. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
TrigonometricFloatingPoint

64. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
TrigonometricFloatingPoint
protocol TrigonometricFloatingPoint: FloatingPoint {
static func sine(radians: Self) -> Self
static func cosine(radians: Self) -> Self
}

65. sin

66. sin
func sin(_ angle: AngleProtocol) -> ???? {
}

67. sin
func sin(_ angle: AngleProtocol) -> ???? {
}

68. sin
func sin<A: AngleProtocol>(_ angle: A) -> A.Real {
return A.Real.sine(radians: angle.radians)
}
func sin(_ angle: AngleProtocol) -> ???? {
}

69. CGAngle
struct CGAngle: AngleDegreesConvertible {
var radians: CGFloat
static var radiansToDegrees: CGFloat {
return 180/CGFloat.pi
}
}
😍

70. CGAngle
struct CGAngle: AngleDegreesConvertible {
var radians: CGFloat
static var radiansToDegrees: CGFloat {
return 180/CGFloat.pi
}
}
😍

73. protocol Point2DProtocol {
associatedtype Scalar: FloatingPoint
init(_ x: Scalar, _ y: Scalar)
var x: Scalar { get set }
var y: Scalar { get set }
}

74. …
static func +(lhs: Self, rhs: Self) -> Self {
return Self(lhs.x + rhs.x, lhs.y + rhs.y)
}
static prefix func -(p: Self) -> Self {
return Self(-p.x, -p.y)
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}
extension Point2DProtocol {
}

75. …
extension Point2DProtocol {
}
var lengthSquared: Scalar {
return self*self
}
var length: Scalar {
return lengthSquared.squareRoot()
}
func projected(on other: Self) -> Self {
return ((self*other)/(other*other))*other
}
🤠

76. extension CGPoint: Point2DProtocol {
public init(_ x: CGFloat, _ y: CGFloat) {
self.x = x
self.y = y
}
}
💯

77. let newPoint = transform * point
[ ]a
db
c
[x
y
]=[ax + cy
]bx + dy

78. let newPoint = transform * point
[ ]a
db
c
1
tx
ty
0 0 [x
y
1 ]=[ax + cy + tx
1 ]bx + dy + ty

80. CGAffineTransform

81. CGAffineTransform
Think Different

82. CGAffineTransform
Think Different
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

83. let newPoint = transform * point
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

84. let newPoint = transform * point
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

85. let newPoint = transform * point
let newPoint = point * transform
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

86. A
C
(0, 0)

87. A
C
(7, 7)
xa = (7, 7)
(0, 0)

88. A
C
(7, 7)
yc = xa * aToC
xa = (7, 7)
(0, 0)

89. A
C
(7, 7)
(1,0)
yc = xa * aToC
xa = (7, 7)
yc == (1, 0)
(0, 0)

90. A
C
(7, 7)
(1,0)
yc = xa * aToC
xa = (7, 7)
yc == (1, 0)
yc * aToC
(0, 0)

91. A
C
(7, 7)
(1,0)
yc = xa * aToC
xa = (7, 7)
yc == (1, 0)
yc * aToC
(0, 0)

92. A

93. A
B

94. A
C

95. A
C
aToB * bToC

96. A
C
aToB * bToC
aToC
=

97. [ ]1
10
0
1
0
0
tx ty [ ]sx
sy0
0
1
0
0
0 0 [ ]
cos a
cos a-sin a
sin a
1
0
0
0 0
translation scale rotation
[ ]1
10
0
1
0
0
0 0
identity
[ ]-1
10
0
1
0
0
0 0
horizontal flip
[ ]1
-10
0
1
0
0
0 0
vertical flip

98. ctm
[ ]2
-20
0
1
0
0
0 1096
userToDevice

99. CGAffineTransform
extension CGAffineTransform {
static func *(point: CGPoint, transform: CGAffineTransform)
-> CGPoint
{
return point.applying(transform)
}
static func *(lhs: CGAffineTransform, rhs: CGAffineTransform)
-> CGAffineTransform
{
return lhs.concatenating(rhs)
}
}
modelToDevice = modelToUser * userToDevice
devicePoint = userPoint * userToDevice

100. 2
let house: [CGPoint] = [CGPoint(1,-1),
CGPoint(1,1),
CGPoint(0,2),
CGPoint(-1,1),
CGPoint(-1,-1)]

101. 2
let house: [CGPoint] = [CGPoint(1,-1),
CGPoint(1,1),
CGPoint(0,2),
CGPoint(-1,1),
CGPoint(-1,-1)]
context.saveGState()
defer {
context.restoreGState()
}
let userToDevice = context.ctm
context.concatenate(userToDevice.inverted())

102. 2
let modelToUser =
CGAffineTransform(scaleX: 1, y: -1) *
CGAffineTransform(scaleX: 100, y: 100) *
CGAffineTransform(translationX: bounds.width/2,
y: bounds.height/2)

103. 2
let modelToUser =
CGAffineTransform(scaleX: 1, y: -1) *
CGAffineTransform(scaleX: 100, y: 100) *
CGAffineTransform(translationX: bounds.width/2,
y: bounds.height/2)
let modelToDevice = modelToUser * userToDevice
context.concatenate(modelToDevice)

104. 2
context.move(to: house.first!)
house.dropFirst().forEach { context.addLine(to: $0)}
context.closePath()
context.strokePath()

105. protocol CoordinateSpace {}
enum ModelSpace: CoordinateSpace {}
enum UserSpace: CoordinateSpace {}
enum DeviceSpace: CoordinateSpace {}

106. struct CGPointT<Space: CoordinateSpace>: Point2DProtocol {
var xy: CGPoint
:
}
let house: [CGPointT<ModelSpace>] = [CGPointT(1,-1),
CGPointT(1,1),
CGPointT(0,2),
CGPointT(-1,1),
CGPointT(-1,-1)]

107. struct CGAffineTransformT<From: CoordinateSpace,
To: CoordinateSpace>
{
var matrix: CGAffineTransform
public func inverted() -> CGAffineTransformT<To,From> {
return CGAffineTransformT<To,From>(matrix.inverted())
}
}

108. struct CGAffineTransformT<From: CoordinateSpace,
To: CoordinateSpace>
{
var matrix: CGAffineTransform
public func inverted() -> CGAffineTransformT<To,From> {
return CGAffineTransformT<To,From>(matrix.inverted())
}
}
public func * <From,To,I>(from: CGAffineTransformT<From, I>,
to: CGAffineTransformT<I, To>) ->
CGAffineTransformT<From, To>
{
return CGAffineTransformT<From,To>
(from.matrix.concatenating(to.matrix))
}

109. To
🐶
🐕
🐩 😸
🐈
😽

110. To
🐶
🐕
🐩 😸
🐈
😽
To
😸
🐈
😽
To
😸
🐈
😽

111. ARKit 3
SIMD
[ ]matrix_float4x4
[ ]float4
post multiply To
[ ]float4

112. ARKit 3
From
worldFromCameralet worldPoint = * cameraPoint

113. float4_t
struct float4_t<Space: CoordinateSpace> {
var point: float4
init(_ point: float4) {
self.point = point
}
}

114. matrix_float4x4_t
struct matrix_float4x4_t<To: CoordinateSpace,
From: CoordinateSpace> {
var matrix: matrix_float4x4
init(_ matrix: matrix_float4x4) {
self.matrix = matrix
}
}

115. extension matrix_float4x4_t {
static func *<To, From>(lhs: matrix_float4x4_t<To, From>,
rhs: float4_t<From>) -> float4_t<To>
{
return float4_t<To>(lhs.matrix * rhs.point)
}
}

116. transform

117. transform

118. transform
cameraFromWorld
worldFromCamera

119. transform
cameraFromWorld
worldFromCamera

121. final class TypedTransforms<Base> {
let base: Base
init(_ base: Base) {
self.base = base
}
}

122. final class TypedTransforms<Base> {
let base: Base
init(_ base: Base) {
self.base = base
}
}
protocol TypedTransformAdditions {
associatedtype Typed
var typed: Typed { get }
}

123. final class TypedTransforms<Base> {
let base: Base
init(_ base: Base) {
self.base = base
}
}
protocol TypedTransformAdditions {
associatedtype Typed
var typed: Typed { get }
}
extension TypedTransformAdditions {
var typed: TypedTransforms<Self> {
return TypedTransforms(self)
}
}

125. extension ARCamera: TypedTransformAdditions {}

126. extension TypedTransforms where Base: ARCamera {
var worldFromCamera: matrix_float4x4_t<WorldSpace,
CameraSpace>
{
return matrix_float4x4_t(base.transform)
}
}
extension ARCamera: TypedTransformAdditions {}

127. let worldFromCamera =
frame.camera.typed.worldFromCamera

128. let shotDirectionCamera =
float4_t<CameraSpace>(float4(0, 0, -3, 1))
let shotDirectionWorld = worldFromCamera *
shotDirectionCamera
let direction =
SCNVector3(float4: shotDirectionWorld.point)
let worldFromCamera =
frame.camera.typed.worldFromCamera

129. let position =
SCNVector3(float4: worldFromCamera.matrix.columns.3)
[ ]
matrix_float4x4
tx
ty
tz
1
0 21 3

130. let ball = Ball()
ball.position = position
ball.physicsBody?.applyForce(direction,
asImpulse: true)
sceneView.scene.rootNode.addChildNode(ball)