To simulate blood flow through a patient’s cardiovascular system—to plan a procedure, test a device, or study how disease is progressing—you first need an accurate 3D model of that person’s anatomy. And ideally, you want the whole picture: the heart chambers pumping the blood and the arteries carrying it away.

The trouble is that building these models from a CT or MR scan is one of the slowest, most manual steps in the entire pipeline. Existing automated methods have mostly picked a side: some are good at reconstructing the cardiac chambers, others at tracing the vasculature. Very few produce a single, connected, simulation-ready model of both.

MeshGrow is our attempt to close that gap.

Why the Heart and the Vessels Fight Back

Cardiac chambers and blood vessels look nothing alike, and that is exactly the problem.

• The heart chambers are big, blob-like volumes. Their overall shape is fairly consistent from patient to patient, so a method that “knows” what a heart looks like can deform a template to fit a new scan.
• The vessels are thin, branching tubes that vary enormously between people and make up only a tiny fraction of the pixels in a scan. A rigid template can’t anticipate where every branch goes; you have to follow them.

Trying to force one technique to handle both anatomies tends to do neither well. So instead of looking for a single hammer, MeshGrow uses the right tool for each job.

The Core Idea: Two Tools for Two Anatomies

MeshGrow is a two-stage framework:

1. Mesh the heart. For the cardiac chambers, we use a template-based deep learning approach. The method starts from a mesh that already encodes what a healthy heart’s chambers look like, and deforms it to match the patient in the scan. Because the template carries prior knowledge of cardiac anatomy, this stays robust even where image quality is poor.

2. Grow the vessels out from it. For the aorta and its main sub-branches, we use a step-wise, growth-based tracer (the same family of ideas behind SeqSeg): starting near the heart, it follows each vessel locally, one small piece at a time, and assembles the branches into a connected tree.

The name says it all—we mesh the heart first, then grow the vasculature outward from it.

Stitching the Heart to the Vessels

Building two halves is only useful if they connect properly. The interesting engineering in MeshGrow is at the seam: the framework joins the cardiac mesh and the vascular mesh into a single watertight surface, and—critically—defines an aortic valve surface where the left ventricle meets the aorta.

That valve surface, along with the vessel inlets and outlets, is exactly what a solver needs to apply boundary conditions: where blood enters, where it leaves, and how the valve gates flow. Without them, you have a pretty picture; with them, you have a computational domain you can actually run physics on.

What We Found

We tested MeshGrow on five CT datasets, comparing its output against state-of-the-art benchmark methods and against ground-truth models built by hand.

• Higher accuracy. MeshGrow achieved higher metric scores than the benchmark methods across the test data.
• It actually simulates. To prove the models are simulation-ready and not just visually plausible, we ran full three-dimensional computational fluid dynamics (CFD) simulations on two of the test cases—end to end, from image to hemodynamics.
• One connected model. By meshing the chambers and growing the vessels with anatomy-specific tools and then fusing them, MeshGrow returns a unified mesh with the valve and boundary surfaces already in place.

Why This Matters

Most automated modeling tools force a choice between the heart and the vessels. MeshGrow shows that you don’t have to choose: by matching the method to the anatomy—template deformation for the chambers, growth-based tracing for the vessels—you can automate the construction of a combined cardiovascular model.

That is a step toward making patient-specific simulation practical at scale: large-cohort studies and, eventually, time-sensitive clinical settings where waiting hours to hand-build a model isn’t an option.

Read the Paper

MeshGrow is published, open access, in JRSM Cardiovascular Disease:

• Paper: MeshGrow: Integrated framework for simulation-ready cardiac and vascular mesh construction from medical imaging
• Earlier conference version: Integrated Framework for Unified Cardiac and Vascular Mesh Construction from Medical Images (FIMH 2025)
• Related work: the vessel-growing idea builds on SeqSeg

This work was done with Arjun Narayanan, Fanwei Kong, and Prof. Shawn Shadden. Curious about automated cardiovascular modeling, or have thoughts on where the remaining bottlenecks are? I’d love to hear from you—reach out or leave a comment below.

If you want to simulate blood flow in a specific patient’s arteries—to plan a treatment, test a device, or see how a disease is progressing—you need a 3D model of that person’s vessels first. The simulation itself is hard enough. Getting a usable geometry out of a CT or MR scan is often worse.

That middle step, image to model, is still mostly done by hand. It’s slow, expensive, and it doesn’t scale.

The Manual Workflow

For more than 20 years, the usual path from a CT or MR scan to a simulation-ready vascular model has looked like this:

1. Trace centerlines through every vessel you care about—usually by hand.
2. Segment the lumen (the open channel blood flows through) at many cross-sections along those centerlines.
3. Loft and join the cross-sections and branches into one connected 3D model.

Each of those steps means a trained person clicking through slices. For a big study, or anything clinical where you need answers soon, that is the bottleneck.

During my PhD at UC Berkeley with Prof. Shawn Shadden, I set out to automate as much of this as I could. The method we ended up with is called SeqSeg (Sequential Segmentation).

Looking Locally Instead

A lot of ML approaches try to segment the whole scan in one shot. That is a tough problem: vessels are a tiny fraction of the voxels, their shape varies a lot between patients, and you still need a connected tree at the end—not a pile of disconnected blobs.

SeqSeg does something simpler. It only looks at a small neighborhood at a time and walks along the vessel, roughly the way you’d follow a road without needing the whole map in your head.

In practice:

• Start from a seed point inside a vessel, plus a rough guess of its size and direction.
• Crop a small box around that point and run a 3D U-Net on just that subvolume.
• From the local segmentation, pull a short centerline and estimate where the vessel is headed next.
• Step forward and repeat.
• If the vessel forks, put the branch on a queue and come back to it later—usually finishing the larger vessels first.

That is the whole loop. From one click, SeqSeg grows a connected vascular tree. You don’t have to draw centerlines up front; it builds them as it goes, which is often the part that ate the most time in the old workflow.

What Actually Worked

We tested SeqSeg on CT and MR images of aortic and aortofemoral anatomy and compared it to strong baselines (2D and 3D nnU-Net). A few things stuck with me:

• It generalizes better than I expected. Up close, a vessel looks like a vessel—coronary, aorta, cerebral. Because SeqSeg only ever sees those local neighborhoods, it could segment anatomies it never saw in training. On an independent hospital dataset it hadn’t been trained on, it even picked up branches that were missing from the “ground truth.”

• It stays connected. Pixel-wise methods often leave gaps, and a broken lumen is useless for simulation. Building the model step by step keeps the tree together, and the branch history is handy when you need to place inlets and outlets.

• It’s faster, and it reaches farther. On the same hardware we saw roughly 20–80 minutes depending on how many branches it chased, versus about 2–3 hours for the benchmark—and SeqSeg usually kept more of the smaller distal branches.

What’s Still Rough

I’m not trying to put experts out of a job. I want them to spend less time clicking and more time on the parts that actually need judgment—and I want patient-specific simulation to be something you can do for more than a handful of cases.

SeqSeg still has sharp edges. If a bifurcation root is hidden by artifacts, a branch can get dropped. The voxel segmentation can leave staircase noise on the surface. And calling a network at every step gets expensive when the vascular tree is huge. Those are the problems I’ve kept working on since.

Try It Yourself

SeqSeg is open access in Annals of Biomedical Engineering:

• Paper: SeqSeg: Learning Local Segments for Automatic Vascular Model Construction
• Code: github.com/numisveinsson/SeqSeg
• Data: training and test models from the open Vascular Model Repository

If you want a walkthrough of setup, training, and inference, there’s a companion tutorial on this blog.

Questions or stuck somewhere in the pipeline? Leave a comment below.

Now that I’ve finished my PhD, the first year looks pretty different than it did while I was living through it. At the time it was exciting and challenging and, honestly, a lot. It was a year of figuring out a new place, a new field, and a new version of myself, and it came with a healthy dose of self-doubt.

Here are the things I wish someone had told me going in. None of it is about getting straight A’s or publishing early. It’s mostly about not burning out, building something you can stand on, and playing the long game.

Think Slow, Act Fast

One of the most useful ideas I picked up in grad school comes from How Big Things Get Done by Bent Flyvbjerg and Dan Gardner: “think slow, act fast.” Before you jump into experiments, code, or data, spend real time understanding the landscape of your field first.

I used to think of literature search as a box to check before the “real” work. It’s not. It’s one of the most important skills you’ll build. Reading widely keeps you from reinventing the wheel, shows you where the actual gaps are, and slowly gives you a feel for what makes some research matter and other research forgettable.

A few things that worked for me:

• Start with review papers and recent high-impact work to get the lay of the land, then drill into the specifics.
• Read with some kind of system. For each paper I’d jot down the problem, the approach, what it couldn’t do, and the questions it left open.
• Ask your advisor and labmates which papers are actually foundational and which ones you can skip. This saves a ton of time.
• Don’t try to read everything, because you can’t. Aim to understand the key ideas and roughly where the field stands.

Thinking slow isn’t the same as being slow. It just means being deliberate about where you put your energy before you sprint off in some direction.

Don’t Get Overwhelmed by Research Progress

For most of my first year I felt this nagging pressure to produce. Other students seemed to be off presenting at conferences and putting out papers, and I kept wondering why I wasn’t. Looking back, almost all of that pressure was coming from me.

Your first year really isn’t about output. It’s about learning how to think. Use it to poke around different directions before you commit to one, to sit with the big questions in your field, and to build up the skills your research is going to need later anyway.

Research is messy and nonlinear. You’ll have weeks where everything clicks and weeks where nothing works, and both are completely normal. Try not to compare your chapter 1 to someone else’s chapter 10. Focus on learning to think like a researcher, getting to know your advisor and labmates, and building habits that’ll actually hold up over the next several years.

Use Coursework, but Keep the Big Picture

First-year coursework can feel weirdly disconnected from your research, but it’s doing more than it seems. It builds the theory your work eventually leans on, drags you into areas you didn’t know you’d care about, and sharpens how you think in general.

While you’re in it, keep asking how a course connects to what you’re interested in, what skills you’re picking up that’ll transfer, and what new questions it’s opening up. The good courses usually leave you with more questions than they answer.

Also, give yourself permission to lean into coursework early. The goal is to do well in your classes while starting to dip into research, not to be amazing at both at the same time. That’s a recipe for stress.

Prioritize Your Health and Wellbeing

Grad school is a marathon, not a sprint, and your health is the thing that makes the whole rest of it possible. It’s not something to trade away.

• Sleep and move. You can’t do good work exhausted, and regular exercise did more for my stress than basically anything else I tried.
• Actually eat. It’s so easy to skip meals when you’re slammed, but your brain needs the fuel.
• Take your mental health seriously. Learn to notice when you’re underwater, and use your university’s counseling services. Therapy is a tool, not a sign you’re failing.
• Set boundaries. Learn to say no, take real weekends, and stop checking email at all hours. Overcommitting is the fastest way I know to burn out.

Taking care of yourself isn’t selfish or a distraction. It’s a prerequisite for doing good work.

Build Community

Grad school can get lonely, especially if you moved somewhere new where you don’t know anyone. Building a community ended up being one of the best things I did.

The reasons are pretty simple. You need people who get the ups and downs, a lot of the best ideas come out of casual hallway conversations, and the people around you slowly become both your network and your friends.

What helped me:

• Show up. Go to the seminars, the socials, the random department gatherings.
• Don’t wait around for invitations. Be the one who organizes the coffee, the study group, the dinner.
• Get to know your lab. Some of my closest friendships started a couple of desks away.
• Build relationships with faculty too. Drop by office hours just to chat, ask about their research, and look for mentors beyond your advisor.

This stuff takes time, so be patient and keep showing up.

Explore Your New Home

If you moved for grad school, spend some time getting to know your new city. It’s not a distraction from your work. It’s part of being a person who’s happy enough to do the work.

Getting out and exploring helped a lot with homesickness, gave me things to look forward to, and made the whole experience about more than just research. Walk or bike around your neighborhood, find your cafe, get outside, go to local events, take the occasional day trip. A happier, more well-rounded person tends to be a better researcher anyway.

Dealing with Impostor Syndrome

Almost everyone in grad school feels like an impostor at some point. Like they don’t belong, aren’t smart enough, or are about to get found out. I definitely did.

And it makes sense why. You’re surrounded by brilliant people, the bar is high, research is uncertain by nature, and comparison is way too easy. A few things that helped me deal with it:

• Talk about it. Saying it out loud to a friend or a counselor takes away most of its power, and you’ll quickly realize you’re not the only one.
• Reframe it. “I don’t belong here” can become “I’m here to learn, and that’s the whole point.”
• Track your own growth. Compare yourself to where you were a year ago, not to everyone around you.
• Celebrate the small wins, and remember you got admitted for a reason.

The people who look the most put-together are usually struggling too. They’ve just gotten better at hiding it. Feeling like an impostor doesn’t make you one. It mostly means you’re somewhere hard and actually growing.

Conclusion

The first year is a big transition, and feeling overwhelmed or unsure of what you’re doing is completely normal. If I had to boil down what I learned, it’d be something like this:

• Think slow, act fast. Understand your field before you dive in.
• Don’t chase output too early. The first year is for building a foundation.
• Use your coursework, but keep the big picture in view.
• Protect your health. It runs everything else.
• Build community, and get to know where you live.
• Expect impostor syndrome, and remember almost everyone has it.

The first year is really where the foundation gets laid, academically, professionally, and personally. Be patient with yourself. You’re probably more capable than you feel right now.

Good luck, and try to enjoy the ride.

Have questions or want to share your own experiences? Feel free to reach out or leave a comment below.

Applying for PhD programs is one of the most significant decisions in an academic career. Unlike undergraduate or even master’s applications, PhD applications require careful consideration of multiple factors: the program’s reputation, the advisor’s research style and mentorship approach, the specific research project, and how all these elements align with your long-term career goals.

Two pieces of advice that cannot be emphasized enough: First, finding the right advisor is more important than finding the “best” program. Second, talking to current and former students is the single most valuable thing you can do to evaluate a potential advisor and program. No amount of reading websites, papers, or even meeting with the advisor can replace honest conversations with people who have actually lived the experience.

This guide draws from my own experience and conversations with peers who have navigated this process. I hope it provides practical insights to help you make informed decisions during your PhD application journey.

Choosing a PhD Program

Program Reputation and Resources

The reputation of a PhD program matters, but it’s not everything. Consider:

• Research output: Look at recent publications from faculty and students. Are they publishing in top-tier venues in your field?
• Funding: Does the program guarantee funding? What’s the typical funding package? How long does funding last?
• Resources: What facilities, equipment, and computational resources are available? Are there opportunities for collaboration?
• Placement: Where do graduates end up? Academia, industry, or other sectors? This can indicate how well the program prepares students for their career goals.

Department Culture and Fit

The culture of a department can significantly impact your PhD experience:

• Collaboration vs. Competition: Is the environment collaborative or competitive? Which do you thrive in?
• Work-life balance: Talk to current students about typical work hours and expectations. Some programs have healthier cultures than others.
• Diversity and inclusion: Consider the diversity of faculty and students. Do you see yourself fitting in and being supported?
• Location: While not the most important factor, location matters. Consider cost of living, proximity to family, and quality of life.

Program Structure

Different programs have different structures:

• Coursework requirements: How many courses are required? Do they align with your interests?
• Qualifying exams: What’s the format? How stressful is the process?
• Thesis timeline: What’s the typical time to degree? Is there flexibility?
• Teaching requirements: Are you required to teach? How much? Is this something you want to do?

Choosing an Advisor

The advisor-student relationship is the single most important factor in your PhD experience. While program reputation, location, and resources matter, your advisor will shape your daily life, research trajectory, career development, and overall well-being for the next 4-6 years. A great advisor at a good program is almost always better than a poor advisor at a top program. This cannot be overstated.

The best way to evaluate a potential advisor? Talk to their current and former students. They will give you the most honest, unfiltered perspective on what it’s really like to work with that advisor. Here’s what to consider:

Research Alignment

• Research interests: Do the advisor’s research interests genuinely align with yours? Read their recent papers and see if you’re excited about the work.
• Research style: Are they theoretical, experimental, computational, or a mix? Does this match your preferred approach?
• Research trajectory: Where is their research heading? Is it a growing field or one that’s becoming saturated?

Mentorship Style

Different advisors have different mentorship styles:

• Hands-on vs. hands-off: Do you want frequent meetings and guidance, or more independence? Which style helps you thrive?
• Communication: How responsive are they to emails? How do they provide feedback?
• Expectations: What are their expectations for work hours, publications, and progress? Are these reasonable and aligned with your goals?

Lab Culture

This is where talking to current and former students becomes absolutely critical. You cannot fully understand lab culture from a website or a single meeting with the advisor. Here’s what to investigate:

• Lab size: Do you prefer a large lab with many collaborators or a smaller, more intimate group?
• Lab dynamics: Talk to current and former students directly. Ask them: What’s the lab culture really like? Is it supportive? Do people help each other? Is there competition or collaboration?
• Collaboration: Do lab members collaborate with each other, or is it more individual work?
• Diversity: Is the lab diverse? Do you see yourself fitting in?
• Work environment: Ask students about typical work hours, work-life balance, and whether the advisor respects boundaries
• Conflict resolution: How are conflicts handled? What happens when things go wrong?

Questions to ask current/former students:

• “What’s the best thing about working with [advisor name]?”
• “What’s the most challenging aspect?”
• “How often do you meet with the advisor? What are those meetings like?”
• “How does the advisor handle setbacks or failed experiments?”
• “Would you choose this advisor again if you could go back?”
• “How do students in this lab typically perform? Do they graduate on time?”

Career Support

• Networking: Does the advisor help students build their network? Do they introduce students to collaborators and potential employers?
• Publication strategy: How do they approach publications? Do students get first authorship opportunities?
• Career guidance: Do they support both academic and industry career paths, or do they focus on one?

Red Flags to Watch For

When talking to current and former students, watch for these warning signs:

• Students who seem unhappy or stressed: If multiple students seem consistently stressed or unhappy, that’s a red flag
• High turnover: Are students leaving early or switching advisors? This often indicates deeper problems
• Advisors who are difficult to reach or unresponsive: If students consistently say the advisor is hard to reach, take note
• Lack of recent publications or funding: This could indicate the advisor is struggling or losing interest
• Negative reviews from former students: One negative review might be personal, but multiple negative reviews with similar themes is a serious red flag
• Students who are hesitant to talk: If students seem reluctant to discuss their experience or give vague answers, that’s concerning
• Inconsistent stories: If the advisor tells you one thing but students tell you another, trust the students

Remember: Current students may be cautious about being completely honest, especially if you’re visiting. Former students (especially those who have graduated) are often the most candid. Reach out to them via email or LinkedIn.

Choosing a Research Project

Project Scope and Feasibility

• Scope: Is the project well-defined but flexible enough to evolve? Avoid projects that are too narrow or too broad.
• Feasibility: Is the project realistic given the timeline and resources? Talk to the advisor about potential challenges.
• Novelty: Is the project addressing an important question? Will it lead to meaningful contributions?

Your Interest and Skills

• Personal interest: Are you genuinely excited about the project? You’ll be working on it for 4-6 years.
• Skill development: Will the project help you develop the skills you want? Consider both technical and soft skills.
• Career alignment: Does the project align with your long-term career goals?

Project Resources and Support

• Funding: Is the project funded? For how long?
• Equipment and data: Do you have access to the necessary equipment, data, or computational resources?
• Collaborations: Are there opportunities for collaboration with other labs or institutions?

The Application Process

Preparing Your Application

Statement of Purpose (SOP):

• Clearly articulate your research interests and how they align with the program and specific faculty
• Mention specific professors you’d like to work with and why
• Discuss your relevant experience and how it prepares you for PhD research
• Be specific and genuine—avoid generic statements

Letters of Recommendation:

• Choose recommenders who know you well and can speak to your research potential
• Provide them with your CV, SOP, and information about the programs you’re applying to
• Give them plenty of time (at least a month)

CV/Resume:

• Highlight research experience, publications, presentations, and relevant coursework
• Include technical skills and any relevant projects
• Keep it concise and well-formatted

Transcripts and Test Scores:

• Most programs require GRE scores (though this is changing), and some require subject tests
• Check each program’s requirements carefully
• Strong grades in relevant courses matter, but research experience often matters more

Reaching Out to Potential Advisors

Before or after applying, consider reaching out to potential advisors:

• Email etiquette: Write a concise, professional email introducing yourself, expressing interest in their research, and asking if they’re taking students
• Timing: Early fall (September-October) is typically a good time, before application deadlines
• Be specific: Mention specific papers or projects of theirs that interest you
• Don’t be discouraged: Many professors are busy and may not respond. This doesn’t necessarily mean they’re not interested.

Interviews and Visits

If you’re invited for interviews or visits:

• Prepare questions: Ask about research projects, lab culture, funding, expectations, and career outcomes
• Talk to students—this is non-negotiable: Make talking to current and former students a top priority. Current students are your best source of honest information about day-to-day life in the lab. Try to talk to them one-on-one, away from the advisor if possible. Ask to speak with former students who have graduated—they often provide the most candid feedback.
• Be yourself: The visit is also for you to assess fit, not just for them to evaluate you
• Take notes: You’ll be meeting many people and it’s easy to forget details
• Trust your instincts: If something feels off when talking to students, or if they seem uncomfortable, pay attention to that

Pro tip: If you can’t visit in person, ask to schedule video calls with current students. Most are happy to talk, and you’ll get valuable insights that you can’t get from the advisor alone.

Making the Final Decision

Once you receive offers, consider:

Compare Your Options

Create a comparison matrix considering:

• Program reputation and resources
• Advisor fit and mentorship style
• Research project interest and feasibility
• Funding package
• Location and quality of life
• Career outcomes of graduates

Trust Your Gut

After gathering all the information, trust your instincts. Which program and advisor do you feel most excited about? Where do you see yourself thriving?

Negotiate (When Appropriate)

• If you have multiple offers, you may be able to negotiate funding or other terms
• Be respectful and professional in any negotiations
• Remember that some things (like guaranteed funding) may be non-negotiable

Conclusion

Choosing a PhD program, advisor, and project is a deeply personal decision that will shape the next several years of your life and your career trajectory. There’s no one-size-fits-all answer, and what works for one person may not work for another.

Before I wrap up, let me reiterate the two most important takeaways:

1. Your advisor matters more than almost anything else. A supportive, well-matched advisor can make a good program great, while a poor advisor can make even the best program miserable. Prioritize finding the right advisor over chasing program rankings.

2. Talk to current and former students—extensively. They are your most valuable resource. They will tell you things that advisors won’t, websites can’t, and you need to know. Don’t skip this step. Reach out via email, LinkedIn, or during visits. Most students are happy to share their experiences, and their insights are irreplaceable.

The key is to gather as much information as possible, talk to current and former students, visit if you can, and trust your judgment about fit. Remember that the “best” program on paper isn’t necessarily the best program for you—fit matters enormously.

Finally, remember that your PhD is a journey, and your interests and goals may evolve. Choose an advisor and program that offer flexibility and support for growth. Good luck with your applications!

Have questions or want to share your own experience? Feel free to reach out or leave a comment below.

On October 25th 2025, I joined the Predictive Modeling in Medicine Lab (PMML), led by Prof. Charley Taylor, as a postdoctoral researcher at the Oden Institute for Computational Engineering and Sciences, with an affiliation at the Texas Advanced Computing Center (TACC). It is an exciting next step that builds directly on my PhD work on patient-specific vascular modeling, and I could not be more thrilled to be part of this group.

The Lab

The PMML is part of the Center for Computational Medicine, a collaboration between the Oden Institute and the Dell Medical School at The University of Texas at Austin. Established in January 2025, the Center draws on medicine, biology, engineering, mathematics, and computational science to advance personalized healthcare.

A central theme of the Center is the development of medical digital twins: mathematical models of disease that go beyond medical imaging to incorporate modalities like genomics and metabolomics, continuously updated with personalized patient data. These models are translated into tools that help clinicians make data-driven treatment decisions based on a patient’s history and risk profile. The work is grounded in computing and machine learning, supported by the Oden Institute’s leadership in digital twin research and the high-performance computing resources at the Texas Advanced Computing Center (TACC).

What I’ll Be Working On

My research integrates artificial intelligence, medical imaging, and computational modeling to study physiology and advance medicine. During my PhD in Mechanical Engineering at UC Berkeley, working with Prof. Shawn Shadden, I combined biomechanics, machine learning, and image-based modeling to improve vascular segmentation and simulation—work that led to the open-source tools SeqSeg and MeshGrow for automated vascular reconstruction and simulation-ready mesh generation from medical images.

At UT Austin, I am expanding this work to explore clinically driven applications of AI and simulation, with the goal of developing digital tools that bridge computational models and patient care. Joining the PMML and the broader Center for Computational Medicine is a fantastic opportunity to push these methods toward real clinical impact, alongside an incredible group of researchers spanning computational engineering and medicine.

More to come soon!

In many of my recent projects on patient-specific vascular modeling — from segmentation to simulation — I’ve run into the same problem over and over: managing the data.
Not just storing it, but doing so in a way that’s traceable, reproducible, and easy for others (and algorithms) to use.

That challenge became the motivation for creating a vascular model repository (see VMR here)— a structured system for organizing, versioning, and sharing vascular data with clear metadata and consistent workflows. What follows is an overview of the design decisions and practical trade-offs involved in building it.

Traceability and Persistent Identifiers

One of the most important principles is traceability.
Once data enters the repository, its full history should stay visible — including updates or replacements over time.

Each dataset gets a persistent identifier (DOI), ensuring that anyone citing or using it can always trace back to the exact version referenced.
When updates are made, the old versions remain archived and linked through a clear version history.
That version lineage is what gives the data real scientific credibility.

Naming Structure and Standardization

Naming conventions sound trivial until you try to merge data from multiple sources — hospitals, labs, and research groups, each with their own systems.

The repository uses a standardized naming pattern to keep things consistent:
{StudyName}{PatientID}{Region}{Modality}{Version}
Example: CCTA001_LAD_CT_v2

But older datasets don’t always fit. For those, we wrote mapping scripts that automatically translate legacy names into the new format.
It’s a constant balance — enforcing standards without breaking compatibility with existing archives.

Hosting and Backup

Reliability starts with where the data lives.
The repository runs on a dedicated research server with backups, so no single point of failure can wipe anything out.

We should also experiment with cloud-based object storage (S3-compatible) for long-term archiving, which would make scaling and collaboration much easier while keeping version control intact.

Workflow for Adding New Data

Adding data should be simple, not chaotic.
The submission process follows three main steps:

1. Upload — contributors upload their model files (segmentations, meshes, or simulation results).
2. Metadata Form — they fill in key details: study name, region, modality, preprocessing steps, and license.
3. Validation Check — automated scripts confirm that the files and metadata follow the required format and naming rules.

This keeps the workflow lightweight, but structured enough to guarantee completeness and consistency.

Quality Control

Every dataset should go through quality control (QC) before it’s officially added.
That includes:

• Checking geometry for intersections or topological errors
• Visual review of segmentations
• Verifying metadata consistency
• Optional short simulation runs to test validity

Contributors should also be able to run the same QC scripts locally before submitting, which helps maintain a uniform quality standard across contributions.

Automated and AI-Based Validation

Manual review doesn’t scale forever.
That’s where AI-assisted validation comes in — lightweight automated checks that flag potential issues, such as:

• Incomplete or disconnected vessel trees
• Unusual geometries
• Low-confidence segmentation areas

These don’t replace human review but act as an early filter, keeping the process fast while maintaining trust in the data.

Data Structure and ML Compatibility

A big design goal was making data not just organized, but usable.
Consistent folder hierarchies, standardized formats (.nii.gz, .vtp, .stl), and structured JSON metadata mean that ML or coding workflows can plug in directly.

With this structure, training pipelines can automatically parse metadata, load the correct models, and run experiments — a major step toward reproducible research at scale.

Looking Ahead

This repository isn’t just a storage project; it’s an attempt to make vascular data reliable, transparent, and usable.
Having structured, traceable datasets doesn’t just help with reproducibility — it builds trust and speeds up collaboration across groups.

Next steps include:

• Finalizing the metadata schema and submission interface
• Releasing the first curated models with DOIs

SeqSeg is now available as a pip installable package! This makes it easier to install and use in your projects. To install SeqSeg, simply run the following command in your terminal:

pip install seqseg

This will install the latest version of SeqSeg along with all its dependencies.

2. Tutorial

To get started with SeqSeg, you can follow the tutorial provided in the SeqSeg GitHub repository. The tutorial has data and code examples to help you understand how to use SeqSeg for medical image segmentation tasks. The data is the same as SimVascular. Main steps in the tutorial include:

1. Seed Point Definition: Define seed points in the images where you want to start the segmentation.
2. Weight Downloading: Download the pre-trained weights for the model.
3. Segmentation: Run the segmentation algorithm on your images using the defined seed points and downloaded weights.
4. Visualization: Visualize the segmentation results to assess the performance of the model.

The first step in using SeqSeg is to preprocess your data.

We require the following data:

• A directory containing the images named images
• A directory containing the masks named truths
• A directory containing the centerlines named centerlines
  • as .vtp files

A few things to note:

• The images and masks and centerlines should have the same name
• If you need to extract centerlines from masks, you can use the SeqSeg/centerlines.py script, or use VMTK or other tools
  • Centerlines must contain radius information in the .vtp file
• Make sure that the masks, images and centerlines align correctly, for example open and view together in an image viewer e.g. Paraview
• Make sure the images contain origin, spacing and direction information in the metadata
  • This is important for correct alignment before centerline extraction

2. Data Preprocessing (for Training)

The next step is to preprocess the data for training. SeqSeg requires a model trained on local patches, so we need to extract patches from the images and masks based on centerlines.

The repository for this is vascular-segment-sampler. Use main_with_nnunet.py to extract patches and convert them to nnU-Net format in one step. First, edit the configuration YAML in config/ (e.g. config/global.yaml) so it matches your dataset, then run:

python3 main_with_nnunet.py \
    --config_name global \
    --data_dir /path/to/data \
    --outdir ./extracted_data/ \
    --num_cores 4 \
    --modality CT \
    --nnunet_name AORTAS \
    --nnunet_dataset_number 1

Key arguments:

• --config_name — name of the configuration file in config/ (without .yaml)
• --data_dir — directory containing images/, truths/, and centerlines/
• --outdir — where extracted patches and the nnU-Net dataset are written (default: ./extracted_data/)
• --modality — imaging modality (CT, MR, or comma-separated, e.g. CT,MR)
• --nnunet_name — dataset name for nnU-Net (default: AORTAS)
• --nnunet_dataset_number — nnU-Net dataset number (default: 1)

For a quick test on a subset of cases:

python3 main_with_nnunet.py \
    --config_name global \
    --data_dir /path/to/data \
    --outdir ./extracted_data/ \
    --modality CT \
    --nnunet_name AORTAS \
    --nnunet_dataset_number 1 \
    --max_samples 100 \
    --testing

The new data can be output anywhere, but we recommend writing directly into the nnU-Net Raw directory (or copying the resulting DatasetXXX_* folder there).

3. Training

The next step is to train the model with nnU-Net (see the documentation for more details). Make sure nnUNet_raw, nnUNet_preprocessed, and nnUNet_results are set, and that the dataset from step 2 is in nnUNet_raw.

Preprocessing

Run fingerprint extraction, experiment planning, and preprocessing:

nnUNetv2_plan_and_preprocess -d 1 --verify_dataset_integrity

Replace 1 with the --nnunet_dataset_number you used above. Use --verify_dataset_integrity the first time you run this. To preprocess only a specific configuration:

nnUNetv2_plan_and_preprocess -d 1 -c 3d_fullres

Training

Train a fold with:

nnUNetv2_train DATASET_NAME_OR_ID CONFIGURATION FOLD

For example, with dataset 1 (Dataset001_AORTAS), train fold 0 of a 3D full-resolution model:

nnUNetv2_train 1 3d_fullres 0

Repeat for folds 0–4 (or train fold all for a single model on all training cases). Other common configurations:

nnUNetv2_train 1 2d 0
nnUNetv2_train 1 3d_lowres 0
nnUNetv2_train 1 3d_fullres 0

Add --npz if you plan to use nnUNetv2_find_best_configuration later. Resume an interrupted run with --c.

4. Inference

The final step is to run SeqSeg inference on new data. This is done with the SeqSeg/seqseg.py script. You need direct access to the directory containing the images and seed points, and another containing the trained model weights.

Data visualization is an essential tool for scientists and engineers to explore and communicate complex data. Visualization allows us to gain insights into our data, identify patterns, and communicate our findings effectively. ParaView is a powerful scientific visualization tool that enables users to visualize and analyze large datasets in 2D and 3D. It supports a wide range of data formats and provides a variety of visualization and analysis tools. Examples of data that can be visualized in ParaView include computational fluid dynamics simulations, geospatial data, medical imaging data, and more.

In this tutorial, we’ll cover the basics of using ParaView for scientific visualization. We’ll explore how to load data, visualize data in 2D and 3D, apply filters for data analysis, and export visualizations for publication.

What is ParaView?

ParaView is an open-source, multi-platform data analysis and visualization application. It is designed to handle large datasets and provides a range of visualization and analysis tools for scientific and engineering applications. ParaView supports a variety of data formats, including structured and unstructured grids, point clouds, and images.

Getting Started with ParaView

To get started with ParaView, you can download the latest version of the software from the ParaView website. ParaView is available for Windows, macOS, and Linux operating systems. Once you have downloaded and installed ParaView, you can launch the application and start exploring its features.

Loading Data

ParaView supports a wide range of data formats, including VTK, XML, CSV, and more. To load data into ParaView, follow these steps:

1. Launch ParaView.
2. Click on the “Open” button in the toolbar.
3. Browse to the location of your data file and select it.
4. Click “OK” to load the data.

Visualizing Data

Once you have loaded data into ParaView, you can visualize it in 2D and 3D. ParaView provides a variety of visualization options, including contour plots, volume rendering, and streamlines. To visualize data in ParaView, follow these steps:

1. Select the data you want to visualize in the Pipeline Browser.
2. Click on the “Apply” button in the toolbar to apply the default visualization.
3. Use the Display panel to customize the visualization, such as changing the color map, opacity, and lighting.

Filters and Data Analysis

ParaView provides a range of filters for data analysis and manipulation. Filters allow you to extract information from your data, apply transformations, and perform calculations.

To apply a filter in ParaView, follow these steps:

1. Select the data you want to filter in the Pipeline Browser.
2. Click on the “Filters” menu and select the desired filter.
3. Configure the filter parameters in the Properties panel.
4. Click “Apply” to apply the filter to the data.

Favorite Filters

Some of my favorite filters in ParaView include:

• Contour: Useful for visualizing isocontours of scalar data.
• Clip: Great for cutting away parts of the dataset to reveal internal structures.
• Slice: Useful for extracting 2D slices from 3D datasets.
• Threshold: Handy for filtering data based on scalar values.
• Stream Tracer: Useful for visualizing flow fields and streamlines.
• Glyph: Great for visualizing vector fields with glyphs.
• Warp by Scalar: Useful for deforming the dataset based on scalar values. This is great for visualizing deformation fields.

Visualizing 3D Medical Image Data

ParaView is a powerful tool for visualizing 3D medical image data, such as MRI and CT scans. It provides a range of tools for volume rendering, segmentation, and surface extraction. To visualize 3D medical image data in ParaView, follow these steps:

1. Load the medical image data into ParaView.
2. Apply a volume rendering filter to visualize the data in 3D.
3. Choose isosurface as blend mode and adjust the opacity and color map.
4. Use the segmentation tools to extract regions of interest.
5. Apply surface extraction filters to create 3D surface meshes.

Saving and Exporting Data

Once you have created a visualization in ParaView, you can save it in a variety of formats for publication and sharing. ParaView supports a range of file formats, including images, videos, and 3D models.

To save a visualization in ParaView, follow these steps:

1. Click on the “File” menu and select “Save Screenshot” to save an image of the visualization.
2. Click on the “File” menu and select “Save Animation” to save a video of the visualization.
3. Click on the “File” menu and select “Export Scene” to save the visualization as a ParaView state file.

Conclusion

ParaView is a powerful scientific visualization tool that enables users to explore and analyze complex datasets in 2D and 3D. In this tutorial, we covered the basics of using ParaView for data visualization, including loading data, visualizing data, applying filters, and exporting visualizations. ParaView is a versatile tool that is widely used in scientific research, engineering, and data analysis. I hope this tutorial has provided you with a solid foundation for using ParaView in your own work. Happy visualizing!

What’s the Difference Between Git and Github?

We’ve already covered the basics of using Git in a previous post. In summary, Git is a powerful version control system that helps developers manage and track changes in their codebase efficiently. Whether you’re working on a solo project or collaborating with a team, understanding the basics of Git is essential. Github, on the other hand, is a web-based platform that provides hosting for software development and version control using Git. It offers distributed version control and source code management functionality of Git, plus its own features. Github is a popular platform for open-source projects and collaborative development. It provides a range of features, including issue tracking, pull requests, and project management tools.

Setting Up a Github Account

If you don’t already have a Github account, you can sign up for one at github.com. Once you have an account, you can create and manage repositories, collaborate with others, and contribute to open-source projects.

Creating a New Repository on Github

You can create a new repository on Github to host your code and collaborate with others.

To create a new repository on Github, follow these steps:

1. Log in to your Github account.
2. Click on the “+” icon in the top right corner of the page and select “New repository.”
3. Enter a name for your repository, and optionally, a description.
4. Choose whether the repository will be public or private.
5. Select the “Initialize this repository with a README” checkbox.

Linking a Local Repository to a Github Repository

Once you have created a repository on Github, you can link it to a local repository on your machine. This allows you to push changes from your local repository to the remote repository on Github.

To link a local repository to a Github repository, follow these steps:

1. Open a terminal or command prompt on your local machine.
2. Navigate to the directory where your local repository is located.
3. Run the following command to add the remote repository URL, replacing <repository_url> with the URL of your Github repository:

git remote add origin <repository_url>

Cloning a Repository

Cloning a repository allows you to create a local copy of a Github repository on your machine. This is useful if you want to work on a project locally, make changes, and then push those changes back to the remote repository on Github.

To clone a repository from Github to your local machine, follow these steps:

1. Navigate to the repository on Github.
2. Click on the “Code” button to reveal the repository URL.
3. Copy the repository URL.
4. Open a terminal or command prompt on your local machine.
5. Navigate to the directory where you want to clone the repository.
6. Run the following command, replacing <repository_url> with the URL you copied:

git clone <repository_url>

Pushing Changes to Github

Once you have made changes to your local repository, you can push those changes to the remote repository on Github.

To push changes to Github, follow these steps:

1. Open a terminal or command prompt on your local machine.
2. Navigate to the directory where your local repository is located.
3. Run the following command to push your changes to the remote repository on Github:

git push origin master

Pulling Changes from Github

If changes have been made to the remote repository on Github, you can pull those changes to your local repository.

To pull changes from Github, follow these steps:

1. Open a terminal or command prompt on your local machine.
2. Navigate to the directory where your local repository is located.
3. Run the following command to pull changes from the remote repository on Github:

git pull origin master

Creating a Pull Request

If you’re collaborating with others on a project, you can create a pull request to propose changes to the codebase. This allows others to review your changes and merge them into the main codebase.

To create a pull request on Github, follow these steps:

1. Navigate to the repository on Github.
2. Click on the “Pull requests” tab.
3. Click on the “New pull request” button.
4. Select the branch that contains your changes.
5. Review the changes and add a description.
6. Click on the “Create pull request” button.

Public vs. Private Repositories

Github allows you to create both public and private repositories. Public repositories are visible to anyone, and anyone can fork and contribute to them. Private repositories, on the other hand, are only visible to you and any collaborators you invite. You can choose the visibility of your repository when creating it on Github.

Using Github Copilot

Github Copilot is a feature I’ve found very useful. It is an AI-powered code completion tool that helps you write code faster and with fewer errors. It is built on OpenAI’s Codex model and provides intelligent code suggestions based on the context of your code. Github Copilot is available as a Visual Studio Code extension and can be used to write code in a variety of programming languages, including Python.

Usage: I link it to VSCode. It requires internet connection to work.

Important Note: Github Copilot is a powerful tool, but it’s important to review the code suggestions it provides and ensure that they align with your project’s requirements and coding standards.

Conclusion

That’s it! You’ve now covered the basics of using Github to manage code development. Happy coding!