On 11/23/2016 8:51 PM, clipka wrote:
 > Am 24.11.2016 um 01:27 schrieb Mike Horvath:
 >> On 11/23/2016 7:22 PM, Christian Froeschlin wrote:
 >>> No threshold will give the desired result using the color
 >>> conversion function directly, as clipka explained you need
 >>> a define a "distance" function for this purpose.
 >>>
 >>> Alternatively you could try to render the clipped function
 >>> (set to 0 outside the gamut) as strongly scattering media but
 >>> it may be fiddly and you don't get the look of a "surface"
 >>> regarding finish and lighting etc.
 >>>
 >>
 >> What is a "distance" function?
 >>
 >> The "convertLCH2RGBb2(y*100,sqrt(x*x+z*z)*100,atan2d(x,z))" bit is what
 >> clipka showed me.
 >
 > You may need to deconstruct the problem into easy-to-handle building
 > blocks, and tackle each of them separately.
 >
 > One building block you need is a function that maps a single RGB colour
 > component to a distance-ish scalar telling you how "far away" the colour
 > component is from the valid range (this time, just for giggles, I'm
 > contructing the function in such a way that <0 is inside, >0 is outside):
 >
 >     #declare fD = function(C) { abs(C-0.5)-0.5 }
 >
 > Another building block you need is a function that combines three such
 > distance-ish scalars, such that you get a positive value if one or more
 > parameters is positive, or a negative value if all are negative, in a
 > manner that avoid steps:
 >
 >     #declare fDist = function(Dr,Dg,Db) { max(Dr,Dg,Db) }
 >
 >
 > That's kind of all you need to know about the "distance" functions;
 > however, those functions alone don't get you anywhere.
 >
 >
 > Another necessary building block is a set of functions that map Lch 
to RGB:
 >
 >     #declare fR = function(L,c,h) { ... }
 >     #declare fG = function(L,c,h) { ... }
 >     #declare fB = function(L,c,h) { ... }
 >
 > And the final building block is a set of functions that map 3D cartesian
 > space to Lch:
 >
 >     #declare fL = function(x,y,z) { y*100 }
 >     #declare fc = function(x,y,z) { sqrt(x*x+z*z)*100 }
 >     #declare fh = function(x,y,z) { atan2d(x,z) }
 >
 >
 > Once you have all these building blocks, all that's left is to plug them
 > all together.
 >
 > The final result to be compared to the threshold by the isosurface is
 > the result of the `fDist` function, so that's where you start:
 >
 >     isosurface {
 >       threshold 0
 >       function { fDist (Dr,Dg,Db) }
 >     }
 >
 > The isosurface doesn't know what `Dr`, `Dg` and `Db` are, but we know
 > they are supposed to be results of the `fD` function, using the three
 > colour channels as input:
 >
 >     isosurface {
 >       threshold 0
 >       function { fDist (
 >         fD (R),
 >         fD (G),
 >         fD (B)
 >       ) }
 >     }
 >
 > Again the isosurface doesn't know `R`, `G` and `B`:
 >
 >     isosurface {
 >       threshold 0
 >       function { fDist (
 >         fD ( fR (L,c,h) ),
 >         fD ( fG (L,c,h) ),
 >         fD ( fB (L,c,h) )
 >       ) }
 >     }
 >
 > Still not done yet, as the isosurface doesn't know `L`, `c` and `h` 
either:
 >
 >     isosurface {
 >       threshold 0
 >       function { fDist (
 >         fD ( fR (fL(x,y,z),fc(x,y,z),fh(x,y,z)) ),
 >         fD ( fG (fL(x,y,z),fc(x,y,z),fh(x,y,z)) ),
 >         fD ( fB (fL(x,y,z),fc(x,y,z),fh(x,y,z)) )
 >       ) }
 >     }
 >
 > Now we have only `x`, `y` and `z` left as parameters, which is what the
 > isosurface can handle.
 >
 >
 > For bonus points, you could eliminate the multiple invocation of
 > `fL(x,y,z)`, `fc(x,y,z)` and `fh(x,y,z)`. To this end, you need to
 > provide a function that does not compute these values itself, but rather
 > takes them as parameters:
 >
 >     #declare fFinal = function(L,c,h) { fDist (
 >       fD ( fR (L,c,h) ),
 >       fD ( fG (L,c,h) ),
 >       fD ( fB (L,c,h) )
 >     ) }
 >
 >     isosurface {
 >       threshold 0
 >       function { fFinal (fL(x,y,z),fc(x,y,z),fh(x,y,z)) }
 >     }
 >
 >
 > And of course you'll want to use different names; I chose the above for
 > brevity.
 >

Next issue: What is the best way to create an accurate pigment to paint
the isosurface?

I was thinking of repurposing the following:

//------------------------------
// HSL Cylinder

#declare CSolid_HSLCylinder_Hue = pigment
{
	function {-f_th(x,y,z)/pi/2}
	color_map
	{
		// need to replace these with calls to CHSL2RGB() or CH2RGB(), then
increase the number of steps
		[0/6 srgb <1,0,0,>]
		[1/6 srgb <1,1,0,>]
		[2/6 srgb <0,1,0,>]
		[3/6 srgb <0,1,1,>]
		[4/6 srgb <0,0,1,>]
		[5/6 srgb <1,0,1,>]
		[6/6 srgb <1,0,0,>]
	}
}
#declare CSolid_HSLCylinder_Saturation = pigment
{
	cylindrical
	pigment_map
	{
		[0 CSolid_HSLCylinder_Hue]
		[1 color srgb 1/2]
	}
	scale	(1 + CSolid_Offset)
}
#declare CSolid_HSLCylinder_Lightness = pigment
{
	gradient y
	pigment_map
	{
		[0/2 color srgb 0]
		[1/2 CSolid_HSLCylinder_Saturation]
		[2/2 color srgb 1]
	}
	scale		(1 + CSolid_Offset)
	translate	-y * CSolid_Offset/2
}
#declare CSolid_HSLCylinder_Pigment = pigment {CSolid_HSLCylinder_Lightness}

Except, in this case using LCH conversion formula to create the gradients:

	[0/6 srgb <convertLCH2RGBb1(50, 50, 0),convertLCH2RGBb2(50, 50,
0),convertLCH2RGBb3(50, 50, 0)>]
	[1/6 srgb <convertLCH2RGBb1(50, 50, 60),convertLCH2RGBb2(50, 50,
60),convertLCH2RGBb3(50, 50, 60)>]
	[2/6 srgb <convertLCH2RGBb1(50, 50, 120),convertLCH2RGBb2(50, 50,
120),convertLCH2RGBb3(50, 50, 120)>]
	[3/6 srgb <convertLCH2RGBb1(50, 50, 180),convertLCH2RGBb2(50, 50,
180),convertLCH2RGBb3(50, 50, 180)>]
	[4/6 srgb <convertLCH2RGBb1(50, 50, 240),convertLCH2RGBb2(50, 50,
240),convertLCH2RGBb3(50, 50, 240)>]
	[5/6 srgb <convertLCH2RGBb1(50, 50, 300),convertLCH2RGBb2(50, 50,
300),convertLCH2RGBb3(50, 50, 300)>]
	[6/6 srgb <convertLCH2RGBb1(50, 50, 360),convertLCH2RGBb2(50, 50,
360),convertLCH2RGBb3(50, 50, 360)>]


Is this maybe a bad idea?

Mike

Post a reply to this message