Julius Meißner - Developer

• Computer Vision & Machine Learning
• C# & .NET
• Android
• Unity 3D
• C++
• Java

Ikea Scan

During a master's course, our task was to create a computer vision application that detects parts and provides an interactive experience for assembly or disassembly. As a team of 4 we decided to use a real-world usecase that could ultimatly be deployed in an production setting. All of the code and training data was to be created by ourselfs, while libraries and tools could be chosen by us. The hardware provided consisted of a Jetson Nano SoC computer with a webcam. Ikea Scan is a self-developed application to detect pieces of an Ikea nightstand and provide an interactive building experience. Developed in Python, our team used the one-shot object detector Yolov5 alongside the interface library Streamlit. All of the training data was photographed and self-labeled using Roboflow. The Project was then deployed on the Jetson Nano AI edge device.

Watch in Action

Solar Detector

Solar Detector is a portfolio application to learn more about Mask R-CNN, PyQt5 and satellite imagery. I chose the Mask R-CNN library due to it being a bit more difficult to use than Yolov5, as well as being open-source, so i can add my own changes for switching between the map and the image with detections. The satellite and aerial imagery is downloaded using the Bing Maps API.

Since there is already an existing Mask R-CNN model to detect houses, I had the goal to train a completely new network for the detection of solar panels. This then allows me to combine the detections of both CNNs, so I don't have to train a model for the houses and wont get a massive class imbalance due to the houses datasets size of roughly 30.000 images. Currently, the detection is working decently well for a model only that was only trained for 10 epochs with under 25 images for solar panels. This rather small training set is due to this project being a short (3 days maximum) MVP for demonstration and learning purposes only.

Graphitty

Graphitty is an application for generating and analyzing large quantities of graphs. The graphs are analyzed to determine total-coloring as well as other NP-complete algorithms, mostly using simple heuristics and brute force methods. We used C#'s MVVM Pattern, WPF for the interface as well as MongoDB for storage and easy access using the LINQ library. Graphitty was a project during my bachelor's, which lasted one whole semester to developed this program. Graph generation can be adjusted from the number of vertices and edges to cluster sizes. Correlations can be made with a sufficient number of generated and analyzed graphs which are then displayed in the application.
Github View the Code on GitHub

Internal Tools @BOSCH

During my time as a holiday worker at BOSCH Schwieberdingen, I developed internal tools for the section Complex Drivers. The applications mostly focused on making existing workflows more userfriendly, such as reading data for ECUs from Excel tables, then automatically choosing the right settings for the given file, which is then loaded into other scripts to create boilerplate C-Code for the ECUs. I wrote C# applications, using WPF and the MVVM Pattern to allow for simple drag&drop of the Excel files, while the program then does the heavylifting.

Simplex Calculator

This little application was created to help with the online exam Operations Research. Since the course at KIT uses their own Simplex format, i created a application to quickly calculate primary and dual simplex steps, as well as allow for warmstarts, which are required for the exam. All of the algorithms used are found as pseudo code in the book: Operations Research, Stefan Nickel, 2022.
Github View the Code on GitHub

Empire Attack 2.0

Empire Attack is an old territorial game form the late '90s. My goal was to recreate some mechanics and learn how to connect ASP Razorpages with a robust C# backend. Connection and communication is done via SignalR. The game uses tilemaps and basic DFS and BFS algorithms, customized for use with a 2D grid. Containerized via Docker, this application was then deployed on a VPS.
Github View the Code on GitHub

One Choice

Initially, a prototype of the game was developed using HTML and JavaScript, as both developers were more familiar with these languages. The first release of the app used this web-based prototype through an Android webview. The game's user interface was then written using XML and the logic was programmed using JAVA. The use of native programming languages for Android resulted in major performance gains. The app is published and can be downloaded on the Google PlayStore.

AMSL

AMSL was a team project during my master's with the goal to create an emotion regulation tool for students. The app was created by 4 students using Android Studio and Kotlin. Challenges during development included working with custom chatbots, as well as asynchronous behavior. Overall the project was a success with a very good grade and learnings taken regarding chatbots and Android development using Kotlin.

Hostile Takeover

Hostile Takeover is a fast-paced territorial game. After initial feedback on the Empire Attack 2 prototype, it was clear, that a fast paced territorial game could meet a demand. Slow paced capture and decay was replaced by building structures and a research menu, which allows the player to purchase upgrades and special attacks. The 2D visuals were abandoned in favor of fully 3D isometric visuals in the low-poly style, known from many indie games. Hostile Takeover features a 4 Player Lobbysystem based on unitys UNet networking library. Maps are loaded using colored PNG files which are then translated into the tilemap with planned variation in the tiles.

There are currently 5 different structure available, with each structure having different effects such as generating more population for attacks or being able to research and use certain effects. Some structures such as Labs can only be placed on special city tiles, making them a valuable resource and hotspots. Building a Lab generates research points, used to buy special attacks allowing for a fast-paced, yet tactical gameplay.

Special attacks use different shapes to attack, like AoE. The area is calculated using a modified BFS algorithm. The population growth is modeled using logistic growth, meaning there is a sweetspot for spending and a penalty for spamming or saving up too much. Overall, this game prototype was a great learning experience with multiplayer and scalable systems.

Breacher

Breacher is a puzzle shooter, inspired by the door breaching mechanics of Call of Duty MW 2. Breacher is built in Unity, and deployed using the WebGL Player. Currently Breacher is in the Demo/Playtest phase and is planned to be released on mobile devices. Keep this in mind when looking at the UI and gameplay elements. Breacher features a fully voiced tutorial, to introduce the player to the mechanics in a fast and concise way.

The map was created using a custom preset for openstreetmaps, with currently two seperate locations. Each location has a subset of playable missions with varying difficulties and weapon selection. Currently, the time to finish is being tracked locally, with Playfab as a online highscore provider being worked on.

Hostage rescue, Bomb defusal and Elimination are the three available modes, with civilians being in the pipeline. The Enemies AI is a basic IFTTT with waypoints and timers, although this system is open for customization. Weapon selection is limited to three distinct classes, a pistol, an assault rifle and a shotgun, each class having their own traits and disadvantages. The system can be expanded with new skins and animations for each class, making this system modular and a monetization possibility for the final version.

Github Play the game here

Raytracer and Shader

During my Computergraphics course in my master's, I created a Raytracer using C++ within a pre-made Framework. The Framework handled the UI and interaction logic, while it was my task to create the raytracer from generating rays, to rasterization to shadow casting. Additionally I also needed to create Shaders from scratch for the program.

University Courses

During my bachelor's degree, I gained experience with Java, primarily through two key courses: the Programming course and the Softwaredesign & Patterns course. In the latter course, I also became familiar with the build automation tool, Maven, which I found easy to use. While my Java experience has been primarily limited to university coursework and some Android app development, I have found that my experience in C# is also applicable to Java. The similarities between the two languages make it easy for me to switch between them, and I prefer to use C# for my personal projects. Overall, I have extensive knowledge of both Java and C#, and I am confident in my ability to utilize these languages in a professional setting.