Stefano Tommesani

The AltaLux image enhancement filter is now available in the popular XnView image viewer!

Now you can enjoy AltaLux technology inside an advanced image viewer and editor, so trying how AltaLux can effectively enhance your photos is just a click away while you keep using your favourite image viewer.

The AltaLux image enhancement filter is now available in the popular IrfanView image viewer!

Now you can enjoy AltaLux technology inside an advanced image viewer and editor, so trying how AltaLux can effectively enhance your photos is just a click away while you keep using your favourite image viewer.

AltaSonita is an image denoising application built to run on nVidia video boards using CUDA technology. Three different denoising algorithms, and five intensity levels let you remove most of noise from photos without blurring small details and edges.

AltaSonita is provided as free software, and you can download it from here. Please note that AltaSonita requires a CUDA-enabled video board, that is a recent nVidia video board; it will not run on any other video board.

As the following images show, the intensity setting works by separating edgy areas (drawn in red) from mostly plain areas (drawn in blue), and in plain areas the amount of noise filtering is higher as there are no relevant edges that would be blurred by the denoising process. Increasing the intensity setting reduces the amount of edge-preserving areas, so that aggressive noise filtering is applied to more zones of the image.

Original image
KNN filter with min intensity	Edges (drawn in red) of KNN filter with min intensity
KNN filter with max intensity	Edges (drawn in red) of KNN filter with max intensity
NLM filter with min intensity	Edges (drawn in red) of NLM filter with min intensity
NLM filter with max intensity	Edges (drawn in red) of NLM filter with max intensity

Back in 2000, Quexal changed the way programmers had to deal with MMX programming. A friendly user interface simplified building parallel versions of algorithms, an optimizing compiler made sure that the resulting code would run fast, and a visual debugger helped pinpoint programming errors.

Even if the focus of the programming community has moved on to more recent instructions sets, after many years I still get queries about Quexal, so I've decided to release it as freeware, as it may be useful for learning SIMD coding. However, simply releasing the last published version of Quexal was not enough for me, and this was an opportunity to spend some time on this pet project of mine and improve it.

So here you have it, an updated version of Quexal for free! Just go to the download section to get it.

AltaLux is an image processing technology that can significantly enhance the quality of images and videos with poor lighting conditions.

AltaLux/Demo is a Windows sample application that lets you enhance the quality of JPEG images for free (download it! from the download area). For even better usability, you can use the AltaLux plugins for IrfanView and XnView.

The animation above shows how the AltaLux filter performs on a real photo, ranging from left (no enhancement) to right (max level of enhancement). On the original photo the palace is underexposed, it appears dark as the sky in the background is much clearer; increasing the amount of enhancement to an intermediate level takes the palace out of the dark, exposing its facade; moving the enhancement to max is too much of a good thing, as previously hidden details pop out of the screen but the scene does not appear natural at all.

Update: the new 2.5 version includes an additional setting (Scale) that changes how each zone of the image influences nearby ones.Click here for a visual explanation of how it affects filter's results.

In this article we will transform a plain C loop into a multi-threaded version using Intel Thread Building Blocks library (TBB).

Here is the loop to transform:

 unsigned char *SrcImagePtr = (unsigned char *)SrcImage;
 unsigned char *DstImagePtr = (unsigned char *)DstBuffer;
 for (int i = (OriginalImageWidth * OriginalImageHeight); i > 0; i--)
 {
 int YValue = (SrcImagePtr[0] * FirstFactor ) +
 (SrcImagePtr[1] * SecondFactor) +
 (SrcImagePtr[2] * ThirdFactor );
 SrcImagePtr += PixelOffset;
 YValue += 1 << (SCALING_LOG - 1);
 YValue >>= SCALING_LOG;
 if (YValue > 255)
 YValue = 255;
 *DstImagePtr = (unsigned char)YValue;
DstImagePtr++;
}

This loops iterates over a three-channel image named SrcImage (usually a RGB one), and it computes the luma value for each pixel storing it into DstImage. As the computation of every pixel has no dependencies whatsoever on other pixel, it is very simple to separate this computation into multiple threads, each performing it on a different slice of the image.

Even if we could directly use threads for such a task, it is much simpler and faster to use an ad-hoc library such as Intel's Thread Building Blocks.