def pc_generate_cyflannKDTree(pc_xyz): #conda install -y -c conda-forge cyflann try: import cyflann except ImportError: raise pc_generate_cyflannKDTree("pyflann not installed.") cyflann.set_distance_type('euclidean') pc_xyz_cyflannKDTree_tree = cyflann.FLANNIndex() pc_xyz_cyflannKDTree_tree.build_index(pc_xyz, algorithm='kdtree_single') return pc_xyz_cyflannKDTree_tree
def test_pickle(): data = np.random.normal(scale=100, size=(1000, 3)) query = np.random.normal(scale=100, size=(100, 3)) idx = cyflann.FLANNIndex(algorithm='kdtree_single') idx.build_index(data) res_i, res_dists = idx.nn_index(query, 2) s = pickle.dumps(idx) del idx idx = pickle.loads(s) res_i2, res_dists2 = idx.nn_index(query, 2) assert np.all(res_i == res_i2)
def flann_from_typedbytes(inp, tempdir=_not_passed): if tempdir is _not_passed: tempdir = DEFAULT_TEMPDIR register_read_ndarray(inp) length = inp.read_int() pts = inp._read() index_bytes = inp.read_bytestring() with tempfile.NamedTemporaryFile(dir=tempdir) as f: f.write(index_bytes) f.flush() del index_bytes index = cyflann.FLANNIndex() index.load_index(f.name, pts) return index
def test_normal(dim, k): data = np.random.normal(scale=100, size=(1000, dim)) query = np.random.normal(scale=100, size=(100, dim)) py = pyflann.FLANN(algorithm='kdtree_single') cy = cyflann.FLANNIndex(algorithm='kdtree_single') py.build_index(data) cy.build_index(data) py_ids, py_dists = py.nn_index(query, k) cy_ids, cy_dists = cy.nn_index(query, k) assert np.all(py_ids == cy_ids), \ "{}/{} different".format(np.sum(py_ids != cy_ids), py_ids.size) assert np.allclose(py_dists, cy_dists, atol=1e-5, rtol=1e-4), \ "max distance {}".format(np.abs(py_dists - cy_dists).max())
def test_normal(): for dim in [1, 4, 10]: for k in [1, 2, 5]: data = np.random.normal(scale=100, size=(1000, dim)) query = np.random.normal(scale=100, size=(100, dim)) py = pyflann.FLANN(algorithm='kdtree_single') cy = cyflann.FLANNIndex(algorithm='kdtree_single') py.build_index(data) cy.build_index(data) py_ids, py_dists = py.nn_index(query, k) cy_ids, cy_dists = cy.nn_index(query, k) f = partial(check_match, py_ids, py_dists, cy_ids, cy_dists) f.description = 'normal vs pyflann - dim {} - k {}'.format(dim, k) yield f
def test_typedbytes_flann(): pts = np.random.normal(size=(100, 2)) for algorithm in ['kdtree_single', 'linear']: idx = cyflann.FLANNIndex(algorithm=algorithm) idx.build_index(pts) with closing(StringIO()) as sio: out = tb.Output(sio) register_write(out) out.write(idx) sio.seek(0) inp = tb.Input(sio) register_read(inp) idx2 = inp.read() fn = partial(_check_flann, idx, idx2) fn.description = "flann typedbytes io - {}".format(algorithm) yield fn
def fit(self, x, y, f=0.005, iterr=3, order=1): """ Locally smoothed regression with the LOWESS algorithm. Parameters ---------- x: float [n, dim] array Values of x for which f(x) is known (e.g. measured). The shape of this is (n, dim), where dim is the number the dimensions and n is the number of distinct coordinates sampled. y: float [n, ] array The known values of f(x) at these points. This has shape (n,) f: int bandwidth or smoothing parameter. Determines how much of the data is used to fit each local polynomial. 0.1 means 10% of the data is used to fit a single data point. Default: 0.005 iterr: int Determines how often a robust weighted fit is conducted. iterr > 1: aapply the robustification procedure from [Cleveland79], page 831 Default: 3 order: int The degree of smoothing functions. 1 is locally linear, 2 locally quadratic, etc. Default: 1 """ self.x = x self.y = y n = y.size x_dim = x.shape[-1] self.r = int(ceil(f * n)) timer = time.time() X = x #nbrs = NearestNeighbors(n_neighbors=self.r, algorithm='ball_tree', n_jobs=-1).fit(X) #distances, self.indices = nbrs.kneighbors(X) #tree = spatial.KDTree(X) #distances, self.indices = tree.query(X, k=self.r) cy = cyflann.FLANNIndex(algorithm='kdtree_single') cy.build_index(X) self.indices, distances = cy.nn_index(X, self.r) distances = np.sqrt(distances) time_for_kNN = time.time() - timer print "%0.2fsec needed for kNN" % time_for_kNN self.w = np.clip(distances/distances[: ,-1][:, None], 0.0, 1.0) self.w = (1 - self.w ** 3) ** 3 positions = [range(x_dim+1)]*order permutations = list(itertools.product(*positions)) sorted_permutations = [sorted(a) for a in permutations] self.permutation_indeces = [list(b) for b in set(tuple(b) for b in sorted_permutations)] self.permutation_indeces.sort() yest = np.zeros(n) self.delta = np.ones(n) for iteration in range(iterr): # Process each voxel p = parallelization(display=True) yest_list = p.start(self.single_voxel_fit, n, range(n)) yest = np.asarray(yest_list) residuals = y - yest s = np.median(np.abs(residuals)) self.delta = np.clip(residuals / (6.0 * s), -1, 1) self.delta = (1 - self.delta ** 2) ** 2 return yest