Move max resolution to launch config

README.md

@@ -31,12 +31,18 @@ HEIC/HEIF uploads are decoded server-side with `pillow-heif`. If a browser canno
 
 ## Resolution controls
 
-The app defaults to a conservative `1,500,000` processing-pixel limit for Hugging Face CPU runners. Local users can raise this in the UI with **Max processing pixels**.
+The app defaults to a conservative `1,500,000` processing-pixel limit for Hugging Face CPU runners. This is intentionally not user-editable in the web UI, so hosted users cannot accidentally overload the Space.
+
+Local runners can raise the limit at launch:
+
+```bash
+python app.py --max-resolution-pixels 4000000
+```
 
 Environment variables are also available:
 
-- `DEFAULT_MAX_RESOLUTION` — default value shown in the UI.
-- `MAX_RESOLUTION_LIMIT` — upper clamp for the UI value.
+- `DEFAULT_MAX_RESOLUTION` — default launch value when no CLI flag is provided.
+- `MAX_RESOLUTION_LIMIT` — upper clamp for the CLI/env value.
 
 Example:
 

app.py

@@ -1,3 +1,4 @@
+import argparse
 import gradio as gr
 import json
 import os
@@ -24,9 +25,43 @@ except Exception as heif_error:  # pragma: no cover - surfaced in UI if HEIC ope
 else:
     HEIF_IMPORT_ERROR = None
 
+MIN_RESOLUTION_LIMIT = 10_000
 DEFAULT_MAX_RESOLUTION = int(os.getenv("DEFAULT_MAX_RESOLUTION", "1500000"))
 MAX_RESOLUTION_LIMIT = int(os.getenv("MAX_RESOLUTION_LIMIT", "20000000"))
-MIN_RESOLUTION_LIMIT = 10_000
+
+
+def parse_launch_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Image to 3D Relief Gradio app")
+    parser.add_argument(
+        "--max-resolution-pixels",
+        type=int,
+        default=None,
+        help=(
+            "Maximum number of pixels processed for depth estimation. "
+            "Default comes from DEFAULT_MAX_RESOLUTION or 1,500,000."
+        ),
+    )
+    parser.add_argument(
+        "--server-name",
+        default=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"),
+        help="Host/interface for Gradio to bind.",
+    )
+    parser.add_argument(
+        "--server-port",
+        type=int,
+        default=int(os.getenv("PORT", os.getenv("GRADIO_SERVER_PORT", "7860"))),
+        help="Port for Gradio to bind.",
+    )
+    args, _ = parser.parse_known_args()
+    return args
+
+
+LAUNCH_ARGS = parse_launch_args()
+REQUESTED_MAX_RESOLUTION = LAUNCH_ARGS.max_resolution_pixels or DEFAULT_MAX_RESOLUTION
+CONFIGURED_MAX_RESOLUTION = int(max(
+    MIN_RESOLUTION_LIMIT,
+    min(MAX_RESOLUTION_LIMIT, REQUESTED_MAX_RESOLUTION),
+))
 MODEL_ID = "depth-anything/Depth-Anything-V2-Large-hf"
 
 DEFAULT_TEXTURE_STRENGTH = 0.1
@@ -475,6 +510,20 @@ def sanitize_max_pixels(max_pixels: Any) -> int:
         requested = DEFAULT_MAX_RESOLUTION
     return int(clamp(requested, MIN_RESOLUTION_LIMIT, MAX_RESOLUTION_LIMIT))
 
+def coerce_float(value: Any, default: float) -> float:
+    try:
+        if value is None:
+            return float(default)
+        return float(value)
+    except (TypeError, ValueError):
+        return float(default)
+
+
+def coerce_z_bounds(min_z: Any, max_z: Any) -> tuple[float, float]:
+    min_z_value = coerce_float(min_z, DEFAULT_MIN_Z)
+    max_z_value = coerce_float(max_z, DEFAULT_MAX_Z)
+    return min_z_value, max_z_value
+
 def get_lanczos_resample_filter() -> int:
     return getattr(getattr(Image, "Resampling", Image), "LANCZOS")
 
@@ -622,8 +671,8 @@ def histogram_json(depth_map: np.ndarray, bins: int = 96) -> str:
     return json.dumps(counts.astype(int).tolist())
 
 
-def prepare_depth(input_filepath: str, max_processing_pixels: float):
-    input_image, load_status = load_and_resize_image(input_filepath, sanitize_max_pixels(max_processing_pixels))
+def prepare_depth(input_filepath: str):
+    input_image, load_status = load_and_resize_image(input_filepath, CONFIGURED_MAX_RESOLUTION)
     depth_normalized = estimate_depth_map(input_image)
     curve_json = curve_points_to_json(DEFAULT_CURVE_POINTS)
     adjusted_depth = apply_depth_curve(depth_normalized, curve_json, invert_depth=False)
@@ -680,6 +729,9 @@ def update_depth_preview(
     min_z: float,
     max_z: float,
 ):
+    min_z, max_z = coerce_z_bounds(min_z, max_z)
+    texture_strength = coerce_float(texture_strength, DEFAULT_TEXTURE_STRENGTH)
+    texture_smoothing = int(coerce_float(texture_smoothing, DEFAULT_TEXTURE_SMOOTHING))
     if max_z <= min_z:
         raise gr.Error("Max Z-height must be greater than Min Z-height.")
     smoothed_depth = get_smoothed_depth_from_state(depth_state, depth_map_smoothing)
@@ -754,6 +806,9 @@ def get_height_map_for_settings(
     min_z: float,
     max_z: float,
 ) -> np.ndarray:
+    min_z, max_z = coerce_z_bounds(min_z, max_z)
+    texture_strength = coerce_float(texture_strength, DEFAULT_TEXTURE_STRENGTH)
+    texture_smoothing = int(coerce_float(texture_smoothing, DEFAULT_TEXTURE_SMOOTHING))
     normalized_curve_json = curve_points_to_json(sanitize_curve_points(curve_points_json))
     cached_height_map = depth_state.get("height_map")
     cache_matches = (
@@ -792,8 +847,9 @@ def get_height_map_for_settings(
 
 
 def normalized_texture_strength(texture_strength: float, min_z: float, max_z: float) -> float:
-    z_span = max(float(max_z) - float(min_z), 1e-6)
-    return float(texture_strength) * (REFERENCE_TEXTURE_Z_SPAN / z_span)
+    min_z, max_z = coerce_z_bounds(min_z, max_z)
+    z_span = max(max_z - min_z, 1e-6)
+    return coerce_float(texture_strength, DEFAULT_TEXTURE_STRENGTH) * (REFERENCE_TEXTURE_Z_SPAN / z_span)
 
 
 def combine_depth_and_texture(
@@ -804,6 +860,7 @@ def combine_depth_and_texture(
     min_z: float,
     max_z: float,
 ) -> np.ndarray:
+    texture_smoothing = int(coerce_float(texture_smoothing, DEFAULT_TEXTURE_SMOOTHING))
     gray_image = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2GRAY)
     brightness_normalized = gray_image.astype(np.float32) / 255.0
     brightness_normalized = apply_smoothing(brightness_normalized, texture_smoothing)
@@ -847,7 +904,7 @@ def build_stl_mesh(z_data: np.ndarray, x_length: float, close_body: bool) -> str
     y_length = x_length * (height / width)
     vertices = np.zeros((height, width, 3), dtype=np.float32)
     x_coords = np.linspace(0, x_length, width, dtype=np.float32)
-    y_coords = np.linspace(y_length, 0, height, dtype=np.float32)
+    y_coords = np.linspace(0, y_length, height, dtype=np.float32)
     vertices[:, :, 0] = x_coords[np.newaxis, :]
     vertices[:, :, 1] = y_coords[:, np.newaxis]
     vertices[:, :, 2] = z_data.astype(np.float32)
@@ -856,7 +913,7 @@ def build_stl_mesh(z_data: np.ndarray, x_length: float, close_body: bool) -> str
     for i in range(height - 1):
         for j in range(width - 1):
             v1, v2, v3, v4 = vertices[i, j], vertices[i + 1, j], vertices[i + 1, j + 1], vertices[i, j + 1]
-            faces.extend([[v1, v2, v3], [v1, v3, v4]])
+            faces.extend([[v1, v3, v2], [v1, v4, v3]])
 
     if close_body:
         v_tl = vertices[0, 0]
@@ -873,7 +930,7 @@ def build_stl_mesh(z_data: np.ndarray, x_length: float, close_body: bool) -> str
             [v_br, b_br, b_bl], [v_br, b_bl, v_bl],
             [v_bl, b_bl, b_tl], [v_bl, b_tl, v_tl],
             [v_tr, b_tr, b_br], [v_tr, b_br, v_br],
-            [b_tl, b_br, b_bl], [b_tl, b_tr, b_br],
+            [b_tl, b_bl, b_br], [b_tl, b_br, b_tr],
         ])
 
     surface = mesh.Mesh(np.zeros(len(faces), dtype=mesh.Mesh.dtype))
@@ -897,6 +954,8 @@ def generate_3d_model_from_adjusted_depth(
     do_pca_correction: bool,
     close_body: bool,
 ):
+    min_z, max_z = coerce_z_bounds(min_z, max_z)
+    x_length = coerce_float(x_length, 100.0)
     if max_z <= min_z:
         raise gr.Error("Max Z-height must be greater than Min Z-height.")
     if x_length <= 0:
@@ -942,14 +1001,9 @@ with gr.Blocks(title="Image to 3D Relief Generator") as demo:
                 label="Upload image (PNG, JPG, WebP, TIFF, HEIC/HEIF)",
                 file_types=ACCEPTED_IMAGE_TYPES,
             )
-            max_processing_pixels = gr.Number(
-                value=DEFAULT_MAX_RESOLUTION,
-                label="Max processing pixels",
-                precision=0,
-                info=(
-                    "Default is conservative for Hugging Face CPU runners. "
-                    "Raise it locally for more detail; very high values can be slow or memory-intensive."
-                ),
+            gr.Markdown(
+                f"Processing limit: **{CONFIGURED_MAX_RESOLUTION:,} pixels**. "
+                "Local runners can change this with `--max-resolution-pixels`; hosted users cannot change it from the UI."
             )
             estimate_btn = gr.Button("Estimate Depth Map", variant="primary")
             analysis_status = gr.Textbox(label="Depth estimation status", lines=4, interactive=False)
@@ -1022,7 +1076,7 @@ with gr.Blocks(title="Image to 3D Relief Generator") as demo:
 
     estimate_btn.click(
         fn=prepare_depth,
-        inputs=[input_file, max_processing_pixels],
+        inputs=[input_file],
         outputs=[
             depth_state,
             original_preview,
@@ -1113,8 +1167,8 @@ with gr.Blocks(title="Image to 3D Relief Generator") as demo:
 
 if __name__ == "__main__":
     demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7860,
+        server_name=LAUNCH_ARGS.server_name,
+        server_port=LAUNCH_ARGS.server_port,
         theme="base",
         css=APP_CSS,
         head=CURVE_EDITOR_HEAD,