nearest_points.jl

Author: boriskaus

docs/src/man/Tutorial_LaPalma.md

@@ -108,7 +108,7 @@ Grid_3D = CartData(xyzGrid(-35:.3:30,-15:.25:45,-50:.5:5))
 Next we check how many earthquakes are around the grid points:
 
 ```julia
-Grid_3D =pointData2NearestGrid(EQ_cart, Grid_3D, radius_factor=3)
+Grid_3D =point_to_nearest_grid(EQ_cart, Grid_3D, radius_factor=3)
 ```
 
 And we can define an array with rock types:

docs/src/man/tools.md

@@ -14,7 +14,7 @@ interpolate_data_surface
 interpolate_topography_plane
 parse_columns_CSV
 rotate_translate_scale!
-pointData2NearestGrid
+point_to_nearest_grid
 convert2UTMzone
 convert2CartData
 project_CartData

src/event_counts.jl

@@ -1,10 +1,10 @@
 using NearestNeighbors
 
-export pointData2NearestGrid, countmap
+export point_to_nearest_grid, countmap
 
 
 """
-    Grid_counts = pointData2NearestGrid(Point::CartData, Grid::CartData; radius_factor=1)
+    Grid_counts = point_to_nearest_grid(Point::CartData, Grid::CartData; radius_factor=1)
 
 Uses nearest neighbour interpolation to count how many points (given by `Point`) are in the vicinity of a 3D `Grid`. 
 The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
@@ -13,38 +13,38 @@ The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
 
 `Grid_counts` is `Grid` but with an additional field `Count` that has the number of hits
 """
-function pointData2NearestGrid(Point::CartData, Grid::CartData; radius_factor=1)
+function point_to_nearest_grid(Point::CartData, Grid::CartData; radius_factor=1)
 
     @assert length(size(Point.x)) == 1
 
     # call routine
-    Count = pointData2NearestGrid(NumValue(Point.x),NumValue(Point.y), NumValue(Point.z), NumValue(Grid.x),NumValue(Grid.y),NumValue(Grid.z); radius_factor=radius_factor)
+    Count = point_to_nearest_grid(NumValue(Point.x),NumValue(Point.y), NumValue(Point.z), NumValue(Grid.x),NumValue(Grid.y),NumValue(Grid.z); radius_factor=radius_factor)
 
     # return CartGrid with added field
     return  addfield(Grid,"Count",Count);
 end
 
 
 """
-    Grid_counts = pointData2NearestGrid(pt_x,pt_y,pt_z, Grid::CartData; radius_factor=1)
+    Grid_counts = point_to_nearest_grid(pt_x,pt_y,pt_z, Grid::CartData; radius_factor=1)
 
 Uses nearest neighbour interpolation to count how many points (given by `pt_x`,`pt_y`,`pt_z` coordinate vectors) are in the 
 vicinity of 3D `CartGrid` specified by `Grid`. The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
 
 `Grid_counts` is `Grid` but with an additional field `Count` that has the number of hits
 """
-function pointData2NearestGrid(pt_x,pt_y,pt_z, Grid::CartData; radius_factor=1)
+function point_to_nearest_grid(pt_x,pt_y,pt_z, Grid::CartData; radius_factor=1)
 
     # call routine
-    Count = pointData2NearestGrid(pt_x,pt_y,pt_z, NumValue(Grid.x),NumValue(Grid.y),NumValue(Grid.z); radius_factor=radius_factor)
+    Count = point_to_nearest_grid(pt_x,pt_y,pt_z, NumValue(Grid.x),NumValue(Grid.y),NumValue(Grid.z); radius_factor=radius_factor)
 
     # return CartGrid with added field
     return  addfield(Grid,"Count",Count);
 end
 
 
 """
-    Grid_counts = pointData2NearestGrid(Point::GeoData, Grid::GeoData; radius_factor=1)
+    Grid_counts = point_to_nearest_grid(Point::GeoData, Grid::GeoData; radius_factor=1)
 
 Uses nearest neighbour interpolation to count how many points (given by `Point`) are in the vicinity of a 3D `Grid`. 
 The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
@@ -53,44 +53,44 @@ The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
 
 `Grid_counts` is `Grid` but with an additional field `Count` that has the number of hits
 """
-function pointData2NearestGrid(Point::GeoData, Grid::GeoData; radius_factor=1)
+function point_to_nearest_grid(Point::GeoData, Grid::GeoData; radius_factor=1)
 
     @assert length(size(Point.lon)) == 1
 
     # call routine
-    Count = pointData2NearestGrid(NumValue(Point.lon),NumValue(Point.lat), NumValue(Point.depth), NumValue(Grid.lon),NumValue(Grid.lat),NumValue(Grid.depth); radius_factor=radius_factor)
+    Count = point_to_nearest_grid(NumValue(Point.lon),NumValue(Point.lat), NumValue(Point.depth), NumValue(Grid.lon),NumValue(Grid.lat),NumValue(Grid.depth); radius_factor=radius_factor)
 
     # return CartGrid with added field
     return  addfield(Grid,"Count",Count);
 end
 
 
 """
-    Grid_counts = pointData2NearestGrid(pt_x,pt_y,pt_z, Grid::GeoData; radius_factor=1)
+    Grid_counts = point_to_nearest_grid(pt_x,pt_y,pt_z, Grid::GeoData; radius_factor=1)
 
 Uses nearest neighbour interpolation to count how many points (given by `pt_x`,`pt_y`,`pt_z` coordinate vectors) are in the 
 vicinity of 3D `GeoData` specified by `Grid`. The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
 
 `Grid_counts` is `Grid` but with an additional field `Count` that has the number of hits
 """
-function pointData2NearestGrid(pt_x,pt_y,pt_z, Grid::GeoData; radius_factor=1)
+function point_to_nearest_grid(pt_x,pt_y,pt_z, Grid::GeoData; radius_factor=1)
 
     # call routine
-    Count = pointData2NearestGrid(pt_x,pt_y,pt_z, NumValue(Grid.lon),NumValue(Grid.lat),NumValue(Grid.depth); radius_factor=radius_factor)
+    Count = point_to_nearest_grid(pt_x,pt_y,pt_z, NumValue(Grid.lon),NumValue(Grid.lat),NumValue(Grid.depth); radius_factor=radius_factor)
 
     # return CartGrid with added field
     return  addfield(Grid,"Count",Count);
 end
 
 """
-    count = pointData2NearestGrid(pt_x,pt_y,pt_z, X,Y,Z; radius_factor=1)
+    count = point_to_nearest_grid(pt_x,pt_y,pt_z, X,Y,Z; radius_factor=1)
 
 This uses nearest neighbour interpolation to count how many points (given by `pt_x`,`pt_y`,`pt_z` coordinate vectors) are in the 
 vicinity of 3D grid point specified by `X`,`Y`,`Z` 3D coordinate arrays, with regular spacing `(Δx,Δy,Δz)`.
 The search radius is `R=radius_factor*(Δx² + Δy² + Δz²)^(1/3)`
 
 """
-function pointData2NearestGrid(pt_x,pt_y,pt_z, X,Y,Z; radius_factor=1)
+function point_to_nearest_grid(pt_x,pt_y,pt_z, X,Y,Z; radius_factor=1)
 
     data = zeros(3,length(pt_x));
     data[1,:],data[2,:],data[3,:] = pt_x[:], pt_y[:], pt_z[:]

src/stl.jl

@@ -10,7 +10,7 @@ using LinearAlgebra
 #using TriangleIntersect
 
 export Ray, Intersection, IntersectRayTriangle, load, TriangleNormal, Point, IntersectRayMesh, coordinates
-export STLToSurface, isInsideClosedSTL
+export STLToSurface, isinside_closed_STL
 
 #=
 # Conversion routines from GeometryBasics triangles to TriangleIntersect triangles:
@@ -163,7 +163,7 @@ end
 
 
 """
-    inside = isInsideClosedSTL(mesh::Mesh, Pt, eps=1e-3)
+    inside = isinside_closed_STL(mesh::Mesh, Pt, eps=1e-3)
 
 Determine whether a point `Pt` is inside a 3D closed triangular `*.stl` surface or not.
 
@@ -172,7 +172,7 @@ https://github.com/marmakoide/inside-3d-mesh
 
 This again is described in the following [paper](https://igl.ethz.ch/projects/winding-number/) by Alec Jacobson, Ladislav Kavan and Olga Sorkine-Hornung.
 """
-function isInsideClosedSTL(mesh::Mesh, Pt::Vector, eps=1e-3)
+function isinside_closed_STL(mesh::Mesh, Pt::Vector, eps=1e-3)
 
      # Compute triangle vertices and their norms relative to X
      M_vec  = [mesh.position[i]-Pt[:]   for i in eachindex(mesh.position)];

test/test_event_counts.jl

@@ -28,23 +28,23 @@ R = (sum(pt.^2,dims=2)).^(1/3)
 ind = findall(R.< 5);
 
 # test the basic routine
-counts = pointData2NearestGrid(pt[:,1],pt[:,2],pt[:,3], NumValue(Grid_cart.x),NumValue(Grid_cart.y), NumValue(Grid_cart.z); radius_factor=2)
+counts = point_to_nearest_grid(pt[:,1],pt[:,2],pt[:,3], NumValue(Grid_cart.x),NumValue(Grid_cart.y), NumValue(Grid_cart.z); radius_factor=2)
 @test extrema(counts) == (0, 85)
 
 # Test if the grid is on a CartData grid
-Grid_Count = pointData2NearestGrid(pt[:,1],pt[:,2],pt[:,3], Grid_cart; radius_factor=2)
+Grid_Count = point_to_nearest_grid(pt[:,1],pt[:,2],pt[:,3], Grid_cart; radius_factor=2)
 @test extrema(Grid_Count.fields.Count) == (0, 85)
 
 # Test in case the EQ data is also specified as CartData
-Grid_Count = pointData2NearestGrid(EQ_cart, Grid_cart; radius_factor=2)
+Grid_Count = point_to_nearest_grid(EQ_cart, Grid_cart; radius_factor=2)
 @test extrema(Grid_Count.fields.Count) == (0, 85)
 
 # Test if the grid is on a GeoData grid
-Grid_Count = pointData2NearestGrid(pt[:,1],pt[:,2],pt[:,3], Grid_geo; radius_factor=2)
+Grid_Count = point_to_nearest_grid(pt[:,1],pt[:,2],pt[:,3], Grid_geo; radius_factor=2)
 @test extrema(Grid_Count.fields.Count) == (0, 85)
 
 # Test in case the EQ data is also specified as GeoData
-Grid_Count = pointData2NearestGrid(EQ_geo, Grid_geo; radius_factor=2)
+Grid_Count = point_to_nearest_grid(EQ_geo, Grid_geo; radius_factor=2)
 @test extrema(Grid_Count.fields.Count) == (0, 85)
 
 # Test countmap

test/test_stl.jl

@@ -5,11 +5,11 @@ using Test, GeophysicalModelGenerator
 mesh    =   load("./test_files/cat.stl")
 X,Y,Z   =   xyzGrid(150:180, -15:2:15, 10:5:60) # Create mesh
 
-# Test isInsideClosedSTL routine for individual points (note: bit slow)
+# Test isinside_closed_STL routine for individual points (note: bit slow)
 Phase = zeros(size(X));
 for i in eachindex(X)
 
-    inside = isInsideClosedSTL(mesh, [X[i], Y[i], Z[i]]) 
+    inside = isinside_closed_STL(mesh, [X[i], Y[i], Z[i]]) 
     if inside   
         Phase[i] = 1;
     end

tutorials/Tutorial_LaPalma.jl

@@ -65,7 +65,7 @@ write_Paraview(Topo_model,"Topo_model")
 Grid_3D = CartData(xyzGrid(-35:.3:30,-15:.25:45,-50:.5:5))
 
 # Next we check how many earthquakes are around the grid points:
-Grid_3D =pointData2NearestGrid(EQ_cart, Grid_3D, radius_factor=3)
+Grid_3D =point_to_nearest_grid(EQ_cart, Grid_3D, radius_factor=3)
 
 # And we can define an array with rock types:
 Phases = zeros(Int64,size(Grid_3D.x))