Aller au contenu principal

Quick Start

Créez votre premier programme avec le Guido Racing SDK en quelques minutes.

Premier Programme​

1. Créer le Projet​

mkdir my-racing-app && cd my-racing-app

2. Fichier CMakeLists.txt​

Créez un fichier CMakeLists.txt :

cmake_minimum_required(VERSION 3.20)
project(MyRacingApp)

# Trouver le SDK Guido
find_package(GuidoRacingSDK REQUIRED)

# Créer l'exécutable
add_executable(my_app main.cpp)

# Lier le SDK
target_link_libraries(my_app PRIVATE GuidoRacing::guido_racing_sdk)

# C++20 requis
set_target_properties(my_app PROPERTIES CXX_STANDARD 20)

3. Code Source (main.cpp)​

Créez un fichier main.cpp :

#include <guido_racing/sdk.hpp>
#include <iostream>

int main() {
    std::cout << "Guido Racing SDK - Quick Start\n";
    
    // Initialiser le SDK
    guido_racing::SDK sdk;
    
    std::cout << "SDK Version: " << sdk.version() << "\n";
    std::cout << "✓ SDK initialized successfully!\n";
    
    return 0;
}

4. Compiler et Exécuter​

mkdir build && cd build
cmake ..
cmake --build .
./my_app

Sortie attendue :

Guido Racing SDK - Quick Start
SDK Version: 1.0.0
✓ SDK initialized successfully!

Charger des Données GPS​

Exemple d'import et d'analyse de données GPS :

#include <guido_racing/sdk.hpp>
#include <iostream>
#include <vector>

int main() {
    guido_racing::SDK sdk;
    
    // Charger un fichier GPX
    try {
        auto session = sdk.loadGPX("session-spa.gpx");
        
        std::cout << "Session chargée:\n";
        std::cout << "  Durée: " << session.duration() << "s\n";
        std::cout << "  Distance: " << session.distance() << "m\n";
        std::cout << "  Tours détectés: " << session.lapCount() << "\n";
        
        // Afficher les temps au tour
        auto laps = session.getLaps();
        for (size_t i = 0; i < laps.size(); ++i) {
            std::cout << "  Tour " << (i + 1) << ": " 
                      << laps[i].time << "s\n";
        }
        
    } catch (const std::exception& e) {
        std::cerr << "Erreur: " << e.what() << "\n";
        return 1;
    }
    
    return 0;
}

Analyser une Session​

Exemple d'analyse complète avec recommandations :

#include <guido_racing/sdk.hpp>
#include <iostream>

int main() {
    guido_racing::SDK sdk;
    
    // Charger et analyser
    auto session = sdk.loadGPX("session-spa.gpx");
    auto analysis = sdk.analyzeSession(session);
    
    // Afficher le résumé
    std::cout << "Analyse de session:\n";
    std::cout << "━━━━━━━━━━━━━━━━━━━━\n";
    std::cout << "Meilleur tour: " << analysis.bestLap().time << "s\n";
    std::cout << "Tour moyen: " << analysis.averageLap().time << "s\n";
    std::cout << "Constance: " << analysis.consistency() << "%\n";
    
    // Recommandations IA
    auto recommendations = analysis.getRecommendations();
    
    std::cout << "\n📊 Recommandations:\n";
    std::cout << "━━━━━━━━━━━━━━━━━━━━\n";
    
    for (const auto& rec : recommendations) {
        std::cout << "📍 " << rec.location << "\n";
        std::cout << "   " << rec.message << "\n";
        std::cout << "   Gain potentiel: " << rec.potentialGain << "s\n";
        std::cout << "   Priorité: " << rec.priority << "\n\n";
    }
    
    return 0;
}

Exemple de sortie :

Analyse de session:
━━━━━━━━━━━━━━━━━━━━
Meilleur tour: 127.34s
Tour moyen: 129.12s
Constance: 92.5%

📊 Recommandations:
━━━━━━━━━━━━━━━━━━━━
📍 Virage 7 (La Source)
   Freinage trop précoce de 12m
   Gain potentiel: 0.28s
   Priorité: Haute

📍 Sortie Virage 15 (Raidillon)
   Réaccélération tardive
   Gain potentiel: 0.15s
   Priorité: Moyenne

Trajectoire Optimale​

Calculer et afficher la trajectoire idéale :

#include <guido_racing/sdk.hpp>
#include <iostream>

int main() {
    guido_racing::SDK sdk;
    
    auto session = sdk.loadGPX("session-spa.gpx");
    
    // Calculer la trajectoire optimale
    auto optimalPath = sdk.calculateOptimalPath(session);
    
    std::cout << "Trajectoire optimale calculée\n";
    std::cout << "Points: " << optimalPath.points.size() << "\n";
    std::cout << "Temps théorique: " << optimalPath.theoreticalTime << "s\n";
    
    // Comparer avec votre meilleur tour
    auto bestLap = session.getBestLap();
    auto comparison = sdk.comparePaths(bestLap.path, optimalPath);
    
    std::cout << "\nComparaison:\n";
    for (const auto& zone : comparison.differenceZones) {
        std::cout << "  Zone " << zone.name << ": ";
        std::cout << (zone.deviation > 0 ? "+" : "") 
                  << zone.deviation << "m\n";
    }
    
    // Exporter pour visualisation
    sdk.exportPathToKML(optimalPath, "optimal-path.kml");
    std::cout << "\nTrajectoire exportée dans optimal-path.kml\n";
    
    return 0;
}

Configuration Avancée​

Personnaliser le comportement du SDK :

#include <guido_racing/sdk.hpp>

int main() {
    // Configuration personnalisée
    guido_racing::Config config;
    config.gps_frequency = 10; // Hz
    config.smoothing_factor = 0.8;
    config.lap_detection_threshold = 0.95;
    config.enable_ai_coaching = true;
    
    guido_racing::SDK sdk(config);
    
    // Utiliser le SDK configuré
    auto session = sdk.loadGPX("session.gpx");
    auto analysis = sdk.analyzeSession(session);
    
    return 0;
}

Prochaines Étapes​

Besoin d'Aide ?​