### Perform Object Tracking with KCFTracker

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Demonstrates a basic tracking loop using OpenCV's VideoCapture and the KCFTracker class. Requires an initial region of interest (ROI) to start the tracking process.

```cpp
#include "kcftracker.hpp"
#include <opencv2/opencv.hpp>
#include <fstream>
#include <iostream>

int main() {
    // Create tracker with HOG + Lab features
    KCFTracker tracker(true, true, true, true);

    // Video capture from file or camera
    cv::VideoCapture cap("video.mp4");
    // cv::VideoCapture cap(0);  // For webcam

    cv::Mat frame;
    cv::Rect result;
    bool initialized = false;

    // Results output file
    std::ofstream outputFile("tracking_results.txt");

    while (cap.read(frame)) {
        if (!initialized) {
            // Initialize with first frame (using predefined ROI or user selection)
            cv::Rect roi(200, 150, 80, 60);
            tracker.init(roi, frame);
            initialized = true;

            outputFile << roi.x << "," << roi.y << ","
                       << roi.width << "," << roi.height << std::endl;

            cv::rectangle(frame, roi, cv::Scalar(0, 255, 0), 2);
        } else {
            // Update tracker and get new bounding box
            result = tracker.update(frame);

            // Save result
            outputFile << result.x << "," << result.y << ","
                       << result.width << "," << result.height << std::endl;

            // Draw tracking result
            cv::rectangle(frame,
                          cv::Point(result.x, result.y),
                          cv::Point(result.x + result.width, result.y + result.height),
                          cv::Scalar(0, 255, 0), 2);
        }

        cv::imshow("KCF Tracker", frame);
        if (cv::waitKey(30) == 27) break;  // ESC to exit
    }

    outputFile.close();
    return 0;
}
```

--------------------------------

### Compile the project

Source: https://github.com/joaofaro/kcfcpp/blob/master/README.md

Standard build process using CMake and make.

```bash
cmake CMakeLists.txt
make
```

--------------------------------

### Building the Project

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Instructions on how to compile the KCF Tracker using CMake and OpenCV.

```APIDOC
## Building the Project

Compile the tracker using CMake with OpenCV.

```bash
# Create build directory and compile
mkdir build && cd build
cmake ..
make

# The executable 'KCF' will be created in the build directory
```
```

--------------------------------

### Integrate KCFTracker in a project

Source: https://github.com/joaofaro/kcfcpp/blob/master/README.md

Initialize the tracker and update it with new frames.

```cpp
// Create the KCFTracker object with one of the available options
KCFTracker tracker(HOG, FIXEDWINDOW, MULTISCALE, LAB);

// Give the first frame and the position of the object to the tracker
tracker.init( Rect(xMin, yMin, width, height), frame );

// Get the position of the object for the new frame
result = tracker.update(frame);
```

--------------------------------

### Initialize KCFTracker with Various Configurations

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Create a KCFTracker instance with different feature extraction and tracking modes. Customize parameters like interpolation factor, sigma, and cell size before calling init().

```cpp
#include "kcftracker.hpp"
#include <opencv2/opencv.hpp>

// Create tracker with HOG features, fixed window, multi-scale, and Lab colors
KCFTracker tracker(true, true, true, true);

// Alternative configurations:
// HOG only (no Lab): KCFTracker tracker(true, true, true, false);
// Single-scale HOG:  KCFTracker tracker(true, true, false, false);
// Grayscale CSK:     KCFTracker tracker(false, true, true, false);

// Customize parameters before calling init() if needed
tracker.interp_factor = 0.02;  // Linear interpolation factor for adaptation
tracker.sigma = 0.5;           // Gaussian kernel bandwidth
tracker.lambda = 0.0001;       // Regularization parameter
tracker.cell_size = 4;         // HOG cell size
tracker.padding = 2.5;         // Area surrounding target, relative to its size
tracker.output_sigma_factor = 0.125;  // Bandwidth of gaussian target
tracker.template_size = 96;    // Template size in pixels
tracker.scale_step = 1.05;     // Scale step for multi-scale estimation
tracker.scale_weight = 0.95;   // Weight to downweight other scales
```

--------------------------------

### Integrate KCFTracker with VOT Benchmark

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Shows how to configure the tracker via command line arguments and process image sequences using VOT-formatted ground truth files. It includes logic to convert rotated bounding boxes to axis-aligned rectangles.

```cpp
#include "kcftracker.hpp"
#include <opencv2/opencv.hpp>
#include <fstream>
#include <sstream>
#include <algorithm>

int main(int argc, char* argv[]) {
    // Parse command line arguments for tracker configuration
    bool HOG = true, FIXEDWINDOW = false, MULTISCALE = true, LAB = false, SILENT = true;

    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "hog") == 0) HOG = true;
        if (strcmp(argv[i], "lab") == 0) { LAB = true; HOG = true; }
        if (strcmp(argv[i], "gray") == 0) HOG = false;
        if (strcmp(argv[i], "fixed_window") == 0) FIXEDWINDOW = true;
        if (strcmp(argv[i], "singlescale") == 0) MULTISCALE = false;
        if (strcmp(argv[i], "show") == 0) SILENT = false;
    }

    // Create tracker
    KCFTracker tracker(HOG, FIXEDWINDOW, MULTISCALE, LAB);

    // Read ground truth (VOT format: x1,y1,x2,y2,x3,y3,x4,y4 for rotated bbox)
    std::ifstream gtFile("region.txt");
    std::string gtLine;
    std::getline(gtFile, gtLine);
    gtFile.close();

    std::istringstream ss(gtLine);
    float x1, y1, x2, y2, x3, y3, x4, y4;
    char ch;
    ss >> x1 >> ch >> y1 >> ch >> x2 >> ch >> y2 >> ch
       >> x3 >> ch >> y3 >> ch >> x4 >> ch >> y4;

    // Convert rotated bbox to axis-aligned bbox
    float xMin = std::min({x1, x2, x3, x4});
    float yMin = std::min({y1, y2, y3, y4});
    float xMax = std::max({x1, x2, x3, x4});
    float yMax = std::max({y1, y2, y3, y4});
    cv::Rect roi(xMin, yMin, xMax - xMin, yMax - yMin);

    // Open output file
    std::ofstream outputFile("output.txt");

    // Read frame list
    std::ifstream frameList("images.txt");
    std::string framePath;
    int frameNum = 0;

    while (std::getline(frameList, framePath)) {
        cv::Mat frame = cv::imread(framePath, cv::IMREAD_COLOR);
        cv::Rect result;

        if (frameNum == 0) {
            // Initialize tracker on first frame
            tracker.init(roi, frame);
            result = roi;
        } else {
            // Track in subsequent frames
            result = tracker.update(frame);
        }

        // Output in VOT format
        outputFile << result.x << "," << result.y << ","
                   << result.width << "," << result.height << std::endl;

        // Visualization
        if (!SILENT) {
            cv::rectangle(frame, result, cv::Scalar(0, 255, 255), 2);
            cv::imshow("KCF Tracking", frame);
            cv::waitKey(1);
        }

        frameNum++;
    }

    frameList.close();
    outputFile.close();

    return 0;
}
```

--------------------------------

### Build KCF Tracker with CMake

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Compile the tracker using CMake and Make. The executable 'KCF' will be generated in the build directory.

```bash
mkdir build && cd build
cmake ..
make
```

--------------------------------

### KCFTracker::init

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Initializes the tracker with the target region of interest in the first frame.

```APIDOC
## KCFTracker::init

Initializes the tracker with the target region of interest in the first frame. This method extracts features from the initial bounding box, creates the Gaussian peak response, initializes the Hanning window, and trains the correlation filter model. Must be called before any update() calls.

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None

### Usage Example
```cpp
#include "kcftracker.hpp"
#include <opencv2/opencv.hpp>

int main() {
    // Load the first frame
    cv::Mat frame = cv::imread("frame_0001.jpg", cv::IMREAD_COLOR);

    // Define initial bounding box (x, y, width, height)
    // This can come from ground truth or user selection
    cv::Rect initialROI(120, 80, 64, 48);  // Target at (120,80) with size 64x48

    // Create and initialize tracker
    KCFTracker tracker(true, true, true, true);
    tracker.init(initialROI, frame);

    // Draw initial bounding box for visualization
    cv::rectangle(frame,
                  cv::Point(initialROI.x, initialROI.y),
                  cv::Point(initialROI.x + initialROI.width,
                           initialROI.y + initialROI.height),
                  cv::Scalar(0, 255, 255), 2);

    cv::imshow("Tracking", frame);
    cv::waitKey(0);

    return 0;
}
```
```

--------------------------------

### Initialize KCFTracker with First Frame

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Initialize the tracker with the target's region of interest in the first frame. This involves feature extraction, Gaussian peak response creation, Hanning window initialization, and correlation filter training. Must be called before update().

```cpp
#include "kcftracker.hpp"
#include <opencv2/opencv.hpp>

int main() {
    // Load the first frame
    cv::Mat frame = cv::imread("frame_0001.jpg", cv::IMREAD_COLOR);

    // Define initial bounding box (x, y, width, height)
    // This can come from ground truth or user selection
    cv::Rect initialROI(120, 80, 64, 48);  // Target at (120,80) with size 64x48

    // Create and initialize tracker
    KCFTracker tracker(true, true, true, true);
    tracker.init(initialROI, frame);

    // Draw initial bounding box for visualization
    cv::rectangle(frame,
                  cv::Point(initialROI.x, initialROI.y),
                  cv::Point(initialROI.x + initialROI.width,
                           initialROI.y + initialROI.height),
                  cv::Scalar(0, 255, 255), 2);

    cv::imshow("Tracking", frame);
    cv::waitKey(0);

    return 0;
}
```

--------------------------------

### Perform FFT Operations with FFTTools

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Provides utilities for forward/inverse FFT, complex arithmetic, and spectrum visualization. Requires input images to be converted to CV_32F format.

```cpp
#include "ffttools.hpp"
#include <opencv2/opencv.hpp>

// Perform 2D FFT on an image
cv::Mat image = cv::imread("patch.png", cv::IMREAD_GRAYSCALE);
image.convertTo(image, CV_32F);

// Forward FFT
cv::Mat spectrum = FFTTools::fftd(image, false);

// Extract real and imaginary parts
cv::Mat realPart = FFTTools::real(spectrum);
cv::Mat imagPart = FFTTools::imag(spectrum);

// Compute magnitude
cv::Mat mag = FFTTools::magnitude(spectrum);

// Complex multiplication (element-wise)
cv::Mat spectrum2 = FFTTools::fftd(image, false);
cv::Mat product = FFTTools::complexMultiplication(spectrum, spectrum2);

// Complex division
cv::Mat quotient = FFTTools::complexDivision(spectrum, spectrum2);

// Inverse FFT
cv::Mat reconstructed = FFTTools::fftd(spectrum, true);
cv::Mat result = FFTTools::real(reconstructed);

// Rearrange quadrants for visualization (shift zero-frequency to center)
cv::Mat visualSpectrum = FFTTools::magnitude(spectrum);
FFTTools::rearrange(visualSpectrum);
FFTTools::normalizedLogTransform(visualSpectrum);
cv::imshow("Spectrum", visualSpectrum);
```

--------------------------------

### KCFTracker Constructor

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Details on creating a new KCFTracker instance with various configuration options.

```APIDOC
## KCFTracker Constructor

Creates a new KCFTracker instance with configurable feature extraction and tracking modes. The constructor accepts boolean flags to enable HOG features, fixed window size, multi-scale tracking, and Lab color features. Default parameters are optimized for the VOT benchmark, but can be customized after construction.

```cpp
#include "kcftracker.hpp"
#include <opencv2/opencv.hpp>

// Create tracker with HOG features, fixed window, multi-scale, and Lab colors
KCFTracker tracker(true, true, true, true);

// Alternative configurations:
// HOG only (no Lab): KCFTracker tracker(true, true, true, false);
// Single-scale HOG:  KCFTracker tracker(true, true, false, false);
// Grayscale CSK:     KCFTracker tracker(false, true, true, false);

// Customize parameters before calling init() if needed
tracker.interp_factor = 0.02;  // Linear interpolation factor for adaptation
tracker.sigma = 0.5;           // Gaussian kernel bandwidth
tracker.lambda = 0.0001;       // Regularization parameter
tracker.cell_size = 4;         // HOG cell size
tracker.padding = 2.5;         // Area surrounding target, relative to its size
tracker.output_sigma_factor = 0.125;  // Bandwidth of gaussian target
tracker.template_size = 96;    // Template size in pixels
tracker.scale_step = 1.05;     // Scale step for multi-scale estimation
tracker.scale_weight = 0.95;   // Weight to downweight other scales
```
```

--------------------------------

### Manual execution commands for KCF tracker

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Use these commands to run the KCF tracker with different feature extraction and visualization settings.

```bash
./KCF hog show                    # HOG features with visualization
./KCF lab show                    # HOG + Lab features with visualization
./KCF gray show                   # Grayscale (CSK) with visualization
./KCF hog singlescale            # Single-scale HOG tracking
./KCF hog fixed_window           # Fixed window size
```

--------------------------------

### Run KCF Tracker via Shell Scripts

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Executes the tracker with different feature configurations for VOT toolkit integration.

```bash
# Run KCF tracker with HOG features only
./KCFCpp.sh

# Run KCF tracker with HOG + Lab color features
./KCFLabCpp.sh
```

--------------------------------

### CMake Project Configuration

Source: https://github.com/joaofaro/kcfcpp/blob/master/CMakeLists.txt

This CMakeLists.txt file configures a C++ project named 'KCF' that depends on OpenCV. It sets C++ standard and optimization flags for non-Windows platforms and links the necessary OpenCV libraries.

```cmake
cmake_minimum_required(VERSION 2.8)
project(test)

find_package(OpenCV REQUIRED)

if(NOT WIN32)
ADD_DEFINITIONS("-std=c++0x -O3")
endif(NOT WIN32)

include_directories(src)
FILE(GLOB_RECURSE sourcefiles "src/*.cpp")
add_executable( KCF ${sourcefiles} )
target_link_libraries( KCF ${OpenCV_LIBS})
```

--------------------------------

### Manipulate Rectangles with RectTools

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Handles geometric calculations, boundary limiting, and subwindow extraction with padding. Useful for managing ROI regions in image frames.

```cpp
#include "recttools.hpp"
#include <opencv2/opencv.hpp>

cv::Mat frame = cv::imread("frame.jpg");
cv::Rect_<float> roi(100, 80, 64, 48);

// Get center of rectangle
cv::Vec2f center = RectTools::center(roi);  // Returns (132, 104)

// Get right edge x-coordinate
float rightX = RectTools::x2(roi);  // Returns 164

// Get bottom edge y-coordinate
float bottomY = RectTools::y2(roi);  // Returns 128

// Resize rectangle by scale factor (centered resize)
cv::Rect_<float> scaled = roi;
RectTools::resize(scaled, 1.5f);  // 50% larger, centered

// Limit rectangle to image boundaries
cv::Rect_<float> bounded = roi;
RectTools::limit(bounded, frame.cols, frame.rows);

// Extract subwindow with replication border padding
// Handles regions that extend beyond image boundaries
cv::Rect window(-10, -10, 100, 100);  // Extends beyond top-left
cv::Mat subwindow = RectTools::subwindow(frame, window, cv::BORDER_REPLICATE);

// Convert to normalized grayscale [0, 1]
cv::Mat gray = RectTools::getGrayImage(frame);
```

--------------------------------

### Extract FHOG Features

Source: https://context7.com/joaofaro/kcfcpp/llms.txt

Computes gradient orientation histograms and applies normalization or PCA. Requires conversion to IplImage and manual memory management for the feature map object.

```cpp
#include "fhog.hpp"
#include <opencv2/opencv.hpp>

cv::Mat image = cv::imread("patch.jpg");
cv::resize(image, image, cv::Size(96, 96));  // Resize to template size

// Convert to IplImage for FHOG interface
IplImage iplImage = image;

// Extract HOG features with cell size of 4 pixels
CvLSVMFeatureMapCaskade* featureMap;
int cellSize = 4;
int result = getFeatureMaps(&iplImage, cellSize, &featureMap);

if (result == LATENT_SVM_OK) {
    // featureMap->sizeX: number of cells in X direction
    // featureMap->sizeY: number of cells in Y direction
    // featureMap->numFeatures: feature vector dimension per cell
    // featureMap->map: raw feature data

    std::cout << "Feature map size: " << featureMap->sizeX << "x"
              << featureMap->sizeY << std::endl;
    std::cout << "Features per cell: " << featureMap->numFeatures << std::endl;

    // Normalize and truncate features (threshold = 0.2)
    normalizeAndTruncate(featureMap, 0.2f);

    // Apply PCA for dimensionality reduction
    PCAFeatureMaps(featureMap);

    // Convert to cv::Mat for use with KCF
    cv::Mat features(cv::Size(featureMap->numFeatures,
                              featureMap->sizeX * featureMap->sizeY),
                     CV_32F, featureMap->map);
    features = features.t();  // Transpose to expected format

    // Free memory when done
    freeFeatureMapObject(&featureMap);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.