SoSe24 - Praktikum Systementwurf - Spurpolynom: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
Zeile 67: Zeile 67:
%***************************************************************/
%***************************************************************/
%% MATLAB initialisieren
%% MATLAB initialisieren
clc; clear all; close all;
clear all; close all


%% Pfade einstellen und Parameter laden
% cell-array mit Fahrbahnmarkierungen laden
addpath 'C:\Semesterordner\SS2024\Team_3_Liu_Pan_Lin\Termin_9\Aufgabe_6'
load('GeradeInKurve_Segmente.mat')
[~,nMaxBilder]=size(Fahrbahnmarkierung)


% Parameter einstellen
%% Video laden
Kameraneigung = 10; % Kameraneigung, Einheit: Grad
Kamerahoehe = 27.5 / 100; % Kamerahöhe über Boden, Einheit: Meter
FahrzeugfrontKamera = 27 / 100; % Abstand von Fahrzeugfront bis Kamera, Einheit: Meter
Fahrzeugbreite = 20 / 100; % Fahrzeugbreite, Einheit: Meter
 
% Winkel in Radiant umrechnen
Kameraneigung_rad = deg2rad(Kameraneigung);
 
% Video und Auflösung laden
stDateiname = 'GeradeInKurve_IPT.mp4';
stDateiname = 'GeradeInKurve_IPT.mp4';
hVideo = VideoReader(stDateiname);
hVideo = VideoReader(stDateiname);
width = hVideo.Width;
height = hVideo.Height;


% Berechnung der tatsächlichen Entfernung pro Pixel
for nBild=1:nMaxBilder % Schleife über alle Frames
d_per_pixel = Fahrzeugbreite / width; % tatsächliche Entfernung pro Pixel, Einheit: Meter
 
% cell-array mit Fahrbahnmarkierungen laden
load('GeradeInKurve_Segmente.mat')
[~, nMaxBilder] = size(Fahrbahnmarkierung);
 
% Video-Schreibobjekt öffnen
outputVideo = VideoWriter('GeradeInKurve_Spurpolynom.mp4', 'MPEG-4');
open(outputVideo);
 
% Initialisierung der Matrix zur Speicherung der Polynomkoeffizienten
PolyCoeffsHistory = zeros(nMaxBilder, 3); % Angenommen, es gibt drei Koeffizienten für das quadratische Polynom
 
for nBild = 1:nMaxBilder % Schleife über alle Frames


     aFrame = readFrame(hVideo); % Bild laden
     aFrame = readFrame(hVideo); % Bild laden
      
      
     %% Fahrspurmasken auslesen
     %% Fahrspurmasken auslesen
     Fahrbahn = Fahrbahnmarkierung{nBild};
     Fahrbahn=Fahrbahnmarkierung{nBild};
     aLinkeFahrspur  = Fahrbahn(:,:,1);
     aLinkeFahrspur  = Fahrbahn(:,:,1);
     aMittelFahrspur = Fahrbahn(:,:,2);
     aMittelFahrspur = Fahrbahn(:,:,2);
     aRechteFahrspur = Fahrbahn(:,:,3);
     aRechteFahrspur = Fahrbahn(:,:,3);


     %% Fahrspuren einfärben
     %% Fahrspuren einf?rben
     % Farbkanäle trennen
     % Farbkan?le trennen
     R = aFrame(:,:,1);
     R = aFrame(:,:,1);
     G = aFrame(:,:,2);
     G = aFrame(:,:,2);
Zeile 128: Zeile 104:
     B(aRechteFahrspur) = 0;
     B(aRechteFahrspur) = 0;
      
      
     aRGBBild = cat(3, R, G, B); % Bild zusammenfügen
     aRGBBild = cat(3, R, G, B); % Bild zusammenfassungen
 
     %% Spurpolynom zwischen roten und gelben Fahrspuren berechnen und darstellen
     %% Fahrspuren in Vektoren kopieren
    [yMittel, xMittel] = find(aMittelFahrspur);
     [yRechts, xRechts] = find(aRechteFahrspur);
     [yRechts, xRechts] = find(aRechteFahrspur);
     [yMitte, xMitte] = find(aMittelFahrspur);
      
 
     if ~isempty(yMittel) && ~isempty(yRechts)
    % Sicherstellen, dass die Stichprobenpunkte einzigartig sind
         % Mittlere y-Koordinate als gemeinsame Basis verwenden
    [yRechts, uniqueIdxRechts] = unique(yRechts);
         yGemeinsam = unique([yMittel; yRechts]);
    xRechts = xRechts(uniqueIdxRechts);
          
    [yMitte, uniqueIdxMitte] = unique(yMitte);
         % Polynom zwischen mittleren und rechten Fahrspuren anpassen
    xMitte = xMitte(uniqueIdxMitte);
         pMittel = polyfit(yMittel, xMittel, 2);
 
         pRechts = polyfit(yRechts, xRechts, 2);
    % Punkteanzahl ausgleichen
          
     if length(xRechts) > 1 && length(xMitte) > 1
         xMittelPoly = polyval(pMittel, yGemeinsam);  
        if length(xRechts) > length(xMitte)
         xRechtsPoly = polyval(pRechts, yGemeinsam);
            xMitteInterp = interp1(yMitte, xMitte, yRechts, 'linear', 'extrap');
            yMitteInterp = yRechts;
            xRechtsInterp = xRechts;
            yRechtsInterp = yRechts;
        else
            xRechtsInterp = interp1(yRechts, xRechts, yMitte, 'linear', 'extrap');
            yRechtsInterp = yMitte;
            xMitteInterp = xMitte;
            yMitteInterp = yMitte;
        end
 
         % Berechnung der Mittellinie der rechten Fahrspur
         xB = (xRechtsInterp + xMitteInterp) / 2;
        yB = (yRechtsInterp + yMitteInterp) / 2;
 
         % Umrechnung in Fahrzeugkoordinaten
         xF = (xB - width / 2) * d_per_pixel; % Querkoordinate, Einheit: Meter
         yF = (height - yB) * d_per_pixel; % Längskoordinate, Einheit: Meter
 
        % Punkte in eine Matrix umwandeln
        aWegpunkte = [xF'; yF'];
 
        % Quadratische Polynominterpolation durchführen
        PolynomKoeffizienten = interpoliereFahrspur(aWegpunkte, 2);
 
        % Speicherung der aktuellen Polynomkoeffizienten
        PolyCoeffsHistory(nBild, :) = PolynomKoeffizienten;
 
        % Polynomkoeffizienten mit gleitendem Durchschnitt glätten
         if nBild > 1
            windowSize = 5; % Größe des gleitenden Durchschnittsfensters
            for j = 1:3
                startIdx = max(1, nBild - windowSize + 1);
                PolyCoeffsHistory(nBild, j) = mean(PolyCoeffsHistory(startIdx:nBild, j));
            end
         end
 
        %% Weiße Parabel zeichnen (Querregelung)
         xVehicle = linspace(min(xF), max(xF), 100);
         yFitQuer = polyval(PolyCoeffsHistory(nBild, :), xVehicle);
 
        % Umrechnung der Fahrzeugkoordinaten in Bildkoordinaten
        xVehicle_img = (xVehicle / d_per_pixel) + width / 2;
        yFitQuer_img = height - (yFitQuer / d_per_pixel);
 
        % Sicherstellen, dass die interpolierten Punkte im Bildbereich liegen
        validIdxQuer = (yFitQuer_img >= 1) & (yFitQuer_img <= height);
          
          
         for i = 1:length(xVehicle_img)
         % Mittelwert der x-Koordinaten als Spurpolynom berechnen
            if validIdxQuer(i)
        xSpurneu = (xMittelPoly + xRechtsPoly) / 2;
                yCoord = round(yFitQuer_img(i)); % y-Wert in Bildkoordinaten umrechnen
                if yCoord > 0 && yCoord <= height && round(xVehicle_img(i)) > 0 && round(xVehicle_img(i)) <= width
                    aRGBBild(yCoord, round(xVehicle_img(i)), 1) = 255; % R
                    aRGBBild(yCoord, round(xVehicle_img(i)), 2) = 255; % G
                    aRGBBild(yCoord, round(xVehicle_img(i)), 3) = 255; % B
                end
            end
        end
     end
     end
      
      
     % Ergebnis im Video speichern
     %% Bild anzeigen
     writeVideo(outputVideo, aRGBBild);
     imshow(aRGBBild)
end
    title(['Frame: ', num2str(nBild), ' / ', num2str(nMaxBilder)]);
    hold on;
   
    if exist('xSpurneu','var')
        h3 = plot(xSpurneu,yGemeinsam, 'w-', 'Linewidth', 2);
    end
    %% Legend hinzufuegen
    h1 = plot(NaN, NaN, 'r-', 'LineWidth', 2); % Dummy plot for red legend
    h2 = plot(NaN, NaN, 'y-', 'LineWidth', 2); % Dummy plot for yellow legend


% Video-Schreibobjekt schließen
    legend([h1 h2 h3], {'Mittelspur', 'Rechtspur', 'Neuespur'});
close(outputVideo);
      
 
     hold off;
% Polynomkoeffizienten speichern
     pause(0.01); % Kurze Pause, um das Bild anzuzeigen
save('Spurpolynom.mat', 'PolyCoeffsHistory');
 
%% Hilfsfunktion
function PolynomKoeffizienten = interpoliereFahrspur(aWegpunkte, n)
     % Berechnung der kleinsten Quadrate Lösung für die n-te Ordnung der Polynominterpolation
     A = ones(size(aWegpunkte, 2), n + 1);
     for k = 1:n
        A(:, k) = aWegpunkte(1, :).^(n + 1 - k);
    end
    b = aWegpunkte(2, :)';
    PolynomKoeffizienten = A \ b; % Kleinste Quadrate Lösung
end
end
</source>
|}


== Ergebnisse ==
== Ergebnisse ==

Version vom 3. Juli 2024, 21:06 Uhr

Abb. 1: GeradeInKurve_Spurpolynom.
Autoren: Yuhan Pan, Xiangyao Liu, Yunkai Lin
Thema: Spurpolynom
Workshoptermin 9: 20.06.2024
Lernzielkontrolle 3: 04.07.2024


Einleitung

In diesem Workshop lernen Sie, wie Bilddaten von Fahrzeugkameras verarbeitet werden, um Fahrspuren zu erkennen und zu analysieren. Der Fokus liegt auf der Transformation von Bildkoordinaten in Fahrzeugkoordinaten und der Erstellung von Polynomen zur Darstellung der Fahrspur. Zudem wird die Berücksichtigung des Blindbereichs und die Ermittlung der Mittellinie für die Querregelung behandelt.

Spurpolynom

In diesem Abschnitt werden die grundlegenden Konzepte und Techniken zur Ermittlung von Spurpolynomen erläutert. Dies umfasst die Theorie der Polynombildung, die Transformation von Bild- zu Fahrzeugkoordinaten, die Berücksichtigung des Blindbereichs sowie die Ermittlung des Spurpolynoms für die Querregelung.

Beschreibung die Theorie der Polynombildung

Die Polynombildung ist ein Verfahren zur Annäherung oder Interpolation von Datenpunkten durch ein Polynom. Ein Polynom n-ten Grades hat die Form: Die Koeffizienten werden so bestimmt, dass die Summe der quadrierten Abweichungen minimiert wird (Methode der kleinsten Quadrate). Im diese Workshop wurden Spurpolynom in Form: zeigen. Man kann durch den Segmentierung der Spurpolynom von Video der Queranzahl x und y festlegen, und durch den Queranzahl y und x den Spurparameter a, b und c berechnen.

Beschreiben Sie die KOS-Trafo Bild- zu Fahrzeugkoordinaten

Die KOS-Transformation wandelt Bildkoordinaten (u, v) in Fahrzeugkoordinaten (X, Y, Z) um. Zuerst werden Bildkoordinaten in Kamerakoordinaten umgerechnet, dann werden diese in Fahrzeugkoordinaten transformiert unter Berücksichtigung der Kameraposition und -neigung.

Berücksichtigung des Blindbereichs

Der Blindbereich umfasst Bereiche, die von der Kamera nicht erfasst werden können. Um den Blindbereich zu berücksichtigen, werden nur sichtbare Bereiche des Bildes in die Fahrzeugkoordinaten transformiert und weiterverarbeitet, indem sie geometrisch berechnet und maskiert werden.

Wie wird das Spurpolynom für die Querregelung aus den Spurpolynomen der Fahrbahnmarkierungen ermittelt?

Das Spurpolynom für die Querregelung wird aus den Spurpolynomen der linken und rechten Fahrbahnmarkierungen berechnet. Die Mittellinie der Fahrspur wird als Mittelwert der Positionen der linken und rechten Fahrbahnmarkierungen bestimmt und anschließend durch ein Polynom approximiert, das geglättet wird, um eine stabile Querregelung zu ermöglichen.


PAP

PAP Ihrer Lösung

Quelltext

Abgerufen von „https://wiki.hshl.de/wiki/index.php?title=SoSe24_-_Praktikum_Systementwurf_-_Spurpolynom&oldid=121323“