title: arkit anchor or node visible in camera and sitting to left or right of frustum
body: <p>How can i detect if an ARAnchor is currently visible in the camera, i need to test when the camera view changes. 
  I want to put arrows on the edge of the screen that point in the direction of the anchor when not on screen. I need to know if the node sits to the left or right of the frustum.</p>
  
  <p>I am now doing this but it says pin is visible when it is not and the X values seem not right? Maybe the renderer frustum does not match the screen camera?</p>
  
  <pre><code> var deltaTime = TimeInterval()
  
   public func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
          deltaTime = time - lastUpdateTime
          if deltaTime&gt;1{
  
              if let annotation = annotationsByNode.first {
  
                  let node = annotation.key.childNodes[0]
  
                  if !renderer.isNode(node, insideFrustumOf: renderer.pointOfView!)
                  {
                      print("Pin is not visible");
                  }else {
                      print("Pin is visible");
                  }
                  let pnt = renderer.projectPoint(node.position)
  
                  print("pos ", pnt.x, " ", renderer.pointOfView!.position)
  
  
              }
              lastUpdateTime = time
          }
  
      }
  </code></pre>
  
  <p>Update: The code works to show if node is visible or not, how can i tell which direction left or right a node is in relation to the camera frustum?</p>
  
  <p>update2! as suggested answer from Bhanu Birani</p>
  
  <pre><code>let screenWidth = UIScreen.main.bounds.width
  let screenHeight = UIScreen.main.bounds.height
  let leftPoint = CGPoint(x: 0, y: screenHeight/2)
  let rightPoint = CGPoint(x: screenWidth,y: screenHeight/2)
  
  let leftWorldPos = renderer.unprojectPoint(SCNVector3(leftPoint.x,leftPoint.y,0))
  let rightWorldPos = renderer.unprojectPoint(SCNVector3(rightPoint.x,rightPoint.y,0))
  let distanceLeft = node.position - leftWorldPos
  let distanceRight = node.position - rightWorldPos
  let dir = (isVisible) ? "visible" : ( (distanceLeft.x&lt;distanceRight.x) ? "left" : "right")
  </code></pre>
  
  <p>I got it working finally which uses the idea from Bhanu Birani of the left and right of the screen but i get the world position differently, unProjectPoint and also get a scalar value of distance which i compare to get the left/right direction. Maybe there is a better way of doing it but it worked for me</p>
  
  <pre><code>public func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
          deltaTime = time - lastUpdateTime
          if deltaTime&gt;0.25{
  
              if let annotation = annotationsByNode.first {
                  guard let pointOfView = renderer.pointOfView else {return}
                  let node = annotation.key.childNodes[0]
                  let isVisible = renderer.isNode(node, insideFrustumOf: pointOfView)
  
                  let screenWidth = UIScreen.main.bounds.width
                  let screenHeight = UIScreen.main.bounds.height
                  let leftPoint = CGPoint(x: 0, y: screenHeight/2)
                  let rightPoint = CGPoint(x: screenWidth,y: screenHeight/2)
  
                  let leftWorldPos = renderer.unprojectPoint(SCNVector3(leftPoint.x, leftPoint.y,0))
                  let rightWorldPos =  renderer.unprojectPoint(SCNVector3(rightPoint.x, rightPoint.y,0))
                  let distanceLeft = node.worldPosition.distance(vector: leftWorldPos)
                  let distanceRight = node.worldPosition.distance(vector: rightWorldPos)
  
                  //let pnt = renderer.projectPoint(node.worldPosition)
                  //guard let pnt = renderer.pointOfView!.convertPosition(node.position, to: nil) else {return}
  
                  let dir = (isVisible) ? "visible" : ( (distanceLeft&lt;distanceRight) ? "left" : "right")
                  print("dir" , dir, " ", leftWorldPos , " ", rightWorldPos)
                  lastDir=dir
                  delegate?.nodePosition?(node:node, pos: dir)
              }else {
                 delegate?.nodePosition?(node:nil, pos: lastDir )
              }
              lastUpdateTime = time
          }
  
  extension SCNVector3
  {
  
      /**
       * Returns the length (magnitude) of the vector described by the SCNVector3
       */
      func length() -&gt; Float {
          return sqrtf(x*x + y*y + z*z)
      }
  
      /**
       * Calculates the distance between two SCNVector3. Pythagoras!
       */
      func distance(vector: SCNVector3) -&gt; Float {
          return (self - vector).length()
      }
  
  
  }
  </code></pre>