Class Tachyon

x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Overrides: object.__init__

(inherited documentation)

File: sage/structure/sage_object.pyx (starting at line 86)

Overrides: structure.sage_object.SageObject.__repr__

(inherited documentation)

INPUT:
    filename -- (default: 'sage.png')
               output filename; the extension of
               the filename determines the type.
               Supported types include:
                 tga -- 24-bit (uncompressed)
                 bmp -- 24-bit Windows BMP (uncompressed)
                 ppm -- 24-bit PPM (uncompressed)
                 rgb -- 24-bit SGI RGB (uncompressed)
                 png -- 24-bit PNG (compressed, lossless)
    verbose -- integer; (default: 0)
               0 -- silent
               1 -- some output
               2 -- very verbose output
    block -- bool (default: True); if False, run the rendering
             command in the background.
    extra_opts -- passed directly to tachyon command line.
             Use tachyon_rt.usage() to see some of the possibilities.

Overrides: structure.sage_object.SageObject.save

INPUT:
    type -- (default: 0)
         0: No special texture, plain shading
         1: 3D checkerboard function, like a rubik's cube
         2: Grit Texture, randomized surface color
         3: 3D marble texture, uses object's base color
         4: 3D wood texture, light and dark brown, not very good yet
         5: 3D gradient noise function (can't remember what it look like
         6: Don't remember
         7: Cylindrical Image Map, requires ppm filename   (don't know how to specify name in sage?!)
         8: Spherical Image Map, requires ppm filename     (don't know how to specify name in sage?!)  
         9: Planar Image Map, requires ppm filename        (don't know how to specify name in sage?!)
    center -- (default: (0,0,0))
    rotate -- (default: (0,0,0))
    scale -- (default: (1,1,1))

EXAMPLES:
We draw an infinite checkboard:
    sage: t = Tachyon(camera_center=(2,7,4), look_at=(2,0,0))
    sage: t.texture('black', color=(0,0,0), texfunc=1)
    sage: t.plane((0,0,0),(0,0,1),'black')
    sage: t.show()

INPUT:
    name -- string; the name of the texture (to be used later)
    ambient -- (default: 0.2)
    diffuse -- (default: 0.8)
    specular -- (default: 0.0)
    opacity -- (default: 1.0)
    color -- (default: (1.0,0.0,0.5))
    texfunc -- (default: 0); a texture function; this is either the output of
               self.texfunc, or a number between 0 and 9, inclusive.  See
               the docs for self.texfunc.
    phong -- (default: 0)
    phongsize -- (default: 0.5)
    phongtype -- (default: "PLASTIC")

EXAMPLES:
We draw a scene with 4 sphere that illustrates various uses of the texture command:
    sage: t = Tachyon(camera_center=(2,5,4), look_at=(2,0,0), raydepth=6)
    sage: t.light((10,3,4), 1, (1,1,1))
    sage: t.texture('mirror', ambient=0.05, diffuse=0.05, specular=.9, opacity=0.9, color=(.8,.8,.8))
    sage: t.texture('grey', color=(.8,.8,.8), texfunc=3)
    sage: t.plane((0,0,0),(0,0,1),'grey')
    sage: t.sphere((4,-1,1), 1, 'mirror')
    sage: t.sphere((0,-1,1), 1, 'mirror')
    sage: t.sphere((2,-1,1), 0.5, 'mirror')
    sage: t.sphere((2,1,1), 0.5, 'mirror')
    sage: show(t)        

INPUT:
    f -- Function of two variables, which returns a float (or coercable to a float)
    (xmin,xmax)
    (ymin,ymax) -- defines the rectangle to plot over
    texture: Name of texture to be used
Optional arguments:
    grad_f -- gradient function.  If specified, smooth triangles will be used.
    max_bend -- Cosine of the threshold angle between triangles used to determine 
                whether or not to recurse after the minimum depth
    max_depth -- maximum recursion depth.  Maximum triangles plotted = $2^{2*max_depth}$
    initial_depth -- minimum recursion depth.  No error-tolerance checking is performed
                     below this depth.  Minimum triangles plotted: $2^{2*min_depth}$
    num_colors -- Number of rainbow bands to color the plot with.  Texture supplied will
                  be cloned (with different colors) using the texture_recolor method of the 
                  Tachyon object.

Plots a function by constructing a mesh with nonstandard sampling density
without gaps. At very high resolutions (depths > 10) it becomes very
slow.  Cython may help.  Complexity is approx.
$O(2^{2*maxdepth})$.  This
algorithm has been optimized for speed, not memory -- values from f(x,y) are
recycled rather than calling the function multiple times.  At high recursion
depth, this may cause problems for some machines.

Flat Triangles:
    sage: t = Tachyon(xres=512,yres=512, camera_center=(4,-4,3),viewdir=(-4,4,-3), raydepth=4)
    sage: t.light((4.4,-4.4,4.4), 0.2, (1,1,1))
    sage: def f(x,y): return float(sin(x*y))
    sage: t.texture('t0', ambient=0.1, diffuse=0.9, specular=0.1,  opacity=1.0, color=(1.0,0,0))
    sage: t.plot(f,(-4,4),(-4,4),"t0",max_depth=5,initial_depth=3, num_colors=60)  # increase min_depth for better picture
    sage: t.show()

Plotting with Smooth Triangles (requires explicit gradient function):
    sage: t = Tachyon(xres=512,yres=512, camera_center=(4,-4,3),viewdir=(-4,4,-3), raydepth=4)
    sage: t.light((4.4,-4.4,4.4), 0.2, (1,1,1))
    sage: def f(x,y): return float(sin(x*y))
    sage: def g(x,y): return ( float(y*cos(x*y)), float(x*cos(x*y)), 1 )
    sage: t.texture('t0', ambient=0.1, diffuse=0.9, specular=0.1,  opacity=1.0, color=(1.0,0,0))
    sage: t.plot(f,(-4,4),(-4,4),"t0",max_depth=5,initial_depth=3, grad_f = g)  # increase min_depth for better picture
    sage: t.show()

Preconditions: f is a scalar function of two variables, grad_f is None or a triple-valued 
               function of two variables, min_x != max_x, min_y != max_y
    sage: f = lambda x,y: x*y
    sage: t = Tachyon()
    sage: t.plot(f,(2.,2.),(-2.,2.),'')
    Traceback (most recent call last):
    ...
    ValueError: Plot rectangle is really a line.  Make sure min_x != max_x and min_y != max_y.

Overrides: structure.sage_object.SageObject.plot

Plots a space curve as a series of speheres and finite cylinders.
Example (twisted cubic) :
    sage: f = lambda t: (t,t^2,t^3)
    sage: t = Tachyon(camera_center=(5,0,4))
    sage: t.texture('t')
    sage: t.light((-20,-20,40), 0.2, (1,1,1))
    sage: t.parametric_plot(f,-5,5,'t',min_depth=6)