From d8fab98ec7edbc7b6e2c53089648d30023f79545 Mon Sep 17 00:00:00 2001 From: Bezierinfo CI Date: Thu, 4 Feb 2021 00:46:51 +0000 Subject: [PATCH] Automated build --- docs/index.html | 32 ++++++++++++++++---------------- docs/ja-JP/index.html | 32 ++++++++++++++++---------------- docs/news/2020-09-18.html | 2 +- docs/news/2020-11-22.html | 2 +- docs/news/index.html | 2 +- docs/news/rss.xml | 2 +- docs/ru-RU/index.html | 32 ++++++++++++++++---------------- docs/uk-UA/index.html | 32 ++++++++++++++++---------------- docs/zh-CN/index.html | 32 ++++++++++++++++---------------- 9 files changed, 84 insertions(+), 84 deletions(-) diff --git a/docs/index.html b/docs/index.html index 87b3147d..0071c3b1 100644 --- a/docs/index.html +++ b/docs/index.html @@ -38,7 +38,7 @@ - + @@ -5915,14 +5915,14 @@ lli = function(line1, line2):

How does that work? Succinctly: we run de Casteljau's algorithm in reverse!

- In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that want to - be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know has - no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for + In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that we want + to be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know + has no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for reasons that will become obvious.

So let's use graphics instead of text to see where this "A" is, because text only gets us so far: move the sliders for the following - graphics to see what, given specific t value, our A coordinate is. As well as some other coordinates, which + graphics to see what, given a specific t value, our A coordinate is. As well as some other coordinates, which taken together let us derive a value that the graphics call "ratio": if you move the curve's points around, A, B, and C will move, what happens to that value?

@@ -5984,7 +5984,7 @@ lli = function(line1, line2): and so neither will C, and if you move either start or end point, C will move but its relative position will not change.

- So, how can we compute C? We start with our observation that C always lies somewhere between the start and ends + So, how can we compute C? We start with our observation that C always lies somewhere between the start and end points, so logically C will have a function that interpolates between those two coordinates:

- So, if we know the start and end coordinates, and we know the t value, we know C, without having to calculate the - A or even B coordinates. In fact, we can do the same for the ratio function: as another function of - t, we technically don't need to know what A or B or C are, we can express it was a - pure function of t, too. + So, if we know the start and end coordinates and the t value, we know C without having to calculate the A or even + B coordinates. In fact, we can do the same for the ratio function. As another function of t, we technically + don't need to know what A or B or C are. It, too, can be expressed as a pure function of + t.

We start by observing that, given A, B, and C, the following always holds:

- Which now leaves us with some powerful tools: given thee points (start, end, and "some point on the curve"), as well as a - t value, we can construct curves: we can compute C using the start and end points, and our + Which now leaves us with some powerful tools: given three points (start, end, and "some point on the curve"), as well as a + t value, we can construct curves. We can compute C using the start and end points and our u(t) function, and once we have C, we can use our on-curve point (B) and the ratio(t) function to find A:

@@ -6094,7 +6094,7 @@ lli = function(line1, line2): ╰ 2 t --> -

And then reverse engineer the curve's control control points:

+

And then reverse engineer the curve's control points:

- So: if we have a curve's start and end point, then for any t value we implicitly know all the ABC values, which (combined + So: if we have a curve's start and end points, then for any t value we implicitly know all the ABC values, which (combined with an educated guess on appropriate e1 and e2 coordinates for cubic curves) gives us the necessary information to reconstruct a curve's "de Casteljau skeleton". Which means that we can now do several things: we can "fit" curves using only three - points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end point, and then reconstructing the + points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end points, and then reconstruct the curve based on where we moved the on-curve point to. These are very useful things, and we'll look at both in the next few sections.

diff --git a/docs/ja-JP/index.html b/docs/ja-JP/index.html index 80cfed8b..0e81940d 100644 --- a/docs/ja-JP/index.html +++ b/docs/ja-JP/index.html @@ -41,7 +41,7 @@ - + @@ -6028,14 +6028,14 @@ lli = function(line1, line2):

How does that work? Succinctly: we run de Casteljau's algorithm in reverse!

- In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that want to - be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know has - no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for + In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that we want + to be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know + has no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for reasons that will become obvious.

So let's use graphics instead of text to see where this "A" is, because text only gets us so far: move the sliders for the following - graphics to see what, given specific t value, our A coordinate is. As well as some other coordinates, which + graphics to see what, given a specific t value, our A coordinate is. As well as some other coordinates, which taken together let us derive a value that the graphics call "ratio": if you move the curve's points around, A, B, and C will move, what happens to that value?

@@ -6101,7 +6101,7 @@ lli = function(line1, line2): and so neither will C, and if you move either start or end point, C will move but its relative position will not change.

- So, how can we compute C? We start with our observation that C always lies somewhere between the start and ends + So, how can we compute C? We start with our observation that C always lies somewhere between the start and end points, so logically C will have a function that interpolates between those two coordinates:

- So, if we know the start and end coordinates, and we know the t value, we know C, without having to calculate the - A or even B coordinates. In fact, we can do the same for the ratio function: as another function of - t, we technically don't need to know what A or B or C are, we can express it was a - pure function of t, too. + So, if we know the start and end coordinates and the t value, we know C without having to calculate the A or even + B coordinates. In fact, we can do the same for the ratio function. As another function of t, we technically + don't need to know what A or B or C are. It, too, can be expressed as a pure function of + t.

We start by observing that, given A, B, and C, the following always holds:

- Which now leaves us with some powerful tools: given thee points (start, end, and "some point on the curve"), as well as a - t value, we can construct curves: we can compute C using the start and end points, and our + Which now leaves us with some powerful tools: given three points (start, end, and "some point on the curve"), as well as a + t value, we can construct curves. We can compute C using the start and end points and our u(t) function, and once we have C, we can use our on-curve point (B) and the ratio(t) function to find A:

@@ -6211,7 +6211,7 @@ lli = function(line1, line2): ╰ 2 t --> -

And then reverse engineer the curve's control control points:

+

And then reverse engineer the curve's control points:

- So: if we have a curve's start and end point, then for any t value we implicitly know all the ABC values, which (combined + So: if we have a curve's start and end points, then for any t value we implicitly know all the ABC values, which (combined with an educated guess on appropriate e1 and e2 coordinates for cubic curves) gives us the necessary information to reconstruct a curve's "de Casteljau skeleton". Which means that we can now do several things: we can "fit" curves using only three - points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end point, and then reconstructing the + points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end points, and then reconstruct the curve based on where we moved the on-curve point to. These are very useful things, and we'll look at both in the next few sections.

diff --git a/docs/news/2020-09-18.html b/docs/news/2020-09-18.html index 5f95f2e0..7d762d7c 100644 --- a/docs/news/2020-09-18.html +++ b/docs/news/2020-09-18.html @@ -34,7 +34,7 @@ - + diff --git a/docs/news/2020-11-22.html b/docs/news/2020-11-22.html index 6c482838..d34ab120 100644 --- a/docs/news/2020-11-22.html +++ b/docs/news/2020-11-22.html @@ -34,7 +34,7 @@ - + diff --git a/docs/news/index.html b/docs/news/index.html index 49be3faa..18697a10 100644 --- a/docs/news/index.html +++ b/docs/news/index.html @@ -33,7 +33,7 @@ - + diff --git a/docs/news/rss.xml b/docs/news/rss.xml index 0f878713..ff3d7dd6 100644 --- a/docs/news/rss.xml +++ b/docs/news/rss.xml @@ -6,7 +6,7 @@ News updates for the primer on Bézier Curves by Pomax en-GB - Mon Jan 18 2021 17:11:41 +00:00 + Thu Feb 04 2021 00:46:16 +00:00 https://pomax.github.io/bezierinfo/images/og-image.png A Primer on Bézier Curves diff --git a/docs/ru-RU/index.html b/docs/ru-RU/index.html index e2d31d40..07790e10 100644 --- a/docs/ru-RU/index.html +++ b/docs/ru-RU/index.html @@ -34,7 +34,7 @@ - + @@ -6189,14 +6189,14 @@ lli = function(line1, line2):

How does that work? Succinctly: we run de Casteljau's algorithm in reverse!

- In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that want to - be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know has - no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for + In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that we want + to be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know + has no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for reasons that will become obvious.

So let's use graphics instead of text to see where this "A" is, because text only gets us so far: move the sliders for the following - graphics to see what, given specific t value, our A coordinate is. As well as some other coordinates, which + graphics to see what, given a specific t value, our A coordinate is. As well as some other coordinates, which taken together let us derive a value that the graphics call "ratio": if you move the curve's points around, A, B, and C will move, what happens to that value?

@@ -6262,7 +6262,7 @@ lli = function(line1, line2): and so neither will C, and if you move either start or end point, C will move but its relative position will not change.

- So, how can we compute C? We start with our observation that C always lies somewhere between the start and ends + So, how can we compute C? We start with our observation that C always lies somewhere between the start and end points, so logically C will have a function that interpolates between those two coordinates:

- So, if we know the start and end coordinates, and we know the t value, we know C, without having to calculate the - A or even B coordinates. In fact, we can do the same for the ratio function: as another function of - t, we technically don't need to know what A or B or C are, we can express it was a - pure function of t, too. + So, if we know the start and end coordinates and the t value, we know C without having to calculate the A or even + B coordinates. In fact, we can do the same for the ratio function. As another function of t, we technically + don't need to know what A or B or C are. It, too, can be expressed as a pure function of + t.

We start by observing that, given A, B, and C, the following always holds:

- Which now leaves us with some powerful tools: given thee points (start, end, and "some point on the curve"), as well as a - t value, we can construct curves: we can compute C using the start and end points, and our + Which now leaves us with some powerful tools: given three points (start, end, and "some point on the curve"), as well as a + t value, we can construct curves. We can compute C using the start and end points and our u(t) function, and once we have C, we can use our on-curve point (B) and the ratio(t) function to find A:

@@ -6372,7 +6372,7 @@ lli = function(line1, line2): ╰ 2 t --> -

And then reverse engineer the curve's control control points:

+

And then reverse engineer the curve's control points:

- So: if we have a curve's start and end point, then for any t value we implicitly know all the ABC values, which (combined + So: if we have a curve's start and end points, then for any t value we implicitly know all the ABC values, which (combined with an educated guess on appropriate e1 and e2 coordinates for cubic curves) gives us the necessary information to reconstruct a curve's "de Casteljau skeleton". Which means that we can now do several things: we can "fit" curves using only three - points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end point, and then reconstructing the + points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end points, and then reconstruct the curve based on where we moved the on-curve point to. These are very useful things, and we'll look at both in the next few sections.

diff --git a/docs/uk-UA/index.html b/docs/uk-UA/index.html index 18ecbfc9..72bdd6fc 100644 --- a/docs/uk-UA/index.html +++ b/docs/uk-UA/index.html @@ -39,7 +39,7 @@ - + @@ -6163,14 +6163,14 @@ lli = function(line1, line2):

How does that work? Succinctly: we run de Casteljau's algorithm in reverse!

- In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that want to - be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know has - no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for + In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that we want + to be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know + has no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for reasons that will become obvious.

So let's use graphics instead of text to see where this "A" is, because text only gets us so far: move the sliders for the following - graphics to see what, given specific t value, our A coordinate is. As well as some other coordinates, which + graphics to see what, given a specific t value, our A coordinate is. As well as some other coordinates, which taken together let us derive a value that the graphics call "ratio": if you move the curve's points around, A, B, and C will move, what happens to that value?

@@ -6236,7 +6236,7 @@ lli = function(line1, line2): and so neither will C, and if you move either start or end point, C will move but its relative position will not change.

- So, how can we compute C? We start with our observation that C always lies somewhere between the start and ends + So, how can we compute C? We start with our observation that C always lies somewhere between the start and end points, so logically C will have a function that interpolates between those two coordinates:

- So, if we know the start and end coordinates, and we know the t value, we know C, without having to calculate the - A or even B coordinates. In fact, we can do the same for the ratio function: as another function of - t, we technically don't need to know what A or B or C are, we can express it was a - pure function of t, too. + So, if we know the start and end coordinates and the t value, we know C without having to calculate the A or even + B coordinates. In fact, we can do the same for the ratio function. As another function of t, we technically + don't need to know what A or B or C are. It, too, can be expressed as a pure function of + t.

We start by observing that, given A, B, and C, the following always holds:

- Which now leaves us with some powerful tools: given thee points (start, end, and "some point on the curve"), as well as a - t value, we can construct curves: we can compute C using the start and end points, and our + Which now leaves us with some powerful tools: given three points (start, end, and "some point on the curve"), as well as a + t value, we can construct curves. We can compute C using the start and end points and our u(t) function, and once we have C, we can use our on-curve point (B) and the ratio(t) function to find A:

@@ -6346,7 +6346,7 @@ lli = function(line1, line2): ╰ 2 t --> -

And then reverse engineer the curve's control control points:

+

And then reverse engineer the curve's control points:

- So: if we have a curve's start and end point, then for any t value we implicitly know all the ABC values, which (combined + So: if we have a curve's start and end points, then for any t value we implicitly know all the ABC values, which (combined with an educated guess on appropriate e1 and e2 coordinates for cubic curves) gives us the necessary information to reconstruct a curve's "de Casteljau skeleton". Which means that we can now do several things: we can "fit" curves using only three - points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end point, and then reconstructing the + points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end points, and then reconstruct the curve based on where we moved the on-curve point to. These are very useful things, and we'll look at both in the next few sections.

diff --git a/docs/zh-CN/index.html b/docs/zh-CN/index.html index 394cd62c..c70790ca 100644 --- a/docs/zh-CN/index.html +++ b/docs/zh-CN/index.html @@ -41,7 +41,7 @@ - + @@ -6004,14 +6004,14 @@ lli = function(line1, line2):

How does that work? Succinctly: we run de Casteljau's algorithm in reverse!

- In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that want to - be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know has - no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for + In order to run de Casteljau's algorithm in reverse, we need a few basic things: a start and end point, a point on the curve that we want + to be moving around, which has an associated t value, and a point we've not explicitly talked about before, and as far as I know + has no explicit name, but lives one iteration higher in the de Casteljau process then our on-curve point does. I like to call it "A" for reasons that will become obvious.

So let's use graphics instead of text to see where this "A" is, because text only gets us so far: move the sliders for the following - graphics to see what, given specific t value, our A coordinate is. As well as some other coordinates, which + graphics to see what, given a specific t value, our A coordinate is. As well as some other coordinates, which taken together let us derive a value that the graphics call "ratio": if you move the curve's points around, A, B, and C will move, what happens to that value?

@@ -6077,7 +6077,7 @@ lli = function(line1, line2): and so neither will C, and if you move either start or end point, C will move but its relative position will not change.

- So, how can we compute C? We start with our observation that C always lies somewhere between the start and ends + So, how can we compute C? We start with our observation that C always lies somewhere between the start and end points, so logically C will have a function that interpolates between those two coordinates:

- So, if we know the start and end coordinates, and we know the t value, we know C, without having to calculate the - A or even B coordinates. In fact, we can do the same for the ratio function: as another function of - t, we technically don't need to know what A or B or C are, we can express it was a - pure function of t, too. + So, if we know the start and end coordinates and the t value, we know C without having to calculate the A or even + B coordinates. In fact, we can do the same for the ratio function. As another function of t, we technically + don't need to know what A or B or C are. It, too, can be expressed as a pure function of + t.

We start by observing that, given A, B, and C, the following always holds:

- Which now leaves us with some powerful tools: given thee points (start, end, and "some point on the curve"), as well as a - t value, we can construct curves: we can compute C using the start and end points, and our + Which now leaves us with some powerful tools: given three points (start, end, and "some point on the curve"), as well as a + t value, we can construct curves. We can compute C using the start and end points and our u(t) function, and once we have C, we can use our on-curve point (B) and the ratio(t) function to find A:

@@ -6187,7 +6187,7 @@ lli = function(line1, line2): ╰ 2 t --> -

And then reverse engineer the curve's control control points:

+

And then reverse engineer the curve's control points:

- So: if we have a curve's start and end point, then for any t value we implicitly know all the ABC values, which (combined + So: if we have a curve's start and end points, then for any t value we implicitly know all the ABC values, which (combined with an educated guess on appropriate e1 and e2 coordinates for cubic curves) gives us the necessary information to reconstruct a curve's "de Casteljau skeleton". Which means that we can now do several things: we can "fit" curves using only three - points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end point, and then reconstructing the + points, which means we can also "mold" curves by moving an on-curve point but leaving its start and end points, and then reconstruct the curve based on where we moved the on-curve point to. These are very useful things, and we'll look at both in the next few sections.