ITK Lecture 8 Neighborhoods

1
ITK Lecture 8 - Neighborhoods
Damion Shelton

• Methods in Image Analysis
• CMU Robotics Institute 16-725
• U. Pitt Bioengineering 2630
• Spring Term, 2004

2
Goals for today

• Understand what a neighborhood is and and the
  different ways of accessing pixels using one
• Use neighborhoods to implement a
  convolution/correlation filter

3
What is a neighborhood?

• You may already be familiar with the concept of
  pixels having neighbors
• Standard terminology in 2D image processing will
  refer to the 4 neighborhood (N,E,S,W) and the 8
  neighborhood (4 neighborhood NE, SE, SW, NW)

4
Neighborhoods in ITK

• ITK carries this concept a bit further
• A neighborhood can be any collection of pixels
  that have a fixed relationship to the center
  based on offsets in data space

5
Neighborhoods in ITK, cont.

• In general, the neighborhood is not completely
  arbitrary
• Neighborhoods are rectangular, defined by a
  radius in N-dimensions
• ShapedNeighborhoods are arbitrary, defined by a
  list of offsets from the center
• The first form is most useful for mathematical
  morphology kinds of operations, convolution, etc.

6
Neighborhood iterators

• The cool useful thing about neighborhoods is
  that they can be used with neighborhood iterators
  to allow efficient access to pixels around a
  target pixel in an image

7
Neighborhood iterators

• Remember that I said access via pixel indices was
  slow?
• Get current index ind
• Upper left pixel index uleft ind - (1,1)
• Get pixel at index uleft
• Neighborhood iterators solve this problem by
  doing pointer arithmetic based on offsets

8
Neighborhood layout

• Neighborhoods have one primary parameter, their
  radius in N-dimensions
• The side length along a particular dimension i is
  2radiusi 1
• Note that the side length is always odd because
  the center pixel always exists

9
A 2x1 neighborhood in 2D
10
Stride

• Neighborhoods have another parameter called
  stride which is the spacing (in data space) along
  a particular axis between adjacent pixels in the
  neighborhood
• In the previous numbering scheme, stride in Y is
  amount then index value changes when you move in
  Y
• In our example, Stridex 1, Stridey 5

11
Neighborhood pixel access

• The numbering on the previous page is important!
  Its how you access that particular pixel when
  using a neighborhood iterator
• This will be clarified in a few slides...

12
NeighborhoodIterator access

• Neighborhood iterators are created using
• The radius of the neighborhood
• The image that will be traversed
• The region of the image to be traversed
• There syntax largely follows that of other
  iterators (, IsAtEnd(), etc.)

13
Neighborhood pixel access, cont.
Lets say theres some region of an image that
has the following pixel values
14
Pixel access, cont.

• Now assume that we place the neighborhood
  iterator over this region and start accessing
  pixels
• What happens?

15
Pixel access, cont.
myNeigh.GetPixel(7) returns 0.7 so does
myNeigh.GetCenterPixel()
16
Pixel access, cont.

• Next, lets get the length of the iterator and
  the stride length
• Size() returns the pixels in the neighborhood
• unsigned int c iterator. Size () / 2
• GetStride returns the stride of dimension N
• unsigned int s iterator. GetStride (1)

17
Pixel access, cont.
myNeigh.GetPixel(c) returns 0.7 myNeigh.GetPixel(c
-1) returns 1.1
18
Pixel access, cont.
myNeigh.GetPixel(c-s) returns 1.8 myNeigh.GetPixel
(c-s-1) returns 1.3
19
The method

• In ImageRegionIterators, the method moves the
  focus of the iterator on a per pixel basis
• In NeighborhoodIterators, the method moves the
  center pixel of the neighborhood and therefore
  implicitly shifts the entire neighborhood

20
Does this sound familiar?

• If I say
• I have a region of interest defined by a certain
  radius around a center pixel
• The ROI is symmetric
• I move it around an image
• What does this sound like?

21
Convolution (ahem, correlation)!

• To do convolution we need 3 things
• A kernel
• A way to access a region of an image the same
  size as the kernel
• A way to compute the inner product between the
  kernel and the image region

22
Item 1 - The kernel

• A NeighborhoodOperator is a set of pixel values
  that can be applied to a Neighborhood to perform
  a user-defined operation (i.e. convolution
  kernel, morphological structuring element)
• NeighborhoodOperator is derived from Neighborhood

23
Item 2 - Image access method

• We already showed that this is possible using the
  neighborhood iterator
• Just be careful setting it up so that its the
  same size as your kernel

24
Item 3 - Inner product method

• The NeighborhoodInnerProduct computes the inner
  product between two neighborhoods
• Since NeighborhoodOperator is derived from
  Neighborhood, we can compute the IP of the kernel
  and the image region

25
Good to go?

• Create an interesting operator to form a kernel
• Move a neighborhood through an image
• Compute the IP of the operator and the
  neighborhood at each pixel in the image
• Voila - convolution in N-dimensions

26
Inner product example

• itkNeighborhoodInnerProductltImageTypegt IP
  itkDerivativeOperatorltImageTypegt operator
• operator-gtSetOrder(1)
• operator-gtSetDirection(0)
• operator-gtCreateDirectional()
• itkNeighborhoodIteratorltImageTypegt
  iterator(operator-gtGetRadius(), myImage,
  myImage-gtGetRequestedRegion())

27
Inner product example, cont.

• iterator.SetToBegin()
• while ( ! iterator. IsAtEnd () )
• stdcout ltlt "Derivative at index " ltlt
  iterator.GetIndex () ltlt is ltlt
• IP(iterator, operator) ltlt stdendl
• iterator

28
This suggests a filter...

• NeighborhoodOperatorImageFilter wraps this
  procedure into a filter that operates on an input
  image
• So, if the main challenge is coming up with an
  interesting neighborhood operator, ITK can do the
  rest

29
Your arch-nemesis... image boundaries

• One obvious problem with inner product techniques
  is what to do when you reach the edge of your
  image
• Is the operation undefined?
• Does the image wrap?
• Should we assume the rest of the world is
  empty/full/something else?

30
ImageBoundaryCondition

• Subclasses of itkImageBoundaryCondition can be
  used to tell neighborhood iterators what to do if
  part of the neighborhood is not in the image

31
ConstantBoundaryCondition

• The rest of the world is filled with some
  constant value of your choice
• The default is 0
• Be careful with the value you choose - you can
  (for example) detect edges that arent really
  there

32
PeriodicBoundaryCondition

• The image wraps, so that if I exceed the length
  of a particular axis, I wrap back to 0 and start
  over again
• If you enjoy headaches, imagine this in 3D
• This isnt a bad idea, but most medical images
  are not actually periodic

33
ZeroFluxNeumannBoundaryCondition

• I am not familiar with how this functions
• The documentation states that its useful for
  solving certain classes of differential equations
• A quick look online suggests a thermodynamic
  motivation

34
Using boundary conditions

• With NeighborhoodOperatorImageFilter, you can
  call OverrideBoundaryCondition

35
SmartNeighborhoodIterator

• This is the iterator thats being used internally
  by the previous filter you can specify its
  boundary behavior using OverrideBoundaryCondition
  too
• In general, I would suggest using the smart
  version - bounds checking is good!

36
An aside numeric traits

• This has nothing to do with Neighborhoods but is
  relevant to the assignment 2
• Question given some arbitrary pixel type, what
  do we know about it from a numerics perspective?

37
itkNumericTraits

• NumericTraits is class thats specialized to
  provide information about pixel types
• Examples include
• min and max values
• IsPositive(), IsNegative()
• Definitions of Zero and One

38
Using traits

• Whats the maximum value that can be represented
  by an unsigned char?
• itkNumericTraitsltunsigned chargtmax()
• Look at vnl_numeric_limits for more data that can
  be provided

39
Next assignment - due 2/12/04

• Design a filter that inverts a grayscale image
• By inverts I mean that dark values (low) become
  light values (high) and vice versa
• This filter should work on a variety of data
  types, by taking into account the numeric traits
  of the input and output types

40
Assignment, cont.

• Im pretty sure theres not an existing
  implementation of this filter
• If there it, its not okay to use it
• Its perfectly fine (and encouraged) to use the
  filter mentioned in the filter lecture as a
  template and rename things
• You should replace the myITKgui filter with your
  inversion filter