1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
## Automatically adapted for scipy Oct 31, 2005 by
# Copyright (c) 1996, 1997, The Regents of the University of California.
# All rights reserved. See Legal.htm for full text and disclaimer.
# The following is so I know about arrays:
from scipy import *
from numpy.core.umath import *
from shapetest import *
from graftypes import *
class Region :
"""
r = Region ( <keyword arguments> ) is used to specify graphing modes
for regions in a QuadMesh plot. If a QuadMesh contains one or more
Region objects, then a Plotter, when asked to plot it, will plot
only the regions specified.
The keyword arguments are:
number = <integer> the number of the Region being specified.
boundary = 0/1 0: plot entire mesh; 1: plot only the boundary of
the selected region. if ktype and ltype are not "none",
then the boundary will be plotted, then the k and l lines
with their own types.
boundary_type, boundary_color: these matter only if boundary = 1,
and tell how the boundary will be plotted and what its color
will be.
inhibit = 0/1/2 1: do not plot the (x [, j], y [, j]) lines;
2: do not plot the (x [i, ], y[i, ]) lines.
levels = optional two-dimensional sequences of floating point
values. If present, a list of the values of z at which you
want contours.
filled = 0/1 If 1, plot a filled mesh using the values of z.
If z is not present, the mesh zones will be filled with the
background color, which allows plotting of a wire frame.
edges, if nonzero when filled=1, draw a solid edge around
each zone.
contours = 0/1 together with filled, controls whether you get
filled contours or just contours, or no contours at all.
z_scale = "lin", "log", or "normal" as for QuadMesh.
vectors = 0/1 allows the user to choose whether or not to
plot vx and vy on this region.
ktype, ltype: can have the same values as type, and allow the
k and l mesh lines to be plotted differently.
#### eventually, we can add kcolor, lcolor, kwidth, lwidth ####
type, color, width, label, hide, marks, marker as for
curves.
"""
def type (self) :
return RegionType
_RegionSpecError = "RegionSpecError"
def __init__ ( self , *kwds , **keywords ) :
if len (kwds) == 1 :
keywords = kwds[0]
if not keywords.has_key ( "number" ) :
raise _RegionSpecError, "Region number not specified!"
self.number = keywords ["number"]
if keywords.has_key ("boundary") :
self.boundary = keywords ["boundary"]
else :
self.boundary = 0
if keywords.has_key ("boundary_type") :
self.boundary_type = keywords ["boundary_type"]
else :
self.boundary_type = "solid"
if keywords.has_key ("boundary_color") :
self.boundary_color = keywords ["boundary_color"]
else :
self.boundary_color = "fg"
if keywords.has_key ("inhibit") :
self.inhibit = keywords ["inhibit"]
else :
self.inhibit = 0
if keywords.has_key ("label") :
self.label = keywords ["label"]
else :
self.label = " "
if keywords.has_key ("hide") :
self.hide = keywords ["hide"]
else :
self.hide = 0
if self.boundary == 1 :
self.line_type = "none"
else :
self.line_type = "solid"
if keywords.has_key ("type") :
self.line_type = keywords ["type"]
if keywords.has_key ("ktype") :
self.ktype = keywords ["ktype"]
else :
self.ktype = self.line_type
if keywords.has_key ("ltype") :
self.ltype = keywords ["ltype"]
else :
self.ltype = self.line_type
if keywords.has_key ("width") :
self.width = keywords ["width"]
else :
self.width = 1
if keywords.has_key ("color") :
self.color = keywords ["color"]
else :
self.color = "fg"
if keywords.has_key ("filled") :
self.filled = keywords ["filled"]
else :
self.filled = 0
if keywords.has_key ("edges") :
self.edges = keywords ["edges"]
else :
self.edges = 0
if keywords.has_key ("vectors") :
self.vectors = keywords ["vectors"]
else :
self.vectors = 1
if keywords.has_key ("contours") :
self.contours = keywords ["contours"]
elif self.filled == 0 and self.edges == 0 and self.vectors == 0 :
self.contours = 1
else :
self.contours = 0
if keywords.has_key ("z_scale") :
self.z_scale = keywords ["z_scale"]
else :
self.z_scale = "lin"
if keywords.has_key ("ewidth") :
self.ewidth = keywords ["ewidth"]
else :
self.ewidth = 1
if keywords.has_key ("ecolor") :
self.ecolor = keywords ["ecolor"]
else :
self.ecolor = "fg"
if keywords.has_key ("levels") :
self.levels = keywords ["levels"]
else :
self.levels = None
if keywords.has_key ("marks") :
self.marks = keywords ["marks"]
else :
self.marks = 0
if keywords.has_key ( "marker" ) :
self.marker = keywords [ "marker" ]
else :
self.marker = "unspecified"
def new ( self, ** keywords ) :
""" new (...keyword arguments...) allows you to reuse a
previously existing Region.
"""
self.__init__ ( keywords )
def set ( self , ** keywords ) :
""" set (...keyword arguments...) allows you to set individual
Region characteristics. No error checking is done.
"""
for k in keywords.keys ():
if k == "type" :
self.line_type = keywords ["type"]
else :
setattr (self, k, keywords [k])
|
