{ "cells": [ { "cell_type": "markdown", "id": "6f2aeb62", "metadata": {}, "source": [ "# Cloud vertices, What is it ?\n", "\n", "## Basics \n", "\n", "Cloud vertices is a synonym for point cloud. It is a group of points in a 3D space.\n", "\n", "It can be initialized from:\n", "\n", "- a list of vertices\n", "- a numpy array (shape (N, 3))\n", "- an Excel file\n", "- a CSV file (with/without header)\n", "- a Shape file (point type)\n", "- a DXF file (MTEXT or INSERT)\n", "\n", "Each point can have associated values.\n", "\n", "## Storage\n", "\n", "All vertices are stored in a dictionnary. The main key is the index of the point in the list. \n", "\n", "Each entry is a dictionnary with at least the following key : `vertex` (the `wolf_vertex` instance).\n", "\n", "Other keys can be added to store additional information.\n", "\n", "## Properties\n", "\n", "The cloud has a `cloudproperties` attribute that contains some properties (mainly for visualization in OpenGL).\n", "\n", "## KD-tree\n", "\n", "A KD-tree is a data structure that allows for efficient nearest neighbor searches in a multi-dimensional space. It is particularly useful for spatial queries, such as finding the closest points in a point cloud.\n", "\n", "Each instance of `cloud_vertices` has a KD-tree associated with it. The KD-tree is built using the vertices of the point cloud, and it allows for fast nearest neighbor searches.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "72cdbc36", "metadata": {}, "outputs": [], "source": [ "import _add_path # this line can be deleted if wolfhece is installed as a package (-> debug mode only)\n", "\n", "from wolfhece import __version__\n", "assert __version__ > '2.2.9', f'Bad version of wolfhece: {__version__} <= 2.2.9'\n", "\n", "from wolfhece.PyVertex import cloud_vertices, wolfvertex\n", "\n", "import numpy as np" ] }, { "cell_type": "markdown", "id": "d7d31aa5", "metadata": {}, "source": [ "## Create a new cloud_vertices instance\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "1ef57f2b", "metadata": {}, "outputs": [], "source": [ "vertices = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]])\n", "\n", "cloud = cloud_vertices()\n", "\n", "cloud.init_from_nparray(vertices)" ] }, { "cell_type": "code", "execution_count": 3, "id": "bc2cf58f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "False\n", "[]\n" ] } ], "source": [ "# number of vertices\n", "print(cloud.nbvertices)\n", "\n", "# Header information\n", "print(cloud.has_values)\n", "print(cloud.header)" ] }, { "cell_type": "markdown", "id": "2e431be2", "metadata": {}, "source": [ "## Plot by matplotlib" ] }, { "cell_type": "code", "execution_count": 4, "id": "c2dcf995", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
, )" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cloud.plot_matplotlib()" ] }, { "cell_type": "markdown", "id": "a4d6f4dc", "metadata": {}, "source": [ "## Get coordinates of the vertices" ] }, { "cell_type": "code", "execution_count": 4, "id": "856f63b4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0. 0. 0.]\n", " [1. 1. 1.]\n", " [2. 2. 2.]\n", " [3. 3. 3.]\n", " [4. 4. 4.]]\n" ] } ], "source": [ "xyz = cloud.xyz # -> np.ndarray with shape (n,3)\n", "\n", "print(xyz)" ] }, { "cell_type": "markdown", "id": "3e71f649", "metadata": {}, "source": [ "## Add a value" ] }, { "cell_type": "code", "execution_count": 5, "id": "55190f85", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['vertex', 'test']\n" ] } ], "source": [ "new_val = np.array([1, 2, 3, 4, 5])\n", "\n", "cloud.add_values_by_id_list('test', new_val)\n", "\n", "print(cloud.header)" ] }, { "cell_type": "markdown", "id": "555d0124", "metadata": {}, "source": [ "## Get coordinates but value as z" ] }, { "cell_type": "code", "execution_count": 6, "id": "4713f371", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0. 0. 1.]\n", " [1. 1. 2.]\n", " [2. 2. 3.]\n", " [3. 3. 4.]\n", " [4. 4. 5.]]\n" ] } ], "source": [ "xyz_val = cloud.get_xyz('test')\n", "\n", "print(xyz_val)" ] }, { "cell_type": "markdown", "id": "e08be8e1", "metadata": {}, "source": [ "## Find the nearest vertex" ] }, { "cell_type": "code", "execution_count": 7, "id": "320212ec", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "distance: 0.7071067811865476\n", "vertex: 0.0 0.0 0.0\n", "key: {'vertex': , 'test': np.int64(1)}\n" ] } ], "source": [ "nb = 1\n", "dist, vert, assoc_dict = cloud.find_nearest([[.5, .5, 0.]], nb= nb)\n", "\n", "# If the number of neighbors is 1, the output is a single list of vertices and distances\n", "# If the number of neighbors is greater than 1, the output is a list of lists of vertices and distances\n", "\n", "print('distance:', dist)\n", "print('vertex:', vert.x, vert.y, vert.z)\n", "print('key:', assoc_dict)" ] }, { "cell_type": "markdown", "id": "69c747ec", "metadata": {}, "source": [ "## Find the nearest vertices\n", "\n", "nb = 2" ] }, { "cell_type": "code", "execution_count": 8, "id": "cdb540cf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "number of neighbors: 2\n", "distance: 0.7071067811865476\n", "vertex: 0.0 0.0 0.0\n", "key: {'vertex': , 'test': np.int64(1)}\n", "distance: 1.224744871391589\n", "vertex: 1.0 1.0 1.0\n", "key: {'vertex': , 'test': np.int64(2)}\n" ] } ], "source": [ "nb = 2\n", "dist, vert, assoc_dict = cloud.find_nearest(np.asarray([[.5, .5, 0.]]), nb= nb)\n", "\n", "# If the number of neighbors is 1, the output is a single list of vertices and distances\n", "# If the number of neighbors is greater than 1, the output is a list of lists of vertices and distances\n", "\n", "print('number of neighbors:', len(dist))\n", "\n", "for i in range(nb):\n", " print('distance:', dist[i])\n", " print('vertex:', vert[i].x, vert[i].y, vert[i].z)\n", " print('key:', assoc_dict[i])\n" ] }, { "cell_type": "markdown", "id": "d819d9d1", "metadata": {}, "source": [ "## Find the nearest vertex for multiple points" ] }, { "cell_type": "code", "execution_count": 9, "id": "6644100b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "distance: 1.118033988749895\n", "vertex: 1.0 1.0 1.0\n", "key: {'vertex': , 'test': np.int64(2)}\n", "distance: 1.118033988749895\n", "vertex: 0.0 0.0 0.0\n", "key: {'vertex': , 'test': np.int64(1)}\n", "distance: 1.118033988749895\n", "vertex: 1.0 1.0 1.0\n", "key: {'vertex': , 'test': np.int64(2)}\n", "distance: 1.8027756377319946\n", "vertex: 2.0 2.0 2.0\n", "key: {'vertex': , 'test': np.int64(3)}\n" ] } ], "source": [ "nb = 2\n", "xyz1 = [.5, 1., 0.]\n", "xyz2 = [.5, 2., 1.]\n", "dist, vert, assoc_dict = cloud.find_nearest([xyz1, xyz2], nb= nb)\n", "\n", "# If the number of neighbors is 1, the output is a single list of vertices and distances\n", "# If the number of neighbors is greater than 1, the output is a list of lists of vertices and distances\n", "\n", "if nb ==1:\n", " for i_vert in range(2):\n", " print('distance:', dist[i_vert])\n", " print('vertex:', vert[i_vert].x, vert[i_vert].y, vert[i_vert].z)\n", " print('key:', assoc_dict[i_vert])\n", "else:\n", " for i_vert in range(2):\n", " for i in range(nb):\n", " dist_list = dist[i_vert]\n", " vert_list = vert[i_vert]\n", " assoc_dict_list = assoc_dict[i_vert]\n", "\n", " print('distance:', dist_list[i])\n", " print('vertex:', vert_list[i].x, vert_list[i].y, vert_list[i].z)\n", " print('key:', assoc_dict_list[i])" ] } ], "metadata": { "kernelspec": { "display_name": "python3.10", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.11" } }, "nbformat": 4, "nbformat_minor": 5 }