Different Results

[IanManning]

Hi All,

I've noticed that when aligning photos, with the same Alignment settings, I am getting different numbers of cameras to align.

In my latest process, I aligned the same chunk of 135 photos five times. Each step was processed with:

Lowest Accuracy
Reference Pair Preselection
Keypoint Limit (0)
Tiepoint Limit (0)

However when I look at my results (keeping in mind these are the same 130 photos) the results are very different. (Photo attached)

In the best case, 105/130 cameras were aligned. In the worst, 95/130. What's the explanation? Is there a random element to the matching process or feature extraction? I'd like to be able to explain where these differences are coming from.

Thank you,
Ian

[Alexey Pasumansky]

Hello Ian,

The alignment results may be different due to stochastic values are employed. However, if there are no problems with the overlap and coverage the results of the processing stages shouldn't differ much.

The difference may be considerable for unstable alignment (lack of texture pattern, low overlap, low accuracy or low image resolution).

[IanManning]

Thank you Alexey,

I thought that might be the case. In this particular scenario, I am working with images with repetitive texture, which makes photo alignment more difficult.  I hadn't noticed it before because I've been re-creating simpler scenes, and all photos have aligned properly.

Where exactly is the stochastic value employed? Is it possible to overwrite this value with a fixed value so results are repeatable?

Thank you,
Ian

[PolarNick]

For those who found this topic on google - why this is not always possible to have reproducible results in an algorithm:

1) If the algorithm is single-threaded - it is enough to fix the seed for the random values generator, so that the random sequence is the same from run to run (on the same computer).

2) If the algorithm is multi-threaded, you can't easily mitigate possible differences in threads execution speed. In general, you can only mitigate it with algorithm speed degradation - f.e. falling back to single-threaded implementation. And the possible difference in threads' execution speed leads to different results.