Removed layers from db

src/airunner/data/managers.py

@@ -1,10 +1,9 @@
 from contextlib import contextmanager
-from typing import Any, Iterator
+from typing import Iterator
 from sqlalchemy.orm import joinedload
 from PyQt6.QtCore import QObject, pyqtSignal
 from airunner.utils import Logger
 
-
 from airunner.data.session_scope import (
     models_scope,
     session_scope,
@@ -125,13 +124,6 @@ def loras(self, search_filter=None):
                 loras = session.query(Lora).options(joinedload('*')).all()
             yield loras            
 
-    @contextmanager
-    def layers(self):
-        from airunner.data.models import Layer
-        with session_scope() as session:
-            layers = session.query(Layer).options(joinedload('*')).all()
-            yield layers
-
     @contextmanager
     def document(self):
         from airunner.data.models import Document

src/airunner/data/models.py

@@ -204,40 +204,3 @@ class ImageFilterValue(BaseModel):
     min_value = Column(Integer, default=0)
     max_value = Column(Integer, default=100)
 
-
-class Layer(BaseModel):
-    __tablename__ = 'layers'
-
-    @property
-    def image(self):
-        # convert base64 image to pil image
-        if self.base_64_image:
-            decoded_image = base64.b64decode(self.base_64_image)
-            bytes_image = io.BytesIO(decoded_image)
-            # convert bytes to PIL iamge:
-            image = Image.open(bytes_image)
-            image = image.convert("RGBA")
-            return image
-        return None
-
-    @image.setter
-    def image(self, value):
-        # convert to base 64
-        if value:
-            buffered = io.BytesIO()
-            value.save(buffered, format="PNG")
-            self.base_64_image = base64.b64encode(buffered.getvalue())
-        else:
-            self.base_64_image = ""
-
-    name = Column(String)
-    visible = Column(Boolean, default=True)
-    opacity = Column(Integer, default=10000)
-    position = Column(Integer, default=0)
-    base_64_image = Column(String, default="")
-    pos_x = Column(Integer, default=0)
-    pos_y = Column(Integer, default=0)
-    pivot_point_x = Column(Integer, default=0)
-    pivot_point_y = Column(Integer, default=0)
-    root_point_x = Column(Integer, default=0)
-    root_point_y = Column(Integer, default=0)

src/airunner/widgets/canvas_plus/canvas_plus_widget.py

@@ -45,18 +45,20 @@ class CanvasPlusWidget(CanvasBaseWidget):
 
     @property
     def image_pivot_point(self):
-        with self.layer_container_widget.current_layer() as layer:
-            try:
-                return QPoint(layer.pivot_x, layer.pivot_y)
-            except Exception as e:
-                pass
-            return QPoint(0, 0)
+        try:
+            layer = self.app.current_layer()
+            return QPoint(layer["pivot_x"], layer["pivot_y"])
+        except Exception as e:
+            self.logger.error(e)
+        return QPoint(0, 0)
 
     @image_pivot_point.setter
     def image_pivot_point(self, value):
-        with self.layer_container_widget.current_layer() as layer:
-            layer.pivot_x = value.x()
-            layer.pivot_y = value.y()
+        layer = self.app.current_layer()
+        self.app.update_current_layer({
+            "pivot_x": value.x(),
+            "pivot_y": value.y()
+        })
 
     @property
     def brush_size(self):
@@ -79,21 +81,11 @@ def active_grid_area_rect(self):
 
     @property
     def current_active_image(self):
-        with self.layer_container_widget.current_layer() as layer:
-            return layer.image
+        return self.app.get_image_from_current_layer()
 
     @current_active_image.setter
     def current_active_image(self, value):
-        with self.layer_container_widget.current_layer() as layer:
-            layer.image = value
-
-    @property
-    def current_layer_index(self):
-        return self.layer_container_widget.current_layer_index
-
-    @current_layer_index.setter
-    def current_layer_index(self, value):
-        self.layer_container_widget.current_layer_index = value
+        self.app.add_image_to_current_layer(value)
 
     @property
     def layer_container_widget(self):
@@ -105,14 +97,12 @@ def canvas_container(self):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        #self.app.settings_manager.changed_signal.connect(self.handle_changed_signal)
         self.app.application_settings_changed_signal.connect(self.handle_changed_signal)
-        with session_scope() as session:
-            self.ui.central_widget.resizeEvent = self.resizeEvent
-            self.app.add_image_to_canvas_signal.connect(self.handle_add_image_to_canvas)
-            self.app.image_data.connect(self.handle_image_data)
-            self.app.load_image.connect(self.load_image_from_path)
-            self.app.load_image_object.connect(self.add_image_to_scene)
+        self.ui.central_widget.resizeEvent = self.resizeEvent
+        self.app.add_image_to_canvas_signal.connect(self.handle_add_image_to_canvas)
+        self.app.image_data.connect(self.handle_image_data)
+        self.app.load_image.connect(self.load_image_from_path)
+        self.app.load_image_object.connect(self.add_image_to_scene)
         self.app.loaded.connect(self.handle_loaded)
         self._zoom_level = 1
         self.canvas_container.resizeEvent = self.window_resized
@@ -331,46 +321,27 @@ def set_canvas_color(self):
         self.scene.setBackgroundBrush(QBrush(QColor(self.canvas_color)))
 
     def draw_layers(self):
-        with self.app.settings_manager.layers() as layers:
-            for layer in layers:
-                image = layer.image
-                if image is None:
-                    continue
-
-                image = apply_opacity_to_image(
-                    image,
-                    layer.opacity / 100.0
-                )
-
-                if layer.id in self.layers:
-                    if not layer.visible:
-                        if self.layers[layer.id] in self.scene.items():
-                            self.scene.removeItem(self.layers[layer.id])
-                    elif layer.visible:
-                        if not self.layers[layer.id] in self.scene.items():
-                            self.scene.addItem(self.layers[layer.id])
-                        self.layers[layer.id].pixmap.convertFromImage(ImageQt(image))
-                    continue
-
-                draggable_pixmap = None
-                if layer.id in self.layers:
-                    self.layers[layer.id].pixmap.convertFromImage(ImageQt(image))
-                    draggable_pixmap = self.layers[layer.id]
-                    self.scene.removeItem(draggable_pixmap)
-
-                if not draggable_pixmap:
-                    draggable_pixmap = DraggablePixmap(self, QPixmap.fromImage(ImageQt(image)))
-                    self.layers[layer.id] = draggable_pixmap
-
-                if layer.visible:
-                    self.scene.addItem(draggable_pixmap)
-
-                pos = QPoint(layer.pos_x, layer.pos_y)
-                canvas_settings = self.app.settings["canvas_settings"]
-                draggable_pixmap.setPos(QPointF(
-                    canvas_settings["pos_x"] + pos.x(),
-                    canvas_settings["pos_y"] + pos.y()
-                ))
+        layers = self.app.settings["layers"]
+        for layer in layers:
+            image = self.app.get_image_from_layer(layer)
+            if image is None:
+                continue
+
+            image = apply_opacity_to_image(
+                image,
+                layer["opacity"] / 100.0
+            )
+
+            if not layer["visible"]:
+                if layer["pixmap"] in self.scene.items():
+                    self.scene.removeItem(layer["pixmap"])
+            elif layer["visible"]:
+                if type(layer["pixmap"]) is not DraggablePixmap or layer["pixmap"] not in self.scene.items():
+                    layer["pixmap"].convertFromImage(ImageQt(image))
+                    layer["pixmap"] = DraggablePixmap(self, layer["pixmap"])
+                    self.app.update_layer(layer)
+                    self.scene.addItem(layer["pixmap"])
+            continue
 
     def set_scene_rect(self):
         self.scene.setSceneRect(0, 0, self.view_size.width(), self.view_size.height())
@@ -487,8 +458,8 @@ def handle_outpaint(self, outpaint_box_rect, outpainted_image, action=None):
 
         pivot_point = self.image_pivot_point
         root_point = QPoint(0, 0)
-        with self.layer_container_widget.current_layer() as layer:
-            current_image_position = QPoint(layer.pos_x, layer.pos_y)
+        layer = self.app.current_layer()
+        current_image_position = QPoint(layer["pos_x"], layer["pos_y"])
 
         is_drawing_left = outpaint_box_rect.x() < current_image_position.x()
         is_drawing_right = outpaint_box_rect.x() > current_image_position.x()
@@ -546,11 +517,8 @@ def load_image(self, image_path):
         self.add_image_to_scene(image)
 
     def current_draggable_pixmap(self):
-        with self.layer_container_widget.current_layer() as layer:
-            index = layer + 1
-            if index in self.layers:
-                return self.layers[index]
-
+        self.app.current_draggable_pixmap()
+
     def copy_image(self, image:Image=None) -> DraggablePixmap:
         pixmap = self.current_pixmap() if image is None else QPixmap.fromImage(ImageQt(image))
         return self.move_pixmap_to_clipboard(pixmap)
@@ -561,9 +529,7 @@ def cut_image(self):
         if not draggable_pixmap:
             return
         self.scene.removeItem(draggable_pixmap)
-        with self.layer_container_widget.current_layer() as layer:
-            if layer.id in self.layers:
-                del self.layers[layer.id]
+        self.app.delete_current_layer()
         self.update()
 
     def delete_image(self):
@@ -636,7 +602,7 @@ def add_layer(self):
         return self.app.ui.layer_widget.add_layer()
 
     def switch_to_layer(self, layer_index):
-        self.current_layer_index = layer_index
+        self.app.switch_layer(layer_index)
 
     def add_image_to_scene(self, image, is_outpaint=False, image_root_point=None):
         #self.image_adder = ImageAdder(self, image, is_outpaint, image_root_point)

src/airunner/widgets/canvas_plus/draggables.py

@@ -15,10 +15,9 @@ def __init__(self, parent, pixmap):
         self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
 
     def snap_to_grid(self):
-        cell_size = self.parent.cell_size
-        grid_size = cell_size
-        x = round(self.x() / grid_size) * grid_size
-        y = round(self.y() / grid_size) * grid_size
+        cell_size = self.parent.app.settings["grid_settings"]["cell_size"]
+        x = round(self.x() / cell_size) * cell_size
+        y = round(self.y() / cell_size) * cell_size
         x += self.parent.last_pos.x()
         y += self.parent.last_pos.y()
         self.setPos(x, y)