Inclusion in a Polygon

Algorithm2

Testing if a point $P = (p_{x}, p_{y})$ is within a 2D polygon.

Let comparisons on points be comparisons in the x dimension of the associated points.

Let $Left$ and $Right$ be line segments left and right of $P$ .

Let the polygon be a list of directed line segments.
Iterate over the line segments.

If the line segment $L_{i}$ intersects line $y = p_{y}$

Let $W = (w_{x}, w_{y})$ be the intersection point.
If $W < P$

If $W \geq Left$

$Left = L_{i}$

else

If $W \leq Right$

$Right = L_{i}$

If no intersections then $P$ is outside the polygon.

If $Left == Right$ then $P$ is on an endpoint.

if $P$ is viewable from $Left$ and $Right$ then $P$ is inside the polygon.

Issues

The shortfalls of algorithms 1 and 2 should be obvious - they are slow. (Algorithm 1 is probably some factor faster than Algorithm 2 because its got more primitive and minimal testing). In more or less formal terms, given $M$ points and $N$ lines its going to take $O (M N)$ time. Which loosely put is quadratic time.

Inclusion in a Convex Polygon

With pre-processing the test can be speed up considerably. Shamos[1] pages 93-95 gives a $O (\log (N))$ algorithm. See Algorithm3. This is the best solution so far in that it is easy to implement.

It is possible to go further. If a non-linear function can be constructed to return which wedge the point lies in. Each interval is associated with an integer and it is the job of the function to compute the integer in constant time.

$f (θ)$ is defined in the following way.
for points $O .. N - 1$
$[θ_{i}, θ_{i + 1}) = i$

With such a function the search is in constant time. So the algorithm is $O (1)$ . With the same test in Issues the complexity is linear. $O (M)$ .

If the function is slightly inaccurate use a linear search to correct it. This will not change the complexity.

Here is an example of such a function which will use some known interpolation technique. First reform the problem.

$ϕ_{i} = \frac{θ_{i} + θ_{i + 1}}{2}$

Let $g (ϕ)$ interpolate ${ϕ_{i}, i}$
$f (θ) \approx ⌊ g (θ) ⌋$

Algorithm3

Pre process: Order the points around a convex polygon into a vector array. The vector supports indexing. Iterate around the polygon constructing half-spaces from the boundary to the inside point generating a vector.

To search which wedge a point lies in, apply a Binary Search to the array by comparing the point with the associated wedges half space.

Inclusion in a Simplex Mesh

Consider a simplex mesh with every simplex occupying a unique space except where they intersect at their boundaries. Given a point in the mesh which simplex does it belong too?

Let each simplex be uniquely identified by an integer. Consider the 2D case where the mesh is a mesh of triangles. Then the problem becomes one of how to construct a function that given a point in the mesh return the integer of the associated simplex.

Let $X$ be a point in n dimension space.
$f (X) \to k$

Further consider the problem where the points remain static and we can use pre processing to build a data structure where the points are accessed. This pre processing is not limited in complexity (except that it must produce in reasonable time ) a data structure. However the aim of this new data structure is to have constant lookup or O(1) complexity when finding a point associated with a simplex.

Approximation with a Continuous Surface

Consider a 2D surface tessellation. Construct a continuous function through points from the tessellation that are integer values at these points.

For example the continuous surface could pass through the indexed integer point k of p_k at that point. The vertex could be used to find further information.

Another example is to generate a surface that when it passes through the centroid of a simplex the integer index of the simplex is a point through the surface.

Then some variation of the floor function is used to get the integer index back given a point on the surface.

Here is one solution that I have considered, but do not have the mathematical machinery to implement. Arrange and relable the simplexes such that jumps between neighboring simplexes in integer indexes are minimized.

The a surface is to pass through all the integer points f(x_i,y_i) where (x_i,y_i) are integer indexes in the mesh.

Next construct some approximating function which approximates the true curve. Call this function g(x,y). Have the function have an additional property that f(x,y) = floor(g(x,y)) indexes a simplex which is no more than e steps away from the simplex which actually contains the point (x,y).

This ensures that the approximation function g can be used to find the simplex associated with (x,y). If evaluation of g has O(1) complexity then so does finding k. ie
O(f) = O(g) + O(1) = O(g)

The advantage of this approach is that it is completely general. For example a mesh with completely different sized simplexes can be built. So adaptive meshes can be handled.

However it is still a very hard problem that has only been separated and not solved. Finding g could possibly be done by many different mathematical techniques and varies on the point distribution.

The function to convert from a continuous function to a discrete integer is problematic. For example what if two points had largly varying integer values. For example the integers between 6 and 100 are useless so the approximation function should give only 6 or 100.

Relabeling or mapping of the integer indexes so that between any boundary the difference is at most 1 is possible. ie given a point set of integer values, find an integer function f(k) -> w where k is the point integer value and w is the new integer value. The catch is that in the mesh any neighboring w have at most 1 difference in their value.

To calculate the function sum polynomials are probably very expensive and difficult to compute. As more points are added the sum grows. While this is interesting I like grids because they are simple and do the job much more easily.

A heirachy of grids could be the best approach. Restrict the heirachy depth to be finite (and meaningful, eg 5) the the grid tile can be located in a fixed time. Further such a grid is adaptable over time.

Grids

Grid are a lattice of points which are a function that they point to the nearest simplex in the mesh. It has the property that its index is computed in constant time.

The grid itself is simply a matrix of integers. Floor functions convert the continuous variable into an integer index into the grid.

The size of the grid cells needs to be such that given any point (x,y) which is inside the mesh the simplex associated with that point can be found with an initial approximation and a greedy search within a bounded number of steps iterating from one simplex to the next.

So the grid needs a fine granularity which is dependent on the distribution of the mesh. If the mesh has simplexes many magnitudes less in size then the grid will have a simplexes indexed many magnitues more times than the smaller ones.

Since this consumes vast resources then meshes that have simplexes with the same size need to be used. This is contradictory to meshes which are of interest ie adaptive meshes which are much more accurate where they need to be.

The question of what is a balances mesh is also raised as this property is required plus that the sizes of the simplexes be comparable/similar.

If we assume that we have the resources to use relatively large amounts of memory (so that computation is fast) then a mesh with a bad distribution of points could be re tessellated to be more balanced.

Alternatively leave the tessellation alone and have a finer grid, but approximate the tessellation with higher order curves so that the tessellation does not fragment the approximation.

A problem with linear interpolation is that it is inaccurate. If we re tessellate on a linear boundary it is always linear. If we re tessellate on a boundary that is a spline then the accuracy is much better (unless the boundary was originally flat).

What I am trying to say is that re tessellation should not loose information but realize it in a different form. So a mesh is composed of simplexes but the boundary of the mesh is a continuous surface.

With this philosophy a mesh can be transformed through retessellation into another mesh with a much smoother boundary and more equally sized simplexes (but not necessarily balanced). This second mesh would have a grid built for it so that a simplex could be identified from any point in constant time.

Bounding Boxes and Half Spaces and Trees

Meshes are generally non convex. And the general case of a mesh is where the granuality (size of the simplexes) varies.

Assume that the mesh is balanced because the following algorithm partions the mesh and builds a tree. If the mesh is not balanced then there may be problems finding half space partitions that divide that part of the mesh in two.

Have a data structure that points to a mesh and has a bounding box of some sort. Let the mesh be inside the bounding box. Generally a point is determined to be within the bounding box in constant time.

Construct a tree of this data structures by having the mesh in the root node. Find a partition that divides the mesh roughly equally in two. Create a pair of children under the node where one contains all the simplexes within the found partition and the other has all the other simplexes. Find bounding boxes for both these sub meshes.

Repeat this subdivision until the meshes are of a certain size which is easily managed.

For dynamic algorithms this data structure will need to be routinely updated to ensure that the mesh is balanced. Rather than using this tree balancing in this case the red/black trees or another tree which is guaranteed to have log(n) complexity should be used.

To find the simplex a point is in can now be done in log(n) time.

The memory requirements of having links to all the simplexes is quite large. The standard way of dealing with this is to have the nodes as bounding boxes and the leafs contain the pointers to the simplexes.

If the mesh has n simplexes then O(n) in memory is required.

References

Shamos M I (1978). Computational Geometry. Dissertation for PhD.