frameGenerator.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_COMMON_FRAMEGENERATOR_HPP
#define CAMCOM_COMMON_FRAMEGENERATOR_HPP
 
#include <cstdint>
#include <memory>
#include <vector>
 
#include "camcom/common/datatype.hpp"
 
namespace camcom::common {
 
enum class PatternType {
    Gaussian,
    MultiGaussian,
    Flat,
    Grid,
    Gradient,
    Ring,
    Checkerboard,
    Noise,
    Grating
};
 
enum class GradientDirection { Horizontal, Vertical, Radial };
enum class NoiseDistribution { Gaussian, Poisson, Uniform };

struct PatternConfig {
    PatternType type{PatternType::Gaussian};
 
    // Dimensions
    int32_t width{512};
    int32_t height{512};
    int32_t bin_x{1};
    int32_t bin_y{1};
    DataType output_type{DataType::BYTE};
 
    // Exposure/gain scaling
    double expo_time{1.0};
    double gain{1.0};
 
    // Frame drift (jitter between frames in a batch)
    int16_t max_shift{50};
    int16_t max_shift_per_frame{5};
 
    // Gaussian / MultiGaussian
    double amplitude{10000.0};
    double sigma{5.0};
    int16_t nb_stars{1};
 
    // Flat
    double flat_intensity{1000.0};
 
    // Grid
    int16_t grid_spacing{50};
    double spot_size{3.0};
 
    // Gradient
    GradientDirection gradient_dir{GradientDirection::Horizontal};
    double gradient_start{0.0};
    double gradient_end{10000.0};
 
    // Ring
    double ring_inner_radius{5.0};
    double ring_outer_radius{10.0};
 
    // Checkerboard
    int16_t checker_size{20};
 
    // Noise
    NoiseDistribution noise_dist{NoiseDistribution::Gaussian};
    double noise_mean{1000.0};
    double noise_std{100.0};
 
    // Grating
    double grating_dispersion{0.5};
    double grating_wavelength_min{400.0};
    double grating_wavelength_max{700.0};
    int16_t grating_order{1};
};

class FrameGenerator {
public:
    FrameGenerator();
    ~FrameGenerator();
 
    // Non-copyable, movable
    FrameGenerator(const FrameGenerator&) = delete;
    FrameGenerator& operator=(const FrameGenerator&) = delete;
    FrameGenerator(FrameGenerator&&) noexcept;
    FrameGenerator& operator=(FrameGenerator&&) noexcept;

    void configure(const PatternConfig& config);

    void generate(int32_t n_frames, std::vector<uint8_t>& output);

    int32_t outputWidth() const;

    int32_t outputHeight() const;

    size_t bytesPerFrame() const;

    size_t bytesPerPixel() const;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

PatternType parsePatternType(const std::string& type_str);

GradientDirection parseGradientDirection(const std::string& dir_str);

NoiseDistribution parseNoiseDistribution(const std::string& dist_str);

size_t bytesPerPixelForType(DataType type);
 
} // namespace camcom::common
 
#endif // CAMCOM_COMMON_FRAMEGENERATOR_HPP