Context Navigation

source: trunk/gui/scripts/field.tcl @ 1463

Last change on this file since 1463 was 1463, checked in by gah, 15 years ago

File size: 25.6 KB

Line
1	# ----------------------------------------------------------------------
2	# COMPONENT: field - extracts data from an XML description of a field
3	#
4	# This object represents one field in an XML description of a device.
5	# It simplifies the process of extracting data vectors that represent
6	# the field.
7	# ======================================================================
8	# AUTHOR: Michael McLennan, Purdue University
9	# Copyright (c) 2004-2005 Purdue Research Foundation
10	#
11	# See the file "license.terms" for information on usage and
12	# redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13	# ======================================================================
14	package require Itcl
15	package require BLT
16
17	namespace eval Rappture { # forward declaration }
18
19	itcl::class Rappture::Field {
20	constructor {xmlobj path} { # defined below }
21	destructor { # defined below }
22
23	public method components {args}
24	public method mesh {{what -overall}}
25	public method values {{what -overall}}
26	public method blob {{what -overall}}
27	public method limits {axis}
28	public method controls {option args}
29	public method hints {{key ""}}
30	public method isunirect2d {}
31	public method isunirect3d {}
32	public method extents {{what -overall}}
33	public method flowhints { cname }
34	protected method _build {}
35	protected method _getValue {expr}
36
37	private variable _xmlobj "" ;# ref to XML obj with device data
38
39	private variable _units "" ;# system of units for this field
40	private variable _limits ;# maps box name => {z0 z1} limits
41	private variable _zmax 0 ;# length of the device
42
43	private variable _field "" ;# lib obj representing this field
44	private variable _comp2dims ;# maps component name => dimensionality
45	private variable _comp2xy ;# maps component name => x,y vectors
46	private variable _comp2vtk ;# maps component name => vtkFloatArray
47	private variable _comp2dx ;# maps component name => OpenDX data
48	private variable _comp2unirect2d ;# maps component name => unirect2d obj
49	private variable _comp2unirect3d ;# maps component name => unirect3d obj
50	private variable _comp2style ;# maps component name => style settings
51	private variable _comp2cntls ;# maps component name => x,y control points
52	private variable _comp2extents
53	private variable _comp2flowhints
54	private common _counter 0 ;# counter for unique vector names
55	}
56
57	# ----------------------------------------------------------------------
58	# CONSTRUCTOR
59	# ----------------------------------------------------------------------
60	itcl::body Rappture::Field::constructor {xmlobj path} {
61	if {![Rappture::library isvalid $xmlobj]} {
62	error "bad value \"$xmlobj\": should be Rappture::library"
63	}
64	set _xmlobj $xmlobj
65	set _field [$xmlobj element -as object $path]
66	set _units [$_field get units]
67
68	set xunits [$xmlobj get units]
69	if {"" == $xunits \|\| "arbitrary" == $xunits} {
70	set xunits "um"
71	}
72
73	# determine the overall size of the device
74	set z0 [set z1 0]
75	foreach elem [$_xmlobj children components] {
76	switch -glob -- $elem {
77	box* {
78	if {![regexp {[0-9]$} $elem]} {
79	set elem "${elem}0"
80	}
81	set z0 [$_xmlobj get components.$elem.corner0]
82	set z0 [Rappture::Units::convert $z0 \
83	-context $xunits -to $xunits -units off]
84
85	set z1 [$_xmlobj get components.$elem.corner1]
86	set z1 [Rappture::Units::convert $z1 \
87	-context $xunits -to $xunits -units off]
88
89	set _limits($elem) [list $z0 $z1]
90	}
91	}
92	}
93	set _zmax $z1
94
95	# build up vectors for various components of the field
96	_build
97	}
98
99	# ----------------------------------------------------------------------
100	# DESTRUCTOR
101	# ----------------------------------------------------------------------
102	itcl::body Rappture::Field::destructor {} {
103	itcl::delete object $_field
104	# don't destroy the _xmlobj! we don't own it!
105
106	foreach name [array names _comp2xy] {
107	eval blt::vector destroy $_comp2xy($name)
108	}
109	foreach name [array names _comp2vtk] {
110	set mobj [lindex $_comp2vtk($name) 0]
111	set class [$mobj info class]
112	${class}::release $mobj
113
114	set fobj [lindex $_comp2vtk($name) 1]
115	rename $fobj ""
116	}
117	foreach name [array names _comp2unirect2d] {
118	itcl::delete object $_comp2unirect2d($name)
119	}
120	foreach name [array names _comp2unirect3d] {
121	itcl::delete object $_comp2unirect3d($name)
122	}
123	foreach name [array names _comp2flowhints] {
124	itcl::delete object $_comp2flowhints($name)
125	}
126	}
127
128	# ----------------------------------------------------------------------
129	# USAGE: components ?-name\|-dimensions\|-style? ?<pattern>?
130	#
131	# Returns a list of names or types for the various components of
132	# this field. If the optional glob-style <pattern> is specified,
133	# then it returns only the components with names matching the pattern.
134	# ----------------------------------------------------------------------
135	itcl::body Rappture::Field::components {args} {
136	Rappture::getopts args params {
137	flag what -name default
138	flag what -dimensions
139	flag what -style
140	flag what -particles
141	flag what -flow
142	flag what -box
143	}
144
145	set pattern *
146	if {[llength $args] > 0} {
147	set pattern [lindex $args 0]
148	set args [lrange $args 1 end]
149	}
150	if {[llength $args] > 0} {
151	error "wrong # args: should be \"components ?switches? ?pattern?\""
152	}
153
154	set rlist ""
155
156	# BE CAREFUL: return component names in proper order
157	foreach cname [$_field children -type component] {
158	if {[info exists _comp2dims($cname)]
159	&& [string match $pattern $cname]} {
160
161	switch -- $params(what) {
162	-name { lappend rlist $cname }
163	-dimensions { lappend rlist $_comp2dims($cname) }
164	-style { lappend rlist $_comp2style($cname) }
165	}
166	}
167	}
168	return $rlist
169	}
170
171	# ----------------------------------------------------------------------
172	# USAGE: mesh ?<name>?
173	#
174	# Returns a list {xvec yvec} for the specified field component <name>.
175	# If the name is not specified, then it returns the vectors for the
176	# overall field (sum of all components).
177	# ----------------------------------------------------------------------
178	itcl::body Rappture::Field::mesh {{what -overall}} {
179	if {$what == "-overall" \|\| $what == "component0"} {
180	set what [lindex [components -name] 0]
181	}
182	if {[info exists _comp2xy($what)]} {
183	return [lindex $_comp2xy($what) 0] ;# return xv
184	}
185	if { [info exists _comp2vtk($what)] } {
186	set mobj [lindex $_comp2vtk($what) 0]
187	return [$mobj mesh]
188	}
189	if {[info exists _comp2dx($what)]} {
190	return "" ;# no mesh -- it's embedded in the value data
191	}
192	if {[info exists _comp2unirect2d($what)]} {
193	set mobj [lindex $_comp2unirect2d($what) 0]
194	return [$mobj mesh]
195	}
196	if {[info exists _comp2unirect3d($what)]} {
197	set mobj [lindex $_comp2unirect3d($what) 0]
198	return [$mobj mesh]
199	}
200	error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
201	}
202
203	# ----------------------------------------------------------------------
204	# USAGE: values ?<name>?
205	#
206	# Returns a list {xvec yvec} for the specified field component <name>.
207	# If the name is not specified, then it returns the vectors for the
208	# overall field (sum of all components).
209	# ----------------------------------------------------------------------
210	itcl::body Rappture::Field::values {{what -overall}} {
211	if {$what == "component0"} {
212	set what "component"
213	}
214	if {[info exists _comp2xy($what)]} {
215	return [lindex $_comp2xy($what) 1] ;# return yv
216	}
217	if { [info exists _comp2vtk($what)] } {
218	return [lindex $_comp2vtk($what) 1] ;# return vtkFloatArray
219	}
220	if {[info exists _comp2dx($what)]} {
221	return $_comp2dx($what) ;# return gzipped, base64-encoded DX data
222	}
223	if {[info exists _comp2unirect2d($what)]} {
224	return [$_comp2unirect2d($what) values]
225	}
226	if {[info exists _comp2unirect3d($what)]} {
227	return [$_comp2unirect3d($what) blob]
228	}
229	error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
230	}
231
232	# ----------------------------------------------------------------------
233	# USAGE: blob ?<name>?
234	#
235	# Returns a string representing the blob of data for the mesh and values.
236	# ----------------------------------------------------------------------
237	itcl::body Rappture::Field::blob {{what -overall}} {
238	if {$what == "component0"} {
239	set what "component"
240	}
241	if {[info exists _comp2xy($what)]} {
242	return ""
243	}
244	if { [info exists _comp2vtk($what)] } {
245	return ""
246	}
247	if {[info exists _comp2dx($what)]} {
248	return $_comp2dx($what) ;# return gzipped, base64-encoded DX data
249	}
250	if {[info exists _comp2unirect2d($what)]} {
251	set mobj $_comp2unirect2d($what)
252	return [$mobj blob]
253	}
254	if {[info exists _comp2unirect3d($what)]} {
255	set mobj $_comp2unirect3d($what)
256	return [$mobj blob]
257	}
258	error "bad option \"$what\": should be [join [lsort [array names _comp2dims]] {, }]"
259	}
260
261	# ----------------------------------------------------------------------
262	# USAGE: limits <axis>
263	#
264	# Returns a list {min max} representing the limits for the specified
265	# axis.
266	# ----------------------------------------------------------------------
267	itcl::body Rappture::Field::limits {which} {
268	set min ""
269	set max ""
270
271	blt::vector create tmp zero
272	foreach comp [array names _comp2dims] {
273	switch -- $_comp2dims($comp) {
274	1D {
275	switch -- $which {
276	x - xlin { set pos 0; set log 0; set axis xaxis }
277	xlog { set pos 0; set log 1; set axis xaxis }
278	y - ylin - v - vlin { set pos 1; set log 0; set axis yaxis }
279	ylog - vlog { set pos 1; set log 1; set axis yaxis }
280	default {
281	error "bad option \"$which\": should be x, xlin, xlog, y, ylin, ylog, v, vlin, vlog"
282	}
283	}
284
285	set vname [lindex $_comp2xy($comp) $pos]
286	$vname variable vec
287
288	if {$log} {
289	# on a log scale, use abs value and ignore 0's
290	$vname dup tmp
291	$vname dup zero
292	zero expr {tmp == 0} ;# find the 0's
293	tmp expr {abs(tmp)} ;# get the abs value
294	tmp expr {tmp + zero*max(tmp)} ;# replace 0's with abs max
295	set vmin [blt::vector expr min(tmp)]
296	set vmax [blt::vector expr max(tmp)]
297	} else {
298	set vmin $vec(min)
299	set vmax $vec(max)
300	}
301
302	if {"" == $min} {
303	set min $vmin
304	} elseif {$vmin < $min} {
305	set min $vmin
306	}
307	if {"" == $max} {
308	set max $vmax
309	} elseif {$vmax > $max} {
310	set max $vmax
311	}
312	}
313	2D - 3D {
314	if {[info exists _comp2unirect2d($comp)]} {
315	set limits [$_comp2unirect2d($comp) limits $which]
316	foreach {vmin vmax} $limits break
317	set axis vaxis
318	} elseif {[info exists _comp2unirect3d($comp)]} {
319	set limits [$_comp2unirect3d($comp) limits $which]
320	foreach {vmin vmax} $limits break
321	set axis vaxis
322	} elseif {[info exists _comp2vtk($comp)]} {
323	foreach {xv yv} $_comp2vtk($comp) break
324	switch -- $which {
325	x - xlin - xlog {
326	foreach {vmin vmax} [$xv limits x] break
327	set axis xaxis
328	}
329	y - ylin - ylog {
330	foreach {vmin vmax} [$xv limits y] break
331	set axis yaxis
332	}
333	z - zlin - zlog {
334	foreach {vmin vmax} [$xv limits z] break
335	set axis zaxis
336	}
337	v - vlin - vlog {
338	catch {unset style}
339	array set style $_comp2style($comp)
340	if {[info exists style(-min)] && [info exists style(-max)]} {
341	# This component has its own hard-coded
342	# min/max range. Ignore it for overall limits.
343	set vmin $min
344	set vmax $max
345	} else {
346	foreach {vmin vmax} [$yv GetRange] break
347	}
348	set axis vaxis
349	}
350	default {
351	error "bad option \"$which\": should be x, xlin, xlog, y, ylin, ylog, v, vlin, vlog"
352	}
353	}
354	} else {
355	set vmin 0 ;# HACK ALERT! must be OpenDX data
356	set vmax 1
357	set axis vaxis
358	}
359	}
360	}
361	if {"" == $min} {
362	set min $vmin
363	} elseif {$vmin < $min} {
364	set min $vmin
365	}
366	if {"" == $max} {
367	set max $vmax
368	} elseif {$vmax > $max} {
369	set max $vmax
370	}
371	}
372	blt::vector destroy tmp zero
373
374	set val [$_field get $axis.min]
375	if {"" != $val && "" != $min} {
376	if {$val > $min} {
377	# tool specified this min -- don't go any lower
378	set min $val
379	}
380	}
381
382	set val [$_field get $axis.max]
383	if {"" != $val && "" != $max} {
384	if {$val < $max} {
385	# tool specified this max -- don't go any higher
386	set max $val
387	}
388	}
389	return [list $min $max]
390	}
391
392	# ----------------------------------------------------------------------
393	# USAGE: controls get ?<name>?
394	# USAGE: controls validate <path> <value>
395	# USAGE: controls put <path> <value>
396	#
397	# Returns a list {path1 x1 y1 val1 path2 x2 y2 val2 ...} representing
398	# control points for the specified field component <name>.
399	# ----------------------------------------------------------------------
400	itcl::body Rappture::Field::controls {option args} {
401	switch -- $option {
402	get {
403	set what [lindex $args 0]
404	if {[info exists _comp2cntls($what)]} {
405	return $_comp2cntls($what)
406	}
407	return ""
408	}
409	validate {
410	set path [lindex $args 0]
411	set value [lindex $args 1]
412	set units [$_xmlobj get $path.units]
413
414	if {"" != $units} {
415	set nv [Rappture::Units::convert \
416	$value -context $units -to $units -units off]
417	} else {
418	set nv $value
419	}
420	if {![string is double $nv]
421	\|\| [regexp -nocase {^(inf\|nan)$} $nv]} {
422	error "Value out of range"
423	}
424
425	set rawmin [$_xmlobj get $path.min]
426	if {"" != $rawmin} {
427	set minv $rawmin
428	if {"" != $units} {
429	set minv [Rappture::Units::convert \
430	$minv -context $units -to $units -units off]
431	set nv [Rappture::Units::convert \
432	$value -context $units -to $units -units off]
433	}
434	# fix for the case when the user tries to
435	# compare values like minv=-500 nv=-0600
436	set nv [format "%g" $nv]
437	set minv [format "%g" $minv]
438
439	if {$nv < $minv} {
440	error "Minimum value allowed here is $rawmin"
441	}
442	}
443
444	set rawmax [$_xmlobj get $path.max]
445	if {"" != $rawmax} {
446	set maxv $rawmax
447	if {"" != $units} {
448	set maxv [Rappture::Units::convert \
449	$maxv -context $units -to $units -units off]
450	set nv [Rappture::Units::convert \
451	$value -context $units -to $units -units off]
452	}
453	# fix for the case when the user tries to
454	# compare values like maxv=-500 nv=-0600
455	set nv [format "%g" $nv]
456	set maxv [format "%g" $maxv]
457
458	if {$nv > $maxv} {
459	error "Maximum value allowed here is $rawmax"
460	}
461	}
462
463	return "ok"
464	}
465	put {
466	set path [lindex $args 0]
467	set value [lindex $args 1]
468	$_xmlobj put $path.current $value
469	_build
470	}
471	default {
472	error "bad option \"$option\": should be get or put"
473	}
474	}
475	}
476
477	# ----------------------------------------------------------------------
478	# USAGE: hints ?<keyword>?
479	#
480	# Returns a list of key/value pairs for various hints about plotting
481	# this field. If a particular <keyword> is specified, then it returns
482	# the hint for that <keyword>, if it exists.
483	# ----------------------------------------------------------------------
484	itcl::body Rappture::Field::hints {{keyword ""}} {
485	foreach {key path} {
486	group about.group
487	label about.label
488	color about.color
489	style about.style
490	scale about.scale
491	units units
492	updir updir
493	camera camera.position
494	} {
495	set str [$_field get $path]
496	if {"" != $str} {
497	set hints($key) $str
498	}
499	}
500
501	# to be compatible with curve objects
502	set hints(xlabel) "Position"
503
504	if {[info exists hints(group)] && [info exists hints(label)]} {
505	# pop-up help for each curve
506	set hints(tooltip) $hints(label)
507	}
508
509	if {$keyword != ""} {
510	if {[info exists hints($keyword)]} {
511	return $hints($keyword)
512	}
513	return ""
514	}
515	return [array get hints]
516	}
517
518	# ----------------------------------------------------------------------
519	# USAGE: _build
520	#
521	# Used internally to build up the vector representation for the
522	# field when the object is first constructed, or whenever the field
523	# data changes. Discards any existing vectors and builds everything
524	# from scratch.
525	# ----------------------------------------------------------------------
526	itcl::body Rappture::Field::_build {} {
527	# discard any existing data
528	foreach name [array names _comp2xy] {
529	eval blt::vector destroy $_comp2xy($name)
530	}
531	foreach name [array names _comp2vtk] {
532	set mobj [lindex $_comp2vtk($name) 0]
533	set class [$mobj info class]
534	${class}::release $mobj
535
536	set fobj [lindex $_comp2vtk($name) 1]
537	rename $fobj ""
538	}
539	foreach name [array names _comp2unirect2d] {
540	eval itcl::delete object $_comp2unirect2d($name)
541	}
542	foreach name [array names _comp2unirect3d] {
543	eval itcl::delete object $_comp2unirect3d($name)
544	}
545	catch {unset _comp2xy}
546	catch {unset _comp2vtk}
547	catch {unset _comp2dx}
548	catch {unset _comp2dims}
549	catch {unset _comp2style}
550	array unset _comp2unirect2d
551	array unset _comp2unirect3d
552	array unset _comp2extents
553	#
554	# Scan through the components of the field and create
555	# vectors for each part.
556	#
557	foreach cname [$_field children -type component] {
558	set type ""
559	if { ([$_field element $cname.constant] != "" &&
560	[$_field element $cname.domain] != "") \|\|
561	[$_field element $cname.xy] != ""} {
562	set type "1D"
563	} elseif {[$_field element $cname.mesh] != "" &&
564	[$_field element $cname.values] != ""} {
565	set type "points-on-mesh"
566	} elseif {[$_field element $cname.vtk] != ""} {
567	set type "vtk"
568	} elseif {[$_field element $cname.opendx] != ""} {
569	set type "opendx"
570	} elseif {[$_field element $cname.dx] != ""} {
571	set type "dx"
572	}
573	set _comp2style($cname) ""
574
575	# Save the extents of the component
576	if { [$_field element $cname.extents] != "" } {
577	set extents [$_field get $cname.extents]
578	} else {
579	set extents 1
580	}
581	set _comp2extents($cname) $extents
582
583	if {$type == "1D"} {
584	#
585	# 1D data can be represented as 2 BLT vectors,
586	# one for x and the other for y.
587	#
588	set xv ""
589	set yv ""
590
591	set val [$_field get $cname.constant]
592	if {$val != ""} {
593	set domain [$_field get $cname.domain]
594	if {$domain == "" \|\| ![info exists _limits($domain)]} {
595	set z0 0
596	set z1 $_zmax
597	} else {
598	foreach {z0 z1} $_limits($domain) { break }
599	}
600	set xv [blt::vector create x$_counter]
601	$xv append $z0 $z1
602
603	foreach {val pcomp} [_getValue $val] break
604	set yv [blt::vector create y$_counter]
605	$yv append $val $val
606
607	if {$pcomp != ""} {
608	set zm [expr {0.5*($z0+$z1)}]
609	set _comp2cntls($cname) \
610	[list $pcomp $zm $val "$val$_units"]
611	}
612	} else {
613	set xydata [$_field get $cname.xy]
614	if {"" != $xydata} {
615	set xv [blt::vector create x$_counter]
616	set yv [blt::vector create y$_counter]
617	set tmp [blt::vector create \#auto]
618	$tmp set $xydata
619	$tmp split $xv $yv
620	blt::vector destroy $tmp
621	}
622	}
623
624	if {$xv != "" && $yv != ""} {
625	# sort x-coords in increasing order
626	$xv sort $yv
627
628	set _comp2dims($cname) "1D"
629	set _comp2xy($cname) [list $xv $yv]
630	incr _counter
631	}
632	} elseif {$type == "points-on-mesh"} {
633	#
634	# More complex 2D/3D data is represented by a mesh
635	# object and an associated vtkFloatArray for field
636	# values.
637	#
638	set path [$_field get $cname.mesh]
639	if {[$_xmlobj element $path] != ""} {
640	set element [$_xmlobj element -as type $path]
641	puts stderr "element is $element"
642	if { $element == "unirect2d" } {
643	set _comp2dims($cname) "2D"
644	set _comp2unirect2d($cname) \
645	[Rappture::Unirect2d \#auto $_xmlobj $_field $cname]
646	set _comp2style($cname) [$_field get $cname.style]
647	if {[$_field element $cname.flow] != ""} {
648	set _comp2flowhints($cname) \
649	[Rappture::FlowHints ::\#auto $_field $cname $_units]
650	}
651	incr _counter
652	} elseif { $element == "unirect3d" } {
653	set _comp2dims($cname) "3D"
654	set _comp2unirect3d($cname) \
655	[Rappture::Unirect3d \#auto $_xmlobj $_field $cname]
656	set _comp2style($cname) [$_field get $cname.style]
657	if {[$_field element $cname.flow] != ""} {
658	set _comp2flowhints($cname) \
659	[Rappture::FlowHints ::\#auto $_field $cname $_units]
660	}
661	incr _counter
662	} elseif { $element == "cloud" \|\| $element == "mesh" } {
663	switch -- $element {
664	cloud {
665	set mobj [Rappture::Cloud::fetch $_xmlobj $path]
666	}
667	mesh {
668	set mobj [Rappture::Mesh::fetch $_xmlobj $path]
669	}
670	}
671	if {[$mobj dimensions] > 1} {
672	#
673	# 2D/3D data
674	# Store cloud/field as components
675	#
676	set values [$_field get $cname.values]
677	set farray [vtkFloatArray ::vals$_counter]
678
679	foreach v $values {
680	if {"" != $_units} {
681	set v [Rappture::Units::convert $v \
682	-context $_units -to $_units -units off]
683	}
684	$farray InsertNextValue $v
685	}
686
687	set _comp2dims($cname) "[$mobj dimensions]D"
688	set _comp2vtk($cname) [list $mobj $farray]
689	set _comp2style($cname) [$_field get $cname.style]
690	incr _counter
691	} else {
692	#
693	# OOPS! This is 1D data
694	# Forget the cloud/field -- store BLT vectors
695	#
696	set xv [blt::vector create x$_counter]
697	set yv [blt::vector create y$_counter]
698
699	set vtkpts [$mobj points]
700	set max [$vtkpts GetNumberOfPoints]
701	for {set i 0} {$i < $max} {incr i} {
702	set xval [lindex [$vtkpts GetPoint $i] 0]
703	$xv append $xval
704	}
705	set class [$mobj info class]
706	${class}::release $mobj
707
708	set values [$_field get $cname.values]
709	foreach yval $values {
710	if {"" != $_units} {
711	set yval [Rappture::Units::convert $yval \
712	-context $_units -to $_units -units off]
713	}
714	$yv append $yval
715	}
716
717	# sort x-coords in increasing order
718	$xv sort $yv
719
720	set _comp2dims($cname) "1D"
721	set _comp2xy($cname) [list $xv $yv]
722	incr _counter
723	}
724	}
725	} else {
726	puts "WARNING: can't find mesh $path for field component"
727	}
728	} elseif {$type == "vtk"} {
729	#
730	# Extract native vtk data from the XML and use a reader
731	# to load it.
732	#
733	vtkRectilinearGridReader $this-gr
734	$this-gr SetInputString [$_field get $cname.vtk]
735
736
737	set _comp2dims($cname) "[$mobj dimensions]D"
738	set _comp2vtk($cname) [list $mobj $farray]
739	set _comp2style($cname) [$_field get $cname.style]
740	incr _counter
741	} elseif {$type == "dx"} {
742	#
743	# HACK ALERT! Extract gzipped, base64-encoded OpenDX
744	# data. Assume that it's 3D. Pass it straight
745	# off to the NanoVis visualizer.
746	#
747	set _comp2dims($cname) "3D"
748	set _comp2dx($cname) [$_field get -decode no $cname.dx]
749	set _comp2style($cname) [$_field get $cname.style]
750	if {[$_field element $cname.flow] != ""} {
751	set _comp2flowhints($cname) \
752	[Rappture::FlowHints ::\#auto $_field $cname $_units]
753	}
754	incr _counter
755	} elseif {$type == "opendx"} {
756	#
757	# HACK ALERT! Extract gzipped, base64-encoded OpenDX
758	# data. Assume that it's 3D. Pass it straight
759	# off to the NanoVis visualizer.
760	#
761	set _comp2dims($cname) "3D"
762	set data [$_field get -decode yes $cname.opendx]
763	set data [Rappture::encoding::decode -as zb64 $data]
764
765	set data "<ODX>$data"
766	set data [Rappture::encoding::encode -as zb64 $data]
767	set _comp2dx($cname) $data
768	set _comp2style($cname) [$_field get $cname.style]
769	if {[$_field element $cname.flow] != ""} {
770	set _comp2flowhints($cname) \
771	[Rapture::FlowHints ::\#auto $_field $cname $_units]
772	}
773	incr _counter
774	}
775	}
776	}
777
778	# ----------------------------------------------------------------------
779	# USAGE: _getValue <expr>
780	#
781	# Used internally to get the value for an expression <expr>. Returns
782	# a list of the form {val parameterPath}, where val is the numeric
783	# value of the expression, and parameterPath is the XML path to the
784	# parameter representing the value, or "" if the <expr> does not
785	# depend on any parameters.
786	# ----------------------------------------------------------------------
787	itcl::body Rappture::Field::_getValue {expr} {
788	#
789	# First, look for the expression among the <parameter>'s
790	# associated with the device.
791	#
792	set found 0
793	foreach pcomp [$_xmlobj children parameters] {
794	set id [$_xmlobj element -as id parameters.$pcomp]
795	if {[string equal $id $expr]} {
796	set val [$_xmlobj get parameters.$pcomp.current]
797	if {"" == $val} {
798	set val [$_xmlobj get parameters.$pcomp.default]
799	}
800	if {"" != $val} {
801	set expr $val
802	set found 1
803	break
804	}
805	}
806	}
807	if {$found} {
808	set pcomp "parameters.$pcomp"
809	} else {
810	set pcomp ""
811	}
812
813	if {$_units != ""} {
814	set expr [Rappture::Units::convert $expr \
815	-context $_units -to $_units -units off]
816	}
817
818	return [list $expr $pcomp]
819	}
820
821	#
822	# isunirect2d --
823	#
824	# Returns if the field is a unirect2d object.
825	#
826	itcl::body Rappture::Field::isunirect2d { } {
827	return [expr [array size _comp2unirect2d] > 0]
828	}
829
830	#
831	# isunirect3d --
832	#
833	# Returns if the field is a unirect3d object.
834	#
835	itcl::body Rappture::Field::isunirect3d { } {
836	return [expr [array size _comp2unirect3d] > 0]
837	}
838
839	#
840	# flowhints --
841	#
842	# Returns the hints associated with a flow vector field.
843	#
844	itcl::body Rappture::Field::flowhints { cname } {
845	if { [info exists _comp2flowhints($cname)] } {
846	return $_comp2flowhints($cname)
847	}
848	return ""
849	}
850
851	#
852	# extents --
853	#
854	# Returns if the field is a unirect2d object.
855	#
856	itcl::body Rappture::Field::extents {{what -overall}} {
857	if {$what == "-overall" } {
858	set max 0
859	foreach cname [$_field children -type component] {
860	if { [info exists _comp2unirect3d($cname)] } {
861	set value [$_comp2unirect3d($cname) components]
862	} elseif { [info exists _comp2unirect2d($cname)] } {
863	set value [$_comp2unirect2d($cname) components]
864	} elseif { [info exists _comp2extents($cname)] } {
865	set value $_comp2extents($cname)
866	} else {
867	continue
868	}
869	if { $max < $value } {
870	set max $value
871	}
872	}
873	return $max
874	}
875	if { $what == "component0"} {
876	set what [lindex [components -name] 0]
877	if { [info exists _comp2unirect3d($what)] } {
878	return [$_comp2unirect3d($what) components]
879	} elseif { [info exists _comp2unirect2d($what)] } {
880	return [$_comp2unirect2d($what) components]
881	} elseif { [info exists _comp2extents($what)] } {
882	return $_comp2extents($what)
883	}
884	}
885	return $_comp2extents($what)
886	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: