<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Christopher Webb on Medium]]></title>
        <description><![CDATA[Stories by Christopher Webb on Medium]]></description>
        <link>https://medium.com/@chris.webb5249?source=rss-e2902aed4442------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*7e6fE0-4dqr6GECpAY6nWg.jpeg</url>
            <title>Stories by Christopher Webb on Medium</title>
            <link>https://medium.com/@chris.webb5249?source=rss-e2902aed4442------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:29:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chris.webb5249/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Application Data Flow: Part One]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/application-data-flow-6e171b8be423?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e171b8be423</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[swift-programming]]></category>
            <category><![CDATA[swift-4]]></category>
            <category><![CDATA[mvvm]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Tue, 27 Mar 2018 04:39:37 GMT</pubDate>
            <atom:updated>2018-03-27T11:25:02.922Z</atom:updated>
            <content:encoded><![CDATA[<h4>Working With Stores</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1w5lxGBI8zAAIgSD1vJAEw.png" /></figure><pre><a href="https://github.com/chriswebb09/SaveExample"><strong>Demo Code</strong></a></pre><p>Before we get stated, if you saw store in the title and thought this was something to do with a commerce app, unfortunately it does not. In this instance, Store is in regards to a particular way of organizing storage and retrieval of data for the application.</p><p>Okay, now that we have that out of the way, today we are going to be talking about application data flow. While the topic may not sound super interesting, having a good handle on the river of information flowing through your application will, in the long run, save you a lot time.</p><h3>Order From Chaos</h3><p>How often do you sit down and sketch out a rough outline of an application before you start building? Regularly? Not at all? If it is regularly, how much of that time is spent mapping the data and application state and how much of it is on planning UI?</p><p>The truth is not nearly as many people spend time planning the data as on the UI. And why not, there are tons of really great tools like Sketch for planning UI, and there tons of blogs and other resources for learning more about planning your UI. Planning your data isn’t nearly half the fun. But, if you do it properly, spending the time to do it will save you double the trouble.</p><h4>Chaos From Organization</h4><p>If you think about it, someone starting without much experience and using MVC in iOS as their guide could end up with code that structured in any number of ways. There are very few constraints or even signposts for them to follow. The sign post that is clearly visible is generally held onto like a life raft. This is why so much beginner code ends up in the ViewController and in particular viewDidLoad. Without much else to reference, this becomes their organizing principle.</p><h4>An Open Canvas</h4><p>Beyond the implementation of the base UI classes, there are almost no decisions made for you you as a programmer. This open canvas is often the source of frustration when you start out, because at that stage you really want to know where you should go. But as you feel more comfortable having this free space opens up new possibilities, it is a great place to explore.</p><h4>MVC</h4><p>For this example we will be working with something close to plain vanilla MVC. In the past, I must admit that I’ve had an unnecessarily harsh opinion of the the standard MVC that iOS uses. Mainly this was due to my own impatience. Given a little time, and the proper implementation, MVC can work really well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*4_Fy-a0HhPp2_1qWi97KeA.gif" /></figure><p>While there are view models in the demo project, there’s nothing particularly fancy about the code, no RxSwift, no coordinators. For all intents and purposes it’s vanilla MVC, the tableview cell models are structured like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7e4507eb58b704a635343d277977a5b6/href">https://medium.com/media/7e4507eb58b704a635343d277977a5b6/href</a></iframe><h3>Data Flow</h3><p>Before we go any further I just want to clarify a term: data flow. When I refer to data flow in an application, I’m referring to how data is passed along through the application from the source to display and how that is structured. It encompasses everything from API response all the way to the data model and ultimately to the rendering of the data.</p><p>For the level of importance it has, it doesn’t get nearly the amount that it deserves. I’d be willing to bet that a lot of my own hangups when I first learning networking calls and started building more complex applications came from the fact that I didn’t really think through the path that my data would take through the application. Hopefully it’ll become more clear just how important it is go forward with the demo code.</p><h4>The Synchronizer</h4><p>The Synchronizer is a class bound protocol. When implemented it allows your controller to subscribe to object that is updating the data model. That way it can act accordingly. In the example that I’ve given. When the data model adds a new item, the controller is notified through its subscription with the Synchronizer. It can then synchronize the data and the view.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cab7b105b4fc6e02061723cac71792b1/href">https://medium.com/media/cab7b105b4fc6e02061723cac71792b1/href</a></iframe><h4>The Sync</h4><p>The Sync, maintains the connection between the controller and object that updates the data. The sync message is sent when you feel that your data has completed updating. This could be at the end of an API call or a CoreData fetch.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/725f1f578ecdc9bef17b7865274c679f/href">https://medium.com/media/725f1f578ecdc9bef17b7865274c679f/href</a></iframe><h4>Store</h4><p>The store coordinates the flow and holds the data. In base form it is just a protocol that defines certain characteristics. It becomes useful when you implement it for specific data and tasks.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d6e28cfcd864ca5fc6719fb1c8ba021a/href">https://medium.com/media/d6e28cfcd864ca5fc6719fb1c8ba021a/href</a></iframe><h4>ItemStore</h4><p>This class conforms to the Store protocol and is specialized to handle the applications main data model, which I’ve ceremoniously named Item. ItemStore implements the Store functionality plus some specialized code.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e0cdf8a466866cd344c5ebf6a6849306/href">https://medium.com/media/e0cdf8a466866cd344c5ebf6a6849306/href</a></iframe><h4>TableViewDataSource</h4><p>The TableViewDataSource in this implementation does double duty as a datasource and as a view model. It serves as the intermediary between the data and the view and the controller. If I had one reservation about this class, it is that it is starting edge close to the line of having multiple purposes. It might be better to separate out the interface between the data and the view modeling into separate classes. The goal is to create a clear separation between the model and the controller, and the view and model. In part two you may see this revised to create a clean separation.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f42b1e058e6f7a82e1f3920f8fd882e/href">https://medium.com/media/0f42b1e058e6f7a82e1f3920f8fd882e/href</a></iframe><h4>ViewController</h4><p>Finally, this would not be complete (nor would it run) without the ViewController. To the extent that we can keep logic out of this class is best. If you find that a lot of view logic is happening in the controller, or API logic, this is a good hint that encapsulation has broken down, and that other objects have not been fully implemented and that the classes are not following proper encapsulation. Within a reasonable degree, try to keep properties private. If for some reason you need to modify or access that property, create a method to facilitate that. If your ViewController can’t see that a property exists, it is much less likely to start performing logic with it.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/271b9f35eb97b130d2a9778d4e195338/href">https://medium.com/media/271b9f35eb97b130d2a9778d4e195338/href</a></iframe><h4>Database</h4><p>Finally, I’ll just append the data storage parts to the end. These are the components that handle the storage and retrieval of the data to the disk directly. They’ve been split into the reading and writing functionalities as protocols which are implemented in the database class.</p><p><strong>Writer</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3258f22faad80d251c4d07cbcfb47e8b/href">https://medium.com/media/3258f22faad80d251c4d07cbcfb47e8b/href</a></iframe><p><strong>Reader</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6fca0b43e6405b52a396489b8424f233/href">https://medium.com/media/6fca0b43e6405b52a396489b8424f233/href</a></iframe><p><strong>Database:</strong></p><p>In the database class we bring both the DataWriter and DataReader protocols together in an implementation using generic T that conforms to Codeable</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c1c8a611842243d238c367229b15a7dc/href">https://medium.com/media/c1c8a611842243d238c367229b15a7dc/href</a></iframe><p><strong>Resources</strong>:</p><ul><li><a href="https://medium.com/seyhunakyurek/unidirectional-data-flow-architecture-redux-in-swift-6fa2ed5c3c76">Unidirectional Data Flow Architecture (Redux) in Swift</a></li><li><a href="https://www.objc.io/blog/">Blog · objc.io</a></li><li><a href="https://blog.githawk.com/">GitHawk Blog</a></li><li><a href="https://www.cocoawithlove.com/">Cocoa with Love</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e171b8be423" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/application-data-flow-6e171b8be423">Application Data Flow: Part One</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploring ARKit: ARSCNPlaneGeometry]]></title>
            <link>https://medium.com/@chris.webb5249/exploring-arkit-f188eb7a0152?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/f188eb7a0152</guid>
            <category><![CDATA[arkit]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[augmented-reality]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Sun, 11 Feb 2018 20:58:06 GMT</pubDate>
            <atom:updated>2018-02-24T07:06:46.031Z</atom:updated>
            <content:encoded><![CDATA[<h4>Scanning The World</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/275/1*nZ1CuZO9-XB1LHY2S4DpIw.gif" /></figure><p>If you’ve heard, Apple’ recently released a major update to ARKit, which it has dubbed ARKit 1.5. While much of the focus has been on the new vertical plane detection capabilities, which had been a glaring omission from ARKit’s initial release, much less has been said about other new plane detection features. Lost in among all the excitement were some deeply powerful new features. It’s arguable that the coolest features in Apple’s ARKit release are the the ones that have barely been mentioned.</p><h3>So what were they?</h3><p>Tucked away, we’re some new property additions to ARPlaneAnchor. Take a moment to look these over. Before we were detecting the presence and location/dimensions of a surface, in ARKit 1.5 we are now getting the contours and the lay of the land.</p><p><strong>ARPlaneGeometry</strong> — A 3D mesh describing the shape of a detected plane in world-tracking AR sessions.</p><pre>This class provides the estimated general shape of a detected plane, in the form of a detailed 3D mesh appropriate for use with various rendering technologies or for exporting 3D assets. </pre><pre>Unlike the <a href="https://developer.apple.com/documentation/arkit/arplaneanchor?language=objc">ARPlaneAnchor</a> <a href="https://developer.apple.com/documentation/arkit/arplaneanchor/2882056-center?language=objc">center</a> and <a href="https://developer.apple.com/documentation/arkit/arplaneanchor/2882055-extent?language=objc">extent</a> properties, which estimate only a rectangular area for a detected plane, a plane anchor&#39;s <a href="https://developer.apple.com/documentation/arkit/arplaneanchor/2941025-geometry?language=objc">geometry</a> property provides a more detailed estimate of the 2D area covered by that plane. For example, if ARKit detects a circular tabletop, the resulting ARPlaneGeometry objects roughly match the general shape of the table. As the session continues to run, ARKit provides updated plane anchors whose associated geometry refines the estimated shape of the plane.</pre><pre>You can use this model to more precisely place 3D content that should appear only on a detected flat surface — for example, to ensure that virtual objects don’t fall off the edge of a table. You can also use this model to create occlusion geometry, which hides other virtual content behind the detected surface in the camera image.</pre><pre>The shape of a plane geometry is always convex. (That is, the boundary polygon for a plane geometry is a minimal convex hull enclosing all points that ARKit recognizes or estimates are part of the plane.)</pre><p><strong>vertices-</strong>A buffer of vertex positions for each point in the plane mesh.</p><pre>Each float3 value in this buffer represents the position of a vertex in the mesh, in a coordinate system whose origin is defined by the owning plane anchor&#39;s transform matrix.</pre><pre>The vertexCount property provides the number of elements in the buffer.</pre><pre>This buffer, together with the triangleIndices buffer, describes a mesh covering the entire surface of the plane. Use this mesh for purposes that involve the filled shape, such as rendering a solid 3D representation of the surface. If instead you only need to know the outline of the shape, see the boundaryVertices property.</pre><p><strong>boundaryVertices — </strong>An array of vertex positions for each point along the plane’s boundary.</p><pre>Each <em>float3</em> value in this array represents the position of a vertex along the boundary polygon of the estimated plane, in a coordinate system whose origin is defined by the owning plane anchor&#39;s <a href="https://developer.apple.com/documentation/arkit/aranchor/2867981-transform">transform</a> matrix.</pre><pre>This array defines the boundary polygon of the plane. Use it for purposes that require only that polygon&#39;s definition, such as rendering an outline of the plane&#39;s estimated shape or testing whether a point is inside the bounded region. If instead you need the filled shape (for example, to render a solid 3D representation of the surface), see the <a href="https://developer.apple.com/documentation/arkit/arplanegeometry/2949170-vertices">vertices</a> property.</pre><p><strong>textureCoordinates — </strong>A buffer of texture coordinate values for each point in the plane mesh.</p><pre>Each <em>float2</em> value in this buffer represents the UV texture coordinates for the vertex at the corresponding index in the <a href="https://developer.apple.com/documentation/arkit/arplanegeometry/2941050-vertices?language=objc">vertices</a> buffer.</pre><p><strong>ARSCNPlaneGeometry — </strong>A SceneKit representation of the 2D shape of a plane, for use with plane detection results in an AR session.</p><pre>This class is a subclass of <a href="https://developer.apple.com/documentation/scenekit/scngeometry?language=objc">SCNGeometry</a> that wraps the mesh data provided by the <a href="https://developer.apple.com/documentation/arkit/arplanegeometry?language=objc">ARPlaneGeometry</a> class. You can use ARSCNPlaneGeometry to quickly and easily visualize the plane shape estimates provided by ARKit in a SceneKit view.</pre><pre>As your AR session continues to run, ARKit provides refined estimates of a detected plane&#39;s 2D shape. Use the <a href="https://developer.apple.com/documentation/arkit/arscnplanegeometry/2941057-updatefromplanegeometry?language=objc">updateFromPlaneGeometry:</a> method to incorporate those refinements into the plane&#39;s SceneKit representation.</pre><p>It’s a rudimentary 3D scanner, albeit with less accuracy than you would expect from one with laser sensors. <br>Regardless, this is huge. For years people have talked about this moment when people could quickly and conveniently create a 3D scan from their environment, and the possibilities that could bring. Well now we’re here (albeit with some caveats)</p><p>To begin with, we were already headed here, with or without the latest update to plane geometry. Apple’s has reportedly been looking to add back facing 3D cameras to its next iPhone models to enhance augmented reality, so this is just a preview of what we are likely to see this summer. It’s also not exactly the smoothest user experience and to get objects fully detected would be time-consuming. But, it looks like there is a lot to look forward to this summer! If I had to guess, Apple might be rolling out usable surface detection for all types of surfaces/shapes. Let’s hope that 2018 sees the end of all occlusion dilemmas in ARKit as well!</p><h3>Setup</h3><pre>import UIKit<br>import SceneKit<br>import ARKit</pre><pre>class ViewController: UIViewController {<br>    <br>    <a href="http://twitter.com/IBOutlet">@IBOutlet</a> var sceneView: ARSCNView!<br>    <br>    private var planeId: Int = 0<br>    <br>    let standardConfiguration: ARWorldTrackingConfiguration = {<br>        let configuration = ARWorldTrackingConfiguration()<br>        configuration.planeDetection = [.horizontal, .vertical]<br>        configuration.isLightEstimationEnabled = true<br>        return configuration<br>    }()<br>    <br>    override func viewDidLoad() {<br>        super.viewDidLoad()<br>    }<br>    <br>    func runSession() {<br>        sceneView.delegate = self<br>        sceneView.session.run(standardConfiguration)<br>        #if DEBUG<br>        sceneView.showsStatistics = true<br>        sceneView.debugOptions = [<br>            ARSCNDebugOptions.showFeaturePoints,<br>            ARSCNDebugOptions.showWorldOrigin<br>        ]<br>        #endif<br>    }<br>    <br>    override func viewWillAppear(_ animated: Bool) {<br>        super.viewWillAppear(animated)<br>        runSession()<br>    }<br>}</pre><h3>SCNNode Extension</h3><pre>extension SCNNode {<br>    <br>    static func createPlaneNode(planeAnchor: ARPlaneAnchor, id: Int) -&gt; SCNNode {<br>        let scenePlaneGeometry = ARSCNPlaneGeometry(device: MTLCreateSystemDefaultDevice()!)<br>        scenePlaneGeometry?.update(from: planeAnchor.geometry)<br>        let planeNode = SCNNode(geometry: scenePlaneGeometry)<br>        planeNode.name = &quot;\(id)&quot;<br>        switch planeAnchor.alignment {<br>        case .horizontal:<br>            planeNode.geometry?.firstMaterial?.diffuse.contents = UIColor.blue.withAlphaComponent(0.3)<br>        case .vertical:<br>            planeNode.geometry?.firstMaterial?.diffuse.contents = UIColor.cyan.withAlphaComponent(0.5)<br>            <br>        }<br>        return planeNode<br>    }<br>    <br>}</pre><h3>ARSCNViewDelegate</h3><pre>// MARK: - ARSCNViewDelegate</pre><pre>extension ViewController: ARSCNViewDelegate {</pre><pre>func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {<br>        guard let planeAnchor = anchor as? ARPlaneAnchor else { return }<br>        let planeNode = SCNNode.createPlaneNode(planeAnchor: planeAnchor, id: planeId)<br>        planeId += 1<br>        node.addChildNode(planeNode)<br>    }<br>    <br>    func renderer(_ renderer: SCNSceneRenderer, didUpdate node: SCNNode, for anchor: ARAnchor) {<br>        guard let planeAnchor = anchor as? ARPlaneAnchor else { return }<br>        node.enumerateChildNodes { child, _ in<br>            child.removeFromParentNode()<br>        }<br>        let planeNode = SCNNode.createPlaneNode(planeAnchor: planeAnchor, id: planeId)<br>        planeId += 1<br>        node.addChildNode(planeNode)<br>    }<br>    <br>    func renderer(_ renderer: SCNSceneRenderer, didRemove node: SCNNode, for anchor: ARAnchor) {<br>        guard let _ = anchor as? ARPlaneAnchor else { return }<br>        node.enumerateChildNodes { child, _ in<br>            child.removeFromParentNode()<br>        }<br>    }<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f188eb7a0152" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Structures]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/data-structures-35b968bcedf5?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/35b968bcedf5</guid>
            <category><![CDATA[swift-4]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Tue, 30 Jan 2018 18:47:49 GMT</pubDate>
            <atom:updated>2018-01-31T10:38:36.257Z</atom:updated>
            <content:encoded><![CDATA[<h4>Stacks and Queues</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5kJdbFLjHufBfHlI5b84PA.png" /></figure><h3>Stack</h3><p>A stack is a Last In First Out data structure. Imagine an immense stack of bricks. You’ve been tasked with taking these bricks and placing them in boxes for shipping. So, looking at this vast stack, do we start pulling bricks from the bottom of the stack or do we take them off the top? Common sense would dictate that we start from the top, and not begin a 10,000 lb game of Jenga. That’s a lot like how stacks work here. The last element placed in the LIFO data structure is the first element that is retrieved from.</p><p>While a stack may superficially resemble an array, the ordering of the elements underpins the functionality. Therefore, when you create a stack, it is essential that you restrict how elements within it are accessed.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c4568bf07470253ca31b0c75dd90f405/href">https://medium.com/media/c4568bf07470253ca31b0c75dd90f405/href</a></iframe><pre><strong>var stack = Stack&lt;String&gt;()</strong></pre><pre><strong>stack.push(element: &quot;one&quot;)</strong></pre><pre><strong>print(stack.count) </strong><em>// 1</em></pre><pre><strong>stack.push(element: &quot;two&quot;)</strong></pre><pre><strong>print(stack.count) </strong><em>// 2</em></pre><pre><strong>stack.push(element: &quot;three&quot;)</strong></pre><pre><strong>print(stack.count)</strong> <em>// 3</em></pre><pre><strong>stack.push(element: &quot;four&quot;)</strong></pre><pre><strong>print(stack.count) </strong><em>// 4</em></pre><pre><strong>stack.isEmpty() </strong><em>// False</em></pre><pre><strong>print(stack.pop())</strong> <em>// Optional(&quot;four&quot;</em>)</pre><pre><strong>print(stack.pop()) </strong><em>// Optional(&quot;three&quot;)</em></pre><pre><strong>print(stack.pop()) </strong><em>// Optional(&quot;two&quot;)</em></pre><pre>p<strong>rint(stack.pop()) </strong><em>// Optional(&quot;one&quot;)</em></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vEGC4lvFYZd1wkABzTqqWg.png" /></figure><h3>Queue</h3><p>A queue is a First In First Out list data structure. A First In First Out data structure means elements can only be inserted in the back and dequeued at the front. A queue can best be represented in the real world by a line to purchase movies tickets. In a ticket line, the first person who gets in line gets to buy their tickets first, and everyone in the line buys their tickets in the order that they joined the line. Like with Stacks, the ordering of data removal from a queue is critical to it functioning correctly, so ensuring that access to the queue data is appropriately managed is vital.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fc1a9e36bc81bb0e26d58b0d0c9a0020/href">https://medium.com/media/fc1a9e36bc81bb0e26d58b0d0c9a0020/href</a></iframe><pre><strong>var queue = Queue&lt;String&gt;()</strong></pre><pre><strong>queue.isEmpty </strong>// true</pre><pre><strong>queue.push(value: &quot;one&quot;)</strong></pre><pre><strong>print(queue.count) </strong>// 1</pre><pre><strong>queue.push(value: &quot;two&quot;)</strong></pre><pre><strong>print(queue.count) </strong>// 2</pre><pre><strong>queue.push(value: &quot;three&quot;)</strong></pre><pre><strong>print(queue.count) </strong>// 3</pre><pre><strong>queue.push(value: &quot;four&quot;)</strong></pre><pre><strong>print(queue.count) </strong>// 4</pre><pre><strong>queue.isEmpty </strong>// false</pre><pre><strong>print(queue.pop()) </strong>// one</pre><pre><strong>print(queue.pop()) </strong>// two</pre><pre><strong>print(queue.pop()) </strong>// three</pre><pre><strong>print(queue.pop()) </strong>// four</pre><h3>Practical Use For Stacks And Queues</h3><p>Stacks and queues can be used as temporary data structures in situations where the order of a list needs to be preserved or the order in which items where added or removed is important.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35b968bcedf5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/data-structures-35b968bcedf5">Data Structures</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ARKit Airport]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/arkit-airport-navigation-in-augmented-reality-part-one-c99d2ad326c0?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/c99d2ad326c0</guid>
            <category><![CDATA[arkit]]></category>
            <category><![CDATA[augmented-reality]]></category>
            <category><![CDATA[virtual-reality]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[ios-11]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Sun, 15 Oct 2017 10:28:53 GMT</pubDate>
            <atom:updated>2018-01-30T21:39:04.652Z</atom:updated>
            <content:encoded><![CDATA[<h4>Navigation In Augmented Reality: Part One</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*_B7gK-eAI6w3pIF77w4Z6g.gif" /></figure><pre><a href="https://github.com/chriswebb09/ARKitAirport"><strong>Demo Code</strong></a></pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*C-20R3T0Vt9qY73ZtXxmXg.gif" /></figure><p>So this past week I started on a new project. I’m trying to combine several concepts that I’ve been playing around with in ARKit into one project. I also found an awesome Spitfire model, which I’ve been having a lot of fun using. So in my previous two posts on ARKit, I touched on navigating in ARKit and manipulating virtual aircraft using ARKit/SceneKit. Let’s combine those two and see if we can build something cool. By the end of this project, we will have an AR app where we can:</p><p>- Tap a location on a map.<br>- Build a tiny AR airport from which a small AR plane will take off.<br>- It will fly to the location you picked.<br>- At that location, a little AR airport will be built.<br>- Our plane will then land there.</p><p>Doesn’t that sound exciting? Let’s get started!</p><h3>Before We Get Started</h3><p>I want to add some caveats here, or at the very least some observations I had while working with ARKit during this project. To begin with, while there probably are more efficient ways to go about this, my first iteration on this concept taxes the phones resources heavily. If you think about it, you’re doing using geolocation services, as well as using MapKit’s navigation API, along with the camera. Also, don’t forget the graphics rendering engine in SceneKit. It all starts to add up. The concept still works, and there are ways to optimize performance that I haven’t explored yet, but by taxing the system this heavily, it’s likely to start throwing weird results. This is particularly true in regards to how it renders virtual objects in the real world, i.e., your objects will drift from where they are supposed to be. All that being said, it’s pretty cool to be able to tap on a map and make something that only exists virtually fly to that location.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*Om1TzwuQK8v-bsP8R3hRMw.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*DDCWzmtkdGqDDdwWRl36wA.gif" /><figcaption>Coordinates are for 7-Eleven, but the plane ends up in Chase.</figcaption></figure><p>One other thing, when dealing with locations, in ARKit, be prepared for deviations. The iPhone’s geolocation systems don’t have the precision necessary, particularly in a large city like New York, to give the same location every time. Most of the time, the location will be within a reasonable range of your destination, occasionally, for whatever reason, it’ll appear wildly off target. Most of the time, the deviation will be like above. It’s not too bad, but if you’re trying to find a small AR plane, even minor changes can make that challenge more annoying and close to impossible.</p><h3>Gathering Our Materials</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*_B7gK-eAI6w3pIF77w4Z6g.gif" /></figure><p>To build the project, it required some assembly and not all of the pieces were included in the box. For one, we need the 3D model for our aircraft and another one for the airport. Just as a spoiler alert, they aren’t exactly ready for use straight out of the box either. I had to use the 3D graphics tool Blender to get the models setup in the way that worked well for the project. At this point I don’t want to focus my this on Blender, that’s a series for another time.</p><p><a href="https://www.dropbox.com/s/03orw33p6z33iam/RAFSpitfire.dae?dl=0">Download Plane Model</a></p><p><a href="https://www.dropbox.com/s/c3cca2jvi5uyxcn/textures-plane.zip">Download Plane Textures</a></p><p>If you’re interested, there are many resources out there for 3D image editing with Blender. For now, I’m going to provide a link to the finished model files. If you’re not jazzed about using a Spitfire, feel free to pick some other model. You can use any 3D model that you want, even a helicopter or a spaceship. You could also choose a helipad or spaceport. <a href="https://www.blender.org/">https://www.blender.org</a></p><h3>Subclassing ARSCNView</h3><p>To start off let’s subclass ARSCNView. That way we can manipulate our 3D models within it, without cluttering up our view controller. We can also give it a lot of SCNNode properties which will hook into various parts of the models and allow us to manipulate them and bring them to life.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1d99ebb264d82a61f98c84144b9224bf/href">https://medium.com/media/1d99ebb264d82a61f98c84144b9224bf/href</a></iframe><p>The most complicated object we’re working with will be our plane model, so let’s separate that into its own setup function.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4bb456547c67258c2224baa5f2f157e8/href">https://medium.com/media/4bb456547c67258c2224baa5f2f157e8/href</a></iframe><h4>Start Engine</h4><p>We’ll also add a little cosmetic method called start engine which will get the propeller on our plane to spin. This looks like it is doing something, but it’s not doing much.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/21d9a51a7b7377a67aaa3a2015fa28a6/href">https://medium.com/media/21d9a51a7b7377a67aaa3a2015fa28a6/href</a></iframe><p>Sometimes it’s necessary to coax each aspect of the model into position individually. This mainly happens I’ve noticed when the designer who initially creates them, model, doesn’t put a lot of thought into a placing the pieces within a logical hierarchy whose top piece can control the rest of the structure.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d686649f9080d7808aed78da6173516e/href">https://medium.com/media/d686649f9080d7808aed78da6173516e/href</a></iframe><h4>Break It Down To Smaller Pieces</h4><p>Now would be a good time to review what we actually want to happen throughout our application.</p><ul><li>Launch</li><li>Tap Map For Destination</li><li>Detect Plane Horizontal Plane</li><li>Place Airport Model Node On Plane</li><li>Place Airplane On Runway</li><li>When User Taps Screen, Airplane Accelerates/Takes Off</li><li>Airplane Orients Itself Towards Coordinates Of Location On Map</li><li>Airplane Flys To Location</li><li>When User Is In Range Of Airplane And Destination — DetectHorizontal Plane</li><li>Place Airport Model Node On Plane</li><li>Airplane Lands On Runway And Breaks</li></ul><p>Let’s wrap it up there. In part two, we’ll dive into place detection, have the mechanics of our plane taking off. Most of the sample code has been finished and is up on Github so feel free to jump ahead!</p><p>Sources:</p><p><a href="https://free3d.com/3d-model/uk-ww-2-spitfire-mk-1-64128.html">UK WW 2 Spitfire MK 1 - 3d model - .3ds, .obj, .dae, .max, .c4d, .tga, .sldprt</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c99d2ad326c0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/arkit-airport-navigation-in-augmented-reality-part-one-c99d2ad326c0">ARKit Airport</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ARKit: Opportunities And Challenges]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/arkit-opportunities-and-challenges-7337d602d43c?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/7337d602d43c</guid>
            <category><![CDATA[arkit]]></category>
            <category><![CDATA[ios-11]]></category>
            <category><![CDATA[augmented-reality]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Wed, 11 Oct 2017 05:11:09 GMT</pubDate>
            <atom:updated>2017-10-12T03:58:56.204Z</atom:updated>
            <content:encoded><![CDATA[<h4>Limitations and Potential</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*C-20R3T0Vt9qY73ZtXxmXg.gif" /><figcaption>Spitfire</figcaption></figure><h3>Meet ARKit</h3><p>The introduction of easy to implement augmented reality through the ARKit API is one of most exciting additions to the iOS toolkit that I’ve seen in awhile. Ever since ARKit was announced at WWDC in June, it has been the subject of fierce debate and speculation. For detractors, at worst, ARKit is a gimmick. A gimmick that won’t pan out or stand the test of time. At best it is still not ready for prime time. From my perspective, after having worked with ARKit for the last few months, the technology is at interesting crossroads, where its future power and potential are self-evident, while at the same time its current challenges and limitations remain very real.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*BYA4CMvCvjd-AcF-u-Z3Kg.gif" /></figure><p>ARKit isn’t a gimmick because augmented reality isn’t a gimmick. As I’ve said before, PokemonGO proved that when it comes to setting, nothing beats our world. Augmented reality is a new medium, and ARKit is just first easy to use tool to promote mass adoption. Like anything new, there are still areas that remain undefined and unrefined, but these will get filled out as well as sanded down as the technology matures. Despite some very real limitations, ARKit has some really awesome applications for the world as it is now and these will only grow over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*bV-Ea_mv0VCf0ycyNCEUXQ.gif" /></figure><h3>Challenges</h3><pre><strong>Battery - </strong>First issue ARKit needs to overcome is that it eats battery. ARKit doesn’t just eat your battery life. It feasts on it. Take the draining capacity of the camera and marry that with the graphics rendering engine of your choice (be it SpriteKit, SceneKit or Metal), sprinkle in some CoreLocation, MapKit or Vision framework, and you’ll drain your battery like a vampire. With rapid and wireless charging and larger battery capacity plus more efficient systems, this will be less of a problem over time, but for now, it’s something to think about.</pre><pre><strong>Plane Detection - </strong>While ARKit’s machine vision alchemy can detect horizontal planes currently, it cannot detect vertical ones. It seems likely that’s something that will be added in the future. For now, without implementing a homebrew solution, you’re stuck playing with the floor. At the same time, it’s easy to see why they left it out. ARKit has a decent amount of trouble detecting horizontal planes, particularly doing so in a timely fashion.</pre><pre><strong>Consistent Positioning - </strong>Even when using the default SceneKit spaceship app that Apple provides, you’ll occasionally notice that the ship will suddenly shift oddly from time to time without you moving. By and large, Apple has done an amazingly good job on calibrating the software and hardware together to create a great augmented reality platform, however occasionally the ARKit engine loses track of the object&#39;s position and it drifts.</pre><h3>The Upshot</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/281/1*K_3U9t-7Riw14Yfy765jdQ.gif" /></figure><p>The good news is these are all eminently solvable issues, and solvable in the very near term. Ever increasing battery capacity (and more energy efficient phones) as well as wireless charging already give us a glimpse of an era where we are untethered from our charging cords. With all of Apple’s technical skills and money pouring into building new homegrown GPU’s we’re likely to see serious upgrades in mobile processing power that will solve issues like plane detection and positioning. Ultimately, none of these issues are large enough of a handicap to keep developers from building projects right now. They are things to keep in mind, but definitely don’t let it deter you from building something cool!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7337d602d43c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/arkit-opportunities-and-challenges-7337d602d43c">ARKit: Opportunities And Challenges</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ARKit Adventures]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/aarkit-adventures-697dfbe7779e?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/697dfbe7779e</guid>
            <category><![CDATA[3d-modeling]]></category>
            <category><![CDATA[swift-4]]></category>
            <category><![CDATA[arkit]]></category>
            <category><![CDATA[drones]]></category>
            <category><![CDATA[augmented-reality]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Sat, 07 Oct 2017 12:16:41 GMT</pubDate>
            <atom:updated>2018-08-07T12:39:46.400Z</atom:updated>
            <content:encoded><![CDATA[<h4>Making A Remote Control Drone</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*LpNpWVlYHaa00I_66QAfAg.gif" /></figure><pre><a href="https://github.com/chriswebb09/ARKitDrone"><strong>Demo Code</strong></a></pre><p>In the last few posts on ARKit, most of the content we placed was pretty static. For this example, I want to switch gears and make something in ARKit that is a bit more interactive.</p><h4><strong>Send in the drones!</strong></h4><p>If you’ve ever wanted to play around with a remote-controlled drone but have never had the opportunity to do so, this tutorial is for you. I know the controls look a bit stupid at the moment, but the point of this post isn’t to create a genuinely impressive interface, it’s to get you started down the road where you’re interacting with the augmented world.</p><h3>Getting Started</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zCcFVio1j-FzFhXGzVUPfA.jpeg" /></figure><p>Given the complexity presented to us in rendering a drone, the best place for us to start would be by finding a good 3D drone model to use. I’ve found that COLLADA files are the easiest for interfacing with Apple’s SceneKit and are the easiest file type to convert to .scn files. COLLADA files use the file extension .dae and can be viewed in Apple’s preview application.</p><blockquote>A file with the DAE <a href="https://www.lifewire.com/what-is-a-file-extension-2625879">file extension</a> is a Digital Asset Exchange file. As the name implies, it’s used by various graphics programs to exchange digital assets under the same format. They may be images, textures, 3D models, etc. — <a href="https://www.lifewire.com/dae-file-2620544">Source</a></blockquote><p>For this example, we’re going to be using a 3D model of a drone that found on <a href="http://free3d.com/">free3d.com</a>. If you’re wary of signing up, you can download the .dae file from the link I will post below, or alternatively, you can you can get the file that I’ve converted to .scn in the finished project files.</p><p>Here is a link to the .dae file:</p><p><a href="https://www.dropbox.com/s/ba7c2ha18cy6uwa/Drone_dae.dae">DropBox</a></p><h4>Converting From .dae To .scn</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tIRXN3MaY3uRsCrFFrAOgA.png" /></figure><p>While SceneKit can handle working with .dae files just fine, for simplicity, we’ll just go ahead and convert it to a .scn file. There might be a better way to do this, I stumbled across this feature while playing around with SceneKit’s settings. To convert to a .scn file, select the .dae file, and in the inspector, on the right side of the screen, there should be a tab for the physics inspector like below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/516/1*t0v0USS2M_rf2JsgiIg1OQ.png" /></figure><p>Once you select a physics body, XCode should pop up a prompt asking you whether you want to convert the document to SCN format.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/904/1*LPVrqLe7dR2vuQ2b9dbkFw.png" /></figure><h3>DroneSceneView</h3><p>Now that we have our model we can start coding our drone. I want to start off by creating a subclass of ARSCNView called DroneSceneView. In this view, we’ll try to encapsulate the behaviors and properties of our drone. We’ll use the controller to connect these behaviors to the UI.</p><h4>Setup</h4><p>We should give our DroneSceneView five properties which will be of type SCNNodes. The helicopterNode gives us a hook into the main body of the drone, the blade1 and blade2 nodes hook us into the the framework surrounding the drones left or right rotors and the rotorR and rotorL nodes hooks into the blade themselves.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9f93c3cccbff774989fe744f5b69841b/href">https://medium.com/media/9f93c3cccbff774989fe744f5b69841b/href</a></iframe><p>The first method we should create will be the overall setup method which I called setupDrone. In setupDrone, we should assign the appropriate parts of our drone model to these nodes. The names passed to the method childNode(withName:, recursively:) match up with the names in our model’s scene graph.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cS13I5c9A8WTbjp_QLD5Ng.png" /></figure><h4>Style</h4><p>Next we’ll add a bit of styling to our drone. This part isn’t hugely important but it can help make it seem more realistic, which is generally a key aspect of augmented reality and it gives you a better visual sense of the different parts.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f1c769dfa9aff328a28afbe1737e5395/href">https://medium.com/media/f1c769dfa9aff328a28afbe1737e5395/href</a></iframe><h4>SpinBlades</h4><p>Because we want our drone to look like the real thing, we’ll need to animate the rotors to rotate. To simplify things, I’m setting it so that the drones rotors are going constantly. To do this need to access the blades themselves, and manipulate them along their z-axis.</p><pre>let rotate = SCNAction.rotateBy(x: 0, y: 0, z: 200, duration: 0.5)</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7a6abacf5b0c9b25f1901456ffdbaaf9/href">https://medium.com/media/7a6abacf5b0c9b25f1901456ffdbaaf9/href</a></iframe><p>The drones rotators will now spin, but it doesn’t actually make any difference in terms of motion.</p><h3>Controls</h3><p>The spinning blades are purely cosmetic. Let’s actually make it do something. To create an animation sequence we’re going to call SCNTransaction.begin</p><pre><strong>SCNTransaction.begin()</strong><br><strong>SCNTransaction.animationDuration = 0.5</strong></pre><pre>// Animation sequence</pre><pre><strong>SCNTransaction.commit()</strong></pre><h4>Lateral</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*4ijWIzcTOG3TjqXif7WStA.gif" /></figure><pre><strong>// Right<br>helicopterNode.position = SCNVector3(helicopterNode.position.x + 0.5, helicopterNode.position.y, helicopterNode.position.z)</strong></pre><pre><strong>// Left<br>helicopterNode.position = SCNVector3(helicopterNode.position.x - 0.5, helicopterNode.position.y, helicopterNode.position.z)</strong></pre><p>To make our drone move to left or right we’ll manipulate the x element in its position property. To move to the left we’ll subtract a float value of -0.5 from x and conversely to move to the right we’ll add a float value of 0.5 to x.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/df1b46fc6442165171d7c095e743f1bb/href">https://medium.com/media/df1b46fc6442165171d7c095e743f1bb/href</a></iframe><h4>Forward/Back</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*9N2crnX-5jfzyIKzPFurww.gif" /></figure><pre><strong>// Forward <br>helicopterNode.position = SCNVector3(helicopterNode.position.x, helicopterNode.position.y, helicopterNode.position.z - 0.5)</strong></pre><pre><strong>// Backward <br>helicopterNode.position = SCNVector3(helicopterNode.position.x, helicopterNode.position.y, helicopterNode.position.z + 0.5)</strong></pre><p>To make our drone move forward or backward we’ll manipulate the z element in its position property. To move to the left we’ll subtract a float value of -0.5 from z and conversely to move to the right we’ll add a float value of 0.5 to z.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/330988f0f780ff105d53852b84f894c6/href">https://medium.com/media/330988f0f780ff105d53852b84f894c6/href</a></iframe><h4>Altitude</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*AuCC5cLuwIZ9QvHeWjXu0A.gif" /></figure><pre><strong>helicopterNode.position = SCNVector3(helicopterNode.position.x, value, helicopterNode.position.z)</strong></pre><p>To make our drone move up or down we’ll manipulate the y element in its position property. By add a flow value to the drones y position property value the drone will move up, if you subtract a float value from the drones y position property value it will descend.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9515a935cdfde05d81259e91828d069/href">https://medium.com/media/b9515a935cdfde05d81259e91828d069/href</a></iframe><h4>Special Effects</h4><p>These animations are mainly for decoration. They tilt the drone when it moves and then resets it to normal resting position. This is more an experiment of mine to try to make the flight look as natural as possible.</p><pre><strong>blade2Node.runAction(SCNAction.rotateBy(x: 0.3, y: 0, z: 0, duration: 1.5)) <br>blade1Node.runAction(SCNAction.rotateBy(x: 0.3, y: 0, z: 0, duration: 1.5)) <br>SCNTransaction.commit() <br>blade2Node.runAction(SCNAction.rotateBy(x: -0.3, y: 0, z: 0, duration: 0.25)) <br>blade1Node.runAction(SCNAction.rotateBy(x: -0.3, y: 0, z: 0, duration: 0.25))</strong></pre><h3>Controls UI</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/472/1*w2eZTn7WbzunABoy7iRmAw.png" /></figure><p>As you can tell from the picture, I’ve constructed rudmentary UI to get us going. It’s basically some arrows and a slider. We’ll use the slider to control our altitude and the arrows to control the direction that our drone moves in.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f4f3c72f2ce086311e0c5897140cca9/href">https://medium.com/media/1f4f3c72f2ce086311e0c5897140cca9/href</a></iframe><h4>Sources:</h4><ul><li><a href="https://3dhaupt.com/">3DHaupt</a></li><li><a href="https://free3d.com/3d-model/controllable-drone-blender-game-engine-67381.html">Controllable Drone - Blender Game Engine - 3d model - .3ds, .obj, .dae, .blend, .fbx, .mtl, .dxf, .stl</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=697dfbe7779e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/aarkit-adventures-697dfbe7779e">ARKit Adventures</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C++ Virtual Functions]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/c-virtual-functions-445bb2c0cf1b?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/445bb2c0cf1b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[cplusplus]]></category>
            <category><![CDATA[object-oriented]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Tue, 26 Sep 2017 10:06:27 GMT</pubDate>
            <atom:updated>2017-10-02T20:18:40.313Z</atom:updated>
            <content:encoded><![CDATA[<h4>Runtime vs. compile time polymorphism</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*AtZsuD4fJNI1adoNh53Hbg.png" /></figure><p>Like all object-oriented languages, C++ has features designed to facilitate polymorphism. In C++ there’s the added capability to specify whether polymorphism is defined at runtime or at compile time. Although this may seem like semantics, the differences can lead to completely different outcomes and functionality.</p><h3>Quick Definition: Polymorphism</h3><p>The word polymorphism means to appear in many form. If you look it up in relation to object-oriented programming, it seems that everyone insists on using their own definition. Ultimately, even if the wording is different, all the definitions revolve around the ability to subclass objects and to pass along traits and behaviors through inheritance. This sort of definition can be too abstract to be of much use, so in this article, I’m going to dive into polymorphism and runtime vs. compile time polymorphism in C++.</p><h4>Inheritance</h4><p>Before we go any further, let’s touch on inheritance. Inheritance is when a subclass gains behaviors and data of the superclass or parent class from which it is inheriting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/176/1*BEUvqTx-LxuzuMeRkM1X-g.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*vllIwCgsDnYAb88iYfprKA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*qNQul8lPtcybSlVDyVdlGQ.jpeg" /></figure><p><strong>Phone</strong></p><p>Think of a phone for just one minute. A phone has a fundamental property, which is the phone number. It also has some fundemental behaviors, which is that it can make and receive calls.</p><p><strong>Cell Phone</strong></p><p>Now let’s think of a derivative, or subclass of a phone. That’s relatively easy, a cell phone. A cell phone still has the fundamental characteristics of a phone, that is it still has a phone number, and it can still make and receive calls. A cell phone is a phone but with some added behaviors like roaming and texting.</p><p><strong>Computer</strong></p><p>Now let’s get a bit more tricky. Let’s think of the characteristic of a computer to browse the web. This computer has a property that is fundemental which is the IP Address (Internet Protocol). It also has a piece of software called a web browser. Finally there is the intrinsic behavior you get when you combine them called “browsing the web”.</p><p>But can we think of anything that inherits characteristics of both a phone and a computer?</p><p><strong>iPhone</strong></p><p>The iPhone! The iPhone doesn’t fit exclusively into either category. Instead it it has the characteristics of both. Therefore an iPhone inherits both from a cell phone and from a computer (and cell phone inherits from phone.)</p><h4>Can I Borrow Your Phone For Sec?</h4><p>What if we had a function called borrow phone, whose only parameter is to accept a phone object. This function uses the passed in phones call function. Could we give it a cell phone? We sure could! We could even give it an iPhone or even an old-timey rotary phone. All this function wants is some object that is a phone. Now, what if we had a function took in a computer and used that computer to surf the web? Could this function take in a phone? Nope! Could it take in a cell phone? Nope! Could it take in an iPhone? It sure could! Now here’s the tricky part, could it use that iPhone to make a call? The answer to this is a bit more complicated, let’s just leave the answer for now as no.</p><h3>Animals In The Zoo</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B-xcwjub5-ZL97fQgLGiNg.jpeg" /></figure><p>To begin with, let’s start with a simple example of polymorphism. We’re going to build a wolf! To get started, let’s create our base class, which will be the class from which everything else inherits from, we’ll call it Animal.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1581d7fc2dda316c22c867ec1cd5bf1d/href">https://medium.com/media/1581d7fc2dda316c22c867ec1cd5bf1d/href</a></iframe><p>Now we’ll create a subclass of animal, called Canine (since wolves are canines). When we do that, let’s also call our superclass Animal in our initializer, we can do that with :</p><p><strong>Canine():Animal()</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4bf92b859897471fda6a9d088f3e02a8/href">https://medium.com/media/4bf92b859897471fda6a9d088f3e02a8/href</a></iframe><p>Now let’s create another subclass of animal called Carnivore, and again, we’ll call our super classes default method before adding our functionality.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c211e3750052d4f25c9b253922291a07/href">https://medium.com/media/c211e3750052d4f25c9b253922291a07/href</a></iframe><p>Finally let’s make our Wolf!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d393c32928f05a7edfe1bb665fbad4ea/href">https://medium.com/media/d393c32928f05a7edfe1bb665fbad4ea/href</a></iframe><p>You might have noticed, that while Wolf calls Carnivore and Canine, it doesn’t call Animal. That’s because Carnivore and Canine already do that for us.</p><h4>Running Our Wolf</h4><p>In your main function instantiate a new Wolf object like so:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f13e651f35e3ae000bc3698dca5c9435/href">https://medium.com/media/f13e651f35e3ae000bc3698dca5c9435/href</a></iframe><p>When you run this, you should get something that looks like this.</p><p><em>Console output:</em></p><pre><strong>Animal</strong></pre><pre><strong>Canine</strong></pre><pre><strong>Carnivore</strong> </pre><pre><strong>Wolf</strong></pre><pre><strong>Program ended with exit code: 0</strong></pre><h3>Wait Just A Minute…</h3><p>Now you might be wondering why this small line:</p><pre>Wolf* pet_wolf = new Wolf();</pre><p>gave us four lines of output. Well that’s the inheritance in action! What we’re doing is calling the default implementation of the superclass all the way down the inheritance tree from Animal to Wolf.</p><p>This is the line where all the super class are being called:</p><pre><strong>Wolf():Carnivore(), Canine() { cout&lt;&lt; “Wolf” &lt;&lt; endl; }</strong></pre><p>Now, a good question to raise at this point would be: Is it always necessary to call the superclass? The short answer is no, and the longer answer is that you should do it most of the time unless you have a specific reason not to.</p><h3>Overriding Default Functionality</h3><p>One feature of subclasses is that they can override the default functionality from the superclass. This can be useful for tailoring our subclasses for specific situations. To see how that works, let’s do another example. We’re going to make our Wolf again, but this time he lives in a Zoo!</p><p>The Animal class is mostly the same, but we’ve added a string property called name, which gets set from a parameter that is passed in during initialization. It also has a method called make_sound, which takes a string and outputs it to the console.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ff4d3b95770e1a9f5bec8e8999f2149/href">https://medium.com/media/2ff4d3b95770e1a9f5bec8e8999f2149/href</a></iframe><p>Our Canine and Carnivore classes are still unmodified.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9aa7922778da31b220fdd8e8c7a53d56/href">https://medium.com/media/9aa7922778da31b220fdd8e8c7a53d56/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/859861975bc2538c0235c1a9a0359744/href">https://medium.com/media/859861975bc2538c0235c1a9a0359744/href</a></iframe><p>Now let’s create our Wolf! This time our Wolf has two methods, howl and make_sound, which it inherits from the superclass.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/701154bc5de61d32d6c8c2c965c2a360/href">https://medium.com/media/701154bc5de61d32d6c8c2c965c2a360/href</a></iframe><p>And finally we need a zoo to house them!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/df26fc826062bfd6c4eb64e133e30c3e/href">https://medium.com/media/df26fc826062bfd6c4eb64e133e30c3e/href</a></iframe><p>In main, let’s instantiate our wolf, and give it a name. Then let’s put our wolf into our zoo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/55f19fd4a305f438e8f94dac941ec394/href">https://medium.com/media/55f19fd4a305f438e8f94dac941ec394/href</a></iframe><p>If we run this we should see something like this.</p><p><em>Console output:</em></p><pre><strong>wolf</strong></pre><pre><strong>Wolfy</strong></pre><pre><strong>NEW</strong></pre><pre><strong>Aroooo</strong></pre><pre><strong>Program ended with exit code: 0</strong></pre><h4>Compile time Polymorphism Vs. Runtime Polymorphism</h4><p>Interesting right? We’re overriding the functionality for our wolf for make_sound, but not when our wolf is placed in the zoo. So how do we make it so we can hear the wolf howl in the zoo? We can make our superclass’ make_sound function into a virtual function and override it in our subclass!</p><p>Let’s add the virtual modifier to our make_sound function:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cdbd2bde50ba9a9da6d89a4b2c525612/href">https://medium.com/media/cdbd2bde50ba9a9da6d89a4b2c525612/href</a></iframe><p>And we’ll add override below:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/149865398724161702ff0cf40ee35eb4/href">https://medium.com/media/149865398724161702ff0cf40ee35eb4/href</a></iframe><p>When you run your code you should see something like below.</p><p><em>Console output:</em></p><pre><strong>wolf</strong></pre><pre><strong>Wolfy</strong></pre><pre><strong>Aroooo</strong></pre><pre><strong>Aroooo</strong></pre><pre><strong>Program ended with exit code: 0</strong></pre><h3>So what happened?</h3><h4>Inlining and Virtualization</h4><p>In as simple an explanation as possible, we went from static dispatch to dynamic dispatch. In static dispatch, the compiler uses inlining which replaces a method/function call with the actual implementation. Essentially, it hardcodes. This can remove the computational overhead of the more dynamic method calls, but it comes at the expense of being less dynamic. It’s also a tradeoff between optimizing for space and optimizing for performance.</p><p>With static dispatch, the compiler does not virtualize. Without getting too sidetracked, virtualization is when your program figures out which implementation of the code it is going to use at runtime, instead of compile time. If that means absolutely nothing to you, don’t worry. I’m planning to write up some more on dispatching soon, so if you’re confused I’m going to come back to this. But for the purposes of this post, virtual keyword signals to the compiler that you want it to take into account runtime polymorphism instead of compile time polymorphism, which in practical terms, means you can change the underlying functionality depending on what get’s passed in at runtime.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=445bb2c0cf1b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/c-virtual-functions-445bb2c0cf1b">C++ Virtual Functions</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Diving Into Core Image - Part One]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/diving-into-core-image-part-one-39f83f0ceb2f?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/39f83f0ceb2f</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Wed, 20 Sep 2017 22:27:25 GMT</pubDate>
            <atom:updated>2017-09-26T06:13:06.273Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*5Rbr0GpAtOXdLUKJHhGNxw.gif" /><figcaption>Demo project</figcaption></figure><p><em>I already have most of the example project for this post done already. You can check it out here:</em></p><p><a href="https://github.com/chriswebb09/CoreCamera">chriswebb09/CoreCamera</a></p><h3>Introduction</h3><p>This post marks the beginning of a series of posts that I am going to write on Core Image. So why Core Image? Working with graphics at a low level can be messy. The lower down you go, the further you’re straying from UIKit and Cocoa. Luckily for developers, Apple provides an abstraction/interface for interacting with lower level graphics processes. Core Image is one of these abstractions, and it is a library you will run across frequently when coding in Apple’s ecosystem. From editing static images to using filters on live video content, Core Image is versatile enough to handle a variety of use cases.</p><p>Before we get started, I just want to warn you that Core Image relies heavily on KVO which can make exploring it somewhat confusing. This barrier pales in comparison to the awesomeness of the world you’ll be able to work with and manipulate so I hope you stick with it.</p><h3>Core Image Basics</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/846/1*yGxx9W3HB2tonxz4pH1TUg.png" /></figure><blockquote>Core Image is an image processing and analysis technology designed to provide near real-time processing for still and video images. It operates on image data types from the Core Graphics, Core Video, and Image I/O frameworks, using either a GPU or CPU rendering path. — <a href="https://developer.apple.com/library/content/documentation/GraphicsImaging/Conceptual/CoreImaging/ci_intro/ci_intro.html#//apple_ref/doc/uid/TP30001185-CH1-TPXREF101">Apple Docs</a></blockquote><h4>Definitions</h4><pre><strong>CIImage: </strong>is the image data format for working with image data in Core Image. It’s the recipe book/instructions for how to treat the image. CIFilters take CIImage as inputs and then passes them back out. Since CIImages get executed lazily, it’s not until they are put into a renderable format, that the recipe/instructions get followed.</pre><pre><strong>CIContext: </strong>is the evaluation context for graphics processing and analysis for Core Image processing with Quartz 2D, Metal, or OpenGL. CIContext is an immutable object that is thread-safe, but the CIFilter that are used with them are not.</pre><pre><strong>CIDetector: </strong>is the image process that notices and catalogs distinguishing features on an image. For a face that might be the eyes, ears, nose, etc. Or it could be a shape, like a box.</pre><pre><strong>Core Image Kernels: </strong>A Core Image Kernel is a small algorithm that is run on every single pixel. The Kernel uses the filter’s parameters and performs its algorithm based on that. Every filter gets wrapped around at least one kernel. The kernel is the functionality which is executed on every single pixel on the destination image. The kernel contains the processing algorithm that we run to generate our output image. The high volume of executions is the reason that GPU’s are designed the way that they are. Each execution might not seem like a lot, but in concert with all the pixels, being rendered simultaneously and it becomes clear we need something specialized to handle them.</pre><pre><strong>Warp Kernel: </strong>Warp kernels are designed for moving, deformation, translating images. If you’ve read the earlier series of posts that I wrote on ARKit, we used matrix transformations to place the nodes in 3D space. Warp kernels perform the operations on the pixels to accomplish these sorts of operation.</pre><pre><strong>Color Kernel: </strong>The color kernel is the kernel is responsible for working with color and only color. It receives an argument that is a component vector. These components are red, green, blue and alpha. If that sounds familiar, it’s because these values are often used with making custom colors using UIColor.</pre><h4>The Rendering Process</h4><pre><strong>Low Level</strong>: Low level processing tasks are computed by the Kernel and a kernel routine must return a vector (vec4) which contains the result of mapping the source pixel to a destination pixel.</pre><pre><strong>High Level</strong>: High level process task are executed with Objective-C. The further the code is from having a direct effect on the hardware, the higher it&#39;s abstraction is. i.e. Kernels perform operations per pixel which is pretty close to the hardware, while a CIContext has a broad responsibility for operations and data which is higher up the chain. </pre><h4>Filters</h4><pre><strong>CIFilter</strong> - A <em>custom filter</em> in CoreImage is a CIFilter for which you write a routine, called a <em>kernel</em>, that specifies the calculations to perform on each source image pixel.</pre><pre><strong>OpenGL Shader</strong> - If you’re not familiar with shaders, they are small programs that are executed on a per-vertex or per-pixel basis during drawing operations (there are also geometry shaders, which operate on geometric primitives, but they will not be covered in this tutorial).</pre><p>If the two definitions above look very similar, that’s because Apple uses a modified version of OpenGL shader language to create filters. In OpenGL, you’ll often find that textures are used to give a 3D object some substance. For instance, you can have a sphere, and then cover it with a metallic texture to make it seem like a metal ball. Apple calls textures filters and you use them with the CIFilter data type.</p><blockquote>In image processing a filter can be thought of as an algorithm which takes a number of inputs, including an image, and produces an output image. A filter is a wrapper around a kernel — which is the algorithm which is applied in turn to every single pixel in the image.</blockquote><h3>Hardware — GPU vs CPU Graphics Processing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*xCw85yKKNWF-7UJ1id_jSw.png" /></figure><p>GPU’s are in nowadays. Cryptocurrencies and machine learning use them, Apple is building them, but CPU’s still have their place. Let’s go over two scenarios which I think will shed light on the differences in core competencies between the CPU and GPU.</p><p><strong>Scenario One:</strong> Think the differences between Tesla and a 18 wheeler truck. If you wanted a vehicle with the latest electronics that could almost drive itself at 120 mph, the 18 wheeler wouldn’t be of much use. It could go, but it’s got an old diesel engine and it doesn’t go much faster than highway speed.</p><p><strong>Scenario Two</strong>: Now imagine you had to take all the boxcars off of a train and drive them to a wear house downtown. This is where the truck would beat the sports car hands down.</p><pre><strong>GPU: </strong>GPU’s were designed to do one thing very well, perform parallel processes on large sets of data. While a CPU has a few highly complex threaded cores, GPUs have many simple cores to perform many operations at the time. While each task is simple enough, it’s a the size of the data set being computed that necessitates the need for the GPU.</pre><pre><strong>CPU: </strong>While CPU’s are more than capable of handling their own when it comes to graphics processing (to some degree), they excel at executing complex logic and not in processing large data sets.</pre><h3>Other APIs</h3><blockquote>Core Image hides the details of low-level graphics processing by providing an easy-to-use application programming interface (API). You don’t need to know the details of OpenGL, OpenGL ES, or Metal to leverage the power of the GPU, nor do you need to know anything about Grand Central Dispatch (GCD) to get the benefit of multicore processing. Core Image handles the details for you. — <a href="https://developer.apple.com/library/content/documentation/GraphicsImaging/Conceptual/CoreImaging/ci_intro/ci_intro.html#//apple_ref/doc/uid/TP30001185-CH1-TPXREF101">Apple Docs</a></blockquote><h4>Definitions</h4><pre><strong>Metal: </strong>Apple has other graphics libraries as well. One of the coolest ones is Metal. Metal is a graphics rendering/parallel data computation engine. In practical terms, that means that it is fast. It provides you with a near-direct access to the GPU, and with the parallel computation, this allows Metal to go beyond the traditional realm of screen graphics and into the new frontiers of mobile machine learning.</pre><pre><strong>GLKit: </strong>Apple’s provides GLKit as a wrapper around the OpenGL library. GLKit makes it easy to access the functionality offered in OpenGL with having to stray too far out of the iOS programming paradigm.</pre><pre><strong>OpenGL: </strong>That brings us to OpenGL. OpenGL is a cross-language, cross-platform open source API for rending 2D and 3D vector graphics. The language itself is written in C and C++.</pre><pre><strong>Quartz 2D: </strong>Sometime’s it&#39;s called Quartz 2D and at others Core Graphics but at the end of the day its the same two-dimensional drawing engine use across Apple’s devices and platforms. Core Image sits between Core Graphics and lower level GPU/CPU processing.</pre><p>If GPU’s and CPU’s are trucks and sports cars, then Metal is Apple’s attempt to make a hybrid sports car-truck. Metal is the highest-performance library out of all of them and, as I mentioned above, the applications go way beyond pure graphics operations.</p><h4>Wrap-Up</h4><p>Now that we’ve gotten most of the background information out of the way, I think this is a good place to wrap things up. In the next post we’ll dive into the code!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39f83f0ceb2f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/diving-into-core-image-part-one-39f83f0ceb2f">Diving Into Core Image - Part One</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ARKit and CoreLocation: Part Three]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-three-98b1d51e2eac?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/98b1d51e2eac</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[augmented-reality]]></category>
            <category><![CDATA[arkit]]></category>
            <category><![CDATA[ios-11]]></category>
            <category><![CDATA[navigation]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Sun, 17 Sep 2017 23:27:25 GMT</pubDate>
            <atom:updated>2017-09-21T07:49:42.659Z</atom:updated>
            <content:encoded><![CDATA[<h4>Navigation With Linear Algebra (and Trig)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/281/1*cgNsYwuE8jAdKZDciDHBDA.gif" /></figure><pre><a href="https://github.com/chriswebb09/ARKitNavigationDemo"><strong>Demo Code</strong></a></pre><pre><a href="https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-one-fc7cb2fa0150"><strong>ARKit and CoreLocation: Part One</strong></a></pre><pre><a href="https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-two-7b045fb1d7a1"><strong>ARKit and CoreLocation: Part Two</strong></a></pre><pre><a href="https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-three-98b1d51e2eac"><strong>ARKit and CoreLocation: Part Three</strong></a></pre><h4>Welcome Back!</h4><p>This post is the third part of the series on ARKit and Core Location. In the <a href="https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-one-fc7cb2fa0150"><strong>first part</strong></a> we went over the basics of ARKit and placing objects, in the <a href="https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-two-7b045fb1d7a1"><strong>second part</strong></a>, we figured out how to calculate the coordinates we need to take our trip and how to translate those locations from two-dimensional plots into the three-dimensional real world.</p><p>Now it’s time to apply what we’ve learned. I’ve created a demo project which incorporates all the thing we’ve previously gone over into practical application. If you try to run it, be sure to change the destination location. Otherwise, it might crash if you’re too far away (we’ll fix that later on.) This is just the rough functionality.</p><p>You can checkout the finished code here: <a href="https://github.com/chriswebb09/ARKitNavigationDemo">https://github.com/chriswebb09/ARKitNavigationDemo</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*acmsGqFhinSeGyUo1hiDrQ.gif" /></figure><h3>Optimizations</h3><p>The demo project I put up is intended to demonstrate the concept rather than provide a great user experience. But what are some things we could do to make it better?</p><pre><strong>Region — </strong>For one, we could render far fewer nodes. In fact, it’s a bit distracting that the entire trip is rendered. To fix this, we could render one leg of the journey at a time. Then we could use our location service to monitor for when we enter that region, or we could calculate the distance from the point of view to the last node in the leg triggering a mechanism to render a new leg and remove the old when they are in proximity. </pre><pre><strong>Dynamic Destination — </strong>Another easy way we could improve it is we could allow the user to set their destination inside the application, instead of hard-coding our destination.</pre><pre><strong>Reset — </strong>As the project is as of this writing, the reset functionality hasn’t been completed. Sometimes ARKit gets confused, sometimes the GPS gets confused (more on the location problems in a bit.) So we can build a mechanism which resets the screen so we can start over. That way you don’t have to quit to reset the trip.</pre><pre><strong>Steady Our Node Positions — </strong>Finally, we could steady the positions of our nodes by setting them to a static position once they’ve been placed.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*BYA4CMvCvjd-AcF-u-Z3Kg.gif" /><figcaption>Project September 16th</figcaption></figure><h3>Challenges</h3><p>There were a bunch of challenges that I came across while working with ARKit and Core Location. Some of these problems were solvable, others were more fundamental and could be not solved with the current hardware. Even if they aren’t solvable, you can mitigate the worst consequences of them with a few quick changes.</p><h4>Concrete Canyons</h4><p>To begin with, the biggest challenge you face when working with ARKit and Core Location is the issue of location accuracy. If you’ve ever been to NYC, you’ll notice that the grid system creates these canyons of concrete, steel, and glass. While it is pretty awesome to look at, if you’re trying to locate someone this terrain can pose a problem. GPS signals are microwaves beamed down from a satellite which means that the signal can be absorbed or reflected by surfaces. This interference is particularly noticeable in NYC. The effect can be that your location (as your phone perceives it) jumps around erratically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/340/1*43hlZL1MtsOWCLcDmaywxw.gif" /></figure><p>In PokemonGO, one of the major features is that Pokemon get geo-positioned on the map. You had to be within a certain radius of the location of the Pokemon in order engage it. This led to an interesting effect. You could be sitting somewhere playing and then get warped to an area several blocks away and be able to engage with the Pokemon at the new location only then to get warped back to your original location.</p><p>With a game like PokemonGO, that’s not a huge deal, and it could even be a bit of a bonus. With navigation, this is another story. One solution is to stop updating the locations once the markers have been set or only use it at certain intervals. While this isn’t the best outcome, it is the easiest to implement. This erratic functionality in addition to draining your battery, AR/SceneKits coordinate system provides ample reason to explore a different set of tools to maintain awareness of your location.</p><h3>Location Awareness</h3><p>Given that location monitoring and awareness is fundamental to our project, before we go further, we need to go over how to monitor a users location as they use the app.</p><h4><strong>Definitions</strong></h4><pre><strong>CLLocationManager: </strong>CLLocationManager is the object that manages the location-related events to your app.</pre><p>We’ll also need to cover Apple Privacy. Apple’s requires that your application ask the users permission and have them agree before you can monitor their location. The are multiple levels of privacy in regards to monitoring the users location. You should add the appropriate one to your info.plist.</p><h4>Privacy Options</h4><pre><strong>When-in-use authorization</strong>: <em>Your app can use most services but cannot use services that automatically relaunch the app. Your app must always start services while running in the foreground. If you enable the background location capability for your app, a suspended app will be woken in the background to handle location events. However, if your app is not running, it will not be launched.</em></pre><pre><strong>Always authorization:</strong> <em>Your app can use all location services, and it can start those services from either the foreground or the background. If a location-related event occurs when your app is not running, the system launches your app and delivers the event.</em></pre><h4>Delegate</h4><p>Our LocationService should conform to the CLLocationManagerDelegate protocol. We don’t want to tie our LocationService directly to the controller so we’ll make a delegate to loosely couple location update to our UI.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/86de6328c513ae2775ab639ae3838d75/href">https://medium.com/media/86de6328c513ae2775ab639ae3838d75/href</a></iframe><p>Now when a location update happens in our LocationService, we can push that new information into our controller to work with.</p><h3>LocationService</h3><p>Now that we’ve gotten our delegate squared away let’s move onto the LocationService! Because CLLocationManagerDelegate inherits from NSObjectProtocol, this class should be a subclass of NSObject and conform to the CLLocationMangerProtocol protocol. It may sound weird to throwback to NS classes, but since everything in Objective-C inherits from NSObject, and Apple’s mission is to make Swift and Objective-C as compatible as possible you will see NSObject pop up from time to time.</p><h4>Definitions</h4><pre><strong>NSObjectProtocol: </strong>The base protocol to which all Objective-C objects conform to.</pre><pre><strong>NSObject</strong>: The base class of most Objective-C classes. Inheriting from NSObject gives the subclass an interface to the system runtime and the basic behavior of Objective-C objects.</pre><pre><em>The Cocoa root class </em><em>NSObject adopts this protocol, so all objects inheriting from </em><em>NSObject have the features described by this protocol.</em></pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/51d0a41ce22d0d24f446897a4822a8d8/href">https://medium.com/media/51d0a41ce22d0d24f446897a4822a8d8/href</a></iframe><p>Whatever class we instantiate the LocationService in, we can now use our protocol conformance to pass location updates between that class and the service.</p><h4>Wrap Up</h4><p>That should cover location monitoring for now. In the next post, we’ll setup MapKit to help us navigate.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98b1d51e2eac" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/arkit-and-corelocation-part-three-98b1d51e2eac">ARKit and CoreLocation: Part Three</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coordinators: Reexamination]]></title>
            <link>https://medium.com/journey-of-one-thousand-apps/coordinators-reexamination-e712f74dc13e?source=rss-e2902aed4442------2</link>
            <guid isPermaLink="false">https://medium.com/p/e712f74dc13e</guid>
            <category><![CDATA[application-architecture]]></category>
            <category><![CDATA[coordinator]]></category>
            <category><![CDATA[swift-4]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <dc:creator><![CDATA[Christopher Webb]]></dc:creator>
            <pubDate>Tue, 12 Sep 2017 22:49:59 GMT</pubDate>
            <atom:updated>2018-01-31T00:49:56.398Z</atom:updated>
            <content:encoded><![CDATA[<h4>Taming Unruly Application Architecture</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*8oMDdNeX-Dt-oLVB_5FEMw.gif" /></figure><h4>Back To Coordinators</h4><p>So it has been a few months since I wrote my previous post on coordinators. In the interim, a lot has happened! I published a new application called PodCatch (which I built using the coordinator concept — still work in progress):</p><p><a href="https://github.com/chriswebb09/podcatcher">chriswebb09/podcatcher</a></p><p>And I attended/volunteered at the <a href="https://medium.com/@jp_pancake/try-swift-nyc-2017-tryswiftnyc-ce3eab349914">try! Swift Conference in New York City</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/166/1*PKi25dN31KSAUjlT8SM22g.jpeg" /><figcaption>Me</figcaption></figure><p>Along the way I’ve had a chance to explore the concept in greater detail and expirement to find what features have worked for me.</p><h4>Circling On Back</h4><p>I feel like now is a good time to circle back and finish up my series on coordinators. Before I get too far, I want to own up to something first. I don’t think my first post was a great introduction to the topic. It lacks focus since I tried to introduce too many concepts into something that is much more narrow in scope. In addition to this post, there will most likely be a part three to this series, because this post isn’t complete in and of itself and I’m not happy with what I originally wrote. I know circling back now is a bit of a non-sequitur from the series I’ve been writing on CoreLocation as well as the example project I hope to have out (next week tentative). I’m writing this now because I want to get it down while the conversations I had on the topic at the try! Swift conference in NYC this past week are still fresh in my mind. <strong>¯\_(</strong>ツ<strong>)_/¯</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*rwLW_2iTuvsJibZ3f9Wu1g.png" /><figcaption><a href="https://will.townsend.io/img/coordinator-diagram.svg">Source</a></figcaption></figure><h3>The Application Controller/ Coordinators</h3><p>So let’s do a bit of review from part one, if you’ve already read that post, this might seem a bit redundant. One of the problems with view controllers is that they can become massive and unwieldy as your application development progresses. This is because their purpose can be interpreted broadly. If most of your application works within views and a view controllers ‘controls’ views then it seems perfectly reasonable to place much of your application logic within it. Obviously there are serious drawbacks to this approach. If you’ve read <a href="http://khanlou.com/2015/10/coordinators-redux/">Soroush Khanlou’s blog posts on coordinators</a> then this is something extra, if you haven’t I’m just briefly going to touch on some background information.</p><blockquote>Unfortunately, a view controller-centric approach to app development isn’t scalable. The Coordinator is a great way to isolate your code into small, easily-replaced chunks, and another part of the solution to view controller malaise.</blockquote><blockquote>— <a href="http://khanlou.com/2015/01/the-coordinator/">Khanlou: The Coordinator</a></blockquote><p>The coordinator pattern is a enterprise software design pattern that has been adapted to the iOS world:</p><blockquote>You can remove duplication by placing all the flow logic in an Application Controller. Input controllers then ask the Application Controller for the appropriate commands for execution against a model and the correct view to use depending on the application context.</blockquote><blockquote>— <a href="https://martinfowler.com/eaaCatalog/applicationController.html">Martin Fowler</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*j_JHNi6hTI_nZi2G3Or1Ow.gif" /><figcaption><a href="https://martinfowler.com/eaaCatalog/applicationController.html">Source</a></figcaption></figure><p>I like the tl;dr they posted at the top, it’s a pretty succinct definition of what coordinators are trying to accomplish:</p><p><em>A centralized point for handling screen navigation and the flow of an application.</em></p><p>For the purposes of this post I want place as much emphasis on the flow of the application as on navigation.</p><h3>Observations</h3><p>I spoke to a few developers at the try! Swift conference in NYC about their use of coordinators and everyone I spoke to had a different interpretation of their limits and responsibilities. Some of the developers I spoke to had defined functionality that is a requirement for anything being labeled a coordinator like a start method. Others used a coordinator protocol without any methods being required to bind the classes controlling their application architecture together.</p><p>From what I gleaned from my conversation with Soroush, the range of interpretations is sort of by design.</p><blockquote>So what is a coordinator? A coordinator is an object that bosses one or more view controllers around. Taking all of the driving logic out of your view controllers, and moving that stuff one layer up is gonna make your life a lot more awesome. — <a href="http://khanlou.com/2015/01/the-coordinator/">Khanlou</a></blockquote><p>Beyond the broad strokes of this definition, it’s really up to developers to decide how and when to use them.</p><h3>Some Issues I’ve Come Across</h3><h4>Coordinator/Delegate Hybrids</h4><p>All that being said, there were a few things that I’ve noticed when building out applications using coordinators. Because coordinators don’t have strict limitations on their responsibility, you can easily get carried away with them. One of the biggest issues I noticed with my projects is they can become coordinators view/view controller delegate hybrids. This isn’t necessarily a bad thing, however taken to an extreme we can end up in the same place we were trying to avoid in the first place by using coordinators: Massive-Coordinator-Controllers. You shouldn’t have to choose between using traditional iOS delegation and coordinators. In fact, finding a place for both has helped provide a natural structure to the pattern when there are very few guidelines.</p><h4>Services</h4><p>Services tend be a broad umbrella. In fact I probably use the category too broadly in many of my applications. If you think about it in relation to the real world, services take some kind of currency and and perform some action in return. In iOS a service can be as strict as a network client, or as broad as anything that works and transforms your models/UI. Figuring out how you want to layer your application and where each piece of functionality is relegated can provide a natural structural integrity to your architecture over the course of development. One thing I’ve taken away from the last few months is it can be helpful to decide how strict or broad you want to be with what classify as a service before you get started.</p><p>If I were rewriting the example project, I probably would not include a UI service.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/964f64edee4b4e00895db743decc8170/href">https://medium.com/media/964f64edee4b4e00895db743decc8170/href</a></iframe><h3>Coordinators</h3><p>I went through a few iterations for example code for this blog post. My first attempt looked something like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/508ee8ee3f87eccc7f47e4bc52856abf/href">https://medium.com/media/508ee8ee3f87eccc7f47e4bc52856abf/href</a></iframe><p>This isn’t bad, but at the end of the project I found myself writing this out, just to ensure I used the start method in my main coordinator:</p><pre><strong>func</strong> <strong><em>start()</em></strong> {<br>    <em>childCoordinators[0]</em><strong><em>.start()</em></strong><br>}</pre><p>For me this was a clue that I wasn’t being broad enough with the overall coordinator protocol as well as not being specific enough with the behaviors of specialized coordinator subtypes.</p><p>What I finally settled on was this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bba2920572709a3d89b894d5f5ec6bf3/href">https://medium.com/media/bba2920572709a3d89b894d5f5ec6bf3/href</a></iframe><h3>Coordinator Subtypes</h3><h4>Main Coordinator</h4><p>One of the interesting things I came across when building PodCatch was the need to delineate different coordinators for types of logical flow. Although I eventually removed it, in my first version of PodCatch I had a sign in/sign up screen for a FireBase backend which was logically siloed off from the Podcast player. The responsibilities were so different that it seemed logical to separate the two areas. The question then arises, if these areas are separated do we need to control the flow between between them? In my case I went with an unequivocal yes.</p><h4>One Abstraction To Rule Them All</h4><p>Here is where I could see myself reading this article and saying: “Okay this guy is getting carried away.” You might be right! All I ask is that you hear me out on this. Remember this quote from a few paragraphs up?</p><p>Soroush: “<em>So what is a coordinator? A coordinator is an object that bosses one or more view controllers around. Taking all of the driving logic out of your view controllers, and moving that stuff one layer up is gonna make your life a lot more awesome.”</em></p><p>Here’s the thing: I don’t see a reason this should only be true for view controllers. What’s stopping us from expanding on that idea one step further by layering our coordinations to make it that much more awesome! If we have clear sections of our applications whose internal coordination flow is separated, doesn’t it stand to reason that we can abstract coordination one step further?</p><h4>Coordinators For Our Coordinators ¯\_(ツ)_/¯</h4><p>Just bear with me for a bit longer. Let’s build the coordinator protocol for our top coordinator:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1084f0fc65b2573d59dad5b485e83a08/href">https://medium.com/media/1084f0fc65b2573d59dad5b485e83a08/href</a></iframe><p>After that we can create class MainCoordinator which conforms to our AppCoordinator protocol like below:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eb324cca6b409e472a449b69b994e5de/href">https://medium.com/media/eb324cca6b409e472a449b69b994e5de/href</a></iframe><p>After that we use protocol conformance to handle the flow between the different areas of our application:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b6c132fbc00b430630f13478f4f86ba/href">https://medium.com/media/8b6c132fbc00b430630f13478f4f86ba/href</a></iframe><p>The interesting thing about this design is it allows flexibility with the different areas of our application. Each section doesn’t necessarily need to have one overarching flow. Within a tabbar, we can have several different coordinator flows going for each tab.</p><p>As an added bonus, the ability to swap out, add or remove flows allows the architecture to work with various conditions say like having a setup profile flow until a user sets up their profile and then swapping that out with a view profile flow. That can be extrapolated out even further for different preferences etc.</p><h3>Controller Coordinator</h3><h4>Side Note On Lessons Learned While Building PodCatch</h4><p>One of things I would do differently if I was building PodCatch over from scratch is the way I went about creating the controller coordinator subtypes. In particular I regret creating a separate tab and navigation coordinator subtypes. It added additional complexity that, looking back, kept me from creating as organized architecture as I would have liked.</p><p><strong>NavigationCoordinator:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7827dfe299502f0ee9bffab6fa7166ec/href">https://medium.com/media/7827dfe299502f0ee9bffab6fa7166ec/href</a></iframe><p><strong>TabCoordinator:</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/77717e337d362278b8f6867a04f619ca/href">https://medium.com/media/77717e337d362278b8f6867a04f619ca/href</a></iframe><p><strong>Unanswered Questions: Tab Bar Controller Coordinator?</strong></p><p>The biggest issue is figuring out how to integrate the coordinator flows into something like a tab bar controller. Should a tab bar itself have its own coordinator? Is that overkill? Possibly, I’m still wrestling with the best way to approach this.</p><h4>Back On Track</h4><p>These are all interesting dilemas but following all the leads pulls this post in too many directions and ultimately muddies the waters. Let’s refocus on the example at hand. For this example project in my first go around I had something like this as a coordinator subtype.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee9ec86eba6082e43cff4a0cc6721550/href">https://medium.com/media/ee9ec86eba6082e43cff4a0cc6721550/href</a></iframe><p>That was probably enough. I wanted to demonstrate the the separation between application areas so I added a controller coordinator delegate (say that ten times fast) to help transition between the start view and color views. I ultimately settled on was this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/62a5e32ffd8d926a3df3fc4d545595bb/href">https://medium.com/media/62a5e32ffd8d926a3df3fc4d545595bb/href</a></iframe><p>For me, even this is starting to get a bit overly complex for foundational layer of the application architecture. It still works and if you can find a simpler way to implement the same idea go for it. For now I’m still okay with it, I’m hoping to find a better way the more I experiment.</p><h4>ColorControllerCoordinator</h4><p>The first go around for implementing my ControllerCoordinator for this example was for the coordinator that handles my view controller subclass ColorViewController:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a5db08ab83c91e7dafafdeff86f1c5b6/href">https://medium.com/media/a5db08ab83c91e7dafafdeff86f1c5b6/href</a></iframe><p>What immediately caught my eye with this implementation was the UI change happening in changeColor method. I think a better way to handle this is to inject styleService into the view and have the view handle up UI change/updates. So there’s definitely a refactor or two that can happen in here. Ultimately we’re working towards separating our concerns. For me, coordinators should not just be another place to throw code that isn’t the view controller.</p><h3>Key Takeaways</h3><p>There were a few things that stick out in my mind about coordinators that I picked up over the conference:</p><p><strong>Children should never tell their parents what to do</strong>: One lesson that has stuck with me was something Brian at Raizlab mentioned: child controllers should never tell their parent controllers what to do. Meaning we shouldn’t be calling <strong><em>self.navigation</em></strong> controller from within a child view controller. Coordinators solve this for us, because in theory, with the logical abstraction of the application data flow out of our view controllers and into our coordinators we’re taking the decisions out of the parent/child view controllers hands. It’s one of those programming concepts that translates really well to human relationships (obviously with exceptions.)</p><h4>Coordinators can be implemented in different ways:</h4><p>Beyond pushing the logical flow out of the view controller, there’s no “one way” or right way to go about implementing. Mao’s probably not the best person to quote in an iOS blog post — but it’s sort of a “let a hundred flowers blossom” type of concept. It’s quite interesting to see the various permutations that grow from its simplicity.</p><h4>Sources:</h4><ul><li><a href="https://martinfowler.com/eaaCatalog/applicationController.html">P of EAA: Application Controller</a></li><li><a href="http://khanlou.com/2015/01/the-coordinator/">Khanlou</a></li></ul><p>If you’re interested, there are some really great blog posts out there with people demoing their take on the concept:</p><ul><li><a href="http://irace.me/navigation-coordinators">Navigation coordinators</a></li><li><a href="http://skyefreeman.io/programming/2016/02/23/playing_with_app_coordinators.html">Skye Freeman | Swift - Coordinators</a></li><li><a href="https://will.townsend.io/2016/an-ios-coordinator-pattern">An iOS Coordinator Pattern</a></li><li><a href="https://www.iamsim.me/the-coordinator-pattern/">I am Simme</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e712f74dc13e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/journey-of-one-thousand-apps/coordinators-reexamination-e712f74dc13e">Coordinators: Reexamination</a> was originally published in <a href="https://medium.com/journey-of-one-thousand-apps">Journey Of One Thousand Apps</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>