pyvcad-rendering 1.0.0__py3-none-any.whl

pyvcad_rendering/__init__.py

@@ -0,0 +1,2 @@
+from .render import *
+from .export import *

pyvcad_rendering/compiler_input_ui/__init__.py

@@ -0,0 +1,13 @@
+from .gcvf_inkjet_ui import GCVFInkjetPanel
+from .gcvf_inkjet_progress_ui import GCVFInkjetProgressPanel
+from .direct_material_inkjet_ui import DirectMaterialInkjetPanel
+from .direct_material_inkjet_progress_ui import DirectMaterialInkjetProgressPanel
+from .color_inkjet_ui import ColorInkjetPanel
+from .myerson_inkjet_ui import MyersonInkjetPanel
+from .myerson_inkjet_progress_ui import MyersonInkjetProgressPanel
+from .meshes_ui import MeshesPanel
+from .meshes_progress_ui import MeshesProgressPanel
+from .finite_element_mesh_ui import FiniteElementMeshPanel
+from .finite_element_mesh_progress_ui import FiniteElementMeshProgressPanel
+from .vat_photo_ui import VatPhotoPanel
+from .vat_photo_progress_ui import VatPhotoProgressPanel

pyvcad_rendering/compiler_input_ui/color_inkjet_ui.py

@@ -0,0 +1,9 @@
+import wx
+
+class ColorInkjetPanel(wx.Panel):
+    def __init__(self, parent):
+        super().__init__(parent)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(wx.StaticText(self, label="Color Inkjet (PNG Stack)"), 0, wx.ALL, 5)
+        self.SetSizer(sizer)
+

pyvcad_rendering/compiler_input_ui/direct_material_inkjet_progress_ui.py

@@ -0,0 +1,137 @@
+import wx
+import wx.lib.newevent
+import threading
+import time
+import os
+import subprocess
+import sys
+import numpy as np
+from wx.lib.newevent import NewEvent
+import pyvcad as pv
+import pyvcad_compilers as pvc
+
+# Custom event for progress updates
+UpdateProgressEvent, EVT_UPDATE_PROGRESS = NewEvent()
+
+class DirectMaterialCompilerWorker(threading.Thread):
+    def __init__(self, parent, root, voxel_size, material_defs, output_directory, file_prefix, liquid_keepout, liquid_keepout_distance):
+        super().__init__()
+        self.parent = parent
+        self.root = root
+        self.voxel_size = voxel_size
+        self.material_defs = material_defs
+        self.output_directory = output_directory
+        self.file_prefix = file_prefix
+        self.liquid_keepout = liquid_keepout
+        self.liquid_keepout_distance = liquid_keepout_distance
+        self._running = True
+
+    def run(self):
+        try:
+            voxel_size_vec3 = pv.Vec3(self.voxel_size[0], self.voxel_size[1], self.voxel_size[2])
+            compiler = pvc.DirectMaterialCompiler(
+                root=self.root,
+                voxel_size=voxel_size_vec3,
+                material_defs=self.material_defs,
+                output_directory=self.output_directory,
+                file_prefix=self.file_prefix,
+                liquid_keep_out=self.liquid_keepout,
+                liquid_keep_out_distance=self.liquid_keepout_distance
+            )
+
+            def progress_callback(progress):
+                if not self._running:
+                    # This is a simplistic way to stop; the compiler might not support interruption.
+                    raise Exception("Export cancelled")
+                evt = UpdateProgressEvent(progress=int(progress * 100), error=None, finished=False)
+                wx.PostEvent(self.parent, evt)
+
+            compiler.setProgressCallback(progress_callback)
+            compiler.compile()
+
+            if self._running:
+                evt = UpdateProgressEvent(progress=100, error=None, finished=True)
+                wx.PostEvent(self.parent, evt)
+
+        except Exception as e:
+            if self._running:
+                evt = UpdateProgressEvent(error=str(e), finished=True)
+                wx.PostEvent(self.parent, evt)
+
+    def stop(self):
+        self._running = False
+
+class DirectMaterialInkjetProgressPanel(wx.Panel):
+    def __init__(self, parent, export_options):
+        super().__init__(parent)
+        self.export_options = export_options
+        self.worker = None
+        self.start_time = None
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(wx.StaticText(self, label="Exporting PNG Stack..."), 0, wx.ALL, 5)
+
+        self.progress_bar = wx.Gauge(self, range=100, style=wx.GA_HORIZONTAL)
+        sizer.Add(self.progress_bar, 0, wx.ALL | wx.EXPAND, 5)
+
+        self.elapsed_time_label = wx.StaticText(self, label="Elapsed time: 00:00:00")
+        sizer.Add(self.elapsed_time_label, 0, wx.ALL, 5)
+
+        self.time_estimate_label = wx.StaticText(self, label="Estimated time remaining: N/A")
+        sizer.Add(self.time_estimate_label, 0, wx.ALL, 5)
+
+        self.SetSizer(sizer)
+
+        self.Bind(EVT_UPDATE_PROGRESS, self.on_update_progress)
+        self.update_timer = wx.Timer(self)
+        self.Bind(wx.EVT_TIMER, self.on_update_timer, self.update_timer)
+
+    def start_export(self):
+        self.start_time = time.time()
+        self.update_timer.Start(1000)
+
+        voxel_size_mm = self.export_options['voxel_size'] / 1000.0
+
+        self.worker = DirectMaterialCompilerWorker(
+            self,
+            self.export_options['root'],
+            np.array([voxel_size_mm[0], voxel_size_mm[1], voxel_size_mm[2]]),
+            self.export_options['materials'],
+            self.export_options['output_directory'],
+            self.export_options['file_prefix'],
+            self.export_options['liquid_keepout'],
+            self.export_options['liquid_keepout_distance']
+        )
+        self.worker.start()
+
+    def on_update_progress(self, event):
+        if event.error:
+            self.update_timer.Stop()
+            wx.MessageBox(f"An error occurred during export: {event.error}", "Error", wx.OK | wx.ICON_ERROR)
+            self.GetParent().GetParent().FindWindowByLabel("Back").Enable(True)
+        elif event.finished:
+            self.update_timer.Stop()
+            self.progress_bar.SetValue(100)
+            elapsed_seconds = time.time() - self.start_time
+            elapsed_time_str = time.strftime('%H:%M:%S', time.gmtime(elapsed_seconds))
+            self.elapsed_time_label.SetLabel(f"Elapsed time: {elapsed_time_str}")
+
+            main_frame = self.GetTopLevelParent()
+            main_frame.on_export_complete(self.export_options['output_directory'], elapsed_time_str)
+        else:
+            self.progress_bar.SetValue(event.progress)
+
+    def on_update_timer(self, event):
+        elapsed_seconds = time.time() - self.start_time
+        self.elapsed_time_label.SetLabel(f"Elapsed time: {time.strftime('%H:%M:%S', time.gmtime(elapsed_seconds))}")
+
+        progress = self.progress_bar.GetValue()
+        if progress > 0:
+            remaining_seconds = (elapsed_seconds * (100 - progress)) / progress
+            self.time_estimate_label.SetLabel(f"Estimated time remaining: {time.strftime('%H:%M:%S', time.gmtime(remaining_seconds))}")
+
+    def __del__(self):
+        if self.worker and self.worker.is_alive():
+            self.worker.stop()
+            self.worker.join()
+        self.update_timer.Stop()

pyvcad_rendering/compiler_input_ui/direct_material_inkjet_ui.py

@@ -0,0 +1,112 @@
+import wx
+import numpy as np
+
+class DirectMaterialInkjetPanel(wx.Panel):
+    def __init__(self, parent, root, materials):
+        super().__init__(parent)
+        self.root = root
+        self.materials = materials
+
+        min_bounds, max_bounds = self.root.bounding_box()
+        self.min_bounds = np.array([min_bounds.x, min_bounds.y, min_bounds.z])
+        self.max_bounds = np.array([max_bounds.x, max_bounds.y, max_bounds.z])
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        # Path
+        path_label = wx.StaticText(self, label="Path:")
+        sizer.Add(path_label, 0, wx.ALL, 5)
+
+        path_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.path_ctrl = wx.TextCtrl(self)
+        path_sizer.Add(self.path_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        browse_btn = wx.Button(self, label="Browse")
+        browse_btn.Bind(wx.EVT_BUTTON, self.on_browse)
+        path_sizer.Add(browse_btn, 0, wx.ALL, 5)
+        sizer.Add(path_sizer, 0, wx.EXPAND)
+
+        # Filename
+        filename_label = wx.StaticText(self, label="Filename:")
+        sizer.Add(filename_label, 0, wx.ALL, 5)
+
+        filename_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.filename_ctrl = wx.TextCtrl(self)
+        filename_sizer.Add(self.filename_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        extension_label = wx.StaticText(self, label="XX.png")
+        filename_sizer.Add(extension_label, 0, wx.ALL, 5)
+        sizer.Add(filename_sizer, 0, wx.EXPAND)
+
+        # Liquid Keepout
+        self.liquid_keepout_check = wx.CheckBox(self, label="Enable Liquid Keepout")
+        self.liquid_keepout_check.Bind(wx.EVT_CHECKBOX, self.on_toggle_keepout)
+        sizer.Add(self.liquid_keepout_check, 0, wx.ALL, 5)
+
+        self.keepout_distance_ctrl = wx.SpinCtrlDouble(self, min=0.0, max=100.0, inc=0.1)
+        self.keepout_distance_ctrl.SetValue(0.0)
+        self.keepout_distance_ctrl.Enable(False)
+        sizer.Add(self.keepout_distance_ctrl, 0, wx.ALL | wx.EXPAND, 5)
+
+        # Voxel Size
+        voxel_size_label = wx.StaticText(self, label="Voxel Size (XYZ) in microns:")
+        sizer.Add(voxel_size_label, 0, wx.ALL, 5)
+
+        voxel_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.voxel_size_x = wx.SpinCtrlDouble(self, min=1.0, max=100000.0, initial=42.3)
+        self.voxel_size_y = wx.SpinCtrlDouble(self, min=1.0, max=100000.0, initial=84.6)
+        self.voxel_size_z = wx.SpinCtrlDouble(self, min=1.0, max=100000.0, initial=27.0)
+        voxel_sizer.Add(self.voxel_size_x, 1, wx.EXPAND | wx.ALL, 5)
+        voxel_sizer.Add(self.voxel_size_y, 1, wx.EXPAND | wx.ALL, 5)
+        voxel_sizer.Add(self.voxel_size_z, 1, wx.EXPAND | wx.ALL, 5)
+        sizer.Add(voxel_sizer, 0, wx.EXPAND)
+
+        for ctrl in [self.voxel_size_x, self.voxel_size_y, self.voxel_size_z]:
+            ctrl.Bind(wx.EVT_SPINCTRLDOUBLE, self.on_voxel_size_change)
+
+        # Sampling Info
+        self.sampling_info_label = wx.StaticText(self, label="")
+        self.update_sampling_info()
+        sizer.Add(self.sampling_info_label, 0, wx.ALL, 5)
+
+        self.SetSizer(sizer)
+
+    def on_browse(self, event):
+        with wx.DirDialog(self, "Choose a directory:",
+                           style=wx.DD_DEFAULT_STYLE) as dirDialog:
+            if dirDialog.ShowModal() == wx.ID_CANCEL:
+                return
+            self.path_ctrl.SetValue(dirDialog.GetPath())
+
+    def on_toggle_keepout(self, event):
+        self.keepout_distance_ctrl.Enable(event.IsChecked())
+
+    def on_voxel_size_change(self, event):
+        self.update_sampling_info()
+
+    def update_sampling_info(self):
+        size = self.max_bounds - self.min_bounds
+        voxel_size_mm = np.array([
+            self.voxel_size_x.GetValue() / 1000.0,
+            self.voxel_size_y.GetValue() / 1000.0,
+            self.voxel_size_z.GetValue() / 1000.0
+        ])
+
+        total_voxels = (size[0] / voxel_size_mm[0]) * (size[1] / voxel_size_mm[1]) * (size[2] / voxel_size_mm[2])
+
+        sampling_info = (f"Sample Space Size: {size[0]:.2f} x {size[1]:.2f} x {size[2]:.2f} mm\n"
+                         f"Total Voxels: {total_voxels:,.0f}")
+        self.sampling_info_label.SetLabel(sampling_info)
+
+    def get_export_options(self):
+        return {
+            "output_directory": self.path_ctrl.GetValue(),
+            "file_prefix": self.filename_ctrl.GetValue(),
+            "liquid_keepout": self.liquid_keepout_check.IsChecked(),
+            "liquid_keepout_distance": self.keepout_distance_ctrl.GetValue(),
+            "voxel_size": np.array([
+                self.voxel_size_x.GetValue(),
+                self.voxel_size_y.GetValue(),
+                self.voxel_size_z.GetValue()
+            ]),
+            "root": self.root,
+            "materials": self.materials
+        }

pyvcad_rendering/compiler_input_ui/finite_element_mesh_progress_ui.py

@@ -0,0 +1,101 @@
+import wx
+import wx.lib.newevent
+import threading
+import time
+import os
+import subprocess
+import sys
+import numpy as np
+from wx.lib.newevent import NewEvent
+
+# Custom event for progress updates
+UpdateProgressEvent, EVT_UPDATE_PROGRESS = NewEvent()
+
+class FiniteElementMeshCompilerWorker(threading.Thread):
+    def __init__(self, parent, export_options):
+        super().__init__()
+        self.parent = parent
+        self.export_options = export_options
+        self._running = True
+
+    def run(self):
+        try:
+            # This is where you would call the actual compiler
+            # For now, we simulate the progress
+            for i in range(101):
+                if not self._running:
+                    break
+                time.sleep(0.05)
+                evt = UpdateProgressEvent(progress=i, error=None, finished=(i == 100))
+                wx.PostEvent(self.parent, evt)
+        except Exception as e:
+            evt = UpdateProgressEvent(error=str(e), finished=True)
+            wx.PostEvent(self.parent, evt)
+
+    def stop(self):
+        self._running = False
+
+class FiniteElementMeshProgressPanel(wx.Panel):
+    def __init__(self, parent, export_options):
+        super().__init__(parent)
+        self.export_options = export_options
+        self.worker = None
+        self.start_time = None
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(wx.StaticText(self, label="Exporting INP File..."), 0, wx.ALL, 5)
+
+        self.progress_bar = wx.Gauge(self, range=100, style=wx.GA_HORIZONTAL)
+        sizer.Add(self.progress_bar, 0, wx.ALL | wx.EXPAND, 5)
+
+        self.elapsed_time_label = wx.StaticText(self, label="Elapsed time: 00:00:00")
+        sizer.Add(self.elapsed_time_label, 0, wx.ALL, 5)
+
+        self.time_estimate_label = wx.StaticText(self, label="Estimated time remaining: N/A")
+        sizer.Add(self.time_estimate_label, 0, wx.ALL, 5)
+
+        self.SetSizer(sizer)
+
+        self.Bind(EVT_UPDATE_PROGRESS, self.on_update_progress)
+        self.update_timer = wx.Timer(self)
+        self.Bind(wx.EVT_TIMER, self.on_update_timer, self.update_timer)
+
+    def start_export(self):
+        self.start_time = time.time()
+        self.update_timer.Start(1000)
+
+        self.worker = FiniteElementMeshCompilerWorker(self, self.export_options)
+        self.worker.start()
+
+    def on_update_progress(self, event):
+        if event.error:
+            self.update_timer.Stop()
+            wx.MessageBox(f"An error occurred during export: {event.error}", "Error", wx.OK | wx.ICON_ERROR)
+            self.GetParent().GetParent().FindWindowByLabel("Back").Enable(True)
+        elif event.finished:
+            self.update_timer.Stop()
+            self.progress_bar.SetValue(100)
+            elapsed_seconds = time.time() - self.start_time
+            elapsed_time_str = time.strftime('%H:%M:%S', time.gmtime(elapsed_seconds))
+            self.elapsed_time_label.SetLabel(f"Elapsed time: {elapsed_time_str}")
+
+            main_frame = self.GetTopLevelParent()
+            main_frame.on_export_complete(self.export_options['file_path'], elapsed_time_str)
+        else:
+            self.progress_bar.SetValue(event.progress)
+
+    def on_update_timer(self, event):
+        elapsed_seconds = time.time() - self.start_time
+        self.elapsed_time_label.SetLabel(f"Elapsed time: {time.strftime('%H:%M:%S', time.gmtime(elapsed_seconds))}")
+
+        progress = self.progress_bar.GetValue()
+        if progress > 0:
+            remaining_seconds = (elapsed_seconds * (100 - progress)) / progress
+            self.time_estimate_label.SetLabel(f"Estimated time remaining: {time.strftime('%H:%M:%S', time.gmtime(remaining_seconds))}")
+
+    def __del__(self):
+        if self.worker and self.worker.is_alive():
+            self.worker.stop()
+            self.worker.join()
+        self.update_timer.Stop()
+

pyvcad_rendering/compiler_input_ui/finite_element_mesh_ui.py

@@ -0,0 +1,230 @@
+import wx
+import numpy as np
+
+class FiniteElementMeshPanel(wx.Panel):
+    def __init__(self, parent, root, materials):
+        super().__init__(parent)
+        self.root = root
+        self.materials = materials
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        # Path
+        path_label = wx.StaticText(self, label="Path:")
+        sizer.Add(path_label, 0, wx.ALL, 5)
+
+        path_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.path_ctrl = wx.TextCtrl(self)
+        path_sizer.Add(self.path_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        browse_btn = wx.Button(self, label="Browse")
+        browse_btn.Bind(wx.EVT_BUTTON, self.on_browse)
+        path_sizer.Add(browse_btn, 0, wx.ALL, 5)
+        sizer.Add(path_sizer, 0, wx.EXPAND)
+
+        # Element Type
+        element_type_label = wx.StaticText(self, label="Element Type:")
+        sizer.Add(element_type_label, 0, wx.ALL, 5)
+        self.element_type_combo = wx.ComboBox(self, choices=["Tetrahedron (C3D4)", "Brick (C3D8)"], style=wx.CB_READONLY)
+        self.element_type_combo.SetSelection(0)
+        self.element_type_combo.Bind(wx.EVT_COMBOBOX, self.on_element_type_change)
+        sizer.Add(self.element_type_combo, 0, wx.ALL | wx.EXPAND, 5)
+
+        # Brick Options
+        self.brick_group_box = wx.StaticBox(self, label="Brick Element (C3D8) Options")
+        self.brick_group_box.Hide()
+        brick_sizer = wx.StaticBoxSizer(self.brick_group_box, wx.VERTICAL)
+
+        brick_grid = wx.GridSizer(2, 3, 5, 5)
+        brick_grid.Add(wx.StaticText(self.brick_group_box, label="X Cells:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        brick_grid.Add(wx.StaticText(self.brick_group_box, label="Y Cells:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        brick_grid.Add(wx.StaticText(self.brick_group_box, label="Z Cells:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        self.x_dim_ctrl = wx.TextCtrl(self.brick_group_box)
+        self.y_dim_ctrl = wx.TextCtrl(self.brick_group_box)
+        self.z_dim_ctrl = wx.TextCtrl(self.brick_group_box)
+        brick_grid.Add(self.x_dim_ctrl, 1, wx.EXPAND)
+        brick_grid.Add(self.y_dim_ctrl, 1, wx.EXPAND)
+        brick_grid.Add(self.z_dim_ctrl, 1, wx.EXPAND)
+        brick_sizer.Add(brick_grid, 0, wx.EXPAND | wx.ALL, 5)
+
+        self.num_elements_label = wx.StaticText(self.brick_group_box, label="Number of Elements: 0")
+        brick_sizer.Add(self.num_elements_label, 0, wx.ALL, 5)
+
+        self.use_volumetric_dither_check = wx.CheckBox(self.brick_group_box, label="Use Volumetric Dither")
+        brick_sizer.Add(self.use_volumetric_dither_check, 0, wx.ALL, 5)
+
+        for ctrl in [self.x_dim_ctrl, self.y_dim_ctrl, self.z_dim_ctrl]:
+            ctrl.Bind(wx.EVT_TEXT, self.on_brick_dim_change)
+
+        sizer.Add(brick_sizer, 0, wx.EXPAND | wx.ALL, 5)
+
+        # Tetrahedral Options
+        self.tetra_group_box = wx.StaticBox(self, label="Tetrahedron Element (C3D4) Options")
+        tetra_sizer = wx.StaticBoxSizer(self.tetra_group_box, wx.VERTICAL)
+
+        # Voxel Size
+        voxel_size_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        voxel_size_sizer.Add(wx.StaticText(self.tetra_group_box, label="Sample Size (mm):"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.voxel_size_ctrl = wx.SpinCtrlDouble(self.tetra_group_box, min=0.000001, max=100.0, initial=0.1, inc=0.000001)
+        self.voxel_size_ctrl.SetDigits(6)
+        voxel_size_sizer.Add(self.voxel_size_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        auto_compute_btn = wx.Button(self.tetra_group_box, label="Auto-compute")
+        auto_compute_btn.Bind(wx.EVT_BUTTON, self.on_auto_compute)
+        voxel_size_sizer.Add(auto_compute_btn, 0, wx.ALL, 5)
+        tetra_sizer.Add(voxel_size_sizer, 0, wx.EXPAND)
+
+        # Variable Mesh Size
+        self.use_variable_mesh_check = wx.CheckBox(self.tetra_group_box, label="Use Gradient-based Variable Mesh Size")
+        self.use_variable_mesh_check.Bind(wx.EVT_CHECKBOX, self.on_toggle_variable_mesh)
+        tetra_sizer.Add(self.use_variable_mesh_check, 0, wx.ALL, 5)
+
+        # Cell Size (non-variable)
+        self.cell_size_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.cell_size_sizer.Add(wx.StaticText(self.tetra_group_box, label="Cell Size:"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.cell_size_ctrl = wx.SpinCtrlDouble(self.tetra_group_box, min=0.000001, max=100.0, initial=0.1, inc=0.000001)
+        self.cell_size_ctrl.SetDigits(6)
+        self.cell_size_sizer.Add(self.cell_size_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        tetra_sizer.Add(self.cell_size_sizer, 0, wx.EXPAND)
+
+        # Variable Mesh Options
+        self.variable_mesh_group = wx.StaticBox(self.tetra_group_box, label="Variable Mesh Size Options")
+        self.variable_mesh_group.Hide()
+        variable_mesh_sizer = wx.StaticBoxSizer(self.variable_mesh_group, wx.VERTICAL)
+
+        min_cell_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        min_cell_sizer.Add(wx.StaticText(self.variable_mesh_group, label="Minimum Cell Size:"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.min_cell_size_ctrl = wx.SpinCtrlDouble(self.variable_mesh_group, min=0.000001, max=100.0, inc=0.000001)
+        self.min_cell_size_ctrl.SetDigits(6)
+        min_cell_sizer.Add(self.min_cell_size_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        variable_mesh_sizer.Add(min_cell_sizer, 0, wx.EXPAND)
+
+        max_cell_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        max_cell_sizer.Add(wx.StaticText(self.variable_mesh_group, label="Maximum Cell Size:"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.max_cell_size_ctrl = wx.SpinCtrlDouble(self.variable_mesh_group, min=0.000001, max=100.0, inc=0.000001)
+        self.max_cell_size_ctrl.SetDigits(6)
+        max_cell_sizer.Add(self.max_cell_size_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        variable_mesh_sizer.Add(max_cell_sizer, 0, wx.EXPAND)
+
+        variable_mesh_sizer.Add(wx.StaticText(self.variable_mesh_group, label="Cell Size Mapping Expression:"), 0, wx.ALL, 5)
+        self.variable_cell_size_expr_ctrl = wx.TextCtrl(self.variable_mesh_group, style=wx.TE_MULTILINE)
+        self.variable_cell_size_expr_ctrl.SetValue("min_cell + h * (max_cell - min_cell)")
+        variable_mesh_sizer.Add(self.variable_cell_size_expr_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        tetra_sizer.Add(variable_mesh_sizer, 0, wx.EXPAND | wx.ALL, 5)
+
+        # Facet Angle
+        facet_angle_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        facet_angle_sizer.Add(wx.StaticText(self.tetra_group_box, label="Facet Angle (deg):"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.facet_angle_slider = wx.Slider(self.tetra_group_box, value=30, minValue=0, maxValue=90)
+        self.facet_angle_label = wx.StaticText(self.tetra_group_box, label="30")
+        self.facet_angle_slider.Bind(wx.EVT_SLIDER, lambda evt: self.facet_angle_label.SetLabel(str(self.facet_angle_slider.GetValue())))
+        facet_angle_sizer.Add(self.facet_angle_slider, 1, wx.EXPAND | wx.ALL, 5)
+        facet_angle_sizer.Add(self.facet_angle_label, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        tetra_sizer.Add(facet_angle_sizer, 0, wx.EXPAND)
+
+        # Facet Size
+        facet_size_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        facet_size_sizer.Add(wx.StaticText(self.tetra_group_box, label="Facet Size (mm):"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.facet_size_ctrl = wx.SpinCtrlDouble(self.tetra_group_box, min=0.000001, max=100.0, inc=0.000001)
+        self.facet_size_ctrl.SetDigits(6)
+        facet_size_sizer.Add(self.facet_size_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        tetra_sizer.Add(facet_size_sizer, 0, wx.EXPAND)
+
+        # Facet Distance
+        facet_dist_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        facet_dist_sizer.Add(wx.StaticText(self.tetra_group_box, label="Facet Distance (mm):"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.facet_dist_ctrl = wx.SpinCtrlDouble(self.tetra_group_box, min=0.000001, max=100.0, inc=0.000001)
+        self.facet_dist_ctrl.SetDigits(6)
+        facet_dist_sizer.Add(self.facet_dist_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        tetra_sizer.Add(facet_dist_sizer, 0, wx.EXPAND)
+
+        # Cell Radius/Edge Ratio
+        cell_ratio_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        cell_ratio_sizer.Add(wx.StaticText(self.tetra_group_box, label="Cell Radius/Edge Ratio:"), 1, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
+        self.cell_ratio_ctrl = wx.SpinCtrl(self.tetra_group_box, min=1, max=10, initial=2)
+        cell_ratio_sizer.Add(self.cell_ratio_ctrl, 1, wx.EXPAND | wx.ALL, 5)
+        tetra_sizer.Add(cell_ratio_sizer, 0, wx.EXPAND)
+
+        sizer.Add(tetra_sizer, 0, wx.EXPAND | wx.ALL, 5)
+
+        self.on_auto_compute(None)
+        self.SetSizerAndFit(sizer)
+
+    def on_browse(self, event):
+        with wx.FileDialog(self, "Save INP File", wildcard="INP files (*.inp)|*.inp",
+                           style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog:
+            if fileDialog.ShowModal() == wx.ID_CANCEL:
+                return
+            pathname = fileDialog.GetPath()
+            if not pathname.lower().endswith(".inp"):
+                pathname += ".inp"
+            self.path_ctrl.SetValue(pathname)
+
+    def on_element_type_change(self, event):
+        is_tetra = self.element_type_combo.GetSelection() == 0
+        self.tetra_group_box.Show(is_tetra)
+        self.brick_group_box.Show(not is_tetra)
+        self.GetParent().Layout()
+
+    def on_brick_dim_change(self, event):
+        try:
+            x = int(self.x_dim_ctrl.GetValue())
+            y = int(self.y_dim_ctrl.GetValue())
+            z = int(self.z_dim_ctrl.GetValue())
+            self.num_elements_label.SetLabel(f"Number of Elements: {x*y*z:,.0f}")
+        except ValueError:
+            self.num_elements_label.SetLabel("Number of Elements: Invalid Input")
+
+    def on_toggle_variable_mesh(self, event):
+        use_variable = self.use_variable_mesh_check.IsChecked()
+        self.variable_mesh_group.Show(use_variable)
+        self.cell_size_sizer.Show(not use_variable)
+        self.GetParent().Layout()
+
+    def on_auto_compute(self, event):
+        if event: # Only show message box on button click
+            reply = wx.MessageBox("This will overwrite the current values. Are you sure you want to continue?", "Overwrite Values?", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
+            if reply == wx.NO:
+                return
+
+        voxel_size = self.voxel_size_ctrl.GetValue()
+        self.voxel_size_ctrl.SetIncrement(voxel_size / 10.0)
+
+        self.facet_size_ctrl.SetValue(voxel_size)
+        self.facet_size_ctrl.SetIncrement(voxel_size / 10.0)
+
+        self.facet_dist_ctrl.SetValue(voxel_size / 10.0)
+        self.facet_dist_ctrl.SetIncrement(voxel_size / 100.0)
+
+        self.cell_size_ctrl.SetValue(voxel_size)
+        self.cell_size_ctrl.SetIncrement(voxel_size / 10.0)
+
+        self.min_cell_size_ctrl.SetValue(voxel_size)
+        self.min_cell_size_ctrl.SetIncrement(voxel_size / 20.0)
+
+        self.max_cell_size_ctrl.SetValue(voxel_size * 10)
+        self.max_cell_size_ctrl.SetIncrement(voxel_size / 20.0)
+
+    def get_export_options(self):
+        options = {"file_path": self.path_ctrl.GetValue()}
+        if self.element_type_combo.GetSelection() == 0: # Tetra
+            options.update({
+                "element_type": "tetra",
+                "voxel_size": self.voxel_size_ctrl.GetValue(),
+                "facet_angle": self.facet_angle_slider.GetValue(),
+                "facet_size": self.facet_size_ctrl.GetValue(),
+                "facet_distance": self.facet_dist_ctrl.GetValue(),
+                "cell_radius_edge_ratio": self.cell_ratio_ctrl.GetValue(),
+                "use_variable_mesh_size": self.use_variable_mesh_check.IsChecked(),
+                "cell_size": self.cell_size_ctrl.GetValue(),
+                "min_cell_size": self.min_cell_size_ctrl.GetValue(),
+                "max_cell_size": self.max_cell_size_ctrl.GetValue(),
+                "variable_cell_size_expression": self.variable_cell_size_expr_ctrl.GetValue(),
+            })
+        else: # Brick
+            options.update({
+                "element_type": "brick",
+                "x_dim": int(self.x_dim_ctrl.GetValue()),
+                "y_dim": int(self.y_dim_ctrl.GetValue()),
+                "z_dim": int(self.z_dim_ctrl.GetValue()),
+                "use_volumetric_dither": self.use_volumetric_dither_check.IsChecked(),
+            })
+        return options