py3dcal 1.0.5__py3-none-any.whl

py3DCal/model_training/lib/train_model.py

@@ -0,0 +1,96 @@
+import torch
+import torch.optim as optim
+import torch.nn as nn
+from torch.utils.data import DataLoader
+from ..datasets.tactile_sensor_dataset import TactileSensorDataset
+from ..datasets.split_dataset import split_dataset
+from .validate_parameters import validate_device
+
+
+def train_model(model: nn.Module, dataset: TactileSensorDataset, num_epochs: int = 60, batch_size: int = 64, learning_rate: float = 1e-4, train_ratio: float = 0.8, loss_fn: nn.Module = nn.MSELoss(), device='cpu'):
+    """
+    Train TouchNet model on a dataset for 60 epochs with a
+    64 batch size, and AdamW optimizer with learning rate 1e-4.
+
+    Args:
+        model (nn.Module): The PyTorch model to be trained.
+        dataset (py3DCal.datasets.TactileSensorDataset): The dataset to train the model on.
+        num_epochs (int): Number of epochs to train for. Defaults to 60.
+        batch_size (int): Batch size. Defaults to 64.
+        learning_rate (float): Learning rate. Defaults to 1e-4.
+        train_ratio (float): Proportion of data to use for training. Defaults to 0.8.
+        loss_fn (nn.Module): Loss function. Defaults to nn.MSELoss().
+        device (str): Device to run the training on. Defaults to 'cpu'.
+
+    Outputs:
+        weights.pth: Trained model weights.
+        loss.csv: Training and testing losses.
+    """
+    validate_device(device)
+    _validate_model_and_dataset(model, dataset)
+
+    optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=1e-4)
+    train_dataset, val_dataset = split_dataset(dataset, train_ratio=train_ratio)
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=True if device == "cuda" else False, persistent_workers=True)
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True if device == "cuda" else False, persistent_workers=True)
+
+    model.to(device)
+
+    epoch_train_losses = []
+    epoch_val_losses = []
+    
+    print("Starting training...\n")
+
+    # Training loop
+    for epoch in range(num_epochs):
+        print(f"Epoch {epoch+1}/{num_epochs}")
+
+        model.train()
+        train_loss = 0.0
+        for batch_idx, (inputs, targets) in enumerate(train_loader):
+            inputs = inputs.to(torch.float32).to(device)
+            targets = targets.to(torch.float32).to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+
+            loss = loss_fn(outputs, targets)
+            loss.backward()
+            optimizer.step()
+
+            train_loss += loss.item()
+
+            print(f"  [Batch {batch_idx}/{len(train_loader)}] - Loss: {loss.item():.4f}")
+
+        avg_train_loss = train_loss / len(train_loader)
+        epoch_train_losses.append(avg_train_loss)
+        print(f"Epoch {epoch+1}/{num_epochs} | Train Loss: {avg_train_loss:.4f}")
+
+        # Validation loop
+        model.eval()
+        val_loss = 0.0
+        
+        with torch.no_grad():
+            for inputs, targets in val_loader:
+                inputs = inputs.to(torch.float32).to(device)
+                targets = targets.to(torch.float32).to(device)
+                outputs = model(inputs)
+                loss = loss_fn(outputs, targets)
+                val_loss += loss.item()
+
+        avg_val_loss = val_loss / len(val_loader)
+        epoch_val_losses.append(avg_val_loss)
+        print(f"VAL LOSS: {avg_val_loss:.4f}")
+
+    with open("losses.csv", "w") as f:
+        f.write("epoch,train_loss,val_loss\n")
+        for i in range(len(epoch_train_losses)):
+            f.write(f"{i+1},{epoch_train_losses[i]},{epoch_val_losses[i]}\n")
+    
+    torch.save(model.state_dict(), "weights.pth")
+
+def _validate_model_and_dataset(model: nn.Module, dataset: TactileSensorDataset):
+    if not isinstance(model, nn.Module):
+        raise ValueError("Model must be an instance of torch.nn.Module.")
+    
+    if not isinstance(dataset, TactileSensorDataset):
+        raise ValueError("Dataset must be an instance of py3DCal.datasets.TactileSensorDataset.")

py3DCal/model_training/lib/validate_parameters.py

@@ -0,0 +1,87 @@
+import os
+import torch
+from typing import Union
+from pathlib import Path
+
+def validate_device(device: str):
+        """
+        Validates the device by converting it to a torch.device object.
+        Args:
+            device (str): Device to run the model on.
+        Returns:
+            None.
+        Raises:
+            ValueError: If the device is not specified or invalid.
+        """
+        try:
+            device = torch.device(device)
+        except Exception as e:
+            raise ValueError(
+                f"Invalid device '{device}'. Valid options include:\n"
+                "  - 'cpu': CPU processing\n"
+                "  - 'cuda' or 'cuda:0': NVIDIA GPU\n"
+                "  - 'mps': Apple Silicon GPU\n"
+                "See: https://pytorch.org/docs/stable/tensor_attributes.html#torch.device"
+            ) from e
+        
+def validate_root(root, must_exist=False):
+    """
+    Validates the root path specified by the user.
+
+    Args:
+        root: root path specified by the user.
+    Returns:
+        None.
+    Raises:
+        ValueError: If the root is not specified or invalid.
+    """
+    if root is None :
+       raise ValueError(
+           "root directory cannot be None.\n"
+       )
+    
+    if not isinstance(root, (str, Path)):
+       raise ValueError(
+           "root directory must be a valid file system path as a string or pathlib.Path object\n"
+       )
+    
+    if must_exist and not os.path.exists(root):
+         raise ValueError(
+              f"root directory '{root}' does not exist.\n"
+         )
+
+def validate_dataset(root, subtract_blank: bool):
+    """
+    Validates the dataset path specified by the user.
+
+    Args:
+        root: Dataset path specified by the user.
+        subtract_blank (bool): Whether to subtract blank image.
+    Returns:
+        None.
+    Raises:
+        FileNotFoundError: If necessary files do not exist.
+    """
+    validate_root(root)
+
+    annotation_path = os.path.join(root, "annotations", "annotations.csv")
+    metadata_path = os.path.join(root, "annotations", "metadata.json")
+    probe_images_path = os.path.join(root, "probe_images")
+    blank_image_path = os.path.join(root, "blank_images", "blank.png")
+
+    # Check if root directory exists
+    if not os.path.exists(root):
+        raise FileNotFoundError(f"Dataset root directory '{root}' does not exist.")
+
+    # Check if all the necessary files exist
+    if not os.path.exists(annotation_path):
+        raise FileNotFoundError(f"annotations.csv file not found in annotations/ directory. Use py3DCal.annotations() function to create it.")
+
+    if not os.path.exists(metadata_path):
+        raise FileNotFoundError(f"metadata.json file not found in annotations/ directory. Use py3DCal.annotations() function to create it.")
+
+    if not os.path.exists(probe_images_path):
+        raise FileNotFoundError(f"probe_images/ directory not found in dataset root.")
+
+    if subtract_blank and not os.path.exists(blank_image_path):
+        raise FileNotFoundError(f"blank.png file not found in blank_images/ directory.")

py3DCal/model_training/models/__init__.py

@@ -0,0 +1 @@
+from .touchnet import SensorType, TouchNet

py3DCal/model_training/models/touchnet.py

@@ -0,0 +1,211 @@
+import os
+import requests
+from tqdm import tqdm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from enum import Enum
+from typing import Union
+from pathlib import Path
+
+class SensorType(Enum):
+    """
+    SensorType: Available sensor types with pretrained weights and compiled datasets
+    """
+    DIGIT = "DIGIT"
+    GELSIGHTMINI = "GelSightMini"
+
+class TouchNet(nn.Module):
+    """
+    TouchNet: A PyTorch neural network for producing surface normal maps from tactile sensor images.
+
+    Args:
+        load_pretrained (bool): If True, loads pretrained weights for the specified sensor type.
+        sensor_type (SensorType): The type of tactile sensor. Must be specified if load_pretrained is True.
+        root (str or pathlib.Path): The root directory for saving/loading the pretrained_weights (.pth) file.
+    """
+    def __init__(self, load_pretrained: bool = False, sensor_type: SensorType = None, root: Union[str, Path] = "."):
+        super().__init__()
+
+        self._validate_parameters(load_pretrained, sensor_type, root)
+
+        self.conv1 = nn.Conv2d(5, 32, kernel_size=7, padding=3)
+        self.bn1 = nn.BatchNorm2d(32)
+        self.dropout1 = nn.Dropout2d(0.2)
+
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=7, padding=3)
+        self.bn2 = nn.BatchNorm2d(64)
+        self.dropout2 = nn.Dropout2d(0.2)
+
+        self.conv3 = nn.Conv2d(64, 128, kernel_size=7, padding=3)
+        self.bn3 = nn.BatchNorm2d(128)
+        self.dropout3 = nn.Dropout2d(0.2)
+
+        self.conv4 = nn.Conv2d(128, 256, kernel_size=5, padding=2)
+        self.bn4 = nn.BatchNorm2d(256)
+        self.dropout4 = nn.Dropout2d(0.3)
+
+        self.conv5 = nn.Conv2d(256, 256, kernel_size=5, padding=2)
+        self.bn5 = nn.BatchNorm2d(256)
+        self.dropout5 = nn.Dropout2d(0.3)
+
+        self.conv6 = nn.Conv2d(256, 128, kernel_size=5, padding=2)
+        self.bn6 = nn.BatchNorm2d(128)
+        self.dropout6 = nn.Dropout2d(0.2)
+
+        self.conv7 = nn.Conv2d(128, 64, kernel_size=3, padding=1)
+        self.bn7 = nn.BatchNorm2d(64)   
+        self.dropout7 = nn.Dropout2d(0.2)
+
+        self.conv8 = nn.Conv2d(64, 32, kernel_size=3, padding=1)
+        self.bn8 = nn.BatchNorm2d(32)
+        self.dropout8 = nn.Dropout2d(0.2)
+
+        self.conv9 = nn.Conv2d(32, 2, kernel_size=1)
+
+        if load_pretrained:
+            self._load_pretrained_model(root, sensor_type)
+    
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = self.dropout1(x)
+
+        x = F.relu(self.bn2(self.conv2(x)))
+        x = self.dropout2(x)
+
+        x = F.relu(self.bn3(self.conv3(x)))
+        x = self.dropout3(x)
+
+        x = F.relu(self.bn4(self.conv4(x)))
+        x = self.dropout4(x)
+
+        x = F.relu(self.bn5(self.conv5(x)))
+        x = self.dropout5(x)
+
+        x = F.relu(self.bn6(self.conv6(x)))
+        x = self.dropout6(x)
+
+        x = F.relu(self.bn7(self.conv7(x)))
+        x = self.dropout7(x)
+
+        x = F.relu(self.bn8(self.conv8(x)))
+        x = self.dropout8(x)
+
+        x = self.conv9(x)
+
+        return x
+    
+    def _validate_parameters(self, load_pretrained, sensor_type, root):
+        if load_pretrained and sensor_type is None:
+            raise ValueError("sensor_type must be specified when load_pretrained is True. sensor_type must be either SensorType.DIGIT or SensorType.GELSIGHTMINI.")
+
+        if load_pretrained and not isinstance(sensor_type, SensorType):
+            raise ValueError("sensor_type must be either SensorType.DIGIT or SensorType.GELSIGHTMINI.")
+        
+        if load_pretrained and root is None:
+            raise ValueError("root directory for storing/loading model cannot be None when load_pretrained is True.")
+        
+        if load_pretrained and not isinstance(root, (str, Path)):
+            raise ValueError("root directory must be a valid file system path as a string or pathlib.Path object when load_pretrained is True.")
+
+        if not load_pretrained and sensor_type is not None:
+            print("Warning: sensor_type parameter is ignored when load_pretrained is False.")
+
+        if not load_pretrained and root is not ".":
+            print("Warning: root parameter is ignored when load_pretrained is False.")
+
+    def _load_pretrained_model(self, root, sensor_type):
+        """
+        Loads a pretrained model for either the DIGIT or GelSightMini sensor.
+        Args:
+            None.
+        Returns:
+            None.
+        """
+        
+        if sensor_type == SensorType.DIGIT:
+            file_path = os.path.join(root, "digit_pretrained_weights.pth")
+
+            # Check if DIGIT pretrained weights exist locally, if not download them
+            if not os.path.exists(file_path):
+
+                print(f"Downloading DIGIT pretrained weights ...")
+                response = requests.get('https://zenodo.org/records/17517028/files/digit_pretrained_weights.pth?download=1', stream=True)
+                response.raise_for_status()
+
+                total_size = int(response.headers.get('content-length', 0))
+                block_size = 1024
+
+                # Save file in chunks to handle large datasets
+                with open(file_path, 'wb') as f, tqdm(
+                    total=total_size,
+                    unit='B',
+                    unit_scale=True,
+                    desc="Downloading",
+                    ncols=80
+                ) as progress_bar:
+                    for chunk in response.iter_content(chunk_size=block_size):
+                        if chunk:
+                            f.write(chunk)
+                            progress_bar.update(len(chunk))
+
+                print(f"Download complete!")
+            else:
+                print(f"DIGIT pretrained weights already exists at: {file_path}/")
+
+        elif sensor_type == SensorType.GELSIGHTMINI:
+            file_path = os.path.join(root, "gsmini_pretrained_weights.pth")
+
+            # Check if GelSight Mini pretrained weights exist locally, if not download them
+            if not os.path.exists(file_path):
+
+                print(f"Downloading GelSight Mini pretrained weights ...")
+                response = requests.get('https://zenodo.org/records/17517028/files/gsmini_pretrained_weights.pth?download=1', stream=True)
+                response.raise_for_status()
+
+                total_size = int(response.headers.get('content-length', 0))
+                block_size = 1024
+
+                # Save file in chunks to handle large datasets
+                with open(file_path, 'wb') as f, tqdm(
+                    total=total_size,
+                    unit='B',
+                    unit_scale=True,
+                    desc="Downloading",
+                    ncols=80
+                ) as progress_bar:
+                    for chunk in response.iter_content(chunk_size=block_size):
+                        if chunk:
+                            f.write(chunk)
+                            progress_bar.update(len(chunk))
+
+                print(f"Download complete!")
+            else:
+                print(f"GelSight Mini pretrained weights already exists at: {file_path}/")
+
+        state_dict = torch.load(file_path, map_location="cpu")
+
+        self.load_state_dict(state_dict)
+
+    def load_weights(self, weights_path: Union[str, Path]):
+        """
+        Loads model weights from a specified .pth file.
+
+        Args:
+            weights_path (str or pathlib.Path): The file path to the .pth file containing the model weights.
+        Returns:
+            None.
+        Raises:
+            ValueError: If the weights_path is not specified or invalid.
+        """
+        if weights_path is None:
+            raise ValueError("weights_path cannot be None.")
+
+        if not isinstance(weights_path, (str, Path)):
+            raise ValueError("weights_path must be a valid file system path as a string or pathlib.Path object.")
+
+        if not os.path.exists(weights_path):
+            raise ValueError(f"The specified weights_path does not exist: {weights_path}")
+
+        state_dict = torch.load(weights_path, map_location="cpu")
+        self.load_state_dict(state_dict)

py3DCal/utils/utils.py

@@ -0,0 +1,32 @@
+import serial
+import sys
+import glob
+
+def list_com_ports():
+        """ Prints serial port names
+
+        :raises EnvironmentError:
+            On unsupported or unknown platforms
+        """
+        if sys.platform.startswith('win'):
+            ports = ['COM%s' % (i + 1) for i in range(256)]
+        elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
+            # this excludes your current terminal "/dev/tty"
+            ports = glob.glob('/dev/tty[A-Za-z]*')
+        elif sys.platform.startswith('darwin'):
+            ports = glob.glob('/dev/tty.*')
+        else:
+            raise EnvironmentError('Unsupported platform')
+
+        result = []
+        for port in ports:
+            try:
+                s = serial.Serial(port)
+                s.close()
+                result.append(port)
+            except (OSError, serial.SerialException):
+                pass
+        
+        print('Available COM Ports: ', end='')
+        print(result)
+        print('\n')

py3dcal-1.0.5.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rohan Kota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py3dcal-1.0.5.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: py3dcal
+Version: 1.0.5
+Summary: UNKNOWN
+Home-page: https://github.com/rohankotanu/py3DCal
+Author: Rohan Kota
+Author-email: rohankota2026@u.northwestern.edu
+License: MIT
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.0.0
+Requires-Dist: matplotlib>=3.0.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scipy>=1.0.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.23.0
+Requires-Dist: pyserial>=3.0
+Requires-Dist: opencv-python>=4.0.0
+Requires-Dist: pillow>=11.0.0
+Requires-Dist: tqdm>=4.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: digit-interface>=0.2.1
+
+# For instructions on how to use this library, please visit https://rohankotanu.github.io/3DCal/
+

py3dcal-1.0.5.dist-info/RECORD

@@ -0,0 +1,40 @@
+py3DCal/__init__.py,sha256=dvqOqTSeNzPAVY37lJGxNjW1IfWK6M3nxt940hDYT-4,813
+py3DCal/data_collection/Calibrator.py,sha256=X9LaLrIPv2maBZR3CwZuWrtKISjsP3GxNEx8UvwVbmc,11586
+py3DCal/data_collection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/data_collection/printers/Printer.py,sha256=ouqgWuJWk8PPjhTRFwolnupXbE0SzO819LIgw1ug-7s,1628
+py3DCal/data_collection/printers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/data_collection/printers/Ender3/Ender3.py,sha256=pkE9Kt-mMH-fpZC5Gl6YyDPAxOdfZxp4Z7s68N7D_is,2239
+py3DCal/data_collection/printers/Ender3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/data_collection/sensors/Sensor.py,sha256=o4tdkPMU2RF27OcOoxLABE4-K7R7Cf-d7kiT-KEDwAk,1063
+py3DCal/data_collection/sensors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/data_collection/sensors/DIGIT/DIGIT.py,sha256=1Jc1qXwinsOFjJ6-QUoUcXOBFjG4M6ylnUjbWMe3NSc,1268
+py3DCal/data_collection/sensors/DIGIT/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/data_collection/sensors/DIGIT/default.csv,sha256=OqjTE9b5uAEAxrHyjsxS7UyUWHgjO8yWPN0gVbBj7_Q,26728
+py3DCal/data_collection/sensors/GelsightMini/GelsightMini.py,sha256=nQ8JbiQypLCdTLM4WBNmXB_FFQ_yyxJ9gaV-OoE08Gg,1193
+py3DCal/data_collection/sensors/GelsightMini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/data_collection/sensors/GelsightMini/default.csv,sha256=lavPHcJ6o4VkvMvOk7lcdRCp9dOJxg_VrPNayf9zVvM,26449
+py3DCal/model_training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/model_training/datasets/DIGIT_dataset.py,sha256=IYRqWDawbTTe4IOVjZuKVr0yVNBe1XLGC6PoDxsTMfo,3017
+py3DCal/model_training/datasets/GelSightMini_dataset.py,sha256=H8Fr_4f3HDHLLl6KshRfqt0FP8-3d4n9XRK0xfPcH0k,3070
+py3DCal/model_training/datasets/__init__.py,sha256=vqrB177ZXrBmqDnL472EWleJS6Y-BxYEy2Ao9hWWDHc,137
+py3DCal/model_training/datasets/split_dataset.py,sha256=AzNJlTgcXGa9AdHJnVJYNEyv__OuNHZAMB76Haqc-io,1351
+py3DCal/model_training/datasets/tactile_sensor_dataset.py,sha256=LuSQYNHY5vkOihlJpG1PIs9EtxYtVW5x3ac6wgRTXLQ,3314
+py3DCal/model_training/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/model_training/lib/add_coordinate_embeddings.py,sha256=8wit43RIx28IKEB82SnH_Of09FAmiWM3jgOeXpamM1I,1198
+py3DCal/model_training/lib/annotate_dataset.py,sha256=mPGLROo7h98w9AOdMZJzqAPa4ZGMJnciJ4ovLlrM7j0,16016
+py3DCal/model_training/lib/depthmaps.py,sha256=eW9rs4Ch64SwgwoTc1riauolX-IDxrYXmOJ0qQqQAgE,3183
+py3DCal/model_training/lib/fast_poisson.py,sha256=wJ5MTkSCxkFU3wUx-zomvIYPcAyEpPZj-LX7JQOx8JE,2252
+py3DCal/model_training/lib/get_gradient_map.py,sha256=IbCigrK_-6ZkeOSaHZAIhMu2pFmkSpWAaz1EjUtenCM,1438
+py3DCal/model_training/lib/precompute_gradients.py,sha256=zc1uvishZP7PjBWYF2VSrIMCtEkLrTPtLktOTpCh9P8,1860
+py3DCal/model_training/lib/train_model.py,sha256=fxFIfKWp3WA1Aa2IEczKBJCivVyVovj7IW2HqNw5IlE,4016
+py3DCal/model_training/lib/validate_parameters.py,sha256=My8cbGPSWsVpMB54jydbLYgfefWPMLGvr4oiPyLImb0,3052
+py3DCal/model_training/models/__init__.py,sha256=FTMTEyUglpRIFJ4hi3Z7y1KdScGDVVg_OxYXip4b8wg,42
+py3DCal/model_training/models/touchnet.py,sha256=JIfhwXX0uIk6UcN2tmCLoiH9il9U2IByjbjYIjQEIqc,8079
+py3DCal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py3DCal/utils/utils.py,sha256=hgTyWZuBXfo9lxLnOLd0445Aw2-uARtKGXuBhZmz-Z0,995
+py3dcal-1.0.5.dist-info/LICENSE,sha256=D95ljbgz6PW9niwHP26EWFN77QBvepSCsMKGp0mRVFM,1066
+py3dcal-1.0.5.dist-info/METADATA,sha256=kOwKuH8L9Lm7BrI04dQaNdO2amIs6YM1t-IasW59_Uw,882
+py3dcal-1.0.5.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+py3dcal-1.0.5.dist-info/entry_points.txt,sha256=_N1ruxvLEyZmSAaPsCx8kEzbYSJ5bHG5S8bvpua_X5E,59
+py3dcal-1.0.5.dist-info/top_level.txt,sha256=NbatjyXjN_E6UMifZpkx-ohahGQH_ZFvqovwmvU7FMA,8
+py3dcal-1.0.5.dist-info/RECORD,,

py3dcal-1.0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py3dcal-1.0.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+list-com-ports = py3DCal:list_com_ports
+

py3dcal-1.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+py3DCal