A curated list of resources dedicated to Machine Learning applications to LEGO bricks.

• Brickognize [2022.12], Talk from the author [2022.07] – Web application which recognizes any Lego part, minifigure, or set.
• Bricksee [2022.11] – Mobile application for organizing a Lego collection with a feature to detect parts from a photo.
• BrickMonkey [2022.11] – Mobile application to recognize minifig and parts.
• RebrickNet [2022.01] – Web application on rebrickable.com. Currently, it detects and recognizes 300 different parts and an unspecified number of colors. Train using real videos and photos submitted by users.
• Minifig Finder [2021.12] – Web application for minifig identification. Uses Mask R-CNN for detecting individual parts (head, torso, and legs) and metric learning for classification. Currently, it looks abandoned and not working.
• Unnamed mobile app [2021.10], Update 1 [2021.11], Update 2 [2021.12] – Unnamed and unreleased mobile app. Uses LDraw renders for training a classifier. The first version recognized only six different parts.
• Brickit [2021.07] – Mobile application for detecting parts and suggesting models which can be built from those parts.
• Brickly [2021.04] – Unfinished and unreleased app for part detection and identification.
• Instabrick, Kickstarter [2019.10], Review [2021.04] – Camera and web application for part identification and inventory.
• BrickBanker [2020.12] – Mobile application which detects up to 2k different parts.

• DIY LEGO Sorting Machine Backgrounds on design choices [2023.12] – The article looks into the details and individual components of our specific sorting machine, explaining the rationale behind various design decisions
• Exploring LEGO Sorting Machines: A Survey of Designs [2023.12] – The article provides a comprehensive overview of the wide range of existing LEGO sorting machines.
• BrickSortingMachine [2023.08], Blog, Code, LEGO build instructions – A LEGO brick sorting machine.
• Lego Sorting Machine [2023.08] – Sorting machine [in progress].
• Nexus [2023.03] – Open-source sorting machine with CAD designs and code available.
• Standard Sorter v1.0 [2023.01] – The robotic arm that can sort based on color and/or size.
• Eppos Sorting Machine [2023.01] – Industrial sorting machine built for 3Bricks.
• Big Robot [2022.06] – Initiative to build Lego AI Open Source Sorting Machine.
• Universal LEGO Sorting Machine [2022.06], Description – Sorting machine built for BSL Bricks store.
• Deep Learning Lego Sorter [2021.11] – A sorting machine built from Lego with instruction and code available.
• Lego Automatic Sorting LegoLAS 2.0 [2021.08], Description (in German), CAD – Student project in the Laboratory for Computer Science in Engineering and Computational Mathematics.
• DISBY Sorting Machine [2021.01] – DISBY is the world’s first automated Lego brick sorting system. It features a novel AI system that recognizes bricks based on a minimal formal description retrieved from the internet (e.g. size, weight, and description).
• The World’s First Universal LEGO Sorting Machine [2019.12], Classifier [2019.12], Dataset [2019.03], CV Pipeline [2019.08] – Sorting machine built by Daniel West.
• The Shape Sifter [2019.06], Blog – The Shape Sifter is a Lego sorting machine utilizing a neural network, image processing software, a conveyor belt, and air jets.
• Lego Sorter using TensorFlow on Raspberry Pi [2018.09] – Sorting machine that recognizes 11 different parts.
• Letzgo Sorter [2018.01] – Sorting machine built for Letzgo company. There are a few more videos available but not many details.
• Automatic Lego Sorting Machine – Students’ report containing the design of the sorting machine. Mostly related to the mechanical side of the machine.
• Sorting 2 Metric Tons of Lego [2017.04], Software Side [2017.05] – One of the first publically described sorter that uses ML for part classification.

• JetClean [2022.10] – JetClean is a small robotic Lego cleaner capable of autonomously navigating around your bedroom and keeping it tidy!

• Setognize [2024.06] – Code for a mobile app that can recognize 50 dfferent Lego sets.
• LegoSorter [2023.09] – Code for a mobile app that can recognize and count Lego bricks. It includes scripts for rendering the dataset, training the model, and the backend for the app.
• OpenBlok [2022.11] – OpenBlok is an open-source Lego identification and sorting system using AI models developed by blokbot.io
• Lego Brick Recognition [2020.03] – Code for generating synthetic dataset and training a classifier for 15 different parts.
• Lego Classifier [2019.08] – Detailed description of training a part classifier and deploying it on Arduino.
• Lego Detector [2019.03] – Code for training a classifer.

• Brickinspector [2023.02], Paper – The paper describes the process of using synthetic data for training semantic segmentation model for detecting Lego parts.
• How to sort them? A network for LEGO bricks classification [2022.07] – The paper presents a comparison of 28 models used for image classification trained to recognize 447 different LEGO bricks.
• Hierarchical 2-step neural-based LEGO bricks detection and labeling [2021.04] – The paper proposes two-step system for identifying LEGO bricks — detection and classification. The model is limited to recognizing only 10 different parts.
• Lego Recognition Tool [2018.03] – The diploma thesis describes the process of developing a machine, that is capable of identifying Lego bricks and sorting them into boxes.

• B200 LEGO Detection Dataset [2024.03] – Dataset for parts detection. It contains 2k high-quality renders for 200 different parts.
• Photos and rendered images of LEGO bricks [2023.11] – The paper describes a collection of datasets containing both LEGO brick renders and real photos. The datasets contain around 155,000 photos and nearly 1,500,000 renders.
• Video of LEGO bricks on conveyor belt [2022.01] – The dataset contains videos of LEGO bricks moving on a white conveyor belt to train a classifier for sorting machine.
• B200C LEGO Classification Dataset [2021.08], Code – Dataset for parts classification. It contains 800k high-quality renders for 200 different parts.
• LEGO bricks for training classification network [2021.06] – The dataset part classification. It contains images of 447 different parts, both real photos (52k) and renders (567k).
• Tagged images with LEGO bricks [2021.02] – The dataset for parts detection. It contains 2933 photos and 2908 renders annotated with bounding boxes. It doesn’t include information about part IDs.
• Lego Brick Sorting [2018.12] – The dataset for parts classification. It contains 4,580 photos of 20 different parts.
• Lego vs. Generic Brick [2018.12] – The dataset for recognizing original vs fake bricks. It contains 12 classes across 6 brick types, and more than 20k images taken by 4 cameras.

• BrickRenderer [2023.06] – Render realistic training images of ldraw pieces.
• Lego Rendering Pipeline [2023.06] – Rendering pipeline for semi-realistic, individual parts.
• Lego multi object detection [2021.11] – Script to generate renders of LEGO parts and corresponding bounding boxes. Uses Python and Blender.
• BrickRegistration [2021.11] – A tool to generate synthetic 3d scenes with LEGO parts and their segmentation information.
• Lego Renderer for ML Projects [2020.01] – A set of Python scripts/Blender utilities for rendering Lego scenes for use in deep learning/computer vision projects. Includes a basic scene with a tracked camera, scripts for rendering images, normals, masks of Lego combinations, and utilities for recording the positions of special features on different pieces (studs, corners, holes) easily.
• Rendering LDraw Parts Images for Rebrickable [2018.10] – Comprehensive guide describing how Rebrickable rendered their images.

• Rebrickable numbering [2023.02]
• Understanding LEGO part numbers [2020.10]
• The curious case of LEGO colors [2016.09] – This post explores the difficulty of defining the exact LEGO color palette. It discusses the various lists, conversions, and color systems.
• Let’s talk about classification of parts
• LDraw Part Number Specification
• Bricklink Item Numbers

• Brick Yourself within 3 Minutes [2022.05] – Given the input portrait, it uses several deep neural networks to extract the attributes to describe the human appearance shown in the image. Built on these attributes, the model generates the corresponding uncolored brick model by iteratively searching for brick components with the coordinate descent algorithm. Finally, it assigns a color to every brick to get the final brick model.
• Brick-by-Brick: Combinatorial Construction with Deep Reinforcement Learning [2021.10] – Generating sets step by step from the 2D images using RL.
• Image2Lego: Customized LEGO® Set Generation from Images [2021.08] – The system takes an image as an input, encodes it as embedding, generates a voxelized 3D model, and finally convert it into LEGO bricks. The model jointly trains a 3D model autoencoder and a 2D-to-3D encoder.
• Automatic Generation of Vivid LEGO Architectural Sculptures [2019] – It introduces an automatic system to convert an architectural model into a LEGO sculpture while preserving the original model’s shape features like repeating components, shape details and planarity.
• Legolization: Optimizing LEGO Designs [2015] – It converts a 3D model into a voxelized 3D model, and then into LEGO bricks. The paper focuses on optimizing the physical stability of the generated design.
• Survey on Automated LEGO Assembly Construction [2014] – The survey paper on converting 3D models into LEGO models.

• Lego sets made in LDraw – Links to over 2000 LEGO sets recreated in LDraw.
• LDraw Official Model Repository – LDraw repository of over 1800 official LEGO sets.
• BrickHub – Almost 500 original and custom sets.

• Robotic LEGO Assembly and Disassembly from Human Demonstration [2023.05] – This paper presents a system that automates LEGO assembly and disassembly by learning from human demonstration.
• Planning Assembly Sequence with Graph Transformer [2022.10] – A graph transformer-based framework for ASP problem, with a heterogeneous graph attention network to encoder the models, which are decoded with the attention mechanism to generate assembly sequence.
• Translating a Visual LEGO Manual to a Machine-Executable Plan [2022.07] – Understanding the assembly process using manual.
• Break and Make: Interactive Structural Understanding Using LEGO Bricks [2022.07] – Introduction of a new task for visual understanding, 3D simulator to manipulate LEGO models, and a model to solve the proposed task of recreating the LEGO model.
• Building LEGO Using Deep Generative Models of Graphs [2020.12] – It proposes a way to represent the LEGO model as graphs and learn how to generate them step-by-step.

• Lego Minifig XL [2023.08] – Stable Diffusion model for generating Minifigures.
• Lego Brickheadz XL [2023.09] – Stable Diffusion model for generating Brickheadz.

• The AI Revolution: How Artificial Intelligence Is Impacting the LEGO Community [2023.11] – The post discusses how AI-generated “LEGO” sets are sparking a debate between inspiration and imitation within the AFOL community.
• Reimagining LEGO sets [2023.03] – Generating realistic versions of LEGO sets.
• LEGO Stable Diffusion [2023.01] – Fine-tuned stable diffusion model for generating images in the LEGO style.
• Generating LEGO Pirates sets and minifigures [2023.01] – Generating LEGO Pirates sets and minifigures using Stable Diffusion.
• Using AI to generate minifigures [2020.07], Part 2 [2020.08], Part 3 [2020.08] – Using different GANs to generate images of minifigures.

• MobileBrick: Building LEGO for 3D Reconstruction on Mobile Devices [2023.03] – A dataset of 153 Lego sets focusing on detailed 3D object reconstruction with a unique data modality of high-resolution RGB images with low-resolution depth maps captured on a mobile device.

• Lego Learning: Using Machine Learning to Predict the Future Value of Lego Sets [2023.11] – Using machine learning algorithms to predict future prices of sets.

• Weeding out or picking winners in open innovation? Factors driving multi-stage crowd selection on LEGO ideas [2023.12] – Very detailed analysis of the factors behind the winning entries on the LEGO Ideas platform.
• Building a GenAI Solution — A Hackathon Success Story! [2023.11] – Description of the winning project of the internal Generative AI Hackathon at the LEGO Group. It focuses on generating a set description based on metadata and an image.
• AI Summit London: Lego’s Brian Schwab on Interaction Design [2023.06] – A short talk with Brian Schwab without many details about the augmented reality for playing with Lego bricks.
• A One-Stop Data Shop: The Lego Group’s Anders Butzbach Christensen [2023.03] – Podcast (and transcript) about LEGO data platform.
• How LEGO plays with data: An interview with chief data officer Orlando Machado [2022.12]
• Inside the annual LEGO Brick Hack [2022.11] – Short description of internal Data Science hackathon.
• Building Blocks of Machine Learning at LEGO with Francesc Joan Riera [2021.11] – Podcast about using ML at LEGO. In particular, their ML infrastructure, content moderation system, and classifying images of LEGO models into thematical categories.

• Awesome LEGO – General list of LEGO resources.

Refer the medium article for a better understanding: https://medium.com/@asavinda/c-program-for-text-compression-using-huffman-coding-6625d31d9e43?source=friends_link&sk=834b8706a7852100070b9000786fc010

This implementation has two seperate C programs. One will input a text file and will output a compressed version of the text file into two separate files. One is the .huffman file which has the content. The other file is .table file where it contains the huffman lookup table. The other program is used for decompression. This program inputs the above generated two .huffman file and .table file and will output a .txt file.

This method of coding was introduced by David A. Huffman In 1951. while he was a Ph.D. student at MIT. He was given the task to find an efficient way of coding and came up with the idea of using a frequency-sorted binary tree and proved this method to be the most efficient. He published a paper in 1952 titled “A Method for the Construction of Minimum Redundancy Codes“.

Huffman tree is a technique that is used to generate codes that are distinct to each other. Using this method, most occurring symbols will get the least number of bits and others accordingly.

1. Sort all the different symbols and their particular frequency or probability.
2. Take the two lowest probability symbol and create a new common node with the probability equal to the sum of the two probability. Always make sure to add the lowest summing up nodes.
3. Add the new node to the table instead of the lowest two symbols or nodes.
4. Repeat step two and three until one symbol or node is remaining.
5. Then allocate ‘0’ to all the right branches and ‘1’ to all right branches
6. Read the bits from top of the tree to the bottom to each symbol and record their particular bit pattern

Consider the following sentence.

THIS IS COMMUNICATION ENGINEERING

The following table represents the letters and their occurances in the above sentence.

For the above table, consider the following huffman tree. Arrange all the letters in ascending order in their frequency of their occurance.

Compile both of the programs called huffman_encode.c and huffman_decode.c using GCC.

gcc -o huffman_encode huffman_encode.c
gcc -o huffman_decode huffman_decode.c

After Compiling use the huffman_encode binary to encode or compress any given text file in .txt format. For example, if you input abc.txt file, this will output two separate files in the same directory with abc.huffman and abc.table extensions.

huffman_encode abc.txt

Use the huffman_decode binary to decode or decompress any .huffman and .table file. These two files are mandatory. The decoded file will be saved in a directory with extension .decoded

huffman_decode abc.txt.huffman

An Ansible Role that configures swap space on Linux.

None.

Available variables are listed below, along with default values (see defaults/main.yml):

swap_file_path: /swapfile

The location of the swap file on the server.

swap_file_size_mb: '512'

How large (in mebibytes) to make the swap file.

swap_swappiness: '60'

The vm.swappiness value to be configured in sysconfig.

swap_file_state: present

If you wish to remove your swapfile, and disable swap, set this to absent. Generally you’d probably want to set this to present.

swap_file_create_command: "dd if=/dev/zero of={{ swap_file_path }} bs=1M count={{ swap_file_size_mb }}"

The command used to create the swap file. You could switch to using fallocate to write the swap file more quickly, though there may be inconsistencies if not writing the file with dd.

None.

- hosts: all

  vars:
    swap_file_size_mb: '1024'

  roles:
    - geerlingguy.swap

MIT / BSD

This role was created in 2018 by Jeff Geerling, author of Ansible for DevOps.

This is a collection of scripts and data I used when working on my dissertation.

• recording_procedure.praat – this is the script I used for collecting the audio
  data (it’s a mess like most Praat scripts I’ve written, but it was good enough
  to do what I wanted)

• survey.sur – PsyToolkit survey for collecting metadata and running the
  experiment
• rating_experiment.psy – The experiment itself
• scale_l_to_r.txt – Code that draws a sliding scale in
  rating_experiment.psy with left-to-right orientation
• scale_r_to_l.txt – Code that draws a sliding scale in
  rating_experiment.psy with right-to-left orientation
• sounds.txt – List of audio files used in the experiment (audio files are not
  included due to license limitations)
• bitmaps/ – Collection of pictures used in rating_experiment.psy
• tables/ – Collection of sounds used in rating_experiment.psy. Each table has
  three columns: variable name, file name, duration

• measure_EER.py – script that draws DET curves and calculates EER values from
  the sid_results_table_individual_files_filtered.csv results table. Simply
  run python measure_EER.py. The script creates a folder named
  EER_measurements which contains temporary files to verify that same and
  different speaker labels are correct.
• sid_results_table_individual_files_filtered.csv – different-sex recordings
  have been filtered out

• phonexia_lid_wrapper.sh – wrapper for the Phonexia LID technology (this is
  mainly here to show which subset of languages was used in the analysis)
• speechbrain_lid_wrapper.py – wrapper for the SpeechBrain LID technology it
  subclasses the EncoderClassifier to extract scores for English and Czech apart
  from the best-matching language (the audio files are not included due to
  license limitations so the script does not really produce the results!)

• sid4_wrapper.sh – wrapper for the Phonexia SID4 technology. A simple helper
  script which extracts voiceprints from all wave files in one directory and
  then compares all voiceprints with each other. It also saves the amount of
  “net speech” in each voiceprint to a file.
• speechbrain_sid_wrapper.py – a wrapper for SpeechBrain’s SpeakerRecognition.
  It has options for computing embeddings from audio files or loading previously
  created embeddings. It subclasses SpeakerRecognition in order to be able to
  perform verification on embeddings instead of on audio files.
  The script creates embeddings from all audio files in a directory and then
  performs speaker verification either on all combinations or all permutations
  of the embeddings set.

Um jogo simples e divertido para testar sua rapidez e percepção de cores.

Sobre • Como Jogar • Demonstração • Tecnologias Utilizadas • Licença • Contato

Uma aplicação simples desenvolvida em HTML, CSS e JavaScript. O objetivo do jogo é clicar no botão cujo texto corresponde à cor exibida acima do botão. O desafio é que o nome da cor é exibido em uma cor diferente, então você precisa estar atento à cor real do texto, não ao seu nome.

O jogo fica cada vez mais difícil conforme você acerta, aumentando a velocidade em que as cores são alteradas e o tempo para fazer a escolha correta diminui.

1. Abra o arquivo index.html no seu navegador ou acesse a demonstração online aqui.
2. Clique no botão “Iniciar” para começar o jogo.
3. A cor e o nome da cor serão exibidos acima dos botões coloridos.
4. Clique no botão com o nome da cor que corresponde à cor do texto exibida acima do botão.
5. Se acertar, sua pontuação aumenta e uma nova cor é exibida. Se errar, ou o tempo acabar, o jogo termina.

Veja o jogo em ação aqui (link para a demonstração online).

• HTML
• CSS
• JavaScript

Este projeto está licenciado sob a MIT License. Sinta-se à vontade para modificar e usar o código conforme necessário.

Para mais informações ou sugestões, entre em contato por e-mail em pscampos221@gmail.com ou visite meu site pessoal pscamposs.

This is the online source repository of Wsite, a lightweight and fully-customizable web server and service with a
Java-powered backend.

In its current state, Wsite is only meant for testing and development-purposes only. Not recommended to
use in production. That being said, a demo of it is being ran at http://whizvox.me

The following must be installed:

• Java 8 or greater: Oracle /
  OpenJDK

If you are having any problems building or running, use Java 8, not Java 9+.

Optional:

• Gradle 4.x
• sqlite3

Run ./gradlew shadowJar. The result will be in ./build/libs/wsite-<version>.jar

Run ./gradlew run. The service will use ./rundir as the working directory.

• First running will result in a small setup service being hosted at localhost:4568/
• Fill in (at minimum) the fields under Initial operator (the SSL and SMTP fields don’t do anything right now)
• Submit the form, and the server will restart with the standard routes
• Login at /login (logout at /logout)
• Every route prefixed with /control will require an operator to be logged in.
• Goto /control to view all available control options

This Windows ransomware example is written in 100% Rust. This code encrypts all files that the computer can read and write under the User directory.

To use the ransomware, you will need to compile it from the source. Here are the steps to do so:

1. Clone the repository to your local machine: git clone https://github.com/kuzeyardabulut/RustyLock.git

2. Install Rust on your machine if you haven’t already. You can download Rust from the official website: https://www.rust-lang.org/tools/install

3. Navigate to the project directory and compile the code:

cd RustyLock
cargo build --release

4. Once the code is compiled, you can run the ransomware:
   ./target/release/inject.exe

5. The ransomware will encrypt all files in the User directory and its subdirectories with the AES algorithm.

This ransomware has been designed to encrypt files on a user’s system and demand a ransom for their release. Here’s how it works:

1. Upon execution, the ransomware copies itself to the startup folder to ensure persistence across reboots.
2. It then scans the user’s directory and subdirectory for files that have read-write permissions and creates a list of these files, which it saves in the /tmp/ directory. The ransomware then waits for the next startup.
3. During the next startup, the ransomware reads the list of files saved in the /tmp/ folder and begins encrypting them. Even if the system is turned off during this process, no data loss will occur. When the system is turned back on, the ransomware will resume the encryption process from where it left off.
4. Once the encryption process is complete, the ransomware creates a file named encoded.txt and awaits the next startup.
5. During the next startup, the ransomware detects the encoded.txt file and begins to decrypt the system. Again, even if the system is turned off during this process, no data loss will occur.
6. Once all decryption processes are complete, the ransomware and its traces are deleted to avoid detection.

Upon opening the .exe file, the program first runs the anti-debugger and check_process functions. If these anti-reversing functions are passed without error, an incognito window is created. In this window, the path of the current location of the .exe file is retrieved, and the file is copied to \AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup. The .dll file in the same directory is also copied to the \AppData\Local\Programs\Microsoft Store folder. Essentially, this adds the .exe to the startup scripts of Windows, ensuring that the file runs each time the computer is turned on.

In real Ransomware examples, running a .exe in startup scripts is not always advisable. Therefore, they can do some configuration for regedit, enabling the .exe to be run in the same way as startup scripts. However, to add configuration to regedit, the user must run the .exe as an administrator.

Following these steps, the ransomware’s .dll file is injected into SecurityHealthSystray using the dll_syringe library. The .dll file activates many security functions, most of which are sourced from here. These anti-reversing functions are performed for a while and the program waits for their completion. If no issues are found during the check, the ransomware is launched.

Initially, AES keys are defined. In real examples, keys are randomly generated and transmitted to the server side over the internet. Every time the program is opened and closed, the program communicates with the server side with certain security measures until the encryption is complete. All key exchanges on the server side and client side are conducted in an asymmetric encrypted manner, making it impossible to reverse engineer and find the key.

Once the keys are created, directories are defined and the program starts. It first checks whether the system has been encrypted before by examining the \AppData\Local\Temp\encoded.txt file (in real examples, this is usually done by communicating with the APIs). If the system has been encrypted before, the program decrypts it using the decrypt_large_file function. Otherwise, the encrypt_file function is called to initiate the encryption.

When these functions are called, the program checks whether the target function has previously been executed. If so, it resumes from where it left off; otherwise, it starts the target function from the beginning.

This ransomware is for educational purposes only. Please do not use it for any malicious activities. The author is not responsible for any damages or legal issues caused by the misuse of this code.

This code is licensed under the MIT License. Please see the LICENSE file for more details.

Contributions are welcome! If you find any bugs or have any suggestions for improvement, please create a pull request.

No Longer Maintained – About to be rewritten.

Guys, I am extremely sorry to say that the Django Server code is severely broken and needs a complete rewrite, I’ll be doing that really soon, so until then. Stay Tuned. 🤷🏽‍♂️

Other than being a mouthful to say; FRAS allows tens of facial-recognition-camera-clients aka tiny Raspberry Pi-es to be deployed all across a college, or an industrial campus, which then record who they see and when they see then to a central database.

The entire system runs for dirt cheap on cloud using Microsoft Face API, Heroku and AWS S3 and using multiple Raspberry Pi Zeros, which cost about 15–17$

1. A Django REST Server, with a PostGres Database runs on Heroku.
2. A 15$ Raspberry Pi Zero with a Camera Module and internet connection is placed at any location – entrances, exits, hallways
3. The Raspberry Pi – Camera Client takes an image at regular intervals and sends this to Microsoft Face API, which tells who-is-who in the image.
4. The Camera Client then sends the names of recognized persons to the REST Server for storage with the captured images which are sent to AWS S3 for storage.
5. Angular Frontend allows users to view the stored data.

This was my high school’s final semester project on which I barely spent 48 hours building. The REST Server and Angular proved to be quite an undertaking! But, the professor seems pleasantly surprised with what I built so it all ended just fine. 🙂

Every Camera Client is responsible for recognizing all of the faces on it’s own and communicating with the Microsoft Face API as well as saving the images to S3, also the users connected to the Angular Client can also need to see the uploaded images, so everything ends up looking like this.

The Main Page shows the list of all registered people, Face API is sent about ~20 images of each person during the initial setup.

Shows the most recently captured images from all Camera Clients

Shows a list of all dates and number of present people, selecting one of them takes you to the next page.

Shows all of the lectures which were held that day in school, and how many people were present for those.

Shows how many students were present for that particular lecture.

This is a high level description of what you could do, but feel free to hit me up on Hangouts at rohansawantct83@gmail.com if you are interested in getting something like this up and running.

1. Setup Microsoft Face API
2. Build OpenCV on a Raspberry Pi Zero
3. Setup up Django Server on Heroku
4. Setup Angular Frontend on Heroku
5. Setup AWS S3

On one rainy day in July, I dejectedly shook my head at the distressed professor who stared back at me, wondering where half of the class was? I shrugged helplessly, and went back to daydreaming about the Black Mirror episode which I watched earlier that day. The school had tried everything, taking attendance twice during lectures, making everyone sign a piece of paper passed around the class, fining for those who remained absent … you name it. All of these seemed like foolproof solutions to the problems according to the school’s middle management, me? I had my doubts.

Lack of attendance in school during lectures…hmm, maybe AI could help me solve this, and helped me-solve-this it did, well at least on paper for the time being.

YES! We could turn the college campus into a total surveillance state, monitor everyone, store everyone’s faces, track their every move, and use that to generate helpful insights to make the world a better place. 🙃

That was how everything started, there are still a lot of features which I left unexplored, Face API also provides support for emotion recognition…

Why? So we know our happy students from the sad ones?

Maybe I could add activity recognition? That would help teachers pick the sleepiest of their pupils.

:down-the-rabbit-hole: 🐇

In my worst nightmares, I imagine a highly sophisticated version of this running running on embedded devices like the Nvidia Nano – on every street corner, every shop and every stop light, the data could be continuously stored in on the blockchain with no central point of failure, as we try and hope hard that our Funky-Glasses are enough to fool the cutting edge ML Models.

NOTE: This project is retired as the component is not accessible.

Similar functionality is now provided by the Multiple variant of the Select With Search component, which is available in the govuk_publishing_components gem.

The accessible autocomplete is a component that helps users choose answers from a list you provide. You can also use it to make the answers you get from users more consistent.

If you’re asking users to provide their country or territory, the govuk-country-and-territory-autocomplete might be more appropriate.

This is a fork of the accessible-autocomplete component. It adds additional functionality such as support for select multiple.

accessible-autocomplete is a JavaScript autocomplete built from the ground up to be accessible. The design goals are:

• Accessibility: Following WAI-ARIA best practices and testing with assistive technologies.
• User experience: Supporting a wide variety of user needs.
• Compatibility: Working with recommended browsers and assistive technologies.

Try out the examples!

The GOV.UK Design System team maintains the accessible autocomplete as a standalone component. However, we’re only able to put in minimal work to support it.

Read about our plans to maintain this component.

Read more about the types of support we can provide.

Install it by running:

npm install --save accessible-autocomplete

The accessibleAutocomplete function will render an autocomplete <input> and its accompanying suggestions and aria-live region. Your page should provide a <label> and a container element:

<label for="my-autocomplete">Select your country</label>
<div id="my-autocomplete-container"></div>

Then import it using a module system like Browserify / Webpack / Rollup, and call the accessibleAutocomplete function, providing an array of values:

import accessibleAutocomplete from 'accessible-autocomplete'

const countries = [
  'France',
  'Germany',
  'United Kingdom'
]

accessibleAutocomplete({
  element: document.querySelector('#my-autocomplete-container'),
  id: 'my-autocomplete', // To match it to the existing <label>.
  source: countries
})

If you want to use it as a replacement for a <select> element, read the Progressive enhancement section.

You can copy the dist/accessible-autocomplete.min.js file to your JavaScript folder and import it into the browser:

<script type="text/javascript" src="assets/js/accessible-autocomplete.min.js"></script>

A stylesheet is included with the package at dist/accessible-autocomplete.min.css.

You can copy it to your stylesheets folder and import it into the browser:

<link rel="stylesheet" href="assets/css/accessible-autocomplete.min.css" />

You can also import it using Sass:

@import "accessible-autocomplete";

If you already use Preact in your application, you can import a bundle that will use that:

import preact from 'preact'
import Autocomplete from 'accessible-autocomplete/preact'

preact.render(
  <Autocomplete id='autocomplete' source={suggest} />,
  document.querySelector('#container')
)

Try out the Preact example!

If you already use React in your application, you can import a bundle that will use that:

import React from 'react'
import ReactDOM from 'react-dom'
import Autocomplete from 'accessible-autocomplete/react'

ReactDOM.render(
  <Autocomplete id='autocomplete' source={suggest} />,
  document.querySelector('#container')
)

Try out the React example!

React v15.5.4 has been tested to work with the Accessible Autocomplete – although make sure to check out documented issues.

React v15.6.2 and 16.0 have been incompletely tested with the Accessible Autocomplete: while no undocumented issues were found, we recommend you carry out thorough testing if you wish to use these or later versions of React.

Type: HTMLElement

The container element in which the autocomplete will be rendered in.

Type: string

The id to assign to the autocomplete input field, to use with a <label for=id>. Not required if using enhanceSelectElement.

Type: Array | Function

An array of values to search when the user types in the input field, or a function to take what the user types and call a callback function with the results to be displayed.

An example of an array of values:

const countries = [
  'France',
  'Germany',
  'United Kingdom'
]

If source is a function, the arguments are: query: string, populateResults: Function

Similar to the source argument for typeahead.js, a backing data source for suggestions. query is what gets typed into the input field, which will callback to populateResults synchronously with the array of string results to display in the menu.

An example of a simple suggestion engine:

function suggest (query, populateResults) {
  const results = [
    'France',
    'Germany',
    'United Kingdom'
  ]
  const filteredResults = results.filter(result => result.indexOf(query) !== -1)
  populateResults(filteredResults)
}

Type: Object

Sets html attributes and their values on the menu. Useful for adding aria-labelledby and setting to the value of the id attribute on your existing label, to provide context to an assistive technology user.

Type: Boolean

Set to true to highlight the first option when the user types in something and receives results. Pressing enter will select it.

Type: Boolean

The autocomplete will confirm the currently selected option when the user clicks outside of the component. Set to false to disable.

Type: string

Use this property to override the BEM block name that the JavaScript component will use. You will need to rewrite the CSS class names to use your specified block name.

Type: string

Specify a string to prefill the autocomplete with.

Type: 'inline' | 'overlay'

You can set this property to specify the way the menu should appear, whether inline or as an overlay.

Type: number

The minimum number of characters that should be entered before the autocomplete will attempt to suggest options. When the query length is under this, the aria status region will also provide helpful text to the user informing them they should type in more.

Type: string

The name for the autocomplete input field, to use with a parent <form>.

Type: Function

Arguments: confirmed: Object

This function will be called when the user confirms an option, with the option they’ve confirmed.

Type: string

This option will populate the placeholder attribute on the input element.

We think placeholders have usability issues and that there are better alternatives to input placeholder text, so we do not recommend using this option.

Type: Boolean

The input field will be rendered with a required attribute, see W3C required attribute definition.

Type: Boolean

If this is set to true, all values are shown when the user clicks the input. This is similar to a default dropdown, so the autocomplete is rendered with a dropdown arrow to convey this behaviour.

Type: Boolean

The autocomplete will display a “No results found” template when there are no results. Set to false to disable.

Type:

{
  inputValue: Function,
  suggestion: Function
}

This object defines templates (functions) that are used for displaying parts of the autocomplete.

inputValue is a function that receives one argument, the currently selected suggestion. It returns the string value to be inserted into the input.

suggestion is a function that receives one argument, a suggestion to be displayed. It is used when rendering suggestions, and should return a string, which can contain HTML.

⚠️ Caution: because this function allows you to output arbitrary HTML, you should make sure it’s trusted, and accessible.

If your template includes child elements with defined foreground or background colours, check they display correctly in forced colors modes. For example, Windows high contrast mode.

Type: Function

A function that gets passed an object with the property className ({ className: '' }) and should return a string of HTML or a (P)React element. ⚠️ Caution: because this function allows you to output arbitrary HTML, you should make sure it’s trusted, and accessible.

Type: Function

A function that receives no arguments and should return the text used in the dropdown to indicate that there are no results.

Type: Function

A function that receives one argument that indicates the minimal amount of characters needed for the dropdown to trigger and should return the text used in the accessibility hint to indicate that the query is too short.

Type: Function

A function that receives no arguments and should return the text that is used in the accessibility hint to indicate that there are no results.

Type: Function

A function that receives two arguments, the selectedOption and the amount of available options, and it should return the text used in the accessibility hint to indicate which option is selected.

Default:

(length, contentSelectedOption) => {
  const words = {
    result: (length === 1) ? 'result' : 'results',
    is: (length === 1) ? 'is' : 'are'
  }

  return <span>{length} {words.result} {words.is} available. {contentSelectedOption}</span>
}

Type: Function

A function that receives two arguments, the count of available options and the return value of tStatusSelectedOption, and should return the text used in the accessibility hint to indicate which options are available and which is selected.

Type: Function

A function that receives no arguments and should return the text to be assigned as the aria description of the html input element, via the aria-describedby attribute. This text is intended as an initial instruction to the assistive tech user. The aria-describedby attribute is automatically removed once user input is detected, in order to reduce screen reader verbosity.

If your autocomplete is meant to select from a small list of options (a few hundred), we strongly suggest that you render a <select> menu on the server, and use progressive enhancement.

If you have the following HTML:

<select id="location-picker">
  <option value="fr">France</option>
  <option value="de">Germany</option>
  <option value="gb">United Kingdom</option>
</select>

You can use the accessibleAutocomplete.enhanceSelectElement function to enhance it into an autocomplete:

accessibleAutocomplete.enhanceSelectElement({
  selectElement: document.querySelector('#location-picker')
})

This will:

• Place an autocomplete input field after the specified <select>
• Default the autocomplete autoselect to true
• Default the autocomplete defaultValue to the select’s option[selected]
• Default the autocomplete id to the <select>‘s id
• Default the autocomplete name attribute to '' to prevent it being included in form submissions
• Default the autocomplete source to use existing <option>s from the <select>
• Hide the <select> using inline display: none
• Set the <select>‘s id to ${id}-select to decouple from any <label>
• Upon confirming a value in the autocomplete, update the original <select>

This function takes the same options as accessibleAutocomplete, with the only difference being that it uses selectElement instead of element, which needs to be an instance of HTMLSelectElement.

Note: The accessibleAutocomplete.enhanceSelectElement function is fairly light and wraps the public API for accessibleAutocomplete. If your use case doesn’t fit the above defaults, try reading the source and seeing if you can write your own.

If your <select> element has a “null” option – a default option with no value – then you can pass a defaultValue option to enhanceSelectElement which will replace the label of this option when it is selected.

With the following HTML:

<select id="location-picker">
  <option value="">Select a country</option>
  <option value="fr">France</option>
  <option value="de">Germany</option>
  <option value="gb">United Kingdom</option>
</select>

Then passing a defaultValue option of '' will then leave the autocomplete blank if the null option is selected.

accessibleAutocomplete.enhanceSelectElement({
  defaultValue: '',
  selectElement: document.querySelector('#location-picker')
})

Any null options will also be filtered out of the options used to populate the source of the autocomplete element. To preserve options with no value in the autocomplete, then pass a preserveNullOptions flag of true to enhanceSelectElement.

The following events get triggered on the input element during the life cycle of the autocomplete:

• onConfirm – This function will be called when the user confirms an option, with the option they’ve chosen.

Example usage:

accessibleAutocomplete({
  // additional options
  onConfirm: (val) => {
    track(val)
  }
})

accessible-autocomplete was built after studying many existing solutions and prototyping patches to fix user experience or accessibility issues. It draws heavy inspiration from the following (and a lot of others):

• ljwatson/design-patterns: great accessible experience
• corejavascript/corejs-typeahead: flexible autocomplete/suggestion engine architecture
• JamieAppleseed/selectToAutocomplete: ease of use

Check out the CONTRIBUTING guide for instructions.

If you want to help and want to get more familiar with the codebase, try starting with the “good for beginners” issues.

MIT.

NOTE: This project is retired as the component is not accessible.

Similar functionality is now provided by the Multiple variant of the Select With Search component, which is available in the govuk_publishing_components gem.

The accessible autocomplete is a component that helps users choose answers from a list you provide. You can also use it to make the answers you get from users more consistent.

If you’re asking users to provide their country or territory, the govuk-country-and-territory-autocomplete might be more appropriate.

This is a fork of the accessible-autocomplete component. It adds additional functionality such as support for select multiple.

accessible-autocomplete is a JavaScript autocomplete built from the ground up to be accessible. The design goals are:

• Accessibility: Following WAI-ARIA best practices and testing with assistive technologies.
• User experience: Supporting a wide variety of user needs.
• Compatibility: Working with recommended browsers and assistive technologies.

Try out the examples!

The GOV.UK Design System team maintains the accessible autocomplete as a standalone component. However, we’re only able to put in minimal work to support it.

Read about our plans to maintain this component.

Read more about the types of support we can provide.

Install it by running:

npm install --save accessible-autocomplete

The accessibleAutocomplete function will render an autocomplete <input> and its accompanying suggestions and aria-live region. Your page should provide a <label> and a container element:

<label for="my-autocomplete">Select your country</label>
<div id="my-autocomplete-container"></div>

Then import it using a module system like Browserify / Webpack / Rollup, and call the accessibleAutocomplete function, providing an array of values:

import accessibleAutocomplete from 'accessible-autocomplete'

const countries = [
  'France',
  'Germany',
  'United Kingdom'
]

accessibleAutocomplete({
  element: document.querySelector('#my-autocomplete-container'),
  id: 'my-autocomplete', // To match it to the existing <label>.
  source: countries
})

If you want to use it as a replacement for a <select> element, read the Progressive enhancement section.

You can copy the dist/accessible-autocomplete.min.js file to your JavaScript folder and import it into the browser:

<script type="text/javascript" src="assets/js/accessible-autocomplete.min.js"></script>

A stylesheet is included with the package at dist/accessible-autocomplete.min.css.

You can copy it to your stylesheets folder and import it into the browser:

<link rel="stylesheet" href="assets/css/accessible-autocomplete.min.css" />

You can also import it using Sass:

@import "accessible-autocomplete";

If you already use Preact in your application, you can import a bundle that will use that:

import preact from 'preact'
import Autocomplete from 'accessible-autocomplete/preact'

preact.render(
  <Autocomplete id='autocomplete' source={suggest} />,
  document.querySelector('#container')
)

Try out the Preact example!

If you already use React in your application, you can import a bundle that will use that:

import React from 'react'
import ReactDOM from 'react-dom'
import Autocomplete from 'accessible-autocomplete/react'

ReactDOM.render(
  <Autocomplete id='autocomplete' source={suggest} />,
  document.querySelector('#container')
)

Try out the React example!

React v15.5.4 has been tested to work with the Accessible Autocomplete – although make sure to check out documented issues.

React v15.6.2 and 16.0 have been incompletely tested with the Accessible Autocomplete: while no undocumented issues were found, we recommend you carry out thorough testing if you wish to use these or later versions of React.

Type: HTMLElement

The container element in which the autocomplete will be rendered in.

Type: string

The id to assign to the autocomplete input field, to use with a <label for=id>. Not required if using enhanceSelectElement.

Type: Array | Function

An array of values to search when the user types in the input field, or a function to take what the user types and call a callback function with the results to be displayed.

An example of an array of values:

const countries = [
  'France',
  'Germany',
  'United Kingdom'
]

If source is a function, the arguments are: query: string, populateResults: Function

Similar to the source argument for typeahead.js, a backing data source for suggestions. query is what gets typed into the input field, which will callback to populateResults synchronously with the array of string results to display in the menu.

An example of a simple suggestion engine:

function suggest (query, populateResults) {
  const results = [
    'France',
    'Germany',
    'United Kingdom'
  ]
  const filteredResults = results.filter(result => result.indexOf(query) !== -1)
  populateResults(filteredResults)
}

Type: Object

Sets html attributes and their values on the menu. Useful for adding aria-labelledby and setting to the value of the id attribute on your existing label, to provide context to an assistive technology user.

Type: Boolean

Set to true to highlight the first option when the user types in something and receives results. Pressing enter will select it.

Type: Boolean

The autocomplete will confirm the currently selected option when the user clicks outside of the component. Set to false to disable.

Type: string

Use this property to override the BEM block name that the JavaScript component will use. You will need to rewrite the CSS class names to use your specified block name.

Type: string

Specify a string to prefill the autocomplete with.

Type: 'inline' | 'overlay'

You can set this property to specify the way the menu should appear, whether inline or as an overlay.

Type: number

The minimum number of characters that should be entered before the autocomplete will attempt to suggest options. When the query length is under this, the aria status region will also provide helpful text to the user informing them they should type in more.

Type: string

The name for the autocomplete input field, to use with a parent <form>.

Type: Function

Arguments: confirmed: Object

This function will be called when the user confirms an option, with the option they’ve confirmed.

Type: string

This option will populate the placeholder attribute on the input element.

We think placeholders have usability issues and that there are better alternatives to input placeholder text, so we do not recommend using this option.

Type: Boolean

The input field will be rendered with a required attribute, see W3C required attribute definition.

Type: Boolean

If this is set to true, all values are shown when the user clicks the input. This is similar to a default dropdown, so the autocomplete is rendered with a dropdown arrow to convey this behaviour.

Type: Boolean

The autocomplete will display a “No results found” template when there are no results. Set to false to disable.

Type:

{
  inputValue: Function,
  suggestion: Function
}

This object defines templates (functions) that are used for displaying parts of the autocomplete.

inputValue is a function that receives one argument, the currently selected suggestion. It returns the string value to be inserted into the input.

suggestion is a function that receives one argument, a suggestion to be displayed. It is used when rendering suggestions, and should return a string, which can contain HTML.

⚠️ Caution: because this function allows you to output arbitrary HTML, you should make sure it’s trusted, and accessible.

If your template includes child elements with defined foreground or background colours, check they display correctly in forced colors modes. For example, Windows high contrast mode.

Type: Function

A function that gets passed an object with the property className ({ className: '' }) and should return a string of HTML or a (P)React element. ⚠️ Caution: because this function allows you to output arbitrary HTML, you should make sure it’s trusted, and accessible.

Type: Function

A function that receives no arguments and should return the text used in the dropdown to indicate that there are no results.

Type: Function

A function that receives one argument that indicates the minimal amount of characters needed for the dropdown to trigger and should return the text used in the accessibility hint to indicate that the query is too short.

Type: Function

A function that receives no arguments and should return the text that is used in the accessibility hint to indicate that there are no results.

Type: Function

A function that receives two arguments, the selectedOption and the amount of available options, and it should return the text used in the accessibility hint to indicate which option is selected.

Default:

(length, contentSelectedOption) => {
  const words = {
    result: (length === 1) ? 'result' : 'results',
    is: (length === 1) ? 'is' : 'are'
  }

  return <span>{length} {words.result} {words.is} available. {contentSelectedOption}</span>
}

Type: Function

A function that receives two arguments, the count of available options and the return value of tStatusSelectedOption, and should return the text used in the accessibility hint to indicate which options are available and which is selected.

Type: Function

A function that receives no arguments and should return the text to be assigned as the aria description of the html input element, via the aria-describedby attribute. This text is intended as an initial instruction to the assistive tech user. The aria-describedby attribute is automatically removed once user input is detected, in order to reduce screen reader verbosity.

If your autocomplete is meant to select from a small list of options (a few hundred), we strongly suggest that you render a <select> menu on the server, and use progressive enhancement.

If you have the following HTML:

<select id="location-picker">
  <option value="fr">France</option>
  <option value="de">Germany</option>
  <option value="gb">United Kingdom</option>
</select>

You can use the accessibleAutocomplete.enhanceSelectElement function to enhance it into an autocomplete:

accessibleAutocomplete.enhanceSelectElement({
  selectElement: document.querySelector('#location-picker')
})

This will:

• Place an autocomplete input field after the specified <select>
• Default the autocomplete autoselect to true
• Default the autocomplete defaultValue to the select’s option[selected]
• Default the autocomplete id to the <select>‘s id
• Default the autocomplete name attribute to '' to prevent it being included in form submissions
• Default the autocomplete source to use existing <option>s from the <select>
• Hide the <select> using inline display: none
• Set the <select>‘s id to ${id}-select to decouple from any <label>
• Upon confirming a value in the autocomplete, update the original <select>

This function takes the same options as accessibleAutocomplete, with the only difference being that it uses selectElement instead of element, which needs to be an instance of HTMLSelectElement.

Note: The accessibleAutocomplete.enhanceSelectElement function is fairly light and wraps the public API for accessibleAutocomplete. If your use case doesn’t fit the above defaults, try reading the source and seeing if you can write your own.

If your <select> element has a “null” option – a default option with no value – then you can pass a defaultValue option to enhanceSelectElement which will replace the label of this option when it is selected.

With the following HTML:

<select id="location-picker">
  <option value="">Select a country</option>
  <option value="fr">France</option>
  <option value="de">Germany</option>
  <option value="gb">United Kingdom</option>
</select>

Then passing a defaultValue option of '' will then leave the autocomplete blank if the null option is selected.

accessibleAutocomplete.enhanceSelectElement({
  defaultValue: '',
  selectElement: document.querySelector('#location-picker')
})

Any null options will also be filtered out of the options used to populate the source of the autocomplete element. To preserve options with no value in the autocomplete, then pass a preserveNullOptions flag of true to enhanceSelectElement.

The following events get triggered on the input element during the life cycle of the autocomplete:

• onConfirm – This function will be called when the user confirms an option, with the option they’ve chosen.

Example usage:

accessibleAutocomplete({
  // additional options
  onConfirm: (val) => {
    track(val)
  }
})

accessible-autocomplete was built after studying many existing solutions and prototyping patches to fix user experience or accessibility issues. It draws heavy inspiration from the following (and a lot of others):

• ljwatson/design-patterns: great accessible experience
• corejavascript/corejs-typeahead: flexible autocomplete/suggestion engine architecture
• JamieAppleseed/selectToAutocomplete: ease of use

Check out the CONTRIBUTING guide for instructions.

If you want to help and want to get more familiar with the codebase, try starting with the “good for beginners” issues.

MIT.