算法 on 醉后的星星

Bezier曲线、B样条曲线、NURBS曲线

Mon, 25 Oct 2021 12:37:00 +0000

Bezier曲线

定义：对于n+1个控制点V_i(i=0,1,2,…,n)V_i(i=0,1,2,…,n)，n次Bezier曲线为： $$ \begin{align} P_n(t) &= \sum_{i=0}^{n} B_{n,i}(t)V_i,0\le t\le 1v \ B_{n,i} &=\frac{n!}{(n-i)!i!}(1-t)^{n-i}t^i \end{align} $$ 其中B_{n,i}B_{n,i}称为n次Bernstein基函数。例如，当n=3时，即3次Bezier曲线为：; $$ \begin{align} P_3(t) &= B_{3,0}(t)V_0+B_{3,1}(t)V_1+B_{3,2}(t)V_2+B_{3,3}(t)V_3,0\le t\le 1v \ B_{3,i} &= \left{\begin{matrix} B_{3,0}(t)=(1-t)^3 \ B_{3,1}(t)=3(1-t)^2t \ B_{3,2}(t)=3(1-t)t^2 \ B_{3,3}(t)=t^3 \end{matrix}\right. \end{align} $$

性质

两端重合：Bezier曲线和控制多边形起始两端点重合，P(0)=V_0,P(1)=V_nP(0)=V_0,P(1)=V_n
两端相切：Bezier曲线和控制多边形起始两端点相切，且切矢模长为n倍，P’(0)=n(V_1-V_0),P’(1)=n(V_n-V_{n-1})P’(0)=n(V_1-V_0),P’(1)=n(V_n-V_{n-1})
对称性：控制点反序够早的曲线一致，只是参数化相反
凸包性：曲线落在控制多边形形成的凸包内
几何不变形：曲线仅取决于控制点，与坐标系无关

递归分割de Casteljau算法 在控制多边形每条边上按比例t:(1-t)进行分割，初始n+1个点，第一次分割得到n个点，n个点连起来组成新的控制点，第二次分割得到n-1个点，直到最后只剩一个点，该点即Bezier曲线上的点。 de Casteljau建立的递归公式如下： $$ \begin{array}{c} \left{\begin{matrix} &V_i^r(t) = (1-t)V_i^{r-1}+tV_{i+1}^{r-1} ,r = 0,1,2,…,n\ &V_i^0(t) = V_i,i = 0,1,2,…,n \end{matrix}\right. \end{array} $$ 该方法适合于编程几何作图。

有理Bezier曲线

定义：比Bezier曲线多了个顶点权重系数，至于哪里有理了不清楚。 $$ P_(t)=\frac{\sum_{i=0}^{n}B_{n,i}(t)w_iV_i}{B_{n,i}(t)w_i} , 0\le t\le 1 $$ 例如，3次有理Bezier曲线表示为： $$ P_3(t)=\frac{(1-t)^3w_0V_0+3t(1-t)^2w_1V_1+3t^2(1-t)w_2V_2+t^3w_3V_3}{(1-t)^3w_0+3t(1-t)^2w_1+3t^2(1-t)w_2+t^3w_3} $$ 权重$w_i$可以一般取大于零的实数。

递归分割Farin算法 和上述过程类似： $$ \begin{array}{c} \left{\begin{matrix} &V_i^r(t) = (1-t)\frac{W_i^{r-1}(t)}{W_i^r(t)} V_i^{r-1}+t\frac{W_{i-1}^{r-1}(t)}{W_i^r(t)}V_{i+1}^{r-1} ,r = 0,1,2,…,n\ &V_i^0(t) = V_i,i = 0,1,2,…,n \end{matrix}\right.\ \left{\begin{matrix} W_i^0=w_i \ W_i^r(t)=\sum_{j=0}^{r}W_{i+j}^{r-1}B_{r,j}(t),r=1,2,…,n \end{matrix}\right. \end{array} $$

B样条方法

B样条方法是Bezier方法的的一种一般化，给定n+1个控制点和阶次k，以及节点向量${t_0,t_1,…,t_{n+k+1}}$: $$ \begin{array}{c} P_n(t) = \sum_{i = 0}^{n}N_{i,k}(t)V_i=\sum_{i = j-k}^{j}N_{i,k}(t)V_i,t_j\le t\le t_{j+1}\ N_{j,0}=\left{\begin{matrix} 1,t_j\le t\le t_{j+1} \ 0,otherwise \end{matrix}\right.\ N_{i,k}(t)=\frac{t-t_i}{t_{i+k}-t_i}N_{i,k-1}(t)+\frac{t_{i+k+1}-t}{t_{i+k+1}-t_{i+1}} N_{i+1,k-1}(t) \end{array}\ *约定 frac{0}{0}=0 $$ 其中$N_{i,k}(t)$为k阶( k-1次 )B样条基函数，${t_0,t_1,…,t_{n+k+1}}$为节点矢量，B样条按其节点矢量分布可分为以下三类：

均匀B样条：均匀分布或等距分布。
准均匀分布：与均匀B样条区别在于两端端点为重节点。
非均匀B样条：任意分布。例如三次均匀B样条基函数为： $$ \left{\begin{matrix} N_{0,3}(t)=\frac{1}{6}(1-t)^3 \ N_{1,3}(t)=\frac{1}{6}(3t^3-6t^2+4) \ N_{2,3}(t)=\frac{1}{6}(-3t^3+3t^2+3t+1) \ N_{3,3}(t)=\frac{1}{6}t^3 \end{matrix}\right. $$ B样条具有局部性：改变一个控制点时，只会对附近曲线段的形状产生影响。对于一个k次的n+1个控制点的B样条，当k=n时，退化为Bezier曲线。

NURBS方法

NURBS曲线全称非均匀有理B样条，是B样条的一般化，非均匀指节点的选取可以是不均匀的，有理主要体现在每个控制点有个权因子。 $$ R_n(t)=\frac{\sum_{i=0}^{n}N_{i,k}(t)w_iV_i}{N_{i,k}(t)w_i} $$

参考

https://blog.csdn.net/johnhany/article/details/8830928 《形状可调的参数曲线曲面造型方法研究》《Bezier曲线曲面的造型设计理论研究》

最小二乘法和移动最小二乘法

Thu, 14 Oct 2021 10:59:00 +0000

已知未知系数的方程$ f(x)=p(x)^{T}\alpha $，以及一系列数据点$(x_{i},y_{i})$，其中$p(x)$是基函数，$\alpha$是系数向量，求解该方程的系数向量，使得损失函数$J=\sum_{i=0}^{n} (f(x_{i})-y_{i})^2$值最小。联立所有方程，一般是一个超定方程组（等式个数大于未知数），一般可以表示为$Ax=b$形式，这里的$x$是指待求系数。以方程$f(x)=a+bx+cx^{2}$为例，可以表示成如下形式： $$ \begin{bmatrix} 1 & x_{1} & x_{1}^{2}\ 1 & x_{2} & x_{2}^{2}\ … & … & …\ 1 & x_{n} & x_{n}^{2} \end{bmatrix} \begin{bmatrix} a\ b\ c \end{bmatrix}

\begin{bmatrix} y_{1}\ y_{2}\ …\ y_{n} \end{bmatrix} $$

求解上述问题，可以有两种思路，一种是从投影的角度，另一种是对损失函数求偏导数令其等于0。结果都是$x=(A^{T}A)^{-1}A^{T}b$，用法线方程法公式计算有个前提就是式中有个逆矩阵，必须保证可逆，否则得用别的方法求解。
上述方法解出来的解误差分布不一定理想，可以通过计算$Cond(A^TA)$条件数判断方程是否是病态的，必要时可以考虑QR分解等解法。
如果方程自变量个数不止一个，或者方程形式较复杂，一般都是通过化简和变量组合向上面的线性形式凑齐然后求解。
至于为什么损失函数是平方和，需要从概率论角度解释，大概意思是残差满足正态分布的最大似然估计就是最小二乘形式。

移动最小二乘法MLS (Moving Least Square)

MLS的拟合方程：$f(x)=p(x)^{T}\alpha(x)$，其中$p(x)$是基函数列向量，$\alpha(x)$不再是常数，而是基于$x$的函数。常见的基函数有线性基：$[1,x]^T$，二次基：$[1,x,x^2]^T$，三次基：$[1,x,x^2，x^3]^T$，而$\alpha(x)$是我们欲求的未知函数。另外MLS引入了紧支概念：即某点处的函数值只受附近点的影响，或者说每个数据点只对自己影响区域内的拟合结果有影响，由此引入权函数$w(x)$，此时损失函数为$J=\sum_{i=0}^{n} w(x-x_i)(f(x_{i})-y_{i})^2=\sum_{i=0}^{n} w(x-x_i)(p(x)^{T}\alpha(x)-y_{i})^2$。比如三次样条函数权函数如下： $$ \begin{array}{c} s=\frac{|x-x_i|}{r}\ w(s)=\left{\begin{matrix} \frac{2}{3}-4s^2+4s^3, &s\le 0.5 \ \frac{4}{3}-4s+4s^2-\frac{4s^2}{3}, &0.5<s\le1\ 0,& s>1 \end{matrix}\right. \end{array} $$ 其中$r$表示影响范围半径。对损失函数求偏导等于0可得$\alpha(x)$： $$ \begin{align} \frac{\partial J}{\partial \alpha(x)} &= A(x)\alpha(x)-B(x)y = 0 \ \alpha(x) &= A^{-1}(x)B(x)y \ & 其中: \ w_i(x) &= w(\frac{|x-x_i|}{r})\ P &= \begin{bmatrix} p_1(x_1)& p_2(x_1)& …& p_m(x_1)\ p_1(x_2)& p_2(x_2)& …& p_m(x_2)\ …& …& …& …\ p_1(x_n)& p_2(x_n)& …& p_m(x_n) \end{bmatrix}\ w(x) &= \begin{bmatrix} w_1(x) & 0& …& 0\ 0& w_2(x)& …& 0\ …& …& …& …\ 0& 0& …& w_n(x) \end{bmatrix}\ A(x) &= P^TW(x)P \ B(x) &= P^TW(x) \ \end{align} $$

权函数$w(s)$应该是非负的，并伴随着$||x-x_i||_2$增大而减小。
实际应用过程中，取不同基函数可以获得不同的拟合精度，取不同的权函数可以获得不同的平滑度。
一般基函数次数越高，曲线越平滑；影响半径越大，曲线越平滑。
影响半径不能太小，太小的话局部点数不够会造成奇异矩阵不可解。

参考

最小二乘： https://zhuanlan.zhihu.com/p/38128785 https://www.zhihu.com/question/37031188/answer/2041682439 https://ww2.mathworks.cn/help/matlab/ref/lsqr.html 移动最小二乘： https://wenku.baidu.com/view/fe7a74976f1aff00bed51eb1.html https://www.doc88.com/p-8778611828185.html https://www.freesion.com/article/7962225749/ https://www.freesion.com/article/991733680/ https://www.doc88.com/p-8778611828185.html https://d.wanfangdata.com.cn/periodical/szjsyyy201510082

各种排序算法的Python实现

Thu, 15 Apr 2021 07:26:00 +0000

注：排序算法的稳定性指相等的元素在排序前后相对位置是否变化，稳定排序主要用于不同键值比较，比如ACM成绩排序，先按分数排序，相同分数再按用时最短排序。

冒泡排序

不断比较相邻元素，每次遍历将最大值移至队尾。

def bubble(arr):
 swapped = True
 end = len(arr)
 while swapped:
 swapped = False
 for i in range(1, end):
 if arr[i-1] > arr[i]:
 arr[i-1], arr[i] = arr[i], arr[i-1]
 swapped = True
 end -= 1
 return arr

选择排序

每次遍历找到一个最小值，将其移至队首。

def selection(arr):
 for start in range(len(arr)-1):
 mini = start
 for i in range(start+1, len(arr)):
 if arr[i] < arr[mini]:
 mini = i
 arr[start], arr[mini] = arr[mini], arr[start]
 return arr

插入排序

很像打麻将，每摸到一张牌，就依次比较将其插入正确的位置。

def insertion(arr):
 for cur in range(len(arr)):
 for i in range(cur-1, -1, -1):
 if arr[cur] < arr[i]:
 arr[cur], arr[i] = arr[i], arr[cur]
 cur = i
 else:
 break
 return arr

归并排序

分分合合

def merge(arr):
 l = len(arr)
 if l <= 1:
 return arr
 arrleft = merge(arr[:l//2])
 arright = merge(arr[l//2:])
 res = []
 while arrleft or arright:
 if arrleft and arright:
 res.append(arrleft.pop(
 0) if arrleft[0] < arright[0] else arright.pop(0))
 elif arrleft:
 res.append(arrleft.pop(0))
 elif arright:
 res.append(arright.pop(0))
 return res

快速排序

选一个基准，然后将基准放在正确的位置上，并保证左边比基准小，右边比基准大，再一直递推下去。

def quick(arr):
 def _quick(i, j):
 if i >= j:
 return
 # 这里选取左端点为参考点
 pivot = arr[i]
 low = i
 high = j
 while i != j:
 # 从右往左 找小于pivot的
 while i < j and arr[j] >= pivot:
 j -= 1
 arr[i] = arr[j]
 # 从左往右 找大于pivot的
 while i < j and arr[i] <= pivot:
 i += 1
 arr[j] = arr[i]
 arr[i] = pivot
 _quick(low, i-1)
 _quick(i+1, high)
 return arr
 return _quick(0, len(arr)-1)

堆排序

每次将堆顶元素和最后一个元素交换，交换后上浮

class HeapSort:
 def __init__(self, arr):
 self.arr = arr
 self.len = len(arr)
 for i in range(len(arr)//2, -1, -1):
 self.heapify(i)

 def heapify(self, i):
 left = 2*i+1
 right = 2*i+2
 largest = i
 if left < self.len and self.arr[left] > self.arr[largest]:
 largest = left
 if right < self.len and self.arr[right] > self.arr[largest]:
 largest = right

 if largest != i:
 self.swap(i, largest)
 self.heapify(largest)

 def swap(self, a, b):
 self.arr[a], self.arr[b] = self.arr[b], self.arr[a]


def heapSort(arr):
 heapq = HeapSort(arr)
 for i in range(len(arr)-1, 0, -1):
 heapq.swap(0, i)
 heapq.len -= 1
 heapq.heapify(0)
 return heapq.arr

计数排序

统计每个数字出现的次数，然后依次取出，适合都是整数且数字集中的场景。

def count(arr):
 if not arr:
 return arr
 minn = min(arr)
 maxn = max(arr)
 dic = {n: 0 for n in range(minn, maxn+1)}
 for n in arr:
 dic[n] += 1
 res = []
 for n in range(minn, maxn+1):
 res += [n]*dic[n]
 return res

基数排序

先创建10个队列（0~9桶），先按个位放入桶中，然后依次清空桶，然后是十位… 适合整数，数据跨度较大的场景。

def radix(arr):
 buckets = [[] for _ in range(10)]
 flag = True
 rad = 1
 while flag:
 flag = False
 for n in arr:
 buckets[n // rad % 10].append(n)
 if not flag and n % rad < n:
 flag = True
 i = 0
 for bucket in buckets:
 while bucket:
 arr[i] = bucket.pop(0)
 i += 1
 rad *= 10
 return arr

桶排序

每个桶有不同的范围，桶内有自己的排序算法

参考

https://visualgo.net/zh/sorting

数据结构与算法

Tue, 02 Mar 2021 08:36:00 +0000

查询：O(1) 插入：O(n) 删除：O(n)

链表

查询：O(n) 插入：O(1) 删除：O(1)

迭代
递归

环判断

set判重
快慢指针

栈Stack

先进后出(FILO)

单调栈

下一个更大的数

队列Queue

先进先出(FIFO)

from collections import deque
q = deque()
q.append(1)
q.append(2)
q.append(3)
q.popleft()
q.pop()

堆

log(n)

import heapq
# 小顶堆
heap0 = []
heapq.heappush(heap0, 5)
heapq.heappush(heap0, 4)

heap1 = [5, 2, 3, 4]
heapq.heapify(heap1)

# 优先队列
heap2 = []
heapq.heappush(heap2, (5, '5'))
heapq.heappush(heap2, (4, '4'))


print(heapq.heappop(heap0)) # 出堆
print(heapq.heappushpop(heap0, 0)) # 先压后弹
print(heapq.heapreplace(heap0, 0)) # 先弹后压

# 大顶堆，没法push，一般用小顶堆相反数
data = [1, 5, 3, 2, 8, 5]
heapq._heapify_max(data)

# 优先队列，可以用heapq实现，也可以用下面的同步方法
from queue import PriorityQueue

二叉堆

父节点的权值不大于儿子的权值（小顶堆），可以用数组存储数据

单调队列

固定大小滑动窗口，获取最值。单独看 push 操作的复杂度确实不是 O(1)，但是算法整体的复杂度依然是 O(N) 线性时间。要这样想，nums 中的每个元素最多被 push_back 和 pop_back 一次，没有任何多余操作，所以整体的复杂度还是 O(N)。单调队列

映射Map

HashMap/TreeMap 无序/有序

from collections
# 有序字典
ordmap = collections.OrderedDict()
ordmap.move_to_end(key)
ordmap.popitem(last=False)
# 计数字典
countmap = collections.Counter()
# 访问不存在的key时自动添加key值为默认值
defaultdict([int,list,set,str,dict])

散列冲突：分离链接、线性探查

集合Set

HashSet/TreeSet

set_a = set('12345')
set_b = set(['1', '2', '3', '4', '5', '5'])
set_c = {1, 2, 3, 4, 5, 5}
set_d = set(set_a)
set_a.add('6')
set_a.update(['1', '2']) # 可以添加列表、集合等
set_a.remove('1') # 元素不存在会报错
set_a.discard('1') # 元素不存在不会报错
print(set_a-set_b)
print(set_a | set_b)
print(set_a & set_b)
print(set_a ^ set_b)

树Tree

二叉树-完全二叉树-满二叉树

二叉搜索树BST

左子树小于根节点 右子树大于根节点左右子书满足二叉搜索树

遍历

前序pre：根-左-右中序in：左-根-右升序返回后续post：左-右-根中序遍历的两种写法

# 递归
def inorder(root):
if root:
inorder(root.left)
print(root.val)
inorder(root.right)
# 迭代
stack = []
while root or stack:
while root:
stack.append(root)
root = root.left
root = stack.pop()
print(root.val)
root = root.right

字典树/前缀树Trie

图Graph

广度优先搜索BFS

最短路径问题

狄克斯特拉算法

有向无环加权图最小开销问题

深度优先搜索DFS

递归

重复计算->效率低

分治

贪心

剪枝-回溯

位运算

x^0=X x^x=0 x&1==0or1 #判断奇偶 x=x&(x-1) #清零最低位1 x&(-x) #取最低位的1 补码=反码+1

动态规划

NP完全问题

旅行商问题集合覆盖问题

并查集

数组实现

LRU/LFU Cache 缓存替换算法

双链表实现

布隆过滤器

判断在不在，肯定不在/应该在

计算空间三角形面积

Sat, 26 Dec 2020 13:14:00 +0000

一直空间散点坐标值，计算三点组成三角形的面积。

方法1

利用矩阵来计算这里是否需要加绝对值？

import numpy as np
def area(p):
 p1, p2, p3 = p
 a = [[1, 1, 1],
 [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]],
 [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]]]
 s = 0.5 * np.linalg.det(a)
 return s

方法2

利用海伦公式

def heron(p):
 p1, p2, p3 = p
 a = ((p1[0]-p2[0])**2+((p1[1]-p2[1]))**2+((p1[2]-p2[2]))**2)**0.5
 b = ((p1[0]-p3[0])**2+((p1[1]-p3[1]))**2+((p1[2]-p3[2]))**2)**0.5
 c = ((p2[0]-p3[0])**2+((p2[1]-p3[1]))**2+((p2[2]-p3[2]))**2)**0.5
 l = (a+b+c)/2
 s = (l*(l-a)*(l-b)*(l-c))**0.5
 return s

单层离散Hopfield神经网络(DHNN)程序实现

Fri, 03 Jul 2020 08:09:00 +0000

DHNN网络由n个神经元组成，每个神经元取值为1或-1。

每个神经元既是输入，也是输出，如果采用异步更新的策略，每次只更新一个神经元，更新顺序可以任意。激活函数为符号函数，大于等于零激活为1，反之为-1，每个神经元没有自反馈，即权重矩阵对角线为零。

DHNN输入一个值后，神经元状态不断更新后最终会收敛于某个“吸引子”。“吸引子”就是网络存储的记忆，是通过网络权重存储的。网络权重的计算方法一般有下面两种：联立方程求解法和外积和法。一般后面的方法用得较多。 DHNN网络是批学习网络，一次性输入样本一次性学习。输入的样本即“吸引子”，若样本值两两正交，则网络最稳定，理论上样本数上限为n。但一般很难做到两两正交，减少样本数（p<0.14n）可以提高抗畸变性，否则会出现“伪吸引子”。

DHNN网络可以靠下面的能量函数判断收敛状态，随着网络更新，能量函数处于递减趋势。

程序实现

下面是一个简单的python实现程序，可以输入简单样本和预测目标后进行不断更新。 [button color=“primary” icon=“fa fa-github” url=“https://github.com/kizx/DHNN” type=""]Github地址[/button]

# -*- coding: utf-8 -*-
import numpy as np
import time


def sgn(x):
 """激活函数"""
 y = 1 if x >= 0 else -1
 return y


class DHNN:
 def __init__(self, v0, tra):
 """初始化"""
 self.n = np.size(v0) # 神经元个数
 self.W = np.diag(np.zeros(self.n)) # 权矩阵 对角线元素为零的对称矩阵
 self.V = v0 # 神经元状态 取值:{-1,1}
 self.Ip = np.zeros(self.n) # 偏置矢量
 self.T = np.zeros(self.n) # 阈值矢量
 self.train(tra)

 def update(self, i):
 """网络更新"""
 net = np.dot(self.V, self.W[:, i]) + self.Ip[i] - self.T[i]
 self.V[i] = sgn(net)
 E = -1 / 2 * np.dot(np.dot(self.V.T, self.W), self.V) - np.dot(self.Ip.T, self.V) + np.dot(self.T.T, self.V)
 # print('能量', E)
 # print('状态', self.V)
 return E, sgn(net)

 def train(self, sample):
 """网络权重计算（记忆存储）"""
 S = sample
 for i in range(self.n):
 for j in range(self.n):
 delta = 1 if i == j else 0
 a = []
 for m in S:
 a_ = m[i] * m[j]
 a.append(a_)
 self.W[i, j] = (1 - delta) * np.sum(a)
 print('权重\n', self.W)


if __name__ == '__main__':
 St = np.array([[-1, -1, 1, 1],
 [-1, 1, 1, -1]])
 test = DHNN(np.array([1, 1, -1, 1]), St)
 while True:
 time.sleep(1)
 test.update(3)

上面这个程序我还做了一个gui界面用于上课演示。当我将上面的程序用于手写数字识别时，图片采用16*16共256个神经元，当样本数量小于4个时，还有点效果，当样本数多了之后，某些“伪吸引子”和样本的吸引力实在太强导致网络效果极差。想必用于实际用途需要更多的改进算法。

参考

https://zhuanlan.zhihu.com/p/144624580 https://blog.csdn.net/qq_41185868/article/details/80789989 https://blog.csdn.net/weixin_42398658/article/details/84027012 https://space.bilibili.com/529985682/video

点云球面最小二乘拟合的python实现

Wed, 29 Apr 2020 04:44:00 +0000

现有近似分布在球面上的点云，试进行球面拟合，求出球心坐标和半径。

解

球面方程为： $$ (x-x_0)^{2}+(y-y_0)^{2}+(z-z_0)^{2}=r^{2} $$ 其中 $ x_0, y_0, z_0, r $是我们要求的参数。

利用求偏导的方式求最小值

构造方程： $$ E(x_0,y_0,z_0,r)=\sum_{i=0}^n((x-x_0)^2+(y-y_0)^2+(z-z_0)^2-r^2)^2 $$ 使方程 $E$ 值最小的参数 $x_0, y_0, z_0, r$ 就是我们的所求。求偏导并使其等于0： $$ \frac{\partial E}{\partial x_0}=-4\sum_{i=0}^n(x_i-x_0)((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$ $$ \frac{\partial E}{\partial y_0}=-4\sum_{i=0}^n(x_i-y_0)((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$ $$ \frac{\partial E}{\partial z_0}=-4\sum_{i=0}^n(z_i-z_0)((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$ $$ \frac{\partial E}{\partial r}=-4\sum_{i=0}^nr((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$

化简得： $$ \sum_{i=0}^nx_i((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$ $$ \sum_{i=0}^ny_i((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$ $$ \sum_{i=0}^nz_i((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$ $$ \sum_{i=0}^n((x_i-x_0)^2+(y_i-y_0)^2+(z_i-z_0)^2-r^2)=0 $$

整理得： $$ \frac{\overline{x^3}}{\overline{x}}-2x_0\frac{\overline{x^2}}{\overline{x}}+x_0^2+\frac{\overline{xy^2}}{\overline{x}}-2y_0\frac{\overline{xy}}{\overline{x}}+y_0^2+\frac{\overline{xz^2}}{\overline{x}}-2z_0\frac{\overline{xz}}{\overline{x}}+z_0^2=r^2 \tag{1} $$ $$ \frac{\overline{xy^2}}{\overline{y}}-2x_0\frac{\overline{xy}}{\overline{y}}+x_0^2+\frac{\overline{y^3}}{\overline{y}}-2y_0\frac{\overline{y^2}}{\overline{y}}+y_0^2+\frac{\overline{yz^2}}{\overline{y}}-2z_0\frac{\overline{yz}}{\overline{y}}+z_0^2=r^2\tag{2} $$ $$ \frac{\overline{x^2z}}{\overline{z}}-2x_0\frac{\overline{xz}}{\overline{z}}+x_0^2+\frac{\overline{y^2z}}{\overline{z}}-2y_0\frac{\overline{yz}}{\overline{z}}+y_0^2+\frac{\overline{z^3}}{\overline{x}}-2z_0\frac{\overline{yz}}{\overline{z}}+z_0^2=r^2\tag{3} $$ $$ \overline{x^2}-2x_0\overline{x}+x_0^2+\overline{y^2}-2y_0\overline{y}+y_0^2+\overline{z^2}-2z_0\overline{z}+z_0^2=r^2\tag{4} $$

分别减去 (4) 式最终可以得到如下线性方程组：

$$ \begin{bmatrix} \overline{x^2}-\bar{x}^2 & \overline{xy}-\bar{x}\cdot \bar{y} & \overline{xz}-\bar{x}\bar{z} \ \overline{xy}-\bar{x}\bar{y} & \overline{y^2}-\bar{y}^2 & \overline{yz}-\bar{y}\bar{z} \ \overline{xz}-\bar{x}\bar{z} & \overline{yz}-\bar{y}\bar{z} & \overline{z^2}-\bar{z}^2 \ \end{bmatrix} \begin{bmatrix} x_0\ y_0\ z_0\ \end{bmatrix}=\frac{1}{2} \begin{bmatrix} (\overline{x^3}-\bar{x}\overline{x^2})+(\overline{x y^2}-\bar{x}\overline{y^2})+(\overline{xz^2}-\bar{x}\overline{z^2}) \ (\overline{x^2y}-\overline{x^2}\bar{y})+(\overline{y^3}-\bar{y}\overline{y^2})+(\overline{yz^2}-\bar{y}\overline{z^2}) \ (\overline{x^2z}-\overline{x^2}\bar{z})+(\overline{zy^2}-\bar{z}*\overline{y^2})+(\overline{z^3}-\bar{z} * \overline{z^2})\ \end{bmatrix} $$

解此线性方程组即可得到坐标 $(x_0, y_0, z_0)$，再代回 (4) 式求出 $r$ 即可。

利用法方程求解矩阵

也可以直接对球面的方程进行拟合，每一个点云坐标对应一个方程，方程数显然大于未知数，可以利用最小二乘法进行求解出一个最小值。

将方程稍微化简可得： $$ 2ax+2by+2cz+r^2-(a^2+b^2+c^2)=x^2+y^2+z^2 $$

将每一个点坐标代入得到一个 $n\times4$ 的矩阵 A： $$ \begin{bmatrix} x_1&y_1&z_1&1\ x_2&y_2&z_2&1\ \vdots&\vdots&\vdots&\vdots\ x_n&y_n&z_n&1\ \end{bmatrix}\begin{bmatrix}2a\2b\2c\r^2-(a^2+b^2+c^2)\end{bmatrix}= \begin{bmatrix}x_1^2+y_1^2+z_1^2\\vdots\x_n^2+y_n^2+z_n^2\end{bmatrix} $$ 方程两边同时左乘以 $A^T$ 可以得到和第一种方法一样的方程，或者直接用公式 $x=(A^TA)^{-1}A^Tb$ 进行求解，这两种方法在本质上是完全一样的。

python实现

针对第一种方法的具体代码

import numpy as np
points = np.array(coor) # coor为点云坐标的列表
points = points.astype(np.float64) # 防止溢出
num_points = points.shape[0]
print(num_points)
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
x_avr = sum(x) / num_points
y_avr = sum(y) / num_points
z_avr = sum(z) / num_points
xx_avr = sum(x * x) / num_points
yy_avr = sum(y * y) / num_points
zz_avr = sum(z * z) / num_points
xy_avr = sum(x * y) / num_points
xz_avr = sum(x * z) / num_points
yz_avr = sum(y * z) / num_points
xxx_avr = sum(x * x * x) / num_points
xxy_avr = sum(x * x * y) / num_points
xxz_avr = sum(x * x * z) / num_points
xyy_avr = sum(x * y * y) / num_points
xzz_avr = sum(x * z * z) / num_points
yyy_avr = sum(y * y * y) / num_points
yyz_avr = sum(y * y * z) / num_points
yzz_avr = sum(y * z * z) / num_points
zzz_avr = sum(z * z * z) / num_points

A = np.array([[xx_avr - x_avr * x_avr, xy_avr - x_avr * y_avr, xz_avr - x_avr * z_avr],
 [xy_avr - x_avr * y_avr, yy_avr - y_avr * y_avr, yz_avr - y_avr * z_avr],
 [xz_avr - x_avr * z_avr, yz_avr - y_avr * z_avr, zz_avr - z_avr * z_avr]])
b = np.array([xxx_avr - x_avr * xx_avr + xyy_avr - x_avr * yy_avr + xzz_avr - x_avr * zz_avr,
 xxy_avr - y_avr * xx_avr + yyy_avr - y_avr * yy_avr + yzz_avr - y_avr * zz_avr,
 xxz_avr - z_avr * xx_avr + yyz_avr - z_avr * yy_avr + zzz_avr - z_avr * zz_avr])
# print(A, b)
b = b / 2
center = np.linalg.solve(A, b)
x0 = center[0]
y0 = center[1]
z0 = center[2]
r2 = xx_avr - 2 * x0 * x_avr + x0 * x0 + yy_avr - 2 * y0 * y_avr + y0 * y0 + zz_avr - 2 * z0 * z_avr + z0 * z0
r = r2 ** 0.5
print(center, r)

参考

https://blog.csdn.net/sunshine_zoe/article/details/78852978 https://blog.csdn.net/liyuanbhu/article/details/80201371 https://blog.csdn.net/woniu199166/article/details/79459807?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1