SSD.h

Go to the documentation of this file.

#pragma once

#include <cassert>
#include <cstddef>

template <class TDb>
class SSD {
public:
  using ValueType = typename TDb::ImgPixelType;
  using ImgType   = typename TDb::ImgType;

public:
  // Constructors and destructors.

  SSD() = default;

  SSD(const TDb &db, size_t idx,
      size_t ctrFixedX, size_t ctrFixedY, size_t ctrMovingX, size_t ctrMovingY,
      size_t radius);

  ~SSD() = default;

public:
  // General-purpose methods.

  inline ValueType GetValue() const;

  inline operator ValueType() const;

  inline bool operator <(const SSD &other) const;

public:
  // Methods for efficient update.

  ValueType ShiftRight();

  ValueType ShiftLeft();

  ValueType ShiftUp();

  ValueType ShiftDown();

  ValueType ShiftImage(const ImgType *img);

private:

  void CalculateValue();

  bool PatchInsideImage(const size_t x, const size_t y);

private:
  const ImgType *fixedImageIt;

  const ImgType *movingImageIt;

  size_t patchSide;

  size_t fixedTopLeftX;

  size_t fixedTopLeftY;

  size_t movingTopLeftX;

  size_t movingTopLeftY;

  ValueType value;
};


// ===== Implementation below =====

template <class TDb>
SSD<TDb>::SSD(const TDb &db, size_t idx,
              size_t ctrFixedX, size_t ctrFixedY,
              size_t ctrMovingX, size_t ctrMovingY,
              size_t radius)
  : fixedImageIt(&db.GetImage(0))
  , movingImageIt(&db.GetImage(idx))
  , patchSide(2 * radius + 1)
  , fixedTopLeftX(ctrFixedX - radius)
  , fixedTopLeftY(ctrFixedY - radius)
  , movingTopLeftX(ctrMovingX - radius)
  , movingTopLeftY(ctrMovingY - radius)
  , value(0)
{
  assert(idx > 0 && "SSD between patches of 0-th image in database!");
  assert(fixedImageIt && movingImageIt && "One of image pointers is null!");

  CalculateValue();
}


template <class TDb>
typename SSD<TDb>::ValueType SSD<TDb>::GetValue() const
{
  return value;
}


template <class TDb>
SSD<TDb>::operator ValueType() const
{
  return GetValue();
}


template <class TDb>
bool SSD<TDb>::operator <(const SSD &other) const
{
  return value < other.value;
}


template <class TDb>
typename SSD<TDb>::ValueType SSD<TDb>::ShiftRight()
{
  for (size_t dy = 0; dy < patchSide; ++dy) {
    // Step to new place (1 px right the right side), add it.
    ValueType diff1 =
      (*fixedImageIt)(fixedTopLeftY + dy, fixedTopLeftX + patchSide) -
      (*movingImageIt)(movingTopLeftY + dy, movingTopLeftX + patchSide);

    // Step from old place, subtract it (the left side).
    ValueType diff2 =
      (*fixedImageIt)(fixedTopLeftY + dy, fixedTopLeftX) -
      (*movingImageIt)(movingTopLeftY + dy, movingTopLeftX);

    value += (diff1 * diff1 - diff2 * diff2);
  }
  ++fixedTopLeftX;
  ++movingTopLeftX;

  return value;
}


template <class TDb>
typename SSD<TDb>::ValueType SSD<TDb>::ShiftLeft()
{
  for (size_t dy = 0; dy < patchSide; ++dy) {
    // Step to new place (1 px left the left side), add it.
    ValueType diff1 =
      (*fixedImageIt)(fixedTopLeftY + dy, fixedTopLeftX - 1) -
      (*movingImageIt)(movingTopLeftY + dy, movingTopLeftX - 1);

    // Step from old place, subtract it (the right side).
    ValueType diff2 =
      (*fixedImageIt)(fixedTopLeftY + dy, fixedTopLeftX + patchSide - 1) -
      (*movingImageIt)(movingTopLeftY + dy, movingTopLeftX + patchSide - 1);

    value += (diff1 * diff1 - diff2 * diff2);
  }
  --fixedTopLeftX;
  --movingTopLeftX;

  return value;
}


template <class TDb>
typename SSD<TDb>::ValueType SSD<TDb>::ShiftUp()
{
  for (size_t dx = 0; dx < patchSide; ++dx) {
    // Step to new place (1 px up the upper side), add it.
    ValueType diff1 =
      (*fixedImageIt)(fixedTopLeftY - 1, fixedTopLeftX + dx) -
      (*movingImageIt)(movingTopLeftY - 1, movingTopLeftX + dx);

    // Step from old place (the lower side), subtract it.
    ValueType diff2 =
      (*fixedImageIt)(fixedTopLeftY + patchSide - 1, fixedTopLeftX + dx) -
      (*movingImageIt)(movingTopLeftY + patchSide - 1, movingTopLeftX + dx);

    value += (diff1 * diff1 - diff2 * diff2);
  }
  --fixedTopLeftY;
  --movingTopLeftY;

  return value;
}


template <class TDb>
typename SSD<TDb>::ValueType SSD<TDb>::ShiftDown()
{
  for (size_t dx = 0; dx < patchSide; ++dx) {
    // Step to new place (1 px down the lower side), add it.
    ValueType diff1 =
      (*fixedImageIt)(fixedTopLeftY + patchSide, fixedTopLeftX + dx) -
      (*movingImageIt)(movingTopLeftY + patchSide, movingTopLeftX + dx);

    // Step from old place (upper side), subtract it.
    ValueType diff2 =
      (*fixedImageIt)(fixedTopLeftY, fixedTopLeftX + dx) -
      (*movingImageIt)(movingTopLeftY, movingTopLeftX + dx);

    value += (diff1 * diff1 - diff2 * diff2);
  }
  ++fixedTopLeftY;
  ++movingTopLeftY;

  return value;
}


template <class TDb>
typename SSD<TDb>::ValueType SSD<TDb>::ShiftImage(const typename SSD<TDb>::ImgType *img)
{
  assert(img && "New image pointer is null!");

  movingImageIt = img;
  CalculateValue();

  return value;
}


template <class TDb>
void SSD<TDb>::CalculateValue()
{
  value = 0;
  for (size_t dy = 0; dy < patchSide; ++dy)
    for (size_t dx = 0; dx < patchSide; ++dx) {
      ValueType diff = (*fixedImageIt)(fixedTopLeftY + dy, fixedTopLeftX + dx) -
                       (*movingImageIt)(movingTopLeftY + dy, movingTopLeftX + dx);
      value += diff * diff;
    }
}