Method "isNode(:insideFrustumOf:)" always true - ios

Question

I'm trying to verify if a specific node is inside the current frustum of the scene.
Therefore I use the method isNode(_:insideFrustumOf:) from Apple.
I save in every call to renderer(_:didAdd:for:) the corresponding node and later test with isNode(_:insideFrustumOf:).
But the result is always true, which is obviously wrong.
Why can't I test the nodes added by ARKit?
UPDATE:
The asked code, if it helps, great!
func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
//...
nodes.append(node)
//...
}
nodes is an array of SCNNodes.
func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
for node in nodes {
let result = sceneView.isNode(node, insideFrustumOf: sceneView.pointOfView!)
//...
}
}
Here the evaluation of the node takes place. Result always true.

Answer 1

Since you haven't posted all your code, its hard to provide a 'definitive' answer.
Having said this, I have created an example for you which works perfectly well.
First I created an [SCNNode] to store any SCNNodes added to the screen:
//Array To Store Any Added Nodes To The Scene Hierachy
var nodesRendered = [SCNNode]()
I then created 3 different SCNNodes:
/// Creates A Red, Blue & Green SCNNode
func createNodes(){
//1. Create A Red Sphere
let redNode = SCNNode()
let redGeometry = SCNSphere(radius: 0.2)
redGeometry.firstMaterial?.diffuse.contents = UIColor.red
redNode.geometry = redGeometry
redNode.position = SCNVector3(-1.5, 0, -1.5)
redNode.name = "RedNode"
//2. Create A Green Sphere
let greenNode = SCNNode()
let greenGeometry = SCNSphere(radius: 0.2)
greenGeometry.firstMaterial?.diffuse.contents = UIColor.green
greenNode.geometry = greenGeometry
greenNode.position = SCNVector3(0, 0, -1.5)
greenNode.name = "GreenNode"
//3. Create A Blue Sphere
let blueNode = SCNNode()
let blueGeometry = SCNSphere(radius: 0.2)
blueGeometry.firstMaterial?.diffuse.contents = UIColor.blue
blueNode.geometry = blueGeometry
blueNode.position = SCNVector3(1.5, 0, -1.5)
blueNode.name = "BlueNode"
//4. Add Them To The Hierachy
augmentedRealityView.scene.rootNode.addChildNode(redNode)
augmentedRealityView.scene.rootNode.addChildNode(greenNode)
augmentedRealityView.scene.rootNode.addChildNode(blueNode)
//5. Store A Reference To The Nodes
nodesRendered.append(redNode)
nodesRendered.append(blueNode)
nodesRendered.append(greenNode)
}
Having done this, I then created a function to determine whether these where in the Frustrum of the Camera:
/// Detects If A Node Is In View Of The Camera
func detectNodeInFrustrumOfCamera(){
guard let cameraPointOfView = self.augmentedRealityView.pointOfView else { return }
for node in nodesRendered{
if augmentedRealityView.isNode(node, insideFrustumOf: cameraPointOfView){
print("\(node.name!) Is In View Of Camera")
}else{
print("\(node.name!) Is Not In View Of Camera")
}
}
}
Finally in the delegate callback I called the function like so:
func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
detectNodeInFrustrumOfCamera()
}
Which yielded results such as:
RedNode Is Not In View Of Camera
BlueNode Is Not In View Of Camera
GreenNode Is In View Of Camera
Hope it points you in the right direction...

Answer 2

So I ran into this issue myself while working on an ARKit project. It seems like the function isNode(node:, insideFrustumOf:) will always return true for nodes that were automatically added by ARKit.
My workaround was instead of attempting to track the node added by ARKit, create a new node with a clear material that has the same "volume" as your detected object then create a reference and check if that node is inside the point of view.
Add these variables:
/// The object that was detected.
var refObject: ARReferenceObject?
/// The reference node for the detected object.
var refNode: SCNNode?
/// additional node which we'll use to check the POV against.
var detectionNode: SCNNode?
Implement the delegate function didAdd:
public func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
if let objectAnchor = anchor as? ARObjectAnchor {
guard let name = objectAnchor.referenceObject.name, name == "my_object"
else { return }
print("detected object for the first time")
// create geometry
let cube = SCNBox(width: 0.1, height: 0.1, length: 0.1, chamferRadius: 0.0)
// apply transparent material
let material = SCNMaterial()
material.transparency = 0.0
cube.firstMaterial = material
// add child node
let detectionNode = SCNNode(geometry: cube)
node.addChildNode(detectionNode)
// store references
self.detectionNode = detectionNode // this is the reference we really need
self.refNode = node
self.refObject = objectAnchor.referenceObject
}
}
Finally implement this delegate function updateAtTime:
public func renderer(_ renderer: SCNSceneRenderer, updateAtTime time: TimeInterval) {
guard let node = self.detectionNode else { return }
if let pointOfView = sceneView.pointOfView {
let isVisible = sceneView.isNode(node, insideFrustumOf: pointOfView)
print("Is node visible: \(isVisible)")
}
}