diff --git a/.github/workflows/website.yaml b/.github/workflows/website.yaml index 8445c997..93d34c02 100644 --- a/.github/workflows/website.yaml +++ b/.github/workflows/website.yaml @@ -33,12 +33,18 @@ jobs: - name: Setup Node uses: actions/setup-node@v4 with: - node-version: 18 + node-version: 24 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" - name: Setup Pages uses: actions/configure-pages@v3 - name: Install dependencies working-directory: docs/vitepress run: npm ci + - name: Update blogs + working-directory: docs/vitepress + run: python update_blogs.py - name: Build with VitePress working-directory: docs/vitepress run: | @@ -67,4 +73,4 @@ jobs: steps: - name: Deploy to GitHub Pages id: deployment - uses: actions/deploy-pages@v4 \ No newline at end of file + uses: actions/deploy-pages@v4 diff --git a/docs/vitepress/.vitepress/config.mjs b/docs/vitepress/.vitepress/config.mjs index 003b339e..604007ff 100644 --- a/docs/vitepress/.vitepress/config.mjs +++ b/docs/vitepress/.vitepress/config.mjs @@ -1,5 +1,7 @@ import { defineConfig } from "vitepress"; +import blogs from "./blogs.json"; + // https://vitepress.dev/reference/site-config export default defineConfig({ base: "/trame", @@ -72,6 +74,7 @@ export default defineConfig({ { text: "Home", link: "/" }, { text: "News", link: "/news" }, { text: "Guide", link: "/guide/" }, + { text: "Blogs", link: "/blogs/" }, { text: "Examples", link: "/examples/" }, { text: "Resources", @@ -179,8 +182,8 @@ export default defineConfig({ // { text: 'Asynchronous ParaView', link: 'https://github.com/Kitware/async-paraview-app' }, // { text: 'PFB Viewer', link: 'https://github.com/Kitware/pfb-viewer' }, // { text: 'ParFlow Simulation Modeler', link: 'https://github.com/Kitware/pf-simulation-modeler' }, - { text: '3D Slicer', link: '/examples/apps/trame-slicer' }, - { text: 'Community', link: '/examples/apps/community' }, + { text: "3D Slicer", link: "/examples/apps/trame-slicer" }, + { text: "Community", link: "/examples/apps/community" }, ], }, { @@ -206,6 +209,7 @@ export default defineConfig({ ], }, ], + "/blogs/": blogs, }, socialLinks: [{ icon: "github", link: "https://github.com/kitware/trame" }], diff --git a/docs/vitepress/blogs/a-framework-for-next-generation-visual-workflows-in-scientific-computing.md b/docs/vitepress/blogs/a-framework-for-next-generation-visual-workflows-in-scientific-computing.md new file mode 100644 index 00000000..04a64dcb --- /dev/null +++ b/docs/vitepress/blogs/a-framework-for-next-generation-visual-workflows-in-scientific-computing.md @@ -0,0 +1,346 @@ +[post](https://www.kitware.com/a-framework-for-next-generation-visual-workflows-in-scientific-computing/) + +# A Framework for Next-Generation Visual Workflows in Scientific Computing + +December 4, 2025 + +[Berk Geveci](https://www.kitware.com/author/berk-geveci/ "Posts by Berk Geveci"), [Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary"), [Cory Quammen](https://www.kitware.com/author/cory-quammen/ "Posts by Cory Quammen"), [Bob O'Bara](https://www.kitware.com/author/bob-obara/ "Posts by Bob O'Bara") and [David Thompson](https://www.kitware.com/author/david-thompson/ "Posts by David Thompson") + +![Screenshots of several scientific visualizations and simulations.](https://www.kitware.com/main/wp-content/uploads/2025/12/SC25-Blog-Feature.jpg) + +The 21st century has witnessed remarkable advances in computational and experimental sciences, with processing power expanding from terascale to exascale—a million-fold increase in capability—and experimental devices achieving unprecedented scales of data collection. Visualization technologies have kept pace, as modern GPUs now enable the analysis and rendering of complex datasets that were once out of reach. At the same time, artificial intelligence has disruptively reshaped research by not only augmenting existing methods but also transforming the problems we can address and the ways we solve them. Scientific and engineering work now depends on the integration of experiments, large-scale computation, and AI, involving diverse participants from domain experts to decision-makers. Yet, traditional tools such as documents, charts, spreadsheets, and static visualizations are no longer sufficient to support collaboration. + +Visual workflows address this gap by providing interactive, domain-aware environments that make complex pipelines understandable and actionable. They democratize access to AI, simulations, and experiments by lowering technical barriers, enabling the transfer of expertise by providing both specialists and non-specialists with productive entry points, and enhancing analysis and communication by allowing users to interrogate results dynamically and present them clearly to diverse audiences. Interactive visual workflows enable activities such as AI/experiment/simulation-to-insight exploration, AI-assisted validation, automated report generation, and migration of traditional desktop tools into collaborative web applications. Their visual nature allows users to see and then manipulate the workflow process, not just the experimental or simulation data. By making processes transparent, adaptive, and inclusive, visual workflows shorten iteration cycles, accelerate discovery, and empower all participants to contribute insights directly. + +The next generation of research and design will rely on such interactive visual workflows, which, by extending powerful tools beyond computational specialists to entire collaborative communities, can unlock new levels of innovation and discovery. + +## Visualization as a Tool for Accessibility and Insight + +Visualization is fundamental to interactive visual workflows because it transforms raw data into forms the human eye and brain can quickly grasp. Numbers in files or static tables cannot match the speed and clarity of visual analysis, where patterns, anomalies, and structures often emerge only through inspection. By working visually, scientists, engineers, and researchers expand cognitive bandwidth, accelerate understanding, and foster collaboration. Well-designed visualizations make insights accessible to both experts and non-experts, creating a shared ground for decision-making. + +## Challenges + +Modern research and engineering workflows are difficult to manage. They involve massive datasets that must be cleaned, wrangled, streamed, and stored at scale. They span many stages—from simulation and experiment setup to AI-driven analysis and visualization—and depend on diverse tools that rarely interoperate smoothly. Each step adds layers of complexity, from managing workflow attributes and assets to ensuring data integrity and reproducibility. While the AI, simulation, or experiment may complete in only weeks on 21st-century computational platforms, the resulting data can be so large that analysis and visualization are constrained to a read-once, derive-once workflow, in which each dataset is read only once to produce a reduced or derived product. Even under this limited approach, the process can take many months and may spill into the next computational allocation cycle.. This delay becomes a major barrier, slowing iteration and extending the time-to-discovery. The central challenge is not the absence of capable tools, but the difficulty of integrating them into coherent workflows that support collaboration, efficiency, and timely insight. + +| Challenge | Value Proposition | +| --- | --- | +| **Democratization of Advanced Capabilities** | | +| Powerful AI, simulation, experiment, analysis, and visualization tools remain concentrated in the hands of specialists, leaving non-experts dependent on intermediaries and slowing collaborative progress. | Democratizing advanced capabilities empowers all participants in a workflow to contribute to insights directly, fostering inclusive collaboration and innovation. | +| **Seamless Transfer of Expertise** | | +| The flow of expertise between developers of AI, simulations, and experiments and their end users is slow and inefficient. Specialists become bottlenecks, and tools are often either too simple or too complex. | Interactive visual workflows that speed expertise transfer and provide customizable, domain-specific environments allow experts and non-experts to engage productively without unnecessary complexity. | +| **Insightful Analysis and Communication** | | +| Traditional tools for analysis and visualization are too rigid or too general. Researchers need to explore results dynamically, while stakeholders need clear and compelling views. | Interactive visual workflows accelerate discovery and facilitate the communication of insights across diverse audiences, enabling more informed and collaborative decision-making. | +| **Shortening Time-to-Discovery** | | +| Complex workflows and fragmented tools often result in lengthy delays between data generation and actionable insights. While simulations, experiments, or AI runs may finish in only weeks, the analysis and visualization of their results can take months. | Integrated, interactive visual workflows shorten the path from raw data to understanding. By reducing months of post-processing into immediate, adaptive visual exploration, they enable faster prototyping, validation, and decision-making. | + +## Toward a Next Generation Platform + +Over the past two decades, the visualization community has developed systems capable of interactively handling vast datasets. Tools such as ParaView exemplify these capabilities, but they remain monolithic and best suited for experts. What is needed now is a flexible platform that spans various use cases, encompassing desktop, Jupyter, and web environments while lowering development effort. + +The urgency is apparent. Today, scientists, engineers, and researchers can complete an extensive simulation, experiment, or AI campaign in a matter of weeks on advanced computational platforms. Yet, the analysis and visualization of the resulting data can still exceed computational allocation boundaries, delaying discovery and slowing innovation. This gap between data generation and actionable insight is now one of the most pressing barriers in scientific and engineering practice. + +The answer lies in a modular platform. This platform must build on decades of investment in frameworks like VTK and ParaView while adopting modern interface technologies. It should support workflows ranging from physics-based AI to combined experiment–simulation pipelines, end-to-end simulations, and cross-disciplinary analytics. By addressing the challenges of democratization, expertise transfer, communication, and time-to-discovery, this platform can collapse months of post-processing into interactive visual workflows that deliver insight at the pace of computation. + +At Kitware, we have been developing components for this platform while transforming our existing frameworks to support the future of visual workflows. The core is written in C++ (with CUDA, HIP, and SYCL) for optimal performance, and Python is used as the integration language to reduce barriers to entry while maintaining flexibility and speed. On top of this foundation, we employ trame, our visual workflow integration framework, which allows developers to build components, combine them into complex workflows, and deliver them seamlessly on desktops, in Jupyter notebooks, or on the web. Backed by HPC resources such as cloud or supercomputers, these workflows reduce the cycle from months to days. + +## Core Components + +### Run-Everywhere Front-End + +Modern workflows demand applications that run seamlessly across desktops, Jupyter notebooks, and the web. Our front-end layer provides this portability, ensuring that visual workflows are accessible wherever researchers and engineers work, and that deliver the same components across environments without duplication of effort. + +**Trame** is the glue that binds the platform together. As a Python-based framework for creating interactive visual workflows, trame integrates scientific libraries, AI tools, and modern web UI components. It lowers technical barriers, supports rapid development, and ensures interoperability between front-end and computational backend frameworks. By doing so, it creates an environment where visual workflows can be composed, extended, and shared. + +### Backend Frameworks + +We built the core of the platform on proven frameworks that address the significant gaps in today’s workflows: + +* **VTK** provides a comprehensive set of libraries for I/O, data models, analysis, rendering, and graphics. +* **ParaView** builds on VTK to provide distributed computing client–server operation while scaling from laptops to supercomputers. Together VTK and ParaView handle massive datasets, ensure high performance, and provide the visualization backbone needed for both experts and non-experts to interrogate complex results. +* **SMTK** addresses the complexity of workflow attributes and asset management, enabling users to define, track, and reuse workflow resources, including parameters, geometries, meshes, materials, and boundary conditions. SMTK supports flexible integration with the other frameworks, enabling interactive workflows that connect setup, execution, analysis, and visualization as well as providing ways of decomposing a workflow into a set of interactive tasks. +* **Fides** simplifies access to simulation and experimental outputs by streaming data at scale, reducing friction in moving results from producers to consumers. +* **Catalyst** enables the in-situ coupling of simulations and experiments with analysis and visualization, ensuring the processing of data as it is generated, rather than months later. Fides and Catalyst close gaps between data producers and data consumers, allowing workflows to incorporate real-time analysis, AI training, and experimental streaming without costly intermediate steps. + +Together, these backend frameworks tackle the most challenging tasks: massive data volumes, data cleaning and wrangling, multi-stage workflows that rely on diverse tools, and the complexities of managing assets and ensuring reproducibility. + +### Desktop Applications + +For off-the-shelf use, our desktop applications make these capabilities directly accessible to scientists and engineers: + +* **ParaView** for scalable visualization and analysis of massive datasets. +* **CMB** (Computational Model Builder) for building and managing complex simulation workflows. +* **Tomviz** for interactive analysis and visualization of large-scale tomography data. + +These applications embody the power of the backend frameworks while providing usable, production-ready environments. They serve both as entry points for new users and as full-featured platforms for experts. + +## Examples + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + Example 1 + + + + Example 2 + + + + Example 3 + +
+ + Example 4 + + + + Example 5 + + + + Example 6 + +
+ + Example 7 + + + + Example 8 + + + + Example 9 + +
+ + Example 10 + + + + Example 11 + + + + Example 12 + +
+ + Example 13 + + + + Example 14 + + + + Example 15 + +
+ + Example 16 + + + + Example 17 + + + + Example 18 + +
+ + + Example 20 + + +
+ +The power of this platform is best understood through concrete use cases. By combining run-everywhere front ends, trame, robust backend frameworks, and production-ready desktop applications, researchers can assemble visual workflows that address real challenges. The following examples illustrate how these components work together to manage massive datasets, streamline data movement, connect simulations with analysis, and simplify complex workflows into environments that accelerate discovery. + + +Convergent Science uses ParaView and Catalyst in their CONVERGE software to improve capture of high-speed physical phenomena inside internal combustion engines such as knocking. Catalyst allows saving isosurfaces at a rate much higher than is possible than saving full datasets and can reduce file output from ~100 gigabytes to ~100 megabytes in a typical simulation. Read the blog post [In Situ Data Analysis Brings Faster Results and Accelerated Insights](https://www.kitware.com/in-situ-data-analysis-brings-faster-results-and-accelerated-insights/) to find out more. + +Frameworks used: ParaView, Catalyst + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-1.jpg) + + +This figure shows an OpenFoam simulation of a boat inside a virtual wave tank. The application was created for Sandia National Laboratories’ Water Power Technologies Program. Applications like this can greatly reduce expenses – compared to either a physical wave tank or the manual creation of simulation inputs. + +Frameworks used: SMTK, CMB, VTK, ParaView. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-2.jpg) + + +This figure shows an OpenFOAM workflow Kitware created for Sandia National Laboratories to evaluate the reactions of objects to wave motion. What’s shown is a ship being inserted into the tank. The box around the aft portion of the vessel is a preview of the OpenFOAM overset mesh (snapped to the ship exterior) that has been crinkle-clipped to reveal the forward part of the ship.This allows inspection of meshes before running a simulation. + +Frameworks used: SMTK, VTK, ParaView + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-3.jpg) + + +Simulation workflows often demand diverse computational resources. For instance, a high-energy physics workflow, leveraging SLAC’s Advanced Computational Electromagnetics 3D Parallel (ACE3P) tools, is employed in the design of particle accelerators and related instrumentation. In this scenario, the user initiates the workflow on their local machine, while the intensive computations are executed on the High-Performance Computing (HPC) resources at NERSC. Users have the flexibility to perform remote post-processing on the HPC machine or conveniently transfer results for local processing, all within the same integrated tool. + +Frameworks used: SMTK, CMB, ParaView, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-4.jpg) + + +Developed for the Cleveland Clinic, this workflow showcases the intricate process of creating and annotating anatomical models. This involves segmenting and processing medical images and meshes. Users needed efficient ways to create and edit surface selections, remesh surfaces, and generate volumetric meshes from them, as well as to incorporate detailed ontologies into the annotation process. + + +Frameworks used: SMTK, CMB, ParaView, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-5.jpg) + + +Computational fluid dynamics workflows, like OpenFOAM-based wind tunnel simulation shown above, require users to perform various tasks: problem setup, mesh generation, simulation processing, and post-processing. Decomposing these complex workflows into manageable, guided tasks is crucial for effective user management. + +Frameworks used: VTK, CMB ParaView, SMTK. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-6.jpg) + + +Computational fluid dynamics (CFD) is integral to whole-body circulatory system workflows, supporting the development of new surgical procedures and patient health monitoring. These workflows often run continuously, necessitating in situ visualization for real-time observation by physicians and researchers. + +The accompanying images illustrate work from the Randles Lab at Duke University, where methods for whole-body circulatory system simulation are being developed, modeling down to individual blood cells using the HARVEY fluid dynamics solver. The video showcases blood flow within a representative human aorta, originating at the ascending aorta, traversing the aortic arch, and concluding at the descending aorta. As the fluid enters the aortic arch, it diverges into the right and left subclavian and common arteries. To mimic in vivo circulation, the flow constantly pulses throughout the animation. Frameworks used: ParaView, ParaView Catalyst + +Frameworks used: ParaView, Catalyst + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-7.jpg) + + +Parsli is a VTK-based viewer for fault system kinematics that enables rapid exploration and export of time-based animations. By leveraging advanced 3D graphics, interactive visualization, and high performance, we’ve transformed a workflow that once took days into one that now takes minutes—or even seconds—for initial validation and analysis. Its ease of use and installation has also encouraged the community to revisit past runs, uncovering phenomena that previously slipped through the cracks of the previous toolchain. + +Frameworks used: Trame, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-8.jpg) + + +Visualizing and exploring multivariate/multimodal volumes, common in material modeling and medical simulations, demands innovative techniques. These techniques are crucial for revealing significant trends and effectively communicating discoveries to both domain experts and general audiences. As an example, the accompanying figure presents an x-ray fluorescence tomography dataset of a mixed ionic-electronic conductor (MIEC), analyzed using Kitware’s MultivariateView tool. + +Frameworks Used: trame, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-9.jpg) + + +High-resolution 3D characterization is crucial for workflows in materials science and nanoscience. This requires advanced image processing, data analysis, visualization, and reproducibility. Integrating these features into a single environment streamlines the entire research pipeline, from raw data to publication-quality 3D renderings. Furthermore, incorporating capabilities like Python scripting and custom extensions expands its applicability to diverse workflows. Tomviz is an example that offers visualization, processing, and analysis for tomographic data. The image above from Tomviz demonstrates drawing a cropping region around 3D reconstructed PtCu nanoparticles, known for their effectiveness as fuel cell electrocatalysts. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-10.jpg) + + +QuickView is a Trame + ParaView-powered tool for exploring atmospheric output from the E3SM Atmosphere Model (EAM). It provides an intuitive, no-scripting interface for multivariate visualization, model validation & verification and supports EAM v2, v3 (and in development v4) data formats – which simplifies the atmosphere modeling and analysis workflows. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-11.jpg) + + +Pan3D is a fast, highly interactive visualization tool for Xarray datasets — a standard format for large, multidimensional arrays in climatology and other geospatial fields. Built on Trame and VTK, it leverages seamless interoperability between VTK and Xarray for efficient data exchange. A defining feature of Pan3D is its collection of Explorers (pictured above): lightweight, task-focused analysis apps that cut through the clutter of traditional, full-featured visualization tools such as ParaView. These explorers enable teams to craft bespoke, purpose-driven solutions, fostering collaboration and clear role separation. + +Platforms: VTK and trame + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-12.jpg) + + +In collaboration with NASA and the University of Colorado Boulder, Kitware is expanding the Catalyst in situ analysis platform to enable powerful AI models to access simulation data in memory at runtime for advanced model training and inference to improve upon existing simulation results. This approach empowers existing, validated simulation codes to leverage modern AI tools without complex and costly code integrations. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-13.jpg) + + +Rotorcraft simulation workflows present a complex, multidisciplinary challenge, as they necessitate the integration of moving-body aerodynamics with structural dynamics for rotor blade deformation, and vehicle flight dynamics and controls. Furthermore, the extensive data generated during a rotorcraft CFD simulation, stemming from numerous timesteps, can be substantial. + +By incorporating in situ capabilities directly into the simulation workflow, developers and analysts can scrutinize crucial variables at each timestep, thereby avoiding the significant overhead associated with I/O and storage. This methodology not only optimizes HPC resource utilization but also facilitates real-time steering, swift validation, and more insightful diagnostics during protracted simulations. The accompanying images illustrate this approach using CREATE’s HELIOS framework, which leverages ParaView Catalyst for in situ visualization and analysis. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-14.jpg) + + +ArrowFlow, focuses on broadening simulation usage by allowing domain scientists to easily create templates and expose them to remote engineers. Its curated web interface for input simulation parameters and easy to use post-processing tools enables quick exploration for validation of settings to use with factory mixer, drier or any machinery setup into the system. +ArrowFlow relies on M-Star CFD™ for its solver and ParaView for its post-processing. Trame is exposing templates, solver and post-processing visualization in an easy to use solution. + +Frameworks used: Trame, ParaView + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-15.jpg) + + +Displaying complex microstructural data is an integral part of many material science workflows and enables researchers to explore and understand the intricate geometries and properties of materials. This integration is crucial for analyzing simulated and experimental data, facilitating insights into material behavior, and accelerating the discovery of new materials with desired characteristics. The above image shows 3D precipitate morphology from a nickel based superalloy. Reconstruction was performed by DREAM3D-NX and subsequently visualized within DREAM3D-NX using VTK to provide advanced 3D rendering and visualization capabilities essential for material science research. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-16.jpg) + + +Acoustic modal analysis of a car cabin by [Undabit Acoustic Simulations](https://undabit.com/). Identifying vibration modes that may impact acoustic properties is crucial, as acoustic resonances can amplify noise generated by the engine, a phenomenon often referred to as “booming.” Understanding the frequencies at which resonance occurs and the spatial distribution of the resonant field is essential. Visualization with ParaView’s advanced ray-tracing capabilities. Source: [Automotive Acoustic Simulation Post-processing with ParaView](https://www.kitware.com/automotive-acoustic-simulation-post-processing-with-paraview/) + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-17.jpg) + + +[![Topological analysis of terrain elevation is crucial for surface water workflows, such as estimating water runoff zones. This analysis allows for the identification and classification of critical points like peaks and pits, the segmentation of watershed boundaries, and the highlighting of ridges and valleys. These elements are essential for understanding the terrain’s structure. In the accompanying figure, colored regions indicate areas feeding into the blue river network, while red paths denote ridges. Platforms used: ParaView and its Topology Toolkit (TTK) plugin. For more information, see [Practical Use Cases for TTK](https://www.kitware.com/practical-use-cases-for-ttk/). + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-18.jpg) + + +Live visualization of a drive train digital twin. Data from 30 temperature sensors on an electric motor are interpolated onto a digital twin model for live display in ParaView. This allows engineers from TotalEnergies to have direct access to a visualization showcasing the measured elements as it is running, and perform analysis and visualization within ParaView, either using the whole set of existing filters or even implementing their own. Platforms used: ParaView. More information at [Build, Control and Run Digital Twins with ParaView](https://www.kitware.com/build-control-and-run-digital-twins-with-paraview/). + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-19.jpg) + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Artificial Intelligence](https://www.kitware.com/tag/artificial-intelligence/) | [Catalyst](https://www.kitware.com/tag/catalyst/) | [CMB](https://www.kitware.com/tag/cmb/) | [Data Visualization](https://www.kitware.com/tag/data-visualization/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [simulations](https://www.kitware.com/tag/simulations/) | [SMTK](https://www.kitware.com/tag/smtk/) | [Tomviz](https://www.kitware.com/tag/tomviz/) | [Trame](https://www.kitware.com/tag/trame/) | [Visual Workflows](https://www.kitware.com/tag/visual-workflows/) | [VTK](https://www.kitware.com/tag/vtk/) diff --git a/docs/vitepress/blogs/a-year-of-innovation-our-most-impactful-projects-and-technologies-in-2024.md b/docs/vitepress/blogs/a-year-of-innovation-our-most-impactful-projects-and-technologies-in-2024.md new file mode 100644 index 00000000..e2090617 --- /dev/null +++ b/docs/vitepress/blogs/a-year-of-innovation-our-most-impactful-projects-and-technologies-in-2024.md @@ -0,0 +1,153 @@ +[post](https://www.kitware.com/a-year-of-innovation-our-most-impactful-projects-and-technologies-in-2024/) + +# A Year of Innovation: Our Most Impactful Projects and Technologies in 2024 + +December 2, 2024 + +[Samantha Schmitt](https://www.kitware.com/author/samantha-schmitt/ "Posts by Samantha Schmitt") + +![A Year of Innovation: Our Most Impactful Projects and Technologies in 2024](https://www.kitware.com/main/wp-content/uploads/2024/12/2024-Year-of-Innovation-Feature.jpg) + +As 2024 comes to a close, we want to take a moment to reflect on a year marked by remarkable achievements and technological strides at Kitware. From transforming environmental monitoring to advancing medical research and training, Kitware’s collaborative efforts have resulted in innovative solutions that positively impact our partners and community. This article highlights some of our most impactful projects and open source tools in 2024 and demonstrates our commitment to solving real-world challenges with cutting-edge technology in the years to come. + +## Transforming Environmental Monitoring with Edge Computing + +![Left: Adam Romlein, senior R&D engineer at Kitware, prepares for a test flight out of Nome, AK. +Right: The 9-camera system we installed in the belly of the aircraft. Three color cameras are at the top, three UV cameras are in the middle, and three IR cameras are at the bottom. This configuration captures a wide swath of imagery in flight to maximize the area covered.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-1-1024x492.jpg) + +Left: Adam Romlein, senior R&D engineer at Kitware, prepares for a test flight out of Nome, AK. +Right: The 9-camera system we installed in the belly of the aircraft. Three color cameras are at the top, three UV cameras are in the middle, and three IR cameras are at the bottom. This configuration captures a wide swath of imagery in flight to maximize the area covered. + +In 2024, the **NOAA KAMERA** project stood out for its innovative edge computing solution designed to enhance environmental monitoring through advanced real-time imaging and analysis. Kitware’s **KAMERA** system has a robust 9-camera setup and can capture images across ultraviolet, infrared, and color modalities, enabling precise detection of marine mammals. Equipped with ruggedized compute units and GPUs, the system enables real-time deep learning processing and immediate data analysis, significantly speeding up survey results. Field tests confirmed **KAMERA’s** durability in challenging Arctic conditions and its ability to synchronize and map imagery seamlessly. With its real-time processing and precise geospatial capabilities, this system overcomes the limitations of traditional, time-intensive data review processes. This innovative technology will empower policy-makers with timely, reliable information for informed decision-making, aiding in conserving vital species and ecosystems. + +To learn more about this project, read our [NOAA KAMERA Project Spotlight](https://www.kitware.com/project-spotlight-noaa-kamera/). + +## Geospatial Analysis for Real-world Applications + +![Illustration of two-stage heavy construction prediction. In the first stage, we run “Broad Area Search” (BAS) on a large region to identify candidate construction sites. The second stage, “Activity Characterization” (AC), refines the event boundary and estimates the probability of each construction stage over time.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-2-1024x492.jpg) + +Illustration of two-stage heavy construction prediction. In the first stage, we run “Broad Area Search” (BAS) on a large region to identify candidate construction sites. The second stage, “Activity Characterization” (AC), refines the event boundary and estimates the probability of each construction stage over time. + +**GeoWATCH** is an AI-driven tool for analyzing sequential imagery from multiple sensors. Originally developed to find heavy construction sites and track stages of construction, such as site preparation, active building, and post-construction phases, GeoWATCH uses multi-sensor data from sources like Landsat-8, Sentinel-2, and WorldView-3. Its adaptable data sampling and neural network capabilities allow it to process different resolutions and revisit rates, making it suitable for a wide range of applications. Beyond construction, GeoWATCH supports critical efforts in disaster response and building damage assessment, providing rapid, actionable insights where they are most needed. It is also being tested for tracking honey bee movement and monitoring algal blooms, showcasing the technology’s versatility. GeoWATCH can operate in challenging conditions where space and power are limited, extending its utility from edge computing environments to field-deployed systems. With applications across environmental monitoring, agriculture, and commercial industries, we are excited about the potential GeoWATCH is bringing to geospatial analysis. + +To learn more about **GeoWATCH**, [read our recent blog post](https://www.kitware.com/geowatch/). + +*Acknowledgment: This research is based upon work supported in part by the Office of the Director of National Intelligence (ODNI), Intelligence Advanced Research Projects Activity (IARPA), via 2021-201100005. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies, either expressed or implied, of ODNI, IARPA, or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for governmental purposes, notwithstanding any copyright annotation therein.* + +## Setting a New Standard for Interactive Web-Based Visualization + +![trame-based application to examine Uber ridesharing pick-ups and drop-offs in New York City over time.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-3-1024x745.jpg) + +trame-based application to examine Uber ridesharing pick-ups and drop-offs in New York City over time. + +**trame** has become a standout innovation, revolutionizing how interactive web-based visual applications are built. This powerful Python package bridges the gap between complex data visualization and intuitive web development, enabling users to create sophisticated web interfaces without needing extensive coding expertise. By leveraging open-source frameworks like VTK and ParaView, **trame** empowers developers to seamlessly integrate advanced 3D rendering and visualization capabilities into their web projects. The tool simplifies the deployment of visualization solutions, making high-level simulation and data analysis more accessible than ever. With micro-workflow features that streamline user interactions and offer customizable templates, **trame** allows for effortless configuration and enhanced usability. Its rapid adoption by a range of organizations underscores its impact on how researchers and developers share complex simulations and insights online. By providing a flexible and scalable platform, **trame** has redefined the landscape of web-based visualization, enhancing both user experience and collaborative opportunities. + +Read the most recent blog post in our [series about trame](https://www.kitware.com/trame-micro-workflow-use-case/) to learn more about its capabilities and applications. + +## Faster Simulation Results with In Situ Data Analysis + +![Timeline of traditional post-processing versus in situ analysis. In a traditional simulation where post-processing is performed after the simulation is complete, a lot of time is spent writing data to disk. Post-processing then takes additional time afterward. With in situ analysis, some additional time is spent performing analysis during simulation, but significantly less time is spent writing data to disk, and results are available for review as soon as the simulation is finished.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-4-1024x393.jpg) + +Timeline of traditional post-processing versus in situ analysis. In a traditional simulation where post-processing is performed after the simulation is complete, a lot of time is spent writing data to disk. Post-processing then takes additional time afterward. With in situ analysis, some additional time is spent performing analysis during simulation, but significantly less time is spent writing data to disk, and results are available for review as soon as the simulation is finished. + +**ParaView Catalyst** is an open source solution that integrates in situ data analysis directly within simulation workflows. This technology bypasses the traditional bottlenecks of writing large data files to disk, accelerating simulation processes and enabling immediate analysis as the simulation runs. By embedding the analysis into the simulation, engineers can access real-time results, leading to quicker design iterations and faster product development. In situ analysis significantly reduces file storage needs by producing compact analysis outputs, enabling higher-frequency data capture that reveals critical design phenomena. For example, in the automotive industry, tools like CONVERGE use **ParaView Catalyst** to analyze engine phenomena such as autoignition, capturing crucial data without excessive storage demands. This approach not only cuts down simulation time by up to 20% but also transforms how complex physical processes are understood and optimized. In situ technology like **ParaView Catalyst** drives innovation and efficiency in automotive and other engineering fields. + +Read more on how [ParaView Catalyst](https://www.kitware.com/in-situ-data-analysis-brings-faster-results-and-accelerated-insights/) brings faster results and accelerated insights. + +## Boosting Developer Productivity Through Exciting New CMake Feature + +![An example CMake file showcasing C++20 modules.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-5-1024x578.jpg) + +An example CMake file showcasing C++20 modules. + +Earlier this year, we announced that CMake now supports **C++20 modules**. Since CMake is the de-facto standard for building C++ code, with over 2 million downloads per month, this update will have a significant impact on the development community. This was an exciting effort involving the creation of a new standard file format that compilers need to provide to build tools like CMake. With this new feature in CMake, users can experiment with and deploy **C++20 modules**, which promises to enhance code organization and reduce compilation times. Unlike traditional header files, **C++20 modules** provide improved encapsulation and help prevent issues like multiple definitions. This development reflects Kitware’s dedication to staying at the forefront of software build innovation and aligning with the latest C++ standards. We are also continuing to add more support for modules, ensuring CMake evolves to meet the needs of developers. By facilitating faster and more manageable builds, this integration is set to benefit developers across diverse industries and applications. + +Read the first blog post in our series about [C++ modules in CMake](https://www.kitware.com/import-cmake-the-experiment-is-over/). + +## Ushering in ​​A New Era in Cross-Platform Dependency Management + +![Spack can now be installed on Windows, in addition to Linux and MacOS.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-6-1024x902.jpg) + +Spack can now be installed on Windows, in addition to Linux and MacOS. + +Kitware achieved a major milestone in 2024 by successfully porting **Spack** to the Windows platform, following years of collaboration with the Lawrence Livermore National Laboratory (LLNL) and other U.S. Department of Energy labs. This achievement marks a significant step forward in cross-platform dependency management, providing Windows users with access to the same powerful, configurable software stack management that Linux and macOS users have benefited from for years. By bringing **Spack** to Windows, Kitware has bridged an essential gap, enabling developers to maintain consistency when building and deploying software across different operating systems. This advancement simplifies workflows, reduces the need for manual dependency handling, and offers a unified approach to managing software environments. The impact is transformative for organizations and researchers who rely on multi-platform support for their development and deployment needs. Kitware’s work underscores its dedication to enhancing open-source tools and driving forward innovation in software development. With **Spack** now available on Windows, developers can enjoy a more comprehensive and flexible approach to cross-platform dependency management. + +Read this blog post to learn more about [Spack on Windows](https://www.kitware.com/spack-on-windows-a-new-era-in-cross-platform-dependency-management/). + +## Advancing Neuroimaging Analysis and Research + +![Browsing results of an OTM analysis using the vtk.js viewer.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-7-1024x320.jpg) + +Browsing results of an OTM analysis using the vtk.js viewer. + +**Web-OTM (Optimal Transport Morphometry)** set a new standard in neuroimaging analysis, providing researchers with advanced tools for comprehensive population-level studies. This web-based application leverages Unbalanced Optimal-Transport Based Morphometry to identify subtle and complex changes in neuroimaging data that traditional voxel-based morphometry might miss. By distinguishing between shifts in the amount of brain matter and its location, **Web-OTM** enables more precise and meaningful analyses. Built on VTK.js, the tool provides robust, interactive visualization powered by WebGL for smooth performance right in the browser. Researchers can effortlessly upload and preprocess their data, conduct quality control, and customize clinical variable analyses. The application’s advanced result visualization supports comprehensive exploration and interpretation, enriching neuroimaging research. With scalable deployment, **Web-OTM** puts cutting-edge analysis tools in the hands of researchers and clinicians, pushing the frontiers of neuroimaging studies forward. + +Watch [Web-OTM](https://www.kitware.com/introducing-web-otm-optimal-transport-morphometry-a-web-based-application-for-advanced-neuroimaging-population-analysis/) in action. + +*Acknowledgment: Research reported in this publication was supported by the National Institute Of Mental Health of the National Institutes of Health under Award Number R42MH118845. The content is solely the responsibility of the authors and does not necessarily represent the official views of the National Institutes of Health. The percentage and dollar amount of the total program or project costs are financed with federal money, and the percentage and dollar amount of the total costs are financed by nongovernmental sources.* + +## Innovative De-Identification Technology for Medical Research + +![ImageDePHI summarizes what metadata will be kept, deleted, or changed for each image. (Note: The data presented above is synthetic, and the slides contain mouse tissue samples.)](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-8-1024x512.jpg) + +ImageDePHI summarizes what metadata will be kept, deleted, or changed for each image. (Note: The data presented above is synthetic, and the slides contain mouse tissue samples.) + +Kitware has developed sophisticated de-identification tools for whole slide imaging (WSI) data through the NIH’s **ImageDePHI** program. This technology automatically detects and redacts protected health information (PHI) while preserving crucial clinical metadata, enabling important research on rare conditions, such as pediatric cancers. The software is built to address complex challenges like large file sizes and overlapping barcodes, ensuring secure and precise data handling. Kitware’s efforts help researchers share medical images while safeguarding patient privacy, promoting greater collaboration in the medical field. As the project progresses into Phase 2, Kitware is incorporating user feedback to refine the software, adding features like command-line interfaces and improving its adaptability for real-world use. By offering these tools as open source solutions, Kitware is empowering the research community with accessible, reliable resources. **ImageDePHI** is poised to have a significant impact on medical research, enabling secure data sharing and the comprehensive analysis of valuable imaging data. + +Learn more about the [ImageDePHI program](https://www.kitware.com/preserving-privacy-advancing-research-solutions-for-medical-image-sharing/). + +## Supporting Disease Research with Whole Slide Image Analysis Software for Digital Pathology + +![HistomicsTK allows researchers to easily create annotations and view millions of annotations simultaneously.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-9-1024x643.jpg) + +HistomicsTK allows researchers to easily create annotations and view millions of annotations simultaneously. + +**HistomicsTK**, Kitware’s open source digital pathology software, is a powerful solution for analyzing and managing whole slide imaging (WSI) data. Developed with scalability and adaptability at its core, **HistomicsTK** provides researchers with a seamless platform for conducting detailed image analysis through an easy-to-use interface. Its open source foundation invites customization, allowing institutions to modify and extend the tool to meet their unique research needs. This software enhances workflows by facilitating detailed image annotation, segmentation, and quantitative analysis, making studying medical images faster and more efficient. The ability to handle large WSI datasets accurately and at scale is crucial for medical research, where quick and reliable data processing is essential. By enabling more effective analysis and data sharing, **HistomicsTK** supports a deeper understanding of diseases and promotes collaborative research efforts. This innovation is pivotal for advancing pathology research, fostering discoveries, and paving the way for important medical breakthroughs. + +Watch this video to learn more about [HistomicsTK](https://youtu.be/lA2cDHZk6wk). + +## Next-Gen Medical Training with Realistic Patient Simulations + +![The Pulse Explorer is used to test and demonstrate training scenarios interactively with a virtual mechanical ventilator.](https://www.kitware.com/main/wp-content/uploads/2024/12/year-innovation-10-1024x336.jpg) + +The Pulse Explorer is used to test and demonstrate training scenarios interactively with a virtual mechanical ventilator. + +Kitware’s **Pulse Physiology Engine** stood out for its significant contributions to enhancing medical training through advanced simulation. One notable application was its use in the Air Force Research Laboratory’s mechanical ventilation simulation project, where it addressed key training challenges clinicians face, especially in military and high-stress environments where a lack of mechanical ventilation skills can be detrimental to patient care. **Pulse** offers a physics-based, real-time simulation of whole-body physiology, allowing trainees to practice with realistic patient scenarios and benefit from automated feedback, minimizing reliance on human trainers and ensuring patient safety during training. This project integrated a sophisticated ventilator simulator with a lung model and complex algorithms to accurately mimic respiratory distress. Validated training scenarios were supported, aligning with ARDSnet and Joint Trauma Clinical Practice Guidelines to ensure clinical relevance. Such effective training solutions are vital for both public and military healthcare providers, preparing them for unexpected situations like pandemics or mass casualty events to maintain high-quality patient care. + +Read more about how Pulse was used to advance [mechanical ventilation training](https://www.kitware.com/project-spotlight-afrl-mechanical-ventilation-simulation/). + +## What’s Next in 2025 + +The achievements highlighted here are not just milestones but stepping stones for even greater advancements in the future. As we look ahead to 2025, we remain committed to driving technology forward, embracing new challenges, and making a meaningful impact in diverse fields. Here’s to continuing our journey of discovery and excellence—together. + +If you would like more information about any of the projects or technologies mentioned in this article, please [contact us](https://www.kitware.com/contact/). + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[CMake](https://www.kitware.com/tag/cmake/) | [Geospatial Intelligence](https://www.kitware.com/tag/geospatial-intelligence/) | [GeoWATCH](https://www.kitware.com/tag/geowatch/) | [HistomicsTK](https://www.kitware.com/tag/histomicstk/) | [ImageDePHI](https://www.kitware.com/tag/imagedephi/) | [KAMERA](https://www.kitware.com/tag/kamera/) | [NOAA](https://www.kitware.com/tag/noaa/) | [ParaView Catalyst](https://www.kitware.com/tag/paraview-catalyst/) | [Pulse](https://www.kitware.com/tag/pulse/) | [spack](https://www.kitware.com/tag/spack-2/) | [Trame](https://www.kitware.com/tag/trame/) | [Web-OTM](https://www.kitware.com/tag/web-otm/) + diff --git a/docs/vitepress/blogs/bring-powerful-3d-visualization-to-the-browser-with-vtk-wasm.md b/docs/vitepress/blogs/bring-powerful-3d-visualization-to-the-browser-with-vtk-wasm.md new file mode 100644 index 00000000..073865f9 --- /dev/null +++ b/docs/vitepress/blogs/bring-powerful-3d-visualization-to-the-browser-with-vtk-wasm.md @@ -0,0 +1,95 @@ +[post](https://www.kitware.com/bring-powerful-3d-visualization-to-the-browser-with-vtk-wasm/) + +# Bring Powerful 3D Visualization to the Browser with VTK.wasm + +October 17, 2025 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") and [Riley Sheedy](https://www.kitware.com/author/riley-sheedy/ "Posts by Riley Sheedy") + +![Visualization of Space Ship](https://www.kitware.com/main/wp-content/uploads/2025/09/VTK-WASM-Webinar-2025-Q3_feature.jpg) + +Modern scientific and engineering applications increasingly rely on rich, interactive 3D visualization to interpret complex data. Traditional desktop deployments, however, create barriers, installation overhead, platform dependencies, and limited scalability. As workflows migrate to the web, there is a clear need for performant, browser-native solutions that can deliver the sophistication of desktop tools without their constraints. + +## Introducing VTK.wasm + +By compiling the Visualization Toolkit (VTK) to WebAssembly, VTK.wasm enables high-performance, interactive 3D visualization directly in the browser. This extends VTK’s flexibility—already established across C++, Python and makes it available to modern web environments. + +## What’s available today + +VTK.wasm provides multiple entry points designed for different development needs: + +### Pre-Built WASM Bundles + +For rapid integration, developers can leverage release and nightly builds that expose a streamlined, browser-focused API. These bundles are particularly suited for: + +* Client/server applications with synchronized state management. +* JavaScript workflows using reactive, browser-native programming models. + +This option is ideal for teams seeking advanced visualization capabilities with minimal setup. + +### Custom C++ Compilation + +For greater control and optimization, developers can build tailored VTK.wasm bundles: + +* Use Docker images and CMake macros to generate compact WebAssembly libraries. +* Include only the VTK modules necessary for a given application. +* Extend functionality through custom class serialization. + +This workflow supports projects that require scalability, performance tuning, and precise customization. + +### Python and trame Integration + +For Python developers, VTK.wasm integrates seamlessly with **trame**, Kitware’s framework for creating browser-based scientific applications. Highlights include: + +* Direct use of vtkRenderWindow that gets displayed in the browser via trame-vtklocal. +* Enable dynamic scene synchronization between server and client. +* Export 3D scenes from Python to a standalone web viewer. + +This lowers the barrier for Python-based development of real-time, browser-native visualization tools, without requiring JavaScript expertise. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/vtkwasm-1-1024x532.jpg) + +## Roadmap + +Development of VTK.wasm is ongoing, with several major capabilities planned: + +* WebGPU support for next-generation rendering (coming soon). +* ParaView integration to extend advanced, large-scale workflows into the browser. +* Dynamic module loading to reduce application footprint. +* Expanded VTK module coverage, including data processing in addition to rendering. + +## Why Kitware? + +At Kitware, we don’t just respond to shifts in technology; we help drive them. As the team behind VTK, ParaView, trame, and now VTK.wasm, we bring decades of expertise in scientific visualization, high-performance computing, and open science. This foundation enables researchers, engineers, and developers to deliver advanced 3D applications that are scalable, efficient, and ready for real-world challenges. + +If you’d like to explore how VTK.wasm can enhance your workflows, our team is available to provide technical guidance and collaboration opportunities. You can also see VTK.wasm in action through our [on-demand webinar](https://www.kitware.com/webinars/vtk-wasm-a-modern-path-to-bringing-vtk-to-the-web/), which highlights practical examples in C++, Python, and JavaScript and offers clear takeaways for building browser-native visualization tools. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[ParaView](https://www.kitware.com/tag/paraview/) | [Python](https://www.kitware.com/tag/python/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/exposing-web-application-with-paraview-5-13-is-getting-simpler.md b/docs/vitepress/blogs/exposing-web-application-with-paraview-5-13-is-getting-simpler.md new file mode 100644 index 00000000..cf47ce2b --- /dev/null +++ b/docs/vitepress/blogs/exposing-web-application-with-paraview-5-13-is-getting-simpler.md @@ -0,0 +1,148 @@ +[post](https://www.kitware.com/exposing-web-application-with-paraview-5-13-is-getting-simpler/) + +# Exposing Web applications with ParaView 5.13 is getting simpler + +September 3, 2024 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") and [Cory Quammen](https://www.kitware.com/author/cory-quammen/ "Posts by Cory Quammen") + +![ParaView Trame Components](https://www.kitware.com/main/wp-content/uploads/2024/08/web-app-output.png) + +Thanks to the new `--venv` feature of ParaView 5.13, covered in our previous [post](https://www.kitware.com/using-python-virtual-environments-in-paraview-5-13-0/), we now have a simple path to leverage [trame](https://kitware.github.io/trame/) within ParaView. + +Trame is a set of Python packages that makes it simple to put ParaView visualization on the web. Because trame development is progressing rapidly, ParaView binary installers do not include it; any version shipped with ParaView would quickly become outdated. Instead, you can use pip as the distribution mechanism to keep trame up to date by combining a ParaView binary release with the new –venv option and a virtual environment with trame dependencies. + +## Setting up a trame environment + +To create such virtual environment, you can do the following steps: + +``` +# create environment locally +python3.10 -m venv .venv + +# activate environment +source .venv/bin/activate + +# install a trame package with some demos +pip install paraview-trame-components + +# exit environment by deactivating it +deactivate +``` + +Now that we have a virtual environment setup with some pre-existing trame applications we can start using it within ParaView. + +## Parallel visualization with ParaView and trame + +The sample code below will use ParaView MPI to show a sphere color coded by the MPI process that owns each part within a web browser. In order to achieve that we will use pvbatch, an MPI-enabled batch-processing Python interpreter distributed as part of the ParaView suite. + +``` +# mpiexec and pvbatch are coming from the ParaView bundle +mpiexec -n 4 pvbatch --venv .venv -m ptc.apps.sphere +``` + +By running this previous command line, a new tab in your web browser will open with the following content. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/Screenshot-2024-08-14-at-15.39.48-1024x777.png) + +If you are wondering what code led to that interactive visualization that run in parallel via MPI, you can find it [here](https://github.com/Kitware/paraview-trame-components/blob/main/ptc/apps/sphere.py) but the listing below is also provided for convenience. + +``` +from paraview import simple +import ptc + +sphere = simple.Sphere() +rep = simple.Show(sphere) +view = simple.Render() + +simple.ColorBy(rep, ("POINTS", "vtkProcessId")) + +rep.RescaleTransferFunctionToDataRange(True, False) +rep.SetScalarBarVisibility(view, True) + +web_app = ptc.Viewer(from_state=True) +web_app.start() +``` + +As you can see from that example, you can easily leverage ParaView parallel capabilities from a simple Python script and drive the visualization from your browser. + +## Interactive data processing and visualization + +Trame provides endless options on what you can do with it, but let’s explore another simple example with ParaView doing interactive data processing and visualization. + +This time we will use pvpython and loads a different example that lets you change an isovalue interactively. And since you already have everything installed, you just need to run the following command. + +``` +pvpython --venv .venv -m ptc.apps.demo +``` + +When your local web browser opens, move the slider and you will see the isosurface change like below. + +[](https://www.kitware.com/main/wp-content/uploads/2024/08/anim.mov) + +While this visualization is not that appealing, look at the code needed to create such interactive data processing web application. + +``` +from paraview import simple +import ptc + +# ParaView code +wavelet = simple.Wavelet() +contour = simple.Contour(Input=wavelet) +contour.ContourBy = ["POINTS", "RTData"] +contour.Isosurfaces = [157.0909652709961] +contour.PointMergeMethod = "Uniform Binning" +rep = simple.Show(contour) +view = simple.Render() + +# Trame WebApp code +web_app = ptc.Viewer() + +with web_app.side_top: + ptc.VSlider( + v_model=("value", contour.Isosurfaces[0]), + min=37, max=276, step=0.5, + color="primary", style="margin: 0 100px;", + ) + +@web_app.state.change("value") +def on_contour_value_change(value, **kwargs): + contour.Isosurfaces = [value] + web_app.update() + +web_app.start() +``` + +## Where to go from there? + +Now that ParaView is able to extend its Python with any external virtual environment, you can easily create bespoke solutions with trame and share the result more easily with anyone. Such applications can come from an external package like the one we use throughout that blog but it can also be a simple standalone file. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[ParaView](https://www.kitware.com/tag/paraview/) | [Python](https://www.kitware.com/tag/python/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Trame](https://www.kitware.com/tag/trame/) + diff --git a/docs/vitepress/blogs/faster-and-better-3d-slicer-rendering-customization.md b/docs/vitepress/blogs/faster-and-better-3d-slicer-rendering-customization.md new file mode 100644 index 00000000..09605516 --- /dev/null +++ b/docs/vitepress/blogs/faster-and-better-3d-slicer-rendering-customization.md @@ -0,0 +1,69 @@ +[post](https://www.kitware.com/faster-and-better-3d-slicer-rendering-customization/) + +# Faster and better 3D Slicer rendering customization + +January 13, 2026 + +[Thibault Pelletier](https://www.kitware.com/author/thibault-pelletier/ "Posts by Thibault Pelletier") and [Julien Finet](https://www.kitware.com/author/julien-finet/ "Posts by Julien Finet") + +![](https://www.kitware.com/main/wp-content/uploads/2025/12/model_glow_example.jpg) + +3D Slicer is a very versatile and powerful medical imaging platform that provides plenty of ways for customization; scripted modules allowing the creation of new logic, Qt widgets in both Python and C++, IO plugins for reading custom file formats, segmentation effects for adding new features to the builtin segmentation tools and much more. + +With the introduction of the **[SlicerLayerDisplayableManager](https://github.com/KitwareMedical/SlicerLayerDisplayableManager)** module in [3D](link)[Slicer 5.10](https://www.kitware.com/3d-slicer-5-10-now-available-for-download/), extending the rendering pipeline is now significantly easier. + +## What can you do with it? + +Consider a simple example: adding hover-based highlighting to any model in the scene. Using the new library, an experienced Slicer developer can implement this functionality from scratch in just a couple of hours. + +

+ +

+ +This [toy example](https://slicerlayerdisplayablemanager.readthedocs.io/en/latest/examples.html) demonstrates how straightforward it is to add selection logic to a custom 3D Slicer module or extension, creating an intuitive user-experience with minimal code. + +## Getting started + +Install the LayerDisplayableManager extension directly from the Extension Manager in 3D Slicer 5.10 or later. + +For examples and detailed API documentation, visit the complete [online documentation](https://slicerlayerdisplayablemanager.readthedocs.io/en/latest/). + +![](https://www.kitware.com/main/wp-content/uploads/2025/12/image.png) + +

Layer Displayable Manager extension in the 3D Slicer Extension Manager

+ +![](https://www.kitware.com/main/wp-content/uploads/2025/12/image-2-1024x875.png) + +

Online documentation of the Layer Displayable Manager extension

+ +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with trame Slicer. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[3D Slicer](https://www.kitware.com/tag/3d-slicer/) | [Medical Imaging](https://www.kitware.com/tag/medical-imaging/) | [Press Releases](https://www.kitware.com/tag/press/) | [rendering](https://www.kitware.com/tag/rendering/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/faster-simpler-python-application-execution-with-uv-and-trame.md b/docs/vitepress/blogs/faster-simpler-python-application-execution-with-uv-and-trame.md new file mode 100644 index 00000000..795e0714 --- /dev/null +++ b/docs/vitepress/blogs/faster-simpler-python-application-execution-with-uv-and-trame.md @@ -0,0 +1,173 @@ +[post](https://www.kitware.com/faster-simpler-python-application-execution-with-uv-and-trame/) + +# Faster, simpler Python application execution with uv and trame + +June 21, 2025 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") + +![Gray Scott reaction diffusion model using Numpy with VTK and trame](https://www.kitware.com/main/wp-content/uploads/2025/06/grayscott.png) + +## Background & Motivation + +Trame has revolutionized how we build interactive scientific visualization applications in Python. By enabling developers to create rich graphical interfaces that seamlessly embed VTK/ParaView, Plotly, Matplotlib, and other visualization libraries with just Python scripts, trame has democratized access to powerful visualization tools. However, this convenience comes with a challenge that many trame developers know all too well: dependency management. + +Trame applications require Kitware and third party packages. A typical trame project might need VTK/ParaView for 3D rendering, various plotting libraries, web frameworks, and their respective dependencies. This is where uv transforms the trame delivery experience. As Astral (the company behind uv) describes it: [uv](https://github.com/astral-sh/uv) is “*an extremely fast Python package and project manager, written in Rust*“. While uv is incredible at creating virtual environments, it also provides new ways for dealing with applications and python scripts. Check out [their installation page](https://docs.astral.sh/uv/getting-started/installation/) so you can run the examples in this blog post in seconds. + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/uv-speed-1024x271.png) + +*Installing [Trio](https://trio.readthedocs.io/)‘s dependencies with a warm cache.* + +Normally, when dealing with Python dependencies, you rely on virtual environments to run applications or scripts. But what if we could skip the creation and management of virtual environments? + +## The uv way + +Since uv is so fast at creating virtual environments, it is offering new ways for dealing with scripts and tools. For tools or applications that live on GitHub or PyPI, you can install them globally and execute them from anywhere without risking breaking your system. In other words, uv keeps them isolated from each other. + +### Running Applications + +Let’s see what it looks like with two example applications we’ve built at Kitware. + +For executables that match their package name, you can simply run `uvx app-name` and skip any install step. uv handles the installation and storage for you. As you can imagine, the first execution will be slower, but any follow-up will be faster. + +For example, if you run `uvx parsli`, you should get the following + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/parsli-web-1024x744.png) + +Parsli is a VTK+trame-based viewer for fault system kinematics that enables fast exploration and export of time animation. + +And with `uvx multivariate-view`, you will get + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/multivariate-view-1024x838.png) + +A multivariate/multimodal volume visualizer inspired by RadVolViz that uses VTK and trame to render multi-channel volumetric datasets. + +Both applications are available on PyPI and can load local files to perform interactive 3D visualization. But the other cool thing about these applications is that they will download a sample dataset automatically, so that you can play with them before generating any data yourself. + +But what about standalone Python scripts with dependencies? + +### Running Scripts + +Let’s explore what you can do with a script. With uv, you can describe your dependencies as a comment at the top of your Python file. And when doing so, you can run that script with uv. + +While it is common practice to deal with local files, uv is smart enough to handle URLs too. In the examples below, I list the URL directly and skip the manual download step. But I would understand if you want to check the file content first! + +Running the following command line should start the application below: + +``` +uv run https://raw.githubusercontent.com/Kitware/trame/refs/heads/master/examples/06_vtk/04_wasm/app.py +``` + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/bike-uv-1024x774.png) + +Trame example using VTK and VTK.wasm for interactive 3D rendering within the browser, while dynamically updating geometry when interacting with the widget. + +Or, you can use that other example that was ported from a [vedo](https://vedo.embl.es/) example using plain VTK and trame. + +``` +uv run https://raw.githubusercontent.com/Kitware/vtk-scene/refs/heads/main/examples/grayscott.py +``` + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/grayscott-1024x818.png) + +Live Gray Scott reaction diffusion model using Numpy with VTK and trame. + +While those two scripts are perfect examples for showcasing the power of uv and trame, they are still demos. What about a solution for dealing with real data from a simulation? + +The case below, while remaining a simple script, is relying on Pan3D, VTK, Zarr, and Xarray to access a complex hdf5 data format. The file loaded is generated by a simulation code named PFlotran, which is an open source, parallel subsurface transport code developed at Berkeley Laboratory. Since the format can not be directly read by off-the-shelf software, we authored a small Python script to parse the hdf5 structure and generate a “reference file system” that maps it to a virtual Zarr dataset. Thanks to that trick, we were able to leverage Xarray with a Zarr engine to load it. At the end, the application is able to load subsurface data, color it by any available field, perform time animation, and slice it along any axis for exploration. To simply run the application/script, you can execute the following command line. + +``` +uv run https://raw.githubusercontent.com/Kitware/vtk-scene/refs/heads/main/examples/remote_pflotran.py +``` + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/pflotran-1024x777.png) + +Pan3D-based viewer for subsurface simulation data, using a PFlotran file with Zarr/Xarray to read and VTK to process and render it. + +Wondering how to update your script and enable such an easy to use setup? You can read the full documentation on [the uv website](https://docs.astral.sh/uv/guides/scripts/), or you can glance at those scripts and look at the comment section at the top. What’s even nicer is that you can use a shebang to automate it even further on Linux and macOS systems. That just makes your scripts a standalone executable. + +If you’d like to try, you can run the following command to grab any previous url and run it locally. The commands below are using a helper file from parsli repository to run the trame application as a desktop user interface. + +``` +curl -O https://raw.githubusercontent.com/brendanjmeade/parsli/refs/heads/main/parsli +chmod +x parsli +./parsli +``` + +![](https://www.kitware.com/main/wp-content/uploads/2025/06/parsli-app-1024x782.png) + +And the content of that file is just + +``` +#!/usr/bin/env -S uv run --script +# +# /// script +# requires-python = ">=3.11" +# dependencies = [ +# "parsli[app]>=1.2.1", +# ] +# /// +from parsli.viewer.core import Viewer +from multiprocessing import freeze_support + +if __name__ == "__main__": + freeze_support() + app = Viewer() + app.server.start(exec_mode="desktop") +``` + +## Conclusion + +Between trame and uv, we are reaching a sweet spot for delivering bespoke applications faster and simpler to a wider audience. + +Trame is capable of delivering interactive solutions with complex visualization locally, in the cloud, within Jupyter, or on HPC with ParaView. But uv is making the installation and execution of trame applications a breeze. + +At Kitware, we thrive at helping researchers, scientists, and industry reach their goals faster. Our expertise in the frameworks we’ve created (i.e. *cmake*, *vtk*, *paraview*, *trame*), data analysis and visualization, and wide domain knowledge across our team enables us to understand your needs and deliver better solutions. + +[Reach out](https://www.kitware.com/contact/), so we can figure out how to best help you in your next endeavor. + +## References + +**Parsli** is an application developed by Kitware for Brendan Meade, a Professor of Earth & Planetary Sciences at Harvard University. Parsli is a lightweight viewer that enables post-processing of simulation results faster than ever before. (https://github.com/brendanjmeade/parsli) + +**Multivariate-view** is an application developed by Kitware under DOE SBIR Award DE-SC0024765 titled “Multivariate Volume Visualization and Machine-Guided Exploration in Tomviz”. By using VTK and trame, we were able to expand the research to be impactful not just for nanoscale imaging, but also for other domains, including medical, chemical, and biological imaging. (https://github.com/Kitware/multivariate-view) + +**RadVolViz** is an “information display-inspired transfer function editor for multivariate volume visualization” (https://ieeexplore.ieee.org/document/10091196) + +**VTK.wasm** is a bundle of VTK that enables users to mirror a VTK scene inside a browser so that it can be interactively explored without any rendering disparity with pure VTK capabilities. Such technology is integrated inside trame to streamline various deployment needs and constraints. (https://kitware.github.io/vtk-wasm/) + +**Gray Scott**: is a reaction-diffusion model example from the book “From Python to Numpy” made by Nicolas Rougier, but extended to use VTK with Numpy and trame (https://www.labri.fr/perso/nrougier/from-python-to-numpy/) + +**Pan3D** is a DOE-funded Phase II effort that aims to simplify the creation of 3D visual workflows using Python and VTK. Technical objectives include interoperability with PyData ecosystems such as XArray, improved integration of trame with Jupyter, VTK WebAssembly enhancements, and the creation of web-based data explorers using VTK and trame. For more information, visit https://github.com/Kitware/pan3d/ + +**Kitware** builds and maintains open source solutions. We support our customers in using these tools, including by adapting them to meet specific needs. For more information on working with Kitware, contact us at https://www.kitware.com/contact/ + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Python](https://www.kitware.com/tag/python/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/how-trame-powers-todays-visualizations.md b/docs/vitepress/blogs/how-trame-powers-todays-visualizations.md new file mode 100644 index 00000000..7bf0d604 --- /dev/null +++ b/docs/vitepress/blogs/how-trame-powers-todays-visualizations.md @@ -0,0 +1,112 @@ +[post](https://www.kitware.com/how-trame-powers-todays-visualizations/) + +# How trame Powers Today’s Visualizations + +August 4, 2025 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery") and [Samantha Schmitt](https://www.kitware.com/author/samantha-schmitt/ "Posts by Samantha Schmitt") + +![The standalone application is now an integral part of their toolchain for performing data analysis and interactive visualization. Thanks to the fact that the application is published to the Python Package Index (PyPI), users can install and run it on any computer from a simple command line.](https://www.kitware.com/main/wp-content/uploads/2025/08/trame-feature4.jpg) + +Many scientific and engineering applications are still built as standalone desktop tools. While these solutions may have served teams well in the past, they often present modern-day challenges: they’re difficult to share, hard to maintain, and disconnected from today’s collaborative and distributed workflows. + +As research increasingly spans labs, institutions, and even continents, tools must adapt. They need to be flexible, accessible, and built for the environments where users and data live—whether that’s on a laptop, in a Jupyter notebook, or on a high-performance computing (HPC) system. + +trame is an open source Python framework designed for exactly that. With best-in-class integration with visualization technologies like VTK and ParaView, trame helps research teams turn complex, domain-specific workflows into interactive, browser-based applications. With trame, you can: + +* Run applications on desktops, in browsers, in notebooks, or on remote servers +* Share tools via simple URLs—no installation required +* Build tailored UIs with little to no front-end development experience +* Stay entirely within the Python ecosystem + +Across domains, researchers are finding new ways to simplify and scale their work using trame. Whether it’s accelerating interactive visualizations in a lightweight environment or making data tools more accessible across remote teams, the shift toward browser-based applications is opening new possibilities. We’ve seen this firsthand as we have helped many customers transition to web applications. + +## Real Projects, Real Impact: Custom trame Solutions + +**Case Study 1: Speed and Simplicity for Academic Researchers** + +Our collaborators from a top-ranked U.S. research university—consistently ranked among the top 5 globally—were using a research pipeline that relied on Matplotlib for rendering within JupyterLab to analyze and visualize simulation output. While this setup worked for analysis, it wasn’t built to scale. Rendering their full dataset was painfully slow, often taking hours to generate the full set of timesteps as a movie. The team was also unable to validate their data until after it went through this time-consuming export process, which meant they had to go through the render process again if they discovered any issues. + +To address these limitations, Kitware incorporated trame and VTK into their workflows. This allowed the team to validate their data in real time before beginning the rendering export process. These platforms also drastically reduced the time it took to export their data, taking only a minute instead of hours to complete. + +Key technical enhancements included: + +* **900x performance improvement** achieved by offloading rendering from Matplotlib to VTK while using multi-threading for encoding the images to disk +* A **Python-only codebase**, with trame serving as the front end and controller, so the researcher could maintain and extend the tool without requiring constant support from Kitware + +The standalone application is now an integral part of their toolchain for performing data analysis and interactive visualization. Thanks to the fact that the application is published to the Python Package Index (PyPI), users can install and run it on any computer from a simple command line. + +![The standalone application is now an integral part of their toolchain for performing data analysis and interactive visualization. Thanks to the fact that the application is published to the Python Package Index (PyPI), users can install and run it on any computer from a simple command line.](https://www.kitware.com/main/wp-content/uploads/2025/08/trame-feature-1024x816.jpg) + +**Case Study 2: Improving Accessibility and Collaboration at Lawrence Berkeley National Laboratory** + +The team at the National Center for Electron Microscopy (NCEM) at Lawrence Berkeley National Laboratory (LBNL) used a Qt-based desktop application to explore 4D STEM materials science datasets collected during electron microscopy experiments. The application interfaced with complex imaging data—often hundreds of gigabytes in size—and included custom widgets for interactively exploring the data in both real space and diffraction space. + +While effective in the lab, the application became a burden once experiments concluded. Remote users needed to: + +1. Download and install the Qt application, which required platform-specific builds and challenges due to unfamiliar installation processes. +2. Manually transfer very large datasets, which sometimes could not be loaded into the application on a user’s computer due to memory constraints. + +Kitware proposed replacing the desktop solution with a trame-powered web application. This new approach mirrored the functionality of the original Qt tool but introduced key improvements: + +* Users can now **access the application through any modern browser** or integrate it directly into JupyterLab, using the same backend. +* The application is deployed on an internal server co-located with the experimental data, **eliminating the need to transfer files**. +* Kitware developed **custom trame widgets** that mimicked the key Qt UI elements—such as panning/zooming and ROI controls—while improving responsiveness and modularity. +* The **architecture was redesigned** to be server-client, allowing the heavy lifting (e.g., rendering, file I/O) to occur near the data while keeping the front end light and responsive. + +This migration allowed NCEM researchers to bypass installation and data transfer altogether. With a single URL, users can now relaunch their analysis sessions from anywhere, interactively explore large datasets in real time, and share insights with collaborators more easily than ever before. + +## Why Teams Choose trame—and Kitware + +Both of these projects demonstrate what’s possible when domain-specific workflows are paired with scalable, interactive visualization platforms. With trame, teams can move beyond the limitations of static visualization inside Jupyter, desktop-bound tools, and into a more agile, cloud-ready development model without abandoning the Python-based ecosystems they already rely on. + +Whether you need to offload GPU rendering to accelerate performance, embed custom UIs into Jupyter workflows, or deploy visual applications alongside large-scale data on HPC infrastructure, trame provides the flexibility to meet you where your research lives. It’s not just a framework—it’s a bridge between scientific code and modern, user-facing tools. In fact, trame, along with VTK, ParaView, and Catalyst, is part of an infrastructure that we are building to make it easy to develop bespoke visualization workflows that are just right for the domain-specific problems that you might be interested in solving. The ability to quickly develop visual workflows that are just right for the problem at hand—no more, no less—represents the next generation of production data analysis, visualization, and visual workflow applications. + +And with Kitware’s help, that bridge can be built quickly and robustly. Our engineers work alongside your team to: + +* Design modular, maintainable architectures +* Develop custom components tailored to your data and users +* Integrate with your existing infrastructure, whether cloud-based or on-premises +* Deliver production-grade applications that evolve with your needs + +If you’re currently maintaining a legacy application—or just starting to prototype a new one—trame offers a modern foundation. And Kitware can help you bring it to life. + +**Interested in accelerating your own visualization tools?** +Join our free webinar on August 13th to see trame in action. + +[Register Now](https://www.kitware.com/webinars/whats-new-in-trame-bespoke-workflows-for-better-productivity/) + +**Ready to modernize your application?** +Contact Kitware for a consultation with our developers. + +[Request at Meeting](https://www.kitware.com/contact/) + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/index.md b/docs/vitepress/blogs/index.md new file mode 100644 index 00000000..0a2d3d91 --- /dev/null +++ b/docs/vitepress/blogs/index.md @@ -0,0 +1,124 @@ +# Blogs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ January 13, 2026

Faster and better 3D Slicer rendering customization + 		+ December 4, 2025

A Framework for Next-Generation Visual Workflows in Scientific Computing + 		+ November 20, 2025

trame-slicer: Bringing the power of 3D Slicer to the web +
+ October 21, 2025

Supercomputing Conference 2025 + 		+ October 17, 2025

Bring Powerful 3D Visualization to the Browser with VTK.wasm + 		+ October 13, 2025

What’s New in trame: Bespoke Workflows for Better Productivity +
+ October 6, 2025

Using Python to Power Scalable, Sustainable Innovation + 		+ August 4, 2025

How trame Powers Today’s Visualizations + 		+ June 21, 2025

Faster, simpler Python application execution with uv and trame +
+ March 3, 2025

Medical Technology Trends to Watch in 2025 + 		+ January 7, 2025

Why Medical Device Leaders Trust Kitware for Medical Image Innovations + 		+ December 17, 2024

JupyterLab Trame Manager at Jülich Supercomputing Centre +
+ December 2, 2024

A Year of Innovation: Our Most Impactful Projects and Technologies in 2024 + 		+ November 5, 2024

LidarView 5.0 – new supported sensors, algorithms, and more! + 		+ October 29, 2024

VTK 9.4: A Step Closer to the Ways of Python +
+ October 28, 2024

Simplify Web Application Development with trame + 		+ October 16, 2024

VTK.wasm and its trame integration + 		+ October 15, 2024

Making Modeling and Simulation Tools Accessible on the Web +
+ October 1, 2024

trame: Micro-Workflow Use Case + 		+ September 5, 2024

trame: Dashboard Use Case + 		+ September 3, 2024

Exposing Web applications with ParaView 5.13 is getting simpler +
+ August 21, 2024

Make Your Automotive Simulation Tools Available on the Web + 		+ August 9, 2024

trame: Architecture and Capabilities + 		+ July 10, 2024

Microscopy & Microanalysis +
+ February 27, 2024

Lidar point cloud on the web with trame + 		+ November 17, 2023

Transform Your Medical Imaging with Kitware’s Comprehensive Suite of Advanced Visualization Solutions + 		+ October 30, 2023

Supercomputing 2023 +
+ August 3, 2023

trame: Revolutionizing Visual Analytics with Python + 		+ June 22, 2023

The Evolution of Peacock: A Powerful Interface for MOOSE Simulations + 		+ January 18, 2023

VERACore: trame in Application +
+ December 8, 2022

Numerical plasma dynamics from the comfort of your web browser with trame + 		+ August 4, 2022

Leveraging MONAI for Medical AI + 		+ January 18, 2022

Scientific Visualization in 2022 +
diff --git a/docs/vitepress/blogs/jupyterlab-trame-manager-at-julich-supercomputing-centre.md b/docs/vitepress/blogs/jupyterlab-trame-manager-at-julich-supercomputing-centre.md new file mode 100644 index 00000000..897d663f --- /dev/null +++ b/docs/vitepress/blogs/jupyterlab-trame-manager-at-julich-supercomputing-centre.md @@ -0,0 +1,182 @@ +[post](https://www.kitware.com/jupyterlab-trame-manager-at-julich-supercomputing-centre/) + +# JupyterLab Trame Manager at Jülich Supercomputing Centre + +December 17, 2024 + +[Francois Mazen](https://www.kitware.com/author/francois-mazen/ "Posts by Francois Mazen") and [Sonia Ayme](https://www.kitware.com/author/sonia-ayme/ "Posts by Sonia Ayme") + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/9f751c47-4a87-4e50-9930-3bec7f8a263a.png) + +**This is a guest blog post from Jonathan Windgassen and Jens Henrik Göbbert, both developing the software stack at the Jülich Supercomputing Centre in Germany. They have agreed to share with us the integration of trame, jupyter lab and ParaView to ease the life of their scientists. As a bonus they include the code to reproduce their work on any supercomputer!** + +*[trame](https://trameapp.kitware.com/)* is a Python based framework developed by Kitware to easily create web applications for visual analytics. The *trame* architecture allows developers to access states, events, widgets, and user interfaces (UI) through Python, by hiding the complexity of web development. You can read more about it [here](https://kitware.github.io/trame/). + +The synergies between *trame* and *[JupyterLab](https://jupyter.org/)* make it a great combination for the development and usage of *trame* apps. For Data Scientists — likely users of *trame* apps — *JupyterLab* has become a popular tool for web-based interactive data analysis and a tool in their everyday work. To support this trend, the [Jülich Supercomputing Centre (JSC)](https://www.fz-juelich.de/jsc) has been providing for some time now a *[JupyterHub](https://jupyter.org/hub)* called **[Jupyter-JSC](https://jupyter.jsc.fz-juelich.de/)** for pure and direct browser-based access to its supercomputers as an easy access to HPC Resources. + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/026e3d80-2acd-407f-94c5-ac36ea604427-1024x403.png) + +In the trend to move HPC applications and workflows to *Jupyter-JSC*, the combination of *trame* and *JupyterLab* has become an attractive combination. This motivated the development of the **[jupyterlab-trame-manager](https://github.com/jwindgassen/jupyterlab-trame-manager)**, where users can access trame apps directly in the browser, making the use of trame in HPC more visible, and easier to launch and manage. It also gives users access to ParaView’s remote visualization capabilities inside *trame* Apps, bridging HPC and cloud computing. + +A showcase demonstrating the *jupyterlab-trame-manager* in action on the JupyterJSC Platform, can be seen [here](https://fz-juelich.sciebo.de/s/A05u8oYqnwnYeeb): + +[](https://www.kitware.com/main/wp-content/uploads/2024/10/trame-manager-2.mp4) + +## Concept + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/32085e20-0a46-4229-8a96-512a19afebf8.png) + +*jupyterlab-trame-manager* creates an additional side-panel in *JupyterLab*, which allows the management of ParaView Servers for remove visualization in the top section and *trame* Apps and their currently running instances in the lower one. + +Custom *trame* apps can be made findable for *jupyterlab-trame-manager* via paths set in the environment variables. Each registered *trame* App itself contains a list of independently, decoupled running instances of this app, which can be separately managed. + +These instances will run on the same server where the JupyterLab server is running, as a subprocess of the JupyterLab server. The frontend of the instance is tunneled through *JupyterLab*, allowing it to be accessed in the browser. +To utilize remote rendering in a *trame* app, each instance can be connected to a ParaView Server from the top Section. This will connect the instance to the ParaView Server, which can run on another node, i.e. a visualization node. + +A schematic overview can be seen here: + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/9f751c47-4a87-4e50-9930-3bec7f8a263a-1024x532.png) + +## Installation + +The *jupyterlab-trame-manager* is platform-independent and capable of running on various architectures. It offers customizable, platform-specific configurations for launching apps and ParaView on specific HPC systems. Thus, the *jupyterlab-trame-manager* can be tried locally before installing it on a cluster. + +To begin, install *JupyterLab* along with the *jupyterlab-trame-manager* extension using pip: + +`pip install jupyterlab jupyterlab-trame-manager` + +Before starting *JupyterLab*, specify what Configuration to use to the extension. For now, use the `desktop` Configuration, designed for the simple testing on a desktop: + +`export TRAME_MANAGER_CONFIGURATION=desktop` + +Once configured, start the *JupyterLab* Server: + +`jupyter lab` + +This should automatically open a new Tab in the browser and navigate to the *JupyterLab* interface. + +### Integrating a trame App + +1) To register the *trame* application with the extension, you first need to place the app somewhere on the system where the *JupyterLab* will be running. + +2) *trame* apps can be made findable via the paths stored in the `JUPYTER_PATH` environment variable, which is also used when [installing a new Notebook Kernel](https://jupyter-client.readthedocs.io/en/latest/kernels.html#kernel-specs). All directories in `JUPYTER_PATH` are searched for a `trame` directory (similar as they are searched for a `kernel` directory by Jupyter itself). If a subdirectory with a YAML file `app.yml` is found, *jupyterlab-trame-manager* will register a new *trame* app based on the configurations inside it. + +By default, the `JUPYTER_PATH` environment variable will contain `~/.local/share/jupyter`, where the `app.yml` can be placed at `~/.local/share/jupyter/trame/my-app/app.yml`. + +In the `app.yml` file, specify the following parameters for the application: + +* **name**: The name to be shown in the UI. While the folder name is more of an internal representation of the app, this allows giving the application a nice, well-formatted name, shown in the UI. +* **command**: The launch command that will be executed to start the app. See below. +* **working\_directory (optional)**: From where the subcommand, which launches the app, is executed. Defaults to the location where the *JupyterLab* is executed. + +In most cases, users would not only need to start their *trame* app, but also prepare the environment (loading modules, defining environment variables) before the startup. A single launch command is the easiest way to enable all of these preparations. + +> **Info**: To keep the *JupyterLab* environment as slim and free of potentially unnecessary dependencies, *trame*, ParaView and its dependencies should only be loaded during the launch command and should not be loaded before *JupyterLab* is started. +> +> Some arguments of the launched app, like port and authentication key, are generated and need to be passed to the actual *trame* executable. These are contained inside a `INSTANCE_ARGS` environment variable and must be appended to the python interpreter: `python main.py --otherArgs $INSTANCE_ARGS` + +The final `app.yml` might look like this: + +``` +name: My trame App +working_directory: ~/.local/share/jupyter/trame/my-app/ +command: | + module purge + module load Stages/2024 + module load GCC ParaStationMPI + module load ParaView/5.12.0-RC2-EGL + module load trame/3.6.3-ParaView + + python __init__.py $INSTANCE_ARGS +``` + +3) Start the *trame* app: Restart *JupyterLab* for *jupyterlab-trame-manager* to discover the app. It should then appear in the lower section of the sidebar. Expand the panel with the app and click on *Launch*. In the following Popup, give the instance a name and specify the data directory (used e.g. by the *trame* `FileBrowser`). After the app has started, click on *Open*, which will open the *trame* app in a new browser tab. + +## Using trame with Remote Rendering via a ParaView Server + +When using VTK or ParaView in a *trame* app, some calculations can become quite compute intensive. For that reason, you might need to outsource these to a separate ParaView Server. +With the *jupyterlab-trame-manager*, this process can be automated, hence the list of ParaView Servers in the upper section of the extension. +Users can launch ParaView Servers, e.g., via SLURM, and then automatically initiate a connection between the *trame* app and the ParaView Server. + +> **Info**: With the `desktop` Configuration, however, the ParaView Server needs to be started manually. The extension is configured to always show a single Server on `localhost:11111`, which is the default Port the ParaView Server uses. +> To try using the *trame* app with a ParaView Server, manually execute `pvserver` in another terminal. + +> **Warning**: Not all *trame* Apps might directly work with ParaView’s Remote Rendering out of the box. *trame* apps might need to be updated to make this possible. We hope to make this process easier and more stable in the future. + +After both the ParaView Server and the *trame* app are launched, a connection between them can be initialized by clicking on “Connect” on the panel for this *trame* instance and select one of the running ParaView instances to connect to: + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/6c1636e9-cd80-45d0-8398-919993ea6636.png) + +To allow the extension to initiate a connection between a *trame* app and a ParaView Server, the *trame* App must be prepared beforehand. To make this a breeze, we developed the `trame-remote-control` extension for *trame*. +It can easily be installed via pip: `pip install trame-remote-control`. +After that, it must be imported and initialized when the app starts. This will attach a REST-API Endpoint to the App, which the extension can use to initiate a connection to a ParaView Server. It can also be used to create a UI, which lets users connect and disconnect from ParaView Servers from within the application: + +``` +from trame.widgets import vuetify, remote_control + +def main(): + ... # Other initialization code + + remote_control.initialize(server) + + ... # Construct UI + with vuetify.VCol: + remote_control.create_panel(server) +``` + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/307b4b72-4767-409f-a86e-c83980f74be1.png) + +## Utilizing HPC Resources + +Now that the setup is running on a local desktop machine, it can be brought to HPC resources. The setup for this is almost identical to the desktop version, with the only difference being the Configuration specified. +The *jupyterlab-trame-manager*, by default, currently only contains configurations for desktop and the HPC Systems at the JSC, which can serve as inspiration for other systems. We are happy to merge new configurations directly into the repository, but they can, of course, also just be added to the local install. + +Additionally, it might be desirable to use a software build framework to install the extension. At the JSC, we use EasyBuild. The easybuild file for installing the extension, as well as configuring it correctly, can be found [here](https://github.com/easybuilders/JSC/blob/2024/Golden_Repo/j/jupyterlab-trame-manager/jupyterlab-trame-manager-0.6.1.eb). + +## Outlook + +While the current setup runs stably for most use cases, we still want to further improve and extend the functionality of the *jupyterlab-trame-manager*. + +One prominent problem is the link between a running *trame* instance and the Jupyter Server. At the moment, *trame* instances are spawned as a subprocess of the Jupyter Server, linking the runtime of the two processes. +Instead, we plan to use *[Unicore](https://www.unicore.eu/)* in the future, which we currently also use on our HPC machines to spawn the *JupyterLab* itself. + +As previously mentioned, we also want to improve the stability when using remote rendering with a ParaView Server. +Furthermore, we originally also planned to give the extension the ability to control in-transit visualization between the ParaView Server and a running Simulation on the Cluster. +This would allow users to easily construct a full visualization pipeline, running from the simulation over a ParaView Server on some visualization nodes into the browser. + +![](https://www.kitware.com/main/wp-content/uploads/2024/11/c0f02b0d-07a9-4d3b-9122-1cd7402d4305-1024x721.png) + +This work has been published as a poster at the [ISC-HPC 2024 conference](https://app.swapcard.com/widget/event/isc-high-performance-2024/planning/UGxhbm5pbmdfMTgzOTk5NQ==). + +Thank you for your interest in reading this article. If you have any questions or ideas, feel free to contact Jonathan via [email](mailto:j.windgassen@fz-juelich.de) or reach out directly to [Kitware](https://www.kitware.com/contact/) for support. + +Contributions and suggestions are always welcome! + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[HPC](https://www.kitware.com/tag/hpc/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Trame](https://www.kitware.com/tag/trame/) diff --git a/docs/vitepress/blogs/leveraging-monai-for-medical-ai.md b/docs/vitepress/blogs/leveraging-monai-for-medical-ai.md new file mode 100644 index 00000000..feae2fa9 --- /dev/null +++ b/docs/vitepress/blogs/leveraging-monai-for-medical-ai.md @@ -0,0 +1,79 @@ +[post](https://www.kitware.com/leveraging-monai-for-medical-ai/) + +# Leveraging MONAI for Medical AI + +August 4, 2022 + +[Stephen Aylward](https://www.kitware.com/author/stephen-aylward/ "Posts by Stephen Aylward"), [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder") and [Samantha Schmitt](https://www.kitware.com/author/samantha-schmitt/ "Posts by Samantha Schmitt") + +![](https://www.kitware.com/main/wp-content/uploads/2022/08/Support-for-MONAI.png) + +Deep learning technologies have demonstrated the potential to improve nearly every aspect of healthcare. However, significant challenges exist when integrating those technologies into healthcare products and processes. These challenges are particularly critical when regulatory approval is the ultimate goal. The risks and costs associated with failing to address these challenges can hurt small and large businesses alike. + +[MONAI](https://monai.io/) is an open source platform designed to address the challenges of integrating deep learning into healthcare solutions. + +## MONAI: Addressing the Challenges of Medical AI + +MONAI spans the entire lifecycle of medical AI product development, including AI-assisted data annotation, data and AI model management, algorithms research, federated learning, solution validation, and solution deployment in clinical and research environments. + +MONAI prioritizes the unique challenges of healthcare AI: supporting medical standards that facilitate integration into clinical workflows, maintaining the clinical integrity of the results it produces, quantifying performance in terms of clinical needs, emphasizing AI transparency and reproducibility, and utilizing GPUs to provide timely results for clinical decision making. + +The success of MONAI in achieving these critical healthcare capabilities has strongly benefited from NVIDIA’s guidance, world-class development expertise, and cutting-edge research collaborations. Kitware can help integrate MONAI and the design and utilization of these NVIDIA resources to achieve the low-latency and scalable compute power needed for any healthcare application. + +![](https://lh5.googleusercontent.com/w0ZaS4sU9_LhQkNJKDSvAt88jONYTuCQMASWrUZwWHfFsvr9_w7pb21wdpZwDsR6qC3eTtVj8FSHq1WnV1AbE-FWYTV6xrfDJrDoqOuWoRnjZF6C-MTrcHRZIEmV5b0795X8auFnijPaq4gZy_82UA) + +*MONAI applications developed in collaboration with Kitware include ultrasound-based scoliosis assessment, AI-assisted pathology image labeling, in-field pneumothorax detection using ultrasound, brain morphology characterization, tooth micro-fracture detection, and non-invasive intracranial pressure estimation.* + +## The Impact of MONAI + +King’s College London and NVIDIA are the co-founders of MONAI. [Stephen Aylward, Ph.D.](https://www.kitware.com/stephen-aylward/), senior director of strategic initiatives at Kitware, is the chair of the MONAI [advisory board](https://monai.io/about.html), which includes academic luminaries from across the world. “Kitware has a long-standing relationship with NVIDIA and we are happy to continue working with them to bring MONAI to the medical community,” said Stephen. “As high-quality, open-source software, MONAI will strengthen that community and accelerate the pace of research and development throughout academia and industry.” + +As co-founder, NVIDIA has led much of MONAI’s development. While MONAI doesn’t require the use of NVIDIA GPUs, it significantly benefits from the acceleration they provide. For example, automatic mixed precision and TF32 are enabled on NVIDIA A100 Tensor Core GPUs. “NVIDIA is committed to the long-term success of MONAI — from actively nurturing a thriving open-source community to connecting MONAI into many accelerated platforms, including NVIDIA Clara Holoscan,” said Prerna Dogra, senior manager for healthcare AI products at NVIDIA. “MONAI is a game changer for researchers and developers engaged in medical research across the globe.” + +## Using MONAI: Companion Open Source Platforms + +An AI algorithm is never an end-to-end solution. It must be integrated with the appropriate data pre- and post-processing transformations, application-specific user interfaces, intuitive and interactive visualizations, performant data management systems, and existing workflows. These integrations are achieved using other open-source, Kitware-developed platforms, such as the following: + +* [Insight Toolkit](https://itk.org/) (ITK) for medical image I/O and pre- and post-processing, +* [ITKWidgets](https://www.kitware.com/monai-and-itkwidgets-getting-started/) for interactive 3D data display within jupyter notebooks for AI research, +* [Tensorboard3D](https://www.kitware.com/tensorboardplugin3d-visualizing-3d-deep-learning-models-in-tensorboard/) for exploration of medical AI results and AI experiment optimization, +* [Glance](https://kitware.github.io/glance/doc/) for interactive 3D data visualization of AI results in web applications, +* [3D Slicer](https://docs.monai.io/projects/label/en/latest/quickstart.html) for AI-assisted annotation of radiological images and custom AI modules, +* [Digital Slide Archive](https://monai.medium.com/pathology-image-labeling-comes-to-monai-a033e200e587) for AI-assisted annotation of pathology images, +* [Trame](https://kitware.github.io/trame/) for in-browser data visualization paired with server-side AI computations, +* [MIQA](https://github.com/OpenImaging/miqa) for AI-assisted medical imaging quality assurance. + +This diversity of companion open source software enables the AI algorithms of MONAI to become integral to nearly any existing medical workflow, with minimal installation and maintenance costs. + +## Partnering with Kitware + +Your needs are what drive our passion for creating outstanding software platforms. Deep customer understanding is at the root of everything we do at Kitware, so we operate as an extension of your team and truly get to know your specific challenges and needs. Kitware can apply our domain expertise to help you integrate the power of deep learning into your healthcare medical imaging solutions using the open source MONAI framework. [Contact our team](https://www.kitware.com/contact/project/) for more information. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[3D Slicer](https://www.kitware.com/tag/3d-slicer/) | [Artificial Intelligence](https://www.kitware.com/tag/artificial-intelligence/) | [Glance](https://www.kitware.com/tag/glance/) | [ITK](https://www.kitware.com/tag/itk/) | [ITKWidgets](https://www.kitware.com/tag/itkwidgets/) | [Medical Computing](https://www.kitware.com/tag/medical-computing/) | [MIQA](https://www.kitware.com/tag/miqa/) | [MONAI](https://www.kitware.com/tag/monai/) | [Open Source](https://www.kitware.com/tag/open-source/) | [Tensorboard3D](https://www.kitware.com/tag/tensorboard3d/) | [Trame](https://www.kitware.com/tag/trame/) diff --git a/docs/vitepress/blogs/lidarview-5-0-new-supported-sensors-algorithms-and-more.md b/docs/vitepress/blogs/lidarview-5-0-new-supported-sensors-algorithms-and-more.md new file mode 100644 index 00000000..80d1aa38 --- /dev/null +++ b/docs/vitepress/blogs/lidarview-5-0-new-supported-sensors-algorithms-and-more.md @@ -0,0 +1,197 @@ +[post](https://www.kitware.com/lidarview-5-0-new-supported-sensors-algorithms-and-more/) + +# LidarView 5.0 – new supported sensors, algorithms, and more! + +November 5, 2024 + +[Timothee Couble](https://www.kitware.com/author/timothee-couble/ "Posts by Timothee Couble") and [Gatien Ferret](https://www.kitware.com/author/gatien-ferret/ "Posts by Gatien Ferret") + +![](https://www.kitware.com/main/wp-content/uploads/2024/11/thumbnail.png) + +## LidarView: One software to read and process them all! + +We’ve added to [LidarView](https://lidarview.kitware.com/) several new LiDARs from different manufacturers. They can be used in the same way, regardless of the model, to visualize live streams, replay .pcap records and running algorithms. You can even open two different LiDARs at the same time! + +Here is a current exhaustive list of sensors supported by [LidarView](https://lidarview.kitware.com/): + +[**Velodyne**](https://www.velodyneacoustics.com/en/): VLP-16, VLP-32, HDL-32, HDL-64, Puck LITE, Puck Hi-Res and Alpha Prime (VLS-128). + +[**Hesai**](https://www.hesaitech.com/): Pandar40P, Pandar40M, Pandar64, Pandar20A, Pandar20B, PandarQT, PandarXT-16, PandarXT-32, PandarXTM and Pandar128. + +[**Robosense**](https://www.robosense.ai/en): RS16, RS32, BPearl, Helios (16 & 32), Ruby (48, 80 & 128), Ruby Plus (48, 80 & 128), M1, M2 and E1. + +[**Livox**](https://www.livoxtech.com/): Mid-360 and HAP. + +[**Leishen**](https://www.lslidar.com/): C16, C32 and MS\_C16. + +![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcXExPXkD5ZVVuZ9t68lOUyIrMzU3jO0zUWvglZF27Ux7ONxLUDVX55QqeLTJncZ-ZhAEKm5HK-gUuT3Qrk1Ch53cMC80QcTSMFmIxhHg2Jl5glDi2kKZFttcB_jtfj2i8YqvL70e_-uOZZH9xmO8YXf7z3?key=CP0dasOOrcWuC0b8kWKI3Q) + +Are you using a sensor that is not supported here and you would like to have it supported? + +* Check [here](https://gitlab.kitware.com/LidarView/lidarview/-/blob/master/README.md?ref_type=heads#introduction) if it isn’t already supported on the master branch as this keeps evolving ( Other Livox sensors are coming up very soon !). +* If not, and that there are public drivers / specifications for them [contact us](https://www.kitware.eu/contact/) so that we can add them. +* If you are yourself developing a sensor, or that you have access to specific drivers / specifications, [contact us](https://www.kitware.eu/contact/) to implement a dedicated plugin (which may stay private if the information used for this is not publicly available). + +For ROS2 users: you can now also read .mcap files in LidarView. This means that you may have access to the whole UI, visualization capabilities and set of algorithms of the software on your data recorded in ROS2. + +## Make LidarView easier to use! + +### LidarView now has 3 modes for simpler interactions + +**The Lidar Viewer mode :** This is the default mode for the simple usage of having a software to visualize live sensor feed, save recordings ( in the form of pcap files), replay those recordings and have access to simple visualization parameterization and data interaction capabilities. + +In previous versions of LidarView (and in VeloView), this was the default mode ( when not switching to “Advanced Mode”). + +For a simpler interface, the Pipeline Browser is hidden from this mode. + +**The Point Cloud Tool mode :** This mode is intended to give access to the still point cloud processing tools of LidarView. In this mode, the time player is not available anymore and Temporal filters are hidden. This can typically be used whenever you have a collected point cloud to process, either using the ParaView functionalities, or the LidarView point cloud specific filters. + +This mode brings LidarView closer to other 3D point cloud processing software + +**The Advanced Mode** : This mode contains all of LidarView capabilities, including any algorithm available in the point cloud Tool mode, the LiDAR player, and all of the filters available in LidarView. + +Those modes are configured with a configuration file ( [interface\_modes\_config.json](https://gitlab.kitware.com/LidarView/lidarview/-/blob/master/Application/Qt/ApplicationComponents/Resources/interface_modes_config.json) file in the share folder of the installation tree), which you can edit manually if you require to customize it even more without having to recompile LidarView. + +![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXewyPXNgMqzppLhC0XT9Q2bMCEiyft3EIPzzzpU21glfRALig6iF_aqOF0L46WysHfM-XgjCUJr3nebdwKhvAb662f9ispPM0rGnxPdMlmWkoX6IiTAvPBcZCQFYtUKUqwOAeyVOGZInsOuGu82RYRKQJx8?key=CP0dasOOrcWuC0b8kWKI3Q) + +In the future, we plan to create modes for specific usages with specific sets of toolboxes, for examples: + +* Point Cloud Statistics toolbox +* Automotive LiDAR setup +* Building Modelling with LiDAR scans +* LiDAR for intersection monitoring +* Big point cloud handling (such as city scale aerial scans) +* … + +Let us know which application you would like to tailor Lidarview for! + +### Lidar Configuration dialog updates + +Some LiDAR require intrinsic calibration files, which contains some correction parameters for each individual sensor estimated at the end of the production line. Though when high precision is not required, default ones are enough, and some are provided within LidarView. Some models embed this calibration within the streamed data and therefore do not require such a file ( see each sensor datasheet for more details). + +Now you may directly select the sensor model you want to work with, and if required, default files will be used automatically. + +You may still use your own files provided by the manufactures for the relevant sensors. + +Those options are now saved for later usage, avoiding having to switch between configs if you are working with various sensors. + +### Toolbar for SLAM ! + +LidarView embeds a state of the art LiDAR SLAM algorithm which is widely configurable to your use case and sensor. + +It is based on an external [open source library](https://gitlab.kitware.com/keu-computervision/slam) that we develop at Kitware, which can also be embedded in ROS/ROS2 environment or even your own software. More details about it in our previous [blogpost](https://www.kitware.com/lidar-slam-spotlight-on-kitwares-open-source-library/). + +On top of registering frames one after the other, it embeds the following features : + +* External sensor fusion : IMU, GNSS,INS, Wheel Odometer, Features from cameras +* Loop closure detection and optimization +* Relocalization in an input map +* Dynamic object removal +* Frame Aggregation for dense maps +* … + +As we know that setting it up and fine tuning it may be a bit tedious, we have added a toolbar to help novice users do it in the most common cases. + +In particular this include : easy setup of the SLAM, default configuration depending on the LiDAR model and environment, dialog for adding external sensor information and for loop closure management. + +This should help you tackle the most common use cases for SLAM algorithms, and feel free to contact us for more challenging ones! + + + +
*SLAM toolbar demo*
+ +## New filters! + +New functionalities have been introduced in LidarView: object tracking based on still point clouds and volume measurement. + +### Motion detector + +The motion detection algorithm highlights all moving points and can even cluster and track them! It requires only a few frames for initialization and stationary LiDAR data. + +It should be tuned according to the LiDAR properties, the range of interest and the sizes of the objects involved + + + +
*Motion detection applied to person detection and tracking in an office environment*
+ +### Volume measurement + +We have added some functionalities to allow for measuring volumes or real objects in point clouds. + +As of now, this calculates the volume contained between a portion of the point cloud (your object of interest) and an underlying plane. It could be extended with other variants depending on the use case. + +This may be used for instance in material stock assessment. + +Input point clouds may come from direct complete scans or be constructed with SLAM as in the example below. + +![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdBTjr2EBOwcwDOCofJE6Y0FGWJicJLQuuA1WZ92k_TbWuBWWTNd6xxWPxCw0Fp_QyzVqmA4hHcwrmInIEUNMnuTqfOkef2YSbEeFaNCU6Woz0fQBtgSEd5B1W8tI0xs-cJxynDNPU0Cb-fPkzw7mKprFx4?key=CP0dasOOrcWuC0b8kWKI3Q) + +
*Toy example of a box in a SLAM reconstructed point cloud of our office.*
+ +## LidarView Client Server mechanism, connectivity and web applications ! + +Similar to its big brother ParaView, LidarView now allows the client server connection. + +As for Paraview, you can now handle large data hosted on a high performance computer from your desktop client, see [this guide](https://www.kitware.com/paraview-hpc-scalability-guide/) for such usage. + +To give an idea of what is now possible, here is an example of such a visualization using WebGPU technology to visualize large scale aerial LiDAR scans (not yet integrated in ParaView / LidarView, more details in that [blogpost](https://www.kitware.com/achieving-interactivity-with-a-point-cloud-of-2-billion-points-in-a-single-workstation/)) + +Deriving from this: one can now also connect to a distant server for remote visualization, meaning having for instance a mobile robot acquiring data and acting as a server streaming resulting images to your client desktop app (warning: this is a stretch from the ParaView inherited server mechanism and has some limitations). + +### Web visualization and interaction + +LidarView can now connect to a python [trame](https://www.kitware.com/trame/) application and expose its functionalities there. + +![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXd-LjnVnFCQDptYPOoi1cpBntTsFfczSM_Ct604Ti25bjp5DjlVTDgjFHVSbvJx9Qms08U19k34kmM8RupKOuaw7IjV_3PsN7o6Iij7bnpWRZE6oalTABbBF67RrLpqs-xl2-7oH_R7OvXJfajFmxcoXWdB?key=CP0dasOOrcWuC0b8kWKI3Q) + +
*Control the SLAM algorithm through a web page written in trame!*
+ +### Outputting data from LidarView to other programs + +We added 2 examples outputting data through UDP: + +* A generic [UDP exporter](https://gitlab.kitware.com/LidarView/lidarview-core/-/blob/master/LidarCore/IO/Network/vtkUDPPointSender.cxx?ref_type=heads) for point data (which includes data such as SLAM trajectories). +* A specific [exporter](https://gitlab.kitware.com/LidarView/lidarview-core/-/blob/master/Plugins/MotionDetectorToolbox/IO/vtkDetectedClusterUDPSender.cxx?ref_type=heads) for detected objects in 3D. + +## Conclusion + +[LidarView 5.0](https://lidarview.kitware.com/) is a big leap towards universal LiDAR viewer and processing tool, Kitware is dedicated to make this tool evolve by: + +* Expanding the list of supported devices. +* Adding base algorithms for LiDAR point cloud processing. +* Adding domain specific algorithms and interfaces. + +You may download the latest [LidarView](https://lidarview.kitware.com/) version and check the full release notes from the [release](https://gitlab.kitware.com/LidarView/lidarview/-/releases) page. + +Contact us to let us know how you would use it, and how it can be adapted to your LiDAR data workflow! + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Computer Vision](https://www.kitware.com/tag/computer-vision/) | [ITS](https://www.kitware.com/tag/its/) | [Lidar](https://www.kitware.com/tag/lidar/) | [LidarView](https://www.kitware.com/tag/lidarview/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Point Cloud](https://www.kitware.com/tag/point-cloud/) | [Sensors](https://www.kitware.com/tag/sensors/) | [slam](https://www.kitware.com/tag/slam/) | [Trame](https://www.kitware.com/tag/trame/) | [UDP](https://www.kitware.com/tag/udp/) diff --git a/docs/vitepress/blogs/make-your-automotive-simulation-tools-available-on-the-web.md b/docs/vitepress/blogs/make-your-automotive-simulation-tools-available-on-the-web.md new file mode 100644 index 00000000..3adae3cf --- /dev/null +++ b/docs/vitepress/blogs/make-your-automotive-simulation-tools-available-on-the-web.md @@ -0,0 +1,75 @@ +[post](https://www.kitware.com/make-your-automotive-simulation-tools-available-on-the-web/) + +# Make Your Automotive Simulation Tools Available on the Web + +August 21, 2024 + +[Cory Quammen](https://www.kitware.com/author/cory-quammen/ "Posts by Cory Quammen") and [Bob O'Bara](https://www.kitware.com/author/bob-obara/ "Posts by Bob O'Bara") + +![Visualization of a car in a wind tunnel](https://www.kitware.com/main/wp-content/uploads/2024/08/OnlineWindTunnel.jpg) + +We use websites to do everything, from communicating with friends and family and paying bills, to shopping for cars, and visiting the doctor. Even at work we rely heavily on the web because it provides a platform for wide-spread and easy access to applications. Web browsers are highly effective at delivering applications with excellent user experiences. + +It’s only natural, then, for engineers to also want easy access to web solutions for their design and simulation modeling. For automotive engineers in particular, having easy and shared access is critical since the overall process involves large teams of engineers and designers working on different parts of the automotive design problems. While tasks such as setting up, running, and analyzing simulations of automobile parts and components have historically been done with desktop software on high-end workstations or on high-performance computers involving proprietary product management systems, these can now all be handled on the web. + +## Simplifying workflows + +Depending on the simulation technology, developing each product or component simulated typically involves the following workflow:: + +* Model creation using CAD or another modeling technique +* Mesh creation +* Preprocessing to define material properties, boundary conditions, and other initial conditions +* Running the simulation itself +* Post-processing and analysis to determine results + +Simulation workflows have been around for decades, but executing them is not always as easy as it could be. Each step in a workflow may require using disparate, specialized tools, each with its own quirks and limitations. In addition, many automotive workflows require physics to be modeled requiring multiple sub-workflows with different geometry, meshes, simulation information, and solvers. The use of all these tools to set up simulations can be difficult – making it easier would help automotive design engineers. This is supported by [2023 survey of computational fluid dynamics (CFD) software trends by Engys](https://blog.engys.com/2023-cfd-technology-trends/) where 47% of respondents agreed that easier model preparation for simulation would significantly help them in their CFD projects. + +Simulation software companies are seeing a demand for integrated and easier to use software packages, and are responding in their latest software releases. Recently, popular simulation software packages such as [Fluent](https://www.ansys.com/products/fluids/ansys-fluent/ansys-fluent-trial) from Ansys, [HyperWorks](https://altair.com/altair-hyperworks) from Altair, and [Fidelity](https://www.cadence.com/en_US/home/tools/system-analysis/computational-fluid-dynamics/fidelity.html) from Cadence have focused on integrating their simulation tools under more intuitive user interfaces. The end goal is to provide a unified interface to the entire workflow to improve efficiency and reduce the costs associated with simulation. + +In addition to providing unified interfaces to different parts of the workflow, modern simulation software is also providing more simplified workflows. These workflows expose only key parameters of a simulation scenario and hide away the full complexity of the simulation tools available. Simplifiying workflows increase the number of engineers who can access simulation tools in a way that is meaningful to their expertise, without requiring them to be experts in the full details of the simulation software. + +## The web advantage + +The broad accessibility of web applications means that people can more easily access their work and share information with colleagues and customers. If a unified interface to simulation software is made available through the web, then everyone with an internet connection and web browser can readily create and access simulation results. The ubiquity of web browsers on devices means people can access web applications from their laptops, workstations – even their smartphones. Contrast this to the long-time status quo where running simulations was limited to workstations or high-performance computer systems where data must be processed and reports generated before distribution of results is possible. + +Web applications also remove the burdens inherent in installing and keeping software up to date on desktop or laptop systems. Software upgrades and enhancements happen behind the scenes, letting web users focus on the task at hand rather than wrangling software. Centralized installation reduces the system administration required to provide simulation and modeling tools. + +## Stepping into the future + +The trend towards simplified workflows in simulation software is encouraging and something we will see much more of in coming years. Engineers would rather focus on the engineering problem they are trying to solve rather than problems with their simulation workflow and software tooling. By packaging workflows nicely and *making them* accessible on the web, simulation solution providers will provide great cost savings to their customers as time-to-solution is reduced and increase demand for their software as access to it is broadened across the enterprise. + +Automotive manufacturers can see additional benefits by expanding the use of simulation by people who are not computational scientists but need the results of simulations to make engineering or process decisions. One way to do this is for a simulation expert to provide curated simulations they can run and analyze themselves, eliminating expensive bottlenecks that can happen when only expert computational scientists can run needed simulations. With the rise of digital twins that inform real-world system operations based on simulation scenarios, this broader access will be essential in maximizing the value they bring to manufacturing and logistics. + +Kitware has extensive experience in providing accessible simulation workflows on the web. By using a framework like [trame](http://trame.kitware.com), we can dynamically generate user interfaces for input parameters to set up a simulation and integrate state-of-the-art web-ready rendering solutions like [VTK](https://www.vtk.org/) and [ParaView](https://www.paraview.org/) for post-processing when the simulation is running or finished. We can help or build it all for you and help with your web strategy to simplify your customer’s lives. If you want to learn more on how Kitware can help you, [please contact us](https://www.kitware.com/contact/project/). + +You can learn more about Kitware’s efficient simulation workflow solutions for automotive manufacturers by visiting our [Automotive Solutions](https://www.kitware.com/automotive/) page. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Automotive Simulation](https://www.kitware.com/tag/automotive-simulation/) | [ParaView](https://www.kitware.com/tag/paraview/) | [simulations](https://www.kitware.com/tag/simulations/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) | [web](https://www.kitware.com/tag/web/) + diff --git a/docs/vitepress/blogs/making-modeling-and-simulation-tools-accessible-on-the-web.md b/docs/vitepress/blogs/making-modeling-and-simulation-tools-accessible-on-the-web.md new file mode 100644 index 00000000..67213f1f --- /dev/null +++ b/docs/vitepress/blogs/making-modeling-and-simulation-tools-accessible-on-the-web.md @@ -0,0 +1,56 @@ +[post](https://www.kitware.com/making-modeling-and-simulation-tools-accessible-on-the-web/) + +# Making Modeling and Simulation Tools Accessible on the Web + +October 15, 2024 + +[Cory Quammen](https://www.kitware.com/author/cory-quammen/ "Posts by Cory Quammen") + +![visualization of wind](https://www.kitware.com/main/wp-content/uploads/2024/08/Model-Sim-Web-Q4-2024-Feature.jpg) + +In today’s fast-paced digital landscape, making advanced modeling and simulation tools available on the web is essential for teams that need to collaborate and scale their workflows. But how can you effectively transition these tools to a browser-based environment while ensuring smooth performance and user-friendly interfaces? + +In this free webinar, our experts provide a comprehensive guide on how open source software solutions can help you create and deploy web-based modeling and simulation applications. Whether you’re looking to set up a web user interface, integrate 3D rendering for pre- and post-processing, or enhance analysis with plotting tools, this webinar covers everything you need to know. + +**Key Takeaways:** + +* **Web-Based User Interfaces:** Learn which tools can help you build intuitive, interactive interfaces for your simulation workflows. +* **3D Rendering:** Explore the best open source software for providing real-time, high-performance 3D rendering, including VTK, vtk.js, and ParaView. +* **Data Analysis and Visualization:** Discover how to integrate plotting tools and generate reports directly in the browser. +* **End-to-End Workflows:** Find out how platforms like trame can simplify and accelerate the development of your web applications, allowing you to handle everything from data input to simulation and result visualization. + +## Who Should Watch? + +This webinar is perfect for developers, engineers, and researchers who want to make their simulation tools accessible on the web without sacrificing performance. If you’re looking for a scalable, open source solution to transform your workflows, this recording is a must-watch. + +Ready to bring your modeling and simulation tools to the web? [Watch the webinar recording now!](https://www.kitware.com/webinars/making-modeling-and-simulation-widely-available-on-the-web/#register) + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Modeling Tools](https://www.kitware.com/tag/modeling-tools/) | [Simulation Tools](https://www.kitware.com/tag/simulation-tools/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) | [webinar](https://www.kitware.com/tag/webinar/) + diff --git a/docs/vitepress/blogs/medical-technology-trends-to-watch-in-2025.md b/docs/vitepress/blogs/medical-technology-trends-to-watch-in-2025.md new file mode 100644 index 00000000..32d2d52c --- /dev/null +++ b/docs/vitepress/blogs/medical-technology-trends-to-watch-in-2025.md @@ -0,0 +1,88 @@ +[post](https://www.kitware.com/medical-technology-trends-to-watch-in-2025/) + +# Medical Technology Trends to Watch in 2025 + +March 3, 2025 + +[Andinet Enquobahrie](https://www.kitware.com/author/andinet-enquobahrie/ "Posts by Andinet Enquobahrie"), [Beatriz Paniagua](https://www.kitware.com/author/beatriz-panigua/ "Posts by Beatriz Paniagua"), [Rachel Clipp](https://www.kitware.com/author/rachel-clipp/ "Posts by Rachel Clipp"), [Jean-Christophe Fillion-Robin](https://www.kitware.com/author/jchris-fillionr/ "Posts by Jean-Christophe Fillion-Robin"), [Shreeraj Jadhav](https://www.kitware.com/author/shreeraj-jadhav/ "Posts by Shreeraj Jadhav") and [Jared Vicory](https://www.kitware.com/author/jared-vicory/ "Posts by Jared Vicory") + +![Medical Trends for 2025](https://www.kitware.com/main/wp-content/uploads/2025/03/Medical-Trend-2025_blog-feature.jpg) + +Medical technology is advancing rapidly, reshaping patient care, diagnostics, and treatment strategies. With advances in AI, real-time patient monitoring, and cloud-based visualization, healthcare professionals now have access to tools that improve efficiency, enhance patient outcomes, and expand the reach of medical innovations. + +As we step into 2025, several emerging technologies stand out for their potential to transform the industry. Whether it’s AI-powered diagnostics, edge computing, or web-based visualization, these advancements are redefining how medical professionals interact with data and make critical decisions. Here are five key medical technology trends to watch this year. + +### 1) Artificial Intelligence Integration + +AI is rapidly becoming one of the most valuable tools in medical imaging and diagnostics. Through automated analysis of complex datasets, AI-based algorithms can help clinicians detect diseases earlier, improve diagnostic accuracy, eliminate human errors, and reduce the time required to interpret medical scans. These AI-driven models are particularly effective in identifying subtle patterns in images that might be difficult for the human eye to catch, making them invaluable in fields such as radiology, cardiology, and oncology. + +The application of AI is also extending into real-time decision support, where it can assist physicians by offering predictive insights into patient conditions. One example of this is Kitware’s collaboration with ARPA-H, where we are developing AI-powered ultrasound technology to [detect congenital heart disease in newborns](https://www.kitware.com/kitware-to-develop-ai-powered-ultrasound-that-can-more-accurately-detect-congenital-heart-disease/). + +One of the biggest challenges in developing AI models for medical applications is the need for large, diverse, and well-annotated datasets. Medical imaging data is often difficult to obtain due to privacy concerns, patient consent regulations, and the cost and time required to manually label images. Furthermore, real-world datasets can be imbalanced, meaning that AI models might not be adequately trained to recognize rare conditions. This is where synthetic data is becoming an essential tool in AI model development. Synthetic data is artificially generated medical images that mimic real-world data, enabling AI algorithms to train on a much broader and more diverse set of examples. By augmenting training datasets with synthetic data, AI models can improve their robustness, reduce bias, and generalize better to real-world cases. Consequently, synthetic data generators will become more widely available in the coming year. In fact, Kitware recently launched [X-ray Genius](https://www.kitware.com/create-a-free-account-and-explore-our-synthetic-x-ray-image-generation-tool/), which provides a scalable solution for generating synthetic X-ray images. Kitware has also used the [Pulse Physiology Engine](https://pulse.kitware.com/) to represent virtual in silico trials and generate synthetic patient populations in the physiological human space to test [treatments](https://www.kitware.com/project-spotlight-afrl-mechanical-ventilation-simulation/). + +### 2) Edge Computing for Faster and Smarter Healthcare + +Edge computing is revolutionizing healthcare by enabling real-time data processing closer to the point of care rather than relying on cloud-based infrastructure. This shift reduces latency, enhances security, and ensures that medical devices can operate independently, making real-time decision-making more efficient. + +This technology allows for faster data processing in critical environments such as emergency rooms, intensive care units, and surgical suites, leading to quicker diagnoses and improved patient outcomes. Wearable health devices, AI-assisted surgical tools, and portable imaging systems are also benefiting from this technology, allowing for rapid analysis without the need for constant internet connectivity. + +Kitware is actively exploring how visualization tools like the Visualization Toolkit (VTK) can enhance edge computing devices, including [integration with NVIDIA’s Holoscan SDK](https://www.kitware.com/bringing-cutting-edge-visualization-to-nvidia-holoscan/). By incorporating advanced rendering capabilities into edge computing pipelines, medical researchers and product developers can create high-performance applications that improve both clinical decision-making and medical imaging workflows. Kitware has also helped customers upgrade their AI computational pipelines to Holoscan SDK and harness its special capabilities to move data efficiently and directly from sensor to GPU. By harnessing the GPUDirect capabilities supported by the Holoscan SDK and partnering hardware vendors, AI and (Augmented Reality) AR pipelines can overcome performance bottlenecks for achieving interactive or near real-time inference and rendering frame rates. Kitware and collaborators on DARPA’s [Perceptually-enabled Task Guidance](https://www.darpa.mil/research/programs/perceptually-enabled-task-guidance) program have used edge computing with XR-powered tools to provide real-time guidance in medical training environments. The HoloLens 2 is used to stream egocentric video and audio data of trainees performing medical tasks to a laptop. The data is processed in real-time to detect relevant objects, the user’s hands, and the manikin pose to predict what task step the trainee is performing. Our augmented reality interface includes an embodied AI agent that leverages an LLM to answer questions and provide next task guidance based on the objects detected and task steps in the context window. Real-time task monitoring and guidance can be a force multiplier for medic trainers, giving feedback as the trainee learns tasks, recording videos for after action review, and giving the trainer quantified feedback about the trainee’s performance. + +### 3) Digital Twin Simulation for Personalized Healthcare + +Digital twin simulation is revolutionizing healthcare by creating virtual models of individual patients, enabling personalized treatment planning, surgical simulations, and AI-powered patient monitoring. These virtual replicas help predict how a patient’s body will respond to treatments, surgical interventions, or disease progression. + +At Kitware, we incorporate high-fidelity 3D models that represent [anatomically accurate representations](https://salt.slicer.org/) of human organs into commercial and research software solutions. These models help study the impact of pathology and disease, as well as improve surgical planning and interventions. + +Digital twins can also be used in medical education and training, providing realistic simulations for students and clinicians to practice complex procedures in a risk-free environment. The [Pulse Physiology Engine](https://pulse.kitware.com/) supports medical simulation and AI-driven physiological modeling, allowing for real-time monitoring of patient health and personalized healthcare interventions. + +### 4) Web-based Medical Visualization For Accessibility and Collaboration + +The increasing adoption of web-based medical applications is transforming how healthcare professionals access and interact with data. Traditionally, medical imaging and simulation tools have required specialized software, limiting their accessibility and collaboration potential. Now, with advancements in web technologies, powerful visualization and analysis tools can be accessed directly through a browser, enabling seamless integration across hospitals, research institutions, and telemedicine platforms. This shift is particularly beneficial in remote and underserved areas, where cloud-based solutions allow for real-time collaboration and second opinions from experts around the world. + +At Kitware, we are actively advancing web-based medical visualization through [vtk.js](http://vtk.js), [Volview](https://volview.kitware.com/) and [trame](https://www.kitware.com/trame/), our open source framework that enables developers to build interactive, web-based visualization applications for medical imaging, digital therapeutics, and patient engagement. A major focus for 2025 is the integration of trame with 3D Slicer, an open-source platform for medical image computing. This work is paving the way for seamless, high-performance 3D medical image visualization directly in the browser, eliminating the need for complex software installations. By leveraging modern web technologies, trame makes it possible to interact with large medical datasets in real time, enabling new possibilities for collaborative diagnostics, remote consultations, and surgical planning. + +By reducing barriers to access and enhancing the user experience, web-based medical applications built with trame will improve efficiency, facilitate collaboration, and expand the reach of advanced healthcare technologies. As medical visualization moves to the web, Kitware is at the forefront of this transformation, ensuring that cutting-edge tools are accessible to clinicians and researchers anytime, anywhere. + +### 5) Generative AI: Transforming Clinical Decision-Making + +Generative AI is making a profound impact on healthcare, from generating synthetic medical images for AI model training to assisting clinicians with complex decision-making. **Large Language Models** (LLMs)—a type of generative AI—can create entirely new content, supporting applications in clinical documentation, medical chatbots, and AI-powered research. Generative AI is also being explored for its potential to support ethical decision-making that aligns with key decision-making attributes (KDMAs) or values of trusted human decision-makers in high-stakes scenarios, such as medical triage. One example of this is Kitware’s involvement in the DARPA ITM ([In The Moment](https://www.kitware.com/kitware-secures-11-5m-multi-year-darpa-contract-to-teach-ai-how-to-make-difficult-decisions-aligned-with-humans/)) program, which aims to develop AI systems that can assist humans in making difficult medical decisions under pressure. As part of this effort, Kitware is leading the development of the Aligned Moral Language Models with Interpretable and Graph-based Knowledge (ALIGN) system, which generates human-trusted medical decisions that align with KDMAs while providing natural language explanations for its reasoning. By dynamically adapting to different users and generalizing to various scenarios, ALIGN aims to produce a more responsible, equitable, and traceable solution with little to [no training data](https://www.kitware.com/naacl-2024/). + +## Looking Ahead: Shaping the Future of Medical Technology + +As 2025 unfolds, these five medical technology trends will continue to push the boundaries of what’s possible in healthcare. From improving diagnostic speed and accuracy to enabling real-time decision-making and expanding accessibility, these innovations are paving the way for a more efficient, intelligent, and patient-centered healthcare system. + +For organizations looking to integrate these cutting-edge technologies into their medical solutions, staying ahead of these trends will be key to driving meaningful impact. + +**Are you ready to integrate these technologies into your medical solutions?** +Kitware’s expertise in AI, visualization, and simulation can help bring these advancements into your workflow. [Let’s talk](https://www.kitware.com/contact/) about how we can collaborate to shape the future of healthcare. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[3D Slicer](https://www.kitware.com/tag/3d-slicer/) | [Artificial Intelligence](https://www.kitware.com/tag/artificial-intelligence/) | [Digital Twins](https://www.kitware.com/tag/digital-twins/) | [Edge Computing](https://www.kitware.com/tag/edge-computing/) | [Generative AI](https://www.kitware.com/tag/generative-ai/) | [Holoscan](https://www.kitware.com/tag/holoscan/) | [Large Language Models](https://www.kitware.com/tag/large-language-models/) | [Machine Learning](https://www.kitware.com/tag/machine-learning/) | [Medical Computing](https://www.kitware.com/tag/medical-computing/) | [Pulse Physiology Engine](https://www.kitware.com/tag/pulse-physiology-engine/) | [Trame](https://www.kitware.com/tag/trame/) | [X-Ray Genius](https://www.kitware.com/tag/x-ray-genius/) + diff --git a/docs/vitepress/blogs/microscopy-microanalysis.md b/docs/vitepress/blogs/microscopy-microanalysis.md new file mode 100644 index 00000000..cba70c7f --- /dev/null +++ b/docs/vitepress/blogs/microscopy-microanalysis.md @@ -0,0 +1,102 @@ +[post](https://www.kitware.com/microscopy-microanalysis/) + +# Microscopy & Microanalysis + +July 10, 2024 + +[Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Sankhesh Jhaveri](https://www.kitware.com/author/sankhesh-jhaveri/ "Posts by Sankhesh Jhaveri") and [Brandon Adamczyk](https://www.kitware.com/author/brandon-adamczyk/ "Posts by Brandon Adamczyk") + +![Microscopy & Microanalysis Conference. July 28 - August 1, 2024.](https://www.kitware.com/main/wp-content/uploads/2024/07/M_M_2024-scaled.jpg) + +### **July 28 – August 1, 2024 in Cleveland, Ohio** + +Microscopy and Microanalysis (M&M) is the premier microscopy education and networking event that brings together researchers, academics, and engineers. Kitware is excited to be exhibiting this year to showcase three of our open source applications – [Tomviz](http://tomviz.org/), [trame](https://trameapp.kitware.com/), and [MultivariateView](https://github.com/Kitware/multivariate-view). Kitware can partner with you to research new visualization and analysis techniques and customize these tools to meet your needs. To learn more, [contact our team](https://www.kitware.com/contact/project/) or visit us at [Booth 335](https://s23.a2zinc.net/clients/corcexpo/MSA2024/Public/Eventmap.aspx?EventId=189&MapID=216&MapItBoothID=283462&MapItBooth=335). + +## Vendor Tutorials + +**trame: An Open Source Framework for Efficiently Building Interactive Visualization and Analysis Applications***Monday July 29 and Wednesday July 31, 2024 +5:45 PM – 6:45 PM*[Booth 335](https://s23.a2zinc.net/clients/corcexpo/MSA2024/Public/Eventmap.aspx?EventId=189&MapID=216&MapItBoothID=283462&MapItBooth=335) +In this hands-on demonstration, learn how to utilize trame for quickly building applications to accelerate your research and expedite your workflows through interactive visual analysis and exploration. + +**Tomviz: Leverage Your 3D Tomographic Data** +*Tuesday July 30, 2024 +5:45 PM – 6:45 PM* +[Booth 335](https://s23.a2zinc.net/clients/corcexpo/MSA2024/Public/Eventmap.aspx?EventId=189&MapID=216&MapItBoothID=283462&MapItBooth=335) +In this hands-on demonstration, learn how to utilize Tomviz as a complete analysis pipeline for 3D tomographic data including alignment, reconstruction, segmentation, and interactive 3D visualization. + +## Multivariate Volume Visualization Presentation + +**Multivariate Volume Data: Achieving Deeper Insight through Multivariate Volume Rendering and Machine-Guided Exploration** +Presenter: [Patrick Avery, Ph.D.](https://www.kitware.com/patrick-avery/) Staff R&D Engineer +*Wednesday July 31, 2024 +11:30 AM – 11:45 AM* + +Detailed analysis of nanoscale imaging data plays an important role in guidance for future experiments and successful scientific discoveries. However, increasing complexity and production of nanoscale imaging data have made this analysis more difficult, and, in some situations, infeasible. Multivariate volumetric data, which contains more than one channel per voxel, has become increasingly prevalent in important industries such as battery technology. Due to its multidimensional nature, however, multivariate data is complex and usually requires substantial human effort to analyze. Oftentimes, each channel is visualized separately and individually. However, this does not reveal the complex yet frequently important interactions between the channels. + +The open source prototype [MultivariateView](https://github.com/Kitware/multivariate-view) is actively being developed to solve many of these challenges. Funded by a DOE Phase I SBIR, and based upon the [RadVolViz application](https://www3.cs.stonybrook.edu/~mueller/papers/TVCG%20RadVolViz.pdf), we are actively building prototypes and exploring new techniques to visualize and analyze many channels in volumetric data simultaneously. + +In our presentation, we will demonstrate the current status of our research efforts, along with our ideas and plans for the near future. + +![](https://www.kitware.com/main/wp-content/uploads/2024/07/multivariate-1-1024x643.jpg) + +![](https://www.kitware.com/main/wp-content/uploads/2024/07/multivariate-2-1024x808.jpg) + +## trame Presentation + +**trame: an Open Source Framework for Efficiently Building Interactive Visualization and Analysis Applications** +Presenter: [Patrick Avery, Ph.D.](https://www.kitware.com/patrick-avery/) Staff R&D Engineer +*Wednesday July 31, 2024 +2:45 PM – 3:00 PM* + +![Example of how an open source framework can efficiently build visually stunning, interactive web applications for scientific visualization and analysis](https://www.kitware.com/main/wp-content/uploads/2024/07/image2.png) + +Designed to integrate seamlessly with the industry-leading open source visualization platforms VTK and ParaView, trame compactly and intuitively enables complete control of 2D and 3D data processing and visualization pipelines. From exploring new visualization and analysis techniques, to optimizing AI training and inference, trame has the potential to accelerate your research and help you exceed your goals. + +Designing web applications traditionally requires knowledge of several programming languages, such as JavaScript for the client and Python for the server. trame, however, simplifies development so that web applications may be written completely in Python, one of the most concise and widely-known programming languages. The entire UI layout, including 2D and 3D render windows and widgets such as buttons, sliders, drop-down menus, etc. can be defined in pure Python. The use of Python also provides access to the wide variety of state-of-the-art open source scientific and mathematical packages available to the Python community. trame’s write-once, run-anywhere paradigm also provides great flexibility for deployment, from desktop to cloud, Jupyter and HPC. + +In our presentation, we will show you how our open source framework can efficiently build visually stunning, interactive web applications for scientific visualization and analysis. + +## Tomviz Poster Presentation + +**Combining Interactive and Automatic Volume Registration Techniques in Tomviz** +Presenter: [Patrick Avery, Ph.D.](https://www.kitware.com/patrick-avery/) Staff R&D Engineer +*Wednesday July 31, 2024 +3:00 PM – 5:00 PM* + +![](https://www.kitware.com/main/wp-content/uploads/2024/07/tomviz-1-1024x651.jpg) + +Tomviz is a cross-platform, open source tool for the visualization and analysis of tomography data. Built on top of the industry-leading open source visualization platforms ParaView and VTK, Tomviz provides state-of-the-art rendering techniques and a broad collection of tools for image processing such as tilt image alignment, tomographic reconstruction, histograms, filters, user-customized Python scripts, and many researcher-contributed algorithms. + +In this poster presentation, we will discuss a new “Manual Manipulation” operator that facilitates manual registration through familiar visualization scene interactions. When the user aligns the volume to another volume through ordinary camera interactions, this operator tracks these interactions in order to populate registration parameters (including shift, rotate, and scale), which are then performed on the underlying data. + +We will also discuss a new Elastix-based “Registration” operator that may be performed to automatically align two volumes, often immediately after manual alignment has been performed. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Artificial Intelligence](https://www.kitware.com/tag/artificial-intelligence/) | [Conference](https://www.kitware.com/tag/conference/) | [Data and Analytics](https://www.kitware.com/tag/data-analytics/) | [Digital Pathology](https://www.kitware.com/tag/digital-pathology/) | [Tomviz](https://www.kitware.com/tag/tomviz/) | [Trame](https://www.kitware.com/tag/trame/) + diff --git a/docs/vitepress/blogs/numerical-plasma-dynamics-from-the-comfort-of-your-web-browser-with-trame.md b/docs/vitepress/blogs/numerical-plasma-dynamics-from-the-comfort-of-your-web-browser-with-trame.md new file mode 100644 index 00000000..c896b96b --- /dev/null +++ b/docs/vitepress/blogs/numerical-plasma-dynamics-from-the-comfort-of-your-web-browser-with-trame.md @@ -0,0 +1,73 @@ +[post](https://www.kitware.com/numerical-plasma-dynamics-from-the-comfort-of-your-web-browser-with-trame/) + +# Numerical plasma dynamics from the comfort of your web browser with trame + +December 8, 2022 + +[Julien Finet](https://www.kitware.com/author/julien-finet/ "Posts by Julien Finet") and [Helene Grandmontagne](https://www.kitware.com/author/helene-grandmontagne/ "Posts by Helene Grandmontagne") + +![](https://www.kitware.com/main/wp-content/uploads/2022/12/Sans-titre3.png) + +Showing off [boltzplatz](https://boltzplatz.eu/)’s expertise in numerical plasma dynamics and how [trame](https://kitware.github.io/trame/index.html) – a web framework from Kitware – was crucial in the rapid development of boltzplatz’s web application. + +## boltzplatz – numerical plasma dynamics GmbH + +boltzplatz is a Stuttgart-based company offering engineering and consulting services for high-tech companies focusing on vacuum- and plasma-based technologies. They develop and maintain the open-source library [PICLas,](https://github.com/piclas-framework/piclas/) cooperatively with the Institute of Space Systems (University of Stuttgart). PICLas is a flexible particle-based plasma simulation suite for numerical simulation of rarefied plasma flows under the influence of electromagnetic interactions. + +As the topic of numerical plasma dynamics is very complex in its own right, naturally, PICLas offers many parameters that a user can configure, including what particle species appear in the simulation together with their energy levels, vibrational states and so on. On top of that, depending on the input mesh and boundary conditions, computing the simulation on one’s desktop computer becomes infeasible. + +The company’s goal thus was to develop a web application that would allow users to configure simulations through a simplified UI, run the simulations on a remote server, share their results and create analyses and graphics with ParaView to illustrate their outputs. + +![](https://www.kitware.com/main/wp-content/uploads/2022/12/Sans-titre-1024x555.png) + +Fig 1. Pre-processed input mesh file showing a section of a vacuum pump rendered with [ParaView-Visualizer](https://github.com/Kitware/paraview-visualizer/) + +## trame for fast, simple and powerful development + +What was outlined above defines a complex web application that involves a lot of user interaction with the server. With trame, all that is simplified to one programming language. Building an application becomes more about defining your feature set rather than building pieces of your infrastructure. + +Thanks to the powerful, yet simple-to-use web framework, Kitware was able to develop a prototype within a few days and a full web application within a few weeks, which lets users configure, run and post-analyze numerical plasma dynamic simulations. And all done in Python. + +The web application’s UI has a modern feel since trame comes with components built upon Vuetify. The UI to configure PICLas is created dynamically through [SimPut](https://github.com/Kitware/trame-simput/), which is fully supported by trame. + +![](https://www.kitware.com/main/wp-content/uploads/2022/12/Sans-titre2-1024x644.png) + +Fig 2. SimPut in action configuring the particle species and their interactions in a simulation + +## Acknowledgements + +If you want to find out more about boltzplatz or particle-based plasma simulation, visit their website here: + +For a more in-depth look at how trame makes developing your next web application fast, simple and powerful: . If you want to try out trame for yourself, check out our [developer’s course](https://www.kitware.com/trame-developers-course/). + +The trame-based web application consulting and development work was performed by Kitware Europe ([www.kitware.eu](http://www.kitware.eu)) as part of boltzplatz’ participation in the European Space Agency Business Incubation Centre in Baden-Württemberg. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Customer Spotlight](https://www.kitware.com/tag/customer-spotlight/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Simulation](https://www.kitware.com/tag/simulation/) | [Trame](https://www.kitware.com/tag/trame/) | [Visualization](https://www.kitware.com/tag/visualization/) | [Visualizer](https://www.kitware.com/tag/visualizer/) | [Web Visualization](https://www.kitware.com/tag/web-visualization/) + diff --git a/docs/vitepress/blogs/sc25.md b/docs/vitepress/blogs/sc25.md new file mode 100644 index 00000000..3c3d7cc2 --- /dev/null +++ b/docs/vitepress/blogs/sc25.md @@ -0,0 +1,323 @@ +[post](https://www.kitware.com/sc25/) + +# Supercomputing Conference 2025 + +October 21, 2025 + +![Supercomputing 2025](https://www.kitware.com/main/wp-content/uploads/2025/10/SC-2025_Hero.jpg) + +### November 16–21, 2025 in St. Louis, Missouri + +Each year, [Supercomputing](https://sc25.supercomputing.org/) (SC) brings together the world’s leaders in high-performance computing to share groundbreaking advances in hardware, software, and scientific innovation. Kitware is proud to return as a long-time exhibitor, showcasing how interactive visual workflows are redefining what’s possible in HPC, AI, and large-scale simulation. + +Our open source ecosystem, including ParaView, Catalyst, and trame, empowers scientists, engineers, and organizations to turn complex data into insights faster. Visit us at **Booth #1011** or [contact our team](https://www.kitware.com/contact/) to see how we can make your workflows more efficient. + +## Solving Today’s HPC Bottlenecks with Visual Workflows + +Modern HPC workflows face integration, collaboration, and scalability barriers that slow progress from computation to insight. Kitware’s interactive visual workflows eliminate these obstacles through open source, modular solutions built for performance and accessibility. + +| Common Challenge | Kitware’s Solutions | +| --- | --- | +| **Fragmented Workflows:** AI, simulation, and experimental systems rarely interoperate smoothly, leading to manual workarounds and lost productivity. | **Democratization of Advanced Capabilities:** Empower entire teams to explore, visualize, and interpret data interactively across web, desktop, and Jupyter. | +| **Bottlenecks:** Knowledge transfer between simulation developers and engineers is slow and inefficient, and tools are often either too simple or too complex. | **Seamless Expertise Transfer:** Interactive visual workflows facilitate more speedy expertise transfer and provide customizable, domain-specific environments that allow experts and non-experts to engage productively without unnecessary complexity. | +| **Rigid Tools:** Static tools limit interactivity, making it hard to validate results or communicate findings effectively. | **Accelerated Insight and Communication:** Interactive visual workflows accelerate discovery and facilitate the communication of insights across diverse audiences, enabling more informed and collaborative decision-making. | +| **Long Post-Processing Cycles:** Complex workflows and fragmented tools often result in lengthy delays between data generation and actionable insights. While simulations, experiments, or AI runs may finish in only weeks, the analysis and visualization of their results can take months. | **Shorter Time-to-Discovery:** Integrated, interactive visual workflows shorten the path from raw data to understanding. By reducing months of post-processing into immediate, adaptive visual exploration, they enable faster prototyping, validation, and decision-making. | + +## A Platform Built for Performance and Flexibility + +At Kitware, we’re evolving the visualization ecosystem to support the next generation of HPC workloads. Our modular platform brings together decades of open source innovation to deliver performance, scalability, and interactivity at every level of the stack, from the backend frameworks to the front-end: + +* **A comprehensive set of libraries** with [VTK](https://vtk.org/) for I/O, data models, analysis, rendering, and graphics. +* **Visualize at scale** with [ParaView](https://www.paraview.org/), which handles massive datasets, ensures high performance, and provides the visualization backbone needed for both experts and non-experts to interrogate complex results. +* **Enable interactive workflows and asset management** with [SMTK](https://www.computationalmodelbuilder.org/smtk/), enabling users to define, track, and reuse workflow resources. SMTK supports flexible integration with other frameworks, enabling interactive workflows that connect setup, execution, analysis, and visualization, as well as providing ways of decomposing a workflow into a set of interactive tasks. +* **Integrate in situ analysis** with [Catalyst](https://kitware.github.io/paraview-catalyst/) to process data as it’s generated, reducing I/O, eliminating data bottlenecks, and enabling real-time performance visualization. +* **A run-everywhere front-end** with [trame](https://www.kitware.com/trame/) that lowers technical barriers, supports rapid development, and ensures interoperability between front-end and computational backend frameworks. + +Together, these technologies form a modular, interoperable platform built on decades of open source innovation. The result: adaptive, interactive workflows that can keep up with the pace of computation. + +## Real-World Impact Across Domains + +The true power of visual workflows is best seen in action. Kitware’s open source platforms are already accelerating discovery and efficiency across industries and research organizations worldwide. + +Each example demonstrates how integrating visualization and simulation within adaptive visual workflows leads to faster validation, better resource utilization, and accelerated innovation. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + Example 1 + + + + Example 2 + + + + Example 3 + +
+ + Example 4 + + + + Example 5 + + + + Example 6 + +
+ + Example 7 + + + + Example 8 + + + + Example 9 + +
+ + Example 10 + + + + Example 11 + + + + Example 12 + +
+ + Example 13 + + + + Example 14 + + + + Example 15 + +
+ + Example 16 + + + + Example 17 + + + + Example 18 + +
+ + + Example 20 + + +
+ +The power of this platform is best understood through concrete use cases. By combining run-everywhere front ends, trame, robust backend frameworks, and production-ready desktop applications, researchers can assemble visual workflows that address real challenges. The following examples illustrate how these components work together to manage massive datasets, streamline data movement, connect simulations with analysis, and simplify complex workflows into environments that accelerate discovery. + + +Convergent Science uses ParaView and Catalyst in their CONVERGE software to improve capture of high-speed physical phenomena inside internal combustion engines such as knocking. Catalyst allows saving isosurfaces at a rate much higher than is possible than saving full datasets and can reduce file output from ~100 gigabytes to ~100 megabytes in a typical simulation. Read the blog post [In Situ Data Analysis Brings Faster Results and Accelerated Insights](https://www.kitware.com/in-situ-data-analysis-brings-faster-results-and-accelerated-insights/) to find out more. + +Frameworks used: ParaView, Catalyst + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-1.jpg) + + +This figure shows an OpenFoam simulation of a boat inside a virtual wave tank. The application was created for Sandia National Laboratories’ Water Power Technologies Program. Applications like this can greatly reduce expenses – compared to either a physical wave tank or the manual creation of simulation inputs. + +Frameworks used: SMTK, CMB, VTK, ParaView. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-2.jpg) + + +This figure shows an OpenFOAM workflow Kitware created for Sandia National Laboratories to evaluate the reactions of objects to wave motion. What’s shown is a ship being inserted into the tank. The box around the aft portion of the vessel is a preview of the OpenFOAM overset mesh (snapped to the ship exterior) that has been crinkle-clipped to reveal the forward part of the ship.This allows inspection of meshes before running a simulation. + +Frameworks used: SMTK, VTK, ParaView + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-3.jpg) + + +Simulation workflows often demand diverse computational resources. For instance, a high-energy physics workflow, leveraging SLAC’s Advanced Computational Electromagnetics 3D Parallel (ACE3P) tools, is employed in the design of particle accelerators and related instrumentation. In this scenario, the user initiates the workflow on their local machine, while the intensive computations are executed on the High-Performance Computing (HPC) resources at NERSC. Users have the flexibility to perform remote post-processing on the HPC machine or conveniently transfer results for local processing, all within the same integrated tool. + +Frameworks used: SMTK, CMB, ParaView, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-4.jpg) + + +Developed for the Cleveland Clinic, this workflow showcases the intricate process of creating and annotating anatomical models. This involves segmenting and processing medical images and meshes. Users needed efficient ways to create and edit surface selections, remesh surfaces, and generate volumetric meshes from them, as well as to incorporate detailed ontologies into the annotation process. + + +Frameworks used: SMTK, CMB, ParaView, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-5.jpg) + + +Computational fluid dynamics workflows, like OpenFOAM-based wind tunnel simulation shown above, require users to perform various tasks: problem setup, mesh generation, simulation processing, and post-processing. Decomposing these complex workflows into manageable, guided tasks is crucial for effective user management. + +Frameworks used: VTK, CMB ParaView, SMTK. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-6.jpg) + + +Computational fluid dynamics (CFD) is integral to whole-body circulatory system workflows, supporting the development of new surgical procedures and patient health monitoring. These workflows often run continuously, necessitating in situ visualization for real-time observation by physicians and researchers. + +The accompanying images illustrate work from the Randles Lab at Duke University, where methods for whole-body circulatory system simulation are being developed, modeling down to individual blood cells using the HARVEY fluid dynamics solver. The video showcases blood flow within a representative human aorta, originating at the ascending aorta, traversing the aortic arch, and concluding at the descending aorta. As the fluid enters the aortic arch, it diverges into the right and left subclavian and common arteries. To mimic in vivo circulation, the flow constantly pulses throughout the animation. Frameworks used: ParaView, ParaView Catalyst + +Frameworks used: ParaView, Catalyst + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-7.jpg) + + +Parsli is a VTK-based viewer for fault system kinematics that enables rapid exploration and export of time-based animations. By leveraging advanced 3D graphics, interactive visualization, and high performance, we’ve transformed a workflow that once took days into one that now takes minutes—or even seconds—for initial validation and analysis. Its ease of use and installation has also encouraged the community to revisit past runs, uncovering phenomena that previously slipped through the cracks of the previous toolchain. + +Frameworks used: Trame, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-8.jpg) + + +Visualizing and exploring multivariate/multimodal volumes, common in material modeling and medical simulations, demands innovative techniques. These techniques are crucial for revealing significant trends and effectively communicating discoveries to both domain experts and general audiences. As an example, the accompanying figure presents an x-ray fluorescence tomography dataset of a mixed ionic-electronic conductor (MIEC), analyzed using Kitware’s MultivariateView tool. + +Frameworks Used: trame, VTK + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-9.jpg) + + +High-resolution 3D characterization is crucial for workflows in materials science and nanoscience. This requires advanced image processing, data analysis, visualization, and reproducibility. Integrating these features into a single environment streamlines the entire research pipeline, from raw data to publication-quality 3D renderings. Furthermore, incorporating capabilities like Python scripting and custom extensions expands its applicability to diverse workflows. Tomviz is an example that offers visualization, processing, and analysis for tomographic data. The image above from Tomviz demonstrates drawing a cropping region around 3D reconstructed PtCu nanoparticles, known for their effectiveness as fuel cell electrocatalysts. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-10.jpg) + + +QuickView is a Trame + ParaView-powered tool for exploring atmospheric output from the E3SM Atmosphere Model (EAM). It provides an intuitive, no-scripting interface for multivariate visualization, model validation & verification and supports EAM v2, v3 (and in development v4) data formats – which simplifies the atmosphere modeling and analysis workflows. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-11.jpg) + + +Pan3D is a fast, highly interactive visualization tool for Xarray datasets — a standard format for large, multidimensional arrays in climatology and other geospatial fields. Built on Trame and VTK, it leverages seamless interoperability between VTK and Xarray for efficient data exchange. A defining feature of Pan3D is its collection of Explorers (pictured above): lightweight, task-focused analysis apps that cut through the clutter of traditional, full-featured visualization tools such as ParaView. These explorers enable teams to craft bespoke, purpose-driven solutions, fostering collaboration and clear role separation. + +Platforms: VTK and trame + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-12.jpg) + + +In collaboration with NASA and the University of Colorado Boulder, Kitware is expanding the Catalyst in situ analysis platform to enable powerful AI models to access simulation data in memory at runtime for advanced model training and inference to improve upon existing simulation results. This approach empowers existing, validated simulation codes to leverage modern AI tools without complex and costly code integrations. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-13.jpg) + + +Rotorcraft simulation workflows present a complex, multidisciplinary challenge, as they necessitate the integration of moving-body aerodynamics with structural dynamics for rotor blade deformation, and vehicle flight dynamics and controls. Furthermore, the extensive data generated during a rotorcraft CFD simulation, stemming from numerous timesteps, can be substantial. + +By incorporating in situ capabilities directly into the simulation workflow, developers and analysts can scrutinize crucial variables at each timestep, thereby avoiding the significant overhead associated with I/O and storage. This methodology not only optimizes HPC resource utilization but also facilitates real-time steering, swift validation, and more insightful diagnostics during protracted simulations. The accompanying images illustrate this approach using CREATE’s HELIOS framework, which leverages ParaView Catalyst for in situ visualization and analysis. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-14.jpg) + + +ArrowFlow, focuses on broadening simulation usage by allowing domain scientists to easily create templates and expose them to remote engineers. Its curated web interface for input simulation parameters and easy to use post-processing tools enables quick exploration for validation of settings to use with factory mixer, drier or any machinery setup into the system. +ArrowFlow relies on M-Star CFD™ for its solver and ParaView for its post-processing. Trame is exposing templates, solver and post-processing visualization in an easy to use solution. + +Frameworks used: Trame, ParaView + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-15.jpg) + + +Displaying complex microstructural data is an integral part of many material science workflows and enables researchers to explore and understand the intricate geometries and properties of materials. This integration is crucial for analyzing simulated and experimental data, facilitating insights into material behavior, and accelerating the discovery of new materials with desired characteristics. The above image shows 3D precipitate morphology from a nickel based superalloy. Reconstruction was performed by DREAM3D-NX and subsequently visualized within DREAM3D-NX using VTK to provide advanced 3D rendering and visualization capabilities essential for material science research. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-16.jpg) + + +Acoustic modal analysis of a car cabin by [Undabit Acoustic Simulations](https://undabit.com/). Identifying vibration modes that may impact acoustic properties is crucial, as acoustic resonances can amplify noise generated by the engine, a phenomenon often referred to as “booming.” Understanding the frequencies at which resonance occurs and the spatial distribution of the resonant field is essential. Visualization with ParaView’s advanced ray-tracing capabilities. Source: [Automotive Acoustic Simulation Post-processing with ParaView](https://www.kitware.com/automotive-acoustic-simulation-post-processing-with-paraview/) + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-17.jpg) + + +[![Topological analysis of terrain elevation is crucial for surface water workflows, such as estimating water runoff zones. This analysis allows for the identification and classification of critical points like peaks and pits, the segmentation of watershed boundaries, and the highlighting of ridges and valleys. These elements are essential for understanding the terrain’s structure. In the accompanying figure, colored regions indicate areas feeding into the blue river network, while red paths denote ridges. Platforms used: ParaView and its Topology Toolkit (TTK) plugin. For more information, see [Practical Use Cases for TTK](https://www.kitware.com/practical-use-cases-for-ttk/). + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-18.jpg) + + +Live visualization of a drive train digital twin. Data from 30 temperature sensors on an electric motor are interpolated onto a digital twin model for live display in ParaView. This allows engineers from TotalEnergies to have direct access to a visualization showcasing the measured elements as it is running, and perform analysis and visualization within ParaView, either using the whole set of existing filters or even implementing their own. Platforms used: ParaView. More information at [Build, Control and Run Digital Twins with ParaView](https://www.kitware.com/build-control-and-run-digital-twins-with-paraview/). + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/supercomputing-2025-19.jpg) + +## See What’s Next in Scientific Visualization + +Visit Kitware at **Booth #1011** to: + +* See live demonstrations of ParaView, Catalyst, and trame. +* Learn how to implement interactive visual workflows that connect your HPC simulations, AI models, and engineering data. +* Talk directly with our technical leaders about integrating Kitware’s open source solutions into your workflow. + +## **Ready to accelerate your discovery process?** Visit us at **Booth #1011** or [contact our team](https://www.kitware.com/contact/) to start the conversation. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Artificial Intelligence](https://www.kitware.com/tag/artificial-intelligence/) | [Catalyst](https://www.kitware.com/tag/catalyst/) | [Conference](https://www.kitware.com/tag/conference/) | [Data Analysis](https://www.kitware.com/tag/data-analysis/) | [HPC](https://www.kitware.com/tag/hpc/) | [In Situ](https://www.kitware.com/tag/in-situ/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Simulation](https://www.kitware.com/tag/simulation/) | [Simulation Workflows](https://www.kitware.com/tag/simulation-workflows/) | [SMTK](https://www.kitware.com/tag/smtk/) | [Supercomputing](https://www.kitware.com/tag/supercomputing/) | [Trame](https://www.kitware.com/tag/trame/) | [Visual Workflows](https://www.kitware.com/tag/visual-workflows/) + diff --git a/docs/vitepress/blogs/scientific-visualization-in-2022.md b/docs/vitepress/blogs/scientific-visualization-in-2022.md new file mode 100644 index 00000000..37d5c967 --- /dev/null +++ b/docs/vitepress/blogs/scientific-visualization-in-2022.md @@ -0,0 +1,105 @@ +[post](https://www.kitware.com/scientific-visualization-in-2022/) + +# Scientific Visualization in 2022 + +January 18, 2022 + +[Berk Geveci](https://www.kitware.com/author/berk-geveci/ "Posts by Berk Geveci"), [Bob O'Bara](https://www.kitware.com/author/bob-obara/ "Posts by Bob O'Bara"), [Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary"), [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder"), [Utkarsh Ayachit](https://www.kitware.com/author/utkarsh-ayachit/ "Posts by Utkarsh Ayachit"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Cory Quammen](https://www.kitware.com/author/cory-quammen/ "Posts by Cory Quammen") and [Chris Harris](https://www.kitware.com/author/chris-harris/ "Posts by Chris Harris") + +![Scientific visualization of jellyfish](https://www.kitware.com/main/wp-content/uploads/2022/01/JellyfishCropped.png) + +![](https://www.kitware.com/main/wp-content/uploads/2022/01/JellyFish-1024x719.png) + +[Kitware’s Scientific Computing Team](https://www.kitware.com/teams/scientific-computing/) is looking forward to another year of groundbreaking technical advances. Building off of the success our world class open source platforms VTK and ParaView, we will be introducing new capabilities that dramatically increase performance and ease of use; significantly improve end-to-end workflows for large-scale simulation and experimental science; support ongoing advances in AR/VR hardware and rendering; and introduce a new Python-based, web integration framework that weaves together visual analytics tools for large scale data analysis. In the following, we provide high-level summaries of a small subset of the work we are undertaking this year, with contact information if you’d like to learn more. Throughout the year, we’ll be announcing these tools as they arrive, in many cases we will be looking for help from the community to test, evaluate, and guide our development efforts. + +## ParaView / VTK + +Development of [VTK](https://vtk.org/) and [ParaView](https://www.paraview.org/) continues at a ferocious pace. The next VTK 9.2 release is expected in the spring of 2022 and 9.3 in the fall of 2022. ParaView 5.10.0 was released in January, and we expect to release 5.11.0 in May and 5.12.0 in October. Other notable goals include: + +* VTK’s ongoing performance improvements due to CPU threading (vtkSMPTools) and GPU accelerators (vtk-m). +* Improving accuracy for statistical filters when operating on point fields by adding support for ghost points. +* Adding support for meshes used in simulations based on discontinuous Galerkin methods. + +##### Contact: [Cory Quammen](mailto:cory.quammen@kitware.com) + +## VTK-m + +[VTK-m](https://m.vtk.org/) is a toolkit of scientific visualization algorithms for emerging processor architectures, especially GPUs. It provides the building blocks for portable algorithm development and a number of core visualization algorithm implementations. In 2022, our focus will be on continuing the port of VTK-m to new GPU architectures including AMD and Intel GPUs. We are also pushing tighter integration of VTK-m into VTK and ParaView where users will be able to choose a runtime option to replace certain filters with their VTK-m counterparts. We hope to demonstrate the use of VTK-m in end-to-end simulation workflows through the Catalyst and Ascent in situ libraries on next generation supercomputers. + +##### Contact: [Berk Geveci](mailto:berk.geveci@kitware.com) + +## Next Generation ParaView: ParaView async + +Over the past couple of years the Scientific Computing Team has envisioned an improved ParaView that is more interactive and responsive no matter the computational load. With a concerted effort now underway, the major objectives are designing and implementing concurrent pipelines, in which rendering and data processing pipelines do not block one another; and supporting pervasive interruptibility, ensuring that filters can be interrupted or aborted at any time to provide application responsiveness. We expect a public prototype to be available for comment and experimentation by early summer, with an early release available for SuperComputing 2022. + +##### Contact: [Utkarsh Ayachit](mailto:utkarsh.ayachit@kitware.com) + +## CMB: Computational Model Builder + +Modeling and simulation are tasks pervasive to the design and manufacturing of modern, high-quality products. However such simulation workflows are typically highly specific to a domain, requiring complex combinations of sophisticated computing tools to implement. [CMB](https://www.computationalmodelbuilder.org/) is a framework that simplifies developing simulation frameworks, enabling scientists and engineers to focus on their domain expertise rather than worrying about the integration of disparate software and simulation codes. Recent developments in CMB provide seamless integration of pre-, post-, and simulation workflows including deployment to large supercomputing systems and servers, and the ability to support multiphysics analyses. In 2022, major goals include supporting simulation workflows with multiple analysis stages, and providing the capability to postprocess results on HPC machines after performing simulation configuration and setup on the local desktop. + +##### Contact: [Bob O’Bara](mailto:bob.obara@kitware.com) + +## AR / VR + +Currently there is extreme interest in AR/VR technologies, and we have several active areas of development underway. Some notable goals for 2022 include: + +* Support OpenXR-based VR visualization for consumer headsets in VTK/ParaView; and enhance the existing ParaView VRPlugin for CAVE-like systems. +* Add support for Hololens in VTK/ParaView/3DSlicer. +* Enable actors to be placed into other coordinate systems such as physical coordinates and device coordinates. This makes it easier to position actors in VR/AR scenes that move with devices or are fixed to the physical space. +* Roll out support for WebXR in VTK.js and add controller/interaction support similar for VTK C++. +* Consolidate APIs between the OpenVR, OpenXR, Cave and Zspace systems. + +##### Contact: [Cory Quammen](mailto:cory.quammen@kitware.com) + +## Chemistry / Material Design + +[Tomviz](https://tomviz.org/) is an application for the characterization of materials at the nano- and meso-scale with emphasis on transmission and scanning transmission electron microscopes (S/TEM). Tomviz is tailored for visualizing and processing the associated large-scale electron tomography data. We have recently been adding features to support X-ray tomography datasets. Building on the success of Tomviz, we have also been developing an application for the calibration and analysis of X-ray diffraction experiments; through the Highly Extensible X-Ray Diffraction Toolkit (HEXRD). Our current focus is improving support for 3D X-ray diffraction (3DXRD). A major goal of our current work is to scale our applications to support datasets of even larger scales which reflect the ever increasing data resolution available to experimentalists. In the area of 4D-STEM, we are harnessing the power of HPC to support high throughput processing of very large experimental datasets. + +##### Contact: [Chris Harris](mailto:chris.harris@kitware.com) + +## Trame: Web-based, Python Integration Framework + +The Python-based integration framework [trame](https://kitware.github.io/trame/index.html) enables non-web-developers to create powerful, complex client-server web applications supporting large-scale data processing and visualization without the need to understand web technologies or frameworks. Based on decades of experience with VTK, ParaView, ParaViewWeb, and VTK.js, trame transparently leverages these visualization tools along with web technologies (including GUI tools) and the Python ecosystem. Extensive resources have been developed including [the trame web site](https://kitware.github.io/trame/), along with a [video](https://vimeo.com/651667960) that follows the trame [tutorial](https://kitware.github.io/trame/docs/tutorial.html). The ease by which complex web applications can be built is exceptional: we expect this platform will grow into another core platform for the Scientific Computing Team. + +##### Contact: [Sebastien Jourdain](mailto:sebastien.jourdain@kitware.com) & [Patrick O’Leary](mailto:patrick.oleary@kitware.com) + +## Catalyst + +[Catalyst](https://catalyst-in-situ.readthedocs.io) is an API specification developed for simulations to analyze and visualize data in situ. It includes a light-weight implementation of the Catalyst API and an SDK to develop implementations of the API to perform data processing and visualization tasks. The Catalyst API uses ‘C’ and is binary compatible with different implementations of the API making it easier to change the implementation at runtime. Starting with 5.9, ParaView releases are packages with an implementation of the Catalyst API. This implementation can be used in lieu of the stub to analyze and visualize simulation results using ParaView’s data-processing and visualization capabilities. We are super excited about this capability and in the coming year will be working hard at replacing previous ParaView Catalyst implementations with this new approach. + +##### Contact: [Berk Geveci](mailto:berk.geveci@kitware.com) + +## Happy New Year! + +We hope you join us in the coming year as the Scientific Computing Team works towards these and many other exciting goals. Please feel free to reach out, we’d enjoy hearing from you and are open to suggestions, guidance, and collaboration. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[AR](https://www.kitware.com/tag/ar/) | [Catalyst](https://www.kitware.com/tag/catalyst/) | [Chemistry](https://www.kitware.com/tag/chemistry/) | [CMB](https://www.kitware.com/tag/cmb/) | [Material Design](https://www.kitware.com/tag/material-design/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Trame](https://www.kitware.com/tag/trame/) | [vr](https://www.kitware.com/tag/vr/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/simplify-web-application-development-with-trame.md b/docs/vitepress/blogs/simplify-web-application-development-with-trame.md new file mode 100644 index 00000000..f7a0f7f2 --- /dev/null +++ b/docs/vitepress/blogs/simplify-web-application-development-with-trame.md @@ -0,0 +1,57 @@ +[post](https://www.kitware.com/simplify-web-application-development-with-trame/) + +# Simplify Web Application Development with trame + +October 28, 2024 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") + +![Visualization of land and what is below it.](https://www.kitware.com/main/wp-content/uploads/2024/09/trame-webinar-Q4-2024-Feature.jpg) + +Creating highly interactive or data-intensive web applications can be challenging, but trame simplifies this process. [trame](https://www.kitware.com/trame/) was designed to help developers create rich, desktop-like experiences on the web. It leverages Python, allowing you to build beautiful user interfaces without needing extensive web development knowledge. + +## Why Use trame? + +With trame, you can quickly transform data visualizations and complex applications into web-friendly interfaces. Whether you are building dashboards, integrating 3D rendering, or generating dynamic UIs for intricate configurations, trame streamlines the development process. The framework supports various deployment options, from desktop bundles (using tools like Tauri) to cloud-based applications, making it versatile and adaptable for different projects. + +## Getting Started with trame + +* **Installation:** trame can be used directly within Jupyter to build UIs. You only need to install the trame package, and you can start creating interactive web applications directly from your notebook or Python scripts. +* **Build Desktop Applications:** For those who need a desktop version, trame can be bundled using Tauri or PyWebView. +* **Deploy to the Cloud:** Utilize trame’s features to create cloud-based applications, perfect for sharing complex visualizations or dashboards with users across the globe. trame makes it easy to deploy applications that offer dynamic UI generation, 3D rendering, and more. + +If you want to learn more about trame’s capabilities and how to start using the tool, you can watch the recording of our webinar, “**Building Interactive Web Applications with trame.**” + +[Watch Webinar](https://www.kitware.com/webinars/from-desktop-to-ubiquitous-application-with-trame/#register) + +If you have questions about trame or would like help using the tool, please [contact our team](https://www.kitware.com/contact/project/). + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Data Visualization](https://www.kitware.com/tag/data-visualization/) | [Python](https://www.kitware.com/tag/python/) | [Trame](https://www.kitware.com/tag/trame/) | [Web Applications](https://www.kitware.com/tag/web-applications/) | [webinar](https://www.kitware.com/tag/webinar/) + diff --git a/docs/vitepress/blogs/supercomputing-2023.md b/docs/vitepress/blogs/supercomputing-2023.md new file mode 100644 index 00000000..9edc291a --- /dev/null +++ b/docs/vitepress/blogs/supercomputing-2023.md @@ -0,0 +1,105 @@ +[post](https://www.kitware.com/supercomputing-2023/) + +# Supercomputing 2023 + +October 30, 2023 + +[Samantha Schmitt](https://www.kitware.com/author/samantha-schmitt/ "Posts by Samantha Schmitt") + +![Computer visualization of pathways marked with cone shapped arrows](https://www.kitware.com/main/wp-content/uploads/2023/10/Blog_Feature_SC23_trame.png) + +**THE INTERNATIONAL CONFERENCE FOR HIGH-PERFORMANCE** +**COMPUTING, NETWORKING, STORAGE, AND ANALYSIS (SC23)** +Hosted by the IEEE Computer Society + +November 12 – 17, 2023 in Denver, Colorado at the Colorado Convention Center + +The theme for [SC23](https://sc23.supercomputing.org/), “I Am HPC,” is fitting for Kitware because we’ve been a part of the HPC community for more than two decades. From the early days at Kitware when we were developing [VTK](https://vtk.org/) to building software that thrives on the world’s most powerful computers today, scientific visualization is a critical part of who we are as a company. + +Kitware is proud to be an exhibitor at this year’s event. We have decades of experience working with government labs, research centers, universities, and commercial organizations. Our team works closely with each of our customers to design custom workflows, user experiences, and interfaces from the ground up. We specialize in delivering tailored software solutions that help you achieve your goals. + +If you are attending SC23, visit us at booth #511 for live demos and to speak with our experts. We are also happy to schedule a meeting outside of the conference to hear about what you’re working on. We can prepare personalized demos and talk about how we can work together to achieve your HPC visualization goals. + +[Contact Us](https://www.kitware.com/contact/project/) + +## Areas of Expertise + +Interested in working with Kitware and learning more about our expertise, [check out our brochure](https://www.kitware.com/main/wp-content/uploads/2023/12/SC-Brochure-2023.pdf). + +
+ + + + + + + + + +
+
+ In Situ Analysis & Visualization + 		+
+ High Performance I/O +
+
+ End-to-end HPC Simulation Workflows + 		+
+ Web-based Visualization +
+
+ +## Open Source Platforms + +Use these links for more information: + +
+ + + + + + + + + + + +
+
+ +
+ +
+ +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[ADIOS](https://www.kitware.com/tag/adios/)[CMake](https://www.kitware.com/tag/cmake/)[CMB](https://www.kitware.com/tag/cmb/)[HPC](https://www.kitware.com/tag/hpc/)[In Situ](https://www.kitware.com/tag/in-situ/)[ParaView](https://www.kitware.com/tag/paraview/)[SC23](https://www.kitware.com/tag/sc23/)[Super Computing](https://www.kitware.com/tag/super-computing/)[Trame](https://www.kitware.com/tag/trame/)[VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/the-evolution-of-peacock-a-powerful-interface-for-moose-simulations.md b/docs/vitepress/blogs/the-evolution-of-peacock-a-powerful-interface-for-moose-simulations.md new file mode 100644 index 00000000..7a8146d5 --- /dev/null +++ b/docs/vitepress/blogs/the-evolution-of-peacock-a-powerful-interface-for-moose-simulations.md @@ -0,0 +1,137 @@ +[post](https://www.kitware.com/the-evolution-of-peacock-a-powerful-interface-for-moose-simulations/) + +# The Evolution of Peacock: A Powerful Interface for MOOSE Simulations + +June 22, 2023 + +[Elim Schenck](https://www.kitware.com/author/elim-schenck/ "Posts by Elim Schenck"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery") and [Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary") + +![Exodus Viewer of Peacock](https://www.kitware.com/main/wp-content/uploads/2023/06/featured-image.jpg) + +## Introduction + +Advanced modeling and simulations play a crucial role in designing and optimizing the efficiency and safety of nuclear reactors and fuels in nuclear energy. MOOSE (Multiphysics Object-Oriented Simulation Environment)(1) is a widely used software framework for performing physics simulations. MOOSE is developed and supported through the Nuclear Energy Advanced Modeling and Simulation (NEAMS) program(2), a U.S. Department of Energy-Office of Nuclear Energy (DOE-NE) program that develops advanced modeling and simulation tools and capabilities to accelerate the deployment of advanced nuclear energy technologies, such as light-water reactors (LWRs), non-light-water reactors (non-LWRs), and advanced fuels. MOOSE leverages finite element analysis and meshes to simulate various physics phenomena. + +To configure, execute, and analyze MOOSE applications, a graphical interface called Peacock(3) was developed by Derek Gaston nearly a decade ago. However, the original version of Peacock had some limitations and built up some technical debt over the years. In this article, we will explore the evolution of Peacock, its new version, and the innovative features that make it a powerful tool for MOOSE simulations. + +## MOOSE + +MOOSE is a powerful software framework that nuclear energy scientists and engineers use to perform physics simulations using finite element analysis. It allows for analyzing and optimizing nuclear reactors and fuels, helping to improve efficiency and safety. MOOSE applications traditionally consist of an executable and an input file configuring the simulation. Although configuring and executing MOOSE simulations is simple, it can seem complex and time-consuming for novice end-users of advanced modeling and simulation. That’s where Peacock comes in. + +![Figure 1: An example MOOSE input file. Brackets denote blocks, which are groupings of parameters. For example, the mesh block configures aspects of the mesh. This mesh comes from a file, reactor.e. Blocks can have sub-blocks. For example, the Variables block has no parameters, just sub-blocks.](https://www.kitware.com/main/wp-content/uploads/2023/06/image8.png) + +**Figure 1:** An example MOOSE input file. Brackets denote blocks, which are groupings of parameters. For example, the mesh block configures aspects of the mesh. This mesh comes from a file, reactor.e. Blocks can have sub-blocks. For example, the Variables block has no parameters, just sub-blocks. + +## Peacock: The Original Interface + +![Screenshot of the Peacock software showing the input definition screen.](https://www.kitware.com/main/wp-content/uploads/2023/06/image4.png) + +![Screenshot of the Peacock software showing the simulation execution screen.](https://www.kitware.com/main/wp-content/uploads/2023/06/image7.png) + +![Screenshot of the Peacock software showing the analysis and visualization](https://www.kitware.com/main/wp-content/uploads/2023/06/image2-2.png) + +**Figure 2:** Peacock consists of three pages: input definition, simulation execution, and analysis and visualization. + +Peacock serves as a graphical interface for configuring and analyzing MOOSE simulations. It provides a user-friendly environment that simplifies creating input files, executing simulations, and visualizing the results. Peacock, the original graphical interface for MOOSE, was initially developed in Python using the Qt framework. While it served its purpose most of the time, there were some lingering issues with its usability, maintenance, and remote usage. The interface could have been more intuitive, but everything made sense once you were an experienced end-user. Development of physics for nuclear energy applications keeps the core MOOSE development team busy, and knowledge of MOOSE, Python, Qt, and VTK concentrate with developers in extremely high demand. Thus, over time, the maintenance of Peacock has become a burden. Additionally, using Peacock remotely, a critical use case for nuclear energy codes, needed to be more straightforward and align better with the Open OnDemand environment. + +## Revisiting Peacock + +To address the limitations of the original Peacock interface, a new version was developed using Kitware’s trame(4) framework. The new Peacock is written in Python and focuses on simplifying remote execution and integration with high-performance computing (HPC) scheduling. With trame, Peacock is now almost entirely written in Python, with only a few custom widgets implemented in JavaScript and maintained in the core trame framework. This evolution simplifies maintenance and allows future developers to work seamlessly within Python. This new client-server version of Peacock now provides access to the front end from various devices and environments and a back end to provide secure computations. + +## Enhanced Input Configuration + +As mentioned previously, the input file configuration is essential to MOOSE simulations. In the new version of Peacock, we determine the input file schema from the MOOSE executable. The MOOSE executable can output the schema as a JSON file, providing valuable information about the available configuration blocks, parameters, and types. Furthermore, the executable can create and output the input mesh as an ExodusII file, which is useful when the input file specifies a description of the mesh rather than a file. Peacock leverages this data and maps it to a SimPut(5) schema, which automates the user interface (UI) generation for editing and updating the input file. To parse the blocks, parameters, and types of the input file, Peacock utilizes the pyhit(6) library. + +![Screenshot of the input tab](https://www.kitware.com/main/wp-content/uploads/2023/06/image5.png) + +**Figure 3:** The input tab. + +The core input file tab in Peacock allows users to create and edit input files for MOOSE simulations. The tab features a tree view representing the input file syntax specific to the simulation application. This tree view is automatically populated via SimPut with blocks and parameters from an existing input file, making it easier for users to navigate and modify the input file structure. + +## GUI and Text Editor Integration + +While Peacock’s graphical user interface (GUI) dramatically simplifies the input file configuration, some advanced end-users may prefer to edit the file directly. Peacock integrates a file editor directly into the interface to cater to both types of end-users. This editor is synced with the GUI, ensuring immediate reflection of changes made in either the GUI or the editor. Peacock utilizes the web-based Monaco editor, the same editor used in VS Code, for its text editing capabilities. We integrated syntax highlighting for the MOOSE custom grammar, and a language server provides hover hints and auto-completion. This integration makes editing the input file more efficient and flexible for advanced end-users. That capability is even now available for everyone to enjoy in trame-code (7). + +![Synced GUI and Text Editor.](https://www.kitware.com/main/wp-content/uploads/2023/06/image1-1-1024x601.png) + +**Figure 4:** Synced GUI and Text Editor. + +## Streamlined Execution + +The execution of MOOSE simulations is a vital step in the workflow. Peacock provides a streamlined execution process through its executor component. The executor leverages the widely adopted web-based terminal Xterm.js used in various development environments like VS Code and JupyterLab. Xterm.js via trame-xterm(8) enhances the readability of MOOSE executable output, ensuring a seamless execution experience for end-users. This feature has been integrated into the core trame framework, enabling other applications to leverage it going forward. + +![The executor with minimal options.](https://www.kitware.com/main/wp-content/uploads/2023/06/image3-1024x602.png) + +**Figure 5:** The executor with minimal options. + +## Enhanced Visualization with ParaView + +The analysis and visualization of simulation results are essential aspects of MOOSE simulations. Peacock uses ParaView, a robust analysis and visualization tool, to enhance its analysis and visualization capabilities. ParaView provides a wide range of analysis and visualization techniques, capabilities, and features, including three-dimensional (3D) visualizations, charts, and annotations. Peacock also utilizes ParaView’s VTK (Visualization Toolkit) library for mesh visualization. + +![The EXODUS Viewer.](https://www.kitware.com/main/wp-content/uploads/2023/06/image6-1024x603.png) + +**Figure 6:** The EXODUS Viewer. + +## Opportunities available using trame + +Peacock is only scratching the surface of what trame has to offer. The client-server architecture of trame allows utilization of such an application as a plain desktop one (like the previous Peacock), embedded inside Jupyter (for data analysis and exploration workflows), installed and deployed via Python anywhere (pip/mamba install), and integrated into an HPC suite using OnDemand. + +While most of those features come organically with trame, we must expose them appropriately. In Peacock’s case, we need a special UI breakdown to best leverage Jupyter’s cell-level workflow. And for OnDemand, we must create additional forms for job submission to accommodate Peacock code launching. All of these tasks are simple. The good news is that those paths are now possible if needed. + +## Future Directions and Research Focus + +While the new version of Peacock has significantly enhanced the usability and functionality of the interface, there are still ongoing efforts to improve its capabilities further. Automation and abstraction will continue to be a focus. Our next immediate task is to have Peacock automate the integration of new analysis and visualization techniques by leveraging ParaView proxies and the SimPut framework. By simply defining the desired analysis or visualization and selecting the relevant options, Peacock could generate the corresponding GUI elements on the fly. This would reduce the amount of programming required and make it easier for end-users to explore and analyze their simulation results and customize their workflows effortlessly. Additionally, the team aims to abstract the automation process to accommodate more general modeling and simulation codes, expanding the applicability of Peacock across various computational domains. + +## Conclusion + +The trame-based evolution of Peacock has transformed it into a more capable interface for MOOSE modeling and simulation. Peacock offers improved design, functionality, and remote execution capabilities. The integration of GUI and text editing, streamlined execution, and enhanced visualization with ParaView make Peacock a comprehensive tool for configuring, executing, and analyzing MOOSE-based applications. + +However, the journey continues. As Peacock continues to evolve and expand its capabilities, it promises to simplify further and enhance the MOOSE modeling and simulation workflow. Whether a novice or an experienced end-user, Peacock provides a user-friendly and efficient environment for modeling and simulation needs. + +So, why not give Peacock a try and experience the benefits of simplified MOOSE modeling and simulation firsthand? Discover how Peacock can streamline your analysis, optimize your designs, and unlock new insights into nuclear reactors and fuels. + +
+ +
+ +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## References + +1. [MOOSE Framework](https://www.mooseframework.org/) +2. [Nuclear Energy Advanced Modeling and Simulation (NEAMS)](https://neams.inl.gov/) +3. [Peacock: A Graphical Interface for MOOSE](https://mooseframework.inl.gov/python/peacock.html) +4. [Kitware’s trame Framework](https://github.com/kitware/trame) +5. [SimPut: Automate create web forms/ui using trame](https://github.com/Kitware/trame-simput) +6. [PyHIT: Reading, writing, and manipulating these files MOOSE input HIT format](https://mooseframework.inl.gov/python/pyhit/) +7. [trame-code: Monaco VS code editor widget for trame](https://github.com/Kitware/trame-code) +8. [trame-xterm: trame widget to expose xterm.js](https://github.com/Kitware/trame-xterm) +9. [trame: Visual Analytics Everywhere](https://www.kitware.com/trame-visual-analytics-everywhere/) +10. [trame Developers Course](https://www.kitware.com/trame-developers-course/) + +Tags: + +[MOOSE Simulations](https://www.kitware.com/tag/moose-simulations/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Peacock](https://www.kitware.com/tag/peacock/) | [Trame](https://www.kitware.com/tag/trame/) diff --git a/docs/vitepress/blogs/trame-architecture-and-capabilities.md b/docs/vitepress/blogs/trame-architecture-and-capabilities.md new file mode 100644 index 00000000..cbc56520 --- /dev/null +++ b/docs/vitepress/blogs/trame-architecture-and-capabilities.md @@ -0,0 +1,75 @@ +[post](https://www.kitware.com/trame-architecture-and-capabilities/) + +# trame: Architecture and Capabilities + +August 9, 2024 + +[Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Berk Geveci](https://www.kitware.com/author/berk-geveci/ "Posts by Berk Geveci"), [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder") and [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery") + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image2-1.jpg) + +Kitware has developed the trame [[1](https://kitware.github.io/trame/)] platform to inspire developers like you to create impactful interactive browser-based visual applications. trame, a Python package, is your gateway to building powerful applications without the need for extensive web development knowledge. Its versatility is truly remarkable – it allows for creating desktop applications, Jupyter tools, HPC applications, or client/server cloud applications used with phones, tablets, laptops, and desktops without any code changes. This adaptability makes it a powerful tool for a diverse range of tasks. trame builds on top of VTK [[2](http://www.vtk.org)] and ParaView [[3](http://www.paraview.org)], as well as a set of web utilities. It allows for the easy definition of unlimited workflows in Python for pre-processing, processing, and post-processing. It seamlessly integrates modern user interface (UI) elements with three-dimensional (3D) renderings, charts, tables, and more to create a visually appealing user experience. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/fig1-1024x465.png) + +***Figure**: (a) The trame architecture allows developers access to states, events, widgets, and user interfaces (UI) through Python, hiding the complexity of web development. (b) The result is an application that can run nearly everywhere (phones, tablets, laptops, and desktops) in various computational environments (desktop, Jupyter, HPC, and Cloud).* + +While trame shares some similarities with tools like Plotly Dash, Bokeh, or Streamlit, its underlying foundations are distinct. Unlike traditional web servers that rely on stateless servers, a trame application utilizes a dedicated stateful server process per client. This design offers two key advantages. Firstly, it enables faster interactions, such as remote rendering of a 3D scene with VTK, by leveraging data in memory without relying on any caching infrastructure. Secondly, it ensures the application does not share objects or memory with other end users. To serve multiple end users on shared hardware, trame provides pre-configured Docker images that manage the individual processes, facilitating basic cloud deployment. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/fig2-1024x258.png) + +***Figure**: A trame application for analysis, inspection, and reduction of multi-detector data produced by the Small-Angle Neutron Scattering (SANS) instruments. The end-user uses the same code for (a) a desktop application, (b) a Jupyter utility, and (c) a traditional client/server web application for use in high-performance computing and cloud environments.* + +Vuetify is a UI toolkit seamlessly integrated with trame that offers a wide range of interactive widgets, enhancing the appearance of applications. It organizes the UI using a hierarchical structure of widgets, similar to HTML, but trame expresses the UI design in plain Python code. Furthermore, trame provides various integrations with popular Python libraries for different analyses and visualizations, such as VTK, ParaView, Markdown, Matplotlib, Plotly, Altair, Vega, PyDeck, and more. Even if trame lacks a specific feature, it’s usually straightforward to integrate, particularly if the components already have web implementations. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/fig3-1024x657.jpg) + +***Figure**: This image depicts interactive explainable artificial intelligence (XAI) toolkit [[4](https://github.com/XAITK/xaitk-saliency-web-demo)] visualizations in a trame-based machine learning inference application that leverages PyTorch-trained models.* + +trame is a platform that offers two straightforward methods to connect the back-end and front-end of an application. It provides a reactive shared state infrastructure that binds variables between processing/analyzing and UI representations/visualizations. Additionally, trame allows Python methods to directly bind to user interface elements that react to end-user events like clicks, touches, or mouse interactions. This user-friendly approach and flexibility make trame a powerful tool for developers of all levels of expertise. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/fig4-1024x359.png) + +***Figure**: (a) Vuetify UI is produced automatically using the trame-simput package. (b) Custom HTML/CSS widgets and visualizations using VTK and Plotly.* + +With trame’s flexibility and “write once, use everywhere” design, you are the winner when you select to build on top of the trame framework. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## References + +[1] trame, Software Package, Ver. 3.6.0, Kitware, Inc., Clifton Park, NY, 2024. , DOI 10.5281/zenodo.10957638 + +[2] Schroeder, W., Martin, K., and Lorensen, B. (2006), The Visualization Toolkit (4th ed.), Kitware, ISBN 978-1-930934-19-1. + +[3] Ahrens, J., Geveci, B., and Law, C., ParaView: An End-User Tool for Large Data Visualization, Visualization Handbook, Elsevier, 2005, ISBN-13: 9780123875822[4] Explainable AI trame application, Software Package, Ver. 2.4.2, Kitware, Inc. Clifton Park, NY, 2024. + +[4] Explainable AI trame application, Software Package, Ver. 2.4.2, Kitware, Inc. Clifton Park, NY, 2024. + +Tags: + +[ParaView](https://www.kitware.com/tag/paraview/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) | [Web Visualization](https://www.kitware.com/tag/web-visualization/) + diff --git a/docs/vitepress/blogs/trame-dashboard-use-case.md b/docs/vitepress/blogs/trame-dashboard-use-case.md new file mode 100644 index 00000000..e1f36627 --- /dev/null +++ b/docs/vitepress/blogs/trame-dashboard-use-case.md @@ -0,0 +1,127 @@ +[post](https://www.kitware.com/trame-dashboard-use-case/) + +# trame: Dashboard Use Case + +September 5, 2024 + +[Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery"), [Berk Geveci](https://www.kitware.com/author/berk-geveci/ "Posts by Berk Geveci") and [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder") + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image5-1.png) + +## trame + +Kitware’s trame [[1](https://kitware.github.io/trame/)] platform is designed to spark creativity and empower developers to build compelling interactive visual applications that can be accessed directly through web browsers. trame, a Python package, serves as a conduit for building robust applications without necessitating extensive web development proficiency. Its remarkable versatility allows for the creation of desktop applications, Jupyter tools, HPC applications, and client/server cloud applications for various devices such as phones, tablets, laptops, and desktops, without the need for any code modifications. Check out our first blog in this series for in-depth information on trame: “trame: Architecture and Capabilities” [[2](https://www.kitware.com/trame-architecture-and-capabilities/)]. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image16-1024x745.jpg) + +**Figure**: trame-based application to examine Uber ridesharing pick-ups and drop-offs in New York City over time. + +## Dashboards + +A dashboard is an analysis and visualization tool that provides at-a-glance views of data and information, especially key metrics or performance indicators, that drive organizational decision-making processes. It combines several interactive reports and is becoming the most common visualization application. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image1-1024x643.png) + +**Figure**: A simple [trame-based US population dashboard](https://github.com/Kitware/trame-app-dashboard) that utilizes state-of-the-art data visualization tools (Altair/Vega, Matplotlib, Plotly, and Markdown), all native in trame. + +There are three main types of dashboards: + +* ***Operational*** for displaying real-time data +* ***Strategic*** for showing patterns and trends over time +* ***Analytical*** for more advanced analytics + +trame shines in producing science and engineering dashboards that often have three-dimensional (3D) visualizations. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image17.png) + +**Figure**: ParaView visualization of a rock sample obtained from an Austin Chalk Formation outcrop [[3](http://www.digitalrocksportal.org/)]. + +trame leverages existing widgets and visualization libraries and tools to create vivid content for visual analytics applications. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image8-300x212.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image13-1-1024x580.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image15-1024x665.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/Untitled-1.png) + +**Figure**: U.S. population (a) a MatPlotLib growth chart over time, (b) a Plotly choropleth map for 2016, (c) an Altair Vega plot of year versus state, (d) a Markdown plot of states with the great gains and losses, and (e) a Vuetify progress plot of top states. + +Big Data, often compared to new oil, requires refining and processing for effective utilization. Data from various sources can create scientific and engineering dashboards and powerful tools, making data easily accessible and understandable and empowering end-users with visual representations of key information. + +Dashboards are essential tools in various scientific and engineering endeavors, and trame supports creating dashboards by organizations, including the Nuclear Energy Advanced Modeling and Simulation (NEAMS) program of the U.S. Department of Energy-Office of Nuclear Energy (DOE-NE). + +The NEAMS program develops advanced modeling and simulation tools and capabilities to expedite the deployment of advanced nuclear energy technologies, including light-water reactors (LWRs), non-light-water reactors (non-LWRs), and advanced fuels. One of the NEAMS Toolkit codes is the Virtual Environment for Reactor Analysis (VERA). VERA is the NEAMS LWR multiphysics code suite. It integrates physics components based on science-based models and state-of-the-art numerical methods (see and ). + +We have innovatively created a [trame-based science and engineering dashboard for VERA](https://github.com/Kitware/VERACore) called VERACore [[4](https://www.kitware.com/veracore-trame-in-application/)], a tool that holds immense potential in the analysis and visualization of VERA results as researchers search for solutions and insights for the design, operation, safety, and performance optimization of current and future nuclear light-water reactors. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image3-1024x727.png) + +**Figure**: The Virtual Environment for Reactor Applications (VERA) dashboard with VTK interactive visualization, Plotly graphs, and custom visualization widgets for navigating to specific pin locations in a 73-thousand-plus pin light-water reactor. + +VERACore leverages existing widget and visualization libraries and tools like Vuetify and Plotly. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image4.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image6.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image7.png) + +**Figure**: (a) a Plotly axial plot component, (b) a Vuetify Table component, and (c) a Plotly time plot. + +VERACore utilizes VTK for 3D volume visualization views. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image11.png) + +**Figure**: A ParaView volume visualization component. + +If necessary or desired, trame allows for the creation and seamless integration of specialized components based on HTML/CSS, Vue, and more. VERACore uses sophisticated custom widgets to navigate these massive data sets from core view down to pellet view. + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image14.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image12-493x1024.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/08/image5-1.png) + +**Figure**: Custom navigational widgets (a) core view for assembly navigation, (b) axial view for vertical navigation, and (c) assembly view for pin/pellet navigation. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## References + +[1] trame, Software Package, Ver. 3.6.0, Kitware, Inc., Clifton Park, NY, 2024. , DOI 10.5281/zenodo.10957638 + +[2] trame: trame: Architecture and Capabilities, June 15, 2024. + +[3] Heidari, Z., and Posenato Garcia, A., “Austin Chalk”, Digital Rocks Portal, 2016. [Online]. Available: . [Assessed: 24-May-2024] + +[4] Avery, P., Jourdain, S., O’Leary, P., and Schroeder, W., VERACore: trame in Application, January 18, 2023. + +Tags: + +[ParaView](https://www.kitware.com/tag/paraview/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Trame](https://www.kitware.com/tag/trame/) | [Visualization](https://www.kitware.com/tag/visualization/) | [VTK](https://www.kitware.com/tag/vtk/) | [web](https://www.kitware.com/tag/web/) + diff --git a/docs/vitepress/blogs/trame-micro-workflow-use-case.md b/docs/vitepress/blogs/trame-micro-workflow-use-case.md new file mode 100644 index 00000000..1f8e7967 --- /dev/null +++ b/docs/vitepress/blogs/trame-micro-workflow-use-case.md @@ -0,0 +1,115 @@ +[post](https://www.kitware.com/trame-micro-workflow-use-case/) + +# trame: Micro-Workflow Use Case + +October 1, 2024 + +[Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Berk Geveci](https://www.kitware.com/author/berk-geveci/ "Posts by Berk Geveci"), [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery") and [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder") + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image6-1.png) + +## trame + +Kitware has created trame [[1](https://kitware.github.io/trame/)] to spark creativity and empower developers to construct compelling interactive visual applications accessible directly through web browsers. trame, a Python package, functions as a tool for building robust applications without the need for extensive knowledge in web development. Its remarkable adaptability facilitates the creation of desktop applications, Jupyter tools, HPC applications, and client/server cloud applications for various devices, including phones, tablets, laptops, and desktops, without making any changes to the code. Check out our other blogs from the trame series for in-depth information on trame: “trame: Architecture and Capabilities” [[2](https://www.kitware.com/trame-architecture-and-capabilities/)] and “trame: Dashboard Use Case” [[3](https://www.kitware.com/trame-dashboard-use-case/)]. + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image6-1024x635.png) + +This image depicts the trame-based conceptual modeler application that uses GemPy and machine learning to design geological models for surface and subsurface modeling. + +## Micro-Workflows + +Imagine a workflow as a carefully choreographed dance of steps, each leading seamlessly to the next, all working together to bring a process to life. However, these elegant workflows often demand the use of complex advanced modeling and simulation (M&S) tools, creating a barrier for many who seek to harness the power of simulation for discovery and innovation. + +We’re on a mission to simplify simulation workflows and enhance simulation software’s usability, all to encourage a broader range of people to embrace simulation technology. To achieve this, we break down software usability into two key elements: how easy it is to learn and how easy it is to use. + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image4-1024x475.png) + +This is a typical simulation workflow, but many others exist. + +Learning the ropes boils down to how powerful and flexible the simulation software is. The more bells and whistles it has, the steeper the learning curve. When end-users have more options, mastering the software becomes more challenging. + +The user experience involves manipulating the simulation product to make it work. This could mean running a command-line function or using a graphical user interface (GUI). The GUI, in particular, is designed to enhance ease of use and simplify the learning process, providing the end-user with a supportive tool to navigate the complexity of the software’s functionality and flexibility. + +The Department of Energy’s Nuclear Energy Advanced Modeling and Simulation (NEAMS) Toolkit offers powerful tools for designing, analyzing, and licensing advanced nuclear systems and experiments. However, it requires specialized training and skills to use effectively. Simplifying the use and deployment of these tools is crucial to enable analysts and other stakeholders to create high-fidelity simulations. This usability enhancement will pave the way for even more efficient and groundbreaking nuclear energy solutions. + +MOOSE [[4](https://www.mooseframework.org/)] is an incredible parallel computing platform created by the Idaho National Laboratory (INL) as part of the NEAMS Toolkit. It’s designed to handle multiphysics and finite-element simulations and has an intuitive interface for advanced nonlinear solver technology. The MOOSE framework is all about being user-friendly and tackling real-world challenges that scientists and engineers encounter. The MOOSE team has considered everything, from making installation a breeze to running simulations on state-of-the-art supercomputers. This attention to detail means that MOOSE can supercharge research, even though getting started with MOOSE can still be tricky. + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image5.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image10-1024x601.png) + +Peacock 2.0 (a) simulation definition with domain visualization and (b) simulation definition where we present synced GUI and text editor views side-by-side to improve ease of learning. + +We created the trame-base Peacock 2.0 [[5](https://mooseframework.inl.gov/python/peacock.html), [6](https://www.kitware.com/the-evolution-of-peacock-a-powerful-interface-for-moose-simulations/)], a cutting-edge technology encapsulating the entire MOOSE workflow in a user-friendly GUI, offering unlimited functionality and flexibility. After years of meticulous consideration by the MOOSE development team, we simply transformed the engineer’s interaction with the platform by replacing key-clicking with mouse-clicking input. The Peacock 2.0 GUI maintains the same functionality and flexibility as the input deck, ensuring a seamless and user-friendly experience but provides limited improvement in usability. + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image8-1024x602.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/image9-1024x603.png) + +Peacock 2.0 (a) simulation execution and (b) embedded analysis and visualization. + +The lesson learned from this experience is that we should tailor exposed simulator functionality to specific use cases and constrain flexibility to enhance ease of use and learning. + +The end-to-end simulation process is a series of tasks connected by data dependencies. To make simulation software more user-friendly, we propose the idea of a micro-workflow. These micro-workflows demonstrate the capabilities of simulation workflows by presenting specific use cases as templates. The end-users can access limited configuration options through a GUI in a trame-based application. + +We have explored an interesting set of workflows relevant to the pharmaceutical industry. Pharmaceutical companies often start by developing and optimizing processes on a small scale. Still, they must also ensure these processes work in larger production-scale bioreactors. To do this, many use M-Star Simulations’ advanced computational fluid dynamic (CFD) software [[7](https://mstarcfd.com/)] to forecast the intricate, multi-fluid mixing process. We’ve enhanced these activities by developing ArrowFlow [[8](https://www.kitware.com/arrowflow/)], a micro-workflow application tailored for specific use cases, allowing their analysts to harness this powerful capability. + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/Screenshot-2024-05-16-at-16.22.17-1024x763.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/Screenshot-2024-05-16-at-16.24.10-1024x763.png) + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/Screenshot-2024-05-16-at-16.25.47-1024x763.png) + +ArrowFlow, which allows stakeholders to define, run, and analyze simulation use cases with M-Star CFD™ for a range of applications. + +The analyst can explore various use cases such as blending time, particle suspension and transportation characteristics, and mean fluid shear and energy dissipation rate. Suppose the analyst selects the blending time use case, for example. In that case, we present a new page where they can adjust micro-workflow parameters like rotation speed, liquid level, and dye injection time. Next, they hit the run button and watch the micro-workflow display the analysis and visualization page with stunning 3D visualizations and interactive 2D charts. The analyst can customize the visualizations by hiding or showing different elements of the 3D simulation domain or plotting different quantities. ArrowFlow makes these micro-workflows easy to learn and use – it’s a game-changer! + +trame’s exceptional flexibility and “write once, use everywhere” design make it the perfect choice for improving the usability of simulation software. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## References + +[1] trame, Software Package, Ver. 3.6.0, Kitware, Inc., Clifton Park, NY, 2024. , DOI 10.5281/zenodo.10957638 + +[2] trame: Architecture and Capabilities, June 15, 2024. + +[3] trame: Dashboad Use Case, September 5, 2024. + +[4] The MOOSE framework, + +[5] Peacock, A Graphical User Interface for MOOSE, + +[6] Schenck, E., Jourdain, S., Avery, P., and O’Leary, P., The Evolution of Peacock: A Powerful Interface for MOOSE Simulations, June 22, 2023. + +[7] M-Star Computational Fluid Dynamics (CFD) Software. Real World Models. Real Time Results. + +[8] ArrowFlow, Software Package, Ver. 2024-05-17, Kitware, Inc., Clifton Park, NY, 2024. + +Tags: + +[ParaView](https://www.kitware.com/tag/paraview/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Scientific Visualization](https://www.kitware.com/tag/scientific-visualization/) | [Simulation Workflows](https://www.kitware.com/tag/simulation-workflows/) | [Trame](https://www.kitware.com/tag/trame/) | [Visualization](https://www.kitware.com/tag/visualization/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/trame-revolutionizing-visual-analytics-with-python.md b/docs/vitepress/blogs/trame-revolutionizing-visual-analytics-with-python.md new file mode 100644 index 00000000..e16eab26 --- /dev/null +++ b/docs/vitepress/blogs/trame-revolutionizing-visual-analytics-with-python.md @@ -0,0 +1,133 @@ +[post](https://www.kitware.com/trame-revolutionizing-visual-analytics-with-python/) + +# trame: Revolutionizing Visual Analytics with Python + +August 3, 2023 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery"), [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder") and [Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary") + +![](https://www.kitware.com/main/wp-content/uploads/2023/08/trame-featured2.jpg) + +In today’s data-driven world, the ability to effectively analyze and visualize complex information is crucial. Visual analytics combines analytical reasoning with interactive visual interfaces to facilitate the exploration, analysis, and understanding of complex data and systems. The ability to visually represent data interactively and intuitively allows end-users to discover patterns, trends, and insights that may otherwise go unnoticed. However, creating visual analytics tools that are versatile, user-friendly, and compatible across various computing platforms can be a daunting task. + +## The Challenges of Building Visual Analytics Tools + +Creating effective visual analytics tools can be challenging, especially when considering modern applications’ diverse computing environments and requirements. Some of these challenges include: + +* Supporting various computing platforms, including mobile, desktop, Jupyter, high-performance computing (HPC), and cloud. +* Ensuring compatibility with different operating systems, such as Linux, macOS/iOS, and Windows. +* Integrating with various programming languages, such as Python, C++, and JavaScript. +* Working with diverse graphics libraries, including OpenGL, Vulkan, Metal, ANARI, and WebGPU. +* Developing client-server applications that handle large data processing and computational loads. +* Creating portable user interfaces (UIs) across computing platforms. +* Developing web-based applications at a rapidly changing web pace. + +## Introducing trame: A Breakthrough in Visual Analytics + +![NYC Uber Ridesharing Data. Showing visualizations of data from around NYC, JFK Airport, La Guardia Airport and Newark Airport.](https://www.kitware.com/main/wp-content/uploads/2023/08/image6-1024x585.jpg) + +*[trame](https://kitware.github.io/trame/index.html)* is a powerful and innovative solution that addresses the challenges of building visual analytics tools. Its open source Python framework enables developers to create visually stunning and interactive applications with scientific visualizations. trame simplifies the process of building web-based applications with its seamless integration of open source components, including VTK, ParaView, and Plotly. This allows developers to focus on the data analysis and visualization aspects without needing extensive web development knowledge. + +1. **Cross-Platform Compatibility:** trame supports various computing platforms, including mobile, desktop, Jupyter, HPC, and cloud. +2. **Integration with Open-Source Libraries:** trame seamlessly weaves together powerful open source components, including VTK and ParaView, to provide a simple and easy-to-use platform for creating visual analytics applications with scientific visualizations. +3. **Easy-to-Use UI Creation:** trame provides a simple and intuitive way to create UIs for visual analytics applications. By incorporating the Vuetify library, developers can easily design beautiful and interactive UI components, making their applications more user-friendly and visually appealing. +4. **Python Integration:** trame is primarily built on Python, making it accessible to many developers. With trame, developers can leverage the integration capabilities to utilize existing platforms like Altair, Vega, Plotly, Matplotlib, PyVista, and Vuetify and incorporate new open platforms like FormKit, Grid-Layout, Monaco, and Xterm into visual analytics applications. +5. **Seamless Client-Server Communication:** trame handles client-server coordination and state transfer transparently, enabling seamless communication between the front-end and back-end of the application. This capability allows for efficient processing and rendering, whether it’s performed on the client-side or server-side. + +## The Benefits of trame: Simple, Powerful, and Innovative + +The name ***trame*** means “***the core that ties things together***” in French, which reflects the framework’s purpose of simplifying the development process. trame offers several key advantages that set it apart from other frameworks: + +### Simplicity + +trame simplifies the development process by providing a clear and intuitive API for building applications. With trame, developers can focus on the data, analysis, and visualization without the complexities of web development. The framework enables developers to build powerful applications without extensive knowledge of web technologies quickly. + +![Orchestration of components from application to trame.](https://www.kitware.com/main/wp-content/uploads/2023/08/image7-1024x370.jpg) + +Building a trame application is just a matter of orchestrating the various components of the application leveraging the Python API for interacting with state, events, widgets, and UI conveniently and transparently. + +### Power and Flexibility + +Various tools and frameworks are available to build visual analytics applications, but only trame can provide full-featured interactive 3D visualization. trame harnesses the power of industry-leading, best-in-class platforms like VTK and ParaView to provide complete control over the processing for analysis and 3D visualization. Developers can leverage the extensive capabilities of these platforms while benefiting from trame’s simplified integration. And the flexibility of either local rendering or remote rendering is seamlessly exposed in trame through a single method call. + +![Screenshot of the Mesh Viewer](https://www.kitware.com/main/wp-content/uploads/2023/08/image4-1024x585.jpg) + +### Rich Features and Integration + +trame leverages existing state-of-the-art libraries and tools. This integration enables developers to utilize the full capabilities of these libraries and tools within their trame applications to create compelling user interfaces and interactive visualizations without reinventing the wheel. trame’s integration capabilities extend beyond the built-in libraries and tools, enabling seamless integration with other popular systems like PyVista and PyTorch. + +![trame altair charts showing US Income by state](https://www.kitware.com/main/wp-content/uploads/2023/08/image2-1024x586.jpg) + +![trame altair chart showing scatter matrix](https://www.kitware.com/main/wp-content/uploads/2023/08/image1-1024x586.jpg) + +### Portability and Deployment + +trame applications can be deployed on local desktops to remote clouds. This flexibility allows end-users to access web-based trame client-server across different computing environments. Wherever the application runs, trame provides a seamless, consistent experience. + +![MStar Simulation](https://www.kitware.com/main/wp-content/uploads/2023/08/image8-1024x675.jpg) + +### Open Source + +trame is open source and licensed under the Apache License Version 2.0, allowing developers to create their own open source or commercial applications without licensing restrictions. Whether you’re building applications for research, commercial use, or personal projects, trame offers a flexible and reliable platform to bring your visual analytics ideas to life. + +## Getting Started with trame + +You can start building interactive visual analytics applications with trame by following these simple steps. + +**Get hands-on guidance from one of the trame developers at Kitware! Register for our upcoming “[Intro to trame](https://www.kitware.com/courses/trame/)” training course.** + +1. **Install trame –** Begin by installing trame using pip, a package manager for Python: + +``` +pip install trame trame-vuetify trame-vtk +``` + +2. **Define application logic –** Next, create the processing functions in plain Python and define the state shared with the UI. This task includes defining the data analysis algorithms and any parameters the end-user can adjust. + +3. **Reactive to state changes –** Define methods that respond to changes in the shared state. For example, if a slider is used to adjust a sampling parameter, define a method that updates the sampling algorithm based on the new slider value. + +4. **Design the UI –** Build a beautiful and accessible UI by defining the layout of your application and connecting the state and functions to the UI elements directly. trame provides a built-in Material Design widget library accessible through Vuetify (https://vuetifyjs.com/en/components/all/), making creating visually appealing UI components easy. + +5. **Run the Application –** Once the application is ready, it can be run locally as a desktop (still a client-server) application. + +``` +python app.py --port 1234 +``` + +![Python code for trame](https://www.kitware.com/main/wp-content/uploads/2023/08/image3-751x1024.png) + +![Screenshot of VTK Local Rendering of a triangle shape](https://www.kitware.com/main/wp-content/uploads/2023/08/image5-1024x833.png) + +## Make Your Data Come to Life with trame + +trame is a game-changer in the field of visual analytics. With its focus on analysis and visualization, trame removes the complexities of web development and enables developers to focus on what matters most: unlocking insights in their data. Start exploring trame and see how it can revolutionize your data analysis workflows. For more information, including tutorials, the discourse forum, and other helpful resources, visit the [trame website](https://kitware.github.io/trame/). + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Open Source](https://www.kitware.com/tag/open-source/) | [Python](https://www.kitware.com/tag/python/) | [Trame](https://www.kitware.com/tag/trame/) | [visual analytics](https://www.kitware.com/tag/visual-analytics/) | [Visual Data](https://www.kitware.com/tag/visual-data/) + diff --git a/docs/vitepress/blogs/trame-slicer-announcement.md b/docs/vitepress/blogs/trame-slicer-announcement.md new file mode 100644 index 00000000..f7ca777d --- /dev/null +++ b/docs/vitepress/blogs/trame-slicer-announcement.md @@ -0,0 +1,91 @@ +[post](https://www.kitware.com/trame-slicer-announcement/) + +# trame-slicer: Bringing the power of 3D Slicer to the web + +November 20, 2025 + +[Thibault Pelletier](https://www.kitware.com/author/thibault-pelletier/ "Posts by Thibault Pelletier") and [Julien Finet](https://www.kitware.com/author/julien-finet/ "Posts by Julien Finet") + +![](https://www.kitware.com/main/wp-content/uploads/2025/11/Screenshot-2025-11-20-082509.png) + +Kitware is pleased to announce the launch of **trame Slicer**. + +trame Slicer is a Python library to create modern Vue-based web applications by leveraging the [trame framework](https://www.kitware.com/trame/). It provides access to core [3D Slicer](https://www.slicer.org/) functionalities, such as segmentation, registration, and volume rendering, directly through Python, greatly improving the development experience. + +The library acts as a bridge between the 3D Slicer core components and the trame web server, allowing web native access to 3D Slicer features and enabling the development of rich medical workflows. This integration will make it possible to build scalable web applications for medical image data visualization and analytics. + +![](https://www.kitware.com/main/wp-content/uploads/2025/11/trame-slicer-medical-app-example-1-1024x614.png) + +*Figure 1: Segmented mandibular and maxillary from [Dental Segmentator](https://github.com/gaudot/SlicerDentalSegmentator)* + +## Why does it matter? + +3D Slicer is a robust and feature-rich platform that brings together over 200 specialized medical modules, making it highly effective for data exploration and medical processing tasks. It supports a wide range of use cases, particularly for expert users who require deep access to tools and customization. + +However, 3D Slicer is desktop-only application, which can make deployment, collaboration, and accessibility challenging especially in modern medical and research environments that increasingly rely on web and cloud-based workflows. Bringing these powerful capabilities to the browser is both important and technically demanding: medical imaging applications require real-time 3D rendering, large-volume processing, and secure data handling, all of which must be delivered efficiently over the web. + +This is where **trame Slicer** makes a difference. + +As a web application framework, trame Slicer enables the development of lightweight, browser-accessible interfaces tailored to specific clinical or research needs. It bridges 3D Slicer’s native power with trame’s modern web architecture, allowing developers to deploy Slicer’s segmentation, registration, and visualization tools directly through Python—all without requiring a local installation. + +By offloading workloads to the server, trame Slicer reduces hardware demands on the client side, making advanced capabilities like AI segmentation accessible on any device. Data such as DICOM files remains securely on the server for processing and rendering, supporting both performance and compliance. This design not only handles massive datasets efficiently but also ensures patient data never leaves the secure environment. + +Ultimately, trame Slicer makes powerful Slicer components available to Python application developers, simplifying the creation of focused medical applications for the web. + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/20251020-kidney-box-2-1024x731.png) + +*Figure 2: Volume rendering and markups interactions powered by 3D Slicer* + +## How to get started? + +Although the library is still in development, core features are already available and production-ready. To get started, the following options are available : + +### trame Slicer library + +The [trame Slicer library](https://github.com/KitwareMedical/trame-slicer) is available for Python-only integration, making it easy to incorporate into custom environments and cloud Docker and Kubernetes deployment. At present, publicly available 3D Slicer core functionality Python wheels have only been provided for Python 3.10 and Linux / Windows. + +Windows and Linux 3D Slicer wheels are [provided for download](https://github.com/KitwareMedical/trame-slicer?tab=readme-ov-file#downloading-the-latest-wheels), and the trame Slicer library itself can be downloaded and installed directly from [PyPI](https://pypi.org/project/trame-slicer/). + +Work is underway with the 3D Slicer community to provide pre-built 3D Slicer wheels directly by the 3D Slicer continuous integration for stable 3D Slicer releases. + +### Slicer trame extension + +The [Slicer trame extension](https://github.com/KitwareMedical/SlicerTrame) provides access to trame Slicer directly from the 3D Slicer application. The extension is available from Slicer 5.9 nightly release onward and available for all nightly release versions. + +This setup provides direct access to all 3D Slicer’s internal libraries and installed modules, though direct compatibility with trame Slicer is not guaranteed at the moment. + +This extension is ideal for early access to the trame Slicer features across all platforms. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with trame Slicer. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## Credits + +The effort behind the trame Slicer library has been partially financed by the [Cure Overgrowth Syndromes (COSY)](https://rhu-cosy.com/en/accueil-english/) RHU Project (ANR-18-RHUS-0005), the [Handling heterogeneous Imaging and signal data for analysing the Neurodevelopmental Trajectories of premature newborns (HINT)](https://anr-hint.pages.in2p3.fr/) ANR project (ANR-22-CE45-0034) and Kitware Europe early-adopter customers. + +Tags: + +[3D Slicer](https://www.kitware.com/tag/3d-slicer/) | [Medical Imaging](https://www.kitware.com/tag/medical-imaging/) | [Press Releases](https://www.kitware.com/tag/press/) | [Trame](https://www.kitware.com/tag/trame/) | [Web Applications](https://www.kitware.com/tag/web-applications/) + diff --git a/docs/vitepress/blogs/transform-your-medical-imaging-with-kitwares-comprehensive-suite-of-advanced-visualization-solutions.md b/docs/vitepress/blogs/transform-your-medical-imaging-with-kitwares-comprehensive-suite-of-advanced-visualization-solutions.md new file mode 100644 index 00000000..f45c37fb --- /dev/null +++ b/docs/vitepress/blogs/transform-your-medical-imaging-with-kitwares-comprehensive-suite-of-advanced-visualization-solutions.md @@ -0,0 +1,51 @@ +[post](https://www.kitware.com/transform-your-medical-imaging-with-kitwares-comprehensive-suite-of-advanced-visualization-solutions/) + +# Transform Your Medical Imaging with Kitware’s Comprehensive Suite of Advanced Visualization Solutions + +November 17, 2023 + +[Andinet Enquobahrie](https://www.kitware.com/author/andinet-enquobahrie/ "Posts by Andinet Enquobahrie"), [Sankhesh Jhaveri](https://www.kitware.com/author/sankhesh-jhaveri/ "Posts by Sankhesh Jhaveri") and [Shreeraj Jadhav](https://www.kitware.com/author/shreeraj-jadhav/ "Posts by Shreeraj Jadhav") + +![](https://www.kitware.com/main/wp-content/uploads/2023/11/FeatureImage.png) + +Are you looking to develop visualization applications with cutting-edge medical imaging technology? + +Kitware can help you realize your product. We have an extensive track record of developing medical visualization applications and scientific software development platforms using web technologies ([VTK-js](https://kitware.github.io/vtk-js/docs/), [Trame](https://kitware.github.io/trame/), [VolView](https://volview.kitware.com/), [Glance](https://kitware.github.io/glance/index.html), [ITK-Jupyter-widgets](https://itkwidgets.readthedocs.io/en/latest/), [ITK-wasm](https://wasm.itk.org/en/latest/)) as well as native desktop toolkits ([VTK](http://vtk.org), [ITK](https://itk.org/), [3D Slicer](https://www.slicer.org/), [Paraview](http://paraview.org) and their customizations). + +VTK and VTK-js include best-in-class 3D medical visualization techniques such as customizable cinematic volume rendering, enhanced lighting, and transfer function editing, demonstrated through our implementation in VolView and 3D-Slicer that can further enhance the user experience and workflow in radiological and diagnostic applications. Our platforms can leverage modern immersive technologies such as OpenVR, OpenXR, and WebXR to create [virtual and augmented reality (VR/AR)](https://www.kitware.com/vtk-js-transforms-web-based-visualization-with-immersive-virtual-and-augmented-reality/) interfaces. Some latest examples include deployment on light-field displays such as the [Looking Glass](https://www.kitware.com/lookingglassvtkmodule-v1-0/) using VolView and head-mounted displays (HMDs) using 3D Slicer. + +We support a broad range of technologies such as application development in C++, Python, C#, and Javascript and user interface development in Qt, WPF, React, and Vue. Additionally, [*trame*](https://www.kitware.com/trame-revolutionizing-visual-analytics-with-python/) is our Python-based integration framework that enables non-web developers to create powerful, complex client-server web applications supporting large-scale data processing and visualization. Whether you want to deploy platform-agnostic web apps or develop highly efficient and responsive desktop applications that can be deployed on clinical workstations, we can support you in leveraging our versatile open-source platforms to achieve your product. We can work with you in many different ways, whether it is rapid development of usable/viable prototypes, improving usability, optimizing performance and troubleshooting latency issues, or providing training and support for leveraging and making the most out of our various high-quality open source platforms. + +![](https://lh7-us.googleusercontent.com/MVJZcYFKntKTBcZYlgyRimekvtv82PPqtVaSVPTHwloAfjqBq1wF9JQqYQjr8NLYaSbitn8Yl1qWBcPIk9IM9jPp1-RddDwCCZuu8QQGXAL-Q4HFtN16LMTAfBhWiPSQ4W8hjUrrb0XohLWl0C3s3k4) + +As you explore options for your visualization product development strategy, consider how collaborating with Kitware can provide a unique advantage to help you bring your innovative technology to market. We will be demonstrating these and other technologies at the [RSNA conference](https://www.kitware.com/rsna-annual-meeting-2023/). If you are attending RSNA, please stop by our booth #4367 for an in-person discussion or [request a meeting](https://www.kitware.com/contact/project/) with our technical experts for a virtual consultation. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[3D Slicer](https://www.kitware.com/tag/3d-slicer/) | [ITK](https://www.kitware.com/tag/itk/) | [itk-wasm](https://www.kitware.com/tag/itk-wasm/) | [Trame](https://www.kitware.com/tag/trame/) | [VolView](https://www.kitware.com/tag/volview/) | [VTK](https://www.kitware.com/tag/vtk/) | [VTK-JS](https://www.kitware.com/tag/vtk-js/) + diff --git a/docs/vitepress/blogs/using-python-to-power-scalable-sustainable-innovation.md b/docs/vitepress/blogs/using-python-to-power-scalable-sustainable-innovation.md new file mode 100644 index 00000000..9b578a43 --- /dev/null +++ b/docs/vitepress/blogs/using-python-to-power-scalable-sustainable-innovation.md @@ -0,0 +1,103 @@ +[post](https://www.kitware.com/using-python-to-power-scalable-sustainable-innovation/) + +# Using Python to Power Scalable, Sustainable Innovation + +October 6, 2025 + +[Jean-Christophe Fillion-Robin](https://www.kitware.com/author/jchris-fillionr/ "Posts by Jean-Christophe Fillion-Robin"), [Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Dženan Zukić](https://www.kitware.com/author/dzenan-zukic/ "Posts by Dženan Zukić") and [Samantha Schmitt](https://www.kitware.com/author/samantha-schmitt/ "Posts by Samantha Schmitt") + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/Python-Expanding.png) + +Python isn’t just a language you code in—it’s the foundation for some of today’s most groundbreaking technologies. From large-scale simulations to NLP and AI, Python is powering research and innovation across industries. By integrating Python into open source platforms, high-performance workflows, and next-generation applications, Kitware is helping organizations tackle their most ambitious projects. + +# Powered by Python + +Across Kitware’s suite of open source platforms, Python transforms what could be just software into engines of innovation—scalable, customizable, and collaborative tools designed to solve real-world challenges. For example: + +* **[ParaView](https://www.paraview.org/)** — We leverage Python scripting to help partners customize and automate large-scale visualization workflows, reducing manual steps and accelerating insight. +* **[3D Slicer](https://www.slicer.org/)** — Our teams extend Slicer through Python modules to support advanced medical imaging research, enabling rapid prototyping and clinical translation. +* **[trame](https://www.kitware.com/trame/)** — Built around Python-first development, trame lets us quickly deploy interactive visualization and simulation applications directly in the browser—without requiring web expertise. +* **[Catalyst](https://kitware.github.io/paraview-catalyst/)** — By integrating Catalyst’s Python capabilities into HPC environments, we connect simulations with live analysis, cutting data movement, and unlocking real-time decision-making. +* [**ITK**](https://itk.org/) **& [VTK](https://vtk.org/)** — Foundational toolkits with robust Python interfaces, ITK and VTK bring advanced image processing and visualization capabilities to developers and researchers worldwide. + +# Case Studies: Python in Action + +The impact of Python is best seen in practice. Here are a few ways Kitware has helped partners solve complex challenges with Python-powered solutions: + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/Pan3D-kitware-1.png) + +## [Interactive Climate Analytics](https://www.kitware.com/vtk-pydata-interoperability-interactive-climate-analytics-with-pan3d-xarray-and-xcdat/) + +With Pan3D, researchers can build complete climate workflows in Python, enabling interactive exploration of multidimensional datasets. **Outcome: Faster, more intuitive insight generation.** + +### + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/OpenLIFU-kitware-1.png) + +## [Ultrasound Research](https://www.kitware.com/openlifu-accelerating-focused-ultrasound-research-with-open-source-hardware-and-3d-slicer-driven-software/) + +OpenLIFU, built on Slicer’s Python framework, provides modular pipelines for focused ultrasound research. **Outcome: Development time was cut in half, and collaboration broadened across institutions.** + +### + +![](https://www.kitware.com/main/wp-content/uploads/2025/10/Complex-Data-kitware-1.png) + +## [Complex Data Analysis](https://www.kitware.com/how-trame-powers-todays-visualizations/) + +For a top U.S. university, Kitware integrated scalable Python workflows to streamline complex data analysis. **Outcome: More efficient data processing and visualization, as well as improved collaboration.** + +# Beyond Platforms: Building the Python Ecosystem + +Kitware doesn’t just build with Python—we help strengthen the ecosystem itself by: + +* Scikit-build-core, which streamlines building Python extensions with CMake. It is downloaded over 5 million times per month, underscoring its widespread adoption across the Python ecosystem ([SciPy 2024 Proceedings](https://proceedings.scipy.org/articles/FMKR8387)). +* Maintaining the [CMake](https://pypi.org/project/cmake/) and [Ninja](https://pypi.org/project/ninja/) Python packages—each downloaded tens of millions of times monthly—which serve as essential tools for developers worldwide. + +* Supporting the [Scientific Python Library Development Guide](https://learn.scientific-python.org/development/), a community resource that helps new contributors adopt sustainable practices. +* Maintaining the [CPython CMake Buildsystem](https://github.com/python-cmake-buildsystem/python-cmake-buildsystem), a modern replacement for CPython’s legacy build tooling. It simplifies cross-compiling, unifies build information across platforms, integrates seamlessly with tools like Ninja, and significantly accelerates build times. + +These efforts ensure Python continues to thrive as a sustainable foundation for innovation. + +# What’s Trending Now: Python for AI, Machine Learning, and Natural Language Processing + +Python dominates AI and machine learning because it supports nearly every stage of the pipeline, from research and prototyping to large-scale deployment. Its rich ecosystem of libraries like TensorFlow, PyTorch, scikit-learn, and spaCy, combined with strong community support, has made it the default choice for projects across government, academia, and industry. As natural language processing (NLP) tools become increasingly prominent, Python’s role will only expand further, powering applications from automated translation and sentiment analysis to large language models. + +Kitware has experienced this trend firsthand. Our [explainable AI software package](https://www.kitware.com/kitware-secures-1-7-million-contract-from-u-s-department-of-defense/) for the U.S. Department of Defense, [large-scale data exploration](https://www.kitware.com/geowatch/) for the Intelligence Advanced Research Projects Activity (IARPA), and developing AI models for [underwater acoustics](https://www.kitware.com/advancing-undersea-soundscape-awareness-kitwares-maritime-acoustic-recognition-and-identification-with-novel-algorithms-marina-project/) for the Defense Advanced Research Projects Agency (DARPA) all rely heavily on Python. + +As tools like large language models become more prominent, expect Python to continue shaping next-generation applications, from conversational AI to real-time decision-making. + +# Harnessing Python + +For organizations already invested in Python, the next challenge is scaling that investment—sustainably, securely, and at speed. Python is more than a programming language—it’s the strategic engine behind today’s most innovative technologies. + +At Kitware, we partner with organizations to translate Python’s potential into measurable impact: accelerating discovery, improving workflows, and sustaining open innovation. **If your organization is ready to take its Python-based projects to the next level, we’d love to collaborate.** [**Contact us to get started.**](https://www.kitware.com/contact/) + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[3D Slicer](https://www.kitware.com/tag/3d-slicer/) | [AI](https://www.kitware.com/tag/ai/) | [Catalyst](https://www.kitware.com/tag/catalyst/) | [Data Analysis](https://www.kitware.com/tag/data-analysis/) | [HPC](https://www.kitware.com/tag/hpc/) | [In Situ](https://www.kitware.com/tag/in-situ/) | [ITK](https://www.kitware.com/tag/itk/) | [Open Source](https://www.kitware.com/tag/open-source/) | [ParaView](https://www.kitware.com/tag/paraview/) | [Python](https://www.kitware.com/tag/python/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Simulation](https://www.kitware.com/tag/simulation/) | [Trame](https://www.kitware.com/tag/trame/) | [Visualization](https://www.kitware.com/tag/visualization/) | [VTK](https://www.kitware.com/tag/vtk/) | [WASM](https://www.kitware.com/tag/wasm/) + diff --git a/docs/vitepress/blogs/veracore-trame-in-application.md b/docs/vitepress/blogs/veracore-trame-in-application.md new file mode 100644 index 00000000..ab9a16ea --- /dev/null +++ b/docs/vitepress/blogs/veracore-trame-in-application.md @@ -0,0 +1,149 @@ +[post](https://www.kitware.com/veracore-trame-in-application/) + +# VERACore: trame in Application + +January 18, 2023 + +[Patrick Avery](https://www.kitware.com/author/patrick-avery/ "Posts by Patrick Avery"), [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain"), [Patrick O'Leary](https://www.kitware.com/author/patrick-oleary/ "Posts by Patrick O'Leary") and [Will Schroeder](https://www.kitware.com/author/will-schroeder/ "Posts by Will Schroeder") + +![](https://www.kitware.com/main/wp-content/uploads/2023/01/VERACore.png) + +In the first posts of this blog series we provided a high-level overview of trame: a Python- and web-based framework for visual analytics[[1](https://www.kitware.com/trame-visual-analytics-everywhere/),[2](https://www.kitware.com/trame-developers-course/)]. In this post we further illustrate some key concepts of trame through a real-world example. Due to the generosity of the DOE’s Nuclear Energy Advanced Modeling and Simulation (NEAMS) program, a complete working application is available to those that wish to learn more about trame. This important NEAMS research program, known as VERA, is used to solve neutronics, thermal-hydraulics, fuel performance, and coupled physics problems for light-water nuclear reactors (LWRs). It integrates physics components based on science-based models and state-of-the-art numerical methods[[3](https://vera.ornl.gov/),[4](https://neams.inl.gov/)]. + +Kitware’s role in this work was to rewrite VERA’s interactive visualization application, [VERAView](https://github.com/CASL/VERAview), used to analyze output data from VERA. VERAView was initially a desktop application developed over a period of approximately seven years. The trame-based replacement, known as VERACore, was recently created in approximately 2.5 weeks of developer effort (admittedly, very skilled Kitware developers) with 3,000 lines of code (LOC) with trame. (For comparison, VERAView is over 30,000 LOC.) Of course, this is not a fair comparison since the desktop VERAView application required envisioning capabilities, designing an effective user interface and workflows, and integrating visualization and other analysis features from VERA. Further, the [VERACore](https://pvw.kitware.com/vera/) trame-based application leverages the powerful capabilities of VTK/ParaView, Vue.js/Vuetify, and several Python libraries. However, the breathtaking speed to develop, and the brevity of this and other trame-based applications, is consistent with the productivity gains we have seen thus far with trame. + +Re-implementing VERAView with trame also added several significant features. + +* Firstly, the new VERACore application is web-based: it is easy to deploy through any standard web browser. (To run VERACore, and interact with the application, simply point your browser to: and you will see something like Figure 1 below.) There is no need to download operating-specific binaries, nor be concerned with security risks related to installing software on a computer. +* VERACore is built on trame’s client-server architecture which can scale to meet data and computational demands. In larger-scale applications, it’s possible to separate heavy computing and even rendering to a remote server, sending results to the web client. This is particularly important when data becomes prohibitively large and copying data to the desktop is not possible – the server can be deployed alongside the data system. Note however that the client and server can be bundled and used as a standalone desktop application–in this case from the user’s point of view the client-server architecture totally disappears. +* Thirdly, trame-based applications can leverage JavaScript especially Vue.js and the Vuetify UI framework. As illustrated by Figure 1, the UI is polished, highly interactive, and customizable – consistent with a modern, well-designed user interface. +* And finally, trame leverages Python libraries: in VERACore, some notable libraries include Plotly, NumPy, and H5py. Of course the Python interface to the visualization and data analysis libraries VTK and ParaView are integrated into trame as well, providing a wealth of visual analytics capabilities. + +In the following post, we will walk you through the trame-based VERACore application and highlight several implementation features. For those of you who cannot wait or want to dive into the details of the source code, please visit this [github site](https://github.com/kitware/veracore). + +### Application Overview + +The figure below shows VERACore in action–small variations in appearance are possible depending on the browser and any special settings. + +![](https://www.kitware.com/main/wp-content/uploads/2023/01/VERACore-1024x602.png) + +Figure 1. VERACore trame application. + +The application consists of several different “Views” of the underlying temporal data, x-y plots of selected data, a timeline indicating current the time step (in the footer of the application), and a horizontal scalar bar and scalar field selection in the header of the application. All views, plots, and other UI elements are cross-linked, so that making changes will automatically update the appropriate UI elements. (Note that progress is indicated after scalar selection by a spinning cursor – a nice UI touch!) The application supports plots, 2D views, and 3D interactive views. For example, the X Axial View shows a 2D reactor core visualization, while the Volume View provides a 3D interactive visualization. + +### Trame Implementation + +In the following we highlight several selected application features. While certainly not an exhaustive description, hopefully it will clarify some implementation details. + +#### Overall Framework + +To begin with, VERA produces output in the form of an HDF5 file. A class named `VeraOutFile` was created as an interface for ingesting this data. Some static information about the reactor core is obtained from this file, including the layout of the core, number of layers, and so on. Output arrays for each time step are also provided by this file. The `VeraOutFile` class is also responsible for tracking which time step in VERACore is currently active, and it loads all of the data from that time step into memory for faster data access when updating the views. Because trame is written in Python, we are able to leverage excellent tools from the scientific community such as h5py. + +On the UI side, `vera_core/app/ui/__init__.py` is responsible for creating the general layout of the program, including the toolbar at the top, the grid layout in the middle, and the time step slider at the bottom. Each item in the grid layout is then defined in its own Python file, which includes the grid item’s layout, initial values, as well as an update function that is called when the grid item needs to be updated. For example, the file `vera_core/app/ui/volume_view.py` defines the Volume View. + +One of the powerful features of trame is that it can be used in conjunction with JavaScript. This enables developers to leverage Vue.js and Vuetify to create compelling interfaces. In VERACore, some simple, custom JavaScript components were written and used within some of the views. For example, the CoreView JavaScript component is responsible for drawing the core view, indicating which assembly is currently selected, and changing the selected assembly on mouse click. + +The plots were created by using Plotly, the table was created using VDataTable (accessible from the trame-vuetify package), and the 3D volume view was created using VTK. + +Much of the power and simplicity of trame comes from its intuitive reactive programming style in which pieces of an application are described in isolation. Developers only need to focus on the part of the state that is needed, and/or link to any events that affect the isolated code. The code examples in the following demonstrate these programming patterns. + +#### Creating and linking views and plots + +The views (including plots) are defined in their own Python files. These files have two main sections: a UI section that defines the layout of the view, and an update section that indicates how and when the view is to be updated. For example, the layout of the axial plot is defined as follows: + +``` +with DivLayout(server, template_name="axial_plot") as layout: + layout.root.style = "height: 100%; width: 100%;" + + figure = trame_plotly.Figure( + display_logo=False, + display_mode_bar=False, + style="height: 100%; width: 100%; user-select: none;", + ) + ctrl.update_axial_plot = figure.update +``` + +The update function (see the *Updating views* section below) then takes the data, generates the figure using Plotly, and then updates the UI figure via `ctrl.update_axial_plot(new_fig)`. + +All of the views and plots are then linked primarily through trame state variables, and sometimes through controller functions. + +#### Managing the scalar bar and timeline + +The range of the scalar data as indicated by the color bar in the application header is automatically set based upon the range of the currently selected scalar array. When the selected array changes, the color range is reset to the new range of the selected array. The colors in the views are then generated by passing the values through a lookup table to determine their color. + +The timeline is a VSlider that is accessible via trame-vuetify. It is connected to the state variable `selected_time`. When the selected time changes, this triggers the `VeraOutFile` object to change the active state to the one at the selected time, and then it calls the controller function `on_vera_out_active_state_index_changed()`, which triggers the needed views to update (see *Updating views* below). + +#### Updating views + +In trame, Python decorators[[5](https://realpython.com/primer-on-python-decorators/)] are typically used to register callbacks for certain events, such as a change in a state variable or a call to a controller function. + +In VERACore, these decorators are used to trigger updates for each view. Let’s take a look at the Core View, for example. The default Core View is displayed below. + +![](https://www.kitware.com/main/wp-content/uploads/2023/01/before.png) + +Figure 2. Pin Powers scalar field. + +The decorators to update the Core View are: + +``` +@state.change("selected_array", "selected_layer") +@ctrl.add("on_vera_out_active_state_index_changed") +def update_core_view(selected_array, selected_layer, **kwargs): + … +``` + +If there is a change to the `selected_array` state variable (which is the active scalar name such as “Pin Powers”, “Pin Clad Temps”, etc.) or the selected\_layer (which is the index in the axial layer), or the controller function `on_vera_out_active_state_index_changed()` is called (which happens after a change in the time step), then the view needs to be updated, and the `update_core_view()` function will be called. + +So, for instance, if the selected array is changed to “Pin Moderator Density”, this function will be called, and the core view is updated to appear as the following: + +![](https://www.kitware.com/main/wp-content/uploads/2023/01/after.png) + +Figure 3. Pin Moderator Density scalar field. + +### Summary + +We have found trame to be an amazingly productive environment for creating visual analytics applications. VERACore is a wonderful example: we were able to reproduce an application that initially took years to design and develop in a matter of weeks. In addition, the new application provides many powerful features including deployment as a web-based, client-server application, leveraging Python packages, JavaScript libraries, and the powerful rendering capabilities of VTK and ParaView. Because trame is web-based, it is a wonderful collaboration tool: simply point collaborators at a URL which can be viewed by any standard web browser. + +In the next post, we will begin to describe the trame architecture and implementation patterns in more detail. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +### References + +[1] Kitware Blog Post: Trame: Visual Analytics Everywhere. + +[2] Kitware Blog Post: Trame Developer Course. + +[3] Oak Ridge National Laboratory. The Virtual Environment for Reactor Applications: VERA. + +[4] NEAMS. VERA. + +[5] Geir Arne Hjelle. Primer on Python Decorators. Real Python. + +Tags: + +[ParaView](https://www.kitware.com/tag/paraview/) | [Scientific Computing](https://www.kitware.com/tag/scientific-computing/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/blogs/visualizing-lidar-point-cloud-on-the-web-with-trame.md b/docs/vitepress/blogs/visualizing-lidar-point-cloud-on-the-web-with-trame.md new file mode 100644 index 00000000..e1dabc56 --- /dev/null +++ b/docs/vitepress/blogs/visualizing-lidar-point-cloud-on-the-web-with-trame.md @@ -0,0 +1,57 @@ +[post](https://www.kitware.com/visualizing-lidar-point-cloud-on-the-web-with-trame/) + +# Lidar point cloud on the web with trame + +February 27, 2024 + +[Adrien Stucky](https://www.kitware.com/author/adrien-stucky/ "Posts by Adrien Stucky"), [Jules Bourdais](https://www.kitware.com/author/jules-bourdais/ "Posts by Jules Bourdais"), [Gatien Ferret](https://www.kitware.com/author/gatien-ferret/ "Posts by Gatien Ferret") and [Julien Finet](https://www.kitware.com/author/julien-finet/ "Posts by Julien Finet") + +![](https://www.kitware.com/main/wp-content/uploads/2024/02/20240226-Screenshot.png) + +[LidarView](https://lidarview.kitware.com/) is an open source application developed by Kitware based on ParaView and enabling live 3D sensor reading, recording and processing from multiple vendors. + +[trame](https://kitware.github.io/trame/), is a python based framework developed by Kitware to easily create web applications for visual analytics by leveraging python libraries and with a client-server mechanism. + +Combining both opens the door to new types of usage and user experience with LiDAR sensors. You can now share a no-install web interface for your point cloud processing pipelines,  remotely render live visualizations seen by a LiDARs sensor without the need to transmit the whole point cloud from the server to the client ( i.e. web browser). + +If you have a robot/drone with a mounted LiDAR sensor, you can visualize in real time what it sees and trigger processes directly from a web page. + +![](https://www.kitware.com/main/wp-content/uploads/2024/02/first_minute_x3speed-800px.gif) + +A trame-based LidarView web application (video accelerated for best effect) + +[A few months ago](https://www.kitware.com/point-cloud-visualization-on-the-web-with-lidarview-and-vtk-js/), we exposed LidarView onto the web with ParaView Web. We recently improved the demo to extend its usage and capabilities. By using trame, we created a web viewer that remotely renders a LiDAR point-cloud while adding more types of visualization (a map with [Leaflet](https://leafletjs.com/) and a chart with [Plotly](https://plotly.com/)). The point-cloud is registered in real-time using [LidarView’s SLAM algorithm](https://www.kitware.com/lidar-slam-spotlight-on-kitwares-open-source-library/). + +The web application is 100% Python code and internally calls LidarView and ParaView Python functions. + +Reach us out if you want to know how you can bring your point-clouds onto the web. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Lidar](https://www.kitware.com/tag/lidar/) | [LidarView](https://www.kitware.com/tag/lidarview/) | [Point Cloud](https://www.kitware.com/tag/point-cloud/) | [Python](https://www.kitware.com/tag/python/) | [slam](https://www.kitware.com/tag/slam/) | [Trame](https://www.kitware.com/tag/trame/) | [Web Visualization](https://www.kitware.com/tag/web-visualization/) + diff --git a/docs/vitepress/blogs/vtk-9-4-a-step-closer-to-the-ways-of-python.md b/docs/vitepress/blogs/vtk-9-4-a-step-closer-to-the-ways-of-python.md new file mode 100644 index 00000000..9aace14f --- /dev/null +++ b/docs/vitepress/blogs/vtk-9-4-a-step-closer-to-the-ways-of-python.md @@ -0,0 +1,285 @@ +[post](https://www.kitware.com/vtk-9-4-a-step-closer-to-the-ways-of-python/) + +# VTK 9.4: A Step Closer to the Ways of Python + +October 29, 2024 + +[Jaswant Panchumarti](https://www.kitware.com/author/jaswant-panchumarti/ "Posts by Jaswant Panchumarti"), [Berk Geveci](https://www.kitware.com/author/berk-geveci/ "Posts by Berk Geveci") and [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/Screenshot-2024-10-18-at-16.35.59.png) + +The Visualization Toolkit (VTK) is a widely used open-source solution for desktop post-processing analysis. Even though the library is written in C++, its sophisticated wrapping infrastructure allows developers to build entire visualization applications in Python and Java. + +Until recently, the python wrapper naively exposed the C++ functions to Python. For example, a C++ member function `vtkRenderWindow::SetSize` got wrapped into the python member function `SetSize`. While that is uninspiring for many, it was already challenging to get to that point. Recall that python wrapping in VTK was developed long before [pybind11](https://github.com/pybind/pybind11) existed. David Gobbi from the University of Calgary, Prabhu Ramachandran from IIT Bombay and Ken Martin formerly at Kitware contributed extensively to the the wrapper subsystems and provided implementations for the Python wrappers. Over the years, the wrapper subsystem was extended to include more capabilities for developer convenience. One of the feature David added for VTK 9.3 was the introduction of interface files (.pyi) that PyCharm and other development tools use to provide more information, such as PEP 484 type hints. + +Starting with the upcoming 9.4 release, Jaswant’s extension to the wrapper subsystem enables access to properties of a VTK object in a pythonic style, initialization of VTK objects through specifying keyword arguments in the constructor, and finally, a convenient syntax to connect VTK algorithms and data objects and reuse the resulting pipelines with different inputs. + +## Class properties + +Many classes in VTK rely on C++ macros to describe properties for generating setters and getters methods with the proper checks. For instance, the code snippet below comes from `vtkConeSource.h`. + +``` +vtkSetClampMacro(Height, double, 0.0, VTK_DOUBLE_MAX); +vtkGetMacro(Height, double); + +vtkSetClampMacro(Radius, double, 0.0, VTK_DOUBLE_MAX); +vtkGetMacro(Radius, double); + +vtkSetClampMacro(Resolution, int, 0, VTK_CELL_SIZE); +vtkGetMacro(Resolution, int); + +vtkSetVector3Macro(Center, double); +vtkGetVectorMacro(Center, double, 3); + +vtkSetVector3Macro(Direction, double); +vtkGetVectorMacro(Direction, double, 3); + +vtkSetMacro(Capping, vtkTypeBool); +vtkGetMacro(Capping, vtkTypeBool); +vtkBooleanMacro(Capping, vtkTypeBool); +``` + +In Python, you could make use of those methods as described below. + +``` +import vtk + +cone_source = vtk.vtkConeSource() + +cone_source.SetHeight(12) +cone_source.SetRadius(0.9) +cone_source.SetResolution(60) +cone_source.SetCenter(0, 0, 0) +cone_source.SetDirection(1, 1, 1) +cone_source.SetCapping(False) +cone_source.SetOutputPointsPrecision(vtk.vtkAlgorithm.SINGLE_PRECISION) + +print(cone_source.GetDirection()) +``` + +As you can see that is not what you could expect from a Python library. Therefore, we made our wrapper generate Python properties to enable the following syntax. + +``` +import vtk + +cone_source = vtk.vtkConeSource() + +cone_source.height = 12 +cone_source.radius = 0.9 +cone_source.resolution = 60 +cone_source.center = (0, 0, 0) +cone_source.direction = (1, 1, 1) +cone_source.capping = False +cone_source.output_points_precision = vtk.vtkAlgorithm.SINGLE_PRECISION + +print(cone_source.direction) +``` + +Those properties internally forward the calls to the Getter and Setter methods of the C++ layer, resulting in a code that is much more Pythonic. + +## Constructor parameters + +VTK by design does not support parameters in the constructor. However, due to a greater control over the generation of the wrappers, VTK is able to intercept the keyword arguments used in a constructor and map them to the class properties, enabling us to rewrite the previous snippet of code in a much more compact way as shown below. + +``` +import vtk + +cone_source = vtk.vtkConeSource( + height = 12, + radius = 0.9, + resolution = 60, + center = (0, 0, 0), + direction = (1, 1, 1), + capping = False, +) + +print(cone_source.direction) +``` + +## VTK Pipeline + +One of the foundations of VTK is its pipeline. The VTK pipeline lets you connect data sources and filters in a way that the data will automatically flow across filters when something changes on any filter or source. + +Let’s explore the following example that generates a sphere and positions a cone at the center of each cell on the sphere, aligned with the face normal. + +``` +sphere_source = vtk.vtkSphereSource( + theta_resolution=16, + phi_resolution=16, +) + +cone_source = vtk.vtkConeSource( + radius=0.1, + height=0.2, + resolution=30, +) + +normals = vtk.vtkPolyDataNormals( + compute_cell_normals = 1, + input_connection = sphere_source.output_port, +) + +cell_centers = vtk.vtkCellCenters( + input_connection=normals.output_port, +) + +glyph_filter = vtk.vtkGlyph3D( + orient = True, + vector_mode = 1, # Normals + input_connection = cell_centers.output_port, + source_connection = cone_source.output_port, +) +``` + +We see some benefit with the new property syntax but we can still do better. Now let’s see how that can be written using the new pipeline syntax. + +``` +sphere_source = vtk.vtkSphereSource( + theta_resolution=16, + phi_resolution=16, +) + +cone_source = vtk.vtkConeSource( + radius=0.1, + height=0.2, + resolution=30, +) + +glyph_filter = vtk.vtkGlyph3D( + source_connection=cone_source.output_port, + orient=True, + vector_mode=1, # normals +) + +pipeline = ( + sphere_source + >> vtk.vtkPolyDataNormals(compute_cell_normals=1) + >> vtk.vtkCellCenters() + >> glyph_filter +) +``` + +Thanks to that new syntax, the code can be compact and inlined with the Python philosophy of simplicity. Additional information on that new syntax is also available on that [vtk examples website page](https://examples.vtk.org/site/PythonicAPIComments/). + +Now lets see how we could turn that VTK code into an interactive solution with trame. + +## Usage example with trame + +Trame lets you create an interactive user interface in pure Python. Now let’s explore the current pipeline example and see how we can turn it into an interactive visualization. Using the previously described example we made a trame application that can be found [here](https://github.com/Kitware/trame/blob/master/examples/blogs/vtk-9.4/pipeline.py). + +To setup your environment and run the example, you can use a Python environment like described below. + +``` +python3 -m venv .venv +source .venv/bin/activate +pip install trame trame-vtk trame-vuetify +pip install "vtk>=9.4.0rc2" --extra-index-url https://wheels.vtk.org + +# Fetch demo code +curl -O https://raw.githubusercontent.com/Kitware/trame/refs/heads/master/examples/blogs/vtk-9.4/pipeline.py + +# Run example +python ./pipeline.py +``` + +At that point, a browser window should appear with the following application. + +![](https://www.kitware.com/main/wp-content/uploads/2024/10/Screenshot-2024-10-18-at-16.35.59-1024x915.png) + +The application leverages its reactive nature to implement two methods that automatically modify the cone or the sphere source, compute statistics on the newly generated mesh, and update the view. + +Below we are only showing one method to illustrate the benefit of the new syntax. + +``` +@change("cone_resolution", "cone_height", "cone_radius") +def update_cone(self, cone_resolution, cone_height, cone_radius, **_): + # Update source + self.cone.resolution = cone_resolution + self.cone.height = cone_height + self.cone.radius = cone_radius + + # Execute filter for output extraction + cone_dataset = self.cone() + output_dataset = self.pipeline() + + # Update UI with new statistics + self.state.update( + { + "cone_points": cone_dataset.number_of_points, + "cone_cells": cone_dataset.number_of_cells, + "total_points": output_dataset.number_of_points, + "total_cells": output_dataset.number_of_cells, + } + ) + + # Update 3D view + self.ctrl.view_update() +``` + +And the user interface definition is captured in the method below to also illustrate how trame can efficiently be used for creating an interactive graphical user environment. + +``` +def _build_ui(self): + with VAppLayout(self.server, fill_height=True) as self.ui: + with v3.VCard( + style="z-index: 1;", + classes="position-absolute w-33 top-0 left-0 ma-4", + ): + # Sphere + TitleWithStatistic("sphere", "Sphere", 4) + v3.VDivider() + with v3.VCardText(): + create_slider("Resolution", "sphere_resolution", 16, 8, 32, 1) + + # Cone + v3.VDivider() + TitleWithStatistic("cone", "Cone", 3) + v3.VDivider() + with v3.VCardText(): + create_slider("Resolution", "cone_resolution", 30, 3, 24, 1) + create_slider("Height", "cone_height", 0.2, 0.01, 0.5, 0.01) + create_slider("Radius", "cone_radius", 0.1, 0.01, 0.2, 0.01) + + # Result + v3.VDivider() + TitleWithStatistic("total", "Result", 5) + + with vtk_widgets.VtkRemoteView(self.rw, interactive_ratio=1) as view: + self.ctrl.view_update = view.update + self.ctrl.view_reset_camera = view.reset_camera +``` + +But as always with OpenSource, you can look at the full code which is available [here](https://github.com/Kitware/trame/blob/master/examples/blogs/vtk-9.4/pipeline.py). + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## Acknowledgment + +This work is partially funded by the US Department of Energy’s Office of Biological and Environmental Research (BER) to develop Pan3D, an open-source toolkit supporting scalable and reproducible scientific workflows for 3D data analytics (DE-SC0022365). The project is led by Aashish Chaudhary, the Principal Investigator (PI), with John Tourtellot as the technical lead, who contributed to this work through their leadership and vision of further improving VTK to support complex 3D workflows. + +Tags: + +[Python](https://www.kitware.com/tag/python/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) diff --git a/docs/vitepress/blogs/vtk-wasm-and-its-trame-integration.md b/docs/vitepress/blogs/vtk-wasm-and-its-trame-integration.md new file mode 100644 index 00000000..c3b928a8 --- /dev/null +++ b/docs/vitepress/blogs/vtk-wasm-and-its-trame-integration.md @@ -0,0 +1,256 @@ +[post](https://www.kitware.com/vtk-wasm-and-its-trame-integration/) + +# VTK.wasm and its trame integration + +October 16, 2024 + +[Jaswant Panchumarti](https://www.kitware.com/author/jaswant-panchumarti/ "Posts by Jaswant Panchumarti") and [Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/Screenshot-2024-09-12-at-17.10.35.png) + +The Visualization Toolkit (VTK) is a widely used open-source solution for post-processing analysis on a desktop. The library is written in C++ but can be used in Python and Java thanks to wrapping infrastructure. + +A JavaScript library (vtk.js) is also available but lacks the decades of investment and development from which the C++ library benefits. Moreover, the goal of that JavaScript library was never to fully match VTK capabilities, especially in terms of data processing. In short, vtk.js focused on bridging VTK toward web visualization by enabling VTK data structures to be rendered natively in a browser. Unfortunately, not all the advanced visualization techniques available in plain VTK have been implemented in JavaScript. + +This dichotomy made the usage of VTK in the Web non-trivial. Thanks to trame, things became much easier with its uniform approach via Python. But that also highlighted the shortcomings of vtk.js compared to VTK. Now with the maturity of WASM we are reaching another level of integration that is worth sharing with the community. + +## The rise of WASM + +WebAssembly or Wasm is a technology that allows native code like VTK (C++) to be compiled into bytecode that can then be run in a browser. With years in the making, runtimes and tools have reached a point where this can be used in production. + +At Kitware we started to leverage WASM for IO and data processing and with the investigation and contribution of [dicehub](https://dicehub.com/welcome/) we have also enabled 3D rendering. + +Today, most of the VTK.wasm rendering works with WebGL2. There is active effort pushing for a WebGPU implementation to enable cross-platform compatibility for desktop and Web. This takes advantage of the latest graphics API for higher performance. Once that work reaches completion, users of VTK.wasm will get native performance and consistent look and feel without any code change on their end. + +## New VTK infrastructure for better WASM integration + +Thanks to the groundwork done for WASM, we made it a viable solution for VTK on the Web. To further leverage the use of VTK.wasm across projects, we created a new set of classes that allow users to capture a server-side VTK scene and synchronize the contents of the scene with a WASM implementation. This new infrastructure aims to be as generic as possible with many implications that go beyond WASM. + +Such design is based on 2 main elements: + +* an automated serialization/deserialization system +* an object manager that can track instances of VTK classes and rebuild/update them from a state + +## VTK Object Marshaling + +One of the core constraints for data synchronization is serialization and deserialization. With VTK being a library with more than 3,000 classes we could not go with a manual approach. We leveraged our wrapping infrastructure along with a macro annotation system to automate generation of code to (de)serialize properties of a VTK class.. So far we only focused on the rendering classes in VTK but additional modules could be added as needed. The current implementation only provides marshaling capabilities with 18 classes that have manual implementations and 366 classes with auto-generated implementations. + +This marshaling infrastructure is being used by a new ***VTK::SerializationManager*** module to enable object synchronization. + +## New Object Manager + +The vtkObjectManager is a new class that relies on the previously described marshaling infrastructure to extract states and rebuild the corresponding instance and its dependent objects from those given states. + +With this manager, a user can register any serializable vtkObject (like a vtkRenderWindow) and extract a serializable representation of the object tree so it can be transferred over the network and rebuilt somewhere else. In this case, we leverage WASM to rebuild the same VTK classes as the server side and produce the full interactive 3D scene. + +## Trame integration + +With that new VTK infrastructure, we created a new trame widget (trame-vtklocal) that encapsulates our VTK wasm module and our protocol to handle the synchronization over the network. This new implementation adds a more robust solution to local rendering with VTK and trame than the current one which relies on vtk.js. + +This new widget preserves the usage patterns from the pure JavaScript predecessor trame-vtk. When creating such a widget, you only need to pass it a vtkRenderWindow instance to control the graphics displayed on the client side. After that, the widget takes care of the rest. Each time you modify the scene by changing anything (filter parameter, actor property…), you just need to call the update method on the widget instance to trigger the scene synchronization and enable the browser to display the latest version of the 3D scene. + +### Simple code example + +With trame we define the full application as a standalone Python script with the VTK logic and graphical user interface definition and interaction binding. + +You can use VTK.wasm today by installing it from Kitware’s package registry, and the object manager supportwill be available from pypi.org beginning with the upcoming VTK 9.4 release. To run the following example, you should set a virtual environment as follows. + +``` +python -m venv .venv +source .venv/bin/activate +pip install trame trame-vtklocal +pip install "vtk==9.4.0rc2" --extra-index-url https://wheels.vtk.org +``` + +In the example below we simplified the vtk imports for better readability so we can focus on a simple VTK pipeline that we modify interactively in trame while enabling local rendering via VTK wasm. [code available here](https://github.com/Kitware/trame-vtklocal/blob/master/examples/demo/basic.py) + +``` +import vtk + +from trame.app import get_server +from trame.ui.html import DivLayout +from trame.widgets import html, client, vtklocal +from trame.decorators import TrameApp, change, trigger + +FULL_SCREEN = "position:absolute; left:0; top:0; width:100vw; height:100vh;" +TOP_RIGHT = "position: absolute; top: 1rem; right: 1rem; z-index: 10;" +TOP_LEFT = "position: absolute; top: 1rem; left: 1rem; z-index: 10;" + +def create_vtk_pipeline(): + renderer = vtk.vtkRenderer() + rw = vtk.vtkRenderWindow() + rw.AddRenderer(renderer) + rwi = vtk.vtkRenderWindowInteractor(render_window=rw) + rwi.interactor_style.SetCurrentStyleToTrackballCamera() + + cone = vtk.vtkConeSource() + mapper = vtk.vtkPolyDataMapper(input_connection=cone.output_port) + actor = vtk.vtkActor(mapper=mapper) + + renderer.AddActor(actor) + renderer.background = (0.1, 0.2, 0.4) + renderer.ResetCamera() + + return rw, cone + +@TrameApp() +class WasmApp: + def __init__(self, server=None): + self.server = get_server(server) + self.render_window, self.cone = create_vtk_pipeline() + self._build_ui() + + @property + def ctrl(self): + return self.server.controller + + @change("resolution") + def on_resolution_change(self, resolution, **_): + self.cone.SetResolution(int(resolution)) + self.ctrl.view_update() + + def _build_ui(self): + with DivLayout(self.server) as layout: + client.Style("body { margin: 0; }") + + html.Button( + "Reset Camera", + click=self.ctrl.view_reset_camera, + style=TOP_RIGHT, + ) + html.Input( + type="range", + v_model=("resolution", 6), + min=3, max=60, step=1, + style=TOP_LEFT, + ) + + with html.Div(style=FULL_SCREEN): + with vtklocal.LocalView(self.render_window) as view: + view.update_throttle.rate = 20 # max update rate + self.ctrl.view_update = view.update_throttle + self.ctrl.view_reset_camera = view.reset_camera + +def main(): + app = WasmApp() + app.server.start() + +if __name__ == "__main__": + main() +``` + +The code above produces the following application. + +![](https://www.kitware.com/main/wp-content/uploads/2024/09/Screenshot-2024-09-12-at-15.33.15-1024x728.png) + +Minimalistic VTK.wasm example with trame using the VTK cone source to illustrate geometry change and code usage + +### 3D widget example + +The example that we are going to look at below requires bi-directional communication to update the server side data processing while tracking the 3D widget interactions on the client side. + +The full code example is available [here](https://github.com/Kitware/trame-vtklocal/blob/master/examples/demo/widget.py) but we will illustrate how things work with the following callback and the graphical user interface definition. + +``` + @change("line_widget") + def _on_widget_update(self, line_widget, **_): + if line_widget is None: + return + + self.seed.SetPoint1(line_widget.get("p1")) + self.seed.SetPoint2(line_widget.get("p2")) + self.ctrl.view_update() + + def _build_ui(self): + with DivLayout(self.server): + client.Style("body { margin: 0; }") + with html.Div(style=FULL_SCREEN): + with vtklocal.LocalView(self.rw) as view: + view.update_throttle.rate = 20 + self.ctrl.view_update = view.update_throttle + self.widget_id = view.register_widget(self.widget) + view.listeners = ( + "listeners", + { + self.widget_id: { + "InteractionEvent": { + "line_widget": { + "p1": ( + self.widget_id, + "WidgetRepresentation", + "Point1WorldPosition", + ), + "p2": ( + self.widget_id, + "WidgetRepresentation", + "Point2WorldPosition", + ), + }, + }, + }, + }, + ) +``` + +From the code above we can see that the UI is similar to what was done before except that now, we register a widget and attach some listeners. + +By registering the widget we allow it to be tracked and therefore allow us to attach a VTK listener. That listener’s only role is to extract data and bind it to the trame state. That way we can update our processing pipeline on that state change. + +The way listeners definition are structured is as follows: + +``` +[id of wasm object to add listener to]: { + [name of the vtk event to observe]: { + [variable name of the trame state to update]: { + [key name]: ([wasm id], [state key to extract], [nested key], ...), + [key fullstate]: [wasm id], + } + } +} +``` + +Then because in our definition we are updating `line_widget` with p1 and p2 from `Point1WorldPosition` of the `WidgetRepresentation` of the widget `self.widget_id`, we create a change listener to reflect those point locations to the vtk seed for the streamline filter. And then we just ask for the view to update the geometry. You can see in the video below how the interaction feels. + +
+ +## Future work + +While the current architecture is sound, we are expecting to see reports of serialization issues either with missing serializers or incomplete state synchronization. Those should be reported [here for serializer missing](https://github.com/Kitware/trame-vtklocal/issues/14) while for an incomplete state synchronization, please create a new issue with a self contained example code. + +In order to support cell/point selections, we will need to provide a way to invoke methods on the WASM objects by providing the name of the C++ function, and arguments in JSON. We aim to leverage our wrapping infrastructure to implement this functionality, so we’ll be targeting that next and hope to have it completed by VTK 9.5. + +If you want to help speed up the development, please [reach out to Kitware](https://www.kitware.com/trame/support/) to discuss how you can help. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +## Acknowledgement + +This work is partially funded by the US Department of Energy’s Office of Biological and Environmental Research (BER) to develop Pan3D, an open-source toolkit supporting scalable and reproducible scientific workflows for 3D data analytics (DE-SC0022365). The project is led by Aashish Chaudhary, the Principal Investigator (PI), with John Tourtellot as the technical lead, who contributed to this work through their leadership and vision of further improving VTK to support complex 3D workflows. + +Tags: + +[Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) | [vtk-wasm](https://www.kitware.com/tag/vtk-wasm/) + diff --git a/docs/vitepress/blogs/whats-new-in-trame-bespoke-workflows-for-better-productivity.md b/docs/vitepress/blogs/whats-new-in-trame-bespoke-workflows-for-better-productivity.md new file mode 100644 index 00000000..735b2bbd --- /dev/null +++ b/docs/vitepress/blogs/whats-new-in-trame-bespoke-workflows-for-better-productivity.md @@ -0,0 +1,84 @@ +[post](https://www.kitware.com/whats-new-in-trame-bespoke-workflows-for-better-productivity/) + +# What’s New in trame: Bespoke Workflows for Better Productivity + +October 13, 2025 + +[Sebastien Jourdain](https://www.kitware.com/author/sebastien-jourdain/ "Posts by Sebastien Jourdain") and [Riley Sheedy](https://www.kitware.com/author/riley-sheedy/ "Posts by Riley Sheedy") + +![Developing interactive applications for scientific and engineering workflows often requires bridging complex visualization backends with responsive user interfaces. Traditional web frameworks can introduce additional overhead, demanding expertise outside the core domain of research and simulation.](https://www.kitware.com/main/wp-content/uploads/2025/10/trame-feature.jpg) + +Developing interactive applications for scientific and engineering workflows often requires bridging complex visualization backends with responsive user interfaces. Traditional web frameworks can introduce additional overhead, demanding expertise outside the core domain of research and simulation. + +trame, an open source framework from Kitware, addresses this challenge by enabling the creation of interactive, production-ready applications entirely in Python. Over the past year, trame has introduced a range of updates that improve performance, extend integration options, and simplify the development of bespoke workflows. + +## Recent Enhancements with Expanded Ecosystem + +We added a better superset for Jupyter by adding a dedicated extension for supporting cloud deployments and network handling. With this work, you can also enable full-screen usage of your trame application within the Jupyter tab infrastructure. + +Then we added a new set of widgets that brings more capabilities for your next application: + +* [vtklocal](https://kitware.github.io/trame/examples/vtk/wasm.html) – A widget for doing local rendering using VTK.wasm, using a similar API as our current ones. This means you can easily upgrade your existing application with just a few lines and start leveraging WASM instead. +* [dockview](https://github.com/Kitware/trame-dockview/) – Dockable panel layouts for complex drag and drop user interface freedom. +* [image-tools](https://github.com/Kitware/trame-image-tools), [react](https://github.com/Kitware/trame-react), and [slicer-trame](https://kitware.github.io/trame/examples/apps/trame-slicer.html) (in progress) – Additional widgets that help extend functionalities around image annotations, react integration, and medical image processing. + +![You can also see trame in action through our on-demand webinar, which demonstrates recent enhancements and provides practical takeaways for applying them in your own applications.](https://www.kitware.com/main/wp-content/uploads/2025/10/trame-1.jpg) + +You can also see trame in action through our [on-demand webinar](https://www.youtube.com/watch?v=P6t9iOTyi4Y&t=3201s), which demonstrates recent enhancements and provides practical takeaways for applying them in your own applications. + +## Why trame + +trame abstracts the complexity of web application development while maintaining the performance and flexibility required for scientific computing: + +* Interfaces are defined entirely in Python. +* Reactive state management synchronizes client and server seamlessly. +* Event handling directly connects UI interactions with Python methods. +* The new VTK multiple rendering backends (X, EGL, OSMesa) support streamlined trame deployment regardless of whether you are targeting cloud, Jupyter, Desktop, or HPC. + +This architecture enables developers to treat distributed or remote workflows as though they were local, accelerating the path from concept to application. + +Trame has been adopted across organizations in diverse domains and technical areas: + +* Energy and Manufacturing – Simulation workflows, in-situ computing, and engineering design. +* Healthcare and Life Sciences – Surgical planning, digital pathology, and imaging systems. +* Defense and Intelligence – AI-driven analysis, 3D reconstruction, and interactive cyber-physical simulations. + +By providing tailored user interfaces to complex backends, trame helps experts focus on analysis and innovation rather than infrastructure. + +![By providing tailored user interfaces to complex backends, trame helps experts focus on analysis and innovation rather than infrastructure.](https://www.kitware.com/main/wp-content/uploads/2025/10/trame-2-1024x864.jpg) + +## Partnering with Kitware + +At Kitware, we don’t just adapt to evolving workflows—we help define them. As the creators of platforms such as Catalyst, VTK, ParaView, and trame, we bring decades of expertise in high-performance computing, large-scale visualization, and open science. This foundation enables research and engineering teams to accelerate the path from simulation to insight with tools that are efficient, scalable, and built for demanding real-world applications. + +If you’d like to learn more about trame or explore how it can support your workflows, [contact our team](https://www.kitware.com/contact/). + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[Python](https://www.kitware.com/tag/python/) | [Scientific and Engineering Workflows](https://www.kitware.com/tag/scientific-and-engineering-workflows/) | [Trame](https://www.kitware.com/tag/trame/) + diff --git a/docs/vitepress/blogs/why-medical-device-leaders-trust-kitware-for-medical-image-innovations.md b/docs/vitepress/blogs/why-medical-device-leaders-trust-kitware-for-medical-image-innovations.md new file mode 100644 index 00000000..4d5f77b3 --- /dev/null +++ b/docs/vitepress/blogs/why-medical-device-leaders-trust-kitware-for-medical-image-innovations.md @@ -0,0 +1,64 @@ +[post](https://www.kitware.com/why-medical-device-leaders-trust-kitware-for-medical-image-innovations/) + +# Why Medical Device Leaders Trust Kitware for Medical Image Innovations + +January 7, 2025 + +[Josh Cates](https://www.kitware.com/author/josh-cates/ "Posts by Josh Cates") + +![](https://www.kitware.com/main/wp-content/uploads/2025/01/feature.png) + +Kitware is a leader in medical imaging solutions. We provide state-of-the-art technology for a diverse range of needs in healthcare. Whether you are an engineer, a product manager, or a marketing strategist at a major medical device company—or even a budding startup—Kitware’s expertise and tools will accelerate your product development and deliver superior outcomes. + +## Transformative Medical Image Solutions + +Modern healthcare demands precise and efficient solutions for both surgeons and patients, while also reducing costs. AI can help achieve this balance by automating repetitive tasks, optimizing planning, and providing valuable new intelligence from existing clinical imaging workflows. Kitware’s extensive expertise in medical imaging, visualization, and machine learning (AI) can help with: + +* **High Performance Industry-Standard Open Source Tools.** We deliver industry-standard software frameworks that integrate into your existing workflows. +* **AI-Powered Insights.** Kitware is a leader in medical image AI solutions. We can help your company leverage the latest deep learning innovations, including the MONAI framework, to automate and analyze planning and treatment. +* **Portable Solutions.** Our open-source frameworks, including [ITK](http://itk.org), [VTK](http://vtk.org), [3D Slicer](http://www.slicer.org), and [Trame](https://kitware.github.io/trame/) support scalable and portable app deployment on desktops, browsers, the cloud, or even mobile apps. +* **Precision 3D Medicine Solutions.**  We are experts in 3D image analysis and visualization, and also employ cutting edge research to reconstruct patient-specific 3D anatomy for planning from 2D X-rays. +* **No License Fees.** Unlike other medical software providers, we don’t rely on perpetual license fees or royalties for closed-source products. Our permissive open source licensing means that you own 100% of the code and the solution. +* **FDA-Compliant Systems.** Our team understands the regulatory landscape for Software-as-a-Medical-Device and helps clients navigate engineering hurdles for these requirements, including developing to the latest in FDA AI guidance. + +## Why Kitware? + +Kitware stands out because of its commitment to open-source innovation and unparalleled technical expertise. By choosing Kitware, you gain access to: + +* A team of experts dedicated to pushing the boundaries of medical imaging. +* A collaborative approach that ensures your solution is tailored to your goals. +* Cutting-edge research and development that sets new industry standards. + +## Partner with Us + +Whether you are enhancing an existing product or building a new solution from the ground up, Kitware has the tools, expertise, and vision to make it happen! Visit [kitware.com](http://kitware.com) to learn more about our offerings and how we can help you revolutionize your field. + +## Support and Services + +Looking to take your application to new heights? [Get in touch](https://www.kitware.com/contact/) with Kitware for expert development and support services to fast-track your success with Kitware's open source frameworks. + + + + + + + + +
+
+ Training
+ Learn how to confidently use and customize 3D Slicer from the expert developers at Kitware. + 		+
+ Support
+ Our experts can assist your team as you build your application and establish in-house expertise. + 		+
+ Custom Development
+ Leverage Kitware's 25+ years of experience to quickly build your application. +
+ +Tags: + +[AI](https://www.kitware.com/tag/ai/) | [ITK](https://www.kitware.com/tag/itk/) | [Medical Device](https://www.kitware.com/tag/medical-device/) | [Medical Device Software](https://www.kitware.com/tag/medical-device-software/) | [Medical Imaging](https://www.kitware.com/tag/medical-imaging/) | [Software Process](https://www.kitware.com/tag/software-process/) | [Surgical Planning](https://www.kitware.com/tag/surgical-planning/) | [Trame](https://www.kitware.com/tag/trame/) | [VTK](https://www.kitware.com/tag/vtk/) + diff --git a/docs/vitepress/update_blogs.py b/docs/vitepress/update_blogs.py new file mode 100644 index 00000000..da87ec1d --- /dev/null +++ b/docs/vitepress/update_blogs.py @@ -0,0 +1,211 @@ +#!/usr/bin/env python3 +""" +Generate an index.md file from blog posts in the blogs/ directory. +Extracts: first image, first H1 title, date, and authors from each blog. +""" + +import re +import json +from pathlib import Path +from dataclasses import dataclass + +BLOG_DIRECTORY = Path(__file__).with_name("blogs") +BLOG_INDEX = BLOG_DIRECTORY / "index.md" +BLOG_MENU = Path(__file__).with_name(".vitepress") / "blogs.json" + +if BLOG_INDEX.exists(): + BLOG_INDEX.unlink() + + +@dataclass +class BlogInfo: + title: str + date: str + authors: str + image: str + filename: str + + +def parse_blog(filepath: Path) -> BlogInfo | None: + """Parse a markdown blog file and extract metadata.""" + try: + content = filepath.read_text(encoding="utf-8") + except Exception as e: + print(f"Error reading {filepath}: {e}") + return None + + lines = content.split("\n") + + title = "" + date = "" + authors = "" + image = "" + + for i, line in enumerate(lines): + # Find first H1 title + if not title and line.startswith("# "): + title = line[2:].strip() + continue + + # Find date (line after title, format like "January 13, 2026") + if title and not date: + # Date pattern: Month Day, Year + date_match = re.match( + r"^(January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},\s+\d{4}$", + line.strip(), + ) + if date_match: + date = line.strip() + continue + + # Find authors (line with markdown links to author pages) + if not authors and "kitware.com/author/" in line: + # Extract author names from markdown links + author_matches = re.findall( + r"\[([^\]]+)\]\(https://www\.kitware\.com/author/", line + ) + if author_matches: + authors = ", ".join(author_matches) + continue + + # Find first image + if not image: + # Markdown image: ![alt](url) + img_match = re.search(r"!\[[^\]]*\]\(([^)]+)\)", line) + if img_match: + image = img_match.group(1) + continue + + # HTML img tag + img_tag_match = re.search(r']+src=["\']([^"\']+)["\']', line) + if img_tag_match: + image = img_tag_match.group(1) + continue + + # Stop if we have all info + if title and date and authors and image: + break + + if not title: + return None + + return BlogInfo( + title=title, + date=date or "Unknown", + authors=authors or "Unknown", + image=image or "", + filename=filepath.name, + ) + + +def generate_index(blogs_dir: Path, output_file: Path, columns: int = 3): + """Generate index.md with a table of blog posts.""" + blog_files = sorted(blogs_dir.glob("*.md")) + blogs = [] + + for blog_file in blog_files: + info = parse_blog(blog_file) + if info: + blogs.append(info) + + # Sort by date (newest first) - parse date for sorting + def parse_date_for_sort(date_str: str) -> tuple: + months = { + "January": 1, + "February": 2, + "March": 3, + "April": 4, + "May": 5, + "June": 6, + "July": 7, + "August": 8, + "September": 9, + "October": 10, + "November": 11, + "December": 12, + } + + match = re.match(r"(\w+)\s+(\d+),\s+(\d+)", date_str) + if match: + month, day, year = match.groups() + return (int(year), months.get(month, 0), int(day)) + + return (0, 0, 0) + + blogs.sort(key=lambda b: parse_date_for_sort(b.date), reverse=True) + + # { + # text: "Core functionalities", + # items: [ + # { text: "Basics", link: "/examples/core/basics" }, + # { text: "Files", link: "/examples/core/files" }, + # { text: "Jupyter", link: "/examples/core/jupyter" }, + # { text: "Plotly", link: "/examples/core/plotly" }, + # { text: "Docker", link: "/examples/core/docker" }, + # // router, docker + # ], + # }, + # + years = {} + + for blog in blogs: + year = blog.date.split(" ").pop() + container = years.setdefault(year, []) + container.append({"text": blog.title, "link": f"/blogs/{blog.filename[:-3]}"}) + + final_structure = [] + for year, items in years.items(): + final_structure.append( + { + "text": year, + "items": items, + } + ) + + BLOG_MENU.write_text(json.dumps(final_structure, indent=2), encoding="utf-8") + + # Generate markdown + md_lines = [ + "# Blogs", + "", + ] + + # Create rows with specified columns + for i in range(0, len(blogs), columns): + md_lines.append(" ") + for j in range(columns): + if i + j < len(blogs): + blog = blogs[i + j] + cell_content = [] + cell_content.append(f"{blog.date}
") + if blog.image: + cell_content.append(f'
') + cell_content.append( + f'{blog.title}' + ) + md_lines.append( + f' ") + else: + md_lines.append(f' ') + md_lines.append(" ") + + md_lines.append("
' + ) + md_lines.append(" " + "".join(cell_content)) + md_lines.append("
") + md_lines.append("") + + BLOG_INDEX.write_text("\n".join(md_lines), encoding="utf-8") + print(f"Generated {output_file} with {len(blogs)} blog entries") + + +if __name__ == "__main__": + script_dir = Path(__file__).parent + blogs_dir = script_dir / "blogs" + output_file = script_dir / "index.json" + + if not blogs_dir.exists(): + print(f"Error: blogs directory not found at {blogs_dir}") + exit(1) + + generate_index(blogs_dir, output_file, columns=3)