Krzysztof Gantzke-C++ Software Developer

Development of new simulator features and extension of existing modules using C++.

GUI design and implementation with Qt for Windows, including redesigns to improve usability and workflow.

Maintenance and expansion of existing codebase: refactoring, bug fixes, and modularization to support new capabilities.

Version control using Git.

Performance optimization of simulation to meet real-time constraints.

Creating and maintaining documentation: technical comments, design docs, API references and user manuals.

Led a redesign that improved operator workflow and reduced task completion time.

Extended simulator architecture to support multiple new scenario types while preserving backward compatibility.

Implemented refactoring and modularization that simplified maintenance and accelerated feature delivery.

Technologies: C++03, Qt4.6, QMake, Git, V-Model, Windows

Design and implement the camera GUI using XML.

Translate product specifications into a polished, maintainable UI.

Define and implement communication protocols between the main camera system and autonomous display devices.

Implement back-end changes to support new UI requirements using C.

Create complex manual UI test scenarios.

Define and implement unit tests and acceptance tests using Robot Framework.

Execute bug fixes and minor feature corrections.

Work within a Yocto Linux environment and use Git (Bitbucket) for version control.

Collaborate on UI prototypes and layouts in Figma.

Delivered a specification-compliant GUI for the ALEXA platform.

Improved UI stability and test coverage through systematic unit and acceptance testing.

Updated communication between autonomous displays and the main system, supporting embedded constraints and real-time requirements.

Technologies: C99, XML, Figma, Robot Framework, Git, Linux

Design and implement application components and reimplement legacy modules to improve reliability and maintainability using C++.

Build a multithreaded application to handle parallel image capture, preprocessing, verification, and UI updates.

Ensure thread safety and efficient synchronization.

Develop and optimize algorithms for face detection, feature extraction, and infrared-based liveness checks.

Integrate a new software component into an existing application stack, ensuring compatibility with concurrent data flows and existing modules.

Implement responsive UI elements to guide verification flows and display results under concurrent workloads.

Define and implement unit tests using GoogleTest to validate functionality and concurrency behavior.

Prepare technical documentation and provide ongoing prototype support and troubleshooting.

Implemented a face verification pipeline that incorporated infrared data to strengthen liveness detection and reduce false positive results.

Delivered a multithreaded solution that increased throughput and reduced verification latency while preserving system stability amid changing requirements.

Established unit-test coverage and technical documentation that accelerated onboarding and reduced defect recurrence.

Technologies: C++14, Qt5.12, OpenCV, MQTT, GoogleTest, Multithreading model, Git, Windows

Develop C++ software and implement ROS nodes for sensor integration and data flow.

Integrate camera and sensors including Leica GS18 and Leica TTB and manage communication protocols including MavLink.

Implement data processing pipelines for geotagging, localization, and object tracking.

Ensure time synchronization across sensors and systems for accurate data fusion.

Define and implement unit tests using GoogleTest and component tests with RosTest (Python).

Design and maintain a SoftwareInLoop (SiL) test environment for validation and regression testing.

Develop Python tools and scripts for automation, test orchestration, and data analysis.

Prepare technical documentation, specifications, and test reports.

Delivered a working software stack that integrates Leica sensors with ROS and embedded platforms.

Established a SiL test environment and automated test suites that accelerate validation and reduce integration time.

Streamlined development on embedded Linux (Yocto) for ARM targets, improving deployment repeatability.

Technologies: C++11, Python, ROS, Multiprocessing model, Communication protocols, CMake, Git, Linux

Develop software components using C++.

Build and enhance processing and verification modules (ACF).

Integrate industrial cameras into the system using GenICam.

Develop image processing algorithms with HALCON.

Implement pattern recognition and defect/noise detection ACF components.

Design and implement verification workflows according to specification documents.

Create user interfaces with Qt.

Define and implement unit tests and component based testing using GoogleTest.

Design and implement a SoftwareInLoop (SiL) test environment.

Prepare and review technical documentation.

Apply multithreading concepts for performance critical components.

Improved image processing performance through optimized HALCON algorithms and multithreading techniques.

Successfully integrated multiple industrial camera models (color and BW) via GenICam, increasing system robustness and flexibility.

Developed reliable ACF based verification components that enhance document inspection accuracy.

Established a comprehensive SiL test environment that reduces regression issues and accelerates development cycles.

Introduced structured unit and component testing practices, significantly improving code quality and maintainability.

Created clear, maintainable technical documentation that supports onboarding, testing, and long term system evolution.

Technologies: C++14, Qt5.5, ACF, GenICam, Image processing, Multithreading model, SVN, Windows

Develop C++ software components for the CA/CL module from DOORS requirements, ensuring compliance with functional specifications.

Design and maintain modular, efficient software architecture aligned with AUTOSAR principles and embedded constraints.

Implement and validate communication stacks using CAN and LIN protocols for reliable in-vehicle messaging.

Create and run unit tests with GoogleTest to ensure code quality, coverage, and regression protection.

Define and implement HiL and SiL tests to automate test scenarios and validate system integration.

Manage source code using Git and document designs, interfaces and test plans in clear technical documentation.

Delivered maintainable, well tested software components that integrate into vehicle ECUs.

Improved test automation and traceability between requirements and implementation, accelerating verification cycles and increasing release confidence.

Technologies: C++03, Communication protocols (CAN and LIN), Embedded, AUTOSAR, DOORS, Git, Linux

Develop C++ software components, including ACF modules, for color management workflows.

Implement Qt based user interfaces to support efficient and intuitive user interaction.

Integrate external libraries and ensure seamless interoperability within the application stack.

Perform bug fixing across internal and third party components.

Port application functionality from Windows to macOS and Linux.

Conduct cross platform testing to ensure consistent behavior and performance.

Delivered stable and optimized ACF components that improve processing performance and reliability.

Successfully ported core application modules to macOS and Linux, expanding product reach.

Reduced defect rates by resolving complex bugs in both internal and external libraries.

Improved cross platform consistency through systematic testing and build pipeline enhancements.

Technologies: C++03, Qt4.8, ACF, SVN, Windows, macOS, Linux