Merge pull request #1033 from UC-Davis-molecular-computing/1032-convert-pair-of-extension-to-bound-domains-on-helices

fixes #1032: convert extensions to domains

Author: dave-doty

.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep:*)",
+      "Bash(dart pub:*)",
+      "Bash(dart analyze:*)",
+      "Bash(dart format:*)"
+    ],
+    "deny": [],
+    "ask": [],
+    "defaultMode": "acceptEdits"
+  }
+}

CLAUDE.md

@@ -0,0 +1 @@
+Please read CONTRIBUTING.md for details about this project.

CONTRIBUTING.md

@@ -4796,3 +4796,45 @@ abstract class OxExportOnlySelectedStrandsSet
   @memoized
   int get hashCode;
 }
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// convert extensions to bound domains on new helix
+
+abstract class ConvertExtensionsToBoundDomains
+    with BuiltJsonSerializable, UndoableAction
+    implements Action, Built<ConvertExtensionsToBoundDomains, ConvertExtensionsToBoundDomainsBuilder> {
+  Extension get extension1;
+
+  Extension? get extension2;
+
+  /************************ begin BuiltValue boilerplate ************************/
+  factory ConvertExtensionsToBoundDomains({required Extension extension1, Extension? extension2}) {
+    return ConvertExtensionsToBoundDomains.from(
+      (b) =>
+          b
+            ..extension1.replace(extension1)
+            ..extension2 = extension2?.toBuilder(),
+    );
+  }
+
+  ConvertExtensionsToBoundDomains._();
+
+  factory ConvertExtensionsToBoundDomains.from([
+    void Function(ConvertExtensionsToBoundDomainsBuilder) updates,
+  ]) = _$ConvertExtensionsToBoundDomains;
+
+  static Serializer<ConvertExtensionsToBoundDomains> get serializer =>
+      _$convertExtensionsToBoundDomainsSerializer;
+
+  @override
+  String short_description() {
+    if (extension2 == null) {
+      return "convert extension to domain on new helix";
+    } else {
+      return "convert extensions to bound domains on new helix";
+    }
+  }
+
+  @memoized
+  int get hashCode;
+}

lib/src/actions/actions.dart

@@ -10,6 +10,17 @@ import 'helix_group_move_reducer.dart';
 import 'inline_insertions_deletions_reducer.dart';
 import 'strands_reducer.dart';
 import '../util.dart' as util;
+import '../state/extension.dart';
+import '../state/helix.dart';
+import '../state/group.dart';
+import '../state/domain.dart';
+import '../state/strand.dart';
+import '../state/grid_position.dart';
+import '../state/grid.dart';
+import '../constants.dart' as constants;
+import '../state/position3d.dart';
+import '../state/geometry.dart';
+import 'dart:math';
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // reducer composition
@@ -75,6 +86,9 @@ GlobalReducer<Design?, AppState> design_whole_global_reducer = combineGlobalRedu
     helix_remove_all_selected_design_global_reducer,
   ),
   TypedGlobalReducer<Design?, AppState, actions.HelixGroupMoveCommit>(helix_group_move_commit_global_reducer),
+  TypedGlobalReducer<Design?, AppState, actions.ConvertExtensionsToBoundDomains>(
+    convert_extensions_to_bound_domains_reducer,
+  ),
 ]);
 
 // need to operate on Design so we can re-set helix svg coordinates
@@ -93,3 +107,272 @@ Design? design_geometry_set_reducer(Design? design, AppState state, actions.Geom
 }
 
 Design? new_design_set_reducer(Design? design, actions.NewDesignSet action) => action.design;
+
+Design? convert_extensions_to_bound_domains_reducer(
+  Design? design,
+  AppState state,
+  actions.ConvertExtensionsToBoundDomains action,
+) {
+  if (design == null) {
+    return null;
+  }
+
+  return _convert_extensions_to_bound_domains(design, action.extension1, action.extension2);
+}
+
+Design _convert_extensions_to_bound_domains(Design design, Extension extension1, Extension? extension2) {
+  // Step 1: Find the strands containing these extensions
+  var strand1 = design.strands.firstWhere((s) => s.extensions.contains(extension1));
+  Strand? strand2 =
+      extension2 != null ? design.strands.firstWhere((s) => s.extensions.contains(extension2)) : null;
+
+  // Step 2: Calculate the new helix group position and pitch angle
+  var new_helix_idx = _get_next_helix_idx(design);
+  var new_group_name = _get_unique_group_name(design, new_helix_idx);
+
+  // Get geometry from the source helix group (where the neighboring domain is)
+  var source_helix = design.helices[extension1.adjacent_domain.helix]!;
+  var source_group = design.groups[source_helix.group]!;
+  var source_geometry = source_group.geometry ?? design.geometry;
+
+  // Step 3: Calculate the correct group position and pitch angle
+  var group_positioning = _calculate_group_positioning(design, extension1, source_geometry);
+
+  var new_group = HelixGroup(
+    helices_view_order: [new_helix_idx],
+    position: group_positioning.group_position,
+    pitch: group_positioning.pitch_angle,
+    yaw: 0,
+    roll: 0,
+    geometry: source_geometry, // Use the same geometry as the source group
+  );
+
+  // Step 4: Create the new helix positioned to coincide with extension1
+  // Calculate the required helix length - should be the maximum of the two extensions
+  // since they overlap at the connection point
+  int total_length =
+      extension2 != null
+          ? [extension1.num_bases, extension2.num_bases].reduce((a, b) => a > b ? a : b)
+          : extension1.num_bases;
+
+  var new_helix = Helix(
+    idx: new_helix_idx,
+    grid: Grid.none,
+    position: Position3D.origin, // Helix is at origin within its group
+    group: new_group_name,
+    min_offset: 0,
+    max_offset: total_length,
+    major_tick_start: 0,
+  );
+
+  // Step 5: Convert extensions to domains and update strands
+  var updated_strands = design.strands.toList();
+
+  // Replace extension1 with a forward domain
+  // Both domains start at offset 0 and overlap at the connection point
+  int domain1_start = 0;
+  int domain1_end = extension1.num_bases;
+
+  var new_domain1 = Domain(
+    helix: new_helix_idx,
+    forward: true,
+    start: domain1_start,
+    end: domain1_end,
+    dna_sequence: extension1.dna_sequence, // Copy DNA sequence from extension
+  );
+
+  var updated_strand1 = _replace_extension_with_domain(strand1, extension1, new_domain1);
+  // Call initialize() after modifying the strand to ensure proper setup
+  updated_strand1 = updated_strand1.initialize();
+  var strand1_idx = design.strands.indexOf(strand1);
+  updated_strands[strand1_idx] = updated_strand1;
+
+  // If there's a second extension, replace it with a reverse domain
+  if (extension2 != null && strand2 != null) {
+    // The second domain also starts at offset 0 and overlaps with the first domain
+    int domain2_start = 0;
+    int domain2_end = extension2.num_bases;
+
+    var new_domain2 = Domain(
+      helix: new_helix_idx,
+      forward: false,
+      start: domain2_start,
+      end: domain2_end,
+      dna_sequence: extension2.dna_sequence, // Copy DNA sequence from extension
+    );
+
+    var updated_strand2 = _replace_extension_with_domain(strand2, extension2, new_domain2);
+    // Call initialize() after modifying the strand to ensure proper setup
+    updated_strand2 = updated_strand2.initialize();
+    var strand2_idx = design.strands.indexOf(strand2);
+    updated_strands[strand2_idx] = updated_strand2;
+  }
+
+  // Step 6: Build the updated design
+  var result = design.rebuild(
+    (b) =>
+        b
+          ..groups.replace({...design.groups.asMap(), new_group_name: new_group})
+          ..helices.replace({...design.helices.asMap(), new_helix_idx: new_helix})
+          ..strands.replace(updated_strands),
+  );
+
+  return result;
+}
+
+class _GroupPositioning {
+  final Position3D group_position;
+  final double pitch_angle;
+
+  _GroupPositioning(this.group_position, this.pitch_angle);
+}
+
+double _calculate_extension_world_angle(Extension extension, HelixGroup group) {
+  // Use the same logic as compute_end_rotation from util.dart
+  var adjacent_domain = extension.adjacent_domain;
+  double display_angle = extension.display_angle;
+
+  // Apply the same transformations as compute_end_rotation
+  var radians = display_angle * 2 * pi / 360.0;
+  num x = cos(radians);
+  num y = sin(radians);
+
+  // Apply the reflections from util.dart compute_end_rotation
+  y = -y;
+  if (!adjacent_domain.forward) {
+    x = -x;
+  }
+  if ((adjacent_domain.forward && extension.is_5p) || (!adjacent_domain.forward && !extension.is_5p)) {
+    x = -x;
+  }
+
+  // Convert back to degrees
+  var reflected_radians = atan2(y, x);
+  var degrees = reflected_radians * 360.0 / (2 * pi);
+
+  // Account for the current group's pitch rotation
+  double current_visual_angle = degrees + group.pitch;
+
+  return current_visual_angle;
+}
+
+_GroupPositioning _calculate_group_positioning(Design design, Extension extension, Geometry geometry) {
+  // Find the helix and group containing the adjacent domain
+  var adjacent_domain = extension.adjacent_domain;
+  var helix = design.helices[adjacent_domain.helix]!;
+  var group = design.groups[helix.group]!;
+
+  // Calculate the 3D position where the extension attaches to the domain
+  var helix_position = helix.position3d(geometry);
+
+  // Calculate the offset position on the helix
+  int end_offset = extension.is_5p ? adjacent_domain.offset_5p : adjacent_domain.offset_3p;
+  double offset_along_helix = end_offset * geometry.rise_per_base_pair;
+
+  var attached_position = Position3D(
+    x: helix_position.x,
+    y: helix_position.y,
+    z: helix_position.z + offset_along_helix,
+  );
+
+  // Transform by group position
+  attached_position = attached_position + group.position;
+
+  // If the adjacent domain is reverse, we need to adjust for the vertical offset
+  // since reverse domains are drawn on the bottom half of the helix
+  // Convert from SVG pixels to nanometers using geometry.svg_pixels_to_nm
+  if (!adjacent_domain.forward) {
+    double y_offset_nm = 2 * geometry.base_height_svg * geometry.svg_pixels_to_nm;
+    attached_position = Position3D(
+      x: attached_position.x,
+      y: attached_position.y + y_offset_nm,
+      z: attached_position.z,
+    );
+  }
+
+  // Calculate the world angle of the extension
+  double world_angle = _calculate_extension_world_angle(extension, group);
+
+  // Calculate target visual angle for the new forward domain
+  double target_visual_angle = world_angle;
+
+  // For 5' extensions, the new domain should appear pointing in the opposite direction
+  // because the extension was pointing towards the 5' end, but the new forward domain
+  // starts from the 5' end and goes towards the 3' end
+  if (extension.is_5p) {
+    target_visual_angle += 180;
+  }
+
+  // For extensions next to reverse domains, the display angle interpretation is inverted
+  // compared to forward domains, so we need to add 180 degrees to compensate
+  if (!adjacent_domain.forward) {
+    target_visual_angle += 180;
+  }
+
+  // The pitch angle should be set so that the forward domain at angle 0 appears
+  // with the target visual angle: 0 + group_pitch = target_visual_angle
+  double pitch_angle = target_visual_angle;
+
+  // Calculate the group position based on where we want the connection to happen
+  Position3D group_position;
+
+  if (extension.is_5p) {
+    // For 5' extensions: we want the 3' end of the new domain (at offset extension.num_bases)
+    // to be positioned at the attached_position
+    // The 3' end is at offset extension.num_bases along the helix, which after rotation by pitch_angle
+    // becomes a vector in the pitched direction
+    double connection_offset = extension.num_bases * geometry.rise_per_base_pair;
+
+    // Convert the offset to world coordinates using the pitch angle
+    // The helix runs along the Z axis (left/right), and the pitch angle rotates
+    // the helix in the Y-Z plane (up/down and left/right in main view)
+    double pitch_radians = pitch_angle * pi / 180.0;
+    double offset_y = -connection_offset * sin(pitch_radians); // Y is up/down in main view
+    double offset_z = -connection_offset * cos(pitch_radians); // Z is left/right in main view
+
+    group_position = Position3D(
+      x: attached_position.x, // X position stays the same (into/out of screen)
+      y: attached_position.y + offset_y,
+      z: attached_position.z + offset_z,
+    );
+  } else {
+    // For 3' extensions: we want the 5' end of the new domain (at offset 0)
+    // to be positioned at the attached_position
+    // Since the helix is at origin in the group, the 5' end is at z = 0
+    // So: group_position + (0, 0, 0) = attached_position
+    // Therefore: group_position = attached_position
+    group_position = attached_position;
+  }
+
+  return _GroupPositioning(group_position, pitch_angle);
+}
+
+int _get_next_helix_idx(Design design) {
+  if (design.helices.isEmpty) {
+    return 0;
+  }
+  return design.helices.keys.fold(0, (max, idx) => idx > max ? idx : max) + 1;
+}
+
+String _get_unique_group_name(Design design, int helix_idx) {
+  String candidate = 'group_${helix_idx}';
+  int counter = 0;
+  while (design.groups.containsKey(candidate)) {
+    counter++;
+    candidate = 'group_${helix_idx}_${counter}';
+  }
+  return candidate;
+}
+
+Strand _replace_extension_with_domain(Strand strand, Extension extension, Domain new_domain) {
+  var substrands = strand.substrands.toList();
+  var extension_index = substrands.indexOf(extension);
+
+  if (extension_index == -1) {
+    throw ArgumentError('Extension not found in strand');
+  }
+
+  substrands[extension_index] = new_domain;
+
+  return strand.rebuild((b) => b..substrands.replace(substrands));
+}

lib/src/reducers/design_reducer.dart

@@ -367,6 +367,7 @@ part 'serializers.g.dart';
   OxdnaExport,
   OxviewExport,
   OxExportOnlySelectedStrandsSet,
+  ConvertExtensionsToBoundDomains,
   Design,
   AssignDomainNameComplementFromBoundStrands,
   AssignDomainNameComplementFromBoundDomains,