danielvandh / naturalneighbours.jl Goto Github PK

I wonder if it would be nice to have a way to interpolate data of the form $\mathbf z = f(x, y)$. One application would be solutions from a PDE, in which case we might want to interpolate at the same point but at many times. Being able to do this just a single time would save a lot of time.

Would still like to eventually implement the following algorithms; chapter numbers refer to pages in Bobach's thesis here.

• Farin's $C^1$ interpolant (Chapter 3.2.7.2)
• Hiyoshi's $C^2$ interpolant (Chapter 3.2.7.3)
• Hioyshi's coordinates (Chapter 3.2.5.5, Chapter 5.5)
• Ghost point extrapolation (Chapter 8)

The main issues being I'm not 100% sure I understand the splines yet for the first two methods, and Bobach's description of Hiyoshi's coordinates confuses me.

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Everything passes locally, but some of the older versions of Julia are having issues in the CI. Should be pretty easy to fix - the true coverage is around 95% once that's done.

Hey, great job on this package !

I'm wondering if this could be extended to 3D data points ?
This could vastly increase usability of your package, though I am not familiar enough with the underlying maths to know if it is relevant or not.
Have a look at https://github.com/eljungsk/ScatteredInterpolation.jl, where they support that.

Nice package, and easy to use!

I come across some weird behavior, though, when the x and y coordinates of the grid points have different scales.
I wonder if this could be easily fixed by having a normalization step before constructing the interpolant, which would scale the given points to an e.g. unit box (then, when the interpolant is called, the coordinates used for the new interpolated data can be transformed with the same normalization)?

An example of the current problem below, and let me know if I've missed something obvious in the docs that solves this 😅

When the y indices have a scale that is 50-times smaller than the x indices:

   using NaturalNeighbours
    using CairoMakie
    N = 50
    f = (xy) -> sinc(sqrt((xy[1])^2 + (xy[2] * N)^2) .+ 0.1 * randn())
    x = Float64.(-6:0.1:6)
    y = Float64.((-6:0.1:6) ./ N)
    xy = Iterators.product(x, y)
    z = f.(xy)

    itp = interpolate(first.(xy)[:], last.(xy)[:], z[:])
    _x = range(-6, 6, length=100)
    _y = range(-6 / N, 6 / N, length=100)
    _xy = Iterators.product(_x, _y)
    _z = itp(first.(_xy)[:], last.(_xy)[:])
    Z = reshape(_z, length.([_x, _y])...)

    f = Figure(size=(600, 300))
    ax = Axis(f[1, 1]; title="Input")
    p = heatmap!(ax, x, y, z)
    ax1 = Axis(f[1, 2]; title="Output")
    heatmap!(ax1, _x, _y, Z)
    display(f)

It works fine for N = 1 though (matched scales):

Dear DanielVandH
I apologize for reaching out to you again. I am writing to seek your guidance on a specific issue regarding obtaining the gradient of a specific point after interpolating a model. Our project has made use of the interpolation method you provided, and we have successfully obtained the model. However, we are currently facing a challenge in retrieving the gradient information of a specific point. It is crucial for us to access the gradient value of that point in order to further refine our algorithms and applications.
The code we have been using is as follows:
itpF(0.0115, 0.1, method=Farin(1), project=false)
this code only returns the Z value of the point,We are wondering if there is any way to retrieve the gradient information with this point.

Thank you for your time and support. We look forward to your response!

Best regards，
Weiling

          Following your instructions, I utilized the following code snippet:

Gsx = Gs[:,1]
Gsy = Gs[:,2]
Gsz = Gs[:,3]
dz = [(row[4], row[5]) for row in eachrow(Gs)] #Gs is a matrix containing data information.
itpF = NaturalNeighbours.interpolate(model.Gsx, model.Gsy, model.Gsz; gradient=model.dz)
diffr = differentiate(itpF, 1)
F = itpF(ϕA, ϕB, method=Nearest(), project=false)
mu = diffr(ϕA, ϕB, interpolant_method=Nearest(), project=false, method=Direct()) /mu = diffr(ϕA, ϕB, interpolant_method=Nearest(), project=false, method=Iterative()) The results obtained by selecting method = Iterative() or Direct() are the same.
My objective is to obtain an interpolated convex surface and analyze a cross-section by selecting ten points. However, upon plotting the results, I observed a certain shift in the interpolated gradient positions compared to the true data points.

The horizontal axis in the graph represents x-values, while the vertical axis corresponds to the interpolated gradient data obtained from diffr.

I am wondering if this discrepancy may be attributed to the fact that the provided gradient=model.dz was not effectively utilized during the gradient calculation. I would greatly appreciate your insights into this matter and any suggestions you may have to address this issue.

Originally posted by @WillingWeiling in #24 (comment)

I need to write an example that compares all the interpolants over several test cases. The tests need to examine

• Differences between the heights
• Differences between the gradients
• Differences between the Hessians

Just need to come up with a good way for it. There are some considerations:

• How can surface roughness best be measured? This can (maybe) be used as a proxy for measuring gradients and Hessians (but not a replacement for).
• What is the best way to define $n$? Minimum edge length? Number of points? Median triangle area?
• How far should we keep points away from the convex hull?
• What's the best way for showing the visual results?

I don't plan to do a rigorous test anyway, but I need to know some of this for my actual applications.

Note that I also have a bunch of test comparisons in the tests, but nothing presentable.

Dear DanielVandH,

I have been exploring the capabilities of NaturalNeighbor.jl and I was wondering if it would be feasible to utilize custom derivatives as additional known information during the interpolation process. Specifically, I would like to provide my own computed derivatives to enhance the accuracy of the interpolation.
Thank you for your attention to my inquiry. I appreciate the work you have done on NaturalNeighbor.jl and I look forward to hearing your insights on this matter.

Best regards,
Weiling H