On Thu, 9 Dec 1999 11:07:49 +0100, Philippe Debar wrote:
>> For another thought experiment, assume that you have a transformation
>> that can turn a cylinder into a cone.  What would it do to the
>> resulting cone?  If it leaves it a cone, then the transformation
>> isn't invertible, because there's some cylinder that maps to the same
>> cone.  If it makes it anything else, then what does it do to a line
>> that lies in the surface of that cone?
>
>I think it turns a cone into an _other_ cone. Line-> line.

But you can find a cylinder that also maps to that other cone.  (proof: there
is a plane where the scale factor perpendicular to the axis is 1. The 
intersection of the cone with this plane is a circle.  Since the intersection 
of the cylinder with the plane is also a circle, and since the scale factor is 
1, the desired cylinder has the same radius.)  If a cone truly does map to a 
different cone, the transform isn't invertible and thus POV can't use it.  
But, as I'll show, it doesn't actually map a cone to another cone so this 
argument is from false assumptions.

As proof that it doesn't map a cone to a cone, try the following script.  
There are three commented lines in the code.  The first one is the equation 
for a cylinder, so that you can verify that the given transform maps a 
cylinder to a cone.  The line after it is the equation for a cone (the one 
it maps the cylinder to, in fact.) As written, the code generates a cone.

The second commented line is an identity transform.  If you uncomment it 
and comment the line after it, you may verify that the code does produce a 
cone.  As written, it transforms each point using a scale factor equal to 
the distance along the Y axis from the origin, except it doesn't change the 
Y coordinate.  You'll see that this transform maps a cone to the SOR of a 
parabola, so it doesn't map all lines to lines.

The third commented line is a different interpretation of the idea "scale 
by an amount equal to the distance along an axis from the origin."  You'll 
see that while it does map a cone to a cone (the same cone, in fact), it 
maps a cylinder to a paraboloid, so it doesn't map lines to lines either.

------------ cut here --------->8========
camera { location <0,1,-5> look_at y }
light_source {-5*z rgb 1}
#declare H = 0;
#while ( H < 2 )
  #declare T = 0;

  //#declare X = 1;   // a cylinder
  #declare X = H;   // a cone
  
  #while ( T < 360 ) 
    #declare Loc = vrotate( <X,H,0>, T*y );
    
    // #declare NewLoc = Loc; // identity transform
    #declare NewLoc = <Loc.x*H,Loc.y,Loc.z*H>; // NL trans 1
    //#declare NewLoc = <Loc.x*H,Loc.y*H,Loc.z*H>; // NL trans 2
    
    sphere { NewLoc, .05 pigment {color red 1}}
    #declare T=T+2;
  #end
  #declare H = H + .05;
#end                
------------ cut here --------->8========

-- 
These are my opinions.  I do NOT speak for the POV-Team.
The superpatch: http://www2.fwi.com/~parkerr/superpatch/
My other stuff: http://www2.fwi.com/~parkerr/traces.html

Post a reply to this message