Coordinate Transformations.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from icecream import ic\n",
    "from tracker_coordinate_transform import *\n",
    "import circle_fit as circle\n",
    "from tracker_coordinate_transform import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = []\n",
    "xc = 1\n",
    "yc= 1\n",
    "r = 1\n",
    "samples.append((0,2))\n",
    "samples.append((1,1))\n",
    "samples.append((2,0))\n",
    "xs =[0,1,2]\n",
    "ys = [2,1,0]\n",
    "#print (np.array(samples))\n",
    "#print (samples)\n",
    "#circle.plot_data_circle(xs,ys,xc=xc,yc=yc,R=r)\n",
    "circle.plot_data_circle(samples,xc=xc,yc=yc,r=r)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_circle_samples(radius=1, xc=0, yc=0, rotation=0, nsamples=5,theta_start=0,theta_end=2*np.pi):\n",
    "    circle_samples = []\n",
    "    # Generate sample angles from 0 to 2*pi \n",
    "    angles = np.linspace(theta_start, theta_end, nsamples) \n",
    "\n",
    "    for angle in angles:\n",
    "        x = radius*np.cos(angle+rotation) + xc\n",
    "        y = radius*np.sin(angle+rotation) + yc\n",
    "        circle_samples.append((x,y))   \n",
    "\n",
    "    ic(angles)\n",
    "    \n",
    "    return (circle_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_circle_samples_array(radius=1, xc=0, yc=0, rotation=0, nsamples=5,theta_start=0,theta_end=2*np.pi):\n",
    "    circle_samples = []\n",
    "    # Generate sample angles from 0 to 2*pi \n",
    "    angles = np.linspace(theta_start, theta_end, nsamples) \n",
    "\n",
    "    for angle in angles:\n",
    "        x = radius*np.cos(angle+rotation) + xc\n",
    "        y = radius*np.sin(angle+rotation) + yc\n",
    "        circle_samples.append([x,y])   \n",
    "\n",
    "    ic(angles)\n",
    "    \n",
    "    return (np.array(circle_samples))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle_samples = generate_circle_samples()\n",
    "ic(circle_samples)\n",
    "xc, yc, r, sigma = circle.least_squares_circle(circle_samples)\n",
    "ic(xc, yc, r, sigma)\n",
    "circle.plot_data_circle(circle_samples,xc=xc,yc=yc,r=r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_angle(p1, p2):\n",
    "    # Calculate the angle in radians between the two points\n",
    "    x1, y1 = p1\n",
    "    x2, y2 = p2\n",
    "    angle1 = np.atan2(y1, x1)\n",
    "    angle2 = np.atan2(y2, x2)\n",
    "    \n",
    "    # Calculate the difference in angles\n",
    "    angle = angle2 - angle1\n",
    "    return angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def find_affine_transform(src_points, dst_points):\n",
    "    \"\"\"\n",
    "    Find the affine transformation matrix that maps src_points to dst_points.\n",
    "    \n",
    "    :param src_points: Source points in the original coordinate system.\n",
    "    :param dst_points: Destination points in the new coordinate system.\n",
    "    :return: 3x3 affine transformation matrix.\n",
    "    \"\"\"\n",
    "    assert src_points.shape == dst_points.shape, \"Source and destination points must have the same shape.\"\n",
    "    \n",
    "    # Create matrices for the affine transformation\n",
    "    n = src_points.shape[0]\n",
    "    A = np.zeros((2 * n, 6))\n",
    "    B = np.zeros((2 * n))\n",
    "\n",
    "    for i in range(n):\n",
    "        A[2 * i] = [src_points[i, 0], src_points[i, 1], 1, 0, 0, 0]\n",
    "        A[2 * i + 1] = [0, 0, 0, src_points[i, 0], src_points[i, 1], 1]\n",
    "        B[2 * i] = dst_points[i, 0]\n",
    "        B[2 * i + 1] = dst_points[i, 1]\n",
    "\n",
    "    # Solve for the affine transformation parameters\n",
    "    params, _, _, _ = np.linalg.lstsq(A, B, rcond=None)\n",
    "    transform_matrix = np.array([\n",
    "        [params[0], params[1], params[2]],\n",
    "        [params[3], params[4], params[5]],\n",
    "        [0, 0, 1]\n",
    "    ])\n",
    "\n",
    "    return transform_matrix\n",
    "\n",
    "def apply_transform(point, transform_matrix):\n",
    "    \"\"\"\n",
    "    Apply the affine transformation to a point.\n",
    "    \n",
    "    :param point: The original point (x, y) in the first coordinate system.\n",
    "    :param transform_matrix: 3x3 affine transformation matrix.\n",
    "    :return: Transformed point (x', y') in the second coordinate system.\n",
    "    \"\"\"\n",
    "    original_point = np.array([point[0], point[1], 1])\n",
    "    transformed_point = np.dot(transform_matrix, original_point)\n",
    "    return transformed_point[:2]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ic| angles: array([0.        , 1.57079633, 3.14159265, 4.71238898, 6.28318531])\n",
      "ic| angles: array([0.        , 1.57079633, 3.14159265, 4.71238898, 6.28318531])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Affine Transformation Matrix:\n",
      " [[-1.00000000e+00  6.66133815e-16 -4.00000000e+00]\n",
      " [-7.03535689e-16 -1.00000000e+00  3.00000000e+00]\n",
      " [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example usage\n",
    "# Source and destination points (must be at least 3 pairs for affine transformation)\n",
    "\n",
    "# Simulate generated points from calibration\n",
    "simulated_src_angle = np.pi\n",
    "simulated_src_xc = -4\n",
    "simulated_src_yc = 3\n",
    "src_points = generate_circle_samples_array(xc=simulated_src_xc,yc=simulated_src_yc,rotation=simulated_src_angle)\n",
    "dst_points = generate_circle_samples_array()\n",
    "\n",
    "\n",
    "\n",
    "# Find the affine transformation matrix\n",
    "transform_matrix = find_affine_transform(src_points, dst_points) \n",
    "print(\"Affine Transformation Matrix:\\n\", transform_matrix)\n",
    "\n",
    "circle.plot_data_circle(src_points,xc=0,yc=0,r=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xc, yc, r, sigma = circle.least_squares_circle(src_points)\n",
    "ic(xc, yc, r, sigma)\n",
    "transformed_points = [apply_transform([x,y],transform_matrix) for x,y in src_points]\n",
    "\n",
    "circle.plot_data_circle(transformed_points,xc=0,yc=0,r=r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example usage\n",
    "# Source and destination points (must be at least 3 pairs for affine transformation)\n",
    "\n",
    "src_points = np.array([\n",
    "    [1, 2],\n",
    "    [3, 4],\n",
    "    [5, 6]\n",
    "])\n",
    "\n",
    "dst_points = np.array([\n",
    "    [4, 5],\n",
    "    [2, 3],\n",
    "    [7, 8]\n",
    "])\n",
    "\n",
    "# Find the affine transformation matrix\n",
    "transform_matrix = find_affine_transform(src_points, dst_points)\n",
    "print(\"Affine Transformation Matrix:\\n\", transform_matrix)\n",
    "\n",
    "# Transform a new point\n",
    "new_point = [2, 3]\n",
    "transformed_point = apply_transform(new_point, transform_matrix)\n",
    "print(f\"Original point: {new_point}\")\n",
    "print(f\"Transformed point: {transformed_point}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform_point_dat(point, translation_vector, scale_factors, rotation_angle):\n",
    "    \"\"\"\n",
    "    Transforms a 2D point by scaling, rotating, and translating.\n",
    "\n",
    "    :param point: Tuple or list with the original x, y coordinates.\n",
    "    :param scale_factors: Tuple or list with the scaling factors for x and y.\n",
    "    :param rotation_angle: Rotation angle in radians.\n",
    "    :param translation_vector: Tuple or list with the translation values for x and y.\n",
    "    :return: Transformed (x, y) coordinates.\n",
    "    \"\"\"\n",
    "    # Convert the point to a NumPy array\n",
    "    point = np.array(point)\n",
    "    \n",
    "    # Create the scaling matrix\n",
    "    scale_matrix = np.array([\n",
    "        [scale_factors[0], 0],\n",
    "        [0, scale_factors[1]]\n",
    "    ])\n",
    "    \n",
    "    # Create the rotation matrix\n",
    "    rotation_matrix = np.array([\n",
    "        [np.cos(rotation_angle), -np.sin(rotation_angle)],\n",
    "        [np.sin(rotation_angle), np.cos(rotation_angle)]\n",
    "    ])\n",
    "    \n",
    "    # Apply scaling\n",
    "    scaled_point = np.dot(scale_matrix, point)\n",
    "    \n",
    "    # Apply rotation\n",
    "    rotated_point = np.dot(rotation_matrix, scaled_point)\n",
    "    \n",
    "    # Apply translation\n",
    "    transformed_point = rotated_point + np.array(translation_vector)\n",
    "    \n",
    "    return transformed_point\n",
    "\n",
    "# Example usage\n",
    "original_point = (1, 2)\n",
    "scale_factors = (2, 3)  # Scaling factors for x and y\n",
    "rotation_angle = np.pi / 4  # 45 degrees in radians\n",
    "translation_vector = (3, 4)  # Translation vector\n",
    "\n",
    "transformed_point = transform_point_dat(original_point, translation_vector, scale_factors, rotation_angle)\n",
    "print(f\"Original point: {original_point}\")\n",
    "print(f\"Transformed point: {transformed_point}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fixingPoint = circle_samples[0]\n",
    "translation = (-xc, -yc)\n",
    "scale = (1,1)\n",
    "rotation_adjust = np.pi/2\n",
    "ic(fixingPoint,translation, scale, rotation)\n",
    "#transformed_points = [transform_point((x,y), translation, scale, np.rad2deg(rotation_adjust)) for x,y in circle_samples]\n",
    "transformed_points = [transform_point_dat((x,y), translation, scale, rotation_adjust) for x,y in circle_samples]\n",
    "\n",
    "ic(xc,xc_offset)\n",
    "ic(yc,yc_offset)\n",
    "ic(rotation,rotation_adjust)\n",
    "circle.plot_data_circle(transformed_points, 0, 0, r)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example points\n",
    "#src_points = [(0, 0), (1, 0), (0, 1)]\n",
    "#dst_points = [(2, 3), (3, 3), (2, 4)]\n",
    "\n",
    "src_points = [(1.073488, -2.271037),(-0.387351, -1.991891),(1.363704, -0.797259)]\n",
    "dst_points = [(0, 0),(1.5, 0),(0, 1.5)]\n",
    "\n",
    "# Compute the transformation matrix\n",
    "transformation_matrix = ic(compute_transformation_matrix(src_points, dst_points))\n",
    "\n",
    "# Transform a point (x, y)\n",
    "point1 = (-2.179, -3.207)\n",
    "point2 = (-0.242, -2.690)\n",
    "point3 = (-0.773, -0.784)\n",
    "point4 = (-1.0,-1.0)\n",
    "\n",
    "for point in [point1, point2, point3, point4]:\n",
    "    transformed_point = ic(transform_point(point, transformation_matrix))\n",
    "\n",
    "#print(f\"Transformed Point: {transformed_point}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# Separate the points into x and y coordinates for plotting\n",
    "src_x, src_y = zip(*src_points)\n",
    "dst_x, dst_y = zip(*dst_points)\n",
    "\n",
    "# Create the plot\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(src_x, src_y, color='blue', label='Source Points')\n",
    "plt.scatter(dst_x, dst_y, color='red', label='Destination Points')\n",
    "\n",
    "# Add lines connecting corresponding points\n",
    "for i in range(len(src_points)):\n",
    "    plt.plot([src_points[i][0], dst_points[i][0]], [src_points[i][1], dst_points[i][1]], 'gray', linestyle='--')\n",
    "\n",
    "# Add labels and title\n",
    "plt.xlabel('X Coordinate')\n",
    "plt.ylabel('Y Coordinate')\n",
    "plt.title('Source and Destination Points')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def calculate_circle(points):\n",
    "    # Convert the list of points to a NumPy array\n",
    "    points = np.array(points)\n",
    "    \n",
    "    # Prepare the matrices for the least squares calculation\n",
    "    x = points[:, 0]\n",
    "    y = points[:, 1]\n",
    "    \n",
    "    # Calculate the coefficients using the least squares method\n",
    "    A = np.c_[x, y, np.ones(len(x))]\n",
    "    b = x**2 + y**2\n",
    "    \n",
    "    # Solve the equation A * [h, k, C] = b\n",
    "    coeffs = np.linalg.lstsq(A, b, rcond=None)[0]\n",
    "    \n",
    "    h, k, C = coeffs\n",
    "    # The radius is calculated from the center\n",
    "    r = np.sqrt(h**2 + k**2 + C)\n",
    "    \n",
    "    return h, k, r\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Example array of points on the circle\n",
    "points = np.array([\n",
    "    [1.2685409784317017,-1.2855279445648193],\n",
    "    [0.4610433280467987, -1.4789505004882812],\n",
    "    [0.10663176327943802, -2.030184745788574]\n",
    "])\n",
    "\n",
    "h, k, r = calculate_circle(points)\n",
    "\n",
    "print(f\"Center of the circle: ({h:.2f}, {k:.2f})\")\n",
    "print(f\"Radius of the circle: {r:.2f}\")\n",
    "print(f\"Circle equation: (x - {h:.2f})^2 + (y - {k:.2f})^2 = {r**2:.2f}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newPoints = [(0.1172790378332138, -2.0815389156341553), (0.13003531098365784, -2.0311286449432373), (0.1446872055530548, -1.980210781097412), (0.16282092034816742, -1.9294254779815674), (0.1850621998310089, -1.8782325983047485), (0.20989999175071716, -1.8281124830245972), (0.23808307945728302, -1.777306079864502), (0.2717342972755432, -1.7264182567596436), (0.3104494512081146, -1.6757774353027344), (0.35316213965415955, -1.6251628398895264), (0.4011218249797821, -1.5748447179794312), (0.451546311378479, -1.5388946533203125), (0.4983119070529938, -1.4879955053329468), (0.5429137945175171, -1.4376658201217651), (0.5934383869171143, -1.4096862077713013), (0.6442127823829651, -1.3851996660232544), (0.6945139765739441, -1.3694506883621216), (0.745102047920227, -1.3547362089157104), (0.7955855131149292, -1.3332085609436035), (0.8465850353240967, -1.317476511001587), (0.8975532650947571, -1.3095701932907104), (0.9483062624931335, -1.3017194271087646), (0.998540997505188, -1.2962006330490112), (1.0496501922607422, -1.294082522392273), (1.1003813743591309, -1.296460509300232), (1.1507503986358643, -1.2991588115692139), (1.2007719278335571, -1.2985177040100098), (1.2507834434509277, -1.3123250007629395)]\n",
    "src_x, src_y = zip(*newPoints)\n",
    "\n",
    "\n",
    "# Create the plot\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(src_x, src_y, color='blue', label='Source Points')\n",
    "\n",
    "# Add lines connecting corresponding points\n",
    "for i in range(len(src_points)):\n",
    "    plt.plot([src_points[i][0], dst_points[i][0]], [src_points[i][1], dst_points[i][1]], 'gray', linestyle='--')\n",
    "\n",
    "# Add labels and title\n",
    "\n",
    "plt.xlabel('X Coordinate')\n",
    "plt.ylabel('Y Coordinate')\n",
    "plt.title('Source and Destination Points')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first point in the array is (0,r) in FRC coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import circle_fit as circle\n",
    "\n",
    "points = [(0.37510570883750916, -0.8342843651771545), (0.3248334228992462, -0.8295403718948364), (0.2743622362613678, -0.826815664768219), (0.22401097416877747, -0.8275769352912903), (0.17294949293136597, -0.8313215374946594), (0.12292873114347458, -0.8372471332550049), (0.07161729037761688, -0.8454130291938782), (0.01786799728870392, -0.8572217226028442), (-0.03314237296581268, -0.8717595338821411), (-0.08444882184267044, -0.8877468109130859), (-0.1356864869594574, -0.909177303314209), (-0.1858465075492859, -0.931339681148529), (-0.23588553071022034, -0.9617758989334106), (-0.286144495010376, -1.0021570920944214), (-0.3378433287143707, -1.047621726989746), (-0.3886015713214874, -1.0919877290725708), (-0.4402550458908081, -1.1180927753448486), (-0.48958367109298706, -1.1719499826431274), (-0.5303281545639038, -1.2228316068649292), (-0.5668140053749084, -1.2742542028427124), (-0.6018678545951843, -1.3261003494262695), (-0.6521179676055908, -1.4362637996673584), (-0.6704638600349426, -1.4875242710113525), (-0.688291072845459, -1.5409655570983887), (-0.7009204030036926, -1.5936079025268555), (-0.7120699286460876, -1.64723539352417), (-0.7195438146591187, -1.699013352394104), (-0.7226626873016357, -1.7497444152832031), (-0.7238384485244751, -1.8031448125839233), (-0.7230956554412842, -1.853276252746582), (-0.7182620763778687, -1.9036403894424438), (-0.7122184634208679, -1.9541934728622437), (-0.7006244659423828, -2.011301279067993), (-0.6879056692123413, -2.063897132873535), (-0.674543559551239, -2.1150455474853516), (-0.6561917066574097, -2.1685309410095215), (-0.6420400142669678, -2.2203590869903564), (-0.6245172619819641, -2.2724807262420654), (-0.6038203835487366, -2.325279474258423), (-0.5710437297821045, -2.3755252361297607), (-0.5205249786376953, -2.4249510765075684), (-0.4698893129825592, -2.4555160999298096), (-0.42012810707092285, -2.506366729736328), (-0.3690338730812073, -2.5524473190307617), (-0.3183332085609436, -2.58925724029541), (-0.26611652970314026, -2.6258749961853027), (-0.21426011621952057, -2.654890537261963), (-0.16310039162635803, -2.6799442768096924), (-0.1130872517824173, -2.70158052444458), (-0.06033956632018089, -2.7201483249664307), (-0.007142858579754829, -2.736077070236206), (0.04541667550802231, -2.749640464782715), (0.096783347427845, -2.7590763568878174), (0.14940038323402405, -2.764655351638794), (0.20081856846809387, -2.7684860229492188), (0.2514599561691284, -2.7703349590301514), (0.30442681908607483, -2.7689523696899414), (0.35688185691833496, -2.7641441822052), (0.40710821747779846, -2.756194829940796), (0.4572412967681885, -2.7465760707855225), (0.5080640316009521, -2.734013080596924), (0.5590968728065491, -2.7164647579193115), (0.6093403100967407, -2.6901438236236572), (0.6608644127845764, -2.6637051105499268), (0.7123205065727234, -2.6389217376708984), (0.7634175419807434, -2.612981081008911), (0.8140966296195984, -2.5843396186828613), (0.8642556071281433, -2.547771453857422), (0.9158142805099487, -2.507453441619873), (0.9576622843742371, -2.456725597381592), (1.0026576519012451, -2.4065487384796143), (1.0446642637252808, -2.355674982070923), (1.0769941806793213, -2.3046677112579346), (1.1121665239334106, -2.2537355422973633), (1.1342887878417969, -2.203183889389038), (1.156294584274292, -2.1523985862731934), (1.174515724182129, -2.101193428039551), (1.1899540424346924, -2.0509696006774902), (1.2030394077301025, -1.998249888420105), (1.2121891975402832, -1.9468461275100708), (1.220396637916565, -1.8967406749725342), (1.2249929904937744, -1.8452216386795044), (1.2259081602096558, -1.7935140132904053), (1.2241673469543457, -1.74313223361969), (1.221623182296753, -1.6927318572998047), (1.2108800411224365, -1.6426976919174194), (1.2041176557540894, -1.5926928520202637), (1.194579839706421, -1.5421632528305054), (1.1786274909973145, -1.4920830726623535), (1.1577316522598267, -1.4420266151428223), (1.1334922313690186, -1.3864538669586182), (1.1093885898590088, -1.3352971076965332), (1.0833134651184082, -1.284781813621521), (1.0501214265823364, -1.2347010374069214), (1.0109409093856812, -1.184482455253601), (0.9670594334602356, -1.1338047981262207), (0.9165676832199097, -1.083878993988037), (0.8657959699630737, -1.0387115478515625), (0.8151199817657471, -1.0030828714370728), (0.7638719081878662, -0.9683163166046143), (0.7132079601287842, -0.9434131979942322), (0.6623708605766296, -0.9125620722770691), (0.6112207174301147, -0.8934564590454102), (0.559902012348175, -0.8762336373329163), (0.509800374507904, -0.8607336282730103), (0.45836520195007324, -0.8442651033401489), (0.4077111482620239, -0.8379084467887878), (0.35752221941947937, -0.8308752775192261), (0.3063535988330841, -0.8252866864204407), (0.2535272240638733, -0.8263100385665894), (0.20282530784606934, -0.8290849328041077)]\n",
    "xc, yc, r, sigma = circle.standardLSQ(points)\n",
    "print(sigma)\n",
    "print(xc,yc,r)\n",
    "circle.plot_data_circle(points,xc,yc,r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "circle.plot_data_circle(points,0,0,r)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "3fcbd7240ee8f908d933dc7f71e8c42a1a91163b70ede8dcff5146d4087436c7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}