tomotree
  • TomoTree package description
  • Quick Start Guide
    • Loading a measurement
    • Basic usage
      • Initialize tomogram with sensor positions and velocity data
      • Perform ERSM reconstruction and estimate sound wood speed
    • Wall thickness measurement
      • Measure wall thickness between sensor pairs
  • EBSI and ERSM Reconstruction Algorithms
    • Input and Notation
    • EBSI (Ellipse-Based Spatial Interpolation)
      • Pseudocode
      • Implementation Notes
    • ERSM (Extended Ray Segmentation Method)
      • Pseudocode
      • Implementation Notes
    • Practical Comparison
  • Technical background: how the analyses are built
    • Architecture in three layers
      • Request flow
      • Adding or changing a page
      • The tomogram is shared between pages
      • Data loading
    • The core: Tomo object
    • Tomograph
      • Rays method, EBSI method, ERSM method
      • Speed calibration
    • Postprocessing
      • Binary Tomo
      • Photo assessment
      • Area selection tool
      • Tomogram measurement tool
      • Background
      • Dividing line
      • Angle plots
    • Scan tools
      • Sensor position
      • Cross section
      • Cross section mechanical analysis
      • 3D scan tools
    • Resistograph
      • Resistograph mean & std
      • Resistograph
      • Define drilling paths
      • Res & Tomo
    • Data & Info & Share
    • Premium pages
  • Installation Guide
    • Prerequisites (all methods)
    • Method 1 — Conda / Mamba
      • 1. Create and activate a new environment
      • 2. Install core dependencies via Conda
      • 3. Install pip-only extras
      • 4. Install the TomoTree package
      • 5. Verify
    • Method 2 — pip
      • Option A — Install directly from GitHub (no clone needed)
      • Option B — Install from a local clone
        • 1. Create and activate a virtual environment
        • 2. Install all dependencies and the package
        • 3. Verify
    • Method 3 — Jupyter / Colab
      • Advantages
      • Limitations
    • Method 4 — Docker
      • Connecting with VS Code Dev Containers
    • Post-Installation Configuration (GUI only)
      • Short path
      • 1. Main configuration file
      • 2. User credentials file
      • 3. Google OAuth Authentication (Optional)
        • a. Create Google OAuth credentials
        • b. Configure Streamlit secrets
        • c. Enable Google OAuth in config
        • d. Result
      • 3b. Logto.io Authentication (Optional)
        • a. Create a logto application
        • b. Configure Streamlit secrets
        • c. Enable logto.io in config
        • d. Result
      • 3c. Other OIDC providers (Optional)
        • Settings at the provider
        • Troubleshooting OIDC login
      • 4. Groq AI Integration (Optional)
      • 5. Required directories
    • Running the Application (GUI only)
      • Streamlit web UI
    • Running the Test Suite
  • TomoTree Web Application — User Guide
    • Overview
    • Login and Registration
    • Home Screen and Data Source
      • Preloaded Data
      • User Data
      • Upload Temporary Data
      • Shared Data
    • Where Your Data Are Stored
      • Storage areas
      • Layout of a dataset
      • Uploading files
      • Tomograph files
      • Older datasets (all files in the root)
      • Other data kept on the server
    • Sidebar Controls
      • Dataset Info & Sources
      • Reconstruction and Plot Settings
    • Tomography Reconstruction
      • Reconstruction Methods
      • Reconstruction Methods
      • Reading the colours
      • Select Rays
      • Speed Calibration
    • Postprocessing
      • Binary Tomo
      • Photo Assessment
      • Area Selection Tool
      • Tomogram Measurement Tool
      • Background
      • Dividing Line
      • Angle Plots
    • Resistance Drilling
      • Viewing Raw Curves
      • Mean and Standard Deviation
      • Define Drilling Paths
      • Resistograph & Tomogram Overlay
    • 3D Scans
      • Sensor Position
      • Cross Section
    • Data Sources
  • Tomotree class reference guide
    • Tomotree module
    • Cell
      • Cell.grid
      • Cell.id
      • Cell.velocity
      • Cell.velocity_no_boundary
      • Cell.status
      • Cell.rays
      • Cell.boundary_points
      • Cell.boundary_points
      • Cell.dx
      • Cell.dy
      • Cell.rays
      • Cell.status
      • Cell.velocity
      • Cell.velocity_no_boundary
      • Cell.x
      • Cell.y
    • Grid
      • Grid.x
      • Grid.y
      • Grid.velocity
      • Grid.velocity_no_boundary
      • Grid.status
      • Grid.all_cells
      • Grid.min_velocity
      • Grid.max_velocity
      • Grid.cell_centers()
      • Grid.cells_boundary_points()
      • Grid.get_cell()
      • Grid.max_velocity
      • Grid.min_velocity
      • Grid.plot()
      • Grid.plot_optimalized()
      • Grid.set_cell_status_from_threshold()
      • Grid.set_cell_velocity_from_ray_means()
    • Node
      • Node.coordinates
      • Node.raw_coordinates
      • Node.rays_from
      • Node.rays_to
      • Node.number
      • Node.get_ray_to
      • Node.active
    • Ray
      • Ray.start
      • Ray.end
      • Ray.speed
      • Ray.time
      • Ray.segments
      • Ray.angle_from_radial
      • Ray.signed_angle_from_radial
      • Ray.length
      • Ray.ori_time
      • Ray.ori_speed
    • Tomo
      • Tomo.nodes
      • Tomo.rays
      • Tomo.tangential_rays
      • Tomo.speeds
      • Tomo.times
      • Tomo.get_node_by_number
      • Tomo.n
      • Tomo.grid
      • Tomo.polygon
      • Tomo.get_node_by_number
      • Tomo.info
      • Tomo.pith
      • Tomo.data_source
      • Tomo.boundary
      • Tomo.allsegments
      • Tomo.cells_velocity_statistics()
      • Tomo.check_triangle_inequality()
      • Tomo.compute_inside_mask()
      • Tomo.correct_with_FBP()
      • Tomo.do_EBSI_method()
      • Tomo.do_ERSM_method()
      • Tomo.do_FBP_method()
      • Tomo.do_Rays_method()
      • Tomo.do_SIRT_method()
      • Tomo.estimate_sound_wood_speed()
      • Tomo.fix_velocity_EBSI()
      • Tomo.get_ray()
      • Tomo.limit_cell_plot_velocities()
      • Tomo.optimize_back()
      • Tomo.optimize_back_tomogram()
      • Tomo.ori_speeds
      • Tomo.ori_times
      • Tomo.plot()
      • Tomo.plot_angular_dependence()
      • Tomo.plot_bokeh()
      • Tomo.plot_plotly()
      • Tomo.plot_sinogram()
      • Tomo.ray_segments()
      • Tomo.ray_time()
      • Tomo.ray_time_comparison()
      • Tomo.speeds
      • Tomo.speeds_at_angles_3Dplot()
      • Tomo.speeds_at_angles_table()
      • Tomo.tangential_rays
      • Tomo.times
      • Tomo.update_segments_from_cells()
      • Tomo.velocities_on_ray()
    • get_boundary_points()
    • is_point_inside_ellipse()
    • perp()
    • speed2color()
    • Node
      • Node.coordinates
      • Node.raw_coordinates
      • Node.rays_from
      • Node.rays_to
      • Node.number
      • Node.get_ray_to
      • Node.active
    • Ray
      • Ray.start
      • Ray.end
      • Ray.speed
      • Ray.time
      • Ray.segments
      • Ray.angle_from_radial
      • Ray.signed_angle_from_radial
      • Ray.length
      • Ray.ori_time
      • Ray.ori_speed
    • Segment
      • Segment.ray
      • Segment.speed
      • Segment.start
      • Segment.end
      • Segment.start_coordinates
      • Segment.end_coordinates
      • Segment.length
      • Segment.length
      • Segment.split()
    • Cell
      • Cell.grid
      • Cell.id
      • Cell.velocity
      • Cell.velocity_no_boundary
      • Cell.status
      • Cell.rays
      • Cell.boundary_points
      • Cell.boundary_points
      • Cell.dx
      • Cell.dy
      • Cell.rays
      • Cell.status
      • Cell.velocity
      • Cell.velocity_no_boundary
      • Cell.x
      • Cell.y
    • Grid
      • Grid.x
      • Grid.y
      • Grid.velocity
      • Grid.velocity_no_boundary
      • Grid.status
      • Grid.all_cells
      • Grid.min_velocity
      • Grid.max_velocity
      • Grid.cell_centers()
      • Grid.cells_boundary_points()
      • Grid.get_cell()
      • Grid.max_velocity
      • Grid.min_velocity
      • Grid.plot()
      • Grid.plot_optimalized()
      • Grid.set_cell_status_from_threshold()
      • Grid.set_cell_velocity_from_ray_means()
    • Reconstruction implementation
      • _TomoReconstructionMixin
        • _TomoReconstructionMixin.correct_with_FBP()
        • _TomoReconstructionMixin.do_EBSI_method()
        • _TomoReconstructionMixin.do_ERSM_method()
        • _TomoReconstructionMixin.do_FBP_method()
        • _TomoReconstructionMixin.do_Rays_method()
        • _TomoReconstructionMixin.do_SIRT_method()
        • _TomoReconstructionMixin.fix_velocity_EBSI()
  • Resistograph class reference guide
    • DrillingPath
      • DrillingPath.angle
      • DrillingPath.data
      • DrillingPath.end
      • DrillingPath.file
      • DrillingPath.name
      • DrillingPath.start
    • Resistograph
      • Resistograph.data
      • Resistograph.directory
      • Resistograph.drilling_paths
      • Resistograph.get_data()
      • Resistograph.nan_lower_limit
      • Resistograph.nan_upper_limit
      • Resistograph.polyorder
      • Resistograph.preprocess_data()
      • Resistograph.read_resistograph_data()
      • Resistograph.remove_global_linear_trend()
      • Resistograph.set_min_treshold
      • Resistograph.smooth
      • Resistograph.window_length
    • add_resistograph_graphs()
    • add_resistograph_to_image()
    • auto_drilling_paths()
    • plot_rolling_mean_std()
    • plot_savgol_mean_std()
    • set_drilling_paths()
  • Dividing line (cracks and cavities)
    • crossing_rays()
    • plot_line()
    • plot_scan()
    • scan_split_lines()
    • split_halves()
    • split_lines()
    • split_metrics()
    • split_tomogram()
  • f3d library reference guide
    • df_nodes()
    • distance_matrix()
    • extract_distance_data()
    • extract_time_data()
    • get_root()
    • get_xml_root()
    • parse_layer()
  • Launching the GUI — Using app.py.dist
    • Quick Start
      • 1. Copy the template
      • 2. Set up configuration files
      • 3. Run the application
    • What app.py.dist Contains
      • Logging
      • Config() — application settings
      • Google OAuth Authentication
      • Relationship between app.py and config/config.yaml
    • Running Without app.py.dist
    • Launching the GUI via Docker
      • Connecting with VS Code
      • Useful Docker commands
    • Changes to Watch for When Updating
  • Administrator Guide — Building and Deploying TomoTree
    • Table of Contents
    • Prerequisites
    • Bumping the Version
    • Building and Publishing the Python Package
      • Publish to GitHub (recommended)
      • Publish to PyPI
        • 1. Build the distribution archives
        • 2. Upload to PyPI
        • 3. Upload to TestPyPI first (optional)
    • Building and Pushing the Docker Image
      • 1. Build the images
      • 2. Tag for Docker Hub
      • 3. Push to Docker Hub
    • Updating a Production Server
      • Typical deployment directory layout
      • compose.yml on the server
      • Running as your user (not root)
      • Pulling the latest image and restarting
      • Converting datasets to the current format
      • Checking the running container
      • Rolling back to a previous version
    • Configuration Files on the Server
      • Editing in the admin console
      • Signed saved states
      • Temporary uploads
      • Installation check
      • Whitelist and Blacklist
      • Account expiry
    • Cleaning Up Old Docker Images and Files
      • Remove dangling images (untagged leftovers)
      • Remove all unused images (including older tagged versions)
      • Remove stopped containers, unused networks, dangling images, and build cache at once
      • Remove a specific old image by tag
      • Typical post-upgrade cleanup sequence
      • Check disk usage before and after
  • Configuration file config.yaml
    • Location
    • Input data
      • Node positions
      • Created from a tomograph file
      • Measurements
      • Data sources (sources, active)
    • Units
    • Access control
    • Grid resolution
    • Velocity colour scale
      • Scale type
      • Bounds — numerical (m/s)
      • Bounds — percentage of reference value
      • Bounds — percentile
    • Tomogram appearance
    • Reconstruction parameters
    • Subset of nodes
    • Disabled rays
    • Sound-wood speed
    • Background photo
    • 3D scan
    • Resistograph settings
    • Dividing line
    • Publication metadata (metadata)
    • Navigation / landing page
    • Minimal example
  • Google OAuth Setup Guide
    • Requirements
    • Step 1: Create a Google Cloud Project
      • 1a. Go to Google Cloud Console
      • 1b. Create a new project
      • 1c. No API needs to be enabled
    • Step 2: Create OAuth 2.0 Credentials
      • 2a. Create OAuth 2.0 Credentials
      • 2b. Create the OAuth 2.0 Client ID
      • 2c. Add Authorized Redirect URIs
      • 2d. Publish the app (switch from Testing to Production)
      • 2e. Save your credentials
    • Step 3: Configure Streamlit Secrets
      • 3a. Create or edit ~/.streamlit/secrets.toml
      • 3b. Add your Google OAuth credentials
      • 3c. Save the file
    • Step 4: Alternative — Project-level secrets file
    • Step 5: Update TomoTree Configuration
      • 5a. Copy configuration template
      • 5b. Enable Google OAuth in config/config.yaml
      • 5c. Define role mappings (optional)
    • Step 6: Run TomoTree
      • 6a. Start the application
      • 6b. Test the login
      • 6c. Assign roles (if needed)
    • Troubleshooting
      • Issue: Google is not offered on the login screen, or a Google user is logged out at once
      • Issue: Redirect URI mismatch error
      • Issue: Credentials not found
      • Issue: Login works but no roles are assigned
      • Issue: Login is refused: e-mail address not verified
      • Issue: Role does not take effect after updating config
      • Issue: After logout the user is still logged in at Google
    • Security Best Practices
    • Docker Deployment
    • Further Reading
  • Publishing datasets on Zenodo
    • Metadata
    • Zenodo connector
    • The package (one ZIP per tree)
      • How the package follows FAIR
    • Metadata in config.yaml
    • In Python
    • Server settings (config/config.yaml)
  • Internationalization (i18n) & Localization (l10n) Guide
    • Table of Contents
    • 1. Architecture overview
    • 2. Directory layout
    • 3. How it works at runtime
      • Initialization
      • Translation look-up
      • Plural forms
    • 4. Marking strings for translation in Python code
      • Import the function
      • Basic usage
      • Variable interpolation — use .format(), not f-strings
      • Multiline strings
      • Loop variable clash
    • 5. Extracting new strings to the template (.pot)
      • Automated extraction with make (recommended)
      • Manual extraction (fallback)
    • 6. Updating existing language files (.po)
      • .po file structure
      • Adding a new string to an existing language
    • 7. Adding a brand-new language
      • Step 1 — Create the directory & PO file
      • Step 2 — Register the language in __init__.py
      • Step 3 — Register the language in po_to_json.py
      • Step 4 — Generate the JSON file
      • Step 5 — Verify
    • 8. Compiling translations (.po → .json)
    • 9. Currently supported languages
    • 10. Common pitfalls
tomotree
  • Search


© Copyright 2025, Valentino Cristini, Robert Mařík.

Built with Sphinx using a theme provided by Read the Docs.