Upload 2 files

ag4masses/alphageometry/graph.py

@@ -2773,7 +2773,7 @@ class Graph:
 
       # not necessary for proofing, but for visualization.
       c_args = list(map(lambda x: self.get(x, lambda: int(x)), c.args))
-      self.additionally_draw(c.name, c_args)
+      # self.additionally_draw(c.name, c_args)
 
       for points, bs in cdef.basics:
         if points:

ag4masses/alphageometry/numericals.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 import math
 from typing import Any, Optional, Union
+import random
 
 import geometry as gm
 import matplotlib
@@ -26,8 +27,10 @@ import matplotlib.colors as mcolors
 import numpy as np
 from numpy.random import uniform as unif  # pylint: disable=g-importing-member
 import graph as gh
+from collections import defaultdict
+from itertools import combinations
 
-matplotlib.use('Agg')
+matplotlib.use('TkAgg')
 
 
 ATOM = 1e-12
@@ -440,72 +443,72 @@ class Circle:
 
 
 class SemiCircle(Circle):
-  """Numerical semicircle, inherits from Circle."""
-
-  def __init__(
-      self,
-      center: Optional[Point] = None,
-      radius: Optional[float] = None,
-      p1: Optional[Point] = None,
-      p2: Optional[Point] = None,
-      p3: Optional[Point] = None,
-  ):
-      self.p1 = p1
-      self.p2 = p2
-      self.p3 = p3
-      # Initialize as a Circle
-      super().__init__(center, radius, p1, p2, p3)
-      # If p1 and p2 define a diameter, set the center and radius accordingly
-      if p1 and p2 and not center:
-          self.center = Point((p1.x + p2.x) / 2, (p1.y + p2.y) / 2)
-          self.radius = p1.distance(p2) / 2
-          self.r2 = self.radius ** 2
-
-      # Define the direction or plane for the semicircle (important for sampling and boundaries)
-
-  def is_within_boundary(self, point: Point) -> bool:
-      """Check if a point is within the boundary of the semicircle."""
-      vector_to_point = point - self.center
-      angle = math.atan2(vector_to_point.y, vector_to_point.x)
-
-      # Normalize the angle within [0, 2*pi]
-      angle = angle if angle >= 0 else (2 * np.pi + angle)
-      
-      # Check if the point is within the semicircle (half of the circle)
-      return -np.pi / 2 <= angle <= np.pi / 2
-
-  def sample_within(self, points: list[Point], n: int = 5) -> list[Point]:
-      """Sample a point within the semicircle."""
-      result = None
-      best = -1.0
-      for _ in range(n):
-          # Generate a random angle between -π/2 and π/2 for the semicircle
-          ang = unif(-0.5, 0.5) * np.pi
-          x = self.center + Point(np.cos(ang), np.sin(ang)) * self.radius
-
-          # Check if the sampled point is within the active part of the semicircle
-          if not self.is_within_boundary(x):
-              continue
-
-          # Find the minimum distance between the generated point and the provided points
-          mind = min([x.distance(p) for p in points])
-          if mind > best:
-              best = mind
-              result = x
-
-      return [result]
-
-  def intersect(self, obj: Union[Line, Circle]) -> tuple[Point, ...]:
-      """Find intersection points with a Line or another Circle, constrained to the semicircle."""
-      if isinstance(obj, Line):
-          intersections = obj.intersect(self)
-      elif isinstance(obj, Circle):
-          intersections = circle_circle_intersection(self, obj)
-      else:
-          return tuple()
-
-      # Filter intersections to only return points within the semicircle
-      return tuple(p for p in intersections if self.is_within_boundary(p))
+    """Numerical semicircle, inherits from Circle."""
+
+    def __init__(
+        self,
+        center: Optional[Point] = None,
+        radius: Optional[float] = None,
+        p1: Optional[Point] = None,
+        p2: Optional[Point] = None,
+        p3: Optional[Point] = None,
+    ):
+        self.p1 = p1
+        self.p2 = p2
+        self.p3 = p3
+        # Initialize as a Circle
+        super().__init__(center, radius, p1, p2, p3)
+        # If p1 and p2 define a diameter, set the center and radius accordingly
+        if p1 and p2 and not center:
+            self.center = Point((p1.x + p2.x) / 2, (p1.y + p2.y) / 2)
+            self.radius = p1.distance(p2) / 2
+            self.r2 = self.radius ** 2
+
+        # Define the direction or plane for the semicircle (important for sampling and boundaries)
+
+    def is_within_boundary(self, point: Point) -> bool:
+        """Check if a point is within the boundary of the semicircle."""
+        vector_to_point = point - self.center
+        angle = math.atan2(vector_to_point.y, vector_to_point.x)
+
+        # Normalize the angle within [0, 2*pi]
+        angle = angle if angle >= 0 else (2 * np.pi + angle)
+        
+        # Check if the point is within the semicircle (half of the circle)
+        return -np.pi / 2 <= angle <= np.pi / 2
+
+    def sample_within(self, points: list[Point], n: int = 5) -> list[Point]:
+        """Sample a point within the semicircle."""
+        result = None
+        best = -1.0
+        for _ in range(n):
+            # Generate a random angle between -π/2 and π/2 for the semicircle
+            ang = unif(-0.5, 0.5) * np.pi
+            x = self.center + Point(np.cos(ang), np.sin(ang)) * self.radius
+
+            # Check if the sampled point is within the active part of the semicircle
+            if not self.is_within_boundary(x):
+                continue
+
+            # Find the minimum distance between the generated point and the provided points
+            mind = min([x.distance(p) for p in points])
+            if mind > best:
+                best = mind
+                result = x
+
+        return [result]
+
+    def intersect(self, obj: Union[Line, Circle]) -> tuple[Point, ...]:
+        """Find intersection points with a Line or another Circle, constrained to the semicircle."""
+        if isinstance(obj, Line):
+            intersections = obj.intersect(self)
+        elif isinstance(obj, Circle):
+            intersections = circle_circle_intersection(self, obj)
+        else:
+            return tuple()
+
+        # Filter intersections to only return points within the semicircle
+        return tuple(p for p in intersections if self.is_within_boundary(p))
 
 
 class HoleCircle(Circle):
@@ -789,7 +792,7 @@ def check_perp(points: list[Point]) -> bool:
 
 def check_cyclic(points: list[Point]) -> bool:
   points = list(set(points))
-  (a, b, c, *ps) = points
+  (a, b, c, *ps)  = points
   circle = Circle(p1=a, p2=b, p3=c)
   for d in ps:
     if not close_enough(d.distance(circle.center), circle.radius):
@@ -975,7 +978,7 @@ def draw_angle(
 
 
 def naming_position(
-    ax: matplotlib.axes.Axes, p: Point, lines: list[Line], circles: list[Circle]
+    ax: matplotlib.axes.Axes, p: Point, lines: list[Line], circles: list[Circle], semicircles: list[SemiCircle]
 ) -> tuple[float, float]:
   """Figure out a good naming position on the drawing."""
   _ = ax
@@ -1034,7 +1037,7 @@ def draw_point(
     name = name[0] + '_' + name[1:]
 
   ax.annotate(
-      name, naming_position(ax, p, lines, circles), color=color, fontsize=15
+      name, naming_position(ax, p, lines, circles, semicircles), color=color, fontsize=15
   )
 
 
@@ -1106,6 +1109,7 @@ def draw_circle(
     ax: matplotlib.axes.Axes, circle: Circle, color: Any = 'cyan'
 ) -> Circle:
   """Draw a circle."""
+  name_circle = circle.name
   if circle.num is not None:
     circle = circle.num
   else:
@@ -1113,11 +1117,14 @@ def draw_circle(
     if len(points) <= 2:
       return
     points = [p.num for p in points]
+    print(len(points))
     p1, p2, p3 = points[:3]
     circle = Circle(p1=p1, p2=p2, p3=p3)
-
-  _draw_circle(ax, circle, color)
-  return circle
+  if "," in name_circle:
+    _draw_circle(ax, circle, color)
+    return circle
+  else:
+    return circle
 
 def check_points_semicircle(p1, p2, p3):
     """
@@ -1175,7 +1182,7 @@ def check_points_semicircle(p1, p2, p3):
     }
 
 def _draw_semicircle(
-    ax: matplotlib.axes.Axes, P1: Point, P2: Point, P3: Point, color: Any = 'cyan', lw: float = 1.2
+    ax: matplotlib.axes.Axes, P1: Point = None, P2: Point = None, P3: Point = None, color: Any = 'cyan', lw: float = 1.2
 ) -> None:
     """
     Draws a semicircle passing through three points or with one or two points on the diameter.
@@ -1186,45 +1193,71 @@ def _draw_semicircle(
         color (Any): Color of the semicircle.
         lw (float): Line width of the semicircle.
     """
-    result = check_points_semicircle((P1.x, P1.y), (P2.x, P2.y), (P3.x, P3.y))
-    if not result['is_valid']:
-        print("Points are collinear; cannot form a semicircle.")
-        return
-    
-    cx, cy = result['center']
-    radius = result['radius']
-    diameter_points = result['diameter_points']
-
-    # If no pair forms a diameter, determine angles for all three points
-    if diameter_points is None:
-        # Calculate angles of all three points relative to the circle's center
-        angles = np.arctan2(
-            [P1.y - cy, P2.y - cy, P3.y - cy], 
-            [P1.x - cx, P2.x - cx, P3.x - cx]
-        )
-        angles = (angles + 2 * np.pi) % (2 * np.pi)  # Normalize to [0, 2π]
+    points = [P for P in (P1, P2, P3) if P is not None]  # Filter out None values
+    if len(points) == 2:
+      cx = (P1.x + P2.x) / 2
+      cy = (P1.y + P2.y) / 2
+      radius = np.sqrt((P2.x - P1.x) ** 2 + (P2.y - P1.y) ** 2) / 2
+
+      # Compute angle of the diameter
+      angle_diameter = np.arctan2(P2.y - P1.y, P2.x - P1.x)
+
+      # Randomly determine the orientation of the semicircle
+      offset_angle = np.pi / 2 if random.choice([True, False]) else -np.pi / 2
+
+      # Start and end angles for the semicircle
+      start_angle = angle_diameter + offset_angle
+      end_angle = start_angle + np.pi
+
+      # Generate points for the semicircle
+      t = np.linspace(start_angle, end_angle, 100)
+      x = cx + radius * np.cos(t)
+      y = cy + radius * np.sin(t)
+      
+      # Plot the semicircle
+      ax.plot(x, y, color=color, lw=lw)
+  
+    if len(points) == 3:
         
-        # Determine the start and end angle for the semicircle
-        start_angle = np.min(angles)
-        end_angle = np.max(angles)
-        if end_angle - start_angle > np.pi:
-            start_angle, end_angle = end_angle, start_angle + 2 * np.pi
-    else:
-        # Use diameter points to define the semicircle angles
-        px, py = diameter_points[0]
-        qx, qy = diameter_points[1]
-        start_angle = np.arctan2(py - cy, px - cx)
-        end_angle = np.arctan2(qy - cy, qx - cx)
-        if end_angle - start_angle > np.pi:
-            start_angle, end_angle = end_angle, start_angle + 2 * np.pi
-
-    # Generate points for the semicircle
-    t = np.linspace(start_angle, end_angle, 100)
-    x = cx + radius * np.cos(t)
-    y = cy + radius * np.sin(t)
-    
-    # Plot the semicircle
-    ax.plot(x, y, color=color, lw=lw)
+      result = check_points_semicircle((P1.x, P1.y), (P2.x, P2.y), (P3.x, P3.y))
+      if not result['is_valid']:
+          print("Points are collinear; cannot form a semicircle.")
+          return
+      
+      cx, cy = result['center']
+      radius = result['radius']
+      diameter_points = result['diameter_points']
+
+      # If no pair forms a diameter, determine angles for all three points
+      if diameter_points is None:
+          # Calculate angles of all three points relative to the circle's center
+          angles = np.arctan2(
+              [P1.y - cy, P2.y - cy, P3.y - cy], 
+              [P1.x - cx, P2.x - cx, P3.x - cx]
+          )
+          angles = (angles + 2 * np.pi) % (2 * np.pi)  # Normalize to [0, 2π]
+          
+          # Determine the start and end angle for the semicircle
+          start_angle = np.min(angles)
+          end_angle = np.max(angles)
+          if end_angle - start_angle > np.pi:
+              start_angle, end_angle = end_angle, start_angle + 2 * np.pi
+      else:
+          # Use diameter points to define the semicircle angles
+          px, py = diameter_points[0]
+          qx, qy = diameter_points[1]
+          start_angle = np.arctan2(py - cy, px - cx)
+          end_angle = np.arctan2(qy - cy, qx - cx)
+          if end_angle - start_angle > np.pi:
+              start_angle, end_angle = end_angle, start_angle + 2 * np.pi
+
+      # Generate points for the semicircle
+      t = np.linspace(start_angle, end_angle, 100)
+      x = cx + radius * np.cos(t)
+      y = cy + radius * np.sin(t)
+      
+      # Plot the semicircle
+      ax.plot(x, y, color=color, lw=lw)
     
 def draw_semicircle(
     ax: matplotlib.axes.Axes, semicircle: SemiCircle, color: Any = 'cyan'
@@ -1296,7 +1329,6 @@ def highlight(
     _draw_line(ax, c, d, color=color2, lw=2.0)
   if name == 'eqangle':
     a, b, c, d, e, f, g, h = args
-
     x = line_line_intersection(Line(a, b), Line(c, d))
     if b.distance(x) > a.distance(x):
       a, b = b, a
@@ -1343,12 +1375,37 @@ def highlight(
     _draw_line(ax, c, d, color=color2, lw=2.0, alpha=0.5)
     _draw_line(ax, m, n, color=color1, lw=2.0, alpha=0.5)
     _draw_line(ax, p, q, color=color2, lw=2.0, alpha=0.5)
-  elif name == 'semicircle':
-    o, a, b, c = args
-    _draw_semicircle(ax, SemiCircle(center=o, p1=a, p2=b, p3=c), color=color1, lw=2.0)
+  if name == 'iso_triangle':
+    a, b, c = args
+    _draw_line(ax, c, b, color=color1, lw=2.0)
+    _draw_line(ax, c, a, color=color1, lw=2.0)
+    _draw_line(ax, b, a, color=color2, lw=2.0)
+  if name == 'semicircle':
+        o, a, b, c = args
+        _draw_semicircle(ax, SemiCircle(center=o, p1=a, p2=b, p3=c), color=color1, lw=2.0)
+
+def convert_point(gm_point: gm.Point) -> Point:
+    return Point(gm_point.num.x, gm_point.num.y)
 
 HCOLORS = None
 
+def find_pairs_with_same_distance(line_lengths):
+    # Step 1: Group point pairs by distance
+    distance_groups = defaultdict(list)
+    for (p1, p2), distance in line_lengths.items():
+        distance_groups[distance].append((p1, p2))
+    
+    # Step 2: Find combinations of pairs with the same distance
+    result = []
+    for pairs in distance_groups.values():
+        if len(pairs) > 1:  # Only consider distances with multiple pairs
+            for i in range(len(pairs)):
+                for j in range(i + 1, len(pairs)):
+                    line1 = pairs[i]
+                    line2 = pairs[j]
+                    result.append((line1, line2))  # Group as ((p1, p2), (p3, p4))
+    
+    return result
 
 def _draw(
     ax: matplotlib.axes.Axes,
@@ -1362,6 +1419,7 @@ def _draw(
 ):
   """Draw everything."""
   colors = ['red', 'green', 'blue', 'orange', 'magenta', 'purple']
+  colors_highlight = [color for color in mcolors.TABLEAU_COLORS.keys() if color not in colors]
   pcolor = 'black'
   lcolor = 'black'
   ccolor = 'grey'
@@ -1374,15 +1432,45 @@ def _draw(
     colors = ['grey']
 
   line_boundaries = []
+  line_lengths = {}
+  # Convert all points
+  for p in points:
+    points_numericals = [convert_point(p) for p in points]
   for l in lines:
     p1, p2 = draw_line(ax, l, color=lcolor)
     line_boundaries.append((p1, p2))
+    points_numericals.append(p1)
+    points_numericals.append(p2)
+  unique_points = []
+  seen = set()
+  for p in points_numericals:
+    if (p.x, p.y) not in seen:
+      unique_points.append(p)
+      seen.add((p.x, p.y))
+  print(len(unique_points))
+  for p1, p2 in combinations(unique_points, 2):
+    line_lengths[(p1, p2)] = round(p1.distance(p2), 9)
   circles = [draw_circle(ax, c, color=ccolor) for c in circles]
   semicircles = [draw_semicircle(ax, c, color=ccolor) for c in semicircles]
 
   for p in points:
     draw_point(ax, p.num, p.name, line_boundaries, circles, semicircles, color=pcolor)
 
+  same_length_pairs = find_pairs_with_same_distance(line_lengths)
+  print(len(same_length_pairs))
+
+  length_color_map = {}  # Dictionary to map length to its color
+  for i, ((p1, p2), (p3, p4)) in enumerate(same_length_pairs):
+    line_length = p1.distance(p2)  # Calculate the length of the line    
+    if line_length not in length_color_map:  # Check if length is already in the dictionary
+        #color = colors_highlight[i % len(colors_highlight)]
+        color = colors_highlight[i % len(colors_highlight) ]  # Assign a new color
+        length_color_map[line_length] = color  # Store the length and color in the dictionary
+    else:
+        color = length_color_map[line_length]  # Use the existing color for this length
+
+    # Call the highlight function with the determined color
+    highlight(ax, 'cong', [p1, p2, p3, p4], lcolor, color, color)
   if equals:
     for i, segs in enumerate(equals['segments']):
       color = colors[i % len(colors)]
@@ -1947,6 +2035,9 @@ def sketch_midp(args: tuple[gm.Point, ...]) -> Point:
   a, b = args
   return (a + b) * 0.5
 
+def sketch_foot(args: tuple[gm.Point, ...]) -> Point:
+  a, b, c = args
+  return a.foot(Line(b, c))
 
 def sketch_pentagon(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
   points = [Point(1.0, 0.0)]