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        99
#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)
 
 
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)
 
 
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);
 
    void AddCalibTCA (const lfLensCalibTCA *lctca);
 
    void AddCalibVignetting (const lfLensCalibVignetting *lcv);
 
    void AddCalibCrop (const lfLensCalibCrop *lcc);
 
    DEPRECATED void AddCalibFov (const lfLensCalibFov *lcf);
 
    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);
 
    bool InterpolateDistortion (float crop, float focal, lfLensCalibDistortion &res) const;
 
    bool InterpolateTCA (float crop, float focal, lfLensCalibTCA &res) const;
 
    bool InterpolateVignetting (
        float crop, float focal, float aperture, float distance, lfLensCalibVignetting &res) const;
 
    bool InterpolateCrop (float crop, float focal, lfLensCalibCrop &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)
 
 
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);
 
LF_EXPORT void lf_lens_add_calib_distortion (lfLens *lens, const lfLensCalibDistortion *dc);
 
LF_EXPORT void lf_lens_add_calib_tca (lfLens *lens, const lfLensCalibTCA *tcac);
 
LF_EXPORT void lf_lens_add_calib_vignetting (lfLens *lens, const lfLensCalibVignetting *vc);
 
LF_EXPORT void lf_lens_add_calib_crop (lfLens *lens, const lfLensCalibCrop *cc);
 
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 ();
 
     static long int ReadTimestamp (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;
 
    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;
 
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);
 
LF_EXPORT lfError lf_db_load_path (lfDatabase *db, const char *pathname);
 
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);
 
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
    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)
 
 
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);
 
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__ */