Over the last 2 days, I've fallen down the mathematical pattern rabbit hole, and
have been experimenting with all manner of what can be done with a simple
pigment {function {}}
statement.

I currently have a list of 155 different patterns, including simple y = f(x)
style functions, implicit equations (some combination of x&y) = (some other
combination of x&y), and even some parametric polar equations and what I believe
are parametric Cartesian equations.

Hammering out that many equations one after the other and using different
methods to visualize the "raw" results has allowed me to learn some new things
and gain valuable insights into how best achieve a good, aesthetically pleasing
result, and why some patterns might be difficult to implement in the absence of
various "tricks".

At this junction, I would like to thank everyone in the POV-Ray community, and
especially Tor Olav Kristensen, Sam Benge, jr, William Pokorny, Jerome Grimbert,
as well as the vast Shadertoy community - most notably Inigo Quilez, Martijn
Steinrucken, and FabriceNeyret2, for inspiring me, and setting me on the path of
discovery with regard to using functions to make amazing patterns.

With that, I'll just leave here a most amazing Greek frieze pattern, produced by
an astonishingly small amount of code, adapted to SDL from a shader by
FabriceNeyret2.

While this is probably one of the most complex patterns I've adapted, simply due
to some specialized and highly technical methods that make its visibility even
possible, I'd love to see people experimenting with simple equations to produce
interesting patterns that we can build a library of.

After progressively trimming down the amount of code I need to make a simple
grid on a plane, I'd love to see such patterns code-golfed down to the bare
minimum, and then parameterized to increase their variation and versatility.

Happy New Year, everyone.

- Bald Eagle

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (973 KB)

Preview of image 'mathpatterns1.png'

Op 05/01/2024 om 22:50 schreef Bald Eagle:
> 
> [snip]
> 
> While this is probably one of the most complex patterns I've adapted, simply due
> to some specialized and highly technical methods that make its visibility even
> possible, I'd love to see people experimenting with simple equations to produce
> interesting patterns that we can build a library of.
> 
> After progressively trimming down the amount of code I need to make a simple
> grid on a plane, I'd love to see such patterns code-golfed down to the bare
> minimum, and then parameterized to increase their variation and versatility.
> 
> Happy New Year, everyone.
> 

First of all: a Happy (and POV-Productive) New Year.

I am literally speechless. You did an awesome bit of work and I wouldn't 
know where to begin, especially as my mathematical skills are rather 
rudimentary. Are you going to provide us with some basic guide lines on 
how to start such experimentation? I guess that would be needed for 
several of us, setting us on our way.

Thanks indeed for your - and all those others - great work!

-- 
Thomas

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
> Over the last 2 days, I've fallen down the mathematical pattern rabbit hole, and
> have been experimenting with all manner of what can be done with a simple
> pigment {function {}}
> statement.
>

Excellent!!

I always had/have hoped that at some time the function language would grow a bit
in the direction of shaders by making more/all internal data available to
functions. Colour and normals are obvious, but just think of having also data on
radiosity, photons and what else there is inside POV-Ray that can be (ab)used.
These internal data do not even have to have any relation to textures or
objects. It's up to the artist to do something with them.

Photon data based displacement mapping for re-modeling meshes ...

A texture dependent on the number of times the light ray bounced before
intersection. Or normals based on the total length of a ray.


"Geluk in' tuk" (good luck in your pocket) for 2024,

ingo

Post a reply to this message

Thomas de Groot <tho### [at] degrootorg> wrote:

> First of all: a Happy (and POV-Productive) New Year.

Thanks Thomas, I hope to see some more excellent landscapes, textures, or even
just doodles with no particular point behind them.

> I am literally speechless.

Ha!  So was I.  :D  The shader is literally only 6 lines of code.
It still took me a fair amount of time to grope in the pitch black towards a
solution.

The funny thing is, earlier in the day I had been struggling (once more) to make
a simple spiral pattern, and here is a spiral, evenly divided into cells by
spiral arc-length, with different animated spirals in each cell!
I was also really happy that the solution relied on using the fwidth function,
as that lit a fire under my lazy butt to actually implement that in SDL as well.

So now I think I actually have all of the tools to push  forward on coding the
knots in the wood texture, along with the spiral interpolation thing... all
because I was doing something completely unrelated, and juts serendipitously
stumbled upon a shader that was linked from a page I found through an image
search.

> You did an awesome bit of work and I wouldn't
> know where to begin, especially as my mathematical skills are rather
> rudimentary.

You, and Kenneth, and jr have all expressed as much, but I will tell you that
it's less about "knowing" the math, than simply acquiring a "feel" for it - a
sense of what types of things are related to what you're trying to accomplish,
or recognizing what terms in an equation are likely to be related to what parts
of the graph's shape.
Playing with an existing equation can rapidly sort all of that out, even if
initially it's all as opaque as obsidian.

> Are you going to provide us with some basic guide lines on
> how to start such experimentation? I guess that would be needed for
> several of us, setting us on our way.

Yes, I started summarizing the things I discovered in a comment section of my
patterns scene, and I'm hoping at some point to make further progress on a
function monograph that I started, specifically with jr and Kenneth in mind.

I think there are several things that have prevented me from successfully coding
some of the patterns that I've tried to reproduce in the past - and that makes
me think that I was probably tantalizingly close, but either I fell into the
trap of convincing myself that "it just couldn't be done", or there were some
finer points of how to visualize what was going on that I was missing.
I'm sure I must have threw away a few equations here & there in this last coding
frenzy, simply because I forgot to subtract the whole thing from y, and so it
just looked like a lot of random static.

I'm finishing up an extended family visit, and have an event to attend later
this evening, but after I get everything settled after that, I ought to have
some uninterrupted hours to devote to doing some more experiments, writing some
educational code, and hopefully finding ways to create some example scenes and
explain things clearly enough so that it's easy enough to follow.

It would actually help a lot to just write out a big list of things that you've
always wondered about, want to do, tried but were confused by, or any other
curiosities and speculations - so that I have a target to aim for.
It's not so much that "you don't know math / were never taught it / don't have
the skills", but WHY certain things are confusing or unknown to you.

Then I can think about what needs explaining, how best to explain it, and what
examples I can code to best illustrate the concepts.  And to be honest, I'm
still at the stage where I don't clearly understand exactly how half of the
stuff I code actually works - so I may do a lot of hand-waving until some of the
smarter people (TOK, Jerome, WFP, Ingo) chime in with explanations or links that
lead me by the nose hairs to enlightenment.

All the best,

- BW

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
>
> With that, I'll just leave here a most amazing Greek frieze pattern, produced by
> an astonishingly small amount of code, adapted to SDL from a shader by
> FabriceNeyret2.
>

That is spectacularly beautiful! I'm dumbfounded, and amazed that your got
POV-ray to render such a fantastical pattern.

Keep at it, by all means; I can't wait to see what else you come up with.

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
>...
> With that, I'll just leave here a most amazing Greek frieze pattern, produced by
> an astonishingly small amount of code, adapted to SDL from a shader by
> FabriceNeyret2.
>...

Very nice. Well done!

I'm glad to see that you are advancing your math and coding skills Bill.

--
Tor Olav
http://subcube.com
https://github.com/t-o-k

Post a reply to this message

"Tor Olav Kristensen" <tor### [at] TOBEREMOVEDgmailcom> wrote:

> Very nice. Well done!
>
> I'm glad to see that you are advancing your math and coding skills Bill.

Well, I'm moving forward bit by bit, but all the credit for that pattern
definitely goes to the author.

There's a function or two that I need to puzzle out to understand what they do
and how they are so essential to creating the pattern.

Just as a reminder to myself, I may have to branch out into the 3rd dimension to
see if I can work some of the same "magic" with media density by incorporating
z.

However, along those lines, I was admiring another nice little piece of work
that I stumbled across, and it prompted me to work out the gory details of
Euler's formula, Taylor series, and all of that "e to the power of" stuff that
seems to creep into all manner of interesting topics.

I edited the poem a bit, but shamelessly stole the idea (even though I had to
painfully work out the implementation from first principles).  I didn't realize
I'd need about 20 terms in the Taylor series to get a good enough approximation.
 :O

Enjoy the eye and mind candy.

- BW

Post a reply to this message

Attachments:
Download 'eulergaussspiral.png' (218 KB)

Preview of image 'eulergaussspiral.png'

Op 09/01/2024 om 21:07 schreef Bald Eagle:
> Enjoy the eye and mind candy.
> 

Oh LOL! Well done :-)

-- 
Thomas

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
> Over the last 2 days, I've fallen down the mathematical pattern rabbit hole, and
> have been experimenting with all manner of what can be done with a simple
> pigment {function {}}
> statement.
>
> I currently have a list of 155 different patterns, including simple y = f(x)
> style functions, implicit equations (some combination of x&y) = (some other
> combination of x&y), and even some parametric polar equations and what I believe
> are parametric Cartesian equations.
>
> Hammering out that many equations one after the other and using different
> methods to visualize the "raw" results has allowed me to learn some new things
> and gain valuable insights into how best achieve a good, aesthetically pleasing
> result, and why some patterns might be difficult to implement in the absence of
> various "tricks".
>
> At this junction, I would like to thank everyone in the POV-Ray community, and
> especially Tor Olav Kristensen, Sam Benge, jr, William Pokorny, Jerome Grimbert,
> as well as the vast Shadertoy community - most notably Inigo Quilez, Martijn
> Steinrucken, and FabriceNeyret2, for inspiring me, and setting me on the path of
> discovery with regard to using functions to make amazing patterns.
>
> With that, I'll just leave here a most amazing Greek frieze pattern, produced by
> an astonishingly small amount of code, adapted to SDL from a shader by
> FabriceNeyret2.
>
> While this is probably one of the most complex patterns I've adapted, simply due
> to some specialized and highly technical methods that make its visibility even
> possible, I'd love to see people experimenting with simple equations to produce
> interesting patterns that we can build a library of.
>
> After progressively trimming down the amount of code I need to make a simple
> grid on a plane, I'd love to see such patterns code-golfed down to the bare
> minimum, and then parameterized to increase their variation and versatility.
>
> Happy New Year, everyone.
>
> - Bald Eagle

Wow, this one looks not easy and beautiful.

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:

(Still experimenting and struggling with various aspects of getting patterns
from other platforms to play well with SDL.)

> Hammering out that many equations one after the other ... has allowed me to learn
some new things and gain valuable i
nsights ...



OK, just to list the ones that I've written down so far:
(Questions, comments, and constructive criticism welcome as always)

Important tips to generate quality patterns from equations
----------------------------------------------------------
Be very careful with the use of parentheses - especially when + or - is in an
equation.  Group terms.
 You may want to declare different parts of a complex equation as separate
functions, then combine them in the final function
Use fmod instead of mod to get a regular repetition of a pattern across the
origin
 HOWEVER, sometimes using mod in certain functions gives a better (more
expected) result - so try both
Use Mike Williams' "shell" trick for isosurfaces to give an infinitely thin line
a visible thickness
Change the line thickness to give definition to patterns that may not show up
with smaller values.
Some equations don't cross the zero/integer/mod threshold often enough to show
finer details.  Multiply the
WHOLE equation (use parentheses) by a factor to increase the number of
lines/levels.
Zoom in or out to see pattern attributes that may not be visible or clearly
rendered.
If you're graphing y as a function of x, then you must write it in the form of:
function {y - formula} since when y=formula, the value is 0
If you're graphing a 2-argument function of both x and y, then you must write it
in the form of: function {(x - x_formula) + (y - y_formula)}

If you're graphing a polar equation, then write it in the form of: function {r -
formula}

POV-Ray's internal method of wrapping function values winds up hiding negative
vs positive parts,
 and won't be revealed until made as an isosurface, or the function is shifted
by + 0.5 and visualized with a color map

If you're using functions that return values in the 0-255 range, you're going to
have to divide the result by 255

If the function repeats over a range of 0-255, then you're going to have to use
mod (Function (x, y, z), 256)/255

You're going to need function versions of HSV to RGB to perform color
calculations

For full-color patterns, you're going to separate functions for r, g, and b,
plus an average texture using all 3 functions

There are common functions and operations that the function parser doesn't
recognize, and you'll have to write your own versions of

identifiers previously declared in a scene (even for loop iterators!) cannot
then be used in a function

If you're experiencing a blank pattern (all black/white/gray) then you have
likely forgotten to explicitly include x, y, and z into your function
argument list.  If your function takes some value N as an argument, but also
uses x, y, or z, then you must #declare F = function (x, y, z, N) {}

If your pattern only appears in the first quadrant (upper right, both x and y
are positive), then you will likely need to use abs(X) and abs(y) in your
equation

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
> "Bald Eagle" <cre### [at] netscapenet> wrote:
>
> (Still experimenting and struggling with various aspects of getting patterns
> from other platforms to play well with SDL.)
>
> Important tips to generate quality patterns from equations
> ----------------------------------------------------------

> Use Mike Williams' "shell" trick for isosurfaces to give an infinitely thin line
> a visible thickness

Say what??!!
That would be really useful.

Do you have a link to this trick, or a short explanation? (--keeping my fingers
crossed--)

Post a reply to this message

"Kenneth" <kdw### [at] gmailcom> wrote:
> "Bald Eagle" <cre### [at] netscapenet> wrote:

>
> > Use Mike Williams' "shell" trick for isosurfaces to give an infinitely
> > thin line a visible thickness
>
>
> Do you have a link to this trick, or a short explanation? (--keeping my fingers
> crossed--)

I just took a look at the Mike Williams 'isosurface tutorial' that you packaged
and sent to me as a .pdf file some years ago. Is the technique you refer to here
the same as Mike's 'thickening' trick using 2 parallel surfaces (page 18 of
149)? Or is it something different?

Thickening--
If we have a function F(x,y,z) we can turn it into two parallel surfaces by
using abs(F(x,y,z))-C where C is some small value. The original function should
be one that works with zero threshold. The two resulting surfaces are what you
would get by rendering the original function with threshold +C and -C, but
combined into a single image. The space between the two surfaces becomes the
"inside" of the object. In this way we can construct things like glasses and
cups that have walls of non-zero thickness.

[example:]
#declare F = function {y + f_noise3d (x*2, 0, z*2)}
isosurface {
function {abs (F(x, y, z))-0.1}
......

Post a reply to this message

"Kenneth" <kdw### [at] gmailcom> wrote:

> Is the technique you refer to here
> the same as Mike's 'thickening' trick using 2 parallel surfaces (page 18 of
> 149)? Or is it something different?

It is the same - yet with a slight difference.

If you're trying to make a black pattern on a white background, you're going to
want a solid black pattern, not a small gradient from -C to 0 to +C.

So you just use select to make a discontinuous function.

#declare Pattern = function {select (abs(F(x,y,z)-C, 0, 0, 1)}

And then when you do plane {z, 0, pigment {function {Pattern (x, y, z)}}}, you
get what you're probably expecting.

- BW

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
> "Kenneth" <kdw### [at] gmailcom> wrote:
>
> > Is the technique you refer to here
> > the same as Mike's 'thickening' trick using 2 parallel surfaces (page 18 of
> > 149)? Or is it something different?
>
> It is the same - yet with a slight difference.
>
> If you're trying to make a black pattern on a white background, you're going to
> want a solid black pattern, not a small gradient from -C to 0 to +C.
>
> So you just use select to make a discontinuous function.
>
> #declare Pattern = function {select (abs(F(x,y,z)-C, 0, 0, 1)}
>
> And then when you do plane {z, 0, pigment {function {Pattern (x, y, z)}}}, you
> get what you're probably expecting.
>
Great, thanks. Yes, you were reading my mind, ha. (Actually, my own use would be
the reverse-- a white pattern on a black background.) I'll test it and play...

Post a reply to this message

I played with a few more functions - I think I'm up to about 189 in the
collection, and still have many more to implement.

This one I liked because it was "simple", and would probably find use in any
number of scenes, for different purposes.

Like the ultra-impressive Greek frieze pattern, this one got adapted from
Desmos, and it takes a lot of reading and thinking to grasp Desmos' syntax /
expression structure, unravel what is meant, and discard the superfluous parts.

I got it wrong about a dozen times, but in the process found that sometimes the
mistakes yield some pretty amazing and complex pattern in and of themselves.
So, when experimenting with new patterns, don't give up, and don't be surprised
when the raw pattern seems to bear absolutely no relation to the pattern that
you're trying to code.  The raw vs "thickened" pattern can differ - starkly - in
appearance.

Hopefully we can get a few new patterns posted in this thread, and I'm going to
try to post at least one new pattern a week, to keep some momentum going.

Hope you like.

- BE

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (59 KB)

Preview of image 'mathpatterns1.png'

"Bald Eagle" <cre### [at] netscapenet> wrote:
> I'm going to try to post at least one new pattern a week, to keep some momentum
going.

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (193 KB)

Preview of image 'mathpatterns1.png'

Neat grid pattern.

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (15 KB)

Preview of image 'mathpatterns1.png'

"Bald Eagle" <cre### [at] netscapenet> wrote:
> "Bald Eagle" <cre### [at] netscapenet> wrote:
> > I'm going to try to post at least one new pattern a week, to keep some momentum
going.

I like this one.

It seems like you're getting pretty good at this.

--
Tor Olav
http://subcube.com
https://github.com/t-o-k

Post a reply to this message

"Tor Olav Kristensen" <tor### [at] TOBEREMOVEDgmailcom> wrote:

> I like this one.

I do too, which is why I posted it.
It brought to mind the vintage Corelle plate rim pattern. (attached)

> It seems like you're getting pretty good at this.

I'm getting a bit better at finding interesting patterns and translating them
from other languages/syntaxes.

I still have a devil of a time with some of them.
Some I can't get to work at all, especially if I have to make lines, use x and y
at the same time, or try to make a parametric function based on atan2(y, x).

I'm also trying to figure out why sometimes I only get a partial pattern.
But they _are_ more than formless grayscale vomit, so there is definitely some
progress.

When I understand WHY things work or don't, and know enough to fix them, then I
will be lots better.

When I can invent such functions on my own, then I will be good.

But that was half of the goal of this - to try implementing so many functions
that eventually I found changes that worked, and could be applied to others that
failed, and iteratively get better.

I'm almost at 200 functions, and at some point I'll have (temporarily) run out
of patterns to copy, and can start investigating variations and combinations.

There also seems to be various common methods for making patterns, and perhaps I
can distill them all down into several macros to make rendering each method a
little easier.

Thank you as always for your interest, tutelage, and encouragement.  :)
- BW

Post a reply to this message

Attachments:
Download 'p0000016777s000000469617t1.jpg' (81 KB)

Preview of image 'p0000016777s000000469617t1.jpg'

Here's one to torture your eyes.  :P

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (422 KB)

Preview of image 'mathpatterns1.png'

This one's sort of like dice.

mod (floor(x)+floor(y), 2) somehow is NOT the same as even (floor(x)+floor(y))

IIRC, Bill Pokorny mentioned something about how floor isn't quite "right".

anyway, this is the last one for the night.

- BW

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (145 KB)

Preview of image 'mathpatterns1.png'

On 13/02/2024 00:46, Bald Eagle wrote:
> Hopefully we can get a few new patterns posted in this thread, and I'm going to
> try to post at least one new pattern a week, to keep some momentum going.



Excellent work! Congratulations

-- 
Kurtz le pirate
Compagnie de la Banquise

Post a reply to this message

On 2/13/24 21:03, Bald Eagle wrote:
> Here's one to torture your eyes.  :P

It does dance around! :-)

Bill P.

Post a reply to this message

On 2/13/24 22:24, Bald Eagle wrote:
> IIRC, Bill Pokorny mentioned something about how floor isn't quite "right".

IICRC... Rings a bell.

With yuqk, I do remember changing the code which creates the 0-1 ramp 
wave - in official POV-Ray there is some hard coded magic which 
sometimes causes trouble if one hits the right (wrong) values.

There is too some hard code clamping of values coming from functions 
into the pattern mechanism that I removed. However, this bit, from your 
results, I would say you are already avoiding. (That you are limiting 
your function() values into the pattern mechanism to 0-1 or >0.0 ranges)

Bill P.

Post a reply to this message

Le 2024-02-13 à 21:03, Bald Eagle a écrit :
> Here's one to torture your eyes.  :P
It moves.
There are colour spots popping everywhere.
It shakes.

Post a reply to this message

Le 2024-02-13 à 22:24, Bald Eagle a écrit :
> This one's sort of like dice.
> 
> mod (floor(x)+floor(y), 2) somehow is NOT the same as even (floor(x)+floor(y))
> 
> IIRC, Bill Pokorny mentioned something about how floor isn't quite "right".
> 
> anyway, this is the last one for the night.
> 
> - BW
Another that play tricks with your eyes...

Post a reply to this message

This is very similar in concept to the Voronoi pattern, and indeed, if the
"annular rings" are fine enough, one gets the visual impression of Voronoi cells
filled with a concentric ring pattern.

I just did this for fun, to illustrate a practical pattern to use for ripples in
water, malachite, rhodochrosite, wood, "jawbreaker" candies, etc, and to
implement an example that makes use of splines, loops, pseudorandom numbers, and
a discrete set of "basis functions" that are evaluated "en-masse".

Enjoy the "bubbles".

(Speaking of which, this could be a fun one to apply iridescence to...)

I'd have to think about how to vary the "radius" of each seed point, and then
apply the true bubble intersection formula to get a nice foam cross-section.
Foam isosurface, anyone?

- BE

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (704 KB)

Preview of image 'mathpatterns1.png'

Triply Periodic Minimal Surface

left - open
right - closed
plane - pigment {function {TPMS}}

This one is called "SplitP"

Post a reply to this message

Attachments:
Download 'implicitlattice.png' (711 KB)

Preview of image 'implicitlattice.png'

hi,

"Bald Eagle" <cre### [at] netscapenet> wrote:
> ...
> plane - pigment {function {TPMS}}

v nice.  I bet it would be "lush" as a woven fabric/cloth.

(light-green with envy :-))


regards, jr.

Post a reply to this message

"jr" <cre### [at] gmailcom> wrote:

> v nice.  I bet it would be "lush" as a woven fabric/cloth.

There's a better one for that, I think - the "Honeycomb" that I found in a
paper.
Kinda looks like a "dog bone" wood patch that alternates in directions like a
checkerboard.

A lot of these are, incidentally, used for support-fill for 3D printing
applications - so Kenneth may have a very practical interest.

Since they can partition space into 2 parts acting as a membrane in between,
when they are given thickness and made of metal, they are being evaluated as
heat-transfer devices, very much like a car radiator works.
The key factor being the very high surface area able to be contained in a very
small space.

> (light-green with envy :-))

You shouldn't be.  You can copy-paste equations as well as I can.  :P

- BW

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
> "jr" <cre### [at] gmailcom> wrote:
>
> > v nice.  I bet it would be "lush" as a woven fabric/cloth.
>
> There's a better one for that, I think - the "Honeycomb" that I found in a
> paper.
> Kinda looks like a "dog bone" wood patch that alternates in directions like a
> checkerboard.

Sometimes these things are a little easier to write using some helper functions.

#declare S2P = function (V) {sin (tau*V/L)}
#declare C2P = function (V) {cos (tau*V/L)}
#declare T = 0.5;
#declare N = 1;
#declare Honeycomb = function (X, Y, Z) {pow(S2P(X)*C2P(Z) + S2P(Z) + C2P(X), N)
- pow(T, N)}

Post a reply to this message

Attachments:
Download 'implicitlattice.png' (600 KB)

Preview of image 'implicitlattice.png'

I think I was playing around with the AI again, and the simplest function caught
my eye.

Slumbering neurons were roused, and I realized that although I didn't have
access to POV-Ray, I _did_ have access to Desmos.

Graphing cos(x) * sin (y) revealed a very surprising pattern, and I did a little
bit of follow-up development from there.  Subtracting a constant in between 0
and 1 changes the pattern from circles, to squircles, to squares.

So then, I had to transition between simple graphing, and mapping equations to a
plane with functions.  I had a surprisingly difficult time getting the lines to
match the dots at the proper slopes, and I had to introduce fudge factors to get
the lines to accurately match the frequency of the dots.

Blah blah blah - here's the original basic pattern and the triangular grid that
I made based on that.

I also needed to alter my fmod function, and I still need to add another level
of select () to fix the doubling of the lines across N=0.

Post a reply to this message

Attachments:
Download 'mathpatterns2.png' (321 KB)

Preview of image 'mathpatterns2.png'

"Bald Eagle" <cre### [at] netscapenet> wrote:

> I also needed to alter my fmod function, and I still need to add another level
> of select () to fix the doubling of the lines across N=0.

I fixed that, and then added an averaged texture to throw some color into the
mix, and by using both functions and scaling the original pattern, you can see
how one relates to the other.

Bet you can even see the cubes and hexagons hidden in there...

Post a reply to this message

Attachments:
Download 'mathpatterns2.png' (555 KB)

Preview of image 'mathpatterns2.png'

I cannot possibly imagine how they came up with this one.

Post a reply to this message

Attachments:
Download 'mathpatterns2.png' (149 KB)

Preview of image 'mathpatterns2.png'

"Bald Eagle" <cre### [at] netscapenet> wrote:
> Over the last 2 days, I've fallen down the mathematical pattern rabbit hole, and
> have been experimenting with all manner of what can be done with a simple
> pigment {function {}}
> statement.
>

Two older ones for your collection. Thing I found on the web years ago:

---%<------%<---
// Persistence of Vision Ray Tracer Scene Description File
// File: contour.pov
// Vers: 3.5
// Desc: contour plots Idea: Eric Weeks
// http://www.physics.emory.edu/~weeks/ideas/tplot.html
// Date: 2003
// Auth: Ingo Janssen

#version 3.5;

#include "gradients.inc"
//https://news.povray.org/povray.binaries.scene-files/message/%3CXnsA9D7C1F3776F3seed7%40news.povray.org%3E/#%3CXnsA9D7
C1F3776F3seed7%40news.povray.org%3E

global_settings {assumed_gamma 1.0}
camera {location <0,0,-25> look_at 0}

#declare Contour = function(x,y,z,A,B,C,D,E,F,I,J,K,L) {
  E*sin(A*sin(I*x)+ B*cos(J*y))+F*cos(C*cos(K*x)+D*sin(L*y))
}

#declare A =1;
#declare B =1;
#declare C =1;
#declare D =1;
#declare E =1;
#declare F =1;

#declare I =1;
#declare J =1;
#declare K =1;
#declare L =1;

#declare Test  = function(Pf){
   (G_smoothstep(Pf,0.1,0.15)-G_smoothstep(Pf,0.15,0.2))
  +(G_smoothstep(Pf,0.4,0.6)-G_smoothstep(Pf,0.7,.9))
};

plane {
  -z, 0
  pigment {
    function{Contour(x,y,z,A,B,C,D,E,F,I,J,K,L)}

    //function{G_Blinn_Wyvill(Contour(x,y,z,A,B,C,D,E,F,I,J,K,L))}

    //function{Test(Contour(x,y,z,A,B,C,D,E,F,I,J,K,L))}

    //function{abs(Contour(x,y,z,A,B,C,D,E,F,I,J,K,L))}

    //sine_wave
    colour_map {
      [0 rgb 0]
      [1 rgb 1]
    }
  }
  finish {ambient 1}
}
---%<------%<---

---%<------%<---
// POV-Ray 3.7
// Ingo
// found on a Japanese site
// +w1280 +h480 +a0.05 +am3 +ac0.90 +r3
#version 3.7;
global_settings{assumed_gamma 1}
#default{ finish{ambient 0 diffuse 1}}
camera {
  orthographic
  location <0,0,1>
  look_at 0
  right x*image_width/image_height
}
#declare PHI = 1.61803399;

// Shuhei Kawachi
// A>0
#declare ShuheiKawachi = function (x,y,z,A,B){
  ((cos(x)*cos(y)+cos((sqrt(A)*x-y)/B)*
  cos((x+sqrt(A)*y)/B)+cos((sqrt(A)*x+y)/B)*
  cos((x-sqrt(A)*y)/B)))/3///6 + 0.5
}


plane{ <0,0,-1>, 0
  texture {
    pigment {
      //function{(ShuheiKawachi(x,y,z,pi,1.5))}
      function{abs(ShuheiKawachi(x,y,z,pi,1.5))}
      sine_wave
      scale 0.02
    }
    finish {ambient 1 diffuse 0}
  }
}
---%<------%<---

ingo

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:
> Over the last 2 days, I've fallen down the mathematical pattern rabbit hole, and
> have been experimenting with all manner of what can be done with a simple
> pigment {function {}}
> statement.

An old one by Alex Kluchikov, not a simple function though:

---%<------%<---

// Alex Kluchikov, 2003
// mailto: klk### [at] ukrnet, akl### [at] mailru
// Feel free to modify/use in any form
include "functions.inc"

camera{
 location -5*z
 look_at 0
 }

// we can get angle from gradient
#declare frad=function{
 pattern{radial}
 }

#declare fboz1=function{
 pattern{crackle form <1,0,0> scale 1}
 }

#declare fboz2=function{
 pattern{bumps noise_generator 3 rotate 60 scale 1.2}
 }

#declare fboz3=function{
 (sin(x+23)*sin(y+2)+sin(x*2.33443+11)*sin(y*2.4332+76)+sin(x*1.133443+32)*sin(y*1.234332+8)+3)*1/6
 }

#declare f1=function(x,y,z){
  (sin(fboz1(x,y,z)*24*pi
   +frad(fboz1(x,y,z)-fboz1(x,y-.07,z),0,fboz1(x,y,z)-fboz1(x+.07,y,z))
//gradient calculation
   *2*pi
//   +clock*pi*2 // uncomment to animate
   )+1)*(1/2)
   *(1-fboz1(x,y,z))
 }

#declare f2=function(x,y,z){
  (sin(fboz2(x,y,z)*24*pi
   +frad(fboz2(x,y,z)-fboz2(x,y-.07,z),0,fboz2(x,y,z)-fboz2(x+.07,y,z))
//gradient calculation
   *2*pi
//   +clock*pi*2 // uncomment to animate
   )+1)*(1/2)
 }

#declare f3=function(x,y,z){
  (sin(fboz3(x,y,z)*24*pi
   +frad(fboz3(x,y,z)-fboz3(x,y-.07,z),0,fboz3(x,y,z)-fboz3(x+.07,y,z))
//gradient calculation
   *2*pi
//   +clock*pi*2 // uncomment to animate
   )+1)*(1/2)
 }

#declare curles_1=texture{pigment{
  function{f1(x,y,z)}
  scale .25}
  finish{ambient 1}
  }

#declare curles_2=texture{pigment{
  function{f2(x,y,z)}
  color_map{[.45,color rgb 0][.55,color rgb 1]}
  scale .25}
  finish{ambient 1}
  }

#declare curles_3=texture{pigment{
  function{f3(x,y,z)}
  color_map{[.45,color rgb 0][.55,color rgb 1]}
  scale .25}
  finish{ambient 1}
  }

plane{
 -z,1
  //use curles_1, curles_2 or curles_2
  texture{curles_1}
 }
---%<------%<------
ingo

Post a reply to this message

Ha!
I think I have one of his "curles" patterns printed out somewhere here in a
pile.
I was just sifting through the archives and pulling out anything that seemed to
pop out.

Hopefully you know a few more - as you can tell, I love this stuff.

Post a reply to this message

I've also been interested in making this pattern:

http://sambrunacini.com/wp-content/uploads/2020/10/pursuit.png

and I could have sworn it has an actual NAME that I found once, and now I of
course can't find again.

Also of interest would be a metal diamond-plate pattern - the "honeycomb"
pattern that I posted for jr has that alternating direction / row attribute that
might be a good starting point for modification.

Post a reply to this message

"Bald Eagle" <cre### [at] netscapenet> wrote:

> Also of interest would be a metal diamond-plate pattern - the "honeycomb"
> pattern that I posted for jr has that alternating direction / row attribute that
> might be a good starting point for modification.

#declare YY = 0.625;
#declare Plate1 = function {select (1-pow(sin(2*pi*x)*cos(2*pi*YY) +
sin(2*pi*YY)*cos(2*pi*z) + sin(2*pi*z)*cos(2*pi*x), 2), 0, 0, 1)}

Post a reply to this message

Attachments:
Download 'mathpatterns2.png' (237 KB)

Preview of image 'mathpatterns2.png'

hi,

"Bald Eagle" <cre### [at] netscapenet> wrote:
> ...
> > Kinda looks like a "dog bone" wood patch that alternates in directions like a
> > checkerboard.
>
> Sometimes these things are a little easier to write using some helper functions.
>
> #declare S2P = function (V) {sin (tau*V/L)}
> #declare C2P = function (V) {cos (tau*V/L)}
> #declare T = 0.5;
> #declare N = 1;
> #declare Honeycomb = function (X, Y, Z) {pow(S2P(X)*C2P(Z) + S2P(Z) + C2P(X), N)
> - pow(T, N)}

plane with "Honeycomb" pattern, seen through "kaleidoscope".


regards, jr.

Post a reply to this message

Attachments:
Download 'ktpms.png' (440 KB)

Preview of image 'ktpms.png'

"jr" <cre### [at] gmailcom> wrote:

> plane with "Honeycomb" pattern, seen through "kaleidoscope".

Wheee!   Nice job.  :)

Can you adjust the symmetry?  Have 6-fold, or 7?

After playing with this stuff a bit, it seems like that whole sin*cos xy yz zx
thing has a lot of potential as a base pattern to do all sorts of interesting
things with.  Even just the threshold can change the apparent look quite a bit.
And then you have the orthogonal plane value/slice to vary.

We can square the whole sum, square the terms, take the root, etc.

- BW

Post a reply to this message

hi,

"Bald Eagle" <cre### [at] netscapenet> wrote:
> ...
> Wheee!   Nice job.  :)

start on.  :-)


> Can you adjust the symmetry?  Have 6-fold, or 7?
> After playing with this stuff a bit, it seems like that whole sin*cos xy yz zx
> thing has a lot of potential as a base pattern to do all sorts of interesting
> things with.  Even just the threshold can change the apparent look quite a bit.

yes, I just discovered that replacing "tau" with "pi * scale_factor" and using
slightly different factors, things get real .. interesting.

re your question, I answer with an Obama quote: "Yes, we can" :-)  below is
excerpted from my WIP code:

/* added bailout & max_trace */
global_settings {adc_bailout (1/254) assumed_gamma 1 max_trace_level 255}

/* #mirrors */
#declare n_ = 3;

#declare angle_ = 360 / n_;

/* epsilon */
#declare eps_ = 1e-3;

/* length of tube */
#declare len_ = 10;

/* prism with hole */
#declare pi_ = <.99,0,0>;
#declare po_ = <1.01,0,0>;

#declare pts_ = array [n_][2];

#for (i_, 0, n_-1)
  #local ta_ = vrotate(po_, <0,(angle_*i_),0>);
  #local tb_ = vrotate(pi_, <0,(angle_*i_),0>);
  #local pts_[i_][0] = <ta_.x,ta_.z>;
  #local pts_[i_][1] = <tb_.x,tb_.z>;
#end

/* rotate to centre on -z */
prism {
  linear_spline eps_, len_, 2*(1+n_),
  #for (i_,n_-1,0,-1) pts_[i_][0], #end pts_[n_-1][0],
  #for (i_,0,n_-1) pts_[i_][1], #end pts_[0][1]
  open
  sturm on
  no_shadow
  finish {ambient 0 reflection {1} specular 0}
  rotate <270,0,0>
}


regards, jr.

Post a reply to this message

This one looks like sliced pita bread or hot dogs buns or something.

#declare Pattern3 = function {tan (3*x) * sin (5*x/2) * sin (z) - 0.1}

Post a reply to this message

Attachments:
Download 'mathpatterns2.png' (602 KB)

Preview of image 'mathpatterns2.png'

An interesting approach that I'll have to look into further.

https://gcboore.com/pages/trigonometric-functions.html

Might be able to do the same thing with pigment patterns and homebrew function
patterns.

Post a reply to this message

On 28/08/2024 22:06, Bald Eagle wrote:
> An interesting approach that I'll have to look into further.
> 
> https://gcboore.com/pages/trigonometric-functions.html
> 
> Might be able to do the same thing with pigment patterns and homebrew function
> patterns.
> 

Really interesting, looking forward to the results of your experiments !
--
YB

Post a reply to this message

"jr" <cre### [at] gmailcom> wrote:
> "Bald Eagle" <cre### [at] netscapenet> wrote:
> > ...
> > #declare S2P = function (V) {sin (tau*V/L)}
> > #declare C2P = function (V) {cos (tau*V/L)}
> > #declare T = 0.5;
> > #declare N = 1;
> > #declare Honeycomb = function (X, Y, Z) {pow(S2P(X)*C2P(Z) + S2P(Z) + C2P(X), N)
> > - pow(T, N)}
>
> plane with "Honeycomb" pattern, seen through "kaleidoscope".

a loop-able animation of the pattern.  warning -- weird ;-).

<https://drive.google.com/file/d/1Aet9noapf8SBgX2u62TTYMFYx5NfbckT/view?usp=sharing>

enjoy, jr.

Post a reply to this message

Finally had a moment of clarity, and figured out a fish-scale pattern that I
wanted to make.

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (64 KB)

Preview of image 'mathpatterns1.png'

"Bald Eagle" <cre### [at] netscapenet> wrote:
> Finally had a moment of clarity, and figured out a fish-scale pattern that I
> wanted to make.

And here's a modification to make it less semi-circular.

Post a reply to this message

Attachments:
Download 'mathpatterns1.png' (45 KB)

Preview of image 'mathpatterns1.png'

I was trying to track down something completely unrelated, and came across this
page:

National Curve Bank
A Collection of Famous Plane Curves
created in POVRAY (Persistence Of Vision RAY tracing)

https://old.nationalcurvebank.org/povray/povray.htm

Post a reply to this message

Was setting up a basic scene for a completely unrelated pattern, and came up
with this.

Trying to consistently get functions to behave consistently across N=0 is a
giant PITA in POV-Ray, when I don't think it ought to be.


- BW

Post a reply to this message

Attachments:
Download 'newpattern.png' (282 KB)

Preview of image 'newpattern.png'