How To’s…

How to add a new processing?

This is done by deriving from StepFactory, or from OTBStepFactory. You’ll find many examples in the default step factories.

The important points are to decide:

  • Where should the step happen in the sequence of pipelines?
    In all cases, don’t forget to add it in a pipeline registered in the sequence of pipelines.

  • Shall its result be considered as a public product, or an intermediary step?
    A public product is expected to be always produced. It shall then conclude a pipeline. Also the pipeline shall be registered with product_required=True in that case.

  • What would be the name of the result files?
    Override build_step_output_filename() with the answer.


    Even if there is no OTB application behind the step, this method needs to forward the filename of the input as done in AnalyseBorders.build_step_output_filename().

  • Which configuration options would be needed?
    Copy them from the constructor that will be passed the s1tiling.libs.configuration.Configure object.

  • What meta information should be filled-in?
    This should be done in complete_meta().
    Meta information can be used:

    • immediately by other methods like parameters(),
    • or by later steps in the pipeline.
  • If there is an OTB application behind the step – which should be the case for most processing steps.

In case the step relates to an OTB application:

  • What parameters shall be sent to the OTB application?
    Return the information from parameters().
  • What are the parameters expected by the OTB application from the images that could be passed in-memory?
    The default are "in" and "out" but could be overridden in the constructor of the new step factory through the parameters param_in and param_out. See for instance s1tiling.libs.otbwrappers.OrthoRectify.__init__() implementation.
  • What is the OTB application?
    Its name is expected to be passed to the constructor of the parent class, from the constructor of the new class.


Most of the time, inheriting of OTBStepFactory is the best choice. Still, it’s possible to take over and to manually answer the following questions:

Technically all other methods from StepFactory could be overridden. For instance, create_step() could be overridden to change the type of Steps instantiated.

Release a new version

Here is a short list of the actions to do for each new release.

  1. Update the release notes
  2. Make sure version matches the name of the version to be released. Don’t forget the rcX suffix if need be.

Version format is expected to follow the following convention: M.m(.p)(rcX) See

Let’s extract version number into a variable to simplify following steps

version="$(awk '/version/ {print $3}' s1tiling/ | xargs )"
echo "version: ${version}"
  1. Handle all the issues associated for the related milestone.

  2. Push develop branch.

    git checkout develop && git push
  1. Merge develop branch into master

    git checkout master && git merge develop
  2. Push master branch.

    git checkout master && git push

6 Create a git tag matching the version number

git tag -a "${version}"
# And fill in version information
  1. Push the tag

    git push --tags


    From there on, the CI will automatically take care of registering the source distribution (only; and not the wheel!) on pypi as if we had manually ran

    # Prepare the packets for pipy
    python3 sdist
    # Push to pipy
    python3 -m twine upload --repository pypi dist/S1Tiling-${version}*
  2. Update version to the next expected version.

    Do not use the rcX suffix for the moment.