[Closed] Find one of each instance – Efficiently

I think this might be more efficient:

(
	fn collectUniqueObjs =
	(
		local objs = #()
		local handles = #{}
		
		for o in objects where not handles[o.inode.handle] do (
			append objs o
			
			local temp = #()
			InstanceMgr.GetInstances o &temp
			
			for x in temp do
				handles[x.inode.handle] = true
		)
		
		objs
	)
)

EDIT: after testing, I found your method is much faster

post deleted

I don’t know about efficiency, but your method is simply wrong. you can’t delete elements in a collection while you’re iterating over it by index. You will miss a lot of objects.

this works, and seems fast enough (I clocked 4000 objects at 40 ms):

fn getUniqueObs obs = -- finds all unique objects in 'obs'
(
	local uniques = #()
	
	while obs.count > 0 do
	(
		InstanceMgr.GetInstances obs[1] &insts
		append uniques insts[1]
		for ins in insts do
		(
			deleteItem obs (findItem obs ins)
		)
	)
	uniques
)

Wow thanks for your quick responses.

@TzMtN
I like the idea of bitarray with handles as the index but you’re as you found going through every node is slowing it down.

@lo
Thanks, your way is slightly faster than mine and looks neater.

I don’t know about efficiency, but your method is simply wrong. you can’t delete elements in a collection while you’re iterating over it by index. You will miss a lot of objects.
I’m sorry I think you’re mistaken. I’m deleting elements I know are instances of the current element so I’m shortening the number of object I need to check. It’s not that different to your way, mine’s not as neat so it’s harder to read

Except that InstanceMgr.GetInstances doesn’t necessarily return the nodes in the same order as they appear in the obs array, therefore you are sometimes deleting objects behind your iterator. You could write your code like this instead, to work around this problem:

for i in insts where i != obs[oI] do
(
	deleteItem obs (findItem obs i)
)

here is my version that i have used for many years:

fn uniqueNodes nodes: = 
(
	if nodes == unsupplied do nodes = objects as array
	local inst, instances = #()
	for n in nodes where findItem instances n == 0 collect
	(
		instanceMgr.getInstances n &inst
		join instances inst
		n
	)
)

my version loses to lo’s version…
playing with different versions i have a leader (Matan’s method with optimization):

fn uniqueNodes nodes: = 
(
	if nodes == unsupplied do nodes = objects as array

	local handles = #{}
	for node in nodes where not handles[GetHandleByAnim node] collect
	(
		InstanceMgr.GetInstances node &inst
		for i in inst do handles[GetHandleByAnim i] = on
		node
	)
)

here is my test scene:

(
	delete objects
	count = 5000
	b = box name:"copy"
	seed 0
	for k=1 to count-1 do case (random 1 3) of 
	(
		1: copy b name:"copy"
		2: instance b name:"instance"
		3: reference b name:"reference"
	)
	
	gc()
)

Thanks for your input Denis. Good job you stopped by and saw the potential in Matan’s code.
And thanks again lo and Matan, I have to go and pick up a sick child from nursery now but I’ll do some more tests tomorrow.