autoforge 1.3.0__tar.gz → 1.3.1__tar.gz

{autoforge-1.3.0 → autoforge-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.3.0
+Version: 1.3.1
 Summary: AutoForge is a Python tool for generating 3D printed layered models from an input image.
 Author-email: Hendric Voss <hvoss@techfak.uni-bielefeld.de>
 License: CC BY-NC-SA 4.0
@@ -30,6 +30,10 @@ AutoForge is a Python tool for generating 3D printed layered models from an inpu
 We recently switched from JAX to PyTorch, to allow for a more streamlined development process. \
 This can have some unforeseen consequences, so please report any bugs you find. 
 
+This release should give better gpu support for more users, especially on windows. \
+If you have problems running the code on your gpu, please refer to the [Pytorch Homepage](https://pytorch.org/) for help. \
+Both CUDA and ROCm are supported, but you need to install the correct version of pytorch for your system.
+
 ## Example
 All examples use only the 13 BambuLab Basic filaments, currently available in Hueforge.
 <div style="display: flex; justify-content: center; gap: 20px;">
@@ -95,8 +99,6 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--csv_file`: **(Required)** Path to the CSV file containing material data. The CSV should include columns for the brand, name, color (hex code), and TD values.
 - `--output_folder`: Folder where output files will be saved. (default: `./outputs`).
 - `--iterations`: Number of optimization iterations (default: 5000).
-- `--best_loss_iterations`: Percentage of optimization iterations after which we start to record the best loss (default: 4000). \
-  **Note:** We currently do this as we increase a penalty loss for color and color swaps as the time goes on. Without this the penalties would have no impact.
 - `--learning_rate`: Learning rate for the optimizer (default: 1e-2).
 - `--layer_height`: Layer thickness in millimeters (default: 0.04).
 - `--max_layers`: Maximum number of layers (default: 75). \

{autoforge-1.3.0 → autoforge-1.3.1}/README.md

@@ -10,6 +10,10 @@ AutoForge is a Python tool for generating 3D printed layered models from an inpu
 We recently switched from JAX to PyTorch, to allow for a more streamlined development process. \
 This can have some unforeseen consequences, so please report any bugs you find. 
 
+This release should give better gpu support for more users, especially on windows. \
+If you have problems running the code on your gpu, please refer to the [Pytorch Homepage](https://pytorch.org/) for help. \
+Both CUDA and ROCm are supported, but you need to install the correct version of pytorch for your system.
+
 ## Example
 All examples use only the 13 BambuLab Basic filaments, currently available in Hueforge.
 <div style="display: flex; justify-content: center; gap: 20px;">
@@ -75,8 +79,6 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--csv_file`: **(Required)** Path to the CSV file containing material data. The CSV should include columns for the brand, name, color (hex code), and TD values.
 - `--output_folder`: Folder where output files will be saved. (default: `./outputs`).
 - `--iterations`: Number of optimization iterations (default: 5000).
-- `--best_loss_iterations`: Percentage of optimization iterations after which we start to record the best loss (default: 4000). \
-  **Note:** We currently do this as we increase a penalty loss for color and color swaps as the time goes on. Without this the penalties would have no impact.
 - `--learning_rate`: Learning rate for the optimizer (default: 1e-2).
 - `--layer_height`: Layer thickness in millimeters (default: 0.04).
 - `--max_layers`: Maximum number of layers (default: 75). \

{autoforge-1.3.0 → autoforge-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AutoForge"
-version="1.3.0"
+version="1.3.1"
 description = "AutoForge is a Python tool for generating 3D printed layered models from an input image."
 authors = [{ name = "Hendric Voss", email = "hvoss@techfak.uni-bielefeld.de" }]
 readme = "README.md"

{autoforge-1.3.0 → autoforge-1.3.1}/src/AutoForge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.3.0
+Version: 1.3.1
 Summary: AutoForge is a Python tool for generating 3D printed layered models from an input image.
 Author-email: Hendric Voss <hvoss@techfak.uni-bielefeld.de>
 License: CC BY-NC-SA 4.0
@@ -30,6 +30,10 @@ AutoForge is a Python tool for generating 3D printed layered models from an inpu
 We recently switched from JAX to PyTorch, to allow for a more streamlined development process. \
 This can have some unforeseen consequences, so please report any bugs you find. 
 
+This release should give better gpu support for more users, especially on windows. \
+If you have problems running the code on your gpu, please refer to the [Pytorch Homepage](https://pytorch.org/) for help. \
+Both CUDA and ROCm are supported, but you need to install the correct version of pytorch for your system.
+
 ## Example
 All examples use only the 13 BambuLab Basic filaments, currently available in Hueforge.
 <div style="display: flex; justify-content: center; gap: 20px;">
@@ -95,8 +99,6 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--csv_file`: **(Required)** Path to the CSV file containing material data. The CSV should include columns for the brand, name, color (hex code), and TD values.
 - `--output_folder`: Folder where output files will be saved. (default: `./outputs`).
 - `--iterations`: Number of optimization iterations (default: 5000).
-- `--best_loss_iterations`: Percentage of optimization iterations after which we start to record the best loss (default: 4000). \
-  **Note:** We currently do this as we increase a penalty loss for color and color swaps as the time goes on. Without this the penalties would have no impact.
 - `--learning_rate`: Learning rate for the optimizer (default: 1e-2).
 - `--layer_height`: Layer thickness in millimeters (default: 0.04).
 - `--max_layers`: Maximum number of layers (default: 75). \

{autoforge-1.3.0 → autoforge-1.3.1}/src/autoforge/Helper/OptimizerHelper.py

@@ -1,4 +1,4 @@
-from itertools import permutations
+import random
 
 import numpy as np
 import torch
@@ -7,7 +7,6 @@ from skimage.color import rgb2lab
 from sklearn.cluster import KMeans
 from sklearn.exceptions import ConvergenceWarning
 from sklearn.utils._testing import ignore_warnings
-from tqdm import tqdm
 from transformers import pipeline
 from PIL import Image
 from sklearn.metrics import silhouette_score
@@ -487,6 +486,104 @@ def init_height_map_depth_color_adjusted(
     return pixel_height_logits
 
 
+def tsp_simulated_annealing(
+    band_reps,
+    start_band,
+    end_band,
+    initial_order=None,
+    initial_temp=1000,
+    cooling_rate=0.995,
+    num_iter=10000,
+):
+    """
+    Solve the band ordering problem using simulated annealing.
+
+    Args:
+        band_reps (list or np.ndarray): List of Lab color representations.
+        start_band (int): Index for the darkest band.
+        end_band (int): Index for the brightest band.
+        initial_order (list, optional): Initial ordering of band indices.
+        initial_temp (float): Starting temperature.
+        cooling_rate (float): Factor to cool the temperature.
+        num_iter (int): Maximum number of iterations.
+
+    Returns:
+        list: An ordering of band indices from start_band to end_band.
+    """
+    if initial_order is None:
+        # Use a simple ordering: start, middle bands as given, then end.
+        middle_indices = [
+            i for i in range(len(band_reps)) if i not in (start_band, end_band)
+        ]
+        order = [start_band] + middle_indices + [end_band]
+    else:
+        order = initial_order.copy()
+
+    def total_distance(order):
+        return sum(
+            np.linalg.norm(band_reps[order[i]] - band_reps[order[i + 1]])
+            for i in range(len(order) - 1)
+        )
+
+    current_distance = total_distance(order)
+    best_order = order.copy()
+    best_distance = current_distance
+    temp = initial_temp
+
+    for _ in range(num_iter):
+        # Randomly swap two indices in the middle of the order
+        new_order = order.copy()
+        idx1, idx2 = random.sample(range(1, len(order) - 1), 2)
+        new_order[idx1], new_order[idx2] = new_order[idx2], new_order[idx1]
+
+        new_distance = total_distance(new_order)
+        delta = new_distance - current_distance
+
+        # Accept the new order if it improves or with a probability to escape local minima
+        if delta < 0 or np.exp(-delta / temp) > random.random():
+            order = new_order.copy()
+            current_distance = new_distance
+            if current_distance < best_distance:
+                best_order = order.copy()
+                best_distance = current_distance
+
+        temp *= cooling_rate
+        if temp < 1e-6:
+            break
+    return best_order
+
+
+def choose_optimal_num_bands(centroids, min_bands=2, max_bands=15, random_seed=None):
+    """
+    Determine the optimal number of clusters (bands) for the centroids
+    by maximizing the silhouette score.
+
+    Args:
+        centroids (np.ndarray): Array of centroid colors (e.g., shape (n_clusters, 3)).
+        min_bands (int): Minimum number of clusters to try.
+        max_bands (int): Maximum number of clusters to try.
+        random_seed (int, optional): Random seed for reproducibility.
+
+    Returns:
+        int: Optimal number of bands.
+    """
+    best_num = min_bands
+    best_score = -1
+
+    for num in range(min_bands, max_bands + 1):
+        kmeans = KMeans(n_clusters=num, random_state=random_seed).fit(centroids)
+        labels = kmeans.labels_
+        # If there's only one unique label, skip to avoid errors.
+        if len(np.unique(labels)) < 2:
+            continue
+        score = silhouette_score(centroids, labels)
+        if score > best_score:
+            best_score = score
+            best_num = num
+
+    return best_num
+
+
 def init_height_map(target, max_layers, h, eps=1e-6, random_seed=None):
     """
     Initialize pixel height logits based on the luminance of the target image.
@@ -512,7 +609,9 @@ def init_height_map(target, max_layers, h, eps=1e-6, random_seed=None):
         return 0.299 * col[0] + 0.587 * col[1] + 0.114 * col[2]
 
     # --- Step 2: Second clustering of centroids into bands ---
-    num_bands = 9
+    num_bands = choose_optimal_num_bands(
+        centroids, min_bands=5, max_bands=max_layers // 2, random_seed=random_seed
+    )
     band_kmeans = KMeans(n_clusters=num_bands, random_state=random_seed).fit(centroids)
     band_labels = band_kmeans.labels_
 
@@ -544,39 +643,7 @@ def init_height_map(target, max_layers, h, eps=1e-6, random_seed=None):
     L_values = [lab[0] for lab in band_reps]
     start_band = np.argmin(L_values)  # darkest band index
     end_band = np.argmax(L_values)  # brightest band index
-
-    # --- Step 5: Find the best ordering for the middle bands ---
-    # We want to order the bands so that the total perceptual difference (Euclidean distance in Lab)
-    # between consecutive bands is minimized, while forcing the darkest band first and brightest band last.
-    all_indices = list(range(len(bands)))
-    middle_indices = [i for i in all_indices if i not in (start_band, end_band)]
-
-    min_total_distance = np.inf
-    best_order = None
-    total = len(middle_indices) * len(middle_indices)
-    # Try all permutations of the middle bands
-    ie = 0
-    tbar = tqdm(
-        permutations(middle_indices),
-        total=total,
-        desc="Finding best ordering for color bands:",
-    )
-    for perm in tbar:
-        candidate = [start_band] + list(perm) + [end_band]
-        total_distance = 0
-        for i in range(len(candidate) - 1):
-            total_distance += np.linalg.norm(
-                band_reps[candidate[i]] - band_reps[candidate[i + 1]]
-            )
-        if total_distance < min_total_distance:
-            min_total_distance = total_distance
-            best_order = candidate
-            tbar.set_description(
-                f"Finding best ordering for color bands: Total distance = {min_total_distance:.2f}"
-            )
-        ie += 1
-        if ie > 500000:
-            break
+    best_order = tsp_simulated_annealing(band_reps, start_band, end_band)
 
     new_order = []
     for band_idx in best_order:

{autoforge-1.3.0 → autoforge-1.3.1}/src/autoforge/Helper/OutputHelper.py

@@ -188,85 +188,98 @@ def generate_project_file(
 
 def generate_stl(height_map, filename, background_height, scale=1.0):
     """
-    Generate a binary STL file from a height map.
+    Generate a binary STL file from a height map with shared boundary vertices
+    to fix non-manifold edge warnings.
 
     Args:
         height_map (np.ndarray): 2D array representing the height map.
         filename (str): The name of the output STL file.
         background_height (float): The height of the background in the STL model.
-        scale (float, optional): Scale factor for the x and y dimensions. Defaults to 1.0.
+        scale (float, optional): Scale factor for the x dimension (and optionally y). Defaults to 1.0.
     """
     H, W = height_map.shape
-    vertices = np.zeros((H, W, 3), dtype=np.float32)
+
+    # Create the top vertices grid.
+    # Note: y is computed as H-1-i. (Apply scale to y if desired.)
+    top_vertices = np.zeros((H, W, 3), dtype=np.float32)
     for i in range(H):
         for j in range(W):
-            # Original coordinates: x = j*scale, y = (H - 1 - i), z = height + background
-            vertices[i, j, 0] = j * scale
-            vertices[i, j, 1] = H - 1 - i  # (Consider applying scale if needed)
-            vertices[i, j, 2] = height_map[i, j] + background_height
+            top_vertices[i, j, 0] = j * scale
+            top_vertices[i, j, 1] = H - 1 - i  # or (H - 1 - i) * scale if you want uniform scaling
+            top_vertices[i, j, 2] = height_map[i, j] + background_height
+
+    # Create the bottom vertices for the boundary by copying the x and y coordinates,
+    # but setting z to 0. Using these ensures that adjacent triangles share the same vertices.
+    bottom_vertices = top_vertices.copy()
+    bottom_vertices[:, :, 2] = 0
 
     triangles = []
 
     def add_triangle(v1, v2, v3):
-        """
-        Add a triangle to the list of triangles.
-
-        Args:
-            v1 (np.ndarray): First vertex of the triangle.
-            v2 (np.ndarray): Second vertex of the triangle.
-            v3 (np.ndarray): Third vertex of the triangle.
-        """
+        """Add a triangle defined by vertices v1, v2, and v3."""
         triangles.append((v1, v2, v3))
 
+    # --- Top Surface ---
     for i in range(H - 1):
         for j in range(W - 1):
-            v0 = vertices[i, j]
-            v1 = vertices[i, j + 1]
-            v2 = vertices[i + 1, j + 1]
-            v3 = vertices[i + 1, j]
-            # Reversed order so normals face upward
+            v0 = top_vertices[i, j]
+            v1 = top_vertices[i, j + 1]
+            v2 = top_vertices[i + 1, j + 1]
+            v3 = top_vertices[i + 1, j]
+            # Using reversed order so that normals face upward.
             add_triangle(v2, v1, v0)
             add_triangle(v3, v2, v0)
 
+    # --- Side Walls ---
+    # Top edge (i = 0)
     for j in range(W - 1):
-        v0 = vertices[0, j]
-        v1 = vertices[0, j + 1]
-        v0b = np.array([v0[0], v0[1], 0], dtype=np.float32)
-        v1b = np.array([v1[0], v1[1], 0], dtype=np.float32)
-        add_triangle(v0, v1, v1b)
-        add_triangle(v0, v1b, v0b)
+        vt0 = top_vertices[0, j]
+        vt1 = top_vertices[0, j + 1]
+        vb0 = bottom_vertices[0, j]
+        vb1 = bottom_vertices[0, j + 1]
+        add_triangle(vt0, vt1, vb1)
+        add_triangle(vt0, vb1, vb0)
+
+    # Bottom edge (i = H - 1)
     for j in range(W - 1):
-        v0 = vertices[H - 1, j]
-        v1 = vertices[H - 1, j + 1]
-        v0b = np.array([v0[0], v0[1], 0], dtype=np.float32)
-        v1b = np.array([v1[0], v1[1], 0], dtype=np.float32)
-        add_triangle(v1, v0, v1b)
-        add_triangle(v0, v0b, v1b)
+        vt0 = top_vertices[H - 1, j]
+        vt1 = top_vertices[H - 1, j + 1]
+        vb0 = bottom_vertices[H - 1, j]
+        vb1 = bottom_vertices[H - 1, j + 1]
+        add_triangle(vt1, vt0, vb0)
+        add_triangle(vt1, vb0, vb1)
+
+    # Left edge (j = 0)
     for i in range(H - 1):
-        v0 = vertices[i, 0]
-        v1 = vertices[i + 1, 0]
-        v0b = np.array([v0[0], v0[1], 0], dtype=np.float32)
-        v1b = np.array([v1[0], v1[1], 0], dtype=np.float32)
-        add_triangle(v1, v0, v1b)
-        add_triangle(v0, v0b, v1b)
+        vt0 = top_vertices[i, 0]
+        vt1 = top_vertices[i + 1, 0]
+        vb0 = bottom_vertices[i, 0]
+        vb1 = bottom_vertices[i + 1, 0]
+        add_triangle(vt1, vt0, vb0)
+        add_triangle(vt1, vb0, vb1)
+
+    # Right edge (j = W - 1)
     for i in range(H - 1):
-        v0 = vertices[i, W - 1]
-        v1 = vertices[i + 1, W - 1]
-        v0b = np.array([v0[0], v0[1], 0], dtype=np.float32)
-        v1b = np.array([v1[0], v1[1], 0], dtype=np.float32)
-        add_triangle(v0, v1, v1b)
-        add_triangle(v0, v1b, v0b)
-
-    v0 = np.array([0, 0, 0], dtype=np.float32)
-    v1 = np.array([(W - 1) * scale, 0, 0], dtype=np.float32)
-    v2 = np.array([(W - 1) * scale, (H - 1) * scale, 0], dtype=np.float32)
-    v3 = np.array([0, (H - 1) * scale, 0], dtype=np.float32)
-    add_triangle(v2, v1, v0)
-    add_triangle(v3, v2, v0)
+        vt0 = top_vertices[i, W - 1]
+        vt1 = top_vertices[i + 1, W - 1]
+        vb0 = bottom_vertices[i, W - 1]
+        vb1 = bottom_vertices[i + 1, W - 1]
+        add_triangle(vt0, vt1, vb1)
+        add_triangle(vt0, vb1, vb0)
+
+    # --- Bottom Face ---
+    # Use the four corner vertices from the bottom_vertices grid.
+    b_top_left = bottom_vertices[0, 0]
+    b_top_right = bottom_vertices[0, W - 1]
+    b_bottom_right = bottom_vertices[H - 1, W - 1]
+    b_bottom_left = bottom_vertices[H - 1, 0]
+    # Triangulate the bottom face (ensure the normal faces downward).
+    add_triangle(b_bottom_right, b_top_right, b_top_left)
+    add_triangle(b_bottom_left, b_bottom_right, b_top_left)
 
     num_triangles = len(triangles)
 
-    # Write the binary STL file.
+    # --- Write Binary STL ---
     with open(filename, "wb") as f:
         header_str = "Binary STL generated from heightmap"
         header = header_str.encode("utf-8")

{autoforge-1.3.0 → autoforge-1.3.1}/src/autoforge/Loss/LossFunctions.py

@@ -15,6 +15,7 @@ def loss_fn(
     material_TDs: torch.Tensor,
     background: torch.Tensor,
     perception_loss_module: torch.nn.Module,
+    add_penalty_loss: bool = True,
 ) -> torch.Tensor:
     """
     Full forward pass for continuous assignment:
@@ -39,6 +40,7 @@ def loss_fn(
         perception_loss_module=perception_loss_module,
         tau_global=tau_global,
         num_materials=material_colors.shape[0],
+        add_penalty_loss=add_penalty_loss,
     )
 
 

{autoforge-1.3.0 → autoforge-1.3.1}/src/autoforge/Modules/Optimizer.py

@@ -105,7 +105,7 @@ class FilamentOptimizer:
                 "Please dont panic if the best discretize composite is blank for a while."
             )
             print(
-                "We only record the best discrete function at the end to allow for penalty loss to function correctly."
+                "We only record the best discrete function after some time to allow for the penalty loss to function correctly."
             )
             plt.ion()
             self.fig, self.ax = plt.subplots(1, 4, figsize=(14, 6))
@@ -173,6 +173,7 @@ class FilamentOptimizer:
             material_TDs=self.material_TDs,
             background=self.background,
             perception_loss_module=self.perception_loss_module,
+            add_penalty_loss=False,
         )
         loss.backward()
         self.optimizer.step()
@@ -370,7 +371,7 @@ class FilamentOptimizer:
         and update the best solution if it improves.
         """
 
-        for i in range(3):
+        for i in range(1):
             # draw random integer seed
             seed = np.random.randint(0, 1000000)
 

{autoforge-1.3.0 → autoforge-1.3.1}/src/autoforge/auto_forge.py

@@ -44,12 +44,6 @@ def main():
     parser.add_argument(
         "--iterations", type=int, default=5000, help="Number of optimization iterations"
     )
-    parser.add_argument(
-        "--best_loss_iterations",
-        type=float,
-        default=0.9,
-        help="Percentage of optimization iterations after which we start to record the best loss",
-    )
 
     parser.add_argument(
         "--learning_rate",
@@ -250,9 +244,7 @@ def main():
     print("Starting optimization...")
     tbar = tqdm(range(args.iterations))
     for i in tbar:
-        loss_val = optimizer.step(
-            record_best=i > args.best_loss_iterations * args.iterations and i % 5 == 0
-        )
+        loss_val = optimizer.step(record_best=i % 3 == 0)
         optimizer.visualize(interval=25)
         if (i + 1) % 100 == 0:
             tbar.set_description(f"Iteration {i + 1}, Loss = {loss_val:.4f}")
@@ -260,6 +252,15 @@ def main():
     # After we finish, we can get the final discrete solution at solver resolution
     disc_global, disc_height_image = optimizer.get_discretized_solution(best=True)
 
+    # Do a quick search for a better rng seed
+    new_rng_seed, new_loss = optimizer.rng_seed_search(
+        optimizer.best_discrete_loss, 1000
+    )
+    if new_loss < optimizer.best_discrete_loss:
+        optimizer.best_seed = new_rng_seed
+        optimizer.best_discrete_loss = new_loss
+        print(f"New best seed found: {new_rng_seed} with loss: {new_loss}")
+
     # Optionally prune
     if args.perform_pruning:
         disc_global = optimizer.prune(
@@ -270,14 +271,14 @@ def main():
             tau_g=optimizer.best_tau,
         )
 
-    # Do a quick search for a better rng seed
-    new_rng_seed, new_loss = optimizer.rng_seed_search(
-        optimizer.best_discrete_loss, 1000
-    )
-    if new_loss < optimizer.best_discrete_loss:
-        optimizer.best_seed = new_rng_seed
-        optimizer.best_discrete_loss = new_loss
-        print(f"New best seed found: {new_rng_seed} with loss: {new_loss}")
+        # Do a quick search for a better rng seed
+        new_rng_seed, new_loss = optimizer.rng_seed_search(
+            optimizer.best_discrete_loss, 1000
+        )
+        if new_loss < optimizer.best_discrete_loss:
+            optimizer.best_seed = new_rng_seed
+            optimizer.best_discrete_loss = new_loss
+            print(f"New best seed found: {new_rng_seed} with loss: {new_loss}")
     else:
         print(
             f"No better seed found. Best seed loss: {optimizer.best_discrete_loss}. Best searched loss: {new_loss}"