Lecture 2
A brief overview of simple Python
and more advanced C++
(Bio)Medical Image Analysis - Spring 2026
16-725 (CMU RI) : BioE 2630 (Pitt)
Dr. John Galeotti
Based in part on Damion Shelton’s slides from 2006
This work by John Galeotti and Damion Shelton, © 2004-2026, was made possible in part by NIH NLM contract#
HHSN276201000580P, and is licensed under a Creative Commons Attribution 3.0 Unported License. To view a copy of this
license, visit [Link] or send a letter to Creative Commons, 171 2nd Street, Suite 300, San 1
Francisco, California, 94105, USA. Permissions beyond the scope of this license may be available by emailing itk@[Link].
The most recent version of these slides may be accessed online via [Link]
First: Online Course Content
§Today’s lecture is online
§ I will usually place lectures online before noon the
day of the class.
2
You need the book
§Free online from CMU Library:
§ [Link]
§There will be an online quiz assigned over the
weekend, due before before next class
§The quiz is supposed to be a not-too-hard
assessment if you read the book and paid
attention. I don’t usually ask quiz questions
requiring deep/complex understanding.
3
Goals for this lecture
§C++ vs. Python
§Brief Python Introduction
§Overview of object-oriented programming
§ Inheritance & polymorphism
§ Public / private / protected derivation
§Overview of generic programming
§ templates
§ templated classes
§ specialization
§ typedef & typename keywords
4
Disclaimer
§Some of you will definitely know more about
Python than I do.
§Some of you may know more about object
oriented programming than what I will present
(or what I remember)
§We will not discuss the more esoteric
inheritance methods, such as friend classes
5
Reference & Review Material
§Books
§ C++ How to Program - Deitel & Deitel
§ Teach Yourself C++ in 21 Days - Liberty
§ Using the STL: The C++ Standard Template Library -
Robson
§ Design Patterns; Elements of Reusable Object-Oriented
Software - Gamma et al.
§Websites
§ [Link]
§ [Link]
§ [Link]
§ I use this one more than the rest.
§ [Link]
§ [Link]
6
C++ vs. Python
§ C++
§ Compile and Link
§ Low-level language (but standardized higher-level libraries
available)
§ Writing code takes longer
§ Code runs very fast
§ Python
§ Interpreted
§ Very high level language
§ Writing code is quick and easy
§ Python code runs more slowly, but…
§ Python can call precompiled C/C++ Libraries
§ Best of both worlds
§ So ITK could should execute at full compiled speed, even when
called from Python.
7
Formatting note
§In general, I will try to format code in a fixed-
width font as follows:
§However, not all code that I present could
actually be executed (the above, for instance)
8
Python Example Code
(Take notes as needed!)
# Everything on a line after a # is a comment
# Warning: Indentation matters in Python!
import SimpleITK as sitk # use sitk as the module name
input = [Link]( "images/[Link]" )
output = [Link] ( input , 2.0 )
[Link]( output )
image = [Link]( 256,256, sitk.sitkFloat32 )
image[160,160]= 99.9 # [] allows direct pixel access
[Link]( [Link]( output, image) )
9
Python Example Code
(Take notes as needed!)
# Continuing from the previous slide...
imagevolume = [Link]( 192,192,32, sitk.sitkInt16 )
# Change image to use the matching pixel type
image = [Link]( image, [Link]() )
# Copy over the previous pixel value of 99
[Link] ( 64,64,0, [Link](160,160) )
sliceNum = 1
while sliceNum < 31: # indention must match!
pixelValue = 16 + 4*sliceNum
imagevolume[96,96,sliceNum] = pixelValue
print(pixelValue)
sliceNum = sliceNum+1
[Link]( imagevolume, "VolTitle" )
10
Python Example Code:
[Link](): The object-oriented alternative
image_viewer = [Link]()
image_viewer.SetTitle(’VolTitle’)
# Now run ImageViewer using the default image viewer:
image_viewer.Execute(imagevolume)
# Change viewer program, then display again:
image_viewer.SetApplication(
'/Applications/[Link]/Contents/MacOS/ITK-SNAP')
image_viewer.Execute(imagevolume)
# Change the viewer command, to also pass arguments:
# (use ITK-SNAP's -z option to open the image in zoomed mode)
image_viewer.SetCommand(
'/Applications/[Link]/Contents/MacOS/ITK-SNAP -z 2’)
image_viewer.Execute(imagevolume)
11
Credit: excerpted from [Link]
List of SimpleITK Pixel Types
§ The definitive list of SimpleITK pixel types is in its
source code
§ SimpleITK’s source code must be downloaded separately
§ Look at the bottom of this file:
§ Warning: Not every compilation of SimpleITK
supports all of these pixel types.
§ The source code has recommendations for how to check that
a given type is available, etc.
12
Don’t freak out about what’s next
§Most students in the class only loosely use
most of the following C++ material.
§Most students will do all or most of their
programming in Python, with only simple
object-oriented programming.
§Most students only need a limited
understanding of what follows, so they can
occasionally make sense of ITK’s C++
documentation (in cases where the Python
documentation isn’t as good).
13
Object-oriented programming
§Identify functional units in your design
§Write classes to implement these functional
units
§ Preferably as “black boxes”
§Separate functionality as much as possible to
promote code re-use
14
Class membership
§Classes have member variables and methods
§ ITK names class member variables with the “m_”
prefix, as in “m_VariableName”
§Class members are 1 of 3 types
§ Public
§ Private
§ Protected
15
Public membership
§Everyone can access the member
§ The rest of the world
§ The class itself
§ Child classes
§You should avoid making member variables
public, in order to prevent undesired
modification.
§ A black box shouldn’t have openings!
16
Private membership
§Only the class itself can access the member
§It’s not visible to the rest of the world
§Child classes can’t access it either
17
Protected membership
§The middle ground between public and private
§The outside world can’t access it… but derived
classes can
18
ITK and membership
§In ITK, member variables are almost always
private
§There are public accessor functions that allow
the rest of the world to get and set the value of
the private member
§This ensures that the class knows when the
value of a variable changes
19
Why do it this way?
§Consider a filter class—if someone changes a
variable in the filter, it should re-run itself the next
time the user asks for output
§If nothing has changed, it doesn’t waste time
running again
§Accessor functions set a “modified flag” to notify
the framework when things have changed
§More on this in another lecture
20
Inheritance in a nutshell
§Pull common functionality into a base class
§Implement specific/unique functionality in
derived classes
§Don’t re-invent the wheel!
§Base classes = parents
§Derived classes = children
21
Overloading
§If a child class re-implements a function from
the base class, it “overloads” the function
§You can use this to change the behavior of a
function in the child class, while preserving the
global interface
22
An example of inheritance in a
graphical drawing program
Shape
Polygon
Triangle
Quadrilateral
Rectangle
Trapezoid
Rhombus
Pentagon
ConicSection
Ellipse
Circle
Parabola
23
An example of ITK inheritance
24
C++ Namespaces
§Namespaces solve the problem of classes that
have the same name
§E.g., ITK contains an Array class, perhaps your
favorite add-on toolkit does too
§You can avoid conflicts by creating your own
namespace around code
25
C++ Namespaces, cont.
§Within a given namespace, you refer to other
classes in the same namespace by their name only,
e.g. inside the itk namespace Array means “use
the ITK array”
§Outside of the namespace, you use the itk:: prefix,
e.g. itk::Array
§Only code which is part of ITK itself should be
inside the itk namespace
§At minimum, you’re always in the global
namespace
26
C++ Namespaces, cont.
§Note that code within the itk namespace
should refer to code outside of the namespace
explicitly
§E.g. use instead of
27
C++ Virtual functions
§Want to enforce a consistent interface across a set
of child classes?
§Virtual functions allow a base class to declare
functions that “might” or “must” be in its child
classes
§The “=0” declaration means that the function must
be implemented in a child class
§ Because it is not implemented in the base class
§Virtual functions that are implemented in the base
class can still be overridden by child classes
28
C++ Virtual functions, cont.
§You can specify (and use) a virtual function
without knowing how it will be implemented in
child classes
§This allows for polymorphism
§For example:
29
C++ Example of polymorphism in a
graphical drawing program
Shape: DrawSelf() = 0;
Polygon: int vertices; DrawSelf() connects vertices with line segments
Triangle: vertices=3
Quadrilateral: vertices=4
Rectangle
Trapezoid
Rhombus
Pentagon: vertices=5
ConicSection
Ellipse: DrawSelf() uses semimajor and semiminor axes
Circle: forces length semiminor axis = length semimajor
Parabola
30
Generic programming
§Generic programming encourages:
§ Writing code without reference to a specific data
type (float, int, etc.)
§ Designing code in the most “abstract” manner
possible
§Why?
§ Trades a little extra design time for greatly improved
re-usability
31
Image example
§Images are usually stored as arrays of a
particular data type
§ e.g.
§It’s convenient to wrap this array inside an
image class (good object oriented design)
§Allowing the user to change the image size is
easy with dynamically allocated arrays
32
Image example, cont.
§Unfortunately, changing the data type is not so
easy
§Typically you make a design choice and live
with it (most common)
§Or, you’re forced to implement a double class, a
float class, an int class, and so on (less
common, can be complicated)
§ This is the interface used by SimpleITK, but…
§ SimpleITK usually automates type selection to make
your life easier
33
Templates to the rescue
§Templates provide a way out of the data type
quandary
§ ITK uses templates extensively
§ SimpleITK relies on ITK, and SimpleITK’s automated
type functionality depends on ITK’s templated nature
§If you’re familiar with macros, you can think of
templates as macros on steroids
§With templates, you design classes to handle
an arbitrary “type”
34
Anatomy of a templated class
Template keyword, the < >’s enclose template
parameters
35
Anatomy of a templated class
TPixel is a class (of some sort)
36
Anatomy of a templated class
VImageDimension is an unsigned int,
with a default value of 2
37
Anatomy of a templated class
Image is the name of this class
38
Anatomy of a templated class
Image is derived from ImageBase in a
public manner
39
Specialization
§When you specify all of the template
parameters, you “fully specialize” the class
§In the previous example,
specializes
the base class by specifying its template
parameter.
§Note that the VImageDimension parameter is
actually “passed through” from Image’s
template parameters
40
Derivation from templated classes
§You must specify all template parameters of the
base class
§The template parameters of the base class may
or may not be linked to template parameters of
the derived class
§You can derive a non-templated class from a
templated one if you want to (by hard coding
all of the template parameters)
41
Partial specialization
§C++ also allows partial specialization
§For example, you write an Image class that
must be 3D, but still templates the pixel type
(or vice-versa)
42
Templated class instances
§To create an instance of a templated class, you must
fully specialize it
§E.g.
Creates a 3D image of integers
(not quite true, but we can pretend it does until we cover smart pointers)
43
shorthand type names
§One consequence of templates is that the names of a
fully defined type may be quite long
§E.g., this might be a legal type:
44
shorthand type names
§You can create a short-hand “alias” for our user-
defined type with the keyword:
45
Fun with
types can themselves be global members of
classes and accessed as such
§In template classes, member aliases are often
defined in terms of template parameters—no problem!
This is quite handy.
46
Naming of templates and
§ITK uses the following conventions:
§ Template parameters are indicated by T (for type) or
V (for value). E.g. means “the type of the
pixel” and means “value
template parameter image dimension”
§ Defined types (created with ) are named as
. E.g.
47
Be careful
§If you’re careless in naming classes, template
arguments, typedefs, aliases, and member
variables (with the “m_” prefix), then it can be
quite difficult to tell them apart!
§Don’t write a new language using typedefs.
§Remember to comment well and don’t use
obscure names
§ e.g. BPType is bad, BoundaryPointType is good
48
Typenames
exists to “optionally” help the compiler
§ Different compilers handle it differently
§ In general, you can take it to mean that you are
promising the compiler that what follows is some sort
of valid type, even if the compiler can’t “see” that yet
§ Example of when to use and not use :
49
For more on “typename”
§ [Link]
§ [Link]
§ [Link]
§ [Link]
§ Note: typename is handled differently in different C++ standards.
ITKv5 is compliant with C++11.
50
.hxx, .cxx, .h
§ITK uses three standard file extensions, and so
should you:
§ .h files indicate a class header file
§ .cxx indicates either
§ executable code (an example, test, demo, etc.)
§ a non-templated class implementation
§ .hxx indicates a templated class implementation
§ Like a .cxx file, but it can’t be compiled by itself because it
does not specify its template parameter values
§ FYI, previous versions of ITK used .txx instead of .hxx
51
Did this all make sense?
§ If not, you probably want to sick to Python or C++ SimpleITK
§ If you want to use full C++ ITK (not required for this class):
§ It’s ok if you’re a little rusty on the details, etc.
§ It’s helpful if you have seen and used some of this stuff before.
§ If this is mostly new to you:
§ Understand that neither I nor the TA will teach you how to do basic
programming in Python or C++
§ You should probably use mostly SimpleITK
§ Beware that SimpleITK lacks many of ITK’s more advanced features, including several
types of registration and the ability to tweak less frequently used parameters.
§ If you don’t know how to write and compile C++ programs, then I recommend
using Python!
§ CMU 15-112: [Link]
§ [Link]
introduction-to-programming-using-python-january-iap-2011/
§ You could also take a class on C++
§ [Link]
and-c-january-iap-2013/
52
Final advice
§ If you run across something in ITK you don’t
understand, don’t panic
§ Be careful not to confuse typedefs with classes
§ Error messages can be quite long with templates and will take
time to get used to
§ Email for help sooner rather than later
§ Learning the style of C++ used by native ITK is at least
half the battle to writing native ITK Code
§ Remember, if you just need to use common ITK
functionality, then SimpleITK is usually the way to go!
§ [Link]
53