学习 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

JS类型转换

Fri, 27 Aug 2021 15:04:00 +0000

首先会判断两者类型，相同直接比较是否全等，类型不相同的话，就会进行类型转换，按以下规则：

布尔->数值
字符+数值->数值
对象->valueof
null==undefined
遇到NaN直接不等

全等`===`不全等`!==`

类型不相同时不会转换类型，直接返回false

null===undefined //true

Object.is()

除了特殊情况一般和===相同

Object.is(NaN,NaN) //true
Object.is(0,-0) //false

转为数值

null->0
undefined->NaN
true->1 false->0
数字字符串->数字
字符串包含非数字->NaN
“”->0
Symbol->报错
对象->valueOf()??toString() []->0 [1]->1 [1,1]->NaN {}->NaN

转为布尔

记住以下false假值：

undefined
null
+0、-0
NaN

转为字符串

null->“null”
undefined->“undefined”
true->“true”、false->“false”
数值->“数值”
对象->toString()方法，该方法会被重写，未重写Object.prototype.toString->"[object 具体类型]"
Symbol->只能强制转换，隐式转换报错

加法

数值+数值：

NaN+*=NaN
Infinity+-Infinity=NaN
-Infinity+-Infinity=-Infinity
-0+-0=-0
0+-0=0 只要有一个操作数是字符串，则转换为字符串进行拼接
[]+{}="[object Object]" {}+[]=0

减法

NaN-*=NaN
Infinity-Infinity=NaN
-Infinity–Infinity=NaN
操作数是字符串、布尔、null、undefined->数值
对象->valueOf()??toString()

>和<

字符串比较->逐个比较字母编码
有一个是数值->将另一个转为数值
对象-》valueof().toString()
布尔->数值
NaN->返回false

valueOf()、toString()

[1,‘a’].valueOf() -> [1,‘a’]
[1,‘a’].toString() -> ‘1,a’
{}.valueOf() -> {}
{}.toString() -> ‘[Object Object]’

arguments

在严格模式或使用...args的的情况下arguments不再追踪参数的变化。

JS常见设计模式

Mon, 23 Aug 2021 13:44:00 +0000

将创建对象的具体逻辑封装在?个函数中，创建后返回这个对象，那么这个函数就可以被视为?个??。

// 简单??模式：只需要?个正确的参数，就可以获取到你所需要的对象，?于?成实例
// 比如对象工厂，函数工厂
function Animal(opts) {
 var obj = new Object();
 obj.color = opts.color;
 obj.name = opts.name;
 obj.getInfo = function () {
 return "名称：" + obj.name + "， 颜?：" + obj.color;
 };
 return obj;
}
var cat = Animal({ name: "波斯猫", color: "??" });

// ???法模式：本意是将实际创建对象的?作推迟到?类中，这样核?类就变成了抽象类，
// ???法只是?个实例化对象的??，只做实例化对象这?件事情，?于?成实例
class User {
 constructor(name = "", viewPage = []) {
 if (new.target === User) {
 throw new Error("抽象类不能实例化!");
 }
 this.name = name;
 this.viewPage = viewPage;
 }
}
class UserFactory extends User {
 constructor(name, viewPage) {
 super(name, viewPage); // 调??类的constructor(name, viewPage)，继承?类的this对象
 }
}
// let user = new User(); // 不允许直接实例化
let userFactory = new UserFactory();

//抽象??模式：并不直接?成实例，?是?于对产品类簇的创建
function getAbstractUserFactory(type) {
 switch (type) {
 case "wechat":
 return UserOfWechat;
 break;
 case "qq":
 return UserOfQq;
 break;
 case "weibo":
 return UserOfWeibo;
 break;
 default:
 throw new Error("参数错误, 可选参数:wechat、qq、weibo");
 }
}
let WechatUserClass = getAbstractUserFactory("wechat");
let QqUserClass = getAbstractUserFactory("qq");
let WeiboUserClass = getAbstractUserFactory("weibo");
let wechatUser = new WechatUserClass("微信?李");
let qqUser = new QqUserClass("QQ?李");
let weiboUser = new WeiboUserClass("微博?李");

单例模式

保证?个类仅有?个实例，并提供?个访问它的全局访问点。

class Singleton {
 static getInstance = (function () {
 let instance;
 return function () {
 if (!instance) {
 instance = new Singleton(...arguments);
 }
 return instance;
 };
 })();
 constructor(name) {
 this.name = name;
 }
}

let s1 = Singleton.getInstance("lisi");
console.log(s1.name); //lisi
let s2 = Singleton.getInstance("san");
console.log(s1.name); //lisi
console.log(s1 === s2); // true

观察者模式

定义了对象间?对多的依赖关系，当?标对象的状态发?改变时，所有依赖它的对象都会得到通知。

// ?标者类
class Subject {
 constructor() {
 this.observers = []; // 观察者列表
 }
 // 添加
 add(observer) {
 this.observers.push(observer);
 }
 // 删除
 remove(observer) {
 let idx = this.observers.findIndex((item) => item === observer);
 idx > -1 && this.observers.splice(idx, 1);
 }
 // 通知
 notify() {
 for (let observer of this.observers) {
 observer.update();
 }
 }
}
// 观察者类
class Observer {
 constructor(name) {
 this.name = name;
 }
 // ?标对象更新时触发的回调
 update() {
 console.log(`?标者通知我更新了，我是：${this.name}`);
 }
}
// 实例化?标者
let subject = new Subject();
// 实例化两个观察者
let obs1 = new Observer("前端开发者");
let obs2 = new Observer("后端开发者");
// 向?标者添加观察者
subject.add(obs1);
subject.add(obs2);
// ?标者通知更新
subject.notify();
// 输出：
// ?标者通知我更新了，我是前端开发者
// ?标者通知我更新了，我是后端开发者

发布订阅模式

实现了对象间多对多的依赖关系，通过事件中?管理多个事件。?标对象并不直接通知观察者，?是通过事件中?来派发通知。

// 事件中?
let pubSub = {
 list: {}, // {onwork:[fn1,fn2],offwork:[fn1,fn2],launch:[fn1,fn2]}
 subscribe: function (key, fn) {
 // 订阅
 if (!this.list[key]) {
 this.list[key] = [];
 }
 this.list[key].push(fn);
 },
 publish: function (key, ...arg) {
 // 发布
 for (let fn of this.list[key]) {
 fn.call(this, ...arg);
 }
 },
 unSubscribe: function (key, fn) {
 // 取消订阅
 let fnList = this.list[key];
 if (!fnList) return false;
 if (!fn) {
 // 不传?指定取消的订阅?法，则清空所有key下的订阅
 fnList && (fnList.length = 0);
 } else {
 fnList.forEach((item, index) => {
 if (item === fn) {
 fnList.splice(index, 1);
 }
 });
 }
 },
};
// 订阅
pubSub.subscribe("onwork", (time) => {
 console.log(`上班了：${time}`);
});
pubSub.subscribe("offwork", (time) => {
 console.log(`下班了：${time}`);
});
pubSub.subscribe("launch", (time) => {
 console.log(`吃饭了：${time}`);
});
// 发布
pubSub.publish("onwork", "9:00:00");
pubSub.publish("offwork", "18:00:00");
pubSub.publish("launch", "12:00:00");
// 取消订阅
pubSub.unSubscribe("onwork");
pubSub.publish("onwork", "9:00:00");

适配器模式

适配器?来解决两个接?不兼容的情况，不需要改变已有的接?，通过包装?层的?式实现两个接?的正常协作。

// 已有的地图接?
var googleMap = {
 show: function () {
 console.log("开始渲染?歌地图");
 },
};
var baiduMap = {
 display: function () {
 console.log("开始渲染百度地图");
 },
};
// 已有的渲染接?
var renderMap = function (map) {
 if (map.show instanceof Function) {
 map.show();
 }
};

// 适配器
var baiduMapAdapter = {
 show: function () {
 return baiduMap.display();
 },
};
renderMap(googleMap); // 开始渲染?歌地图
renderMap(baiduMapAdapter); // 开始渲染百度地图

代理模式

不直接引?另?个对象，通过代理对象间接引用，起到中介的作?。

var obj = {};
var proxy = new Proxy(obj, {
 get: function (target, key, receiver) {
 console.log(`getting ${key}!`);
 return Reflect.get(target, key, receiver);
 },
 set: function (target, key, value, receiver) {
 console.log(`setting ${key}=${value}!`);
 return Reflect.set(target, key, value, receiver);
 },
});
proxy.count = 1;
proxy.count;

装饰模式

不改变已有的函数，给函数添加额外的功能，?如ES7中的装饰器。

参考

https://refactoringguru.cn/design-patterns/catalog

学习资料

Tue, 13 Jul 2021 07:55:00 +0000

后盾人 CS-Note

算法

代码随想录

知识点

Cookies,Session和Token TCP 三次握手源码 TCP握手挥手 Service Worker HTTPS 加密、证书、签名与握手 4种常见的内存泄露 JS模块化简单了解二叉树diff算法如何实现一个 Virtual DOM 算法 js 异步历史与 co.js 解读

博客

https://78.al/ https://jerryzou.com/posts/rxjs-practice-01/ 前端面试题阮一峰的网络日志

TypeScript基础

Sat, 05 Jun 2021 14:09:00 +0000

https://www.tslang.cn/docs/home.html

变量

// 布尔
let isDone: boolean = false;
// 数字
let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;
let binaryLiteral: number = 0b1010;
let octalLiteral: number = 0o744;
// 字符串
let fname: string = "bob";
let sentence: string = `Hello, my name is ${fname}.`;

// 数组
let list1: number[] = [1, 2, 3];
let list2: Array<number> = [1, 2, 3];
// 元组
let x: [string, number];
x = ["hello", 10]; // OK
// x = [10, "hello"]; // Error
// 枚举
enum Color {
 Red,
 Green,
 Blue,
}
let c: Color = Color.Green;
console.log(c); //1
let colorName: string = Color[2];
console.log(colorName); //Blue
// Any
let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // ok
let list: any[] = [1, true, "free"];
list[1] = 100;
let some; //声明时未指定类型时默认any
some = 1;
some = "a";
// void
function warnUser(): void {
 console.log("This is my warning message");
}
// undefined null 可以赋给其他类型变量
let u: undefined = undefined;
let n: null = null;
// never
function error(message: string): never {
 throw new Error(message);
}
function infiniteLoop(): never {
 while (true) {}
}
// Object
let o: object = {};
// 类型断言 规避类型检查
let someValue: any = "this is a string";
let strLength1: number = (<string>someValue).length;
let strLength: number = (someValue as string).length;
// 类型推断
let somea = 1; //类型自动推断为number
// somea = "1"; //报错
//联合类型
let star: string | number = "1";
star = 1;
// 别名
type mytype = string | number;
type Eventname = "Click" | "scroll";

接口

// 对象接口
interface person {
 name: string;
 age: number;
 readonly gender: string; //只读属性
 like?: string; //可选属性
 [propName: string]: any; //任意属性
}
// 索引
interface numberArr {
 [index: number]: number;
}
// 函数接口
interface SearchFunc {
 (source: string, subString: string): boolean;
}
let mySearch: SearchFunc;
mySearch = function (src, sub) {
 let result = src.search(sub);
 return result > -1;
};
// 类接口
interface ClockInterface {
 currentTime: Date;
 setTime(d: Date): void;
}
class Clock implements ClockInterface {
 currentTime: Date;
 setTime(d: Date) {
 this.currentTime = d;
 }
 constructor(h: number, m: number) {
 this.currentTime = new Date();
 }
}
// 接口继承
interface Shape {
 color: string;
}
interface PenStroke {
 penWidth: number;
}
interface Square extends Shape, PenStroke {
 sideLength: number;
}
let square = <Square>{};
square.color = "blue";
square.sideLength = 10;
square.penWidth = 5.0;

面向对象

class Animal {
 // 继承类可以访问
 protected name: string;
 // 构造函数里可以使用 public name 来简写
 constructor(name: string) {
 this.name = name;
 }
 move(distanceInMeters: number = 0) {
 console.log(`Animal moved ${distanceInMeters}m.`);
 }
 static isAnimal(animal: object): boolean {
 return animal instanceof Animal;
 }
}
//继承
class Dog extends Animal {
 // 私有属性，只读
 private readonly color: string = "blackack";
 constructor(name: string) {
 super(name);
 }
 move(distanceInMeters: number = 0) {
 console.log(`${this.name} moved ${distanceInMeters}m.`);
 }
 bark() {
 console.log(`${this.color} ${this.name}: Woof! Woof!`);
 }
}

const dog = new Dog("dog");
dog.move(10);
dog.bark();
console.log(Animal.isAnimal(dog));

//抽象类
abstract class absAnimal {
 abstract makeSound(): void; // 必须在派生类中实现
 move(): void {
 console.log("roaming the earch...");
 }
}

函数

//可选参数
function buildName1(firstName: string, lastName?: string) {
 if (lastName) return firstName + " " + lastName;
 else return firstName;
}
//默认参数
function buildName2(firstName: string, lastName = "Smith") {
 if (lastName) return firstName + " " + lastName;
 else return firstName;
}
//收集参数
function buildName3(firstName: string, ...restOfName: string[]) {
 return firstName + " " + restOfName.join(" ");
}
//函数重载
function getInfo(name: string): void;
function getInfo(age: number): void;
function getInfo(str: any): void {
 if (typeof str == "string") {
 console.log("名字:", str);
 }
 if (typeof str == "number") {
 console.log("年龄", str);
 }
}

泛型

function createArray<T>(value: T, length: number): Array<T> {
 let result: T[] = [];
 for (let i = 0; i < length; i++) {
 result[i] = value;
 }
 return result;
}
let a = createArray([1, 2, 3], 3);

class GenericNumber<T> {
 zeroValue: T;
 add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function (x, y) {
 return x + y;
};

CSS居中时内容溢出滚动显示不全的问题

Fri, 14 May 2021 02:42:27 +0000

当我们有如下的布局时，其中 img 是我们内容，用一个 overflow:auto 来设置一个滚动区域，当图片较长时，会发现即使滚动到顶部，图片顶部仍有部分看不到。

<!DOCTYPE html>
<html lang="zh">
 <head>
 <meta charset="UTF-8" />
 <meta http-equiv="X-UA-Compatible" content="IE=edge" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <title>Document</title>
 </head>
 <style>
 .container {
 width: 500px;
 height: 500px;
 overflow: auto;
 display: flex;
 justify-content: center;
 align-items: center;
 }
 img {
 width: 100%;
 }
 </style>
 <body>
 <div class="container">
 <img src="./static/1.jpg" alt="" />
 </div>
 </body>
</html>

解决方法

设置内容的 margin:auto 就可以滚动显示完全了。

img {
 width: 100%;
 margin: auto;
}

我们换一张宽度较宽的图，并设置 height:100%，这时新的问题出现了，图片滚动到最左边，图片左边仍有部分被遮挡显示不全。

img {
 height: 100%;
 margin: auto;
}

继续解决

我们换一种居中布局的方式，就可是使图片左右滚动能显示全。

.container {
 width: 500px;
 height: 500px;
 overflow: auto;
 position: relative;
}
img {
 height: 100%;
 margin: auto;
 position: absolute;
 top: 0;
 right: 0;
 bottom: 0;
 left: 0;
}

但是当我们换回高度较高的图片，并设置 width:100%时，发现问题又回来了，图片顶部显示不全。难道说说没有一种同时能满足上下滚动和左右滚动显示全的布局方式吗？

解决方案

一般来说图片要么 width:100%，要么 height:100%，所以上面选一种布局方式即可，但是我写的一个页面刚好要在两种状态中进行切换，因为切换是通过 js 操作的，可以在 css 里写两个布局，然后通过 js 控制元素 class 来进行切换。我在 flex 布局的基础上，当图片左右滚动不能显示完全时，只需要改变 flex-direction 的方向即可。

.container {
 width: 500px;
 height: 500px;
 overflow: auto;
 display: flex;
 justify-content: center;
 align-items: center;
 flex-direction: column;
}
img {
 height: 100%;
 margin: auto;
}

javascript一些方法原理实现

Tue, 13 Apr 2021 10:01:00 +0000

一般认为js数据类型为7种：number,string,boolean,undefined,null,symbol,object，（有的把bigint也算一种，）其中object为引用类型，其余为基本类型。

console.log(typeof 2); // number
console.log(typeof true); // boolean
console.log(typeof "str"); // string
console.log(typeof []); // object
console.log(typeof {}); // object
console.log(typeof function () {}); // function
console.log(typeof undefined); // undefined
console.log(typeof null); // object

console.log((2).constructor === Number); // true
console.log(true.constructor === Boolean); // true
console.log("str".constructor === String); // true
console.log([].constructor === Array); // true
console.log({}.constructor === Object); // true
console.log(function () {}.constructor === Function); // true

let str = Object.prototype.toString;
console.log(str.call(2)); //[object Number]
console.log(str.call(true)); //[object Boolean]
console.log(str.call("str")); //[object String]
console.log(str.call([])); //[object Array]
console.log(str.call(function () {})); //[object Function]
console.log(str.call({})); //[object Object]
console.log(str.call(undefined)); //[object Undefined]
console.log(str.call(null)); //[object Null]

instanceof

instanceof 运算符用于判断构造函数的 prototype 属性是否出现在对象的原型链中的任何位置，不能用来判断包装对象。

console.log(2 instanceof Number); // false
console.log(true instanceof Boolean); // false
console.log('str' instanceof String); // false

console.log([] instanceof Array); // true
console.log(function () {} instanceof Function); // true
console.log({} instanceof Object); // true
console.log(Object instanceof Object); //true
console.log(Function instanceof Object); //true

// 原理实现
function myInstanceof(obj, tar) {
 // 获取对象的原型
 let proto = Object.getPrototypeOf(obj);
 // 获取构造函数的 prototype 对象
 let prototype = tar.prototype;
 // 对象原型走到头了
 if (!proto) return false;
 //判断原型是否相等
 return proto === prototype ? true : myInstanceof(proto, tar);
}

深拷贝

数组、对象的typeof结果都为’object’，需要注意的是null的typeof结果也为’object’，函数的typeof结果为’function’，symbol无法直接遍历到。

function deepcopy(data) {
 if (data === null) return null;
 let obj = data instanceof Array ? [] : {};
 for (const [k, v] of Object.entries(data)) {
 obj[k] = typeof v === "object" ? deepcopy(v) : v;
 }
 for (const k of Object.getOwnPropertySymbols(data)) {
 obj[k] = typeof data[k] === "object" ? deepcopy(data[k]) : data[k];
 }
 return obj;
}

Object.create

Object.create()方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__，和new有点像。

function create(proto) {
 obj = {};
 obj.__proto__ = proto;
 return obj;
} //直译

function create(proto) {
 function F() {}
 F.prototype = proto;
 return new F();
} //推荐

new

new操作主要执行了以下操作：

新建一个空对象obj
将空对象的__proto__原型链指向构造函数的原型prototype
将构造函数的this指向obj，执行构造函数
返回构造函数的返回，如果返回为空则返回obj

function newObj(p, ...args) {
 const obj = Object.create(p.prototype);
 const result = p.apply(obj, args);
 return result || obj;
}

function Person(name) {
 this.name = name;
}
Person.prototype.getname = function () {
 console.log(this.name);
};
let person1 = new Person("san");
console.log(person1);
let person2 = newObj(Person, "si");
console.log(person2);

防抖

快速连续触发事件时，只有最后一次触发能成功执行。

function debounce(fn) {
 let timeout = null; // 创建一个标记用来存放定时器的返回值
 return function () {
 clearTimeout(timeout); // 每当用户输入的时候把前一个 setTimeout clear 掉
 timeout = setTimeout(() => {
 // 然后又创建一个新的 setTimeout, 这样就能保证输入字符后的 interval 间隔内如果还有字符输入的话，就不会执行 fn 函数
 fn.apply(this, arguments);
 }, 500);
 };
}
function sayHi() {
 console.log("防抖成功");
}

let inp = document.createElement("input");
inp.addEventListener("input", debounce(sayHi));
document.body.append(inp);

节流

一定时间内只会执行1次，上一次未处理完则不会执行。

function throttle(fn) {
 let canRun = true; // 通过闭包保存一个标记
 return function () {
 if (!canRun) return; // 在函数开头判断标记是否为true，不为true则return
 canRun = false; // 立即设置为false
 setTimeout(() => {
 // 将外部传入的函数的执行放在setTimeout中
 fn.apply(this, arguments);
 // 最后在setTimeout执行完毕后再把标记设置为true(关键)表示可以执行下一次循环了。当定时器没有执行的时候标记永远是false，在开头被return掉
 canRun = true;
 }, 500);
 };
}
function sayHi() {
 console.log("节流成功");
}
btn = document.createElement("button");
btn.innerHTML = "节流";
btn.addEventListener("click", throttle(sayHi));
document.body.append(btn);

call

将this挂载到目标上后执行，最后再删除

Function.prototype.myCall = function (context) {
 context = context || window;
 context.fn = this;
 let arg = [...arguments].slice(1);
 let result = context.fn(...arg);
 delete context.fn;
 return result;
};

apply

Function.prototype.myApply = function (context) {
 context = context || window;
 context.fn = this;
 let result;
 // 需要判断是否存储第二个参数
 // 如果存在，就将第二个参数展开
 if (arguments[1]) {
 result = context.fn(...arguments[1]);
 } else {
 result = context.fn();
 }
 delete context.fn;
 return result;
};

bind

Function.prototype.myBind = function (context) {
 let fn = this;
 var args = [...arguments].slice(1);
 // 返回一个函数
 return function () {
 return fn.apply(context, args.concat(...arguments));
 };
};

柯里化

将能够接收多个参数的函数转化为接收单一参数的函数，并且返回能接收余下参数且返回结果的新函数的技术

function add() {
 return Array.from(arguments).reduce((cur, item) => cur + item, 0);
}

function currying(fn) {
 let args = [];
 return function () {
 args.push(...arguments);
 return fn.apply(this, args);
 };
}

add = currying(add);
console.log(add(1)); //1
console.log(add(2)); //3
console.log(add(3, 4)); //10
console.log(add()); //10

反柯里化

方法借用，扩展方法使用范围，和call,apply,bind类似

function unCurrying(fn) {
 return function (obj, ...args) {
 return fn.apply(obj, args);
 };
}

push = unCurrying(Array.prototype.push);
obj = {};
push(obj, "lisi", "san");
console.log(obj);

// 等同于bind方法
obj = {};
push = Array.prototype.push.bind(obj);
push("lisi", "san");
console.log(obj);

双向绑定

通过Proxy实现对数据监听。

<input type="text" v-model="input" />
<input type="text" v-model="input" />
<div v-bind="input"></div>
<script>
 data = {};
 proxy = new Proxy(data, {
 get(obj, property) {},
 set(obj, property, value) {
 // model赋值
 // obj[property] = value;
 Reflect.set(...arguments);

 //视图响应
 let els = document.querySelectorAll(
 `[v-model="${property}"],[v-bind="${property}"]`
 );
 for (let el of els) {
 el.innerHTML = value;
 el.value = value;
 }
 return true;
 },
 });

 (function () {
 const els = document.querySelectorAll("[v-model]");
 for (const el of els) {
 el.addEventListener("keyup", function () {
 proxy[this.getAttribute("v-model")] = this.value;
 });
 }
 })();
</script>

数组扁平化

function flat(arr) {
 let res = [];
 for (let item of arr) {
 res = Array.isArray(item) ? res.concat(flat(item)) : res.concat(item);
 }
 return res;
}

数据结构与算法

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 缓存替换算法

双链表实现

布隆过滤器

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

numpy.linalg中solve和lstsq的区别

Sun, 27 Dec 2020 11:53:16 +0000

用于求解形如AX=b的方程组。

不同点

numpy.linalg.solve需要A矩阵为方阵，求解的结果为方程准确解。 numpy.linalg.lstsq允许A矩阵为超定的，当方程数大于未知数时求解结果为最小二乘近似解。另外在使用时注意返回值不同，lstsq返回更多信息。

X = numpy.linalg.solve(A, b)
X = np.linalg.lstsq(A, B, rcond=None)[0]

当A矩阵为方阵时，计算结果没有差别，可以认为lstsq是solve的超集。

参考

https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html https://numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html

计算空间三角形面积

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

blender插件编写入门

Sat, 05 Dec 2020 14:12:00 +0000

都说blender的python脚本编写起来很简单，虽然已经能够在脚本里调用一些api实现自动化，但实际写成插件还是有很多东西需要摸索的，这里记录一些关键知识点。

参考

先将一些重要的和有益的参考或学习资料列一下：

一篇相当棒的入门教程 Blender Python小白向入门
主要是第2期和第3期杂志关于插件一节写的很棒 blendercn电子杂志
其中Quickstart部分不错，不过需要一定经验后回头看才能看的更明白，其他时候主要是当作字典查询，其中有许多example值得参考 blenderAPI
blender软件中自带的Templates

概览

blender插件大部分内容都是写在class中的，无论是新建一个api接口，还是绘制一个新的界面，都是新建一个class，然后继承相应的类，所以找到相应的类，是编写插件的第一步。然后新写的类都要通过下面的注册函数register才能成为blender的一部分，有注册就有注销，注册函数在启用插件时激活，注销函数在取消启用插件时激活。

bpy.utils.register_class(CLASS_NAME)
bpy.utils.unregister_class(CLASS_NAME)

下面是一个在顶部添加语言切换功能的面板示例代码，关键的部分有继承bpy.types.Header，定义bl_space_type等内容，这些参数可以通过查阅api获取，或者从别人的代码参考过来，绘制界面就是重写draw()函数。

class LanguageChange(bpy.types.Header):
 bl_space_type = "TOPBAR"
 bl_idname = "MY_HT_LanguageChange"

 def draw(self, context):
 if context.region.alignment != "RIGHT":
 self.layout.prop(context.preferences.view,
 "use_translate_interface", text="Language")

传入的context就表示当前上下文，通过打印dir(context)可知其包涵以下属性和方法：

[’doc’, ‘module’, ‘slots’, ‘active_annotation_layer’, ‘active_base’, ‘active_bone’, ‘active_editable_fcurve’, ‘active_gpencil_frame’, ‘active_gpencil_layer’, ‘active_object’, ‘active_operator’, ‘active_pose_bone’, ‘annotation_data’, ‘annotation_data_owner’, ‘area’, ‘bl_rna’, ‘blend_data’, ‘collection’, ‘copy’, ’edit_object’, ’editable_bones’, ’editable_fcurves’, ’editable_gpencil_layers’, ’editable_gpencil_strokes’, ’editable_objects’, ’engine’, ’evaluated_depsgraph_get’, ‘gizmo_group’, ‘gpencil_data’, ‘gpencil_data_owner’, ‘image_paint_object’, ’layer_collection’, ‘mode’, ‘object’, ‘objects_in_mode’, ‘objects_in_mode_unique_data’, ‘particle_edit_object’, ‘pose_object’, ‘preferences’, ‘region’, ‘region_data’, ‘rna_type’, ‘scene’, ‘screen’, ‘sculpt_object’, ‘selectable_objects’, ‘selected_bones’, ‘selected_editable_bones’, ‘selected_editable_fcurves’, ‘selected_editable_objects’, ‘selected_editable_sequences’, ‘selected_nla_strips’, ‘selected_objects’, ‘selected_pose_bones’, ‘selected_pose_bones_from_active_object’, ‘selected_sequences’, ‘selected_visible_fcurves’, ‘sequences’, ‘space_data’, ’tool_settings’, ‘vertex_paint_object’, ‘view_layer’, ‘visible_bones’, ‘visible_fcurves’, ‘visible_gpencil_layers’, ‘visible_objects’, ‘visible_pose_bones’, ‘weight_paint_object’, ‘window’, ‘window_manager’, ‘workspace’]

界面布局layout就不细说了，prop和operator两个控件用的比较多，前者用于显示各种属性值，后者就是一个按钮，按下可以执行关联的的api，这两个控件也不细说了，可以查阅api文档。

自定义方法

到目前位置我们还只能调用blender已有的属性和方法的api，我们实现自己的功能必然需要新建一个自己的api，同样新建api也是新写一个类，如下所示，继承bpy.types.Operator，然后定义bl_idname等内容，执行的具体代码在execute()函数中编写，同样这个类写完后记得注册后才能调用。

class PointsImport(bpy.types.Operator):
 bl_idname = 'obj.import_points'
 bl_label = '导入点云'
 bl_options = {'REGISTER', 'UNDO'}

 def execute(self, context):
 print('我的代码')
 return {'FINISHED'}

调用的方法是在界面类里调用layout.operator("obj.import_points")，可以看到，bl_idname 就是注册后api的名字。

自定义变量

除了自定义方法，有时候我们还需要自定义变量，可以参考文档 https://docs.blender.org/api/current/bpy.props.html 这一节，就是在方法的类中通过bpy.props.FloatProperty等函数定义变量，调用的时候需要将实例赋值给一个变量，然后通过变量去调用和修改，可以参考文档的示例代码。

有时候我们希望从界面视图中输入一个值，然后将这个值作为自定义api的一个输入参数，如果在界面中直接调用我们创建的方法的属性变量，你就会发现在界面中这个值只能显示出来而不能修改。

要想获得一个可以在界面中修改的属性，需要在blender的data中创建一个数据，方法如下，在Scene中加入了一个变量，或者在WindowManager中添加一个变量，当然在其他数据块中添加变量也可以，添加的变量可以在blender api data面板中进行查看。

bpy.types.Scene.points_name = bpy.props.StringProperty()
bpy.types.WindowManager.points_name = bpy.props.StringProperty()

然后将这个值再赋值给方法的属性就可以了，参考我的下面代码。

class MyPanel(bpy.types.Panel):
 bl_label = "面板" # 面板显示的名称
 bl_idname = "MY_PT_Import" # 面板的id，每个面版类的id应保持唯一，建议格式大写NAME_PT_id
 bl_space_type = "VIEW_3D" # 面板所处的模式，"VIEW_3D"=3D视窗
 bl_region_type = "UI" # 面板所在的位置，"UI"=N面板
 bl_category = "点云" # 面板所在的标签页

 bpy.types.Scene.points_name = bpy.props.StringProperty(default='yp')
 bpy.types.Scene.points_file_path = bpy.props.StringProperty(
 default=r'C:\Users\kizx\Desktop\Projects\cv\ypa.npy', subtype='FILE_PATH')

 def draw(self, context):
 layout = self.layout

 row = layout.row()
 row.prop(context.scene, "points_name", text="名称")
 row = layout.row()
 row.prop(context.scene, "points_file_path", text="点云文件")
 row = layout.row()
 pc = row.operator("obj.import_points")
 pc.path = context.scene.points_file_path
 pc.name = context.scene.points_name

点云球面最小二乘拟合的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

QPixmap.scaled在Pyside2和Pyqt5中的不同

Mon, 13 Apr 2020 16:23:00 +0000

这个参数有以下三个值。

对于一个单独的布局的label来说，两者参数的表现并无不同，但是当我的图片放置在一个网格布局中时，Pyside2的参数设置为KeepAspectRatio和Pyqt5参数设置为KeepAspectRatioByExpanding表现是一样的，很是奇怪。以下是Pyqt5的显示结果。准确点来说是Pyqt5的参数在这里显示有点不对劲，具体原因有待研究。

参考

https://doc.qt.io/qtforpython/PySide2/QtGui/QPixmap.html?highlight=qpixmap#PySide2.QtGui.PySide2.QtGui.QPixmap.scaled https://doc.qt.io/archives/qtjambi-4.5.2_01/com/trolltech/qt/core/Qt.AspectRatioMode.html

We live in an “age of anxiety”

Fri, 11 Oct 2019 14:50:00 +0000

The teacher of our group introduced us to some research and views about anxiety. Although we are no longer suffering from diseases, hunger and war in the present era, we still need to worry about health, billing, study, work, interpersonal relationships and so on. We are not only anxious for the present, but also for the future.

After the speech, the teacher asked us three questions.

The first question is “Have you ever experienced mental anxiety, and what are you anxious about?”. Some of our team members are anxious about the exam, while others are worried about their relationship with their classmates, and generally we are all anxious about future work.

The second question is “What do you think are the causes of anxiety?”. After our group discussion, we have summarized the following reasons. First of all, we feel anxious because of the lack of knowledge of anxiety and lack of ability and experience. The second reason is our mentality. When we encounter challenging things, an optimistic and confident attitude will help us overcome anxiety. On the contrary, a negative attitude will contribute to our anxiety.

The last question is “Do you know how to relieve anxiety? Can you recommend some good ways to relieve anxiety?”. In response to the anxiety factors we discussed above, our group members believe that to relieve anxiety, we should first learn more and improve our abilities and experience. So that we can have enough confidence and optimism to overcome anxiety. If we are already in anxiety, we can use the means of self-motivation to distract ourselves from anxiety. And we think that proper venting or relaxation is also a good way to relieve anxiety.

Finally, I hope everyone can stay away from anxiety and enjoy life!

IG Nobel Prize

Mon, 30 Sep 2019 17:07:00 +0000

Good afternoon everyone, then I will share with you a news about the IG Nobel Prize. This prize is an interesting imitation of the Nobel Prize, and it is awarded to those scientific achievements that first make people laugh, then make them think deeply.

This month, the 29th first Ig Nobel Prize was announced, and this year’s winners, covering 10 categories. So next I will choose some of them to introduce to you.

First of all. The Medical Prize was awarded to Italian scientists for pizza and illness studies. The researchers showed that “often eat pizza ” seems to have a lower risk of cancer and heart attack. But there’s just one catch – the pizza must be made and eaten in Italy. Maybe they only did experiments on Italians.

The next prize is very interesting. The award for the Medical Education Prize is to train the surgeon with “clicker training”. People often use it to train dogs and other animals. But the study found that training a surgeon would be as similar as training a dog.

The Biology Prize is more interesting. The researchers placed a group of live cockroaches and dead cockroaches in a strong magnetic field. After 20 minutes, the dead cockroaches could be sucked into the refrigerator like a sticker, but the live group could not. This research may reveal the connection between biology and magnetic fields, and could help in the development of new magnetic sensors.

The Engineering Prize was awarded to the invention of an automatic baby-diaper-changing machine. That’s sounds like a good invention. unfortunately the machine doesn’t actually change the child’s diaper. Instead, it is a bit like an oven to dry the diaper.

The Chemistry Prize examines how much saliva a 5-year-old child will produce one day. It turned out that the five-year-old child produce about 500 milliliter of saliva a day. But we are still not sure what the significance of this study.

The most funny award is the Physics Prize. Researchers had discovered how the wombat manages to produce cube-shaped poo. It’s the only animal in the world known to do this, and the team found the secret of the cube-shaped poo is their intestine movement. But the researchers still don’t know for sure why wombats evolved to produce cube-shaped poo.

(Next is the Peace Prize. Tickling will always make you feel good. However, do you know which part of the body can effectively relieve itching? Do you know how to scratch to maximize your body and mind? This research will make you feel comfortable and scratched.

The Economics Prize examines which country’s banknotes are the most susceptible to dangerous bacteria. Does this have anything to do with the economy?)

reference https://newatlas.com/science/ig-nobel-awards-2019/ https://mp.weixin.qq.com/s/jcjwCNhju1eK_ehSKHiq7g

Questions

Do you think the Ig Nobel Prize makes sense, or is it just for fun?
Which Prize do you think is the most interesting？
Can you also give a similar interesting research?