def makePrediction(self): for blob in self.blobs: dxs = [] dys = [] #magnitudes = [] #angles = [] for motion in self.motions: if nx.pnpoly(motion.x, motion.y, blob.contour()): #dxs.append(motion.dx) #dys.append(motion.dy) (uvx, uvy) = motion.vector() dxs.append(uvx) dys.append(uvy) #angles.append(np.rad2deg(np.arctan(uvy/uvx))) #magnitudes.append(motion.magnitude()) #if not math.isnan(np.mean(magnitudes)): if not math.isnan(np.mean(dxs)): mean_dx = np.mean(dxs) mean_dy = np.mean(dys) print("mean_dx" + str(mean_dx)) print("mean_dy" + str(mean_dy)) blob_img = blob.blobImage() (size_x, size_y) = blob_img.size() new_x = int(blob.x + mean_dx) - size_x/2 new_y = int(blob.y + mean_dy) - size_y/2 alpha_mask = blob_img.binarize().invert() self.image = self.image.blit(blob_img, pos=(new_x, new_y), alphaMask=alpha_mask)
def makePrediction(self): for blob in self.blobs: dxs = [] dys = [] #magnitudes = [] #angles = [] for motion in self.motions: if nx.pnpoly(motion.x, motion.y, blob.contour()): #dxs.append(motion.dx) #dys.append(motion.dy) (uvx, uvy) = motion.vector() dxs.append(uvx) dys.append(uvy) #angles.append(np.rad2deg(np.arctan(uvy/uvx))) #magnitudes.append(motion.magnitude()) #if not math.isnan(np.mean(magnitudes)): if not math.isnan(np.mean(dxs)): mean_dx = np.mean(dxs) mean_dy = np.mean(dys) print("mean_dx" + str(mean_dx)) print("mean_dy" + str(mean_dy)) blob_img = blob.blobImage() (size_x, size_y) = blob_img.size() new_x = int(blob.x + mean_dx) - size_x / 2 new_y = int(blob.y + mean_dy) - size_y / 2 alpha_mask = blob_img.binarize().invert() self.image = self.image.blit(blob_img, pos=(new_x, new_y), alphaMask=alpha_mask)
def pts_in_polygon(xpoints, ypoints, polygon): isin = list() for i in xrange(0, len(xpoints)): isin.append(nxutils.pnpoly(xpoints[i], ypoints[i], polygon)) ispol = np.array(isin) == 1 return ispol == 1
def get_cmd_shape(color, mag): ''' gets the outline of a cmd. Guesses at a large polygon, and then add points that are outside of the polygon, ignores points within. then polar sorts the result. returns: N,2 array. ''' # make a guess at the polygon. left = (np.min(color), mag[np.argmin(color)]) right = (np.max(color), mag[np.argmax(color)]) up = (color[np.argmin(mag)], np.min(mag)) down = (color[np.argmax(mag)], np.max(mag)) verts = np.vstack((left, right, up, down)) points = np.column_stack((color, mag)) for point in points: if nxutils.pnpoly(point[0], point[1], verts) == 0.: # add point to verts col = verts[:, 0] m = verts[:, 1] col = np.append(col, point[0]) m = np.append(m, point[1]) # order the new points in a circle verts = polar_sort(zip(col, m)) verts = np.append(verts, [verts[0]], axis=0) # plt.plot(verts[:, 0], verts[:, 1], lw = 2) return verts
def correct_mask(pts): for j in range(y.size): for i in range(x.size): if mask[j,i] > 0: if nx.pnpoly(x[i], y[j], pts): mask[j,i] = 2 else: mask[j,i] = 1
def inpolygon(x,y,xp,yp): ''' Points inside polygon test. Based on matplotlib nxutils for old matplotlib versions http://matplotlib.sourceforge.net/faq/howto_faq.html#test-whether-a-point-is-inside-a-polygon Can also use Path.contains_point, for recent versions, or the pnpoly extension - point in polyon test - by W R Franklin, http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html ''' try: from matplotlib.nxutils import pnpoly, points_inside_poly _use_mpl = 1 except ImportError: from matplotlib.path import Path _use_mpl = 2 except: import pnpoly _use_mpl = False shape=False try: if x.ndim>1: shape=x.shape x=x.flat y=y.flat except: pass if _use_mpl==1: verts=np.array(zip(xp,yp)) if isiterable(x,y): points=np.array(zip(x,y)) res=points_inside_poly(points,verts) else: res=pnpoly(x,y,verts)==1 elif _use_mpl==2: verts=np.array(zip(xp,yp)) p=Path(verts) if not isiterable(x,y): x,y,itr=[x],[y],0 else: itr=1 res=[p.contains_point((x[i],y[i]), radius=0.) for i in range(len(x))] res=np.asarray(res,'bool') if not itr: res=res[0] else: if not isiterable(x,y): x,y,itr=[x],[y],0 else: itr=1 res=np.zeros(len(x)) res=[pnpoly.pnpoly(x[i],y[i],xp,yp,len(xp)) for i in range(len(x))] res=np.asarray(res)==1 if not itr: res=res[0] if not shape is False: res.shape=shape return res
def in_healpix_image(x, y): r""" Return True if and only if `(x, y)` lies in the image of the HEALPix projection of the unit sphere. EXAMPLES:: >>> eps = 0 # Test boundary points. >>> hp = [ ... (-pi - eps, pi/4), ... (-3*pi/4, pi/2 + eps), ... (-pi/2, pi/4 + eps), ... (-pi/4, pi/2 + eps), ... (0, pi/4 + eps), ... (pi/4, pi/2 + eps), ... (pi/2, pi/4 + eps), ... (3*pi/4, pi/2 + eps), ... (pi + eps, pi/4), ... (pi + eps,-pi/4), ... (3*pi/4,-pi/2 - eps), ... (pi/2,-pi/4 - eps), ... (pi/4,-pi/2 - eps), ... (0,-pi/4 - eps), ... (-pi/4,-pi/2 - eps), ... (-pi/2,-pi/4 - eps), ... (-3*pi/4,-pi/2 - eps), ... (-pi - eps,-pi/4) ... ] >>> for p in hp: ... if not in_healpix_image(*p): ... print 'Fail' ... >>> in_healpix_image(0, 0) True >>> in_healpix_image(0, pi/4 + 0.1) False """ # matplotlib is a third-party module. from matplotlib.nxutils import pnpoly # Fuzz to slightly expand HEALPix image boundary so that pnpoly() # counts points on the original boundary as lying in the image. eps = 1e-10 vertices = [(-pi - eps, pi / 4), (-3 * pi / 4, pi / 2 + eps), (-pi / 2, pi / 4 + eps), (-pi / 4, pi / 2 + eps), (0, pi / 4 + eps), (pi / 4, pi / 2 + eps), (pi / 2, pi / 4 + eps), (3 * pi / 4, pi / 2 + eps), (pi + eps, pi / 4), (pi + eps, -pi / 4), (3 * pi / 4, -pi / 2 - eps), (pi / 2, -pi / 4 - eps), (pi / 4, -pi / 2 - eps), (0, -pi / 4 - eps), (-pi / 4, -pi / 2 - eps), (-pi / 2, -pi / 4 - eps), (-3 * pi / 4, -pi / 2 - eps), (-pi - eps, -pi / 4)] return bool(pnpoly(x, y, vertices))
def __call__(self,indices): """Divide the data points up into num_vars bins at the points specified in indices. Then perform orthogonal regression on all the points in each bin and return the total error. Thus, each bin of points is considered to be a candidate for the collection of all the points along a given side of the polygon.""" self.sane = True self.generate_polygon(indices) self.sane = self.sane and pnpoly(self.centroid[0], self.centroid[1], self.corners) if not self.sane: return 1e308 else: return self.error
def in_rhealpix_image(x, y, north_square=0, south_square=0): r""" Return True if and only if the point `(x, y)` lies in the image of the rHEALPix projection of the unit sphere. EXAMPLES:: >>> eps = 0 # Test boundary points. >>> north_square, south_square = 0, 0 >>> rhp = [ ... (-pi - eps, pi/4 + eps), ... (-pi + north_square*pi/2 - eps, pi/4 + eps), ... (-pi + north_square*pi/2 - eps, 3*pi/4 + eps), ... (-pi + (north_square + 1)*pi/2 + eps, 3*pi/4 + eps), ... (-pi + (north_square + 1)*pi/2 + eps, pi/4 + eps), ... (pi + eps, pi/4 + eps), ... (pi + eps,-pi/4 - eps), ... (-pi + (south_square + 1)*pi/2 + eps,-pi/4 - eps), ... (-pi + (south_square + 1)*pi/2 + eps,-3*pi/4 - eps), ... (-pi + south_square*pi/2 - eps,-3*pi/4 - eps), ... (-pi + south_square*pi/2 -eps,-pi/4 - eps), ... (-pi - eps,-pi/4 - eps) ... ] >>> for p in rhp: ... if not in_rhealpix_image(*p): ... print 'Fail' ... >>> print in_rhealpix_image(0, 0) True >>> print in_rhealpix_image(0, pi/4 + 0.1) False """ # matplotlib is a third-party module. from matplotlib.nxutils import pnpoly # Fuzz to slightly expand rHEALPix image boundary so that pnpoly() # counts points on the original boundary as lying in the image. eps = 1e-15 vertices = [(-pi - eps, pi / 4 + eps), (-pi + north_square * pi / 2 - eps, pi / 4 + eps), (-pi + north_square * pi / 2 - eps, 3 * pi / 4 + eps), (-pi + (north_square + 1) * pi / 2 + eps, 3 * pi / 4 + eps), (-pi + (north_square + 1) * pi / 2 + eps, pi / 4 + eps), (pi + eps, pi / 4 + eps), (pi + eps, -pi / 4 - eps), (-pi + (south_square + 1) * pi / 2 + eps, -pi / 4 - eps), (-pi + (south_square + 1) * pi / 2 + eps, -3 * pi / 4 - eps), (-pi + south_square * pi / 2 - eps, -3 * pi / 4 - eps), (-pi + south_square * pi / 2 - eps, -pi / 4 - eps), (-pi - eps, -pi / 4 - eps)] return bool(pnpoly(x, y, vertices))
def __call__(self, indices): """Divide the data points up into num_vars bins at the points specified in indices. Then perform orthogonal regression on all the points in each bin and return the total error. Thus, each bin of points is considered to be a candidate for the collection of all the points along a given side of the polygon.""" self.sane = True self.generate_polygon(indices) self.sane = self.sane and pnpoly(self.centroid[0], self.centroid[1], self.corners) if not self.sane: return 1e308 else: return self.error
def pathtally(args): '''Tally the number of paths that intersect the given square.''' square, paths = args tally = 0 for path in paths: for point in path['coordinates']: if nx.pnpoly(point[0],point[1],square[:-1]): tally += path['weight'] break return tally
def contains(self, mouseevent): """Test whether the mouse event occurred in the patch. Returns T/F, {} """ if callable(self._contains): return self._contains(self,mouseevent) try: # TODO: make this consistent with patch collection algorithm x, y = self.get_transform().inverse_xy_tup((mouseevent.x, mouseevent.y)) xyverts = self.get_verts() inside = nxutils.pnpoly(x, y, xyverts) #print str(self),"%g,%g is in"%(x,y),xyverts,inside return inside,{} except ValueError: return False,{}
def pointInPolygon(x, y, poly): """Determine if a point (`x`, `y`) is inside a polygon, using the ray casting method. `poly` is a list of 3+ vertices as (x,y) pairs. If given a `ShapeStim`-based object, will use the rendered vertices and position as the polygon. Returns True (inside) or False (outside). Used by :class:`~psychopy.visual.ShapeStim` `.contains()` """ try: #do this using try:...except rather than hasattr() for speed poly = poly.verticesPix #we want to access this only once except: pass nVert = len(poly) if nVert < 3: msg = 'pointInPolygon expects a polygon with 3 or more vertices' logging.warning(msg) return False # faster if have matplotlib tools: if haveMatplotlib: if matplotlib.__version__ > '1.2': return mpl_Path(poly).contains_point([x,y]) else: try: return bool(nxutils.pnpoly(x, y, poly)) except: pass # fall through to pure python: # as adapted from http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/ # via http://www.ariel.com.au/a/python-point-int-poly.html inside = False # trace (horizontal?) rays, flip inside status if cross an edge: p1x, p1y = poly[-1] for p2x, p2y in poly: if y > min(p1y, p2y) and y <= max(p1y, p2y) and x <= max(p1x, p2x): if p1y != p2y: xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x if p1x == p2x or x <= xints: inside = not inside p1x, p1y = p2x, p2y return inside
def pointInPolygon(x, y, poly): """Determine if a point is inside a polygon; returns True if inside. (`x`, `y`) is the point to test. `poly` is a list of 3 or more vertices as (x,y) pairs. If given an object, such as a `ShapeStim`, will try to use its vertices and position as the polygon. Same as the `.contains()` method elsewhere. """ try: # do this using try:...except rather than hasattr() for speed poly = poly.verticesPix # we want to access this only once except Exception: pass nVert = len(poly) if nVert < 3: msg = 'pointInPolygon expects a polygon with 3 or more vertices' logging.warning(msg) return False # faster if have matplotlib tools: if haveMatplotlib: if matplotlib.__version__ > '1.2': return mplPath(poly).contains_point([x, y]) else: try: return bool(nxutils.pnpoly(x, y, poly)) except Exception: pass # fall through to pure python: # adapted from http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/ # via http://www.ariel.com.au/a/python-point-int-poly.html inside = False # trace (horizontal?) rays, flip inside status if cross an edge: p1x, p1y = poly[-1] for p2x, p2y in poly: if y > min(p1y, p2y) and y <= max(p1y, p2y) and x <= max(p1x, p2x): if p1y != p2y: xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x if p1x == p2x or x <= xints: inside = not inside p1x, p1y = p2x, p2y return inside
def pointInPolygon(x, y, poly): """Determine if a point is inside a polygon; returns True if inside. (`x`, `y`) is the point to test. `poly` is a list of 3 or more vertices as (x,y) pairs. If given an object, such as a `ShapeStim`, will try to use its vertices and position as the polygon. Same as the `.contains()` method elsewhere. """ try: # do this using try:...except rather than hasattr() for speed poly = poly.verticesPix # we want to access this only once except Exception: pass nVert = len(poly) if nVert < 3: msg = 'pointInPolygon expects a polygon with 3 or more vertices' logging.warning(msg) return False # faster if have matplotlib tools: if haveMatplotlib: if parse_version(matplotlib.__version__) > parse_version('1.2'): return mplPath(poly).contains_point([x, y]) else: try: return bool(nxutils.pnpoly(x, y, poly)) except Exception: pass # fall through to pure python: # adapted from http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/ # via http://www.ariel.com.au/a/python-point-int-poly.html inside = False # trace (horizontal?) rays, flip inside status if cross an edge: p1x, p1y = poly[-1] for p2x, p2y in poly: if y > min(p1y, p2y) and y <= max(p1y, p2y) and x <= max(p1x, p2x): if p1y != p2y: xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x if p1x == p2x or x <= xints: inside = not inside p1x, p1y = p2x, p2y return inside
def contains(self,mouseevent): """Test whether the mouse event occurred in the patch. Returns T/F, {} """ if callable(self._contains): return self._contains(self,mouseevent) try: l,b,w,h = self.get_window_extent().get_bounds() except: # TODO: why does this error occur #print str(self),"error looking at get_window_extent" return False,{} r = l+w t = b+h xyverts = (l,b), (l, t), (r, t), (r, b) x, y = mouseevent.x, mouseevent.y inside = nxutils.pnpoly(x, y, xyverts) return inside,{}
def contains(self, mouseevent): """Test whether the mouse event occurred in the patch. Returns T/F, {} """ if callable(self._contains): return self._contains(self, mouseevent) if not self.get_visible() or self._renderer is None: return False, {} l, b, w, h = self.get_window_extent().bounds r = l + w t = b + h xyverts = (l, b), (l, t), (r, t), (r, b) x, y = mouseevent.x, mouseevent.y inside = nxutils.pnpoly(x, y, xyverts) return inside, {}
def contains(self, mouseevent): """Test whether the mouse event occurred in the patch. Returns T/F, {} """ if callable(self._contains): return self._contains(self, mouseevent) try: l, b, w, h = self.get_window_extent().get_bounds() except: # TODO: why does this error occur #print str(self),"error looking at get_window_extent" return False, {} r = l + w t = b + h xyverts = (l, b), (l, t), (r, t), (r, b) x, y = mouseevent.x, mouseevent.y inside = nxutils.pnpoly(x, y, xyverts) return inside, {}
def drop(self): if self.state == GRASPING: #success = self.manager.put_down_object(self.grasp_arm, max_place_tries=25, use_place_override=1) place_pose = PoseStamped() ptt = self.transformAtLatestCommonTime('table', self.point) place_pose.header = ptt.header place_pose.pose.position = ptt.point place_pose.pose.orientation = euler_to_quaternion(0, 0, 0) place_pose.pose.position.z = 0.03 # see if it's in one of our predefined boxes pw, ph = 0.1, 0.1 #boxes = [('TRASH', TRASH), ('RECYCLING', RECYCLING)] boxes = [] for name, polygon in boxes: pts_arr = np.array([[(p.x, p.y) for p in polygon.polygon.points]]) print pts_arr if pnpoly(ptt.point.x, ptt.point.y, pts_arr.squeeze()): # we're doing this from the top right corner (don't ask) # place_pose.pose.position = polygon.polygon.points[0] poly_center = pts_arr.squeeze().mean(0) place_pose.pose.position.x = poly_center[0] place_pose.pose.position.y = poly_center[1] pw, ph = w, h rospy.loginfo('Placing in box: %s' % name) rospy.loginfo('Placing at %s' % place_pose) self.place_viz_pub.publish(place_pose) #import pdb; pdb.set_trace() self.manager.set_place_area(place_pose, (pw, ph)) # status = self.manager.place_object(self.grasp_arm, place_pose, padding=0) status = self.manager.put_down_object(self.grasp_arm, max_place_tries=25, use_place_override=1) if status == ManipulationResult.SUCCESS: self.state = NOTGRASPING self.grasp_arm = -1
def contains(self,mouseevent): """Test whether the mouse event occurred in the patch. In the case of text, a hit is true anywhere in the axis-aligned bounding-box containing the text. Returns True or False. """ if callable(self._contains): return self._contains(self,mouseevent) if not self.get_visible() or self._renderer is None: return False,{} l,b,w,h = self.get_window_extent().bounds r = l+w t = b+h xyverts = (l,b), (l, t), (r, t), (r, b) x, y = mouseevent.x, mouseevent.y inside = nxutils.pnpoly(x, y, xyverts) return inside,{}
def drop(self): if self.state == GRASPING: #success = self.manager.put_down_object(self.grasp_arm, max_place_tries=25, use_place_override=1) place_pose = PoseStamped() ptt = self.transformAtLatestCommonTime('table', self.point) place_pose.header = ptt.header place_pose.pose.position = ptt.point place_pose.pose.orientation = euler_to_quaternion(0,0,0) place_pose.pose.position.z = 0.03 # see if it's in one of our predefined boxes pw,ph = 0.1,0.1 #boxes = [('TRASH', TRASH), ('RECYCLING', RECYCLING)] boxes = [] for name, polygon in boxes: pts_arr = np.array([[(p.x,p.y) for p in polygon.polygon.points]]) print pts_arr if pnpoly(ptt.point.x, ptt.point.y, pts_arr.squeeze()): # we're doing this from the top right corner (don't ask) # place_pose.pose.position = polygon.polygon.points[0] poly_center = pts_arr.squeeze().mean(0) place_pose.pose.position.x = poly_center[0] place_pose.pose.position.y = poly_center[1] pw,ph = w,h rospy.loginfo('Placing in box: %s' % name) rospy.loginfo('Placing at %s' % place_pose) self.place_viz_pub.publish(place_pose) #import pdb; pdb.set_trace() self.manager.set_place_area(place_pose, (pw,ph)) # status = self.manager.place_object(self.grasp_arm, place_pose, padding=0) status = self.manager.put_down_object(self.grasp_arm, max_place_tries=25, use_place_override=1) if status == ManipulationResult.SUCCESS: self.state = NOTGRASPING self.grasp_arm = -1
def testGame(file_path): TEST_CASES = 100 game = gambit.read_game(file_path) vertices,edges = CorrEq.findPolygon(game) edges = CorrEq.removeExtraEdges(vertices,edges) constraints = deriveConstraints(game) points = CorrEq.orderVertices(edges) if points == None: points = vertices for i in range(TEST_CASES): # Pick a random probability distribution probs = [random() for j in range(len(game.contingencies))] # Ensure probabilities sum to 1 probs = [j/sum(probs) for j in probs] # Determine whether the distribution is a correlated equilibrium # It is if it satisfies the constraints in the LP is_corr_eq = True for j in constraints: if sum(multiply(probs,j)) < 0: is_corr_eq = False break u1,u2 = CorrEq.probsToUtilities(probs, game) inside = pnpoly(u1,u2,points) if is_corr_eq == True and inside == False: raise Exception('Test failed on: ' + file_path) print 'Test failed on: ' + file_path
def testGame(file_path): TEST_CASES = 100 game = gambit.read_game(file_path) vertices, edges = CorrEq.findPolygon(game) edges = CorrEq.removeExtraEdges(vertices, edges) constraints = deriveConstraints(game) points = CorrEq.orderVertices(edges) if points == None: points = vertices for i in range(TEST_CASES): # Pick a random probability distribution probs = [random() for j in range(len(game.contingencies))] # Ensure probabilities sum to 1 probs = [j / sum(probs) for j in probs] # Determine whether the distribution is a correlated equilibrium # It is if it satisfies the constraints in the LP is_corr_eq = True for j in constraints: if sum(multiply(probs, j)) < 0: is_corr_eq = False break u1, u2 = CorrEq.probsToUtilities(probs, game) inside = pnpoly(u1, u2, points) if is_corr_eq == True and inside == False: raise Exception('Test failed on: ' + file_path) print 'Test failed on: ' + file_path
def calculate_mass_center_in_support_plan(box, overlap_planes): """ 判斷目標貨物是否能夠被支點所支撐 透過 ConvexHull 演算法, 檢查目標貨物的重心 (x,y) 坐標, 是否在支點形成的凸面之中 """ from scipy.spatial import ConvexHull import matplotlib.nxutils as nx # 取出所有的支點 points = [] for left, right, top, bottom in overlap_planes: points.extend([ (left, top), (left, bottom), (right, top), (right, bottom) ]) # 計算支點形成的凸面 hull = ConvexHull(points) # 確認box重心是否在凸面之中 r = nx.pnpoly(box.center_x, box.center_y, hull) return r and True
def contains(self, mouseevent): """ Test whether the mouse event occurred in the collection. Returns T/F, dict(ind=itemlist), where every item in itemlist contains the event. """ if callable(self._contains): return self._contains(self,mouseevent) # TODO: Consider doing the test in data coordinates # Patch transforms the mouse into data coordinates and does the # test for membership there. This is more efficient though it # may not match the visual appearance of the polygon on the # screen. Regardless, patch and patch collection should use # the same algorithm. Here's the code in patch: # # x, y = self.get_transform().inverse_xy_tup((mouseevent.x, mouseevent.y)) # xyverts = self.get_verts() # inside = nxutils.pnpoly(x, y, xyverts) # ind = [] x, y = mouseevent.x, mouseevent.y for i, thispoly in enumerate(self.get_transformed_patches()): inside = nxutils.pnpoly(x, y, thispoly) if inside: ind.append(i) return len(ind)>0,dict(ind=ind)
def contains(self, mouseevent): """ Test whether the mouse event occurred in the collection. Returns T/F, dict(ind=itemlist), where every item in itemlist contains the event. """ if callable(self._contains): return self._contains(self, mouseevent) # TODO: Consider doing the test in data coordinates # Patch transforms the mouse into data coordinates and does the # test for membership there. This is more efficient though it # may not match the visual appearance of the polygon on the # screen. Regardless, patch and patch collection should use # the same algorithm. Here's the code in patch: # # x, y = self.get_transform().inverse_xy_tup((mouseevent.x, mouseevent.y)) # xyverts = self.get_verts() # inside = nxutils.pnpoly(x, y, xyverts) # ind = [] x, y = mouseevent.x, mouseevent.y for i, thispoly in enumerate(self.get_transformed_patches()): inside = nxutils.pnpoly(x, y, thispoly) if inside: ind.append(i) return len(ind) > 0, dict(ind=ind)
for record in data: if 'Graffiti' in record.split(',')[5]: graffitis.append(record) # Get id, datetime, point(lat, lng) formatted_graffitis = [] for record in graffitis: array = record.split(',') formatted_graffitis.append([array[0], datetime.strptime(array[1], "%m/%d/%Y %I:%M:%S %p"), Point((array[49], array[50]))]) # Graffiti in 2013 w/ coordinates formatted_graffitis_2013 = [] for record in formatted_graffitis: if record[1].year == 2013 and nx.pnpoly(record[2].latitude, record[2].longitude, lower_manhattan) == 1: formatted_graffitis_2013.append(record) # sort by time formatted_graffitis.sort(key=itemgetter(1), reverse=True) # get in months formatted_graffitis_2013_month_dict = {} for i in range(1, 13): l = [] for record in formatted_graffitis_2013: if record[1].month == i: l.append(record) formatted_graffitis_2013_month_dict[i] = l # Get Noise Data
def find_nearestgridpoints(longitude, latitude, grd, Cpos="rho"): if type(grd).__name__ == "ROMS_Grid": if Cpos is "u": lon = grd.hgrid.lon_u[:, :] lat = grd.hgrid.lat_u[:, :] elif Cpos is "v": lon = grd.hgrid.lon_v[:, :] lat = grd.hgrid.lat_v[:, :] elif Cpos is "rho": lon = grd.hgrid.lon_rho[:, :] lat = grd.hgrid.lat_rho[:, :] elif Cpos is "vert": lon = grd.hgrid.lon_vert[:, :] lat = grd.hgrid.lat_vert[:, :] else: raise Warning, "%s bad position. Cpos must be rho, u or v." % Cpos if type(grd).__name__ == "CGrid_geo": if Cpos is "u": lon = grd.lon_u[:, :] lat = grd.lat_u[:, :] elif Cpos is "v": lon = grd.lon_v[:, :] lat = grd.lat_v[:, :] elif Cpos is "rho": lon = grd.lon_rho[:, :] lat = grd.lat_rho[:, :] elif Cpos is "vert": lon = grd.lon_vert[:, :] lat = grd.lat_vert[:, :] else: raise Warning, "%s bad position. Cpos must be rho, u or v." % Cpos dlon = lon[:, :] - longitude dlat = lat[:, :] - latitude diff = (dlon * dlon) + (dlat * dlat) jidx, iidx = np.where(diff == diff.min()) iidx = iidx[0] # take element 1 in case min dist is not unique jidx = jidx[0] try: iindex = [iidx, iidx + 1, iidx + 1, iidx] jindex = [jidx, jidx, jidx + 1, jidx + 1] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: iindex = [iidx, iidx + 1, iidx + 1, iidx] jindex = [jidx - 1, jidx - 1, jidx, jidx] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: iindex = [iidx - 1, iidx, iidx, iidx - 1] jindex = [jidx - 1, jidx - 1, jidx, jidx] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: iindex = [iidx - 1, iidx, iidx, iidx - 1] jindex = [jidx, jidx, jidx + 1, jidx + 1] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: raise ValueError, "well where is it then?" iindex = iindex[:2] jindex = jindex[1:3] except: # print 'point (%f, %f) is not in the grid' %(longitude, latitude) iindex = [] jindex = [] return iindex, jindex
#!/usr/bin/env python import os, sys, time import matplotlib.nxutils as nxutils import matplotlib.numerix as nx def report_memory(i): pid = os.getpid() a2 = os.popen('ps -p %d -o rss,sz' % pid).readlines() print i, ' ', a2[1], return int(a2[1].split()[1]) for i in range(500): report_memory(i) verts = nx.mlab.rand(100, 2) b = nxutils.pnpoly(x, y, verts) for i in range(500): report_memory(i) verts = nx.mlab.rand(100, 2) points = nx.mlab.rand(10000,2) mask = nxutils.points_inside_poly(points, verts)
def poly_contains(self, poly, pt): """Check whether a polynomial contains pt.""" poly = numpy.array(poly, float) nxutils.pnpoly(pt[0], pt[1], poly)
def in_image(x, y, proj='healpix_sphere', north=0, south=0): r""" Return True if `(x, y)` lies in the image of the projection `proj` of the unit sphere, where `proj` is either 'healpix_sphere' or 'rhealpix_sphere' and `north` and `south` indicate the positions of the polar squares in case `proj` = 'rhealpix_sphere'. Return False otherwise. EXAMPLES:: >>> eps = 0 # Test boundary points. >>> hp = [ ... (-pi - eps, pi/4), ... (-3*pi/4, pi/2 + eps), ... (-pi/2, pi/4 + eps), ... (-pi/4, pi/2 + eps), ... (0, pi/4 + eps), ... (pi/4, pi/2 + eps), ... (pi/2, pi/4 + eps), ... (3*pi/4, pi/2 + eps), ... (pi + eps, pi/4), ... (pi + eps,-pi/4), ... (3*pi/4,-pi/2 - eps), ... (pi/2,-pi/4 - eps), ... (pi/4,-pi/2 - eps), ... (0,-pi/4 - eps), ... (-pi/4,-pi/2 - eps), ... (-pi/2,-pi/4 - eps), ... (-3*pi/4,-pi/2 - eps), ... (-pi - eps,-pi/4) ... ] >>> for p in hp: ... if not in_image(*p): ... print 'Fail' ... >>> in_image(0, 0) True >>> in_image(0, pi/4 + 0.1) False >>> eps = 0 # Test boundary points. >>> north, south = 0, 0 >>> rhp = [ ... (-pi - eps, pi/4 + eps), ... (-pi + north*pi/2 - eps, pi/4 + eps), ... (-pi + north*pi/2 - eps, 3*pi/4 + eps), ... (-pi + (north + 1)*pi/2 + eps, 3*pi/4 + eps), ... (-pi + (north + 1)*pi/2 + eps, pi/4 + eps), ... (pi + eps, pi/4 + eps), ... (pi + eps,-pi/4 - eps), ... (-pi + (south + 1)*pi/2 + eps,-pi/4 - eps), ... (-pi + (south + 1)*pi/2 + eps,-3*pi/4 - eps), ... (-pi + south*pi/2 - eps,-3*pi/4 - eps), ... (-pi + south*pi/2 -eps,-pi/4 - eps), ... (-pi - eps,-pi/4 - eps) ... ] >>> for p in rhp: ... if not in_image(*p, proj='rhealpix_sphere'): ... print 'Fail' ... >>> in_image(0, 0,proj='rhealpix_sphere') True >>> in_image(0, pi/4 + 0.1, proj='rhealpix_sphere') False """ # matplotlib is a third-party module. from matplotlib.nxutils import pnpoly # Fuzz to slightly expand (r)HEALPix image boundary so that pnpoly() # counts points on the original boundary as lying in the image. eps = 1e-12 if proj == 'healpix_sphere': vertices = [(-pi - eps, pi / 4), (-3 * pi / 4, pi / 2 + eps), (-pi / 2, pi / 4 + eps), (-pi / 4, pi / 2 + eps), (0, pi / 4 + eps), (pi / 4, pi / 2 + eps), (pi / 2, pi / 4 + eps), (3 * pi / 4, pi / 2 + eps), (pi + eps, pi / 4), (pi + eps, -pi / 4), (3 * pi / 4, -pi / 2 - eps), (pi / 2, -pi / 4 - eps), (pi / 4, -pi / 2 - eps), (0, -pi / 4 - eps), (-pi / 4, -pi / 2 - eps), (-pi / 2, -pi / 4 - eps), (-3 * pi / 4, -pi / 2 - eps), (-pi - eps, -pi / 4)] else: # Assume proj == 'rhealpix_sphere' vertices = [(-pi - eps, pi / 4 + eps), (-pi + north * pi / 2 - eps, pi / 4 + eps), (-pi + north * pi / 2 - eps, 3 * pi / 4 + eps), (-pi + (north + 1) * pi / 2 + eps, 3 * pi / 4 + eps), (-pi + (north + 1) * pi / 2 + eps, pi / 4 + eps), (pi + eps, pi / 4 + eps), (pi + eps, -pi / 4 - eps), (-pi + (south + 1) * pi / 2 + eps, -pi / 4 - eps), (-pi + (south + 1) * pi / 2 + eps, -3 * pi / 4 - eps), (-pi + south * pi / 2 - eps, -3 * pi / 4 - eps), (-pi + south * pi / 2 - eps, -pi / 4 - eps), (-pi - eps, -pi / 4 - eps)] return bool(pnpoly(x, y, vertices))
def calculate_dvh(structure, dose, limit=None, callback=None): """Calculate the differential DVH for the given structure and dose grid.""" sPlanes = structure['planes'] logger.debug("Calculating DVH of %s %s", structure['id'], structure['name']) # Get the dose to pixel LUT doselut = dose.GetPatientToPixelLUT() # Generate a 2d mesh grid to create a polygon mask in dose coordinates # Code taken from Stack Overflow Answer from Joe Kington: # http://stackoverflow.com/questions/3654289/scipy-create-2d-polygon-mask/3655582 # Create vertex coordinates for each grid cell x, y = np.meshgrid(np.array(doselut[0]), np.array(doselut[1])) x, y = x.flatten(), y.flatten() dosegridpoints = np.vstack((x,y)).T # Create an empty array of bins to store the histogram in cGy # only if the structure has contour data or the dose grid exists if ((len(sPlanes)) and ("PixelData" in dose.ds)): # Get the dose and image data information dd = dose.GetDoseData() id = dose.GetImageData() maxdose = int(dd['dosemax'] * dd['dosegridscaling'] * 100) # Remove values above the limit (cGy) if specified if not (limit == None): if (limit < maxdose): maxdose = limit hist = np.zeros(maxdose) else: hist = np.array([0]) volume = 0 plane = 0 # Iterate over each plane in the structure for z, sPlane in sPlanes.iteritems(): # Get the contours with calculated areas and the largest contour index contours, largestIndex = calculate_contour_areas(sPlane) # Get the dose plane for the current structure plane doseplane = dose.GetDoseGrid(z) # If there is no dose for the current plane, go to the next plane if not len(doseplane): break # Calculate the histogram for each contour for i, contour in enumerate(contours): m = get_contour_mask(doselut, dosegridpoints, contour['data']) h, vol = calculate_contour_dvh(m, doseplane, maxdose, dd, id, structure) # If this is the largest contour, just add to the total histogram if (i == largestIndex): hist += h volume += vol # Otherwise, determine whether to add or subtract histogram # depending if the contour is within the largest contour or not else: contour['inside'] = False for point in contour['data']: if nx.pnpoly(point[0], point[1], np.array(contours[largestIndex]['data'])): contour['inside'] = True # Assume if one point is inside, all will be inside break # If the contour is inside, subtract it from the total histogram if contour['inside']: hist -= h volume -= vol # Otherwise it is outside, so add it to the total histogram else: hist += h volume += vol plane += 1 if not (callback == None): callback(plane, len(sPlanes)) # Volume units are given in cm^3 volume = volume/1000 # Rescale the histogram to reflect the total volume hist = hist*volume/sum(hist) # Remove the bins above the max dose for the structure hist = np.trim_zeros(hist, trim='b') return hist
def paintEvent(self, e): if rospy.is_shutdown(): QtGui.QApplication.quit() # circle the objects r = 150 self.SCREEN_HEIGHT = self.height() self.SCREEN_WIDTH = self.width() cursor_coords = None with self.object_lock: # Draw the circles if self.objects is not None and self.projected_objects is not None and self.circle_objects: # is dist(cursor,pt) <= dist(cursor,obj) for all obj? cursor = np.median(self.projected_cursor, 0) distances = [ self.dist(pp, cursor) for pp in self.projected_objects[0] ] closest_pt = self.projected_objects[0, np.argmin(distances)] for pt, xformed in zip(self.objects[0], self.projected_objects[0]): qp = QtGui.QPainter() qp.begin(self) qp.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing) color = Colors.WHITE if self.isHilighted(pt): # color = self.getHilightColor(pt) inner_pen = qp.pen() inner_pen.setWidth(6) inner_pen.setColor(self.getHilightColor(pt)) qp.setPen(inner_pen) coords = self.maybe_flip((xformed[1], xformed[0])) inner_rect = QtCore.QRectF( self.SCREEN_WIDTH - coords[0] - r / 2 + X_OFFSET + 5, self.SCREEN_HEIGHT - coords[1] - r / 2 + Y_OFFSET + 5, r - 10, r - 10) qp.drawArc(inner_rect, 0, 360 * 16) if (self.use_selected_thresh and self.isSelected(xformed)) or\ (not self.use_selected_thresh and all(xformed==closest_pt)): self.selected_pt = pt color = Colors.GREEN else: self.selected_pt = CLICK_RESET # is it the clicked point? if self.sameObject(pt, self.click_loc): color = Colors.BLUE qp.setPen(color) pen = qp.pen() pen.setWidth(5) qp.setPen(pen) coords = self.maybe_flip((xformed[1], xformed[0])) rect = QtCore.QRectF(coords[0] - r / 2 + X_OFFSET, coords[1] - r / 2 + Y_OFFSET, r, r) qp.drawArc(rect, 0, 360 * 16) qp.end() # draw the cursor r = 10 with self.object_lock: if self.cursor_pts is not None and len( self.projected_cursor) > 0: xformed = np.median(self.projected_cursor, 0) coords = self.maybe_flip((xformed[1], xformed[0])) cursor_x = coords[0] cursor_y = coords[1] qp = QtGui.QPainter() qp.begin(self) qp.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing) color = Colors.BLUE qp.setPen(color) pen = qp.pen() pen.setWidth(5) qp.setPen(pen) # if the cursor is on-screen, draw it if cursor_x > 0 and cursor_y > 0 and cursor_x < self.SCREEN_WIDTH and cursor_y < self.SCREEN_HEIGHT: rect = QtCore.QRectF( cursor_x - r / 2, # + X_OFFSET, cursor_y - r / 2, # + Y_OFFSET, r, r) qp.drawArc(rect, 0, 360 * 16) # if the cursor is off screen, draw a hint as to where it is else: hint_x = cursor_x if cursor_x < 0: hint_x = 0 if cursor_x > self.SCREEN_WIDTH: hint_x = self.SCREEN_WIDTH hint_y = cursor_y if cursor_y < 0: hint_y = 0 if cursor_y > self.SCREEN_HEIGHT: hint_y = self.SCREEN_HEIGHT head = np.array([hint_x, hint_y]) # + [X_OFFSET, Y_OFFSET] tail_x, tail_y = 0, 0 if hint_x == 0: tail_x = 50 if hint_x == self.SCREEN_WIDTH: tail_x = -50 if hint_y == 0: tail_y = 50 if hint_y == self.SCREEN_HEIGHT: tail_y = -50 tail = head + [tail_x, tail_y] pen.setWidth(r) qp.setPen(pen) qp.drawLine(head[0], head[1], tail[0], tail[1]) qp.end() # draw any polygons qp = QtGui.QPainter() qp.begin(self) qp.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing) for uid, (polygon, color, label, text_rect) in self.polygons.iteritems(): poly = PySide.QtGui.QPolygon() pts_arr = np.array([[(p.x, p.y, p.z) for p in polygon.polygon.points]]) points = self.projectPoints(pts_arr, polygon.header) points = cv2.perspectiveTransform(points, self.H) if self.flip: points[0] = ([self.SCREEN_HEIGHT, self.SCREEN_WIDTH] - points[0]) if self.cursor_pts is not None and len( self.projected_cursor) > 0: if pnpoly(cursor_y, cursor_x, points[0]): color = Colors.GREEN self.selected_pt = np.array(pts_arr.squeeze().mean(0)) selected_pt_xformed = self.projectPoints( np.array([[self.click_loc.squeeze()]]), polygon.header) selected_pt_xformed = cv2.perspectiveTransform( selected_pt_xformed, self.H).squeeze() if pnpoly(selected_pt_xformed[0], selected_pt_xformed[1], points[0]): color = Colors.BLUE if not self.click_stale: self.clicked_object_pub.publish(uid) self.click_stale = True qp.setPen(color) pen = qp.pen() pen.setWidth(5) qp.setPen(pen) for point in points[0]: poly.push_back(PySide.QtCore.QPoint(point[1], point[0])) qp.drawPolygon(poly) origin = points[0].min(0) size = points[0].max(0) - origin textRect = poly.boundingRect() if len(text_rect.points) > 0: text_rect_points = self.projectPoints( np.array([[(p.x, p.y, p.z) for p in text_rect.points]]), polygon.header) text_rect_points = cv2.perspectiveTransform( text_rect_points, self.H) if self.flip: text_rect_points[0] = ( [self.SCREEN_HEIGHT, self.SCREEN_WIDTH] - text_rect_points[0]) text_poly = PySide.QtGui.QPolygon() for point in text_rect_points[0]: text_poly.push_back( PySide.QtCore.QPoint(point[1], point[0])) textRect = text_poly.boundingRect() qp.setFont(QtGui.QFont('Decorative', 30)) qp.drawText(textRect, QtCore.Qt.AlignCenter | QtCore.Qt.TextWordWrap, label) # reset once the click has expired if (rospy.Time.now() - self.click) >= self.click_duration: self.click_loc = CLICK_RESET self.click_stale = False self.click_duration = rospy.Duration(2.0) self.rate_pub.publish()
def find_nearestgridpoints(longitude, latitude, grd, Cpos='rho'): if type(grd).__name__ == 'ROMS_Grid': if Cpos is 'u': lon = grd.hgrid.lon_u[:,:] lat = grd.hgrid.lat_u[:,:] elif Cpos is 'v': lon = grd.hgrid.lon_v[:,:] lat = grd.hgrid.lat_v[:,:] elif Cpos is 'rho': lon = grd.hgrid.lon_rho[:,:] lat = grd.hgrid.lat_rho[:,:] elif Cpos is 'vert': lon = grd.hgrid.lon_vert[:,:] lat = grd.hgrid.lat_vert[:,:] else: raise Warning, '%s bad position. Cpos must be rho, u or v.' % Cpos if type(grd).__name__ == 'CGrid_geo': if Cpos is 'u': lon = grd.lon_u[:,:] lat = grd.lat_u[:,:] elif Cpos is 'v': lon = grd.lon_v[:,:] lat = grd.lat_v[:,:] elif Cpos is 'rho': lon = grd.lon_rho[:,:] lat = grd.lat_rho[:,:] elif Cpos is 'vert': lon = grd.lon_vert[:,:] lat = grd.lat_vert[:,:] else: raise Warning, '%s bad position. Cpos must be rho, u or v.' % Cpos dlon = lon[:,:] - longitude dlat = lat[:,:] - latitude diff = (dlon * dlon) + (dlat * dlat) jidx, iidx = np.where(diff==diff.min()) iidx = iidx[0] # take element 1 in case min dist is not unique jidx = jidx[0] try: iindex = [iidx, iidx+1, iidx+1, iidx] jindex = [jidx, jidx, jidx+1, jidx+1] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: iindex = [iidx, iidx+1, iidx+1, iidx] jindex = [jidx-1, jidx-1, jidx, jidx] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: iindex = [iidx-1, iidx, iidx, iidx-1] jindex = [jidx-1, jidx-1, jidx, jidx] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: iindex = [iidx-1, iidx, iidx, iidx-1] jindex = [jidx, jidx, jidx+1, jidx+1] xp = lon[jindex, iindex] yp = lat[jindex, iindex] verts = [] for n in range(4): verts.append([xp[n], yp[n]]) inside = pnpoly(longitude, latitude, verts) if inside == 0: raise ValueError, 'well where is it then?' iindex = iindex[:2] jindex = jindex[1:3] except: #print 'point (%f, %f) is not in the grid' %(longitude, latitude) iindex = [] jindex = [] return iindex, jindex
def calculate_dvh(structure, dose, limit=None, callback=None): """Calculate the differential DVH for the given structure and dose grid.""" sPlanes = structure['planes'] logger.debug("Calculating DVH of %s %s", structure['id'], structure['name']) # Get the dose to pixel LUT doselut = dose.GetPatientToPixelLUT() # Generate a 2d mesh grid to create a polygon mask in dose coordinates # Code taken from Stack Overflow Answer from Joe Kington: # http://stackoverflow.com/questions/3654289/scipy-create-2d-polygon-mask/3655582 # Create vertex coordinates for each grid cell x, y = np.meshgrid(np.array(doselut[0]), np.array(doselut[1])) x, y = x.flatten(), y.flatten() dosegridpoints = np.vstack((x, y)).T # Create an empty array of bins to store the histogram in cGy # only if the structure has contour data or the dose grid exists if ((len(sPlanes)) and ("PixelData" in dose.ds)): # Get the dose and image data information dd = dose.GetDoseData() id = dose.GetImageData() maxdose = int(dd['dosemax'] * dd['dosegridscaling'] * 100) # Remove values above the limit (cGy) if specified if not (limit == None): if (limit < maxdose): maxdose = limit hist = np.zeros(maxdose) else: hist = np.array([0]) volume = 0 plane = 0 # Iterate over each plane in the structure for z, sPlane in sPlanes.iteritems(): # Get the contours with calculated areas and the largest contour index contours, largestIndex = calculate_contour_areas(sPlane) # Get the dose plane for the current structure plane doseplane = dose.GetDoseGrid(z) # If there is no dose for the current plane, go to the next plane if not len(doseplane): break # Calculate the histogram for each contour for i, contour in enumerate(contours): m = get_contour_mask(doselut, dosegridpoints, contour['data']) h, vol = calculate_contour_dvh(m, doseplane, maxdose, dd, id, structure) # If this is the largest contour, just add to the total histogram if (i == largestIndex): hist += h volume += vol # Otherwise, determine whether to add or subtract histogram # depending if the contour is within the largest contour or not else: contour['inside'] = False for point in contour['data']: if nx.pnpoly(point[0], point[1], np.array(contours[largestIndex]['data'])): contour['inside'] = True # Assume if one point is inside, all will be inside break # If the contour is inside, subtract it from the total histogram if contour['inside']: hist -= h volume -= vol # Otherwise it is outside, so add it to the total histogram else: hist += h volume += vol plane += 1 if not (callback == None): callback(plane, len(sPlanes)) # Volume units are given in cm^3 volume = volume / 1000 # Rescale the histogram to reflect the total volume hist = hist * volume / sum(hist) # Remove the bins above the max dose for the structure hist = np.trim_zeros(hist, trim='b') return hist
""" Another broken test... """ import os, sys, time import matplotlib.nxutils as nxutils from numpy.random import rand def report_memory(i): pid = os.getpid() a2 = os.popen('ps -p %d -o rss,sz' % pid).readlines() print i, ' ', a2[1], return int(a2[1].split()[1]) for i in range(500): report_memory(i) verts = rand(100, 2) b = nxutils.pnpoly(x, y, verts) # x, y don't exist for i in range(500): report_memory(i) verts = rand(100, 2) points = rand(10000,2) mask = nxutils.points_inside_poly(points, verts)
#!/usr/bin/env python """ Another broken test... """ from __future__ import print_function import os, sys, time import matplotlib.nxutils as nxutils from numpy.random import rand def report_memory(i): pid = os.getpid() a2 = os.popen('ps -p %d -o rss,sz' % pid).readlines() print(i, ' ', a2[1], end='') return int(a2[1].split()[1]) for i in range(500): report_memory(i) verts = rand(100, 2) b = nxutils.pnpoly(x, y, verts) # x, y don't exist for i in range(500): report_memory(i) verts = rand(100, 2) points = rand(10000, 2) mask = nxutils.points_inside_poly(points, verts)