invariant_state.py @ 74f419d

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 74f419d was b9a5f0e, checked in by krzywon, 10 years ago
90% complete with the conversion.
Property mode set to `100644`
File size: 32.1 KB

Rev	Line
[51f14603]	1	"""
	2	"""
	3
	4	#import time
	5	import os
	6	import sys
	7	import logging
	8	import copy
[79492222]	9	import sas.dataloader
[51f14603]	10	#from xml.dom.minidom import parse
	11	from lxml import etree
[79492222]	12	from sas.dataloader.readers.cansas_reader import Reader as CansasReader
	13	from sas.dataloader.readers.cansas_reader import get_content
	14	from sas.guiframe.utils import format_number
	15	from sas.guiframe.gui_style import GUIFRAME_ID
	16	from sas.guiframe.dataFitting import Data1D
[51f14603]	17
	18	INVNODE_NAME = 'invariant'
	19	CANSAS_NS = "cansas1d/1.0"
	20
	21	# default state
	22	list = {'file': 'None',
	23	'compute_num':0,
	24	'state_num':0,
	25	'is_time_machine':False,
	26	'background_tcl':0.0,
	27	'scale_tcl':1.0,
	28	'contrast_tcl':1.0,
	29	'porod_constant_tcl':'',
	30	'npts_low_tcl':10,
	31	'npts_high_tcl':10,
	32	'power_high_tcl':4.0,
	33	'power_low_tcl': 4.0,
	34	'enable_high_cbox':False,
	35	'enable_low_cbox':False,
	36	'guinier': True,
	37	'power_law_high': False,
	38	'power_law_low': False,
	39	'fit_enable_high': False,
	40	'fit_enable_low': False,
	41	'fix_enable_high':True,
	42	'fix_enable_low':True,
	43	'volume_tcl':'',
	44	'volume_err_tcl':'',
	45	'surface_tcl':'',
	46	'surface_err_tcl':''}
	47	# list of states: This list will be filled as panel
	48	# init and the number of states increases
	49	state_list = {}
	50	bookmark_list = {}
	51	# list of input parameters (will be filled up on panel init) used by __str__
	52	input_list = {'background_tcl':0,
	53	'scale_tcl':0,
	54	'contrast_tcl':0,
	55	'porod_constant_tcl':'',
	56	'npts_low_tcl':0,
	57	'npts_high_tcl':0,
	58	'power_high_tcl':0,
	59	'power_low_tcl': 0}
	60	# list of output parameters (order sensitive) used by __str__
	61	output_list = [["qstar_low", "Q* from low Q extrapolation [1/(cm*A)]"],
	62	["qstar_low_err", "dQ* from low Q extrapolation"],
	63	["qstar_low_percent", "Q* percent from low Q extrapolation"],
	64	["qstar", "Q* from data [1/(cm*A)]"],
	65	["qstar_err", "dQ* from data"],
	66	["qstar_percent", "Q* percent from data"],
	67	["qstar_high", "Q* from high Q extrapolation [1/(cm*A)]"],
	68	["qstar_high_err", "dQ* from high Q extrapolation"],
	69	["qstar_high_percent", "Q* percent from low Q extrapolation"],
	70	["qstar_total", "total Q* [1/(cm*A)]"],
	71	["qstar_total_err", "total dQ*"],
	72	["volume", "volume fraction"],
	73	["volume_err", "volume fraction error"],
	74	["surface", "specific surface"],
	75	["surface_err", "specific surface error"]]
	76
	77
	78
	79	class InvariantState(object):
	80	"""
	81	Class to hold the state information of the InversionControl panel.
	82	"""
	83	def __init__(self):
	84	"""
	85	Default values
	86	"""
	87	# Input
	88	self.file = None
	89	self.data = Data1D(x=[], y=[], dx=None, dy=None)
	90	self.theory_lowQ = Data1D(x=[], y=[], dy=None)
	91	self.theory_lowQ.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
	92	self.theory_highQ = Data1D(x=[], y=[], dy=None)
	93	self.theory_highQ.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
	94	#self.is_time_machine = False
	95	self.saved_state = list
	96	self.state_list = state_list
	97	self.bookmark_list = bookmark_list
	98	self.input_list = input_list
	99	self.output_list = output_list
	100
	101	self.compute_num = 0
	102	self.state_num = 0
	103	self.timestamp = ('00:00:00', '00/00/0000')
	104	self.container = None
	105	#plot image
	106	self.wximbmp = None
	107	# report_html strings
[b9a5f0e]	108	import sas.perspectives.invariant as invariant
[51f14603]	109	path = invariant.get_data_path(media='media')
	110	path_report_html = os.path.join(path,"report_template.html")
	111	html_template = open(path_report_html,"r")
	112	self.template_str = html_template.read()
	113	self.report_str = self.template_str
	114	#self.report_str_save = None
	115	html_template.close()
	116
	117	def __str__(self):
	118	"""
	119	Pretty print
	120
	121	: return: string representing the state
	122	"""
	123	# Input string
	124	compute_num = self.saved_state['compute_num']
	125	compute_state = self.state_list[str(compute_num)]
	126	my_time, date = self.timestamp
	127	file_name = self.file
	128
	129	state_num = int(self.saved_state['state_num'])
	130	state = "\n[Invariant computation for %s: " % file_name
	131	state += "performed at %s on %s] \n" % (my_time, date)
	132	state += "State No.: %d \n" % state_num
	133	state += "\n=== Inputs ===\n"
	134
	135	# text ctl general inputs ( excluding extrapolation text ctl)
	136	for key, value in self.input_list.iteritems():
	137	if value == '':
	138	continue
	139	key_split = key.split('_')
	140	max_ind = len(key_split)-1
	141	if key_split[max_ind] == 'tcl':
	142	name = ""
	143	if key_split[1] == 'low' or key_split[1] == 'high':
	144	continue
	145	for ind in range(0, max_ind):
	146	name += " %s" % key_split[ind]
	147	state += "%s: %s\n" % (name.lstrip(" "), value)
	148
	149	# other input parameters
	150	extra_lo = compute_state['enable_low_cbox']
	151	if compute_state['enable_low_cbox']:
	152	if compute_state['guinier']:
	153	extra_lo = 'Guinier'
	154	else:
	155	extra_lo = 'Power law'
	156	extra_hi = compute_state['enable_high_cbox']
	157	if compute_state['enable_high_cbox']:
	158	extra_hi = 'Power law'
	159	state += "\nExtrapolation: High=%s; Low=%s\n" %(extra_hi, extra_lo)
	160	low_off = False
	161	high_off = False
	162	for key, value in self.input_list.iteritems():
	163	key_split = key.split('_')
	164	max_ind = len(key_split) - 1
	165	if key_split[max_ind] == 'tcl':
	166	name = ""
	167	# check each buttons whether or not ON or OFF
	168	if key_split[1] == 'low' or key_split[1] == 'high':
	169	if not compute_state['enable_low_cbox'] and \
	170	key_split[max_ind-1] == 'low':
	171	low_off = True
	172	continue
	173	elif not compute_state['enable_high_cbox'] and \
	174	key_split[max_ind-1] == 'high':
	175	high_off = True
	176	continue
	177	elif extra_lo == 'Guinier' and key_split[0] == 'power' and \
	178	key_split[max_ind-1] == 'low':
	179	continue
	180	for ind in range(0, max_ind):
	181	name += " %s" % key_split[ind]
	182	name = name.lstrip(" ")
	183	if name == "power low" :
	184	if compute_state['fix_enable_low']:
	185	name += ' (Fixed)'
	186	else:
	187	name += ' (Fitted)'
	188	if name == "power high" :
	189	if compute_state['fix_enable_high']:
	190	name += ' (Fixed)'
	191	else:
	192	name += ' (Fitted)'
	193	state += "%s: %s\n" % (name, value)
	194	# Outputs
	195	state += "\n=== Outputs ==="
	196	for item in output_list:
	197	item_split = item[0].split('_')
	198	# Exclude the extrapolation that turned off
	199	if len(item_split) > 1:
	200	if low_off and item_split[1] == 'low':
	201	continue
	202	if high_off and item_split[1] == 'high':
	203	continue
	204	max_ind = len(item_split) - 1
	205	value = None
	206	try:
	207	# Q* outputs
	208	exec "value = self.container.%s\n" % item[0]
	209	except:
	210	# other outputs than Q*
	211	name = item[0] + "_tcl"
	212	if name in self.saved_state.keys():
	213	exec "value = self.saved_state['%s']" % name
	214
	215	# Exclude the outputs w/''
	216	if value == '':
	217	continue
	218	# Error outputs
	219	if item_split[max_ind] == 'err':
	220	state += "+- %s " % format_number(value)
	221	# Percentage outputs
	222	elif item_split[max_ind] == 'percent':
	223	try:
	224	value = float(value) * 100
	225	except:
	226	pass
	227	state += "(%s %s)" % (format_number(value), '%')
	228	# Outputs
	229	else:
	230	state += "\n%s: %s " % (item[1],
	231	format_number(value, high=True))
	232	# Include warning msg
	233	if self.container is not None:
	234	state += "\n\nNote:\n" + self.container.warning_msg
	235	return state
	236
	237	def clone_state(self):
	238	"""
	239	deepcopy the state
	240	"""
	241	return copy.deepcopy(self.saved_state)
	242
	243	def toXML(self, file="inv_state.inv", doc=None, entry_node=None):
	244	"""
	245	Writes the state of the InversionControl panel to file, as XML.
	246
	247	Compatible with standalone writing, or appending to an
	248	already existing XML document. In that case, the XML document
	249	is required. An optional entry node in the XML document
	250	may also be given.
	251
	252	: param file: file to write to
	253	: param doc: XML document object [optional]
	254	: param entry_node: XML node within the XML document at which we will append the data [optional]
	255	"""
[92a2ecd]	256	# TODO: Get this to work
[51f14603]	257	from xml.dom.minidom import getDOMImplementation
	258	import time
	259	timestamp = time.time()
	260	# Check whether we have to write a standalone XML file
	261	if doc is None:
	262	impl = getDOMImplementation()
	263
	264	doc_type = impl.createDocumentType(INVNODE_NAME, "1.0", "1.0")
	265
	266	newdoc = impl.createDocument(None, INVNODE_NAME, doc_type)
	267	top_element = newdoc.documentElement
	268	else:
	269	# We are appending to an existing document
	270	newdoc = doc
	271	top_element = newdoc.createElement(INVNODE_NAME)
	272	if entry_node is None:
	273	newdoc.documentElement.appendChild(top_element)
	274	else:
	275	entry_node.appendChild(top_element)
[92a2ecd]	276
[51f14603]	277	attr = newdoc.createAttribute("version")
	278	attr.nodeValue = '1.0'
	279	top_element.setAttributeNode(attr)
	280
	281	# File name
	282	element = newdoc.createElement("filename")
	283	if self.file != None and self.file != '':
	284	element.appendChild(newdoc.createTextNode(str(self.file)))
	285	else:
	286	element.appendChild(newdoc.createTextNode(str(file)))
	287	top_element.appendChild(element)
	288
	289	element = newdoc.createElement("timestamp")
	290	element.appendChild(newdoc.createTextNode(time.ctime(timestamp)))
	291	attr = newdoc.createAttribute("epoch")
	292	attr.nodeValue = str(timestamp)
	293	element.setAttributeNode(attr)
	294	top_element.appendChild(element)
	295
	296	# Current state
	297	state = newdoc.createElement("state")
	298	top_element.appendChild(state)
	299
	300	for name,value in self.saved_state.iteritems():
	301	element = newdoc.createElement(str(name))
	302	element.appendChild(newdoc.createTextNode(str(value)))
	303	state.appendChild(element)
	304
	305	# State history list
	306	history = newdoc.createElement("history")
	307	top_element.appendChild(history)
	308
	309	for name, value in self.state_list.iteritems():
	310	history_element = newdoc.createElement('state_' + str(name))
	311	for state_name,state_value in value.iteritems():
	312	state_element = newdoc.createElement(str(state_name))
	313	child = newdoc.createTextNode(str(state_value))
	314	state_element.appendChild(child)
	315	history_element.appendChild(state_element)
	316	#history_element.appendChild(state_list_element)
	317	history.appendChild(history_element)
	318
	319	# Bookmarks bookmark_list[self.bookmark_num] = [\
	320	#my_time,date,state,comp_state]
	321	bookmark = newdoc.createElement("bookmark")
	322	top_element.appendChild(bookmark)
	323	item_list = ['time','date','state','comp_state']
	324	for name, value_list in self.bookmark_list.iteritems():
	325	element = newdoc.createElement('mark_'+ str(name))
	326	_,date,state,comp_state = value_list
	327	time_element = newdoc.createElement('time')
	328	time_element.appendChild(newdoc.createTextNode(str(value_list[0])))
	329	date_element = newdoc.createElement('date')
	330	date_element.appendChild(newdoc.createTextNode(str(value_list[1])))
	331	state_list_element = newdoc.createElement('state')
	332	comp_state_list_element = newdoc.createElement('comp_state')
	333	for state_name, state_value in value_list[2].iteritems():
	334	state_element = newdoc.createElement(str(state_name))
	335	child = newdoc.createTextNode(str(state_value))
	336	state_element.appendChild(child)
	337	state_list_element.appendChild(state_element)
	338	for comp_name, comp_value in value_list[3].iteritems():
	339	comp_element = newdoc.createElement(str(comp_name))
	340	comp_element.appendChild(newdoc.createTextNode(str(comp_value)))
	341	comp_state_list_element.appendChild(comp_element)
	342	element.appendChild(time_element)
	343	element.appendChild(date_element)
	344	element.appendChild(state_list_element)
	345	element.appendChild(comp_state_list_element)
	346	bookmark.appendChild(element)
	347
	348	# Save the file
	349	if doc is None:
	350	fd = open('test000', 'w')
	351	fd.write(newdoc.toprettyxml())
	352	fd.close()
	353	return None
	354	else:
[92a2ecd]	355	return newdoc
[51f14603]	356
	357	def fromXML(self, file=None, node=None):
	358	"""
	359	Load invariant states from a file
	360
	361	: param file: .inv file
	362	: param node: node of a XML document to read from
	363	"""
	364	if file is not None:
	365	msg = "InvariantSate no longer supports non-CanSAS"
	366	msg += " format for invariant files"
	367	raise RuntimeError, msg
	368
	369	if node.get('version')\
	370	and node.get('version') == '1.0':
	371
	372	# Get file name
	373	entry = get_content('ns:filename', node)
	374	if entry is not None:
	375	file_name = entry.text.strip()
	376
	377	# Get time stamp
	378	entry = get_content('ns:timestamp', node)
	379	if entry is not None and entry.get('epoch'):
	380	try:
	381	timestamp = (entry.get('epoch'))
	382	except:
	383	msg = "InvariantSate.fromXML: Could not read"
	384	msg += " timestamp\n %s" % sys.exc_value
	385	logging.error(msg)
	386
	387	# Parse bookmarks
	388	entry_bookmark = get_content('ns:bookmark', node)
	389
	390	for ind in range(1, len(entry_bookmark) + 1):
	391	temp_state = {}
	392	temp_bookmark = {}
	393	entry = get_content('ns:mark_%s' % ind, entry_bookmark)
	394
	395	if entry is not None:
	396	my_time = get_content('ns:time', entry)
	397	val_time = str(my_time.text.strip())
	398	date = get_content('ns:date', entry)
	399	val_date = str(date.text.strip())
	400	state_entry = get_content('ns:state', entry)
	401	for item in list:
	402
	403	input_field = get_content('ns:%s' % item, state_entry)
	404	val = str(input_field.text.strip())
	405	if input_field is not None:
	406	try:
	407	exec "temp_state['%s'] = %s" % (item, val)
	408	except:
	409	exec "temp_state['%s'] = '%s'" % (item, val)
	410	comp_entry = get_content('ns:comp_state', entry)
	411
	412	for item in list:
	413	input_field = get_content('ns:%s' % item, comp_entry)
	414	val = str(input_field.text.strip())
	415	if input_field is not None:
	416	try:
	417	exec "temp_bookmark['%s'] = %s" % (item, val)
	418	except:
	419	exec "temp_bookmark['%s'] = '%s'" % (item, val)
	420	try:
	421	cmd = "self.bookmark_list[%s] = [val_time,"
	422	cmd += "val_date,temp_state,temp_bookmark]"
	423	exec cmd % ind
	424	except:
	425	raise "missing components of bookmarks..."
	426	# Parse histories
	427	entry_history = get_content('ns:history', node)
	428
	429	for ind in range(0, len(entry_history)):
	430	temp_state = {}
	431	entry = get_content('ns:state_%s' % ind, entry_history)
	432
	433	if entry is not None:
	434	for item in list:
	435	input_field = get_content('ns:%s' % item, entry )
	436	val = str(input_field.text.strip())
	437
	438	if input_field is not None:
	439	try:
	440	exec "temp_state['%s'] = %s" % (item, val)
	441	except:
	442	exec "temp_state['%s'] = '%s'" % (item, val)
	443	finally:
	444	exec "self.state_list['%s'] = temp_state" % ind
	445	# Parse current state (ie, saved_state)
	446	entry = get_content('ns:state', node)
	447	if entry is not None:
	448	for item in list:
	449	input_field = get_content('ns:%s' % item, entry)
	450	val = str(input_field.text.strip())
	451	if input_field is not None:
	452	self.set_saved_state(name=item, value=val)
	453	self.file = file_name
	454
	455	def set_report_string(self):
	456	"""
	457	Get the values (strings) from __str__ for report
	458	"""
	459	strings = self.__str__()
	460
	461	# default string values
	462	for num in range (1, 19):
	463	exec "s_%s = 'NA'" % str(num)
	464	lines = strings.split('\n')
	465	# get all string values from __str__()
	466	for line in range(0, len(lines)):
	467	if line == 1:
	468	s_1 = lines[1]
	469	elif line == 2:
	470	s_2 = lines[2]
	471	else:
	472	item = lines[line].split(':')
	473	item[0] = item[0].strip()
	474	if item[0] == "scale":
	475	s_3 = item[1]
	476	elif item[0] == "porod constant":
	477	s_4 = item[1]
	478	elif item[0] == "background":
	479	s_5 = item[1]
	480	elif item[0] == "contrast":
	481	s_6 = item[1]
	482	elif item[0] == "Extrapolation":
	483	extra = item[1].split(";")
	484	bool_0 = extra[0].split("=")
	485	bool_1 = extra[1].split("=")
	486	s_8 = " " + bool_0[0] + "Q region = " + bool_0[1]
	487	s_7 = " " + bool_1[0] + "Q region = " + bool_1[1]
	488	elif item[0] == "npts low":
	489	s_9 = item[1]
	490	elif item[0] == "npts high":
	491	s_10 = item[1]
	492	elif item[0] == "volume fraction":
	493	val=item[1].split("+-")[0].strip()
	494	error = item[1].split("+-")[1].strip()
	495	s_17 = val + " ± " + error
	496	elif item[0] == "specific surface":
	497	val = item[1].split("+-")[0].strip()
	498	error = item[1].split("+-")[1].strip()
	499	s_18 = val + " ± " + error
	500	elif item[0].split("(")[0].strip() == "power low":
	501	s_11 = item[0]+" ="+item[1]
	502	elif item[0].split("(")[0].strip() == "power high":
	503	s_12 = item[0]+" ="+item[1]
	504	elif item[0].split("[")[0].strip() == "Q* from low Q extrapolation":
	505	#looks messy but this way the symbols +_ and % work on html
	506	val = item[1].split("+-")[0].strip()
	507	error = item[1].split("+-")[1].strip()
	508	err = error.split("%")[0].strip()
	509	percent = error.split("%")[1].strip()
	510	s_13 = val + " ± " + err + "&#37" + percent
	511	elif item[0].split("[")[0].strip() == "Q* from data":
	512	val = item[1].split("+-")[0].strip()
	513	error = item[1].split("+-")[1].strip()
	514	err = error.split("%")[0].strip()
	515	percent = error.split("%")[1].strip()
	516	s_14 = val + " ± " + err + "&#37" + percent
	517	elif item[0].split("[")[0].strip() == "Q* from high Q extrapolation":
	518	val = item[1].split("+-")[0].strip()
	519	error = item[1].split("+-")[1].strip()
	520	err = error.split("%")[0].strip()
	521	percent = error.split("%")[1].strip()
	522	s_15 = val + " ± " + err + "&#37" + percent
	523	elif item[0].split("[")[0].strip() == "total Q*":
	524	val = item[1].split("+-")[0].strip()
	525	error = item[1].split("+-")[1].strip()
	526	s_16 = val + " ± " + error
	527	else:
	528	continue
	529
	530	s_1 = self._check_html_format(s_1)
	531	file_name = self._check_html_format(self.file)
	532
	533	# make plot image
	534	self.set_plot_state(extra_high=bool_0[1],extra_low=bool_1[1])
	535	# get ready for report with setting all the html strings
	536	self.report_str = str(self.template_str) % (s_1, s_2,
	537	s_3, s_4, s_5, s_6, s_7, s_8,
	538	s_9, s_10, s_11, s_12, s_13, s_14, s_15,
	539	s_16, s_17, s_18, file_name, "%s")
	540
	541	def _check_html_format(self, name):
	542	"""
	543	Check string '%' for html format
	544	"""
	545	if name.count('%'):
	546	name = name.replace('%', '&#37')
	547
	548	return name
	549
	550	def set_saved_state(self, name, value):
	551	"""
	552	Set the state list
	553
	554	: param name: name of the state component
	555	: param value: value of the state component
	556	"""
	557	rb_list = [['power_law_low','guinier'],
	558	['fit_enable_low','fix_enable_low'],
	559	['fit_enable_high','fix_enable_high']]
	560
	561	try:
	562	if value == None or value.lstrip().rstrip() == '':
	563	exec "self.%s = '%s'" % (name, value)
	564	exec "self.saved_state['%s'] = '%s'" % (name, value)
	565	else:
	566	exec 'self.%s = %s' % (name, value)
	567	exec "self.saved_state['%s'] = %s" % (name, value)
	568	# set the count part of radio button clicked
	569	# False for the saved_state
	570	for title, content in rb_list:
	571	if name == title:
	572	name = content
	573	value = False
	574	elif name == content:
	575	name = title
	576	value = False
	577	exec "self.saved_state['%s'] = '%s'" % (name, value)
	578	self.state_num = self.saved_state['state_num']
	579	except:
	580	pass
	581
	582	def set_plot_state(self, extra_high=False, extra_low=False):
	583	"""
	584	Build image state that wx.html understand
	585	by plotting, putting it into wx.FileSystem image object
	586
	587	: extrap_high,extra_low: low/high extrapolations
	588	are possible extra-plots
	589	"""
	590	# some imports
	591	import wx
	592	import matplotlib.pyplot as plt
	593	from matplotlib.backends.backend_agg import FigureCanvasAgg
	594
	595	#we use simple plot, not plotpanel
	596	#make matlab figure
	597	fig = plt.figure()
	598	fig.set_facecolor('w')
	599	graph = fig.add_subplot(111)
	600
	601	#data plot
	602	graph.errorbar(self.data.x, self.data.y, yerr=self.data.dy, fmt='o')
	603	#low Q extrapolation fit plot
	604	if not extra_low == 'False':
	605	graph.plot(self.theory_lowQ.x,self.theory_lowQ.y)
	606	#high Q extrapolation fit plot
	607	if not extra_high == 'False':
	608	graph.plot(self.theory_highQ.x,self.theory_highQ.y)
	609	graph.set_xscale("log", nonposx='clip')
	610	graph.set_yscale("log", nonposy='clip')
	611	graph.set_xlabel('$\\rm{Q}(\\AA^{-1})$', fontsize = 12)
	612	graph.set_ylabel('$\\rm{Intensity}(cm^{-1})$', fontsize = 12)
	613	canvas = FigureCanvasAgg(fig)
	614	#actually make image
	615	canvas.draw()
	616
	617	#make python.Image object
	618	#size
	619	w, h = canvas.get_width_height()
	620	#convert to wx.Image
	621	wximg = wx.EmptyImage(w,h)
	622	#wxim.SetData(img.convert('RGB').tostring() )
	623	wximg.SetData(canvas.tostring_rgb())
	624	#get the dynamic image for the htmlwindow
	625	wximgbmp = wx.BitmapFromImage(wximg)
	626	#store the image in wx.FileSystem Object
	627	wx.FileSystem.AddHandler(wx.MemoryFSHandler())
	628	# use wx.MemoryFSHandler
	629	self.imgRAM = wx.MemoryFSHandler()
	630	#AddFile, image can be retrieved with 'memory:filename'
	631	self.imgRAM.AddFile('img_inv.png', wximgbmp, wx.BITMAP_TYPE_PNG)
	632
	633	self.wximgbmp = 'memory:img_inv.png'
	634	self.image = fig
	635
	636	class Reader(CansasReader):
	637	"""
	638	Class to load a .inv invariant file
	639	"""
	640	## File type
	641	type_name = "Invariant"
	642
	643	## Wildcards
	644	type = ["Invariant file (.inv)\|.inv",
[b9a5f0e]	645	"SASView file (.svs)\|.svs"]
[51f14603]	646	## List of allowed extensions
	647	ext = ['.inv', '.INV', '.svs', 'SVS']
	648
	649	def __init__(self, call_back, cansas=True):
	650	"""
	651	Initialize the call-back method to be called
	652	after we load a file
	653
	654	: param call_back: call-back method
	655	: param cansas: True = files will be written/read in CanSAS format
	656	False = write CanSAS format
	657	"""
	658	## Call back method to be executed after a file is read
	659	self.call_back = call_back
	660	## CanSAS format flag
	661	self.cansas = cansas
	662	self.state = None
	663
	664	def read(self, path):
	665	"""
	666	Load a new invariant state from file
	667
	668	: param path: file path
	669	: return: None
	670	"""
	671	if self.cansas == True:
	672	return self._read_cansas(path)
	673	else:
	674	return self._read_standalone(path)
	675
	676	def _read_standalone(self, path):
	677	"""
	678	Load a new invariant state from file.
	679	The invariant node is assumed to be the top element.
	680
	681	: param path: file path
	682	: return: None
	683	"""
	684	# Read the new state from file
	685	state = InvariantState()
	686
	687	state.fromXML(file=path)
	688
	689	# Call back to post the new state
	690	self.call_back(state)
	691	return None
	692
	693	def _parse_state(self, entry):
	694	"""
	695	Read an invariant result from an XML node
	696
	697	: param entry: XML node to read from
	698	: return: InvariantState object
	699	"""
	700	state = None
	701	# Locate the invariant node
	702	try:
	703	nodes = entry.xpath('ns:%s' % INVNODE_NAME,
	704	namespaces={'ns': CANSAS_NS})
	705	# Create an empty state
	706	if nodes != []:
	707	state = InvariantState()
	708	state.fromXML(node=nodes[0])
	709	except:
	710	msg = "XML document does not contain invariant"
	711	msg += " information.\n %s" % sys.exc_value
	712	logging.info(msg)
	713	return state
	714
	715	def _read_cansas(self, path):
	716	"""
	717	Load data and invariant information from a CanSAS XML file.
	718
	719	: param path: file path
	720	: return: Data1D object if a single SASentry was found,
	721	or a list of Data1D objects if multiple entries were found,
	722	or None of nothing was found
	723	: raise RuntimeError: when the file can't be opened
	724	: raise ValueError: when the length of the data vectors are inconsistent
	725	"""
	726	output = []
	727	if os.path.isfile(path):
	728	basename = os.path.basename(path)
	729	root, extension = os.path.splitext(basename)
	730
	731	if extension.lower() in self.ext or \
	732	extension.lower() == '.xml':
	733	tree = etree.parse(path, parser=etree.ETCompatXMLParser())
	734
	735	# Check the format version number
	736	# Specifying the namespace will take care of
	737	# the file format version
	738	root = tree.getroot()
	739
	740	entry_list = root.xpath('/ns:SASroot/ns:SASentry',
	741	namespaces={'ns': CANSAS_NS})
	742
	743	for entry in entry_list:
	744
[92a2ecd]	745	sas_entry, _ = self._parse_entry(entry)
[51f14603]	746	invstate = self._parse_state(entry)
	747
	748	#invstate could be None when .svs file is loaded
	749	#in this case, skip appending to output
	750	if invstate != None:
	751	sas_entry.meta_data['invstate'] = invstate
	752	sas_entry.filename = invstate.file
	753	output.append(sas_entry)
	754	else:
	755	raise RuntimeError, "%s is not a file" % path
	756
	757	# Return output consistent with the loader's api
	758	if len(output) == 0:
	759	return None
	760	elif len(output) == 1:
	761	# Call back to post the new state
	762	self.state = output[0].meta_data['invstate']
	763	self.call_back(state=output[0].meta_data['invstate'],
	764	datainfo = output[0])
	765	return output[0]
	766	else:
	767	return output
	768
	769	def get_state(self):
	770	return self.state
	771
	772	def write(self, filename, datainfo=None, invstate=None):
	773	"""
	774	Write the content of a Data1D as a CanSAS XML file
	775
	776	: param filename: name of the file to write
	777	: param datainfo: Data1D object
	778	: param invstate: InvariantState object
	779	"""
	780	# Sanity check
	781	if self.cansas == True:
	782	doc = self.write_toXML(datainfo,invstate)
	783	# Write the XML document
	784	fd = open(filename, 'w')
	785	fd.write(doc.toprettyxml())
	786	fd.close()
	787	else:
	788	invstate.toXML(file=filename)
	789
	790	def write_toXML(self, datainfo=None, state=None):
	791	"""
	792	Write toXML, a helper for write()
	793
	794	: return: xml doc
	795	"""
	796	if datainfo is None:
[79492222]	797	datainfo = sas.dataloader.data_info.Data1D(x=[], y=[])
	798	elif not issubclass(datainfo.__class__, sas.dataloader.data_info.Data1D):
[51f14603]	799	msg = "The cansas writer expects a Data1D"
	800	msg += " instance: %s" % str(datainfo.__class__.__name__)
	801	raise RuntimeError, msg
	802	#make sure title and data run is filled up.
	803	if datainfo.title == None or datainfo.title == '':
	804	datainfo.title = datainfo.name
	805	if datainfo.run_name == None or datainfo.run_name == {}:
	806	datainfo.run = [str(datainfo.name)]
	807	datainfo.run_name[0] = datainfo.name
	808	# Create basic XML document
	809	doc, sasentry = self._to_xml_doc(datainfo)
	810	# Add the invariant information to the XML document
	811	if state is not None:
[92a2ecd]	812	doc = state.toXML(datainfo.name,doc=doc, entry_node=sasentry)
[51f14603]	813	return doc
	814

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

SasView

source: sasview/src/sas/perspectives/invariant/invariant_state.py @ 74f419d

Download in other formats: