/**
* Kiszamitja az n! (n faktorialis) erteket.
* @param {Number} n A szam, melynek a faktorialisat ki szeretnenk szamolni.
* @returns {Number} n! erteke.
*/
function f_factorial(n) {
let result = 1
for (let i = 1; i <= n; i++) {
result *= i
}
return result
}
/**
* Az n alatt az i binomialis egyutthato erteket szamitja ki.
* @param {Number} n n
* @param {Number} i i
* @returns {Number} A binomialis egyutthato erteke.
*/
function f_binomial(n, i) {
const szamlalo = f_factorial(n)
const nevezo = f_factorial(i) * f_factorial(n - i)
return szamlalo / nevezo
}
/**
* Kiszamitja az i-edik n-edfoku Bernstein-polinom (B_i,n) erteket adott t helyen.
* @param {Number} n n.
* @param {Number} i i.
* @param {Number} t A futo parameter, ahol 0 <= t <= 1.
* @returns {Number} A polinom erteke.
*/
function f_bernstein(n, i, t) {
return f_binomial(n, i) * Math.pow(t, i) * Math.pow(1 - t, n - i)
}
f_efficientFactorial = (function factory() {
const cache = [1]
return function factorial(n) {
if (cache.length <= n) {
for (let i = cache.length - 1; i <= n; i++) {
cache.push((i + 1) * cache[cache.length - 1])
}
}
return cache[n]
}
})()
f_efficientBinomial = (function factory() {
const cache = new Map()
return function binomial(n, i) {
if (!cache.has(n)) {
cache.set(n, new Map())
}
const iCache = cache.get(n)
if (!iCache.has(i)) {
const value = f_efficientFactorial(n) / (f_efficientFactorial(i) * f_efficientFactorial(n - i))
iCache.set(i, value)
}
return iCache.get(i);
}
})()
f_efficientPow = function factory(K) {
// Veszunk K pontot a [0, 1] intervallumbol, majd
// kepzunk egy ketdimenzios tombot, melyben a pontok
// 0., es 1. hatvanyai szerepelnek.
const cache = $maths.linspace(0, 1, K)
.map(i => [1, i])
// j az egyik dimenzio (alap), i a masik dimenzio (kitevo) szerinti index.
return function pow(j, i) {
// Lekerjuk a j indexnek megfelelo ertek eddig tarolt hatvanyait.
const powArray = cache[j];
// Ha az i kitevonek megfelelo ertek meg nincs kiszamolva.
if (i >= powArray.length) {
// A legnagyobb mar kiszamolt kitevotol elindulva, sorozatos
// szorzasok segitsegevel kiszamoljuk a szukseges erteket.
for (let k = powArray.length; k <= i; ++k) {
powArray.push(powArray[powArray.length - 1] * powArray[1])
}
}
return powArray[i]
}
}
/**
* Kiszamolja a points kontrollpontokkal adott Bezier-gorbe K gorbepontjat.
* @param {Array} points A kontrollpontok tombje.
* @param {Number} K A kiertekelesi helyek szama.
* @returns {Array} Egy vec2 objektumokbol allo tomb, mely a gorbepontokat tartalmazza.
*/
function f_efficientBezier(points, K) {
const pow = f_efficientPow(K)
const n = points.length - 1;
const result = []
// Vegigmegyunk a [0, 1] tartomany beosztasainak megfelelo indexeken.
// Ez felel meg a t: 0 -> 1 ciklusnak.
for (let t = 0; t < K; ++t) {
const point = glMatrix.vec2.create()
// Adott t-nel kiertekeljuk a sulyfuggvenyeket, es kepezzuk
// a kontrollpontok sulyozott osszegeget.
for (let i = 0; i < points.length; ++i) {
// Vegyuk eszre, hogy K - 1-et hasznalunk. Erre azert van szukseg, hogy
// elkeruljuk a tulindexelest, hiszen, bar K erteket tarolunk, a legutolso
// index K - 1.
const b = f_efficientBinomial(n, i) * pow(t, i) * pow(K - 1 - t, n - i)
const p = glMatrix.vec2.create()
glMatrix.vec2.scale(p, points[i], b)
glMatrix.vec2.add(point, point, p)
}
result.push(point)
}
return result
}
/**
* Visszaadja a de Casteljau algoritmus altal egy adott t-hez kiszamolt osszes pontot.
* @param {Array} points A kontrollpontok tombje.
* @param {Number} t A 0 <= t <= 1 futo parameter.
* @returns {Array} A generaciok ketdimentios tombje.
*/
function f_deCasteljau(points, t) {
const result = [points]
while (result[result.length - 1].length > 1) {
const gen = []
for (let i = 0; i < result[result.length - 1].length - 1; i++) {
const sp1 = glMatrix.vec2.create()
glMatrix.vec2.scale(sp1, result[result.length - 1][i], 1 - t)
const sp2 = glMatrix.vec2.create()
glMatrix.vec2.scale(sp2, result[result.length - 1][i + 1], t)
const p = glMatrix.vec2.create()
glMatrix.vec2.add(p, sp1, sp2)
gen.push(p)
}
result.push(gen)
}
return result
}
/**
* Adott helyen ketteoszt egy Bezier-gorbet.
* @param {Array} points A kontrollpontok tombje.
* @param {Number} t A ketteosztas helyet megado 0 <= t <= 1 ertek.
* @returns {object} A bal- es jobboldali gorbek kontrollpontjait tartalmazo tombok objektuma.
*/
function f_splitBezier(points, t) {
const left = [points[0]]
const right = [points[points.length - 1]]
const temp = [...points]
while (temp.length > 1) {
for (let i = 0; i < temp.length - 1; i++) {
const sp1 = glMatrix.vec2.create()
glMatrix.vec2.scale(sp1, temp[i], 1 - t)
const sp2 = glMatrix.vec2.create()
glMatrix.vec2.scale(sp2, temp[i + 1], t)
const p = glMatrix.vec2.create()
glMatrix.vec2.add(p, sp1, sp2)
temp[i] = p
}
temp.pop()
left.push(temp[0])
right.push(temp[temp.length - 1])
}
return {
left,
right
}
}
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
