computational-geometry

I have as an input a 2D polygon with holes, and I need to find it's straight skeleton, like in the picture: (source: cgal.org ) Maybe there is a good Java library for it? And if not, can you point me to the good explanation of the algorithm, so I could implement it myself? (I haven't found good resources on Google) I wrote this a little while back. Not sure if it's robust enough. https://github.com/twak/campskeleton (edited for 2018...) See http://www.sable.mcgill.ca/~dbelan2/roofs/roofs.html which contains an applet. Edit: Ah. I see that " Straight Skeleton " is a technical term. The

Suppose there is a polygon with no holes and self-intersections (i.e. a simple polygon) defined by n vertices. Choose a reflex vertex v of this polygon. I'd like to find any other vertex u of the same polygon which is "visible" from the vertex v . By visible I mean, that a line segment between v and u lies completely inside the polygon. Is there an algorithm to do that in O(N) time or better? Is there an algorithm that can find all visible vertices in O(N) time? A quick research suggests that for a given polygon and any point inside this polygon a visibility polygon can be constructed in O(N)

I'm trying to create a method that will take in two arbitrary lists of nodes, for a subject and a clipping polygon, and output either: a) the area of the overlap b) a list of nodes for the resulting (clipped) polygon so that I can calculate the area I've found lots of examples which clip an arbitrary polygon using a rectangular window (which is fairly standard in graphics) but that's not what I need. I understand that it's fairly complex, particularly when you get holes, convex polygons and the like. The only simplifying assumption which I can make is that the arbitrary polygons will not

I would like to modify this following python script for RDP algorithm with the purpose of not using epsilon but to choose the number of points I want to keep at the final : class DPAlgorithm(): def distance(self, a, b): return sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) def point_line_distance(self, point, start, end): if (start == end): return self.distance(point, start) else: n = abs( (end[0] - start[0]) * (start[1] - point[1]) - (start[0] - point[0]) * (end[1] - start[1]) ) d = sqrt( (end[0] - start[0]) ** 2 + (end[1] - start[1]) ** 2 ) return n / d def rdp(self, points, epsilon): """

I have to make a program to find all convex quadrilaterals from the given list of 2d points. I have tried it with vector cross product but it doesn't seem to be a correct solution. Maybe there is some effective algorithm to this problem but I can not find it. This is an example case with inputs and outputs: Input Number of Points: 6 coordinates of points (x,y): 0 0 0 1 1 0 1 1 2 0 2 1 Output Number of convex quadrilaterals: 9 Gareth Rees A quadrilateral is convex if its diagonals intersect. Conversely, if two line segments intersect, then their four endpoints make a convex quadrilateral. Every

I have a bunch of points on a 2-dimensional Grid. I want to group the Points into pairs, while minimizing the sum of the euclidean distances between the points of the pairs. Example: Given the points: p1: (1,1) p2: (5,5) p3: (1,3) p4: (6,6) Best solution: pair1 = (p1,p3), distance = 2 pair2 = (p2,p4), distance = 1 Minimized total distance: 1+2 = 3 I suspect this problem might be solvable with a variant of the Hungarian Algorithm ?! What is the fastest way to solve the problem? (Little Remark: I always should have less than 12 points.) ChuckCottrill The problem you are trying to solve is