sl_oc::tools Namespace Reference

Classes
class	CSimpleIniTempl
struct	SI_GenericCase
struct	SI_GenericNoCase
class	SI_ConvertA
class	SI_ConvertW
struct	SI_NoCase
class	ConfManager
class	StereoSgbmPar
	The StereoSgbmPar class is used to store/retrieve the stereo matching parameters. More...
class	StopWatch
	Stop Timer used to measure time intervals. More...

Typedefs
typedef unsigned int	UTF32
typedef unsigned short	UTF16
typedef unsigned char	UTF8
typedef CSimpleIniTempl< char, SI_NoCase< char >, SI_ConvertA< char > >	CSimpleIniA
typedef CSimpleIniTempl< char, SI_Case< char >, SI_ConvertA< char > >	CSimpleIniCaseA
typedef CSimpleIniTempl< UChar, SI_NoCase< UChar >, SI_ConvertW< UChar > >	CSimpleIniW
typedef CSimpleIniTempl< UChar, SI_Case< UChar >, SI_ConvertW< UChar > >	CSimpleIniCaseW

Enumerations
enum	SI_Error {   SI_OK = 0 , SI_UPDATED = 1 , SI_INSERTED = 2 , SI_FAIL = -1 ,   SI_NOMEM = -2 , SI_FILE = -3 }
enum	ConversionResult { conversionOK , sourceExhausted , targetExhausted , sourceIllegal }
enum	ConversionFlags { strictConversion = 0 , lenientConversion }

Functions
ConversionResult	ConvertUTF8toUTF16 (const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF16 **targetStart, UTF16 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF16toUTF8 (const UTF16 **sourceStart, const UTF16 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF8toUTF32 (const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF32toUTF8 (const UTF32 **sourceStart, const UTF32 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF16toUTF32 (const UTF16 **sourceStart, const UTF16 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)
ConversionResult	ConvertUTF32toUTF16 (const UTF32 **sourceStart, const UTF32 *sourceEnd, UTF16 **targetStart, UTF16 *targetEnd, ConversionFlags flags)
Boolean	isLegalUTF8Sequence (const UTF8 *source, const UTF8 *sourceEnd)
std::vector< std::string > &	split (const std::string &s, char delim, std::vector< std::string > &elems)
std::vector< std::string >	split (const std::string &s, char delim)
bool	checkFile (std::string path)
bool	downloadCalibrationFile (unsigned int serial_number, std::string &calibration_file)
bool	initCalibration (std::string calibration_file, cv::Size2i image_size, cv::Mat &map_left_x, cv::Mat &map_left_y, cv::Mat &map_right_x, cv::Mat &map_right_y, cv::Mat &cameraMatrix_left, cv::Mat &cameraMatrix_right, double *baseline=nullptr)
void	showImage (std::string name, cv::UMat &img, sl_oc::video::RESOLUTION res, bool change_name=true, std::string info="")
	Rescale the OpenCV T-API images [cv::UMat] according to the selected resolution to better display them on screen and show. More...
void	showImage (std::string name, cv::Mat &img, sl_oc::video::RESOLUTION res, bool change_name=true, std::string info="")
	Rescale the OpenCV images [cv::Mat] according to the selected resolution to better display them on screen and show. More...

Variables
const std::string	STEREO_PAR_FILENAME = "zed_oc_stereo.yaml"
	STEREO_PAR_FILENAME default stereo parameter configuration file. More...

Typedef Documentation

CSimpleIniA

typedef CSimpleIniTempl<char,SI_NoCase<char>, SI_ConvertA<char> > sl_oc::tools::CSimpleIniA

Definition at line 3935 of file calibration.hpp.

CSimpleIniCaseA

typedef CSimpleIniTempl<char,SI_Case<char>, SI_ConvertA<char> > sl_oc::tools::CSimpleIniCaseA

Definition at line 3937 of file calibration.hpp.

CSimpleIniCaseW

typedef CSimpleIniTempl< wchar_t, SI_Case< wchar_t >, SI_ConvertW< wchar_t > > sl_oc::tools::CSimpleIniCaseW

Definition at line 3943 of file calibration.hpp.

CSimpleIniW

typedef CSimpleIniTempl< wchar_t, SI_NoCase< wchar_t >, SI_ConvertW< wchar_t > > sl_oc::tools::CSimpleIniW

Definition at line 3941 of file calibration.hpp.

UTF16

typedef unsigned short sl_oc::tools::UTF16

Definition at line 2769 of file calibration.hpp.

UTF32

typedef unsigned int sl_oc::tools::UTF32

Definition at line 2768 of file calibration.hpp.

UTF8

typedef unsigned char sl_oc::tools::UTF8

Definition at line 2770 of file calibration.hpp.

Enumeration Type Documentation

ConversionFlags

enum sl_oc::tools::ConversionFlags

Enumerator
strictConversion
lenientConversion

Definition at line 2786 of file calibration.hpp.

             {
    strictConversion = 0,
    lenientConversion
} ConversionFlags;

ConversionResult

enum sl_oc::tools::ConversionResult

Enumerator
conversionOK
sourceExhausted
targetExhausted
sourceIllegal

Definition at line 2779 of file calibration.hpp.

             {
    conversionOK, /* conversion successful */
    sourceExhausted, /* partial character in source, but hit end */
    targetExhausted, /* insuff. room in target for conversion */
    sourceIllegal /* source sequence is illegal/malformed */
} ConversionResult;

SI_Error

enum sl_oc::tools::SI_Error

Enumerator
SI_OK	No error.
SI_UPDATED	An existing value was updated.
SI_INSERTED	A new value was inserted.
SI_FAIL	Generic failure.
SI_NOMEM	Out of memory error.
SI_FILE	File error (see errno for detail error)

Definition at line 93 of file calibration.hpp.

              {
    SI_OK = 0, 
    SI_UPDATED = 1, 
    SI_INSERTED = 2, 
 
    // note: test for any error with (retval < 0)
    SI_FAIL = -1, 
    SI_NOMEM = -2, 
    SI_FILE = -3 
};

Function Documentation

checkFile()

bool sl_oc::tools::checkFile

(

std::string

path

)

Definition at line 4048 of file calibration.hpp.

                               {
    std::ifstream f(path.c_str());
    return f.good();
}

Referenced by downloadCalibrationFile(), and initCalibration().

ConvertUTF16toUTF32()

ConversionResult sl_oc::tools::ConvertUTF16toUTF32	(	const UTF16 **	sourceStart,
		const UTF16 *	sourceEnd,
		UTF32 **	targetStart,
		UTF32 *	targetEnd,
		ConversionFlags	flags
	)

Definition at line 2893 of file calibration.hpp.

                                                                          {
        ConversionResult result = conversionOK;
        const UTF16* source = *sourceStart;
        UTF32* target = *targetStart;
        UTF32 ch, ch2;
        while (source < sourceEnd) {
            const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
            ch = *source++;
            /* If we have a surrogate pair, convert to UTF32 first. */
            if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
                /* If the 16 bits following the high surrogate are in the source buffer... */
                if (source < sourceEnd) {
                    ch2 = *source;
                    /* If it's a low surrogate, convert to UTF32. */
                    if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
                        ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
                                + (ch2 - UNI_SUR_LOW_START) + halfBase;
                        ++source;
                    } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
                        --source; /* return to the illegal value itself */
                        result = sourceIllegal;
                        break;
                    }
                } else { /* We don't have the 16 bits following the high surrogate. */
                    --source; /* return to the high surrogate */
                    result = sourceExhausted;
                    break;
                }
            } else if (flags == strictConversion) {
                /* UTF-16 surrogate values are illegal in UTF-32 */
                if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
                    --source; /* return to the illegal value itself */
                    result = sourceIllegal;
                    break;
                }
            }
            if (target >= targetEnd) {
                source = oldSource; /* Back up source pointer! */
                result = targetExhausted;
                break;
            }
            *target++ = ch;
        }
        *sourceStart = source;
        *targetStart = target;
#ifdef CVTUTF_DEBUG
        if (result == sourceIllegal) {
            fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
            fflush(stderr);
        }
#endif
        return result;
    }

References conversionOK, sourceExhausted, sourceIllegal, strictConversion, and targetExhausted.

ConvertUTF16toUTF8()

ConversionResult sl_oc::tools::ConvertUTF16toUTF8	(	const UTF16 **	sourceStart,
		const UTF16 *	sourceEnd,
		UTF8 **	targetStart,
		UTF8 *	targetEnd,
		ConversionFlags	flags
	)

Definition at line 2998 of file calibration.hpp.

                                                                        {
        ConversionResult result = conversionOK;
        const UTF16* source = *sourceStart;
        UTF8* target = *targetStart;
        while (source < sourceEnd) {
            UTF32 ch;
            unsigned short bytesToWrite = 0;
            const UTF32 byteMask = 0xBF;
            const UTF32 byteMark = 0x80;
            const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
            ch = *source++;
            /* If we have a surrogate pair, convert to UTF32 first. */
            if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
                /* If the 16 bits following the high surrogate are in the source buffer... */
                if (source < sourceEnd) {
                    UTF32 ch2 = *source;
                    /* If it's a low surrogate, convert to UTF32. */
                    if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
                        ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
                                + (ch2 - UNI_SUR_LOW_START) + halfBase;
                        ++source;
                    } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
                        --source; /* return to the illegal value itself */
                        result = sourceIllegal;
                        break;
                    }
                } else { /* We don't have the 16 bits following the high surrogate. */
                    --source; /* return to the high surrogate */
                    result = sourceExhausted;
                    break;
                }
            } else if (flags == strictConversion) {
                /* UTF-16 surrogate values are illegal in UTF-32 */
                if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
                    --source; /* return to the illegal value itself */
                    result = sourceIllegal;
                    break;
                }
            }
            /* Figure out how many bytes the result will require */
            if (ch < (UTF32) 0x80) {
                bytesToWrite = 1;
            } else if (ch < (UTF32) 0x800) {
                bytesToWrite = 2;
            } else if (ch < (UTF32) 0x10000) {
                bytesToWrite = 3;
            } else if (ch < (UTF32) 0x110000) {
                bytesToWrite = 4;
            } else {
                bytesToWrite = 3;
                ch = UNI_REPLACEMENT_CHAR;
            }
 
            target += bytesToWrite;
            if (target > targetEnd) {
                source = oldSource; /* Back up source pointer! */
                target -= bytesToWrite;
                result = targetExhausted;
                break;
            }
            switch (bytesToWrite) { /* note: everything falls through. */
                case 4: *--target = (UTF8) ((ch | byteMark) & byteMask);
                    ch >>= 6;
                case 3: *--target = (UTF8) ((ch | byteMark) & byteMask);
                    ch >>= 6;
                case 2: *--target = (UTF8) ((ch | byteMark) & byteMask);
                    ch >>= 6;
                case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
            }
            target += bytesToWrite;
        }
        *sourceStart = source;
        *targetStart = target;
        return result;
    }

References conversionOK, sourceExhausted, sourceIllegal, strictConversion, and targetExhausted.

Referenced by sl_oc::tools::SI_ConvertW< SI_CHAR >::ConvertToStore().

ConvertUTF32toUTF16()

ConversionResult sl_oc::tools::ConvertUTF32toUTF16	(	const UTF32 **	sourceStart,
		const UTF32 *	sourceEnd,
		UTF16 **	targetStart,
		UTF16 *	targetEnd,
		ConversionFlags	flags
	)

Definition at line 2842 of file calibration.hpp.

                                                                          {
        ConversionResult result = conversionOK;
        const UTF32* source = *sourceStart;
        UTF16* target = *targetStart;
        while (source < sourceEnd) {
            UTF32 ch;
            if (target >= targetEnd) {
                result = targetExhausted;
                break;
            }
            ch = *source++;
            if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
                /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
                if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
                    if (flags == strictConversion) {
                        --source; /* return to the illegal value itself */
                        result = sourceIllegal;
                        break;
                    } else {
                        *target++ = UNI_REPLACEMENT_CHAR;
                    }
                } else {
                    *target++ = (UTF16) ch; /* normal case */
                }
            } else if (ch > UNI_MAX_LEGAL_UTF32) {
                if (flags == strictConversion) {
                    result = sourceIllegal;
                } else {
                    *target++ = UNI_REPLACEMENT_CHAR;
                }
            } else {
                /* target is a character in range 0xFFFF - 0x10FFFF. */
                if (target + 1 >= targetEnd) {
                    --source; /* Back up source pointer! */
                    result = targetExhausted;
                    break;
                }
                ch -= halfBase;
                *target++ = (UTF16) ((ch >> halfShift) + UNI_SUR_HIGH_START);
                *target++ = (UTF16) ((ch & halfMask) + UNI_SUR_LOW_START);
            }
        }
        *sourceStart = source;
        *targetStart = target;
        return result;
    }

References conversionOK, sourceIllegal, strictConversion, and targetExhausted.

ConvertUTF32toUTF8()

ConversionResult sl_oc::tools::ConvertUTF32toUTF8	(	const UTF32 **	sourceStart,
		const UTF32 *	sourceEnd,
		UTF8 **	targetStart,
		UTF8 *	targetEnd,
		ConversionFlags	flags
	)

Definition at line 3215 of file calibration.hpp.

                                                                        {
        ConversionResult result = conversionOK;
        const UTF32* source = *sourceStart;
        UTF8* target = *targetStart;
        while (source < sourceEnd) {
            UTF32 ch;
            unsigned short bytesToWrite = 0;
            const UTF32 byteMask = 0xBF;
            const UTF32 byteMark = 0x80;
            ch = *source++;
            if (flags == strictConversion) {
                /* UTF-16 surrogate values are illegal in UTF-32 */
                if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
                    --source; /* return to the illegal value itself */
                    result = sourceIllegal;
                    break;
                }
            }
            /*
             * Figure out how many bytes the result will require. Turn any
             * illegally large UTF32 things (> Plane 17) into replacement chars.
             */
            if (ch < (UTF32) 0x80) {
                bytesToWrite = 1;
            } else if (ch < (UTF32) 0x800) {
                bytesToWrite = 2;
            } else if (ch < (UTF32) 0x10000) {
                bytesToWrite = 3;
            } else if (ch <= UNI_MAX_LEGAL_UTF32) {
                bytesToWrite = 4;
            } else {
                bytesToWrite = 3;
                ch = UNI_REPLACEMENT_CHAR;
                result = sourceIllegal;
            }
 
            target += bytesToWrite;
            if (target > targetEnd) {
                --source; /* Back up source pointer! */
                target -= bytesToWrite;
                result = targetExhausted;
                break;
            }
            switch (bytesToWrite) { /* note: everything falls through. */
                case 4: *--target = (UTF8) ((ch | byteMark) & byteMask);
                    ch >>= 6;
                case 3: *--target = (UTF8) ((ch | byteMark) & byteMask);
                    ch >>= 6;
                case 2: *--target = (UTF8) ((ch | byteMark) & byteMask);
                    ch >>= 6;
                case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
            }
            target += bytesToWrite;
        }
        *sourceStart = source;
        *targetStart = target;
        return result;
    }

References conversionOK, sourceIllegal, strictConversion, and targetExhausted.

Referenced by sl_oc::tools::SI_ConvertW< SI_CHAR >::ConvertToStore().

ConvertUTF8toUTF16()

ConversionResult sl_oc::tools::ConvertUTF8toUTF16	(	const UTF8 **	sourceStart,
		const UTF8 *	sourceEnd,
		UTF16 **	targetStart,
		UTF16 *	targetEnd,
		ConversionFlags	flags
	)

Definition at line 3134 of file calibration.hpp.

                                                                          {
        ConversionResult result = conversionOK;
        const UTF8* source = *sourceStart;
        UTF16* target = *targetStart;
        while (source < sourceEnd) {
            UTF32 ch = 0;
            unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
            if (source + extraBytesToRead >= sourceEnd) {
                result = sourceExhausted;
                break;
            }
            /* Do this check whether lenient or strict */
            if (!isLegalUTF8(source, extraBytesToRead + 1)) {
                result = sourceIllegal;
                break;
            }
            /*
             * The cases all fall through. See "Note A" below.
             */
            switch (extraBytesToRead) {
                case 5: ch += *source++;
                    ch <<= 6; /* remember, illegal UTF-8 */
                case 4: ch += *source++;
                    ch <<= 6; /* remember, illegal UTF-8 */
                case 3: ch += *source++;
                    ch <<= 6;
                case 2: ch += *source++;
                    ch <<= 6;
                case 1: ch += *source++;
                    ch <<= 6;
                case 0: ch += *source++;
            }
            ch -= offsetsFromUTF8[extraBytesToRead];
 
            if (target >= targetEnd) {
                source -= (extraBytesToRead + 1); /* Back up source pointer! */
                result = targetExhausted;
                break;
            }
            if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
                /* UTF-16 surrogate values are illegal in UTF-32 */
                if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
                    if (flags == strictConversion) {
                        source -= (extraBytesToRead + 1); /* return to the illegal value itself */
                        result = sourceIllegal;
                        break;
                    } else {
                        *target++ = UNI_REPLACEMENT_CHAR;
                    }
                } else {
                    *target++ = (UTF16) ch; /* normal case */
                }
            } else if (ch > UNI_MAX_UTF16) {
                if (flags == strictConversion) {
                    result = sourceIllegal;
                    source -= (extraBytesToRead + 1); /* return to the start */
                    break; /* Bail out; shouldn't continue */
                } else {
                    *target++ = UNI_REPLACEMENT_CHAR;
                }
            } else {
                /* target is a character in range 0xFFFF - 0x10FFFF. */
                if (target + 1 >= targetEnd) {
                    source -= (extraBytesToRead + 1); /* Back up source pointer! */
                    result = targetExhausted;
                    break;
                }
                ch -= halfBase;
                *target++ = (UTF16) ((ch >> halfShift) + UNI_SUR_HIGH_START);
                *target++ = (UTF16) ((ch & halfMask) + UNI_SUR_LOW_START);
            }
        }
        *sourceStart = source;
        *targetStart = target;
        return result;
    }

References conversionOK, sourceExhausted, sourceIllegal, strictConversion, and targetExhausted.

Referenced by sl_oc::tools::SI_ConvertW< SI_CHAR >::ConvertFromStore().

ConvertUTF8toUTF32()

ConversionResult sl_oc::tools::ConvertUTF8toUTF32	(	const UTF8 **	sourceStart,
		const UTF8 *	sourceEnd,
		UTF32 **	targetStart,
		UTF32 *	targetEnd,
		ConversionFlags	flags
	)

Definition at line 3278 of file calibration.hpp.

                                                                          {
        ConversionResult result = conversionOK;
        const UTF8* source = *sourceStart;
        UTF32* target = *targetStart;
        while (source < sourceEnd) {
            UTF32 ch = 0;
            unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
            if (source + extraBytesToRead >= sourceEnd) {
                result = sourceExhausted;
                break;
            }
            /* Do this check whether lenient or strict */
            if (!isLegalUTF8(source, extraBytesToRead + 1)) {
                result = sourceIllegal;
                break;
            }
            /*
             * The cases all fall through. See "Note A" below.
             */
            switch (extraBytesToRead) {
                case 5: ch += *source++;
                    ch <<= 6;
                case 4: ch += *source++;
                    ch <<= 6;
                case 3: ch += *source++;
                    ch <<= 6;
                case 2: ch += *source++;
                    ch <<= 6;
                case 1: ch += *source++;
                    ch <<= 6;
                case 0: ch += *source++;
            }
            ch -= offsetsFromUTF8[extraBytesToRead];
 
            if (target >= targetEnd) {
                source -= (extraBytesToRead + 1); /* Back up the source pointer! */
                result = targetExhausted;
                break;
            }
            if (ch <= UNI_MAX_LEGAL_UTF32) {
                /*
                 * UTF-16 surrogate values are illegal in UTF-32, and anything
                 * over Plane 17 (> 0x10FFFF) is illegal.
                 */
                if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
                    if (flags == strictConversion) {
                        source -= (extraBytesToRead + 1); /* return to the illegal value itself */
                        result = sourceIllegal;
                        break;
                    } else {
                        *target++ = UNI_REPLACEMENT_CHAR;
                    }
                } else {
                    *target++ = ch;
                }
            } else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
                result = sourceIllegal;
                *target++ = UNI_REPLACEMENT_CHAR;
            }
        }
        *sourceStart = source;
        *targetStart = target;
        return result;
    }

References conversionOK, sourceExhausted, sourceIllegal, strictConversion, and targetExhausted.

Referenced by sl_oc::tools::SI_ConvertW< SI_CHAR >::ConvertFromStore().

downloadCalibrationFile()

bool sl_oc::tools::downloadCalibrationFile	(	unsigned int	serial_number,
		std::string &	calibration_file
	)

Examples

zed_oc_depth_example.cpp, zed_oc_rectify_example.cpp, and zed_oc_tune_stereo_sgbm.cpp.

Definition at line 4101 of file calibration.hpp.

                                                                                      {
#ifndef _WIN32
    std::string path = getHiddenDir();
    char specific_name[128];
    sprintf(specific_name, "SN%d.conf", serial_number);
    calibration_file = path + specific_name;
    if (!checkFile(calibration_file)) {
        std::string cmd;
        int res;
 
        // Create download folder
        cmd = "mkdir -p " + path;
        res = system(cmd.c_str());
 
        // Download the file
        std::string url("'https://calib.stereolabs.com/?SN=");
 
        cmd = "wget " + url + std::to_string(serial_number) + "' -O " + calibration_file;
        std::cout << cmd << std::endl;
        res = system(cmd.c_str());
 
        if( res == EXIT_FAILURE )
        {
            std::cerr << "Error downloading the calibration file" << std::endl;
            return false;
        }
 
        if (!checkFile(calibration_file)) {
            std::cerr << "Invalid calibration file" << std::endl;
            return false;
        }
    }
#else
    std::string path = getHiddenDir();
    char specific_name[128];
    sprintf(specific_name, "SN%d.conf", serial_number);
    calibration_file = path + specific_name;
    if (!checkFile(calibration_file)) {
        TCHAR *settingFolder = new TCHAR[path.size() + 1];
        settingFolder[path.size()] = 0;
        std::copy(path.begin(), path.end(), settingFolder);
        SHCreateDirectoryEx(NULL, settingFolder, NULL); //recursive creation
 
        std::string url("https://calib.stereolabs.com/?SN=");
        url += std::to_string(serial_number);
        TCHAR *address = new TCHAR[url.size() + 1];
        address[url.size()] = 0;
        std::copy(url.begin(), url.end(), address);
        TCHAR *calibPath = new TCHAR[calibration_file.size() + 1];
        calibPath[calibration_file.size()] = 0;
        std::copy(calibration_file.begin(), calibration_file.end(), calibPath);
 
        HRESULT hr = URLDownloadToFile(NULL, address, calibPath, 0, NULL);
        if (hr != 0) {
            std::cout << "Fail to download calibration file" << std::endl;
            return false;
        }
 
        if (!checkFile(calibration_file)) {
            std::cout << "Invalid calibration file" << std::endl;
            return false;
        }
    }
#endif
 
    return true;
}

References checkFile().

Referenced by main().

initCalibration()

bool sl_oc::tools::initCalibration	(	std::string	calibration_file,
		cv::Size2i	image_size,
		cv::Mat &	map_left_x,
		cv::Mat &	map_left_y,
		cv::Mat &	map_right_x,
		cv::Mat &	map_right_y,
		cv::Mat &	cameraMatrix_left,
		cv::Mat &	cameraMatrix_right,
		double *	baseline = nullptr
	)

Examples

zed_oc_depth_example.cpp, zed_oc_rectify_example.cpp, and zed_oc_tune_stereo_sgbm.cpp.

Definition at line 4172 of file calibration.hpp.

                                                                                                                               {
 
    if (!checkFile(calibration_file)) {
        std::cout << "Calibration file missing." << std::endl;
        return 0;
    }
 
    // Open camera configuration file
    ConfManager camerareader(calibration_file.c_str());
    if (!camerareader.isOpened())
        return 0;
 
    std::string resolution_str;
    switch ((int) image_size.width) {
        case 2208:
            resolution_str = "2k";
            break;
        case 1920:
            resolution_str = "fhd";
            break;
        case 1280:
            resolution_str = "hd";
            break;
        case 672:
            resolution_str = "vga";
            break;
        default:
            resolution_str = "hd";
            break;
    }
 
    // Get translations
    float T_[3];
    T_[0] = camerareader.getValue("stereo:baseline", 0.0f);
    T_[1] = camerareader.getValue("stereo:ty_" + resolution_str, 0.f);
    T_[2] = camerareader.getValue("stereo:tz_" + resolution_str, 0.f);
 
    if(baseline) *baseline=T_[0];
 
    // Get left parameters
    float left_cam_cx = camerareader.getValue("left_cam_" + resolution_str + ":cx", 0.0f);
    float left_cam_cy = camerareader.getValue("left_cam_" + resolution_str + ":cy", 0.0f);
    float left_cam_fx = camerareader.getValue("left_cam_" + resolution_str + ":fx", 0.0f);
    float left_cam_fy = camerareader.getValue("left_cam_" + resolution_str + ":fy", 0.0f);
    float left_cam_k1 = camerareader.getValue("left_cam_" + resolution_str + ":k1", 0.0f);
    float left_cam_k2 = camerareader.getValue("left_cam_" + resolution_str + ":k2", 0.0f);
    float left_cam_p1 = camerareader.getValue("left_cam_" + resolution_str + ":p1", 0.0f);
    float left_cam_p2 = camerareader.getValue("left_cam_" + resolution_str + ":p2", 0.0f);
    float left_cam_k3 = camerareader.getValue("left_cam_" + resolution_str + ":k3", 0.0f);
 
    // Get right parameters
    float right_cam_cx = camerareader.getValue("right_cam_" + resolution_str + ":cx", 0.0f);
    float right_cam_cy = camerareader.getValue("right_cam_" + resolution_str + ":cy", 0.0f);
    float right_cam_fx = camerareader.getValue("right_cam_" + resolution_str + ":fx", 0.0f);
    float right_cam_fy = camerareader.getValue("right_cam_" + resolution_str + ":fy", 0.0f);
    float right_cam_k1 = camerareader.getValue("right_cam_" + resolution_str + ":k1", 0.0f);
    float right_cam_k2 = camerareader.getValue("right_cam_" + resolution_str + ":k2", 0.0f);
    float right_cam_p1 = camerareader.getValue("right_cam_" + resolution_str + ":p1", 0.0f);
    float right_cam_p2 = camerareader.getValue("right_cam_" + resolution_str + ":p2", 0.0f);
    float right_cam_k3 = camerareader.getValue("right_cam_" + resolution_str + ":k3", 0.0f);
 
    // (Linux only) Safety check A: Wrong "." or "," reading in file conf.
#ifndef _WIN32
    if (right_cam_k1 == 0 && left_cam_k1 == 0 && left_cam_k2 == 0 && right_cam_k2 == 0) {
        std::cout << "ZED File invalid" << std::endl;
 
        std::string cmd = "rm " + calibration_file;
        int res = system(cmd.c_str());
        if( res == EXIT_FAILURE )
        {
            exit(1);
        }
 
        exit(1);
    }
#endif
 
    // Get rotations
    cv::Mat R_zed = (cv::Mat_<double>(1, 3) << camerareader.getValue("stereo:rx_" + resolution_str, 0.f), camerareader.getValue("stereo:cv_" + resolution_str, 0.f), camerareader.getValue("stereo:rz_" + resolution_str, 0.f));
    cv::Mat R;
 
    cv::Rodrigues(R_zed /*in*/, R /*out*/);
 
    cv::Mat distCoeffs_left, distCoeffs_right;
 
    // Left
    cameraMatrix_left = (cv::Mat_<double>(3, 3) << left_cam_fx, 0, left_cam_cx, 0, left_cam_fy, left_cam_cy, 0, 0, 1);
    distCoeffs_left = (cv::Mat_<double>(5, 1) << left_cam_k1, left_cam_k2, left_cam_p1, left_cam_p2, left_cam_k3);
 
    // Right
    cameraMatrix_right = (cv::Mat_<double>(3, 3) << right_cam_fx, 0, right_cam_cx, 0, right_cam_fy, right_cam_cy, 0, 0, 1);
    distCoeffs_right = (cv::Mat_<double>(5, 1) << right_cam_k1, right_cam_k2, right_cam_p1, right_cam_p2, right_cam_k3);
 
    // Stereo
    cv::Mat T = (cv::Mat_<double>(3, 1) << T_[0], T_[1], T_[2]);
    std::cout << " Camera Matrix L: \n" << cameraMatrix_left << std::endl << std::endl;
    std::cout << " Camera Matrix R: \n" << cameraMatrix_right << std::endl << std::endl;
 
    cv::Mat R1, R2, P1, P2, Q;
    cv::stereoRectify(cameraMatrix_left, distCoeffs_left, cameraMatrix_right, distCoeffs_right, image_size, R, T,
            R1, R2, P1, P2, Q, cv::CALIB_ZERO_DISPARITY, 0, image_size);
 
    //Precompute maps for cv::remap()
    initUndistortRectifyMap(cameraMatrix_left, distCoeffs_left, R1, P1, image_size, CV_32FC1, map_left_x, map_left_y);
    initUndistortRectifyMap(cameraMatrix_right, distCoeffs_right, R2, P2, image_size, CV_32FC1, map_right_x, map_right_y);
 
    cameraMatrix_left = P1;
    cameraMatrix_right = P2;
 
    return 1;
}

References checkFile(), sl_oc::tools::ConfManager::getValue(), and sl_oc::tools::ConfManager::isOpened().

Referenced by main().

isLegalUTF8Sequence()

bool sl_oc::tools::isLegalUTF8Sequence	(	const UTF8 *	source,
		const UTF8 *	sourceEnd
	)

Definition at line 3124 of file calibration.hpp.

                                                                        {
        int length = trailingBytesForUTF8[*source] + 1;
        if (source + length > sourceEnd) {
            return false;
        }
        return isLegalUTF8(source, length);
    }

showImage() [1/2]

void sl_oc::tools::showImage	(	std::string	name,
		cv::Mat &	img,
		sl_oc::video::RESOLUTION	res,
		bool	change_name = true,
		std::string	info = ""
	)

Rescale the OpenCV images [cv::Mat] according to the selected resolution to better display them on screen and show.

Parameters

name	Name of the display window
img	Image to be displayed
res	Image resolution
change_name	Add rescaling information in window name if true
info	optional info string

Definition at line 64 of file ocv_display.hpp.

{
    cv::Mat resized;
    switch(res)
    {
    default:
    case sl_oc::video::RESOLUTION::VGA:
        resized = img;
        break;
    case sl_oc::video::RESOLUTION::HD720:
        if(change_name) name += " [Resize factor 0.6]";
        cv::resize( img, resized, cv::Size(), 0.6, 0.6 );
        break;
    case sl_oc::video::RESOLUTION::HD1080:
    case sl_oc::video::RESOLUTION::HD2K:
        if(change_name) name += " [Resize factor 0.4]";
        cv::resize( img, resized, cv::Size(), 0.4, 0.4 );
        break;
    }
 
    if(!info.empty())
    {
        cv::putText( resized, info, cv::Point(20,40),cv::FONT_HERSHEY_SIMPLEX, 0.75,
                     cv::Scalar(100,100,100), 2);
    }
 
    cv::imshow( name, resized );
}

References sl_oc::video::HD1080, sl_oc::video::HD2K, sl_oc::video::HD720, and sl_oc::video::VGA.

showImage() [2/2]

void sl_oc::tools::showImage	(	std::string	name,
		cv::UMat &	img,
		sl_oc::video::RESOLUTION	res,
		bool	change_name = true,
		std::string	info = ""
	)

Rescale the OpenCV T-API images [cv::UMat] according to the selected resolution to better display them on screen and show.

Parameters

name	Name of the display window
img	Image to be displayed
res	Image resolution
change_name	Add rescaling information in window name if true
info	optional info string

Examples

zed_oc_depth_example.cpp, zed_oc_rectify_example.cpp, zed_oc_tune_stereo_sgbm.cpp, and zed_oc_video_example.cpp.

Definition at line 27 of file ocv_display.hpp.

{
    cv::UMat resized;
    switch(res)
    {
    default:
    case sl_oc::video::RESOLUTION::VGA:
        resized = img;
        break;
    case sl_oc::video::RESOLUTION::HD720:
        if(change_name) name += " [Resize factor 0.6]";
        cv::resize( img, resized, cv::Size(), 0.6, 0.6 );
        break;
    case sl_oc::video::RESOLUTION::HD1080:
    case sl_oc::video::RESOLUTION::HD2K:
        if(change_name) name += " [Resize factor 0.4]";
        cv::resize( img, resized, cv::Size(), 0.4, 0.4 );
        break;
    }
 
    if(!info.empty())
    {
        cv::putText( resized, info, cv::Point(20,40),cv::FONT_HERSHEY_SIMPLEX, 0.75,
                     cv::Scalar(100,100,100), 2);
    }
 
    cv::imshow( name, resized );
}

References sl_oc::video::HD1080, sl_oc::video::HD2K, sl_oc::video::HD720, and sl_oc::video::VGA.

Referenced by applyStereoMatching(), and main().

split() [1/2]

std::vector<std::string> sl_oc::tools::split ( const std::string &  s, char  delim  )

inline

Definition at line 3997 of file calibration.hpp.

                                                                  {
    std::vector<std::string> elems;
    split(s, delim, elems);
    return elems;
}

References split().

split() [2/2]

std::vector<std::string>& sl_oc::tools::split ( const std::string &  s, char  delim, std::vector< std::string > &  elems  )

inline

Definition at line 3988 of file calibration.hpp.

                                                                                                {
    std::stringstream ss(s);
    std::string item;
    while (getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

Referenced by sl_oc::tools::ConfManager::getValue(), sl_oc::tools::ConfManager::setValue(), and split().

Variable Documentation

STEREO_PAR_FILENAME

const std::string sl_oc::tools::STEREO_PAR_FILENAME = "zed_oc_stereo.yaml"

STEREO_PAR_FILENAME default stereo parameter configuration file.

Definition at line 14 of file stereo.hpp.

Referenced by sl_oc::tools::StereoSgbmPar::load(), and sl_oc::tools::StereoSgbmPar::save().