{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":71549,"databundleVersionId":8561470,"sourceType":"competition"}],"dockerImageVersionId":30746,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import pandas as pd\n\n# Define the file path\nfile_path = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_series_descriptions.csv'\n\n# Load the CSV file into a DataFrame\ndf = pd.read_csv(file_path)\n\n# Display the first few rows of the DataFrame\nprint(df.head())","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-07-31T17:20:28.467289Z","iopub.execute_input":"2024-07-31T17:20:28.467691Z","iopub.status.idle":"2024-07-31T17:20:29.789482Z","shell.execute_reply.started":"2024-07-31T17:20:28.467654Z","shell.execute_reply":"2024-07-31T17:20:29.788127Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"len(df)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:04:12.606072Z","iopub.execute_input":"2024-07-31T01:04:12.606587Z","iopub.status.idle":"2024-07-31T01:04:12.618424Z","shell.execute_reply.started":"2024-07-31T01:04:12.606548Z","shell.execute_reply":"2024-07-31T01:04:12.616627Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"unique_values = df.nunique()\n\n# Display the number of unique values for each column\nprint(unique_values)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:04:13.883699Z","iopub.execute_input":"2024-07-31T01:04:13.884598Z","iopub.status.idle":"2024-07-31T01:04:13.903856Z","shell.execute_reply.started":"2024-07-31T01:04:13.884466Z","shell.execute_reply":"2024-07-31T01:04:13.902157Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n# Count the occurrences of each unique value in the 'series_description' column\nvalue_counts = df['series_description'].value_counts()\n\n# Plot the pie chart\nplt.figure(figsize=(10, 7))\nplt.pie(value_counts, labels=value_counts.index, autopct='%1.1f%%', startangle=140)\nplt.title('Distribution of Series Descriptions')\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:04:15.885301Z","iopub.execute_input":"2024-07-31T01:04:15.885824Z","iopub.status.idle":"2024-07-31T01:04:16.138795Z","shell.execute_reply.started":"2024-07-31T01:04:15.885784Z","shell.execute_reply":"2024-07-31T01:04:16.137201Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import pydicom\n\n# Load the DICOM file\ndcm_file = pydicom.dcmread('/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/test_images/44036939/2828203845/14.dcm')\n\n# Access the image data\nimage_data = dcm_file.pixel_array\n\n# Display the image using matplotlib\nimport matplotlib.pyplot as plt\n\nplt.imshow(image_data, cmap='gray')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:05:11.66302Z","iopub.execute_input":"2024-07-31T01:05:11.663562Z","iopub.status.idle":"2024-07-31T01:05:12.005073Z","shell.execute_reply.started":"2024-07-31T01:05:11.663523Z","shell.execute_reply":"2024-07-31T01:05:12.003427Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Print all available properties (tags)\nprint(\"Available DICOM tags and their values:\")\nfor elem in dcm_file:#skip pixel data\n    if elem.description() != \"Pixel Data\":\n        print(f\"{elem.tag} {elem.description()} = {elem.value}\")\n\n# Alternatively, you can use dir() to list all attributes\nprint(\"\\nList of attributes using dir():\")\nattributes = dir(dcm_file)\nprint(attributes)\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:09:04.874588Z","iopub.execute_input":"2024-07-31T01:09:04.875168Z","iopub.status.idle":"2024-07-31T01:09:04.885139Z","shell.execute_reply.started":"2024-07-31T01:09:04.875122Z","shell.execute_reply":"2024-07-31T01:09:04.883415Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import pydicom\nimport time\nfrom PIL import Image\n\n# Path to your DICOM and PNG files\ndcm_file_path = 'path_to_your_file.dcm'\npng_file_path = 'path_to_your_file.png'\n\n# Load DICOM file and measure time\nstart_time = time.time()\ndcm_file = pydicom.dcmread(dcm_file_path)\ndcm_image = dcm_file.pixel_array\ndcm_load_time = time.time() - start_time\n\n# Load PNG file and measure time\nstart_time = time.time()\npng_image = Image.open(png_file_path)\npng_load_time = time.time() - start_time\n\nprint(f'Time to load DICOM file: {dcm_load_time:.4f} seconds')\nprint(f'Time to load PNG file: {png_load_time:.4f} seconds')\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\n\n# Directory containing the DICOM files\ndcm_dir = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/test_images/44036939/2828203845'\n\n# List all DICOM files in the directory\ndcm_files = [f for f in os.listdir(dcm_dir) if f.endswith('.dcm')]\n\n# Dictionary to store the slices by Series Instance UID\nseries_slices = {}\n\n# Load all DICOM files and check their Series Instance UID and Instance Number\nfor file in dcm_files:\n    file_path = os.path.join(dcm_dir, file)\n    dcm_data = pydicom.dcmread(file_path)\n    \n    series_uid = dcm_data.SeriesInstanceUID\n    instance_number = dcm_data.InstanceNumber\n    \n    if series_uid not in series_slices:\n        series_slices[series_uid] = []\n    series_slices[series_uid].append(instance_number)\n\n# Display the number of slices for each series\nfor series_uid, instances in series_slices.items():\n    print(f'Series Instance UID: {series_uid}')\n    print(f'Number of slices: {len(instances)}')\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:15:27.893655Z","iopub.execute_input":"2024-07-31T01:15:27.894156Z","iopub.status.idle":"2024-07-31T01:15:28.230081Z","shell.execute_reply.started":"2024-07-31T01:15:27.894119Z","shell.execute_reply":"2024-07-31T01:15:28.22873Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport matplotlib.pyplot as plt\n\n# Directory containing the DICOM files\ndcm_dir = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/test_images/44036939/2828203845'\n\n# List all DICOM files in the directory\ndcm_files = [f for f in os.listdir(dcm_dir) if f.endswith('.dcm')]\n\n# Dictionary to store the slices by Series Instance UID\nseries_slices = {}\n\n# Load all DICOM files and check their Series Instance UID and Instance Number\nfor file in dcm_files:\n    file_path = os.path.join(dcm_dir, file)\n    dcm_data = pydicom.dcmread(file_path)\n    \n    series_uid = dcm_data.SeriesInstanceUID\n    instance_number = dcm_data.InstanceNumber\n    \n    if series_uid not in series_slices:\n        series_slices[series_uid] = []\n    series_slices[series_uid].append((instance_number, dcm_data))\n\n# Select a series to display (assuming there's at least one series)\nseries_uid, slices = list(series_slices.items())[0]\n\n# Sort slices by Instance Number\nslices.sort(key=lambda x: x[0])\n\n# Display all slices in the selected series\nfor instance_number, dcm_data in slices:\n    plt.figure()\n    plt.imshow(dcm_data.pixel_array, cmap='gray')\n    plt.title(f'Series: {series_uid}, Slice: {instance_number}')\n    plt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T01:16:48.112958Z","iopub.execute_input":"2024-07-31T01:16:48.113475Z","iopub.status.idle":"2024-07-31T01:16:59.393919Z","shell.execute_reply.started":"2024-07-31T01:16:48.113437Z","shell.execute_reply":"2024-07-31T01:16:59.392416Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![image.png](attachment:0ba6bfd8-a9a0-4664-a0f4-ddf2819e9245.png)","metadata":{},"attachments":{"0ba6bfd8-a9a0-4664-a0f4-ddf2819e9245.png":{"image/png":"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"}}},{"cell_type":"code","source":"!pip install pydicom pillow","metadata":{"execution":{"iopub.status.busy":"2024-07-31T17:20:44.687974Z","iopub.execute_input":"2024-07-31T17:20:44.688913Z","iopub.status.idle":"2024-07-31T17:21:00.909155Z","shell.execute_reply.started":"2024-07-31T17:20:44.688878Z","shell.execute_reply":"2024-07-31T17:21:00.907563Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport random\nimport shutil\nimport pydicom\nimport numpy as np\nfrom PIL import Image\n\n# Function to convert DICOM to PNG\ndef convert_dicom_to_png(dicom_path, png_path):\n    dicom_data = pydicom.dcmread(dicom_path)\n    image = dicom_data.pixel_array\n    image = image.astype(np.float32)\n\n    # Normalize the image to [0, 255]\n    image = 255 * (image - np.min(image)) / (np.max(image) - np.min(image))\n    image = image.astype(np.uint8)\n\n    # Convert to PIL Image and save as PNG\n    img = Image.fromarray(image)\n    img.save(png_path)\n\n# Input and output directories\ndicom_dir = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/test_images/44036939/2828203845'\noutput_dir = '/kaggle/working/'\ndcm_output_dir = os.path.join(output_dir, 'dcm')\npng_output_dir = os.path.join(output_dir, 'png')\n\n# Create the output directories if they don't exist\nos.makedirs(dcm_output_dir, exist_ok=True)\nos.makedirs(png_output_dir, exist_ok=True)\n\n# Get list of DICOM files\ndicom_files = [f for f in os.listdir(dicom_dir) if f.endswith('.dcm')]\n\n# Select 10 random DICOM files\nselected_dicom_files = random.sample(dicom_files, 10)\n\n# Copy and convert each selected DICOM file\nfor dicom_file in selected_dicom_files:\n    dicom_path = os.path.join(dicom_dir, dicom_file)\n    \n    # Copy DICOM file to the dcm output directory\n    shutil.copy(dicom_path, dcm_output_dir)\n    \n    # Convert and save PNG in the png output directory\n    png_file_name = os.path.splitext(dicom_file)[0] + '.png'\n    png_path = os.path.join(png_output_dir, png_file_name)\n    convert_dicom_to_png(dicom_path, png_path)\n\nprint(f'Copied and converted {len(selected_dicom_files)} DICOM files to {output_dir}')","metadata":{"execution":{"iopub.status.busy":"2024-07-31T17:22:54.120748Z","iopub.execute_input":"2024-07-31T17:22:54.121244Z","iopub.status.idle":"2024-07-31T17:22:55.539185Z","shell.execute_reply.started":"2024-07-31T17:22:54.121209Z","shell.execute_reply":"2024-07-31T17:22:55.53782Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport random\nimport shutil\nimport pydicom\nimport numpy as np\nfrom PIL import Image\nimport torch\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\nimport time\nimport matplotlib.pyplot as plt\n\n# Define the input and output directories\ndicom_dir = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/test_images/44036939/2828203845'\noutput_dir = '/kaggle/working/'\ndcm_output_dir = os.path.join(output_dir, 'dcm')\npng_output_dir = os.path.join(output_dir, 'png')\n\n# Create the output directories if they don't exist\nos.makedirs(dcm_output_dir, exist_ok=True)\nos.makedirs(png_output_dir, exist_ok=True)\n\n# Function to convert DICOM to PNG with resizing\ndef convert_dicom_to_png(dicom_path, png_path, size):\n    dicom_data = pydicom.dcmread(dicom_path)\n    image = dicom_data.pixel_array\n    image = image.astype(np.float32)\n\n    # Normalize the image to [0, 255]\n    image = 255 * (image - np.min(image)) / (np.max(image) - np.min(image))\n    image = image.astype(np.uint8)\n\n    # Resize the image\n    img = Image.fromarray(image).resize((size, size))\n    img.save(png_path)\n\n# Custom dataset class for loading images\nclass CustomImageDataset(Dataset):\n    def __init__(self, image_dir, transform=None):\n        self.image_dir = image_dir\n        self.image_files = [f for f in os.listdir(image_dir) if f.endswith('.png') or f.endswith('.dcm')]\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.image_files)\n\n    def __getitem__(self, idx):\n        img_path = os.path.join(self.image_dir, self.image_files[idx])\n        if img_path.endswith('.dcm'):\n            dicom_data = pydicom.dcmread(img_path)\n            image = dicom_data.pixel_array\n            image = image.astype(np.float32)\n            image = 255 * (image - np.min(image)) / (np.max(image) - np.min(image))\n            image = image.astype(np.uint8)\n            image = Image.fromarray(image)\n        else:\n            image = Image.open(img_path).convert('L')\n\n        if self.transform:\n            image = self.transform(image)\n\n        return image, 0  # Dummy label\n\n# Sizes to test\nsizes = [32, 64, 128, 256, 512, 640]\n\n# Select 10 random DICOM files\ndicom_files = [f for f in os.listdir(dicom_dir) if f.endswith('.dcm')]\nselected_dicom_files = random.sample(dicom_files, 10)\n\n# Convert and save each selected DICOM file as PNG in different sizes\nfor size in sizes:\n    size_dir = os.path.join(png_output_dir, f'{size}')\n    os.makedirs(size_dir, exist_ok=True)\n    for dicom_file in selected_dicom_files:\n        dicom_path = os.path.join(dicom_dir, dicom_file)\n        png_file_name = os.path.splitext(dicom_file)[0] + '.png'\n        png_path = os.path.join(size_dir, png_file_name)\n        convert_dicom_to_png(dicom_path, png_path, size)\n\n# Function to measure loading time\ndef measure_loading_time(image_dir, batch_size=4):\n    transform = transforms.Compose([\n        transforms.ToTensor()\n    ])\n    dataset = CustomImageDataset(image_dir, transform=transform)\n    dataloader = DataLoader(dataset, batch_size=batch_size, num_workers=4)\n    \n    start_time = time.time()\n    for images, labels in dataloader:\n        pass  # Simulate processing\n    return time.time() - start_time\n\n# Measure loading times for different sizes and formats\nloading_times = {'dcm': [], 'png': {size: [] for size in sizes}}\n\n# Measure DICOM loading time for each size (using original DICOM files)\nfor size in sizes:\n    loading_times['dcm'].append(measure_loading_time(dicom_dir))\n\n# Measure PNG loading times for different sizes\nfor size in sizes:\n    size_dir = os.path.join(png_output_dir, f'{size}')\n    png_loading_time = measure_loading_time(size_dir)\n    loading_times['png'][size] = png_loading_time\n\n# Plot the loading times\nplt.figure(figsize=(10, 6))\nplt.plot(sizes, loading_times['dcm'], label='DICOM', marker='o')\nfor size in sizes:\n    plt.plot(size, loading_times['png'][int(size)], label=f'PNG {size}', marker='o')\nplt.xlabel('Image Size')\nplt.ylabel('Loading Time (seconds)')\nplt.title('Loading Times for Different Image Formats and Sizes')\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T17:27:29.947001Z","iopub.execute_input":"2024-07-31T17:27:29.947457Z","iopub.status.idle":"2024-07-31T17:27:38.097234Z","shell.execute_reply.started":"2024-07-31T17:27:29.947424Z","shell.execute_reply":"2024-07-31T17:27:38.095893Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport random\nimport shutil\nimport pydicom\nimport numpy as np\nfrom PIL import Image\nimport torch\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\nimport time\nimport matplotlib.pyplot as plt\n\n# Define the input and output directories\ndicom_dir = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images/1004726367/992525108'\noutput_dir = '/kaggle/working/'\ndcm_output_dir = os.path.join(output_dir, 'dcm')\npng_output_dir = os.path.join(output_dir, 'png')\n\n# Create the output directories if they don't exist\nos.makedirs(dcm_output_dir, exist_ok=True)\nos.makedirs(png_output_dir, exist_ok=True)\n\n# Function to convert DICOM to PNG with resizing\ndef convert_dicom_to_png(dicom_path, png_path, size):\n    dicom_data = pydicom.dcmread(dicom_path)\n    image = dicom_data.pixel_array\n    image = image.astype(np.float32)\n\n    # Normalize the image to [0, 255]\n    image = 255 * (image - np.min(image)) / (np.max(image) - np.min(image))\n    image = image.astype(np.uint8)\n\n    # Resize the image\n    img = Image.fromarray(image).resize((size, size))\n    img.save(png_path)\n\n# Custom dataset class for loading images\nclass CustomImageDataset(Dataset):\n    def __init__(self, image_dir, transform=None):\n        self.image_dir = image_dir\n        self.image_files = [f for f in os.listdir(image_dir) if f.endswith('.png') or f.endswith('.dcm')]\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.image_files)\n\n    def __getitem__(self, idx):\n        img_path = os.path.join(self.image_dir, self.image_files[idx])\n        if img_path.endswith('.dcm'):\n            dicom_data = pydicom.dcmread(img_path)\n            image = dicom_data.pixel_array\n            image = image.astype(np.float32)\n            image = 255 * (image - np.min(image)) / (np.max(image) - np.min(image))\n            image = image.astype(np.uint8)\n            image = Image.fromarray(image)\n        else:\n            image = Image.open(img_path).convert('L')\n\n        if self.transform:\n            image = self.transform(image)\n\n        return image, 0  # Dummy label\n\n# Sizes to test\nsizes = [32, 64, 128, 256, 512, 640]\n\n# Select 10 random DICOM files\ndicom_files = [f for f in os.listdir(dicom_dir) if f.endswith('.dcm')]\nselected_dicom_files = random.sample(dicom_files, 30)\n\n# Convert and save each selected DICOM file as PNG in different sizes\nfor size in sizes:\n    size_dir = os.path.join(png_output_dir, f'{size}')\n    os.makedirs(size_dir, exist_ok=True)\n    for dicom_file in selected_dicom_files:\n        dicom_path = os.path.join(dicom_dir, dicom_file)\n        png_file_name = os.path.splitext(dicom_file)[0] + '.png'\n        png_path = os.path.join(size_dir, png_file_name)\n        convert_dicom_to_png(dicom_path, png_path, size)\n\n# Function to measure loading time\ndef measure_loading_time(image_dir, batch_size=4):\n    transform = transforms.Compose([\n        transforms.ToTensor()\n    ])\n    dataset = CustomImageDataset(image_dir, transform=transform)\n    dataloader = DataLoader(dataset, batch_size=batch_size, num_workers=4)\n    \n    start_time = time.time()\n    for images, labels in dataloader:\n        pass  # Simulate processing\n    return time.time() - start_time\n\n# Function to measure DataLoader creation time\ndef measure_loader_creation_time(image_dir, batch_size=4):\n    transform = transforms.Compose([\n        transforms.ToTensor()\n    ])\n    dataset = CustomImageDataset(image_dir, transform=transform)\n    \n    start_time = time.time()\n    dataloader = DataLoader(dataset, batch_size=batch_size, num_workers=4)\n    return time.time() - start_time\n\n# Measure loading times for different sizes and formats\nloading_times = {'dcm': [], 'png': []}\ncreation_times = {'dcm': [], 'png': []}\n\n# Measure DICOM loading and creation time\nloading_time = measure_loading_time(dicom_dir)\ncreation_time = measure_loader_creation_time(dicom_dir)\nfor _ in sizes:\n    loading_times['dcm'].append(loading_time)\n    creation_times['dcm'].append(creation_time)\n\n# Measure PNG loading and creation times for different sizes\nfor size in sizes:\n    size_dir = os.path.join(png_output_dir, f'{size}')\n    loading_time = measure_loading_time(size_dir)\n    creation_time = measure_loader_creation_time(size_dir)\n    loading_times['png'].append(loading_time)\n    creation_times['png'].append(creation_time)\n\n# Plot the loading times\nplt.figure(figsize=(10, 6))\nplt.plot(sizes, loading_times['dcm'], label='DICOM', marker='o')\nplt.plot(sizes, loading_times['png'], label='PNG', marker='o')\nplt.xlabel('Image Size')\nplt.ylabel('Loading Time (seconds)')\nplt.title('Loading Times for Different Image Formats and Sizes')\nplt.legend()\nplt.show()\n\n# Plot the DataLoader creation times\nplt.figure(figsize=(10, 6))\nplt.plot(sizes, creation_times['dcm'], label='DICOM', marker='o')\nplt.plot(sizes, creation_times['png'], label='PNG', marker='o')\nplt.xlabel('Image Size')\nplt.ylabel('DataLoader Creation Time (seconds)')\nplt.title('DataLoader Creation Times for Different Image Formats and Sizes')\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T17:38:08.392007Z","iopub.execute_input":"2024-07-31T17:38:08.39245Z","iopub.status.idle":"2024-07-31T17:38:16.934652Z","shell.execute_reply.started":"2024-07-31T17:38:08.392411Z","shell.execute_reply":"2024-07-31T17:38:16.933292Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport pandas as pd\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:41:38.994845Z","iopub.execute_input":"2024-08-01T04:41:38.995262Z","iopub.status.idle":"2024-08-01T04:41:41.802446Z","shell.execute_reply.started":"2024-08-01T04:41:38.995229Z","shell.execute_reply":"2024-08-01T04:41:41.801339Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"data_path = \"/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images\"\n\npatient_data = []\n\n# List directories\ndirectories = [d for d in os.listdir(data_path) if os.path.isdir(os.path.join(data_path, d))]\n\n# Limit to the first 10 directories\nlimited_directories = directories[:10]\n\n#limited_directories","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:45:29.105273Z","iopub.execute_input":"2024-08-01T04:45:29.105697Z","iopub.status.idle":"2024-08-01T04:45:29.132108Z","shell.execute_reply.started":"2024-08-01T04:45:29.105664Z","shell.execute_reply":"2024-08-01T04:45:29.130879Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from tqdm import tqdm\n\n# Traverse only the first 10 directories with progress bar\nfor study_id in tqdm(limited_directories, desc=\"Processing Patients\"):\n    study_path = os.path.join(data_path, study_id)\n    for series_id in os.listdir(study_path):\n        series_path = os.path.join(study_path, series_id)\n        if os.path.isdir(series_path):\n            for file in os.listdir(series_path):\n                if file.endswith(\".dcm\"):\n                    file_path = os.path.join(series_path, file)\n                    dicom = pydicom.dcmread(file_path)\n                    instance_number = dicom.InstanceNumber\n                    # Get Series Description (Sequence Name)\n                    series_description = dicom.get('Series Description', 'Unknown')\n                    patient_data.append([study_id, series_description, instance_number])\n\n\n# Convert to DataFrame\ndf = pd.DataFrame(patient_data, columns=['StudyID', 'SeriesID', 'InstanceNumber'])\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:53:43.391686Z","iopub.execute_input":"2024-08-01T04:53:43.392288Z","iopub.status.idle":"2024-08-01T04:53:44.657747Z","shell.execute_reply.started":"2024-08-01T04:53:43.392249Z","shell.execute_reply":"2024-08-01T04:53:44.656633Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Convert to DataFrame\ndf = pd.DataFrame(patient_data, columns=['StudyID', 'SeriesID', 'InstanceNumber'])\n\n# Count instances per SeriesID per StudyID\ninstance_counts = df.groupby(['StudyID', 'SeriesID']).size().reset_index(name='InstanceCount')\n\n# Debugging step: Print first few rows of the instance_counts to verify the data\nprint(instance_counts.head())\n\n\n# Plotting with Matplotlib\nplt.figure(figsize=(12, 8))\n\n# Generate the plot\nfor study_id in instance_counts['StudyID'].unique():\n    study_data = instance_counts[instance_counts['StudyID'] == study_id]\n    plt.bar(study_data['SeriesID'], study_data['InstanceCount'], label=f'Study ID: {study_id}')\n\nplt.title('Number of Instances per Series for Each Patient (First 10 Folders)')\nplt.xlabel('Series ID')\nplt.ylabel('Number of Instances')\nplt.legend(title='Study ID', bbox_to_anchor=(1.05, 1), loc='upper left')\nplt.xticks(rotation=90)\nplt.tight_layout()\n\n# Show the plot\nplt.savefig(\"ds.png\")\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:53:48.145388Z","iopub.execute_input":"2024-08-01T04:53:48.146412Z","iopub.status.idle":"2024-08-01T04:53:49.981241Z","shell.execute_reply.started":"2024-08-01T04:53:48.146371Z","shell.execute_reply":"2024-08-01T04:53:49.980163Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(instance_counts.head())","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:48:53.688993Z","iopub.execute_input":"2024-08-01T04:48:53.689401Z","iopub.status.idle":"2024-08-01T04:48:53.698385Z","shell.execute_reply.started":"2024-08-01T04:48:53.689371Z","shell.execute_reply":"2024-08-01T04:48:53.696617Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"%matplotlib inline","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:49:04.212074Z","iopub.execute_input":"2024-08-01T04:49:04.212838Z","iopub.status.idle":"2024-08-01T04:49:04.219319Z","shell.execute_reply.started":"2024-08-01T04:49:04.212794Z","shell.execute_reply":"2024-08-01T04:49:04.217961Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom tqdm import tqdm\n\ndata_path = \"/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images\"\n\nslice_gaps = []\n\n# List directories\ndirectories = [d for d in os.listdir(data_path) if os.path.isdir(os.path.join(data_path, d))]\n\n# Limit to the first 10 directories\nlimited_directories = directories[:10]\n\n# Traverse only the first 10 directories with progress bar\nfor study_id in tqdm(limited_directories, desc=\"Processing Patients\"):\n    study_path = os.path.join(data_path, study_id)\n    for series_id in os.listdir(study_path):\n        series_path = os.path.join(study_path, series_id)\n        if os.path.isdir(series_path):\n            positions = []\n            for file in os.listdir(series_path):\n                if file.endswith(\".dcm\"):\n                    file_path = os.path.join(series_path, file)\n                    dicom = pydicom.dcmread(file_path)\n                    # Get Image Position (Patient) - assuming this tag contains slice positions\n                    position = dicom.ImagePositionPatient[2]  # Z-coordinate\n                    positions.append(position)\n            \n            # Calculate gaps between consecutive slices\n            if len(positions) > 1:\n                positions.sort()\n                gaps = [positions[i+1] - positions[i] for i in range(len(positions) - 1)]\n                slice_gaps.extend(gaps)\n\n# Plot the distribution of gaps between slices\nplt.figure(figsize=(12, 6))\nplt.hist(slice_gaps, bins=30, edgecolor='black')\nplt.title('Distribution of Gaps Between Slices')\nplt.xlabel('Gap Between Slices (mm)')\nplt.ylabel('Frequency')\nplt.grid(True)\n\n# Show the plot\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:56:59.847652Z","iopub.execute_input":"2024-08-01T04:56:59.848133Z","iopub.status.idle":"2024-08-01T04:57:02.238342Z","shell.execute_reply.started":"2024-08-01T04:56:59.848098Z","shell.execute_reply":"2024-08-01T04:57:02.237316Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom tqdm import tqdm\n\ndata_path = \"/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images\"\n\n# Dictionary to store gaps for each series\nseries_gaps = {}\n\n# List directories\ndirectories = [d for d in os.listdir(data_path) if os.path.isdir(os.path.join(data_path, d))]\n\n# Limit to the first 10 directories\nlimited_directories = directories[:10]\n\n# Traverse only the first 10 directories with progress bar\nfor study_id in tqdm(limited_directories, desc=\"Processing Patients\"):\n    study_path = os.path.join(data_path, study_id)\n    for series_id in os.listdir(study_path):\n        series_path = os.path.join(study_path, series_id)\n        if os.path.isdir(series_path):\n            positions = []\n            for file in os.listdir(series_path):\n                if file.endswith(\".dcm\"):\n                    file_path = os.path.join(series_path, file)\n                    dicom = pydicom.dcmread(file_path)\n                    # Get Image Position (Patient) - assuming this tag contains slice positions\n                    position = dicom.ImagePositionPatient[2]  # Z-coordinate\n                    positions.append(position)\n            \n            # Calculate gaps between consecutive slices\n            if len(positions) > 1:\n                positions.sort()\n                gaps = [positions[i+1] - positions[i] for i in range(len(positions) - 1)]\n                series_gaps[series_id] = gaps\n\n# Plot the distribution of gaps for each series\nplt.figure(figsize=(14, 8))\n\nfor series_id, gaps in series_gaps.items():\n    plt.hist(gaps, bins=30, alpha=0.5, label=f'Series: {series_id}')\n\nplt.title('Distribution of Gaps Between Slices for Each Series')\nplt.xlabel('Gap Between Slices (mm)')\nplt.ylabel('Frequency')\nplt.legend(title='Series ID')\nplt.grid(True)\n\n# Show the plot\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:57:37.861406Z","iopub.execute_input":"2024-08-01T04:57:37.861827Z","iopub.status.idle":"2024-08-01T04:57:41.680893Z","shell.execute_reply.started":"2024-08-01T04:57:37.861797Z","shell.execute_reply":"2024-08-01T04:57:41.67962Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom tqdm import tqdm\n\ndata_path = \"/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images\"\n\nseries_lengths = {}\n\n# List directories\ndirectories = [d for d in os.listdir(data_path) if os.path.isdir(os.path.join(data_path, d))]\n\n# Limit to the first 10 directories\nlimited_directories = directories[:10]\n\n# Traverse only the first 10 directories with progress bar\nfor study_id in tqdm(limited_directories, desc=\"Processing Patients\"):\n    study_path = os.path.join(data_path, study_id)\n    for series_id in os.listdir(study_path):\n        series_path = os.path.join(study_path, series_id)\n        if os.path.isdir(series_path):\n            positions = []\n            for file in os.listdir(series_path):\n                if file.endswith(\".dcm\"):\n                    file_path = os.path.join(series_path, file)\n                    dicom = pydicom.dcmread(file_path)\n                    # Get Image Position (Patient) - assuming this tag contains slice positions\n                    position = dicom.ImagePositionPatient[2]  # Z-coordinate\n                    positions.append(position)\n            \n            # Calculate gaps between consecutive slices\n            if len(positions) > 1:\n                positions.sort()\n                gaps = [positions[i+1] - positions[i] for i in range(len(positions) - 1)]\n                average_gap = sum(gaps) / len(gaps)  # Average gap between slices\n                length_scanned = average_gap * (len(positions) - 1)\n                series_lengths[series_id] = length_scanned\n\n# Plot the length scanned for each series\nplt.figure(figsize=(14, 8))\n\nseries_ids = list(series_lengths.keys())\nlengths = list(series_lengths.values())\n\nplt.bar(series_ids, lengths, color='skyblue')\nplt.title('Length Scanned per Series')\nplt.xlabel('Series ID')\nplt.ylabel('Length Scanned (mm)')\nplt.xticks(rotation=90)\nplt.grid(axis='y')\n\n# Show the plot\nplt.tight_layout()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T04:59:15.617325Z","iopub.execute_input":"2024-08-01T04:59:15.61822Z","iopub.status.idle":"2024-08-01T04:59:18.951014Z","shell.execute_reply.started":"2024-08-01T04:59:15.618178Z","shell.execute_reply":"2024-08-01T04:59:18.949801Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom tqdm import tqdm\n\ndata_path = \"/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images\"\n\nlengths_scanned = []\n\n# List directories\ndirectories = [d for d in os.listdir(data_path) if os.path.isdir(os.path.join(data_path, d))]\n\n# Limit to the first 100 directories\nlimited_directories = directories[:100]\n\n# Traverse only the first 100 directories with progress bar\nfor study_id in tqdm(limited_directories, desc=\"Processing Patients\"):\n    study_path = os.path.join(data_path, study_id)\n    for series_id in os.listdir(study_path):\n        series_path = os.path.join(study_path, series_id)\n        if os.path.isdir(series_path):\n            positions = []\n            for file in os.listdir(series_path):\n                if file.endswith(\".dcm\"):\n                    file_path = os.path.join(series_path, file)\n                    dicom = pydicom.dcmread(file_path)\n                    # Get Image Position (Patient) - assuming this tag contains slice positions\n                    position = dicom.ImagePositionPatient[2]  # Z-coordinate\n                    positions.append(position)\n            \n            # Calculate gaps between consecutive slices\n            if len(positions) > 1:\n                positions.sort()\n                gaps = [positions[i+1] - positions[i] for i in range(len(positions) - 1)]\n                average_gap = sum(gaps) / len(gaps)  # Average gap between slices\n                length_scanned = average_gap * (len(positions) - 1)\n                lengths_scanned.append(length_scanned)\n\n# Plot the histogram of the length distribution\nplt.figure(figsize=(12, 6))\nplt.hist(lengths_scanned, bins=30, edgecolor='black')\nplt.title('Distribution of Scanned Lengths for First 100 Folders')\nplt.xlabel('Length Scanned (mm)')\nplt.ylabel('Frequency')\nplt.grid(True)\n\n# Show the plot\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T05:00:10.003099Z","iopub.execute_input":"2024-08-01T05:00:10.003862Z","iopub.status.idle":"2024-08-01T05:00:22.185511Z","shell.execute_reply.started":"2024-08-01T05:00:10.003823Z","shell.execute_reply":"2024-08-01T05:00:22.184442Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pydicom\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\n\ndata_path = \"/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification/train_images\"\n\nlengths_scanned = []\n\n# List directories\ndirectories = [d for d in os.listdir(data_path) if os.path.isdir(os.path.join(data_path, d))]\n\n# Limit to the first 100 directories\nlimited_directories = directories[:100]\n\n# Traverse only the first 100 directories with progress bar\nfor study_id in tqdm(limited_directories, desc=\"Processing Patients\"):\n    study_path = os.path.join(data_path, study_id)\n    for series_id in os.listdir(study_path):\n        series_path = os.path.join(study_path, series_id)\n        if os.path.isdir(series_path):\n            positions = []\n            for file in os.listdir(series_path):\n                if file.endswith(\".dcm\"):\n                    file_path = os.path.join(series_path, file)\n                    dicom = pydicom.dcmread(file_path)\n                    # Get Image Position (Patient) - assuming this tag contains slice positions\n                    position = dicom.ImagePositionPatient  # X, Y, Z coordinates\n                    positions.append(position)\n            \n            # Calculate distances between consecutive slices\n            if len(positions) > 1:\n                positions = np.array(positions)\n                distances = np.sqrt(np.sum(np.diff(positions, axis=0) ** 2, axis=1))\n                average_distance = np.mean(distances)\n                length_scanned = average_distance * (len(positions) - 1)\n                lengths_scanned.append(length_scanned)\n\n# Plot the histogram of the length distribution\nplt.figure(figsize=(12, 6))\nplt.hist(lengths_scanned, bins=30, edgecolor='black')\nplt.title('Distribution of Scanned Lengths for First 100 Folders')\nplt.xlabel('Length Scanned (mm)')\nplt.ylabel('Frequency')\nplt.grid(True)\n\n# Show the plot\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-08-01T05:02:07.13433Z","iopub.execute_input":"2024-08-01T05:02:07.134808Z","iopub.status.idle":"2024-08-01T05:02:20.131853Z","shell.execute_reply.started":"2024-08-01T05:02:07.134776Z","shell.execute_reply":"2024-08-01T05:02:20.130636Z"},"trusted":true},"execution_count":null,"outputs":[]}]}