├── Dockerfile ├── requirements.txt ├── README.md ├── .gitignore ├── duke_dbt_data.py ├── dcmread_image.ipynb └── draw_box.ipynb /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM python:3.8 2 | 3 | RUN pip install --upgrade pip==20.3.1 4 | 5 | COPY requirements.txt ./ 6 | 7 | RUN pip install --no-cache-dir -r requirements.txt 8 | 9 | WORKDIR /duke-dbt 10 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | jupyter==1.0.0 2 | numpy==1.19.4 3 | pandas==1.1.4 4 | scikit-learn==0.23.2 5 | imageio==2.9.0 6 | scikit-image==0.17.2 7 | pydicom==2.1.1 8 | pylibjpeg==1.1.1 9 | matplotlib==3.3.3 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # duke-dbt-data 2 | 3 | A repository with code samples and notebooks for DukeDBT Dataset. 4 | 5 | ## docker 6 | 7 | Build docker image: 8 | 9 | ``` 10 | docker build -t duke-dbt . 11 | ``` 12 | 13 | Run container bash: 14 | 15 | ``` 16 | docker run --rm -it \ 17 | -v `pwd`:/duke-dbt \ 18 | -v /path/to/data:/data \ 19 | -p 8889:8889 \ 20 | duke-dbt bash 21 | ``` 22 | 23 | Replace `/path/to/data` with a path to the downloaded data folder. 24 | 25 | ## jupyter notebook 26 | 27 | Serve jupyter notebook from the container: 28 | 29 | ``` 30 | jupyter notebook --allow-root --ip=0.0.0.0 --port=8889 31 | ``` 32 | 33 | ## read dicom image 34 | 35 | `dcmread_image.ipynb` notebook shows how to read image data from a DICOM file in the coordinate system that maches the ground truth bounding boxes. 36 | 37 | ## draw bounding box 38 | 39 | `draw_box.ipynb` notebook shows how to draw a bounding box on the image. 40 | 41 | ## helper functions 42 | 43 | To use helper functions from the notebooks, simply copy the `duke_dbt_data.py` file to your project. 44 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by https://www.toptal.com/developers/gitignore/api/linux,macos,python,jupyternotebooks,intellij+all,vim,vscode 2 | # Edit at https://www.toptal.com/developers/gitignore?templates=linux,macos,python,jupyternotebooks,intellij+all,vim,vscode 3 | 4 | ### Intellij+all ### 5 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 6 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 7 | 8 | # User-specific stuff 9 | .idea/**/workspace.xml 10 | .idea/**/tasks.xml 11 | .idea/**/usage.statistics.xml 12 | .idea/**/dictionaries 13 | .idea/**/shelf 14 | 15 | # Generated files 16 | .idea/**/contentModel.xml 17 | 18 | # Sensitive or high-churn files 19 | .idea/**/dataSources/ 20 | .idea/**/dataSources.ids 21 | .idea/**/dataSources.local.xml 22 | .idea/**/sqlDataSources.xml 23 | .idea/**/dynamic.xml 24 | .idea/**/uiDesigner.xml 25 | .idea/**/dbnavigator.xml 26 | 27 | # Gradle 28 | .idea/**/gradle.xml 29 | .idea/**/libraries 30 | 31 | # Gradle and Maven with auto-import 32 | # When using Gradle or Maven with auto-import, you should exclude module files, 33 | # since they will be recreated, and may cause churn. Uncomment if using 34 | # auto-import. 35 | # .idea/artifacts 36 | # .idea/compiler.xml 37 | # .idea/jarRepositories.xml 38 | # .idea/modules.xml 39 | # .idea/*.iml 40 | # .idea/modules 41 | # *.iml 42 | # *.ipr 43 | 44 | # CMake 45 | cmake-build-*/ 46 | 47 | # Mongo Explorer plugin 48 | .idea/**/mongoSettings.xml 49 | 50 | # File-based project format 51 | *.iws 52 | 53 | # IntelliJ 54 | out/ 55 | 56 | # mpeltonen/sbt-idea plugin 57 | .idea_modules/ 58 | 59 | # JIRA plugin 60 | atlassian-ide-plugin.xml 61 | 62 | # Cursive Clojure plugin 63 | .idea/replstate.xml 64 | 65 | # Crashlytics plugin (for Android Studio and IntelliJ) 66 | com_crashlytics_export_strings.xml 67 | crashlytics.properties 68 | crashlytics-build.properties 69 | fabric.properties 70 | 71 | # Editor-based Rest Client 72 | .idea/httpRequests 73 | 74 | # Android studio 3.1+ serialized cache file 75 | .idea/caches/build_file_checksums.ser 76 | 77 | ### Intellij+all Patch ### 78 | # Ignores the whole .idea folder and all .iml files 79 | # See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360 80 | 81 | .idea/ 82 | 83 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023 84 | 85 | *.iml 86 | modules.xml 87 | .idea/misc.xml 88 | *.ipr 89 | 90 | # Sonarlint plugin 91 | .idea/sonarlint 92 | 93 | ### JupyterNotebooks ### 94 | # gitignore template for Jupyter Notebooks 95 | # website: http://jupyter.org/ 96 | 97 | .ipynb_checkpoints 98 | */.ipynb_checkpoints/* 99 | 100 | # IPython 101 | profile_default/ 102 | ipython_config.py 103 | 104 | # Remove previous ipynb_checkpoints 105 | # git rm -r .ipynb_checkpoints/ 106 | 107 | ### Linux ### 108 | *~ 109 | 110 | # temporary files which can be created if a process still has a handle open of a deleted file 111 | .fuse_hidden* 112 | 113 | # KDE directory preferences 114 | .directory 115 | 116 | # Linux trash folder which might appear on any partition or disk 117 | .Trash-* 118 | 119 | # .nfs files are created when an open file is removed but is still being accessed 120 | .nfs* 121 | 122 | ### macOS ### 123 | # General 124 | .DS_Store 125 | .AppleDouble 126 | .LSOverride 127 | 128 | # Icon must end with two \r 129 | Icon 130 | 131 | 132 | # Thumbnails 133 | ._* 134 | 135 | # Files that might appear in the root of a volume 136 | .DocumentRevisions-V100 137 | .fseventsd 138 | .Spotlight-V100 139 | .TemporaryItems 140 | .Trashes 141 | .VolumeIcon.icns 142 | .com.apple.timemachine.donotpresent 143 | 144 | # Directories potentially created on remote AFP share 145 | .AppleDB 146 | .AppleDesktop 147 | Network Trash Folder 148 | Temporary Items 149 | .apdisk 150 | 151 | ### Python ### 152 | # Byte-compiled / optimized / DLL files 153 | __pycache__/ 154 | *.py[cod] 155 | *$py.class 156 | 157 | # C extensions 158 | *.so 159 | 160 | # Distribution / packaging 161 | .Python 162 | build/ 163 | develop-eggs/ 164 | dist/ 165 | downloads/ 166 | eggs/ 167 | .eggs/ 168 | lib/ 169 | lib64/ 170 | parts/ 171 | sdist/ 172 | var/ 173 | wheels/ 174 | pip-wheel-metadata/ 175 | share/python-wheels/ 176 | *.egg-info/ 177 | .installed.cfg 178 | *.egg 179 | MANIFEST 180 | 181 | # PyInstaller 182 | # Usually these files are written by a python script from a template 183 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 184 | *.manifest 185 | *.spec 186 | 187 | # Installer logs 188 | pip-log.txt 189 | pip-delete-this-directory.txt 190 | 191 | # Unit test / coverage reports 192 | htmlcov/ 193 | .tox/ 194 | .nox/ 195 | .coverage 196 | .coverage.* 197 | .cache 198 | nosetests.xml 199 | coverage.xml 200 | *.cover 201 | *.py,cover 202 | .hypothesis/ 203 | .pytest_cache/ 204 | pytestdebug.log 205 | 206 | # Translations 207 | *.mo 208 | *.pot 209 | 210 | # Django stuff: 211 | *.log 212 | local_settings.py 213 | db.sqlite3 214 | db.sqlite3-journal 215 | 216 | # Flask stuff: 217 | instance/ 218 | .webassets-cache 219 | 220 | # Scrapy stuff: 221 | .scrapy 222 | 223 | # Sphinx documentation 224 | docs/_build/ 225 | doc/_build/ 226 | 227 | # PyBuilder 228 | target/ 229 | 230 | # Jupyter Notebook 231 | 232 | # IPython 233 | 234 | # pyenv 235 | .python-version 236 | 237 | # pipenv 238 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 239 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 240 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 241 | # install all needed dependencies. 242 | #Pipfile.lock 243 | 244 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 245 | __pypackages__/ 246 | 247 | # Celery stuff 248 | celerybeat-schedule 249 | celerybeat.pid 250 | 251 | # SageMath parsed files 252 | *.sage.py 253 | 254 | # Environments 255 | .env 256 | .venv 257 | env/ 258 | venv/ 259 | ENV/ 260 | env.bak/ 261 | venv.bak/ 262 | pythonenv* 263 | 264 | # Spyder project settings 265 | .spyderproject 266 | .spyproject 267 | 268 | # Rope project settings 269 | .ropeproject 270 | 271 | # mkdocs documentation 272 | /site 273 | 274 | # mypy 275 | .mypy_cache/ 276 | .dmypy.json 277 | dmypy.json 278 | 279 | # Pyre type checker 280 | .pyre/ 281 | 282 | # pytype static type analyzer 283 | .pytype/ 284 | 285 | # profiling data 286 | .prof 287 | 288 | ### Vim ### 289 | # Swap 290 | [._]*.s[a-v][a-z] 291 | !*.svg # comment out if you don't need vector files 292 | [._]*.sw[a-p] 293 | [._]s[a-rt-v][a-z] 294 | [._]ss[a-gi-z] 295 | [._]sw[a-p] 296 | 297 | # Session 298 | Session.vim 299 | Sessionx.vim 300 | 301 | # Temporary 302 | .netrwhist 303 | # Auto-generated tag files 304 | tags 305 | # Persistent undo 306 | [._]*.un~ 307 | 308 | ### vscode ### 309 | .vscode/* 310 | !.vscode/settings.json 311 | !.vscode/tasks.json 312 | !.vscode/launch.json 313 | !.vscode/extensions.json 314 | *.code-workspace 315 | 316 | # End of https://www.toptal.com/developers/gitignore/api/linux,macos,python,jupyternotebooks,intellij+all,vim,vscode -------------------------------------------------------------------------------- /duke_dbt_data.py: -------------------------------------------------------------------------------- 1 | from typing import AnyStr, BinaryIO, Dict, List, NamedTuple, Optional, Union 2 | 3 | import matplotlib 4 | import numpy as np 5 | import pandas as pd 6 | import pydicom as dicom 7 | from skimage.exposure import rescale_intensity 8 | 9 | 10 | def dcmread_image( 11 | fp: Union[str, "os.PathLike[AnyStr]", BinaryIO], 12 | view: str, 13 | index: Optional[np.uint] = None, 14 | ) -> np.ndarray: 15 | """Read pixel array from DBT DICOM file""" 16 | ds = dicom.dcmread(fp) 17 | ds.decompress(handler_name="pylibjpeg") 18 | pixel_array = ds.pixel_array 19 | view_laterality = view[0].upper() 20 | image_laterality = _get_image_laterality(pixel_array[index or 0]) 21 | if index is not None: 22 | pixel_array = pixel_array[index] 23 | if not image_laterality == view_laterality: 24 | pixel_array = np.flip(pixel_array, axis=(-1, -2)) 25 | window_center = _get_window_center(ds) 26 | window_width = _get_window_width(ds) 27 | low = (2 * window_center - window_width) / 2 28 | high = (2 * window_center + window_width) / 2 29 | pixel_array = rescale_intensity( 30 | pixel_array, in_range=(low, high), out_range="dtype" 31 | ) 32 | return pixel_array 33 | 34 | 35 | def read_boxes( 36 | boxes_fp: pd._typing.FilePathOrBuffer, filepaths_fp: pd._typing.FilePathOrBuffer 37 | ) -> pd.DataFrame: 38 | """Read pandas DataFrame with bounding boxes joined with file paths""" 39 | df_boxes = pd.read_csv(boxes_fp) 40 | df_filepaths = pd.read_csv(filepaths_fp) 41 | primary_key = ("PatientID", "StudyUID", "View") 42 | if not all([key in df_boxes.columns for key in primary_key]): 43 | raise AssertionError( 44 | f"Not all primary key columns {primary_key} are present in bounding boxes columns {df_boxes.columns}" 45 | ) 46 | if not all([key in df_boxes.columns for key in primary_key]): 47 | raise AssertionError( 48 | f"Not all primary key columns {primary_key} are present in file paths columns {df_filepaths.columns}" 49 | ) 50 | return pd.merge(df_boxes, df_filepaths, on=primary_key) 51 | 52 | 53 | def draw_box( 54 | image: np.ndarray, 55 | x: int, 56 | y: int, 57 | width: int, 58 | height: int, 59 | color: Optional[Union[int, tuple]] = None, 60 | lw=4, 61 | ): 62 | """Draw bounding box on the image""" 63 | x = min(max(x, 0), image.shape[1] - 1) 64 | y = min(max(y, 0), image.shape[0] - 1) 65 | if color is None: 66 | color = np.max(image) 67 | if len(image.shape) > 2 and not hasattr(color, "__len__"): 68 | color = (color,) + (0,) * (image.shape[-1] - 1) 69 | image[y : y + lw, x : x + width] = color 70 | image[y + height - lw : y + height, x : x + width] = color 71 | image[y : y + height, x : x + lw] = color 72 | image[y : y + height, x + width - lw : x + width] = color 73 | return image 74 | 75 | 76 | def evaluate( 77 | labels_fp: pd._typing.FilePathOrBuffer, 78 | boxes_fp: pd._typing.FilePathOrBuffer, 79 | predictions_fp: pd._typing.FilePathOrBuffer, 80 | ) -> Dict[str, float]: 81 | """Evaluate predictions""" 82 | df_labels = pd.read_csv(labels_fp) 83 | df_boxes = pd.read_csv(boxes_fp, dtype={"VolumeSlices": float}) 84 | df_pred = pd.read_csv(predictions_fp, dtype={"Score": float}) 85 | 86 | df_labels = df_labels.reset_index().set_index(["StudyUID", "View"]).sort_index() 87 | df_boxes = df_boxes.reset_index().set_index(["StudyUID", "View"]).sort_index() 88 | df_pred = df_pred.reset_index().set_index(["StudyUID", "View"]).sort_index() 89 | 90 | df_pred["TP"] = 0 91 | df_pred["GTID"] = -1 92 | 93 | thresholds = [df_pred["Score"].max() + 1.0] 94 | 95 | # find true positive predictions and assign detected ground truth box ID 96 | for box_pred in df_pred.itertuples(): 97 | if box_pred.Index not in df_boxes.index: 98 | continue 99 | 100 | df_boxes_view = df_boxes.loc[[box_pred.Index]] 101 | view_slice_offset = df_boxes.loc[[box_pred.Index], "VolumeSlices"].iloc[0] / 4 102 | tp_boxes = [ 103 | b 104 | for b in df_boxes_view.itertuples() 105 | if _is_tp(box_pred, b, slice_offset=view_slice_offset) 106 | ] 107 | if len(tp_boxes) > 1: 108 | # find the nearest GT box 109 | tp_distances = [_distance(box_pred, b) for b in tp_boxes] 110 | tp_boxes = [tp_boxes[np.argmin(tp_distances)]] 111 | if len(tp_boxes) > 0: 112 | tp_i = tp_boxes[0].index 113 | df_pred.loc[df_pred["index"] == box_pred.index, ("TP", "GTID")] = (1, tp_i) 114 | thresholds.append(box_pred.Score) 115 | 116 | thresholds.append(df_pred["Score"].min() - 1.0) 117 | 118 | # compute sensitivity at 2 FPs/volume on all cases 119 | evaluation_fps_all = (2.0,) 120 | tpr_all = _froc( 121 | df_pred=df_pred, 122 | thresholds=thresholds, 123 | n_volumes=len(df_labels), 124 | n_boxes=len(df_boxes), 125 | evaluation_fps=evaluation_fps_all, 126 | ) 127 | result = {f"sensitivity_at_2_fps_all": tpr_all[0]} 128 | 129 | # compute mean sensitivity at 1, 2, 3, 4 FPs/volume on positive cases 130 | df_pred = df_pred[df_pred.index.isin(df_boxes.index)] 131 | df_labels = df_labels[df_labels.index.isin(df_boxes.index)] 132 | evaluation_fps_positive = (1.0, 2.0, 3.0, 4.0) 133 | tpr_positive = _froc( 134 | df_pred=df_pred, 135 | thresholds=thresholds, 136 | n_volumes=len(df_labels), 137 | n_boxes=len(df_boxes), 138 | evaluation_fps=evaluation_fps_positive, 139 | ) 140 | 141 | result.update( 142 | dict( 143 | (f"sensitivity_at_{int(x)}_fps_positive", y) 144 | for x, y in zip(evaluation_fps_positive, tpr_positive) 145 | ) 146 | ) 147 | result.update({"mean_sensitivity_positive": np.mean(tpr_positive)}) 148 | 149 | return result 150 | 151 | 152 | def _froc( 153 | df_pred: pd.DataFrame, 154 | thresholds: List[float], 155 | n_volumes: int, 156 | n_boxes: int, 157 | evaluation_fps: tuple, 158 | ) -> List[float]: 159 | tpr = [] 160 | fps = [] 161 | for th in sorted(thresholds, reverse=True): 162 | df_th = df_pred.loc[df_pred["Score"] >= th] 163 | df_th_unique_tp = df_th.reset_index().drop_duplicates( 164 | subset=["StudyUID", "View", "TP", "GTID"] 165 | ) 166 | n_tps_th = float(sum(df_th_unique_tp["TP"])) 167 | tpr_th = n_tps_th / n_boxes 168 | n_fps_th = float(len(df_th[df_th["TP"] == 0])) 169 | fps_th = n_fps_th / n_volumes 170 | tpr.append(tpr_th) 171 | fps.append(fps_th) 172 | if fps_th > max(evaluation_fps): 173 | break 174 | return [np.interp(x, fps, tpr) for x in evaluation_fps] 175 | 176 | 177 | def _is_tp( 178 | box_pred: NamedTuple, box_true: NamedTuple, slice_offset: int, min_dist: int = 100 179 | ) -> bool: 180 | pred_y = box_pred.Y + box_pred.Height / 2 181 | pred_x = box_pred.X + box_pred.Width / 2 182 | pred_z = box_pred.Z + box_pred.Depth / 2 183 | true_y = box_true.Y + box_true.Height / 2 184 | true_x = box_true.X + box_true.Width / 2 185 | true_z = box_true.Slice 186 | # 2D distance between true and predicted center points 187 | dist = np.linalg.norm((pred_x - true_x, pred_y - true_y)) 188 | # compute radius based on true box size 189 | dist_threshold = np.sqrt(box_true.Width ** 2 + box_true.Height ** 2) / 2.0 190 | dist_threshold = max(dist_threshold, min_dist) 191 | slice_diff = np.abs(pred_z - true_z) 192 | # TP if predicted center within radius and slice within slice offset 193 | return dist <= dist_threshold and slice_diff <= slice_offset 194 | 195 | 196 | def _distance(box_pred: NamedTuple, box_true: NamedTuple) -> float: 197 | pred_y = box_pred.Y + box_pred.Height / 2 198 | pred_x = box_pred.X + box_pred.Width / 2 199 | pred_z = box_pred.Z + box_pred.Depth / 2 200 | true_y = box_true.Y + box_true.Height / 2 201 | true_x = box_true.X + box_true.Width / 2 202 | true_z = box_true.Slice 203 | return np.linalg.norm((pred_x - true_x, pred_y - true_y, pred_z - true_z)) 204 | 205 | 206 | def _get_dicom_laterality(ds: dicom.dataset.FileDataset) -> str: 207 | """Unreliable - DICOM laterality is incorrect for some cases""" 208 | return ds[0x5200, 0x9229][0][0x0020, 0x9071][0][0x0020, 0x9072].value 209 | 210 | 211 | def _get_image_laterality(pixel_array: np.ndarray) -> str: 212 | left_edge = np.sum(pixel_array[:, 0]) # sum of left edge pixels 213 | right_edge = np.sum(pixel_array[:, -1]) # sum of right edge pixels 214 | return "R" if left_edge < right_edge else "L" 215 | 216 | 217 | def _get_window_center(ds: dicom.dataset.FileDataset) -> np.float32: 218 | return np.float32(ds[0x5200, 0x9229][0][0x0028, 0x9132][0][0x0028, 0x1050].value) 219 | 220 | 221 | def _get_window_width(ds: dicom.dataset.FileDataset) -> np.float32: 222 | return np.float32(ds[0x5200, 0x9229][0][0x0028, 0x9132][0][0x0028, 0x1051].value) 223 | -------------------------------------------------------------------------------- /dcmread_image.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import os\n", 10 | "\n", 11 | "%matplotlib inline\n", 12 | "import matplotlib.pyplot as plt\n", 13 | "import pandas as pd\n", 14 | "\n", 15 | "from duke_dbt_data import dcmread_image" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 2, 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "df = pd.read_csv(\"/data/file-paths-train.csv\")" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 3, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "view_series = df.iloc[0]\n", 34 | "view = view_series[\"View\"]\n", 35 | "# if you have image data saved in classic path folder structure, read the file path from \"classic_path\"\n", 36 | "# image_path = os.path.join(\"/data\", view_series[\"classic_path\"])\n", 37 | "image_path = os.path.join(\"/data\", view_series[\"descriptive_path\"])" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 4, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "name": "stderr", 47 | "output_type": "stream", 48 | "text": [ 49 | "/usr/local/lib/python3.8/site-packages/openjpeg/utils.py:189: UserWarning: The (0028,0101) Bits Stored value '10' in the dataset does not match the component precision value '16' found in the JPEG 2000 data. It's recommended that you change the Bits Stored value to produce the correct output\n", 50 | " warnings.warn(\n" 51 | ] 52 | }, 53 | { 54 | "name": "stdout", 55 | "output_type": "stream", 56 | "text": [ 57 | "CPU times: user 14.4 s, sys: 894 ms, total: 15.3 s\n", 58 | "Wall time: 15.4 s\n" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "%%time\n", 64 | "image = dcmread_image(fp=image_path, view=view)" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 5, 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "data": { 74 | "image/png": "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\n", 75 | "text/plain": [ 76 | "
" 77 | ] 78 | }, 79 | "metadata": { 80 | "needs_background": "light" 81 | }, 82 | "output_type": "display_data" 83 | } 84 | ], 85 | "source": [ 86 | "plt.imshow(image[0], cmap=plt.cm.gray);" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [] 95 | } 96 | ], 97 | "metadata": { 98 | "kernelspec": { 99 | "display_name": "Python 3", 100 | "language": "python", 101 | "name": "python3" 102 | }, 103 | "language_info": { 104 | "codemirror_mode": { 105 | "name": "ipython", 106 | "version": 3 107 | }, 108 | "file_extension": ".py", 109 | "mimetype": "text/x-python", 110 | "name": "python", 111 | "nbconvert_exporter": "python", 112 | "pygments_lexer": "ipython3", 113 | "version": "3.8.6" 114 | } 115 | }, 116 | "nbformat": 4, 117 | "nbformat_minor": 4 118 | } 119 | -------------------------------------------------------------------------------- /draw_box.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import os\n", 10 | "\n", 11 | "%matplotlib inline\n", 12 | "import matplotlib.pyplot as plt\n", 13 | "\n", 14 | "from duke_dbt_data import dcmread_image, read_boxes, draw_box" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "metadata": { 21 | "scrolled": false 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "df = read_boxes(boxes_fp=\"/data/boxes-train.csv\", filepaths_fp=\"/data/file-paths-train.csv\")" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "box_series = df.iloc[0]\n", 35 | "view = box_series[\"View\"]\n", 36 | "slice_index = box_series[\"Slice\"]\n", 37 | "# if you have image data saved in classic path folder structure, read the file path from \"classic_path\"\n", 38 | "# image_path = os.path.join(\"/data\", view_series[\"classic_path\"])\n", 39 | "image_path = os.path.join(\"/data\", box_series[\"descriptive_path\"])" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 4, 45 | "metadata": {}, 46 | "outputs": [ 47 | { 48 | "name": "stderr", 49 | "output_type": "stream", 50 | "text": [ 51 | "/usr/local/lib/python3.8/site-packages/openjpeg/utils.py:189: UserWarning: The (0028,0101) Bits Stored value '10' in the dataset does not match the component precision value '16' found in the JPEG 2000 data. It's recommended that you change the Bits Stored value to produce the correct output\n", 52 | " warnings.warn(\n" 53 | ] 54 | }, 55 | { 56 | "name": "stdout", 57 | "output_type": "stream", 58 | "text": [ 59 | "CPU times: user 12.5 s, sys: 160 ms, total: 12.7 s\n", 60 | "Wall time: 12.7 s\n" 61 | ] 62 | } 63 | ], 64 | "source": [ 65 | "%%time\n", 66 | "image = dcmread_image(fp=image_path, view=view, index=slice_index)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 5, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "x, y, width, height = box_series[[\"X\", \"Y\", \"Width\", \"Height\"]]\n", 76 | "image = draw_box(image=image, x=x, y=y, width=width, height=height, lw=10)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 6, 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "image/png": "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\n", 87 | "text/plain": [ 88 | "
" 89 | ] 90 | }, 91 | "metadata": { 92 | "needs_background": "light" 93 | }, 94 | "output_type": "display_data" 95 | } 96 | ], 97 | "source": [ 98 | "plt.imshow(image, cmap=plt.cm.gray);" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": null, 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [] 107 | } 108 | ], 109 | "metadata": { 110 | "kernelspec": { 111 | "display_name": "Python 3", 112 | "language": "python", 113 | "name": "python3" 114 | }, 115 | "language_info": { 116 | "codemirror_mode": { 117 | "name": "ipython", 118 | "version": 3 119 | }, 120 | "file_extension": ".py", 121 | "mimetype": "text/x-python", 122 | "name": "python", 123 | "nbconvert_exporter": "python", 124 | "pygments_lexer": "ipython3", 125 | "version": "3.8.6" 126 | } 127 | }, 128 | "nbformat": 4, 129 | "nbformat_minor": 4 130 | } 131 | --------------------------------------------------------------------------------