AttractorsPartitionStep.cpp

Go to the documentation of this file.

#include <limits>

#include "SEFramework/Image/Image.h"
#include "SEFramework/Image/ImageAccessor.h"
#include "SEFramework/Property/DetectionFrame.h"

#include "SEImplementation/Property/PixelCoordinateList.h"
#include "SEImplementation/Plugin/DetectionFrameSourceStamp/DetectionFrameSourceStamp.h"
#include "SEImplementation/Plugin/PixelBoundaries/PixelBoundaries.h"
#include "SEImplementation/Partition/AttractorsPartitionStep.h"

namespace SourceXtractor {

std::vector<std::unique_ptr<SourceInterface>> AttractorsPartitionStep::partition(std::unique_ptr<SourceInterface> source) const {
  using Accessor = ImageAccessor<DetectionImage::PixelType>;
  Accessor stamp(source->getProperty<DetectionFrameSourceStamp>().getStamp());
  auto& detection_frame = source->getProperty<DetectionFrame>();
  auto& bounds = source->getProperty<PixelBoundaries>();

  auto bbox_min = bounds.getMin();
  auto bbox_max = bounds.getMax();

  auto value_function = [bbox_min, bbox_max, &stamp](PixelCoordinate coord) {
    if (coord.m_x < bbox_min.m_x || coord.m_x > bbox_max.m_x || coord.m_y < bbox_min.m_y || coord.m_y > bbox_max.m_y) {
      return std::numeric_limits<DetectionImage::PixelType>::lowest();
    }
    auto offset_coord = coord - bbox_min;
    return stamp.getValue(offset_coord.m_x, offset_coord.m_y);
  };

  std::vector<std::pair<PixelCoordinate, PixelCoordinate>> pixel_coordinates;
  auto& pixel_list = source->getProperty<PixelCoordinateList>().getCoordinateList();
  pixel_coordinates.reserve(pixel_list.size());
  for (auto& pixel : pixel_list) {
    pixel_coordinates.emplace_back(pixel, pixel);
  }

  std::unordered_map<PixelCoordinate, std::vector<PixelCoordinate>> attractors;

  attractPixels(pixel_coordinates, attractors, value_function);
  auto merged = mergeAttractors(attractors);

  // If we end up with a single group use the original group
  std::vector<std::unique_ptr<SourceInterface>> sources;
  if (merged.size() == 1) {
    sources.emplace_back(std::move(source));
  } else {
    for (auto& source_pixels : merged) {
      auto new_source = m_source_factory->createSource();
      new_source->setProperty<PixelCoordinateList>(source_pixels);
      new_source->setProperty<DetectionFrame>(detection_frame.getEncapsulatedFrame());
      sources.emplace_back(std::move(new_source));
    }
  }
  return sources;
}

void AttractorsPartitionStep::attractPixels(
    const std::vector<std::pair<PixelCoordinate, PixelCoordinate>>& pixels_with_origin,
    std::unordered_map<PixelCoordinate, std::vector<PixelCoordinate>>& attractors,
    std::function<DetectionImage::PixelType  (PixelCoordinate)> value_function) const {

  PixelCoordinate offsets[5] {
    PixelCoordinate( 0,  0),
    PixelCoordinate(-1,  0),
    PixelCoordinate( 0, -1),
    PixelCoordinate( 1,  0),
    PixelCoordinate( 0,  1)
  };

  if (pixels_with_origin.size() == 0) {
    return;
  }

  std::vector<std::pair<PixelCoordinate, PixelCoordinate>> pixels_to_be_processed;

  for (auto& pixel_origin : pixels_with_origin) {
    auto pixel = pixel_origin.first;
    auto origin = pixel_origin.second;

    DetectionImage::PixelType values[5];
    for (int i=0; i<5; i++) {
      values[i] = value_function(pixel + offsets[i]);
    }

    size_t max = 0;
    for (int i=1; i<3; i++) {
      if (values[i] > values[max]) {
        max = i;
      }
    }
    for (int i=3; i<5; i++) {
      if (values[i] >= values[max]) {
        max = i;
      }
    }

    if (max == 0) {
      // We are at the attractor pixel
      attractors[pixel].push_back(origin);
    } else {
      pixels_to_be_processed.push_back(
          std::pair<PixelCoordinate, PixelCoordinate>(pixel + offsets[max], origin));
    }
  }
  attractPixels(pixels_to_be_processed, attractors, value_function);
}

std::vector<std::vector<PixelCoordinate>> AttractorsPartitionStep::mergeAttractors(
    const std::unordered_map<PixelCoordinate, std::vector<PixelCoordinate>>& attractors) const {
  std::vector<std::vector<PixelCoordinate>> merged;
  std::vector<PixelCoordinate> bbox_min;
  std::vector<PixelCoordinate> bbox_max;

  for (auto& attractor : attractors) {
    auto coord = attractor.first;
    auto& pixels = attractor.second;
    bool done = false;

    for (size_t i=0; i < merged.size(); i++) {
      if (coord.m_x >= bbox_min[i].m_x-1 && coord.m_x <= bbox_max[i].m_x+1 && coord.m_y >= bbox_min[i].m_y-1 && coord.m_y <= bbox_max[i].m_y+1) {
        bbox_min[i] = PixelCoordinate(std::min(coord.m_x, bbox_min[i].m_x), std::min(coord.m_y, bbox_min[i].m_y));
        bbox_max[i] = PixelCoordinate(std::max(coord.m_x, bbox_max[i].m_x), std::max(coord.m_y, bbox_max[i].m_y));
        merged[i].insert(merged[i].begin(), pixels.begin(), pixels.end());
        done = true;
        break;
      }
    }
    if (!done) {
      merged.push_back(pixels);
      bbox_min.push_back(coord);
      bbox_max.push_back(coord);
    }
  }
  return merged;
}

} // SEImplementation namespace