computational-geometry

I'm trying to compute the exact boundaries of every region of a Voronoi Diagram using scipy.spatial.Voronoi, in the case when all the points are inside a pre-defined polygon. For example, using the example in the documentation, http://docs.scipy.org/doc/scipy-dev/reference/generated/scipy.spatial.Voronoi.html what if I need to compute Voroni with the same points but inside a rectangle with the following boundaries global_boundaries = np.array([[-2, -2], [4, -2], [4, 4], [-2, 4], [-2, -2]]) and I need to compute the precise boundaries of every voronoi region, like that? voronoi_region_1

I need to solve a computational problem that boils down to searching for reciprocally-nearest pairs of points between two sets. The problem goes something like this: Given a set of points A and a set of points B in euclidean space, find all pairs (a,b) such that b is the closest point in B to a and a is the closest point in A to b. The sets A and B are of approximately equal size, and we will call this size N. For my particular problem N is approximately 250,000. The brute force solution is to compare every point against every other point, which has quadratic time complexity. Is there any more

An O(n) algorithm to detect if a line intersects a convex polygon consists in checking if any edge of the polygon intersects the line, and look if the number of intersections is odd or even. Is there an asymptotically faster algorithm, e.g. an O(log n) one? lhf's answer is close to correct. Here is a version that should fix the problem with his. Let the polygon have vertices v0, v1, ..., vn in counterclockwise order. Let the points x0 and x1 be on the line. Note two things: First, finding the intersection of two lines (and determining its existence) can be done in constant time. Second,

This was a problem in the 2010 Pacific ACM-ICPC contest. The gist of it is trying to find a way to partition a set of points inside a triangle into three subtriangles such that each partition contains exactly a third of the points. Input: Coordinates of a bounding triangle: (v1x,v1y),(v2x,v2y),(v3x,v3y) A number 3n < 30000 representing the number of points lying inside the triangle Coordinates of the 3n points: (x_i,y_i) for i=1...3n Output: A point (sx,sy) that splits the triangle into 3 subtriangles such that each subtriangle contains exactly n points. The way the splitting point splits the

What is the right approach for slicing a 3D mesh? The mesh are all closed surfaces and the slices need to be binary images of what's inside the mesh. So for example, a mesh representing a sphere and slice images are those of filled circles. I am looking for a software library or algorithm that I can integrate into my current C++ project. My open source game library contains an implementation of mesh slicing. It works with the Irrlicht api, but could be rewritten to use a different API with a modest effort. You can use the code under the terms of the BSD license, or learn from it an implement

I have a computational geometry problem that I feel should have a relatively simple solution, but I can't quite figure it out. I need to determine the non-convex outline of a region defined by several line segments. I'm aware of various non-convex hull algorithms (e.g. alpha shapes), but I don't need a fully general algorithm, as the line segments define a unique solution in most cases. As @Jean-FrançoisCorbett has pointed out, there are cases where there are multiple solutions. I clearly need to think more about my definition. However, what I'm trying to do is reverse-engineer and use a

CGAL seems to do just about everything I need and a little more for my upcoming project. It can create polygons out of arc line segments and run boolean operations on them. It has spatial sorting packages already that would save me a lot of time regarding a few things and the whole library seems quite standardized and well planned. There's just the issue with the license being QPL (GPL for the upcoming version 4.0) for most of the packages (except the very basic ones). I've got a meager budget and can likely not gather funds to buy the commercial licenses for those specific packages in CGAL

You are given a set U of n points on the plane and you can compute distance between any pair of points in constant time. Choose a subset of U called C such that C has exactly k points in it and the distance between the farthest 2 points in C is as small as possible for given k. 1 < k <= n What's the fastest way to do this besides the obvious n-choose-k solution? A solution is shown in Finding k points with minimum diameter and related problems - Aggarwal, 1991. The algorithm described therein has running time: O(k^2.5 n log k + n log n) For those who have no access to the paper: the problem is