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

shinestacker/_version.py

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

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_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