344 lines
16 KiB
Markdown
344 lines
16 KiB
Markdown
# Reader.cs
|
|
|
|
``` cs
|
|
/// Author : Maxime Rohmer
|
|
/// Date : 30/05/2023
|
|
/// File : Reader.cs
|
|
/// Brief : Class used to Read the config file for the OCR
|
|
/// Version : Alpha 1.0
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Text.Json;
|
|
|
|
namespace TrackTrends
|
|
{
|
|
public class Reader
|
|
{
|
|
const int NUMBER_OF_DRIVERS = 20;
|
|
public List<string> Drivers;
|
|
public List<Zone> MainZones;
|
|
|
|
private SqliteStorage _storage;
|
|
private List<DriverData>[] DriverDataLogs = new List<DriverData>[NUMBER_OF_DRIVERS];
|
|
private int[] DriverLaps = new int[NUMBER_OF_DRIVERS];
|
|
|
|
public SqliteStorage Storage { get => _storage; private set => _storage = value; }
|
|
|
|
public Reader(string configFile, Bitmap image, bool loadOCR = true)
|
|
{
|
|
Storage = new SqliteStorage();
|
|
MainZones = Load(image, configFile, ref Drivers, loadOCR);
|
|
}
|
|
/// <summary>
|
|
/// Method that reads the JSON config file and create all the Zones and Windows
|
|
/// </summary>
|
|
/// <param name="imageNumber">The image #id on wich you want to create the zones on</param>
|
|
public List<Zone> Load(Bitmap image, string configFilePath, ref List<string> driverListToFill, bool LoadOCR)
|
|
{
|
|
// Note : You may wonder why in the H... I have all the zones and windows stored in a JSON file and not just for example the first and the last
|
|
// Its because they are not perfectly aligned to each others and every zone has his own alignement to the main image
|
|
List<Zone> mainZones = new List<Zone>();
|
|
Bitmap fullImage = image;
|
|
Zone mainZone;
|
|
|
|
for (int i = 0; i < NUMBER_OF_DRIVERS; i++)
|
|
{
|
|
DriverDataLogs[i] = new List<DriverData>();
|
|
DriverLaps[i] = 0;
|
|
}
|
|
|
|
try
|
|
{
|
|
string jsonString = File.ReadAllText(configFilePath);
|
|
|
|
JsonDocument document = JsonDocument.Parse(jsonString);
|
|
|
|
JsonElement root = document.RootElement;
|
|
|
|
mainZones = new List<Zone>();
|
|
driverListToFill = new List<string>();
|
|
|
|
JsonElement main = root.GetProperty("Main");
|
|
|
|
int x = main.GetProperty("x").GetInt32();
|
|
int y = main.GetProperty("y").GetInt32();
|
|
int width = main.GetProperty("width").GetInt32();
|
|
int height = main.GetProperty("height").GetInt32();
|
|
|
|
mainZone = new Zone(fullImage, new Rectangle(x, y, width, height), "Main");
|
|
|
|
mainZone.ResetWindows();
|
|
mainZone.ResetZones();
|
|
|
|
JsonElement driverZones = main.GetProperty("DriverZones");
|
|
|
|
foreach (JsonElement driverZoneElement in driverZones.EnumerateArray())
|
|
{
|
|
string name = driverZoneElement.GetProperty("name").GetString();
|
|
int driverX = driverZoneElement.GetProperty("x").GetInt32() + mainZone.Bounds.X;
|
|
int driverY = driverZoneElement.GetProperty("y").GetInt32() + mainZone.Bounds.Y;
|
|
int driverWidth = driverZoneElement.GetProperty("width").GetInt32();
|
|
int driverHeight = driverZoneElement.GetProperty("height").GetInt32();
|
|
|
|
Zone driverZone = new Zone(fullImage, new Rectangle(driverX, driverY, driverWidth, driverHeight), "Driver");
|
|
|
|
JsonElement windowsElement = driverZoneElement.GetProperty("Windows");
|
|
|
|
//string[] windowNames = new string[] { "Position","GapToLeader","LapTime","DRS","Tyres","Name","Sector1","Sector2","Sector3" };
|
|
|
|
foreach (JsonElement windowElement in windowsElement.EnumerateArray())
|
|
{
|
|
//Position
|
|
JsonElement posEl = windowElement.GetProperty("Position");
|
|
DriverPositionWindow positionWindow = new DriverPositionWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
posEl.GetProperty("x").GetInt32(),
|
|
posEl.GetProperty("y").GetInt32(),
|
|
posEl.GetProperty("width").GetInt32(),
|
|
posEl.GetProperty("height").GetInt32()),
|
|
LoadOCR);
|
|
|
|
//GapToLeader
|
|
JsonElement gapEl = windowElement.GetProperty("GapToLeader");
|
|
DriverGapToLeaderWindow gapWindow = new DriverGapToLeaderWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
gapEl.GetProperty("x").GetInt32(),
|
|
gapEl.GetProperty("y").GetInt32(),
|
|
gapEl.GetProperty("width").GetInt32(),
|
|
gapEl.GetProperty("height").GetInt32()),
|
|
LoadOCR);
|
|
|
|
//LapTime
|
|
JsonElement lapEl = windowElement.GetProperty("LapTime");
|
|
DriverLapTimeWindow lapWindow = new DriverLapTimeWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
lapEl.GetProperty("x").GetInt32(),
|
|
lapEl.GetProperty("y").GetInt32(),
|
|
lapEl.GetProperty("width").GetInt32(),
|
|
lapEl.GetProperty("height").GetInt32()),
|
|
LoadOCR);
|
|
|
|
//DRS
|
|
JsonElement drsEl = windowElement.GetProperty("DRS");
|
|
DriverDrsWindow drsWindow = new DriverDrsWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
drsEl.GetProperty("x").GetInt32(),
|
|
drsEl.GetProperty("y").GetInt32(),
|
|
drsEl.GetProperty("width").GetInt32(),
|
|
drsEl.GetProperty("height").GetInt32()),
|
|
LoadOCR);
|
|
|
|
//Tyre
|
|
JsonElement tyresEl = windowElement.GetProperty("Tyres");
|
|
DriverTyresWindow tyreWindow = new DriverTyresWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
tyresEl.GetProperty("x").GetInt32(),
|
|
tyresEl.GetProperty("y").GetInt32(),
|
|
tyresEl.GetProperty("width").GetInt32(),
|
|
tyresEl.GetProperty("height").GetInt32()),
|
|
LoadOCR);
|
|
|
|
//Name
|
|
JsonElement nameEl = windowElement.GetProperty("Name");
|
|
DriverNameWindow nameWindow = new DriverNameWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
nameEl.GetProperty("x").GetInt32(),
|
|
nameEl.GetProperty("y").GetInt32(),
|
|
nameEl.GetProperty("width").GetInt32(),
|
|
nameEl.GetProperty("height").GetInt32()),
|
|
LoadOCR);
|
|
|
|
//Sector1
|
|
JsonElement sec1El = windowElement.GetProperty("Sector1");
|
|
DriverSectorWindow sec1Window = new DriverSectorWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
sec1El.GetProperty("x").GetInt32(),
|
|
sec1El.GetProperty("y").GetInt32(),
|
|
sec1El.GetProperty("width").GetInt32(),
|
|
sec1El.GetProperty("height").GetInt32()),
|
|
1, LoadOCR);
|
|
|
|
//Sector2
|
|
JsonElement sec2El = windowElement.GetProperty("Sector2");
|
|
DriverSectorWindow sec2Window = new DriverSectorWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
sec2El.GetProperty("x").GetInt32(),
|
|
sec2El.GetProperty("y").GetInt32(),
|
|
sec2El.GetProperty("width").GetInt32(),
|
|
sec2El.GetProperty("height").GetInt32()),
|
|
2, LoadOCR);
|
|
|
|
//Sector3
|
|
JsonElement sec3El = windowElement.GetProperty("Sector3");
|
|
DriverSectorWindow sec3Window = new DriverSectorWindow(driverZone.ZoneImage,
|
|
new Rectangle(
|
|
sec3El.GetProperty("x").GetInt32(),
|
|
sec3El.GetProperty("y").GetInt32(),
|
|
sec3El.GetProperty("width").GetInt32(),
|
|
sec3El.GetProperty("height").GetInt32()),
|
|
3, LoadOCR);
|
|
|
|
driverZone.AddWindow(positionWindow);
|
|
driverZone.AddWindow(gapWindow);
|
|
driverZone.AddWindow(lapWindow);
|
|
driverZone.AddWindow(drsWindow);
|
|
driverZone.AddWindow(tyreWindow);
|
|
driverZone.AddWindow(nameWindow);
|
|
driverZone.AddWindow(sec1Window);
|
|
driverZone.AddWindow(sec2Window);
|
|
driverZone.AddWindow(sec3Window);
|
|
}
|
|
mainZone.AddZone(driverZone);
|
|
}
|
|
|
|
JsonElement driversElement = main.GetProperty("Drivers");
|
|
foreach (JsonElement driverElement in driversElement.EnumerateArray())
|
|
{
|
|
string driverName = driverElement.GetString();
|
|
driverListToFill.Add(driverName);
|
|
Storage.AddDriver(driverName);
|
|
}
|
|
|
|
mainZones.Add(mainZone);
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
MessageBox.Show("Error reading JSON file: " + ex.Message);
|
|
}
|
|
catch (JsonException ex)
|
|
{
|
|
MessageBox.Show("Invalid JSON format: " + ex.Message);
|
|
}
|
|
int driverID = 0;
|
|
foreach (Zone z in mainZones[0].Zones)
|
|
{
|
|
driverID++;
|
|
z.ZoneImage.Save("LoadedDriver" + driverID + ".png");
|
|
}
|
|
return mainZones;
|
|
}
|
|
/// <summary>
|
|
/// Method that calls all the zones and windows to get the content they can find on the image to display them
|
|
/// </summary>
|
|
/// <param name="idImage">The id of the image we are working with</param>
|
|
/// <returns>a string representation of all the returns</returns>
|
|
public List<DriverData> Decode(List<Zone> mainZones, List<string> drivers)
|
|
{
|
|
List<DriverData> mainResults = new List<DriverData>();
|
|
//Decode
|
|
for (int mainZoneId = 0; mainZoneId < mainZones.Count; mainZoneId++)
|
|
{
|
|
switch (mainZoneId)
|
|
{
|
|
case 0:
|
|
//object lockObject = new object();
|
|
//Main Zone
|
|
Parallel.For(0, mainZones[mainZoneId].Zones.Count, async i =>
|
|
//for (int i = 0; i < mainZones[mainZoneId].Zones.Count; i++)
|
|
{
|
|
DriverData data = mainZones[mainZoneId].Zones[i].Decode(new List<string>(drivers));
|
|
mainResults.Add(data);
|
|
DriverDataLogs[i].Add(data);
|
|
|
|
if (data.Position != -1 && DriverDataLogs[i].Count > 1)
|
|
{
|
|
//Tries to fix the tyres
|
|
if (data.CurrentTyre.NumberOfLaps > DriverDataLogs[i][DriverDataLogs[i].Count - 2].CurrentTyre.NumberOfLaps + 3)
|
|
data.CurrentTyre.NumberOfLaps = DriverDataLogs[i][DriverDataLogs[i].Count - 2].CurrentTyre.NumberOfLaps + 1;
|
|
|
|
//Checking if its a new lap
|
|
//If the third sector is filled but it was'nt the last time, then it means that a new Lap has been started
|
|
//Lap detection can be f***ed if the OCR takes so much time that an entire sector can be raced without us knowing.
|
|
if (
|
|
DriverDataLogs[i][DriverDataLogs[i].Count - 1].Sector3 != 0
|
|
&& DriverDataLogs[i][DriverDataLogs[i].Count - 2].Sector3 == 0
|
|
&& DriverDataLogs[i][DriverDataLogs[i].Count - 2].Position != -1
|
|
&& DriverDataLogs[i][DriverDataLogs[i].Count - 1].Position != -1)
|
|
{
|
|
DriverData stats = new DriverData();
|
|
stats = DriverDataLogs[i][DriverDataLogs[i].Count - 1];
|
|
DriverLaps[i]++;
|
|
Storage.AddDriverStat(stats, DriverLaps[i]);
|
|
}
|
|
//Checking if its a pitstop
|
|
//Forget this the best way to know if a tyre has been changed is if the number of laps is zero
|
|
if (data.CurrentTyre.Coumpound != Tyre.Type.Undefined && data.CurrentTyre.NumberOfLaps == 0 && DriverDataLogs[i][DriverDataLogs[i].Count - 2].CurrentTyre.NumberOfLaps != 0)
|
|
{
|
|
Storage.AddPitstop(data.Name, DriverLaps[i] - 1, data.CurrentTyre.Coumpound.ToString());
|
|
//Driver laps -1 because it would take AT LEAST one lap for this program to detect a pitstop
|
|
}
|
|
}
|
|
DriverDataLogs[i].Add(data);
|
|
});
|
|
break;
|
|
//Next there could be a Title Zone and TrackInfoZone
|
|
}
|
|
}
|
|
//mainResults = mainResults.OrderBy(driver => driver.Position >= 0).ThenBy(driver => driver.Position).ToList();
|
|
mainResults = mainResults.OrderBy(driver => driver.Position).ToList();
|
|
return mainResults;
|
|
}
|
|
/// <summary>
|
|
/// Changes the image in all of the zones wich then will do the same for theyre own subzones and windows
|
|
/// </summary>
|
|
/// <param name="Image">The new Image from the F1TV data channel</param>
|
|
public void ChangeImage(Bitmap Image)
|
|
{
|
|
foreach (Zone z in MainZones)
|
|
{
|
|
z.Image = Image;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Method that can be used to convert an amount of miliseconds into a more readable human form
|
|
/// </summary>
|
|
/// <param name="amountOfMs">The given amount of miliseconds ton convert</param>
|
|
/// <returns>A human readable string that represents the ms</returns>
|
|
public static string ConvertMsToTime(int amountOfMs)
|
|
{
|
|
//Convert.ToInt32 would round upand I dont want that
|
|
int minuts = (int)((float)amountOfMs / (1000f * 60f));
|
|
int seconds = (int)((amountOfMs - (minuts * 60f * 1000f)) / 1000);
|
|
int ms = amountOfMs - ((minuts * 60 * 1000) + (seconds * 1000));
|
|
|
|
return minuts + ":" + seconds.ToString("00") + ":" + ms.ToString("000");
|
|
}
|
|
/// <summary>
|
|
/// Old method that can draw on an image where the windows and zones are created. mostly used for debugging
|
|
/// </summary>
|
|
/// <param name="idImage">the #id of the image we are working with</param>
|
|
/// <returns>the drawed bitmap</returns>
|
|
public Bitmap Draw(Bitmap image, List<Zone> mainZones)
|
|
{
|
|
|
|
Graphics g = Graphics.FromImage(image);
|
|
|
|
foreach (Zone z in mainZones)
|
|
{
|
|
int count = 0;
|
|
foreach (Zone zz in z.Zones)
|
|
{
|
|
g.DrawRectangle(Pens.Red, z.Bounds);
|
|
foreach (Window w in zz.Windows)
|
|
{
|
|
g.DrawRectangle(Pens.Blue, new Rectangle(z.Bounds.X + zz.Bounds.X, z.Bounds.Y + zz.Bounds.Y, zz.Bounds.Width, zz.Bounds.Height));
|
|
}
|
|
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
}
|
|
}
|
|
|
|
```
|