autoforge 1.3.0__tar.gz → 1.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.3.0
+Version: 1.3.2
 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). \
@@ -160,7 +162,6 @@ Although I would love to be it fully color compatible with hueforge, I don't thi
 AutoForge © 2025 by Hendric Voss is licensed under [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/).
 The software is provided as-is and comes with no warranty or guarantee of support.
 
-The 
 
 ## Acknowledgements
 

{autoforge-1.3.0 → autoforge-1.3.2}/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). \
@@ -140,7 +142,6 @@ Although I would love to be it fully color compatible with hueforge, I don't thi
 AutoForge © 2025 by Hendric Voss is licensed under [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/).
 The software is provided as-is and comes with no warranty or guarantee of support.
 
-The 
 
 ## Acknowledgements
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AutoForge"
-version="1.3.0"
+version="1.3.2"
 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.2}/src/AutoForge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.3.0
+Version: 1.3.2
 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). \
@@ -160,7 +162,6 @@ Although I would love to be it fully color compatible with hueforge, I don't thi
 AutoForge © 2025 by Hendric Voss is licensed under [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/).
 The software is provided as-is and comes with no warranty or guarantee of support.
 
-The 
 
 ## Acknowledgements
 

{autoforge-1.3.0 → autoforge-1.3.2}/src/AutoForge.egg-info/SOURCES.txt

@@ -10,7 +10,6 @@ src/autoforge/__init__.py
 src/autoforge/__main__.py
 src/autoforge/auto_forge.py
 src/autoforge/auto_forge_gradio.py
-src/autoforge/color_fit_bayesian.py
 src/autoforge/filamentcolors_library.py
 src/autoforge/old_jax_files.py
 src/autoforge/Helper/FilamentHelper.py
@@ -22,5 +21,7 @@ src/autoforge/Helper/__init__.py
 src/autoforge/Loss/LossFunctions.py
 src/autoforge/Loss/PerceptionLoss.py
 src/autoforge/Loss/__init__.py
+src/autoforge/Misc/__init__.py
+src/autoforge/Misc/color_fit_all.py
 src/autoforge/Modules/Optimizer.py
 src/autoforge/Modules/__init__.py

autoforge-1.3.2/src/autoforge/Helper/ImageHelper.py

@@ -0,0 +1,22 @@
+import cv2
+
+
+def resize_image(img, max_size):
+    h_img, w_img, _ = img.shape
+
+    # Compute the scaling factor based on the larger dimension
+    if w_img >= h_img:
+        scale = max_size / w_img
+    else:
+        scale = max_size / h_img
+
+    # Compute new dimensions and round them
+    new_w = int(round(w_img * scale))
+    new_h = int(round(h_img * scale))
+
+    # Resize the image with an appropriate interpolation method
+    img_out = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_CUBIC)
+    # INTER_CUBIC is actually not a good choice for shrinking images. Except in our case.
+    # As we shrink the image, we lose information and the image becomes blurry with INTER_AREA. This is detrimental for the solver. If you want to try it out be my guest.
+    # INTER_AREA actually destroys a lot of the colors of our solver.
+    return img_out

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

@@ -1,3 +1,4 @@
+import random
 from itertools import permutations
 
 import numpy as np
@@ -111,9 +112,10 @@ def composite_image(
     comp = torch.zeros(H, W, 3, dtype=torch.float32, device=pixel_height.device)
     remaining = torch.ones(H, W, dtype=torch.float32, device=pixel_height.device)
 
-    A = 0.1215
-    k = 61.6970
-    b = 0.4773
+    o = -1.1021105e-02
+    A = 1.0786635e00
+    k = 3.0878708e01
+    b = -5.0812101e00
 
     for i in range(max_layers):
         layer_idx = max_layers - 1 - i
@@ -147,8 +149,11 @@ def composite_image(
         color_i = torch.matmul(p_i, material_colors)
         TD_i = torch.matmul(p_i, material_TDs) * 0.1
         TD_i = torch.clamp(TD_i, 1e-8, 1e8)
-        opac = A * torch.log1p(k * (eff_thick / TD_i)) + b * (eff_thick / TD_i)
+
+        opac = o + (A * torch.log1p(k * (eff_thick / TD_i)) + b * (eff_thick / TD_i))
         opac = torch.clamp(opac, 0.0, 1.0)
+        # Setting opac to 1.0 for the layers where the thickness is less than 2*h to avoid single layer artifacts
+        opac = torch.where(TD_i <= h * 2, torch.tensor(1.0), opac)
 
         comp = comp + ((remaining * opac).unsqueeze(-1) * color_i)
         remaining = remaining * (1 - opac)
@@ -487,6 +492,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 +615,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=10, random_seed=random_seed
+    )
     band_kmeans = KMeans(n_clusters=num_bands, random_state=random_seed).fit(centroids)
     band_labels = band_kmeans.labels_
 
@@ -589,7 +694,7 @@ def init_height_map(target, max_layers, h, eps=1e-6, random_seed=None):
 
     new_labels = new_labels.astype(np.float32) / new_labels.max()
 
-    normalized_lum = np.array(new_labels, dtype=np.float64)
+    normalized_lum = np.array(new_labels, dtype=np.float32)
     # convert out to inverse sigmoid logit function
     pixel_height_logits = np.log((normalized_lum + eps) / (1 - normalized_lum + eps))
 

{autoforge-1.3.0 → autoforge-1.3.2}/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.2}/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,
     )