Code & Thoughts

Lock-free Multithreaded “Find Duplicates” support in digiKam 7.3.0

2022-08-07T00:00:00+00:00

Preface: Juggling between multiple image hosting web services

Like many other young kids in Brazil in the early 2000s, Fotolog (discontinued) was my first photo collection web service. From there, I switched to Flickr, back then a broad image service in which you could store high-resolution photos.

In the meanwhile, Orkut (re-activated?) was the most popular social network in Brazil, and I used to store some of my photos in there too. Orkut eventually got replaced with Facebook, which at the time made it simple to store e.g. a batch of photos from my trips around the world.

Then, came Google Drive, Google+ (discontinued), and later on Google Photos. Until 2019, Google Drive and Google Photos were in sync, but that service got discontinued too.

Finally, my personal NAS also acted as a photo storage device until recently, when Seagate discontinued its PersonalCloud web service and its NAS OS 4 operating system.

As you can imagine, my photo collections got scattered over multiple providers and naturally, an increasing amount of duplicated images with varying qualities and sizes evolved over the years.

To solve this, I decided to put all of these in a single database, and started searching for software to handle the duplicates. As a big fan of the KDE community, I chose digiKam, an open-source professional photo management software.

Part 1: How digiKam finds similar images

In order to find similarities between images, digiKam uses the Haar cascades classifier algorithm from OpenCV. An excerpt from its Fuzzy View documentation provides more details:

digiKam characterizes every image by a lengthy number using a special technique (Haar algorithm) that makes it possible to compare images by comparing this calculated signature. The less numerical difference there is between any two image signatures, the more they resemble each other.

Before you can have digiKam finding duplicates their signatures (or fingerprints) have to be calculated. This process is atomic in a sense that each signature can be calculated independently. The image signature is created when the image is imported in the database.

Once the list of images to compare is calculated, their fingerprints are obtained from the database and stored in a memory cache on-demand for faster look-ups.

Once the fingerprints are known, the images are then ready to be compared against each other. This process translates in the pseudo-code below:

for imageId in imagesToCompare {
    similarImages = []

    if (imageId not in signatureCache) {
        signatureCache[imageId] = querySignatureFromDatabase(imageId)
    }

    for otherId in imagesToCompare {

        if (imageId == otherId) {
            continue
        }

        if (otherId not in signatureCache) {
            signatureCache[otherId] = querySignatureFromDatabase(otherId)
        }

        diff = calculateDiff(signatureCache[imageId], signatureCache[otherId])
        if (diff > threshold) {
            similarImages << otherId
        }
    }

    similarImagesDatabase[imageId] = similarImages
}

Part 2: Optimizing the sequential logic

This operation is implemented using a naïve O(n²) solution, and until recently was implemented sequentially on a single worker thread (search job). On a significantly large collection of photos, finding similar images could be an hours-long process that sub-utilized the computer’s capabilities.

Because each image gets its own similar images list, I realized this process could be broken down using in lock-free parallel threads. For that, I implemented the following:

Resolve all image ids before starting the searches jobs.
Create a shared Haar interface with signature cache to be used by all searches jobs in parallel.
Spawn a given amount of worker threads (searches jobs) depending on the amount of CPU cores.
Break down the whole “images to scan” set into iterator ranges, and assign each range to a dedicated worker thread.
Rebuild (or update) the search albums in the database.

The step 3) can be run lock-free with some adjustments e.g. because we’re using constant iterator ranges, it is not possible to remove unused images from the cache when running multi-thread. Also, because we use ranges in step 3), sometimes the same search album is generated multiple times in separate threads using different reference images.

In step 4) we ensure the aggregated results are filtered so there’s only one search album with similar images per duplicates found.

This work has since been released in the digiKam 7.3.0 release.

Find Duplicates tool in digiKam

Special thanks to Gilles Caulier and Maik Qualmann for their code reviews :bow:

Restart

2022-08-05T00:00:00+00:00

Time flies if you don’t pay attention to it! Thanks to the Internet Archive, I found a couple of different iterations of my personal blog websites: brunoabinader.blogspot.com, abinader.com.br, and cabledogs.org/abinader as well as posts made in the Qt blog and Mapbox blog.

I am bringing some of these old posts back (in chronological order):

ISSC Generic Bluetooth Dongle on Windows (XP, Vista) (Dec 2, 2007)
Atheros AR5BXB63 on Ubuntu Hardy Heron 8.04 with madwifi (May 12, 2008)
Sending patches using git-email (Sep 25, 2008)
How CMake simplifies the build process (Part 1: Basic build system) (Dec 7, 2009)
How CMake simplifies the build process (Part 2: Advanced build system) (Dec 9, 2009)
New kid on the block: Plasma Water Animation (Apr 19, 2010)
A guide for Qt5/WebKit2 development setup for Nokia N9 on Ubuntu Linux (Apr 11, 2012)
Vim Quicktip: Navigating to function implementation with ctags (Apr 12, 2012)
WebKit CSS3 text-decoration properties (preview) (Aug 1, 2012)
CSS Level 3 Text Decoration on WebKit and Blink - status (May 15, 2013)
CSS Level 3 Text Decoration properties now available in Google Chrome Canary! (Aug 20, 2013)
Converting C-Like Enums to String values in Rust (Jan 28, 2014)
Qt Framework officially supported (May 9, 2016)
Customizable vector maps with the Mapbox Qt SDK (Oct 4, 2016)
HD Vector Maps in Rightware’s Kanzi (Feb 20, 2018)
Qt Navigation SDK for automotive and embedded devices (May 30, 2018)
Interview With Team Helsinki (Mar 14, 2022)

Interview With Team Helsinki

2022-03-14T00:00:00+00:00

Excerpt from: https://www.mapbox.com/blog/interview-with-team-helsinki-hyvaa-vuosipaivaa-helsinki

Bruno, you’re part of the Helsinki office as a co-founder. Tell us more about what you do and what the team in Helsinki works on.

Bruno: I joined Mapbox in 2015, just three months after Thiago, who invited me to join this “cool SF-based startup doing amazing tech with maps!”.

I started as a Software Engineer in the GL Native team and focused on the ongoing partnerships with our automotive customers which eventually led me into building a spin-off team named Core SDK in 2019, where I am currently an Engineering Manager.

First day at the Mapbox Espoo office in 2015. Mapbox featured in Rimac’s beautiful dashboard.

The Core SDK team initially was responsible for providing custom-tailored solutions to our automotive customers. That work has helped us to learn about opportunities for converging solutions across teams, and we have since changed its scope to being a platform team providing shared solutions to our internal SDK teams.

Today, the Helsinki team spans beyond hosting both GL Native and Core SDK teams, and also includes Android, iOS, graphics, and backend engineers, map designers, and many more exciting roles that we have open!

Mapbox featured in Qt’s Automotive and Rightware’s Kanzi UIs.

‍Bruno: My very first project at Mapbox was about adapting our maps rendering engine to run inside a leading EV manufacturer’s user interface. Back then, the customer had its UI implemented in Qt and Thiago had just the right proof of concept ready. Thus, the work Thiago and I did implementing the Mapbox Maps SDK for Qt has been key to some of our early automotive partnerships. Starting with our Qt framework official support, then leading to a Qt Navigation SDK for automotive and embedded devices, as well as implementing HD Vector Maps in Rightware’s Kanzi.

I worked closely with automotive partners like the Qt Company, Rightware, and NNG, as well as customers like Rimac, Porsche, and others.

Qt Navigation SDK for automotive and embedded devices

2018-05-30T00:00:00+00:00

Link: https://blog.mapbox.com/qt-navigation-sdk-for-automotive-and-embedded-devices-cbd8c95fe343

The Mapbox Navigation SDK for Qt is now available with the latest Qt 5.11 release, enabling turn-by-turn navigation with real-time traffic, lane level guidance, and voice instructions. These features add to the beautiful hardware accelerated vector maps and address/point of interest search that we’ve made available since Qt 5.9.

The SDK comes with professionally-designed maps for navigation and user interface templates optimized for driver safety and efficiency — only the most important information is surfaced to drivers at the right time. The maps and UI are also fully customizable.

The Navigation SDK for Qt is a drop-in library that adds turn-by-turn navigation to automotive and embedded applications.

We partnered closely with the Qt Company to build the first navigation solution for Qt Location, delivering maps, search, and routing services through Qt Location APIs. This release makes the Navigation SDK available as a new Navigator QML Type allowing for ease of integration via QML.

The Navigation SDK for Qt is now available in alpha release. For more information and to enroll as an alpha tester, head to mapbox.com/qt and sign up.

HD Vector Maps in Rightware’s Kanzi

2018-02-20T00:00:00+00:00

Link: https://blog.mapbox.com/hd-vector-maps-in-rightwares-kanzi-2f6363a44700

Rightware’s Kanzi Studio is like Photoshop for designing and building the human-machine interface (HMI) in cars and other interfaces for the automotive industry. The latest Kanzi Studio plug-in now adds our HD Vector Maps into their 3D design environment. From digital instrument clusters to infotainment (IVI) systems to head-up displays (HUDs) the Kanzi software is deployed by 35 automotive brands and live in millions of cars worldwide. Here is a look at the new maps design studio:

The HD Vector Maps use Protocol Buffers for serialization and it is optimized to the exact resolution required by the dataset. This makes streaming streets, satellite imagery, and terrain data into Kanzi insanely fast and radically saves bandwidth for streaming data to a car and reduces storage size for larger area coverage offline. Vector tiles offer styling flexibility, and the result is accelerated development while introducing a unique appearance, true to the OEM brand identity.

Kanzi Maps provide car manufacturers, automotive suppliers, and design studios a streamlined tool for creating beautiful maps that run in digital instrument clusters, infotainment systems, and head-up displays.

We’re a Kanzi Technology Partner working closely with the Rightware team to make maps available out-of-the-box. Follow me @brunoabinader or @RightwareLtd to track our progress.

Customizable vector maps with the Mapbox Qt SDK

2016-10-04T00:00:00+00:00

Link: https://www.qt.io/blog/2016/10/04/customizable-vector-maps-with-the-mapbox-qt-sdk

Mapbox is a mapping platform that makes it easy to integrate location into any mobile and online application. We are pleased to showcase the Mapbox Qt SDK as a target platform for our open source vector maps rendering engine. Our Qt SDK is a key component in Mapbox Drive, the first lane guidance map designed for car companies to control the in-car experience. The Qt SDK also brings high quality, OpenGL accelerated and customizable maps to Qt native and QtQuick.

| Mapbox QML properties and runtime style examples

The combination of Qt and Yocto is perfect for bringing our maps to a whole series of embedded devices, ranging from professional NVIDIA and i.MX6 based boards to the popular Raspberry Pi 3.

As part of our Mapbox Qt SDK, we expose Mapbox GL to Qt in two separate APIs:

QMapboxGL - implements a C++03x-conformant API that has been tested from Qt 4.7 onwards (Travis CI currently builds it using both Qt 4 and Qt 5).
QQuickMapboxGL - implements a Qt Quick (QML) item that can be added to a scene. Because QQuickFramebufferObjecthas been added in Qt version 5.2, we support this API from this version onwards. The QML item interface matches the Qt Map QML type almost entirely, making it easy to exchange from the upstream solution.

QMapboxGL and QQuickMapboxGL solve different problems. The former is backwards-compatible with previous versions of Qt and is easily integrated into pure C++ environments. The latter takes advantage of Qt Quick’s modern user interface technology, and is the perfect tool for adding navigation maps on embedded platforms. So far we have been testing our code on Linux and macOS desktops, as well as on Linux based embedded devices.

Mapbox is on a joint effort with the Qt Company to make the Mapbox Qt SDK also available through the official Qt Location module - we are aligning APIs to make sure Mapbox-specific features like runtime styles are available.

QQuickMapboxGL API matches Qt’s Map QML Type, as you can see from the example below:

import QtPositioning 5.0
import QtQuick 2.0
import QtQuick.Controls 1.0

import QQuickMapboxGL 1.0

ApplicationWindow {
    width: 640
    height: 480
    visible: true

    QQuickMapboxGL {
        anchors.fill: parent

        parameters: [
            MapParameter {
                property var type: "style"
                property var url: "mapbox://styles/mapbox/streets-v9"
            },
        ]

        center: QtPositioning.coordinate(60.170448, 24.942046) // Helsinki
        zoomLevel: 14
    }
}

Mapbox Qt SDK is currently in beta stage. We’re continuously adding new features and improving documentation is one of our immediate goals. Your patches and ideas are always welcome!

We also invite you to join us next month at Qt World Summit 2016 and contribute to Mapbox on GitHub.

Qt Framework officially supported

2016-05-09T00:00:00+00:00

Link: https://blog.mapbox.com/qt-framework-officially-supported-40b60bfbb0d0

Mapbox GL Native now officially supports Qt, an open-source cross-platform application framework designed to write once, deploy everywhere. Qt is widely used in many industries, including mobile, automotive, avionics and much more due to its fast development cycle, extensive documentation and big community.

Mapbox QML example

We are committed to Qt and Mapbox GL Native now welcomes it as a first-class platform. Mapbox Qt SDK provides QMapboxGL and QQuickMapboxGL.

QMapboxGL and QQuickMapboxGL solve different problems. The former is a low-level implementation that can be used on previous versions of Qt and is easily integrated into pure C++ environments. The latter takes advantage of Qt Quick’s modern user interface technology, and is the perfect tool for adding navigation maps on embedded platforms.

Grab our open source code on GitHub and join us at QtCon this September in Berlin.

Converting C-Like Enums to String values in Rust

2014-01-28T00:00:00+00:00

Note: The contents of this post are based on an API that is now deprecated. For latest guidance over Rust usage of enums from a C/C++ perspective, I recommend reading fasterthanlime’s Peeking inside a rust enum guide.

Suppose you have a C-like enumerator in Rust:

enum Foo {
    SomeValue,
    OtherValue
}

Note: C-Like enumerations in Rust have no parameters (i.e. SomeValue(~str)), and can have their discriminator values explicitly set to a constant value (i.e. SomeValue = 0). See the Rust book section 4.13 Enums for details.

If you want to obtain the string value (i.e. “SomeValue”) given an unsigned integer, the trick is to first cast it as a Foo value, then use format to obtain its string representation. For the former step, first we need to make Foo implement the CLike trait:

extern mod extra;

use std::cast;
use extra::enum_set::CLike;

#[repr(uint)]
enum Foo {
    SomeValue,
    OtherValue
}

impl CLike for Foo {
    fn to_uint(&self) -> uint {
        *self as uint
    }
    fn from_uint(v: uint) -> Foo {
        unsafe { cast::transmute(v) }
    }
}

The latter step is easy, we just need to format the output as string. The simplest way is to make Foo derive from ToStr:

extern mod extra;

use std::cast;
use extra::enum_set::CLike;
use std::to_str::ToStr;

#[repr(uint)]
#[deriving(ToStr)]
enum Foo {
    SomeValue,
    OtherValue
}

impl CLike for Foo {
    fn to_uint(&self) -> uint {
        *self as uint
    }
    fn from_uint(v: uint) -> Foo {
        unsafe { cast::transmute(v) }
    }
}

fn main() {
    let i : Foo = CLike::from_uint(1);
    println!("{}", i.to_str());
}

The output for this code is SomeValue.

CSS Level 3 Text Decoration properties now available in Google Chrome Canary!

2013-08-20T00:00:00+00:00

As of Monday (August 19th), Google Chrome Canary now supports CSS3 Text Decoration shorthand property. Once in Canary, you can enable the Experimental Web Platform Features runtime flag by checking the link below:

chrome://flags/#enable-experimental-web-platform-features

After enabling it, restart your browser and you should be able to use the following pattern:

text-decoration: underline dashed red;

Gives the following result: underline dashed red

As specified in CSS Level 3 Text Decoration shorthand specification. I am also proposing these properties to go enabled by default in WebKit - stay tuned for further updates!

CSS Level 3 Text Decoration on WebKit and Blink - status

2013-05-15T00:00:00+00:00

It’s been a while since I wrote the last post about progress on implementing CSS Level 3 Text Decoration features in WebKit. I’ve been involved with other projects but now I can finally resume this work. So far I have implemented:

These properties are currently available under -webkit- prefix on WebKit, and guarded by a feature flag CSS3_TEXT which is enabled by default on both EFL and GTK ports. On Blink, plans are to get these properties un-prefixed and under a runtime flag, which can be activated by enabling the “Experimental Web Platform Features” flag (see chrome://flags inside Google Chrome/Chromium).

There are still some Skia-related issues to fix on Blink to enable proper dashed and dotted text decoration styles to be displayed. In the near future, we shall also have the text-decoration shorthand as specified on CSS Level 3 specification.

Note: Do not confuse text-decoration-line’s blink value with Google’s Blink project :smile: