fix: handle non-canonicalizable breakpoint when both breakends at same position

When both breakends are at the same genomic position with
leftPositive=false and rightPositive=true, calling reversed() produces
an identical breakpoint (it is a fixed-point of the reversal
operation). The previous isCanonical check returned false for this
case, causing an unnecessary and ineffective reversal.

Fix isCanonical to accept any same-position breakpoint where at least
one strand is positive, since these cannot be further canonicalized.
Only (false, false) is non-canonical, which correctly reverses to
(true, true).

Author: nh13

src/main/scala/com/fulcrumgenomics/sv/Breakpoint.scala

@@ -96,10 +96,12 @@ case class Breakpoint(leftRefIndex: Int,
   )
 
   /** Returns true if the representation of the breakpoint is canonical, with the left hand side of the break
-   * earlier on the genome than the right hand side. */
+   * earlier on the genome than the right hand side.  When both breakends are at the same position, the breakpoint
+   * is canonical if at least one strand is positive.  This handles the fixed-point cases where `reversed` produces
+   * an identical breakpoint (e.g. same position with leftPositive=false, rightPositive=true). */
   def isCanonical: Boolean = (leftRefIndex < rightRefIndex) ||
     (leftRefIndex == rightRefIndex && leftPos < rightPos) ||
-    (leftRefIndex == rightRefIndex && leftPos == rightPos && leftPositive)
+    (leftRefIndex == rightRefIndex && leftPos == rightPos && (leftPositive || rightPositive))
 
   /** Returns an [[Interval]] for the left side of this breakpoint */
   def leftInterval(dict: SequenceDictionary): Interval = new Interval(

src/test/scala/com/fulcrumgenomics/sv/BreakpointTest.scala

@@ -79,7 +79,21 @@ class BreakpointTest extends UnitSpec {
     (rbp.rightPos, rbp.rightPositive) shouldBe (1000, true)
   }
 
-  it should "represent a tandem duplication sanely" in {
+  "Breakpoint.isCanonical" should "treat all strand combinations at the same position as canonical except (F, F)" in {
+    val base = Breakpoint(leftRefIndex=0, leftPos=100, leftPositive=true, rightRefIndex=0, rightPos=100, rightPositive=true)
+
+    // (T, T) at same position: canonical
+    base.copy(leftPositive=true,  rightPositive=true).isCanonical  shouldBe true
+    // (T, F) at same position: canonical (fixed-point of reversed)
+    base.copy(leftPositive=true,  rightPositive=false).isCanonical shouldBe true
+    // (F, T) at same position: canonical (fixed-point of reversed)
+    base.copy(leftPositive=false, rightPositive=true).isCanonical  shouldBe true
+    // (F, F) at same position: NOT canonical, reversed gives (T, T)
+    base.copy(leftPositive=false, rightPositive=false).isCanonical shouldBe false
+    base.copy(leftPositive=false, rightPositive=false).reversed.isCanonical shouldBe true
+  }
+
+  "Breakpoint.apply(segment, segment)" should "represent a tandem duplication sanely" in {
     // We want the same representation regardless of which piece of the duplication was sequenced more so
     // we test where the second segment is shorter, the same length as, and longer than the first
     Seq(-1, 0, 1).foreach { addend =>