autoforge 1.4.0__tar.gz → 1.4.2__tar.gz

{autoforge-1.4.0 → autoforge-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.4.0
+Version: 1.4.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
@@ -114,6 +114,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
   **Note:** We solve on a smaller size as this is many times faster, but also a bit less accurate. Increase if you need more accuracy.
 - `--init_tau`: Initial tau value for Gumbel-Softmax (default: 1.0).
 - `--final_tau`: Final tau value for the Gumbel-Softmax formulation (default: 0.01).
+- `--stl_output_size`: Size of the output stl file in mm (default: 200) (20cm).
 - `--visualize`: Flag to enable live visualization of the composite image during optimization.
 - `--tensorboard`: Enable TensorBoard logging
 - `--run-name`: Name of the run used for TensorBoard logging (optional).

{autoforge-1.4.0 → autoforge-1.4.2}/README.md

@@ -93,6 +93,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
   **Note:** We solve on a smaller size as this is many times faster, but also a bit less accurate. Increase if you need more accuracy.
 - `--init_tau`: Initial tau value for Gumbel-Softmax (default: 1.0).
 - `--final_tau`: Final tau value for the Gumbel-Softmax formulation (default: 0.01).
+- `--stl_output_size`: Size of the output stl file in mm (default: 200) (20cm).
 - `--visualize`: Flag to enable live visualization of the composite image during optimization.
 - `--tensorboard`: Enable TensorBoard logging
 - `--run-name`: Name of the run used for TensorBoard logging (optional).

{autoforge-1.4.0 → autoforge-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AutoForge"
-version="1.4.0"
+version="1.4.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.4.0 → autoforge-1.4.2}/src/AutoForge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.4.0
+Version: 1.4.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
@@ -114,6 +114,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
   **Note:** We solve on a smaller size as this is many times faster, but also a bit less accurate. Increase if you need more accuracy.
 - `--init_tau`: Initial tau value for Gumbel-Softmax (default: 1.0).
 - `--final_tau`: Final tau value for the Gumbel-Softmax formulation (default: 0.01).
+- `--stl_output_size`: Size of the output stl file in mm (default: 200) (20cm).
 - `--visualize`: Flag to enable live visualization of the composite image during optimization.
 - `--tensorboard`: Enable TensorBoard logging
 - `--run-name`: Name of the run used for TensorBoard logging (optional).

{autoforge-1.4.0 → autoforge-1.4.2}/src/autoforge/Helper/ImageHelper.py

@@ -23,6 +23,14 @@ def resize_image(img, max_size):
     return img_out
 
 
+def resize_image_exact(img, new_w, new_h):
+    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
+
+
 def srgb_to_lab(srgb, eps=1e-6):
     """
     Converts an sRGB image (values in [0, 255]) to the CIELAB color space.

{autoforge-1.4.0 → autoforge-1.4.2}/src/autoforge/Helper/OutputHelper.py

@@ -186,108 +186,147 @@ def generate_project_file(
         json.dump(project_data, f, indent=4)
 
 
-def generate_stl(height_map, filename, background_height, scale=1.0):
+import numpy as np
+import struct
+
+
+def generate_stl(height_map, filename, background_height, maximum_x_y_size, alpha_mask=None):
     """
-    Generate a binary STL file from a height map with shared boundary vertices
-    to fix non-manifold edge warnings.
+    Generate a binary STL file from a height map with an optional alpha mask.
+    If alpha_mask is provided, vertices where alpha < 128 are omitted.
+    This function builds a manifold mesh consisting of:
+      - a top surface (only quads whose four vertices are valid),
+      - side walls along the boundary edges of the top surface, and
+      - a bottom face covering the valid region.
 
     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 dimension (and optionally y). Defaults to 1.0.
+        maximum_x_y_size (float): Maximum size (in millimeters) for the x and y dimensions.
+        alpha_mask (np.ndarray): Optional alpha mask (same shape as height_map).
+            A pixel is “valid” only if its alpha is ≥ 128.
     """
     H, W = height_map.shape
 
-    # Create the top vertices grid.
-    # Note: y is computed as H-1-i. (Apply scale to y if desired.)
+    # Compute valid mask: True if no alpha mask or alpha >= 128.
+    if alpha_mask is None:
+        valid_mask = np.ones((H, W), dtype=bool)
+    else:
+        valid_mask = (alpha_mask >= 128)
+
+    # --- Create vertices for the top surface ---
+    # We compute a grid of vertices (even for masked-out regions) but later only use those that are valid.
     top_vertices = np.zeros((H, W, 3), dtype=np.float32)
     for i in range(H):
         for j in range(W):
-            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, 0] = j
+            # Note: y coordinate is set so that row 0 is at the top.
+            top_vertices[i, j, 1] = H - 1 - i
             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.
+    # Create corresponding bottom vertices (same x,y but z = 0)
     bottom_vertices = top_vertices.copy()
     bottom_vertices[:, :, 2] = 0
 
-    triangles = []
+    # --- Scale vertices so that the maximum x or y dimension equals maximum_x_y_size ---
+    original_max = max(W - 1, H - 1)
+    scale = maximum_x_y_size / original_max
+    top_vertices[:, :, 0] *= scale
+    top_vertices[:, :, 1] *= scale
+    bottom_vertices[:, :, 0] *= scale
+    bottom_vertices[:, :, 1] *= scale
+
+    triangles = []  # List to collect all triangles (each as a tuple of three vertices)
 
     def add_triangle(v1, v2, v3):
-        """Add a triangle defined by vertices v1, v2, and v3."""
+        """Append a triangle (defined by 3 vertices) to the triangle list."""
         triangles.append((v1, v2, v3))
 
     # --- Top Surface ---
+    # For the top surface, we iterate over each cell (quad) in the grid.
+    # Only if all 4 corners of the quad are valid do we add two triangles.
+    # We also store the grid indices (i,j) of the vertices used so we can later extract the boundary edges.
+    top_triangles_indices = []  # Each element is a tuple of 3 (i,j) indices.
     for i in range(H - 1):
         for j in range(W - 1):
-            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)
+            if valid_mask[i, j] and valid_mask[i, j + 1] and valid_mask[i + 1, j + 1] and valid_mask[i + 1, j]:
+                # Define the four corners of the quad.
+                v0 = top_vertices[i, j]
+                v1 = top_vertices[i, j + 1]
+                v2 = top_vertices[i + 1, j + 1]
+                v3 = top_vertices[i + 1, j]
+                # For the top surface, use a reversed order so that the computed normal (via cross product) faces upward.
+                add_triangle(v2, v1, v0)
+                add_triangle(v3, v2, v0)
+                # Save the corresponding grid indices (for later boundary detection)
+                top_triangles_indices.append(((i, j), (i, j + 1), (i + 1, j + 1)))
+                top_triangles_indices.append(((i + 1, j), (i + 1, j + 1), (i, j)))
 
     # --- Side Walls ---
-    # Top edge (i = 0)
-    for j in range(W - 1):
-        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):
-        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):
-        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):
-        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)
+    # Instead of simply using the rectangular border, we compute the boundary of the top surface.
+    # We count each undirected edge from the top surface triangles and select those that appear only once.
+    edge_count = {}
+
+    def add_edge(idx1, idx2):
+        # Store an undirected edge as a sorted tuple of the grid indices.
+        key = tuple(sorted((idx1, idx2)))
+        edge_count[key] = edge_count.get(key, 0) + 1
+
+    for tri in top_triangles_indices:
+        add_edge(tri[0], tri[1])
+        add_edge(tri[1], tri[2])
+        add_edge(tri[2], tri[0])
+
+    # A boundary edge appears only once.
+    boundary_edges = [edge for edge, count in edge_count.items() if count == 1]
+
+    # Helper functions to get the coordinate for a given grid index.
+    def get_top_vertex(idx):
+        i, j = idx
+        return top_vertices[i, j]
+
+    def get_bottom_vertex(idx):
+        i, j = idx
+        return bottom_vertices[i, j]
+
+    # For each boundary edge, create a vertical wall.
+    for edge in boundary_edges:
+        idx1, idx2 = edge
+        v_top1 = get_top_vertex(idx1)
+        v_top2 = get_top_vertex(idx2)
+        v_bottom1 = get_bottom_vertex(idx1)
+        v_bottom2 = get_bottom_vertex(idx2)
+        # Create a quad (two triangles) connecting the top edge to the bottom.
+        add_triangle(v_top1, v_top2, v_bottom2)
+        add_triangle(v_top1, v_bottom2, v_bottom1)
 
     # --- 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)
+    # For the bottom face, we mimic the top-surface logic but using the bottom vertices.
+    # The ordering is reversed (relative to the top face) so that the normals face downward.
+    for i in range(H - 1):
+        for j in range(W - 1):
+            if valid_mask[i, j] and valid_mask[i, j + 1] and valid_mask[i + 1, j + 1] and valid_mask[i + 1, j]:
+                v0 = bottom_vertices[i, j]
+                v1 = bottom_vertices[i, j + 1]
+                v2 = bottom_vertices[i + 1, j + 1]
+                v3 = bottom_vertices[i + 1, j]
+                # Order so that the normal will point downward.
+                add_triangle(v0, v1, v2)
+                add_triangle(v0, v2, v3)
 
     num_triangles = len(triangles)
 
-    # --- Write Binary STL ---
+    # --- Write Binary STL File ---
     with open(filename, "wb") as f:
-        header_str = "Binary STL generated from heightmap"
+        header_str = "Binary STL generated from heightmap with alpha mask"
         header = header_str.encode("utf-8")
         header = header.ljust(80, b" ")
         f.write(header)
         f.write(struct.pack("<I", num_triangles))
         for tri in triangles:
             v1, v2, v3 = tri
+            # Compute the normal as the normalized cross product of (v2-v1) and (v3-v1).
             normal = np.cross(v2 - v1, v3 - v1)
             norm = np.linalg.norm(normal)
             if norm == 0:

{autoforge-1.4.0 → autoforge-1.4.2}/src/autoforge/auto_forge.py

@@ -7,7 +7,7 @@ import numpy as np
 from tqdm import tqdm
 
 from autoforge.Helper.FilamentHelper import hex_to_rgb, load_materials
-from autoforge.Helper.ImageHelper import resize_image
+from autoforge.Helper.ImageHelper import resize_image, resize_image_exact
 from autoforge.Helper.OptimizerHelper import (
     init_height_map,
     composite_image,
@@ -86,10 +86,16 @@ def main():
         help="Maximum dimension for solver (fast) image",
     )
     parser.add_argument(
-        "--init_tau", type=float, default=1.0, help="Initial tau value for Gumbel-Softmax"
+        "--init_tau",
+        type=float,
+        default=1.0,
+        help="Initial tau value for Gumbel-Softmax",
     )
     parser.add_argument(
-        "--final_tau", type=float, default=0.01, help="Final tau value for Gumbel-Softmax"
+        "--final_tau",
+        type=float,
+        default=0.01,
+        help="Final tau value for Gumbel-Softmax",
     )
 
     parser.add_argument(
@@ -98,6 +104,13 @@ def main():
         help="Enable visualization during optimization",
     )
 
+    parser.add_argument(
+        "--stl_output_size",
+        type=int,
+        default=200,
+        help="Size of the longest dimension of the output STL file",
+    )
+
     parser.add_argument(
         "--perform_pruning",
         type=bool,
@@ -171,14 +184,10 @@ def main():
         help="Use the Metal Performance Shaders (MPS) backend, if available.",
     )
     parser.add_argument(
-        "--run-name",
-        type=str,
-        help="Name of the run used for TensorBoard logging"
+        "--run-name", type=str, help="Name of the run used for TensorBoard logging"
     )
     parser.add_argument(
-        "--tensorboard",
-        action="store_true",
-        help="Enable TensorBoard logging"
+        "--tensorboard", action="store_true", help="Enable TensorBoard logging"
     )
 
     args = parser.parse_args()
@@ -218,7 +227,18 @@ def main():
     material_TDs = torch.tensor(material_TDs_np, dtype=torch.float32, device=device)
 
     # Read input image
-    img = cv2.imread(args.input_image)
+    img = cv2.imread(args.input_image, cv2.IMREAD_UNCHANGED)
+
+    alpha = None
+    # check for alpha mask
+    if img.shape[2] == 4:
+        # Extract the alpha channel
+        alpha = img[:, :, 3]
+        alpha = alpha[..., None]
+        alpha = resize_image(alpha, args.output_size)
+        # Convert the image from BGRA to BGR
+        img = img[:, :, :3]
+
     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
 
     # This smaller 'target' is the solver resolution
@@ -247,11 +267,15 @@ def main():
             output_img_np, args.max_layers, args.layer_height, random_seed=random_seed
         )
 
+    # if we have an alpha mask we set the height for thos pixels to -13.815512 (the lowest init sigmoid value)
+    if alpha is not None:
+        pixel_height_logits_init[alpha < 128] = -13.815512
+
     # But we will solve at the smaller resolution => resize that init to solver size
     # Add a dummy channel so that cv2.resize can handle it
     tmp_3d = pixel_height_logits_init[..., None]  # shape (H, W, 1)
-    phl_solver_np = resize_image(
-        tmp_3d, args.solver_size
+    phl_solver_np = resize_image_exact(
+        tmp_3d, target_solver.shape[1], target_solver.shape[0]
     )  # shape (H', W') cause of weird opencv quirk
 
     # VGG Perceptual Loss
@@ -298,7 +322,9 @@ def main():
         optimizer.best_discrete_loss = new_loss
         print(f"New best seed found: {new_rng_seed} with loss: {new_loss}")
 
-    optimizer.log_to_tensorboard(interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1))
+    optimizer.log_to_tensorboard(
+        interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1)
+    )
 
     # Optionally prune
     if args.perform_pruning:
@@ -310,14 +336,18 @@ def main():
             tau_g=optimizer.best_tau,
         )
 
-        optimizer.log_to_tensorboard(interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1))
+        optimizer.log_to_tensorboard(
+            interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1)
+        )
 
         # Do a quick search for a better rng seed
         new_rng_seed, new_loss = optimizer.rng_seed_search(
             optimizer.best_discrete_loss, 500
         )
 
-        optimizer.log_to_tensorboard(interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1))
+        optimizer.log_to_tensorboard(
+            interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1)
+        )
 
         if new_loss < optimizer.best_discrete_loss:
             optimizer.best_seed = new_rng_seed
@@ -371,8 +401,9 @@ def main():
         rng_seed=optimizer.best_seed,
     )
 
-    optimizer.log_to_tensorboard(interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1))
-
+    optimizer.log_to_tensorboard(
+        interval=1, namespace="post_opt", step=(post_opt_step := post_opt_step + 1)
+    )
 
     comp_disc_np = comp_disc.cpu().numpy().astype(np.uint8)
     comp_disc_np = cv2.cvtColor(comp_disc_np, cv2.COLOR_RGB2BGR)
@@ -382,7 +413,13 @@ def main():
     height_map_mm = (
         disc_height_image.cpu().numpy().astype(np.float32)
     ) * args.layer_height
-    generate_stl(height_map_mm, stl_filename, args.background_height, scale=1.0)
+    generate_stl(
+        height_map_mm,
+        stl_filename,
+        args.background_height,
+        maximum_x_y_size=args.stl_output_size,
+        alpha_mask=alpha,
+    )
 
     # Swap instructions
     background_layers = int(args.background_height // args.layer_height)