[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

Public Types | Static Public Member Functions | List of all members
NeighborCode Class Reference

Encapsulation of direction management for the 8-neighborhood. More...

`#include <vigra/pixelneighborhood.hxx>`

Inheritance diagram for NeighborCode:

## Public Types

enum | Direction { Error = -1 , East = 0 , NorthEast , North , NorthWest , West , SouthWest , South , SouthEast , DirectionCount , CausalFirst = NorthEast , CausalLast = West , AntiCausalFirst = SouthWest , AntiCausalLast = East , InitialDirection = East , OppositeDirPrefix = 1 , OppositeOffset = West }

## Static Public Member Functions

static Diff2D const & | bottom ()
static Diff2D const & | bottomLeft ()
static Diff2D const & | bottomRight ()
static Direction | code (Diff2D const &diff)
static Direction | code (FourNeighborhood::Direction d)
static Diff2D const & | diff (Direction code)
static Diff2D const & | diff (int code)
static int | dX (Direction code)
static int | dX (int code)
static int | dY (Direction code)
static int | dY (int code)
static Diff2D const & | east ()
static bool | isDiagonal (Direction code)
static Diff2D const & | left ()
static unsigned int | nearBorderDirectionCount (AtImageBorder b)
static Direction | nearBorderDirections (AtImageBorder b, int index)
static Diff2D const & | north ()
static Diff2D const & | northEast ()
static Diff2D const & | northWest ()
static Diff2D const & | relativeDiff (Direction fromCode, Direction toCode)
static Diff2D const & | relativeDiff (int fromCode, int toCode)
static Diff2D const & | right ()
static Diff2D const & | south ()
static Diff2D const & | southEast ()
static Diff2D const & | southWest ()
static Diff2D const & | top ()
static Diff2D const & | topLeft ()
static Diff2D const & | topRight ()
static Diff2D const & | west ()

## Detailed Description

Encapsulation of direction management for the 8-neighborhood.

This helper class allows the transformation between Freeman chain codes (East = 0, NorthEast = 1 etc.) and the corresponding Diff2D instances and back.

You can either use the chain codes by explicit qualification:

// the following three lines are equivalent
EightNeighborhood::NeighborCode::Direction d = EightNeighborhood::NeighborCode::East;
EightNeighborCode::Direction d = EightNeighborCode::East;
EightNeighborhood::Direction d = EightNeighborhood::East;
vigra::EightNeighborhood::NeighborCode::Direction
Direction
Definition pixelneighborhood.hxx:434
vigra::EightNeighborhood::NeighborCode::East
@ East
&#160;
Definition pixelneighborhood.hxx:436
vigra::EightNeighborhood::East
static const Direction East
Definition pixelneighborhood.hxx:609
vigra::EightNeighborhood::Direction
NeighborCode::Direction Direction
Definition pixelneighborhood.hxx:607

or you can fix 8-neighborhood by importing the entire namespace in your function:

using namespace EightNeighborhood;
Direction d = East;
vigra::EightNeighborhood
Definition pixelneighborhood.hxx:389

If you want to pass 8-neighborhood codes as a template parameter, use the class EightNeighborhood::NeighborCode.

#include <vigra/pixelneighborhood.hxx>
Namespace: vigra::EightNeighborhood

## Member Enumeration Documentation

## ◆ Direction

enum Direction

Freeman direction codes for the 8-neighborhood. East = 0, North = 1 etc. DirectionCount may be used for portable loop termination conditions. CausalFirst and CausalLast are the first and last (inclusive) neighbors in the causal neighborhood, i.e. in the set of neighbors that have already been visited when the image is traversed in scan order. AntiCausalFirst and AntiCausalLast are the opposite.

Enumerator
Error |
East |
NorthEast |
North |
NorthWest |
West |
SouthWest |
South |
SouthEast |
DirectionCount |
CausalFirst |
CausalLast |
AntiCausalFirst |
AntiCausalLast |

## Member Function Documentation

## ◆ nearBorderDirectionCount()

unsigned int nearBorderDirectionCount | ( | AtImageBorder | b | ) |

static

The number of valid neighbors if the current center is at the image border.

## ◆ nearBorderDirections()

Direction nearBorderDirections | ( | AtImageBorder | b,
|  | int | index )

static

The valid direction codes when the center is at the image border. index must be in the range 0...nearBorderDirectionCount(b)-1.

## ◆ diff() [1/2]

Diff2D const & diff | ( | Direction | code | ) |

static

Transform direction code into corresponding Diff2D offset. (note: there is no bounds checking on the code you pass.)

## ◆ diff() [2/2]

Diff2D const & diff | ( | int | code | ) |

static

Equivalent to diff(static_cast<Direction>(code)). (note: there is no bounds checking on the code you pass.)

## ◆ relativeDiff() [1/2]

Diff2D const & relativeDiff | ( | Direction | fromCode,
|  | Direction | toCode )

static

Get the relative offset from one neighbor to the other. For example, relativeDiff(East, West) == Diff2D(-2,0). (note: there is no bounds checking on the code you pass.)

## ◆ relativeDiff() [2/2]

Diff2D const & relativeDiff | ( | int | fromCode,
|  | int | toCode )

static

Equivalent to relativeDiff(static_cast<Direction>(fromCode), static_cast<Direction>(toCode)). (note: there is no bounds checking on the code you pass.)

## ◆ dX() [1/2]

int dX | ( | Direction | code | ) |

static

X-component of diff()

## ◆ dY() [1/2]

int dY | ( | Direction | code | ) |

static

Y-component of diff()

## ◆ dX() [2/2]

int dX | ( | int | code | ) |

static

X-component of diff()

## ◆ dY() [2/2]

int dY | ( | int | code | ) |

static

Y-component of diff()

## ◆ code() [1/2]

Direction code | ( | FourNeighborhood::Direction | d | ) |

static

Transform 4-neighborhood code into 8-neighborhood code.

## ◆ code() [2/2]

Direction code | ( | Diff2D const & | diff | ) |

static

Transform Diff2D offset into corresponding direction code. The code Direction::Error will be returned if diff is not in the 8-neighborhood.

## ◆ isDiagonal()

bool isDiagonal | ( | Direction | code | ) |

static

Check whether a code refers to a diagonal direction. Useful if you want to abstract the differences between 4- and 8-neighborhood.

## ◆ right()

Diff2D const & right | ( |  | ) |

static

Offset to the right neighbor

## ◆ topRight()

Diff2D const & topRight | ( |  | ) |

static

Offset to the topRight neighbor

## ◆ top()

Diff2D const & top | ( |  | ) |

static

Offset to the top neighbor

## ◆ topLeft()

Diff2D const & topLeft | ( |  | ) |

static

Offset to the topLeft neighbor

## ◆ left()

Diff2D const & left | ( |  | ) |

static

Offset to the left neighbor

## ◆ bottomLeft()

Diff2D const & bottomLeft | ( |  | ) |

static

Offset to the bottomLeft neighbor

## ◆ bottom()

Diff2D const & bottom | ( |  | ) |

static

Offset to the bottom neighbor

## ◆ bottomRight()

Diff2D const & bottomRight | ( |  | ) |

static

Offset to the bottomRight neighbor

## ◆ east()

Diff2D const & east | ( |  | ) |

static

Offset to the east neighbor

## ◆ northEast()

Diff2D const & northEast | ( |  | ) |

static

Offset to the northEast neighbor

## ◆ north()

Diff2D const & north | ( |  | ) |

static

Offset to the north neighbor

## ◆ northWest()

Diff2D const & northWest | ( |  | ) |

static

Offset to the northWest neighbor

## ◆ west()

Diff2D const & west | ( |  | ) |

static

Offset to the west neighbor

## ◆ southWest()

Diff2D const & southWest | ( |  | ) |

static

Offset to the southWest neighbor

## ◆ south()

Diff2D const & south | ( |  | ) |

static

Offset to the south neighbor

## ◆ southEast()

Diff2D const & southEast | ( |  | ) |

static

Offset to the southEast neighbor

The documentation for this class was generated from the following file:

- vigra/pixelneighborhood.hxx

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.12.4