I have found an important (for me) pattern. Excuse me, let me record it here.


#declare f_crackle_base =
function(x, y, z) {
pow(
(1 - f_crackle(x, y, z + 2.7) ) ,
4
)
}




#declare bum_size = 0.98; // can be adjusted...

#declare f_bump_base =
function(x, y, z) {
pow(
f_bumps(x/bum_size, y/bum_size, z/bum_size),
1
)
}





#declare f_test =
function(x, y, z) {
f_crackle_base(x,y,z) * f_bump_base(x,y,z)
}



// -------- another part ------------------
#declare mappingBumpSize = 10.265;


#declare f_disturb_bump =
function(x, y, z) {
(
 1.0* f_bumps(x/mappingBumpSize, y/mappingBumpSize, z/mappingBumpSize)
 + 0.5* f_bumps(x/mappingBumpSize/0.5, y/mappingBumpSize/0.5,
z/mappingBumpSize/0.5 + 47.7)
) / 1.5

}



// ---------- combine ---------------------

#declare f_output2 =
function(x, y, z) {
f_test(
x , y,
 pow(
 (x*x + y*y)/ (f_disturb_bump(x, y, z)+1)
 , 0.75)
)
}

Post a reply to this message

Attachments:
Download 'cracke test 3 important.png' (2210 KB)

Preview of image 'cracke test 3 important.png'

The "f_disturb_bump" mentioned above can be a collocation, too.

Its value has some regular relation with the "f_output2"

Post a reply to this message

Attachments:
Download 'cracke test 4 f_disturb_bump.png' (385 KB)

Preview of image 'cracke test 4 f_disturb_bump.png'

Because the pattern has the feature of wood-cell-fiber, it is good to see the
interesting pattern.

The side section diagram:

Post a reply to this message

Attachments:
Download 'cracke test 5 side.png' (2272 KB)

Preview of image 'cracke test 5 side.png'

On 1/17/24 09:35, And wrote:
> Because the pattern has the feature of wood-cell-fiber, it is good to see the
> interesting pattern.
> 
> The side section diagram:

Yes, interesting - and cool looking. Hopefully I can spend a little time 
looking more at how this works.

Bill P.

Post a reply to this message

William F Pokorny <ano### [at] anonymousorg> wrote:
> On 1/17/24 09:35, And wrote:
> > Because the pattern has the feature of wood-cell-fiber, it is good to see the
> > interesting pattern.
> >
> > The side section diagram:
>
> Yes, interesting - and cool looking. Hopefully I can spend a little time
> looking more at how this works.
>
> Bill P.

I can explained it a little to save your time.
This is the first time I explore the f_crackle(x,y,z) pattern(in fact, I have
question to ask).


step1:

The "f_crackle_base" is a crackle pattern, I substract "f_crackle" from "1" for
I needing a 1.0 (white) value threads(voronoi  border) filled the space. Then
power(.., 4) to make the thread thiner.

Post a reply to this message

Attachments:
Download 'voronoi border.png' (693 KB)

Preview of image 'voronoi border.png'

My question is: Does POV-Ray have another version of voronoi pattern to use? I
said "Worley noise"
As a function?



---------------------------------------------

step2:

multiply "f_crackle_base" to a f_bumps(x,y,z) noise, the "f_bumps" noise should
change its relative size to "f_crackle", so I #declare bum_size to adjust it.


#declare f_test(x,y,z) =
function(x, y, z) {
f_crackle_base(x,y,z) * f_bump_base(x,y,z)
}



The "f_test" pattern:

Post a reply to this message

Attachments:
Download 'f_test.png' (664 KB)

Preview of image 'f_test.png'

step3:

f_disturb_bump(x,y,z) is another bumps pattern (It has two frequency). I wish
use it to disturb the "f_test" function, so I tried some combine method + - *
/...


And this one is awesome. When I see I feel... great.

#declare f_output2 =
function(x, y, z) {
f_test(
x , y,
 pow(
 (x*x + y*y)/ (f_disturb_bump(x, y, z)+1)
 , 0.75)
)
}


----------- ending -------------

Post a reply to this message

On 1/18/24 07:48, And wrote:
> My question is: Does POV-Ray have another version of voronoi pattern to use? I
> said "Worley noise"
> As a function?

First, thanks for the break down of how what you've done works.

On the Worley noise... The answer given has been that it can be 
duplicated with some set up of our crackle pattern, but I confess I've 
never looked closely enough to know if this is exactly so. Let me see if 
I can turn up references... Yes.

Ingo mentions the worley capability in the first post of this thread 
(and I'd guess from the whole thread blob based potential pattern of 
v3.8 might be able to emulate it too):

https://news.povray.org/povray.general/thread/%3CXnsAED66DFB68413seed7%40news.povray.org%3E/

Another thread from 2017:

https://news.povray.org/povray.general/thread/%3Cweb.5886420fb6cdab0dc437ac910%40news.povray.org%3E/

Having glanced at those threads wondering if yuqk's updated ripples and 
waves patterns might be a partial path too.

https://news.povray.org/povray.pov4.discussion.general/thread/%3C6415c37b%241%40news.povray.org%3E/

But again, I've never really looked at what others are calling Worley 
noise. Often with things like this there is sort of a base concept with 
lots of tuning / customization capability piled on top. What one person 
'calls' Worley noise might not be quite what someone else 'calls' Worley 
noise.

Aside: The craters discussion happening now in another thread reminded 
me that a long time ago I created an craters image based on crackle 
where I might have, more or less, stumbled upon a near 'worley' set up. 
Unfortunately, searches just now failed to turn up the work. Piles and 
piles of of half backed projects from days gone by... :-)

Ah, I'd guess this link might help too when looking at crackle's form 
vector:

https://www.imagico.de/pov/cr_form_en.php

especially maybe the javascript link on that page.

Bill P.

Post a reply to this message

On 1/19/24 06:23, William F Pokorny wrote:
> As a function?

Hit me while getting coffee this morning I didn't answer your second 
question.

You can turn any pattern into a function of your own with something like:

#declare FnCrackle = function { pattern { crackle form <-1,1,0> ... }

The bit wrapped in pattern{} there can be any sort of valid pattern 
specification as you'd set up for *_map use.

When you use something like 'f_crackle() in the official releases of 
POV-Ray, what your are really getting is a shipped user defined function 
coded at the bottom of functions.inc - and these are very simple 
implementations like:

#declare f_crackle = function { pattern {crackle} }

with no provided ability to set options(a).

Bill P.


(a) - This one of the shortcomings I've worked some to address in my 
yuqk fork / v4.0 suggestions. While I've not gotten to crackle, there 
is, for example, a true inbuilt f_agate() implementation which makes 
available all the options of the inbuilt pattern 'agate' as parameters 
(and a few additional options).

Post a reply to this message

William F Pokorny <ano### [at] anonymousorg> wrote:
> On 1/19/24 06:23, William F Pokorny wrote:
> > As a function?
>
> Hit me while getting coffee this morning I didn't answer your second
> question.
>
> You can turn any pattern into a function of your own with something like:
>
> #declare FnCrackle = function { pattern { crackle form <-1,1,0> ... }
>
> The bit wrapped in pattern{} there can be any sort of valid pattern
> specification as you'd set up for *_map use.
>
>

Thanks for your reminder. Although I ever use function {pattern {...}}, but I'm
not very familiar with it, so I forgot this a lot.

Post a reply to this message