Coverage for local/lib/python2.7/site-packages/sage/plot/plot3d/base.pyx: 74%

string_list = ["ply\nformat ascii 1.0\ncomment {}\nelement vertex {}\nproperty float x\nproperty float y\nproperty float z\nelement face {}\nproperty list uchar int vertex_indices\nend_header\n".format(name, len(self.vertex_list()), len(faces))]

vertex_template = '{} {} {}\n'

for v in self.vertices():

string_list += [vertex_template.format(*v)]

for f in faces:

string_list += [str(len(f))

+ ''.join(' {}'.format(k) for k in f) + '\n']

return "".join(string_list)

def amf_ascii_string(self, name="surface"):

"""

Return an AMF (Additive Manufacturing File Format) representation of

the surface.

.. WARNING::

This only works for triangulated surfaces!

INPUT:

- ``name`` (string, default: "surface") -- name of the surface.

OUTPUT:

A string that represents the surface in the AMF format.

See :wikipedia:`Additive_Manufacturing_File_Format`

.. TODO::

This should rather be saved as a ZIP archive to save space.

EXAMPLES::

sage: x,y,z = var('x,y,z')

sage: a = implicit_plot3d(x^2+y^2+z^2-9,[x,-5,5],[y,-5,5],[z,-5,5])

sage: a_amf = a.amf_ascii_string()

sage: a_amf[:160]

'<?xml version="1.0" encoding="utf-8"?><amf><object id="surface"><mesh><vertices><vertex><coordinates><x>2.94871794872</x><y>-0.384615384615</y><z>-0.39358974359'

sage: p = polygon3d([[0,0,0], [1,2,3], [3,0,0]])

sage: print(p.amf_ascii_string(name='triangle'))

<?xml version="1.0" encoding="utf-8"?><amf><object id="triangle"><mesh><vertices><vertex><coordinates><x>0.0</x><y>0.0</y><z>0.0</z></coordinates></vertex><vertex><coordinates><x>1.0</x><y>2.0</y><z>3.0</z></coordinates></vertex><vertex><coordinates><x>3.0</x><y>0.0</y><z>0.0</z></coordinates></vertex></vertices><volume><triangle><v1>0</v1><v2>1</v2><v3>2</v3></triangle></volume></mesh></object></amf>

"""

faces = self.index_faces()

if not faces:

self.triangulate()

faces = self.index_faces()

if len(faces[0]) > 3:

raise ValueError('not made of triangles')

string_list = ['<?xml version="1.0" encoding="utf-8"?><amf><object id="{}"><mesh>'.format(name)]

string_list += ['<vertices>']

vertex_template = '<vertex><coordinates><x>{}</x><y>{}</y><z>{}</z></coordinates></vertex>'

for v in self.vertices():

string_list += [vertex_template.format(*v)]

string_list += ['</vertices><volume>']

face_template = '<triangle><v1>{}</v1><v2>{}</v2><v3>{}</v3></triangle>'

for i, j, k in faces:

string_list += face_template.format(i, j, k)

string_list += ['</volume></mesh></object></amf>']

return "".join(string_list)

def plot(self):

"""

Draw a 3D plot of this graphics object, which just returns this

object since this is already a 3D graphics object.

Needed to support PLOT in doctrings, see :trac:`17498`

EXAMPLES::

sage: S = sphere((0,0,0), 2)

sage: S.plot() is S

True

"""

return self

# if you add any default parameters you must update some code below

SHOW_DEFAULTS = {'viewer': 'jmol',

'verbosity': 0,

'figsize': 5,

'aspect_ratio': "automatic",

'frame_aspect_ratio': "automatic",

'zoom': 1,

'frame': True,

'axes': False}

class Graphics3dGroup(Graphics3d):

"""

This class represents a collection of 3d objects. Usually they are formed

implicitly by summing.

"""

def __init__(self, all=(), rot=None, trans=None, scale=None, T=None):

"""

EXAMPLES::

sage: sage.plot.plot3d.base.Graphics3dGroup([icosahedron(), dodecahedron(opacity=.5)])

Graphics3d Object

sage: type(icosahedron() + dodecahedron(opacity=.5))

"""

self.all = list(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]))

self._set_extra_kwds(optimal_extra_kwds([a._extra_kwds for a in all]))

def __add__(self, other):

"""

We override this here to make large sums more efficient.

EXAMPLES::

sage: G = sum(tetrahedron(opacity=1-t/11).translate(t, 0, 0) for t in range(10))

sage: G

Graphics3d Object

sage: len(G.all)

We check that :trac:`17258` is solved::

sage: g = point3d([0,-2,-2]); g += point3d([2,-2,-2])

sage: len(g.all)

sage: h = g + arrow([0,-2,-2], [2,-2,-2])

sage: len(g.all)

sage: g == h

False

"""

if type(self) is Graphics3dGroup and isinstance(other, Graphics3d):

s_all = list(self.all)

s_all.append(other)

return Graphics3dGroup(s_all)

else:

return Graphics3d.__add__(self, other)

def bounding_box(self):

"""

Box that contains the bounding boxes of

all the objects that make up ``self``.

EXAMPLES::

sage: A = sphere((0,0,0), 5)

sage: B = sphere((1, 5, 10), 1)

sage: A.bounding_box()

((-5.0, -5.0, -5.0), (5.0, 5.0, 5.0))

sage: B.bounding_box()

((0.0, 4.0, 9.0), (2.0, 6.0, 11.0))

sage: (A+B).bounding_box()

((-5.0, -5.0, -5.0), (5.0, 6.0, 11.0))

sage: (A+B).show(aspect_ratio=1, frame=True)

sage: sage.plot.plot3d.base.Graphics3dGroup([]).bounding_box()

((0.0, 0.0, 0.0), (0.0, 0.0, 0.0))

"""

if len(self.all) == 0:

return Graphics3d.bounding_box(self)

v = [obj.bounding_box() for obj in self.all]

return min3([a[0] for a in v]), max3([a[1] for a in v])

def transform(self, **kwds):

"""

Transforming this entire group simply makes a transform group with

the same contents.

EXAMPLES::

sage: G = dodecahedron(color='red', opacity=.5) + icosahedron(color='blue')

sage: G

Graphics3d Object

sage: G.transform(scale=(2,1/2,1))

Graphics3d Object

sage: G.transform(trans=(1,1,3))

Graphics3d Object

"""

T = TransformGroup(self.all, **kwds)

T._set_extra_kwds(self._extra_kwds)

return T

def set_texture(self, **kwds):

"""

EXAMPLES::

sage: G = dodecahedron(color='red', opacity=.5) + icosahedron((3, 0, 0), color='blue')

sage: G

Graphics3d Object

sage: G.set_texture(color='yellow')

sage: G

Graphics3d Object

"""

for g in self.all:

g.set_texture(**kwds)

def json_repr(self, render_params):

"""

The JSON representation of a group is simply the concatenation of the

representations of its objects.

EXAMPLES::

sage: G = sphere() + sphere((1, 2, 3))

sage: G.json_repr(G.default_render_params())

[[['{"vertices":...']], [['{"vertices":...']]]

"""

return [g.json_repr(render_params) for g in self.all]

def tachyon_repr(self, render_params):

"""

The tachyon representation of a group is simply the concatenation of

the representations of its objects.

EXAMPLES::

sage: G = sphere() + sphere((1,2,3))

sage: G.tachyon_repr(G.default_render_params())

[['Sphere center 0.0 0.0 0.0 Rad 1.0 texture...'],

['Sphere center 1.0 2.0 3.0 Rad 1.0 texture...']]

"""

return [g.tachyon_repr(render_params) for g in self.all]

def x3d_str(self):

"""

The x3d representation of a group is simply the concatenation of

the representation of its objects.

EXAMPLES::

sage: G = sphere() + sphere((1,2,3))

sage: print(G.x3d_str())

</Transform>

</Transform>

"""

return "\n".join([g.x3d_str() for g in self.all])

def obj_repr(self, render_params):

"""

The obj representation of a group is simply the concatenation of

the representation of its objects.

EXAMPLES::

sage: G = tetrahedron() + tetrahedron().translate(10, 10, 10)

sage: G.obj_repr(G.default_render_params())

[['g obj_1',

'usemtl ...',

['v 0 0 1',

'v 0.942809 0 -0.333333',

'v -0.471405 0.816497 -0.333333',

'v -0.471405 -0.816497 -0.333333'],

['f 1 2 3', 'f 2 4 3', 'f 1 3 4', 'f 1 4 2'],

[]],

[['g obj_2',

'usemtl ...',

['v 10 10 11',

'v 10.9428 10 9.66667',

'v 9.5286 10.8165 9.66667',

'v 9.5286 9.1835 9.66667'],

['f 5 6 7', 'f 6 8 7', 'f 5 7 8', 'f 5 8 6'],

[]]]]

"""

return [g.obj_repr(render_params) for g in self.all]

def jmol_repr(self, render_params):

r"""

The jmol representation of a group is simply the concatenation of

the representation of its objects.

EXAMPLES::

sage: G = sphere() + sphere((1,2,3))

sage: G.jmol_repr(G.default_render_params())

[[['isosurface sphere_1 center {0.0 0.0 0.0} sphere 1.0\ncolor isosurface [102,102,255]']],

[['isosurface sphere_2 center {1.0 2.0 3.0} sphere 1.0\ncolor isosurface [102,102,255]']]]

"""

return [g.jmol_repr(render_params) for g in self.all]

def texture_set(self):

"""

The texture set of a group is simply the union of the textures of

all its objects.

EXAMPLES::

sage: G = sphere(color='red') + sphere(color='yellow')

sage: [t for t in G.texture_set() if t.color == colors.red] # one red texture

[Texture(texture..., red, ff0000)]

sage: [t for t in G.texture_set() if t.color == colors.yellow] # one yellow texture

[Texture(texture..., yellow, ffff00)]

sage: T = sage.plot.plot3d.texture.Texture('blue'); T

Texture(texture..., blue, 0000ff)

sage: G = sphere(texture=T) + sphere((1, 1, 1), texture=T)

sage: len(G.texture_set())

TESTS:

Check that :trac:`23200` is fixed::

sage: G = sage.plot.plot3d.base.Graphics3dGroup()

sage: G.texture_set()

set()

"""

if not self.all:

return set()

return reduce(set.union, [g.texture_set() for g in self.all])

def flatten(self):

"""

Try to reduce the depth of the scene tree by consolidating groups

and transformations.

EXAMPLES::

sage: G = sum([circle((0, 0), t) for t in [1..10]], sphere()); G

Graphics3d Object

sage: G.flatten()

Graphics3d Object

sage: len(G.all)

sage: len(G.flatten().all)

"""

if len(self.all) == 1:

return self.all[0].flatten()

all = []

for g in self.all:

g = g.flatten()

if type(g) is Graphics3dGroup:

all += g.all

else:

all.append(g)

return Graphics3dGroup(all)

def plot(self):

return self

class TransformGroup(Graphics3dGroup):

"""

This class is a container for a group of objects with a common

transformation.

"""

def __init__(self, all=[], rot=None, trans=None, scale=None, T=None):

"""

EXAMPLES::

sage: sage.plot.plot3d.base.TransformGroup([sphere()], trans=(1,2,3)) + point3d((0,0,0))

Graphics3d Object

The are usually constructed implicitly::

sage: type(sphere((1,2,3)))

sage: type(dodecahedron().scale(2))

"""

Graphics3dGroup.__init__(self, all)

self._rot = rot

self._trans = trans

if scale is not None and len(scale) == 1:

if isinstance(scale, (tuple, list)):

scale = scale[0]

scale = (scale, scale, scale)

self._scale = scale

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]))

self._set_extra_kwds(optimal_extra_kwds([a._extra_kwds for a in all if a._extra_kwds is not None]))

def bounding_box(self):

"""

Return the bounding box of ``self``, i.e., the box containing the

contents of ``self`` after applying the transformation.

EXAMPLES::

sage: G = cube()

sage: G.bounding_box()

((-0.5, -0.5, -0.5), (0.5, 0.5, 0.5))

sage: G.scale(4).bounding_box()

((-2.0, -2.0, -2.0), (2.0, 2.0, 2.0))

sage: G.rotateZ(pi/4).bounding_box()

((-0.7071067811865475, -0.7071067811865475, -0.5),

(0.7071067811865475, 0.7071067811865475, 0.5))

"""

try:

return self._bounding_box

except AttributeError:

pass

cdef Transformation T = self.get_transformation()

w = sum([T.transform_bounding_box(obj.bounding_box()) for obj in self.all], ())

self._bounding_box = point_list_bounding_box(w)

return self._bounding_box

def x3d_str(self):

r"""

To apply a transformation to a set of objects in x3d, simply make them

all children of an x3d Transform node.

EXAMPLES::

sage: sphere((1,2,3)).x3d_str()

"<Transform translation='1 2 3'>\n<Shape><Sphere radius='1.0'/><Appearance><Material diffuseColor='0.4 0.4 1.0' shininess='1.0' specularColor='0.0 0.0 0.0'/></Appearance></Shape>\n\n</Transform>"

"""

s = "<Transform"

if self._rot is not None:

s += " rotation='%s %s %s %s'"%tuple(self._rot)

if self._trans is not None:

s += " translation='%s %s %s'"%tuple(self._trans)

if self._scale is not None:

s += " scale='%s %s %s'"%tuple(self._scale)

s += ">\n"

s += Graphics3dGroup.x3d_str(self)

s += "\n</Transform>"

return s

def json_repr(self, render_params):

"""

Transformations are applied at the leaf nodes.

EXAMPLES::

sage: G = cube().rotateX(0.2)

sage: G.json_repr(G.default_render_params())

[['{"vertices":[{"x":0.5,"y":0.589368,"z":0.390699},...']]

"""

render_params.push_transform(self.get_transformation())

rep = [g.json_repr(render_params) for g in self.all]

render_params.pop_transform()

return rep

def tachyon_repr(self, render_params):

"""

Transformations for Tachyon are applied at the leaf nodes.

EXAMPLES::

sage: G = sphere((1,2,3)).scale(2)

sage: G.tachyon_repr(G.default_render_params())

[['Sphere center 2.0 4.0 6.0 Rad 2.0 texture...']]

"""

render_params.push_transform(self.get_transformation())

rep = [g.tachyon_repr(render_params) for g in self.all]

render_params.pop_transform()

return rep

def obj_repr(self, render_params):

"""

Transformations for .obj files are applied at the leaf nodes.

EXAMPLES::

sage: G = cube().scale(4).translate(1, 2, 3)

sage: G.obj_repr(G.default_render_params())

[[['g obj_1',

'usemtl ...',

['v 3 4 5',

'v -1 4 5',

'v -1 0 5',

'v 3 0 5',

'v 3 4 1',

'v -1 4 1',

'v 3 0 1',

'v -1 0 1'],

['f 1 2 3 4',

'f 1 5 6 2',

'f 1 4 7 5',

'f 6 5 7 8',

'f 7 4 3 8',

'f 3 2 6 8'],

[]]]]

"""

render_params.push_transform(self.get_transformation())

rep = [g.obj_repr(render_params) for g in self.all]

render_params.pop_transform()

return rep

def jmol_repr(self, render_params):

r"""

Transformations for jmol are applied at the leaf nodes.

EXAMPLES::

sage: G = sphere((1,2,3)).scale(2)

sage: G.jmol_repr(G.default_render_params())

[[['isosurface sphere_1 center {2.0 4.0 6.0} sphere 2.0\ncolor isosurface [102,102,255]']]]

"""

render_params.push_transform(self.get_transformation())

rep = [g.jmol_repr(render_params) for g in self.all]

render_params.pop_transform()

return rep

def get_transformation(self):

"""

Return the actual transformation object associated with ``self``.

EXAMPLES::

sage: G = sphere().scale(100)

sage: T = G.get_transformation()

sage: T.get_matrix()

[100.0 0.0 0.0 0.0]

[ 0.0 100.0 0.0 0.0]

[ 0.0 0.0 100.0 0.0]

[ 0.0 0.0 0.0 1.0]

"""

try:

return self.T

except AttributeError:

self.T = Transformation(self._scale, self._rot, self._trans)

return self.T

def flatten(self):

"""

Try to reduce the depth of the scene tree by consolidating groups

and transformations.

EXAMPLES::

sage: G = sphere((1,2,3)).scale(100)

sage: T = G.get_transformation()

sage: T.get_matrix()

[100.0 0.0 0.0 0.0]

[ 0.0 100.0 0.0 0.0]

[ 0.0 0.0 100.0 0.0]

[ 0.0 0.0 0.0 1.0]

sage: G.flatten().get_transformation().get_matrix()

[100.0 0.0 0.0 100.0]

[ 0.0 100.0 0.0 200.0]

[ 0.0 0.0 100.0 300.0]

[ 0.0 0.0 0.0 1.0]

"""

G = Graphics3dGroup.flatten(self)

if isinstance(G, TransformGroup):

return TransformGroup(G.all, T=self.get_transformation() * G.get_transformation())

elif isinstance(G, Graphics3dGroup):

return TransformGroup(G.all, T=self.get_transformation())

else:

return TransformGroup([G], T=self.get_transformation())

def transform(self, **kwds):

"""

Transforming this entire group can be done by composing transformations.

EXAMPLES::

sage: G = dodecahedron(color='red', opacity=.5) + icosahedron(color='blue')

sage: G

Graphics3d Object

sage: G.transform(scale=(2,1/2,1))

Graphics3d Object

sage: G.transform(trans=(1,1,3))

Graphics3d Object

"""

return Graphics3d.transform(self, **kwds)

class Viewpoint(Graphics3d):

"""

This class represents a viewpoint, necessary for x3d.

In the future, there could be multiple viewpoints, and they could have

more properties. (Currently they only hold a position).

"""

def __init__(self, *x):

"""

EXAMPLES::

sage: sage.plot.plot3d.base.Viewpoint(1, 2, 4).x3d_str()

"<Viewpoint position='1 2 4'/>"

"""

if isinstance(x[0], (tuple, list)):

x = tuple(x[0])

self.pos = x

def x3d_str(self):

"""

EXAMPLES::

sage: sphere((0,0,0), 100).viewpoint().x3d_str()

"<Viewpoint position='0 0 6'/>"

"""

return "<Viewpoint position='%s %s %s'/>"%self.pos

cdef class PrimitiveObject(Graphics3d):

"""

This is the base class for the non-container 3d objects.

"""

def __init__(self, **kwds):

if 'texture' in kwds:

self.texture = kwds['texture']

if not is_Texture(self.texture):

self.texture = Texture(self.texture)

else:

self.texture = Texture(kwds)

def set_texture(self, texture=None, **kwds):

"""

EXAMPLES::

sage: G = dodecahedron(color='red'); G

Graphics3d Object

sage: G.set_texture(color='yellow'); G

Graphics3d Object

"""

if not is_Texture(texture):

texture = Texture(texture, **kwds)

self.texture = texture

def get_texture(self):

"""

EXAMPLES::

sage: G = dodecahedron(color='red')

sage: G.get_texture()

Texture(texture..., red, ff0000)

"""

return self.texture

def texture_set(self):

"""

EXAMPLES::

sage: G = dodecahedron(color='red')

sage: G.texture_set()

{Texture(texture..., red, ff0000)}

"""

return set([self.texture])

def x3d_str(self):

r"""

EXAMPLES::

sage: sphere().flatten().x3d_str()

"<Transform>\n<Shape><Sphere radius='1.0'/><Appearance><Material diffuseColor='0.4 0.4 1.0' shininess='1.0' specularColor='0.0 0.0 0.0'/></Appearance></Shape>\n\n</Transform>"

"""

return "<Shape>" + self.x3d_geometry() + self.texture.x3d_str() + "</Shape>\n"

def tachyon_repr(self, render_params):

"""

Default behavior is to render the triangulation.

EXAMPLES::

sage: from sage.plot.plot3d.shapes import Torus

sage: G = Torus(1, .5)

sage: G.tachyon_repr(G.default_render_params())

['TRI V0 0 1 0.5

...

'texture...']

"""

return self.triangulation().tachyon_repr(render_params)

def obj_repr(self, render_params):

"""

Default behavior is to render the triangulation.

EXAMPLES::

sage: from sage.plot.plot3d.shapes import Torus

sage: G = Torus(1, .5)

sage: G.obj_repr(G.default_render_params())

['g obj_1',

'usemtl ...',

['v 0 1 0.5',

...

'f ...'],

[]]

"""

return self.triangulation().obj_repr(render_params)

def jmol_repr(self, render_params):

r"""

Default behavior is to render the triangulation. The actual polygon

data is stored in a separate file.

EXAMPLES::

sage: from sage.plot.plot3d.shapes import Torus

sage: G = Torus(1, .5)

sage: G.jmol_repr(G.testing_render_params())

['pmesh obj_1 "obj_1.pmesh"\ncolor pmesh [102,102,255]']

"""

return self.triangulation().jmol_repr(render_params)

class BoundingSphere(SageObject):

"""

A bounding sphere is like a bounding box, but is simpler to deal with and

behaves better under rotations.

"""

def __init__(self, cen, r):

"""

EXAMPLES::

sage: from sage.plot.plot3d.base import BoundingSphere

sage: BoundingSphere((0,0,0), 1)

Center (0.0, 0.0, 0.0) radius 1

sage: BoundingSphere((0,-1,5), 2)

Center (0.0, -1.0, 5.0) radius 2

"""

self.cen = vector(RDF, cen)

self.r = r

def __repr__(self):

"""

TESTS::

sage: from sage.plot.plot3d.base import BoundingSphere

sage: BoundingSphere((0,-1,10), 2)

Center (0.0, -1.0, 10.0) radius 2

"""

return "Center %s radius %s" % (self.cen, self.r)

def __add__(self, other):

"""

Return the bounding sphere containing both terms.

EXAMPLES::

sage: from sage.plot.plot3d.base import BoundingSphere

sage: BoundingSphere((0,0,0), 1) + BoundingSphere((0,0,0), 2)

Center (0.0, 0.0, 0.0) radius 2

sage: BoundingSphere((0,0,0), 1) + BoundingSphere((0,0,100), 1)

Center (0.0, 0.0, 50.0) radius 51.0

sage: BoundingSphere((0,0,0), 1) + BoundingSphere((1,1,1), 2)

Center (0.7886751345948128, 0.7886751345948128, 0.7886751345948128) radius 2.36602540378

Treat None and 0 as the identity::

sage: BoundingSphere((1,2,3), 10) + None + 0

Center (1.0, 2.0, 3.0) radius 10

"""

if other == 0 or other is None:

return self

elif self == 0 or self is None:

return other

if self.cen == other.cen:

return self if self.r > other.r else other

diff = other.cen - self.cen

dist = (diff[0]*diff[0] + diff[1]*diff[1] + diff[2]*diff[2]).sqrt()

diam = dist + self.r + other.r

off = diam/2 - self.r

return BoundingSphere(self.cen + (off/dist)*diff, diam/2)

def transform(self, T):

"""

Return the bounding sphere of this sphere acted on by T. This always

returns a new sphere, even if the resulting object is an ellipsoid.

EXAMPLES::

sage: from sage.plot.plot3d.transform import Transformation

sage: from sage.plot.plot3d.base import BoundingSphere

sage: BoundingSphere((0,0,0), 10).transform(Transformation(trans=(1,2,3)))

Center (1.0, 2.0, 3.0) radius 10.0

sage: BoundingSphere((0,0,0), 10).transform(Transformation(scale=(1/2, 1, 2)))

Center (0.0, 0.0, 0.0) radius 20.0

sage: BoundingSphere((0,0,3), 10).transform(Transformation(scale=(2, 2, 2)))

Center (0.0, 0.0, 6.0) radius 20.0

"""

return BoundingSphere(T.transform_point(self.cen), self.r * T.max_scale())

class RenderParams(SageObject):

"""

This class is a container for all parameters that may be needed to

render triangulate/render an object to a certain format. It can

contain both cumulative and global parameters.

Of particular note is the transformation object, which holds the

cumulative transformation from the root of the scene graph to this

node in the tree.

"""

_uniq_counter = 0

randomize_counter = 0

force_reload = False

mesh = False

dots = False

antialiasing = 8

def __init__(self, **kwds):

"""

EXAMPLES::

sage: params = sage.plot.plot3d.base.RenderParams(foo='x')

sage: params.transform_list

[]

sage: params.foo

'x'

"""

self.output_file = tmp_filename()

self.obj_vertex_offset = 1

self.transform_list = []

self.transform = None

self.ds = 1

self.crease_threshold = .8

self.__dict__.update(kwds)

# for jmol, some things (such as labels) must be attached to atoms

self.atom_list = []

def push_transform(self, T):

"""

Push a transformation onto the stack, updating self.transform.

EXAMPLES::

sage: from sage.plot.plot3d.transform import Transformation

sage: params = sage.plot.plot3d.base.RenderParams()

sage: params.transform is None

True

sage: T = Transformation(scale=(10,20,30))

sage: params.push_transform(T)

sage: params.transform.get_matrix()

[10.0 0.0 0.0 0.0]

[ 0.0 20.0 0.0 0.0]

[ 0.0 0.0 30.0 0.0]

[ 0.0 0.0 0.0 1.0]

sage: params.push_transform(T) # scale again

sage: params.transform.get_matrix()

[100.0 0.0 0.0 0.0]

[ 0.0 400.0 0.0 0.0]

[ 0.0 0.0 900.0 0.0]

[ 0.0 0.0 0.0 1.0]

"""

self.transform_list.append(self.transform)

if self.transform is None:

self.transform = T

else:

self.transform = self.transform * T

def pop_transform(self):

"""

Remove the last transformation off the stack, resetting self.transform

to the previous value.

EXAMPLES::

sage: from sage.plot.plot3d.transform import Transformation

sage: params = sage.plot.plot3d.base.RenderParams()

sage: T = Transformation(trans=(100, 500, 0))

sage: params.push_transform(T)

sage: params.transform.get_matrix()

[ 1.0 0.0 0.0 100.0]

[ 0.0 1.0 0.0 500.0]

[ 0.0 0.0 1.0 0.0]

[ 0.0 0.0 0.0 1.0]

sage: params.push_transform(Transformation(trans=(-100, 500, 200)))

sage: params.transform.get_matrix()

[ 1.0 0.0 0.0 0.0]

[ 0.0 1.0 0.0 1000.0]

[ 0.0 0.0 1.0 200.0]

[ 0.0 0.0 0.0 1.0]

sage: params.pop_transform()

sage: params.transform.get_matrix()

[ 1.0 0.0 0.0 100.0]

[ 0.0 1.0 0.0 500.0]

[ 0.0 0.0 1.0 0.0]

[ 0.0 0.0 0.0 1.0]

"""

self.transform = self.transform_list.pop()

def unique_name(self, desc="name"):

"""

Return a unique identifier starting with ``desc``.

INPUT:

- ``desc`` (string) -- the prefix of the names (default 'name')

EXAMPLES::

sage: params = sage.plot.plot3d.base.RenderParams()

sage: params.unique_name()

'name_1'

sage: params.unique_name()

'name_2'

sage: params.unique_name('texture')

'texture_3'

"""

if self.randomize_counter:

self._uniq_counter = randint(1,1000000)

else:

self._uniq_counter += 1

return "%s_%s" % (desc, self._uniq_counter)

def flatten_list(L):

"""

This is an optimized routine to turn a list of lists (of lists ...)

into a single list. We generate data in a non-flat format to avoid

multiple data copying, and then concatenate it all at the end.

This is NOT recursive, otherwise there would be a lot of redundant

copying (which we are trying to avoid in the first place, though at

least it would be just the pointers).

EXAMPLES::

sage: from sage.plot.plot3d.base import flatten_list

sage: flatten_list([])

[]

sage: flatten_list([[[[]]]])

[]

sage: flatten_list([['a', 'b'], 'c'])

['a', 'b', 'c']

sage: flatten_list([['a'], [[['b'], 'c'], ['d'], [[['e', 'f', 'g']]]]])

['a', 'b', 'c', 'd', 'e', 'f', 'g']

"""

if type(L) is not list:

return [L]

flat = []

L_stack = []; L_pop = L_stack.pop

i_stack = []; i_pop = i_stack.pop

cdef Py_ssize_t i = 0

while i < PyList_GET_SIZE(L) or PyList_GET_SIZE(L_stack) > 0:

while i < PyList_GET_SIZE(L):

tmp = <object>PyList_GET_ITEM(L, i)

if type(tmp) is list:

PyList_Append(L_stack, L)

L = tmp

PyList_Append(i_stack, i)

i = 0

else:

PyList_Append(flat, tmp)

i += 1

if PyList_GET_SIZE(L_stack) > 0:

L = L_pop()

i = i_pop()

i += 1

return flat

def min3(v):

"""

Return the componentwise minimum of a list of 3-tuples.

EXAMPLES::

sage: from sage.plot.plot3d.base import min3, max3

sage: min3([(-1,2,5), (-3, 4, 2)])

(-3, 2, 2)

"""

return tuple([min([a[i] for a in v]) for i in range(3)])

def max3(v):

"""

Return the componentwise maximum of a list of 3-tuples.

EXAMPLES::

sage: from sage.plot.plot3d.base import min3, max3

sage: max3([(-1,2,5), (-3, 4, 2)])

(-1, 4, 5)

"""

return tuple([max([a[i] for a in v]) for i in range(3)])

def point_list_bounding_box(v):

"""

Return the bounding box of a list of points.

EXAMPLES::

sage: from sage.plot.plot3d.base import point_list_bounding_box

sage: point_list_bounding_box([(1,2,3),(4,5,6),(-10,0,10)])

((-10.0, 0.0, 3.0), (4.0, 5.0, 10.0))

sage: point_list_bounding_box([(float('nan'), float('inf'), float('-inf')), (10,0,10)])

((10.0, 0.0, 10.0), (10.0, 0.0, 10.0))

"""

cdef point_c low, high, cur

low.x, low.y, low.z = INFINITY, INFINITY, INFINITY

high.x, high.y, high.z = -INFINITY, -INFINITY, -INFINITY

for P in v:

cur.x, cur.y, cur.z = P

point_c_update_finite_lower_bound(&low, cur)

point_c_update_finite_upper_bound(&high, cur)

return ((low.x, low.y, low.z), (high.x, high.y, high.z))

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)]

return [1.0, 1.0, 1.0]

def optimal_extra_kwds(v):

"""

Given a list v of dictionaries, this function merges them such that

later dictionaries have precedence.

"""

if len(v) == 0:

return {}

a = dict(v[0]) # make a copy!

for b in v[1:]:

for k, w in b.iteritems():

a[k] = w

return a

Coverage for local/lib/python2.7/site-packages/sage/plot/plot3d/base.pyx : 74%

834 statements 615 run 219 missing 0 excluded