shinestacker 0.3.6__tar.gz → 0.5.0__tar.gz

{shinestacker-0.3.6 → shinestacker-0.5.0}/CHANGELOG.md

@@ -2,16 +2,44 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v0.5.0] - 2025-08-20
+**GUI and robustness improvements**
+
+### Changes
+
+* layer selection highlightted with a blue border
+* improved font rendering in brush preview
+* fixed thumbnail spacing
+* fixed and improved save strategy for retouched images
+* added checks for updated version in about dialog
+* disable "Save" and "Save As..." menus if do not apply to current status
+
 ---
 
-## [v-.-.-] - 2025-08-17
-**Unreleased changes, for next release round**
+## [v0.4.0] - 2025-08-19
+**Support touchpad navigation**
+
+### Changes
+
+* implemented touchpad image navigation (pan, zoom with pinch)
+* alignment robustness: retry without subsampling if number of bood matches is below a threshold parameter
+* added more robust path management in retouch area
+* added frame count display in "New Project" dialog
+* more unifrom color code in GUI run log
+* code clanup, removed remnants of obsolete code
+* various fixes
+
+---
+
+## [v0.3.6] - 2025-08-18
+**Bug fixes**
 
 ### Changes
 
 * fixed a bug that prevented a complete clean up when "New Project" action is called
 * fixed the management of project file path while loading and saving
-* removed duplicated code, code clean up
+* removed duplicated code
+* some code clean up
 
 ---
 

shinestacker-0.5.0/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

{shinestacker-0.3.6 → shinestacker-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 0.3.6
+Version: 0.5.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -37,10 +37,10 @@ Dynamic: license-file
 [![PyPI version](https://img.shields.io/pypi/v/shinestacker?color=success)](https://pypi.org/project/shinestacker/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/shinestacker)](https://pypi.org/project/shinestacker/)
 [![Qt Versions](https://img.shields.io/badge/Qt-6-blue.svg?&logo=Qt&logoWidth=18&logoColor=white)](https://www.qt.io/qt-for-python)
-[![pylint](https://img.shields.io/badge/PyLint-9.98-yellow?logo=python&logoColor=white)](https://github.com/lucalista/shinestacker/blob/main/.github/workflows/pylint.yml)
+[![pylint](https://img.shields.io/badge/PyLint-10.00-brightgreen?logo=python&logoColor=white)](https://github.com/lucalista/shinestacker/blob/main/.github/workflows/pylint.yml)
 [![codecov](https://codecov.io/github/lucalista/shinestacker/graph/badge.svg?token=Y5NKW6VH5G)](https://codecov.io/github/lucalista/shinestacker)
 [![Documentation Status](https://readthedocs.org/projects/shinestacker/badge/?version=latest)](https://shinestacker.readthedocs.io/en/latest/?badge=latest)
-
+ [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies.gif' width="400" referrerpolicy="no-referrer">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies_stack.jpg' width="400" referrerpolicy="no-referrer">
 
@@ -83,7 +83,8 @@ Pyramid methods in image processing
 
 # License
 
-The software is provided as is under the [GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/).
+<img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
+The software is provided as is under the [GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html). See [LICENSE](https://github.com/lucalista/shinestacker/blob/main/LICENSE) for details.
 
 # Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as:

{shinestacker-0.3.6 → shinestacker-0.5.0}/README.md

@@ -6,10 +6,10 @@
 [![PyPI version](https://img.shields.io/pypi/v/shinestacker?color=success)](https://pypi.org/project/shinestacker/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/shinestacker)](https://pypi.org/project/shinestacker/)
 [![Qt Versions](https://img.shields.io/badge/Qt-6-blue.svg?&logo=Qt&logoWidth=18&logoColor=white)](https://www.qt.io/qt-for-python)
-[![pylint](https://img.shields.io/badge/PyLint-9.98-yellow?logo=python&logoColor=white)](https://github.com/lucalista/shinestacker/blob/main/.github/workflows/pylint.yml)
+[![pylint](https://img.shields.io/badge/PyLint-10.00-brightgreen?logo=python&logoColor=white)](https://github.com/lucalista/shinestacker/blob/main/.github/workflows/pylint.yml)
 [![codecov](https://codecov.io/github/lucalista/shinestacker/graph/badge.svg?token=Y5NKW6VH5G)](https://codecov.io/github/lucalista/shinestacker)
 [![Documentation Status](https://readthedocs.org/projects/shinestacker/badge/?version=latest)](https://shinestacker.readthedocs.io/en/latest/?badge=latest)
-
+ [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies.gif' width="400" referrerpolicy="no-referrer">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies_stack.jpg' width="400" referrerpolicy="no-referrer">
 
@@ -52,7 +52,8 @@ Pyramid methods in image processing
 
 # License
 
-The software is provided as is under the [GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/).
+<img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
+The software is provided as is under the [GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html). See [LICENSE](https://github.com/lucalista/shinestacker/blob/main/LICENSE) for details.
 
 # Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as:

{shinestacker-0.3.6 → shinestacker-0.5.0}/docs/alignment.md

@@ -66,7 +66,8 @@ alignment_config = {
     'border_value': (0, 0, 0, 0),
     'border_blur': 50,
     'subsample': 1,
-    'fast_subsampling': False
+    'fast_subsampling': False,
+    'min_good_matches': 100
 }
 ```
 * ```transform``` (optional, default: ```ALIGN_RIGID```): the transformation applied to register images. Possible values are:
@@ -80,7 +81,8 @@ alignment_config = {
 * ```align_confidence``` (optional, default: 99.9): alignment algorithm confidence (%). Used only if ```transform=ALIGN_RIGID```. 
 * ```max_iters``` (optional, default: 2000): maximum number of iterations. Used only if ```transform=ALIGN_HOMOGRAPHY```. 
 * ```subsample``` (optional, default: 1): subsample image for faster alignment. Faster, but alignment could be less accurate. It can save time, in particular for large images.
-* ```fast_subsampling``` (optiona, default: ```False```): perform fast image subsampling without interpolation. Used if ```subsample``` is set to ```True```.
+* ```fast_subsampling``` (optional, default: ```False```): perform fast image subsampling without interpolation. Used if ```subsample``` is set to ```True```.
+* ```min_good_matches``` (optional, default: 100): if ```subsample```>1 and the number of good matches is below ```min_good_matches```, the alignment is retried without subsampling. This improbes robustness in case a too large subsampling factor is specified. 
 * ```border_mode``` (optional, default: ```BORDER_REPLICATE_BLUR```): border mode. See [Adding borders to your images](https://docs.opencv.org/3.4/dc/da3/tutorial_copyMakeBorder.html) for more details.  Possible values are:
   * ```BORDER_CONSTANT```: pad the image with a constant value. The border value is specified with the parameter ```border_value```.
   * ```BORDER_REPLICATE```: the rows and columns at the very edge of the original are replicated to the extra border.

shinestacker-0.5.0/scripts/git-rev-list.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+git rev-list --objects --all |
+  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' |
+  awk '/^blob/ {print $3,$4}' |
+  sort -n -k1 |
+  tail -50

shinestacker-0.5.0/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '0.5.0'

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/align.py

@@ -5,6 +5,7 @@ import matplotlib.pyplot as plt
 import cv2
 from .. config.constants import constants
 from .. core.exceptions import AlignmentError, InvalidOptionError
+from .. core.colors import color_str
 from .utils import img_8bit, img_bw_8bit, save_plot
 from .utils import get_img_metadata, validate_image
 from .stack_framework import SubAction
@@ -33,7 +34,8 @@ _DEFAULT_ALIGNMENT_CONFIG = {
     'border_value': constants.DEFAULT_BORDER_VALUE,
     'border_blur': constants.DEFAULT_BORDER_BLUR,
     'subsample': constants.DEFAULT_ALIGN_SUBSAMPLE,
-    'fast_subsampling': constants.DEFAULT_ALIGN_FAST_SUBSAMPLING
+    'fast_subsampling': constants.DEFAULT_ALIGN_FAST_SUBSAMPLING,
+    'min_good_matches': constants.DEFAULT_ALIGN_MIN_GOOD_MATCHES
 }
 
 
@@ -164,21 +166,31 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     if callbacks and 'message' in callbacks:
         callbacks['message']()
     subsample = alignment_config['subsample']
-    if subsample > 1:
-        if alignment_config['fast_subsampling']:
-            img_0_sub, img_1_sub = img_0[::subsample, ::subsample], img_1[::subsample, ::subsample]
+    min_good_matches = alignment_config['min_good_matches']
+    while True:
+        if subsample > 1:
+            if alignment_config['fast_subsampling']:
+                img_0_sub, img_1_sub = \
+                    img_0[::subsample, ::subsample], img_1[::subsample, ::subsample]
+            else:
+                img_0_sub = cv2.resize(img_0, (0, 0),
+                                       fx=1 / subsample, fy=1 / subsample,
+                                       interpolation=cv2.INTER_AREA)
+                img_1_sub = cv2.resize(img_1, (0, 0),
+                                       fx=1 / subsample, fy=1 / subsample,
+                                       interpolation=cv2.INTER_AREA)
         else:
-            img_0_sub = cv2.resize(img_0, (0, 0),
-                                   fx=1 / subsample, fy=1 / subsample,
-                                   interpolation=cv2.INTER_AREA)
-            img_1_sub = cv2.resize(img_1, (0, 0),
-                                   fx=1 / subsample, fy=1 / subsample,
-                                   interpolation=cv2.INTER_AREA)
-    else:
-        img_0_sub, img_1_sub = img_0, img_1
-    kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub,
-                                                  feature_config, matching_config)
-    n_good_matches = len(good_matches)
+            img_0_sub, img_1_sub = img_0, img_1
+        kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub,
+                                                      feature_config, matching_config)
+        n_good_matches = len(good_matches)
+        if n_good_matches > min_good_matches or subsample == 1:
+            break
+        subsample = 1
+        if callbacks and 'warning' in callbacks:
+            callbacks['warning'](
+                f"only {n_good_matches} < {min_good_matches} matches found, "
+                "retrying without subsampling")
     if callbacks and 'matches_message' in callbacks:
         callbacks['matches_message'](n_good_matches)
     img_warp = None
@@ -277,14 +289,19 @@ class AlignFrames(SubAction):
         img_ref = self.process.img_ref(ref_idx)
         return self.align_images(idx, img_ref, img_0)
 
+    def sub_msg(self, msg, color=constants.LOG_COLOR_LEVEL_3):
+        self.process.sub_message_r(color_str(msg, color))
+
     def align_images(self, idx, img_1, img_0):
         idx_str = f"{idx:04d}"
         callbacks = {
-            'message': lambda: self.process.sub_message_r(': find matches'),
-            'matches_message': lambda n: self.process.sub_message_r(f": matches: {n}"),
-            'align_message': lambda: self.process.sub_message_r(': align images'),
-            'ecc_message': lambda: self.process.sub_message_r(": ecc refinement"),
-            'blur_message': lambda: self.process.sub_message_r(': blur borders'),
+            'message': lambda: self.sub_msg(': find matches'),
+            'matches_message': lambda n: self.sub_msg(f": good matches: {n}"),
+            'align_message': lambda: self.sub_msg(': align images'),
+            'ecc_message': lambda: self.sub_msg(": ecc refinement"),
+            'blur_message': lambda: self.sub_msg(': blur borders'),
+            'warning': lambda msg: self.sub_msg(
+                f': {msg}', constants.LOG_COLOR_ALERT),
             'save_plot': lambda plot_path: self.process.callback(
                 'save_plot', self.process.id,
                 f"{self.process.name}: matches\nframe {idx_str}", plot_path)

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/balance.py

@@ -6,6 +6,7 @@ from scipy.optimize import bisect
 from scipy.interpolate import interp1d
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
+from .. core.colors import color_str
 from .utils import read_img, save_plot
 from .stack_framework import SubAction
 
@@ -408,6 +409,6 @@ class BalanceFrames(SubAction):
 
     def run_frame(self, idx, _ref_idx, image):
         if idx != self.process.ref_idx:
-            self.process.sub_message_r(': balance image')
+            self.process.sub_message_r(color_str(': balance image', constants.LOG_COLOR_LEVEL_3))
             image = self.correction.apply_correction(idx, image)
         return image

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/base_stack_algo.py

@@ -2,6 +2,7 @@
 import numpy as np
 from .. core.exceptions import InvalidOptionError, ImageLoadError
 from .. config.constants import constants
+from .. core.colors import color_str
 from .utils import read_img, get_img_metadata, validate_image
 
 
@@ -27,7 +28,7 @@ class BaseStackAlgo:
         return self._steps_per_frame
 
     def print_message(self, msg):
-        self.process.sub_message_r(msg)
+        self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
 
     def read_image_and_update_metadata(self, img_path, metadata):
         img = read_img(img_path)

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/multilayer.py

@@ -176,7 +176,9 @@ class MultiLayer(JobBase, FrameMultiDirectory):
         else:
             raise RuntimeError("input_path option must contain a path or an array of paths")
         if len(paths) == 0:
-            self.print_message(color_str("no input paths specified", "red"), level=logging.WARNING)
+            self.print_message(color_str("no input paths specified",
+                                         constants.LOG_COLOR_LEVEL_ALERT),
+                               level=logging.WARNING)
             return
         files = self.folder_filelist()
         if len(files) == 0:
@@ -184,22 +186,23 @@ class MultiLayer(JobBase, FrameMultiDirectory):
                 color_str(f"no input in {len(paths)} specified path" +
                           ('s' if len(paths) > 1 else '') + ": "
                           ", ".join([f"'{p}'" for p in paths]),
-                          "red"),
+                          constants.LOG_COLOR_LEVEL_ALERT),
                 level=logging.WARNING)
             return
-        self.print_message(color_str("merging frames in " + self.folder_list_str(), "blue"))
+        self.print_message(color_str("merging frames in " + self.folder_list_str(),
+                           constants.LOG_COLOR_LEVEL_2))
         input_files = [f"{self.working_path}/{f}" for f in files]
         self.print_message(
-            color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]), "blue"))
-        self.print_message(
-            color_str("reading files", "blue"))
+            color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]),
+                      constants.LOG_COLOR_LEVEL_2))
+        self.print_message(color_str("reading files", constants.LOG_COLOR_LEVEL_2))
         filename = ".".join(files[0].split("/")[-1].split(".")[:-1])
         output_file = f"{self.working_path}/{self.output_path}/{filename}.tif"
         callbacks = {
             'exif_msg': lambda path: self.print_message(
-                color_str(f"copying exif data from path: {path}", "blue")),
+                color_str(f"copying exif data from path: {path}", constants.LOG_COLOR_LEVEL_2)),
             'write_msg': lambda path: self.print_message(
-                color_str(f"writing multilayer tiff file: {path}", "blue"))
+                color_str(f"writing multilayer tiff file: {path}", constants.LOG_COLOR_LEVEL_2))
         }
         write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
                               callbacks=callbacks)

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/noise_detection.py

@@ -73,7 +73,8 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
 
     def run_core(self):
         self.print_message(color_str(
-            f"map noisy pixels from frames in {self.folder_list_str()}", "blue"
+            f"map noisy pixels from frames in {self.folder_list_str()}",
+            constants.LOG_COLOR_LEVEL_2
         ))
         files = self.folder_filelist()
         in_paths = [self.working_path + "/" + f for f in files]
@@ -89,7 +90,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
         mean_img = mean_image(
             file_paths=in_paths, max_frames=self.max_frames,
             message_callback=lambda path: self.print_message_r(
-                color_str(f"reading frame: {path.split('/')[-1]}", "blue")
+                color_str(f"reading frame: {path.split('/')[-1]}", constants.LOG_COLOR_LEVEL_2)
             ),
             progress_callback=progress_callback)
         if not config.DISABLE_TQDM:
@@ -103,13 +104,16 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
         hot_rgb = cv2.bitwise_or(hot_px[0], cv2.bitwise_or(hot_px[1], hot_px[2]))
         msg = []
         for ch, hot in zip(['rgb', *constants.RGB_LABELS], [hot_rgb] + hot_px):
-            msg.append(f"{ch}: {np.count_nonzero(hot > 0)}")
-        self.print_message("hot pixels: " + ", ".join(msg))
+            hpx = color_str(f"{ch}: {np.count_nonzero(hot > 0)}",
+                            {'rgb': 'black', 'r': 'red', 'g': 'green', 'b': 'blue'}[ch])
+            msg.append(hpx)
+        self.print_message(color_str("hot pixels: " + ", ".join(msg), constants.LOG_COLOR_LEVEL_2))
         path = "/".join(self.file_name.split("/")[:-1])
         if not os.path.exists(f"{self.working_path}/{path}"):
             self.print_message(f"create directory: {path}")
             os.mkdir(f"{self.working_path}/{path}")
-        self.print_message(f"writing hot pixels map file: {self.file_name}")
+        self.print_message(color_str(f"writing hot pixels map file: {self.file_name}",
+                                     constants.LOG_COLOR_LEVEL_2))
         cv2.imwrite(f"{self.working_path}/{self.file_name}", hot_rgb)
         plot_range = self.plot_range
         min_th, max_th = min(self.channel_thresholds), max(self.channel_thresholds)
@@ -155,7 +159,9 @@ class MaskNoise(SubAction):
         self.process = process
         path = f"{process.working_path}/{self.noise_mask}"
         if os.path.exists(path):
-            self.process.sub_message_r(f': reading noisy pixel mask file: {self.noise_mask}')
+            self.process.sub_message_r(color_str(
+                f': reading noisy pixel mask file: {self.noise_mask}',
+                constants.LOG_COLOR_LEVEL_3))
             self.noise_mask_img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
             if self.noise_mask_img is None:
                 raise ImageLoadError(path, f"failed to load image file {self.noise_mask}.")
@@ -163,7 +169,7 @@ class MaskNoise(SubAction):
             raise ImageLoadError(path, "file not found.")
 
     def run_frame(self, _idx, _ref_idx, image):
-        self.process.sub_message_r(': mask noisy pixels')
+        self.process.sub_message_r(color_str(': mask noisy pixels', constants.LOG_COLOR_LEVEL_3))
         if len(image.shape) == 3:
             corrected = image.copy()
             for c in range(3):

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/stack.py

@@ -3,6 +3,7 @@ import os
 import numpy as np
 from .. config.constants import constants
 from .. core.framework import JobBase
+from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
 from .utils import write_img
 from .stack_framework import FrameDirectory, ActionList
@@ -23,7 +24,7 @@ class FocusStackBase(JobBase, FrameDirectory):
         self.frame_count = -1
 
     def focus_stack(self, filenames):
-        self.sub_message_r(': reading input files')
+        self.sub_message_r(color_str(': reading input files', constants.LOG_COLOR_LEVEL_3))
         img_files = sorted([os.path.join(self.input_full_path, name) for name in filenames])
         stacked_img = self.stack_algo.focus_stack(img_files)
         in_filename = filenames[0].split(".")
@@ -42,7 +43,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             copy_exif_from_file_to_file(exif_filename, out_filename)
             self.sub_message_r(' ' * 60)
         if self.plot_stack:
-            idx_str = f"{self.frame_count:04d}" if self.frame_count >= 0 else ''
+            idx_str = f"{self.frame_count + 1:04d}" if self.frame_count >= 0 else ''
             name = f"{self.name}: {self.stack_algo.name()}"
             if idx_str != '':
                 name += f"\nbunch: {idx_str}"
@@ -91,9 +92,9 @@ class FocusStackBunch(ActionList, FocusStackBase):
         ActionList.end(self)
 
     def run_step(self):
-        self.print_message_r(f"fusing bunch: {self.count}")
+        self.print_message_r(color_str(f"fusing bunch: {self.count + 1}/{self.counts}",
+                                       constants.LOG_COLOR_LEVEL_2))
         self.focus_stack(self._chunks[self.count - 1])
-        self.callback('after_step', self.id, self.name, self.count)
 
 
 class FocusStack(FocusStackBase):

{shinestacker-0.3.6 → shinestacker-0.5.0}/src/shinestacker/algorithms/stack_framework.py

@@ -52,8 +52,7 @@ class FramePaths:
         self.filenames = self.folder_filelist()
         file_list = self.input_full_path.replace(self.working_path, '').lstrip('/')
         self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_list}",
-                                     'blue'))
-        self.print_message(color_str("focus stacking", 'blue'))
+                                     constants.LOG_COLOR_LEVEL_2))
 
     def init(self, job):
         if self.working_path == '':
@@ -213,14 +212,14 @@ class FramesRefActions(ActionList, FrameDirectory):
         pass
 
     def run_step(self):
-        if self.count == 1:
+        if self.count == 0:
             self._idx = self.ref_idx if self.step_process else 0
             self._ref_idx = self.ref_idx
             self._idx_step = +1
         ll = len(self.filenames)
         self.print_message_r(
-            color_str(f"step {self.count}/{ll}: process file: {self.filenames[self._idx]}, "
-                      f"reference: {self.filenames[self._ref_idx]}", "blue"))
+            color_str(f"step {self.count + 1}/{ll}: process file: {self.filenames[self._idx]}, "
+                      f"reference: {self.filenames[self._ref_idx]}", constants.LOG_COLOR_LEVEL_2))
         self.run_frame(self._idx, self._ref_idx)
         if self._idx < ll:
             if self.step_process:
@@ -269,7 +268,7 @@ class CombinedActions(FramesRefActions):
 
     def run_frame(self, idx, ref_idx):
         filename = self.filenames[idx]
-        self.sub_message_r(': read input image')
+        self.sub_message_r(color_str(': read input image', constants.LOG_COLOR_LEVEL_3))
         img = read_img(f"{self.input_full_path}/{filename}")
         if self.dtype is not None and img.dtype != self.dtype:
             raise BitDepthError(self.dtype, img.dtype, )
@@ -278,7 +277,8 @@ class CombinedActions(FramesRefActions):
         if img is None:
             raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
         if len(self._actions) == 0:
-            self.sub_message(color_str(": no actions specified.", "red"), level=logging.WARNING)
+            self.sub_message(color_str(": no actions specified.", constants.LOG_COLOR_ALERT),
+                             level=logging.WARNING)
         for a in self._actions:
             if not a.enabled:
                 self.get_logger().warning(color_str(f"{self.base_message}: sub-action disabled",
@@ -287,12 +287,14 @@ class CombinedActions(FramesRefActions):
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
                 img = a.run_frame(idx, ref_idx, img)
-        self.sub_message_r(': write output image')
+        self.sub_message_r(color_str(': write output image', constants.LOG_COLOR_LEVEL_3))
         if img is not None:
             write_img(self.output_dir + "/" + filename, img)
         else:
-            self.print_message("No output file resulted from processing input file: "
-                               f"{self.input_full_path}/{filename}", level=logging.WARNING)
+            self.print_message(color_str(
+                "No output file resulted from processing input file: "
+                f"{self.input_full_path}/{filename}",
+                constants.LOG_COLOR_ALERT), level=logging.WARNING)
 
     def end(self):
         for a in self._actions: