Upload app.py

app.py

@@ -88,23 +88,49 @@ def process_dem(dem_file):
         # Try to read the file directly to diagnose format issues
         try:
             with open(dem_file, 'r') as f:
-                first_lines = [next(f) for _ in range(10) if _ < 10]
-            print("First 10 lines of the DEM file:")
-            for line in first_lines:
-                print(line.strip())
+                header_lines = []
+                for i in range(6):  # ESRI ASCII files should have 6 header lines
+                    try:
+                        line = next(f).strip()
+                        header_lines.append(line)
+                        print(f"Header line {i+1}: {line}")
+                    except StopIteration:
+                        print(f"File too short, only {i} header lines")
+                        break
+                
+                # Check if the header looks correct
+                has_valid_header = (
+                    len(header_lines) >= 6 and
+                    header_lines[0].lower().startswith('ncols') and
+                    header_lines[1].lower().startswith('nrows') and
+                    header_lines[2].lower().startswith('xll') and
+                    header_lines[3].lower().startswith('yll') and
+                    header_lines[4].lower().startswith('cell') and
+                    header_lines[5].lower().startswith('nodata')
+                )
+                
+                if has_valid_header:
+                    print("File has valid ESRI ASCII header format")
+                else:
+                    print("File doesn't have valid ESRI ASCII header format")
+                
+                # Read a few data lines
+                data_lines = []
+                for i in range(4):  # Read 4 data lines
+                    try:
+                        line = next(f).strip()
+                        data_lines.append(line)
+                        print(f"Data line {i+1}: {line}")
+                    except StopIteration:
+                        break
         except Exception as file_read_e:
             print(f"Warning: Could not read the file directly: {file_read_e}")
+            has_valid_header = False
         
         # Read the DEM file with landlab
         try:
             print(f"Attempting to read file with landlab.io.read_esri_ascii: {dem_file}")
-            # Debug each line of the file to see what might be wrong
-            with open(dem_file, 'r') as f:
-                lines = f.readlines()
-                for i, line in enumerate(lines[:10]):
-                    print(f"Line {i+1}: {line.strip()}")
-                    
-            # Try to read with landlab
+            
             try:
                 (grid, elevation) = read_esri_ascii(dem_file)
                 print(f"Successfully read DEM file with grid shape: {grid.shape}")
@@ -112,34 +138,84 @@ def process_dem(dem_file):
             except Exception as e:
                 print(f"Error with read_esri_ascii: {e}")
                 
-                # Try a different approach if the header is invalid
+                # If there's no valid header or read_esri_ascii failed, try manual parsing
+                if not has_valid_header:
+                    raise ValueError("Invalid ESRI ASCII header")
+                    
+                # Try a different approach if the header is invalid but seems to be in the right format
                 try:
                     print("Trying to parse ASCII grid manually...")
                     header = {}
-                    with open(dem_file, 'r') as f:
-                        # Parse header
-                        header['ncols'] = int(f.readline().split()[1])
-                        header['nrows'] = int(f.readline().split()[1])
-                        header['xllcorner'] = float(f.readline().split()[1])
-                        header['yllcorner'] = float(f.readline().split()[1])
-                        header['cellsize'] = float(f.readline().split()[1])
-                        header['nodata_value'] = float(f.readline().split()[1])
+                    
+                    # Parse header from our previously read header lines
+                    if len(header_lines) >= 6:
+                        try:
+                            header['ncols'] = int(header_lines[0].split()[1])
+                            header['nrows'] = int(header_lines[1].split()[1])
+                            header['xllcorner'] = float(header_lines[2].split()[1])
+                            header['yllcorner'] = float(header_lines[3].split()[1])
+                            header['cellsize'] = float(header_lines[4].split()[1])
+                            header['nodata_value'] = float(header_lines[5].split()[1])
+                        except (IndexError, ValueError) as parse_error:
+                            print(f"Error parsing header lines: {parse_error}")
+                            raise ValueError("Invalid header values")
+                    else:
+                        # If we don't have header lines, try to reopen the file
+                        with open(dem_file, 'r') as f:
+                            header['ncols'] = int(f.readline().split()[1])
+                            header['nrows'] = int(f.readline().split()[1])
+                            header['xllcorner'] = float(f.readline().split()[1])
+                            header['yllcorner'] = float(f.readline().split()[1])
+                            header['cellsize'] = float(f.readline().split()[1])
+                            header['nodata_value'] = float(f.readline().split()[1])
+                    
+                    # Validate the header values make sense
+                    if header['ncols'] <= 0 or header['nrows'] <= 0 or header['cellsize'] <= 0:
+                        raise ValueError("Invalid header values (negative or zero dimensions)")
+                    
+                    if header['ncols'] > 10000 or header['nrows'] > 10000:
+                        raise ValueError("Grid too large, dimensions exceed 10000")
                         
-                        # Create empty grid
-                        mg = RasterModelGrid((header['nrows'], header['ncols']), header['cellsize'])
+                    print(f"Header parsed: ncols={header['ncols']}, nrows={header['nrows']}, cellsize={header['cellsize']}")
+                    
+                    # Create empty grid
+                    mg = RasterModelGrid((header['nrows'], header['ncols']), header['cellsize'])
+                    
+                    # Read elevation data
+                    with open(dem_file, 'r') as f:
+                        # Skip header lines
+                        for i in range(6):
+                            f.readline()
                         
-                        # Read elevation data
-                        elevation = []
+                        # Read all data lines
+                        data = []
                         for line in f:
-                            elevation.extend([float(val) for val in line.split()])
-                            
-                        # Set elevation field
-                        mg.add_field("topographic__elevation", np.array(elevation), at="node")
+                            data.extend([float(val) for val in line.split()])
+                    
+                    # Check if we have the right amount of data
+                    expected_data_points = header['nrows'] * header['ncols']
+                    if len(data) != expected_data_points:
+                        print(f"Warning: Data length mismatch. Expected {expected_data_points}, got {len(data)}")
                         
-                        print(f"Successfully parsed ASCII grid manually. Grid shape: {mg.shape}")
-                        return mg
+                        # Fill or truncate if needed
+                        if len(data) < expected_data_points:
+                            nodata = header['nodata_value']
+                            data.extend([nodata] * (expected_data_points - len(data)))
+                            print(f"Extended data with {expected_data_points - len(data)} nodata values")
+                        else:
+                            data = data[:expected_data_points]
+                            print(f"Truncated data to {expected_data_points} values")
+                    
+                    # Set elevation field
+                    mg.add_field("topographic__elevation", np.array(data), at="node")
+                    
+                    print(f"Successfully parsed ASCII grid manually. Grid shape: {mg.shape}")
+                    return mg
                 except Exception as manual_e:
+                    import traceback
                     print(f"Error with manual parsing: {manual_e}")
+                    print(traceback.format_exc())
+                    print("Falling back to default grid")
                     return setup_basic_grid("dome")
                 
         except Exception as inner_e:
@@ -645,6 +721,49 @@ with demo:
                             return f"Error: File not found at {file_path}"
                             
                         try:
+                            # Check if file appears to be an ESRI ASCII Grid
+                            file_size = os.path.getsize(file_path)
+                            if file_size == 0:
+                                return "Error: File is empty"
+                                
+                            # Check first few lines to validate format
+                            with open(file_path, 'r') as f:
+                                try:
+                                    # Check header lines
+                                    header_valid = True
+                                    expected_headers = ["ncols", "nrows", "xll", "yll", "cell", "nodata"]
+                                    
+                                    for i, expected in enumerate(expected_headers):
+                                        try:
+                                            line = f.readline().strip().lower()
+                                            if not line.startswith(expected):
+                                                header_valid = False
+                                                return f"Error: Invalid ESRI ASCII file format. Expected '{expected}' in line {i+1}, but got: '{line}'"
+                                        except Exception:
+                                            header_valid = False
+                                            return f"Error: File too short, missing required header line {i+1}"
+                                    
+                                    # Try to parse a few data lines
+                                    data_lines_valid = True
+                                    for i in range(3):  # Check first 3 data lines
+                                        try:
+                                            line = f.readline().strip()
+                                            # Check if line contains valid numbers
+                                            try:
+                                                [float(val) for val in line.split()]
+                                            except ValueError:
+                                                data_lines_valid = False
+                                                return f"Error: Line {i+7} contains non-numeric data: '{line}'"
+                                        except Exception:
+                                            if i == 0:  # Must have at least one data line
+                                                return "Error: File contains header but no data lines"
+                                            break
+                                            
+                                except UnicodeDecodeError:
+                                    return "Error: File is not a valid text file. Please upload an ASCII file."
+                                except Exception as e:
+                                    print(f"Warning during file validation: {str(e)}")
+                            
                             # Copy file to temp directory
                             filename = os.path.basename(file_path)
                             temp_path = os.path.join(TEMP_DIR, filename)
@@ -662,10 +781,13 @@ with demo:
                                 
                             # Store path globally
                             saved_dem_path = temp_path
-                            file_size = os.path.getsize(temp_path) / (1024*1024)
+                            file_size_mb = file_size / (1024*1024)
                             
-                            return f"File processed and ready: {filename} ({file_size:.2f} MB)"
+                            return f"File processed and ready: {filename} ({file_size_mb:.2f} MB)"
                         except Exception as e:
+                            import traceback
+                            print(f"Error processing file: {str(e)}")
+                            print(traceback.format_exc())
                             return f"Error processing file: {str(e)}"
                     
                     # Connect file upload button
@@ -856,8 +978,9 @@ with demo:
                             print(f"Warning - Copy error (but continuing anyway): {str(copy_error)}")
                     else:
                         print(f"File does not exist at path: {dem_data}")
-                        progress_text.update("Error: Uploaded file not found")
-                        return [None] * 8
+                        error_msg = "Error: Uploaded file not found"
+                        progress_text.update(error_msg)
+                        return [None] * 8 + [error_msg]
                 else:
                     print("No file provided directly. Checking temp directory for ASC files...")
                     
@@ -875,7 +998,8 @@ with demo:
                         dem_data = None
             
             # Run the landscape evolution simulation
-            progress_text.update("Starting simulation. This may take several minutes...")
+            progress_msg = "Starting simulation. This may take several minutes..."
+            progress_text.update(progress_msg)
             
             try:
                 outputs = run_landscape_evolution(
@@ -891,21 +1015,27 @@ with demo:
                     save_animation=save_animation.value
                 )
                 
-                progress_text.update("Simulation completed successfully!")
-                return outputs
+                success_msg = "Simulation completed successfully!"
+                progress_text.update(success_msg)
+                
+                # Return the visualization outputs plus the status message
+                return list(outputs) + [success_msg]
+                
             except Exception as sim_error:
                 import traceback
-                print(f"Error in simulation: {str(sim_error)}")
+                error_msg = f"Error in simulation: {str(sim_error)}"
+                print(error_msg)
                 print(traceback.format_exc())
-                progress_text.update(f"Error in simulation: {str(sim_error)}")
-                return [None] * 8
+                progress_text.update(error_msg)
+                return [None] * 8 + [error_msg]
                 
         except Exception as e:
             import traceback
-            print(f"Error setting up simulation: {str(e)}")
+            error_msg = f"Error setting up simulation: {str(e)}"
+            print(error_msg)
             print(traceback.format_exc())
-            progress_text.update(f"Error setting up simulation: {str(e)}")
-            return [None] * 8  # Return None for all outputs
+            progress_text.update(error_msg)
+            return [None] * 8 + [error_msg]
     
     # Connect the run button to the simulation function using Gradio 5.24.0 syntax
     run_btn.click(
@@ -996,84 +1126,4 @@ with demo:
 
 # Launch the interface
 if __name__ == "__main__":
-    # Create basic event handlers for the buttons
-    
-    # Simplified handler for simulation button - guaranteed to work
-    def simple_run_simulation():
-        try:
-            progress_text_val = "Starting simulation..."
-            
-            if saved_dem_path and os.path.exists(saved_dem_path):
-                print(f"Running simulation with file: {saved_dem_path}")
-                outputs = run_landscape_evolution(
-                    dem_file=saved_dem_path,
-                    grid_type=grid_type.value,
-                    grid_rows=grid_rows.value,
-                    grid_cols=grid_cols.value,
-                    grid_resolution=grid_resolution.value,
-                    simulation_steps=simulation_steps.value,
-                    rainfall_rate=rainfall_rate.value,
-                    erosion_rate=erosion_rate.value,
-                    diffusion_rate=diffusion_rate.value,
-                    save_animation=save_animation.value
-                )
-                progress_text_val = "Simulation completed successfully!"
-            else:
-                print("Using terrain generator (no DEM file)")
-                outputs = run_landscape_evolution(
-                    dem_file=None,
-                    grid_type=grid_type.value,
-                    grid_rows=grid_rows.value,
-                    grid_cols=grid_cols.value,
-                    grid_resolution=grid_resolution.value,
-                    simulation_steps=simulation_steps.value,
-                    rainfall_rate=rainfall_rate.value,
-                    erosion_rate=erosion_rate.value,
-                    diffusion_rate=diffusion_rate.value,
-                    save_animation=save_animation.value
-                )
-                progress_text_val = "Simulation completed successfully!"
-                
-            # Add progress text to outputs
-            return outputs + (progress_text_val,)
-            
-        except Exception as e:
-            import traceback
-            error_msg = f"Error in simulation: {str(e)}"
-            print(error_msg)
-            print(traceback.format_exc())
-            # Return None for all visual outputs plus the error message
-            return [None] * 8 + (error_msg,)
-    
-    # Simplified handler for debug button - guaranteed to work
-    def simple_debug():
-        if saved_dem_path:
-            return f"Saved DEM path: {saved_dem_path} (exists: {os.path.exists(saved_dem_path)})"
-        else:
-            temp_files = os.listdir(TEMP_DIR)
-            asc_files = [f for f in temp_files if f.endswith(".asc")]
-            return f"No saved DEM. Files in temp dir: {asc_files}"
-    
-    # Override the button handlers with simpler versions
-    run_btn.click(
-        fn=simple_run_simulation,
-        inputs=None,
-        outputs=[
-            initial_topo, 
-            final_topo, 
-            diff_topo,
-            flow_acc,
-            topo_3d,
-            evolution_animation,
-            report,
-            final_dem
-        ]
-    )
-    
-    debug_btn.click(
-        fn=simple_debug,
-        inputs=None,
-        outputs=progress_text
-    )
-    
     demo.launch()