SensorSilCam.h

#pragma once
 
#include "SampleClock.h"
#include "SensorFrame.h"
#include "SensorNoise.h"
 
#include <fhsim/simobject/SimObject.h>
#include <string>
#include <vector>
 
namespace environment
{
class EnvironmentProvider;
}
 
class SensorSilCam : public SimObject
{
public:
   struct Settings
   {
      double       frameRate                   = 4.0;                   
      int          framesPerOutput             = 40;                    
      double       sampleVolume[3]             = {0.040, 0.055, 0.065}; 
      double       captureEfficiency           = 0.85;                  
      double       detectionProbability        = 0.92;                  
      double       assumedDetectionProbability = 0.92;                  
      double       falsePositiveRate           = 0.05;                  
      double       individualMassKg            = 1.1e-6;                
      double       lengthM                     = 0.0028;                
      double       lengthStdM                  = 0.0007;                
      double       sizeErrorStdRelative        = 0.08;                  
      int          numSizeBins                 = 8;                     
      double       sizeBinMin                  = 0.0005;                
      double       sizeBinMax                  = 0.0060;                
      unsigned int noiseSeed                   = 0;                     
   };
 
   struct Measurement
   {
      double              concentration       = 0.0;     
      double              numberConcentration = 0.0;     
      double              count               = 0.0;     
      double              sizeMean            = 0.0;     
      double              sizeStd             = 0.0;     
      std::vector<double> histogram;                     
      double              sampleTime  = 0.0;             
      double              position[3] = {0.0, 0.0, 0.0}; 
      double              valid       = 0.0;             
   };
 
   SensorSilCam(std::string simObjectName, ISimObjectCreator* creator);
 
   SensorSilCam(std::string simObjectName, const Settings& settings);
 
   static double SampleVolumeOf(const double sideLengths[3]);
 
   static double FrameLambdaOf(double numberConcentration, double sampleVolume,
         double captureEfficiency, double detectionProbability);
 
   static double LengthLogSigmaOf(double medianLength, double stdLength);
 
   static int BinIndexOf(double length, double binMin, double binMax, int numBins);
 
   void OdeFcn(const double dT, const double* const adX, double* const adXDot) const override;
 
   void AcceptedStep(const double dT, const double* const adX) override;
 
   void FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator) override;
 
#ifdef FH_VISUALIZATION
   void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator) override { }
   void RenderUpdate(const double dT, const double* const adX) override { }
#endif
 
   int CaptureIfDue(double t, double numberConcentration, const double position[3]);
 
   bool CaptureFrame(double t, double numberConcentration, const double position[3]);
 
   const Measurement& HeldMeasurement() const { return m_held; }
 
   const Settings& GetSettings() const { return m_settings; }
 
   int FramesInWindow() const { return m_framesInWindow; }
 
   long long FramesCaptured() const { return m_framesCaptured; }
 
   double NextFrameTime() const { return m_frameClock.NextSampleTime(); }
 
protected:
   const double* OutConcentration(const double dT, const double* const adX);
 
   const double* OutNumberConcentration(const double dT, const double* const adX);
 
   const double* OutCount(const double dT, const double* const adX);
 
   const double* OutSizeMean(const double dT, const double* const adX);
 
   const double* OutSizeStd(const double dT, const double* const adX);
 
   const double* OutSizeHistogram(const double dT, const double* const adX);
 
   const double* OutSampleTime(const double dT, const double* const adX);
 
   const double* OutPosition(const double dT, const double* const adX);
 
   const double* OutValid(const double dT, const double* const adX);
 
private:
   struct Window
   {
      double              count       = 0.0;                
      double              sumLength   = 0.0;                
      double              sumLengthSq = 0.0;                
      std::vector<double> binCounts;                        
      double              sumTime        = 0.0;             
      double              sumPosition[3] = {0.0, 0.0, 0.0}; 
   };
 
   struct AnalyticParticle
   {
      double              meanLength   = 0.0; 
      double              secondMoment = 0.0; 
      std::vector<double> binProbabilities;   
   };
 
   void UpdateAnalyticParticle();
 
   void ResetWindow();
 
   void AccumulateAnalyticFrame(double lambda);
 
   void AccumulateDrawnFrame(double lambda);
 
   void AddParticle(double length, double weight);
 
   void CloseWindow();
 
   double DrawAnimalLength();
 
   double DrawFalsePositiveLength();
 
   double TotalLogSigma() const;
 
   void AnalyticBinProbabilities(std::vector<double>& out) const;
 
   void ResolveEnvironment(ISimObjectCreator* const creator);
 
   double NumberConcentrationAt(double dT, const double position[3]) const;
 
   SensorFrame m_frame;      
   SampleClock m_frameClock; 
   SensorNoise m_noise;      
   Settings    m_settings;   
 
   std::string m_name;             
   std::string m_speciesFieldName; 
   std::string m_parameterLibrary; 
 
   bool m_individualMassGiven = false; 
 
   environment::EnvironmentProvider* m_environment   = nullptr; 
   int                               m_speciesHandle = -1;      
 
   bool m_hasPorts = false; 
 
   double m_sampleVolume = 0.0; 
 
   AnalyticParticle m_analytic; 
 
   Window      m_window;             
   Measurement m_held;               
   int         m_framesInWindow = 0; 
   long long   m_framesCaptured = 0; 
};