io.hpp

Go to the documentation of this file.

// I/O stuff, such as Cairo and star catalog interactions.
 
#ifndef IO_H
#define IO_H
 
#include <cairo/cairo.h>
 
#include <random>
#include <vector>
#include <map>
#include <utility>
#include <string>
#include <sstream>
#include <iostream>
#include <memory>
 
 
#ifndef CAIRO_HAS_PNG_FUNCTIONS
#error LOST requires Cairo to be compiled with PNG support
#endif
 
#include "centroiders.hpp"
#include "star-utils.hpp"
#include "star-id.hpp"
#include "camera.hpp"
#include "attitude-utils.hpp"
#include "attitude-estimators.hpp"
#include "databases.hpp"
 
namespace lost {
 
const char kNoDefaultArgument = 0;
 
class UserSpecifiedOutputStream {
public:
    explicit UserSpecifiedOutputStream(std::string filePath, bool isBinary);
    ~UserSpecifiedOutputStream();
 
    std::ostream &Stream() { return *stream; };
 
private:
    bool isFstream;
    std::ostream *stream;
};
 
// use the environment variable LOST_BSC_PATH, or read from ./bright-star-catalog.tsv
const Catalog &CatalogRead();
// Convert a cairo surface to array of grayscale bytes
unsigned char *SurfaceToGrayscaleImage(cairo_surface_t *cairoSurface);
cairo_surface_t *GrayscaleImageToSurface(const unsigned char *, const int width, const int height);
 
// take an astrometry download from the bash script, and parse it into stuff.
// void v_astrometry_parse(std::string
//                         cairo_surface_t **pcairoSurface,   // image data
//                         Star      **ppx_centroids, // centroids according to astrometry
//                         int             *pi_centroids_length); // TODO: fov, actual angle, etc
 
// type for functions that create a centroid algorithm (by prompting the user usually)
 
class Image {
public:
    unsigned char *image;
 
    int width;
    int height;
};
 
// PIPELINE INPUT //
 
 
class PipelineOptions {
public:
#define LOST_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg) \
    type prop = defaultVal;
#include "./pipeline-options.hpp"
#undef LOST_CLI_OPTION
};
 
class PipelineInput {
public:
    virtual ~PipelineInput(){};
 
    virtual const Image *InputImage() const { return NULL; };
    virtual const Catalog &GetCatalog() const = 0;
    virtual const Stars *InputStars() const { return NULL; };
    virtual const StarIdentifiers *InputStarIds() const { return NULL; };
    virtual const Attitude *InputAttitude() const { return NULL; };
    virtual const Camera *InputCamera() const { return NULL; };
    cairo_surface_t *InputImageSurface() const;
 
    virtual const Stars *ExpectedStars() const { return InputStars(); };
    virtual const StarIdentifiers *ExpectedStarIds() const { return InputStarIds(); };
    virtual const Attitude *ExpectedAttitude() const { return InputAttitude(); };
};
 
class GeneratedPipelineInput : public PipelineInput {
public:
    GeneratedPipelineInput(const Catalog &, Attitude, Camera, std::default_random_engine *,
 
                           bool centroidsOnly,
                           decimal observedReferenceBrightness, decimal starSpreadStdDev,
                           decimal sensitivity, decimal darkCurrent, decimal readNoiseStdDev,
                           Attitude motionBlurDirection, decimal exposureTime, decimal readoutTime,
                           bool shotNoise, int oversampling,
                           int numFalseStars, int falseMinMagnitude, int falseMaxMagnitude,
                           int cutoffMag,
                           decimal perturbationStddev);
 
 
    const Image *InputImage() const override { return &image; };
    const Stars *InputStars() const override { return &inputStars; };
    const Stars *ExpectedStars() const override { return &expectedStars; };
    const Camera *InputCamera() const override { return &camera; };
    const StarIdentifiers *InputStarIds() const override { return &inputStarIds; };
    const StarIdentifiers *ExpectedStarIds() const override { return &expectedStarIds; };
    const Attitude *InputAttitude() const override { return &attitude; };
    const Catalog &GetCatalog() const override { return catalog; };
 
private:
    std::vector<unsigned char> imageData;
    Image image;
    Stars expectedStars;
    Stars inputStars;
    Camera camera;
    Attitude attitude;
    const Catalog &catalog;
    StarIdentifiers inputStarIds;
    StarIdentifiers expectedStarIds;
};
 
typedef std::vector<std::unique_ptr<PipelineInput>> PipelineInputList;
 
PipelineInputList GetPipelineInput(const PipelineOptions &values);
 
class PngPipelineInput : public PipelineInput {
public:
    PngPipelineInput(cairo_surface_t *, Camera, const Catalog &);
    ~PngPipelineInput();
 
    const Image *InputImage() const override { return &image; };
    const Camera *InputCamera() const override { return &camera; };
    const Catalog &GetCatalog() const override { return catalog; };
 
private:
    Image image;
    Camera camera;
    const Catalog &catalog;
};
 
// PIPELINE OUTPUT //
 
struct PipelineOutput {
    std::unique_ptr<Stars> stars = nullptr;
    std::unique_ptr<StarIdentifiers> starIds = nullptr;
    std::unique_ptr<Attitude> attitude = nullptr;
 
    long long centroidingTimeNs = -1;
    long long starIdTimeNs = -1;
    long long attitudeEstimationTimeNs = -1;
 
    Catalog catalog;
};
 
struct StarIdComparison {
    int numCorrect;
 
    int numIncorrect;
 
    int numTotal;
};
 
std::ostream &operator<<(std::ostream &, const Camera &);
 
// PIPELINE //
 
class Pipeline {
    friend Pipeline SetPipeline(const PipelineOptions &values);
 
public:
    Pipeline() = default;
    Pipeline(CentroidAlgorithm *, StarIdAlgorithm *, AttitudeEstimationAlgorithm *, unsigned char *);
    PipelineOutput Go(const PipelineInput &);
    std::vector<PipelineOutput> Go(const PipelineInputList &);
 
private:
    std::unique_ptr<CentroidAlgorithm> centroidAlgorithm;
 
    // next two options are for magnitude filter:
    int centroidMinMagnitude = 0;
    int centroidMinStars = 0;
 
    std::unique_ptr<StarIdAlgorithm> starIdAlgorithm;
    std::unique_ptr<AttitudeEstimationAlgorithm> attitudeEstimationAlgorithm;
    std::unique_ptr<unsigned char[]> database;
};
 
Pipeline SetPipeline(const PipelineOptions &values);
 
// TODO: rename. Do something with the output
void PipelineComparison(const PipelineInputList &expected,
                        const std::vector<PipelineOutput> &actual,
                        const PipelineOptions &values);
 
StarIdComparison StarIdsCompare(const StarIdentifiers &expected, const StarIdentifiers &actual,
                                // use these to map indices to names for the respective lists of StarIdentifiers
                                const Catalog &expectedCatalog, const Catalog &actualCatalog,
                                decimal centroidThreshold,
                                const Stars &expectedStars, const Stars &inputStars);
 
// DB BUILDER //
 
class DatabaseOptions {
public:
#define LOST_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg) \
    type prop = defaultVal;
#include "database-options.hpp"
#undef LOST_CLI_OPTION
};
 
SerializeContext serFromDbValues(const DatabaseOptions &values);
 
MultiDatabaseDescriptor GenerateDatabases(const Catalog &, const DatabaseOptions &values);
 
// INSPECT CATALOG //
 
void InspectCatalog();
 
}
 
#endif