visioncamera.h

Go to the documentation of this file.

#pragma once
 
#include <opencv2/opencv.hpp>
 
#include <networktables/NetworkTableInstance.h>
#include <networktables/NetworkTable.h>
#include <networktables/IntegerTopic.h>
#include <cameraserver/CameraServer.h>
#include <wpi/json.h>
 
 
class VisionCamera final: public cs::VideoCamera {
public:
    inline static const cv::Mat_<float>
        default_matrix{cv::Mat_<float>::zeros(3, 3)},
        default_distort{cv::Mat_<float>::zeros(1, 5)}
    ;
 
    //VisionCamera() = default;
    VisionCamera(CS_Source source_handle);
    VisionCamera(const cs::VideoSource& source, const wpi::json& config = wpi::json());
    VisionCamera(const cs::UsbCamera& source, const wpi::json& config = wpi::json());   // these were not working
    VisionCamera(const cs::HttpCamera& source, const wpi::json& config = wpi::json());  // ^
    VisionCamera(const wpi::json& source_config, const wpi::json& calibration);
    VisionCamera(const wpi::json& source_config);
    VisionCamera(const VisionCamera&) = delete;
    VisionCamera(VisionCamera&&);
    // inline VisionCamera(const VisionCamera&) { std::cout << "VCamera copied." << std::endl; }
    // inline VisionCamera(VisionCamera&&) { std::cout << "VCamera moved." << std::endl; }
    ~VisionCamera();
 
    inline VisionCamera& operator=(const VisionCamera&) = delete;
    VisionCamera& operator=(VisionCamera&&);
    // inline VisionCamera& operator=(const VisionCamera&) { std::cout << "VCamera copied via operator." << std::endl; }
    // inline VisionCamera& operator=(VisionCamera&&) { std::cout << "VCamera moved via operator." << std::endl; }
 
    bool isValidJson() const;
    const wpi::json& getJson() const;
    bool isValidStreamJson() const;
    wpi::json getStreamJson() const;
 
    bool getJsonCameraMatrix(cv::Mat_<double>& array) const;
    bool getJsonCameraMatrix(cv::Mat_<float>& array) const;
    bool getJsonDistortionCoefs(cv::Mat_<double>& array) const;
    bool getJsonDistortionCoefs(cv::Mat_<float>& array) const;
    inline const cv::Mat_<float>& getCameraMatrix() const { return this->camera_matrix; }
    inline const cv::Mat_<float>& getDistortionCoefs() const { return this->distortion; }
 
    bool setCalibrationJson(const wpi::json&);
    bool setCameraMatrix(const cv::Mat_<float>&);
    bool setDistortionCoefs(const cv::Mat_<float>&);
 
    uint64_t getFrame(cv::Mat& o_frame, double timeout = 0.225) const;
    uint64_t getFrameNoTmO(cv::Mat& o_frame) const;
    inline const cs::CvSink& getSink() const { return this->raw; }
 
    int getWidth() const;
    int getHeight() const;
    int getPixels() const;
    int getConfigFPS() const;
    cv::Size getResolution() const;
 
    int getBrightness() const;
    int getExposure() const;
    int getWhiteBalance() const;
 
    void setBrightness(int b);      // ranges 0 through 100 (a percent)
    void setWhiteBalance(int wb);   // ranges 0 through ~7000(+?) (look up) -> -1 sets to auto
    void setExposure(int e);        // ranges 0 through 100 -> -1 sets to auto
 
    void setNetworkBase(const std::shared_ptr<nt::NetworkTable>& table);
    void setNetworkAdjustable();
 
protected:
    int _setBrightness(int b);
    int _setWhiteBalance(int wb);
    int _setExposure(int e);
 
private:
    wpi::json config, calibration;
    cs::CvSink raw;
    cv::Mat_<float> camera_matrix{default_matrix}, distortion{default_distort};
    cs::VideoMode properties;
 
    std::shared_ptr<nt::NetworkTable> ntable{
        nt::NetworkTableInstance::GetDefault().GetTable("Cameras")->GetSubTable(this->GetName())};
    nt::IntegerEntry
        nt_brightness, nt_exposure, nt_whitebalance;
    NT_Listener listener_handle{0};
 
 
};