Optimize Center of Circle given noisy data points on arbitrary Plane

I don't seem to find an algorithm to calculate the center of a circle given a set of noisy data (on the circumference of the circle) on an arbitrary Plane in 3D.
I did try different approached as to calculating the center by only taking 3 points at a time and then averaging the centers, yet I believe there must be a better solution to optimize the center by minimizing the distance to all points.
Does anyone have an Idea?

Any Ideas or approaches would be highly appreciated!

Finally I found several Solutions adjusting my search terms:

<https://de.mathworks.com/matlabcentral/answers/475212-circle-least-squares-fit-for-3d-data>

<https://jekel.me/2015/Least-Squares-Sphere-Fit/>

Both Approaches work very well. In the second link you have to calculate the plane first, which can be done using SVD. Basically I think both approaches are very similar and produce basically the same results.

Here's how I do it:

I have an auxiliary structure (called Aprox) that contains Center, Radius (I use its square for speed optimization) and Boundary points (two or three).

I have the following functions:

CircumscribedCircle_2Points(P1, P2):Aprox (center of the line segment in 3D)

CircumscribedCircle_3Points(P1, P2, P3):Aprox (center of the circle traced ), programmed by https://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates_from_cross-_and_dot-products

CircumscribedCircle_IsIn($Aprox, $Pnt):boolean (It is in the given Approx)

I compute Aprox from the first two points and then run through the other points. If it's in circle I do nothing, if it's out I calculate a new Aprox and run through again (all points).
The rule is: If there are 4 points in the plane, one of them is always inside the circle given by the other three.

function CircumscribedCircle_2Points($P1, $P2,
  $Aprox=[])
{
$Aprox = as_New('Borders', [$P1, $P2]);
$Aprox['Center'] = v3d_AvgV3($P1, $P2);
$Aprox['RadSq'] = v3d_mV3AbsKv($Aprox['Center'], $P1);
$Aprox['RadSq'] = $Aprox['RadSq'] + 0.0001; //Float rounding errors
return $Aprox;
}

function CircumscribedCircle_3Points($P1, $P2, $P3,
  $Aprox=[],$JmP=0,$Jm=0,$u1=0,$u2=0,$u3=0)
//https://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates_from_cross-_and_dot-products
{
$Aprox = as_New('Borders', [$P1, $P2, $P3]);
$JmP = v3d_Abs(v3d_vxV3(v3d_mV3($P1,$P2),v3d_mV3($P2,$P3)));
$Jm = 2 * $JmP**2;
$u1 = v3d_mV3AbsKv($P2,$P3) * v3d_sxV3(v3d_mV3($P1,$P2),v3d_mV3($P1,$P3)) / $Jm;
$u2 = v3d_mV3AbsKv($P1,$P3) * v3d_sxV3(v3d_mV3($P2,$P1),v3d_mV3($P2,$P3)) / $Jm;
$u3 = v3d_mV3AbsKv($P1,$P2) * v3d_sxV3(v3d_mV3($P3,$P1),v3d_mV3($P3,$P2)) / $Jm;
$Aprox['Center'] = v3d_pV3pV3(v3d_xSkl($P1,$u1), v3d_xSkl($P2,$u2), v3d_xSkl($P3,$u3));
$Aprox['RadSq'] = v3d_mV3AbsKv($P1,$P2) * v3d_mV3AbsKv($P2,$P3) * v3d_mV3AbsKv($P3,$P1) / (2*$JmP)**2;
$Aprox['RadSq'] = $Aprox['RadSq'] + 0.0001; //Float rounding errors
return $Aprox;
}

function CircumscribedCircle_IsIn($Aprox, $Pnt)
{
return v3d_mV3AbsKv($Aprox['Center'], $Pnt) <= $Aprox['RadSq'];
}


function CircumscribedCircle_SetAprox($Aprox, $Pnt,
  $HrLen=0,$i=0,$TestAprox=[],$Ok=true,$j=0, $TestRet=[])
{
$HrLen=ar_Count($Aprox['Borders']); //2 or 3
for ($i=0; $i<$HrLen; $i++)
  {
  $TestAprox = CircumscribedCircle_2Points($Aprox['Borders'][$i], $Pnt);
  $Ok = true;
  for ($j=0; $j<$HrLen; $j++)
    {
    if ($i==$j) continue;
    if (CircumscribedCircle_IsIn($TestAprox, $Aprox['Borders'][$j])) continue;
    $Ok = false;
    break;
    }
  if ($Ok) return $TestAprox;
  }
if ($HrLen==2)
  {
  return CircumscribedCircle_3Points($Aprox['Borders'][0], $Aprox['Borders'][1], $Pnt);
  }
$TestRet = ar_New();
$TestAprox = CircumscribedCircle_3Points($Aprox['Borders'][0], $Aprox['Borders'][1], $Pnt);
if (CircumscribedCircle_IsIn($TestAprox, $Aprox['Borders'][2])) ar_Push($TestRet, $TestAprox);
$TestAprox = CircumscribedCircle_3Points($Aprox['Borders'][0], $Aprox['Borders'][2], $Pnt);
if (CircumscribedCircle_IsIn($TestAprox, $Aprox['Borders'][1])) ar_Push($TestRet, $TestAprox);
$TestAprox = CircumscribedCircle_3Points($Aprox['Borders'][1], $Aprox['Borders'][2], $Pnt);
if (CircumscribedCircle_IsIn($TestAprox, $Aprox['Borders'][0])) ar_Push($TestRet, $TestAprox);
ar_Sort($TestRet, function($a, $b){return $a['RadSq']-$b['RadSq'];});
return $TestRet[0];
}

function CircumscribedCircle($Arr,
  $Aprox=[], $i=0, $l=0, $max=0)
{
$Aprox = CircumscribedCircle_2Points($Arr[0], $Arr[1]);
for ($i=0, $l=ar_Count($Arr); $i<$l; $i++)
  {
  if (CircumscribedCircle_IsIn($Aprox, $Arr[$i])) continue;
  $Aprox = CircumscribedCircle_SetAprox($Aprox, $Arr[$i]);
  if (!$Aprox) return false;
  $i=-1;
  }
return as_New('Center',$Aprox['Center'], 'Radius', nm_Sqrt($Aprox['RadSq']));
}

//-------------------------
in JS
const x = 0;
const y = 1;
const z = 2;
in PHP
define('x', 0);
define('y', 1);
define('z', 2);

function v3d_AvgV3($v, $w)
//Diameter of two vectors (center of the line segment)
{
return ar_New(($v[x]+$w[x])/2, ($v[y]+$w[y])/2, ($v[z]+$w[z])/2);
}

function v3d_Abs($v)
//Absolute vector size
{
return nm_Sqrt($v[x]**2 + $v[y]**2 + $v[z]**2);
}

function v3d_vxV3($v,$w)
//Vector product
{
return ar_New($v[y]*$w[z]-$w[y]*$v[z], $v[z]*$w[x]-$w[z]*$v[x], $v[x]*$w[y]-$w[x]*$v[y]);
}

function v3d_mV3Abs($v, $w)
//Vector difference
{
return nm_Sqrt(($v[x]-$w[x])**2 + ($v[y]-$w[y])**2 + ($v[z]-$w[z])**2);
}

function v3d_mV3AbsKv($v, $w)
//Square of vector difference
{
return ($v[x]-$w[x])**2 + ($v[y]-$w[y])**2 + ($v[z]-$w[z])**2;
}

function v3d_sxV3($v,$w)
//Scalar product
{
return $v[x]*$w[x] + $v[y]*$w[y] + $v[z]*$w[z];
}

function v3d_pV3pV3($v,$w,$u)
//Sum 3 3D vect
{
return ar_New($v[x]+$w[x]+$u[x], $v[y]+$w[y]+$u[y], $v[z]+$w[z]+$u[z]);
}

function v3d_xSkl($v,$k)
//3D vect multiple scalar
{
return ar_New($v[x]*$k, $v[y]*$k, $v[z]*$k);
}

The code is universal and works both in PHP and Javascript I declare auxiliary variables as optional parameters (to avoid using var keyword)

as_* are functions related to associative arrays, ar_* are functions related to numeric arrays, nm_* is numeric and their function is clear from their name. v3d_* are functions related to 3d vectors and are listed in the footnote.

Translated with www.DeepL.com/Translator (free version)