lensfun.h

Go to the documentation of this file.

/* -*- mode:c++ -*- */
/*
    Lensfun - a library for maintaining a database of photographical lenses,
    and providing the means to correct some of the typical lens distortions.
    Copyright (C) 2007 by Andrew Zabolotny

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __LENSFUN_H__
#define __LENSFUN_H__

#include <stddef.h>

#ifndef __cplusplus
    #if (defined(_MSC_VER) && (_MSC_VER < 1800)) // Visual studio up to VS2013 does not have stdbool.h
        typedef int bool;
        #define true 1
        #define false 0
    #else
        #include <stdbool.h>
    #endif
#endif

#ifdef __cplusplus

#include <string>
#include <vector>
#include <set>

extern "C" {
#  define C_TYPEDEF(t,c)
#else
#  define C_TYPEDEF(t,c) typedef t c c;
#endif

/*----------------------------------------------------------------------------*/

#define LF_VERSION_MAJOR        0
#define LF_VERSION_MINOR        3
#define LF_VERSION_MICRO        95
#define LF_VERSION_BUGFIX       0
#define LF_VERSION      ((LF_VERSION_MAJOR << 24) | (LF_VERSION_MINOR << 16) | (LF_VERSION_MICRO << 8) | LF_VERSION_BUGFIX)

#define LF_MIN_DATABASE_VERSION 0
#define LF_MAX_DATABASE_VERSION 2

#if defined CONF_LENSFUN_STATIC
#   define LF_EXPORT
#else
#   ifdef CONF_SYMBOL_VISIBILITY
#       if defined PLATFORM_WINDOWS
#           define LF_EXPORT    __declspec(dllexport)
#       elif defined CONF_COMPILER_GCC || __clang__
#           define LF_EXPORT    __attribute__((visibility("default")))
#       else
#           error "I don't know how to change symbol visibility for your compiler"
#       endif
#   else
#       if defined PLATFORM_WINDOWS || defined _MSC_VER
#           define LF_EXPORT    __declspec(dllimport)
#       else
#           define LF_EXPORT
#       endif
#   endif
#endif

#ifndef CONF_LENSFUN_INTERNAL
#    ifdef __GNUC__
#        define DEPRECATED __attribute__((deprecated))
#    elif defined(_MSC_VER)
#        define DEPRECATED __declspec(deprecated)
#    else
#        pragma message("WARNING: You need to implement DEPRECATED for this compiler")
#        define DEPRECATED
#    endif
#else
#    define DEPRECATED
#endif

#define cbool int

typedef char *lfMLstr;

enum lfError
{
    LF_NO_ERROR = 0,
    LF_WRONG_FORMAT,
    LF_NO_DATABASE
};

C_TYPEDEF (enum, lfError)


typedef unsigned char lf_u8;
typedef unsigned short lf_u16;
typedef unsigned int lf_u32;
typedef float lf_f32;
typedef double lf_f64;

LF_EXPORT void lf_free (void *data);

LF_EXPORT const char *lf_mlstr_get (const lfMLstr str);

LF_EXPORT lfMLstr lf_mlstr_add (lfMLstr str, const char *lang, const char *trstr);

LF_EXPORT lfMLstr lf_mlstr_dup (const lfMLstr str);

/*----------------------------------------------------------------------------*/

struct LF_EXPORT lfMount
{
    lfMLstr Name;
    DEPRECATED char **Compat;

#ifdef __cplusplus

    lfMount ();

    lfMount (const lfMount &other);

    lfMount &operator = (const lfMount &other);

    bool operator == (const lfMount& other);

    ~lfMount ();

    void SetName (const char *val, const char *lang = NULL);

    void AddCompat (const char *val);

    const char* const* GetCompats () const;

    bool Check ();

private:
    std::vector<char*> MountCompat;
#endif
};

C_TYPEDEF (struct, lfMount)


DEPRECATED LF_EXPORT lfMount *lf_mount_new ();

LF_EXPORT lfMount *lf_mount_create();

LF_EXPORT void lf_mount_destroy (lfMount *mount);

LF_EXPORT void lf_mount_copy (lfMount *dest, const lfMount *source);

LF_EXPORT cbool lf_mount_check (lfMount *mount);

LF_EXPORT void lf_mount_add_compat (lfMount *mount, const char *val);

LF_EXPORT const char* const* lf_mount_get_compats (lfMount *mount);

/*----------------------------------------------------------------------------*/

struct LF_EXPORT lfCamera
{
    lfMLstr Maker;
    lfMLstr Model;
    lfMLstr Variant;
    char *Mount;
    float CropFactor;
    int Score;

#ifdef __cplusplus

    lfCamera ();

    lfCamera (const lfCamera &other);

    ~lfCamera ();

    lfCamera &operator = (const lfCamera &other);

    void SetMaker (const char *val, const char *lang = NULL);

    void SetModel (const char *val, const char *lang = NULL);

    void SetVariant (const char *val, const char *lang = NULL);

    void SetMount (const char *val);

    bool Check ();
#endif
};

C_TYPEDEF (struct, lfCamera)


DEPRECATED LF_EXPORT lfCamera *lf_camera_new ();

LF_EXPORT lfCamera *lf_camera_create ();

LF_EXPORT void lf_camera_destroy (lfCamera *camera);

LF_EXPORT void lf_camera_copy (lfCamera *dest, const lfCamera *source);

LF_EXPORT cbool lf_camera_check (lfCamera *camera);

/*----------------------------------------------------------------------------*/

struct lfLensCalibAttributes
{    
    float CropFactor;
    float AspectRatio;

    #ifdef __cplusplus
    bool operator==(const lfLensCalibAttributes& other)
    {
        return CropFactor == other.CropFactor &&
               AspectRatio == other.AspectRatio;
    }
    #endif
};

C_TYPEDEF (struct, lfLensCalibAttributes)


enum lfDistortionModel
{
    LF_DIST_MODEL_NONE,
    LF_DIST_MODEL_POLY3,
    LF_DIST_MODEL_POLY5,
    LF_DIST_MODEL_PTLENS,
    LF_DIST_MODEL_ACM,
};

C_TYPEDEF (enum, lfDistortionModel)


struct lfLensCalibDistortion
{
    enum lfDistortionModel Model;
    float Focal;
    float RealFocal;
    cbool RealFocalMeasured;
    float Terms [5];
    lfLensCalibAttributes CalibAttr;
};

C_TYPEDEF (struct, lfLensCalibDistortion)


enum lfTCAModel
{
    LF_TCA_MODEL_NONE,
    LF_TCA_MODEL_LINEAR,
    LF_TCA_MODEL_POLY3,
    LF_TCA_MODEL_ACM
};

C_TYPEDEF (enum, lfTCAModel)


struct lfLensCalibTCA
{
    enum lfTCAModel Model;
    float Focal;
    float Terms [12];
    lfLensCalibAttributes CalibAttr;
};

C_TYPEDEF (struct, lfLensCalibTCA)


enum lfVignettingModel
{
    LF_VIGNETTING_MODEL_NONE,
    LF_VIGNETTING_MODEL_PA,
    LF_VIGNETTING_MODEL_ACM
};

C_TYPEDEF (enum, lfVignettingModel)


struct lfLensCalibVignetting
{
    enum lfVignettingModel Model;
    float Focal;
    float Aperture;
    float Distance;
    float Terms [3];
    lfLensCalibAttributes CalibAttr;
};

C_TYPEDEF (struct, lfLensCalibVignetting)


enum lfCropMode
{
    LF_NO_CROP,
    LF_CROP_RECTANGLE,
    LF_CROP_CIRCLE
};

C_TYPEDEF(enum, lfCropMode)


struct lfLensCalibCrop
{
    float Focal;
    enum lfCropMode CropMode;
    float Crop [4];
    lfLensCalibAttributes CalibAttr;
};

C_TYPEDEF (struct, lfLensCalibCrop)


struct lfLensCalibFov
{
    float Focal;
    float FieldOfView;
    lfLensCalibAttributes CalibAttr;
};

C_TYPEDEF (struct, lfLensCalibFov)


struct lfLensCalibrationSet
{
    lfLensCalibAttributes Attributes;

#ifdef __cplusplus
    lfLensCalibrationSet(lfLensCalibAttributes attributes) : Attributes(attributes) {}

    lfLensCalibrationSet(const lfLensCalibrationSet &other)
    {
        Attributes = other.Attributes;
        for (auto *cb : other.CalibDistortion)
            CalibDistortion.push_back(new lfLensCalibDistortion(*cb));
        for (auto *cb : other.CalibVignetting)
            CalibVignetting.push_back(new lfLensCalibVignetting(*cb));
        for (auto *cb : other.CalibTCA)
            CalibTCA.push_back(new lfLensCalibTCA(*cb));
        for (auto *cb : other.CalibCrop)
            CalibCrop.push_back(new lfLensCalibCrop(*cb));
        for (auto *cb : other.CalibFov)
            CalibFov.push_back(new lfLensCalibFov(*cb));
    }

    ~lfLensCalibrationSet()
    {
        for (auto cb : CalibDistortion)
            delete cb;
        for (auto cb : CalibVignetting)
            delete cb;
        for (auto cb : CalibTCA)
            delete cb;
        for (auto cb : CalibCrop)
            delete cb;
        for (auto cb : CalibFov)
            delete cb;
    }

    bool Empty() const
    {
        return CalibDistortion.empty() && CalibTCA.empty() && CalibVignetting.empty() &&
               CalibCrop.empty() && CalibFov.empty();
    }

    bool HasDistortion() const { return !CalibDistortion.empty(); }
    bool HasTCA() const { return !CalibTCA.empty(); }
    bool HasVignetting() const { return !CalibVignetting.empty(); }
    bool HasCrop() const { return !CalibCrop.empty(); }
    bool HasFov() const { return !CalibFov.empty(); }

  private:

    std::vector<lfLensCalibDistortion*> CalibDistortion;
    std::vector<lfLensCalibTCA*> CalibTCA;
    std::vector<lfLensCalibVignetting*> CalibVignetting;
    std::vector<lfLensCalibCrop*> CalibCrop;
    std::vector<lfLensCalibFov*> CalibFov;

    friend struct lfDatabase;
    friend struct lfLens;
#endif
};


struct lfParameter
{
    const char *Name;
    float Min;
    float Max;
    float Default;
};

C_TYPEDEF (struct, lfParameter)


enum lfLensType
{
    LF_UNKNOWN,
    LF_RECTILINEAR,
    LF_FISHEYE,
    LF_PANORAMIC,
    LF_EQUIRECTANGULAR,
    LF_FISHEYE_ORTHOGRAPHIC,
    LF_FISHEYE_STEREOGRAPHIC,
    LF_FISHEYE_EQUISOLID,
    LF_FISHEYE_THOBY
};

C_TYPEDEF (enum, lfLensType)


struct LF_EXPORT lfLens
{
    lfMLstr Maker;
    lfMLstr Model;
    float MinFocal;
    float MaxFocal;
    float MinAperture;
    float MaxAperture;
    DEPRECATED char **Mounts;
    lfLensType Type;
    float CenterX;
    float CenterY;
    DEPRECATED float CropFactor;
    DEPRECATED float AspectRatio;
    DEPRECATED lfLensCalibDistortion **CalibDistortion;
    DEPRECATED lfLensCalibTCA **CalibTCA;
    DEPRECATED lfLensCalibVignetting **CalibVignetting;
    DEPRECATED lfLensCalibCrop **CalibCrop;
    DEPRECATED lfLensCalibFov **CalibFov;
    int Score;

#ifdef __cplusplus

    lfLens ();

    lfLens (const lfLens &other);

    ~lfLens ();

    lfLens &operator = (const lfLens &other);

    void SetMaker (const char *val, const char *lang = NULL);

    void SetModel (const char *val, const char *lang = NULL);

    void AddMount (const char *val);

    void AddCalibDistortion (const lfLensCalibDistortion *lcd);

    DEPRECATED bool RemoveCalibDistortion (int idx);

    void AddCalibTCA (const lfLensCalibTCA *lctca);

    DEPRECATED bool RemoveCalibTCA (int idx);

    void AddCalibVignetting (const lfLensCalibVignetting *lcv);

    DEPRECATED bool RemoveCalibVignetting (int idx);

    void AddCalibCrop (const lfLensCalibCrop *lcc);

    DEPRECATED bool RemoveCalibCrop (int idx);

    DEPRECATED void AddCalibFov (const lfLensCalibFov *lcf);

    DEPRECATED bool RemoveCalibFov (int idx);

    void RemoveCalibrations();

    void GuessParameters ();

    bool Check ();

    static const char *GetDistortionModelDesc (
        lfDistortionModel model, const char **details, const lfParameter ***params);
    static const char *GetTCAModelDesc (
        lfTCAModel model, const char **details, const lfParameter ***params);

    static const char *GetVignettingModelDesc (
        lfVignettingModel model, const char **details, const lfParameter ***params);

    static const char *GetCropDesc (
        lfCropMode mode, const char **details, const lfParameter ***params);

    static const char *GetLensTypeDesc (lfLensType type, const char **details);

    DEPRECATED bool InterpolateDistortion (float focal, lfLensCalibDistortion &res) const;

    bool InterpolateDistortion (float crop, float focal, lfLensCalibDistortion &res) const;

    DEPRECATED bool InterpolateTCA (float focal, lfLensCalibTCA &res) const;

    bool InterpolateTCA (float crop, float focal, lfLensCalibTCA &res) const;

    DEPRECATED bool InterpolateVignetting (
        float focal, float aperture, float distance, lfLensCalibVignetting &res) const;

    bool InterpolateVignetting (
        float crop, float focal, float aperture, float distance, lfLensCalibVignetting &res) const;

    DEPRECATED bool InterpolateCrop (float focal, lfLensCalibCrop &res) const;

    bool InterpolateCrop (float crop, float focal, lfLensCalibCrop &res) const;

    DEPRECATED bool InterpolateFov (float focal, lfLensCalibFov &res) const;

    DEPRECATED bool InterpolateFov (float crop, float focal, lfLensCalibFov &res) const;

    int  AvailableModifications(float crop) const;

    const lfLensCalibrationSet* const* GetCalibrationSets() const;

    const char* const* GetMountNames() const;

    private:
        void UpdateLegacyCalibPointers();

        std::vector<lfLensCalibrationSet*> Calibrations;
        std::vector<char*> MountNames;

        lfLensCalibrationSet* GetClosestCalibrationSet(const float crop) const;
        lfLensCalibrationSet* GetCalibrationSetForAttributes(const lfLensCalibAttributes lcattr);

        friend struct lfDatabase;
#endif
};

C_TYPEDEF (struct, lfLens)


DEPRECATED LF_EXPORT lfLens *lf_lens_new ();

LF_EXPORT lfLens *lf_lens_create ();

LF_EXPORT void lf_lens_destroy (lfLens *lens);

LF_EXPORT void lf_lens_copy (lfLens *dest, const lfLens *source);

LF_EXPORT cbool lf_lens_check (lfLens *lens);

LF_EXPORT void lf_lens_guess_parameters (lfLens *lens);

LF_EXPORT void lf_lens_add_mount (lfLens *lens, const char *val);

LF_EXPORT const char* const* lf_lens_get_mount_names (const lfLens *lens);

LF_EXPORT const char *lf_get_distortion_model_desc (
    enum lfDistortionModel model, const char **details, const lfParameter ***params);

LF_EXPORT const char *lf_get_tca_model_desc (
    enum lfTCAModel model, const char **details, const lfParameter ***params);

LF_EXPORT const char *lf_get_vignetting_model_desc (
    enum lfVignettingModel model, const char **details, const lfParameter ***params);

LF_EXPORT const char *lf_get_crop_desc (
    enum lfCropMode mode, const char **details, const lfParameter ***params);

LF_EXPORT const char *lf_get_lens_type_desc (
    enum lfLensType type, const char **details);

LF_EXPORT cbool lf_lens_interpolate_distortion (const lfLens *lens, float crop, float focal,
    lfLensCalibDistortion *res);

LF_EXPORT cbool lf_lens_interpolate_tca (const lfLens *lens, float crop, float focal, lfLensCalibTCA *res);

LF_EXPORT cbool lf_lens_interpolate_vignetting (const lfLens *lens, float crop, float focal, float aperture,
    float distance, lfLensCalibVignetting *res);

LF_EXPORT cbool lf_lens_interpolate_crop (const lfLens *lens, float crop, float focal,
    lfLensCalibCrop *res);

DEPRECATED LF_EXPORT cbool lf_lens_interpolate_fov (const lfLens *lens, float crop, float focal,
    lfLensCalibFov *res);

LF_EXPORT void lf_lens_add_calib_distortion (lfLens *lens, const lfLensCalibDistortion *dc);

DEPRECATED LF_EXPORT cbool lf_lens_remove_calib_distortion (lfLens *lens, int idx);

LF_EXPORT void lf_lens_add_calib_tca (lfLens *lens, const lfLensCalibTCA *tcac);

DEPRECATED LF_EXPORT cbool lf_lens_remove_calib_tca (lfLens *lens, int idx);

LF_EXPORT void lf_lens_add_calib_vignetting (lfLens *lens, const lfLensCalibVignetting *vc);

DEPRECATED LF_EXPORT cbool lf_lens_remove_calib_vignetting (lfLens *lens, int idx);

LF_EXPORT void lf_lens_add_calib_crop (lfLens *lens, const lfLensCalibCrop *cc);

DEPRECATED LF_EXPORT cbool lf_lens_remove_calib_crop (lfLens *lens, int idx);

DEPRECATED LF_EXPORT void lf_lens_add_calib_fov (lfLens *lens, const lfLensCalibFov *cf);

DEPRECATED LF_EXPORT cbool lf_lens_remove_calib_fov (lfLens *lens, int idx);

LF_EXPORT void lf_lens_remove_calibrations (lfLens *lens);

LF_EXPORT int lf_lens_available_modifications (lfLens *lens, float crop);

/*----------------------------------------------------------------------------*/

enum
{
    LF_SEARCH_LOOSE = 1,
    LF_SEARCH_SORT_AND_UNIQUIFY = 2
};

struct LF_EXPORT lfDatabase
{
    DEPRECATED char *HomeDataDir;
    DEPRECATED char *UserUpdatesDir;

#ifdef __cplusplus

    static const char *const UserLocation;
    static const char *const UserUpdatesLocation;
    static const char *const SystemLocation;
    static const char *const SystemUpdatesLocation;

    lfDatabase ();
    ~lfDatabase ();

    DEPRECATED static lfDatabase *Create ();

    DEPRECATED void Destroy ();

     static long int ReadTimestamp (const char *dirname);

     DEPRECATED bool LoadDirectory (const char *dirname);

    lfError Load ();

    lfError Load (const char *pathname);

    lfError Load (const char *xml, size_t data_size);

    lfError Save (const char *filename) const;

    DEPRECATED char *Save () const;

    lfError Save (char*& xml, size_t& data_size) const;

    const lfCamera **FindCameras (const char *maker, const char *model) const;

    const lfCamera **FindCamerasExt (const char *maker, const char *model,
                                     int sflags = 0) const;

    const lfCamera *const *GetCameras ();

    const lfLens **FindLenses (const lfCamera *camera, const char *maker,
                               const char *model, int sflags = 0) const;

    const lfLens *const *GetLenses ();

    const lfMount *FindMount (const char *mount) const;

    const char *MountName (const char *mount) const;

    const lfMount *const *GetMounts ();

    void AddMount (lfMount *mount);

    void AddCamera (lfCamera *camera);

    void AddLens (lfLens *lens);

private:

    int MatchScore (const lfLens *pattern, const lfLens *match, const lfCamera *camera,
                                void *fuzzycmp, const char* const* compat_mounts) const;

    lfError Load (const char *errcontext, const char *data, size_t data_size);

    std::vector<lfMount*>  Mounts;
    std::vector<lfCamera*> Cameras;
    std::vector<lfLens*>   Lenses;
#endif
};

C_TYPEDEF (struct, lfDatabase)


extern const char* const lf_db_system_location;
extern const char* const lf_db_system_updates_location;
extern const char* const lf_db_user_location;
extern const char* const lf_db_user_updates_location;

DEPRECATED LF_EXPORT lfDatabase *lf_db_new (void);

LF_EXPORT lfDatabase *lf_db_create (void);

LF_EXPORT void lf_db_destroy (lfDatabase *db);

LF_EXPORT long int lf_db_read_timestamp (const char *dirname);

LF_EXPORT lfError lf_db_load (lfDatabase *db);

DEPRECATED LF_EXPORT lfError lf_db_load_file (lfDatabase *db, const char *filename);

DEPRECATED LF_EXPORT cbool lf_db_load_directory (lfDatabase *db, const char *dirname);

LF_EXPORT lfError lf_db_load_path (lfDatabase *db, const char *pathname);

DEPRECATED LF_EXPORT lfError lf_db_load_data (lfDatabase *db, const char *errcontext, const char *data, size_t data_size);

LF_EXPORT lfError lf_db_load_str (lfDatabase *db, const char *xml, size_t data_size);

LF_EXPORT lfError lf_db_save_all (const lfDatabase *db, const char *filename);

LF_EXPORT lfError lf_db_save_str (const lfDatabase *db, char **xml, size_t* data_size);

LF_EXPORT const lfCamera **lf_db_find_cameras (
    const lfDatabase *db, const char *maker, const char *model);

LF_EXPORT const lfCamera **lf_db_find_cameras_ext (
    const lfDatabase *db, const char *maker, const char *model, int sflags);

LF_EXPORT const lfCamera *const *lf_db_get_cameras (lfDatabase *db);

DEPRECATED LF_EXPORT const lfLens **lf_db_find_lenses_hd (
    const lfDatabase *db, const lfCamera *camera, const char *maker,
    const char *lens, int sflags);

LF_EXPORT const lfLens **lf_db_find_lenses (
    const lfDatabase *db, const lfCamera *camera,
    const char *maker, const char *lens, int sflags);

LF_EXPORT const lfLens *const *lf_db_get_lenses (lfDatabase *db);

LF_EXPORT const lfMount *lf_db_find_mount (const lfDatabase *db, const char *mount);

LF_EXPORT const char *lf_db_mount_name (const lfDatabase *db, const char *mount);

LF_EXPORT const lfMount *const *lf_db_get_mounts (lfDatabase *db);

/*----------------------------------------------------------------------------*/

enum
{
    LF_MODIFY_TCA         = 0x00000001,
    LF_MODIFY_VIGNETTING  = 0x00000002,
    /* Value 0x00000004 is deprecated. */
    LF_MODIFY_DISTORTION  = 0x00000008,
    LF_MODIFY_GEOMETRY    = 0x00000010,
    LF_MODIFY_SCALE       = 0x00000020,
    LF_MODIFY_PERSPECTIVE = 0x00000040,
    LF_MODIFY_ALL         = ~0
};

enum lfPixelFormat
{
    LF_PF_U8,
    LF_PF_U16,
    LF_PF_U32,
    LF_PF_F32,
    LF_PF_F64
};

C_TYPEDEF (enum, lfPixelFormat)


enum lfComponentRole
{
    LF_CR_END = 0,
    LF_CR_NEXT,
    LF_CR_UNKNOWN,
    LF_CR_INTENSITY,
    LF_CR_RED,
    LF_CR_GREEN,
    LF_CR_BLUE
};

C_TYPEDEF (enum, lfComponentRole)


#define LF_CR_1(a)              (LF_CR_ ## a)

#define LF_CR_2(a,b)            ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4))

#define LF_CR_3(a,b,c)          ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4) | \
                                 ((LF_CR_ ## c) << 8))

#define LF_CR_4(a,b,c,d)        ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4) | \
                                 ((LF_CR_ ## c) << 8) | ((LF_CR_ ## d) << 12))

#define LF_CR_5(a,b,c,d,e)      ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4) | \
                                 ((LF_CR_ ## c) << 8) | ((LF_CR_ ## d) << 12) | \
                                 ((LF_CR_ ## e) << 16))

#define LF_CR_6(a,b,c,d,e,f)    ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4) | \
                                 ((LF_CR_ ## c) << 8) | ((LF_CR_ ## d) << 12) | \
                                 ((LF_CR_ ## e) << 16) | ((LF_CR_ ## f) << 20))

#define LF_CR_7(a,b,c,d,e,f,g)   ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4) | \
                                 ((LF_CR_ ## c) << 8) | ((LF_CR_ ## d) << 12) | \
                                 ((LF_CR_ ## e) << 16) | ((LF_CR_ ## f) << 20) | \
                                 ((LF_CR_ ## g) << 24))

#define LF_CR_8(a,b,c,d,e,f,g,h) ((LF_CR_ ## a) | ((LF_CR_ ## b) << 4) | \
                                 ((LF_CR_ ## c) << 8) | ((LF_CR_ ## d) << 12) | \
                                 ((LF_CR_ ## e) << 16) | ((LF_CR_ ## f) << 20) | \
                                 ((LF_CR_ ## g) << 24) | ((LF_CR_ ## h) << 28))

// @cond



// @endcond

#ifdef __cplusplus
}
#endif

struct LF_EXPORT lfModifier
{
#ifdef __cplusplus

    DEPRECATED lfModifier (const lfLens *lens, float crop, int width, int height);

    DEPRECATED static lfModifier *Create (const lfLens *lens, float crop, int width, int height);

    DEPRECATED int Initialize (
        const lfLens *lens, lfPixelFormat format, float focal, float aperture,
        float distance, float scale, lfLensType targeom, int flags, bool reverse);

    DEPRECATED void Destroy ();

    lfModifier (const lfLens *lens, float imgfocal, float imgcrop, int imgwidth, int imgheight, lfPixelFormat pixel_format, bool reverse = false);

    ~lfModifier ();

    int EnableDistortionCorrection (const lfLensCalibDistortion& lcd);
    int EnableDistortionCorrection ();

    int EnableTCACorrection (const lfLensCalibTCA& lctca);
    int EnableTCACorrection ();

    int EnableVignettingCorrection (const lfLensCalibVignetting& lcv);
    int EnableVignettingCorrection (float aperture, float distance);

    int EnableProjectionTransform (lfLensType target_projection);

    int EnableScaling (float scale);

    int EnablePerspectiveCorrection (float *x, float *y, int count, float d);

    int GetModFlags ();

    float GetAutoScale (bool reverse);

    bool ApplyColorModification (void *pixels, float x, float y, int width, int height,
                                 int comp_role, int row_stride) const;

    bool ApplyGeometryDistortion (float xu, float yu, int width, int height,
                                  float *res) const;

    bool ApplySubpixelDistortion (float xu, float yu, int width, int height,
                                  float *res) const;

    bool ApplySubpixelGeometryDistortion (float xu, float yu, int width, int height,
                                          float *res) const;

private:

    struct lfCallbackData
    {
        virtual  ~lfCallbackData() {}
        int priority;

        bool operator<(const lfCallbackData& c) const { return priority < c.priority; }
        bool operator>(const lfCallbackData& c) const { return priority > c.priority; }
    };

    struct lfCallBackDataPtrComp
    {
        bool operator () (const lfCallbackData* lhs, const lfCallbackData* rhs) const {
            return lhs->priority < rhs->priority;
        }
    };

    typedef void (*lfModifySubpixCoordFunc) (void *data, float *iocoord, int count);

    typedef void (*lfModifyColorFunc) (void *data, float x, float y,
                                       void *pixels, int comp_role, int count);

    typedef void (*lfModifyCoordFunc) (void *data, float *iocoord, int count);

    struct lfSubpixelCallback : public lfCallbackData
    {
        lfModifySubpixCoordFunc callback;
    };

    struct lfSubpixTCACallback : public lfSubpixelCallback
    {
        float terms [12];
    };

    struct lfCoordCallback : public lfCallbackData
    {
        lfModifyCoordFunc callback;
    };

    struct lfCoordDistCallbackData : public lfCoordCallback
    {
        float terms [5];
    };

    struct lfCoordScaleCallbackData : public lfCoordCallback
    {
        float scale_factor;
    };

    struct lfCoordGeomCallbackData : public lfCoordCallback
    {
    };

    struct lfCoordPerspCallbackData : public lfCoordCallback
    {
        float A [3][3];
        float delta_a, delta_b;
    };

    struct lfColorCallback : public lfCallbackData
    {
        lfModifyColorFunc callback;
    };

    struct lfColorVignCallbackData : public lfColorCallback
    {
        float norm_scale;
        float terms [3];
    };

    std::multiset<lfSubpixelCallback*, lfCallBackDataPtrComp> SubpixelCallbacks;
    std::multiset<lfColorCallback*, lfCallBackDataPtrComp> ColorCallbacks;
    std::multiset<lfCoordCallback*, lfCallBackDataPtrComp> CoordCallbacks;

    // A test point in the autoscale algorithm
    typedef struct { float angle, dist; } lfPoint;

    void AddSubpixTCACallback (const lfLensCalibTCA& lcd, lfModifySubpixCoordFunc func, int priority);
    void AddCoordGeomCallback (lfModifyCoordFunc func, int priority);
    void AddCoordDistCallback (const lfLensCalibDistortion& lcd, lfModifyCoordFunc func, int priority);
    void AddColorVignCallback (const lfLensCalibVignetting& lcv, lfModifyColorFunc func, int priority);

    double AutoscaleResidualDistance (float *coord) const;
    float GetTransformedDistance (lfPoint point) const;

    static void ModifyCoord_TCA_Linear (void *data, float *iocoord, int count);
    static void ModifyCoord_UnTCA_Poly3 (void *data, float *iocoord, int count);
    static void ModifyCoord_TCA_Poly3 (void *data, float *iocoord, int count);
    static void ModifyCoord_TCA_ACM (void *data, float *iocoord, int count);

    static void ModifyCoord_UnDist_Poly3 (void *data, float *iocoord, int count);
    static void ModifyCoord_Dist_Poly3 (void *data, float *iocoord, int count);
#ifdef VECTORIZATION_SSE
    static void ModifyCoord_Dist_Poly3_SSE (void *data, float *iocoord, int count);
#endif
    static void ModifyCoord_UnDist_Poly5 (void *data, float *iocoord, int count);
    static void ModifyCoord_Dist_Poly5 (void *data, float *iocoord, int count);
    static void ModifyCoord_UnDist_PTLens (void *data, float *iocoord, int count);
    static void ModifyCoord_Dist_PTLens (void *data, float *iocoord, int count);
#ifdef VECTORIZATION_SSE
    static void ModifyCoord_UnDist_PTLens_SSE (void *data, float *iocoord, int count);
    static void ModifyCoord_Dist_PTLens_SSE (void *data, float *iocoord, int count);
#endif
    static void ModifyCoord_Dist_ACM (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_FishEye_Rect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Panoramic_Rect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_Rect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Rect_FishEye (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Panoramic_FishEye (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_FishEye (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Rect_Panoramic (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_FishEye_Panoramic (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_Panoramic (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Rect_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_FishEye_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Panoramic_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Orthographic_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_Orthographic (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Stereographic_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_Stereographic (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Equisolid_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_Equisolid (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_Thoby_ERect (void *data, float *iocoord, int count);
    static void ModifyCoord_Geom_ERect_Thoby (void *data, float *iocoord, int count);
    static void ModifyCoord_Perspective_Correction (void *data, float *iocoord, int count);
    static void ModifyCoord_Perspective_Distortion (void *data, float *iocoord, int count);
#ifdef VECTORIZATION_SSE
    static void ModifyColor_DeVignetting_PA_SSE (
      void *data, float _x, float _y, lf_f32 *pixels, int comp_role, int count);
#endif
#ifdef VECTORIZATION_SSE2
    static void ModifyColor_DeVignetting_PA_SSE2 (
      void *data, float _x, float _y, lf_u16 *pixels, int comp_role, int count);
#endif

    template<typename T> static void ModifyColor_Vignetting_PA (
        void *data, float x, float y, T *rgb, int comp_role, int count);
    template<typename T> static void ModifyColor_DeVignetting_PA (
        void *data, float x, float y, T *rgb, int comp_role, int count);

    static void ModifyCoord_Scale (void *data, float *iocoord, int count);
#endif
    double Width, Height;
    double Crop;
    double Focal;
    double RealFocal;
    double CenterX, CenterY;
    double NormScale, NormUnScale;

    cbool Reverse;

    lfPixelFormat PixelFormat;

    const lfLens* Lens;

    int EnabledMods;
};

#ifdef __cplusplus
extern "C" {
#endif

C_TYPEDEF (struct, lfModifier)


DEPRECATED LF_EXPORT lfModifier *lf_modifier_new (
    const lfLens *lens, float crop, int width, int height);

LF_EXPORT lfModifier *lf_modifier_create (
    const lfLens* lens, float imgfocal, float imgcrop, int imgwidth, int imgheight, lfPixelFormat pixel_format, bool reverse);

LF_EXPORT void lf_modifier_destroy (lfModifier *modifier);

DEPRECATED LF_EXPORT int lf_modifier_initialize (
    lfModifier *modifier, const lfLens *lens, lfPixelFormat format,
    float focal, float aperture, float distance, float scale,
    lfLensType targeom, int flags, cbool reverse);

LF_EXPORT int lf_modifier_enable_scaling (lfModifier *modifier, float scale);

LF_EXPORT int lf_modifier_enable_distortion_correction (lfModifier *modifier);

LF_EXPORT int lf_modifier_enable_tca_correction (lfModifier *modifier);

LF_EXPORT int lf_modifier_enable_vignetting_correction (
    lfModifier *modifier, float aperture, float distance);

LF_EXPORT cbool lf_modifier_enable_projection_transform (
    lfModifier *modifier, lfLensType target_projection);

LF_EXPORT int lf_modifier_enable_perspective_correction (
    lfModifier *modifier, float *x, float *y, int count, float d);

LF_EXPORT int lf_modifier_get_mod_flags (lfModifier *modifier);

LF_EXPORT float lf_modifier_get_auto_scale (
    lfModifier *modifier, cbool reverse);

LF_EXPORT cbool lf_modifier_apply_subpixel_distortion (
    lfModifier *modifier, float xu, float yu, int width, int height, float *res);

LF_EXPORT cbool lf_modifier_apply_color_modification (
    lfModifier *modifier, void *pixels, float x, float y, int width, int height,
    int comp_role, int row_stride);

LF_EXPORT cbool lf_modifier_apply_geometry_distortion (
    lfModifier *modifier, float xu, float yu, int width, int height, float *res);

LF_EXPORT cbool lf_modifier_apply_subpixel_geometry_distortion (
    lfModifier *modifier, float xu, float yu, int width, int height, float *res);

#undef cbool

#ifdef __cplusplus
}
#endif

#endif /* __LENSFUN_H__ */