def transform_path_non_affine(self, src_path): """ Transforms from source to target coordinates. Caches results, so subsequent calls with the same *src_path* argument (and the same source and target projections) are faster. Args: * src_path - A matplotlib :class:`~matplotlib.path.Path` object with vertices in source coordinates. Returns * A matplotlib :class:`~matplotlib.path.Path` with vertices in target coordinates. """ mapping = _PATH_TRANSFORM_CACHE.get(src_path) if mapping is not None: key = (self.source_projection, self.target_projection) result = mapping.get(key) if result is not None: return result # Allow the vertices to be quickly transformed, if # quick_vertices_transform allows it. new_vertices = self.target_projection.quick_vertices_transform( src_path.vertices, self.source_projection) if new_vertices is not None: if new_vertices is src_path.vertices: return src_path else: return mpath.Path(new_vertices, src_path.codes) if src_path.vertices.shape == (1, 2): return mpath.Path(self.transform(src_path.vertices)) transformed_geoms = [] for geom in patch.path_to_geos(src_path): transformed_geoms.append( self.target_projection.project_geometry(geom, self.source_projection) ) if not transformed_geoms: result = mpath.Path(np.empty([0, 2])) else: paths = patch.geos_to_path(transformed_geoms) if not paths: return mpath.Path(np.empty([0, 2])) points, codes = zip(*[patch.path_segments(path, curves=False, simplify=False) for path in paths]) result = mpath.Path(np.concatenate(points, 0), np.concatenate(codes)) # store the result in the cache for future performance boosts key = (self.source_projection, self.target_projection) if mapping is None: _PATH_TRANSFORM_CACHE[src_path] = {key: result} else: mapping[key] = result return result