Scripting a Spherical Noise Map Generator

A few weeks ago, I stumbled across an example Spherical Noise Map Generator using C++/libnoise. That got me to wondering if FF would be capable of doing it, too. I posted a Feature Request and emme helpfully supplied an example Map Script, pointing out that it could be further enhanced to multi-octave noise, and other cool things.

spherical_noise_v001.ffxml

I remembered one of the Script API I saved was for multi-octave perlin noise and went back to study it, for help making emme's example work along the same lines. Unfortunately, I'm pretty much a beginner with Lua, and it's been years since I've done any real coding, so I could not see a direct path to follow. It seems that the "multi-octave" portion of the script is already using a z-coordinate, so that struck me as a conflict even before I realized emme's 3-coordinate example sets up the variables in a very different way. As in, I barely understand the logic of what it's doing, so I can't follow the transition from my 2-coordinate multi-octave example to 3-coordinates.

Maybe somebody can help me with that. The API I'm referencing is: Script API - Multi-Octave Perlin.ffxml. This is going to be a learning project for me, and other features will come to mind, or variations along the same lines (I've mentioned exploring a way to do a Whorley noise spherical map generator, for example). I'm just not sure how much I have to study before I can figure this out on my own.

Whatever happens, I'll try to keep track of my progress here, for the benefit of anyone interested in the same challenge.

Thank you, emme! I'll check out your added features now. I discovered pretty quickly that learning Lua is going to be a little harder than I first thought. The documentation I've found so far is a bit dry and quite a bit shy of tutorials I can pick up on quickly. I still think it's worth learning, and I hope the forums here will help with that. I already have a few ideas of what features I'd like the component to have, starting with the usual: probably map inputs for color, roughness, contrast, and possibly distortion, with scale (already there), angle, details (now added) and variation. I think I'd also like to be able to pan through the 3 coordinates interactively to explore and position the noise. I did pick up the whorley noise API, today. I'll be interested to see what you come up with--you'll probably figure it out way ahead of me .

As for Blender, the answer helps. I imagine I'd have already learned how to do it if I'd experimented with texture baking beyond learning that it could be done. The first time is always a bit daunting.

I wrote a nice little post detailing my first update to emme's script, and it got discarded during preview as I was logged off the forum. Bother. Just to recap, what I remember, I found it easy to add offsets to the x, y and z coordinates via grayscale input. I tested it out with perlin noise inputs in seamless and non-seamless modes and the results were both seamless, so adding the values to the initial coordinate declarations worked fine. Obviously, the offsets can produce additional distortion, so extreme results are possible. I'm posting the script code for quick review, with the ffxml attached below.

I still need some tutoring or an example to follow up on adding Contrast or Roughness (independent of Details) to this. I just don't know the math for the first, and my example of the second is implemented very differently from emme's approach. I sort of understand what it's doing, but not well enough to adapt it.

Code

function prepare()    oct_max = get_intslider_input(NOISE_OCTAVES)    detail = 4 - get_slider_input(DETAIL) * 2 + 0.01    scale = get_slider_input(NOISE_SCALE) * 10 + 1    distort = get_slider_input(NOISE_DISTORT) *2    aspect = OUTPUT_HEIGHT / OUTPUT_WIDTH * 2    set_perlin_noise_seed(get_intslider_input(NOISE_SEED)) end; function get_sample(x, y)    local v = 0    local vosx = get_sample_grayscale(x, y, OFFSET_X)    local vosy = get_sample_grayscale(x, y, OFFSET_Y)    local vosz = get_sample_grayscale(x, y, OFFSET_Z)    local s = 500    local amp = 1    local x = x * aspect * math.pi    local y = y * math.pi    local nx = math.cos(x) * math.sin(y) * scale + vosx    local ny = math.sin(x) * math.sin(y) * scale + vosy    local nz = math.cos(y) * scale + vosz    for oct = 1, oct_max do       local d1 = get_perlin_noise(nx+1,ny,nz,s) * distort       local d2 = get_perlin_noise(nx+2,ny,nz,s) * distort       local d3 = get_perlin_noise(nx+3,ny,nz,s) * distort       if oct == 1 then v = get_perlin_noise(nx+d1,ny+d2,nz+d3,s) else          v = (v + get_perlin_noise(nx+d1/oct,ny+d2/oct,nz+d3/oct,s) * amp ) / (1 + amp)       end       nz = nz * 2       s = s / 2       amp = amp / detail    end    v = get_sample_curve(x,y,v,NOISE_PROFILE)    return v,v,v,1 end;

Script API - Spherical Noise v.001.1.ffxml

A quick little progress update, here's some thoughts on Brightness/Contrast adjustment adapted fr om an online source. I revised the examples from the two articles I found into rough Lua code, without changing any of the values given. I only updated the variable names to fit in with other scripting I've dealt with. I've noted which values before the code blocks. I assume I'll need to convert the values for a 0-1 range before proceeding?

Image Adjustment links to the Articles (copyright © 2008, 2010, 2015 Francis G. Loch) included.

Brightness Adjustment

Adjusting the brightness of an image is one of the easiest image processing operations that can be done. All that is involved is adding the desired change in brightness to each of the red, green and blue color components.

In pseudo-code it would go something like this (unstated, but assuming value range of 0-255)(also assuming brightness is a slider value, so technically declared in prepare() and omitted here):

Code
function get_sample(x,y)   local r, g, b, a = get_sample_map(x, y, COLOR)   local nr = truncate(r + brightness)   local ng = truncate(g + brightness)   local nb = truncate(b + brightness)   return nr, nb, ng, a end;

Contrast Adjustment

The first step is to calculate a contrast correction factor which is given by the following formula (assuming the value in question is RGB in the 0-255 value range):

Code
f = 259 * (c + 255) / 255 * (259 - c)

In order for the algorithm to function correctly the value for the contrast correction factor (F [or f, in the line above]) needs to be stored as a floating point number and not as an integer. The value C [c] in the formula denotes the desired level of contrast.

The next step is to perform the actual contrast adjustment itself. The following formula shows the adjustment in contrast being made to the red component of a color:

Code
r = f * (r - 128) + 128

Translating the above formulas into pseudo-code would give something like this (assuming the value of contrast will be in the range of -255 to +255, wh ere negative values will decrease the amount of contrast and, conversely, positive values will increase the amount of contrast):

Code
factor = (259 * (contrast + 255)) / (255 * (259 - contrast))   function get_sample(x,y)     local r, g, b, a = get_sample_map(x, y, COLOR)     local nr = truncate(factor * (r  - 128) + 128)     local ng = truncate(factor * (g - 128) + 128)     local nb = truncate(factor * (b - 128) + 128)     return nr, ng, nb, a   end;

The function truncate() just ensures that the new values of red, green and blue are within the valid range of 0 to 255.

The function truncate() in pseudo-code (assuming value range of 0-255):

Code
function truncate(value)      If value < 0 Then value = 0      If value > 255 Then value = 255      Return value   end;

As always, your thoughts are welcome. This is just a nudge in the direction of a -- hoped for -- mapped contrast control. That, and a mapped roughness control are my two main objectives for now.

I'm sure I am, emme. I've been known to do that. Got the stubbornness gene from both parents, I guess! I missed your update with the mapped details/roughness and distortion while I was working, so my update this time contains my own solution for mapped roughness. I played a little with the details formula to get in a little extra roughness at the high end. I'll post the code for those who just want a glance at the script, before the attached ffxml with my current experiments in it.

One last thought, how do you enter a tab inside the script editor? Or do you compose the script outside it and just paste in the final version when you're done?

Code

function prepare()    oct_max = get_intslider_input(NOISE_OCTAVES) --   detail = 4 - get_slider_input(NOISE_DETAIL) * 2 + 0.01 -- mapped alternate --   scale = get_slider_input(NOISE_SCALE) * 10 + 1 -- mapped alternate    distort = get_slider_input(NOISE_DISTORT) * 2    aspect = OUTPUT_HEIGHT / OUTPUT_WIDTH * 2    set_perlin_noise_seed(get_intslider_input(NOISE_SEED)) end; function get_sample(x, y)    local v = 0    local scale = get_sample_grayscale(x, y, SCALE) -- * 10 + 1 -- unsuitable range    local vosx = get_sample_grayscale(x, y, OFFSET_X)    local vosy = get_sample_grayscale(x, y, OFFSET_Y)    local vosz = get_sample_grayscale(x, y, OFFSET_Z)    local detail = 3.75 - get_sample_grayscale(x, y, DETAIL) * 2 + 0.01    local s = 500    local amp = 1    local x = x * aspect * math.pi    local y = y * math.pi    local nx = math.cos(x) * math.sin(y) * scale + vosx    local ny = math.sin(x) * math.sin(y) * scale + vosy    local nz = math.cos(y) * scale + vosz    for oct = 1, oct_max do       local d1 = get_perlin_noise(nx+1,ny,nz,s) * distort       local d2 = get_perlin_noise(nx+2,ny,nz,s) * distort       local d3 = get_perlin_noise(nx+3,ny,nz,s) * distort       if oct == 1 then v = get_perlin_noise(nx+d1,ny+d2,nz+d3,s) else          v = (v + get_perlin_noise(nx+d1/oct,ny+d2/oct,nz+d3/oct,s) * amp ) / (1 + amp)       end       nz = nz * 2       s = s / 2       amp = amp / detail    end    v = get_sample_curve(x,y,v,NOISE_PROFILE)    return v,v,v,1 end;

Hey, emme. I've confirmed that mapped curves do break spherical seamlessness, unless their sources are spherically mapped. Even then, some curve utilities, like Repeat, still break it.

Oops! Pointed out the wrong bad guy. Repeat did not break seamlessness after all. It was an Offset mapping of Amplitude that got weird. It didn't really break seamlessness as populate the background with fractional offsets of the source noise. It technically doesn't break the seam at top and bottom, it just creates an unwanted tiling within the perimeter.

Since I lost what I was working on, once I finished reconstructing what I could still remember (last post), I thought I'd begin looking into other types of spherical noise. I quickly composed my own version of Spherical Uniform Noise and got it working in color and grayscale modes. Sadly, the results don't differ any from the API - Uniform Noise. You just get a uniform size noise, without polar distortion like I expected. Still, it was just a warm-up before trying to tackle something more challenging, like Cell Noise. I'm not yet sure if I can adapt the example to this, but at the moment it's the only kind I have an example for.

I'd be thrilled if anyone can provide (or post links to) scripts or coding samples for scripting/programming other types of Worley noise. I can't bug emme for everything (though some times I can't help myself )!

Just the code snip, this time:

Code

function prepare()    set_noise_seed(get_intslider_input(SEED))    aspect = OUTPUT_HEIGHT / OUTPUT_WIDTH * 2    color = get_checkbox_input(COLOR) end; function get_sample(x, y)    local x = x * aspect * math.pi    local y = y * math.pi    local nx = math.cos(x) * math.sin(y) -- * scale    local ny = math.sin(x) * math.sin(y) -- * scale    local nz = math.cos(y) -- * scale    local v = get_noise(nx,ny,nz)    local r = get_noise(nx,ny,nz+1)    local g = get_noise(nx,ny,nz+2)    local b = get_noise(nx,ny,nz+3)    if color then       return r,g,b,1    else       return v,v,v,1    end end;

I've been scouring the web for help on Worley noise, but the examples are in different scripting or coding languages and are nowhere near as succinct and clear as the API script I got from the Noise API page on the FF site. I'll keep looking over what I find, but I'm getting more new questions than answers. For example, how to implement different distance formulas for Euclidean, Manhattan, Chebyshev (sp?), etc.

These are the key to the various types of Worley noise you can get. A great overview of this is in the following video: Coding in the Cabana 4: Worley Noise

The video mentions several online resources you'd come across searching the web, which I've seen (I can retrieve the links if prompted, but again, they're not terribly hard to find). The real trick is really understanding what these pages contain. It's really quite the rabbit hole. To those who have become knowledgeable about this stuff, how did you learn it? I don't think you can google your way to expertise. If there are more explicit tutorials and examples out there, they're not turning up in my searches. I will keep sharing anything I learn, as I go, however.

A little progress... I was partly on the right track with my analysis, after all. Once I provided a z coordinate, I was able to generate 3d Worley noise. It's still cartesian, rather than spherical, but the feature points used to calculate the distances are now arranged in x,y,z coordinate space.

Here's the code:

Code

function prepare()    MIN_SCALE = 0.01    scale = math.max(MIN_SCALE, get_slider_input(SCALE) / 2)    set_noise_seed(get_intslider_input(NOISE_SEED)) end; function get_sample(x, y)    local z_coord = get_sample_grayscale(x, y, Z_COORDINATE)    local sx, sy = x / scale , y / scale    local sz = z_coord / scale    local cell_x, cell_y = math.floor(sx), math.floor(sy)    local cell_z = math.floor(sz)    local offset_x, offset_y, offset_z    local min_dist = 100    for offset_x=-1,1 do       for offset_y=-1,1 do          for offset_z=-1,1 do             local dx = cell_x + offset_x + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dy = cell_y + offset_y + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dz = cell_z + offset_z + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dist = math.sqrt((sx - dx)^2 + (sy - dy)^2 + (sz - dz)^2)             min_dist = math.min(dist, min_dist)          end       end    end    local a = 1    min_dist = 1.0 - min_dist    return min_dist, min_dist, min_dist, a end;

Here's the output I got:

Okay, I went ahead and added map inputs for Foreground/Background, and a Profile curve. The next step would be to implement Offset X/Y/Z, Detail and Distortion like my Spherical Perlin, but I'm not sure how they'd fit into the structure of my Spherical Cell Noise. I may have to see if emme has some advice, there, before proceeding. I'll skip the code this time and just share the output example. You can get the Map Script from the ffxml I'll be posting right after this.

In the hope of adding Detail and Distortion, I've tried a few things, including making a get_worley_noise() function, but my inexperience with Lua, or rustiness with coding and scripting in general, have been tripping me up. With the function, I'm having trouble with referring x,y,z parameters to the function and returning them as x,y,z values to the get_sample() that calls it. As for Detail and Distortion, I'm not sure where to apply the modifiers so they'll have the desired effect. I'm mostly breaking the distance mapping, in the way's I've tried so far. I'm pretty talented at breaking code, as opposed to fixing it. So, if there are any willing volunteers, I'll leave those objectives out there for anyone interested in lending a hand. I wish I was good enough at this to do it on my own, but I'm relying mostly on my intuition and scripting doesn't lend itself to intuitive approaches very often.

Oh, since a bit part of the goal here is learning, along the way, I'd be interested in any help with Lua. If you just post a sample function like what I'm after, I'm game to try and apply the lesson to my goal, myself. No, the forum is not seeing a lot of traffic, so it might take a while for anyone to bite. I'll keep trying until help arrives or I eventually figure it out. It got me halfway where I wanted with Spherical Worley Noise. Help is always appreciated, though.

Yay! Persistence pays off!

Once I had my Worley noise isolated, the previous approach to Detail and Distortion worked again. I now have my Spherical Cell Noise module caught up to my Spherical Perlin Noise. I'm going to tinker with it a bit more, before posting the ffxml, but here's the final script and a preview of the output:

Code

function prepare()    oct_max = get_intslider_input(OCTAVES)    MIN_SCALE = 0.01    scale = math.max(MIN_SCALE, get_slider_input(SCALE) / 2) * 5    set_noise_seed(get_intslider_input(NOISE_SEED))    aspect = OUTPUT_HEIGHT / OUTPUT_WIDTH * 2    if (get_checkbox_input(HDR)) then       hdr = true    else       hdr = false    end end; function get_sample(x, y)    local r, g, b, a = get_sample_map(x, y, BACKGROUND)    local r2, g2, b2, a2 = get_sample_map(x, y, FOREGROUND)    local vosx = get_sample_grayscale(x, y, OFFSET_X)    local vosy = get_sample_grayscale(x, y, OFFSET_Y)    local vosz = get_sample_grayscale(x, y, OFFSET_Z)    local amp = 1    local s = scale    local detail = 3.75 - get_sample_grayscale(x, y, DETAIL) * 2 + 0.01    local distortion = get_sample_grayscale(x, y, DISTORTION) * 2    local x = x * aspect * math.pi    local y = y * math.pi    local z = get_sample_grayscale(x, y, Z_COORDINATE)    local nx = math.cos(x) * math.sin(y) + vosx    local ny = math.sin(x) * math.sin(y) + vosy    local nz = math.cos(y) * z + vosz    for oct = 1, oct_max do       local d1 = get_worley_noise(nx+1,ny,nz,s) * distortion       local d2 = get_worley_noise(nx+2,ny,nz,s) * distortion       local d3 = get_worley_noise(nx+3,ny,nz,s) * distortion       if oct == 1 then v = get_worley_noise(nx+d1,ny+d2,nz+d3,s) else          v = (v + get_worley_noise(nx+d1/oct,ny+d2/oct,nz+d3/oct,s) * amp ) / (1 + amp)       end       nz = nz * 2       s = s / 2       amp = amp / detail    end    v = get_sample_curve(x,y,v,PROFILE)    local opacity = v    r, g, b, a = blend_normal(r, g, b, a, r2, g2, b2, a2, opacity, hdr)    return r, g, b, a end; function get_worley_noise(x,y,z,s)    local sx, sy, sz = x / s , y / s, z / s    local cell_x, cell_y, cell_z = math.floor(sx), math.floor(sy), math.floor(sz)    local offset_x, offset_y, offset_z    local min_dist = 100    for offset_x=-1,1 do       for offset_y=-1,1 do          for offset_z=-1,1 do             local dx = cell_x + offset_x + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dy = cell_y + offset_y + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dz = cell_z + offset_z + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dist = math.sqrt((sx - dx)^2 + (sy - dy)^2 + (sz - dz)^2)             min_dist = math.min(dist, min_dist)          end       end    end    min_dist = 1.0 - min_dist    return min_dist end;

I'm kind of at a crossroads, with this project. I've gone about as far as I can working with the API Noise and valuable help fr om emme. Now I'm confronted with the challenges I discovered in the process of researching noise generation online. So, before starting anything today, I'm taking a moment to organize some of my thoughts. I'll begin with the loose threads I've already mentioned.

Quote
I still need to figure out how to address the nth point as a variable, to get other permutations, i.e. 2nd closest, 3rd closest, etc. point. I also need to figure out how to apply the other distance formulas for Manhattan, Chebyshev, etc. That's where the other Worley type noises we're familiar come from, with formula variations. So, still work to do!

And:

Quote
The only thing I didn't really do, do to my lack of experience, was optimize the distance algorithms for the Worley noise. To do that, I have to use a sorted table and do a little more searching on the subject of Worley noises.

The problem I'm having has to do with a feature of Worley noise I've seen in every example, except for the API Worley noise I actually used. In most implementations of Worley noise, there is a set of steps devoted to creating, distributing and querying the feature points, which are distance mapped in Euclidean, Manhattan, Chebyshev, etc. method. The API Worley Noise does not seem to openly address that step. I can't see where it determines which point is closest to a given point. I'd have to know that to impement a QuadTree -- the optimization I mentioned last. I'm pretty sure a QuadTree could be implemented in Lua; the structure is similar to Tech Noise Scrippet shared in the forums by ThreeDee (I can't find the thread at the moment, but I'll attach a sample image.Edit: You can find it here) There are other variations of Cell noise created by mapping to the nth closest point (1st, 2nd, 3rd, etc.). Those are also dependent on identifying and sorting seed points, by relative distance.

It's unfortunate that I'm such a novice at graphics scripting; I'm asking for help a lot, which has to bother people at times. I do make progress on my own, provided I have something to lean on, wh ere my own expertise is nil. I do look for answers outside the forum, but there are some very smart people here who do help out on occasion, So, I'll keep asking. But in a lot of ways, I'm flooding the forum (on my own thread, so why not?) mostly to keep track of what I'm doing, and how I'm doing it. If it helps others, fantastic. If it's annoying, well, I'm sorry for that. It gets me through, day to day, though, so it's worth it to me.

If you're still reading, and feel helpful (and of course have the knowledge to share and time to share it) I'd like to see other noise examples roughly on par with the API Worley Noise. I do wish FF had provided scripted examples for each of the Worley-based noises in FF. Collecting and preserving those here is one of the objectives of this thread. I think that's everything on my mind this morning. Today is going to be spent surfing for noise algorithms I can, hopefully, adapt for this project.

TTFN

Another victory for persistence! I had been looking for examples of Worley using different distance calculations when I should have just googled the four types I've come across: Euclidean, Manhattan, Chebyshev and Minkowski. That little shift in focus got me the results I was hoping for, and each of the formulas (with a partial exception for Minkowski) boiled down to one line of code.

I tested each one out and got decent results, though I'm clearly still missing whatever produces chaffs or stones. I did not find anything yet on superquadratic distance calculations. I did run into an odd problem when I tried to make the different distance methods controllable by an intslider. The "if" conditions generated a script error, saying "attempt to compare number with nil". I did a little testing assigning the intslider to set different rgba values and it worked outside the "for" loop, but not when it was inside it where the distance mapping needs to occur. Here's a simplified version of the script that's giving me trouble. Maybe someone else can figure out, or knows, what the problem is. Of course, I can just make a different map script for each type of distance mapping. It just seems like I should be able to switch modes in the same script.

Code

function prepare()    -- v.002    MIN_SCALE = 0.01    scale = math.max(MIN_SCALE, get_slider_input(SCALE) / 2) * 5    set_noise_seed(get_intslider_input(NOISE_SEED))    aspect = OUTPUT_HEIGHT / OUTPUT_WIDTH * 2    dtype = get_intslider_input(DISTANCE_TYPE)    p = get_intslider_input(P) end; function get_sample(x, y)    local x = x * aspect * math.pi    local y = y * math.pi    local z = get_sample_grayscale(x, y, Z_COORDINATE)    local nx = math.cos(x) * math.sin(y)    local ny = math.sin(x) * math.sin(y)    local nz = math.cos(y) * z    local sx, sy, sz = nx / scale , ny / scale, nz / scale    local cell_x, cell_y, cell_z = math.floor(sx), math.floor(sy), math.floor(sz)    local offset_x, offset_y, offset_z    local min_dist = 100    for offset_x=-1,1 do       for offset_y=-1,1 do          for offset_z=-1,1 do             local dx = cell_x + offset_x + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dy = cell_y + offset_y + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             local dz = cell_z + offset_z + get_noise(cell_x + offset_x, cell_y + offset_y, cell_z + offset_z)             if dtype == 1 then                r,g,b,a = 1,0,0,1             elseif dtype == 2 then                r,g,b,a = 0,1,0,1             elseif dtype == 3 then                r,g,b,a = 0,0,1,1             else                r,g,b,a = 1,1,1,1             end                local dist = math.sqrt((sx - dx)^2 + (sy - dy)^2 + (sz - dz)^2)             min_dist = math.min(dist, min_dist)          end       end    end    -- local a = 1    min_dist = 1.0 - min_dist    -- return min_dist, min_dist, min_dist, a    return r,g,b,a end;

Okay, I hit a stopping point early today. I was seeing what I could accomplish working with the API Multi-Octave Perlin and discovered that the way it handles Roughness is not compatible with spherical mapping. Remapping was not that hard, but there is a stretching artifact along the "equator" that, at best, could only be minimized -- not eliminated. There also seems to be an issue with scale settings for completely zoomed in. What worked in Cartesian space, without modifications to the input scale, does not work even with modifications to scale in the sphere map.

I was able to map Roughness and Contrast (which was easy enough to add), so there's at least a v.001 that works. The ffxml has a v.002 started, current to where I left off. I'll post the code and file for anyone who wants to take a crack at this. I'm sure there are many people on the forums who would fare much better than I.

Code

function prepare() --   v.002 --   constants    AMPLITUDE_CORRECTION_FACTOR = 1.731628995    ROUGHNESS_THRESHOLD = 0.00001    REMAINDER_THRESHOLD = 0.00001    aspect = OUTPUT_HEIGHT / OUTPUT_WIDTH * 2    set_perlin_noise_seamless(SEAMLESS)    set_perlin_noise_seamless_region(SEAMLESS_REGION_WIDTH, SEAMLESS_REGION_HEIGHT) --   input values    details = get_slider_input(DETAILS) * 10 + 1    OCTAVES_COUNT = math.floor(details)    NOISE_SIZE = get_slider_input(SCALE)    set_perlin_noise_seed(get_intslider_input(NOISE_VARIATION)) end; function get_sample(x, y)    local r, g, b, a = get_sample_map(x, y, BACKGROUND)    local noise_r, noise_g, noise_b, noise_a = get_sample_map(x, y, NOISE)    local remainder = details - OCTAVES_COUNT    if (remainder > REMAINDER_THRESHOLD) then       OCTAVES_COUNT = OCTAVES_COUNT + 1    end        local roughness = ROUGHNESS_THRESHOLD +       get_sample_grayscale(x, y, ROUGHNESS) * (1.0 - ROUGHNESS_THRESHOLD)    local contrast = (get_sample_grayscale(x, y, CONTRAST) * 2) - 1    local factor = (259 * (contrast + 1)) / (1 * (259 - contrast))        OCTAVES = {}    local cell_size = (0.01 + NOISE_SIZE * 0.99) * 150    local scale = roughness    local octave_index    for octave_index = 1, OCTAVES_COUNT do       if (scale < ROUGHNESS_THRESHOLD) then          OCTAVES_COUNT = octave_index - 1          break       end       OCTAVES[octave_index] = {cell_size, scale}       cell_size = cell_size * 0.5       scale = scale * roughness    end        if (remainder >= 0.001) then       OCTAVES[OCTAVES_COUNT][2] = OCTAVES[OCTAVES_COUNT][2] * remainder    end    NORM_FACTOR = 0    for octave_index = 1, OCTAVES_COUNT do       NORM_FACTOR = NORM_FACTOR + OCTAVES[octave_index][2] ^ 2    end    NORM_FACTOR = 1 / math.sqrt(NORM_FACTOR)    -- ins ert spheremapping calculations    local x = x * aspect * math.pi    local y = y * math.pi    local nx = math.cos(x) * math.sin(y) -- * scale + vosx    local ny = math.sin(x) * math.sin(y) -- * scale + vosy    -- local nz = math.cos(y) * math.pi -- * scale + vosz    local alpha = 0        for octave_index = 1, OCTAVES_COUNT do       -- this minimizes stretching the most, still has artifacts       local nz = octave_index * math.cos(y) * math.pi       local size = OCTAVES[octave_index][1]       local opacity = OCTAVES[octave_index][2]       -- local d1 = get_perlin_noise(nx+1,ny,nz,size) -- * distortion       -- local d2 = get_perlin_noise(nx+2,ny,nz,size) -- * distortion       -- local d3 = get_perlin_noise(nx+3,ny,nz,size) -- * distortion       -- local noise_z = octave_index       -- -- ins ert spheremapped x,y,z coordinates       --  -- produces stretching along equator       alpha = alpha + opacity * (2 * get_perlin_noise(nx,ny,nz,size) - 1)       -- alpha = alpha + opacity * (2 * get_perlin_noise(nx+d1,ny+d2,nz+d3,size) - 1)    end        alpha = (alpha * NORM_FACTOR + AMPLITUDE_CORRECTION_FACTOR) *       (0.5 / AMPLITUDE_CORRECTION_FACTOR)    local alpha = truncate(factor * (alpha - 0.5) + 0.5)        return blend_normal(r, g, b, a, noise_r, noise_g, noise_b, noise_a, alpha)    -- return size,size,size,1 end; function truncate(value)    if value <= 0 then value = 0 end    if value >= 1 then val ue = 1 end    return val ue end;

Script API - Multi-Octave Perlin v.001.ffxml

Here is the other. It's slower, by a minute, but now offers four different variations (Euclidean, Manhattan, Chebyshev and Minkowski), as noted a couple posts ago. Manhattan gives a result most similar to Pyramids. Chebyshev falls somewhere between blocks and Techno -- and Minkowski offers a range between Euclidean (Cell noise) and Chebyhsev. Once you apply any of the possible distortions and levels of detail, they tend to become even more similar. Oh well.

Spherical Worley Noise Map Script.ffxml

So, it's been a year and change since I thought about this, but I came back to it today and find the problem still stumps me:

Quote
David Roberson wrote: I was seeing what I could accomplish working with the API Multi-Octave Perlin and discovered that the way it handles Roughness is not compatible with spherical mapping. Remapping was not that hard, but there is a stretching artifact along the "equator"...

I compared this to a few other noise scripts I've done or used as examples, to try and understand why this seems to happen only with Perlin noise called using get_perlin_noise(). Or rather, the version in Egret's API Perlin Noise script. The octave blending emme provided an example did not have this problem. I would be inclined to keep using that, but the Roughness just isn't as nice as Egret's. I do hope an FF team member can chime in here, since Egret's implementation was based on the FF version.

I'll post a pic of what I'm talking about, since I'm just throwing this out there again to see if someone can shed some light on why this is happening or how to fix it.

Looking at the spherical Perlin I produced, I had one idea regarding the mapping required for a seamless plane; basically, I need to get mapping coordinates for a torus, which curves in 3d space to create a perfect 2d planar mapping. I'll see if I can find the right function for this, but I'm making a note of it here in case someone else wants to try this idea out.