Nicolás Diego Badano, Dr. Eng.

Blender Ray-traced Render of OpenFOAM simulation

Posted on October 16, 2025 by Nicolas Badano

Over the years, I've tried several times to produce proper ray-traced renders of flow simulated with OpenFOAM — but I always ran into severe artifacting. This week, I spent some time on it again, and I think I've finally found a workflow that works!

Apparently, I was doing two things wrong:

• Face normals on all fluid surfaces must be consistent and point outward. The surface sampling I was using via functionObjects created many randomly reversed faces.
• All meshes need to be joined in Blender so that volumetric rendering works without artifacts.

With those fixes in place, rendering works fine. The question now is whether making the visuals fully realistic is actually the best approach.

Water is, by nature, almost transparent — so it's difficult to convey flow clearly in realistic renders, especially if bubbles and foam are not simulated. Tinting the water in a slightly non-realistic way (with color subtly changing with depth) seems to work better. The attached video switches between both techniques.

The render isn't perfect, but it's a nice step forward — and good ground for future experimentation. What do you think?

BTW, thanks to Jan Höll for the tip about using OBJ files to bridge data between Paraview and Blender

Dynamic Remeshing in OpenFOAM

Posted on September 17, 2025 by Nicolas Badano

I've been experimenting lately with combining mesh deformation and remeshing in OpenFOAM.

It's an interesting technique, with strong advantages and some drawbacks.

I'll be sharing more details later this year at the XLI Argentinian Congress on Computational Mechanics (MECOM 2025).

Flushing the toilet with OpenFOAM

Posted on August 13, 2024 by Nicolas Badano

Flush toilets 🚽 are unsung heroes of modern life. Not only are they super practical; but they can be exciting as well from a fluid mechanics perspective! Let's postpone the easy jokes for a minute 😉, and give them the Computation Fluid Dynamics (CFD) treatment they deserve.

In the video, a CFD simulation of the flushing process is presented. It was created in OpenFOAM, using a fine hex-core mesh (through snappyHexMesh) and the isoAdvector method (thanks Johan Rønby!), which allows for precise tracking of the free surface.

Creating the toilet geometry was tricky, because of the complexity of the shapes involved (especially for a OnShape beginner like me). And even though I started from a reference picture, it took me three tries until the flow started working as expected; it turns out that details matter in these things!

But I think it was worth it! The results are interesting to look at, and they taught me a few things along the way. It's nice to see the hidden flow inside the body of the toilet; I've never noticed before that there's usually an internal channel going all around the perimeter. Also interesting to see when and how the siphon activates and deactivates.

Keep in mind the simulation represents a relatively primitive toilet; I saw quite a few pictures of small innovations that more modern toilets have to improve their performance, flush faster, and use less water. It may be interesting for future simulations!

If you are curious, I have uploaded the source code for this case to GitHub:

https://github.com/nicolasbadano/Toilet

What do you think? Did you learn anything new from this? I bet you'll have a couple of jokes about this as well.

Physically based interpolation of bathymetric data

Posted on April 1th, 2024 by Nicolas Badano

This Easter weekend I finally found a few hours and decided to toy around with an idea I've had for ages: trying to create a physically-informed intepolation method for river bathymetries.

As you know survey campaigns are usually required to create bathymetric Digital Terrain Models (DTM). But very often your modeling domain is not fully surveyed, so you need to interpolate the available data somehow. Using general-purpose methods such as Inverse Distance Weighting (IDW), or Triangular Irregular Networks (TIN) can work, but usually, they take time and generate unphysical artifacts.

Instead of using these methods, in this experiment, I initially solve the flow field with a flat bathymetry and then use the resulting velocity field as an input to a custom Partial Equation Derivative (PDE) solver written in OpenFOAM. This solver uses the known data as constraints and computes bottom levels for the rest of the domain. The procedure can then be applied iteratively a few times, using the new bathymetries to update the flow field.

The trick here is to construct a sensible PDE that does the interpolation. For this experiment I used a very simple one, but with an important twist. Can you guess which? Would love to hear your guess in the comments!

I have several ideas to further improve this PDE, but those will have to wait for now.

Stratified flow with OpenFOAM

Posted on May 16, 2023 by Nicolas Badano

We have been discussing a problem involving stratified saltwater/freshwater. I don't have much experience with this type of problem, so I'm doing a few OpenFOAM simulations to better understand how they work.

In this video, I show the vertical profile of a channel, in which flow encounters a bottom obstacle. Saltwater and freshwater have the same velocity on the upstream border, so the heavier fraction has to raise to flow above the obstacle. This led to an interesting dynamic.

The solution was calculated using interMixingFoam, with OpenFOAM v2112. Saltwater and freshwater are solved as miscible phases.

Stirring Coffee with OpenFOAM - Now as a human!

Posted on May 3, 2023 by Nicolas Badano

Do you stir your coffee like Team Robot or like Team Human? In this video, we get to see how different those look, courtesy of Computational Fluid Dynamics (CFD).

Once upon a time I implemented a CFD model of the stirring of a coffee cup. The spoon just rotated around the cup, changing in orientation so the wide side always faced the flow; many colleagues complained that this motion was far too unrealistic. No human could stir like that, hence Team Robot!

In this new version, I implemented a slightly more realistic motion, in which the spoon maintains its initial orientation through the stirring. Go Team Human!

Stepping behind the curtain, it's obvious that the original version was simpler to implement in OpenFOAM. A cylindrical pair of Arbitrary Mesh Interface patches (AMI) patches split the mesh into two separate regions. The inner part, containing the spoon, rotated at a fixed angular velocity, while the outer part remains fixed. That dynamic mesh technique is often employed when simulating turbomachinery, propellers, and wind turbines.

The new approach ups complexity a couple of notches: now there are two pairs of AMI patches, dividing the mesh into three regions: a fixed region, a rotating outer region, and a translating inner region, which contains the spoon. The movement of these regions is carefully choreographed so the AMI patches can behave like sliding interfaces.

Check the video until the end, where the mixing of sugary water, initially concentrated on the bottom of the mug, is shown. What stirring technique do you think is more effective?

If you are curious, I have uploaded the source code for this case to GitHub:

https://github.com/nicolasbadano/stirring

Flow through a tunnel with columns - cyclicAMI

Posted on Febraury 23, 2023 by Nicolas Badano

Once in a while, I need to compute a steady state flow solution along a channel, or a conduit with regularly repeating geometry. Using cyclic boundary conditions can lead to very fast solutions for those cases.

In this video, I show the setup for one of these cases, involving an old underground river with a roof supported by columns (inspired by a few running under Buenos Aires).

Only a single module is modeled, and the inlet and outlet patches are configured as Cyclic Arbitrary Mesh Interfaces (AMI). Using AMI means that the mesh doesn't need to match perfectly between patches, which makes things much simpler to set up. Creating perfectly matching patches is very difficult/impossible with some meshers.

Most flow variables, such as velocity and phase fraction, can be mapped directly between patches. However, as flow steadily goes downward, the p_rgh needs to have a discrete jump between both ends. To this end, I have a custom boundary condition called p_rghJump which introduces the correct offset based on the density of the fluid on each face.

Using this cyclic approach, the steady-state solution can be obtained at a much reduced computational cost, compared to simulating a stretch of many modules.

If you are curious, I have uploaded the source code for this case and the boundary condition to GitHub:

https://github.com/nicolasbadano/CyclicAMIChannel

Flow through a fish passage simulation - Delayed Detached Eddy Simulation (DDES)

Posted on Febraury 7, 2023 by Nicolas Badano

I've been fascinated with fish passages for a long time, and always wanted to simulate one. Unfortunately, the couple of proposals I presented for different projects in the past few years were not picked up.

This weekend I had one of the workstations available and decided to go for it. I sketched a simple geometry on CAD and implemented an OpenFOAM model. I only simulated three chambers to keep computational costs low enough; typical fish ladders include many more.z

I went for a Delayed Detached Eddy Simulation (DDES) turbulence treatment to better capture the flow instabilities in the chambers. DDES balances accuracy and computational efficiency by using a combination of Reynolds-Averaged Navier-Stokes (RANS) turbulence modeling and Large Eddy Simulation (LES) turbulence modeling. In DDES, the turbulence is resolved at large length scales, in places where the mesh is fine enough, and modeled at smaller scales. This approach allows for a more accurate representation of turbulence behavior while reducing computational costs compared to traditional LES. z

The model has a couple of interesting features, including a fixed water level boundary condition, achieved by fixing the pressure (p_rgh) on all the wetted faces.z

If you are curious, I have uploaded the source code for this case to GitHub:

https://github.com/nicolasbadano/fishpassage

Stirring Coffee with OpenFOAM

Posted on October 11, 2022 by Nicolas Badano

Ever wondered what happens within your mug when you stir your coffee? In this video we get to see this process unfold, courtesy of Computation Fluid Dynamics (CFD).

The mesh for this case was generated using snappyHexMesh. A cylindrical set of faces was generated, which was then duplicated and transformed into a pair of Arbitrary Mesh Interface patches (AMI) patches. When doing so, the mesh gets divided into two regions: the inner part of the cylinder, containing the spoon, is free to rotate at a fixed angular velocity, while the outer part remains fixed. The pair of AMI patches are coupled together on each timestep to provide a continuous solution across this boundary. This mesh motion technique is often employed when simulating turbomachinery, propellers, and wind turbines.

The model, solved with interMixingFoam contains three fluid phases: air, water, and sugar. The last two are configured to be miscible, while the air interface remains immiscible. interMixingFoam is a Volume of Fluid (VOF) solver: it only solves a single momentum conservation equation for the mixture. I'll probably discuss the differences between the Euler-Euler approach and this one in a different post soon.

As expected, the vortices produced by stirring tend to mix the sugar, initially concentrated on the bottom of the mug, and spread it over the water.

This simulation would benefit from using a finer mesh, and solving more of the turbulent scales, but I could not spare the computational resources required this week. Maybe sometime in the future :).

If you are curious, I have uploaded the source code for this case to GitHub:

https://github.com/nicolasbadano/stirring

Monochromatic vs spectrum waves

Posted on October 6, 2022 by Nicolas Badano

In natural conditions, waves are seldom regular, even when produced by almost uniform wind conditions. Instead, a spectrum of amplitudes is generated, which has been repeatedly studied in the literature. Perhaps the most popular model for this spectrum has been published by Hasselmann et al. (1973), after analyzing data collected during the Joint North Sea Wave Observation Project (JONSWAP).

In this video, I show the comparison between regular monochromatic, long-crested waves and stochastic waves produced following the JONSWAP spectrum. In both cases the significant height is 0.9m, with a 4s period. The stochastic waves also include a 5-degree standard deviation in direction.

Notice how the regular waves produce strong interference patterns, which are mostly absent with under stochastic conditions.

Both conditions were computed using the SWASH code, maintained by the Delft University of Technology.

Disk Entry in OpenFOAM

Posted on August 29, 2022 by Nicolas Badano

After a couple of evenings of coding and testing I managed to get Adaptive Mesh Refinement (AMR) working together with a moving meshes in OpenFOAM v2112. It was quite a journey!

The creation of a new library (dynamicMotionSolverRefineFvMesh) which could handle mesh moving and dynamic refinement was actually the easy part. I just followed a paper by Andreas Nygren (which was developed back in the day for OpenFOAM 3.X), and it worked perfectly.

But that's when I hit a wall: all the six degree of freedom methods currently available on OpenFOAM rely on moving the mesh based on displacements: calculating the next position of each node from its *original* position at the start of the simulation. This is fundamentally incompatible with adding and deleting nodes from the mesh, and making it compatible would have required a deep rewrite of those methods, as far as I see.

Luckily, there was another way: work with velocities, and move each node from its last position instead of its original one. That involved creating a custom sixDoFRigidBodyVelocity boundary condition, which calculates those velocities for every node of the moving object on each step. And it worked!

There are still a few issues to work out:

• OpenFOAM does not currently have a load balancing of the decomposed mesh. Hence, this simulation using AMR takes about the same run time as just refining the entire region statically. I plan on implementing a makeshift rebalancing strategy, by stopping the simulation at a certain interval, reconstructing the mesh, and then decomposing it again. I'll let you know how that goes.
• I'm not sure about the accuracy of my sixDoFRigidBodyVelocity implementation. Resulting disk velocities seem to be slightly different from the previous simulations.
• Using the Crank-Nicolson time discretization method produces all kinds of issues in the refinement/unrefinement zone. I'm not sure if this happens with the vanilla implementation of AMR too. In any case I switched to Euler for now.

In any case, I have uploaded the new library, boundary condition and case to the GitHub repository of the disk entry project in case you want to take a look.

https://github.com/nicolasbadano/DiskEntry

Stone Skipping with OpenFOAM

Posted on August 3, 2022 by Nicolas Badano

Have you ever wondered how to solve flow interaction with a moving object, with any arbitrarily big displacement? OpenCFD's version of OpenFOAM includes a wide array of Overset-Grid-capable solvers, which are the perfect fit for this type of problem.

Overset gridding refers to the use of multiple disconnected grids to discretize the flow domain, which can overlap each other. For moving objects, you would typically have a fixed base grid, discretizing the entire flow domain, and a second grid discretizing the zone around the object in greater detail, which would move following the object itself. With that setup you can always have great discretization where you need it, regardless of how much the object moves.

In the attached video I show an example of this technique, applied to a very popular pastime: stone skipping. I tried to replicate the experimental setup published by Tsai et al. (https://doi.org/10.1016/j.expthermflu), which used a non-spinning 30mm by 5mm aluminum disk, thrown toward water at 5 m/s, but I might have gotten some of the details wrong (no 2nd skip 😔).

The case uses the overInterDyMFoam multiphase solver. The fixed mesh has a 5mm horizontal and 2.5mm vertical discretization (which is too coarse to solve splashing accurately); meanwhile, the mesh around the disk has a 1mm cell size, with further refinement near the surface. The disk motion is solved with six degrees of freedom, without any constraint.

As always, nothing is perfect, and the overset grid technique has some drawbacks.

The main one I found is that the mesh-to-mesh geometric mapping, which needs to be performed every time the object moves (every timestep!), is a bit slow, and accounted for ~ 50% of the simulation time in this case. Without looking into the implementation in depth, I have the impression that it is done from scratch every time, which is probably unnecessary (displacements are small on a single time step), so maybe this could be optimized in the future.

With the current implementation, multiple overset meshes are allowed to cover each other, and even extend beyond the main mesh. However, holes in those meshes (solid objects) cannot move beyond the boundaries of the base mesh without causing issues.

Another commonly pointed limitation is that this technique is not rigorously mass-conserving, but I don't think that is a big problem for cases like this one.

In case you want to take a closer look at how the model is put together, I have uploaded the case to GitHub:

https://github.com/nicolasbadano/OversetSkipping

Local Time Stepping - Why and How?

Posted on July 11, 2022 by Nicolas Badano

Sometimes your numerical problem is stiff, meaning you have two related timescales: one that is fast and requires a small time step to maintain stability, and the other much slower, which requires long simulation times to reach a steady state. If you are only interested in that final steady state, Local Time Stepping (LTS) can really cut down the computational costs on these types of problems. This technique is supported by many solvers in the OpenFOAM toolkit.

The idea behind this method is quite simple: the model uses different time steps for each cell of the model. Big cells or cells with small velocities use larger time steps, while small cells with high velocities use lower time steps. All this is based on the local Courant number, which is desired to remain almost constant throughout the domain. This is not achieved perfectly in practice, though, among other things, because that local time scale is smoothed over neighbouring cells.

In this video I show an example of this method on a problem involving a weir (high velocity, fast time scale) and a dam reservoir (low velocity, slow time scale).

The flow is first solved using the Euler scheme, solving the transient physically. Convergence on levels and outlet discharges is not reached even after 20000 time steps of 0.005s, which yield a maximum Courant number of around 0.9.

Then the flow is solved using the localEuler (LTS) scheme, targeting a Courant number of 0.9 in all cells. Convergence is approximately achieved after 10000 time steps (or iterations); that's less than half the computational cost! Results can be even more extreme on other problems, specially as the fast and slow time scales are increasingly more different.

These performance improvements do come with a cost; notice, the unphysical oscillations that develop in the localEuler simulation on the low velocity zone upstream of the weir.

In case you want to take a closer look at how the models are put together, I have uploaded the case to GitHub:

https://github.com/nicolasbadano/DamReservoirLTS

Flow around a cylinder - Adaptive Mesh Refinement (AMR)

Posted on July 4, 2022 by Nicolas Badano

What if your mesh could be adapted automatically to improve the accuracy of your solution? That's exactly what Adaptive Mesh Refinement (AMR) is all about. OpenFOAM has built-in tools to automatically refine the mesh locally using whatever criteria you specify. But, what criteria should we use?

Probably the most sound method involves simply looking for zones with large enough gradients on the flow solution variables. After all, the whole point of discretizing space is to solve the effect of those spatial derivatives!

In this video, I show an example of how to set-up this kind of AMR criteria, using the flow around a cylinder (with Reynolds number of 220) as an example. Mesh is refined wherever the magnitude of the gradient of the velocity field exceeds a certain threshold.

The implementation is pretty straightforward: first, a coded function object is included in the "controlDict" file, which computes the refinement indicator field, in this case mag(grad(U)). Then the desired thresholds are configured in the "dynamicMeshDict" file.

Notice that the gradient of a single variable (the velocity) is used as refinement criteria in this simple case. For more complex cases, like those involving advected scalars (temperature, pollutants, etc), the gradient of two or more variables could be included in the same algorithm. For example, in a case with variables U and T, the refinement indicator field could be defined as:

indicatorField = max(mag(grad(U)) / U_threshold, mag(grad(T)) / T_threshold)

And refinement would be performed wherever indicatorField is greater than one.

In case you want to take a closer look at how everything is put together, I have uploaded the case to GitHub:

https://github.com/nicolasbadano/GradientAMR

Weir with moving gate - Moving mesh and Cyclic AMI

Posted on June 21, 2022 by Nicolas Badano

Have you ever wondered how to include a moving gate in your CFD simulations? There's actually quite a few ways to do that, but perhaps the most straightforward one is using a moving mesh region, combined with Cyclic Arbitrary Mesh Interfaces (AMI). In this video I show the setup and results for a simple case using this technique.

Notice that Paraview has a hard time rendering the free surface across the AMI interfaces, due to the neighbouring cells not connecting directly and having duplicate patches, which leads to some visual glitches. This works even worse when using the real polyhedric elements (instead of using the "Decompose polyhedra" option), which is unfortunate (the free surface, away from the interface looks nicer when polyhedric elements are not decomposed).

Despite the rendering issues, the technique works well, and is quite fast and robust. It does have some limitations though, like being very difficult to generate proper boundary elements on the gate itself.

Excuse the pretty rough mesh used in the example. I have the office cluster filled to the brim with actually important simulations, so this is all I could spare this weekend!

In case you want to take a closer look at how everything is put together, I have uploaded the case to GitHub:

https://github.com/nicolasbadano/WeirWithMovingGate

Attenuating spurious velocities in the air phase on free surface simulations

Posted on June 13, 2022 by Nicolas Badano

Many times in multiphasic simulations (e.g. interFoam) of hydraulic problems, only the results of the water fraction are of interest, but due to poor mesh quality or non-optimal case setups, high velocities develop in the lighter air fraction. These often increase computational times, and might potentially lead to instabilities.

For those cases, I have developed a custom sink term for the momentum equation called airVelocityAttenuation, which is available on GitHub:

https://github.com/nicolasbadano/airVelocityAttenuation

This sink term helps reduce velocities in the air by making momentum dissipate. The rate of dissipation, as well as the volume fraction threshold below which momentum is dissipated can be conveniently changed at runtime.

The dissipation term is implemented implicitly, so it's really stable.

No explicit compilation is required. Just copy the fvOptions file on the constant directory of the case and edit if needed.

On the attached figure I ran the "weirOverflow" OpenFOAM example with different attenuation rates. Notice how air velocities, which are very noisy in the original case, tend to calm down smoothly.

Disclaimer: always check that modifying the velocities on the air doesn't actually affect the quality of the "important" results. Most of the times it's just better to fix the mesh and/or case setup to avoid spurious velocities in the first place.

Flow through bottom discharger Simulation -DualSPHysics

Posted on May 16, 2022 by Nicolas Badano

I wasn't able to progress very much onto the validation plans for DualSPHysics. So far, I 've fixed the initial conditions, switched to a better temporal integrator and to a proper turbulence model, and I'm now running "mesh" convergence tests.

In the meantime, I got curious about the VisualSPHysics code, which is a companion project to DualSPHysics. It lets you easily import model results into Blender, overlay a bubble+foam+spray post-processing simulation to generate great looking visualizations.

In this video I show the render that comes out of the simulation I posted last week. I don't know what you think, but it looks pretty nice to me! No wonder SPH models are the de-facto standard in the VFX industry.

I'm tempted to try writing a similar post-processing foam simulator for the interFoam solver. With this treatment, even if the trapped air doesn't affect the flow solution, it surely helps show the fluid motion in a very natural way.

The SPH simulation has 15 cm inter-particle distance, which results in a peak of 1.2 million particles. The render was done with the Cycles raytracing engine on Blender, with motion blur enabled.

Hydraulic Jump simulation - Rendering in Paraview

Posted on April 19, 2022 by Nicolas Badano

I spent part of the Easter weekend playing with Paraview 5.10.1, trying to improve result rendering for a typical hydraulic problem, to make them easier to digest by less technically inclined customers. So I grabbed an old case CFD of a submerged hydraulic jump solved with LES, and let it run for a few hours.

In this video, I've compiled a few of the rendering attempts I made. I'm not satisfied yet, so I'll probably try a bit more when I have some free time again.

Particles were solved using a custom version of the icoUncoupledKinematicCloud function object from OpenFOAM. It was necessary to modify the code, as the default version doesn't work with multiphasic simulations.

Particle streaks were computed on Paraview using the StreamTracerWithCustomSource filter. These have the limitation of having a fixed length, independent of the particle speed. In my next attempt, I'll probably try generating those streaks offline with a python program from past particle positions, which I think will probably look and perform better.

PhD Thesis Defended

Posted on October 23, 2021 by Nicolas Badano

The day has finally arrived. On Friday, I defended my thesis and received my PhD in Engineering from the University of Buenos Aires.

I have uploaded the thesis presentation to YouTube for any hydraulics colleagues who might find it interesting.

With that same goal in mind, I will be presenting it at the Latin American Hydraulics Congress next month.

I would like to take this opportunity to publicly thank everyone who has supported and encouraged me during these eight years of work.

First and foremost, my supervisor, Dr. Ángel Menéndez, who went above and beyond the call of duty to carry out this project, faithful to the role of true mentor he has played for many years. To my monitoring committee, made up of Dr. Guillermo Marshal and Dr. Alejandro Otero, who also served as one of the jurors. To the other three judges, Drs. Fabián Bombardelli, Andrés Rodríguez, and Carlos Marcelo García, who, along with Alejandro, took the time to carefully read and evaluate the thesis. To my colleagues, especially Dr. Pablo García, who constantly advised and guided me throughout this journey.

And on a personal level, I can't help but thank my family: my wife Fernanda; my daughters Cata, Sofi, Luci, and Emilia; my parents, sisters, grandmother, brothers-in-law, nephews, and parents-in-law. All of them, like many of my friends, shared in my small sacrifices and offered me constant help and encouragement; true members of a team and honorary co-authors.

Finally, I thank God for placing all these willing people in my path. Because I have nothing that I haven't received. And because He didn't let me give up when things seemed impossibly difficult.

Thesis is available here:

Badano, 2021. Assessment of scale effects on hydraulic structures by means of numerical modelling.

Low-Reynolds Rough Boundary Conditions for OpenFOAM

Posted on April 15, 2021 by Nicolas Badano

I released a new set of boundary conditions for simulating rough surfaces in OpenFOAM, using fine meshes with near wall distances around y+=1 or lower.

• kAupoixLowReWallFunction
• kLeeLowReWallFunction
• omegaAupoixWallFunction
• omegaKnoppWallFunction
• omegaLeeWallFunction

GitHub Repository, with source code and binaries:

https://github.com/nicolasbadano/lowReRoughWallBCs

PRip v0.3 released

Posted on December 17, 2015 by Nicolas Badano

PRip is a tool for digitizing scientific plots and graphs, getting numeric data. It works similarly to the popular g3data application, but has a greater enphasis on usability, precision and portability.

PRip is written in Python, and used the Qt toolkit through the PyQt bindings. This language and toolkit selection hopefully makes it very portable.

PRip is entirely open-source, and everyone is free to propose changes or maintain their own, customized version as long as they make their changes open to the public in accordance with the GNU General Public License (for more information check the license file attached to this project).

Current Features

• Import plots captured on typical image formats (jpg, png, etc).
• Define reference points for x and y axis.
• Digitize data using the free zoom view, which allow fast input and great precision.
• Drag data points to improve the fit.
• Export data as plain text.
• Store the digitizing project for latter review or improvement.
• Digitize multiple datasets per plot
• Planned Features

GitHub Repository, with source code and binaries:

https://github.com/nicolasbadano/prip