lazylabel-gui 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

lazylabel/core/segment_manager.py

@@ -1,183 +1,188 @@
-"""Segment management functionality."""
-
-from typing import Any
-
-import cv2
-import numpy as np
-from PyQt6.QtCore import QPointF
-
-
-class SegmentManager:
-    """Manages image segments and classes."""
-
-    def __init__(self):
-        self.segments: list[dict[str, Any]] = []
-        self.class_aliases: dict[int, str] = {}
-        self.next_class_id: int = 0
-        self.active_class_id: int | None = None  # Currently active/toggled class
-
-    def clear(self) -> None:
-        """Clear all segments and reset state."""
-        self.segments.clear()
-        self.class_aliases.clear()
-        self.next_class_id = 0
-        self.active_class_id = None
-
-    def add_segment(self, segment_data: dict[str, Any]) -> None:
-        """Add a new segment.
-
-        If the segment is a polygon, convert QPointF objects to simple lists
-        for serialization compatibility.
-        """
-        if "class_id" not in segment_data:
-            # Use active class if available, otherwise use next class ID
-            if self.active_class_id is not None:
-                segment_data["class_id"] = self.active_class_id
-            else:
-                segment_data["class_id"] = self.next_class_id
-
-        # Convert QPointF to list for storage if it's a polygon
-        if segment_data.get("type") == "Polygon" and segment_data.get("vertices"):
-            segment_data["vertices"] = [
-                [p.x(), p.y()] for p in segment_data["vertices"]
-            ]
-
-        self.segments.append(segment_data)
-        self._update_next_class_id()
-
-    def delete_segments(self, indices: list[int]) -> None:
-        """Delete segments by indices."""
-        for i in sorted(indices, reverse=True):
-            if 0 <= i < len(self.segments):
-                del self.segments[i]
-        self._update_next_class_id()
-
-    def assign_segments_to_class(self, indices: list[int]) -> None:
-        """Assign selected segments to a class."""
-        if not indices:
-            return
-
-        existing_class_ids = [
-            self.segments[i]["class_id"]
-            for i in indices
-            if i < len(self.segments) and self.segments[i].get("class_id") is not None
-        ]
-
-        if existing_class_ids:
-            target_class_id = min(existing_class_ids)
-        else:
-            target_class_id = self.next_class_id
-
-        for i in indices:
-            if i < len(self.segments):
-                self.segments[i]["class_id"] = target_class_id
-
-        self._update_next_class_id()
-
-    def get_unique_class_ids(self) -> list[int]:
-        """Get sorted list of unique class IDs."""
-        return sorted(
-            {
-                seg.get("class_id")
-                for seg in self.segments
-                if seg.get("class_id") is not None
-            }
-        )
-
-    def rasterize_polygon(
-        self, vertices: list[QPointF], image_size: tuple[int, int]
-    ) -> np.ndarray | None:
-        """Convert polygon vertices to binary mask."""
-        if not vertices:
-            return None
-
-        h, w = image_size
-        points_np = np.array([[p.x(), p.y()] for p in vertices], dtype=np.int32)
-        mask = np.zeros((h, w), dtype=np.uint8)
-        cv2.fillPoly(mask, [points_np], 1)
-        return mask.astype(bool)
-
-    def create_final_mask_tensor(
-        self, image_size: tuple[int, int], class_order: list[int]
-    ) -> np.ndarray:
-        """Create final mask tensor for saving."""
-        h, w = image_size
-        id_map = {old_id: new_id for new_id, old_id in enumerate(class_order)}
-        num_final_classes = len(class_order)
-        final_mask_tensor = np.zeros((h, w, num_final_classes), dtype=np.uint8)
-
-        for seg in self.segments:
-            class_id = seg.get("class_id")
-            if class_id not in id_map:
-                continue
-
-            new_channel_idx = id_map[class_id]
-
-            if seg["type"] == "Polygon":
-                # Convert stored list of lists back to QPointF objects for rasterization
-                qpoints = [QPointF(p[0], p[1]) for p in seg["vertices"]]
-                mask = self.rasterize_polygon(qpoints, image_size)
-            else:
-                mask = seg.get("mask")
-
-            if mask is not None:
-                final_mask_tensor[:, :, new_channel_idx] = np.logical_or(
-                    final_mask_tensor[:, :, new_channel_idx], mask
-                )
-
-        return final_mask_tensor
-
-    def reassign_class_ids(self, new_order: list[int]) -> None:
-        """Reassign class IDs based on new order."""
-        id_map = {old_id: new_id for new_id, old_id in enumerate(new_order)}
-
-        for seg in self.segments:
-            old_id = seg.get("class_id")
-            if old_id in id_map:
-                seg["class_id"] = id_map[old_id]
-
-        # Update aliases
-        new_aliases = {
-            id_map[old_id]: self.class_aliases.get(old_id, str(old_id))
-            for old_id in new_order
-            if old_id in self.class_aliases
-        }
-        self.class_aliases = new_aliases
-        self._update_next_class_id()
-
-    def set_class_alias(self, class_id: int, alias: str) -> None:
-        """Set alias for a class."""
-        self.class_aliases[class_id] = alias
-
-    def get_class_alias(self, class_id: int) -> str:
-        """Get alias for a class."""
-        return self.class_aliases.get(class_id, str(class_id))
-
-    def set_active_class(self, class_id: int | None) -> None:
-        """Set the active class ID."""
-        self.active_class_id = class_id
-
-    def get_active_class(self) -> int | None:
-        """Get the active class ID."""
-        return self.active_class_id
-
-    def toggle_active_class(self, class_id: int) -> bool:
-        """Toggle a class as active. Returns True if now active, False if deactivated."""
-        if self.active_class_id == class_id:
-            self.active_class_id = None
-            return False
-        else:
-            self.active_class_id = class_id
-            return True
-
-    def _update_next_class_id(self) -> None:
-        """Update the next available class ID."""
-        all_ids = {
-            seg.get("class_id")
-            for seg in self.segments
-            if seg.get("class_id") is not None
-        }
-        if not all_ids:
-            self.next_class_id = 0
-        else:
-            self.next_class_id = max(all_ids) + 1
+"""Segment management functionality."""
+
+from typing import Any
+
+import cv2
+import numpy as np
+from PyQt6.QtCore import QPointF
+
+
+class SegmentManager:
+    """Manages image segments and classes."""
+
+    def __init__(self):
+        self.segments: list[dict[str, Any]] = []
+        self.class_aliases: dict[int, str] = {}
+        self.next_class_id: int = 0
+        self.active_class_id: int | None = None  # Currently active/toggled class
+
+    def clear(self) -> None:
+        """Clear all segments and reset state."""
+        self.segments.clear()
+        self.class_aliases.clear()
+        self.next_class_id = 0
+        self.active_class_id = None
+
+    def add_segment(self, segment_data: dict[str, Any]) -> None:
+        """Add a new segment.
+
+        If the segment is a polygon, convert QPointF objects to simple lists
+        for serialization compatibility.
+        """
+        if "class_id" not in segment_data:
+            # Use active class if available, otherwise use next class ID
+            if self.active_class_id is not None:
+                segment_data["class_id"] = self.active_class_id
+            else:
+                segment_data["class_id"] = self.next_class_id
+
+        # Convert QPointF to list for storage if it's a polygon and contains QPointF objects
+        if (
+            segment_data.get("type") == "Polygon"
+            and segment_data.get("vertices")
+            and segment_data["vertices"]
+            and isinstance(segment_data["vertices"][0], QPointF)
+        ):
+            segment_data["vertices"] = [
+                [p.x(), p.y()] for p in segment_data["vertices"]
+            ]
+
+        self.segments.append(segment_data)
+        self._update_next_class_id()
+
+    def delete_segments(self, indices: list[int]) -> None:
+        """Delete segments by indices."""
+        for i in sorted(indices, reverse=True):
+            if 0 <= i < len(self.segments):
+                del self.segments[i]
+        self._update_next_class_id()
+
+    def assign_segments_to_class(self, indices: list[int]) -> None:
+        """Assign selected segments to a class."""
+        if not indices:
+            return
+
+        existing_class_ids = [
+            self.segments[i]["class_id"]
+            for i in indices
+            if i < len(self.segments) and self.segments[i].get("class_id") is not None
+        ]
+
+        if existing_class_ids:
+            target_class_id = min(existing_class_ids)
+        else:
+            target_class_id = self.next_class_id
+
+        for i in indices:
+            if i < len(self.segments):
+                self.segments[i]["class_id"] = target_class_id
+
+        self._update_next_class_id()
+
+    def get_unique_class_ids(self) -> list[int]:
+        """Get sorted list of unique class IDs."""
+        return sorted(
+            {
+                seg.get("class_id")
+                for seg in self.segments
+                if seg.get("class_id") is not None
+            }
+        )
+
+    def rasterize_polygon(
+        self, vertices: list[QPointF], image_size: tuple[int, int]
+    ) -> np.ndarray | None:
+        """Convert polygon vertices to binary mask."""
+        if not vertices:
+            return None
+
+        h, w = image_size
+        points_np = np.array([[p.x(), p.y()] for p in vertices], dtype=np.int32)
+        mask = np.zeros((h, w), dtype=np.uint8)
+        cv2.fillPoly(mask, [points_np], 1)
+        return mask.astype(bool)
+
+    def create_final_mask_tensor(
+        self, image_size: tuple[int, int], class_order: list[int]
+    ) -> np.ndarray:
+        """Create final mask tensor for saving."""
+        h, w = image_size
+        id_map = {old_id: new_id for new_id, old_id in enumerate(class_order)}
+        num_final_classes = len(class_order)
+        final_mask_tensor = np.zeros((h, w, num_final_classes), dtype=np.uint8)
+
+        for seg in self.segments:
+            class_id = seg.get("class_id")
+            if class_id not in id_map:
+                continue
+
+            new_channel_idx = id_map[class_id]
+
+            if seg["type"] == "Polygon":
+                # Convert stored list of lists back to QPointF objects for rasterization
+                qpoints = [QPointF(p[0], p[1]) for p in seg["vertices"]]
+                mask = self.rasterize_polygon(qpoints, image_size)
+            else:
+                mask = seg.get("mask")
+
+            if mask is not None:
+                final_mask_tensor[:, :, new_channel_idx] = np.logical_or(
+                    final_mask_tensor[:, :, new_channel_idx], mask
+                )
+
+        return final_mask_tensor
+
+    def reassign_class_ids(self, new_order: list[int]) -> None:
+        """Reassign class IDs based on new order."""
+        id_map = {old_id: new_id for new_id, old_id in enumerate(new_order)}
+
+        for seg in self.segments:
+            old_id = seg.get("class_id")
+            if old_id in id_map:
+                seg["class_id"] = id_map[old_id]
+
+        # Update aliases
+        new_aliases = {
+            id_map[old_id]: self.class_aliases.get(old_id, str(old_id))
+            for old_id in new_order
+            if old_id in self.class_aliases
+        }
+        self.class_aliases = new_aliases
+        self._update_next_class_id()
+
+    def set_class_alias(self, class_id: int, alias: str) -> None:
+        """Set alias for a class."""
+        self.class_aliases[class_id] = alias
+
+    def get_class_alias(self, class_id: int) -> str:
+        """Get alias for a class."""
+        return self.class_aliases.get(class_id, str(class_id))
+
+    def set_active_class(self, class_id: int | None) -> None:
+        """Set the active class ID."""
+        self.active_class_id = class_id
+
+    def get_active_class(self) -> int | None:
+        """Get the active class ID."""
+        return self.active_class_id
+
+    def toggle_active_class(self, class_id: int) -> bool:
+        """Toggle a class as active. Returns True if now active, False if deactivated."""
+        if self.active_class_id == class_id:
+            self.active_class_id = None
+            return False
+        else:
+            self.active_class_id = class_id
+            return True
+
+    def _update_next_class_id(self) -> None:
+        """Update the next available class ID."""
+        all_ids = {
+            seg.get("class_id")
+            for seg in self.segments
+            if seg.get("class_id") is not None
+        }
+        if not all_ids:
+            self.next_class_id = 0
+        else:
+            self.next_class_id = max(all_ids) + 1

lazylabel/ui/editable_vertex.py

@@ -55,8 +55,8 @@ class EditableVertexItem(QGraphicsEllipseItem):
                     "type": "move_vertex",
                     "segment_index": self.segment_index,
                     "vertex_index": self.vertex_index,
-                    "old_pos": self.initial_pos,
-                    "new_pos": self.pos(),
+                    "old_pos": [self.initial_pos.x(), self.initial_pos.y()],
+                    "new_pos": [self.pos().x(), self.pos().y()],
                 }
             )
         self.initial_pos = None

lazylabel/ui/main_window.py

@@ -912,7 +912,7 @@ class MainWindow(QMainWindow):
             return
 
         new_segment = {
-            "vertices": list(self.polygon_points),
+            "vertices": [[p.x(), p.y()] for p in self.polygon_points],
             "type": "Polygon",
             "mask": None,
         }
@@ -1070,7 +1070,9 @@ class MainWindow(QMainWindow):
         elif action_type == "move_polygon":
             initial_vertices = last_action.get("initial_vertices")
             for i, vertices in initial_vertices.items():
-                self.segment_manager.segments[i]["vertices"] = vertices
+                self.segment_manager.segments[i]["vertices"] = [
+                    [p[0], p[1]] for p in vertices
+                ]
                 self._update_polygon_item(i)
             self._display_edit_handles()
             self._highlight_selected_segments()
@@ -1079,13 +1081,27 @@ class MainWindow(QMainWindow):
             segment_index = last_action.get("segment_index")
             vertex_index = last_action.get("vertex_index")
             old_pos = last_action.get("old_pos")
-            self.segment_manager.segments[segment_index]["vertices"][vertex_index] = (
-                old_pos
-            )
-            self._update_polygon_item(segment_index)
-            self._display_edit_handles()
-            self._highlight_selected_segments()
-            self._show_notification("Undid: Move Vertex")
+            if (
+                segment_index is not None
+                and vertex_index is not None
+                and old_pos is not None
+            ):
+                if segment_index < len(self.segment_manager.segments):
+                    self.segment_manager.segments[segment_index]["vertices"][
+                        vertex_index
+                    ] = old_pos
+                    self._update_polygon_item(segment_index)
+                    self._display_edit_handles()
+                    self._highlight_selected_segments()
+                    self._show_notification("Undid: Move Vertex")
+                else:
+                    self._show_warning_notification(
+                        "Cannot undo: Segment no longer exists"
+                    )
+                    self.redo_history.pop()  # Remove from redo history if segment is gone
+            else:
+                self._show_warning_notification("Cannot undo: Missing vertex data")
+                self.redo_history.pop()  # Remove from redo history if data is incomplete
 
         # Add more undo logic for other action types here in the future
         else:
@@ -1147,8 +1163,7 @@ class MainWindow(QMainWindow):
                 for i, vertices in final_vertices.items():
                     if i < len(self.segment_manager.segments):
                         self.segment_manager.segments[i]["vertices"] = [
-                            [v.x(), v.y()]
-                            for v in [QPointF(p[0], p[1]) for p in vertices]
+                            [p[0], p[1]] for p in vertices
                         ]
                         self._update_polygon_item(i)
                 self._display_edit_handles()
@@ -1178,10 +1193,10 @@ class MainWindow(QMainWindow):
                     self._show_warning_notification(
                         "Cannot redo: Segment no longer exists"
                     )
-                    self.action_history.pop()
+                    self.action_history.pop()  # Remove from action history if segment is gone
             else:
                 self._show_warning_notification("Cannot redo: Missing vertex data")
-                self.action_history.pop()
+                self.action_history.pop()  # Remove from action history if data is incomplete
         else:
             self._show_warning_notification(
                 f"Redo for action '{action_type}' not implemented."
@@ -1321,7 +1336,7 @@ class MainWindow(QMainWindow):
                 selected_indices = self.right_panel.get_selected_segment_indices()
                 self.drag_initial_vertices = {
                     i: [
-                        QPointF(p[0], p[1])
+                        [p.x(), p.y()] if isinstance(p, QPointF) else p
                         for p in self.segment_manager.segments[i]["vertices"]
                     ]
                     for i in selected_indices
@@ -1360,7 +1375,7 @@ class MainWindow(QMainWindow):
                 self.drag_start_pos = pos
                 self.rubber_band_rect = QGraphicsRectItem()
                 self.rubber_band_rect.setPen(
-                    QPen(Qt.GlobalColor.red, 2, Qt.PenStyle.DashLine)
+                    QPen(Qt.GlobalColor.red, self.line_thickness, Qt.PenStyle.DashLine)
                 )
                 self.viewer.scene().addItem(self.rubber_band_rect)
         elif self.mode == "selection" and event.button() == Qt.MouseButton.LeftButton:
@@ -1371,9 +1386,13 @@ class MainWindow(QMainWindow):
         if self.mode == "edit" and self.is_dragging_polygon:
             delta = event.scenePos() - self.drag_start_pos
             for i, initial_verts in self.drag_initial_vertices.items():
-                # initial_verts are already QPointF objects
+                # initial_verts are lists, convert to QPointF for addition with delta
                 self.segment_manager.segments[i]["vertices"] = [
-                    [(p + delta).x(), (p + delta).y()] for p in initial_verts
+                    [
+                        (QPointF(p[0], p[1]) + delta).x(),
+                        (QPointF(p[0], p[1]) + delta).y(),
+                    ]
+                    for p in initial_verts
                 ]
                 self._update_polygon_item(i)
             self._display_edit_handles()  # Redraw handles at new positions
@@ -1395,7 +1414,10 @@ class MainWindow(QMainWindow):
         if self.mode == "edit" and self.is_dragging_polygon:
             # Record the action for undo
             final_vertices = {
-                i: list(self.segment_manager.segments[i]["vertices"])
+                i: [
+                    [p.x(), p.y()] if isinstance(p, QPointF) else p
+                    for p in self.segment_manager.segments[i]["vertices"]
+                ]
                 for i in self.drag_initial_vertices
             }
             self.action_history.append(
@@ -1431,7 +1453,7 @@ class MainWindow(QMainWindow):
                 polygon.append(rect.bottomLeft())
 
                 new_segment = {
-                    "vertices": list(polygon),
+                    "vertices": [[p.x(), p.y()] for p in list(polygon)],
                     "type": "Polygon",  # Bounding boxes are stored as polygons
                     "mask": None,
                 }

{lazylabel_gui-1.1.4.dist-info → lazylabel_gui-1.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.1.4
+Version: 1.1.5
 Summary: An image segmentation GUI for generating ML ready mask tensors and annotations.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License

{lazylabel_gui-1.1.4.dist-info → lazylabel_gui-1.1.5.dist-info}/RECORD

@@ -7,16 +7,16 @@ lazylabel/config/settings.py,sha256=Ud27cSadJ7M4l30XN0KrxZ3ixAOPXTUhj-SvvanMjaI,
 lazylabel/core/__init__.py,sha256=FmRjop_uIBSJwKMGhaZ-3Iwu34LkoxTuD-hnq5vbTSY,232
 lazylabel/core/file_manager.py,sha256=Blo55jXW-uGVLrreGRmlHUtK2yTbyj3jsTKkfjD0z7k,4796
 lazylabel/core/model_manager.py,sha256=P3IahI0xUk6-F7Y5U4r5RpnUQSelJqX2KBtcmUGNeNY,3368
-lazylabel/core/segment_manager.py,sha256=1lABdVdaa69_RPKx6ftYKJh7lNWCanodTsh7Utrpn2Q,6477
+lazylabel/core/segment_manager.py,sha256=M6kHcYeiub3WqL01NElCvKOc2GNmf72LUM1W8XwSaxc,6465
 lazylabel/models/__init__.py,sha256=fIlk_0DuZfiClcm0XlZdimeHzunQwBmTMI4PcGsaymw,91
 lazylabel/models/sam_model.py,sha256=89v99hpD0ngAAQKiuRyIib0E-5u9zTDJcubtmxxG-PM,7878
 lazylabel/ui/__init__.py,sha256=4qDIh9y6tABPmD8MAMGZn_G7oSRyrcHt2HkjoWgbGH4,268
 lazylabel/ui/control_panel.py,sha256=UlETN2IZv1l2xiaWPQvdalaK_f9YQf9iiB1Jb_EEgfs,9260
-lazylabel/ui/editable_vertex.py,sha256=xzc5QdFJJXiy035C3HgR4ph-tuJu8245l-Ar7aBvVv8,2399
+lazylabel/ui/editable_vertex.py,sha256=nAFC2UuFfbvMbGBbAiLWA77cS5-Hn3a08xe1_QLz2yk,2449
 lazylabel/ui/hotkey_dialog.py,sha256=ZlZoPvY822ke8YkbCy22o2RUjxtkXSoEOg8eVETIKpQ,15118
 lazylabel/ui/hoverable_pixelmap_item.py,sha256=kJFOp7WXiyHpNf7l73TZjiob85jgP30b5MZvu_z5L3c,728
 lazylabel/ui/hoverable_polygon_item.py,sha256=aclUwd0P8H8xbcep6GwhnfaVs1zSkqeZKAL-xeDyMiU,1222
-lazylabel/ui/main_window.py,sha256=ta3nzb6MWG-eLexlGKBc3oKtlsF9HpI-q1SvlrA-W2o,78623
+lazylabel/ui/main_window.py,sha256=h0wfVjQRskiTIq6X-Wd7OvM-PfOdKEKdFcwgx0iRIj0,79831
 lazylabel/ui/numeric_table_widget_item.py,sha256=dQUlIFu9syCxTGAHVIlmbgkI7aJ3f3wmDPBz1AGK9Bg,283
 lazylabel/ui/photo_viewer.py,sha256=4n2zSpFAnausCoIU-wwWDHDo6vsNp_RGIkhDyhuM2_A,1997
 lazylabel/ui/reorderable_class_table.py,sha256=sxHhQre5O_MXLDFgKnw43QnvXXoqn5xRKMGitgO7muI,2371
@@ -29,9 +29,9 @@ lazylabel/ui/widgets/status_bar.py,sha256=wTbMQNEOBfmtNj8EVFZS_lxgaemu-CbRXeZzEQ
 lazylabel/utils/__init__.py,sha256=V6IR5Gim-39HgM2NyTVT-n8gy3mjilCSFW9y0owN5nc,179
 lazylabel/utils/custom_file_system_model.py,sha256=-3EimlybvevH6bvqBE0qdFnLADVtayylmkntxPXK0Bk,4869
 lazylabel/utils/utils.py,sha256=sYSCoXL27OaLgOZaUkCAhgmKZ7YfhR3Cc5F8nDIa3Ig,414
-lazylabel_gui-1.1.4.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
-lazylabel_gui-1.1.4.dist-info/METADATA,sha256=hYVIAtM7vZNaJ8-0QOnFtNyaK3UpScgswNyJuaiJaFE,9506
-lazylabel_gui-1.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lazylabel_gui-1.1.4.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
-lazylabel_gui-1.1.4.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
-lazylabel_gui-1.1.4.dist-info/RECORD,,
+lazylabel_gui-1.1.5.dist-info/licenses/LICENSE,sha256=kSDEIgrWAPd1u2UFGGpC9X71dhzrlzBFs8hbDlENnGE,1092
+lazylabel_gui-1.1.5.dist-info/METADATA,sha256=2MNsqA48WN9e7YJMg864WZYGMZixitm3XtMnD2uZin4,9506
+lazylabel_gui-1.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lazylabel_gui-1.1.5.dist-info/entry_points.txt,sha256=Hd0WwEG9OPTa_ziYjiD0aRh7R6Fupt-wdQ3sspdc1mM,54
+lazylabel_gui-1.1.5.dist-info/top_level.txt,sha256=YN4uIyrpDBq1wiJaBuZLDipIzyZY0jqJOmmXiPIOUkU,10
+lazylabel_gui-1.1.5.dist-info/RECORD,,