DetectionFrameConfig.cpp

Go to the documentation of this file.

 
#include <iostream>
 
#include <boost/filesystem.hpp>
 
#include "Configuration/ConfigManager.h"
 
#include "SEFramework/Image/ConstantImage.h"
#include "SEFramework/Image/ProcessedImage.h"
 
#include "SEImplementation/Background/BackgroundAnalyzerFactory.h"
#include "SEImplementation/Configuration/BackgroundConfig.h"
#include "SEImplementation/Configuration/DetectionImageConfig.h"
#include "SEImplementation/Configuration/WeightImageConfig.h"
 
#include "SEImplementation/CheckImages/CheckImages.h"
 
#include "SEImplementation/Configuration/DetectionFrameConfig.h"
 
using namespace Euclid::Configuration;
namespace po = boost::program_options;
 
namespace SourceXtractor {
 
DetectionFrameConfig::DetectionFrameConfig(long manager_id) : Configuration(manager_id) {
  declareDependency<WeightImageConfig>();
  declareDependency<DetectionImageConfig>();
  declareDependency<BackgroundConfig>();
  declareDependency<BackgroundAnalyzerFactory>();
}
 
void DetectionFrameConfig::initialize(const UserValues& ) {
 
  for (size_t i=0; i<getDependency<DetectionImageConfig>().getExtensionsNb(); i++) {
    auto detection_image = getDependency<DetectionImageConfig>().getDetectionImage(i);
    auto detection_image_path = getDependency<DetectionImageConfig>().getDetectionImagePath();
    auto detection_image_coordinate_system = getDependency<DetectionImageConfig>().getCoordinateSystem(i);
    auto detection_image_gain = getDependency<DetectionImageConfig>().getGain(i);
    auto detection_image_saturation = getDependency<DetectionImageConfig>().getSaturation(i);
    auto interpolation_gap = getDependency<DetectionImageConfig>().getInterpolationGap(i);
 
    auto weight_image = getDependency<WeightImageConfig>().getWeightImage(i);
    auto weight_threshold = getDependency<WeightImageConfig>().getWeightThreshold(i);
    bool is_weight_absolute = getDependency<WeightImageConfig>().isWeightAbsolute();
 
    auto detection_frame = std::make_shared<DetectionImageFrame>(detection_image, weight_image,
        weight_threshold, detection_image_coordinate_system, detection_image_gain,
        detection_image_saturation, interpolation_gap);
    detection_frame->setLabel(boost::filesystem::basename(detection_image_path));
 
    auto background_analyzer = getDependency<BackgroundAnalyzerFactory>().createBackgroundAnalyzer();
    auto background_model = background_analyzer->analyzeBackground(detection_frame->getOriginalImage(), weight_image,
        ConstantImage<unsigned char>::create(detection_image->getWidth(), detection_image->getHeight(), false), detection_frame->getVarianceThreshold());
 
    detection_frame->setBackgroundLevel(background_model.getLevelMap(), background_model.getMedianRms());
 
    if (weight_image != nullptr) {
      if (is_weight_absolute) {
        detection_frame->setVarianceMap(weight_image);
      } else {
        // apply the rms scaling factor from the background
        auto bck_scaling_factor = background_model.getScalingFactor();
        auto scaled_image = MultiplyImage<SeFloat>::create(weight_image, bck_scaling_factor);
        detection_frame->setVarianceMap(scaled_image);
        detection_frame->setVarianceThreshold(detection_frame->getVarianceThreshold()*bck_scaling_factor);
      }
    } else {
      // re-set the variance check image to what's in the detection_frame()
      detection_frame->setVarianceMap(background_model.getVarianceMap());
    }
 
    const auto& background_config = getDependency<BackgroundConfig>();
    // Override background level and threshold if requested by the user
    if (background_config.isBackgroundLevelAbsolute()) {
      auto background = ConstantImage<DetectionImage::PixelType>::create(
          detection_image->getWidth(), detection_image->getHeight(), background_config.getBackgroundLevel());
 
      detection_frame->setBackgroundLevel(background, background_model.getMedianRms());
 
      CheckImages::getInstance().addBackgroundCheckImage(background);
    } else {
      CheckImages::getInstance().addBackgroundCheckImage(background_model.getLevelMap());
    }
 
    if (background_config.isDetectionThresholdAbsolute()) {
      detection_frame->setDetectionThreshold(background_config.getDetectionThreshold());
    }
 
    auto img_source = getDependency<DetectionImageConfig>().getImageSource(i);
    detection_frame->setMetadata(img_source->getMetadata());
 
    detection_frame->setHduIndex(i);
 
    CheckImages::getInstance().addVarianceCheckImage(detection_frame->getImage(FrameImageLayer::LayerVarianceMap));
    CheckImages::getInstance().addFilteredCheckImage(detection_frame->getImage(FrameImageLayer::LayerFilteredImage));
    CheckImages::getInstance().addThresholdedCheckImage(detection_frame->getImage(FrameImageLayer::LayerThresholdedImage));
    CheckImages::getInstance().addSnrCheckImage(detection_frame->getImage(FrameImageLayer::LayerSignalToNoiseMap));
 
    m_frames.emplace_back(detection_frame);
  }
}
 
}