{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f5662507-f32c-4537-b0d8-b9234768b2c2",
   "metadata": {},
   "source": [
    "# HOOPS AI: Use the Dataset Explorer to navigate the dataset\n",
    "\n",
    "\n",
    "The `dataset` module provides a comprehensive framework for exploring, navigating, and loading CAD model datasets for machine learning applications. It consists of two primary components that work together to simplify data handling:\n",
    "\n",
    "1. **DatasetExplorer** - For exploring and querying dataset contents\n",
    "2. **DatasetLoader** - For loading and preparing datasets for machine learning training\n",
    "\n",
    "These components are designed to work with the processed data from the `cadaccess` and `cadencoder` modules, as well as the outputs from the flow pipeline system. They provide high-level abstractions that allow users to focus on machine learning tasks rather than data handling complexities.\n",
    "\n",
    "## DatasetExplorer\n",
    "\n",
    "The `DatasetExplorer` class (`dataset_explorer.py`) provides methods for exploring and querying datasets stored in Zarr format (.dataset) with accompanying metadata (.infoset) in Parquet files. This class focuses on data discovery, filtering, and statistical analysis.\n",
    "\n",
    "### Key Methods\n",
    "\n",
    "#### Data Discovery and Metadata\n",
    "\n",
    "- `available_groups() -> set`: Returns the set of available dataset groups (faces, edges, file, etc.)\n",
    "- `get_descriptions(table_name: str, key_id: Optional[int] = None, use_wildchar: Optional[bool] = False) -> pd.DataFrame`: Retrieves metadata descriptions (labels, face types, edge types, etc.)\n",
    "- `get_parquet_info_by_code(file_id_code: int)`: Returns rows from the Parquet file for a specific file ID code\n",
    "- `get_file_info_all() -> pd.DataFrame`: Returns all file info from the Parquet metadata\n",
    "\n",
    "#### Data Distribution Analysis\n",
    "\n",
    "- `create_distribution(key: str, bins: int = 10, group: str = \"faces\") -> Dict[str, Any]`: Computes histograms of data distributions using Dask for parallel processing\n",
    "\n",
    "#### Data Filtering and Selection\n",
    "\n",
    "- `get_file_list(group: str, where: Callable[[xr.Dataset], xr.DataArray]) -> List[str]`: Returns file IDs matching a boolean filter condition\n",
    "- `file_dataset(file_id_code: int, group: str) -> xr.Dataset`: Returns a subset of the dataset for a specific file\n",
    "- `build_membership_matrix(group: str, key: str, bins_or_categories: Union[int, List, np.ndarray], as_counts: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]`: Builds a file-by-bin membership matrix for stratified splitting\n",
    "- `decode_file_id_code(code: int) -> str`: Converts an integer file ID code to the original string identifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "021c4256-d764-4983-aae8-4a87498b483e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ℹ️ Using TEST LICENSE (expires December 8, 2025 - 37 days remaining)\n",
      "   For production use, obtain your own license from Tech Soft 3D\n",
      "======================================================================\n",
      "✓ HOOPS AI License: Valid (TEST LICENSE - expires Dec 6, 2025)\n",
      "======================================================================\n"
     ]
    }
   ],
   "source": [
    "import hoops_ai\n",
    "import os\n",
    "\n",
    "hoops_ai.set_license(hoops_ai.use_test_license())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "381fd5db-d080-4004-a103-fd5d358ee504",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\LuisSalazar\\Documents\\MAIN\\MLProject\\repo\\HOOPS-AI-tutorials\\packages\\flows\\cadsynth_aag\n",
      "[DatasetExplorer] Default local cluster started: <Client: 'tcp://127.0.0.1:57953' processes=1 threads=16, memory=7.45 GiB>\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ff6d70a731c24cf2a703a8dc28a18450",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Processing file info:   0%|          | 0/162412 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from hoops_ai.dataset import DatasetExplorer\n",
    "import pathlib \n",
    "# Define paths\n",
    "flow_name = \"cadsynth_aag\"\n",
    "\n",
    "flow_root_dir = pathlib.Path.cwd().parent.joinpath(\"packages\", \"flows\", flow_name)\n",
    "print(flow_root_dir)\n",
    "\n",
    "parquet_file_path        = str(flow_root_dir.joinpath(f\"{flow_name}.infoset\"))\n",
    "merged_store_path     = str(flow_root_dir.joinpath(f\"{flow_name}.dataset\"))\n",
    "parquet_file_attribs  = str(flow_root_dir.joinpath(f\"{flow_name}.attribset\"))\n",
    "\n",
    "\n",
    "explorer = DatasetExplorer(merged_store_path=merged_store_path, parquet_file_path=parquet_file_path, parquet_file_attribs=parquet_file_attribs)\n",
    "#explorer.print_table_of_contents()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "69c2007a-7731-4787-a499-06db1a4bcca7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'faceface', 'faces', 'file', 'edges', 'graph'}\n"
     ]
    }
   ],
   "source": [
    "groups = explorer.available_groups()\n",
    "print(groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a785595e-8d70-4d6c-a54f-d189339bbbf3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>    id        name description  table_name\n",
      "0   0       Plane     not set  face_types\n",
      "1   1    Cylinder     not set  face_types\n",
      "2   2        Cone     not set  face_types\n",
      "3  14   Extrusion     not set  face_types\n",
      "4   3      Sphere     not set  face_types\n",
      "5   4       Torus     not set  face_types\n",
      "6   5       Nurbs     not set  face_types\n",
      "7  13  Revolution     not set  face_types\n"
     ]
    }
   ],
   "source": [
    "face_type_description = explorer.get_descriptions(\"face_types\")\n",
    "print(type(face_type_description), face_type_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1fd33405-d646-487a-9b81-f2bd9d0510a3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>                                name                             description  \\\n",
      "0  0007c9b910d876090f12c2cad80794df  C:\\Temp\\Cadsynth_aag\\step\\00035533.stp   \n",
      "\n",
      "  subset  id table_name  \n",
      "0  train  25  file_info  \n"
     ]
    }
   ],
   "source": [
    "# Get and print meta data information\n",
    "file_id = 25\n",
    "df_info = explorer.get_parquet_info_by_code(file_id)\n",
    "print(type(df_info), df_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "af3a683e-c6f1-408e-9c0c-3e7ad9446feb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets (Table of Content) for file ID '25':\n",
      "  [faceface] DATA: a3_distance, Shape: (2025, 64), Dims: ('faceface_flat', 'bins_d'), Size: 129600\n",
      "  [faceface] DATA: d2_distance, Shape: (2025, 64), Dims: ('faceface_flat', 'bins_a'), Size: 129600\n",
      "  [faceface] DATA: extended_adjacency, Shape: (2025,), Dims: ('faceface_flat',), Size: 2025\n",
      "  [faceface] DATA: face_pair_edges_path, Shape: (2025, 32), Dims: ('faceface_flat', 'dim_path'), Size: 64800\n",
      "  [faceface] DATA: face_x, Shape: (2025,), Dims: ('faceface_flat',), Size: 2025\n",
      "  [faceface] DATA: face_y, Shape: (2025,), Dims: ('faceface_flat',), Size: 2025\n",
      "  [faceface] DATA: file_id_code_faceface, Shape: (2025,), Dims: ('faceface_flat',), Size: 2025\n",
      "  [faces] DATA: face_areas, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [faces] DATA: face_indices, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [faces] DATA: face_labels, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [faces] DATA: face_loops, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [faces] DATA: face_neighborscount, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [faces] DATA: face_types, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [faces] DATA: face_uv_grids, Shape: (45, 5, 5, 7), Dims: ('face', 'uv_x', 'uv_y', 'component'), Size: 7875\n",
      "  [faces] DATA: file_id_code_faces, Shape: (45,), Dims: ('face',), Size: 45\n",
      "  [file] DATA: duration_dglconvert, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [file] DATA: file_id_code_file, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [file] DATA: size_cadfile, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [file] DATA: size_dglfile, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [edges] DATA: edge_convexities, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [edges] DATA: edge_dihedral_angles, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [edges] DATA: edge_indices, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [edges] DATA: edge_lengths, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [edges] DATA: edge_types, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [edges] DATA: edge_u_grids, Shape: (128, 5, 6), Dims: ('edge', 'dim_x', 'component'), Size: 3840\n",
      "  [edges] DATA: file_id_code_edges, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [graph] DATA: destination, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [graph] DATA: file_id_code_graph, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [graph] DATA: num_nodes, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "  [graph] DATA: source, Shape: (128,), Dims: ('edge',), Size: 128\n",
      "\n",
      "type of file_data_arrays <class 'xarray.core.dataset.Dataset'>\n",
      "type of array_areas <class 'numpy.ndarray'>\n",
      "brep surfaces (45,)\n"
     ]
    }
   ],
   "source": [
    "# Access various dataset groups\n",
    "file_datasetGroup = {grp: explorer.file_dataset(file_id_code=file_id, group=grp) for grp in groups}\n",
    "\n",
    "print(f\"Datasets (Table of Content) for file ID '{file_id}':\")\n",
    "for grp, ds in file_datasetGroup.items():\n",
    "    for name, da in ds.data_vars.items():\n",
    "        print(f\"  [{grp}] DATA: {name}, Shape: {da.shape}, Dims: {da.dims}, Size: {da.size}\")\n",
    "print()\n",
    "\n",
    "file_dataset = file_datasetGroup[\"faces\"]\n",
    "print(\"type of file_data_arrays\", type(file_dataset))\n",
    "\n",
    "#print the areas of each face\n",
    "array_areas = file_dataset[\"face_areas\"].data.compute()\n",
    "print(\"type of array_areas\", type(array_areas))\n",
    "print(\"brep surfaces\", array_areas.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b6ed3a30-beef-4f26-a17a-46538c5f4fc2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy array shape (45, 5, 5, 7)\n"
     ]
    }
   ],
   "source": [
    "# this requires to be a bit familiar with pandas and dask.\n",
    "uv_grid_data = file_dataset[\"face_uv_grids\"].data.compute()\n",
    "\n",
    "\n",
    "print(\"numpy array shape\", uv_grid_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "66844184-060d-433e-855a-4e94fcc27e2d",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "#print(uv_grid_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d13f4ae0-82e8-4369-93b7-99c163d64b7c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>description</th>\n",
       "      <th>subset</th>\n",
       "      <th>id</th>\n",
       "      <th>table_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>00001d44b8eb37fe4bb6ec4e89746ea3</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00021388.stp</td>\n",
       "      <td>train</td>\n",
       "      <td>0</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000093c3b74c8076fbba20bf8613e2a2</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\20221121_154647_2127...</td>\n",
       "      <td>validation</td>\n",
       "      <td>1</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>00012dc0e22bd178d7c6a12436734130</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00067737.stp</td>\n",
       "      <td>validation</td>\n",
       "      <td>2</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>00013001df401fe06d5213ef6fc9e581</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00058353.stp</td>\n",
       "      <td>validation</td>\n",
       "      <td>3</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>00015d0e0e285c5089a485360b34db1a</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00048571.stp</td>\n",
       "      <td>train</td>\n",
       "      <td>4</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>162407</th>\n",
       "      <td>fffe278b406958997fff4c1f76b72ee0</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\20221123_142528_2390...</td>\n",
       "      <td>test</td>\n",
       "      <td>162407</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>162408</th>\n",
       "      <td>fffe3fba779b5fa5543c4a82c3cfbabb</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00091954.stp</td>\n",
       "      <td>train</td>\n",
       "      <td>162408</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>162409</th>\n",
       "      <td>fffee3edd46107ca808a958811dcb9a8</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\20221124_154714_1362...</td>\n",
       "      <td>validation</td>\n",
       "      <td>162409</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>162410</th>\n",
       "      <td>ffff1ac0abc28d3ede6b7bfb6434cdf4</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00065860.stp</td>\n",
       "      <td>train</td>\n",
       "      <td>162410</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>162411</th>\n",
       "      <td>ffffdc1d0cb629065026fa55a97ca314</td>\n",
       "      <td>C:\\Temp\\Cadsynth_aag\\step\\00016373.stp</td>\n",
       "      <td>train</td>\n",
       "      <td>162411</td>\n",
       "      <td>file_info</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>162412 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                    name  \\\n",
       "0       00001d44b8eb37fe4bb6ec4e89746ea3   \n",
       "1       000093c3b74c8076fbba20bf8613e2a2   \n",
       "2       00012dc0e22bd178d7c6a12436734130   \n",
       "3       00013001df401fe06d5213ef6fc9e581   \n",
       "4       00015d0e0e285c5089a485360b34db1a   \n",
       "...                                  ...   \n",
       "162407  fffe278b406958997fff4c1f76b72ee0   \n",
       "162408  fffe3fba779b5fa5543c4a82c3cfbabb   \n",
       "162409  fffee3edd46107ca808a958811dcb9a8   \n",
       "162410  ffff1ac0abc28d3ede6b7bfb6434cdf4   \n",
       "162411  ffffdc1d0cb629065026fa55a97ca314   \n",
       "\n",
       "                                              description      subset      id  \\\n",
       "0                  C:\\Temp\\Cadsynth_aag\\step\\00021388.stp       train       0   \n",
       "1       C:\\Temp\\Cadsynth_aag\\step\\20221121_154647_2127...  validation       1   \n",
       "2                  C:\\Temp\\Cadsynth_aag\\step\\00067737.stp  validation       2   \n",
       "3                  C:\\Temp\\Cadsynth_aag\\step\\00058353.stp  validation       3   \n",
       "4                  C:\\Temp\\Cadsynth_aag\\step\\00048571.stp       train       4   \n",
       "...                                                   ...         ...     ...   \n",
       "162407  C:\\Temp\\Cadsynth_aag\\step\\20221123_142528_2390...        test  162407   \n",
       "162408             C:\\Temp\\Cadsynth_aag\\step\\00091954.stp       train  162408   \n",
       "162409  C:\\Temp\\Cadsynth_aag\\step\\20221124_154714_1362...  validation  162409   \n",
       "162410             C:\\Temp\\Cadsynth_aag\\step\\00065860.stp       train  162410   \n",
       "162411             C:\\Temp\\Cadsynth_aag\\step\\00016373.stp       train  162411   \n",
       "\n",
       "       table_name  \n",
       "0       file_info  \n",
       "1       file_info  \n",
       "2       file_info  \n",
       "3       file_info  \n",
       "4       file_info  \n",
       "...           ...  \n",
       "162407  file_info  \n",
       "162408  file_info  \n",
       "162409  file_info  \n",
       "162410  file_info  \n",
       "162411  file_info  \n",
       "\n",
       "[162412 rows x 5 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "explorer.get_file_info_all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9b977880-8df0-4eda-a43d-57fe16a625e1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Visualization libraries\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def print_distribution_info(dist, title=\"Distribution\"):\n",
    "    \"\"\"Helper function to print and visualize distribution data.\"\"\"\n",
    "    list_filecount = list()\n",
    "    for i, bin_files in enumerate(dist['file_id_codes_in_bins']):\n",
    "        list_filecount.append(bin_files.size)\n",
    "\n",
    "    dist['file_count'] =list_filecount\n",
    "    # Visualization with matplotlib\n",
    "    fig, ax = plt.subplots(figsize=(12, 4))\n",
    "    \n",
    "    bin_centers = 0.5 * (dist['bin_edges'][1:] + dist['bin_edges'][:-1])\n",
    "    ax.bar(bin_centers, dist['file_count'], width=(dist['bin_edges'][1] - dist['bin_edges'][0]), \n",
    "           alpha=0.7, color='steelblue', edgecolor='black', linewidth=1)\n",
    "    \n",
    "    # Add file count annotations\n",
    "    for i, count in enumerate(dist['file_count']):\n",
    "        if count > 0:  # Only annotate non-empty bins\n",
    "            ax.text(bin_centers[i], count + 0.5, f\"{count}\", \n",
    "                    ha='center', va='bottom', fontsize=8)\n",
    "    \n",
    "    ax.set_xlabel('Value')\n",
    "    ax.set_ylabel('Count')\n",
    "    ax.set_title(f'{title} Histogram')\n",
    "    ax.grid(True, linestyle='--', alpha=0.7)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "477d5cad-0bcb-4575-9079-55f16327ac67",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Face labels distribution created in 2.31 seconds\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "start_time = time.time()\n",
    "face_dist = explorer.create_distribution(key=\"face_labels\", bins=None, group=\"faces\")\n",
    "print(f\"Face labels distribution created in {(time.time() - start_time):.2f} seconds\\n\")\n",
    "print_distribution_info(face_dist, title=\"Labels\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "42e37fde-a9db-40c7-baf0-ae183bda4abe",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    id                                name description   table_name\n",
      "14   0                            no-label     not set  face_labels\n",
      "15   7                 2sides_through_step     not set  face_labels\n",
      "16  11              rectangular_blind_slot     not set  face_labels\n",
      "17  18                 circular blind step     not set  face_labels\n",
      "18   5                      6sides_passage     not set  face_labels\n",
      "19   9              rectangular_blind_step     not set  face_labels\n",
      "20  12                  rectangular_pocket     not set  face_labels\n",
      "21  13                   triangular_pocket     not set  face_labels\n",
      "22  14                       6sides_pocket     not set  face_labels\n",
      "23  21                 circular end pocket     not set  face_labels\n",
      "24  23                          blind hole     not set  face_labels\n",
      "25   2             triangular_through_slot     not set  face_labels\n",
      "26  17                        through hole     not set  face_labels\n",
      "27   3                 rectangular_passage     not set  face_labels\n",
      "28  16               circular through slot     not set  face_labels\n",
      "29   4                  triangular_passage     not set  face_labels\n",
      "30   6            rectangular_through_step     not set  face_labels\n",
      "31  10               triangular_blind_step     not set  face_labels\n",
      "32  24                              fillet     not set  face_labels\n",
      "33   1            rectangular_through_slot     not set  face_labels\n",
      "34  15                             chamfer     not set  face_labels\n",
      "35  19  horizontal circular end blind slot     not set  face_labels\n",
      "36  22                              o-ring     not set  face_labels\n",
      "37   8                slanted_through_step     not set  face_labels\n",
      "38  20    vertical circular end blind slot     not set  face_labels\n"
     ]
    }
   ],
   "source": [
    "print(explorer.get_descriptions(\"face_labels\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cf864c67-0f5f-4b7d-8037-b2803e180fa8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Face labels distribution created in 4.20 seconds\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "dist = explorer.create_distribution(key=\"num_nodes\", bins=12, group=\"graph\")\n",
    "print(f\"Face labels distribution created in {(time.time() - start_time):.2f} seconds\\n\")\n",
    "print_distribution_info(dist, title=\"Brep facecount Distribution\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83793d5b-93c9-423a-be2e-0d543e33d15f",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Gather files that fulfilled a given condition. Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "39715be3-a1ed-43db-a950-6def2d0a64bf",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtering completed in 0.21 seconds\n",
      "Found 32234 files with face_labels == 15 (chamfer)\n",
      "\n",
      "[    10     12     15 ... 162392 162398 162401]\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "# condition\n",
    "label_is_pipefittings = lambda ds: ds['face_labels'] == 15\n",
    "\n",
    "filelist = explorer.get_file_list(group=\"faces\", where=label_is_pipefittings)\n",
    "print(f\"Filtering completed in {(time.time() - start_time):.2f} seconds\")\n",
    "print(f\"Found {len(filelist)} files with face_labels == 15 (chamfer)\\n\")\n",
    "print(filelist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30cfce7a-515a-4ebe-87bd-2286235a823b",
   "metadata": {},
   "source": [
    "# Query data for single file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "83350a38-9bde-47a3-84a5-2bd47724a5e0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def demo_query_single_file(explorer, file_id):\n",
    "    \"\"\"Show how to access and query dataset details for a single file.\"\"\"\n",
    "    print(\"=== Single File Dataset Access ===\")\n",
    "    import time\n",
    "    # Get and print parquet info\n",
    "    df_info = explorer.get_parquet_info_by_code(file_id)\n",
    "    print(\"Files info:\")\n",
    "    for column in df_info.columns:\n",
    "        print(f\"Column: {column}\")\n",
    "        for value in df_info[column]:\n",
    "            print(f\"  {value}\")\n",
    "    print()\n",
    "\n",
    "    # Access various dataset groups\n",
    "    groups = [\"faces\", \"file\", \"edges\", \"graph\"]\n",
    "    datasets = {grp: explorer.file_dataset(file_id_code=file_id, group=grp) for grp in groups}\n",
    "\n",
    "    print(f\"Datasets for file ID '{file_id}':\")\n",
    "    for grp, ds in datasets.items():\n",
    "        for name, da in ds.data_vars.items():\n",
    "            print(f\"  [{grp}] VARIABLE: {name}, Shape: {da.shape}, Dims: {da.dims}, Size: {da.size}\")\n",
    "    print()\n",
    "\n",
    "    # Query uv grids data for a specific face\n",
    "    start_time = time.time()\n",
    "    uv_grid_data = datasets[\"faces\"][\"face_uv_grids\"].isel(face=2)\n",
    "    print(\"uv_grids data for face index 2:\")\n",
    "    np_uvgrid = uv_grid_data.data.compute()\n",
    "    print(f\"Query took {(time.time() - start_time):.2f} seconds\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4dd615c0-6659-4407-b3a8-951770560272",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== Single File Dataset Access ===\n",
      "Files info:\n",
      "Column: name\n",
      "  07207dfd094fe0ebe9368ded4c271b23\n",
      "Column: description\n",
      "  C:\\Temp\\Cadsynth_aag\\step\\20221124_154714_17096.step\n",
      "Column: subset\n",
      "  test\n",
      "Column: id\n",
      "  4500\n",
      "Column: table_name\n",
      "  file_info\n",
      "\n",
      "Datasets for file ID '4500':\n",
      "  [faces] VARIABLE: face_areas, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [faces] VARIABLE: face_indices, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [faces] VARIABLE: face_labels, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [faces] VARIABLE: face_loops, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [faces] VARIABLE: face_neighborscount, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [faces] VARIABLE: face_types, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [faces] VARIABLE: face_uv_grids, Shape: (38, 5, 5, 7), Dims: ('face', 'uv_x', 'uv_y', 'component'), Size: 6650\n",
      "  [faces] VARIABLE: file_id_code_faces, Shape: (38,), Dims: ('face',), Size: 38\n",
      "  [file] VARIABLE: duration_dglconvert, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [file] VARIABLE: file_id_code_file, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [file] VARIABLE: size_cadfile, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [file] VARIABLE: size_dglfile, Shape: (1,), Dims: ('file',), Size: 1\n",
      "  [edges] VARIABLE: edge_convexities, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [edges] VARIABLE: edge_dihedral_angles, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [edges] VARIABLE: edge_indices, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [edges] VARIABLE: edge_lengths, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [edges] VARIABLE: edge_types, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [edges] VARIABLE: edge_u_grids, Shape: (96, 5, 6), Dims: ('edge', 'dim_x', 'component'), Size: 2880\n",
      "  [edges] VARIABLE: file_id_code_edges, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [graph] VARIABLE: destination, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [graph] VARIABLE: file_id_code_graph, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [graph] VARIABLE: num_nodes, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "  [graph] VARIABLE: source, Shape: (96,), Dims: ('edge',), Size: 96\n",
      "\n",
      "uv_grids data for face index 2:\n",
      "Query took 1.13 seconds\n",
      "\n"
     ]
    }
   ],
   "source": [
    "demo_query_single_file(explorer,file_id=4500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca936a97-a46e-4b43-bebc-7c3623d1dff7",
   "metadata": {},
   "source": [
    "# Create subsets (train, validation, test) based on the label distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9b25d773-2a63-45b9-8b3f-8a21c751c2e7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "def demo_stratified_splits(explorer):\n",
    "    \"\"\"Show building a membership matrix and performing stratified splits.\"\"\"\n",
    "    print(\"=== Membership Matrix and Data Splitting ===\")\n",
    "    \n",
    "    import time\n",
    "    from iterstrat.ml_stratifiers import MultilabelStratifiedShuffleSplit\n",
    "    import numpy as np\n",
    "    start_time = time.time()\n",
    "\n",
    "    df_label = explorer.get_descriptions(\"label\", None, True)\n",
    "    label_key = df_label[\"table_name\"].iloc[0]\n",
    "\n",
    "    if label_key == \"file_label\":\n",
    "        group = \"file\"\n",
    "    else:\n",
    "        group = \"faces\"\n",
    "\n",
    "    matrix, file_codes, _ = explorer.build_membership_matrix(group=group, key=label_key, bins_or_categories=None, as_counts=False)\n",
    "\n",
    "    # First split: 70% train, 30% temporary\n",
    "    msss = MultilabelStratifiedShuffleSplit(n_splits=1, test_size=0.30, random_state=42)\n",
    "    for train_idx, temp_idx in msss.split(np.arange(len(matrix))[:, None], matrix):\n",
    "        pass\n",
    "\n",
    "    # Second split on the temporary set into 50% validation, 50% test => 15% each overall\n",
    "    msss2 = MultilabelStratifiedShuffleSplit(n_splits=1, test_size=0.5, random_state=43)\n",
    "    for val_sub, test_sub in msss2.split(np.arange(len(temp_idx))[:, None], matrix[temp_idx]):\n",
    "        val_idx = temp_idx[val_sub]\n",
    "        test_idx = temp_idx[test_sub]\n",
    "\n",
    "    print(\"Train file IDs:\", file_codes[train_idx].shape)\n",
    "    print(\"Validation file IDs:\", file_codes[val_idx].shape)\n",
    "    print(\"Test file IDs:\", file_codes[test_idx].shape)\n",
    "    print(f\"Stratified Splitting completed in {(time.time() - start_time):.2f} seconds\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a4fc2bb1-25ab-47c0-b513-da792ab4b3ae",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== Membership Matrix and Data Splitting ===\n",
      "Train file IDs: (113479,)\n",
      "Validation file IDs: (24453,)\n",
      "Test file IDs: (24480,)\n",
      "Stratified Splitting completed in 15.14 seconds\n",
      "\n"
     ]
    }
   ],
   "source": [
    "demo_stratified_splits(explorer)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "HOOPS AI (CPU)",
   "language": "python",
   "name": "hoops_ai_cpu"
  },
  "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.9.21"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}