視覚化とSwiftのタイプについて

Ray Fix
Photo by Renato Sanchez Lozada on Unsplash
iOSDC

RayWenderlich.com
Ray Ray Wenderlich 😉

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

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

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

I❤Swift
https://github.com/rayﬁx/TypedTransforms

視覚化とSwiftのタイプについて

protocol AngleProtocol {
}
associatedtype TT

}
associatedtype T

}
associatedtype Real

}
associatedtype Real : FloatingPoint

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

(1)
extension AngleProtocol {
}

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

(1)
}
static func +=(lhs: inout Self, rhs: Self) {
lhs = lhs + rhs
}
return Self(radians: lhs.radians + rhs.radians)
}

(2)
}

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

(2)
}
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}

(2)
}
}
return lhs+(-rhs)
}
static func -=(lhs: inout Self, rhs: Self) {
lhs = lhs - rhs
}

(3)
}

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

(3)
}
}
static func *(angle: Self, multiple: Real) -> Self {
return multiple * angle
}

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

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

}
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.

}
}
var hashValue: Int {
return radians.hashValue
}

}
}
var hashValue: Int {
return radians.hashValue
}
static func <(lhs: Self, rhs: Self) -> Bool {
return lhs.radians < rhs.radians
}

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

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

(1)
var degrees: Real {
get {
}
}
}
radiansToDegrees

(1)
var degrees: Real {
get {
}
}
}
radiansToDegrees
radiansToDegreesradians

(1)
var degrees: Real {
get {
}
}
}
radiansToDegrees
radiansToDegrees degrees

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

(2)
}
Inverse Transform

(2)
}
ToDegreesradians
Inverse Transform

(2)
}
ToDegrees radians
Inverse Transform
Radiansdegrees

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

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

To
🐶
🐕
🐩 😸
🐈
😽

To
🐶
🐕
🐩 😸
🐈
😽
To
🐶
🐕
🐩😸
🐈
😽

associatedtype Real:
init(radians: Real)
}
FloatingPoint

init(radians: Real)
}
TrigonometricFloatingPoint

init(radians: Real)
}
TrigonometricFloatingPoint
protocol TrigonometricFloatingPoint: FloatingPoint {
static func sine(radians: Self) -> Self
static func cosine(radians: Self) -> Self
}

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

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

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

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

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

…
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
}
🤠

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

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

[ ]a
db
c
1
tx
ty
0 0 [x
y
1 ]=[ax + cy + tx
1 ]bx + dy + ty

CGAffineTransform
Think Diﬀerent

CGAffineTransform
Think Diﬀerent
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

let newPoint = point * transform
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

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

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

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

[ ]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 ﬂip
[ ]1
-10
0
1
0
0
0 0
vertical ﬂip

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

CGAfﬁneTransform
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

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

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())

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

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)

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

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

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)]

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

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))
}

To
🐶
🐕
🐩 😸
🐈
😽
To
😸
🐈
😽
To
😸
🐈
😽

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

ARKit 3
From
worldFromCameralet worldPoint = * cameraPoint

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

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

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)
}
}

transform
cameraFromWorld
worldFromCamera

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

let base: Base
self.base = base
}
}
protocol TypedTransformAdditions {
associatedtype Typed
var typed: Typed { get }
}

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

extension ARCamera: TypedTransformAdditions {}

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

let worldFromCamera =
frame.camera.typed.worldFromCamera

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

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

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

視覚化とSwiftのタイプについて

More Related Content

What's hot (20)

Similar to 視覚化とSwiftのタイプについて (20)

Recently uploaded (20)

視覚化とSwiftのタイプについて