diff --git a/Examples/Stereo/stereo_uzh-fpv.cc b/Examples/Stereo/stereo_uzh-fpv.cc
new file mode 100644
index 0000000..3de76dc
--- /dev/null
+++ b/Examples/Stereo/stereo_uzh-fpv.cc
@@ -0,0 +1,308 @@
+/**
+* This file is part of ORB-SLAM3
+*
+* Copyright (C) 2017-2021 Carlos Campos, Richard Elvira, Juan J. Gómez Rodríguez, José M.M. Montiel and Juan D. Tardós, University of Zaragoza.
+* Copyright (C) 2014-2016 Raúl Mur-Artal, José M.M. Montiel and Juan D. Tardós, University of Zaragoza.
+*
+* ORB-SLAM3 is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
+* License as published by the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* ORB-SLAM3 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 General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License along with ORB-SLAM3.
+* If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include<iostream>
+#include<algorithm>
+#include<fstream>
+#include<iomanip>
+#include<chrono>
+#include <unistd.h>
+
+#include<opencv2/core/core.hpp>
+
+#include<System.h>
+
+using namespace std;
+
+void LoadImages(const string &strPath, const string &strPathTimesLeft, const string &strPathTimesRight,
+                vector<string> &vstrImageLeft, vector<string> &vstrImageRight, vector<double> &vTimeStamps);
+
+double ttrack_tot = 0;
+int main(int argc, char **argv)
+{
+    const int num_seq = (argc-3)/3;
+    cout << "num_seq = " << num_seq << endl;
+    bool bFileName= (((argc-3) % 3) == 1);
+    string file_name;
+    if (bFileName)
+        file_name = string(argv[argc-1]);
+
+    if(argc < 6)
+    {
+        cerr << endl << "Usage: ./stereo_uzh-fpv path_to_vocabulary path_to_settings path_to_image_folder_1 path_to_times_file_left_1 path_to_times_file_right_1 (path_to_image_folder1_2 path_to_image_folder2_2 path_to_times_file_2 ... path_to_image_folder1_N path_to_image_folder2_N path_to_times_file_N) (trajectory_file_name)" << endl;
+        return 1;
+    }
+
+    // Load all sequences:
+    int seq;
+    vector< vector<string> > vstrImageLeftFilenames;
+    vector< vector<string> > vstrImageRightFilenames;
+    vector< vector<double> > vTimestampsCam;
+    vector<int> nImages;
+
+    vstrImageLeftFilenames.resize(num_seq);
+    vstrImageRightFilenames.resize(num_seq);
+    vTimestampsCam.resize(num_seq);
+    nImages.resize(num_seq);
+
+    int tot_images = 0;
+    for (seq = 0; seq<num_seq; seq++)
+    {
+        cout << "Loading images for sequence " << seq << "...";
+        LoadImages(string(argv[3]), string(argv[4]), string(argv[5]), vstrImageLeftFilenames[seq], vstrImageRightFilenames[seq], vTimestampsCam[seq]);
+        cout << "Total images: " << vstrImageLeftFilenames[seq].size() << endl;
+        cout << "Total cam ts: " << vTimestampsCam[seq].size() << endl;
+        cout << "first cam ts: " << vTimestampsCam[seq][0] << endl;
+
+        cout << "LOADED!" << endl;
+
+        nImages[seq] = vstrImageLeftFilenames[seq].size();
+        tot_images += nImages[seq];
+
+        if((nImages[seq]<=0))
+        {
+            cerr << "ERROR: Failed to load images for sequence" << seq << endl;
+            return 1;
+        }
+
+    }
+
+    // Vector for tracking time statistics
+    vector<float> vTimesTrack;
+    vTimesTrack.resize(tot_images);
+
+    cout << endl << "-------" << endl;
+    cout.precision(17);
+
+    // Create SLAM system. It initializes all system threads and gets ready to process frames.
+    ORB_SLAM3::System SLAM(argv[1],argv[2],ORB_SLAM3::System::STEREO,true);
+    float imageScale = SLAM.GetImageScale();
+
+    cout << endl << "-------" << endl;
+    cout.precision(17);
+
+    cv::Mat imLeft, imRight;
+    cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE(3.0, cv::Size(8, 8));
+
+    double t_resize = 0.f;
+    double t_track = 0.f;
+
+    int proccIm = 0;
+    for (seq = 0; seq<num_seq; seq++)
+    {
+        // Main loop
+        proccIm = 0;
+        for(int ni=0; ni<nImages[seq]; ni++, proccIm++)
+        {
+
+            // Read image from file
+            std::string imgPathLeft(vstrImageLeftFilenames[seq][ni].begin(), vstrImageLeftFilenames[seq][ni].end() - 1);
+            std::string imgPathRight(vstrImageRightFilenames[seq][ni].begin(), vstrImageRightFilenames[seq][ni].end() - 1);
+//            std::cout << "Reading the image at path: " << imgPath << std::endl;
+            imLeft = cv::imread(imgPathLeft,cv::IMREAD_GRAYSCALE);
+            imRight = cv::imread(imgPathRight,cv::IMREAD_GRAYSCALE);
+
+            if(imageScale != 1.f)
+            {
+#ifdef REGISTER_TIMES
+    #ifdef COMPILEDWITHC11
+                std::chrono::steady_clock::time_point t_Start_Resize = std::chrono::steady_clock::now();
+    #else
+                std::chrono::monotonic_clock::time_point t_Start_Resize = std::chrono::monotonic_clock::now();
+    #endif
+#endif
+                int width = imLeft.cols * imageScale;
+                int height = imLeft.rows * imageScale;
+                cv::resize(imLeft, imLeft, cv::Size(width, height));
+                cv::resize(imRight, imRight, cv::Size(width, height));
+#ifdef REGISTER_TIMES
+    #ifdef COMPILEDWITHC11
+                std::chrono::steady_clock::time_point t_End_Resize = std::chrono::steady_clock::now();
+    #else
+                std::chrono::monotonic_clock::time_point t_End_Resize = std::chrono::monotonic_clock::now();
+    #endif
+                t_resize = std::chrono::duration_cast<std::chrono::duration<double,std::milli> >(t_End_Resize - t_Start_Resize).count();
+                SLAM.InsertResizeTime(t_resize);
+#endif
+            }
+
+            // clahe
+            clahe->apply(imLeft,imLeft);
+            clahe->apply(imRight,imRight);
+
+            double tframe = vTimestampsCam[seq][ni];
+
+            if(imLeft.empty() || imRight.empty())
+            {
+                cerr << endl << "Failed to load image at: "
+                     <<  vstrImageLeftFilenames[seq][ni] << endl;
+                return 1;
+            }
+
+    #ifdef COMPILEDWITHC11
+            std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
+    #else
+            std::chrono::monotonic_clock::time_point t1 = std::chrono::monotonic_clock::now();
+    #endif
+
+            // Pass the image to the SLAM system
+            SLAM.TrackStereo(imLeft,imRight,tframe);
+
+    #ifdef COMPILEDWITHC11
+            std::chrono::steady_clock::time_point t2 = std::chrono::steady_clock::now();
+    #else
+            std::chrono::monotonic_clock::time_point t2 = std::chrono::monotonic_clock::now();
+    #endif
+
+#ifdef REGISTER_TIMES
+            t_track = t_resize + std::chrono::duration_cast<std::chrono::duration<double,std::milli> >(t2 - t1).count();
+            SLAM.InsertTrackTime(t_track);
+#endif
+
+            double ttrack= std::chrono::duration_cast<std::chrono::duration<double> >(t2 - t1).count();
+            ttrack_tot += ttrack;
+            // std::cout << "ttrack: " << ttrack << std::endl;
+
+            vTimesTrack[ni]=ttrack;
+
+            // Wait to load the next frame
+            double T=0;
+            if(ni<nImages[seq]-1)
+                T = vTimestampsCam[seq][ni+1]-tframe;
+            else if(ni>0)
+                T = tframe-vTimestampsCam[seq][ni-1];
+
+            if(ttrack<T)
+                usleep((T-ttrack)*1e6); // 1e6
+        }
+        if(seq < num_seq - 1)
+        {
+            cout << "Changing the dataset" << endl;
+
+            SLAM.ChangeDataset();
+        }
+    }
+
+
+    // Stop all threads
+    SLAM.Shutdown();
+
+    // Tracking time statistics
+
+    // Save camera trajectory
+    std::chrono::system_clock::time_point scNow = std::chrono::system_clock::now();
+    std::time_t now = std::chrono::system_clock::to_time_t(scNow);
+    std::stringstream ss;
+    ss << now;
+
+    if (bFileName)
+    {
+        const string kf_file =  "kf_" + string(argv[argc-1]) + ".txt";
+        const string f_file =  "f_" + string(argv[argc-1]) + ".txt";
+        SLAM.SaveTrajectoryEuRoC(f_file);
+        SLAM.SaveKeyFrameTrajectoryEuRoC(kf_file);
+    }
+    else
+    {
+        SLAM.SaveTrajectoryEuRoC("CameraTrajectory.txt");
+        SLAM.SaveKeyFrameTrajectoryEuRoC("KeyFrameTrajectory.txt");
+    }
+
+    sort(vTimesTrack.begin(),vTimesTrack.end());
+    float totaltime = 0;
+    for(int ni=0; ni<nImages[0]; ni++)
+    {
+        totaltime+=vTimesTrack[ni];
+    }
+    cout << "-------" << endl << endl;
+    cout << "median tracking time: " << vTimesTrack[nImages[0]/2] << endl;
+    cout << "mean tracking time: " << totaltime/proccIm << endl;
+
+    return 0;
+}
+
+/*void LoadImages(const string &strPathLeft, const string &strPathRight, const string &strPathTimes,
+                vector<string> &vstrImageLeft, vector<string> &vstrImageRight, vector<double> &vTimeStamps)
+{
+    ifstream fTimes;
+    cout << strPathLeft << endl;
+    cout << strPathRight << endl;
+    cout << strPathTimes << endl;
+    fTimes.open(strPathTimes.c_str());
+    vTimeStamps.reserve(5000);
+    vstrImageLeft.reserve(5000);
+    vstrImageRight.reserve(5000);
+    while(!fTimes.eof())
+    {
+        string s;
+        getline(fTimes,s);
+        if(!s.empty())
+        {
+            stringstream ss;
+            ss << s;
+            vstrImageLeft.push_back(strPathLeft + "/" + ss.str() + ".png");
+            vstrImageRight.push_back(strPathRight + "/" + ss.str() + ".png");
+            double t;
+            ss >> t;
+            vTimeStamps.push_back(t/1e9);
+        }
+    }
+}*/
+
+void LoadImages(const string &strPath, const string &strPathTimesLeft, const string &strPathTimesRight,
+                vector<string> &vstrImageLeft, vector<string> &vstrImageRight, vector<double> &vTimeStamps)
+{
+    ifstream fTimesLeft, fTimesRight;
+    cout << strPath << endl;
+    cout << strPathTimesRight << endl;
+    cout << strPathTimesLeft << endl;
+    fTimesLeft.open(strPathTimesLeft.c_str());
+    fTimesRight.open(strPathTimesRight.c_str());
+    vTimeStamps.reserve(5000);
+    vstrImageLeft.reserve(5000);
+    vstrImageRight.reserve(5000);
+    while(!fTimesLeft.eof())
+    {
+        string sLeft, sRight;
+        getline(fTimesLeft,sLeft);
+        getline(fTimesRight, sRight);
+
+        if(!sLeft.empty())
+        {
+            if (sLeft[0] == '#')
+                continue;
+
+            int pos = sLeft.find(' ');
+            sLeft = sLeft.substr(pos+1, string::npos);
+            sRight = sRight.substr(pos+1, string::npos);
+            pos = sLeft.find(' ');
+            string item = sLeft.substr(0, pos);
+            string strImgLeft = sLeft.substr(pos+1, string::npos);
+//            std::cout << "The resulting left filename string is: " << strImgLeft << std::endl;
+            string strImgRight = sRight.substr(pos+1, string::npos);
+            std::remove(strImgLeft.begin(), strImgLeft.end(), ' ');
+            std::remove(strImgRight.begin(), strImgRight.end(), ' ');
+
+            vstrImageLeft.push_back(strPath + "/" + strImgLeft);
+            vstrImageRight.push_back(strPath + "/" + strImgRight);
+
+            double t = stod(item);
+            vTimeStamps.push_back(t);
+        }
+    }
+}