So here is my page! I am living in Meath and working for Movidius, which is now part of Intel. I am conducting research into aerial mapping techniques and using the myriad chip for 3D mapping. You can contact me at jonathanbyrn@gmail.com.

My  curriculum vitae is available online here and you can download a copy of my thesis here. If I can create a video of my work I will upload it to my youtube channel.


I like coding. A lot. Here is a list of some of the software projects I have worked on. The source code is either available on my github repo or by request:

I am playing around with autoencoders for data compression I  trained an one that encodes faces into a latent representation and then decodes them. I then tried breaking it by passing in non-face images.

I built an Openflexure 3D printed microscope. It uses stepper motors, an arduino and a raspberry pi to automate the data collection process and allows you to create high resolution images by stitching many patches together.

If you are looking for an excellent device that provides visual tracking  and odometry”out of the box” for a robotics project, I would strongly recommend the Realsense T265 which uses the myriadX, you can see a video of it in  action here

I converted the old robotic lawnmower into a toddler controlled deathtrap. After alex flipped it by ramping over the fireplace,  I will be installing a roll cage on the next revision

Tried out the latest Openvino models in the model zoo. You can now get skeleton tracking running at 15 fps on a cpu or recognise text regardless of angle or the font used

Looked at different approaches for finding attentional areas in an object detector.

I managed to power up cheetah bot but the legs are a bit sticky and need to be reworked. If you want to build one yourself the instructions are here

I tried to create a hierarchical graph of all 110,000 employees in a giant multinational.

Set up a websocket based system for recording how many people enter and exit a room to control the numbers of people in a lab at a given time.

Silicon Republic wrote a lovely article on our work helping start-ups build  computer vision applications.

I made a 3D voxelization of one of my employees in order to win an argument with him 🙂 He is both sharp and argumentative and I love debating inconsequential things like hamming distance vs euclidean distance with him. It gives everyone a greater understanding as to what is going on.

I tried to make a visualization of the interconnections of everyone in Intel. Even the most powerful graphing software in the world cannot make sense of our corporate structure….

Developed an obstacle detector that uses a median filter on a noisy depth image. It splits it into 9 squares and uses a threshold distance to sense the direction of an obstacle. The plan is to incorporate it into Violet, the coronavirus killing robot.

Converting my robomow to a robocar for the kids. My wife made me add an emergency stop, I don’t think she trusts me…

Luxonis have finished a custom board based on the MyriadX that runs using POE, essentially turning it into an IP camera. Look at how many components are in it

I had some great fun with the latest release of openvino. The capabilities of some of the pretrained networks are amazing:

I ran some tests on my 3D printer after reading a paper showing that it can adversely effect air quality through the emission of small particles and volatile organic compounds. Basically it isn’t too bad if you use PLA or PETG but ventilation would be recommended. I posted the results here.

After alpha testing with the fantastic Luxonis A.I. Depth Camera based on the Myriad X, I designed a mount for the LCD screen and a cover for the main board. You can read about it here.

I built a set of electronic gates from 2 desk raising linear actuators, an ESP32 module with a GPRS sim module, a 4 switch relay and some 3D printed enclosures. It took a long time to debug because relays can draw a lot of current when powering up and the power supply thinks it is a short circuit. All fixed with a MOSFET and help from my colleague Cory. You can see it in action here.

I designed a hand-held edge inferencer using a raspberryPi, a neural compute stick and battery. It allows you to test computer vision networks “in the wild.

I built my first robot from generic chinese electronics and 3D printed case. It is a tracked robot based on the Edrover for maximum mobility and uses a pi 4 and picamera for navigation. It runs as a webserver and so can be controlled from your phone or your computer. You can also add an NCS to run computer vision algos for navigation!

Tested out an amazing plugin called octolapse for 3D printing timelapses, it edits the gcode to move the print bed to a particular location before taking the image. It looks like it magically appears on the build plate!

I managed to get the higrow moisture sensor working despite it seemingly being vaporware. It works but still needs to be calibrated.

I built a new beecam. This uses POE to provide power of a network cable. This a great as I can verify it is up and running and automatically pull the images off it. It is already getting a lot of attention from the bees.

The new ESP32 module is amazing, very low power and even has LORA capabilities. I built a solar powered enclosure for monitoring my bees. There is also a new version that comes with a camera, PIR sensor and OLED display. It managed to broadcast for 10 hours on an 18650 battery.

Playing around with neopixels, shockingly easy to program all the colors of the rainbow!

A face tracking robot with googly eyes to make it slightly less terrifying.

I wrote a monte carlo simulation of my lawnmower to see if it would explain why I get patches of grass in one area of my garden. I ran it again now that I built a fence and it messes everything up. Source code here.

I am building a ESP32 based solar powered LORA transmitter for sending the weight of my beehives to me over long distances.

I helped get some raspberry pi based bee detector code originally developed by Matt Kelcey running on the neural compute stick .

I set up a continuous integration system based on Jenkins. It brutalises the person submitting the pull request to conforming with the google style guide, a tough linting,  doxygen checks to make sure all methods and variables are documented and unit test coverage.

I helped develop a voxel completion technique that uses a deep NN trained on high quality data to fill in the gaps existing city scans.

A classical computer vision solution to automatically build a digital archive of connectors.

A classical computer vision solution for identifying particles on a slide.

A raspberry pi based sound monitor that records the time and duration of sounds beyond a certain decibel level.

I built a Tesla Coil! It is a OneTesla TS kit and can also play music as soon as I sort that bit out….

I ran a computational fluid dynamics simulation of my silo shed to see how it would handle a storm.

A compressed volumetric format that allows for the easy transfer of 3D point cloud data across the web called VOLA. You can view it here.

I am currently optimising the firmware on a Floureon H101 micro drone to allow for cheap robotics testing and mapping.

A volumetric representation of 3D data that allows for massively compressed  3D maps to be store and sent across a network in realtime.

A robotic lawnmower based on the Arduino microcontroller. More information can be found here.

I generated a parametric pattern and laser etched it onto my laptop!

A plant identification app that classifies plant images captured on your phone using a deep neural net.

A rotation and noise invariant tracker to follow an object in a video feed.

An opencv motion tracking algorithm hooked up to an IP camera to find out what is wandering through my garden at night.

A Dublin bikes app that shows whether the stations are full or empty.

A visualisation of the bike flow between stations in Dublin.

A prototype hollow frame for a beehive. Normally wax mixed with paraffin is used to build a foundation frame, this can lead to disease being spread amongst different hives. The 3D printed frame is hollow to allow the bees to compose the structure of their own wax. The design was implemented using a parametric rule system to generate the rhombic dodecahedrons that make up the frame.

An arduino based label winding machine.

A filtering script that automatically detects trees in LIDAR data.

A raspberry pi timelapse system that captures sunsets. It pulls the sunset time from an online API and starts 2 hours beforehand. It stops when it gets dark, merges the images into a movie and automatically uploads it to my dropbox.

Set up an augmented reality sandbox for the civil engineering students to learn about topology and iso-lines.

Developed a technique for orienting normals accurately on a city block scale point cloud.

Helped set up a lasersaur laser cutter. It is not directly my project but I cannot miss the chance to play with lasers.

A selenium website testing framework that integrates in Testrail testcase management software

Generating and 3D printing bespoke Catenary structures using the blender physics engine.

I used the solid isotropic material with penalization (SIMP) topology optimisation algorithm to optimise three dimensional structures. These algorithms were originally considered too theoretical as the pieces could not be manufactured. Now these pieces are entirely possible with additive manufacturing approaches.

I wrote a numerical model of a gene regulatory system based on the work of Wolfgang Banzhaf and Miguel Nicolau. I then wrote a distributed python framework so that it could run on UCD’s Phaeton HPC cluster.

Implemented a comparison between breadth first search and the A star algorithm for solving grid mazes. I used python ncurses for the GUI.

I used Poisson reconstruction to create printable, watertight models from the LIDAR data obtained by the Urban Modelling Group. I also investigated delaunay triangulation and RANSAC but the data was too noisy for these approaches.

Used the FreeCAD parametric design system to generate car designs for wind tunnel testing using OpenFOAM

Implemented cubify a point cloud parser based on the octree datastructure. It generates solid voxel structures from point cloud data.

Wrote a parser and scraper for telegram (whatsapp clone) so that I could graph the quantity and frequency of being made.

Wrote a parser for converting point cloud data into a Minecraft level format. This allows me to easily explore the dataset.

Wrote a program that automatically pulls point cloud data from the Kinect 1, a structured light scanner for the xbox.

Wrote a program that uses the PCL library iterative closest point algorithm to align point clouds.

Developed a program that pulls kinect scans from multiple angles, aligns them, and meshes them to create a full body scan.

Reimplemented code for pulling a 3D model directly from the memory of a graphics card. Used for getting a 3D model from google earth.

Set up a node.js server to see what it is all about.

Wrote a parser to convert LAS format point clouds to a more amenable ascii PCD format.

Built an FPV racing drone that uses a cc3d controller flashed with librepilot and a 4 to 1 ESC.

I implemented a kalman filter for averaging the flight path of a cannon ball. Kalman filters are based on a bayesian statistical model and can fuse noisy data from multiple sources.

Bi-directional Evolutionary structural optimisation is a topology optimisation algorithm, I re-implemented a 99 line piece of matlab code in python so that I could distribute the computation.

Set up a postgres server for handling point cloud information, conducted speed tests against a standard mysql server and text file access.

Set up a hadoop server to see if it performed any better at handling massive amounts of point cloud data.

Used a PANDA based python framework for efficiently querying point cloud data.

Implemented a 50 line genetic algorithm to use for teaching and a starter point for people to apply GA’s.

Used the Gephi graphing library to analyse the dependencies between various packages in the debian system.

Implemented an evolutionary aircraft optimiser based on OpenVSP a parametric aircraft design tool and openFOAM for the computational fluid dynamics solver.

Implemented NSGA2 Multi-objective fitness function. It uses non-dominated sorting to select the fitest individuals.

Performed comparisons with the SPEA2 Mutli-objective fitness function, a newer design that uses solution density when evaluating indviduals. Not much of a performance increase TBH.

Implemented an Electricity pylon optimiser that uses loading trees from design specification document. This means the structure can be created just from the planned loadings automatically with no intervention from the user.

Wrote a weather scraper to pull weather information from multiple sources around Ireland.

Implemented a webgl interface to render wind speeds around Ireland. It is automatically updated by the webscraper every 3 hours.

Wrote a script that used taskfarming to distribute jobs on Fionn, Ireland’s largest supercomputer. It greatly increases the speed of processing by pulling in additional nodes as they become free.

Implemented a script that automatically extrudes 3D stl files from 2D SVG images. This allows you to automatically generate 3D printable files from images.

Wrote a parser that automatically scrapes a html5 webpage and converts it to a format that it can be used with iPad presentation software.

A wave spectral analyser to generate spectrum diagrams from MP3s.

Re-implemented Daniel Schiffman’s shakespeare Genetic Algorithm code to allow for control of crossover.

Wrote a script to control my crazyflie micro-UAV directly from python.

Set up Unity to work with an Oculus Rift and imported scanned buildings into interactive environment.

Created a Flight simulator for android that uses the accelerometers.

A time series generator for creating periodic and chaotic time series, such as sine waves, the mackey glass time series and the logistic differential function.

A simulation for a single and double pendulum. the double pendulum can be completely chaotic when enough force is applied and it makes a very pretty (non-repeating!) pattern

Implemented a Hopfield network.This is the simplest recurrent network and the training is more akin to a settling process than traditional neuronal training such as back propagation.

Implemented an Echo state network, a recursively structured neural network algorithm that has been shown to exhibit histeresis (a simple form of “memory”). It is very easily trained using a single linear algebra update to minimise errors. Once it was running it could filter noisy data and predict missing input. I used a least squares solver to train the network.

I coded up a photobooth program using PyGame and libgphoto. The results were displayed for 5 seconds on the screen and backed up. One nice thing was that because it was not limited to an actual booth, more people could get in the photo which made it much funnier.

I laser etched my wedding invitations on plywood because they were going to charge me 500 euro for “wedding” paper. I wrote a script that parsed the names from a list to create the unique pdf files for the printer.

A timelapse generator using a raspberryPi and a webcam. The intention was to do timelapses over very long time periods. This software would check the images and email me with the results each week. If the server crashed, another server would contact me.

Implemented a simplified twitter clone using Flask, a python based web framework.

A Delaunay triangulation algorithm in webgl and animated using points that moved according to brownian motion.

DVD detector, a small daemon that would execute whenever a DVD was inserted. It would pull the relevant information from IMDB and rip the DVD to a media server that was running openelec.

A simple cash register and barcode system. There was a database of products and each sale would update the database to keep track of stock.

I took part in the ISS longeron challenge. The aim was to optimise the placement of the solar panels (on arms called longerons) on the ISS as it orbited the earth. I used a covariant matrix adaptation solution (CMA-ES). Although I had high hopes my solution was not that great and we didn’t win the competition

A quine is a program that outputs itself when it is executed. I wrote an e-quine, an evolutionary program that keeps mutating and rewriting itself until it finds the answer.

I became obsessed with fractals for a while and I have code for generating them in Java, C, C++, and python.

Autovolve is an evolutionary strategy algorithm that allows you to easily specify what you want to optimise. It saves you having to rewrite the algorithm for each specific problem.

Compustat is a highly detailed database of company metrics going back 30 years. I wrote code that sanitised the data and allowed this information to be processed in parallel by multiple machine learning processes.

I re-implemented a simple flight simulator in C. it used a heightmap (think of a 2d map where color relates to height) to generate the scenery.

I implemented code to calculate the Sharpe ratio, a measure of return vs.volatility to evaluate the risk adjusted performance of different machine learning algorithms. I also used linear regression and windowed moving averages to examine significance in daily / monthly / annual price fluctuations.

A twitter scraper that pulls down approximately 30 tweets a second. The idea was to build up a corpora of English text but the spelling was so bad it became a serious challenge to work out whether a tweet was english or not.

I programmed an arduino board to sing “Daisy Bell (bicycle built for two)”

I implemented a version of the “Imprintable Dynamic Model” as set out by Matthew Egbert. I used processing as the visual aspect of the model working was easily implemented.

I implemented some simple examples of AJAX callbacks to understand how this allows you to update parts of a web page and examined how much it reduced the loading overhead.

Parsimony was a natural language processor built on the NLTK toolkit. It incorporated a webscraper for generating corpora and applied unigram taggers to the data. One the words had be tagged with their implicit grammatical information, they were built into hierarchical structures that could then be queried at a basic level.

The canon hack development kit allows you to access hidden features of any canon camera through a simple firmware upgrade. I used the CHDK and a script to create plant time lapses that ran over several months. This timescale is required to see the dynamic behaviour of plants.

I used gource and the log information of my SVN repository to create animations of all the code I have worked on. It is nice on a collaborative project as you can see the effect of everyone’s changes while they may consider that they are working in isolation

The multi-touch screen interface of an android device is perfect for interacting with swarms. Accordingly I implemented a simple swarm algorithm that the user can either attract or repulse the individuals in a swarm.

I created a simple program for passing images over peer to peer wifi. The ability for android devices to create robust ad-hoc networks is very impressive and under-utilised.

Alan Turing discussed morphogenesis (how an organism turns from a collection of uniform cells into a distinct shape with differentiated parts) as the interaction of two different chemical interactions far from equilibrium. 40 years later he was proved correct. I wrote code to simulate this pattern formation occuring from local interaction.

Boids was the original swarm / flocking algorithm developed by Craig Reynolds. It has been used in animation, vision systems and in several other areas. I implement a version of it to better
understand it.

I created an interactive interface for my user experiments. I have used multiple frameworks during this study for creating GUIs including wx, qt, tcltk and gtk.

Python uses first class functions which allow it handle higher order functions and to easily implement function currying. This allowed me to create complex designs using a simple hierarchical grammar based on these features.

We ran a summer school to introduce programming to transition year students. We used the lego mindstorms system to teach them the basics of robotics. I have used them in several projects, most recently an automated scanning system using a kinect 2 and an NXT chassis.

Combining the wiimote library allows you to read information from the IR sensor. I combined this with pygame to create a simple drawing tool.

Architype was a structural optimisation program that combined finite element analysis (SLFFEA) with grammatical evolution. We used it to optimise truss designs, bridge designs and electricity pylons.

Tetragen was a design optimiser that generated shapes from tetrahedrons. While it was capable of generating very complex shapes, the fitness function could not make it generate efficient designs.

A PHP based online survey. This allowed me to conduct experiments online which greatly increased the sample size and to automate the data gathering process.

A haskell implementation of grammatical evolution. Haskell is a purely functional language and is difficult to initially get your head around. It allows you to write incredibly succinct programs and was a very valuable learning experience.

I wrote an evolutionary A.I. for the game toribash. The game has a Lua scripting engine implemented for developing plugins so I rewrote grammatical evolution in Lua. I ended up writing an A.I. that played the game better than I did!

I have written 500+ scripts for graphing, plotting, statistically analysing, and visualising in a variety of languages. My favorites are the python library matplotlib and R.