DeepSDFStruct 1.7.2__py3-none-any.whl

DeepSDFStruct/trained_models/test_experiment_homogenization/specs.json

@@ -0,0 +1,83 @@
+{
+  "Description": "This experiment is intented for testing purposes only.",
+  "NetworkArch": "deep_sdf_decoder",
+  "TrainSplit": "splits/splines_v2_small.json",
+  "TestSplit": "splits/splines_v2_small.json",
+  "ReconstructionSplit": "",
+  "NetworkSpecs": {
+    "dims": [
+      32,
+      32,
+      32,
+      32,
+      32,
+      32
+    ],
+    "dropout": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7
+    ],
+    "dropout_prob": 0.2,
+    "norm_layers": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7
+    ],
+    "latent_in": [
+      2
+    ],
+    "xyz_in_all": false,
+    "use_tanh": false,
+    "latent_dropout": false,
+    "weight_norm": true,
+    "geom_dimension": 3,
+    "homogen_predictor_dims": [
+      64,
+      64,
+      64,
+      64,
+      9
+    ]
+  },
+  "CodeLength": 10,
+  "NumEpochs": 5,
+  "LogFrequency": 5,
+  "SnapshotFrequency": 100,
+  "AdditionalSnapshots": [
+    1,
+    5
+  ],
+  "LearningRateSchedule": [
+    {
+      "Type": "Step",
+      "Initial": 0.0005,
+      "Interval": 500,
+      "Factor": 0.5
+    },
+    {
+      "Type": "Step",
+      "Initial": 0.001,
+      "Interval": 500,
+      "Factor": 0.5
+    }
+  ],
+  "SamplesPerScene": 4,
+  "ScenesPerBatch": 2,
+  "DataLoaderThreads": 1,
+  "ClampingDistance": 0.1,
+  "CodeRegularization": true,
+  "AddHomogenization": true,
+  "CodeRegularizationLambda": 1e-4,
+  "CodeBound": 1.0
+}

DeepSDFStruct/trained_models/test_experiment_homogenization/training_summary.json

@@ -0,0 +1,10 @@
+{
+    "loss": 9775.975620117188,
+    "num_epochs": 5,
+    "timestamp": "2026-05-21 17:39:48",
+    "host_name": "neptune",
+    "device": "cpu",
+    "training_duration": "0:00:28",
+    "data_dir": "/storage/mkofler/dissertation/data/",
+    "version": "1.7.1.dev40+g989384bd4.d20260330"
+}

DeepSDFStruct/utils.py

@@ -0,0 +1,96 @@
+"""
+Utility Functions
+=================
+
+This module provides general utility functions used throughout DeepSDFStruct,
+including logging configuration and color scheme definitions.
+
+Functions
+---------
+configure_logging
+    Set up logging for the DeepSDFStruct package with customizable
+    output format and destinations.
+
+Constants
+---------
+_TUWIEN_COLOR_SCHEME
+    TU Wien corporate color scheme for consistent visualization styling.
+"""
+
+import logging
+import DeepSDFStruct
+
+
+def configure_logging(level=logging.INFO, logfile=None):
+    """Configure logging for the DeepSDFStruct package.
+
+    Sets up a logger with a standard format and optional file output.
+    This is called automatically when DeepSDFStruct is imported.
+
+    Parameters
+    ----------
+    level : int, default logging.INFO
+        Logging level (e.g., logging.DEBUG, logging.INFO, logging.WARNING).
+    logfile : str, optional
+        Path to log file. If provided, logs are written to both console
+        and file. If None, logs only to console.
+
+    Examples
+    --------
+    >>> from DeepSDFStruct.utils import configure_logging
+    >>> import logging
+    >>>
+    >>> # Set debug level and log to file
+    >>> configure_logging(level=logging.DEBUG, logfile='deepsdf.log')
+
+    Notes
+    -----
+    The log format is: "HH:MM:SS message"
+    All log messages are prefixed with a timestamp for easy debugging.
+    """
+    logger = logging.getLogger(DeepSDFStruct.__name__)
+    logger.setLevel(level)
+    formatter = logging.Formatter("%(asctime)s %(message)s", datefmt="%H:%M:%S")
+    if not logger.hasHandlers():
+        logger_handler = logging.StreamHandler()
+        logger_handler.setFormatter(formatter)
+        logger.addHandler(logger_handler)
+
+    if logfile is not None:
+        file_logger_handler = logging.FileHandler(logfile)
+        file_logger_handler.setFormatter(formatter)
+        logger.addHandler(file_logger_handler)
+
+
+#: TU Wien corporate color scheme
+#:
+#: Dictionary mapping color names to RGB tuples (0-255 range).
+#: Includes primary colors (blue, black, white) and secondary colors
+#: (green, magenta, yellow, grey) with multiple shades of each.
+#:
+#: Useful for creating plots and visualizations with consistent branding.
+_TUWIEN_COLOR_SCHEME = {
+    "blue": (0, 102, 153),
+    "black": (0, 0, 0),
+    "white": (255, 255, 255),
+    "blue_1": (84, 133, 171),
+    "blue_2": (114, 173, 213),
+    "blue_3": (166, 213, 236),
+    "blue_4": (223, 242, 253),
+    "grey": (100, 99, 99),
+    "grey_1": (157, 157, 156),
+    "grey_2": (208, 208, 208),
+    "grey_3": (237, 237, 237),
+    "green": (0, 126, 113),
+    "green_1": (106, 170, 165),
+    "green_2": (162, 198, 194),
+    "green_3": (233, 241, 240),
+    "magenta": (186, 70, 130),
+    "magenta_1": (205, 129, 168),
+    "magenta_2": (223, 175, 202),
+    "magenta_3": (245, 229, 239),
+    "yellow": (225, 137, 34),
+    "yellow_1": (238, 180, 115),
+    "yellow_2": (245, 208, 168),
+    "yellow_3": (153, 239, 225),
+}

DeepSDFStruct/visualization/latent_viewer.py

@@ -0,0 +1,211 @@
+import torch
+import streamlit as st
+import os
+import io
+import meshio
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.manifold import TSNE
+from sklearn.cluster import KMeans
+from streamlit_stl import stl_from_text
+
+import random
+
+
+from DeepSDFStruct.pretrained_models import get_model, PRETRAINED_MODELS_DIR
+from DeepSDFStruct.SDF import SDFfromDeepSDF
+from DeepSDFStruct.mesh import create_3D_mesh
+
+from mlflow import MlflowClient
+from mlflow.entities import Experiment
+
+client = MlflowClient(tracking_uri="sqlite:///mlruns.db")
+
+all_exp = client.search_experiments()
+experiments = {exp.name: exp for exp in all_exp}
+
+
+def get_runs_from_experiment(experiment: Experiment):
+    runs = client.search_runs(experiment_ids=[experiment.experiment_id])
+    return runs
+
+
+st.set_page_config(page_title="Cluster Shape Explorer", layout="wide")
+
+# -------------------------------------------------------------------------
+# Sidebar: Model Selector
+# -------------------------------------------------------------------------
+
+available_dirs = ["Pretrained Models"] + list(experiments.keys())
+
+model_dir = st.sidebar.selectbox("Select experiment", available_dirs, 0)
+
+available_models = {}
+
+if model_dir == "Pretrained Models":
+    # Local folder models
+    for name in os.listdir(PRETRAINED_MODELS_DIR):
+        path = os.path.join(PRETRAINED_MODELS_DIR, name)
+        if os.path.isdir(path):
+            available_models[name] = path
+
+else:
+    # MLflow experiment (runs)
+    ml_exp = experiments[model_dir]
+    runs = client.search_runs(experiment_ids=[ml_exp.experiment_id])
+
+    for run in runs:
+        run_name = run.data.tags.get("mlflow.runName", run.info.run_id)
+        available_models[run_name] = run.info.artifact_uri
+model_name = st.sidebar.selectbox("Select a model", available_models)
+
+local_path = available_models[model_name]
+epoch_dir = os.path.join(local_path, "ModelParameters")
+
+available_epochs = [
+    file[:-4]
+    for file in os.listdir(epoch_dir)
+    if file.endswith(".pth") or file.endswith(".pt")
+]
+
+if "cluster_index" not in st.session_state.keys():
+    st.session_state.cluster_index = 0
+
+epoch = st.sidebar.selectbox(
+    "Select epoch", available_epochs, len(available_epochs) - 1
+)
+
+
+# -------------------------------------------------------------------------
+# Load model once
+# -------------------------------------------------------------------------
+@st.cache_resource
+def load_model(model_name: str, epoch: str):
+    """
+    model_dir: 'deepsdf_experiments' or mlflow experiment name
+    model_name: run-name or folder-name
+    epoch: checkpoint epoch
+    """
+    model_path = available_models[model_name]
+    model = get_model(model_path, checkpoint=epoch)
+    sdf = SDFfromDeepSDF(model)
+    return model, sdf
+
+
+model, sdf = load_model(model_name, epoch)
+latent_vectors = model._trained_latent_vectors.detach().cpu().numpy()
+
+
+# -------------------------------------------------------------------------
+# Cluster computation (TSNE + KMeans)
+# -------------------------------------------------------------------------
+@st.cache_resource
+def compute_clusters(latent_vectors, n_clusters=10, perplexity=3):
+    X_embedded = TSNE(
+        n_components=2, learning_rate="auto", init="random", perplexity=perplexity
+    ).fit_transform(latent_vectors)
+    kmeans = KMeans(n_clusters=n_clusters, random_state=0).fit(X_embedded)
+    return kmeans.labels_, X_embedded
+
+
+n_clusters = st.sidebar.slider(
+    "Number of clusters", min_value=2, max_value=20, value=10
+)
+labels, X_embedded = compute_clusters(latent_vectors, n_clusters=n_clusters)
+
+# -------------------------------------------------------------------------
+# Sidebar: Cluster selector
+# -------------------------------------------------------------------------
+
+# -------------------------------------------------------------------------
+# Navigation buttons (main window)
+# -------------------------------------------------------------------------
+col1, col2, col3 = st.columns([1, 2, 1])
+with col1:
+    if st.button("Prev"):
+        st.session_state.cluster_index = max(0, st.session_state.cluster_index - 1)
+with col3:
+    if st.button("Next"):
+        st.session_state.cluster_index = min(
+            n_clusters - 1, st.session_state.cluster_index + 1
+        )
+with col2:
+    st.text(f"Cluster {st.session_state.cluster_index+1}/{n_clusters}")
+
+indices_in_cluster = np.argwhere(labels == st.session_state.cluster_index).flatten()
+
+
+# -------------------------------------------------------------------------
+# STL generation function
+# -------------------------------------------------------------------------
+def generate_stl(lat_vec, color_rgb):
+    lat_vec_torch = torch.tensor(lat_vec, dtype=torch.float32, device=model.device)
+    sdf.set_latent_vec(lat_vec_torch)
+    with torch.inference_mode():
+        surf_mesh, _ = create_3D_mesh(
+            sdf, 100, differentiate=False, mesh_type="surface", device=model.device
+        )
+    surf_mesh_gus = surf_mesh.to_gus()
+    surf_mesh_gus.show_options["c"] = color_rgb  # apply color
+    mesh = meshio.Mesh(
+        points=surf_mesh_gus.vertices, cells=[("triangle", surf_mesh_gus.faces)]
+    )
+    output = io.StringIO()
+    meshio.write(output, mesh, file_format="stl", binary=False)
+    return output
+
+
+# -------------------------------------------------------------------------
+# Display selected geometry
+# -------------------------------------------------------------------------
+def rgb_to_hex(rgb):
+    """Convert an RGB list [R,G,B] to hex string."""
+    return "#{:02x}{:02x}{:02x}".format(*rgb)
+
+
+indices = [random.choice(list(indices_in_cluster)) for i in range(4)]
+n_select = min(5, len(indices_in_cluster))
+
+indices = random.sample(list(indices_in_cluster), n_select)
+columns_row1 = st.columns(3)
+columns_row2 = st.columns(3)
+
+fig, ax = plt.subplots(figsize=(6, 6))
+scatter = ax.scatter(
+    X_embedded[:, 0], X_embedded[:, 1], c=labels, cmap="tab10", alpha=0.6
+)
+
+# Map cluster id to color
+cmap = plt.get_cmap("tab10")
+cluster_color = [int(255 * c) for c in cmap(st.session_state.cluster_index)[:3]]
+
+ax.scatter(
+    X_embedded[indices, 0],
+    X_embedded[indices, 1],
+    edgecolors="k",
+    facecolor=cmap(st.session_state.cluster_index),
+    s=120,
+    linewidths=2,
+)
+plt.colorbar(scatter, ax=ax, label="Cluster")
+columns_row1[0].pyplot(fig)
+
+for selected_idx, column in zip(indices, columns_row1[1:] + columns_row2):
+    lat_vec = latent_vectors[selected_idx]
+
+    # st.subheader(
+    #     f"Latent vector index: {selected_idx} (Cluster {st.session_state.cluster_index})"
+    # )
+    stl_io = generate_stl(lat_vec, cluster_color)
+    with column:
+        stl_from_text(
+            text=stl_io.getvalue(),
+            color=rgb_to_hex(cluster_color),
+            material="material",
+            auto_rotate=True,
+            opacity=1,
+            shininess=10,
+            cam_v_angle=60,
+            cam_h_angle=-90,
+            height=500,
+        )

DeepSDFStruct/visualization/latent_viewer_cli.py

@@ -0,0 +1,8 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+def main():
+    script_path = Path(__file__).parent / "latent_viewer.py"
+    subprocess.run([sys.executable, "-m", "streamlit", "run", str(script_path)])