MoleditPy 3.4.1__tar.gz → 3.5.0__tar.gz

{moleditpy-3.4.1 → moleditpy-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 3.4.1
+Version: 3.5.0
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy-3.4.1 → moleditpy-3.5.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "MoleditPy"
 
-version = "3.4.1"
+version = "3.5.0"
 
 license = {file = "LICENSE"}
 

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/MoleditPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 3.4.1
+Version: 3.5.0
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/moleditpy/ui/bond_item.py

@@ -11,6 +11,7 @@ DOI: 10.5281/zenodo.17268532
 """
 
 from __future__ import annotations
+import math
 import logging
 from typing import Any, Optional, Tuple, Union
 
@@ -109,6 +110,44 @@ class BondItem(QGraphicsItem):
         self.prepareGeometryChange()
         self.update()
 
+    @staticmethod
+    def _ring_inner_double_bond_shorten_factor(
+        line: QLineF, local_ring_center: QPointF
+    ) -> float:
+        """Shorten inner ring double bonds based on the ring angle at both atoms."""
+
+        def angle_between(v1: QPointF, v2: QPointF) -> Optional[float]:
+            len1 = math.hypot(v1.x(), v1.y())
+            len2 = math.hypot(v2.x(), v2.y())
+            if len1 <= 1e-6 or len2 <= 1e-6:
+                return None
+            dot = v1.x() * v2.x() + v1.y() * v2.y()
+            cos_angle = max(-1.0, min(1.0, dot / (len1 * len2)))
+            return math.acos(cos_angle)
+
+        p1 = line.p1()
+        p2 = line.p2()
+        half_angles = [
+            angle_between(p2 - p1, local_ring_center - p1),
+            angle_between(p1 - p2, local_ring_center - p2),
+        ]
+        interior_angles = [2 * a for a in half_angles if a is not None]
+        if not interior_angles:
+            return 0.8
+
+        ring_angle = sum(interior_angles) / len(interior_angles)
+        benzene_angle = 2 * math.pi / 3
+        cyclopropene_angle = math.pi / 3
+
+        if ring_angle <= benzene_angle:
+            angle_range = benzene_angle - cyclopropene_angle
+            sharpness = min(1.0, max(0.0, (benzene_angle - ring_angle) / angle_range))
+            return max(0.55, 0.8 - 0.25 * sharpness)
+
+        wide_angle_range = math.pi - benzene_angle
+        openness = min(1.0, max(0.0, (ring_angle - benzene_angle) / wide_angle_range))
+        return min(0.9, 0.8 + 0.1 * openness)
+
     def __init__(
         self, atom1_item: Any, atom2_item: Any, order: int = 1, stereo: int = 0
     ) -> None:
@@ -473,7 +512,9 @@ class BondItem(QGraphicsItem):
 
                         # Draw short inner line (80% length)
                         inner_line = line.translated(inner_offset)
-                        shorten_factor = 0.8
+                        shorten_factor = self._ring_inner_double_bond_shorten_factor(
+                            line, local_ring_center
+                        )
                         p1 = inner_line.p1()
                         p2 = inner_line.p2()
                         center = QPointF((p1.x() + p2.x()) / 2, (p1.y() + p2.y()) / 2)

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/moleditpy/ui/export_logic.py

@@ -79,12 +79,6 @@ class ExportManager:
         return basename
 
     def export_stl(self) -> None:
-        if not self.host.view_3d_manager.current_mol:
-            self.host.statusBar().showMessage(
-                "Error: Please generate a 3D structure first."
-            )
-            return
-
         default_path = self._get_default_path()
 
         file_path, _ = QFileDialog.getSaveFileName(
@@ -113,12 +107,6 @@ class ExportManager:
 
     def export_obj_mtl(self) -> None:
         """Export as OBJ/MTL (with colors)."""
-        if not self.host.view_3d_manager.current_mol:
-            self.host.statusBar().showMessage(
-                "Error: Please generate a 3D structure first."
-            )
-            return
-
         default_path = self._get_default_path()
 
         file_path, _ = QFileDialog.getSaveFileName(
@@ -257,12 +245,6 @@ class ExportManager:
 
     def export_color_stl(self) -> None:
         """Export as Color STL."""
-        if not self.host.view_3d_manager.current_mol:
-            self.host.statusBar().showMessage(
-                "Error: Please generate a 3D structure first."
-            )
-            return
-
         default_path = self._get_default_path()
 
         file_path, _ = QFileDialog.getSaveFileName(
@@ -954,10 +936,6 @@ class ExportManager:
 
     def export_3d_png(self) -> None:
         """Export 3D view as PNG."""
-        if not self.host.view_3d_manager.current_mol:
-            self.host.statusBar().showMessage("No 3D molecule to export.", 2000)
-            return
-
         # Default filename: {name}.png
         default_path = self._get_default_path()
 

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/moleditpy/ui/molecular_scene_handler.py

@@ -236,7 +236,7 @@ class TemplateMixin:
             if i < num_points and j < num_points
         ]
         avg_len = (sum(ref_lengths) / len(ref_lengths)) if ref_lengths else 20.0
-        map_threshold = max(0.5 * avg_len, 8.0)
+        click_map_threshold = max(0.5 * avg_len, 8.0)
 
         for ex_item in existing_items:
             try:
@@ -248,7 +248,7 @@ class TemplateMixin:
                     d = dist_pts(p, ex_pos)
                     if best_d is None or d < best_d:
                         best_d, best_idx = d, i
-                if best_idx != -1 and best_d <= max(map_threshold, 1.5 * avg_len):
+                if best_idx != -1 and best_d <= max(click_map_threshold, 1.5 * avg_len):
                     atom_items[best_idx] = ex_item
                     used_indices.add(best_idx)
             except (AttributeError, RuntimeError, ValueError, TypeError) as e:
@@ -258,27 +258,29 @@ class TemplateMixin:
 
         # --- 2) Enumerate existing atoms in the scene from self.data.atoms and map them ---
         mapped_atoms = {it for it in atom_items if it is not None}
-        for i, p in enumerate(points):
-            if atom_items[i] is not None:
-                continue
+        if self.get_setting("atom_fusing_enabled_2d", True):
+            map_threshold = self.get_setting("atom_fusing_distance_2d", 14.0)
+            for i, p in enumerate(points):
+                if atom_items[i] is not None:
+                    continue
 
-            nearby = None
-            best_d = float("inf")
+                nearby = None
+                best_d = float("inf")
 
-            for atom_data in self.data.atoms.values():
-                a_item = atom_data.get("item")
-                if not a_item or a_item in mapped_atoms:
-                    continue
-                try:
-                    d = dist_pts(p, a_item.pos())
-                except (AttributeError, RuntimeError, ValueError, TypeError):
-                    continue
-                if d < best_d:
-                    best_d, nearby = d, a_item
+                for atom_data in self.data.atoms.values():
+                    a_item = atom_data.get("item")
+                    if not a_item or a_item in mapped_atoms:
+                        continue
+                    try:
+                        d = dist_pts(p, a_item.pos())
+                    except (AttributeError, RuntimeError, ValueError, TypeError):
+                        continue
+                    if d < best_d:
+                        best_d, nearby = d, a_item
 
-            if nearby and best_d <= map_threshold:
-                atom_items[i] = nearby
-                mapped_atoms.add(nearby)
+                if nearby and best_d <= map_threshold:
+                    atom_items[i] = nearby
+                    mapped_atoms.add(nearby)
 
         # --- 3) Create missing vertices ---
         for i, p in enumerate(points):
@@ -369,12 +371,16 @@ class TemplateMixin:
             except ValueError:
                 return
 
-        items_under = self.items(pos)  # top-most first
         item = None
-        for it in items_under:
-            if isinstance(it, (AtomItem, BondItem)):
-                item = it
-                break
+        if pos:
+            snap_dist = self.get_setting("template_snapping_distance_2d", 14.0)
+            item = self.find_atom_near(pos, tol=snap_dist)
+        if item is None:
+            items_under = self.items(pos)  # top-most first
+            for it in items_under:
+                if isinstance(it, (AtomItem, BondItem)):
+                    item = it
+                    break
 
         points, bonds_info = [], []
         l = DEFAULT_BOND_LENGTH
@@ -566,12 +572,16 @@ class TemplateMixin:
             return
 
         # Find attachment point (first atom or clicked item)
-        items_under = self.items(pos)
         attachment_atom = None
-        for item in items_under:
-            if isinstance(item, AtomItem):
-                attachment_atom = item
-                break
+        if pos:
+            snap_dist = self.get_setting("template_snapping_distance_2d", 14.0)
+            attachment_atom = self.find_atom_near(pos, tol=snap_dist)
+        if attachment_atom is None:
+            items_under = self.items(pos)
+            for item in items_under:
+                if isinstance(item, AtomItem):
+                    attachment_atom = item
+                    break
 
         # Calculate template positions
         points = []
@@ -722,9 +732,18 @@ class KeyboardMixin:
     def keyPressEvent(self, event: Any) -> None:
         view = self.views()[0]
         cursor_pos = view.mapToScene(view.mapFromGlobal(QCursor.pos()))
-        item_at_cursor = self.itemAt(cursor_pos, view.transform())
+        transform = view.transform()
         key = event.key()
         modifiers = event.modifiers()
+        item_at_cursor = None
+        if key == Qt.Key.Key_4:
+            snap_dist = self.get_setting("template_snapping_distance_2d", 14.0)
+            item_at_cursor = self.find_atom_near(cursor_pos, tol=snap_dist)
+        elif self.get_setting("atom_fusing_enabled_2d", True):
+            fuse_dist = self.get_setting("atom_fusing_distance_2d", 14.0)
+            item_at_cursor = self.find_atom_near(cursor_pos, tol=fuse_dist)
+        if item_at_cursor is None:
+            item_at_cursor = self.itemAt(cursor_pos, transform)
 
         if not self.window.ui_manager.is_2d_editable:
             return
@@ -741,13 +760,69 @@ class KeyboardMixin:
                     if isinstance(item_at_cursor, AtomItem):
                         p0 = item_at_cursor.pos()
                         l = DEFAULT_BOND_LENGTH
-                        direction = QLineF(p0, cursor_pos).unitVector()
-                        p1 = (
-                            p0 + direction.p2() * l
-                            if direction.length() > 0
-                            else p0 + QPointF(l, 0)
-                        )
-                        points = self._calculate_polygon_from_edge(p0, p1, n)
+
+                        # Check if this is a terminal atom (exactly 1 neighbor)
+                        neighbor_positions = []
+                        if hasattr(item_at_cursor, "bonds") and item_at_cursor.bonds:
+                            for b in item_at_cursor.bonds:
+                                if not sip_isdeleted_safe(b):
+                                    other = (
+                                        b.atom1
+                                        if b.atom2 is item_at_cursor
+                                        else b.atom2
+                                    )
+                                    if (
+                                        other
+                                        and not sip_isdeleted_safe(other)
+                                        and hasattr(other, "pos")
+                                    ):
+                                        try:
+                                            neighbor_positions.append(other.pos())
+                                        except RuntimeError:
+                                            continue
+
+                        if len(neighbor_positions) == 1:
+                            v_to_neighbor = neighbor_positions[0] - p0
+                            angle_to_neighbor = math.atan2(
+                                v_to_neighbor.y(), v_to_neighbor.x()
+                            )
+                            angle_plus = angle_to_neighbor + math.radians(120)
+                            angle_minus = angle_to_neighbor - math.radians(120)
+                            angle_cursor = math.atan2(
+                                cursor_pos.y() - p0.y(), cursor_pos.x() - p0.x()
+                            )
+                            diff_plus = abs(
+                                math.atan2(
+                                    math.sin(angle_cursor - angle_plus),
+                                    math.cos(angle_cursor - angle_plus),
+                                )
+                            )
+                            diff_minus = abs(
+                                math.atan2(
+                                    math.sin(angle_cursor - angle_minus),
+                                    math.cos(angle_cursor - angle_minus),
+                                )
+                            )
+                            best_angle = (
+                                angle_plus if diff_plus < diff_minus else angle_minus
+                            )
+                            p1 = p0 + QPointF(
+                                l * math.cos(best_angle), l * math.sin(best_angle)
+                            )
+                            bend_dir = p0 - v_to_neighbor
+                            points = self._calculate_polygon_from_edge(
+                                p0, p1, n, cursor_pos=bend_dir
+                            )
+                        else:
+                            direction = QLineF(p0, cursor_pos).unitVector()
+                            p1 = (
+                                p0 + direction.p2() * l
+                                if direction.length() > 0
+                                else p0 + QPointF(l, 0)
+                            )
+                            points = self._calculate_polygon_from_edge(
+                                p0, p1, n, cursor_pos=cursor_pos
+                            )
                         existing_items = [item_at_cursor]
 
                     elif isinstance(item_at_cursor, BondItem):
@@ -1008,7 +1083,12 @@ class KeyboardMixin:
                     target_pos = start_pos + new_pos_offset
 
                     # Find nearby atom
-                    near_atom = self.find_atom_near(target_pos, tol=SNAP_DISTANCE)
+                    near_atom = None
+                    if self.get_setting("atom_fusing_enabled_2d", True):
+                        fuse_dist = self.get_setting(
+                            "atom_fusing_distance_2d", SNAP_DISTANCE
+                        )
+                        near_atom = self.find_atom_near(target_pos, tol=fuse_dist)
 
                     if near_atom and near_atom is not start_atom:
                         # Bond if exists
@@ -1377,6 +1457,8 @@ class SceneQueryMixin:
             return False
 
     def find_atom_near(self, pos: Any, tol: float = 14.0) -> Any:
+        if pos is None:
+            return None
         # Create a small search rectangle around the position
         search_rect = QRectF(pos.x() - tol, pos.y() - tol, 2 * tol, 2 * tol)
         nearby_items = self.items(search_rect)

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/moleditpy/ui/molecule_scene.py

@@ -107,7 +107,8 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             and self.window
             and hasattr(self.window, "init_manager")
         ):
-            return self.window.init_manager.settings.get(key, default)
+            settings = self.window.init_manager.settings
+            return settings.get(key, default)
         return default
 
     def update_connected_bonds(self, atoms: List[AtomItem]) -> None:
@@ -210,7 +211,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
                     if isinstance(it, (AtomItem, BondItem))
                     and not sip_isdeleted_safe(it)
                 ]
-            except Exception as e:
+            except (AttributeError, RuntimeError, TypeError, ValueError) as e:
                 # Fallback to empty selection if the scene state is inconsistent during event processing
                 logging.debug(
                     f"Failed to retrieve selected items in mousePressEvent: {e}"
@@ -304,9 +305,16 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             self.clearSelection()
             event.accept()
 
-        item: Optional[QGraphicsItem] = self.itemAt(
-            self.press_pos, self.views()[0].transform()
-        )
+        item = None
+        if (
+            self.mode.startswith("bond")
+            and self.get_setting("atom_fusing_enabled_2d", True)
+            and self.press_pos
+        ):
+            fuse_dist = self.get_setting("atom_fusing_distance_2d", 14.0)
+            item = self.find_atom_near(self.press_pos, tol=fuse_dist)
+        if item is None:
+            item = self.itemAt(self.press_pos, self.views()[0].transform())
 
         if isinstance(item, AtomItem):
             self.start_atom = item
@@ -352,10 +360,14 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             end_point = current_pos
 
             target_atom = None
-            for item in self.items(current_pos):
-                if isinstance(item, AtomItem):
-                    target_atom = item
-                    break
+            if self.get_setting("atom_fusing_enabled_2d", True) and current_pos:
+                fuse_dist = self.get_setting("atom_fusing_distance_2d", 14.0)
+                target_atom = self.find_atom_near(current_pos, tol=fuse_dist)
+            else:
+                for item in self.items(current_pos):
+                    if isinstance(item, AtomItem):
+                        target_atom = item
+                        break
 
             is_valid_snap_target = target_atom is not None and (
                 self.start_atom is None or target_atom is not self.start_atom
@@ -544,7 +556,12 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             self.mode.startswith("atom") or self.mode.startswith("bond")
         ):
             line = QLineF(self.start_atom.pos(), end_pos)
-            end_item = self.itemAt(end_pos, self.views()[0].transform())
+            end_item = None
+            if self.get_setting("atom_fusing_enabled_2d", True) and end_pos:
+                fuse_dist = self.get_setting("atom_fusing_distance_2d", 14.0)
+                end_item = self.find_atom_near(end_pos, tol=fuse_dist)
+            if end_item is None:
+                end_item = self.itemAt(end_pos, self.views()[0].transform())
             # Determine bond style to use
             # In atom modes, set bond_order/stereo to None so create_bond uses defaults (1, 0)
             # In bond_* modes, use current settings (self.bond_order/stereo)
@@ -593,7 +610,12 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
                 self.create_atom(self.current_atom_symbol, end_pos)
                 self.data_changed_in_event = True
             else:
-                end_item = self.itemAt(end_pos, self.views()[0].transform())
+                end_item = None
+                if self.get_setting("atom_fusing_enabled_2d", True) and end_pos:
+                    fuse_dist = self.get_setting("atom_fusing_distance_2d", 14.0)
+                    end_item = self.find_atom_near(end_pos, tol=fuse_dist)
+                if end_item is None:
+                    end_item = self.itemAt(end_pos, self.views()[0].transform())
                 if isinstance(end_item, AtomItem):
                     start_id = self.create_atom(
                         self.current_atom_symbol, self.start_pos

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/moleditpy/ui/settings_tabs/settings_2d_tab.py

@@ -15,6 +15,7 @@ from typing import Any, Optional
 
 from PyQt6.QtGui import QColor, QFont
 from PyQt6.QtWidgets import (
+    QCheckBox,
     QColorDialog,
     QComboBox,
     QFontComboBox,
@@ -135,16 +136,56 @@ class Settings2DTab(SettingsTabBase):
             ),
         )
 
-        from PyQt6.QtWidgets import QCheckBox
-
         self.atom_use_bond_color_2d_checkbox = QCheckBox()
         self.atom_use_bond_color_2d_checkbox.setToolTip(
-            "If checked, atoms will use the unified Bond Color instead of element-specific colors (CPK)."
+            "If checked, atoms will use the unified Bond Color "
+            "instead of element-specific colors (CPK)."
         )
         form_layout.addRow(
             "Use Bond Color for Atoms:", self.atom_use_bond_color_2d_checkbox
         )
 
+        form_layout.addRow(self._create_separator())
+
+        # --- Atom Fusing Settings ---
+        form_layout.addRow(QLabel("<b>Atom Fusing Settings</b>"))
+
+        self.atom_fusing_enabled_2d_checkbox = QCheckBox()
+        self.atom_fusing_enabled_2d_checkbox.setToolTip(
+            "If checked, drawing or placing templates near an existing atom "
+            "will connect to it rather than creating a new one."
+        )
+        form_layout.addRow("Enable Atom Fusing:", self.atom_fusing_enabled_2d_checkbox)
+
+        # Fusing Distance
+        self.atom_fusing_distance_2d_slider, self.atom_fusing_distance_2d_label = (
+            self._create_slider(5, 50, 1.0, is_int=True)
+        )
+        form_layout.addRow(
+            "Fusing Distance (px):",
+            self._wrap_layout(
+                self.atom_fusing_distance_2d_slider, self.atom_fusing_distance_2d_label
+            ),
+        )
+
+        form_layout.addRow(self._create_separator())
+
+        # --- Template Snapping Settings ---
+        form_layout.addRow(QLabel("<b>Template Snapping Settings</b>"))
+
+        # Template Snapping Distance
+        (
+            self.template_snapping_distance_2d_slider,
+            self.template_snapping_distance_2d_label,
+        ) = self._create_slider(5, 50, 1.0, is_int=True)
+        form_layout.addRow(
+            "Snapping Distance (px):",
+            self._wrap_layout(
+                self.template_snapping_distance_2d_slider,
+                self.template_snapping_distance_2d_label,
+            ),
+        )
+
     def _pick_bg_color_2d(self) -> None:
         color = QColorDialog.getColor(
             QColor(self.current_bg_color_2d), self, "Select 2D Background Color"
@@ -209,6 +250,15 @@ class Settings2DTab(SettingsTabBase):
         self.atom_use_bond_color_2d_checkbox.setChecked(
             settings_dict.get("atom_use_bond_color_2d", False)
         )
+        self.atom_fusing_enabled_2d_checkbox.setChecked(
+            settings_dict.get("atom_fusing_enabled_2d", True)
+        )
+        self.atom_fusing_distance_2d_slider.setValue(
+            int(settings_dict.get("atom_fusing_distance_2d", 14.0))
+        )
+        self.template_snapping_distance_2d_slider.setValue(
+            int(settings_dict.get("template_snapping_distance_2d", 14.0))
+        )
 
     def get_settings(self) -> dict[str, Any]:
         return {
@@ -223,4 +273,11 @@ class Settings2DTab(SettingsTabBase):
             "atom_font_family_2d": self.atom_font_family_2d_combo.currentFont().family(),
             "atom_font_size_2d": self.atom_font_size_2d_slider.value(),
             "atom_use_bond_color_2d": self.atom_use_bond_color_2d_checkbox.isChecked(),
+            "atom_fusing_enabled_2d": self.atom_fusing_enabled_2d_checkbox.isChecked(),
+            "atom_fusing_distance_2d": float(
+                self.atom_fusing_distance_2d_slider.value()
+            ),
+            "template_snapping_distance_2d": float(
+                self.template_snapping_distance_2d_slider.value()
+            ),
         }

{moleditpy-3.4.1 → moleditpy-3.5.0}/src/moleditpy/utils/default_settings.py

@@ -76,6 +76,9 @@ DEFAULT_SETTINGS = {
     "bond_wedge_width_2d": 6.0,
     "bond_dash_count_2d": 8,
     "atom_font_family_2d": "Arial",
+    "atom_fusing_enabled_2d": True,
+    "atom_fusing_distance_2d": 14.0,
+    "template_snapping_distance_2d": 14.0,
     # --- Application Session / UI State ---
     "theme": "light",
     "window_size": [1200, 800],