Ambiguity.h

Go to the documentation of this file.

 
#pragma once
 
#include "data/IqData.h"
#include "data/Map.h"
#include "process/meta/HammingNumber.h"
#include <stdint.h>
#include <fftw3.h>
#include <memory>
 
class Ambiguity
{
 
public:
 
  using Complex = std::complex<double>;
 
  struct PerformanceStats {
    double process_time_ms{0};
    double range_fft_time_ms{0};
    double doppler_fft_time_ms{0};
  };
 
 
  Ambiguity(int32_t delayMin, int32_t delayMax, int32_t dopplerMin, int32_t dopplerMax, uint32_t fs, uint32_t n, bool roundHamming = false);
 
  ~Ambiguity();
 
  Map<Complex> *process(IqData *x, IqData *y);
 
  double doppler_middle() const { return dopplerMiddle_; }
 
  uint16_t delay_bin_count() const { return nDelayBins_; }
 
  uint16_t doppler_bin_count() const { return nDopplerBins_; }
 
  uint16_t corr_samples_per_pulse() const { return nCorr_; }
 
  double cpi_length_seconds() const { return cpi_; }
 
  uint32_t fft_bin_count() const { return nfft_; }
 
  PerformanceStats get_latest_performance() const { return latest_performance_; }
private:
  int32_t delayMin_;
 
  int32_t delayMax_;
 
  int32_t dopplerMin_;
 
  int32_t dopplerMax_;
 
  uint32_t fs_;
 
  uint32_t nSamples_;
 
  double dopplerMiddle_;
 
  uint16_t nDelayBins_;
 
  uint16_t nDopplerBins_;
 
  uint16_t nCorr_;
 
  double cpi_;
 
  fftw_plan fftXi_;
  fftw_plan fftYi_;
  fftw_plan fftZi_;
  fftw_plan fftDoppler_;
 
  std::vector<Complex> dataXi_;
  std::vector<Complex> dataYi_;
  std::vector<Complex> dataZi_;
  std::vector<Complex> dataCorr_;
  std::vector<Complex> dataDoppler_;
 
  uint32_t nfft_;
 
  std::vector<Complex> corr_;
  std::vector<Complex> delayProfile_;
 
  std::unique_ptr<Map<Complex>> map_;
 
  PerformanceStats latest_performance_;
};
 
std::ostream& operator<<(std::ostream& str, const Ambiguity::PerformanceStats& stats);