/[escript]/trunk/doc/user/pyvisi.tex
ViewVC logotype

Contents of /trunk/doc/user/pyvisi.tex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 606 - (show annotations)
Mon Mar 20 23:34:00 2006 UTC (14 years, 4 months ago) by gross
File MIME type: application/x-tex
File size: 26880 byte(s)
documentation on pyvisi added
1 \chapter{The module \pyvisi}
2
3 \declaremodule{extension}{pyvisi}
4 \modulesynopsis{visualization interface}
5
6 The idea behind is to provide an easy to use interface and unified to a variety of
7 visualization tools like \VTK, \OpenDX and \GnuPlot.
8
9 The following script illustartes the usage of \pyvisi together with the
10 \VTK library:
11 \begin{python}
12 from esys.pyvisi import * # base level visualisation stuff
13 from esys.pyvisi.renderers.vtk import * # vtk renderer module
14 from esys.escript import *
15 from esys.finley import Brick
16 # now make some data of some kind
17 domain = Brick(3,5,7) # a Finley domain
18 vectorData = domain.getX() # get vector data from the domain nodes
19 # define the scene object
20 scene = Scene()
21 # create an ArrowPlot object
22 plot = ArrowPlot(scene)
23 # add the plot to the scene
24 scene.add(plot)
25 # assign some data to the plot
26 plot.setData(vectorData)
27 # render the scene
28 scene.render()
29 # saving a scene
30 scene.save(file="example.jpg", format="jpeg")
31 \begin{python}
32 A \Scene is a container for all of the kinds of things you want to put into your plot,
33 for instance, images, domaines, arrow plots, contour plots, spheres etc.
34 The renderer is specified in the scene initialisation. In fact the
35 \code{from esys.pyvisi.renderers.vtk import *} provides the specific implementation for
36 \VTK
37
38
39 \begin{verbose}
40 class ArrowPlot3D(Plot):
41 """
42 Arrow field plot in three dimensions
43 """
44 def __init__(self, scene):
45 """
46 Initialisation of the ArrowPlot3D class
47
48 @param scene: The Scene to render the plot in
49 @type scene: Scene object
50 def setData(self, *dataList, **options):
51 """
52 Set data to the plot
53
54 @param dataList: List of data to set to the plot
55 @type dataList: tuple
56
57 @param options: Dictionary of extra options
58 @type options: dict
59
60 @param fname: Filename of the input vtk file
61 @type fname: string
62
63 @param format: Format of the input vtk file ('vtk' or 'vtk-xml')
64 @type format: string
65
66 @param vectors: the name of the vector data in the vtk file to use
67 @type vectors: string
68 """
69 class ArrowPlot(Plot):
70 """
71 Arrow field plot
72 """
73 def __init__(self, scene):
74 """
75 Initialisation of the ArrowPlot class
76
77 @param scene: The Scene to render the plot in
78 @type scene: Scene object
79 """
80 def setData(self, *dataList, **options):
81 """
82 Set data to the plot
83
84 @param dataList: List of data to set to the plot
85 @type dataList: tuple
86
87 @param options: Dictionary of extra options
88 @type options: dict
89
90 @param fname: the name of the input vtk file
91 @type fname: string
92
93 @param format: the format of the input vtk file ('vtk' or 'vtk-xml')
94 @type format: string
95
96 @param vectors: the name of the vector data in the vtk file to use
97 @type vectors: string
98 """
99 class Axes(Plot):
100 """
101 Axes class
102 """
103 def __init__(self):
104 """
105 Initialisation of Axes object
106 """
107 debugMsg("Called Axes.__init__()")
108 Plot.__init__(self)
109
110 class BallPlot(Plot):
111 """
112 Ball plot
113 """
114 def __init__(self, scene):
115
116 def setData(self, points=None,
117 fname=None, format=None,
118 radii=None, colors=None, tags=None):
119 """
120 Set data to the plot
121 @param points: the array to use for the points of the sphere
122 locations in space
123 @type points: float array
124
125 @param fname: the name of the input vtk file
126 @type fname: string
127
128 @param format: the format of the input vtk file ('vtk' or 'vtk-xml')
129 @type format: string
130
131 @param radii: the name of the scalar array in the vtk unstructured
132 grid to use as the radii of the balls
133 @type radii: float array
134
135 @param colors: the name of the scalar array in the vtk unstructured
136 grid to use as the colour tags of the balls
137 @type colors: string
138
139 @param tags: the name of the scalar array in the vtk unstructured
140 grid to use as the colour of the tags of the balls
141 @type tags: integer array
142 """
143
144 class Box(Item):
145 """
146 Generic class for Box objects
147
148 To define a box one specify one of three groups of things:
149 - The bounds of the box: xmin, xmax, ymin, ymax, zmin, zmax
150 - The dimensions and origin: width, height, depth and origin
151 - The bottom left front and top right back corners: blf, trb
152 """
153
154 def __init__(self):
155 """
156 Initialisation of the Box object
157 """
158 debugMsg("Called Box.__init__()")
159 Item.__init__(self)
160
161 # define a box in many ways, either by its centre and width, height
162 # and depth, or by its bounds, xmin, xmax, ymin, ymax, zmin, zmax,
163 # or by its bottom left front and top right back points.
164
165 # set the default bounds
166 self.xmin = -0.5
167 self.xmax = 0.5
168 self.ymin = -0.5
169 self.ymax = 0.5
170 self.zmin = -0.5
171 self.zmax = 0.5
172
173 # set the default origin (the centre of the box)
174 self.origin = ((self.xmin + self.xmax)/2.0,
175 (self.ymin + self.ymax)/2.0,
176 (self.zmin + self.zmax)/2.0)
177
178 # set the default dimensions
179 self.width = self.xmax - self.xmin
180 self.height = self.ymax - self.ymin
181 self.depth = self.zmax - self.zmin
182
183 # set the default blf and trb points
184 self.blf = (self.xmin, self.ymin, self.zmin)
185 self.trb = (self.xmax, self.ymax, self.zmax)
186
187 # tolerance for calculated variables checking purposes
188 self.tolerance = 1e-8
189
190 def setBounds(self, xmin, xmax, ymin, ymax, zmin, zmax):
191 """
192 Set the bounds of the box
193 """
194 def getBounds(self):
195 """
196 Get the current bounds of the box
197 """
198
199 def setOrigin(self, xo, yo, zo):
200 """
201 Set the origin of the box
202 """
203 def getOrigin(self):
204 """
205 Get the current origin of the box
206 """
207 debugMsg("Called Box.getOrigin()")
208 return self.origin
209
210 def setWidth(self, width):
211 """
212 Set the width of the box
213 """
214 def getWidth(self):
215 """
216 Get the current box width
217 """
218 debugMsg("Called Box.getWidth()")
219 return self.width
220
221 def setHeight(self, height):
222 """
223 Set the box height
224 """
225
226 def getHeight(self):
227 """
228 Get the current box height
229 """
230 debugMsg("Called Box.getHeight()")
231 return self.height
232
233 def setDepth(self, depth):
234 """
235 Set the box depth
236 """
237
238 def getDepth(self):
239 """
240 Get the current box depth
241 """
242 debugMsg("Called Box.getDepth()")
243 return self.depth
244
245 def setBLF(self, bottom, left, front):
246 """
247 Set the position of the bottom, left, front corner
248 """
249
250 def getBLF(self):
251 """
252 Get the current position of the bottom, left, front corner
253 """
254 debugMsg("Called Box.getBLF()")
255 return self.blf
256
257 def setTRB(self, top, right, back):
258 """
259 Set the position of the top, right, back corner
260 """
261
262 def getTRB(self):
263 """
264 Get the current position of the top, right, back corner
265 """
266 debugMsg("Called Box.getTRB()")
267 return self.trb
268
269
270 class ClipBox(Box):
271 """
272 Clip box class: used to clip data sets with a box
273
274 A box in this sense means three planes at right angles to one another
275 """
276
277 def __init__(self, plot):
278 """
279 Intialisation of the ClipBox object
280 """
281
282 def setInsideOut(self, insideOut):
283 """
284 Set the inside out flag
285 """
286
287 def getInsideOut(self):
288 """
289 Get the current value of the inside out flag
290 """
291
292 class Camera(Item):
293 """
294 Camera class
295 """
296 def __init__(self, scene):
297 """
298 Initialisation of the Camera object
299
300 @param scene: The Scene object to add the Camera object to
301 @type scene: Scene object
302 """
303 def setPosition(self, *pos):
304 """
305 Set position of camera within scene
306
307 @param pos: Position to set camera in terms of x,y,z coordinates
308 @type pos: tuple
309 """
310
311 def getPosition(self):
312 """
313 Get the position of Camera within Scene
314
315 Returns the position in a tuple of form (xPos, yPos, zPos)
316 """
317 debugMsg("Called Camera.getPosition()")
318
319 return (self.xPos, self.yPos, self.zPos)
320
321 def setFocalPoint(self, *pos):
322 """
323 Sets the focal point of the Camera with the Scene
324
325 @param pos: Position to set the focal point
326 @type pos: tuple
327 """
328
329 def getFocalPoint(self):
330 """
331 Get the position of the focal point of the Camera
332
333 Returns the position of the focal point in a tuple of form
334 (xPos, yPos, zPos)
335 """
336
337 def setElevation(self, elevation):
338 """
339 Set the elevation angle (in degrees) of the Camera
340
341 @param elevation: The elevation angle (in degrees) of the Camera
342 @type elevation: float
343 """
344
345 return
346
347 def getElevation(self):
348 """
349 Gets the elevation angle (in degrees) of the Camera
350 """
351
352 def setAzimuth(self, azimuth):
353 """
354 Set the azimuthal angle (in degrees) of the Camera
355
356 @param azimuth: The azimuthal angle (in degrees) of the Camera
357 @type azimuth: float
358 """
359
360 def getAzimuth(self):
361 """
362 Get the azimuthal angle (in degrees) of the Camera
363 """
364 class ContourPlot(Plot):
365 """
366 Contour plot
367 """
368 def __init__(self, scene):
369 """
370 Initialisation of the ContourPlot class
371
372 @param scene: The Scene to render the plot in
373 @type scene: Scene object
374 """
375 def setData(self, *dataList, **options):
376 """
377 Set data to the plot
378
379 @param dataList: List of data to set to the plot
380 @type dataList: tuple
381
382 @param options: Dictionary of extra options
383 @type options: dict
384
385 @param fname: the name of the input vtk file
386 @type fname: string
387
388 @param format: the format of the input vtk file ('vtk' or 'vtk-xml')
389 @type format: string
390
391 @param scalars: the scalar data in the vtk file to use
392 @type scalars: string
393 """
394
395 class EllipsoidPlot(Plot):
396 """
397 Ellipsoid plot
398 """
399 def __init__(self, scene):
400 """
401 Initialisation of the EllipsoidPlot class
402
403 @param scene: The Scene to render the plot in
404 @type scene: Scene object
405 """
406 debugMsg("Called EllipsoidPlot.__init__()")
407 Plot.__init__(self, scene)
408
409 self.renderer = scene.renderer
410 self.renderer.addToInitStack("# EllipsoidPlot.__init__()")
411
412 # labels and stuff
413 self.title = None
414 self.xlabel = None
415 self.ylabel = None
416 self.zlabel = None
417
418 # default values for fname, format and tensors
419 self.fname = None
420 self.format = None
421 self.tensors = None
422
423 # default values for shared info
424 self.escriptData = False
425 self.otherData = False
426
427 # add the plot to the scene
428 scene.add(self)
429
430 def setData(self, *dataList, **options):
431 """
432 Set data to the plot
433
434 @param dataList: List of data to set to the plot
435 @type dataList: tuple
436
437 @param options: Dictionary of keyword options to the method
438 @type options: dict
439
440 @param fname: the name of the input vtk file
441 @type fname: string
442
443 @param format: the format of the input vtk file ('vtk' or 'vtk-xml')
444 @type format: string
445
446 @param tensors: the name of the tensor data in the vtk file to use
447 @type tensors: string
448 """
449
450 class Image(Item):
451 """
452 Image class. Generic class to handle image data.
453 """
454 def __init__(self, scene=None):
455 """
456 Initialises the Image class object
457
458 @param scene: The Scene object to add to
459 @type scene: Scene object
460 """
461 debugMsg("Called Image.__init__()")
462 Item.__init__(self)
463
464 if scene is not None:
465 self.renderer = scene.renderer
466
467 def load(self, fname):
468 """
469 Loads image data from file.
470
471 @param fname: The filename from which to load image data
472 @type fname: string
473 """
474 debugMsg("Called Image.load()")
475
476 fileCheck(fname)
477
478 return
479
480 class JpegImage(Image):
481 """
482 Subclass of Image class to explicitly handle jpeg images
483 """
484 def __init__(self, scene=None):
485 """
486 Initialises the JpegImage class object
487
488 @param scene: The Scene object to add to
489 @type scene: Scene object
490 """
491
492 def load(self, fname):
493 """
494 Loads jpeg image data from file.
495
496 @param fname: The filename from which to load jpeg image data
497 @type fname: string
498 """
499
500 class PngImage(Image):
501 """
502 Subclass of Image class to explicitly handle png images
503 """
504 def __init__(self, scene=None):
505 """
506 Initialises the PngImage class object
507
508 @param scene: The Scene object to add to
509 @type scene: Scene object
510 """
511
512 def load(self, fname):
513 """
514 Loads png image data from file.
515
516 @param fname: The filename from which to load png image data
517 @type fname: string
518 """
519 class BmpImage(Image):
520 """
521 Subclass of Image class to explicitly handle bmp images
522 """
523 def __init__(self, scene=None):
524 """
525 Initialises the BmpImage class object
526
527 @param scene: The Scene object to add to
528 @type scene: Scene object
529 """
530 def load(self, fname):
531 """
532 Loads bmp image data from file.
533
534 @param fname: The filename from which to load bmp image data
535 @type fname: string
536 """
537
538 class TiffImage(Image):
539 """
540 Subclass of Image class to explicitly handle tiff images
541 """
542 def __init__(self, scene=None):
543 """
544 Initialises the TiffImage class object
545
546 @param scene: The Scene object to add to
547 @type scene: Scene object
548 """
549 def load(self, fname):
550 """
551 Loads tiff image data from file.
552
553 @param fname: The filename from which to load tiff image data
554 @type fname: string
555 """
556 class PnmImage(Image):
557 """
558 Subclass of Image class to explicitly handle pnm (ppm, pgm, pbm) images
559 """
560 def __init__(self, scene=None):
561 """
562 Initialises the PnmImage class object
563
564 @param scene: The Scene object to add to
565 @type scene: Scene object
566 """
567
568 def load(self, fname):
569 """
570 Loads pnm (ppm, pgm, pbm) image data from file.
571
572 @param fname: The filename from which to load pnm image data
573 @type fname: string
574 """
575
576 class PsImage(Image):
577 """
578 Subclass of Image class to explicitly handle ps images
579 """
580 def __init__(self, scene=None):
581 """
582 Initialises the PsImage class object
583
584 This object is B{only} used for generating postscript output
585
586 @param scene: The Scene object to add to
587 @type scene: Scene object
588 """
589
590 def load(self, fname):
591 """
592 Loads ps image data from file.
593
594 B{NOT} supported by this renderer module
595
596 @param fname: The filename from which to load ps image data
597 @type fname: string
598 """
599 debugMsg("Called PsImage.load()")
600
601 # need to check if the file exists
602 fileCheck(fname)
603
604 # this ability not handled by this renderer module
605 unsupportedError()
606
607 return
608
609 def render(self):
610 """
611 Does PsImage object specific (pre)rendering stuff
612 """
613 debugMsg("Called PsImage.render()")
614
615 return
616
617 class PdfImage(Image):
618 """
619 Subclass of Image class to explicitly handle pdf images
620 """
621 def __init__(self, scene=None):
622 """
623 Initialises the PdfImage class object
624
625 This object is B{only} used for generating pdf output
626
627 @param scene: The Scene object to add to
628 @type scene: Scene object
629 """
630
631 def load(self, fname):
632 """
633 Loads pdf image data from file.
634
635 B{NOT} supported by this renderer module
636
637 @param fname: The filename from which to load pdf image data
638 @type fname: string
639 """
640
641 class IsosurfacePlot(Plot):
642 """
643 Isosurface plot
644 """
645 def __init__(self, scene):
646 """
647 Initialisation of the IsosurfacePlot class
648
649 @param scene: The Scene to render the plot in
650 @type scene: Scene object
651 """
652 def setData(self, *dataList, **options):
653 """
654 Set data to the plot
655
656 @param dataList: List of data to set to the plot
657 @type dataList: tuple
658
659 @param options: Dictionary of keyword options to the method
660 @type options: dict
661
662 @param fname: the name of the input vtk file
663 @type fname: string
664
665 @param format: the format of the input vtk file ('vtk' or 'vtk-xml')
666 @type format: string
667
668 @param scalars: the name of the scalar data in the vtk file to use
669 @type scalars: string
670 """
671
672 class LinePlot(Plot):
673 """
674 Line plot
675 """
676 def __init__(self, scene):
677 """
678 Initialisation of the LinePlot class
679
680 @param scene: The Scene to render the plot in
681 @type scene: Scene object
682 """
683
684 def setData(self, *dataList, **options):
685 """
686 Set data to the plot
687
688 @param dataList: List of data to set to the plot
689 @type dataList: tuple
690
691 @param options: Dictionary of extra options
692 @type options: dict
693
694 @param offset: whether or not to offset the lines from one another
695 @type offset: boolean
696
697 @param fname: Filename of the input vtk file
698 @type fname: string
699
700 @param format: format of the input vtk file ('vtk' or 'vtk-xml')
701 @type format: string
702
703 @param scalars: the name of the scalar data in the vtk file to use
704 @type scalars: string
705 """
706
707 class OffsetPlot(Plot):
708 """
709 Offset plot
710 """
711 def __init__(self, scene):
712 """
713 Initialisation of the OffsetPlot class
714
715 @param scene: The Scene to render the plot in
716 @type scene: Scene object
717 """
718
719 def setData(self, *dataList, **options):
720 """
721 Set data to the plot
722
723 @param dataList: List of data to set to the plot
724 @type dataList: tuple
725
726 @param options: Dictionary of extra options
727 @type options: dict
728
729 @param fname: Filename of the input vtk file
730 @type fname: string
731
732 @param format: Format of the input vtk file ('vtk' or 'vtk-xml')
733 @type format: string
734
735 @param scalars: the name of the scalar data in the vtk file to use
736 @type scalars: string
737 """
738 class Plane(Item):
739 """
740 Generic class for Plane objects
741 """
742
743 def __init__(self, scene):
744 """
745 Initialisation of the Plane object
746 """
747
748 def setOrigin(self, x, y, z):
749 """
750 Set the origin of the plane
751 """
752
753 def getOrigin(self):
754 """
755 Get the current origin of the plane
756 """
757
758 def setNormal(self, vx, vy, vz):
759 """
760 Set the normal vector to the plane
761 """
762
763 def getNormal(self):
764 """
765 Get the current normal vector to the plane
766 """
767
768 def mapImageToPlane(self, image):
769 # this really needs to go somewhere else!!!
770 """
771 Maps an Image object onto a Plane object
772 """
773
774 class CutPlane(Plane):
775 """
776 Cut plane class: used to cut data sets with a plane
777
778 Cut plane objects define a plane to cut a data set or plot by and return
779 the data along the intersection between the data set or plot with the
780 defined plane.
781 """
782
783 def __init__(self):
784 """
785 Intialisation of the CutPlane object
786 """
787
788
789 class ClipPlane(Plane):
790 """
791 Class for planes used to clip datasets
792 """
793
794 def __init__(self):
795 """
796 Intialisation of the ClipPlane object
797 """
798
799 def setInsideOut(self, insideOut):
800 """
801 Set the inside out flag
802 """
803
804 def getInsideOut(self):
805 """
806 Get the current value of the inside out flag
807 """
808
809 class Plot(Item):
810 """
811 Abstract plot class
812 """
813 def __init__(self, scene):
814 """
815 Initialisation of the abstract Plot class
816
817 @param scene: The Scene to render the plot in
818 @type scene: Scene object
819 """
820
821 def setData(self, *dataList, **options):
822 """
823 Set data to the plot
824
825 @param dataList: List of data to set to the plot
826 @type dataList: tuple
827
828 @param options: Dictionary of extra options
829 @type options: dict
830 """
831
832 def setTitle(self, title):
833 """
834 Set the plot title
835
836 @param title: the string holding the title to the plot
837 @type title: string
838 """
839 debugMsg("Called setTitle() in Plot()")
840
841
842 def setXLabel(self, label):
843 """
844 Set the label of the x-axis
845
846 @param label: the string holding the label of the x-axis
847 @type label: string
848 """
849
850 def setYLabel(self, label):
851 """
852 Set the label of the y-axis
853
854 @param label: the string holding the label of the y-axis
855 @type label: string
856 """
857
858 def setZLabel(self, label):
859 """
860 Set the label of the z-axis
861
862 @param label: the string holding the label of the z-axis
863 @type label: string
864 """
865
866 def setLabel(self, axis, label):
867 """
868 Set the label of a given axis
869
870 @param axis: string (Axis object maybe??) of the axis (e.g. x, y, z)
871 @type axis: string or Axis object
872
873 @param label: string of the label to set for the axis
874 @type label: string
875 """
876
877 class Renderer(BaseRenderer):
878 """
879 A generic object holding a renderer of a Scene().
880 """
881
882 def __init__(self):
883 """
884 Initialisation of Renderer() class
885 """
886 debugMsg("Called Renderer.__init__()")
887 BaseRenderer.__init__(self)
888
889 # initialise some attributes
890 self.renderWindowWidth = 640
891 self.renderWindowHeight = 480
892
893 # what is the name of my renderer?
894 self.name = _rendererName
895
896 # the namespace to run the exec code
897 self.renderDict = {}
898
899 # initialise the evalstack
900 self._evalStack = ""
901
902 # keep the initial setup of the module for later reuse
903 self._initStack = ""
904
905 # initialise the renderer module
906 self.runString("# Renderer._initRendererModule")
907 self.addToInitStack("import vtk")
908 self.addToInitStack("from numarray import *")
909
910 __revision__ = '$Revision: 1.33 $'
911
912 class Scene(BaseScene):
913 """
914 The main object controlling the scene.
915
916 Scene object methods and classes overriding the BaseScene class.
917 """
918
919 def __init__(self):
920 """
921 The init function
922 """
923
924 def add(self, obj):
925 """
926 Add a new item to the scene
927
928 @param obj: The object to add to the scene
929 @type obj: object
930 """
931
932 def place(self, obj):
933 """
934 Place an object within a scene
935
936 @param obj: The object to place within the scene
937 @type obj: object
938 """
939
940 def render(self, pause=False, interactive=False):
941 """
942 Render (or re-render) the scene
943
944 Render the scene, either to screen, or to a buffer waiting for a save
945
946 @param pause: Flag to wait at end of script evaluation for user input
947 @type pause: boolean
948
949 @param interactive: Whether or not to have interactive use of the output
950 @type interactive: boolean
951 """
952
953 def save(self, fname, format):
954 """
955 Save the scene to a file
956
957 Possible formats are:
958 - Postscript
959 - PNG
960 - JPEG
961 - TIFF
962 - BMP
963 - PNM
964
965 @param fname: Name of output file
966 @type fname: string
967
968 @param format: Graphics format of output file
969 @type format: Image object or string
970 """
971
972 def setBackgroundColor(self, *color):
973 """
974 Sets the background color of the Scene
975
976 @param color: The color to set the background to. Can be RGB or CMYK
977 @type color: tuple
978 """
979
980 def getBackgroundColor(self):
981 """
982 Gets the current background color setting of the Scene
983 """
984
985 def setSize(self, xSize, ySize):
986 """
987 Sets the size of the scene.
988
989 This size is effectively the renderer window size.
990
991 @param xSize: the size to set the x dimension
992 @type xSize: float
993
994 @param ySize: the size to set the y dimension
995 @type ySize: float
996 """
997
998 def getSize(self):
999 """
1000 Gets the current size of the scene
1001
1002 This size is effectively the renderer window size. Returns a tuple
1003 of the x and y dimensions respectively, in pixel units(??).
1004 """
1005 class SurfacePlot(Plot):
1006 """
1007 Surface plot
1008 """
1009 def __init__(self, scene):
1010 """
1011 Initialisation of the SurfacePlot class
1012
1013 @param scene: The Scene to render the plot in
1014 @type scene: Scene object
1015 """
1016
1017 def setData(self, *dataList, **options):
1018 """
1019 Set data to the plot
1020
1021 @param dataList: List of data to set to the plot
1022 @type dataList: tuple
1023
1024 @param options: Dictionary of extra options
1025 @type options: dict
1026
1027 @param fname: the name of the input vtk file
1028 @type fname: string
1029
1030 @param format: the format of the input vtk file ('vtk' or 'vtk-xml')
1031 @type format: string
1032
1033 @param scalars: the scalar data in the vtk file to use
1034 @type scalars: string
1035 """
1036
1037 class Text(Item):
1038 """
1039 Text
1040 """
1041 def __init__(self, scene):
1042 """
1043 Initialisation of the Text object
1044
1045 @param scene: the scene with which to associate the Text object
1046 @type scene: Scene object
1047 """
1048
1049 def setFont(self, font):
1050 """
1051 Set the current font
1052
1053 @param font: the font to set
1054 @type font: string
1055 """
1056
1057 def getFont(self):
1058 """
1059 \end{verbose}

  ViewVC Help
Powered by ViewVC 1.1.26