autoforge 1.1.2__tar.gz → 1.1.3__tar.gz

{autoforge-1.1.2 → autoforge-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.1.2
+Version: 1.1.3
 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
@@ -34,18 +34,21 @@ All examples use only the 13 BambuLab Basic filaments, currently available in Hu
 <div style="display: flex; justify-content: center; gap: 20px;">
   <div style="text-align: center;">
     <h3>Input Image</h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi.jpg" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature.jpg" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat.jpg" width="200" />
   </div>
   <div style="text-align: center;">
     <h3>Autoforge Output (75 color layers (3.0mm) + 10 gray background layers (0.4mm)) </h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_discretized.jpg" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_discretized.jpg" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_discretized.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_discretized.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat_discretized.jpg" width="200" />
   </div>
   <div style="text-align: center;">
     <h3>Imported Hueforge View</h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_hueforge.png" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_hueforge.png" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_hueforge.png" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_hueforge.png" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat_hueforge.png" width="200" />
   </div>
 </div>
 
@@ -66,33 +69,17 @@ I would love to see what you made!
 
 ## Installation
 
-1. **Clone the Repository**
-
-   ```bash
-   git clone https://github.com/hvoss-techfak/AutoForge.git
-   cd AutoForge
-   ```
-
-2. **Set Up a Virtual Environment (Optional but Recommended)**
-
-   ```bash
-   python -m venv venv
-   source venv/bin/activate  # On Windows: venv\Scripts\activate
-   ```
-
-3. **Install Dependencies**
-
-   ```bash
-   pip install -r requirements.txt
-   ```
+To install AutoForge, simply install the current version from PyPI:
+```bash
+   pip install autoforge
+```
 
-See the [requirements.txt](requirements.txt) file for a complete list of dependencies.  
-The optimizer is built using JAX, which benefits from a CUDA-compatible GPU for optimal performance.  
-Without a dedicated GPU the process can take significantly longer (up to 10-20x slower).  
-If you have a GPU, you can install the GPU version of JAX by running:
+The optimizer is built using JAX, which benefits from a CUDA-compatible GPU for optimal performance.  \
+Without a dedicated GPU the process can take significantly longer (up to 10-20x slower).  \
+If you have a GPU, you can install the GPU version of autoforge by running:\
 
 ```bash
-pip install -U "jax[cuda12]"
+   pip install autoforge[gpu]
 ```
 
 Currently, jax gpu support is only available under linux. \
@@ -108,7 +95,7 @@ The script is run from the command line and accepts several arguments. Below is
 > If you want to limit the amount of colors the program can use, you can simply delete the colors you don't want from the CSV file.
 
 ```bash
-python auto_forge.py --input_image path/to/input_image.jpg --csv_file path/to/materials.csv --output_folder outputs 
+autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv --output_folder outputs 
 ```
 
 ### Command Line Arguments
@@ -174,5 +161,6 @@ AutoForge makes use of several open source libraries:
 Example Images:  
 <a href="https://www.vecteezy.com/free-photos/anime-girl">Anime Girl Stock photos by Vecteezy</a>  
 <a href="https://www.vecteezy.com/free-photos/nature">Nature Stock photos by Vecteezy</a>
+<a href="https://www.vecteezy.com/free-photos/ai-generated">Ai Generated Stock photos by Vecteezy</a>
 
 Happy printing!

{autoforge-1.1.2 → autoforge-1.1.3}/README.md

@@ -12,18 +12,21 @@ All examples use only the 13 BambuLab Basic filaments, currently available in Hu
 <div style="display: flex; justify-content: center; gap: 20px;">
   <div style="text-align: center;">
     <h3>Input Image</h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi.jpg" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature.jpg" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat.jpg" width="200" />
   </div>
   <div style="text-align: center;">
     <h3>Autoforge Output (75 color layers (3.0mm) + 10 gray background layers (0.4mm)) </h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_discretized.jpg" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_discretized.jpg" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_discretized.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_discretized.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat_discretized.jpg" width="200" />
   </div>
   <div style="text-align: center;">
     <h3>Imported Hueforge View</h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_hueforge.png" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_hueforge.png" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_hueforge.png" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_hueforge.png" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat_hueforge.png" width="200" />
   </div>
 </div>
 
@@ -44,33 +47,17 @@ I would love to see what you made!
 
 ## Installation
 
-1. **Clone the Repository**
-
-   ```bash
-   git clone https://github.com/hvoss-techfak/AutoForge.git
-   cd AutoForge
-   ```
-
-2. **Set Up a Virtual Environment (Optional but Recommended)**
-
-   ```bash
-   python -m venv venv
-   source venv/bin/activate  # On Windows: venv\Scripts\activate
-   ```
-
-3. **Install Dependencies**
-
-   ```bash
-   pip install -r requirements.txt
-   ```
+To install AutoForge, simply install the current version from PyPI:
+```bash
+   pip install autoforge
+```
 
-See the [requirements.txt](requirements.txt) file for a complete list of dependencies.  
-The optimizer is built using JAX, which benefits from a CUDA-compatible GPU for optimal performance.  
-Without a dedicated GPU the process can take significantly longer (up to 10-20x slower).  
-If you have a GPU, you can install the GPU version of JAX by running:
+The optimizer is built using JAX, which benefits from a CUDA-compatible GPU for optimal performance.  \
+Without a dedicated GPU the process can take significantly longer (up to 10-20x slower).  \
+If you have a GPU, you can install the GPU version of autoforge by running:\
 
 ```bash
-pip install -U "jax[cuda12]"
+   pip install autoforge[gpu]
 ```
 
 Currently, jax gpu support is only available under linux. \
@@ -86,7 +73,7 @@ The script is run from the command line and accepts several arguments. Below is
 > If you want to limit the amount of colors the program can use, you can simply delete the colors you don't want from the CSV file.
 
 ```bash
-python auto_forge.py --input_image path/to/input_image.jpg --csv_file path/to/materials.csv --output_folder outputs 
+autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv --output_folder outputs 
 ```
 
 ### Command Line Arguments
@@ -152,5 +139,6 @@ AutoForge makes use of several open source libraries:
 Example Images:  
 <a href="https://www.vecteezy.com/free-photos/anime-girl">Anime Girl Stock photos by Vecteezy</a>  
 <a href="https://www.vecteezy.com/free-photos/nature">Nature Stock photos by Vecteezy</a>
+<a href="https://www.vecteezy.com/free-photos/ai-generated">Ai Generated Stock photos by Vecteezy</a>
 
 Happy printing!

{autoforge-1.1.2 → autoforge-1.1.3}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: AutoForge
-Version: 1.1.2
+Version: 1.1.3
 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
@@ -34,18 +34,21 @@ All examples use only the 13 BambuLab Basic filaments, currently available in Hu
 <div style="display: flex; justify-content: center; gap: 20px;">
   <div style="text-align: center;">
     <h3>Input Image</h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi.jpg" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature.jpg" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat.jpg" width="200" />
   </div>
   <div style="text-align: center;">
     <h3>Autoforge Output (75 color layers (3.0mm) + 10 gray background layers (0.4mm)) </h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_discretized.jpg" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_discretized.jpg" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_discretized.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_discretized.jpg" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat_discretized.jpg" width="200" />
   </div>
   <div style="text-align: center;">
     <h3>Imported Hueforge View</h3>
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_hueforge.png" width="300" />
-    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_hueforge.png" width="300" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/lofi_hueforge.png" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/nature_hueforge.png" width="200" />
+    <img src="https://github.com/hvoss-techfak/AutoForge/blob/main/images/cat_hueforge.png" width="200" />
   </div>
 </div>
 
@@ -66,33 +69,17 @@ I would love to see what you made!
 
 ## Installation
 
-1. **Clone the Repository**
-
-   ```bash
-   git clone https://github.com/hvoss-techfak/AutoForge.git
-   cd AutoForge
-   ```
-
-2. **Set Up a Virtual Environment (Optional but Recommended)**
-
-   ```bash
-   python -m venv venv
-   source venv/bin/activate  # On Windows: venv\Scripts\activate
-   ```
-
-3. **Install Dependencies**
-
-   ```bash
-   pip install -r requirements.txt
-   ```
+To install AutoForge, simply install the current version from PyPI:
+```bash
+   pip install autoforge
+```
 
-See the [requirements.txt](requirements.txt) file for a complete list of dependencies.  
-The optimizer is built using JAX, which benefits from a CUDA-compatible GPU for optimal performance.  
-Without a dedicated GPU the process can take significantly longer (up to 10-20x slower).  
-If you have a GPU, you can install the GPU version of JAX by running:
+The optimizer is built using JAX, which benefits from a CUDA-compatible GPU for optimal performance.  \
+Without a dedicated GPU the process can take significantly longer (up to 10-20x slower).  \
+If you have a GPU, you can install the GPU version of autoforge by running:\
 
 ```bash
-pip install -U "jax[cuda12]"
+   pip install autoforge[gpu]
 ```
 
 Currently, jax gpu support is only available under linux. \
@@ -108,7 +95,7 @@ The script is run from the command line and accepts several arguments. Below is
 > If you want to limit the amount of colors the program can use, you can simply delete the colors you don't want from the CSV file.
 
 ```bash
-python auto_forge.py --input_image path/to/input_image.jpg --csv_file path/to/materials.csv --output_folder outputs 
+autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv --output_folder outputs 
 ```
 
 ### Command Line Arguments
@@ -174,5 +161,6 @@ AutoForge makes use of several open source libraries:
 Example Images:  
 <a href="https://www.vecteezy.com/free-photos/anime-girl">Anime Girl Stock photos by Vecteezy</a>  
 <a href="https://www.vecteezy.com/free-photos/nature">Nature Stock photos by Vecteezy</a>
+<a href="https://www.vecteezy.com/free-photos/ai-generated">Ai Generated Stock photos by Vecteezy</a>
 
 Happy printing!

{autoforge-1.1.2 → autoforge-1.1.3}/src/AutoForge.egg-info/SOURCES.txt

@@ -9,5 +9,7 @@ src/AutoForge.egg-info/top_level.txt
 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/helper_functions.py

{autoforge-1.1.2 → autoforge-1.1.3}/src/autoforge/auto_forge.py

@@ -67,9 +67,9 @@ def composite_pixel_combined(pixel_height_logit, global_logits, tau_height, tau_
     if mode == "pruning":
         global_logits = jax.nn.one_hot(global_logits, len(material_colors))
 
-    A = 0.178763
-    k = 39.302848
-    b = 0.351177
+    A = 0.1215
+    k = 61.6970
+    b = 0.4773
 
     def step_fn(carry, i):
         comp, remaining = carry
@@ -274,7 +274,7 @@ def discretize_solution_jax(params, tau_global, gumbel_keys, h, max_layers):
 
 
 
-def run_optimizer(rng_key, target, H, W, max_layers, h, material_colors, material_TDs, background,
+def run_optimizer(rng_key, target,pixel_height_logits, H, W, max_layers, h, material_colors, material_TDs, background,
                   num_iters, learning_rate, decay_v, loss_function, visualize=False,
                   output_folder=None, save_interval_pct=None,
                   img_width=None, img_height=None, background_height=None,
@@ -313,7 +313,7 @@ def run_optimizer(rng_key, target, H, W, max_layers, h, material_colors, materia
     rng_key, subkey = random.split(rng_key)
 
     #pixel_height_logits = initialize_pixel_height_logits(target)
-    pixel_height_logits = init_height_map(target,max_layers,h)
+
     #pixel_height_logits = random.uniform(subkey, (H, W), minval=-2.0, maxval=2.0)
 
     params = {'global_logits': global_logits, 'pixel_height_logits': pixel_height_logits}
@@ -494,7 +494,7 @@ def save_intermediate_outputs(iteration, params, tau_global, gumbel_keys, h, max
                           np.array(disc_height_image),
                           img_width, img_height, stl_filename, csv_file)
 
-def pruning(target,best_params,disc_global,tau_global_disc,gumbel_keys_disc,h,max_layers,material_colors,material_TDs,background,max_loss_increase=0.05):
+def pruning(target,best_params,disc_global,tau_global_disc,gumbel_keys_disc,h,max_layers,material_colors,material_TDs,background,max_loss_increase=0.1):
     initial_image = composite_image_combined_jit(best_params['pixel_height_logits'], disc_global,
                                              tau_global_disc, tau_global_disc, gumbel_keys_disc,
                                              h, max_layers, material_colors, material_TDs, background, mode="pruning")
@@ -524,40 +524,69 @@ def pruning(target,best_params,disc_global,tau_global_disc,gumbel_keys_disc,h,ma
     # Pruning test 1 - Try removing entire color bands
     current_bands = len(color_bands)
 
-    for _ in tqdm(range(100),desc="Pruning - Removing entire color bands"):
+    def get_image_loss(disc_global):
+        disc_global = jnp.array(disc_global)
+        return jnp.mean((composite_image_combined_jit(best_params['pixel_height_logits'], disc_global,
+                                             tau_global_disc, tau_global_disc, gumbel_keys_disc,
+                                             h, max_layers, material_colors, material_TDs, background, mode="pruning") - target) ** 2)
+
+    for _ in tqdm(range(10),desc="Pruning - Removing entire color bands"):
+        change = False
+        #testing removing color bands forward
         for i in range(1,len(color_bands)):
             band = color_bands[i]
             disc_global_copy = np.asarray(disc_global).copy()
             disc_global_copy[band[0]:band[1]+1] = color_bands[i-1][2]
-            disc_global_copy = jnp.array(disc_global_copy)
-            new_image = composite_image_combined_jit(best_params['pixel_height_logits'], disc_global_copy,
-                                                 tau_global_disc, tau_global_disc, gumbel_keys_disc,
-                                                 h, max_layers, material_colors, material_TDs, background, mode="pruning")
-            new_loss = jnp.mean((new_image - target) ** 2)
+            new_loss = get_image_loss(disc_global)
             if new_loss < max_loss:
+                change = True
                 disc_global = disc_global_copy
-                max_loss = new_loss
                 color_bands[i] = color_bands[i-1]
 
-        # Same as above but in reverse
+        # testing removing color bands backwards
         for i in reversed(range(0,len(color_bands)-1)):
             band = color_bands[i]
             disc_global_copy = np.asarray(disc_global).copy()
             disc_global_copy[band[0]:band[1]+1] = color_bands[i+1][2]
-            disc_global_copy = jnp.array(disc_global_copy)
-            new_image = composite_image_combined_jit(best_params['pixel_height_logits'], disc_global_copy,
-                                                 tau_global_disc, tau_global_disc, gumbel_keys_disc,
-                                                 h, max_layers, material_colors, material_TDs, background, mode="pruning")
-            new_loss = jnp.mean((new_image - target) ** 2)
+            new_loss = get_image_loss(disc_global)
             if new_loss < max_loss:
+                change = True
                 disc_global = disc_global_copy
-                max_loss = new_loss
                 color_bands[i] = color_bands[i+1]
-        if current_bands == get_color_bands(disc_global):
+
+        #we only check for these one if the loss decreases as otherwise we risk color band shifting
+        p2_initial_loss = get_image_loss(disc_global)
+        #testing border shifting forward
+        for i in range(0,len(color_bands)):
+            band = color_bands[i]
+            disc_global_copy = np.asarray(disc_global).copy()
+            disc_global_copy[band[0]:min(band[1]+2,max_layers)] = band[2]
+            new_loss = get_image_loss(disc_global)
+            if new_loss < p2_initial_loss:
+                #print(f"color band {i} shifted forwards - {band} - {new_loss}")
+                p2_initial_loss = new_loss
+                change = True
+                disc_global = disc_global_copy
+                color_bands[i] = (band[0],band[1]+1,band[2])
+
+        #testing border shifting backwards
+        for i in reversed(range(0,len(color_bands))):
+            band = color_bands[i]
+            disc_global_copy = np.asarray(disc_global).copy()
+            disc_global_copy[max(0,band[0]-1):band[1]+1] = band[2]
+            new_loss = get_image_loss(disc_global)
+            if new_loss < p2_initial_loss:
+                #print(f"color band {i} shifted backwards - {band} - {new_loss}")
+                p2_initial_loss = new_loss
+                change = True
+                disc_global = disc_global_copy
+                color_bands[i] = (band[0]-1,band[1],band[2])
+
+
+
+        if not change:
             print("No changes in color bands. Exiting pruning.")
             break
-        else:
-            current_bands = get_color_bands(disc_global)
     #calculate color band difference
     new_color_bands = get_color_bands(disc_global)
     print(f"Color bands before pruning: {len(color_bands)}")
@@ -607,6 +636,7 @@ def main():
     parser.add_argument("--visualize", action="store_true", help="Enable visualization during optimization")
     parser.add_argument("--perform_gumbal_search", type=bool, default=True, help="Perform gumbal search after optimization")
     parser.add_argument("--perform_pruning", type=bool, default=True, help="Perform pruning after optimization")
+    parser.add_argument("--pruning_max_loss_increase", type=float, default=0.1, help="Maximum loss increase for pruning")
     parser.add_argument("--save_interval_pct", type=float, default=20,help="Percentage interval to save intermediate results")
 
     args = parser.parse_args()
@@ -638,12 +668,22 @@ def main():
     new_h, new_w, _ = target.shape
 
     output_target = resize_image(img,args.output_size)
+    print(target.shape)
+
+    pixel_height_logits = init_height_map(output_target, args.max_layers, h_value)
+    pixel_height_logits = np.asarray(pixel_height_logits)
+    print(pixel_height_logits.shape)
+
+    #resize to target size
+    o_shape = pixel_height_logits.shape
+    pixel_height_logits_solver = resize_image(pixel_height_logits.reshape(o_shape[0],o_shape[1],1),args.solver_size)
 
     target = jnp.array(target, dtype=jnp.float64)
 
+
     rng_key = random.PRNGKey(int(time.time()))
     best_params, _, val_gumbel_keys = run_optimizer(
-        rng_key, target, new_h, new_w, max_layers_value, h_value,
+        rng_key, target,pixel_height_logits_solver, new_h, new_w, max_layers_value, h_value,
         material_colors, material_TDs, background,
         args.iterations, args.learning_rate, decay_v_value,
         loss_function=loss_fn,
@@ -664,7 +704,7 @@ def main():
                                             max_layers_value, rng_key, target, val_gumbel_keys,iterations=1000,desc="Searching small size image for best gumbal keys")
 
     if args.solver_size != args.output_size and args.perform_gumbal_search:
-        best_params["pixel_height_logits"] = init_height_map(output_target, args.max_layers, h_value)
+        best_params["pixel_height_logits"] = pixel_height_logits
 
         val_gumbel_keys = gumbal_bruteforce(background, best_params, decay_v_value, h_value, material_TDs, material_colors,
                                             max_layers_value, rng_key, output_target, val_gumbel_keys, iterations=1000,
@@ -673,7 +713,7 @@ def main():
     disc_global, disc_height_image = discretize_solution_jax(best_params, tau_global_disc, val_gumbel_keys, h_value, max_layers_value)
 
     if args.perform_pruning:
-        disc_global = pruning(output_target,best_params,disc_global,tau_global_disc,val_gumbel_keys,h_value,args.max_layers,material_colors,material_TDs,background)
+        disc_global = pruning(output_target,best_params,disc_global,tau_global_disc,val_gumbel_keys,h_value,args.max_layers,material_colors,material_TDs,background,max_loss_increase=args.pruning_max_loss_increase)
 
     disc_comp = composite_image_combined_jit(best_params['pixel_height_logits'], disc_global,
                                              tau_global_disc, tau_global_disc, val_gumbel_keys,

autoforge-1.1.3/src/autoforge/auto_forge_gradio.py

@@ -0,0 +1,495 @@
+#!/usr/bin/env python
+"""
+gradio_interface.py
+
+This file demonstrates a Gradio interface that wraps your optimization code
+and also adds a "Height Map Annotation" tab. In that tab the initial height map
+is previewed (using your init_height_map function) and you can annotate it manually
+with color labels loaded from your CSV file.
+"""
+import json
+import threading
+import time
+import queue
+import os
+import cv2
+import numpy as np
+import gradio as gr
+import jax
+import jax.numpy as jnp
+import optax
+import math
+import time
+
+import pandas as pd
+
+# Import your functions from your original module.
+# (Make sure these functions are available in your PYTHONPATH or adjust the import as needed.)
+from autoforge.auto_forge import (
+    run_optimizer,
+    loss_fn,
+    composite_image_combined_jit,
+    init_height_map,
+    hex_to_rgb,
+    load_materials,
+    generate_stl,
+    generate_swap_instructions,
+    generate_project_file,
+    gumbal_bruteforce,
+    pruning
+)
+from autoforge.filamentcolors_library import download_filament_info
+from autoforge.helper_functions import extract_colors_from_swatches, swatch_data_to_table
+
+# -------------------------------
+# Global state for background optimization
+# -------------------------------
+pause_flag = threading.Event()
+stop_flag = threading.Event()
+update_queue = queue.Queue()
+optimizer_thread = None
+current_optimizer_state = {}  # Holds the latest state (iteration, loss, composite image, etc.)
+
+
+# =============================================================================
+# Helper functions for height map preview and annotation
+# =============================================================================
+def compute_initial_height_map(input_image, max_layers, layer_height):
+    """
+    Compute and return an initial height map preview from the input image.
+    The height map is normalized to 0-255 for display.
+    """
+    # Convert the input image to a jax array (assumed to be RGB)
+    target = jnp.array(input_image, dtype=jnp.float64)
+    height_map = init_height_map(target, max_layers, layer_height)
+    height_map_np = np.array(height_map)
+    # Normalize for display purposes.
+    norm = (height_map_np - height_map_np.min())
+    norm = norm / (norm.max() + 1e-6)
+    normalized = (255 * norm).astype(np.uint8)
+    return normalized
+
+
+def get_material_labels(csv_file):
+    """
+    Load the material names from the CSV file.
+    """
+    _, _, material_names, _ = load_materials(csv_file)
+    return material_names
+
+
+def init_height_map_preview(input_image, max_layers, layer_height, csv_file):
+    """
+    Compute the initial height map from the uploaded image and update the color labels.
+    Returns:
+      - The height map image for preview.
+      - An update for the dropdown choices containing the material labels.
+    """
+    if input_image is None:
+        return None, gr.Dropdown.update(choices=[])
+    hm = compute_initial_height_map(input_image, max_layers, layer_height)
+    labels = get_material_labels(csv_file)
+    default_val = labels[0] if labels else None
+    return hm, gr.Dropdown.update(choices=labels, value=default_val)
+
+
+def save_annotated_height_map(annotated_hm):
+    """
+    Save the annotated height map image to a file and return the file path.
+    """
+    output_path = "annotated_height_map.png"
+    # Assume the annotated image is in RGB format.
+    cv2.imwrite(output_path, cv2.cvtColor(annotated_hm, cv2.COLOR_RGB2BGR))
+    return output_path
+
+
+# =============================================================================
+# Background Optimization Function (Simulated)
+# =============================================================================
+def run_optimization_background(
+        input_image, csv_file,
+        iterations, learning_rate,
+        layer_height, max_layers,
+        background_height, background_color,
+        output_size, solver_size,
+        decay, perform_gumbal_search, perform_pruning,
+        save_interval_pct
+):
+    """
+    This function loads the image and material data, then runs the optimizer.
+    It updates a shared queue with intermediate outputs for the UI.
+    (Here we simulate the iterative updates; integrate your actual optimizer loop as needed.)
+    """
+    global current_optimizer_state
+
+    pause_flag.clear()
+    stop_flag.clear()
+
+    # Load and prepare the image.
+    img = cv2.cvtColor(np.array(input_image), cv2.COLOR_RGB2BGR)
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    H, W, _ = img.shape
+    solver_size = int(solver_size)
+    target_solver = cv2.resize(img, (solver_size, solver_size))
+    target_solver = jnp.array(target_solver, dtype=jnp.float64)
+
+    # Load materials.
+    material_colors, material_TDs, material_names, material_hex = load_materials(csv_file)
+    background = jnp.array(hex_to_rgb(background_color), dtype=jnp.float64)
+
+    # Initialize optimizer state (simulate initialization).
+    rng_key = jax.random.PRNGKey(int(time.time()))
+
+    # Simulated iterative optimization loop.
+    for i in range(iterations):
+        if stop_flag.is_set():
+            current_optimizer_state["message"] = "Optimization stopped."
+            update_queue.put(current_optimizer_state)
+            return
+        # Pause if needed.
+        while pause_flag.is_set():
+            current_optimizer_state["message"] = f"Paused at iteration {i}."
+            update_queue.put(current_optimizer_state)
+            time.sleep(0.2)
+
+        # Simulate an update step.
+        simulated_loss = np.exp(-i / iterations) * 100 + np.random.rand() * 5
+        simulated_comp = np.clip(np.random.randn(solver_size, solver_size, 3) * 20 + 128, 0, 255).astype(np.uint8)
+        current_optimizer_state = {
+            "iteration": i,
+            "loss": simulated_loss,
+            "composite": simulated_comp,
+            "message": ""
+        }
+        update_queue.put(current_optimizer_state)
+        time.sleep(0.1)
+
+    current_optimizer_state["message"] = "Optimization complete."
+    update_queue.put(current_optimizer_state)
+
+
+# =============================================================================
+# Live update generator for Gradio streaming
+# =============================================================================
+def live_updates():
+    """
+    Generator that yields the latest composite image and status text.
+    """
+    while True:
+        try:
+            state = update_queue.get(timeout=1.0)
+            composite = state.get("composite", np.zeros((128, 128, 3), dtype=np.uint8))
+            iteration = state.get("iteration", 0)
+            loss = state.get("loss", 0)
+            message = state.get("message", "")
+            status_text = f"Iteration: {iteration} | Loss: {loss:.4f} {message}"
+            yield composite, status_text
+            if message in ["Optimization complete.", "Optimization stopped."]:
+                break
+        except queue.Empty:
+            if stop_flag.is_set():
+                break
+
+
+# =============================================================================
+# Button callback functions for optimization control.
+# =============================================================================
+def start_optimization(
+        input_image, csv_file,
+        iterations, learning_rate,
+        layer_height, max_layers,
+        background_height, background_color,
+        output_size, solver_size,
+        decay, perform_gumbal_search, perform_pruning,
+        save_interval_pct
+):
+    global optimizer_thread
+    if optimizer_thread is None or not optimizer_thread.is_alive():
+        optimizer_thread = threading.Thread(
+            target=run_optimization_background,
+            args=(
+                input_image, csv_file, iterations, learning_rate,
+                layer_height, max_layers, background_height, background_color,
+                output_size, solver_size, decay, perform_gumbal_search, perform_pruning,
+                save_interval_pct
+            ),
+            daemon=True
+        )
+        optimizer_thread.start()
+    return "Optimization started."
+
+
+def pause_optimization():
+    pause_flag.set()
+    return "Optimization paused."
+
+
+def resume_optimization():
+    pause_flag.clear()
+    return "Optimization resumed."
+
+
+def stop_optimization():
+    stop_flag.set()
+    return "Optimization stopped."
+
+# =============================================================================
+# Filament Tab Helper
+# =============================================================================
+def filter_table(search_text, table):
+    if not search_text:
+        return table
+    filtered = [
+        row for row in table
+        if search_text.lower() in row["Brand"].lower() or search_text.lower() in row["Name"].lower()
+    ]
+    return filtered
+
+# Function to update the active list based on selection.
+def update_active(selected, table):
+    # 'selected' is a list of strings in the format "Brand - Name"
+    active = [row for row in table if f'{row["Brand"]} - {row["Name"]}' in selected]
+    return active
+
+# =============================================================================
+# Postprocessing callbacks (simulated)
+# =============================================================================
+def run_gumbal_search_callback():
+    updated_comp = np.clip(np.random.randn(128, 128, 3) * 20 + 150, 0, 255).astype(np.uint8)
+    status = "Gumbal search completed."
+    return updated_comp, status
+
+
+def run_pruning_callback():
+    updated_comp = np.clip(np.random.randn(128, 128, 3) * 20 + 170, 0, 255).astype(np.uint8)
+    status = "Pruning completed."
+    return updated_comp, status
+
+
+# =============================================================================
+# Export callback.
+# =============================================================================
+def export_outputs_callback():
+    output_folder = "temp_output"
+    os.makedirs(output_folder, exist_ok=True)
+    stl_path = os.path.join(output_folder, "final_model.stl")
+    swap_path = os.path.join(output_folder, "swap_instructions.txt")
+    project_path = os.path.join(output_folder, "project_file.hfp")
+
+    with open(stl_path, "w") as f:
+        f.write("STL file content")
+    with open(swap_path, "w") as f:
+        f.write("Swap instructions content")
+    with open(project_path, "w") as f:
+        f.write("Project file content")
+
+    # For this example, we return the STL file for download.
+    return stl_path
+
+#download filament info
+print(f"Downloading filament info...")
+print("If this is your first time running this script, it may take a few minutes.")
+download_filament_info()
+#load swatch json file
+with open("swatches.json", "r") as f:
+    swatch_data = json.load(f)
+
+table = swatch_data_to_table(swatch_data)
+table_df = pd.DataFrame(table)
+
+
+def filter_swatches_callback(search_query, table_data):
+    """
+    Given a search query and the full swatch table data,
+    returns a filtered table (including the header) where the query is
+    found in any field (case-insensitive).
+    """
+    if table_data is None or len(table_data) == 0:
+        return []
+    header = table_data[0]
+    rows = table_data[1:]
+    if search_query is None or search_query.strip() == "":
+        filtered = table_data
+    else:
+        filtered_rows = [
+            row for row in rows
+            if any(search_query.lower() in str(cell).lower() for cell in row)
+        ]
+        filtered = [header] + filtered_rows
+    return filtered
+
+
+def add_to_active_callback(selected, table_data, active_data):
+    """
+    Given a list of selected material names (e.g., "Brand - Name"),
+    adds those rows from the full table_data (if not already present)
+    to the active list.
+    """
+    if table_data is None or len(table_data) == 0:
+        return active_data
+    header = table_data[0]
+    if active_data is None or len(active_data) == 0:
+        active_data = [header]
+    else:
+        # Ensure header is set
+        if active_data[0] != header:
+            active_data[0] = header
+    # Build a set of already-added materials (by "Brand - Name")
+    existing = {row[0] + " - " + row[1] for row in active_data[1:]}
+    # Loop through table_data rows and add those whose "Brand - Name" is in selected
+    for row in table_data[1:]:
+        material = row[0] + " - " + row[1]
+        if material in selected and material not in existing:
+            active_data.append(row)
+    return active_data
+
+def highlight_cols(x):
+    df = x.copy()
+    df.loc[:, :] = 'color: purple'
+    df[['B', 'C', 'E']] = 'color: green'
+    return df
+
+# ------------------------------------------------------------------------------
+# Gradio Interface (including the new Color Filament Tab)
+# ------------------------------------------------------------------------------
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Autoforge")
+
+    # -------------------------
+    # Color Filament Tab
+    # -------------------------
+    with gr.Tab("Color Filament"):
+        gr.Markdown("### Manage and Select Filament Colors")
+
+        with gr.Row():
+            #fill with data from table_df
+            material_select = gr.Dropdown(label="Select Filaments", multiselect=True,interactive=Trueasdasdasdsseee, choices=[brand + " - " + name + " - " + hex_color for brand,name,hex_color in table_df[["Brand", "Name", "Hex Color"]].values.tolist()])
+            add_active_btn = gr.Button("Add to Active List")
+        with gr.Row():
+            active_filaments = gr.DataFrame(label="Active Filaments", interactive=True)
+
+        with gr.Row():
+            #s = table_df.grsdfstyle.apply(highlight_cols, axis=None)
+            swatch_table = gr.DataFrame(value=table_df,label="All Filaments", interactive=True)
+
+        # 3. Add the selected materials to the active list.grgr
+        add_active_btn.click(
+            add_to_active_callback,
+            inputs=[material_select, swatch_table, active_filaments],
+            outputs=active_filaments
+        )
+
+    with gr.Tab("Height Map Annotation"):
+        gr.Markdown("### Preview and Annotate Height Map")
+        with gr.Row():
+            hm_input_image = gr.Image(label="Upload Image",
+              sources=['upload'],
+              type='numpy'
+            )
+            hm_csv_file = gr.Textbox(label="CSV File Path", value="materials.csv")
+        with gr.Row():
+            hm_max_layers = gr.Slider(10, 150, label="Max Layers", value=75, step=1)
+            hm_layer_height = gr.Slider(0.01, 0.1, label="Layer Height (mm)", value=0.04, step=0.01)
+        load_hm_btn = gr.Button("Load Height Map Preview")
+        with gr.Row():
+            height_map_preview = gr.ImageEditor(
+                label="Height Map",
+                sources=['upload'],
+                type='pil'
+            )
+
+            color_label_dropdown = gr.Dropdown(label="Select Material Label", choices=[], value=None)
+        save_hm_btn = gr.Button("Save Annotated Height Map")
+        hm_download = gr.File(label="Download Annotated Height Map")
+
+        # When "Load Height Map Preview" is clicked, compute the initial height map and update the dropdown.
+        load_hm_btn.click(
+            init_height_map_preview,
+            inputs=[hm_input_image, hm_max_layers, hm_layer_height, hm_csv_file],
+            outputs=[height_map_preview, color_label_dropdown]
+        )
+        # When "Save Annotated Height Map" is clicked, save the current annotated image.
+        save_hm_btn.click(
+            save_annotated_height_map,
+            inputs=[height_map_preview],
+            outputs=hm_download
+        )
+
+    with gr.Tab("Optimization"):
+            with gr.Row():
+                input_image = gr.ImageEditor(label="Upload Image",
+                  sources=['upload'],
+                  type= 'pil'
+                )
+                csv_file = gr.Textbox(label="CSV File Path", value="materials.csv")
+            with gr.Row():
+                iterations_slider = gr.Slider(100, 10000, step=100, label="Iterations", value=5000)
+                learning_rate_slider = gr.Slider(1e-4, 1e-1, label="Learning Rate", value=1e-2, step=1e-4)
+            with gr.Row():
+                layer_height_slider = gr.Slider(0.01, 0.1, label="Layer Height (mm)", value=0.04, step=0.01)
+                max_layers_slider = gr.Slider(10, 150, label="Max Layers", value=75, step=1)
+            with gr.Row():
+                background_height_slider = gr.Slider(0.1, 2.0, label="Background Height (mm)", value=0.4, step=0.1)
+                output_size_slider = gr.Slider(256, 2048, label="Output Size", value=1024, step=64)
+                solver_size_slider = gr.Slider(64, 512, label="Solver Size", value=128, step=16)
+            with gr.Row():
+                decay_slider = gr.Slider(0.001, 0.1, label="Decay", value=0.01, step=0.001)
+            with gr.Row():
+                perform_gumbal_search_checkbox = gr.Checkbox(label="Perform Gumbal Search", value=True)
+                perform_pruning_checkbox = gr.Checkbox(label="Perform Pruning", value=True)
+            with gr.Row():
+                save_interval_slider = gr.Slider(1, 100, label="Save Interval (%)", value=20, step=1)
+            # Create a separate textbox component for background color
+            background_color_textbox = gr.Textbox(label="Background Color", value="#000000")
+            with gr.Row():
+                start_btn = gr.Button("Start Optimization")
+                pause_btn = gr.Button("Pause")
+                resume_btn = gr.Button("Resume")
+                stop_btn = gr.Button("Stop")
+            status_box = gr.Textbox(label="Status", interactive=False)
+            live_image = gr.Image(label="Current Composite")
+            live_status = gr.Textbox(label="Live Status", interactive=False)
+
+            start_btn.click(
+                start_optimization,
+                inputs=[
+                    input_image, csv_file,
+                    iterations_slider, learning_rate_slider,
+                    layer_height_slider, max_layers_slider,
+                    background_height_slider, background_color_textbox,
+                    output_size_slider, solver_size_slider,
+                    decay_slider, perform_gumbal_search_checkbox, perform_pruning_checkbox,
+                    save_interval_slider
+                ],
+                outputs=status_box
+            )
+            pause_btn.click(pause_optimization, outputs=status_box)
+            resume_btn.click(resume_optimization, outputs=status_box)
+            stop_btn.click(stop_optimization, outputs=status_box)
+
+            live_interface = gr.Interface(
+                fn=live_updates,
+                inputs=[],
+                outputs=[live_image, live_status],
+                live=True,
+                title="Live Optimization Updates"
+            )
+
+    with gr.Tab("Post-Processing"):
+        gr.Markdown("### Run Post-Processing Steps")
+        with gr.Row():
+            gumbal_btn = gr.Button("Run Gumbal Search")
+            pruning_btn = gr.Button("Run Pruning")
+        post_image = gr.Image(label="Post-Processed Composite")
+        post_status = gr.Textbox(label="Post-Processing Status", interactive=False)
+        gumbal_btn.click(run_gumbal_search_callback, inputs=[], outputs=[post_image, post_status])
+        pruning_btn.click(run_pruning_callback, inputs=[], outputs=[post_image, post_status])
+
+    with gr.Tab("Export Outputs"):
+        gr.Markdown("### Export Files")
+        export_btn = gr.Button("Export Outputs")
+        export_file = gr.File(label="Download Output (STL)")
+        export_btn.click(export_outputs_callback, inputs=[], outputs=export_file)
+
+demo.launch()

autoforge-1.1.3/src/autoforge/color_fit_bayesian.py

@@ -0,0 +1,225 @@
+import math
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+import optuna
+import multiprocessing
+
+# ===== Helper Functions: Color Conversion =====
+def hex_to_rgb(hex_str):
+    """Convert a hex color (e.g. "#d9e0e9") to an RGB numpy array (floats 0-255)."""
+    hex_str = hex_str.lstrip('#')
+    return np.array([int(hex_str[i:i+2], 16) for i in (0, 2, 4)], dtype=float)
+
+def rgb_to_hex(rgb):
+    """Convert an RGB numpy array (floats 0-255) to a hex color string."""
+    return '#' + ''.join(f'{int(round(x)):02X}' for x in rgb)
+
+# ---- sRGB <-> Linear conversion functions ----
+def srgb_to_linear(rgb):
+    """Convert an sRGB color (0-255) to linear space (0-1)."""
+    rgb = rgb / 255.0
+    linear = np.where(rgb <= 0.04045, rgb / 12.92, ((rgb + 0.055) / 1.055) ** 2.4)
+    return linear
+
+def linear_to_srgb(linear):
+    """Convert a linear color (0-1) to sRGB (0-255)."""
+    srgb = np.where(linear <= 0.0031308, linear * 12.92, 1.055 * (linear ** (1/2.4)) - 0.055)
+    srgb = np.clip(srgb, 0, 1)
+    return srgb * 255
+
+def model7(params, t, T):
+    A, k = params
+    if k < 1e-6:
+        return 0.0
+    return A * math.log(1 + k * (t / T)) / math.log(1 + k)
+
+def new_model4(params, t, T):
+    A, k, B = params
+    return A * math.log(1 + k*(t/T)) + B * (t/T)
+
+# ===== Dictionary of Extra Candidate Models =====
+extra_models = {
+    "New Model 4: Log-Linear": {
+        "func": new_model4,
+        "ranges": [(0.0, 1.0), (0.0, 100.0), (0.0, 1.0)],
+        "param_names": ["A", "k", "B"]
+    },
+}
+
+# ===== Loss Calculation =====
+def total_loss_for_model(model_func, params, df, layer_thickness, blending_mode="sRGB"):
+    loss = 0.0
+    for idx, row in df.iterrows():
+        T = float(row['Transmission Distance']) * 0.1
+        bg = hex_to_rgb(row['Background Material'])
+        fg = hex_to_rgb(row['Layer Material'])
+        for layer in range(1, 17):
+            t = layer * layer_thickness
+            alpha = model_func(params, t, T)
+            # Ensure alpha is within [0, 1]
+            if np.isscalar(alpha):
+                alpha = max(0.0, min(1.0, alpha))
+            else:
+                alpha = np.clip(alpha, 0.0, 1.0)
+            pred = bg + alpha * (fg - bg)
+            meas = hex_to_rgb(row[f"Layer {layer}"])
+            loss += np.sum((pred - meas) ** 2)
+    loss /= len(df) * 16
+    return loss, params
+
+# ===== Optuna Bayesian Optimization using Process-Based Parallelism =====
+def optuna_search_model_process(model_func, model_name, param_ranges, param_names, df,
+                                layer_thickness, total_trials, blending_mode="sRGB"):
+    print(f"Starting Optuna Bayesian Optimization (process-based) for {model_name} ({blending_mode}) ...")
+
+    # Define the objective function for Optuna
+    def objective(trial):
+        params = []
+        for i, name in enumerate(param_names):
+            low, high = param_ranges[i]
+            params.append(trial.suggest_float(name, low, high))
+        loss, _ = total_loss_for_model(model_func, params, df, layer_thickness, blending_mode)
+        return loss
+
+    # Create a study with a shared SQLite storage so multiple processes can add trials.
+    study = optuna.create_study(
+        direction="minimize",
+        study_name=model_name,
+        storage="sqlite:///{}.db".format(model_name.replace(" ", "_")),
+        load_if_exists=True,
+    )
+
+    # Determine the number of worker processes and how many trials each will run.
+    cpu_count = multiprocessing.cpu_count()
+    trials_per_worker = total_trials // cpu_count
+    print(f"Launching {cpu_count} processes, each with {trials_per_worker} trials.")
+
+    # Function for each process to run its share of trials.
+    def run_worker():
+        study.optimize(objective, n_trials=trials_per_worker, n_jobs=1)
+
+    # Launch the worker processes.
+    processes = []
+    for _ in range(cpu_count):
+        p = multiprocessing.Process(target=run_worker)
+        p.start()
+        processes.append(p)
+    for p in processes:
+        p.join()
+
+    best_params_dict = study.best_params
+    best_params = [best_params_dict[name] for name in param_names]
+    best_loss = study.best_value
+    print(f"Best Loss={best_loss:.2f} for {model_name} with params {best_params}")
+    return best_params, best_loss, study
+
+# ===== Worker Function for Model Search =====
+def run_search_for_model(task):
+    model_name, model_data, df, layer_thickness, total_trials, blending_mode = task
+    func = model_data["func"]
+    param_ranges = model_data["ranges"]
+    param_names = model_data["param_names"]
+    best_params, best_loss, study = optuna_search_model_process(
+        func, model_name, param_ranges, param_names,
+        df, layer_thickness, total_trials, blending_mode
+    )
+    return {
+        "model": model_name,
+        "blending_mode": blending_mode,
+        "best_params": best_params,
+        "best_loss": best_loss,
+        "param_names": param_names,
+        "func": func,
+        "study": study
+    }
+
+# ===== Main Function =====
+def main():
+    # Load CSV (adjust path as needed)
+    df = pd.read_csv("printed_colors.csv")
+    layer_thickness = 0.04  # mm per layer
+    blending_mode = "sRGB"  # using sRGB blending
+
+    # --- Phase 1: Process-Based Optuna Bayesian Optimization search for all models ---
+    total_trials = 5000  # Total trials per model (will be divided among processes)
+
+    results = []
+    for model_name, model_data in extra_models.items():
+        result = run_search_for_model((model_name, model_data, df, layer_thickness, total_trials, blending_mode))
+        results.append(result)
+
+    results.sort(key=lambda x: x["best_loss"])
+    print("\n=== Phase 1: Results (Optuna Process-Based Optimization) ===")
+    for res in results:
+        param_str = ", ".join(f"{name}={val:.4f}" for name, val in zip(res["param_names"], res["best_params"]))
+        print(f"{res['model']} ({res['blending_mode']}): Loss = {res['best_loss']:.2f} with {param_str}")
+
+    # --- Plot Sample Comparison for the Best Model (all CSV rows) ---
+    best_result = results[0]
+    func = best_result["func"]
+    best_params = best_result["best_params"]
+
+    # Optional: plot the model curve for new_model4 for a range of t values.
+    y = [new_model4(best_params, t/10, 1) for t in range(1, 11)]
+    x = list(range(1, 11))
+    plt.figure()
+    plt.plot(x, y, marker='o')
+    plt.title(f"{best_result['model']} Curve")
+    plt.xlabel("t/10")
+    plt.ylabel("Model Output")
+    plt.show()
+
+    n_csv = len(df)
+    # Create a figure with 2 rows per CSV row (measured and predicted) for the best model.
+    n_rows = 2 * n_csv
+    n_cols = 1
+
+    fig, axes = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=(8, 3 * n_csv))
+    fig.suptitle("Best Model: All CSV Rows\nMeasured (top row) vs. Predicted (bottom row)", fontsize=16)
+
+    for idx in range(n_csv):
+        row_data = df.iloc[idx]
+        T = float(row_data['Transmission Distance'])
+        bg = hex_to_rgb(row_data['Background Material'])
+        fg = hex_to_rgb(row_data['Layer Material'])
+        measured = [hex_to_rgb(row_data[f"Layer {layer}"]) for layer in range(1, 17)]
+        predicted = []
+        for layer in range(1, 17):
+            t = layer * layer_thickness
+            alpha = func(best_params, t, T)
+            if np.isscalar(alpha):
+                alpha = max(0.0, min(1.0, alpha))
+            else:
+                alpha = np.clip(alpha, 0.0, 1.0)
+            pred = bg + alpha * (fg - bg)
+            predicted.append(pred)
+
+        # Plot measured colors
+        ax_meas = axes[2*idx]
+        for j in range(16):
+            rect = Rectangle((j, 0), 1, 1, color=np.clip(measured[j] / 255, 0, 1))
+            ax_meas.add_patch(rect)
+        ax_meas.set_xlim(0, 16)
+        ax_meas.set_ylim(0, 1)
+        ax_meas.set_xticks([])
+        ax_meas.set_yticks([])
+        ax_meas.set_ylabel(f"Row {idx+1}\nMeasured", fontsize=10)
+
+        # Plot predicted colors
+        ax_pred = axes[2*idx + 1]
+        for j in range(16):
+            rect = Rectangle((j, 0), 1, 1, color=np.clip(predicted[j] / 255, 0, 1))
+            ax_pred.add_patch(rect)
+        ax_pred.set_xlim(0, 16)
+        ax_pred.set_ylim(0, 1)
+        ax_pred.set_xticks([])
+        ax_pred.set_yticks([])
+        ax_pred.set_ylabel(f"Row {idx+1}\nPredicted", fontsize=10)
+
+    plt.tight_layout(rect=[0, 0, 1, 0.95])
+    plt.show()
+
+if __name__ == '__main__':
+    main()

{autoforge-1.1.2 → autoforge-1.1.3}/src/autoforge/filamentcolors_library.py

@@ -80,7 +80,7 @@ def download_all_pages(url):
         tbar.update(1)
     return all_results
 
-def main():
+def download_filament_info():
     """
     Main function to manage the swatch data update process.
 
@@ -120,4 +120,4 @@ def main():
     save_local_version(api_version)
     print("Download complete, data saved to", DATA_FILE)
 if __name__ == "__main__":
-    main()
+    download_filament_info()

{autoforge-1.1.2 → autoforge-1.1.3}/src/autoforge/helper_functions.py

@@ -27,6 +27,50 @@ import numpy as np
 import struct
 
 
+def extract_colors_from_swatches(swatch_data):
+
+    # we keep only data with transmission distance
+    swatch_data = [swatch for swatch in swatch_data if swatch["td"]]
+
+    #For now we load it and convert it in the same way as the hueforge csv files
+    out = {}
+    for swatch in swatch_data:
+        brand = swatch["manufacturer"]["name"]
+        name = swatch["color_name"]
+        color = swatch["hex_color"]
+        td = swatch["td"]
+        out[(brand, name)] = (color, td)
+
+    #convert to the same format as the hueforge csv files
+    material_names = [brand + " - " + name for (brand, name) in out.keys()]
+    material_colors = jnp.array([hex_to_rgb("#"+color) for color, _ in out.values()], dtype=jnp.float64)
+    material_TDs = jnp.array([td for _, td in out.values()], dtype=jnp.float64)
+    colors_list = [color for color, _ in out.values()]
+
+    return material_colors, material_TDs, material_names, colors_list
+
+def swatch_data_to_table(swatch_data):
+    """
+    Converts swatch JSON data into a table (list of dicts) with columns:
+    "Brand", "Name", "Transmission Distance", "Hex Color".
+    """
+    table = []
+    for swatch in swatch_data:
+        if not swatch["td"]:
+            continue
+        brand = swatch["manufacturer"]["name"]
+        name = swatch["color_name"]
+        hex_color = swatch["hex_color"]
+        td = swatch["td"]
+        table.append({
+            "Brand": brand,
+            "Name": name,
+            "Transmission Distance": td,
+            "Hex Color": f"#{hex_color}"
+        })
+    return table
+
+
 def resize_image(img, max_size):
     h_img, w_img, _ = img.shape
     if w_img >= h_img: