Changeset 7922:0357fa4b519b

Timestamp:

01/03/08 12:08:25 (5 years ago)

Author:

Robert Bradshaw <robertwb@…>

Branch:

default

Parents:

7921:bc8c4b756d60 (diff), 7919:feb90d6ac1e9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

...

Location:

sage/plot/plot3d

Files:

• all.py (modified) (1 diff)
• all.py (modified) (1 diff)
• base.pyx (modified) (5 diffs)
• base.pyx (modified) (11 diffs)
• plot3d.py (modified) (1 diff)
• shapes.pyx (modified) (2 diffs)
• shapes.pyx (modified) (1 diff)

sage/plot/plot3d/all.py

@@ -3 +3 @@
 
 from shapes import Box, ColorCube, Cone, Cylinder, LineSegment, Arrow, Sphere, Torus, Text as Text3D
-
-from parametric_surface import MobiusStrip
-
-
+from parametric_surface import ParametricSurface, MobiusStrip
 from plot3d import plot3d, axes as axes3d
 from platonic import Tetrahedron, Cube, Octahedron, Dodecahedron, IndexFaceSet, Icosahedron

sage/plot/plot3d/all.py

@@ +1 @@
+from parametric_plot3d import parametric_plot3d
+from list_plot3d import list_plot3d
+
 from shapes import Box, ColorCube, Cone, Cylinder, LineSegment, Arrow, Sphere, Torus, Text as Text3D
 from parametric_surface import ParametricSurface, MobiusStrip
-from parametric_plot3d import parametric_plot3d
 from plot3d import plot3d, axes as axes3d
 from platonic import Tetrahedron, Cube, Octahedron, Dodecahedron, IndexFaceSet, Icosahedron

sage/plot/plot3d/base.pyx

@@ -47 +47 @@
 from math import atan2
 from random import randint
+import zipfile
+from cStringIO import StringIO
 
 import sage.misc.misc
@@ -205 +207 @@
         render_params.output_file = filename
         render_params.force_reload = render_params.randomize_counter = force_reload
-        f = open(filename, 'w')
+        render_params.output_archive = zipfile.ZipFile(filename, 'w', zipfile.ZIP_DEFLATED, True)
+        
+        f = StringIO()
+        
         # Set the scene background color
         f.write('background [%s,%s,%s]\n'%tuple([int(a*255) for a in background]))
@@ -227 +232 @@
         # Put the rest of the object in
         f.write("\n".join(flatten_list([self.jmol_repr(render_params), ""])))
-        f.close()
+        
+        render_params.output_archive.writestr('SCRIPT', f.getvalue())
+        render_params.output_archive.close()
 
     def jmol_repr(self, render_params):
@@ -434 +441 @@
             #    fg = 2
             filename = '%s-size%s%s'%(base, fg*100, ext)
+            ext = "jmol"
+            archive_name = "%s.%s.zip" % (filename, ext)
 
             T = self._prepare_for_jmol(frame, axes, frame_aspect_ratio, aspect_ratio, zoom)
-            T.export_jmol(filename + ".jmol", force_reload=EMBEDDED_MODE, **kwds)
+            T.export_jmol(archive_name, force_reload=EMBEDDED_MODE, **kwds)
             viewer_app = sage.misc.misc.SAGE_LOCAL + "/java/jmol/jmol"
-            ext = "jmol"
+
+            # We need a script to load the file
+            f = open(filename + '.jmol', 'w')
+            f.write('set defaultdirectory "%s"\n' % archive_name)
+            f.write('script SCRIPT\n')
+            f.close()
 
         if ext is None:
@@ -675 +689 @@
         self.transform = None
         self.ds = 1
+        self.crease_threshold = .8
         self.__dict__.update(kwds)
         

sage/plot/plot3d/base.pyx

@@ -77 +77 @@
             return other
         return Graphics3dGroup([self, other])
+
+    def aspect_ratio(self, v=None):
+        if not v is None:
+            if not isinstance(v, (tuple, list)):
+                raise TypeError, "v must be a list or tuple of length 3"
+            self._aspect_ratio = [float(a) for a in v]
+        else:
+            if self._aspect_ratio is None:
+                self._aspect_ratio = [1.0,1.0,1.0]
+            return self._aspect_ratio
+
+    def frame_aspect_ratio(self, v=None):
+        if not v is None:
+            self._frame_aspect_ratio = v
+        else:
+            if self._frame_aspect_ratio is None:
+                self._frame_aspect_ratio = [1,1,1]
+            return self._frame_aspect_ratio
 
     def bounding_box(self):
@@ -233 +251 @@
             return self.transform(T=T)
 
-    def _rescale_for_aspect_ratio_and_zoom(self, b, aspect_ratio, zoom):
-        if aspect_ratio is None:
+    def _rescale_for_frame_aspect_ratio_and_zoom(self, b, frame_aspect_ratio, zoom):
+        if frame_aspect_ratio is None:
             return (b*zoom,b*zoom,b*zoom), (-b*zoom,-b*zoom,-b*zoom)
-        box = [b*w for w in aspect_ratio]
+        box = [b*w for w in frame_aspect_ratio]
         # Now take the maximum length in box and rescale to b.
         s = b / max(box)
@@ -243 +261 @@
         return box_min, box_max
 
-    def _prepare_for_jmol(self, frame, axes, aspect_ratio, zoom):
-        box_min, box_max = self._rescale_for_aspect_ratio_and_zoom(6.0, aspect_ratio, zoom)
-        return self._transform_to_bounding_box(box_min, box_max, frame=frame,
-                                               axes=axes, thickness=1)
-
-    def _prepare_for_tachyon(self, frame, axes, aspect_ratio, zoom):
-        box_min, box_max = self._rescale_for_aspect_ratio_and_zoom(1.0, aspect_ratio, zoom)
-        A = self._transform_to_bounding_box(box_min, box_max,
+    def _prepare_for_jmol(self, frame, axes, frame_aspect_ratio, aspect_ratio, zoom):
+        box_min, box_max = self._rescale_for_frame_aspect_ratio_and_zoom(6.0, frame_aspect_ratio, zoom)
+        a_min, a_max = self._box_for_aspect_ratio(aspect_ratio, box_min, box_max)
+        return self._transform_to_bounding_box(box_min, box_max, a_min, a_max, frame=frame,
+                                            axes=axes, thickness=1)
+
+    def _prepare_for_tachyon(self, frame, axes, frame_aspect_ratio, aspect_ratio, zoom):
+        box_min, box_max = self._rescale_for_frame_aspect_ratio_and_zoom(1.0, frame_aspect_ratio, zoom)
+        a_min, a_max = self._box_for_aspect_ratio(aspect_ratio, box_min, box_max)
+        return self._transform_to_bounding_box(box_min, box_max, a_min, a_max,
                                             frame=frame, axes=axes, thickness=0.5)
-        return A
-
-    def _transform_to_bounding_box(self, xyz_min, xyz_max, frame, axes, thickness):
+
+    def _box_for_aspect_ratio(self, aspect_ratio, box_min, box_max):
+        # Lengths of new box
+        new_box = [box_max[i] - box_min[i] for i in range(3)]
+        
+        # Find a box around self so that when self gets rescaled into the
+        # box defined by box_min, box_max, it has the right aspect ratio
+        if aspect_ratio == "automatic":
+            return self.bounding_box()
         a_min, a_max = self.bounding_box()
         a_min = list(a_min); a_max = list(a_max)
@@ -261 +287 @@
                 a_min[i] = -1
                 a_max[i] = 1
+                
+        # 1. 
+        longest_side = 0; longest_length = 0
+        shortest_side = 0; shortest_length = a_max[0] - a_min[0]
+        
+        for i in range(3):
+            s = a_max[i] - a_min[i]
+            if s > longest_length:
+                longest_length = s
+                longest_side = i
+            if s < shortest_length:
+                shortest_length = s
+                shortest_side = i
+
+        # 2. Rescale aspect_ratio so the shortest side is 1.
+        r = float(aspect_ratio[shortest_side])
+        aspect_ratio = [a/r for a in aspect_ratio]
+
+        # 3. Extend the bounding box of self by rescaling so the sides
+        # have the same ratio as aspect_ratio, and without changing
+        # the longest side.
+        long_box_side = box_max[longest_side] - box_min[longest_side]
+        sc = [1.0,1.0,1.0]
+        for i in range(3):
+            if i != longest_side:
+                # compute the length we want:
+                new_length = longest_length / aspect_ratio[i]
+                # change the side length by a_min and a_max so
+                # that a_max[i] - a_min[i] = new_length
+
+                # We have to take into account the ratio of the sides after transforming
+                # to the bounding box.
+                z = long_box_side / (box_max[i] - box_min[i])
+                w = new_length / ((a_max[i] - a_min[i]) * z)
+                sc[i] = w
+
+        w = min(sc)
+        sc = [z/w for z in sc]
+        for i in range(3):
+            a_min[i] *= sc[i]
+            a_max[i] *= sc[i]            
+            
+        return a_min, a_max
+
+    def _transform_to_bounding_box(self, xyz_min, xyz_max, a_min, a_max, frame, axes, thickness):
 
         # Rescale in each direction
@@ -291 +362 @@
 
     def show(self, viewer="jmol", filename=None, verbosity=0, figsize=5,
-             aspect_ratio = None, zoom=1, 
+             aspect_ratio = "automatic",
+             frame_aspect_ratio = "automatic",
+             zoom=1, 
              frame=True, axes = False, **kwds):
         """
@@ -305 +378 @@
                        pixels in each direction is 100 times figsize[0].
                        This is ignored for the jmol embedded renderer. 
-            **kwds -- other options, which make sense for particular rendering engines           
+            **kwds -- other options, which make sense for particular rendering engines
+
+        EXAMPLES:
+
+        We illustrate use of the aspect_ratio option:
+           sage: var('x,y')
+           sage: p = plot3d(2*sin(x*y), (x, -pi, pi), (y, -pi, pi))
+           sage: p.show(aspect_ratio=[1,1,1])
+
+        This looks flattened, but filled with the plot:
+           sage: p.show(frame_aspect_ratio=[1,1,1/16])
+
+        This looks flattened, but the plot is square and smaller:
+           sage: p.show(aspect_ratio=[1,1,1], frame_aspect_ratio=[1,1,1/8])
+           
         """
+        if frame_aspect_ratio == "automatic":
+            frame_aspect_ratio = self.frame_aspect_ratio()
+
         import sage.misc.misc
         if filename is None:
@@ -326 +416 @@
 
         if DOCTEST_MODE or viewer=='tachyon' or (viewer=='java3d' and EMBEDDED_MODE):
-            T = self._prepare_for_tachyon(frame, axes, aspect_ratio, zoom)
+            T = self._prepare_for_tachyon(frame, axes, frame_aspect_ratio, aspect_ratio, zoom)
             tachyon_rt(T.tachyon(**kwds), filename+".png", verbosity, True, opts)
             ext = "png"
@@ -354 +444 @@
             archive_name = "%s.%s.zip" % (filename, ext)
 
-            T = self._prepare_for_jmol(frame, axes, aspect_ratio, zoom)
+            T = self._prepare_for_jmol(frame, axes, frame_aspect_ratio, aspect_ratio, zoom)
             T.export_jmol(archive_name, force_reload=EMBEDDED_MODE, **kwds)
             viewer_app = sage.misc.misc.SAGE_LOCAL + "/java/jmol/jmol"
@@ -377 +467 @@
     def __init__(self, all=[]):
         self.all = all
+        self.frame_aspect_ratio(optimal_aspect_ratios([a.frame_aspect_ratio() for a in all]))
+        self.aspect_ratio(optimal_aspect_ratios([a.aspect_ratio() for a in all]))
 
     def bounding_box(self):
@@ -429 +521 @@
         if T is not None: 
             self.T = T
+        self.frame_aspect_ratio(optimal_aspect_ratios([a.frame_aspect_ratio() for a in all]))
+        self.aspect_ratio(optimal_aspect_ratios([a.aspect_ratio() for a in all]))
 
     def bounding_box(self):
@@ -670 +764 @@
     """
     return tuple([max([a[i] for a in v]) for i in range(3)])
+
+
+def optimal_aspect_ratios(ratios):
+    # average the aspect ratios
+    n = len(ratios)
+    if n > 0:
+        return [max([z[i] for z in ratios]) for i in range(3)]
+    else:
+        return [1.0,1.0,1.0]
+        

sage/plot/plot3d/plot3d.py

@@ -59 +59 @@
         return [a,b,c]
 
+import parametric_plot3d
+def plot3d(f, urange, vrange, **kwds):
+    """
+    EXAMPLES:
+    We plot a 3d function defined as a Python function:
+        sage: show(plot3d(lambda x, y: x^2 + y^2, (-2,2), (-2,2)))
 
-def plot3d(f,(xmin,xmax),(ymin,ymax),texture=None, opacity=1, grad_f=None,
+    We plot some 3d symbolic functions:
+        sage: var('x,y')
+        sage: show(plot3d(x^2 + y^2, (x,-2,2), (y,-2,2)))
+        sage: show(plot3d(sin(x*y), (x, -pi, pi), (y, -pi, pi)))
+
+    We draw two parametric surfaces and a transparent plane:
+        sage: L = plot3d(lambda x,y: 0, (-5,5), (-5,5), texture=Texture("lightblue", opacity=0.8))
+        sage: P = plot3d(lambda x,y: 4 - x^3 - y^2, (-2,2), (-2,2), texture=Texture('green'))
+        sage: Q = plot3d(lambda x,y: x^3 + y^2 - 4, (-2,2), (-2,2), texture=Texture('orange'))
+        sage: show(L + P + Q)    
+    """
+    if len(urange) == 2:
+        w = (lambda u,v: u, lambda u,v: v, f)
+    else:
+        u = urange[0]
+        v = vrange[0]
+        w = (u, v, f)
+    P = parametric_plot3d.parametric_plot3d(w, urange, vrange, **kwds)
+    P.frame_aspect_ratio([1.0,1.0,0.5])
+    return P
+
+# This sucks.  It looks like crap.  Simple grid sampling looks way better?!
+def plot3d_old(f,(xmin,xmax),(ymin,ymax),texture=None, opacity=1, grad_f=None,
            max_bend=.5, max_depth=5, initial_depth=4, num_colors=None):
     """
     EXAMPLES:
-    
-
     """
     if initial_depth >= max_depth:

sage/plot/plot3d/shapes.pyx

@@ -184 +184 @@
             return ParametricSurface.tachyon_repr(self, render_params)
             
-        if transform is None:
-            base = (0,0,0)
-            top = (0,0,self.height)
-            rad = self.radius
-        else:
-            base = transform.transform_point((0,0,0))
-            top = transform.transform_point((0,0,self.height))
-            radv = transform.transform_vector((self.radius,0,0))
-            rad = sqrt(sum([x*x for x in radv]))
+        base, top = self.get_endpoints(transform)
+        rad = self.get_radius(transform)
         cyl = """FCylinder 
    Base %s %s %s
@@ -207 +200 @@
         else:
             return cyl
+            
+    def jmol_repr(self, render_params):
+        transform = render_params.transform
+        base, top = self.get_endpoints(transform)
+        rad = self.get_radius(transform)
+        
+        cdef double ratio = sqrt(rad*rad / ((base[0]-top[0])**2 + (base[1]-top[1])**2 + (base[2]-top[2])**2))
+
+        if ratio > .02:
+            if not (transform is None or transform.is_uniform_on([(1,0,0),(0,1,0)])) or ratio > .05:
+                # Jmol can't do sqashed
+                return ParametricSurface.jmol_repr(self, render_params)
+            
+        name = render_params.unique_name('line')
+        return ["""
+draw %s width %s {%s %s %s} {%s %s %s}\n%s
+""" % (name, 
+       rad,
+       base[0], base[1], base[2],
+       top [0], top [1], top [2],
+       self.texture.jmol_str("$" + name)) ]
+       
+    def get_endpoints(self, transform=None):
+        if transform is None:
+            return (0,0,0), (0,0,self.height)
+        else:
+            return transform.transform_point((0,0,0)), transform.transform_point((0,0,self.height))
+            
+    def get_radius(self, transform=None):
+        if transform is None:
+            return self.radius
+        else:
+            radv = transform.transform_vector((self.radius,0,0))
+            return sqrt(sum([x*x for x in radv]))
+    
 
     def get_grid(self, ds):

sage/plot/plot3d/shapes.pyx

@@ -207 +207 @@
         
         cdef double ratio = sqrt(rad*rad / ((base[0]-top[0])**2 + (base[1]-top[1])**2 + (base[2]-top[2])**2))
-        print ratio
 
         if ratio > .02: