MoleditPy 3.6.0__tar.gz → 3.6.1__tar.gz

{moleditpy-3.6.0 → moleditpy-3.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 3.6.0
+Version: 3.6.1
 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.6.0 → moleditpy-3.6.1}/pyproject.toml

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

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/MoleditPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 3.6.0
+Version: 3.6.1
 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.6.0 → moleditpy-3.6.1}/src/moleditpy/__init__.py

@@ -8,15 +8,14 @@ Author: Hiromichi Yokoyama
 License: GPL-3.0 license
 Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
-"""
 
-"""Top-level package for moleditpy."""
+Top-level package for moleditpy.
+"""
 
 import importlib.util
+from .utils.constants import VERSION as __version__  # noqa: F401
 
 try:
     OBABEL_AVAILABLE = importlib.util.find_spec("openbabel") is not None
 except ImportError:
     OBABEL_AVAILABLE = False
-
-from .utils.constants import VERSION as __version__  # noqa: F401

moleditpy-3.6.1/src/moleditpy/ui/atom_picking.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+import logging
+
+import numpy as np
+
+try:
+    from ..utils.constants import VDW_RADII, pt
+except ImportError:
+    from moleditpy.utils.constants import VDW_RADII, pt
+
+
+def _world_to_display(renderer: Any, pos: Any) -> Optional[tuple[float, float, float]]:
+    try:
+        renderer.SetWorldPoint(float(pos[0]), float(pos[1]), float(pos[2]), 1.0)
+        renderer.WorldToDisplay()
+        display = renderer.GetDisplayPoint()
+        return (float(display[0]), float(display[1]), float(display[2]))
+    except (AttributeError, RuntimeError, TypeError, ValueError, IndexError):
+        return None
+
+
+def _atom_world_radius(view_3d_manager: Any, mol: Any, atom_idx: int) -> float:
+    try:
+        atom = mol.GetAtomWithIdx(int(atom_idx))
+        symbol = atom.GetSymbol()
+    except (AttributeError, RuntimeError, TypeError, ValueError):
+        symbol = "C"
+
+    settings = {}
+    try:
+        settings = view_3d_manager.host.init_manager.settings
+    except (AttributeError, RuntimeError, TypeError):
+        pass
+
+    style = str(getattr(view_3d_manager, "current_3d_style", "ball_and_stick"))
+    style = style.lower().replace(" ", "_")
+
+    if style == "cpk":
+        scale = settings.get("cpk_atom_scale", 1.0)
+        try:
+            radius = pt.GetRvdw(pt.GetAtomicNumber(symbol))
+            return float(radius if radius > 0.1 else 1.5) * float(scale)
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            return 1.5 * float(scale)
+
+    if style == "stick":
+        return float(settings.get("stick_bond_radius", 0.15))
+
+    if style == "wireframe":
+        return 0.01
+
+    scale = settings.get("ball_stick_atom_scale", 1.0)
+    return float(VDW_RADII.get(symbol, 0.4)) * float(scale)
+
+
+def _projected_radius_px(
+    renderer: Any, center: Any, world_radius: float
+) -> Optional[float]:
+    center_display = _world_to_display(renderer, center)
+    if center_display is None:
+        return None
+
+    offsets = (
+        (world_radius, 0.0, 0.0),
+        (0.0, world_radius, 0.0),
+        (0.0, 0.0, world_radius),
+    )
+    radius_px = 0.0
+    for offset in offsets:
+        edge = (
+            float(center[0]) + offset[0],
+            float(center[1]) + offset[1],
+            float(center[2]) + offset[2],
+        )
+        edge_display = _world_to_display(renderer, edge)
+        if edge_display is None:
+            continue
+        radius_px = max(
+            radius_px,
+            float(
+                np.hypot(
+                    edge_display[0] - center_display[0],
+                    edge_display[1] - center_display[1],
+                )
+            ),
+        )
+
+    return radius_px
+
+
+def pick_atom_index_from_screen_sequential(
+    view_3d_manager: Any,
+    click_pos: tuple[int, int],
+    mol: Optional[Any] = None,
+    padding_px: float = 8.0,
+    min_radius_px: float = 14.0,
+    max_radius_px: float = 96.0,
+) -> Optional[int]:
+    """Return the atom nearest a screen click without invoking VTK cell picking."""
+    try:
+        plotter = view_3d_manager.plotter
+        renderer = plotter.renderer
+        positions = view_3d_manager.atom_positions_3d
+    except (AttributeError, RuntimeError, TypeError):
+        return None
+
+    if positions is None:
+        return None
+
+    try:
+        positions_array = np.asarray(positions, dtype=float)
+    except (TypeError, ValueError):
+        return None
+
+    if positions_array.ndim != 2 or positions_array.shape[1] < 3:
+        return None
+
+    if mol is None:
+        mol = getattr(view_3d_manager, "current_mol", None)
+
+    try:
+        atom_count = int(mol.GetNumAtoms()) if mol is not None else len(positions_array)
+    except (AttributeError, RuntimeError, TypeError, ValueError):
+        atom_count = len(positions_array)
+
+    best_idx: Optional[int] = None
+    best_score: Optional[tuple[float, float]] = None
+
+    for atom_idx in range(min(atom_count, len(positions_array))):
+        center = positions_array[atom_idx]
+        display = _world_to_display(renderer, center)
+        if display is None or not np.all(np.isfinite(display[:2])):
+            continue
+
+        world_radius = _atom_world_radius(view_3d_manager, mol, atom_idx)
+        projected_radius = _projected_radius_px(renderer, center, world_radius)
+        hit_radius = max(
+            float(min_radius_px),
+            min(float(max_radius_px), float(projected_radius or 0.0) + padding_px),
+        )
+        distance = float(np.hypot(display[0] - click_pos[0], display[1] - click_pos[1]))
+        if distance > hit_radius:
+            continue
+
+        score = (distance / hit_radius, distance)
+        if best_score is None or score < best_score:
+            best_idx = atom_idx
+            best_score = score
+
+    return best_idx
+
+
+def pick_atom_index_from_screen_vectorized(
+    view_3d_manager: Any,
+    click_pos: tuple[int, int],
+    mol: Optional[Any] = None,
+    padding_px: float = 8.0,
+    min_radius_px: float = 14.0,
+    max_radius_px: float = 96.0,
+) -> Optional[int]:
+    """
+    Vectorized atom picking using the camera's projection matrix.
+    Eliminates the O(N) Python loop and VTK C++ boundary calls.
+    """
+    try:
+        plotter = view_3d_manager.plotter
+        renderer = plotter.renderer
+        positions = view_3d_manager.atom_positions_3d
+    except (AttributeError, RuntimeError, TypeError):
+        return None
+
+    if positions is None or len(positions) == 0:
+        return None
+
+    try:
+        positions_array = np.asarray(positions, dtype=float)  # Shape: (N, 3)
+    except (TypeError, ValueError):
+        return None
+
+    if positions_array.ndim != 2 or positions_array.shape[1] < 3:
+        return None
+
+    if mol is None:
+        mol = getattr(view_3d_manager, "current_mol", None)
+
+    try:
+        atom_count = int(mol.GetNumAtoms()) if mol is not None else len(positions_array)
+    except (AttributeError, RuntimeError, TypeError, ValueError):
+        atom_count = len(positions_array)
+
+    active_atoms = min(atom_count, len(positions_array))
+    if active_atoms == 0:
+        return None
+
+    positions_array = positions_array[:active_atoms]
+
+    # 1. Retrieve the View-Projection (Composite) Matrix from the active camera
+    try:
+        camera = renderer.GetActiveCamera()
+        aspect_ratio = renderer.GetTiledAspectRatio()
+        # Get the 4x4 composite projection matrix (vtkMatrix4x4)
+        vtk_matrix = camera.GetCompositeProjectionTransformMatrix(aspect_ratio, -1, 1)
+
+        # Convert vtkMatrix4x4 to a NumPy 4x4 array
+        matrix = np.zeros((4, 4))
+        for i in range(4):
+            for j in range(4):
+                matrix[i, j] = vtk_matrix.GetElement(i, j)
+    except Exception:
+        return None
+
+    # 2. Convert all N world coordinates to homogeneous coordinates (N, 4)
+    homogeneous_coords = np.hstack([positions_array, np.ones((active_atoms, 1))])
+
+    # 3. Apply Matrix Multiplication: (N, 4) x (4, 4).T -> Clip Space Coordinates
+    clip_coords = homogeneous_coords @ matrix.T
+
+    # 4. Perform Perspective Divide -> Normalized Device Coordinates (NDC)
+    w = clip_coords[:, 3:4]
+    w_copy = np.copy(w)
+    w_copy[np.abs(w_copy) < 1e-5] = 1.0
+    ndc_coords = clip_coords[:, :3] / w_copy
+
+    # 5. Transform NDC to Screen/Display Coordinates
+    try:
+        size = renderer.GetSize()  # (width, height)
+    except Exception:
+        return None
+
+    # VTK display space coordinates: X: [0, W], Y: [0, H]
+    display_coords = np.zeros((active_atoms, 2))
+    display_coords[:, 0] = (ndc_coords[:, 0] + 1.0) * 0.5 * size[0]
+    display_coords[:, 1] = (ndc_coords[:, 1] + 1.0) * 0.5 * size[1]
+
+    # 6. Vectorized Distance and Hit Radius Calculation
+    dx = display_coords[:, 0] - click_pos[0]
+    dy = display_coords[:, 1] - click_pos[1]
+    distances = np.hypot(dx, dy)
+
+    try:
+        if camera.GetParallelProjection():
+            pixel_scale = size[1] / (2.0 * camera.GetParallelScale())
+        else:
+            view_angle_rad = np.radians(camera.GetViewAngle())
+            pixel_scale = size[1] / (
+                2.0 * np.abs(w.flatten()) * np.tan(view_angle_rad / 2.0)
+            )
+    except Exception:
+        pixel_scale = 20.0  # Safe fallback scale
+
+    # Pre-calculate world radii for all atoms
+    world_radii = np.array(
+        [_atom_world_radius(view_3d_manager, mol, idx) for idx in range(active_atoms)]
+    )
+
+    projected_radii = world_radii * pixel_scale
+    hit_radii = np.maximum(
+        min_radius_px, np.minimum(max_radius_px, projected_radii + padding_px)
+    )
+
+    # 7. Mask out atoms that are further than their hit radius
+    valid_mask = distances <= hit_radii
+    if not np.any(valid_mask):
+        return None
+
+    # 8. Score calculation and find the best index
+    # Tie-breaking logic: (ratio) + (distances * 1e-8)
+    scores = (distances / hit_radii) + (distances * 1e-8)
+
+    scores[~valid_mask] = np.inf
+    best_idx = int(np.argmin(scores))
+
+    return best_idx if scores[best_idx] != np.inf else None
+
+
+def pick_atom_index_from_screen(
+    view_3d_manager: Any,
+    click_pos: tuple[int, int],
+    mol: Optional[Any] = None,
+    padding_px: float = 8.0,
+    min_radius_px: float = 14.0,
+    max_radius_px: float = 96.0,
+) -> Optional[int]:
+    """Return the atom nearest a screen click, trying vectorized first, falling back to sequential."""
+    try:
+        best_idx = pick_atom_index_from_screen_vectorized(
+            view_3d_manager, click_pos, mol, padding_px, min_radius_px, max_radius_px
+        )
+        if best_idx is not None:
+            return best_idx
+    except Exception as e:
+        logging.debug("Vectorized picking failed, falling back to sequential: %s", e)
+
+    return pick_atom_index_from_screen_sequential(
+        view_3d_manager, click_pos, mol, padding_px, min_radius_px, max_radius_px
+    )

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/moleditpy/ui/constrained_optimization_dialog.py

@@ -877,6 +877,3 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
 
         # Default processing for other keys
         QDialog.keyPressEvent(self, event)
-
-
-from typing import Any

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/moleditpy/ui/custom_interactor_style.py

@@ -405,7 +405,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             dx = current_pos[0] - move_group_dialog._drag_start_pos[0]
             dy = current_pos[1] - move_group_dialog._drag_start_pos[1]
 
-            if abs(dx) > 2 or abs(dy) > 2:
+            if abs(dx) > 5 or abs(dy) > 5:
                 move_group_dialog._mouse_moved = True
 
             return  # Disable camera rotation
@@ -423,7 +423,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             dx = current_pos[0] - move_group_dialog._rotation_start_pos[0]
             dy = current_pos[1] - move_group_dialog._rotation_start_pos[1]
 
-            if abs(dx) > 2 or abs(dy) > 2:
+            if abs(dx) > 5 or abs(dy) > 5:
                 move_group_dialog._rotation_mouse_moved = True
 
             return  # Disable camera rotation
@@ -493,6 +493,13 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             if getattr(
                 move_group_dialog, "_is_dragging_group_vtk", False
             ) and not getattr(move_group_dialog, "_mouse_moved", False):
+                # No drag = click only -> toggle
+                clicked_atom = getattr(move_group_dialog, "_drag_atom_idx", None)
+                if clicked_atom is not None:
+                    try:
+                        move_group_dialog.on_atom_picked(clicked_atom)
+                    except (AttributeError, RuntimeError, TypeError, ValueError) as e:
+                        logging.error(f"Error in toggle: {e}")
                 # Reset if multi-clicked without drag
                 move_group_dialog._is_dragging_group_vtk = False
                 move_group_dialog._drag_start_pos = None

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/moleditpy/ui/edit_3d_logic.py

@@ -12,15 +12,25 @@ DOI: 10.5281/zenodo.17268532
 
 from __future__ import annotations
 
-"""
-main_window_edit_3d.py
-Mixin class separated from main_window.py
-"""
+# main_window_edit_3d.py
+# Mixin class separated from main_window.py
 
 import logging
 from typing import Any, List, Optional
 
 import numpy as np
+import pyvista as pv
+from PyQt6.QtCore import QPointF
+from PyQt6.QtGui import QColor, QFont
+from PyQt6.QtWidgets import QGraphicsTextItem
+
+try:
+    from PyQt6 import sip as _sip  # type: ignore
+
+    _sip_isdeleted = getattr(_sip, "isdeleted", None)
+except ImportError:
+    _sip = None  # type: ignore[assignment]
+    _sip_isdeleted = None
 
 try:
     from .mol_geometry import (
@@ -41,20 +51,6 @@ try:
 except ImportError:
     from moleditpy.utils.sip_isdeleted_safe import sip_isdeleted_safe
 
-# PyQt6 Modules
-import pyvista as pv
-from PyQt6.QtCore import QPointF
-from PyQt6.QtGui import QColor, QFont
-from PyQt6.QtWidgets import QGraphicsTextItem
-
-try:
-    from PyQt6 import sip as _sip  # type: ignore
-
-    _sip_isdeleted = getattr(_sip, "isdeleted", None)
-except ImportError:
-    _sip = None  # type: ignore[assignment]
-    _sip_isdeleted = None
-
 try:
     # package relative imports (preferred when running as `python -m moleditpy`)
     from .constants import VDW_RADII
@@ -169,8 +165,8 @@ class Edit3DManager:
             return
 
         # Prepare label positions and text
-        atom_indices = [l[0] for l in self.measurement_labels]
-        labels = [l[1] for l in self.measurement_labels]
+        atom_indices = [item[0] for item in self.measurement_labels]
+        labels = [item[1] for item in self.measurement_labels]
         positions = []
         texts = []
         positions_3d = self.host.view_3d_manager.atom_positions_3d

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/moleditpy/ui/edit_actions_logic.py

@@ -1443,9 +1443,9 @@ class EditActionsManager:
                         pos_i = positions_i[k]
                         vdw_i = vdw_i_all[k]
 
-                        for l, _ in enumerate(frag_j["indices"]):
-                            pos_j = positions_j[l]
-                            vdw_j = vdw_j_all[l]
+                        for idx, _ in enumerate(frag_j["indices"]):
+                            pos_j = positions_j[idx]
+                            vdw_j = vdw_j_all[idx]
 
                             distance_vec = pos_i - pos_j
                             distance_sq = np.dot(

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/moleditpy/ui/molecular_scene_handler.py

@@ -32,11 +32,10 @@ except ImportError:
     from moleditpy.utils.sip_isdeleted_safe import sip_isdeleted_safe
 
 try:
-    from ..utils.constants import DEFAULT_BOND_LENGTH, SNAP_DISTANCE, SUM_TOLERANCE
+    from ..utils.constants import DEFAULT_BOND_LENGTH, SUM_TOLERANCE
 except ImportError:
     from moleditpy.utils.constants import (
         DEFAULT_BOND_LENGTH,
-        SNAP_DISTANCE,
         SUM_TOLERANCE,
     )
 
@@ -724,7 +723,9 @@ class KeyboardMixin:
 
     temp_line: Optional[QGraphicsLineItem]
 
-    def _calculate_new_atom_position(self, start_atom: Any, bond_length: Any) -> Any:
+    def _calculate_new_atom_position(
+        self, start_atom: Any, bond_length: Any, target_order: int = 1
+    ) -> Any:
         """
         Calculate the position for a new atom based on the surroundings of start_atom.
         Returns the offset QPointF.
@@ -752,8 +753,12 @@ class KeyboardMixin:
             other_atom = bond.atom1 if bond.atom2 is start_atom else bond.atom2
             existing_bond_vector = start_pos - other_atom.pos()
 
-            # Rotate 60° clockwise from existing bond
-            angle_rad = math.radians(60)
+            # Rotate 60° clockwise/anticlockwise from existing bond (or 0°/180° straight continuation for alkyne)
+            is_clockwise = getattr(self, "placement_direction_clockwise", True)
+            angle_deg = 60 if is_clockwise else -60
+            if target_order == 3 or getattr(bond, "order", 1) == 3:
+                angle_deg = 0
+            angle_rad = math.radians(angle_deg)
             cos_a, sin_a = math.cos(angle_rad), math.sin(angle_rad)
             vx, vy = existing_bond_vector.x(), existing_bond_vector.y()
             new_vx, new_vy = vx * cos_a - vy * sin_a, vx * sin_a + vy * cos_a
@@ -820,9 +825,9 @@ class KeyboardMixin:
         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("template_fusing_enabled_2d", True):
-            fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-            item_at_cursor = self.find_atom_near(cursor_pos, tol=fuse_dist)
+        else:
+            snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+            item_at_cursor = self.find_atom_near(cursor_pos, tol=snap_dist)
         if item_at_cursor is None:
             item_at_cursor = self.itemAt(cursor_pos, transform)
 
@@ -1160,7 +1165,7 @@ class KeyboardMixin:
                     start_pos = start_atom.pos()
                     bond_len = DEFAULT_BOND_LENGTH
                     new_pos_offset = self._calculate_new_atom_position(
-                        start_atom, bond_len
+                        start_atom, bond_len, target_order
                     )
 
                     # SNAP_DISTANCE is a module-level constant
@@ -1168,11 +1173,8 @@ class KeyboardMixin:
 
                     # Find nearby atom
                     near_atom = None
-                    if self.get_setting("template_fusing_enabled_2d", True):
-                        fuse_dist = self.get_setting(
-                            "template_fusing_distance_2d", SNAP_DISTANCE
-                        )
-                        near_atom = self.find_atom_near(target_pos, tol=fuse_dist)
+                    snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                    near_atom = self.find_atom_near(target_pos, tol=snap_dist)
 
                     if near_atom and near_atom is not start_atom:
                         # Bond if exists
@@ -1193,6 +1195,13 @@ class KeyboardMixin:
                             bond_stereo=0,
                         )
 
+                    if target_order != 3:
+                        if hasattr(self, "placement_direction_clockwise"):
+                            self.placement_direction_clockwise = (
+                                not self.placement_direction_clockwise
+                            )
+                        else:
+                            self.placement_direction_clockwise = False
                     self.clearSelection()
                     self.update_all_items()
                     self.window.edit_actions_manager.push_undo_state()

{moleditpy-3.6.0 → moleditpy-3.6.1}/src/moleditpy/ui/molecule_scene.py

@@ -177,6 +177,11 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
 
     def mousePressEvent(self, event: Any) -> None:
         self.press_pos = event.scenePos()
+        self.was_selected_on_press = False
+        if self.mode == "select" and event.button() == Qt.MouseButton.LeftButton:
+            item = self.itemAt(self.press_pos, self.views()[0].transform())
+            if isinstance(item, AtomItem) and item.isSelected():
+                self.was_selected_on_press = True
         self.mouse_moved_since_press = False
         self.data_changed_in_event = False
 
@@ -239,7 +244,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
                         if hasattr(item, "stereo") and item.stereo in [3, 4]:
                             item.set_stereo(0)
                             # Also update the data model
-                            for (id1, id2), bdata in self.data.bonds.items():
+                            for bdata in self.data.bonds.values():
                                 if bdata.get("item") is item:
                                     bdata["stereo"] = 0
                                     break
@@ -306,14 +311,14 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             event.accept()
 
         item = None
-        if (
-            self.mode.startswith("bond")
-            and self.get_setting("template_fusing_enabled_2d", True)
-            and self.press_pos
-        ):
-            fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-            item = self.find_atom_near(self.press_pos, tol=fuse_dist)
-        if item is None:
+        if self.mode.startswith("bond") and self.press_pos:
+            snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+            item = self.find_atom_near(self.press_pos, tol=snap_dist)
+            if item is None:
+                candidate = self.itemAt(self.press_pos, self.views()[0].transform())
+                if not isinstance(candidate, AtomItem):
+                    item = candidate
+        else:
             item = self.itemAt(self.press_pos, self.views()[0].transform())
 
         if isinstance(item, AtomItem):
@@ -360,14 +365,9 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             end_point = current_pos
 
             target_atom = None
-            if self.get_setting("template_fusing_enabled_2d", True) and current_pos:
-                fuse_dist = self.get_setting("template_fusing_distance_2d", 7.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
+            if current_pos:
+                snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                target_atom = self.find_atom_near(current_pos, tol=snap_dist)
 
             is_valid_snap_target = target_atom is not None and (
                 self.start_atom is None or target_atom is not self.start_atom
@@ -387,7 +387,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
 
         end_pos = event.scenePos()
         is_click = (
-            self.press_pos
+            self.press_pos is not None
             and (end_pos - self.press_pos).manhattanLength()
             < QApplication.startDragDistance()
         )
@@ -557,11 +557,13 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
         ):
             line = QLineF(self.start_atom.pos(), end_pos)
             end_item = None
-            if self.get_setting("template_fusing_enabled_2d", True) and end_pos:
-                fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-                end_item = self.find_atom_near(end_pos, tol=fuse_dist)
+            if end_pos:
+                snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                end_item = self.find_atom_near(end_pos, tol=snap_dist)
             if end_item is None:
-                end_item = self.itemAt(end_pos, self.views()[0].transform())
+                candidate = self.itemAt(end_pos, self.views()[0].transform())
+                if not isinstance(candidate, AtomItem):
+                    end_item = candidate
             # 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)
@@ -611,11 +613,13 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
                 self.data_changed_in_event = True
             else:
                 end_item = None
-                if self.get_setting("template_fusing_enabled_2d", True) and end_pos:
-                    fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-                    end_item = self.find_atom_near(end_pos, tol=fuse_dist)
+                if end_pos:
+                    snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                    end_item = self.find_atom_near(end_pos, tol=snap_dist)
                 if end_item is None:
-                    end_item = self.itemAt(end_pos, self.views()[0].transform())
+                    candidate = self.itemAt(end_pos, self.views()[0].transform())
+                    if not isinstance(candidate, AtomItem):
+                        end_item = candidate
                 if isinstance(end_item, AtomItem):
                     start_id = self.create_atom(
                         self.current_atom_symbol, self.start_pos
@@ -642,6 +646,14 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
         # 5. Other processing (Select mode, etc.)
         else:
             super().mouseReleaseEvent(event)
+            if (
+                self.mode == "select"
+                and is_click
+                and getattr(self, "was_selected_on_press", False)
+            ):
+                released_item = self.itemAt(end_pos, self.views()[0].transform())
+                if isinstance(released_item, AtomItem):
+                    released_item.setSelected(False)
 
         # Safely check for moved objects
         moved_atoms = []