// Copyright (c) 2012-2017 VideoStitch SAS // Copyright (c) 2018 stitchEm #ifndef INPUT_DEF_HPP_ #define INPUT_DEF_HPP_ #include "config.hpp" #include "curves.hpp" #include "status.hpp" #include "geometryDef.hpp" #include "readerInputDef.hpp" #include namespace VideoStitch { namespace Ptv { class Value; } namespace Core { class GeometryDefinition; /** * @brief An input stream representation class. */ class VS_EXPORT InputDefinition : public ReaderInputDefinition { public: /** * An identifier for a group of inputs * (inputs with a common time referential) */ typedef int group_t; /** * Input format (projection). */ enum class Format { Rectilinear = 0, CircularFisheye = 2, FullFrameFisheye = 3, Equirectangular = 4, CircularFisheye_Opt = 5, FullFrameFisheye_Opt = 6 }; /** * Legacy/Optimized lens model category */ enum class LensModelCategory { Legacy, // Rectilinear, CircularFisheye, FullFrameFisheye, Equirectangular Optimized // CircularFisheye_Opt, FullFrameFisheye_Opt }; /** * Photometric response type of the camera. */ enum class PhotoResponse { LinearResponse, GammaResponse, EmorResponse, InvEmorResponse, CurveResponse }; virtual ~InputDefinition(); /** * Clones an InputDefinition java-style. * @return A similar InputDefinition. Ownership is given to the caller. */ virtual InputDefinition* clone() const; /** * Build from a Ptv::Value. * @param value Input value. * @return The parsed InputDefinition, or nullptr on error. */ static InputDefinition* create(const Ptv::Value& value, bool enforceMandatoryFields = true); virtual Ptv::Value* serialize() const; /** * Comparison operator. */ virtual bool operator==(const InputDefinition& other) const; /** * Validate that the input makes sense. * @param os The sink for error messages. * @return false of failure. */ virtual bool validate(std::ostream& os) const; /** * Convert a panotools int to an InputDefinition::Format. * @param ptFmt a PanoTools integer representing the format. * @param fmt VideoStitch output format. * @return false of the input format is not supported. */ static bool fromPTFormat(const char* ptFmt, Format* fmt); /** * Converts a projection name to a InputDefinition::Format. * @param fmt projection name. * @param fmtOut On output, contains the format if successful. * @return false is the projection is unknown. */ static bool getFormatFromName(const std::string& fmt, InputDefinition::Format& fmtOut); /** * Returns the data for the mask of this input. */ virtual const std::string& getMaskData() const; /** * Returns true if masked pixels are taken into account when computing stitching seam geometry. */ virtual bool deletesMaskedPixels() const; /** * Represents an input mask. */ struct MaskPixelData { public: MaskPixelData() : width(0), height(0), data(NULL) {} ~MaskPixelData(); /** * Returns the mask's width. */ virtual int64_t getWidth() const { return width; } /** * Returns the mask's width. */ virtual int64_t getHeight() const { return height; } /** * Reallocate a buffer. * @param newWidth Width of the new buffer. * @param newHeight Height of the new buffer. * @return true on success. */ virtual bool realloc(int64_t newWidth, int64_t newHeight); /** * Returns the (const) data buffer. */ virtual const unsigned char* getData() const { return data; } private: friend class InputDefinition; int64_t width; int64_t height; unsigned char* data; // Owned. }; /** * Returns the raw pixel data for the mask of this input. * The data is invalidated by any call to a non-const method to the InputDefinition. * Note that the size is not necessarily that of the InputDefinition. * @return MaskPixelData() if there is no data, or if the data is invalid. */ virtual const MaskPixelData& getMaskPixelData() const; /** * A helper that returns the raw pixel data for the mask of this input; or NULL if there is no mask. * Functionally equivalent to: * return validateMask() ? maskPixelDataCache.getData() : NULL; */ virtual const unsigned char* getMaskPixelDataIfValid() const; /** * Returns true if there is no mask or if the mask data is valid (i.e. can be decoded and is of the correct size). */ virtual bool validateMask() const; /** * Returns the group of this input. * Groups are readers with a common time referential. */ virtual group_t getGroup() const; /** * Sets the group of this input. * Groups are readers with a common time referential. */ virtual void setGroup(group_t); /** * Returns the width of this input, NOT including the optionally cropped part. */ virtual int64_t getCroppedWidth() const; /** * Returns the height of this input, NOT including the optionally cropped part. */ virtual int64_t getCroppedHeight() const; /** * Get the place the distortion take place * @return is the distortion in meter space */ virtual bool getUseMeterDistortion() const; /** * Returns the input projection name. */ static const char* getFormatName(Format fmt); /** * Returns the input projection. */ virtual Format getFormat() const; /** * Sets the input projection. */ virtual void setFormat(Format); /** * Returns the lens category */ virtual LensModelCategory getLensModelCategory() const; /** * Returns true if parameters are relative to the cropped area. */ virtual bool hasCroppedArea() const; /** * Returns the cost of current input */ virtual double getSynchroCost() const; /** * Returns the input stack order. */ virtual int getStack() const; /** * Sets the stack order. If two inputs have the same stack order, the first one is merged first. * @param value stack value to set. */ virtual void setStack(int value); /** * Sets the mask data of this input (2-bit png). * @param data "file:/path/to/file", data or NULL for no mask. * @param len Length of @a data. */ virtual void setMaskData(const std::string& maskData); /** * Sets whether the masked pixels are taken into account when computing stitching seam geometry. * @param value True to delete masked pixels (i.e. do as if they were not masked.). */ virtual void setDeletesMaskedPixels(bool value); /** * Sets the mask data of this input from raw pixel data by compressing the data. * @param buffer Pixel data, of size @a maskWidth x @a maskHeight * @param maskWidth Width of @a buffer. * @param maskHeight Height of @a buffer. * @return false on failure. */ virtual bool setMaskPixelData(const char* buffer, uint64_t maskWidth, uint64_t maskHeight); /** * Set the synchronization cost for current input * @param cost Cost of synchronization for current input */ virtual void setSynchroCost(double cost); /** * green/red/blue compensation factor. (Linear scale, 1.0 means no correction) * For hugin, this is always 1. For PTGui, this is computed from red and blue so that the sum of the 3 components is 0 * in log scale. We convert it on import. */ DECLARE_CURVE(RedCB, double) DECLARE_CURVE(GreenCB, double) DECLARE_CURVE(BlueCB, double) /** * Exposure value, log scale. */ DECLARE_CURVE(ExposureValue, double) /** * Geometries * @note Reseter method resetGeometries() not defined by the macro, but explicitly below with an argument */ DECLARE_CURVE_WITHOUT_RESETER(Geometries, GeometryDefinition) /** * Resets the geometries to the given HFOV * @param HFOV Horizontal field of view */ virtual void resetGeometries(const double HFOV); /** * Get the preprocessors config, or NULL. */ virtual const Ptv::Value* getPreprocessors() const; // --------------------- Lens -------------------- // The distortion can evolve in time for a better image // alignement, look in GeometryDef. /** * Set the place the distortion take place * @param meter is the distortion in meter space */ virtual void setUseMeterDistortion(bool meter); // -------------------- Camera response function -------------- /** * Returns the photometric response type. */ virtual PhotoResponse getPhotoResponse() const; /** * Returns the coefficient of the 2nd eigenvector in the EMoR basis. * @note Only makes sense for EmorResponse photometric responses. */ virtual double getEmorA() const; /** * Returns the coefficient of the 3rd eigenvector in the EMoR basis. * @note Only makes sense for EmorResponse photometric responses. */ virtual double getEmorB() const; /** * Returns the coefficient of the 4th eigenvector in the EMoR basis. * @note Only makes sense for EmorResponse photometric reponses. */ virtual double getEmorC() const; /** * Returns the coefficient of the 5th eigenvector in the EMoR basis. * @note Only makes sense for EmorResponse photometric responses. */ virtual double getEmorD() const; /** * Returns the coefficient of the 6th eigenvector in the EMoR basis. * @note Only makes sense for EmorResponse photometric responses. */ virtual double getEmorE() const; /** * Returns the photometric gamma. * @note Only makes sense for GammaResponse photometric responses. */ virtual double getGamma() const; /** * Returns the value-based response curve * @note Only valid for CurveResponse photometric responses, otherwise may be NULL */ virtual const std::array* getValueBasedResponseCurve() const; /** * Sets the camera response curve to an EMoR-parametrised curve */ virtual void setEmorA(double emorA); /** * Sets the camera response curve to an EMoR-parametrised curve */ virtual void setEmorB(double emorB); /** * Sets the camera response curve to an EMoR-parametrised curve */ virtual void setEmorC(double emorC); /** * Sets the camera response curve to an EMoR-parametrised curve */ virtual void setEmorD(double emorD); /** * Sets the camera response curve to an EMoR-parametrised curve */ virtual void setEmorE(double emorE); /** * Sets the camera response to an EMoR-parametrised curve */ virtual void setEmorPhotoResponse(double emorA, double emorB, double emorC, double emorD, double emorE); /** * Resets the photo response to its default */ virtual void resetPhotoResponse(); /** * Sets the photometric gamma. * @note Only makes sense for GammaResponse photometric responses. */ virtual void setGamma(double gamma); /** * Sets the camera response to a value-based response curve */ virtual void setValueBasedResponseCurve(const std::array& values); // ------------------ Vignetting ----------------------- /** * Returns the constant vignetting coefficient. */ virtual double getVignettingCoeff0() const; /** * Returns the linear vignetting coefficient. */ virtual double getVignettingCoeff1() const; /** * Returns the quadratic vignetting coefficient. */ virtual double getVignettingCoeff2() const; /** * Returns the order three vignetting coefficient. */ virtual double getVignettingCoeff3() const; /** * Returns the vignetting center (X). */ virtual double getVignettingCenterX() const; /** * Returns the vignetting center (Y). */ virtual double getVignettingCenterY() const; /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setVignettingCoeff0(double vignettingCoeff0); /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setVignettingCoeff1(double vignettingCoeff1); /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setVignettingCoeff2(double vignettingCoeff2); /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setVignettingCoeff3(double vignettingCoeff3); /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setVignettingCenterX(double vignettingCenterX); /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setVignettingCenterY(double vignettingCenterY); /** * Sets the vignetting type to a parametrised radial vignetting */ virtual void setRadialVignetting(double vignettingCoeff0, double vignettingCoeff1, double vignettingCoeff2, double vignettingCoeff3, double vignettingCenterX, double vignettingCenterY); /** * Resets radial vignetting parameters and disables vignetting */ virtual void resetVignetting(); /** * @brief getInputCenterX * @return input center X */ virtual double getInputCenterX() const; /** * @brief getInputCenterY * @return input center Y */ virtual double getInputCenterY() const; /** * @brief getCenterX * @param geometry used geometry input * @return lens center X coordinate */ virtual double getCenterX(const GeometryDefinition& geometry) const; /** * @brief getCenterY * @param geometry used geometry input * @return lens center Y coordinate */ virtual double getCenterY(const GeometryDefinition& geometry) const; // ------------------- Crop ----------------- /** * Returns where to start using pixels, starting from the left border. * @note May be negative. */ virtual int64_t getCropLeft() const; /** * Returns where to stop using pixels, starting from the left border. * @note May be larger than the actual width. */ virtual int64_t getCropRight() const; /** * Returns where to start using pixels, starting from the top border. * @note May be negative. */ virtual int64_t getCropTop() const; /** * Returns where to stop using pixels, starting from the top border. * @note May be larger than the actual height. */ virtual int64_t getCropBottom() const; /** * Sets the input crop values and calculate the relative crop * @param left Crop left value */ virtual void setCropLeft(int64_t left); /** * Sets the input crop values and calculate the relative crop * @param right Crop right value */ virtual void setCropRight(int64_t right); /** * Sets the input crop values and calculate the relative crop * @param top Crop top value */ virtual void setCropTop(int64_t top); /** * Sets the input crop values and calculate the relative crop * @param bottom Crop bottom value */ virtual void setCropBottom(int64_t bottom); /** * Sets the input crop values and calculate the relative crop * @param left Crop left value * @param right Crop right value * @param top Crop top value * @param bottom Crop bottom value */ virtual void setCrop(int64_t left, int64_t right, int64_t top, int64_t bottom); /** * Resets the crop value to the image bounds */ virtual void resetCrop(); /** * Resets all distortion parameters and the geometry and vignetting center */ virtual void resetDistortion(); /** * Compute what focal the input should have if its distortion were removed. */ virtual double computeFocalWithoutDistortion() const; protected: /** * Build with the mandatory fields. The others take default values. */ InputDefinition(); /** * Disabled, use clone() */ InputDefinition(const InputDefinition&) = delete; /** * Disabled, use clone() */ InputDefinition& operator=(const InputDefinition&) = delete; /** * Parse from the given ptv. Values not specified are not overridden. * @param diff Input diff. * @param enforceMandatoryFields If false, ignore missing mandatory values. */ Status applyDiff(const Ptv::Value& diff, bool enforceMandatoryFields); /** * @brief resetExposure Resets exposure curve values for this InputDefinition. */ virtual void resetExposure(); /** * Parse an Input from a pto line. * @param line The input line * @param prevInputs The vector of previous InputDefinitions for back references. * @return The parsed InputDefinition. */ static Potential parseFromPtoLine(char* line, const std::vector& prevInputs); /** * Parse from a pts line. * @param line The input line * @param prevInputs The vector of previous InputDefinitions for back references. * @return The parsed InputDefinition. */ static Potential parseFromPtsLine(char* line, const std::vector& prevInputs); private: friend class PanoDefinition; friend Potential parseFromPtoLine(char*, const std::vector&); class Pimpl; Pimpl* const pimpl; // keep the compiler happy using ReaderInputDefinition::operator==; }; } // namespace Core } // namespace VideoStitch #endif