COS | C Object System : a framework that brings C | Compiler library

If you have two images that are similar (or the same) and you want to align them, you can do it using both functions rotate and shift :

I couldn't figure out your math. I think you should try annotating this kind of code with explanatory comments. Often that will help you spot your own mistake:

This seems to be caused by a JVM intrinsic function for Math.cos, which is described in the related issue JDK-8242461. The behavior experienced there is not considered an issue:

The returned results reported in this bug are indeed adjacent floating-point values [this is the case here as well]

[...]

Therefore, while it is possible one or the other of the returned values is outside of the accuracy bounds, just have different return values for Math.cos is not in and of itself evidence of a problem.

For reproducible results, use the StrictMath.cos instead.

And indeed, disabling the intrinsics using -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_dcos (as proposed in the linked issue), causes Math.cos to have the same (expected) result as StrictMath.cos.

So it appears the behavior you are seeing here is most likely compliant with the Math documentation as well.

In the platform that produces “-4,09139395927863E+154”, the Math.Cos routine is broken. It apparently uses a processor instruction that does not support operands outside [−2⁻⁶³, +2⁻⁶³].

Since I do not use C#, here is a C program that reproduces the correct behavior:

veganCovEllipse is not an exported function. This means that it is not intended for interactive use, but it is a support function only to be called from other functions in vegan. Therefore it is not documented. However, the answer is simple: it can calculate any kind of ellipse depending on the input. In vegan the function is called for instance from ordiellipse and there it can draw standard error ellipses, "confidence" ellipses (standard error multiplied by some value picked from statistical distribution), standard deviation ellipses, standard deviation ellipses multiplied by similar constants as standard errors, or enclosing ellipses that contain all points of a group, depending on the input to the function. In showvarparts function it is just re-used to draw circles. Actually veganCovEllipse does not fit anything: it just calculates the coordinates to draw what you asked it to draw, and your input defines the shape, size, orientation and location of the ellipse coordinates.

There are other functions in other packages that do the same: return you the points needed to plot an ellipse from your input data. For instance, the standard (recommended) package cluster makes similar calculations in non-exported functions cluster:::ellipsoidPoints with effectively the same mathematics, but in completely different way. This function is non-exported as well, and it is intended to be called from user function cluster::predict.ellipsoid. The vegan implementation is similar as in the ellipse function in the car package, where these calculations are embedded in that function and cannot be called separately from car::ellipse.

In golang I have taken an array ARR1 which represents a time series ( could be audio or in my case an image ) where each element of this time domain array is a floating point value which represents the height of the raw audio curve as it wobbles ... I then fed this floating point array into a FFT call which returned a new array ARR2 by definition in the frequency domain where each element of this array is a single complex number where both the real and the imaginary parts are floating points ... when I then fed this array into an inverse FFT call ( IFFT ) it gave back a floating point array ARR3 in the time domain ... to a first approximation ARR3 matched ARR1 ... needless to say if I then took ARR3 and fed it into a FFT call its output ARR4 would match ARR2 ... essentially you have this time_domain_array --> FFT call -> frequency_domain_array --> InverseFFT call -> time_domain_array ... rinse N repeat

I know Web Audio API has a FFT call ... do not know whether it has an IFFT api call however if no IFFT ( inverse FFT ) you can write your own such function here is how ... iterate across ARR2 and for each element calculate the magnitude of this frequency ( each element of ARR2 represents one frequency and in the literature you will see ARR2 referred to as the frequency bins which simply means each element of the array holds one complex number and as you iterate across the array each successive element represents a distinct frequency starting from element 0 to store frequency 0 and each subsequent array element will represent a frequency defined by adding incr_freq to the frequency of the prior array element )

Each index of ARR2 represents a frequency where element 0 is the DC bias which is the zero offset bias of your input ARR1 curve if its centered about the zero crossing point this value is zero normally element 0 can be ignored ... the difference in frequency between each element of ARR2 is a constant frequency increment which can be calculated using

I think you might be slightly overcomplicating things. Ideally, you'd just want a single key drawing method for the whole layer. However, because you're using a Stat to do the majority of calculations, this becomes hairy to implement. In my answer, I'm avoiding this.

Let's say I'd want to use a geom-only implementation of such a layer. I can make the following (simplified) class/constructor pair. Below, I haven't bothered width_scale or height_scale parameters, just for simplicity.

You can use a 2D FFT to find the general direction in which the crop is aligned (as proposed by mozway in the comments). The idea is that the general direction can be easily extracted from centred beaming rays appearing in the magnitude spectrum when the input contains many lines in the same direction. You can find more information about how it works in this previous post. It works directly with the input image, but it is better to apply the Gaussian + Canny filters.

Here is the interesting part of the magnitude spectrum of the filtered gray image:

The main beaming ray can be easily seen. You can extract its angle by iterating over many lines with an increasing angle and sum the magnitude values on each line as in the following figure:

Here is the magnitude sum of each line plotted against the angle (in radian) of the line:

Based on that, you just need to find the angle that maximize the computed sum.

Here is the resulting code:

First of All, Yes you can do this with high accuracy if the GPS coordinates are accurate.

Second, the main problem is rotation if the field are straight with lat lng lines this would be easy and straightforward (no bun intended).

The easy way is to convert coordinate to rotated image similar to the real field then rotated every X,Y point to the new straight image. (see the image below)

Here is how to rotate x,y knowing the angel: