Borbin the 🐱

Sunny Sunday afternoon at the Kirkland Piers.

Interactive Panorama Kirkland Pier 1

1/800s f/5,6 ISO 100/21° f=7,5mm

Hidden, but in plain sight. This pier is next to the popular Marina park, but since the entrance is behind the street, it was rather empty.
The long shadow (picture #4 in the index) was covered by taking a nadir picture (picture #8 in the index) off center. Almost. One piece of the shadow is still visible at the siding of the pier.

Interactive Panorama Kirkland Pier 2

1/1000s f/5,6 ISO 100/21° f=7,5mm

Sauron is watching you.

1/320s f/6,3 ISO 100/21° 16-50mm f/3,5-6,3 VR f=16mm/24mm

1/320s f/6,3 ISO 100/21° 16-50mm f/3,5-6,3 VR f=16mm/24mm

1/320s f/6,3 ISO 100/21° 16-50mm f/3,5-6,3 VR f=16mm/24mm

Der schönste letzte Tag im Jahr 🎉

1/60s f/8,0 ISO 100/21° 16-50mm f/3,5-6,3 VR f=28mm/42mm mit SB-700 +0,7EV

Die Herstellung

Focus stacking involves taking multiple photos at different focus points and merging them into a single image that contains only the sharpest areas.
See also Combine pictures with PTGui, Focus stacking.

Three images, each focused on different points -foreground, middle ground, and background- were taken and subsequently merged using PTGui and HeliconFocus.

PTGui

PTGui automatically established control points and precisely aligned all the images, performing as expected for a panoramic image application. Using a simple mask, the three in-focus areas were seamlessly integrated.

HeliconFocus

Since all the images were taken handheld, there are slight variations in perspective. This is evident in the results from HeliconFocus. It is likely that a dedicated focus stacking application expects images to be captured using a tripod for optimal results.

Isn't it surprising how good a panorama stitching app performs compared to a dedicated focus stacking app?

The Making of test picture

Painting made by @jamila.draws on Instagram

Taken at the 2024 Winter Solstice ♑︎, the shortest day of the year.

This panorama is the 2024 Winter Solstice contribution for the 'December Wrinkle' event of WorldWidePanorama.

Interactive Panorama Overlake Hospital

I took this panorama about an hour before sunset without a tripod while waiting at the main exit. The main challenge was aligning the pathway with the building's geometric facade.
Taking more pictures than necessary helps with panoramas because it allows for better adjustments and alignment.
Using the mask feature in PTGui is another significant advantage. It allows you to force the seamlines into less prominent areas, thereby minimizing visible overlaps and reducing poor alignment.

1/60s f/5,6 ISO 100/21° 7,5mm

Only the central parts of the images were used, which minimized errors. Note the nearly uniform size of the horizontal image parts, with the exception of the pair on the left side of the large building.

At one point, I had this rare PTGui result:

The C++ standard does not allow the usage of a function inside another function. Instead, a lambda expression can be used to achieve this functionality.

For instance, it is not permissible to define this function within another function. However, you can achieve the same functionality by using a lambda expression as follows:

// function definition
BYTE grey_sum(int x, int y)
{
    const int index(3 * ((rect_y + y) * requested_data2.picture_width + rect_x + x));
    const BYTE grey(data[index]);
    return grey;
}

The lambda syntax starts with the capture clause [=] to have read access on all the variables in the scope (use an empty clause [] to access only local variables, or use [&] to use all the variables as references, or list explicitly which variables are used by value and which by reference, for example: [a, &b]), the argument list (int x, int y) and then the return type -> BYTE. The mutable specification and the exception specification are optional and not used here.
The lambda is then used like a function: grey_sum1 += grey_sum(x1, y1);

// equivalent lambda definition
auto grey_sum = [=](int x, int y) -> BYTE
    {
        const int index(3 * ((rect_y + y) * requested_data2.picture_width + rect_x + x));
        const BYTE grey(data[index]);
        return grey;
    };

See this example from the AsciiArt plugin for cPicture (github link).
Using a traditional function would necessitate passing all local data as arguments, which can be inefficient. In contrast, a lambda expression provides a more streamlined and effective approach by capturing local variables directly within its scope.

    // Lambda to calculate the grey value.
    auto grey_sum = [=](int x, int y) -> BYTE
        {
            const int index(3 * ((rect_y + y) * requested_data2.picture_width + rect_x + x));
            const BYTE grey(data[index]);
            return grey;
        };

    // Read the rect segment at (rect_x, rect_y).
    for (register int y1 = 0; y1 < rect_h / 2; y1++)
    {
        for (register int x1 = 0; x1 < rect_w / 2; x1++)
            grey_sum1 += grey_sum(x1, y1);

        for (register int x2 = rect_w / 2; x2 < rect_w; x2++)
            grey_sum2 += grey_sum(x2, y1);
    }
    for (register int y2 = rect_h / 2; y2 < rect_h; y2++)
    {
        for (register int x1 = 0; x1 < rect_w / 2; x1++)
            grey_sum3 += grey_sum(x1, y2);

        for (register int x2 = rect_w / 2; x2 < rect_w; x2++)
            grey_sum4 += grey_sum(x2, y2);
    }

    const int rect_area4 = rect_area / 4;

    // Lambda to check if the contrast and brightness adjusted grey sum exceeds the threshold.
    auto match = [=](__int64 grey_sum) -> bool
        {
            return ((grey_sum / rect_area4 - 127) * (100 - contrast) / 100 + brightness + 127) <= 127;
        };

    // rect area is divided into 4 equal parts
    // 12
    // 34
    const bool b1 = match(grey_sum1);
    const bool b2 = match(grey_sum2);
    const bool b3 = match(grey_sum3);
    const bool b4 = match(grey_sum4);