"Bald Eagle" <cre### [at] netscapenet> wrote:
>
> Anyway, I did the bleeding obvious, and just defined a function {} to be
> rendered as an isosurface and noodled out ways to adjust the thickness of the
> spirals, adjust the frequency of the spirals, and render multiple spirals.
>
> I left in the original function and a few of my experimental modifications.
> The straightforward spiral code is the uncommented line, and should run
> fine as-is.
> [code]

I'm having fun playing around with this (the various constants, multipliers and
exponents in the functions; even adding multiple functions together!) It's like
a basic 'spiral workshop', with seven 'preset' spiral shapes to examine. Thanks
for taking the time to work it out. I do notice that the functions don't yet
produce 'tapering' of the spiral at the start and end points (i.e, tapering to a
fine point)-- but that's a minor quibble right now, and actually gives us more
opportunities for experimentation, function-wise. And, so far, I haven't seen a
need for a sphere shape at the center; only a bit of isosurface accuracy
adjustment instead. Perhaps the sphere requirement applies to other more complex
spiral cross-sections (or tapering).

Meanwhile... here's a spiral doodle just for the fun of it, that looks like a
rubber mat, draped over an invisible rod.

------
#version 3.71; // or 3.7

global_settings {assumed_gamma 1}
#include "colors.inc"

light_source { <-3,8,2> color .7*White}
light_source { <3,8,-4> color .7*White}
light_source { <0,.5,-1> color .4*White}

camera {
 location <-2, 10, -10>
 look_at  <0, 2, 0>
 angle 50
}

plane {y, -1 pigment { checker Grey, White }}

#declare RADIUS = 4;
#declare Thickness = 0.2;
#declare Freq = 8;
#declare Spirals = 2;

isosurface {
 function {Thickness - y*y*Freq - pow(sin((sqrt(x*x+z*z)*Freq -
 0.5*atan2(z,x))),2) + 5 - pow(x,3)}

 accuracy 0.01
 threshold 0
 max_gradient 107
 contained_by {sphere {<0,0,0>, RADIUS}}
 open
 texture {pigment {Red} finish {specular 0.4}}
 rotate 90*z
 rotate -30*y
 translate 3.2*y
   }

Post a reply to this message

"Kenneth" <kdw### [at] gmailcom> wrote:
> Thanks
> for taking the time to work it out.

Sure thing.  It wasn't too bad once I had enough time to look it over from a
fresh perspective.

> I do notice that the functions don't yet
> produce 'tapering' of the spiral at the start and end points (i.e, tapering to a
> fine point)-- but that's a minor quibble right now, and actually gives us more
> opportunities for experimentation, function-wise. And, so far, I haven't seen a
> need for a sphere shape at the center; only a bit of isosurface accuracy
> adjustment instead. Perhaps the sphere requirement applies to other more complex
> spiral cross-sections (or tapering).

Well, the thing that I did notice, is that there IS tapering - x-z-wise.  The
y-component remains constant, but the spirals get pinched off so that you have a
vertical y-edge.  If you closely, I believe the same thing happens with the
original function, which is presumably what the sphere was intended to cover up.

I haven't experimented enough to gain enough perspective on the various parts of
the function[s] to see why, or how it get changed - if it can.  But have some
vague ideas for further experiments.

> Meanwhile... here's a spiral doodle just for the fun of it, that looks like a
> rubber mat, draped over an invisible rod.

Ha!  That's excellent.  I played around with trying to cram everything into one
super-function using select(), and I got something similar, but it's symmetric
around the axis of rotation and looks like yours - where the tubes blend
together.

I'm wondering if the idiosyncrasies of this shape are best addressed by a
parametric rather than an isosurface.  Implicit / closed form equations can be
pretty difficult to grapple with sometimes, whereas separating the x, y, and
z-components can be easier, more tunable, and seem to be a lot more readable /
intuitive.

I'm glad you're having fun and producing some fun-looking shapes.  I'll bet
they'd look great in glass.  A light probe, radiosity and photons would probably
make for long render times, but pretty sharp looking scenes.

Also, I was looking at some seashell sites, and taking a slice out of your open
surface might be something to try, as would wireframing / grid-texturing it,
either with uv-mapping or tightly-banded color/texture/material maps (with rbgt
1).

Post a reply to this message

You might also be interested in a completely different way of producing a spiral
image:

https://swiftcoder.wordpress.com/2010/06/21/logarithmic-spiral-distance-field/

I though the fading effect was pretty cool.  I don't understand it yet, but I
got it to work after fixing something positively ridiculous.

Just thought I'd post it here since it's such a radically different way of
visualizing it.


#version 3.7;
//------------------------------------------
// SDL for spiral distance field
// Bill Walker - October 2017
//------------------------------------------
global_settings {assumed_gamma 1}

#include "colors.inc"
#include "consts.inc"

light_source { <-1,8,2> color White}

camera {
 orthographic
 location <0, 0, -100>
 look_at  <0, 0,   0>
 right x*image_width
 up y*image_height
}

plane {z, 1 pigment {checker Gray20, White} scale 10}
light_source {<0, 10, -500> color White*0.5}

#macro Spiral (X, Y)
 #declare a=1;
 #declare b=0.5;
 // calculate the target radius and theta
  #local R = sqrt (X*X +Y*Y);

   // early exit if the point requested is the origin itself
 // to avoid taking the logarithm of zero in the next step
 #if (R = 0)
  0
 #else
  #local T = atan2 (Y, X);
  // calculate the floating point approximation for n
  #local n = (log(R/a)/b - T)/(tau);

  // find the two possible radii for the closest point
  #local upper_r = a * pow(e, b * (T + tau*ceil(n)));
  #local lower_r = a * pow(e, b * (T + tau*floor(n)));

  // return the minimum distance to the target point
  min (abs(upper_r - R), abs(R - lower_r))
 #end
#end


#for (i, -image_width/2, image_width/2)
 #for (j, -image_height/2, image_height/2)
  box { -0.5, 0.5 translate <i, j, 0> pigment {color rgb min(1, Spiral(i, j)/255
)} }
 #end
#end

Post a reply to this message