Distributed under a permissive BSD license, Chrono is an open-source multi-physics package used to model and simulate:

• dynamics of large systems of connected rigid bodies governed by differential-algebraic equations (DAE)
• dynamics of deformable bodies governed by partial differential equations (PDE)
• granular dynamics using either a non-smooth contact formulation resulting in differential variational inequality (DVI) problems or a smooth contact formulation resulting in DAEs
• fluid-solid interaction problems whose dynamics is governed by coupled DAEs and PDEs
• first-order dynamic systems governed by ordinary differential equations (ODE)
• sensors (camera, LiDAR, GPS, IMU, SPAD) to support simulation in robotics and autonomous agents via a ROS2 interface

Chrono provides a mature and stable code base that continues to be augmented with new features and modules. The core functionality of Chrono provides support for the modeling, simulation, and visualization of rigid and flexible multibody systems with additional capabilities offered through optional modules. These modules provide support for additional classes of problems (e.g., granular dynamics and fluid-solid interaction), modeling and simulation of specialized systems (such as ground vehicles and robots), co-simulation, run-time visualization, post-processing, interfaces to external linear solvers, or specialized parallel computing algorithms (multi-core, GPU, and distributed) for large-scale simulations.

Used in many different scientific and engineering problems by researchers from academia, industry, and federal government, Chrono has mature support for multibody dynamics, finite element analysis, granular dynamics, fluid-solid interaction, ground vehicle simulation, robotics, embodied AI, and terramechanics.

Implemented almost entirely in C++, Chrono also provides Python and C# APIs. The build system is based on CMake. Chrono is platform-independent and is actively tested on Linux, Windows, and MacOS using a variety of compilers.

• Project website
• Build and install instructions

• C++ API reference
  • Main development branch
  • Release 9.0.1
  • Release 8.0.0
• Python interface
  • PyChrono
• Reference manuals
  • Core module
  • Chrono::Vehicle module

• Google Groups user forum

The structure of the Chrono git repository was changed as follows:

• The main development branch is now called main (previously develop)
• The master branch, now obsolete, was deleted
• Releases are located in branches named release/*.* and have tags of the form *.*.*

A Mediator implementation for Dart inspired by MediatR.

This package provides a simple yet configurable solution.

• Request/Response
• Commands
• Request/Command Pipelines
• Events
• Event Observers

An event can have multiple handlers. All handlers will be executed in parallel (by default).

import 'package:dart_mediator/mediator.dart';

/// Strongly typed event class containing the event data.
/// All events must implement the [DomainEvent] interface.
class MyEvent implements DomainEvent {}

Future<void> main() async {
  final mediator = Mediator.create();

  // Subscribe to the event.
  mediator.events.on<MyEvent>()
    .subscribeFunction(
      (event) => print('event received'),
    );

  // Sends the event to all handlers.
  // This will print 'event received'.
  await mediator.events.dispatch(MyEvent());
}

A command can only have one handler and doesn’t return a value.

/// This command will not return a value.
class MyCommand implements Command {}

class MyCommandHandler implements CommandHandler<MyCommand> {
  @override
  FutureOr<void> handle(MyCommand request) {
    // Do something
  }
}

Future<void> main() async {
  final mediator = Mediator.create();

  mediator.requests.register(MyCommandHandler());

  /// Sends the command request. Return value is [void].
  await mediator.requests.send(MyCommand());
}

A request can only have one handler and returns a value.

import 'package:dart_mediator/mediator.dart';

class Something {}

/// This query will return a [Something] object.
class MyQuery implements Query<Something> {}

class MyQueryHandler implements QueryHandler<Something, MyQuery> {
  @override
  FutureOr<Something> handle(MyQuery request) {
    // do something
    return Something();
  }
}

Future<void> main() async {
  final mediator = Mediator.create();

  mediator.requests.register(MyQueryHandler());

  // Sends the query request and returns the response.
  final Something response = await mediator.requests.send(MyQuery());

  print(response);
}

An observer can be used to observe events being dispatched, handled or when an error occurs. For example logging events.

class LoggingEventObserver implements EventObserver {

  /// Called when an event is dispatched but before any handlers have
  /// been called.
  @override
  void onDispatch<TEvent>(
    TEvent event,
    Set<EventHandler> handlers,
  ) {
    print(
      '[LoggingEventObserver] onDispatch "$event" with ${handlers.length} handlers',
    );
  }

  /// Called when an event returned an error for a given handler.
  @override
  void onError<TEvent>(
    TEvent event,
    EventHandler handler,
    Object error,
    StackTrace stackTrace,
  ) {
    print('[LoggingEventObserver] onError $event -> $handler ($error)');
  }

  /// Called when an event has been handled by a handler.
  @override
  void onHandled<TEvent>(
    TEvent event,
    EventHandler handler,
  ) {
    print('[LoggingEventObserver] onHandled $event -> $handler');
  }
}

void main() {
  final mediator = Mediator.create(
    // Adds the logging event observer.
    observers: [LoggingEventObserver()],
  );

  // Dispatch an event.
}

A pipeline behavior can be used to add cross cutting concerns to requests/commands. For example logging.

class LoggingBehavior implements PipelineBehavior {
  @override
  Future handle(dynamic request, RequestHandlerDelegate next) async {
    try {
      print('[LoggingBehavior] [${request.runtimeType}] Before');
      return await next();
    } finally {
      print('[LoggingBehavior] [${request.runtimeType}] After');
    }
  }
}

void main() {
    final mediator = Mediator.create();

    // add logging behavior
    mediator.requests.pipeline.registerGeneric(LoggingBehavior());
}

• MediatR

This project is a Python script that enables you to download tagged images from Imgur.

This script supports two download modes: sequential and threaded.

• Sequential: In this mode, images are downloaded one after another using only the main thread of the process.

• Threaded: This mode creates multiple threads to download images concurrently.

The script measures and logs the time taken to download the images in both modes. This enables you to see the effect of using the different modes and different numbers of threads on the script’s performance.

The project’s only dependency is the requests module, which can be installed using pip:

pip install requests

The script also requires an Imgur client ID which should be set in your environment variables as imgur_client_id. To obtain an Imgur client ID, create an account on Imgur and follow the instructions on registering an application.

To run the script, you need to use the command line. Navigate to the directory containing the script, then run the command with the following format:

python download.py --tag <tag> --mode <mode> [--threads <threads>]

Where:

• <script name> is the name of the python file.
• <tag> is the tag of the images you want to download. For example, astronomy or cats.
• <mode> is the download mode which can be either threaded or sequential.
• <threads> (optional) is the number of threads to use in threaded mode. Default is 10. Only valid when --mode=threaded.

An example command to download images tagged with astronomy using 10 threads is:

python download.py --tag astronomy --mode threaded --threads 12

Examples of Imgur tags you can use include: astronomy, cats, cars, nature, earth.

The downloaded images will be saved in an images directory in the same location as the script. Each run will save its images in a new directory with the current time stamp. For tags with multiple images, each image will be saved in a separate directory within this top-level directory.

Number or letter sequences are easy to obtain when you are only interested in sequence of numbers (ascending or descending) that follow
a predefined order, for example decimal numbers 0,1,2,3,4,5,6,7,8,9 always follow that order, the number 1 will follow the number 0, the number 3 will follow the number 2.

Other numbers of larger quantities also follow the same order of formation, all are composed of digits between 0 and 9. This same feature for sequential letters can be applied to vowels, all of which correspond to characters sequences that follow a predefined order.

But, what if you need to create a sequence that has a completely different formation order? A string or number that does not follow the rule natural of decimal numbers or the alphabet? For example, if you need to create sequences like the following:

AA-0001
AA-0002
AA-0003

AA-9999
AB-0001
AB-0002
AB-0003

AB-9999
AC-0001
AC-0002
AC-0003

AC-9999
AD-0001
AD-0002
AD-0003


Other sequence

A-2019-01
A-2019-02
A-2019-03

A-2019-99
B-2019-01
B-2019-02

B-2019-99
C-2019-01
C-2019-02

How to create growing sequences but made up of characters made up of letters, numbers, punctuation marks, etc.? For this kind of need it is that the “sequence” package was created which contains classes and the means that allow the definition of a sequence of alphanumeric values and the generation these values in ascending / descending sequential order.

You can define any sequence of numeric or alphanumeric characters, which can be letters, numbers, decimals, hexadecimals, DNA sequence, etc. Using the sequence generator you can create sequences that will be generated in ascending or descending order.

You can create your own sequences or use the predefined ones.

Example:

seq = factory("WM [0-9][0-9]")
for x in range(100):
    print(seq.next().get())
    
seq = factory("WM [0-9]{2}")
for x in range(100):
    print(seq.next().get())
    
seq = factory("WM [0-9]{2}", order=[0, 1])
for x in range(100):
    print(seq.next().get())
    

• exrex

Audious is a virtual assistant for music collections. Amongst other things, it provides the ability to manage albums by indicating the ones which are not in playlists. It also gives detailed statistics about a music collection, such as the number of artists and albums or the overall duration of a music category. It can also be used to sanitize playlists by showing corrupted or missing songs, and can export playlists in different formats, such as FLAC or MP3.

🎶

The more your music collection will grow, the more it will be difficult to remember which albums and songs you liked or listened to. Playlists are there to help us reminding which songs or albums we liked. But there might be albums that you didn’t place in a playlist. Audious will help you managing the albums that are not present in your playlists.

Having information about the song currently being played or even the year of the album you want to listen to is easy. However, getting the number of artists and albums, or how finding long it would take you if you wanted to listen to your entire music collection, it’s a different story. Audious will give you statistics about your music collection as well as your playlists.

Nowadays, space is cheap. But lossless music is still demanding in size. Having your entire music collection with you all the time on a phone might be impossible. Audious will export all the songs of your playlists and ensure that your favorite songs will always be with you.

🎶

• Getting started: This section provides everything that is required to install Audious. It also shows how to setup it properly.
  1. Requirements
  2. Installation
  3. Edit the preferences
  4. Launching Audious
• Tips: Several tips are given in this section to have a better user experience.
• For Developers and Audiophiles: Audious has been designed as an open source project since day 1. This section clarifies the tool’s internals, explaining how to generate the source code documentation, and how the MP3 conversion is performed during the exportation process.
• About: The origin of the project and the different licenses are detailed in this section.

🎶

Without music, life would be a mistake. — F. Nietzsche

• A basic knowledge of lossless and lossy audio formats
• A command line
• Python 3
• FFmpeg, which includes the FLAC and LAME packages
• A music collection with FLAC songs
• M3U playlists
• A wish to organize a music collection with playlists

• Install FFmpeg and LAME on the OS:
  • On macOS: brew install ffmpeg lame
  • On Linux (Debian-based): sudo apt install ffmpeg lame
• Clone this repository: git clone https://github.com/sljrobin/Audious
• Go to the Audious directory: cd Audious/
• Create and activate a Python virtual environment:
  • python3 -m venv venv
  • source ./venv/bin/activate
• Install the requirements with pip3: pip install -r requirements.txt

• A preferences file, named preferences.json, is available under a preferences/ directory located at root of the repository. It needs to be properly configured before running Audious for the first time.
• The file is presented as follow:

{
  "collection": {
    "root": "",
    "playlists": "",
    "music": {
      "artists": "",
      "soundtracks": ""
    }
  },
  "exportation": {
    "root": "",
    "playlists": "",
    "format": ""
  }
}

• As it can be seen above, the file contains two main keys, collection and exportation.

The collection key gives details about the music collection:

• root is the absolute path of the directory where is located the music collection
• playlists is the directory containing all the playlists
• music gives the different categories of the music collection. For instance:
  • artists is the directory that contains all the Artists of the music collection
  • soundtracks on the other hand, contains only soundtracks
  • Other music categories can be added under the music key (e.g. "spoken word": "Spoken Word/")
  • The artists and soundtracks keys are not mandatory, however, at least one key is required
• Note: all given directories should have an ending / (e.g. Artists/, and not Artists)

For instance, let’s suppose that a simple music collection is structured as follow:

Collection/
├── Artists/
├── Playlists/
└── Soundtracks/

The collection key in preferences.json should be edited as shown below:

"collection": {
  "root": "/Users/<username>/Music/Collection/",
  "playlists": "Playlists/",
  "music": {
    "artists": "Artists/",
    "soundtracks": "Soundtracks/"
}

The exportation key gives details about the playlists exportation:

• root is the absolute path of the directory where will be located the exported songs and playlists
• playlists is the directory containing all the exported playlists
• format is the format song for the playlists exportation; only two options are available: flac and mp3
• Note: all given directories should have an ending / (e.g. Artists/, and not Artists)

For instance, let’s suppose that we create an Export/ directory in the Collection/ and we want to export all the songs of the playlists in FLAC; the exportation key in preferences.json should be edited as shown below:

"exportation": {
  "root": "/Users/<username>/Music/Collection/Export/",
  "playlists": "Playlists/",
  "format": "flac"
}

• Ensure first the Python virtual environment is enabled by running source ./venv/bin/activate
• Run Audious: python audious.py --help

% python audious.py --help
usage: audious.py [-h] [-e] [-p] [-s]

optional arguments:
  -h, --help    show this help message and exit
  -e, --export  Export the playlists in FLAC or in MP3
  -p, --pick    Pick the albums from the music collection that are not in the playlists
  -s, --stats   Provide statistics of the music collection and the playlists

• Everything is now ready!

Because Audious is capable of parsing big music collections, the generated outputs might be relatively long. As a result, it might be difficult to have a quick glance at the statistics of a category or at the albums that were picked without scrolling.

An easy way to handle this scrolling issue is to combine Audious with the less command, as shown in the examples below:

• python audious.py -s | less -R
• python audious.py -p | less -R

Press the space bar to switch to the next page on the terminal.

Hidden files on Linux or macOS are beginning with a dot (.). For instance, macOS creates lots of these files, called resource forks. As a result, an album with a song called 08 - High Voltage.flac might also contain a hidden file name ._08 - High Voltage.flac.

Audious is capable of handling these hidden files; it will indicate that it is not a valid file and does not contain any valid metadata. Nevertheless, having these files might generate a lot of noise in Audious outputs with plenty of errors (e.g. The following song could not be parsed and will be ignored: [...]).

To recursively remove these files and have clean outputs, go to the root of the music collection and use the following commands (Source):

• To only display hidden files in the music collection:

find /<path to music collection> -name '._*' -type f

• To delete hidden files in the music collection:

find /<path to music collection> -name '._*' -type f -delete

• The source code of Audious has been thoroughly documented in order to help people adding new features or simply improving the code.
• Because the code is commented, generating a documentation becomes easy.
• Amongst most popular solutions, we recommend using pydoc for the documentation generation process.
• Examples:
  • Generate the documentation for the Exporter() class: python -m pydoc lib/exporter.py
  • Generate the documentation for the entire library: python -m pydoc lib/*
  • Follow this tutorial for more information about pydoc
• Snippet of the documentation for the lib/collection.py class:

NAME
    collection

CLASSES
    builtins.object
        Collection

    class Collection(builtins.object)
     |  Collection(display, preferences)
     |
     |  Methods defined here:
     |
     |  get_category_albums(self, category_songs)
     |      Open a category in the music collection and get a list of all the albums contained in this category.
     |      Handle macOS hidden files. Check the number of albums in the music category as well as in the music collection.
     |      Increment the total.
     |
     |      :param list category_songs: list of songs contained in a music category.
     |      :return list category_albums: list of albums contained in a music category.
     |
     |  get_category_songs(self, category, path)
     |      Open a category in the music collection and get a list of all the songs contained in this category. Select
     |      only .mp3 and .flac files with a regex.
     |
     |      :param str category: the music collection category name.
     |      :param str path: the path where the music collection category is located.
     |      :return list category_songs: list of songs contained in a music category.
[...]

• Ogg format offers a better sound quality compared to the MP3 format. (Source)
• The MP3 format was chosen as the secondary format in the exportation options. This decision was made to ensure a better compatibility with devices (e.g. vintage audio systems, etc.).

• A list of all FFmpeg parameters can be obtained with ffmpeg --help.
• The MP3 conversion is performed via FFmpeg with the following command:

ffmpeg -v quiet -y -i <song.flac> -codec:a libmp3lame -qscale:a 0 -map_metadata 0 -id3v2_version 3 <song.mp3>

• The parameters that were used are detailed below. They were carefully selected by following the FFmpeg MP3 Encoding Guide.
  • -v quiet: does not produce any log on the console
  • -y: overwrites output files
  • -i <song.flac>: gives a song in FLAC as input (note: a full path is required)
  • -codec:a libmp3lame: specifies to use the libmp3lame codec
  • -qscale:a 0: controls quality, 0 being the lower value, it provides the higher quality possible
  • -map_metadata 0: properly maps the FLAC song metadata to the MP3 song metadata (Source)
  • -id3v2_version 3: selects ID3v2.3 for ID3 metadata
  • <song.mp3>: specifies the exported song in MP3 (note: a full path is required)

• VBR Encoding was preferred to CBR Encoding.
• -qscale:a 0 is an equivalent of -V 0 and produces an average of 245 kbps for each exported song.
• More information about the settings is available here.

• In case other formats need to be supported for the exportation process, the -map_metadata 0 will need to be changed.
• Indeed, mapping metadata to files with FFmpeg might be tricky and the parameter need to be modified, depending on the wished export format.
• For more information, please refer to:
  • FLAC to OGG conversion with metadata kept
  • Mapping metadata with avconv does not work
  • Converting FLAC with images into OGG with FFmpeg

The name “Audious” was taken from the HBO’s Silicon Valley. In this comedy television series, “Audious” is also a virtual assistant but seems to have more bugs!

• Audious is licensed under the MIT License (Source)
• FFmpeg is licensed under the LGPL License (Source)
• tinytag is licensed under the MIT License (Source)

«crnn-ctc» implemented CRNN+CTC

ONLINE DEMO：LICENSE PLATE RECOGNITION

For each sub-dataset, the model performance as follows:

If you want to achieve license plate detection, segmentation, and recognition simultaneously, please refer to zjykzj/LPDet.

• Table of Contents
• News🚀🚀🚀
• Background
• Installation
• Usage
  • Train
  • Eval
  • Predict
• Maintainers
• Thanks
• Contributing
• License

This warehouse aims to better understand and apply CRNN+CTC, and has currently achieved digital recognition and license plate recognition. Meanwhile, LPRNet(+STNet) is a pure convolutional architecture for license plate recognition network. I believe that the implementation of these algorithms can help with the deployment of license plate recognition algorithms, such as on edge devices.

Relevant papers include:

1. Towards End-to-End License Plate Detection and Recognition: A Large Dataset and Baseline
2. An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition
3. Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks
4. LPRNet: License Plate Recognition via Deep Neural Networks

Relevant blogs (Chinese):

1. Towards End-to-End License Plate Detection and Recognition: A Large Dataset and Baseline
2. An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition
3. LPRNet: License Plate Recognition via Deep Neural Networks

$ pip install -r requirements.txt

Or use docker container

$ docker run -it --runtime nvidia --gpus=all --shm-size=16g -v /etc/localtime:/etc/localtime -v $(pwd):/workdir --workdir=/workdir --name crnn-ctc ultralytics/yolov5:latest

• ChineseLicensePlate: Baidu Drive(ad7l)

# EMNIST
$ python3 train_emnist.py ../datasets/emnist/ ./runs/crnn-emnist-b512/ --batch-size 512 --device 0 --not-tiny
# Plate
$ python3 train_plate.py ../datasets/chinese_license_plate/recog/ ./runs/crnn-plate-b512/ --batch-size 512 --device 0 --not-tiny

# EMNIST
$ CUDA_VISIBLE_DEVICES=0 python eval_emnist.py crnn-emnist.pth ../datasets/emnist/ --not-tiny
args: Namespace(not_tiny=True, pretrained='crnn-emnist.pth', use_lstm=False, val_root='../datasets/emnist/')
Loading CRNN pretrained: crnn-emnist.pth
crnn-emnist summary: 29 layers, 7924363 parameters, 7924363 gradients, 2.2 GFLOPs
Batch:49999 ACC:100.000: 100%|████████████████████████████████████████████████████████| 50000/50000 [03:47<00:00, 219.75it/s]
ACC:98.570
# Plate
$ CUDA_VISIBLE_DEVICES=0 python3 eval_plate.py crnn-plate.pth ../datasets/chinese_license_plate/recog/ --not-tiny
args: Namespace(add_stnet=False, not_tiny=True, only_ccpd2019=False, only_ccpd2020=False, only_others=False, pretrained='crnn-plate.pth', use_lprnet=False, use_lstm=False, use_origin_block=False, val_root='../datasets/chinese_license_plate/recog/')
Loading CRNN pretrained: crnn-plate.pth
crnn-plate summary: 29 layers, 15083854 parameters, 15083854 gradients, 4.0 GFLOPs
Load test data: 149002
Batch:4656 ACC:100.000: 100%|████████████████████████████████████████████████████████████| 4657/4657 [00:52<00:00, 89.13it/s]
ACC:82.147

$ CUDA_VISIBLE_DEVICES=0 python predict_emnist.py crnn-emnist.pth ../datasets/emnist/ ./runs/predict/emnist/ --not-tiny
args: Namespace(not_tiny=True, pretrained='crnn-emnist.pth', save_dir='./runs/predict/emnist/', use_lstm=False, val_root='../datasets/emnist/')
Loading CRNN pretrained: crnn-emnist.pth
crnn-emnist summary: 29 layers, 7924363 parameters, 7924363 gradients, 2.2 GFLOPs
Label: [0 4 2 4 7] Pred: [0 4 2 4 7]
Label: [2 0 6 5 4] Pred: [2 0 6 5 4]
Label: [7 3 9 9 5] Pred: [7 3 9 9 5]
Label: [9 6 6 0 9] Pred: [9 6 6 0 9]
Label: [2 3 0 7 6] Pred: [2 3 0 7 6]
Label: [6 5 9 5 2] Pred: [6 5 9 5 2]

$ CUDA_VISIBLE_DEVICES=0 python predict_plate.py crnn-plate.pth ./assets/plate/宁A87J92_0.jpg runs/predict/plate/ --not-tiny
args: Namespace(add_stnet=False, image_path='./assets/plate/宁A87J92_0.jpg', not_tiny=True, pretrained='crnn-plate.pth', save_dir='runs/predict/plate/', use_lprnet=False, use_lstm=False, use_origin_block=False)
Loading CRNN pretrained: crnn-plate.pth
crnn-plate summary: 29 layers, 15083854 parameters, 15083854 gradients, 4.0 GFLOPs
Pred: 宁A·87J92 - Predict time: 5.4 ms
Save to runs/predict/plate/plate_宁A87J92_0.jpg
$ CUDA_VISIBLE_DEVICES=0 python predict_plate.py crnn-plate.pth ./assets/plate/川A3X7J1_0.jpg runs/predict/plate/ --not-tiny
args: Namespace(add_stnet=False, image_path='./assets/plate/川A3X7J1_0.jpg', not_tiny=True, pretrained='crnn-plate.pth', save_dir='runs/predict/plate/', use_lprnet=False, use_lstm=False, use_origin_block=False)
Loading CRNN pretrained: crnn-plate.pth
crnn-plate summary: 29 layers, 15083854 parameters, 15083854 gradients, 4.0 GFLOPs
Pred: 川A·3X7J1 - Predict time: 4.7 ms
Save to runs/predict/plate/plate_川A3X7J1_0.jpg

• zhujian – Initial work – zjykzj

• rinabuoy/crnn-ctc-loss-pytorch
• we0091234/crnn_plate_recognition
• sirius-ai/LPRNet_Pytorch
• CA-USTC/License_Plate_Recognition_pytorch
• zjykzj/LPDet

Anyone’s participation is welcome! Open an issue or submit PRs.

Small note:

• Git submission specifications should be complied with Conventional Commits
• If versioned, please conform to the Semantic Versioning 2.0.0 specification
• If editing the README, please conform to the standard-readme specification.

Apache License 2.0 © 2023 zjykzj

This section will go over my knowledge of the COBOL programming language. I am not very experienced with it, and likely won’t dedicate too much time to it, since it is obsolete, and only used by dinosaur mainframe computers in businesses and governments who refuse to update from an 8 bit system while the rest of the world uses (rarely:32 bit) 64 bit and 128 bit systems. Enough bashing of the language with jargon terms, so far I actually like writing in it for some reason. It isn’t as productive as C or Python though, so I prefer to stick with a newer, modern language.

In COBOL, to print to the screen you use the DISPLAY keyword like so:

DISPLAY "Sample text".

COBOL comments are written like so:

*> COBOL only supports single line comments

Out of this example, I can only memorize the DISPLAY keyword. Here is the standard Hello World program in COBOL

       IDENTIFICATION DIVISION.
       PROGRAM-ID. hello-world.
       PROCEDURE DIVISION.
           DISPLAY "Hello, world!"
           .

In COBOL, a . must be placed at the end of every line. It is the languages equivalent to a semicolon. It is done like so:

DISPLAY "EOL".

1. COBOL stands for COmmon Business Oriented Language

2. COBOL uses the .cob .cbl and .cpy file extension, and according to Notepad++ it also uses the .cdc file format.

3. The Jargon file refers to COBOL as “a language for dinosaur computers”

4. COBOL is considered archaic by its own developers since the 1970s (specifically after the release of the C programming language) but it is still used by too many industries (over 5 billion lines of code written annually, over 200 billion lines of COBOL in total)

5. COBOL is NOT a semicolon and curly bracket language

6. No other knowledge of the COBOL programming language.

Hi, I’m Long, author of this repository 🚀.

YOLOV7-BASED VIETNAMESE ID CARD DETECTION

• In this day and age, we have many model detection such as Faster-RCNN, SDD, YOLO, and so on.
• More specifically, we will apply the lastest version of YOLO, namely YOLOv7. In order to take ROI in ID Card, we additionally use Perspective Transform based on 4 orientations of image, namely top-left, top-right, bottom-left, bottom-right.
• However, when we cut the ROI in image completely, the orientation of image is not correct. Moreover, many applications have used classification model to category the corners such as CNN, ResNet50, AlexNet, and so on. But this method will be low inference.
• Therefore, we decide to apply mathematics so as to calculate the corner replied on the orientated vector of top-left and top-right that we will describe in this repository.

First of all, we need to install anaconda environment.

• conda

  conda create your_conda_environment
  conda activate your_conda_environment

Then, we install our frameworks and libraries by using pip command line.

• pip

  pip install -r path/to/requirements.txt

We suggest that you should use python version 3.8.12 to implement this repository.

1. Check CUDA and install Pytorch with conda

   nvidia-smi
   conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch

2. Clone the repository

   git clone https://github.com/Syun1208/IDCardDetectionAndRecognition.git

1. Preprocessing Data

• Dataset size

      Total: 21777 images (100%)
      Train: 10888 images (50%)
      Val: 4355 images (20%)
      Test: 6534 (30%)

• Data’s label structure.

  [    
    {
        "image": "/home/long/Downloads/datasets/version1/top_132045101_13680_jpg.rf.6d2adba419f676ee9bbab8c5a277a1b2.jpg",
        "id": 13946,
        "label": [
            {
                "points": [
                    [
                        8.88888888888889,
                        36.796875
                    ],
                    [
                        86.25,
                        37.1875
                    ],
                    [
                        85.83333333333333,
                        64.765625
                    ],
                    [
                        9.305555555555555,
                        64.609375
                    ]
                ],
                "polygonlabels": [
                    "top-cmnd"
                ],
                "original_width": 720,
                "original_height": 1280
            }
        ],
        "annotator": 9,
        "annotation_id": 16871,
        "created_at": "2022-09-27T11:06:56.424119Z",
        "updated_at": "2022-09-27T11:06:58.197087Z",
        "lead_time": 15.073
    }, 
    ......................
  ]

• Folder structure trained on YOLOv7

    ├── test
    │   ├── images
    │   └── labels
    ├── train
    │   ├── images
    │   └── labels
    └── val
        ├── images
        └── labels

• If you want custom datasets(json) to yolo’s bounding box, please run this command line.

  python path/to/data/preprocessing/convertJson2YOLOv5Label.py --folderBoundingBox path/to/labels --folderImage path/to/images --imageSaveBoundingBox path/to/save/visualization --jsonPath path/to/json/label 

• If you want custom datasets(json) to yolo’s polygon and 4 corners of images, please run this command line.

  python path/to/data/preprocessing/convertJson2YOLOv54Corners.py --folderBoundingBox path/to/save/labels --folderPolygon path/to/save/labels --folderImage path/to/images --imageSaveBoundingBox path/to/save/visualization --imageSavePolygon path/to/save/visualization --jsonPath path/to/json/label

• Padding your dataset containing image.

  python path/to/data/preprocessing/augment_padding_datasets.py --folder path/to/folder/images --folder_save --path/to/save/result

2. Testing on local computer

• Put your image’s option and run to see the result

  python path/to/main.py --weights path/to/weight.pt --cfg-detection yolov7 --img_path path/to/image 

3. Testing on API

• You need change your local host and port which you want to configure

  python path/to/fast_api.py --local_host your/local/host --port your/port

4. Request to API

• If you are down for requesting a huge of image to API, run this command

  python path/to/test_api.py --url link/to/api --source path/to/folder/images

• Data Cleaning
• Preprocessing Data
• Model Survey and Selection
• Do research on paper
• Configuration and Training Model
• Testing and Evaluation
• Implement Correcting Image Orientation
• Build Docker and API using FastAPI
• Write Report and Conclusion

See the open issues for a full list of proposed features ( and known issues).

Based on the predicted bounding box, we will flip the image with 3 cases 90, 180, 270 degrees by calculating the angle between vector Ox and vector containing coordinates top left and top right for vector AB with A as top left, B is the top right of the image as shown below.

Let’s assume that vector AB(xB – xA, yB-yA) is the combination between top_left(tl) and top_right(tr) coordination. Therefore, we will have the equation to rotate.

On the other hand, if the image has the angle which is different with zero and greater than 180 degrees, the image will be considered with the condition below to rotate suitably. Otherwise, the angle will be rotated following the figure above.

Finally we will flip in an anti-clockwise angle.

1. Polygon Detection

2. Correcting Image Rotation

3. Image Alignment

4. Results in API

   [
       {
           "image_name": "back_sang1_jpg.rf.405e033a9ecb2fb3593541e6ae20d056.jpg"
       },
       [
           {
               "class_id": 0,
               "class_name": "top_left",
               "bbox_coordinates": [
                   11,
                   120,
                   111,
                   287
               ],
               "confidence_score": 0.76953125
           },
           {
               "class_id": 1,
               "class_name": "top_right",
               "bbox_coordinates": [
                   519,
                   136,
                   636,
                   295
               ],
               "confidence_score": 0.85498046875
           },
           {
               "class_id": 2,
               "class_name": "bottom_right",
               "bbox_coordinates": [
                   524,
                   383,
                   636,
                   564
               ],
               "confidence_score": 0.89697265625
           },
           {
               "class_id": 3,
               "class_name": "bottom_left",
               "bbox_coordinates": [
                   41,
                   404,
                   104,
                   560
               ],
               "confidence_score": 0.7001953125
           }
       ],
       {
           "polygon_coordinates": {
               "top_left": {
                   "x_min": 61.0,
                   "y_min": 203.5
               },
               "top_right": {
                   "x_max": 577.5,
                   "y_min": 215.5
               },
               "bottom_right": {
                   "x_max": 580.0,
                   "y_max": 473.5
               },
               "bottom_left": {
                   "x_min": 72.5,
                   "y_max": 482.0
               }
           }
       }
   ]

1. Fork the Project
2. Create your Feature Branch

• git checkout -b exist/folder

3. Commit your Changes

• git commit -m 'Initial Commit'

4. Push to the Branch

• git remote add origin https://git.sunshinetech.vn/dev/ai/icr/idc-transformation.git
• git branch -M main
• git push -uf origin main

5. Open a Pull Request

My Information – LinkedIn – longpm@unicloud.com.vn

Project Link: https://github.com/Syun1208/IDCardDetectionAndRecognition.git

• Unicloud Group
• Leader: Kieu-Anh Nguyen