shinestacker 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '0.2.2'
+__version__ = '0.3.1'

shinestacker/algorithms/denoise.py

@@ -0,0 +1,9 @@
+import cv2
+import numpy as np
+
+
+def denoise(image, h_luminance, template_window_size=7, search_window_size=21):
+    norm_type = cv2.NORM_L2 if image.dtype == np.uint8 else cv2.NORM_L1
+    if image.dtype == np.uint16:
+        h_luminance = h_luminance * 256
+    return cv2.fastNlMeansDenoising(image, [h_luminance], None, template_window_size, search_window_size, norm_type)

shinestacker/algorithms/sharpen.py

@@ -0,0 +1,22 @@
+import cv2
+import numpy as np
+
+
+def unsharp_mask(image, radius=1.0, amount=1.0, threshold=0.0):
+    if image.dtype == np.uint16:
+        threshold = threshold * 256
+    blurred = cv2.GaussianBlur(image, (0, 0), radius)
+    if threshold == 0:
+        sharpened = cv2.addWeighted(image, 1.0 + amount, blurred, -amount, 0)
+    else:
+        image_float = image.astype(np.float32)
+        blurred_float = blurred.astype(np.float32)
+        diff = image_float - blurred_float
+        mask = np.abs(diff) > threshold
+        sharpened_float = np.where(mask, image_float + amount * diff, image_float)
+        if np.issubdtype(image.dtype, np.integer):
+            min_val, max_val = np.iinfo(image.dtype).min, np.iinfo(image.dtype).max
+            sharpened = np.clip(sharpened_float, min_val, max_val).astype(image.dtype)
+        else:
+            sharpened = sharpened_float.astype(image.dtype)
+    return sharpened

shinestacker/algorithms/stack.py

@@ -1,5 +1,4 @@
 import numpy as np
-import cv2
 import os
 from .. config.constants import constants
 from .. core.colors import color_str
@@ -8,6 +7,7 @@ from .. core.exceptions import InvalidOptionError
 from .utils import write_img
 from .stack_framework import FrameDirectory, ActionList
 from .exif import copy_exif_from_file_to_file
+from .denoise import denoise
 
 
 class FocusStackBase:
@@ -30,7 +30,7 @@ class FocusStackBase:
         out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + '.'.join(in_filename[1:])
         if self.denoise > 0:
             self.sub_message_r(': denoise image')
-            stacked_img = cv2.fastNlMeansDenoisingColored(stacked_img, None, self.denoise, self.denoise, 7, 21)
+            stacked_img = denoise(stacked_img, self.denoise, self.denoise)
         write_img(out_filename, stacked_img)
         if self.exif_path != '' and stacked_img.dtype == np.uint8:
             self.sub_message_r(': copy exif data')

shinestacker/algorithms/utils.py

@@ -47,10 +47,14 @@ def img_bw(img):
 
 
 def get_img_metadata(img):
+    if img is None:
+        return None, None
     return img.shape[:2], img.dtype
 
 
 def validate_image(img, expected_shape=None, expected_dtype=None):
+    if img is None:
+        raise RuntimeError("Image is None")
     shape, dtype = get_img_metadata(img)
     if expected_shape and shape[:2] != expected_shape[:2]:
         raise ShapeError(expected_shape, shape)

shinestacker/algorithms/white_balance.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def white_balance_from_rgb(img, target_rgb):
+    img_float = img.astype(np.float64)
+    target_bgr = (target_rgb[2], target_rgb[1], target_rgb[0])
+    target_gray = sum(target_bgr) / 3.0
+    scales = [target_gray / val if val != 0 else 1.0 for val in target_bgr]
+    for c in range(3):
+        img_float[..., c] *= scales[c]
+    max_val = np.iinfo(img.dtype).max
+    img_float = np.clip(img_float, 0, max_val)
+    return img_float.astype(img.dtype)

shinestacker/gui/new_project.py

@@ -85,6 +85,7 @@ class NewProjectDialog(QDialog):
         bunch_overlap_range = gui_constants.NEW_PROJECT_BUNCH_OVERLAP
         self.bunch_overlap.setRange(bunch_overlap_range['min'], bunch_overlap_range['max'])
         self.bunch_overlap.setValue(constants.DEFAULT_OVERLAP)
+        self.update_bunch_options(gui_constants.NEW_PROJECT_BUNCH_STACK)
         self.focus_stack_pyramid = QCheckBox()
         self.focus_stack_pyramid.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_PYRAMID)
         self.focus_stack_depth_map = QCheckBox()

shinestacker/retouch/brush_controller.py

@@ -22,7 +22,7 @@ class BrushController:
         y_start, y_end = max(0, y_center - radius), min(h, y_center + radius + 1)
         if x_start >= x_end or y_start >= y_end:
             return 0, 0, 0, 0
-        mask = self._get_brush_mask(radius)
+        mask = self.get_brush_mask(radius)
         if mask is None:
             return 0, 0, 0, 0
         master_area = master_layer[y_start:y_end, x_start:x_end]
@@ -31,10 +31,10 @@ class BrushController:
         mask_layer_area = mask_layer[y_start:y_end, x_start:x_end]
         mask_area = mask[y_start - (y_center - radius):y_end - (y_center - radius), x_start - (x_center - radius):x_end - (x_center - radius)]
         mask_layer_area[:] = np.clip(mask_layer_area + mask_area * self.brush.flow / 100.0, 0.0, 1.0)  # np.maximum(mask_layer_area, mask_area)
-        self._apply_mask(master_area, source_area, mask_layer_area, dest_area)
+        self.apply_mask(master_area, source_area, mask_layer_area, dest_area)
         return x_start, y_start, x_end, y_end
 
-    def _get_brush_mask(self, radius):
+    def get_brush_mask(self, radius):
         mask_key = (radius, self.brush.hardness)
         if mask_key not in self._brush_mask_cache.keys():
             full_mask = create_brush_mask(size=radius * 2 + 1, hardness_percent=self.brush.hardness,
@@ -42,7 +42,7 @@ class BrushController:
             self._brush_mask_cache[mask_key] = full_mask
         return self._brush_mask_cache[mask_key]
 
-    def _apply_mask(self, master_area, source_area, mask_area, dest_area):
+    def apply_mask(self, master_area, source_area, mask_area, dest_area):
         opacity_factor = float(self.brush.opacity) / 100.0
         effective_mask = np.clip(mask_area * opacity_factor, 0, 1)
         dtype = master_area.dtype

shinestacker/retouch/brush_gradient.py

@@ -0,0 +1,20 @@
+from PySide6.QtGui import QRadialGradient
+from PySide6.QtGui import QColor
+from .. config.gui_constants import gui_constants
+
+
+def create_brush_gradient(center_x, center_y, radius, hardness, inner_color=None, outer_color=None, opacity=100):
+    gradient = QRadialGradient(center_x, center_y, float(radius))
+    inner = inner_color if inner_color is not None else QColor(*gui_constants.BRUSH_COLORS['inner'])
+    outer = outer_color if outer_color is not None else QColor(*gui_constants.BRUSH_COLORS['gradient_end'])
+    inner_with_opacity = QColor(inner)
+    inner_with_opacity.setAlpha(int(float(inner.alpha()) * float(opacity) / 100.0))
+    if hardness < 100:
+        hardness_normalized = float(hardness) / 100.0
+        gradient.setColorAt(0.0, inner_with_opacity)
+        gradient.setColorAt(hardness_normalized, inner_with_opacity)
+        gradient.setColorAt(1.0, outer)
+    else:
+        gradient.setColorAt(0.0, inner_with_opacity)
+        gradient.setColorAt(1.0, inner_with_opacity)
+    return gradient

shinestacker/retouch/brush_preview.py

@@ -1,6 +1,6 @@
 import numpy as np
 from PySide6.QtWidgets import QGraphicsPixmapItem
-from PySide6.QtCore import Qt, QPointF
+from PySide6.QtCore import Qt
 from PySide6.QtGui import QPixmap, QPainter, QImage
 
 
@@ -42,6 +42,8 @@ def create_brush_mask(size, hardness_percent, opacity_percent):
 class BrushPreviewItem(QGraphicsPixmapItem):
     def __init__(self):
         super().__init__()
+        self.layer_collection = None
+        self.brush = None
         self.setVisible(False)
         self.setZValue(500)
         self.setTransformationMode(Qt.SmoothTransformation)
@@ -68,31 +70,26 @@ class BrushPreviewItem(QGraphicsPixmapItem):
         else:
             raise Exception("Bitmas is neither 8 bit nor 16, but of type " + area.dtype)
 
-    def update(self, editor, pos, size):
+    def update(self, scene_pos, size):
         try:
-            if editor.current_stack is None or not hasattr(editor, 'image_viewer') or size <= 0:
+            if self.layer_collection.layer_stack is None or size <= 0:
                 self.hide()
                 return
             radius = size // 2
-            if isinstance(pos, QPointF):
-                scene_pos = pos
-            else:
-                cursor_pos = editor.image_viewer.mapFromGlobal(pos)
-                scene_pos = editor.image_viewer.mapToScene(cursor_pos)
             x = int(scene_pos.x() - radius + 0.5)
             y = int(scene_pos.y() - radius)
             w = h = size
-            if editor.current_layer < 0 or editor.current_layer >= len(editor.current_stack):
+            if not self.layer_collection.valid_current_layer_idx():
                 self.hide()
                 return
-            layer_area = self.get_layer_area(editor.current_stack[editor.current_layer], x, y, w, h)
-            master_area = self.get_layer_area(editor.master_layer, x, y, w, h)
+            layer_area = self.get_layer_area(self.layer_collection.current_layer(), x, y, w, h)
+            master_area = self.get_layer_area(self.layer_collection.master_layer, x, y, w, h)
             if layer_area is None or master_area is None:
                 self.hide()
                 return
-            height, width = editor.current_stack[editor.current_layer].shape[:2]
-            full_mask = create_brush_mask(size=size, hardness_percent=editor.brush.hardness,
-                                          opacity_percent=editor.brush.opacity)[:, :, np.newaxis]
+            height, width = self.layer_collection.current_layer().shape[:2]
+            full_mask = create_brush_mask(size=size, hardness_percent=self.brush.hardness,
+                                          opacity_percent=self.brush.opacity)[:, :, np.newaxis]
             mask_x_start = max(0, -x) if x < 0 else 0
             mask_y_start = max(0, -y) if y < 0 else 0
             mask_x_end = size - (max(0, (x + w) - width)) if (x + w) > width else size