Enfuse Verbosity Levels

Enfuse isa command-line program used to merge different exposures of the same scene to produce an image that looks very much like a tonemapped image (without the halos) but requires no creation of an HDR image. Therefore it is much simpler to use and allows the creation of very large multiple exposure panoramas.

Openreach to deploy permanent Full Fibre monitoring technology to help deliver ultrafast and ultra-reliable broadband to millions of UK homes and businesses.LONDON, UK, Jan. The default verbosity level of Enfuse is ⟨1⟩. 4.2.2   Advanced Options c. Advanced options control e.g. The channel depth, color model, and the cropping of the output image.-blend-colorspace= COLORSPACE Force blending in selected COLORSPACE. Given well matched images this option should not change the output image much. Edit the same lines as above in the top level./CMakeLists.txt file and in./mac/Version.xconfig The same applies to the @api-min and @api-max settings in the scripts. Verify that the branches are ok and push them to the official repository. Since we intentionally create a new remote branch, we use the -f switch in the push command. Enfuse Verbosity Levels Sagar Sen Rabindra Sangeet Mp3 Free Download Splan 6 1552 Biagio Antonacci Sognami Free Vbst Bitcrusher Air Cooler Mobilna Klima Artcam 2008 software, free download With Crack Fader Magazine Cover Malayalam Serial Artist Directory Chief Architect Crack Download Assassin's Creed Unity Corepack.

Enfuse is based on a paper by Tom Mertens, Jan Kautz and Frank Van Reeth: 'Exposure fusion' The implementation was done by Andrew Mihal (developer of Enblend) and the hugin team around Pablo d'Angelo

An extended documentation could be found on Enfuse reference manual

Other programs using Exposure Fusion: tufuse and PTGui Pro

• 1State of development
• 2Description
• 3Usage
• 4External Links
  • 4.2GUIs

State of development

On 8 September 2008 the first official version of enfuse has been released together with enblend.Enfuse/enblend can be downloaded from enblend.sourceforge.net. On that site you will find the 3.2 version source code as well as precompiled windows binaries.

Beta (development) releases can be downloaded from

• panorama.dyndns.org (scroll down on that page) for MacOSX
• and also from hugin.panotools.org

Known bugs

(This section needs to be updated)
This is a list of known bugs in the current version as linked above. For a list of bugs in previous versions please refer to an older version of this page

• If contrasty structures are near zenith or nadir in an equirectangular image, there might be an artifact (vortex) in the resulting pano.

Workaround: use on zenith and nadir images separately and stitch them in the resulting pano afterwards.

- unknown, whether could be fixed easily

Description

Enfuse merges overlapping images using the Mertens-Kautz-Van Reeth exposure fusion algorithm. This is a quick way to blend differently exposed images into a nice output image, without producing intermediate HDR images that are then tonemapped to a viewable image. This simplified process often works much better than the currently known tonemapping algorithms.

Enfuse can also be used to build extended DOF images, by blending a focus stack.

Basics

The basic idea is that pixels in the input images are weighted according to qualities such as proper exposure, good contrast, and high saturation. These weights determine how much a given pixel will contribute to the final image.

This idea is not quite new. F.e. Ardeshir Goshtasby proposed a technique to select and blend only well exposed blocks and Erik Krause provided a photoshop action to smart mask badly exposed areas. Many such 'DRI' or 'Exposure Blending' solutions exist.

The problem of all this techniques was to find good transitions between the areas taken from differently exposed images. There always was a risk of getting banding or even reversed gradients within areas where the brightness gradually changed.

Enfuse solves this problem by using the multi resolution spline blending technique well known from enblend and smartblend - and it is actually this step which is responsible for the wonderful results. The technique is described detailed for enblend and it works almost the same for enfuse, with the exception that instead of the initial seam line a mask is created according to the given criteria.

Enfuse uses three different criteria to judge the quality of a pixel: Exposure, saturation, and contrast.

• The exposure criteria favors pixels with luminance close to the middle of the range. These pixels are considered better-exposed than those with high or low luminance levels.
• The saturation criteria favors highly-saturated pixels.
• The contrast criteria favors high-contrast pixels. The local gray or color value standard deviation is used as a contrast measure. The Mertens-Kautz-Van Reeth paper suggest using a laplacian filter, but the standard deviation produces much better results for differently focused images.

Adjustments

You can adjust how much importance is given to each criteria by setting the weight parameters on the command line. For example, if you set --wExposure=1.0 and --wSaturation=0.5, Enfuse will favor well-exposed pixels over highly-saturated pixels when blending the source images. The impact of these parameters on the final result will not always be clear. The quality of the result is subject to your artistic interpretation. Playing with the weights may or may not give you a more pleasing result. I encourage you to experiment (perhaps using downsized images for speed).

Enfuse allows each input image to have an alpha channel. By setting the alpha values of pixels to zero, users can manually remove those pixels from consideration when blending. If an input image lacks an alpha channel, Enfuse will print a warning and continue assuming all pixels should be processed for final output. Any alpha value other than zero is interpreted as 'this pixel should should be considered for the final image'.

Usage

The usage below refers to the CVS version of the 21 Dec 2007. Use enfuse as follows:

Input files can be a list of files or a wildcard (on windows f.e. IMG*.jpg for all jpg images that begin with IMG.

Common options

Print information on the available options.

Use exactly this many levels for pyramid blending. A low number trades off quality of results for faster execution time and lower memory usage. The default is to use as many levels as possible given the source image size. However, recent versions don't seem to do that hence it might be useful to specify an arbitrary high number (f.e. -l 20) for best results. If you specify a high number Enfuse may still use a smaller number of levels if the geometry of the images demands it.

Required. Specify the name of the output file.

Verbose output.

Blend around the -180/+180 boundary. Useful for full-360 panoramas. Enfuse currently does not blend the zenith or the nadir, so you may still see some seams in these areas.

Write a compressed output file. Valid values are NONE, PACKBITS, LZW and DEFLATE for TIFF files, and numbers from 0-100 for JPEG files.

Extended options

Set the block size for Enfuse's image cache. This is the amount of data that Enfuse will move to and from the disk in one go. The default is 2 MiB which should be good for most systems.

Use the CIECAM02 color appearance model for blending colors. Your input TIFF files should have embedded ICC profiles. If no ICC profile is present, Enfuse will assume that image uses the sRGB color space. The difference between using this option and Enfuse's default color blending algorithm is very slight, and will be most noticeable when you need to blend areas of different primary colors together.

Gimp (ver. < 2) and Cinepaint exhibit unusual behaviors when loading images with unassociated alpha channels. Use the -g flag to work around this. With this flag Enfuse will create the output image with the associated alpha tag set, even though the image is really unassociated alpha.

Set the size and position of the output image manually. This is useful when the input images are cropped TIFF files, such as those produced by Nona.

Set the size of Enfuse's image cache. This is the amount of RAM (in megabytes) Enfuse will use for storing image data before swapping to disk. The default is 1024 MB.

Fusion options

W is a number between 0 (no weight) and 1 (full weight)

Sets the relative weight of the well-exposedness criterion. Increasing this weight relative to the others will make well-exposed pixels contribute more to the final output.

Sets the relative weight of high-saturation pixels. Increasing this weight makes pixels with high saturation contribute more to the final output.

Sets the relative weight of high-contrast pixels. Increasing this weight makes pixels with neighboring differently colored pixels contribute more to the final output. Particularly useful for focus stacks.

Mean of the gaussian weighting function (from 0 to 1) for the exposure criterion only. default value: 0.5. This moves the peak of the curve towards the brighter or darker end of the histogram. Higher values pick more brighter pixels from the source images, lower values more darker ones.

Standard deviation of the gaussian weighting function (from 0) for the exposure criterion only. default value: 0.2. Higher values cause a wider curve and more pixels to be taken from a particular image (possibly including under- and over-exposed ones). A lower value causes a narrower curve and less pixels to be taken, possibly resulting in banding.

Force hard blend masks on the finest scale. This avoids averaging of fine details (only), at the expense of increasing the noise. This improves the sharpness of focus stacks considerably.

Expert options

Window size for local contrast analysis. Values larger than 5 might result in increased computation times. Values in the range of 3 to 7 have given good results on focus stacks. The impact on the result quality is not easy to define. You will have to experiment.

Apply grayscale projection OPERATOR, where OPERATOR is one of 'average', 'l-star', 'lightness', 'value', 'luminance', or 'channel-mixer:RED-WEIGHT:GREEN-WEIGHT:BLUE-WEIGHT'. Default: 'average'

Scale on which to look for edges. Positive LCESCALE switches on local contrast enhancement by LCEFACTOR (EDGESCALE, LCESCALE, LCEFACTOR >= 0).
Append '%' to LCESCALE for values relative to EDGESCALE;
append '%' to LCEFACTOR for relative value. Defaults: 0:0:0

Minimum CURVATURE for an edge to qualify. Append '%' for relative values. Default: 0.

Output intermediate images for debugging.

External Links

Command line

Another implementation of the enfuse algorithm is TuFuse from Max Lyons, which features automatic DOF fusion (from a focus stack) and exposure fusion in one go as well as some additional options: http://www.tawbaware.com/tufuse.htm (freeware, windows only)

GUIs

enfuse has triggered the development of some GUIs.

Multi platform

• The recent release of hugin has integrate enfuse fully. Get it from http://hugin.sourceforge.net (open source).

• PTGui Pro since version 7.7 has a built in image fusion tool which features the exposure criterion only but has extended adjustment possibilities.

• LR/Enfuse is a Lightroom plugin for blending exposures directly from within Lightroom using Enfuse. It works on Mac and PC. Get it from http://photographers-toolbox.com/products/lrenfuse.php

Linux

• KImageFuser by Harry van der Wolf is an enfuse/align_image_stack Gui for Linux (free GPL V3). It has a preview function and batch options. It is written in the graphical script environment kommander and can run on any linux platform. Dependencies are: kdewebdev-3.5.9 or newer, enfuse, align_image_stack (from Hugin), convert (ImageMagick). Not a dependendency but highly recommended: Exiftool to be able to copy all relevant exif data (ImageDescription, Make, Model, Artist, WhitePoint, Copyright, GPS:all, DateTimeOriginal, CreateDate, UserComment, ColorSpace, OwnerName, SerialNumber, all IPTC, all JFIF, XResolution, YResolution, ResolutionUnit, Lens, FocalLengthIn35mmFormat and FocalLength) to the new image. All dependencies are available in the main linux distributions. Note also that at least one KDE theme should be available like e.g. the famous (and default) 'bluecurve' theme. KImageFuser has also been added to the Hugin svn in it's own project KImageFuser tree.
• digiKam can use enfuse to blend bracketed images.

Windows

• The droplets by Erik Krause are contained in the hugin windows package from http://hugin.sourceforge.net and installed ready to use. A group of image files or an entire folder can be dragged and dropped on a droplet. In case of a folder the user can specify the number of images in a bracketed series, hence multiple series can be enfused in one go. The droplets copy relevant EXIF data to the result image such that camera and lens data isn't lost f.e. for subsequent stitching. Another droplet version does automatic alignment in order to allow for handheld bracketed series. (open source)

• EnfuseGUI by Ingemar Bergmark is a graphical user interface (free).

• TuFuse Pro by Max Lyons is a nice graphical user interface to his own tufuse free command line application (commercial)

• Tufusion is a free GUI for Max Lyons' tufuse, developed by TuFuse forum user 'entropy'. It's not as sophisticated as TuFuse Pro, but it surely makes life a lot easier, compared to using the command line application.

Mac OSX

• Bracketeer (commercial) by Brian Greenstone is a graphical user interface with preview function for OS X 10.4 and higher.

• EnfuseGUI (donationware) by Ingemar Bergmark is a graphical user interface for OS X 10.4 and higher.

• ImageFuser (Open Source) by Harry van der Wolf is a graphical user interface for enfuse and align_image_stack with preview function for OS X 10.4 and higher.

• XFuse (free) by Kevin Kratzke is a graphical user interface that allows for batch processing and works on OS X 10.4 and higher. Development of this application is discontinued, last downloadable version is 0.5 as of Feb. 8, 2008.

• 2Contribution
• 3Processes
  • 3.8Release
    • 3.8.1Release Plan
    • 3.8.2Release Notes
    • 3.8.4Keeping the Release Branch in Sync with Default
    • 3.8.6Declare a Release Final
• 5Build your Own Test Builds
  • 5.6Dependencies
• 6Packaging and Distribution

Panorama Related Open Source tools

Contribution

Why contribute?

The above tools are free for you (and every other user), because volunteers have contributed their skills and time. They provide immense value to the whole community. They provide value to you, don't they? If they do, please consider contributing something back.

How to contribute?

Join the hugin-ptx mailing list to find out what is going on at the moment and how you can help.

If you don't have time, you are most likely a busy professional. You can donate money to Hugin, Enblend/Enfuse on their project pages through Sourceforge.

At the time of updating this text (6-Mar-2011) the building process of Hugin is robust and there are more and more people mastering it on the different platform. The 2011.0 release cycle is well underway. Beyond that, a few exciting features such as a python scripting interface are in line for future releases.

Don't be afraid of failures in the building process

• You may encounter errors when following the build processes linked below is high. Don't worry such errors will not compromise your computer.
• The failure of the building process is actually your success! Every time you report such a failure, with as much detail as possible to how it came about, you are contributing to the progress toward a stable release.
• See also If you encounter errors, Fixing The Hugin Build.

If you are fluent in other languages than English, you can help translate Hugin. There's a Hugin translation guide to help you get started or help when you run into translation problems.

Processes

The release process introduced in 2009 has decoupled the development processes from the release process, avoiding artificial slow downs (trunk freezes).

Hugin uses an asynchronous development process based on Mercurial, which means that:

• the default branch never freezes, and committers can continuously add improvements to it.
• anybody can branch out development codelines on their local copy of the repository, and even publish that repository.
• usually developers will branch out to implement major changes or changes that will not be completed very soon; and builders will branch out to clean up releases; without disrupting the continuous flow of contributions.
• unlike in the previous Subversion repository, branches are no longer stored in different folders. Give them a meaningful name to distinguish release branches (version number) from development branches (feature being implemented / worked on).
• developers have write access to the official repository on Sourceforge and can push changes and branches to it. The project is very liberal in giving such write access - if you have something to contribute, mention it on hugin-ptx and chances are one of the admins will give you the necessary write rights.
• once a months, developers are polled as to whether it is worth issuing a release. if there is enough support and one person volunteers as release manager, that person branches out a release codeline from the default codeline. That release codeline is equivalent to a trunk freeze in traditional synchronous development. only bug fixes and translations should go into that codeline. Tarballs are to be released from release codelines only.

Development

• If you are working on something big that requires multiple changes to complete, you're encouraged to start your own branch:

• If you are working on incremental improvements to the default branch, feel free to push them any time. There is no trunk freeze.
• You're encouraged to continue with your usual pace of bug fixing and development.
• To do things perfectly: commit all your changes to the default branch; and apply those that are bug fixes also to the current release codeline if the project is in the midst of a release cycle.
• The new thing about Mercurial (coming from Subversion): commit is to your local repository only. To avoid multiple heads, pull/update before committing; and remember to push your change from time to time so that others can test them / benefit from them / add value to them.

• If you forget about it and commit only to one codeline, do not worry. The release manager takes responsibility to sync between the default branch and the release branch.
• Try not to add new features, particularly new strings, to the release codeline later in the release cycle.

Translation

• Generally same as development. For specifics see the translation guide.

Debugging

Working through Hugin Trackers.

Clearing the tickets in the tracker is an iterative process critical to the release cycle. Feedback from tester is essential for this process. Please take the time to check if the older reports apply to a current snapshot and add new findings to the ticket.

We'll be releasing frequent snapshots until a release candidate emerges. This is an iterative process:

1. Volunteers check the release-critical bugs listed in the bug tracker against the most recent snapshot. The most recent snapshot for is usually posted on the Hugin-PTX mailing list.
   • Install the latest snapshot.
   • Try to reproduce the bug on your system.
   • If you find that the bug no longer occurs, chances are that it has been fixed. Close it (assuming you have the required access), or simply leave a note that it has been fixed (together with the exact version number and the system used for testing).
   • If you reproduce the bug, leave a note to confirm that it is still actual. Note the SHA1 ID and the system used for testing. Post detailed instructions how to reproduce the crash. Provide a test case if you can.
   • Add any comments you have to the ticket in the bug tracker. Let the community know you have tested. The tracker is like a mailing list or forum thread, don't be afraid to post.
   • If you don't want to open an account with Launchpad, post your observations on the hugin-ptx mailing list.
2. The developers fix the bugs identified in the tracker.
3. The builders build new snapshots including the fixes.

Development Codelines

It is recommended to work separately on major changes and integrate them in the main codeline when they are ready. The currently open development branches are listed in the repository along the release branches.

If you want to work on a major new feature, open yourself a branch.

If you want to publish that branch on Sourceforge, ask for write right and push your changes to Sourceforge.

The branch owners are strongly encouraged to regularly sync their branch with default, i.e. merge the changes that have occurred since the last sync (or branching) into their branch.

If an unresolved conflict arises, see below the Merging section.

When development is complete or has reached a milestone, it may be integrated into default. Before integrating into default it is recommended to:

• Merge all of default's changes since the last sync into the branch.
• Test that the branch builds on the major supported platforms.
• Test that the branch does not break existing functionality (unless the break is intended, e.g. when a new functionality replaces an existing one).

When the development branch has fulfilled its purpose; is superseded or has been abandoned, close it.

Enfuse Verbosity Levels

Merging

Most of the time Mercurial is quite good at merging different codelines. However sometimes there are conflicting version and even Mercurial does not know what to do. It will prompt for you to solve the conflicts.

The preferred tool to solve conflicts is [KDiff3 http://mercurial.selenic.com/wiki/KDiff3]. According to Mercurial's wiki it is 'the 'best' merge tools' and included with the Windows installer of TortoiseHg. Handbook. On Ubuntu install it with `sudo apt-get install kdiff3`. To work comfortably with KDiff3, add the following lines to ~/.hgrc:

First close the codeline to be merged with a last commit. Then switch to the default branch and start the merge.

During the merge operation, Mercurial will trigger KDiff3 automatically in case of an unresolved conflict. Kdiff3 will show three versions side by side in the top half of the window:

• in the middle is the current one
• on the right is the new one
• on the left is the base (common ancestor? not sure?)
• In the bottom half of the window is the resulting merge, with conflicts highlighted.
• Using the buttons bar:
  • Use the symbol with the three arrows up/down to jump to the previous/next unsolved conflict.
  • When a <Merge Conflict> area is highlighted in the bottom pane, hit the A/B/C buttons to select which version(s) to use/merge in.
• Once all conflicts are solved, save and quit. Mercurial will continue the merge operation.

Once the merge operation is finished, commit and push.

Maturity Criteria

A development codeline - whether under revision control or presented as a patch - is considered mature when:

• a: the functionality it is intended to implement works on the developer's machine ('works for me' condition)
• b: it has been tested to build on the major supported platforms ('does not leave them behind' condition) by at least one contributor for each: Windows, OSX, Linux
• c: it does not unintentionally break existing functionality ('no regression' condition)

When a development codeline reaches maturity, it enters the integration queue.

Integration Queue

The integration queue is the ordered list of new features / development codelines waiting to be integrated in trunk. The prioritization is a collective decision by consensus of the developers. Silence = consent. The discussion, and the latest version of the list, are on the mailing list.

The integration queue is not set in stone: a change in the maturity status of a feature in waiting is good reason to review/change the ordered list. In any case it is reviewed after every release branching.

Release

Once a month the developers are polled if there is reason to issue a release. If there is enough support for releasing, one developer takes on the role of release manager and undertakes the following steps:

The conditions to declare a release final are:

• the code builds on the major supported platforms (Ubuntu, Fedora, OSX, Windows)
• there is no (known) regression, unless intentional. This means: what worked with the previous release should work with the current one.

Release Plan

Planning the release helps contributors pace and schedule their contributions. On Launchpad there is a simple and adequate tool for planning and communicating releases.

Register a New Hugin Releases Series in Launchpad

When starting a new release cycle, register first a new Releases Series in Launchpad.

• Prerequisites: must be logged in to Launchpad and be a member of the Hugin-Devs team.
• Point your web browser to: https://launchpad.net/hugin/+addseries
• Enter the Version in the Release Name field: V_MAJOR.V_MINOR
• As Summary enter a bullet points list of the most relevant new features that will be introduced by the release.
• Hit Register Release Series.
• On the next page edit the Release Manager.

Edit Status of Previous Series

As a policy:

• Only the default branch, the latest release, and the active development branches are in active development.
• Only the previous two releases are supported.
• Older releases are obsolete.

To change the status as a consequence of the new release cycle, point your browser to https://launchpad.net/hugin/<V_MAJOR.V_MINOR>/+edit, e.g. https://launchpad.net/hugin/2010.4/+edit for the relevant series.

• Change the status of the previous release from Active Development to Supported.
• Change the status of the oldest supported release to Obsolete.

Register Milestones for the release

Planning milestones in advance and registering them with targeted dates will make the process more predictable and help builders plan for the binaries releases.

As a rule of thumb plan for two betas spaced by 2 weeks; for one release candidate two weeks after the last planned beta; and for the first RC to be declared final two weeks after release. Adapt to the circumstances. Things will change during the cycle and you can also add extra betas and rcs. Toward the end of the cycle, spacing can be one week.

• Point your browser to https://launchpad.net/hugin/<V_MAJOR.V_MINOR>/+addmilestone of the new releases series, e.g. https://launchpad.net/hugin/2011.0/+addmilestone
• Enter a name following these conventions:
  • Betas: <V_MAJOR>.<V_MINOR>beta<INCREMENT> with INCREMENT starting from 1, 'beta' in small caps and no spaces or underscores, no leading zeros. Example 2011.0beta1
  • Release Candidates: <V_MAJOR>.<V_MINOR>rc<INCREMENT> with INCREMENT starting from 1, 'rc' in small caps and no spaces or underscores, no leading zeros. Example 2010.4rc2
  • Final Release: <V_MAJOR>.<V_MINOR>.<V_PATCH>, no leading zeros. Example: 2009.2.0
• No need to enter a Code name.
• Enter the date targeted for the tarball release.
• No need to enter a Summary.
• Hit Register Milestone.

Release Notes

The Release Notes are an important document accompanying the release. Although it is just a list of new features, it gets distributed widely. Most readers are unlikely to have used Hugin before. When drafting them, think that the target audience is somebody who has an idea of what a panorama stitcher might be, has never heard of Hugin, but is interested in discovering cool new software.

Start drafting them early in the process to allow for translators to translate the Release Notes on the website. Moreover, you will send them as simple text with each released tarball.

Important: store the release notes in the repository, as a text file inside doc/releases/. Use those texts as inspiration example.

Set Up

Set yourself up to edit the release notes on the website. You will need write access to the SourceForge project.

The Editing Cycle

The website updates automatically about every hour. Wait enough time and point your web browser to http://hugin.sourceforge.net/releases/2010.4/ to verify the result of your edits.

Release Notes for the First Beta Release in a New Release Cycle

Before posting the beta1 of the release cycle, you want to have at least a working draft of the Release Notes. Edit them directly on the website. List the relevant new features. Use the release notes from past releases as a template. Copy them in text form for the email announcing the beta1 release. Don't link them from the homepage. Translators will want to start working on the text as soon as possible. Try to finish it early in the process. Add a comment at the beginning of the text to detail its current status. Not all translators follow the Changelog of the website and so are not aware if you committed the document as skeleton / draft / update / final.

Release Notes for Follow Up Releases in the Same Release Cycle

It is important to show the changes relative to the previous tarball, however only in the email announcing the new tarball. The HTML page on the website will most likely stay untouched (unless an important new feature has been added so late in the cycle). Add a section 'Changes since previous beta release' (or 'Changes since previous release candidate' if we're already at the RC stage) to the text mail you sent announcing the beta1 release. Copy and edit the relevant Changelog entries in there.

Branching Out For Release

1. Identify and add the new strings for translation.

Before running the script, make sure you have wxrc installed. On older Ubuntu, run sudo apt-get install wxrc. On Ubuntu 10.4LTS it is sudo apt-get install wx-common.

2. Update the Changes.txt file

3. Identify the last time a release branch was branched from the default branch. This is usually tagged with a beta1 tag, so just use `hg view` and note down the revision number associated with the last beta1 tag. Extract the relevant changelog information for the release notes and save them in a file for later use:

4. Branch out a new release-codeline (replace 2010.4 below with the appropriate version number. 2010 stands for the current year and 4 stands for the next even number in sequence, starting with 0 if the year has changed and this is the first release of the year).

5. Bump up the version number:

In the top level ./CMakeLists.txt edit the lines

In mac/Version.xcconfig edit the lines

6. Update the @api-min and @api-max setting of the Python scripts in src/hugin_script_interface/plugins. For this it needs to check if they work with the current API or if there was an incompatible API change. In the latter case the scripts should updated or removed from the release.

This is not required for the scripts in src/hugin_script_interface/plugins-dev. These files contains only the rough framework for script developer.

7. Set the red splash screen to indicate that the artwork embellishing the release has not been selected yet (only to be done, if there is artwork selected for the release).

(April 2015: currently not needed)

8. Switch back to the default branch and bump up to the next odd version number, e.g. 2010.5 in this example.

Edit the same lines as above in the top level ./CMakeLists.txt file and in ./mac/Version.xconfig

The same applies to the @api-min and @api-max settings in the scripts.

9. Verify that the branches are ok and push them to the official repository. Since we intentionally create a new remote branch, we use the -f switch in the push command.

Keeping the Release Branch in Sync with Default

Committers have no obligation to help maintaining the release branch. In fact, it is best if they keep working in default on both code and translations. As a release manager, you want to stay on top of the changes in default and synchronize them into your branch prior to release if relevant.

The Hgk Mercurial extensions will help you with this. Edit your ~/.hgrc file to activate it. In [extensions] section add:

If `hg view` does not work / returns an error, you may be missing a dependency. In Ubuntu type `sudo apt-get install tk8.5`.

In Hgk the changesets are displayed chronologically per branch with the newest one on top. Branches are indicated visually by a tree on the left. Tags have a yellow background and te top of branches are indicated by a box with green background and the name of the branch, except the default branch. Tags are displayed on yellow background.

Syncing Code from Default to Release Branch

This is for code only. For translations, see below.

• Make sure your repo is up to date and get an overview of the two branches with Hgk:
• Find the first changeset on the default branch after the last time you synchronized and work yourself up to the present.
• Select one changeset at a time. You will see details of the change set in the lower part of the window.
• In the lower left panel, read the changeset log and its revision number.
• Decide if you want to apply it to the Release branch (i.e. if it is a bug fix)
• If you decided that the changeset should apply to the Release branch, check if it has not been applied already by the developer.
• If it has not been applied, apply it, using the <REVISION_NUMBER>:
• If you deem this to have been a major change, go through a build/test cycle
• Repeat until all new changes have been applied
• Go through a build/test cycle
• Push your changes to the public repository

Syncing Code from the Release Branch to Default

This is for code only. For translations, see below.

The procedure is the same, just make sure you're working in default:

Updating Translations

Translations must always be imported using `msgmerge`.

• copy the file with the new contributed translation to src/translations/<LANG>.contributed.po
• check how many strings will be added/removed
• merge the new translation with the existing translation into a new file src/translations/<LANG>.merged.po
• examine the old and the new po files with msgfmt.
• if the statistics look good, overwrite the old file with the new file, commit, push, and ask native language speakers to check.
• repeat separately for each affected branch.

To check the status of the translations you could do something like:

This will give you something like:

Release

1. Start with a clean checkout.

2. Switch to the branch you are going to release (example 2013.0 release; and when you don't know do a 'hg branches')

3. Update the Changelog (make sure LC_ALL is set to UTF-8 when doing this). In Ubuntu you may have to do something like `export && export LC_ALL='en_CA.UTF-8'`

4. commit the Changelog

5. Update the appdata files in platforms/linux/appdata. Add a line with the date and release number like

in the <releases> block to calibrate_lens_gui.appdata.xml, hugin.appdata.xml and PTBatcherGUI.appdata.xml.

6. tag the release (list the tags first to see how releases are named and ensure consistency.

• Betas: <V_MAJOR>.<V_MINOR>beta<INCREMENT> with INCREMENT starting from 1, 'beta' in small caps and no spaces or underscores, no leading zeros. Example 2011.0beta1
• Release Candidates: <V_MAJOR>.<V_MINOR>rc<INCREMENT> with INCREMENT starting from 1, 'rc' in small caps and no spaces or underscores, no leading zeros. Example 2010.4rc2
• Final Release: <V_MAJOR>.<V_MINOR>.<V_PATCH>, no leading zeros. Example: 2009.2.0

To fix/clean up tags:

• remove a tag with `hg tag --remove <TAG_NAME>`
• add a tag by going to a specific revision and tagging it: `hg up -q -r <REV> && hg tag <TAGNAME>`
• if a tag exists already and you want to move it, just use `hg tag -f <TAGNAME>` at the new revision to be tagged

7. note down the revision/hash for the release

7. Create tarball

8. Build an rpm or deb (depending on your distro) from the tarball as a sanity check. Test what you can test.

9. Rename the tarball. For snapsnots, append _snapshotYYMMDD (replace YYMMDD with Year/Month/Day). For betas, append _betaX with X being an incremental number starting with 1. For release candidates, append _rcX with X being an incremental number starting with 1. Eventually the last candidate will be made final (by removing the appendix) after a few more tests prove that no further candidate is needed.

10. Determine the tarball's checksum for the announcement notice

11. Upload the tarball to SourceForge.

• Must to be a 'Release tech'.
• Preferred: with rsync (best with SSH Key set up, else need to enter password):

• Web based alternative (not reliable, outdated instructions may not work since SourceForge has made major changes in February 2010)
  • log on to the SF file manager
  • left-click to navigate to the appropriate subfolder (e.g. hugin -> hugin-2009.2)
  • click on the icon next to the appropriate subfolder and in the context menu select 'Uploads here' (or 'New folder') if you need a new folder.
  • click on 'upload file'
  • browse to the local file and let the upload begin.
  • prepare a release notes text file (e.g. 'hugin-2009.2.0.release_notes.txt') and upload it as well, to the same subfolder
  • left-click on the release notes text file and click the checkbox 'Release Note'
  • left-click on the released file. If you want it to be the default download for a specific platform, click the appropriate checkbox
  • in the 'Release Notes' dropdown list, select the appropriate ones for this file
  • note the SHA1 sum calculated by SF. Compare it with the one determined in step 8. If it is different, delete the uploaded file and try again.

12. Upload the tarball to Launchpad.

• Must be a member of the Hugin Developers Team on Launchpad.
• Strongly recommended: a GPG Key set up on Launchpad.
• Must have a pre-registered Series (see Release Plan above).
• Sign the tarball (if you have a GPG Key)

• Point your browser to https://launchpad.net/hugin/<SERIES>/+addrelease, e.g. https://launchpad.net/hugin/2011.0/+addrelease
• Select the milestone against which you are uploading in the drop down menu, or if there was no milestone yet create one on the fly
• Set the release date
• Copy the Release Notes and ChangeLog into the fields
• Hit 'Register the release'
• Hit 'Add download file' (max file size is 200MB)
• Enter short Description: Hugin 2010.0.0 release tarball
• Browse to the .tar.bz2 file
• Browse to the .tar.bz2.asc signature
• Set Content Type: code release tarball
• Hit 'Upload'

13. Draft the release announcement.

• Extract the relevant ChangeLog section since the last release (look up the last release by tag or by revision number in `hg view`, then issue a command `hg log -r <REV_OF_PREV_RELEASE>: -b default --follow --style=changelog > relchange.txt
• Use the Mercurial Tag noted earlier.
• Use the SHA1SUM noted earlier.

14. Mail the announcement to hugin-ptx.

15. Clear the bug tracker. Go over the reports identified as fix committed and change their status to fix released.

16. Wait for feedback and fixes. Volunteers may fix critical bugs. Test that the codeline builds on the major supported platforms. Test that no major functionality is broken. Repeats steps 1-13 as often as necessary.

17. Once the codeline is final, port relevant 'polish' commits that have not been ported yet to default.

Enfuse Verbosity Levels Chart

18. Later on if patches are required, apply them to the branch. Bump up V_PATCH in ./CMakeLists.txt and HUGIN_VERSION_PATCH in ./mac/Version.xcconfig, tag, and release.

Declare a Release Final

• No tarball is to be released as final without being a release candidate (RC) first. If fixes are committed to the release codeline after the last RC, you have two options: either declare the current RC final and the issue a known issue; or release a new RC and wait again for it to be deemed of final quality. Make the decision by consensus on the mailing list.
• Once you've decided that the current release candidate is final, polish the release notes in /doc/releases/ and on the website in /releases/ (this should be a process along with the polishing of the release itself). This will be mostly just text shuffling as information important during the release cycle such as calls for translation is pushed down in the document in favor of information that is more important for daily use.

Mercurial Repository

• identify the revision number that was tagged as the last RC (the number before the semicolon in the list of tags produced by the first command below) and tag it with the final version number:

• commit the release notes into doc/releases/ if you have not done so yet.

SourceForge

The following procedure can be done on the web or more conveniently in a shell.

Web interface:

• Log on to SourceForge's web interface.
• In the download folder for the current release cycle, delete all betas and rc except the last one (hit the hash sign button if on the web interface)
• Rename the last RC files, e.g. hugin-2010.4.0.tar.bz2
• Rename the folder for the current release cycle to a final folder name

Shell:

Rename a text document with the release notes README and upload it

Must be done on the web interface:

• Hit the circle symbol with the i on the line listing the download to show details
• for the README file, tick the Exclude Stats box
• for the tarball tick the Default Download boxes for all systems except Windows and Mac
• for Windows or Mac binaries, tick the appropriate Default Download box. (Issue: no discrimination of 32/64 bits -> use the 32 bits)
• Paste the announcement into the SourceForge news system. You need to be a 'News Editor' to do this. Log on to https://sourceforge.net/news/submit.php?group_id=77506 and paste the announcement. Note: we have not been using SF's news for at least a year.

Launchpad

Enfuse Verbosity Levels Definition

• If you have not kept a copy of the last release candidate and its signature that were uploaded to Launchpad on release of the last release candidate:
  • Point your browser to the last release candidate on Launchpad, e.g. https://launchpad.net/hugin/+milestone/2011.0rc1
  • Download the last release candidate e.g. http://launchpad.net/hugin/2011.0/2011.0rc1/+download/hugin-2011.0.0_rc1.tar.bz2
  • Download the last signature e.g. http://launchpad.net/hugin/2011.0/2011.0rc1/+download/hugin-2011.0.0_rc1.tar.bz2.asc
• Point your browser to https://launchpad.net/hugin/<SERIES>/+addrelease, e.g. https://launchpad.net/hugin/2011.0/+addrelease
• Select the milestone against which you are uploading in the drop down menu, or if there was no milestone yet create one on the fly
• Set the release date
• Copy the Release Notes and ChangeLog into the fields
• Hit 'Register the release'
• Hit 'Add download file' (max file size is 200MB)
• Enter short Description: Hugin 2011.0.0 release tarball
• Browse to the .tar.bz2 file
• Browse to the .tar.bz2.asc signature
• Set Content Type: code release tarball
• Hit 'Upload'

Public Announcement

• update Hugin homepage with link to the new release notes
• mail the announcement to Hugin-PTX (subscription required).
• mail the announcement to CREATE (subscription required).

Testing

• There is only so much testing that can be done with our limited resources.
• Final releases are expected to build and work on the major supported platforms, however it is possible that a bug slips in due to lack of resources / systematic testing
• We may issue patch releases in case of security issues or other major issues reported after final release.

Distribution

• The Hugin project releases source code that is tested to build on the main supported platforms: Fedora, Ubuntu, Windows, OSX. It works on the developers machines. YMMV.
• Building and distributing binaries is left to the users communities. Once there are binaries of appropriate quality level for platforms that do not have a package manager (Windows and OSX) we add them as a courtesy to the SourceForge download archive - as usual 'WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.' See the GNU General Public License for more details.

Download Test Build

Users publish test builds in different places of their choosing. Refer to hugin-ptx for the latest information.

• Ubuntu: when there are changes in the repository and when the latest revision builds, an automated nightly is produced every 24 hours for the Hugin PPA. Add it to your system with:

• OSX: from time to time bleeding edge bundles are updated on Harry van der Wolf's site.

Build your Own Test Builds

If you are ready to go through the building process, here are the instructions.

Goal

An infrastructure for on-demand build and distribution of usable test-binaries for the most popular platforms. Ideally on demand, and synchronized with the project's major milestones and releases. But also builds for personal use.

Process

1. The build process for Hugin and related tools is documented for each of the supported platform.
2. Users reproduce the documented process and report success or failure.
3. Experienced users and/or developers follow up on the reports and keep the documentation current.
4. Power users script and automate the building process.
5. Users with packaging skills package the builds for distribution (installers).
6. The produced binaries/installers will be made available via the package distribution tools of well managed O/S; and/or on the web.

Specific revisions

When building from the repository, some revisions may be broken. This process is meant to build the latest revision so that if the latest revision has bugs these can be identified, reported and corrected. However sometimes these bugs can be more critical than other times. If you need a more or less working version of Hugin, try applying the process to an earlier revision or to a released branch. To stay on top of all changes, consult the revision logs and the discussions on the hugin-ptx mailing list.

Supported Platforms

• If you don't find your preferred platform listed below and you are willing to contribute your time and skills to build Hugin on it, feel free to add it to the table. We will accommodate any well supported platform in the regular release process.
• Redundancy is good. If you have access to one of the listed platforms, please try to run the documented process below and report success to hugin-ptx.

Enfuse Verbosity Levels Meaning

Stati

Build Chain

• tbd: looking for responsible
• OK: mostly automated build process ready on request
• unavailable: temporarily unavailable (e.g. responsible on holiday)
• HW-broken: the hardware is temporarily unavailable
• SW-broken: temporarily dysfunctional, working on a fix
• broken: nobody is working on a fix
• unsupported: has been dropped for lack of support

Process

• tbd: status unknown
• auto: work as documented and has been automated to a reasonable extent
• OK: works as documented, could use automation / scripting
• draft: documented, needs validation / testing / cleaning
• incomplete: parts are missing (e.g. enblend, libpano)
• outdated: worked in the past but needs an update
• obsolete: nobody has the time to update

Dependencies

Hugin is work in progress and dependencies can be added any time. If your build does not work, see Fixing The Hugin Build.

Hugin depends on the following packages. The list may be incomplete, and there may be some platform-specific dependencies. Details for specific platforms are in the platform documents linked above.

Build-Time Dependencies

Users compiling Hugin (version 2016.1 and later) from source will need:

• A C++ compiler which supports OpenMP and C++11
  • OpenMP support is not required. But when compiling without OpenMP nona and cpfind (and some other algorithm) are running only with one thread, which is slower.

Enfuse Verbosity Levels Examples

• The wxWidgets GUI toolkit version >=2.7.0. the 3.x series is supported.
• std::filesystem from C++17 or boost::filesystem (Boost >= 1.47)
• libzlib the zlib compression library.
• libtiff the TIFF library with LZW support.
• libpano13 version >=2.9.19
• libjpg the JPEG library
• libpng the PNG library
• libopenexr the OpenEXR library
• vigra the VIGRA Computer Vision Library >=1.9
• Exiv2 Image metadata library
• GLEW the OpenGL Extension Wrangler Library
• optionally, libfftw3
• On Unix/Linux you need also
  • libGLU the OpenGL utility library
• On Windows you need also
  • HTML Help Workshop for generating compiled HTML help file
  • optional WiX toolset to create the installer
• On MacOS you need also
  • freeglut or glut, the OpenGL utility toolkit

• for the optional Python Scripting Interface (currently functional and tested only on Linux and Windows)
  • Python version >=2.6
  • SWIG >=2.0 - If Python >=3.2, SWIG must be >=2.0.4
• Hugin can be compiled with gcc, as well as with MSVC.
• The build process requires CMake version >=3.1

Run-Time Dependencies

At runtime

• enblend >= 3.2 is required.
• Exiftool >=9.09 is required.
• Starting with Hugin 2010.3 and newer, Hugin ships with its own control points generator cpfind. Prior to 2010.3 another optional but recommended runtime dependency was a control points generator.
• Optionally Python argparse command-line parsing library for the Python scripts.

Packaging and Distribution

Instructions for packaging binaries for distribution will follow. Some important points:

Snapshots

• comply with the GPL
  • join a text of the GPL in the distribution
  • give access to the source code
  • credit the authors
• label clearly the snapshot as such, with a reference to the build date and/or the SVN revision number
• edit the text / readme files that come with the snapshot
  • indicate clearly that it is unstable, experimental software
  • indicate where to find the latest version
  • indicate that the advertised features might or might not work

Release

• comply with the GPL
  • join a text of the GPL in the distribution
  • give access to the source code
  • credit the authors

Feedback

When running through the building process documented above chances are that something goes wrong. While it is disappointing when the process ends in a flurry of cryptic error messages it is not harmful. This is the nature of software development and you are now part of it. There is a lot of value in your experience and you can help improve the process and get closer to the hoped for software package. Don't be ashamed that it did not work. This happens even to the most expert coders. Give the developers feedback on the hugin-ptx mailing list. Only with your feedback they can know that something goes wrong, and a well crafted feedback is the most important step to help identify what went wrong and devise a solution. Be a part of the solution, not a part of the problem!

To give good feedback, note down carefully all of this information while you are going through the instructions.

1. Details about your computer. CPU, operating system, other particularities
2. The revision number of the code checked out with Mercurial (`hg sum`). If you don't find a revision number, the date and time when you checked out the code.
3. The last step / command you entered into the command line.
4. A copy of the last few lines displayed, from where you think the error messages started. Don't worry if you copy a couple of lines too many, it is better to give more lines than less lines.

Even the standard feedback is good feedback. For those wishing to dig deeper, you can try

• to use 'make VERBOSE=1' when building hugin.
• to do a debug build 'cmake -DCMAKE_BUILD_TYPE=DEBUG' and use oprofile for profiling.