<commit_before>clear(); // Löschen aller Variablen
clearglobal(); // Löschen aller globalen Variablen

// Öffnendialog starten
data_path = uigetfile("*.*","","Select CSV data",%t);

// einlesen der Daten
data = fscanfMat(data_path);

numOfTracks = max(data(:,2));
numOfImg = max(data(:,3));

// Spalten
// 2 = TrackID
// 3 = ImageID
// 4 = Xcoord
// 5 = Ycoord


// Trackfolge
// 1 = Ferse
// 2 = Ballen
// 3 = Knöchel
// 4 = Knie

toes = struct('x','y');
heel = struct('x','y');
ankle = struct('x','y');
knee = struct('x','y');

// Bool Anweisung, >, >=, <, <=, ==, ~=
// Größer, Grö.gl., Kleiner, Kl.gl., Gl., ungl.

lowerLimbLength = [];

for i = 1 : numOfImg
    
                                  
    if i == 1 then                
        heel.x = data(10*(i - 1) + 1:i*10 , 4);
        heel.y = data(10*(i - 1) + 1:i*10 , 5) * (-1) + 2;
    elseif i == 2 then
        toes.x = data(10*(i - 1) + 1:i*10 , 4);
        toes.y = data(10*(i - 1) + 1:i*10 , 5) * (-1) + 2;
    elseif i == 3 then
        ankle.x = data(10*(i - 1) + 1:i*10 , 4);
        ankle.y = data(10*(i - 1) + 1:i*10 , 5) * (-1) + 2;
    elseif i == 4 then
        knee.x = data(10*(i - 1) + 1:i*10 , 4);
        knee.y = data(10*(i - 1) + 1:i*10 , 5) * (-1) + 2;
    end
end


disp(ankle.x)       // Equivalent zu print()
disp(ankle.y)

function [distance, CoM] = calcCoM(proximalJoint, distalJoint, anthrof)
    for i = 1 : size(proximalJoint.x,1)
        dx = distalJoint.x(i) - proximalJoint.x(i);
        dy = distalJoint.y(i) - proximalJoint.y(i);
        distance(i) = sqrt((dx)^2 + (dy)^2);
        CoM(i, 1) = dx * anthrof + proximalJoint.x(i);
        CoM(i, 2) = dy * anthrof + proximalJoint.y(i);
    end
endfunction

lowerLimb = [];
centerOfMassLowerLimb = [];

lowerLimb, centerOfMassLowerLimb = calcCoM(knee, ankle, 0.433)

for i = 1:size(ankle.x,1)
    dx = ankle.x(i) - knee.x(i);
    dy = ankle.y(i) - knee.y(i);
    lowerLimbLength(i) = sqrt( (dx)^2 + (dy)^2);
    UsS(i,1) = dx*0.433 + knee.x(i);
    UsS(i,2) = dy*0.433 + knee.y(i);
end

plot(knee.x,knee.y,'or'); // Plot x, y, ?

savetarget = uiputfile("*.txt*");


fprintfMat(savetarget, UsS); // Speichern fprintfMat(Zielpfad, Daten)<commit_msg>neues Auswertungsskript, 12 neue Funktionen, Dokumentation<commit_after>clear(); // Löschen aller Variablen
clearglobal(); // Löschen aller globalen Variablen

//********************************************
//              CONSTANTS
//********************************************

PI = 3.14;


//********************************************
//              DATA-IMPORT
//********************************************

// Öffnendialog starten
data_path = uigetfile("*.*","","Select CSV data",%t);

// Einlesen der Daten
delimiter = " ";                                // Ist klar
regex_ignore = '/(Track).*$/';                  // Löschen aller mit "Track" beginnenden Zeilen
header = 5;                                     // Anzahl an Zeilen im Kopf
data = csvRead(data_path, delimiter, [], [], [], regex_ignore, [], header);

// Meta-Daten der Bilder
nOfT = size(data,1) / max(data(:, 2))           // Number of Tracks
nOfI = max(data(:, 2))                          // Number of Images per Track
DELTA_T = 0.02;                                 // 50 FPS
CALIBRATION = 300;                              // Pix per m / mm?
Y_RESOLUTION = 576;                             // Höhe in Pixeln

// Kalibrieren
data = data / CALIBRATION;

// Eingelesenen Datensatz gemäß der Logik beim Tracken in 8 Datensätze unterteilen
// Jeder Datensatz wird logisch in x und y Werte unterteilt
// Gelenk.x und Gelenk.y enthalten jeweils eine 1 spaltige Matrix mit Koordinatenwerten
// Multiplikation mit -1 der y-Werte um "natürliches Koordinatensystem" zu erhalten
for i = 1 : nOfT                                 
    if i == 1 then                
        toes.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        toes.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 2 then
        ankle.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        ankle.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 3 then
        knee.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        knee.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 4 then
        hip.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        hip.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 5 then
        shoulder.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        shoulder.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 6 then
        elbow.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        elbow.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 7 then
        hand.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        hand.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    elseif i == 8 then
        neck.x = data(nOfI*(i - 1) + 1:i*nOfI , 3);
        neck.y = data(nOfI*(i - 1) + 1:i*nOfI , 4) * (-1) + Y_RESOLUTION;
    end
end


//********************************************
//              NUMERICS
//********************************************

// Ableiten per Vorwärtsdifferenz, erster Wert wird gesetzt
// Übergabe: 1 Spaltige Matrix, Skalares Delta-t
// Rückgabe: 1 Spaltige Matrix
function [fdiff] = ForwardDiff (values, delta)
    fdiff(1) = (values(2) - values(1)) / delta;
    for i = 2 : size(values, 1)
        fdiff(i, 1) = (values(i) - values(i - 1)) / delta;
    end
endfunction

// Ableiten per Rückwärtsdifferenz, letzter Wert wird gesetzt
// Übergabe: 1 Spaltige Matrix, Skalares Delta-t
// Rückgabe: 1 Spaltige Matrix
function [bdiff] = BackwardDiff (values, delta)
    endofdata = size(values,1)
    for i = 1 : endofdata - 1
        bdiff(i) = (values(i + 1) - values(i)) / delta;
    end
    bdiff(endofdata) = (values(endofdata) - values(endofdata - 1)) / delta;
endfunction

// Ableiten per Zentraldifferenz, Mittelwert aus Vorwärts und Rückwärtsdifferenz
// Übergabe: 1 Spaltige Matrix, Skalares Delta-t
// Rückgabe: 1 Spaltige Matrix
function [cdiff]= CentralDiff (values, delta)
    cdiff = (BackwardDiff(values, delta) + ForwardDiff(values, delta)) / 2
endfunction

// Vektorielle Größe in Skalare Größe umwandeln
// Übergabe: Struct mit 1 Spalte x und 1 Spalte y Werten
// Rückgabe: Matrix mit 1 Spalte absoluten Werten
function [scalarValues] = GetScalar(jointData)
    for i = 0 : size(jointData.x, 1)
        scalarValues(i) = sqrt(jointData.x(i)^2 + jointData.y(i)^2);
    end
endfunction

// Gleitenden Mittelwert eines Datensatzes berechnen
// Übergabe: Eine 1 spaltige Matrix
// Rückgabewert: Eine 1 spaltige Matrix
// Erster und letzter Wert werden nicht verändert, Länge der Matrix wird 
// beibehalten
function [movingMean] = MovingMean (values)
    movingMean(1) = values(1);
    endofdata = size(values,1)
    for i = 2 : endofdata - 1
        movingMean = (values(i-1) + values(i) + values(i+1)) / 3;
    end
    movingMean(endofdata) = values(endofdata);
endfunction

// Gewichteter Mittelwert eines Datensatzes berechnen
// Übergabe: Eine 1 spaltige Matrix, drei Gewichtungswerte für vorhergehenden
//           aktuellen und nachfolgenden Wert
// Rückgabe: Eine 1 spaltige Matrix 
function [weightedMovingMean] = WeightedMovingMean (values, weightA, weightB, weightC)
    weightedMovingMean(1) = values(1);
    endofdata = size(values,1)
    for i = 2 : endofdata - 1
        weightedMovingMean = (values(i-1) * weightA + values(i) * weightB + values(i+1) * weightC) / (weightA + weightB + weightC);
    end
    weightedMovingMean(endofdata) = values(endofdata);
endfunction

// Abstand zwischen zwei Punkten über Satz des Pythagoras
// Übergabe: Zwei 2 Spaltige Matrizen
// Rückgabe: Eine 1 Spaltige Matrix mit Skalaren Entfernungswerten
function [limbLength] = GetLimbLength (proximalJoint, distalJoint)
        dx = distalJoint.x(i) - proximalJoint.x(i);
        dy = distalJoint.y(i) - proximalJoint.y(i);
        limbLength(i) = sqrt((dx)^2 + (dy)^2);
endfunction

//********************************************
//              LOKO-FUNCTIONS
//********************************************

// Massenschwerpunkt eines Körperteils berechnen per Anthroprometrie
// Übergabe: Zwei 2 Spaltige Matrizen und skalarer Wert aus Tabelle
// Rückgabe: Eine Zweispaltige Matrix mit Koordinaten des Masseschwerpunkts
function [CoM] = CalcCoM(proximalJoint, distalJoint, anthrof)
    for i = 1 : size(proximalJoint.x,1)
        dx = distalJoint.x(i) - proximalJoint.x(i);
        dy = distalJoint.y(i) - proximalJoint.y(i);
        CoM(i, 1) = dx * anthrof + proximalJoint.x(i);
        CoM(i, 2) = dy * anthrof + proximalJoint.y(i);
    end
endfunction

// Translative Geschwindigkeit eines Punktes / Gelenks berechnen per Zentraldiff
// Übergabe: Eine 2 Spaltige Matrix mit Ortskoordinaten
// Rückgabe: Eine 2 Spaltige Matrix mit Geschwindigkeitsvektoren
function [speed]= CalcSpeed (joint)
    speed.x = CentralDiff(joint.x, DELTA_T);
    speed.y = CentralDiff(joint.y, DELTA_T);
endfunction

// Translative Beschleunigung eines Punktes per Zentraldifferenz
// Übergabe: Eine 2 spaltige Matrix mit Ortskoordinaten
// Rückgabe: Eine 2 spaltige Matrix mit Beschleunigungsvektoren
function [transAcc] = CalcAcceleration (joint)
    speed = CalcSpeed(joint);
    transAcc = CalcSpeed(speed);
endfunction
// Winkel der am mittleren Gelenk von drei übergebenen Gelenken anliegt
// Übergabe: Drei 2 spaltige Matrizen mit Koordinaten
// Rückgabe: Eine 1 spaltige Matrix mit skalaren Winkelwerten (Einheit Grad)
function [angle] = CalcAngle(proximalJoint, middleJoint, distalJoint)
    dxProx = proximalJoint.x - middleJoint.x;
    dyProx = proximalJoint.y - middleJoint.y;
    dxDist = middleJoint.x - distalJoint.x;
    dyDist = middleJoint.y - distalJoint.y;
    angle = (atan(dyProx, dxProx) + atan(dxDist, dyDist)) / (2 * PI) * 180;
endfunction

// Winkelgeschwindigkeit am mittleren Gelenk von drei übergebenen Gelenken
// Übergabe: Drei 2 spaltige Matrizen mit Koordinaten
// Rückgabe: Eine 1 spaltige Matrix mit skalaren Winkelgeschw.werten (Einheit Grad/s)
function [angSpeed]= CalcAngSpeed (proximalJoint, middleJoint, distalJoint)
    angle = CalcAngle(proximalJoint, middleJoint, distalJoint);
    angSpeed = CentralDiff(angle, DELTA_T);
endfunction


plot(knee.x,knee.y,'or'); // Plot x, y, ?

//savetarget = uiputfile("*.txt*");


//fprintfMat(savetarget, UsS); // Speichern fprintfMat(Zielpfad, Daten)
{'fraction_non_alphanumeric': 0.17228823303947874, 'fraction_numerical': 0.02462629359908011, 'mean_word_length': 2.8598372781065087, 'pattern_counts': {'":': 0, '<': 5, '<?xml version=': 0, '>': 5, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '6467415', 'n_tokens_mistral': 4153, 'n_tokens_neox': 3902, 'n_words': 968}