情報処理学会 インタラクション 2020
IPSJ Interaction 2020

3B-25
2020/3/9

Developing a Road Accident Simulator for Automatic Road Accident Report System
Helton Agbewonou YAWOVI†

Tadachika OZONO† Toramatsu SHINTANI†

Abstract: Nowadays, road accidents represent a big challenge for every country in the world. Lot of researches in AI,
Machine Learning and Deep Learning are conducting every year to find some solutions to reduce road accidents
through predictions by using previous data of vehicles crashes. In Our research, we focused on a system that canautomatically build a 3D simulation (for visualization purpose) of an accident given in input the manually madeaccident report. Our simulator, then, automatically generates labeled training data that will be used by the system forimage recognition task to predict the responsibilities of each actor in the accident. The simulator, also, generates asketch of the accident to append to the manually made accident report inputted into the system by the user.

1. Introduction
Since the apparition of vehicles, road accidents are a serious
issue that all countries in the world are facing and challenging.
After an accident, the investigation to know the circumstances
around the incident is very important to determine theresponsibilities of each actor (who was wrong and who was right).
This task sometimes can be time-consuming and, therefore,
support systems are requested. Existing researches [1] have been
focused on support systems that help actors within non mortal
accidents to fulfill the report and draw the sketch by dragging
elements on the interface. This paper proposes an approach ofsimulating in 3D a given accident taking in input its complete
accident report. The system then, after enough training, learns tomake an automatic and instant road accident report based onmachine learning and knowledge systems and predict theresponsibility of each actor in an accident.

2. Automatic road accidents’ 3D simulation system
Our system is a web based application composed of a 3D
simulation system for road accidents that generates thesimulation of an accident based on the inputted accident report in
the system. It takes a full completed accident report, analyzes itto know which kind of road accident it is and simulate that
accident in his 3D view. After the simulation, the systemgenerates the sketch of the accident that is attached to theaccident report and train a model that will be used to predict theresponsibilities of each actor and export again a new accident
report that includes the generated sketch of the accident. Also,
after the exportation of the new accident report with the sketch
included, the system exports the video of the crash as a recorded
video by a dash cam (driving recorder). That video is then stored
as the crash video of the accident to be used later during thetraining process of the model for the AI part to make the decision
about the responsibilities.

generates labeled training data. Moreover, the simulator makes asketch for an accident report when users manually make thereport. Furthermore, they can refer to the simulation or its movies
to consider accidents.
In this paper we describe a) the process of inputting theseimportant information in the system via the submission of thecompleted accident report with a possible selection of thecircumstances of the accident via check-boxes; b) the simulationof the accident in the 3D view; c) the exporting of the sketch of
the accident with exportation of the video of the simulation as thedash cam crash video; d) The model training and the inferenceengine for predicting the responsibilities of each actors of theaccident.

3. Previous work
In a previous work [2], we based our system on a) the driverrecorder of the vehicles (that is the source of the video to train
the model for the image recognition task), b) an IoT part inside
the vehicles that includes speed sensors, GPS chip, accelerometer,gyroscope, shock sensors and detects the shock of the car whenan accident happened, then gets the video from the driverrecorder and send all the data to c) the AI part that processes theinformation sent by the IoT part and generates automatically theassociated report and predict the responsibilities of each actors
using a knowledge system. Figure 1 shows the previous structureof the system.

The inputted report of the system has to respect a generalpolice format, therefore, must contain some important
information such as the date and location of the accident, detailson drivers and vehicles (name, address, phone number, driver'slicense number and date of birth, license plate number…) anddetails about passengers and witnesses as shown as in Figure 2.
Our road accident simulator has two purposes: 1) to generate
training data for an image recognition system and 2) to makesketches of road accidents. To build the image recognition, we
need to collect training data, and the simulator automaticallyFigure 1: The previous system structure†Department of Computer Science, Graduate School ofEngineering - Nagoya Institute of Technology© 2020 Information Processing Society of Japan896

情報処理学会 インタラクション 2020
IPSJ Interaction 2020

3B-25
2020/3/9

4. Design of the system

4.2 The simulation by the 3D simulator

Generally, when an accident occurs, there are two primaryactors or even one sometimes (the other actors are secondary). Soin an accident report, there are usually 2 parties. So one party inthe accident can have only one of these three statuses:
Responsible, Half Responsible or Not Responsible. The outputof the expert algorithm of our system is the degree of negligence(see section 3.4 for more details) and either “unknown”, “-1”, “0”or “1”. “unknown” is set for unknown result (the responsibilities
cannot be determined by the system), “-1” set for the firstprimary driver is not responsible (so the other party is theresponsible), “0” set for the first primary driver is halfresponsible (the responsibilities are shared between the actors)
and “1” set for the first primary driver is responsible of theaccident (so did not respect the traffic rules).

To make our 3D simulator available via browser, we
implemented it using Blender 3D (a free and open-source 3Dcomputer graphics software) and Verge 3D (a real-time rendererof 3D on websites). With Blender 3D, we created (and in somecases imported free models from internet) and animated all
objects (vehicles, buildings, roads, traffic signs…) in the 3D
world. We animated different kinds of accidents with different
scenario and export all these objects into web readable files using
Verge 3D.

To achieve that, our system is essentially composed of 3 mainparts: a) A form that contents a template of the European
accident statement; b) a 3D view for the simulation that will
export the crash video and c) the output panel that will show thenew exported report with the sketch of the accident and theprediction about the responsibilities of the actors.

4.1 The inputted accident report
Accident reports vary from region to region. So a standard
version of an accident report does not exist. But in this paper wewill use the European accident statement format to input data in
our system. To use the system, the user, first needs to fill theform of the accident and describe the circumstances of theaccident by checking some check-boxes and press the “Simulatenow” button.

To make a simulation with our system, the user has to fill theform of the accident report located at the left side of the simulator(as shown in Figure 3) by inputting some important informationof the accident such as the date and location of the accident,details on drivers and vehicles (name, address, phone number,driver's license number and date of birth, license plate number…)and details about passengers and witnesses. Then, he has to selectthe circumstances of the accident by checking the check-boxes
located in the middle of the form. By checking these check-boxes,
the system knows and selects automatically the type of thecorresponding road accident in the list of the accidents located in
the right side of the simulator (as shown in Figure 3). We also
make available the possibility for the user to select the vehicles
he wants to be involved in the simulation. After the selection of
those elements, the user simply presses the button “Simulatenow” to simulate the accident and visualize it in the 3D view.
While simulating the accident, the system generates the video of
the crash and the labeled training data for the image recognition
task to predict the responsibility of each actor in the accident.
Also, after the simulation, it generates the sketch image and put itin the “Sketch of the accident” section in the accident report.

Sketch of theaccident

Sketch of theaccident

Figure 2: A sample of the European accident report template© 2020 Information Processing Society of Japan

Figure 3: A screenshot of our simulator taking in input anaccident report

4.3 The data training
In this section, we describe how to implement the object
detection system for road information in our system. For theobject detection task, we use the object detector YOLOv3 and thelibrary Open CV (The duo is fast and accurate). The program has
to detect the traffic signs and their type or current state and not897

情報処理学会 インタラクション 2020
IPSJ Interaction 2020

only the class they belong to (Ex: the system must detect a 50 km
speed limit sign and not only a limit sign or a green traffic lightand not only a traffic light), road limits, the collided object (it canbe a tree, a car…).
Therefore, we use a YOLO custom trained model with a set ofimages of green/red/yellow traffic lights, 20/130km speed limit
signs, crosswalks, road limits,… generated by the 3D simulator
after a simulation. We followed the steps bellow, including data
annotation, configuration and training, to train YOLO and get ourcustom model [3]:3B-25
2020/3/9

50% returns the result Half Responsible. These results areoutputted after a couple of derivations within our inferenceengine using a forward chaining (reasoning) of a set of rules. Anexample (as shown as in Figure 4 bellow) of the rules can be: “Ifthe pedestrian (the other party in the accident) starts crossingin yellow and the driver (the first party in the accident) enter inred, the degree of negligence for the driver is 90%.”[6]Data annotation: We use the BBox Label Tool (a Pythonlibrary) to annotate the training images (a set of different images
per category: green traffic lights, red traffic lights, crosswalks…).
It allows us to easily generate the training data in the correct
format YOLO requires.
YOLO configuration files: YOLO needs certain specific files
to know how and what to train. We created these three required
files: cfg/obj.data, cfg/obj.names, cfg/yolo-obj.cfg.
The file obj.data contains the information about the number ofclasses we are training, what the train and validation set files are
and what file contains the names for the categories we want todetect. The file obj.names simply contains the name of thecategories. Every new category should be on a new line. The fileyolo-obj.cfg is just the duplication of the original yolov3openimages.cfg [4] that comes with the code of YOLO.
Training YOLO: To start training, YOLO requires a set ofconvolutional weights. So we downloaded, from the official
YOLO website, a set of convolutional weights that was pretrained on ImageNet. This set of convolutional weights file(conv.23 file) provides an excellent starting point and help us to
finally train YOLO.
After the training, we now have a .weights file that
represents our trained model. This trained model file is ourdetector file that our system uses to detect the custom objects in
the generated videos and these detected objects are the input
source for the inference engine and knowledge based task.

4.4 Inference engine and knowledge based task
For the inference engine and knowledge based task of oursystem, we use a set of defined rules to determine either the firstparty of the accident is responsible or not. In road rules there aresome basic methods and principles. One of the methods todetermine the fault of actors after a road accident occurs is called
the degree of negligence (or percentage of fault). Our systemdetermines the responsibility by using this method. According to“legalmatch.com”, “Basically, negligence means that theresponsible party acted in a way that disregarded their duty todrive safely on the road, resulting in injury to the plaintiff [5]”.
If the first party has more than 50% of degree of negligence,the program returns the result Responsible. If it is less than 50%,
the program returns the result Not Responsible and if it equals to© 2020 Information Processing Society of Japan

Figure 4: An example of degree of negligence determination
based on the traffic rules in Japan. From jiko-online.com
Finally after detecting objects in the generated video, thesystem uses the inference engine to predict the responsible of theaccident.

5. Conclusion
After traffic accidents, the police and insurance companies
have to make reports to determine the responsibilities of eachactor. This task being time-consuming and requiring experts’knowledge intervention required support systems. We realized anexpert system to help in making a decision on the responsibilitiesof each actor of the accident and generate a sketch of the accident
giving as input a completed accident report after simulating thecrash in the 3D simulator of the system.
Acknowledgement
This work was supported in part by JSPS KAKENHI Grant
Number JP16K00420, 19K12097, 19K12266.

References[1] Habib M. Fardoun, Daniyal M. Alghazzawi & Antonio Paules
Cipres, “Improving User-Insurance Communication on Accident
Reports”, Page 1-6 (2014).
[2] YAWOVI Agbewonou Helton, OZONO Tadachika, SHINTANIToramatsu: Implementing an automatic and instant road accident
report system using Knowledge System, FIT2019, Vol. 2, F-039,
pp. 353--354.
[3] https://timebutt.github.io/static/how-to-train-yolov2-to-detectcustom-objects/[4] https://pjreddie.com/media/files/yolov3-openimages.weights[5] http://www.jiko-online.com/jiho1.htm[6] https://www.legalmatch.com/law-library/article/negligence-in-acar-accident-lawsuit.html

898