Context Navigation

source: trunk/GSASIIimgGUI.py @ 2322

Last change on this file since 2322 was 2322, checked in by vondreele, 7 years ago
(partially) fixed Cancel/Pause? behavior in AutoIntegrate?. Will crash 32-bit if Cancel pressed too soon & if Pause pressed repeatedly during integration. 64-bit seems immune to this.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 131.3 KB

Line
1	# -- coding: utf-8 --
2	#GSASII - image data display routines
3	########### SVN repository information ###################
4	# $Date: 2016-06-15 12:40:20 +0000 (Wed, 15 Jun 2016) $
5	# $Author: vondreele $
6	# $Revision: 2322 $
7	# $URL: trunk/GSASIIimgGUI.py $
8	# $Id: GSASIIimgGUI.py 2322 2016-06-15 12:40:20Z vondreele $
9	########### SVN repository information ###################
10	'''
11	GSASIIimgGUI: Image GUI
12	-------------------------
13
14	Control image display and processing
15
16	'''
17	import os
18	import copy
19	import glob
20	import re
21	import bisect
22	import math
23	import time
24	import sys
25	import wx
26	import wx.lib.scrolledpanel as wxscroll
27	import wx.lib.mixins.listctrl as listmix
28	import matplotlib as mpl
29	import numpy as np
30	import GSASIIpath
31	GSASIIpath.SetVersionNumber("$Revision: 2322 $")
32	import GSASIIimage as G2img
33	import GSASIImath as G2mth
34	import GSASIIplot as G2plt
35	import GSASIIIO as G2IO
36	import GSASIIgrid as G2gd
37	import GSASIIctrls as G2G
38	import GSASIIpy3 as G2py3
39
40	VERY_LIGHT_GREY = wx.Colour(235,235,235)
41	WACV = wx.ALIGN_CENTER_VERTICAL
42
43	# trig functions in degrees
44	sind = lambda x: math.sin(x*math.pi/180.)
45	tand = lambda x: math.tan(x*math.pi/180.)
46	cosd = lambda x: math.cos(x*math.pi/180.)
47	asind = lambda x: 180.*math.asin(x)/math.pi
48
49	################################################################################
50	##### Image Data
51	################################################################################
52
53	def GetImageZ(G2frame,data):
54	'''Gets image & applies dark, background & flat background corrections
55	:param wx.Frame G2frame: main GSAS-II frame
56	param: dict data: Image Controls dictionary
57	return: array sumImg: corrected image for background/dark/flat back
58	'''
59
60	Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(G2frame.Image)
61	imagefile = G2IO.CheckImageFile(G2frame,imagefile)
62	formatName = data.get('formatName','')
63	sumImg = G2IO.GetImageData(G2frame,imagefile,True,ImageTag=imagetag,FormatName=formatName)
64	if not 'dark image' in data:
65	return sumImg
66	darkImg,darkScale = data['dark image']
67	if darkImg:
68	Did = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, darkImg)
69	if Did:
70	Ddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Did,'Image Controls'))
71	dformatName = Ddata.get('formatName','')
72	Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(Did)
73	imagefile = G2IO.CheckImageFile(G2frame,imagefile)
74	darkImage = G2IO.GetImageData(G2frame,imagefile,True,ImageTag=imagetag,FormatName=dformatName)
75	sumImg += np.array(darkImage*darkScale,dtype='int32')
76	if not 'background image' in data:
77	return sumImg
78	backImg,backScale = data['background image']
79	if backImg: #ignores any transmission effect in the background image
80	Bid = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, backImg)
81	if Bid:
82	Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(Bid)
83	imagefile = G2IO.CheckImageFile(G2frame,imagefile)
84	Bdata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Bid,'Image Controls'))
85	bformatName = Bdata.get('formatName','')
86	backImage = G2IO.GetImageData(G2frame,imagefile,True,ImageTag=imagetag,FormatName=bformatName)
87	if darkImg:
88	Did = G2gd.GetPatternTreeItemId(G2frame, G2frame.root,darkImg)
89	if Did:
90	Ddata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Did,'Image Controls'))
91	dformatName = Ddata.get('formatName','')
92	Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(Did)
93	imagefile = G2IO.CheckImageFile(G2frame,imagefile)
94	darkImage = G2IO.GetImageData(G2frame,imagefile,True,ImageTag=imagetag,FormatName=dformatName)
95	backImage += np.array(darkImage*darkScale,dtype='int32')
96	sumImg += np.array(backImage*backScale,dtype='int32')
97	if darkImg: del darkImg #force cleanup
98	if backImg: del backImg
99	# GSASIIpath.IPyBreak()
100	sumImg -= int(data.get('Flat Bkg',0))
101	Imax = np.max(sumImg)
102	data['range'] = [(0,Imax),[0,Imax]]
103	return sumImg
104
105	def UpdateImageData(G2frame,data):
106
107	def OnPixVal(event):
108	Obj = event.GetEventObject()
109	id = Indx[Obj.GetId()]
110	try:
111	data['pixelSize'][id] = min(500,max(10,float(Obj.GetValue())))
112	except ValueError:
113	pass
114	Obj.SetValue('%.3f'%(data['pixelSize'][id]))
115	G2plt.PlotExposedImage(G2frame,newPlot=True,event=event)
116
117	if G2frame.dataDisplay:
118	G2frame.dataDisplay.Destroy()
119	if not G2frame.dataFrame.GetStatusBar():
120	G2frame.dataFrame.CreateStatusBar()
121	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
122	G2frame.ImageZ = GetImageZ(G2frame,data)
123	mainSizer = wx.BoxSizer(wx.VERTICAL)
124	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,
125	label='Do not change anything here unless you are absolutely sure!'),0,WACV)
126	mainSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Image size: %d by %d'%(data['size'][0],data['size'][1])),0,WACV)
127	pixSize = wx.FlexGridSizer(0,4,5,5)
128	pixLabels = [u' Pixel X-dimension (\xb5m)',u' Pixel Y-dimension (\xb5m)']
129	Indx = {}
130	for i,[pixLabel,pix] in enumerate(zip(pixLabels,data['pixelSize'])):
131	pixSize.Add(wx.StaticText(G2frame.dataDisplay,label=pixLabel),0,WACV)
132	pixVal = wx.TextCtrl(G2frame.dataDisplay,value='%.3f'%(pix),style=wx.TE_PROCESS_ENTER)
133	Indx[pixVal.GetId()] = i
134	pixVal.Bind(wx.EVT_TEXT_ENTER,OnPixVal)
135	pixVal.Bind(wx.EVT_KILL_FOCUS,OnPixVal)
136	pixSize.Add(pixVal,0,WACV)
137	mainSizer.Add(pixSize,0)
138
139	mainSizer.Layout()
140	G2frame.dataDisplay.SetSizer(mainSizer)
141	fitSize = mainSizer.Fit(G2frame.dataFrame)
142	G2frame.dataFrame.setSizePosLeft(fitSize)
143	G2frame.dataDisplay.SetSize(fitSize)
144
145	################################################################################
146	##### Image Controls
147	################################################################################
148	def UpdateImageControls(G2frame,data,masks,IntegrateOnly=False):
149	'''Shows and handles the controls on the "Image Controls"
150	data tree entry
151	'''
152	import ImageCalibrants as calFile
153	#patch
154	if 'Flat Bkg' not in data:
155	data['Flat Bkg'] = 0.0
156	if 'GonioAngles' not in data:
157	data['GonioAngles'] = [0.,0.,0.]
158	if 'DetDepth' not in data:
159	data['DetDepth'] = 0.
160	if 'SampleAbs' not in data:
161	data['SampleShape'] = 'Cylinder'
162	data['SampleAbs'] = [0.0,False]
163	if 'binType' not in data:
164	if 'PWDR' in data['type']:
165	data['binType'] = '2-theta'
166	elif 'SASD' in data['type']:
167	data['binType'] = 'log(q)'
168	if 'varyList' not in data:
169	data['varyList'] = {'dist':True,'det-X':True,'det-Y':True,'tilt':True,'phi':True,'dep':False,'wave':False}
170	#end patch
171
172	# Menu items
173
174	def OnCalibrate(event):
175	G2frame.dataFrame.GetStatusBar().SetStatusText('Select > 4 points on 1st used ring; LB to pick, RB on point to delete else RB to finish')
176	G2frame.ifGetRing = True
177
178	def OnRecalibrate(event):
179	G2img.ImageRecalibrate(G2frame,data,masks)
180	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
181
182	def OnRecalibAll(event):
183	Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
184	dlg = G2G.G2MultiChoiceDialog(G2frame,'Image calibration controls','Select images to recalibrate:',Names)
185	try:
186	if dlg.ShowModal() == wx.ID_OK:
187	items = dlg.GetSelections()
188	G2frame.EnablePlot = False
189	for item in items:
190	name = Names[item]
191	print 'calibrating',name
192	G2frame.Image = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
193	CId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Image Controls')
194	Data = G2frame.PatternTree.GetItemPyData(CId)
195	G2frame.ImageZ = GetImageZ(G2frame,Data)
196	Data['setRings'] = True
197	Mid = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Masks')
198	Masks = G2frame.PatternTree.GetItemPyData(Mid)
199	G2img.ImageRecalibrate(G2frame,Data,Masks)
200	finally:
201	dlg.Destroy()
202	G2plt.PlotExposedImage(G2frame,event=None)
203	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
204
205	def OnClearCalib(event):
206	data['ring'] = []
207	data['rings'] = []
208	data['ellipses'] = []
209	G2plt.PlotExposedImage(G2frame,event=event)
210
211	def ResetThresholds():
212	Imin = max(0.,np.min(G2frame.ImageZ))
213	Imax = np.max(G2frame.ImageZ)
214	data['range'] = [(0,Imax),[Imin,Imax]]
215	masks['Thresholds'] = [(0,Imax),[Imin,Imax]]
216	MaxSizer.GetChildren()[2].Window.SetValue(str(int(Imax))) #tricky
217	MaxSizer.GetChildren()[5].Window.SetValue(str(int(Imin))) #tricky
218
219	def OnIntegrate(event):
220	'''Integrate image in response to a menu event or from the AutoIntegrate
221	dialog. In the latter case, event=None.
222	'''
223	CleanupMasks(masks)
224	blkSize = 128 #this seems to be optimal; will break in polymask if >1024
225	Nx,Ny = data['size']
226	nXBlks = (Nx-1)/blkSize+1
227	nYBlks = (Ny-1)/blkSize+1
228	Nup = nXBlksnYBlks3+1 #exact count expected so AUTO_HIDE works!
229	if IntegrateOnly:
230	pdlg = wx.ProgressDialog("Elapsed time","2D image integration\nCancel to pause",
231	Nup,style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_CAN_ABORT)
232	else:
233	pdlg = wx.ProgressDialog("Elapsed time","2D image integration",Nup,
234	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
235	try:
236	sumImg = GetImageZ(G2frame,data)
237	G2frame.Integrate = G2img.ImageIntegrate(sumImg,data,masks,blkSize,pdlg)
238	del sumImg #force cleanup
239	Id = G2IO.SaveIntegration(G2frame,G2frame.PickId,data,(event is None))
240	G2frame.PatternId = Id
241	G2frame.PatternTree.SelectItem(Id)
242	G2frame.PatternTree.Expand(Id)
243	finally:
244	if pdlg:
245	pdlg.Destroy()
246	for item in G2frame.MakePDF: item.Enable(True)
247	G2frame.PauseIntegration = G2frame.Integrate[-1]
248
249	def OnIntegrateAll(event):
250	Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
251	dlg = G2G.G2MultiChoiceDialog(G2frame,'Image integration controls','Select images to integrate:',Names)
252	try:
253	if dlg.ShowModal() == wx.ID_OK:
254	items = dlg.GetSelections()
255	G2frame.EnablePlot = False
256	for item in items:
257	name = Names[item]
258	G2frame.Image = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
259	CId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Image Controls')
260	Data = G2frame.PatternTree.GetItemPyData(CId)
261	blkSize = 128 #this seems to be optimal; will break in polymask if >1024
262	Nx,Ny = Data['size']
263	nXBlks = (Nx-1)/blkSize+1
264	nYBlks = (Ny-1)/blkSize+1
265	Nup = nXBlksnYBlks3+3
266	dlgp = wx.ProgressDialog("Elapsed time","2D image integration",Nup,
267	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE)
268	try:
269	image = GetImageZ(G2frame,Data)
270	Masks = G2frame.PatternTree.GetItemPyData(
271	G2gd.GetPatternTreeItemId(G2frame,G2frame.Image,'Masks'))
272	G2frame.Integrate = G2img.ImageIntegrate(image,Data,Masks,blkSize,dlgp)
273	del image #force cleanup
274	pId = G2IO.SaveIntegration(G2frame,CId,Data)
275	finally:
276	dlgp.Destroy()
277	if G2frame.Integrate[-1]: #Cancel from progress bar?
278	break
279	else:
280	G2frame.EnablePlot = True
281	G2frame.PatternTree.SelectItem(pId)
282	G2frame.PatternTree.Expand(pId)
283	G2frame.PatternId = pId
284	# GSASIIpath.IPyBreak()
285	finally:
286	dlg.Destroy()
287
288	def OnCopyControls(event):
289	Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
290	if len(Names) == 1:
291	G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
292	return
293	Source = G2frame.PatternTree.GetItemText(G2frame.Image)
294	Names.pop(Names.index(Source))
295	# select targets & do copy
296	dlg = G2G.G2MultiChoiceDialog(G2frame,'Copy image controls','Copy controls from '+Source+' to:',Names)
297	try:
298	if dlg.ShowModal() == wx.ID_OK:
299	items = dlg.GetSelections()
300	G2frame.EnablePlot = False
301	for item in items:
302	name = Names[item]
303	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
304	CId = G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls')
305	oldData = copy.deepcopy(G2frame.PatternTree.GetItemPyData(CId))
306	Data = copy.deepcopy(data)
307	Data['size'] = oldData['size']
308	Data['GonioAngles'] = oldData.get('GonioAngles', [0.,0.,0.])
309	Data['ring'] = []
310	Data['rings'] = []
311	Data['ellipses'] = []
312	if name == Data['dark image'][0]:
313	Data['dark image'] = ['',-1.]
314	if name == Data['background image'][0]:
315	Data['background image'] = ['',-1.]
316	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Image Controls'),copy.deepcopy(Data))
317	finally:
318	dlg.Destroy()
319	G2frame.PatternTree.SelectItem(G2frame.PickId)
320
321	def OnCopySelected(event):
322	Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
323	if len(Names) == 1:
324	G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
325	return
326	Source = G2frame.PatternTree.GetItemText(G2frame.Image)
327	# Assemble a list of item labels
328	keyList = ['type','wavelength','calibrant','distance','center',
329	'tilt','rotation','azmthOff','fullIntegrate','LRazimuth',
330	'IOtth','outChannels','outAzimuths','invert_x','invert_y','DetDepth',
331	'calibskip','pixLimit','cutoff','calibdmin','Flat Bkg','varyList',
332	'binType','SampleShape','PolaVal','SampleAbs','dark image','background image']
333	keyText = [i+'='+str(data[i]) for i in keyList]
334	# sort both lists together, ordered by keyText
335	selectedKeys = []
336	dlg = G2G.G2MultiChoiceDialog(
337	G2frame.dataFrame,
338	'Select which image controls\nto copy',
339	'Select image controls', keyText)
340	try:
341	if dlg.ShowModal() == wx.ID_OK:
342	selectedKeys = [keyList[i] for i in dlg.GetSelections()]
343	finally:
344	dlg.Destroy()
345	if not selectedKeys: return # nothing to copy
346	copyDict = {}
347	for parm in selectedKeys:
348	copyDict[parm] = data[parm]
349	dlg = G2G.G2MultiChoiceDialog(
350	G2frame.dataFrame,
351	'Copy image controls from\n'+Source+' to...',
352	'Copy image controls', Names)
353	try:
354	if dlg.ShowModal() == wx.ID_OK:
355	result = dlg.GetSelections()
356	for i in result:
357	item = Names[i]
358	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,item)
359	Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Image Controls'))
360	Controls.update(copy.deepcopy(copyDict))
361	finally:
362	dlg.Destroy()
363
364	def OnSaveControls(event):
365	pth = G2G.GetExportPath(G2frame)
366	dlg = wx.FileDialog(G2frame, 'Choose image controls file', pth, '',
367	'image control files (.imctrl)\|.imctrl',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
368	try:
369	if dlg.ShowModal() == wx.ID_OK:
370	filename = dlg.GetPath()
371	# make sure extension is .imctrl
372	filename = os.path.splitext(filename)[0]+'.imctrl'
373	File = open(filename,'w')
374	keys = ['type','wavelength','calibrant','distance','center',
375	'tilt','rotation','azmthOff','fullIntegrate','LRazimuth',
376	'IOtth','outChannels','outAzimuths','invert_x','invert_y','DetDepth',
377	'calibskip','pixLimit','cutoff','calibdmin','Flat Bkg','varyList',
378	'binType','SampleShape','PolaVal','SampleAbs','dark image','background image']
379	for key in keys:
380	if key not in data: #uncalibrated!
381	continue
382	File.write(key+':'+str(data[key])+'\n')
383	File.close()
384	finally:
385	dlg.Destroy()
386
387	def OnLoadControls(event):
388	cntlList = ['wavelength','distance','tilt','invert_x','invert_y','type',
389	'fullIntegrate','outChannels','outAzimuths','LRazimuth','IOtth','azmthOff','DetDepth',
390	'calibskip','pixLimit','cutoff','calibdmin','Flat Bkg','varyList',
391	'PolaVal','SampleAbs','dark image','background image']
392	pth = G2G.GetImportPath(G2frame)
393	if not pth: pth = '.'
394	dlg = wx.FileDialog(G2frame, 'Choose image controls file', pth, '',
395	'image control files (.imctrl)\|.imctrl',wx.OPEN)
396	try:
397	if dlg.ShowModal() == wx.ID_OK:
398	filename = dlg.GetPath()
399	File = open(filename,'r')
400	save = {}
401	S = File.readline()
402	while S:
403	if S[0] == '#':
404	S = File.readline()
405	continue
406	[key,val] = S[:-1].split(':',1)
407	if key in ['type','calibrant','binType','SampleShape',]: #strings
408	save[key] = val
409	elif key in ['varyList',]:
410	save[key] = eval(val) #dictionary
411	elif key in ['rotation']:
412	save[key] = float(val)
413	elif key in ['center',]:
414	if ',' in val:
415	save[key] = eval(val)
416	else:
417	vals = val.strip('[] ').split()
418	save[key] = [float(vals[0]),float(vals[1])]
419	elif key in cntlList:
420	save[key] = eval(val)
421	S = File.readline()
422	data.update(save)
423	# next line removed. Previous updates tree contents. The next
424	# makes a copy of data, puts it into tree and "disconnects" data
425	# from tree contents (later changes to data are lost!)
426	#G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'),copy.deepcopy(data))
427	File.close()
428	finally:
429	dlg.Destroy()
430	G2frame.ImageZ = GetImageZ(G2frame,data)
431	ResetThresholds()
432	G2plt.PlotExposedImage(G2frame,event=event)
433	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
434
435	# Sizers
436	Indx = {}
437	def ComboSizer():
438
439	def OnDataType(event):
440	data['type'] = typeSel.GetValue()[:4]
441	if 'SASD' in data['type']:
442	data['SampleAbs'][0] = np.exp(-data['SampleAbs'][0]) #switch from muT to trans!
443	if data['binType'] == '2-theta': data['binType'] = 'log(q)' #switch default bin type
444	elif 'PWDR' in data['type']:
445	data['SampleAbs'][0] = -np.log(data['SampleAbs'][0]) #switch from trans to muT!
446	if data['binType'] == 'log(q)': data['binType'] = '2-theta' #switch default bin type
447	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
448
449	def OnNewColorBar(event):
450	data['color'] = colSel.GetValue()
451	G2plt.PlotExposedImage(G2frame,event=event)
452
453	def OnAzmthOff(event):
454	try:
455	azmthoff = float(azmthOff.GetValue())
456	data['azmthOff'] = azmthoff
457	except ValueError:
458	pass
459	azmthOff.SetValue("%.2f"%(data['azmthOff'])) #reset in case of error
460	G2plt.PlotExposedImage(G2frame,event=event)
461
462	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
463	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Type of image data: '),0,WACV)
464	typeSel = wx.ComboBox(parent=G2frame.dataDisplay,value=typeDict[data['type']],choices=typeList,
465	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
466	typeSel.SetValue(data['type'])
467	typeSel.Bind(wx.EVT_COMBOBOX, OnDataType)
468	comboSizer.Add(typeSel,0,WACV)
469	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Color bar '),0,WACV)
470	colSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['color'],choices=colorList,
471	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
472	colSel.Bind(wx.EVT_COMBOBOX, OnNewColorBar)
473	comboSizer.Add(colSel,0,WACV)
474	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Azimuth offset '),0,WACV)
475	azmthOff = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f" % (data['azmthOff'])),
476	style=wx.TE_PROCESS_ENTER)
477	azmthOff.Bind(wx.EVT_TEXT_ENTER,OnAzmthOff)
478	azmthOff.Bind(wx.EVT_KILL_FOCUS,OnAzmthOff)
479	comboSizer.Add(azmthOff,0,WACV)
480	return comboSizer
481
482	def MaxSizer():
483
484	def OnMaxVal(event):
485	try:
486	value = min(data['range'][0][1],int(maxVal.GetValue()))
487	if value < data['range'][1][0]+1:
488	raise ValueError
489	data['range'][1][1] = value
490	except ValueError:
491	pass
492	maxVal.SetValue('%.0f'%(data['range'][1][1]))
493	DeltOne = data['range'][1][1]-max(0.0,data['range'][0][0])
494	sqrtDeltOne = math.sqrt(DeltOne)
495	maxSel.SetValue(int(100*sqrtDeltOne/sqrtDeltZero))
496	minSel.SetValue(int(100*(data['range'][1][0]/DeltOne)))
497	G2plt.PlotExposedImage(G2frame,event=event)
498
499	def OnMinVal(event):
500	try:
501	value = int(minVal.GetValue())
502	if value > data['range'][1][1]-1:
503	raise ValueError
504	data['range'][1][0] = value
505	except ValueError:
506	pass
507	minVal.SetValue('%.0f'%(data['range'][1][0]))
508	minSel.SetValue(int(100*(data['range'][1][0]-max(0.0,data['range'][0][0]))/DeltOne))
509	G2plt.PlotExposedImage(G2frame,event=event)
510
511	def OnMaxSlider(event):
512	sqrtDeltZero = math.sqrt(data['range'][0][1])
513	imax = int(maxSel.GetValue())*sqrtDeltZero/100.
514	data['range'][1][1] = imax**2
515	data['range'][1][0] = max(0.0,min(data['range'][1][1]-1,data['range'][1][0]))
516	DeltOne = max(1.0,data['range'][1][1]-data['range'][1][0])
517	minSel.SetValue(int(100*(data['range'][1][0]/DeltOne)))
518	maxVal.SetValue('%.0f'%(data['range'][1][1]))
519	G2plt.PlotExposedImage(G2frame,event=event)
520
521	def OnMinSlider(event):
522	DeltOne = data['range'][1][1]-data['range'][1][0]
523	imin = int(minSel.GetValue())*DeltOne/100.
524	data['range'][1][0] = max(0.0,min(data['range'][1][1]-1,imin))
525	minVal.SetValue('%.0f'%(data['range'][1][0]))
526	G2plt.PlotExposedImage(G2frame,event=event)
527
528	maxSizer = wx.FlexGridSizer(0,3,0,5)
529	maxSizer.AddGrowableCol(1,1)
530	maxSizer.SetFlexibleDirection(wx.HORIZONTAL)
531	sqrtDeltZero = max(1.0,math.sqrt(data['range'][0][1]-max(0.0,data['range'][0][0])))
532	DeltOne = max(1.0,data['range'][1][1]-max(0.0,data['range'][0][0]))
533	sqrtDeltOne = math.sqrt(DeltOne)
534	maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Max intensity'),0,WACV)
535	maxSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
536	value=int(100*sqrtDeltOne/sqrtDeltZero))
537	maxSizer.Add(maxSel,1,wx.EXPAND)
538	maxSel.Bind(wx.EVT_SLIDER, OnMaxSlider)
539	maxVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.0f'%(data['range'][1][1]))
540	maxVal.Bind(wx.EVT_TEXT_ENTER,OnMaxVal)
541	maxVal.Bind(wx.EVT_KILL_FOCUS,OnMaxVal)
542	maxSizer.Add(maxVal,0,WACV)
543	maxSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min intensity'),0,WACV)
544	minSel = wx.Slider(parent=G2frame.dataDisplay,style=wx.SL_HORIZONTAL,
545	value=int(100*(data['range'][1][0]-max(0.0,data['range'][0][0]))/DeltOne))
546	maxSizer.Add(minSel,1,wx.EXPAND)
547	minSel.Bind(wx.EVT_SLIDER, OnMinSlider)
548	minVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.0f'%(data['range'][1][0]))
549	minVal.Bind(wx.EVT_TEXT_ENTER,OnMinVal)
550	minVal.Bind(wx.EVT_KILL_FOCUS,OnMinVal)
551	maxSizer.Add(minVal,0,WACV)
552	return maxSizer
553
554	def CalibCoeffSizer():
555
556	def OnCalRef(event):
557	Obj = event.GetEventObject()
558	name = Indx[Obj]
559	data['varyList'][name] = Obj.GetValue()
560
561	def OnCalVal(event):
562	Obj = event.GetEventObject()
563	name = Indx[Obj]
564	try:
565	value = float(Obj.GetValue())
566	if name == 'wave' and value < 0.01:
567	raise ValueError
568	except ValueError:
569	value = Parms[name][2]
570	if name == 'dist':
571	data['distance'] = value
572	elif name == 'det-X':
573	data['center'][0] = value
574	elif name == 'det-Y':
575	data['center'][1] = value
576	elif name == 'tilt':
577	data['tilt'] = value
578	elif name == 'phi':
579	data['rotation'] = value
580	elif name == 'wave':
581	data['wavelength'] = value
582	elif name == 'dep':
583	data['DetDepth'] = value
584	Parms[name][2] = value
585	Obj.SetValue(Parms[name][1]%(value))
586
587	calibSizer = wx.FlexGridSizer(0,2,5,5)
588	calibSizer.SetFlexibleDirection(wx.HORIZONTAL)
589	calibSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration coefficients'),0,WACV)
590	calibSizer.Add((5,0),0)
591	cent = data['center']
592	Names = ['det-X','det-Y','wave','dist','tilt','phi']
593	if 'PWDR' in data['type']:
594	Names.append('dep')
595	Parms = {'dist':['Distance','%.3f',data['distance']],'det-X':['Beam center X','%.3f',data['center'][0]],
596	'det-Y':['Beam center Y','%.3f',data['center'][1]],'tilt':['Tilt angle','%.3f',data['tilt']],
597	'phi':['Tilt rotation','%.2f',data['rotation']],'dep':['Penetration','%.2f',data['DetDepth']],
598	'wave':['Wavelength','%.6f',data['wavelength']]}
599	# Indx = {}
600	for name in Names:
601	calSel = wx.CheckBox(parent=G2frame.dataDisplay,label=Parms[name][0])
602	calibSizer.Add(calSel,0,WACV)
603	calSel.Bind(wx.EVT_CHECKBOX, OnCalRef)
604	calSel.SetValue(data['varyList'][name])
605	Indx[calSel] = name
606	calVal = wx.TextCtrl(G2frame.dataDisplay,value=(Parms[name][1]%(Parms[name][2])),style=wx.TE_PROCESS_ENTER)
607	calVal.Bind(wx.EVT_TEXT_ENTER,OnCalVal)
608	calVal.Bind(wx.EVT_KILL_FOCUS,OnCalVal)
609	Indx[calVal] = name
610	calibSizer.Add(calVal,0,WACV)
611	return calibSizer
612
613	def IntegrateSizer():
614
615	def OnNewBinType(event):
616	data['binType'] = binSel.GetValue()
617	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
618
619	def OnIOtth(event):
620	Ltth = max(float(G2frame.InnerTth.GetValue()),0.001)
621	Utth = float(G2frame.OuterTth.GetValue())
622	if Ltth > Utth:
623	Ltth,Utth = Utth,Ltth
624	if 'Q' in data['binType']:
625	data['IOtth'] = [2.asind(Ltthwave/(4.math.pi)),2.asind(Utthwave/(4.math.pi))]
626	else:
627	data['IOtth'] = [Ltth,Utth]
628	G2frame.InnerTth.SetValue("%8.3f" % (Ltth))
629	G2frame.OuterTth.SetValue("%8.3f" % (Utth))
630	G2plt.PlotExposedImage(G2frame,event=event)
631
632	def OnLRazim(event):
633	Lazm = int(G2frame.Lazim.GetValue())%360
634	Razm = int(G2frame.Razim.GetValue())%360
635	if Lazm > Razm:
636	Razm += 360
637	if data['fullIntegrate']:
638	Razm = Lazm+360
639	G2frame.Lazim.SetValue("%6d" % (Lazm))
640	G2frame.Razim.SetValue("%6d" % (Razm))
641	data['LRazimuth'] = [Lazm,Razm]
642	G2plt.PlotExposedImage(G2frame,event=event)
643
644	def OnNumOutChans(event):
645	try:
646	numChans = int(outChan.GetValue())
647	if numChans < 10:
648	raise ValueError
649	data['outChannels'] = numChans
650	except ValueError:
651	pass
652	outChan.SetValue(str(data['outChannels'])) #reset in case of error
653
654	def OnNumOutAzms(event):
655	try:
656	numAzms = int(outAzim.GetValue())
657	if numAzms < 1:
658	raise ValueError
659	data['outAzimuths'] = numAzms
660	except ValueError:
661	pass
662	outAzim.SetValue(str(data['outAzimuths'])) #reset in case of error
663	G2plt.PlotExposedImage(G2frame,event=event)
664
665	def OnOblique(event):
666	if data['Oblique'][1]:
667	data['Oblique'][1] = False
668	else:
669	data['Oblique'][1] = True
670
671	def OnObliqVal(event):
672	try:
673	value = float(obliqVal.GetValue())
674	if 0.01 <= value <= 0.99:
675	data['Oblique'][0] = value
676	else:
677	raise ValueError
678	except ValueError:
679	pass
680	obliqVal.SetValue('%.3f'%(data['Oblique'][0]))
681
682	def OnSampleShape(event):
683	data['SampleShape'] = samShape.GetValue()
684	if 'Cylind' in data['SampleShape']:
685	data['SampleAbs'][0] = 0.0
686	elif 'Fixed' in data['SampleShape']:
687	data['SampleAbs'][0] = 1.0
688	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
689
690	def OnSamAbs(event):
691	if data['SampleAbs'][1]:
692	data['SampleAbs'][1] = False
693	else:
694	data['SampleAbs'][1] = True
695
696	def OnSamAbsVal(event):
697	try:
698	value = float(samabsVal.GetValue())
699	minmax = [0.,2.]
700	if 'Fixed' in data['SampleShape']:
701	minmax = [.05,1.0]
702	if minmax[0] <= value <= minmax[1]:
703	data['SampleAbs'][0] = value
704	else:
705	raise ValueError
706	except ValueError:
707	pass
708	samabsVal.SetValue('%.3f'%(data['SampleAbs'][0]))
709
710	def OnShowLines(event):
711	if data['showLines']:
712	data['showLines'] = False
713	else:
714	data['showLines'] = True
715	G2plt.PlotExposedImage(G2frame,event=event)
716
717	def OnFullIntegrate(event):
718	Lazm =int(G2frame.Lazim.GetValue())
719	if data['fullIntegrate']:
720	data['fullIntegrate'] = False
721	data['LRazimuth'] = [Lazm,Lazm+20]
722	else:
723	data['fullIntegrate'] = True
724	data['LRazimuth'] = [Lazm,Lazm+360]
725	wx.CallLater(100,UpdateImageControls,G2frame,data,masks)
726	G2plt.PlotExposedImage(G2frame,event=event)
727
728	def OnSetDefault(event):
729	if data['setDefault']:
730	G2frame.imageDefault = {}
731	data['setDefault'] = False
732	else:
733	G2frame.imageDefault = copy.copy(data)
734	data['setDefault'] = True
735
736	def OnCenterAzm(event):
737	if data['centerAzm']:
738	data['centerAzm'] = False
739	else:
740	data['centerAzm'] = True
741	G2plt.PlotExposedImage(G2frame,event=event)
742
743	def OnApplyPola(event):
744	if data['PolaVal'][1]:
745	data['PolaVal'][1] = False
746	else:
747	data['PolaVal'][1] = True
748
749	def OnPolaVal(event):
750	try:
751	value = float(polaVal.GetValue())
752	if 0.001 <= value <= 0.999:
753	data['PolaVal'][0] = value
754	else:
755	raise ValueError
756	except ValueError:
757	pass
758	polaVal.SetValue('%.3f'%(data['PolaVal'][0]))
759
760	dataSizer = wx.FlexGridSizer(0,2,5,3)
761	dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Integration coefficients'),0,WACV)
762	dataSizer.Add((5,0),0)
763	if 'PWDR' in data['type']:
764	binChoice = ['2-theta','Q']
765	elif 'SASD' in data['type']:
766	binChoice = ['2-theta','Q','log(q)']
767	dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Bin style: Constant step bins in'),0,WACV)
768	binSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['binType'],choices=binChoice,
769	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
770	binSel.Bind(wx.EVT_COMBOBOX, OnNewBinType)
771	dataSizer.Add(binSel,0,WACV)
772	binType = '2-theta'
773	if 'q' in data['binType'].lower():
774	binType = 'Q'
775	dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Inner/Outer '+binType),0,WACV)
776	IOtth = data['IOtth'][:]
777	if 'Q' in data['binType']:
778	wave = data['wavelength']
779	IOtth = [4.math.pisind(IOtth[0]/2.)/wave,4.math.pisind(IOtth[1]/2.)/wave]
780	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
781	G2frame.InnerTth = wx.TextCtrl(parent=G2frame.dataDisplay,
782	value=("%8.3f" % (IOtth[0])),style=wx.TE_PROCESS_ENTER)
783	G2frame.InnerTth.Bind(wx.EVT_TEXT_ENTER,OnIOtth)
784	G2frame.InnerTth.Bind(wx.EVT_KILL_FOCUS,OnIOtth)
785	littleSizer.Add(G2frame.InnerTth,0,WACV)
786	G2frame.OuterTth = wx.TextCtrl(parent=G2frame.dataDisplay,
787	value=("%8.2f" % (IOtth[1])),style=wx.TE_PROCESS_ENTER)
788	G2frame.OuterTth.Bind(wx.EVT_TEXT_ENTER,OnIOtth)
789	G2frame.OuterTth.Bind(wx.EVT_KILL_FOCUS,OnIOtth)
790	littleSizer.Add(G2frame.OuterTth,0,WACV)
791	dataSizer.Add(littleSizer,0,)
792	dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Start/End azimuth'),0,WACV)
793	LRazim = data['LRazimuth']
794	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
795	G2frame.Lazim = wx.TextCtrl(parent=G2frame.dataDisplay,
796	value=("%6d" % (LRazim[0])),style=wx.TE_PROCESS_ENTER)
797	G2frame.Lazim.Bind(wx.EVT_TEXT_ENTER,OnLRazim)
798	G2frame.Lazim.Bind(wx.EVT_KILL_FOCUS,OnLRazim)
799	littleSizer.Add(G2frame.Lazim,0,WACV)
800	G2frame.Razim = wx.TextCtrl(parent=G2frame.dataDisplay,
801	value=("%6d" % (LRazim[1])),style=wx.TE_PROCESS_ENTER)
802	G2frame.Razim.Bind(wx.EVT_TEXT_ENTER,OnLRazim)
803	G2frame.Razim.Bind(wx.EVT_KILL_FOCUS,OnLRazim)
804	if data['fullIntegrate']:
805	G2frame.Razim.Enable(False)
806	G2frame.Razim.SetBackgroundColour(VERY_LIGHT_GREY)
807	G2frame.Razim.SetValue("%6d" % (LRazim[0]+360))
808	littleSizer.Add(G2frame.Razim,0,WACV)
809	dataSizer.Add(littleSizer,0,)
810	dataSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' No. 2-theta/azimuth bins'),0,WACV)
811	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
812	outChan = wx.TextCtrl(parent=G2frame.dataDisplay,value=str(data['outChannels']),style=wx.TE_PROCESS_ENTER)
813	outChan.Bind(wx.EVT_TEXT_ENTER,OnNumOutChans)
814	outChan.Bind(wx.EVT_KILL_FOCUS,OnNumOutChans)
815	littleSizer.Add(outChan,0,WACV)
816	outAzim = wx.TextCtrl(parent=G2frame.dataDisplay,value=str(data['outAzimuths']),style=wx.TE_PROCESS_ENTER)
817	outAzim.Bind(wx.EVT_TEXT_ENTER,OnNumOutAzms)
818	outAzim.Bind(wx.EVT_KILL_FOCUS,OnNumOutAzms)
819	littleSizer.Add(outAzim,0,WACV)
820	dataSizer.Add(littleSizer,0,)
821	samplechoice = ['Cylinder','Fixed flat plate',]
822	dataSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Select sample shape'),0,WACV)
823	samShape = wx.ComboBox(G2frame.dataDisplay,value=data['SampleShape'],choices=samplechoice,
824	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
825	samShape.Bind(wx.EVT_COMBOBOX,OnSampleShape)
826	dataSizer.Add(samShape,0,WACV)
827	#SampleShape - cylinder or flat plate choice?
828	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
829	samabs = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply sample absorption?')
830	dataSizer.Add(samabs,0,WACV)
831	samabs.Bind(wx.EVT_CHECKBOX, OnSamAbs)
832	samabs.SetValue(data['SampleAbs'][1])
833	if 'Cylind' in data['SampleShape']: #cylinder mu*R; flat plate transmission
834	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='mu*R (0.00-2.0) '),0,WACV)
835	elif 'Fixed' in data['SampleShape']:
836	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='transmission '),0,WACV) #for flat plate
837	samabsVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.3f'%(data['SampleAbs'][0]),style=wx.TE_PROCESS_ENTER)
838	samabsVal.Bind(wx.EVT_TEXT_ENTER,OnSamAbsVal)
839	samabsVal.Bind(wx.EVT_KILL_FOCUS,OnSamAbsVal)
840	littleSizer.Add(samabsVal,0,WACV)
841	dataSizer.Add(littleSizer,0,)
842	if 'PWDR' in data['type']:
843	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
844	oblique = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply detector absorption?')
845	dataSizer.Add(oblique,0,WACV)
846	oblique.Bind(wx.EVT_CHECKBOX, OnOblique)
847	oblique.SetValue(data['Oblique'][1])
848	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Value (0.01-0.99) '),0,WACV)
849	obliqVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.3f'%(data['Oblique'][0]),style=wx.TE_PROCESS_ENTER)
850	obliqVal.Bind(wx.EVT_TEXT_ENTER,OnObliqVal)
851	obliqVal.Bind(wx.EVT_KILL_FOCUS,OnObliqVal)
852	littleSizer.Add(obliqVal,0,WACV)
853	dataSizer.Add(littleSizer,0,)
854	if 'SASD' in data['type']:
855	littleSizer = wx.BoxSizer(wx.HORIZONTAL)
856	setPolariz = wx.CheckBox(parent=G2frame.dataDisplay,label='Apply polarization?')
857	dataSizer.Add(setPolariz,0,WACV)
858	setPolariz.Bind(wx.EVT_CHECKBOX, OnApplyPola)
859	setPolariz.SetValue(data['PolaVal'][1])
860	littleSizer.Add(wx.StaticText(G2frame.dataDisplay,label='Value (0.001-0.999) '),0,WACV)
861	polaVal = wx.TextCtrl(parent=G2frame.dataDisplay,value='%.3f'%(data['PolaVal'][0]),
862	style=wx.TE_PROCESS_ENTER)
863	polaVal.Bind(wx.EVT_TEXT_ENTER,OnPolaVal)
864	polaVal.Bind(wx.EVT_KILL_FOCUS,OnPolaVal)
865	littleSizer.Add(polaVal,0,WACV)
866	dataSizer.Add(littleSizer,0,)
867
868	showLines = wx.CheckBox(parent=G2frame.dataDisplay,label='Show integration limits?')
869	dataSizer.Add(showLines,0,WACV)
870	showLines.Bind(wx.EVT_CHECKBOX, OnShowLines)
871	showLines.SetValue(data['showLines'])
872	fullIntegrate = wx.CheckBox(parent=G2frame.dataDisplay,label='Do full integration?')
873	dataSizer.Add(fullIntegrate,0,WACV)
874	fullIntegrate.Bind(wx.EVT_CHECKBOX, OnFullIntegrate)
875	fullIntegrate.SetValue(data['fullIntegrate'])
876	setDefault = wx.CheckBox(parent=G2frame.dataDisplay,label='Use for all new images?')
877	dataSizer.Add(setDefault,0,WACV)
878	setDefault.Bind(wx.EVT_CHECKBOX, OnSetDefault)
879	setDefault.SetValue(data['setDefault'])
880	centerAzm = wx.CheckBox(parent=G2frame.dataDisplay,label='Azimuth at bin center?')
881	dataSizer.Add(centerAzm,0,WACV)
882	centerAzm.Bind(wx.EVT_CHECKBOX, OnCenterAzm)
883	centerAzm.SetValue(data['centerAzm'])
884	return dataSizer
885
886	def BackSizer():
887
888	def OnBackImage(event):
889	data['background image'][0] = backImage.GetValue()
890	G2frame.ImageZ = GetImageZ(G2frame,data)
891	ResetThresholds()
892	G2plt.PlotExposedImage(G2frame,event=event)
893
894	def OnDarkImage(event):
895	data['dark image'][0] = darkImage.GetValue()
896	G2frame.ImageZ = GetImageZ(G2frame,data)
897	ResetThresholds()
898	G2plt.PlotExposedImage(G2frame,event=event)
899
900	def OnFlatBkg(event):
901	oldFlat = data.get('Flat Bkg',0.)
902	try:
903	value = float(flatbkg.GetValue())
904	data['Flat Bkg'] = value
905	except ValueError:
906	pass
907	flatbkg.SetValue("%.0f"%(data['Flat Bkg']))
908	G2frame.ImageZ += int(oldFlat-data['Flat Bkg'])
909	ResetThresholds()
910	G2plt.PlotExposedImage(G2frame,event=event)
911
912	def OnBackMult(event):
913	try:
914	mult = float(backMult.GetValue())
915	data['background image'][1] = mult
916	except ValueError:
917	pass
918	backMult.SetValue("%.3f" % (data['background image'][1])) #reset in case of error
919	G2frame.ImageZ = GetImageZ(G2frame,data)
920	ResetThresholds()
921	G2plt.PlotExposedImage(G2frame,event=event)
922
923	def OnDarkMult(event):
924	try:
925	mult = float(darkMult.GetValue())
926	data['dark image'][1] = mult
927	except ValueError:
928	pass
929	darkMult.SetValue("%.3f" % (data['dark image'][1])) #reset in case of error
930	G2frame.ImageZ = GetImageZ(G2frame,data)
931	ResetThresholds()
932	G2plt.PlotExposedImage(G2frame,event=event)
933
934	backSizer = wx.FlexGridSizer(0,6,5,5)
935
936	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Dark image'),0,WACV)
937	Choices = ['',]+G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
938	Source = G2frame.PatternTree.GetItemText(G2frame.Image)
939	Choices.pop(Choices.index(Source))
940	darkImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['dark image'][0],choices=Choices,
941	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
942	darkImage.Bind(wx.EVT_COMBOBOX,OnDarkImage)
943	backSizer.Add(darkImage)
944	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,WACV)
945	darkMult = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (data['dark image'][1])),
946	style=wx.TE_PROCESS_ENTER)
947	darkMult.Bind(wx.EVT_TEXT_ENTER,OnDarkMult)
948	darkMult.Bind(wx.EVT_KILL_FOCUS,OnDarkMult)
949	backSizer.Add(darkMult,0,WACV)
950	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Flat Bkg: '),0,WACV)
951	flatbkg = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.0f" % (data['Flat Bkg'])),
952	style=wx.TE_PROCESS_ENTER)
953	flatbkg.Bind(wx.EVT_TEXT_ENTER,OnFlatBkg)
954	flatbkg.Bind(wx.EVT_KILL_FOCUS,OnFlatBkg)
955	backSizer.Add(flatbkg,0,WACV)
956
957	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' Background image'),0,WACV)
958	backImage = wx.ComboBox(parent=G2frame.dataDisplay,value=data['background image'][0],choices=Choices,
959	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
960	backImage.Bind(wx.EVT_COMBOBOX,OnBackImage)
961	backSizer.Add(backImage)
962	backSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,' multiplier'),0,WACV)
963	backMult = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (data['background image'][1])),
964	style=wx.TE_PROCESS_ENTER)
965	backMult.Bind(wx.EVT_TEXT_ENTER,OnBackMult)
966	backMult.Bind(wx.EVT_KILL_FOCUS,OnBackMult)
967	backSizer.Add(backMult,0,WACV)
968	return backSizer
969
970	def CalibSizer():
971
972	def OnNewCalibrant(event):
973	data['calibrant'] = calSel.GetValue().strip()
974	if data['calibrant']:
975	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=True)
976	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMCALIBRATE,enable=True)
977	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBALL,enable=True)
978	data['calibskip'] = calFile.Calibrants[data['calibrant']][3]
979	limits = calFile.Calibrants[data['calibrant']][4]
980	data['calibdmin'],data['pixLimit'],data['cutoff'] = limits
981	pixLimit.SetValue(str(limits[1]))
982	cutOff.SetValue('%.1f'%(limits[2]))
983	calibSkip.SetValue(str(data['calibskip']))
984	calibDmin.SetValue('%.1f'%(limits[0]))
985	else:
986	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=False)
987	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMCALIBRATE,enable=False)
988	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBALL,enable=False)
989	def OnCalibSkip(event):
990	data['calibskip'] = int(calibSkip.GetValue())
991
992	def OnCalibDmin(event):
993	try:
994	dmin = float(calibDmin.GetValue())
995	if dmin < 0.25:
996	raise ValueError
997	data['calibdmin'] = dmin
998	except ValueError:
999	pass
1000	calibDmin.SetValue("%.2f"%(data['calibdmin'])) #reset in case of error
1001
1002	def OnCutOff(event):
1003	try:
1004	cutoff = float(cutOff.GetValue())
1005	if cutoff < 0.1:
1006	raise ValueError
1007	data['cutoff'] = cutoff
1008	except ValueError:
1009	pass
1010	cutOff.SetValue("%.1f"%(data['cutoff'])) #reset in case of error
1011
1012	def OnPixLimit(event):
1013	data['pixLimit'] = int(pixLimit.GetValue())
1014
1015	def OnSetRings(event):
1016	if data['setRings']:
1017	data['setRings'] = False
1018	else:
1019	data['setRings'] = True
1020	G2plt.PlotExposedImage(G2frame,event=event)
1021
1022	calibSizer = wx.FlexGridSizer(0,3,5,5)
1023	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
1024	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibrant '),0,WACV)
1025	calSel = wx.ComboBox(parent=G2frame.dataDisplay,value=data['calibrant'],choices=calList,
1026	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
1027	calSel.Bind(wx.EVT_COMBOBOX, OnNewCalibrant)
1028	comboSizer.Add(calSel,0,WACV)
1029	calibSizer.Add(comboSizer,0)
1030
1031	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
1032	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calib lines to skip '),0,WACV)
1033	calibSkip = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['calibskip']),choices=[str(i) for i in range(25)],
1034	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
1035	calibSkip.Bind(wx.EVT_COMBOBOX, OnCalibSkip)
1036	comboSizer.Add(calibSkip,0,WACV)
1037	calibSizer.Add(comboSizer,0)
1038
1039	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
1040	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min calib d-spacing '),0,WACV)
1041	calibDmin = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f" % (data['calibdmin'])),
1042	style=wx.TE_PROCESS_ENTER)
1043	calibDmin.Bind(wx.EVT_TEXT_ENTER,OnCalibDmin)
1044	calibDmin.Bind(wx.EVT_KILL_FOCUS,OnCalibDmin)
1045	comboSizer.Add(calibDmin,0,WACV)
1046	calibSizer.Add(comboSizer,0)
1047
1048	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
1049	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Min ring I/Ib '),0,WACV)
1050	cutOff = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.1f" % (data['cutoff'])),
1051	style=wx.TE_PROCESS_ENTER)
1052	cutOff.Bind(wx.EVT_TEXT_ENTER,OnCutOff)
1053	cutOff.Bind(wx.EVT_KILL_FOCUS,OnCutOff)
1054	comboSizer.Add(cutOff,0,WACV)
1055	calibSizer.Add(comboSizer,0)
1056
1057	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
1058	comboSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Pixel search range '),0,WACV)
1059	pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(data['pixLimit']),choices=['1','2','5','10','15','20'],
1060	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
1061	pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
1062	comboSizer.Add(pixLimit,0,WACV)
1063	calibSizer.Add(comboSizer,0)
1064
1065	comboSizer = wx.BoxSizer(wx.HORIZONTAL)
1066	setRings = wx.CheckBox(parent=G2frame.dataDisplay,label='Show ring picks?')
1067	comboSizer.Add(setRings,0)
1068	setRings.Bind(wx.EVT_CHECKBOX, OnSetRings)
1069	setRings.SetValue(data['setRings'])
1070	calibSizer.Add(comboSizer,0)
1071	return calibSizer
1072
1073	def GonioSizer():
1074
1075	ValObj = {}
1076
1077	def OnGonioAngle(event):
1078	Obj = event.GetEventObject()
1079	item = ValObj[Obj.GetId()]
1080	try:
1081	value = float(Obj.GetValue())
1082	except ValueError:
1083	value = data['GonioAngles'][item]
1084	data['GonioAngles'][item] = value
1085	Obj.SetValue('%8.2f'%(value))
1086
1087	def OnGlobalEdit(event):
1088	Names = []
1089	Items = []
1090	if G2frame.PatternTree.GetCount():
1091	id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
1092	while id:
1093	name = G2frame.PatternTree.GetItemText(id)
1094	if 'IMG' in name:
1095	ctrls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'Image Controls'))
1096	Names.append(name)
1097	Items.append(ctrls['GonioAngles'])
1098	id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
1099	if len(Names) == 1:
1100	G2frame.ErrorDialog('Nothing for global editing','There must be more than one "IMG" pattern')
1101	return
1102	dlg = G2G.G2HistoDataDialog(G2frame,' Edit sample goniometer data:',
1103	'Edit data',['Omega','Chi','Phi'],['%.2f','%.2f','%.2f'],Names,Items)
1104	try:
1105	if dlg.ShowModal() == wx.ID_OK:
1106	result = dlg.GetData()
1107	id, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
1108	while id:
1109	name = G2frame.PatternTree.GetItemText(id)
1110	if 'IMG' in name:
1111	ctrls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id,'Image Controls'))
1112	vals = Items[Names.index(name)]
1113	ctrls['GonioAngles'] = vals
1114	# G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,id, 'Image Controls'),ctrls)
1115	id, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
1116	finally:
1117	dlg.Destroy()
1118	G2frame.PatternTree.SelectItem(G2frame.PickId)
1119
1120	gonioSizer = wx.BoxSizer(wx.HORIZONTAL)
1121	names = ['Omega','Chi','Phi']
1122	gonioSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,'Sample goniometer angles: '),0,WACV)
1123	for i,name in enumerate(names):
1124	gonioSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,name),0,WACV)
1125	angle = wx.TextCtrl(G2frame.dataDisplay,-1,value='%8.2f'%(data['GonioAngles'][i]),
1126	style=wx.TE_PROCESS_ENTER)
1127	angle.Bind(wx.EVT_TEXT_ENTER,OnGonioAngle)
1128	angle.Bind(wx.EVT_KILL_FOCUS,OnGonioAngle)
1129	ValObj[angle.GetId()] = i
1130	gonioSizer.Add(angle,0,WACV)
1131	globEdit = wx.Button(G2frame.dataDisplay,-1,'Global edit')
1132	globEdit.Bind(wx.EVT_BUTTON,OnGlobalEdit)
1133	gonioSizer.Add(globEdit,0,WACV)
1134	return gonioSizer
1135
1136	# Image Controls main code
1137
1138	#fix for old files:
1139	if 'azmthOff' not in data:
1140	data['azmthOff'] = 0.0
1141	if 'background image' not in data:
1142	data['background image'] = ['',-1.0]
1143	if 'dark image' not in data:
1144	data['dark image'] = ['',-1.0]
1145	if 'centerAzm' not in data:
1146	data['centerAzm'] = False
1147	if 'Oblique' not in data:
1148	data['Oblique'] = [0.5,False]
1149	if 'PolaVal' not in data:
1150	data['PolaVal'] = [0.99,False]
1151	#end fix
1152
1153	if IntegrateOnly:
1154	OnIntegrate(None)
1155	return
1156
1157	colorList = sorted([m for m in mpl.cm.datad.keys() if not m.endswith("_r")],key=lambda s: s.lower())
1158	calList = sorted([m for m in calFile.Calibrants.keys()],key=lambda s: s.lower())
1159	typeList = ['PWDR - powder diffraction data','SASD - small angle scattering data',
1160	'REFL - reflectometry data']
1161	if not data.get('type'): #patch for old project files
1162	data['type'] = 'PWDR'
1163	typeDict = {'PWDR':typeList[0],'SASD':typeList[1],'REFL':typeList[2]}
1164	if G2frame.dataDisplay:
1165	G2frame.dataDisplay.Destroy()
1166	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.ImageMenu)
1167	if not G2frame.dataFrame.GetStatusBar():
1168	G2frame.dataFrame.CreateStatusBar()
1169	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCalibrate, id=G2gd.wxID_IMCALIBRATE)
1170	G2frame.dataFrame.Bind(wx.EVT_MENU, OnRecalibrate, id=G2gd.wxID_IMRECALIBRATE)
1171	G2frame.dataFrame.Bind(wx.EVT_MENU, OnRecalibAll, id=G2gd.wxID_IMRECALIBALL)
1172	G2frame.dataFrame.Bind(wx.EVT_MENU, OnClearCalib, id=G2gd.wxID_IMCLEARCALIB)
1173	if data.get('calibrant'):
1174	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=True)
1175	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMCALIBRATE,enable=True)
1176	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBALL,enable=True)
1177	else:
1178	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBRATE,enable=False)
1179	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMCALIBRATE,enable=False)
1180	G2frame.dataFrame.ImageEdit.Enable(id=G2gd.wxID_IMRECALIBALL,enable=False)
1181	G2frame.dataFrame.Bind(wx.EVT_MENU, OnIntegrate, id=G2gd.wxID_IMINTEGRATE)
1182	G2frame.dataFrame.Bind(wx.EVT_MENU, OnIntegrateAll, id=G2gd.wxID_INTEGRATEALL)
1183	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyControls, id=G2gd.wxID_IMCOPYCONTROLS)
1184	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopySelected, id=G2gd.wxID_IMCOPYSELECTED)
1185	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveControls, id=G2gd.wxID_IMSAVECONTROLS)
1186	G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadControls, id=G2gd.wxID_IMLOADCONTROLS)
1187	def OnDestroy(event):
1188	G2frame.autoIntFrame = None
1189	def OnAutoInt(event):
1190	if G2frame.autoIntFrame: # ensure only one open at a time
1191	G2frame.autoIntFrame.Raise()
1192	return
1193	G2frame.autoIntFrame = AutoIntFrame(G2frame,PollTime=10.0)
1194	G2frame.autoIntFrame.Bind(wx.EVT_WINDOW_DESTROY,OnDestroy) # clean up name on window close
1195	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAutoInt, id=G2gd.wxID_IMAUTOINTEG)
1196	G2frame.dataDisplay = wx.Panel(G2frame.dataFrame)
1197
1198	mainSizer = wx.BoxSizer(wx.VERTICAL)
1199	mainSizer.Add((5,10),0)
1200	mainSizer.Add(ComboSizer(),0,wx.ALIGN_LEFT)
1201	mainSizer.Add((5,5),0)
1202	MaxSizer = MaxSizer() #keep this so it can be changed in BackSizer
1203	mainSizer.Add(MaxSizer,0,wx.ALIGN_LEFT\|wx.EXPAND)
1204
1205	mainSizer.Add((5,5),0)
1206	DataSizer = wx.FlexGridSizer(0,2,5,0)
1207	DataSizer.Add(CalibCoeffSizer(),0)
1208	DataSizer.Add(IntegrateSizer(),0)
1209	mainSizer.Add(DataSizer,0)
1210	mainSizer.Add((5,5),0)
1211	mainSizer.Add(BackSizer(),0)
1212	mainSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Calibration controls:'),0,WACV)
1213	mainSizer.Add((5,5),0)
1214	mainSizer.Add(CalibSizer(),0,WACV)
1215	mainSizer.Add((5,5),0)
1216	mainSizer.Add(GonioSizer(),0,WACV)
1217
1218	mainSizer.Layout()
1219	G2frame.dataDisplay.SetSizer(mainSizer)
1220	fitSize = mainSizer.Fit(G2frame.dataFrame)
1221	G2frame.dataFrame.setSizePosLeft(fitSize)
1222	G2frame.dataDisplay.SetSize(fitSize)
1223
1224	################################################################################
1225	##### Masks
1226	################################################################################
1227	def CleanupMasks(data):
1228	'''If a mask creation is not completed, an empty mask entry is created in the
1229	masks array. This cleans them out. It is called when the masks page is first loaded
1230	and before saving them or after reading them in. This should also probably be done
1231	before they are used for integration.
1232	'''
1233	for key in ['Points','Rings','Arcs','Polygons']:
1234	data[key] = data.get(key,[])
1235	l1 = len(data[key])
1236	data[key] = [i for i in data[key] if i]
1237	l2 = len(data[key])
1238	if GSASIIpath.GetConfigValue('debug') and l1 != l2:
1239	print 'Mask Cleanup:',key,'was',l1,'entries','now',l2
1240
1241	def UpdateMasks(G2frame,data):
1242	'''Shows and handles the controls on the "Masks" data tree entry
1243	'''
1244
1245	def OnTextMsg(event):
1246	Obj = event.GetEventObject()
1247	Obj.SetToolTipString('Drag this mask on 2D Powder Image with mouse to change ')
1248
1249	def Replot(args,*kwargs):
1250	wx.CallAfter(G2plt.PlotExposedImage,G2frame)
1251
1252	def onDeleteMask(event):
1253	Obj = event.GetEventObject()
1254	typ = Obj.locationcode.split('+')[1]
1255	num = int(Obj.locationcode.split('+')[2])
1256	del(data[typ][num])
1257	wx.CallAfter(UpdateMasks,G2frame,data)
1258	G2plt.PlotExposedImage(G2frame,event=event)
1259
1260	def onDeleteFrame(event):
1261	data['Frames'] = []
1262	wx.CallAfter(UpdateMasks,G2frame,data)
1263	G2plt.PlotExposedImage(G2frame,event=event)
1264
1265	def OnCopyMask(event):
1266	Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
1267	if len(Names) == 1:
1268	G2frame.ErrorDialog('Nothing to copy masks to','There must be more than one "IMG" pattern')
1269	return
1270	Source = G2frame.PatternTree.GetItemText(G2frame.Image)
1271	Names.pop(Names.index(Source))
1272	Data = copy.deepcopy(data)
1273	Thresh = Data.pop('Thresholds') # & remove it as well
1274	dlg = G2G.G2MultiChoiceDialog(G2frame,'Copy mask data','Copy masks from '+Source+' to:',Names)
1275	try:
1276	if dlg.ShowModal() == wx.ID_OK:
1277	items = dlg.GetSelections()
1278	for item in items:
1279	name = Names[item]
1280	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
1281	MId = G2gd.GetPatternTreeItemId(G2frame,Id,'Masks')
1282	Mask = copy.deepcopy(G2frame.PatternTree.GetItemPyData(MId))
1283	Mask.update(Data)
1284	Mask['Thresholds'][1][0] = Thresh[1][0] #copy only lower threshold
1285	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Masks'),Mask)
1286	finally:
1287	dlg.Destroy()
1288
1289	def OnSaveMask(event):
1290	CleanupMasks(data)
1291	pth = G2G.GetExportPath(G2frame)
1292	dlg = wx.FileDialog(G2frame, 'Choose image mask file', pth, '',
1293	'image mask files (.immask)\|.immask',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
1294	try:
1295	if dlg.ShowModal() == wx.ID_OK:
1296	filename = dlg.GetPath()
1297	filename = os.path.splitext(filename)[0]+'.immask'
1298	File = open(filename,'w')
1299	keys = ['Points','Rings','Arcs','Polygons','Frames','Thresholds']
1300	for key in keys:
1301	File.write(key+':'+str(data[key])+'\n')
1302	File.close()
1303	finally:
1304	dlg.Destroy()
1305
1306	def OnLoadMask(event):
1307	if event.Id == G2gd.wxID_MASKLOADNOT:
1308	ignoreThreshold = True
1309	else:
1310	ignoreThreshold = False
1311	pth = G2G.GetImportPath(G2frame)
1312	if not pth: pth = '.'
1313	dlg = wx.FileDialog(G2frame, 'Choose image mask file', pth, '',
1314	'image mask files (.immask)\|.immask',wx.OPEN)
1315	try:
1316	if dlg.ShowModal() == wx.ID_OK:
1317	filename = dlg.GetPath()
1318	File = open(filename,'r')
1319	save = {}
1320	oldThreshold = data['Thresholds'][0]
1321	S = File.readline()
1322	while S:
1323	if S[0] == '#':
1324	S = File.readline()
1325	continue
1326	[key,val] = S[:-1].split(':')
1327	if key in ['Points','Rings','Arcs','Polygons','Frames','Thresholds']:
1328	if ignoreThreshold and key == 'Thresholds':
1329	S = File.readline()
1330	continue
1331	save[key] = eval(val)
1332	if key == 'Thresholds':
1333	save[key][0] = oldThreshold
1334	save[key][1][1] = min(oldThreshold[1],save[key][1][1])
1335	S = File.readline()
1336	File.close()
1337	data.update(save)
1338	CleanupMasks(data)
1339	wx.CallAfter(UpdateMasks,G2frame,data)
1340	G2plt.PlotExposedImage(G2frame,event=event)
1341	finally:
1342	dlg.Destroy()
1343
1344	def OnNewSpotMask(event):
1345	'Start a new spot mask'
1346	G2frame.MaskKey = 's'
1347	G2plt.OnStartMask(G2frame)
1348
1349	def OnNewArcMask(event):
1350	'Start a new arc mask'
1351	G2frame.MaskKey = 'a'
1352	G2plt.OnStartMask(G2frame)
1353
1354	def OnNewRingMask(event):
1355	'Start a new ring mask'
1356	G2frame.MaskKey = 'r'
1357	G2plt.OnStartMask(G2frame)
1358
1359	def OnNewPolyMask(event):
1360	'Start a new polygon mask'
1361	G2frame.MaskKey = 'p'
1362	G2plt.OnStartMask(G2frame)
1363
1364	def OnNewFrameMask(event):
1365	'Start a new Frame mask'
1366	G2frame.MaskKey = 'f'
1367	G2plt.OnStartMask(G2frame)
1368
1369	startScroll = None
1370	if G2frame.dataDisplay:
1371	startScroll = G2frame.dataDisplay.GetScrollPos(wx.VERTICAL) # save scroll position
1372	G2frame.dataDisplay.Destroy()
1373	else:
1374	CleanupMasks(data) # posting page for 1st time; clean out anything unfinished
1375	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.MaskMenu)
1376	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyMask, id=G2gd.wxID_MASKCOPY)
1377	G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadMask, id=G2gd.wxID_MASKLOAD)
1378	G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadMask, id=G2gd.wxID_MASKLOADNOT)
1379	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveMask, id=G2gd.wxID_MASKSAVE)
1380	G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewSpotMask, id=G2gd.wxID_NEWMASKSPOT)
1381	G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewArcMask, id=G2gd.wxID_NEWMASKARC)
1382	G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewRingMask, id=G2gd.wxID_NEWMASKRING)
1383	G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewPolyMask, id=G2gd.wxID_NEWMASKPOLY)
1384	G2frame.dataFrame.Bind(wx.EVT_MENU, OnNewFrameMask, id=G2gd.wxID_NEWMASKFRAME)
1385	if not G2frame.dataFrame.GetStatusBar():
1386	Status = G2frame.dataFrame.CreateStatusBar()
1387	if G2frame.MaskKey == 'f':
1388	G2frame.dataFrame.GetStatusBar().SetStatusText('Frame mask active - LB pick next point, RB close polygon')
1389	elif G2frame.MaskKey == 'p':
1390	G2frame.dataFrame.GetStatusBar().SetStatusText('Polygon mask active - LB pick next point, RB close polygon')
1391	elif G2frame.MaskKey == 's':
1392	G2frame.dataFrame.GetStatusBar().SetStatusText('Spot mask active - LB pick spot location')
1393	elif G2frame.MaskKey == 'a':
1394	G2frame.dataFrame.GetStatusBar().SetStatusText('Arc mask active - LB pick arc location')
1395	elif G2frame.MaskKey == 'r':
1396	G2frame.dataFrame.GetStatusBar().SetStatusText('Ring mask active - LB pick ring location')
1397	else:
1398	G2frame.dataFrame.GetStatusBar().SetStatusText("To add mask: press a,r,s,p or f on 2D image for arc/ring/spot/polygon/frame")
1399	G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
1400	mainSizer = wx.BoxSizer(wx.VERTICAL)
1401	mainSizer.Add((5,10),0)
1402
1403	thresh = data['Thresholds'] #min/max intensity range
1404	Spots = data['Points'] #x,y,radius in mm
1405	Rings = data['Rings'] #radius, thickness
1406	Polygons = data['Polygons'] #3+ x,y pairs
1407	if 'Frames' not in data:
1408	data['Frames'] = []
1409	frame = data['Frames'] #3+ x,y pairs
1410	Arcs = data['Arcs'] #radius, start/end azimuth, thickness
1411
1412	littleSizer = wx.FlexGridSizer(0,3,0,5)
1413	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper limits '),0,WACV)
1414	Text = wx.TextCtrl(G2frame.dataDisplay,value=str(thresh[0][0]),style=wx.TE_READONLY)
1415	littleSizer.Add(Text,0,WACV)
1416	Text.SetBackgroundColour(VERY_LIGHT_GREY)
1417	Text = wx.TextCtrl(G2frame.dataDisplay,value=str(thresh[0][1]),style=wx.TE_READONLY)
1418	littleSizer.Add(Text,0,WACV)
1419	Text.SetBackgroundColour(VERY_LIGHT_GREY)
1420	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' Lower/Upper thresholds '),0,WACV)
1421	lowerThreshold = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=thresh[1],key=0,
1422	min=thresh[0][0],OnLeave=Replot,typeHint=int)
1423	littleSizer.Add(lowerThreshold,0,WACV)
1424	upperThreshold = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=thresh[1],key=1,
1425	max=thresh[0][1],OnLeave=Replot,typeHint=int)
1426	littleSizer.Add(upperThreshold,0,WACV)
1427	mainSizer.Add(littleSizer,0,)
1428	if Spots:
1429	lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Spot masks')
1430	lbl.SetBackgroundColour(wx.Colour(200,200,210))
1431	mainSizer.Add(lbl,0,wx.EXPAND\|wx.ALIGN_CENTER,0)
1432	littleSizer = wx.FlexGridSizer(0,3,0,5)
1433	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' position, mm'),0,WACV)
1434	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' diameter, mm'),0,WACV)
1435	littleSizer.Add((5,0),0)
1436	for i in range(len(Spots)):
1437	if Spots[i]:
1438	x,y,d = Spots[i]
1439	spotText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.2f,%.2f" % (x,y)),
1440	style=wx.TE_READONLY)
1441	spotText.SetBackgroundColour(VERY_LIGHT_GREY)
1442	littleSizer.Add(spotText,0,WACV)
1443	spotText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
1444	spotDiameter = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Spots[i],key=2,
1445	max=100.,OnLeave=Replot,nDig=[8,2])
1446	littleSizer.Add(spotDiameter,0,WACV)
1447	spotDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
1448	locationcode='Delete+Points+'+str(i),
1449	handler=onDeleteMask)
1450	littleSizer.Add(spotDelete,0,WACV)
1451	mainSizer.Add(littleSizer,0,)
1452	if Rings:
1453	lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Ring masks')
1454	lbl.SetBackgroundColour(wx.Colour(200,200,210))
1455	mainSizer.Add(lbl,0,wx.EXPAND\|wx.ALIGN_CENTER,0)
1456	littleSizer = wx.FlexGridSizer(0,3,0,5)
1457	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,WACV)
1458	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,WACV)
1459	littleSizer.Add((5,0),0)
1460	for i in range(len(Rings)):
1461	if Rings[i]:
1462	ringText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (Rings[i][0])),
1463	style=wx.TE_READONLY)
1464	ringText.SetBackgroundColour(VERY_LIGHT_GREY)
1465	ringText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
1466	littleSizer.Add(ringText,0,WACV)
1467	ringThick = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Rings[i],key=1,
1468	min=0.001,max=1.,OnLeave=Replot,nDig=[8,3])
1469	littleSizer.Add(ringThick,0,WACV)
1470	ringDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
1471	locationcode='Delete+Rings+'+str(i),
1472	handler=onDeleteMask)
1473	littleSizer.Add(ringDelete,0,WACV)
1474	mainSizer.Add(littleSizer,0,)
1475	if Arcs:
1476	lbl = wx.StaticText(parent=G2frame.dataDisplay,label=' Arc masks')
1477	lbl.SetBackgroundColour(wx.Colour(200,200,210))
1478	mainSizer.Add(lbl,0,wx.EXPAND\|wx.ALIGN_CENTER,0)
1479	littleSizer = wx.FlexGridSizer(0,4,0,5)
1480	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' 2-theta,deg'),0,WACV)
1481	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' azimuth, deg'),0,WACV)
1482	littleSizer.Add(wx.StaticText(parent=G2frame.dataDisplay,label=' thickness, deg'),0,WACV)
1483	littleSizer.Add((5,0),0)
1484	for i in range(len(Arcs)):
1485	if Arcs[i]:
1486	tth,azimuth,thick = Arcs[i]
1487	arcText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.3f" % (tth)),
1488	style=wx.TE_READONLY)
1489	arcText.SetBackgroundColour(VERY_LIGHT_GREY)
1490	arcText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
1491	littleSizer.Add(arcText,0,WACV)
1492	azmText = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%d,%d" % (azimuth[0],azimuth[1])),
1493	style=wx.TE_READONLY)
1494	azmText.SetBackgroundColour(VERY_LIGHT_GREY)
1495	azmText.Bind(wx.EVT_ENTER_WINDOW,OnTextMsg)
1496	littleSizer.Add(azmText,0,WACV)
1497	arcThick = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,loc=Arcs[i],key=2,
1498	min=0.001,max=20.,OnLeave=Replot,nDig=[8,3])
1499	littleSizer.Add(arcThick,0,WACV)
1500	arcDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
1501	locationcode='Delete+Arcs+'+str(i),
1502	handler=onDeleteMask)
1503	littleSizer.Add(arcDelete,0,WACV)
1504	mainSizer.Add(littleSizer,0,)
1505	if Polygons:
1506	lbl = wx.StaticText(parent=G2frame.dataDisplay,
1507	label=' Polygon masks (on plot RB vertex drag to move,\nLB vertex drag to insert)')
1508	lbl.SetBackgroundColour(wx.Colour(200,200,210))
1509	mainSizer.Add(lbl,0,wx.EXPAND\|wx.ALIGN_CENTER,0)
1510	littleSizer = wx.FlexGridSizer(0,2,0,5)
1511	for i in range(len(Polygons)):
1512	if Polygons[i]:
1513	polyList = []
1514	for x,y in Polygons[i]:
1515	polyList.append("%.2f, %.2f"%(x,y))
1516	polyText = wx.ComboBox(G2frame.dataDisplay,value=polyList[0],choices=polyList,style=wx.CB_READONLY)
1517	littleSizer.Add(polyText,0,WACV)
1518	polyDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
1519	locationcode='Delete+Polygons+'+str(i),
1520	handler=onDeleteMask)
1521	littleSizer.Add(polyDelete,0,WACV)
1522	mainSizer.Add(littleSizer,0,)
1523	if frame:
1524	lbl = wx.StaticText(parent=G2frame.dataDisplay,
1525	label=' Frame mask (on plot RB vertex drag to move,LB vertex drag to insert)')
1526	lbl.SetBackgroundColour(wx.Colour(200,200,210))
1527	mainSizer.Add(lbl,0,wx.EXPAND\|wx.ALIGN_CENTER,0)
1528	littleSizer = wx.FlexGridSizer(0,2,0,5)
1529	frameList = []
1530	for x,y in frame:
1531	frameList.append("%.2f, %.2f"%(x,y))
1532	frameText = wx.ComboBox(G2frame.dataDisplay,value=frameList[0],choices=frameList,style=wx.CB_READONLY)
1533	littleSizer.Add(frameText,0,WACV)
1534	frameDelete = G2G.G2LoggedButton(G2frame.dataDisplay,label='delete?',
1535	locationcode='Delete+Frame',
1536	handler=onDeleteFrame)
1537	littleSizer.Add(frameDelete,0,WACV)
1538	mainSizer.Add(littleSizer,0,)
1539	mainSizer.Layout()
1540	G2frame.dataDisplay.SetSizer(mainSizer)
1541	G2frame.dataDisplay.SetSize(mainSizer.Fit(G2frame.dataFrame))
1542	G2frame.dataDisplay.SetupScrolling()
1543	Size = mainSizer.Fit(G2frame.dataFrame)
1544	Size[0] += 50 # room for scrollbar & status msg
1545	Size[1] = min(Size[1],500)
1546	G2frame.dataDisplay.SetSize(Size)
1547	G2frame.dataFrame.setSizePosLeft(Size)
1548	wx.Yield()
1549	if startScroll: # reset scroll to saved position
1550	G2frame.dataDisplay.Scroll(0,startScroll) # set to saved scroll position
1551	wx.Yield()
1552
1553	################################################################################
1554	##### Stress/Strain
1555	################################################################################
1556
1557	def UpdateStressStrain(G2frame,data):
1558	'''Shows and handles the controls on the "Stress/Strain"
1559	data tree entry
1560	'''
1561
1562	def OnAppendDzero(event):
1563	data['d-zero'].append({'Dset':1.0,'Dcalc':0.0,'pixLimit':10,'cutoff':1.0,
1564	'ImxyObs':[[],[]],'ImtaObs':[[],[]],'ImtaCalc':[[],[]],'Emat':[1.0,1.0,1.0]})
1565	UpdateStressStrain(G2frame,data)
1566
1567	def OnUpdateDzero(event):
1568	for item in data['d-zero']:
1569	if item['Dcalc']: #skip unrefined ones
1570	item['Dset'] = item['Dcalc']
1571	UpdateStressStrain(G2frame,data)
1572
1573	def OnCopyStrSta(event):
1574	Names = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
1575	if len(Names) == 1:
1576	G2frame.ErrorDialog('Nothing to copy controls to','There must be more than one "IMG" pattern')
1577	return
1578	Source = G2frame.PatternTree.GetItemText(G2frame.Image)
1579	Names.pop(Names.index(Source))
1580	# GSASIIpath.IPyBreak()
1581	dlg = G2G.G2MultiChoiceDialog(G2frame,'Copy stress/strain controls','Copy controls from '+Source+' to:',Names)
1582	try:
1583	if dlg.ShowModal() == wx.ID_OK:
1584	items = dlg.GetSelections()
1585	for item in items:
1586	name = Names[item]
1587	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
1588	CId = G2gd.GetPatternTreeItemId(G2frame,Id,'Stress/Strain')
1589	oldData = G2frame.PatternTree.GetItemPyData(CId)
1590	load = oldData.get('Sample load',0.0)
1591	Data = copy.deepcopy(data)
1592	Data['Sample load'] = load
1593	G2frame.PatternTree.SetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Stress/Strain'),Data)
1594	finally:
1595	dlg.Destroy()
1596	G2frame.PatternTree.SelectItem(G2frame.PickId)
1597
1598	def OnLoadStrSta(event):
1599	pth = G2G.GetImportPath(G2frame)
1600	if not pth: pth = '.'
1601	dlg = wx.FileDialog(G2frame, 'Choose stress/strain file', pth, '',
1602	'image control files (.strsta)\|.strsta',wx.OPEN)
1603	try:
1604	if dlg.ShowModal() == wx.ID_OK:
1605	filename = dlg.GetPath()
1606	File = open(filename,'r')
1607	S = File.read()
1608	data = eval(S)
1609	Controls = G2frame.PatternTree.GetItemPyData(
1610	G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
1611	G2img.FitStrSta(G2frame.ImageZ,data,Controls)
1612	UpdateStressStrain(G2frame,data)
1613	G2plt.PlotExposedImage(G2frame,event=event)
1614	G2plt.PlotStrain(G2frame,data,newPlot=True)
1615	File.close()
1616	finally:
1617	dlg.Destroy()
1618
1619	def OnSaveStrSta(event):
1620	pth = G2G.GetExportPath(G2frame)
1621	dlg = wx.FileDialog(G2frame, 'Choose stress/strain file', pth, '',
1622	'image control files (.strsta)\|.strsta',wx.FD_SAVE\|wx.FD_OVERWRITE_PROMPT)
1623	try:
1624	if dlg.ShowModal() == wx.ID_OK:
1625	filename = dlg.GetPath()
1626	File = open(filename,'w')
1627	save = {}
1628	keys = ['Type','Sample phi','Sample z','Sample load']
1629	keys2 = ['Dset','Dcalc','pixLimit','cutoff','Emat']
1630	File.write('{\n\t')
1631	for key in keys:
1632	if key in 'Type':
1633	File.write("'"+key+"':'"+data[key]+"',")
1634	else:
1635	File.write("'"+key+"':"+str(data[key])+',')
1636	File.write('\n\t'+"'d-zero':[\n")
1637	for data2 in data['d-zero']:
1638	File.write('\t\t{')
1639	for key in keys2:
1640	File.write("'"+key+"':"+str(data2[key])+',')
1641	File.write("'ImxyObs':[[],[]],'ImtaObs':[[],[]],'ImtaCalc':[[],[]]},\n")
1642	File.write('\t]\n}')
1643	File.close()
1644	finally:
1645	dlg.Destroy()
1646
1647	def OnStrStaSample(event):
1648	filename = ''
1649	pth = G2G.GetImportPath(G2frame)
1650	if not pth: pth = '.'
1651	dlg = wx.FileDialog(G2frame, 'Choose multihistogram metadata text file', pth, '',
1652	'metadata file (.)\|.',wx.OPEN)
1653	try:
1654	if dlg.ShowModal() == wx.ID_OK:
1655	filename = dlg.GetPath()
1656	File = open(filename,'r')
1657	S = File.readline()
1658	newItems = []
1659	itemNames = []
1660	Comments = []
1661	while S:
1662	if S[0] == '#':
1663	Comments.append(S)
1664	S = File.readline()
1665	continue
1666	S = S.replace(',',' ').replace('\t',' ')
1667	Stuff = S[:-1].split()
1668	itemNames.append(Stuff[0])
1669	newItems.append(Stuff[1:])
1670	S = File.readline()
1671	File.close()
1672	finally:
1673	dlg.Destroy()
1674	if not filename:
1675	G2frame.ErrorDialog('Nothing to do','No file selected')
1676	return
1677	dataDict = dict(zip(itemNames,newItems))
1678	ifany = False
1679	Names = [' ','Sample phi','Sample z','Sample load']
1680	dlg = G2G.G2ColumnIDDialog( G2frame,' Choose multihistogram metadata columns:',
1681	'Select columns',Comments,Names,np.array(newItems).T)
1682	try:
1683	if dlg.ShowModal() == wx.ID_OK:
1684	colNames,newData = dlg.GetSelection()
1685	dataDict = dict(zip(itemNames,newData.T))
1686	for item in colNames:
1687	if item != ' ':
1688	ifany = True
1689	finally:
1690	dlg.Destroy()
1691	if not ifany:
1692	G2frame.ErrorDialog('Nothing to do','No columns identified')
1693	return
1694	histList = []
1695	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
1696	while item:
1697	name = G2frame.PatternTree.GetItemText(item)
1698	if name.startswith('IMG'):
1699	histList.append(name)
1700	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
1701	colIds = {}
1702	for i,name in enumerate(colNames):
1703	if name != ' ':
1704	colIds[name] = i
1705	for hist in histList:
1706	name = hist.split()[1] #this is file name
1707	if name in dataDict:
1708	newItems = {}
1709	for item in colIds:
1710	newItems[item] = float(dataDict[name][colIds[item]])
1711	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,hist)
1712	stsrData = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id,'Stress/Strain'))
1713	stsrData.update(newItems)
1714	UpdateStressStrain(G2frame,data)
1715
1716	def OnFitStrSta(event):
1717	Controls = G2frame.PatternTree.GetItemPyData(
1718	G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
1719	G2img.FitStrSta(G2frame.ImageZ,data,Controls)
1720	print 'Strain fitting finished'
1721	UpdateStressStrain(G2frame,data)
1722	G2plt.PlotExposedImage(G2frame,event=event)
1723	G2plt.PlotStrain(G2frame,data,newPlot=True)
1724
1725	def OnFitAllStrSta(event):
1726	choices = G2gd.GetPatternTreeDataNames(G2frame,['IMG ',])
1727	sel = []
1728	dlg = G2G.G2MultiChoiceDialog(G2frame,'Stress/Strain fitting','Select images to fit:',choices)
1729	dlg.SetSelections(sel)
1730	names = []
1731	if dlg.ShowModal() == wx.ID_OK:
1732	for sel in dlg.GetSelections():
1733	names.append(choices[sel])
1734	dlg.Destroy()
1735	SeqResult = {}
1736	dlg = wx.ProgressDialog('Sequential IMG Strain fit','Data set name = '+names[0],len(names),
1737	style = wx.PD_ELAPSED_TIME\|wx.PD_AUTO_HIDE\|wx.PD_REMAINING_TIME\|wx.PD_CAN_ABORT)
1738	wx.BeginBusyCursor()
1739	goodnames = []
1740	try:
1741	for i,name in enumerate(names):
1742	print ' Sequential strain fit for ',name
1743	GoOn = dlg.Update(i,newmsg='Data set name = '+name)[0]
1744	if not GoOn:
1745	break
1746	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,name)
1747	G2frame.Image = Id
1748	Controls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Image Controls'))
1749	StaCtrls = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Stress/Strain'))
1750	if not len(StaCtrls['d-zero']):
1751	continue
1752	goodnames.append(name)
1753	id = G2gd.GetPatternTreeItemId(G2frame, G2frame.root, name)
1754	Npix,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(Id)
1755	image = GetImageZ(G2frame,Controls)
1756	G2img.FitStrSta(image,StaCtrls,Controls)
1757	G2plt.PlotStrain(G2frame,StaCtrls,newPlot=True)
1758	parmDict = {'Sample load':StaCtrls['Sample load'],}
1759	varyNames = ['e11','e12','e22']
1760	sig = []
1761	varyList = []
1762	variables = []
1763	for i,item in enumerate(StaCtrls['d-zero']):
1764	variables += item['Emat']
1765	sig += item['Esig']
1766	varylist = ['%d%s%s'%(i,';',Name) for Name in varyNames]
1767	varyList += varylist
1768	parmDict.update(dict(zip(varylist,item['Emat'])))
1769	parmDict['%d:Dcalc'%(i)] = item['Dcalc']
1770	SeqResult[name] = {'variables':variables,'varyList':varyList,'sig':sig,'Rvals':[],
1771	'covMatrix':np.eye(len(variables)),'title':name,'parmDict':parmDict}
1772	else:
1773	SeqResult['histNames'] = goodnames
1774	dlg.Destroy()
1775	print ' *** Sequential strain refinement successful ***'
1776	finally:
1777	wx.EndBusyCursor()
1778	Id = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Sequential results')
1779	if Id:
1780	G2frame.PatternTree.SetItemPyData(Id,SeqResult)
1781	else:
1782	Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text='Sequential results')
1783	G2frame.PatternTree.SetItemPyData(Id,SeqResult)
1784	G2frame.PatternTree.SelectItem(Id)
1785	print 'All images fitted'
1786
1787	def SamSizer():
1788
1789	def OnStrainType(event):
1790	data['Type'] = strType.GetValue()
1791
1792	def OnSamPhi(event):
1793	try:
1794	value = float(samPhi.GetValue())
1795	except ValueError:
1796	value = data['Sample phi']
1797	data['Sample phi'] = value
1798	samPhi.SetValue("%.3f" % (data['Sample phi']))
1799
1800	def OnSamZ(event):
1801	try:
1802	value = float(samZ.GetValue())
1803	except ValueError:
1804	value = data['Sample z']
1805	data['Sample z'] = value
1806	samZ.SetValue("%.3f" % (data['Sample z']))
1807
1808	def OnSamLoad(event):
1809	try:
1810	value = float(samLoad.GetValue())
1811	except ValueError:
1812	value = data['Sample load']
1813	data['Sample load'] = value
1814	samLoad.SetValue("%.3f" % (data['Sample load']))
1815
1816	samSizer = wx.BoxSizer(wx.HORIZONTAL)
1817	samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Strain type: '),0,WACV)
1818	strType = wx.ComboBox(G2frame.dataDisplay,value=data['Type'],choices=['True','Conventional'],
1819	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
1820	strType.SetValue(data['Type'])
1821	strType.Bind(wx.EVT_COMBOBOX, OnStrainType)
1822	samSizer.Add(strType,0,WACV)
1823
1824	samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample phi: '),0,WACV)
1825	samPhi = wx.TextCtrl(G2frame.dataDisplay,-1,value=("%.3f" % (data['Sample phi'])),
1826	style=wx.TE_PROCESS_ENTER)
1827	samSizer.Add(samPhi,0,WACV)
1828	samPhi.Bind(wx.EVT_TEXT_ENTER,OnSamPhi)
1829	samPhi.Bind(wx.EVT_KILL_FOCUS,OnSamPhi)
1830	samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample delta-z(mm): '),0,WACV)
1831	samZ = wx.TextCtrl(G2frame.dataDisplay,-1,value=("%.3f" % (data['Sample z'])),
1832	style=wx.TE_PROCESS_ENTER)
1833	samSizer.Add(samZ,0,WACV)
1834	samZ.Bind(wx.EVT_TEXT_ENTER,OnSamZ)
1835	samZ.Bind(wx.EVT_KILL_FOCUS,OnSamZ)
1836	samSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=' Sample load(MPa): '),0,WACV)
1837	samLoad = G2G.ValidatedTxtCtrl(G2frame.dataDisplay,data,'Sample load',
1838	nDig=[8,3],typeHint=float,)
1839	samSizer.Add(samLoad,0,WACV)
1840
1841	return samSizer
1842
1843	def DzeroSizer():
1844
1845	def OnDzero(event):
1846	Obj = event.GetEventObject()
1847	try:
1848	value = min(20.0,max(0.25,float(Obj.GetValue())))
1849	except ValueError:
1850	value = 1.0
1851	Obj.SetValue("%.5f"%(value))
1852	data['d-zero'][Indx[Obj.GetId()]]['Dset'] = value
1853	data['d-zero'] = G2mth.sortArray(data['d-zero'],'Dset',reverse=True)
1854	Ring,R = G2img.MakeStrStaRing(data['d-zero'][Indx[Obj.GetId()]],G2frame.ImageZ,Controls)
1855	if len(Ring):
1856	data['d-zero'][Indx[Obj.GetId()]].update(R)
1857	else:
1858	G2frame.ErrorDialog('Strain peak selection','WARNING - No points found for this ring selection')
1859
1860	UpdateStressStrain(G2frame,data)
1861	G2plt.PlotExposedImage(G2frame,event=event,newPlot=False)
1862	G2plt.PlotStrain(G2frame,data,newPlot=True)
1863
1864	def OnDeleteDzero(event):
1865	Obj = event.GetEventObject()
1866	del(data['d-zero'][delIndx.index(Obj)])
1867	UpdateStressStrain(G2frame,data)
1868	G2plt.PlotExposedImage(G2frame,event=event,newPlot=True)
1869	G2plt.PlotStrain(G2frame,data,newPlot=True)
1870
1871	def OnCutOff(event):
1872	Obj = event.GetEventObject()
1873	try:
1874	value = min(10.0,max(0.5,float(Obj.GetValue())))
1875	except ValueError:
1876	value = 1.0
1877	Obj.SetValue("%.1f"%(value))
1878	data['d-zero'][Indx[Obj.GetId()]]['cutoff'] = value
1879	Ring,R = G2img.MakeStrStaRing(data['d-zero'][Indx[Obj.GetId()]],G2frame.ImageZ,Controls)
1880	G2plt.PlotExposedImage(G2frame,event=event)
1881	G2plt.PlotStrain(G2frame,data,newPlot=True)
1882
1883	def OnPixLimit(event):
1884	Obj = event.GetEventObject()
1885	data['d-zero'][Indx[Obj.GetId()]]['pixLimit'] = int(Obj.GetValue())
1886	Ring,R = G2img.MakeStrStaRing(data['d-zero'][Indx[Obj.GetId()]],G2frame.ImageZ,Controls)
1887	G2plt.PlotExposedImage(G2frame,event=event)
1888	G2plt.PlotStrain(G2frame,data,newPlot=True)
1889
1890	Indx = {}
1891	delIndx = []
1892	dzeroSizer = wx.FlexGridSizer(0,8,5,5)
1893	for id,dzero in enumerate(data['d-zero']):
1894	dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' d-zero #%d: '%(id))),0,WACV)
1895	dZero = wx.TextCtrl(G2frame.dataDisplay,-1,value=('%.5f'%(dzero['Dset'])),
1896	style=wx.TE_PROCESS_ENTER)
1897	dzeroSizer.Add(dZero,0,WACV)
1898	dZero.Bind(wx.EVT_TEXT_ENTER,OnDzero)
1899	dZero.Bind(wx.EVT_KILL_FOCUS,OnDzero)
1900	Indx[dZero.GetId()] = id
1901	dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' d-zero ave: %.5f'%(dzero['Dcalc']))),0,WACV)
1902
1903	dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Min ring I/Ib '),0,WACV)
1904	cutOff = wx.TextCtrl(parent=G2frame.dataDisplay,value=("%.1f" % (dzero['cutoff'])),
1905	style=wx.TE_PROCESS_ENTER)
1906	cutOff.Bind(wx.EVT_TEXT_ENTER,OnCutOff)
1907	cutOff.Bind(wx.EVT_KILL_FOCUS,OnCutOff)
1908	Indx[cutOff.GetId()] = id
1909	dzeroSizer.Add(cutOff,0,WACV)
1910
1911	dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,label=' Pixel search range '),0,WACV)
1912	pixLimit = wx.ComboBox(parent=G2frame.dataDisplay,value=str(dzero['pixLimit']),choices=['1','2','5','10','15','20'],
1913	style=wx.CB_READONLY\|wx.CB_DROPDOWN)
1914	pixLimit.Bind(wx.EVT_COMBOBOX, OnPixLimit)
1915	Indx[pixLimit.GetId()] = id
1916	dzeroSizer.Add(pixLimit,0,WACV)
1917
1918	dzeroDelete = wx.CheckBox(parent=G2frame.dataDisplay,label='delete?')
1919	dzeroDelete.Bind(wx.EVT_CHECKBOX,OnDeleteDzero)
1920	delIndx.append(dzeroDelete)
1921	dzeroSizer.Add(dzeroDelete,0,WACV)
1922
1923	dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=(' Strain tensor:')),WACV)
1924	names = ['e11','e12','e22']
1925	for i in range(3):
1926	dzeroSizer.Add(wx.StaticText(G2frame.dataDisplay,-1,label=names[i]),0,WACV)
1927	tensorElem = wx.TextCtrl(G2frame.dataDisplay,-1,value='%.2f'%(dzero['Emat'][i]),style=wx.TE_READONLY)
1928	tensorElem.SetBackgroundColour(VERY_LIGHT_GREY)
1929	dzeroSizer.Add(tensorElem,0,WACV)
1930	dzeroSizer.Add((5,5),0)
1931	return dzeroSizer
1932
1933	# patches
1934	if 'Sample load' not in data:
1935	data['Sample load'] = 0.0
1936	# end patches
1937
1938	if G2frame.dataDisplay:
1939	G2frame.dataDisplay.Destroy()
1940	Controls = G2frame.PatternTree.GetItemPyData(
1941	G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls'))
1942	G2gd.SetDataMenuBar(G2frame,G2frame.dataFrame.StrStaMenu)
1943	G2frame.dataFrame.Bind(wx.EVT_MENU, OnAppendDzero, id=G2gd.wxID_APPENDDZERO)
1944	G2frame.dataFrame.Bind(wx.EVT_MENU, OnUpdateDzero, id=G2gd.wxID_UPDATEDZERO)
1945	G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitStrSta, id=G2gd.wxID_STRSTAFIT)
1946	G2frame.dataFrame.Bind(wx.EVT_MENU, OnFitAllStrSta, id=G2gd.wxID_STRSTAALLFIT)
1947	G2frame.dataFrame.Bind(wx.EVT_MENU, OnCopyStrSta, id=G2gd.wxID_STRSTACOPY)
1948	G2frame.dataFrame.Bind(wx.EVT_MENU, OnLoadStrSta, id=G2gd.wxID_STRSTALOAD)
1949	G2frame.dataFrame.Bind(wx.EVT_MENU, OnSaveStrSta, id=G2gd.wxID_STRSTASAVE)
1950	G2frame.dataFrame.Bind(wx.EVT_MENU, OnStrStaSample, id=G2gd.wxID_STRSTSAMPLE)
1951	if not G2frame.dataFrame.GetStatusBar():
1952	Status = G2frame.dataFrame.CreateStatusBar()
1953	if G2frame.StrainKey == 'a': #probably doesn't happen
1954	G2frame.dataFrame.GetStatusBar().SetStatusText('Add strain ring active - LB pick d-zero value')
1955	else:
1956	G2frame.dataFrame.GetStatusBar().SetStatusText("To add strain data: On 2D Powder Image, key a:add ring")
1957
1958	G2frame.dataDisplay = wxscroll.ScrolledPanel(G2frame.dataFrame)
1959	mainSizer = wx.BoxSizer(wx.VERTICAL)
1960	mainSizer.Add((5,10),0)
1961	mainSizer.Add(SamSizer())
1962	mainSizer.Add((5,10),0)
1963	mainSizer.Add(DzeroSizer())
1964
1965	mainSizer.Layout()
1966	G2frame.dataDisplay.SetSizer(mainSizer)
1967	G2frame.dataDisplay.SetAutoLayout(1)
1968	G2frame.dataDisplay.SetupScrolling()
1969	Size = mainSizer.Fit(G2frame.dataFrame)
1970	Size[0] += 25
1971	G2frame.dataDisplay.SetSize(Size)
1972	G2frame.dataFrame.setSizePosLeft(Size)
1973
1974	###########################################################################
1975	# Autointegration follows
1976	def ReadMask(filename):
1977	'Read a mask (.immask) file'
1978	File = open(filename,'r')
1979	save = {}
1980	S = File.readline()
1981	while S:
1982	if S[0] == '#':
1983	S = File.readline()
1984	continue
1985	[key,val] = S[:-1].split(':')
1986	if key in ['Points','Rings','Arcs','Polygons','Frames','Thresholds']:
1987	save[key] = eval(val)
1988	S = File.readline()
1989	File.close()
1990	CleanupMasks(save)
1991	return save
1992
1993	def ReadControls(filename):
1994	'read an image controls (.imctrl) file'
1995	cntlList = ['wavelength','distance','tilt','invert_x','invert_y','type',
1996	'fullIntegrate','outChannels','outAzimuths','LRazimuth','IOtth','azmthOff','DetDepth',
1997	'calibskip','pixLimit','cutoff','calibdmin','Flat Bkg',
1998	'PolaVal','SampleAbs','dark image','background image']
1999	File = open(filename,'r')
2000	save = {}
2001	S = File.readline()
2002	while S:
2003	if S[0] == '#':
2004	S = File.readline()
2005	continue
2006	[key,val] = S[:-1].split(':')
2007	if key in ['type','calibrant','binType','SampleShape',]: #strings
2008	save[key] = val
2009	elif key in ['rotation']:
2010	save[key] = float(val)
2011	elif key in ['center',]:
2012	if ',' in val:
2013	save[key] = eval(val)
2014	else:
2015	vals = val.strip('[] ').split()
2016	save[key] = [float(vals[0]),float(vals[1])]
2017	elif key in cntlList:
2018	save[key] = eval(val)
2019	S = File.readline()
2020	File.close()
2021	return save
2022
2023	def Read_imctrl(imctrl_file):
2024	'''Read an image control file and record control parms into a dict, with some simple
2025	type conversions
2026	'''
2027	file_opt = options = {}
2028	save = {'filename':imctrl_file}
2029	immask_file = os.path.splitext(imctrl_file)[0]+'.immask'
2030	if os.path.exists(immask_file):
2031	save['maskfile'] = immask_file
2032	else:
2033	save['maskfile'] = '(none)'
2034	cntlList = ['wavelength','distance','tilt','invert_x','invert_y','type',
2035	'fullIntegrate','outChannels','outAzimuths','LRazimuth','IOtth','azmthOff','DetDepth',
2036	'calibskip','pixLimit','cutoff','calibdmin','Flat Bkg',
2037	'PolaVal','SampleAbs','dark image','background image']
2038	File = open(imctrl_file,'r')
2039	fullIntegrate = False
2040	try:
2041	S = File.readline()
2042	while S:
2043	if S[0] == '#':
2044	S = File.readline()
2045	continue
2046	[key,val] = S[:-1].split(':')
2047	if key in ['type','calibrant','binType','SampleShape',]: #strings
2048	save[key] = val
2049	elif key == 'rotation':
2050	save[key] = float(val)
2051	elif key == 'fullIntegrate':
2052	fullIntegrate = eval(val)
2053	elif key == 'LRazimuth':
2054	save['LRazimuth_min'],save['LRazimuth_max'] = eval(val)[0:2]
2055	elif key == 'IOtth':
2056	save['IOtth_min'],save['IOtth_max'] = eval(val)[0:2]
2057	elif key == 'center':
2058	if ',' in val:
2059	vals = eval(val)
2060	else:
2061	vals = val.strip('[] ').split()
2062	vals = [float(vals[0]),float(vals[1])]
2063	save['center_x'],save['center_y'] = vals[0:2]
2064	elif key in cntlList:
2065	save[key] = eval(val)
2066	S = File.readline()
2067	finally:
2068	File.close()
2069	if fullIntegrate: save['LRazimuth_min'],save['LRazimuth_max'] = 0,0
2070	return save
2071
2072	class AutoIntFrame(wx.Frame):
2073	'''Creates a wx.Frame window for the Image AutoIntegration.
2074	The intent is that this will be used as a non-modal dialog window.
2075
2076	Implements a Start button that morphs into a pause and resume button.
2077	This button starts a processing loop that is repeated every
2078	:meth:`PollTime` seconds.
2079
2080	:param wx.Frame G2frame: main GSAS-II frame
2081	:param float PollTime: frequency in seconds to repeat calling the
2082	processing loop. (Default is 3.0 seconds.)
2083	'''
2084
2085	def __init__(self,G2frame,PollTime=60.0):
2086	def OnStart(event):
2087	'''Called when the start button is pressed. Changes button label
2088	to Pause. When Pause is pressed the label changes to Resume.
2089	When either Start or Resume is pressed, the processing loop
2090	is started. When Pause is pressed, the loop is stopped.
2091	'''
2092	# check inputs for errors before starting
2093	#err = ''
2094	#if not any([self.params[fmt] for fmt in self.fmtlist]):
2095	# err += '\nPlease select at least one output format\n'
2096	#if err:
2097	# G2G.G2MessageBox(self,err)
2098	# return
2099	self.Pause = False
2100	# change button label
2101	if self.btnstart.GetLabel() != 'Pause':
2102	self.btnstart.SetLabel('Pause')
2103	if self.timer.IsRunning(): self.timer.Stop()
2104	self.PreventReEntryTimer = False
2105	self.StartLoop()
2106	self.OnTimerLoop(None) # run once immediately and again after delay
2107	self.timer.Start(int(1000*PollTime),oneShot=False)
2108	self.Status.SetStatusText('Press Pause to delay integration or Reset to prepare to reintegrate all images')
2109	else:
2110	self.btnstart.SetLabel('Resume')
2111	if self.timer.IsRunning(): self.timer.Stop()
2112	print('\nPausing autointegration\n')
2113	self.Status.SetStatusText('Press Resume to continue integration or Reset to prepare to reintegrate all images')
2114	self.Pause = True
2115
2116	def OnReset(event):
2117	'''Called when Reset button is pressed. This stops the
2118	processing loop and resets the list of integrated files so
2119	all images can be reintegrated.
2120	'''
2121	self.btnstart.SetLabel('Restart')
2122	self.Status.SetStatusText('Press Restart to reload and re-integrate images matching filter')
2123	if self.timer.IsRunning(): self.timer.Stop()
2124	self.Reset = True
2125	self.Pause = True
2126
2127	def OnQuit(event):
2128	'''Stop the processing loop and close the Frame
2129	'''
2130	if self.timer.IsRunning(): self.timer.Stop() # make sure we stop first
2131	wx.CallAfter(self.Destroy)
2132
2133	def OnBrowse(event):
2134	'''Responds when the Browse button is pressed to load a file.
2135	The routine determines which button was pressed and gets the
2136	appropriate file type and loads it into the appropriate place
2137	in the dict.
2138	'''
2139	if btn3 == event.GetEventObject():
2140	dlg = wx.DirDialog(
2141	self, 'Select directory for output files',
2142	self.params['outdir'],wx.DD_DEFAULT_STYLE)
2143	dlg.CenterOnParent()
2144	try:
2145	if dlg.ShowModal() == wx.ID_OK:
2146	self.params['outdir'] = dlg.GetPath()
2147	fInp3.SetValue(self.params['outdir'])
2148	finally:
2149	dlg.Destroy()
2150	return
2151
2152	def OnRadioSelect(event):
2153	'''Respond to a radiobutton selection and when in table
2154	mode, get distance-dependent parameters from user.
2155	'''
2156	self.Evaluator = None
2157	if r2.GetValue():
2158	try:
2159	dlg = IntegParmTable(self.G2frame) # create the dialog
2160	dlg.CenterOnParent()
2161	if dlg.ShowModal() == wx.ID_OK:
2162	self.ImgTblParms = dlg.parms
2163	self.IMfileList = dlg.IMfileList
2164	self.Evaluator = DefineEvaluator(dlg)
2165	self.params['Mode'] = 'table'
2166	r2E.Enable(True)
2167	else:
2168	self.useActive.SetValue(True)
2169	finally:
2170	dlg.Destroy()
2171	if self.useActive.GetValue():
2172	self.params['Mode'] = 'active'
2173	self.imageBase = G2frame.Image
2174	self.useActive.SetLabel("Active Image: "+
2175	G2frame.PatternTree.GetItemText(self.imageBase))
2176	r2E.Enable(False)
2177
2178	def OnEditTable(event):
2179	'''Called to edit the distance-dependent parameter look-up table.
2180	Should be called only when table is defined and active.
2181	'''
2182	try:
2183	dlg = IntegParmTable(self.G2frame,self.ImgTblParms,self.IMfileList)
2184	dlg.CenterOnParent()
2185	if dlg.ShowModal() == wx.ID_OK:
2186	self.ImgTblParms = dlg.parms
2187	self.IMfileList = dlg.IMfileList
2188	self.Evaluator = DefineEvaluator(dlg)
2189	self.params['Mode'] = 'table'
2190	r2E.Enable(True)
2191	else:
2192	self.useActive.SetValue(True)
2193	self.params['Mode'] = 'active'
2194	self.imageBase = G2frame.Image
2195	self.useActive.SetLabel("Active Image: "+
2196	G2frame.PatternTree.GetItemText(self.imageBase))
2197	r2E.Enable(False)
2198	finally:
2199	dlg.Destroy()
2200
2201	##################################################
2202	# beginning of __init__ processing
2203	##################################################
2204	self.G2frame = G2frame
2205	self.ImgTblParms = None
2206	self.IMfileList = None
2207	self.Evaluator = None
2208	self.params = {}
2209	self.Reset = False
2210	self.Pause = False
2211	self.PreventReEntryShowMatch = False
2212	self.PreventReEntryTimer = False
2213	self.params['IMGfile'] = ''
2214	self.params['MaskFile'] = ''
2215	self.params['IgnoreMask'] = True
2216	self.fmtlist = G2IO.ExportPowderList(G2frame)
2217	self.timer = wx.Timer()
2218	self.timer.Bind(wx.EVT_TIMER,self.OnTimerLoop)
2219	self.imageBase = G2frame.Image
2220
2221	controlsId = G2frame.PatternTree.GetSelection()
2222	size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(self.imageBase)
2223	self.imagedir,fileroot = os.path.split(imagefile)
2224	self.params['filter'] = '*'+os.path.splitext(fileroot)[1]
2225	self.params['outdir'] = os.path.abspath(self.imagedir)
2226	wx.Frame.__init__(self, G2frame, title='Automatic Integration',
2227	style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX)
2228	self.Status = self.CreateStatusBar()
2229	self.Status.SetStatusText('Press Start to load and integrate images matching filter')
2230	mnpnl = wx.Panel(self)
2231	mnsizer = wx.BoxSizer(wx.VERTICAL)
2232	# box for integration controls & masks input
2233	lbl = wx.StaticBox(mnpnl, wx.ID_ANY, "Integration Control")
2234	lblsizr = wx.StaticBoxSizer(lbl, wx.VERTICAL)
2235	lblsizr.Add(wx.StaticText(mnpnl, wx.ID_ANY,'Use integration parameters from:'))
2236	self.useActive = wx.RadioButton(mnpnl, wx.ID_ANY,
2237	style = wx.RB_GROUP)
2238	self.useActive.Bind(wx.EVT_RADIOBUTTON, OnRadioSelect)
2239	self.useActive.SetLabel("Active Image: "+
2240	G2frame.PatternTree.GetItemText(self.imageBase))
2241	lblsizr.Add(self.useActive,1,wx.EXPAND,1)
2242	self.useActive.SetValue(True)
2243	minisizer = wx.BoxSizer(wx.HORIZONTAL)
2244	r2 = wx.RadioButton(mnpnl, wx.ID_ANY, "From distance look-up table")
2245	minisizer.Add(r2,0,wx.ALIGN_LEFT\|wx.ALL,1)
2246	r2.Bind(wx.EVT_RADIOBUTTON, OnRadioSelect)
2247	r2E = wx.Button(mnpnl, wx.ID_ANY, "Edit table")
2248	minisizer.Add(r2E,0,wx.ALIGN_LEFT,10)
2249	r2E.Enable(False)
2250	r2E.Bind(wx.EVT_BUTTON, OnEditTable)
2251	# bind button and deactivate be default
2252	lblsizr.Add(minisizer)
2253	mnsizer.Add(lblsizr,1,wx.EXPAND,1)
2254
2255	# file filter stuff
2256	sizer = wx.BoxSizer(wx.HORIZONTAL)
2257	sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY,'Image filter'))
2258	flterInp = G2G.ValidatedTxtCtrl(mnpnl,self.params,'filter',
2259	OnLeave=self.ShowMatchingFiles)
2260	sizer.Add(flterInp)
2261	mnsizer.Add(sizer,0,wx.ALIGN_RIGHT,1)
2262	self.ListBox = wx.ListBox(mnpnl,size=(-1,100))
2263	mnsizer.Add(self.ListBox,0,wx.EXPAND,1)
2264	self.ShowMatchingFiles(self.params['filter'])
2265	# box for output selections
2266	lbl = wx.StaticBox(mnpnl, wx.ID_ANY, "Output settings")
2267	lblsizr = wx.StaticBoxSizer(lbl, wx.VERTICAL)
2268	sizer = wx.BoxSizer(wx.HORIZONTAL)
2269	sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY,'Write to: '))
2270	fInp3 = G2G.ValidatedTxtCtrl(mnpnl,self.params,'outdir',
2271	notBlank=False,size=(300,-1))
2272	sizer.Add(fInp3)
2273	btn3 = wx.Button(mnpnl, wx.ID_ANY, "Browse")
2274	btn3.Bind(wx.EVT_BUTTON, OnBrowse)
2275	sizer.Add(btn3)
2276	lblsizr.Add(sizer)
2277	#lblsizr.Add(wx.StaticText(mnpnl, wx.ID_ANY,'Select format(s): '))
2278	sizer = wx.BoxSizer(wx.HORIZONTAL)
2279	sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY,'Select format(s): '))
2280	for dfmt in self.fmtlist:
2281	fmt = dfmt[1:]
2282	self.params[fmt] = False
2283	btn = G2G.G2CheckBox(mnpnl,dfmt,self.params,fmt)
2284	sizer.Add(btn)
2285	lblsizr.Add(sizer)
2286	sizer = wx.BoxSizer(wx.HORIZONTAL)
2287	sizer.Add(wx.StaticText(mnpnl, wx.ID_ANY,'Separate dir for each format: '))
2288	self.params['SeparateDir'] = False
2289	sizer.Add(G2G.G2CheckBox(mnpnl,'',self.params,'SeparateDir'))
2290	lblsizr.Add(sizer)
2291	mnsizer.Add(lblsizr,0,wx.ALIGN_CENTER,1)
2292
2293	# buttons on bottom
2294	mnsizer.Add(wx.StaticText(mnpnl, wx.ID_ANY,'AutoIntegration controls'),0,wx.TOP,5)
2295	sizer = wx.BoxSizer(wx.HORIZONTAL)
2296	sizer.Add((20,-1))
2297	self.btnstart = wx.Button(mnpnl, wx.ID_ANY, "Start")
2298	self.btnstart.Bind(wx.EVT_BUTTON, OnStart)
2299	sizer.Add(self.btnstart)
2300	btnstop = wx.Button(mnpnl, wx.ID_ANY, "Reset")
2301	btnstop.Bind(wx.EVT_BUTTON, OnReset)
2302	sizer.Add(btnstop)
2303	sizer.Add((20,-1),wx.EXPAND,1)
2304	btnquit = wx.Button(mnpnl, wx.ID_ANY, "Close")
2305	btnquit.Bind(wx.EVT_BUTTON, OnQuit)
2306	sizer.Add(btnquit)
2307	sizer.Add((20,-1))
2308	mnsizer.Add(sizer,0,wx.EXPAND\|wx.BOTTOM\|wx.TOP,5)
2309
2310	# finish up window
2311	mnpnl.SetSizer(mnsizer)
2312	OnRadioSelect(None) # disable widgets
2313	mnsizer.Fit(self)
2314	self.CenterOnParent()
2315	self.Show()
2316
2317	def ShowMatchingFiles(self,value,invalid=False,**kwargs):
2318	G2frame = self.G2frame
2319	if invalid: return
2320	msg = ''
2321	if self.PreventReEntryShowMatch: return
2322	self.PreventReEntryShowMatch = True
2323	imageFileList = []
2324	for img in G2gd.GetPatternTreeDataNames(G2frame,['IMG ']):
2325	imgId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
2326	size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(imgId)
2327	if imagefile not in imageFileList: imageFileList.append(imagefile)
2328	if img not in G2frame.IntegratedList:
2329	if msg: msg += '\n'
2330	msg += ' ' + img
2331	if msg: msg = "Loaded images to integrate:\n" + msg + "\n"
2332	msg1 = ""
2333	try:
2334	imageList = sorted(
2335	glob.glob(os.path.join(self.imagedir,value)))
2336	if not imageList:
2337	msg1 = 'Warning: No files match search string '+os.path.join(self.imagedir,value)
2338	else:
2339	for fil in imageList:
2340	if fil not in imageFileList: msg1 += '\n '+fil
2341	if msg1:
2342	msg += 'Files to integrate from '+os.path.join(self.imagedir,value)+msg1
2343	else:
2344	msg += 'All files integrated'
2345	except IndexError:
2346	msg += 'Error searching for files named '+os.path.join(self.imagedir,value)
2347	self.ListBox.Clear()
2348	self.ListBox.AppendItems(msg.split('\n'))
2349	self.PreventReEntryShowMatch = False
2350	return
2351
2352	def IntegrateImage(self,img):
2353	'''Integrates a single image'''
2354	G2frame = self.G2frame
2355	imgId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
2356	G2frame.Image = imgId
2357	G2frame.PickId = G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Image Controls')
2358	# do integration
2359	size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(imgId)
2360	masks = G2frame.PatternTree.GetItemPyData(
2361	G2gd.GetPatternTreeItemId(G2frame,G2frame.Image, 'Masks'))
2362	data = G2frame.PatternTree.GetItemPyData(G2frame.PickId)
2363	# simulate a Image Controls press, since that is where the
2364	# integration is hidden
2365	UpdateImageControls(G2frame,data,masks,IntegrateOnly=True)
2366	G2frame.IntegratedList.append(img) # note this as integrated
2367	# split name and control number
2368	s = re.split(r'(\d+)\Z',os.path.split(os.path.splitext(imagefile)[0])[1])
2369	namepre = s[0]
2370	if len(s) > 1:
2371	namenum = s[1]
2372	else:
2373	namenum = ''
2374	for Id in G2frame.IntgOutList: # loop over newly created PDWR entry(ies)
2375	# save the created PWDR tree names so that a reset can delete them
2376	G2frame.Image = Id
2377	treename = G2frame.PatternTree.GetItemText(Id)
2378	G2frame.AutointPWDRnames.append(treename)
2379	# write out the images in the selected formats
2380	Sdata = G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(G2frame,Id, 'Sample Parameters'))
2381	# determine the name for the current file
2382	fileroot = namepre
2383	if len(G2frame.IntgOutList) > 1:
2384	fileroot += "_AZM"
2385	if 'Azimuth' in Sdata:
2386	fileroot += str(int(10*Sdata['Azimuth']))
2387	fileroot += "_"
2388	fileroot += namenum
2389	# loop over selected formats
2390	for dfmt in self.fmtlist:
2391	if not self.params[dfmt[1:]]: continue
2392	if self.params['SeparateDir']:
2393	subdir = dfmt[1:]
2394	else:
2395	subdir = ''
2396	fil = os.path.join(self.params['outdir'],subdir,fileroot)
2397	print('writing file '+fil+dfmt)
2398	G2IO.ExportPowder(G2frame,treename,fil,dfmt)
2399
2400	def ResetFromTable(self,dist):
2401	'''Sets integration parameters based on values from
2402	the lookup table
2403	'''
2404	#dist = self.controlsDict['distance']
2405	interpDict,imgctrl,immask = self.Evaluator(dist) # interpolated calibration values
2406	#if GSASIIpath.GetConfigValue('debug'):
2407	if GSASIIpath.GetConfigValue('debug'):
2408	print 'interpolated values: ',interpDict
2409	self.ImageControls = ReadControls(imgctrl)
2410	self.ImageControls.update(interpDict)
2411	self.ImageControls['showLines'] = True
2412	self.ImageControls['ring'] = []
2413	self.ImageControls['rings'] = []
2414	self.ImageControls['ellipses'] = []
2415	self.ImageControls['setDefault'] = False
2416	for i in 'range','size','GonioAngles':
2417	if i in self.ImageControls:
2418	del self.ImageControls[i]
2419	# load copy of Image Masks
2420	if immask:
2421	self.ImageMasks = ReadMask(immask)
2422	if list(self.ImageMasks['Thresholds'][0]) == self.ImageMasks['Thresholds'][1]: #avoid copy of unchanged thresholds
2423	del self.ImageMasks['Thresholds']
2424	else:
2425	self.ImageMasks = {'Points':[],'Rings':[],'Arcs':[],'Polygons':[],'Frames':[]}
2426
2427	def StartLoop(self):
2428	'''Save current Image params for use in future integrations
2429	also label the window so users understand what is being used
2430	'''
2431	print '\nStarting new autointegration\n'
2432	G2frame = self.G2frame
2433	# show current IMG base
2434	if self.params['Mode'] != 'table':
2435	self.useActive.SetLabel("Active Image: "+
2436	G2frame.PatternTree.GetItemText(self.imageBase))
2437	# load copy of Image Controls from current image and clean up
2438	# items that should not be copied
2439	self.ImageControls = copy.deepcopy(
2440	G2frame.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(
2441	G2frame,self.imageBase, 'Image Controls')))
2442	self.ImageControls['showLines'] = True
2443	self.ImageControls['ring'] = []
2444	self.ImageControls['rings'] = []
2445	self.ImageControls['ellipses'] = []
2446	self.ImageControls['setDefault'] = False
2447	del self.ImageControls['range']
2448	del self.ImageControls['size']
2449	del self.ImageControls['GonioAngles']
2450	# load copy of Image Masks, keep thresholds
2451	self.ImageMasks = copy.deepcopy(
2452	G2frame.PatternTree.GetItemPyData(
2453	G2gd.GetPatternTreeItemId(G2frame,self.imageBase, 'Masks')))
2454	self.Thresholds = self.ImageMasks['Thresholds'][:]
2455	if list(self.Thresholds[0]) == self.Thresholds[1]: #avoid copy of unchanged thresholds
2456	del self.ImageMasks['Thresholds']
2457	# make sure all output directories exist
2458	if self.params['SeparateDir']:
2459	for dfmt in self.fmtlist:
2460	if not self.params[dfmt[1:]]: continue
2461	dir = os.path.join(self.params['outdir'],dfmt[1:])
2462	if not os.path.exists(dir): os.makedirs(dir)
2463	else:
2464	if not os.path.exists(self.params['outdir']):
2465	os.makedirs(self.params['outdir'])
2466	if self.Reset: # special things to do after Reset has been pressed
2467	self.G2frame.IntegratedList = []
2468
2469	if self.params['Mode'] != 'table': # reset controls and masks for all IMG items in tree to master
2470	for img in G2gd.GetPatternTreeDataNames(G2frame,['IMG ']):
2471	# update controls from master
2472	controlsDict = G2frame.PatternTree.GetItemPyData(
2473	G2gd.GetPatternTreeItemId(G2frame,self.imageBase, 'Image Controls'))
2474	controlsDict.update(self.ImageControls)
2475	# update masks from master
2476	ImageMasks = G2frame.PatternTree.GetItemPyData(
2477	G2gd.GetPatternTreeItemId(G2frame,self.imageBase, 'Masks'))
2478	ImageMasks.update(self.ImageMasks)
2479	# delete all PWDR items created after last Start was pressed
2480	idlist = []
2481	item, cookie = G2frame.PatternTree.GetFirstChild(G2frame.root)
2482	while item:
2483	itemName = G2frame.PatternTree.GetItemText(item)
2484	if itemName in G2frame.AutointPWDRnames:
2485	idlist.append(item)
2486	item, cookie = G2frame.PatternTree.GetNextChild(G2frame.root, cookie)
2487	for item in idlist:
2488	G2frame.PatternTree.Delete(item)
2489	wx.Yield()
2490	self.Reset = False
2491	G2frame.AutointPWDRnames = [] # list of created PWDR tree item names
2492
2493	def OnTimerLoop(self,event):
2494	'''A method that is called every :meth:`PollTime` seconds that is
2495	used to check for new files and process them. This is called only
2496	after the "Start" button is pressed (then its label reads "Pause").
2497	'''
2498	G2frame = self.G2frame
2499	try:
2500	self.currImageList = sorted(
2501	glob.glob(os.path.join(self.imagedir,self.params['filter'])))
2502	self.ShowMatchingFiles(self.params['filter'])
2503	except IndexError:
2504	self.currImageList = []
2505	return
2506
2507	if self.PreventReEntryTimer: return
2508	self.PreventReEntryTimer = True
2509	imageFileList = []
2510	# integrate the images that have already been read in, but
2511	# have not yet been processed
2512	for img in G2gd.GetPatternTreeDataNames(G2frame,['IMG ']):
2513	imgId = G2gd.GetPatternTreeItemId(G2frame,G2frame.root,img)
2514	size,imagefile,imagetag = G2frame.PatternTree.GetImageLoc(imgId)
2515	# Create a list of image files that have been read in
2516	if imagefile not in imageFileList: imageFileList.append(imagefile)
2517	# skip if already integrated
2518	if img in G2frame.IntegratedList: continue
2519	controlsDict = G2frame.PatternTree.GetItemPyData(
2520	G2gd.GetPatternTreeItemId(G2frame,imgId, 'Image Controls'))
2521	ImageMasks = G2frame.PatternTree.GetItemPyData(
2522	G2gd.GetPatternTreeItemId(G2frame,imgId, 'Masks'))
2523	if self.params['Mode'] == 'table': # look up parameter values from table
2524	self.ResetFromTable(controlsDict['distance'])
2525	# update controls from master
2526	controlsDict.update(self.ImageControls)
2527	# update masks from master w/o Thresholds
2528	ImageMasks.update(self.ImageMasks)
2529	self.IntegrateImage(img)
2530	self.Pause = G2frame.PauseIntegration
2531	self.G2frame.oldImagefile = '' # mark image as changed; reread as needed
2532	wx.Yield()
2533	self.ShowMatchingFiles(self.params['filter'])
2534	wx.Yield()
2535	if self.Pause:
2536	self.btnstart.SetLabel('Resume')
2537	if self.timer.IsRunning(): self.timer.Stop()
2538	print('\nPausing autointegration\n')
2539	self.Status.SetStatusText('Press Resume to continue integration or Reset to prepare to reintegrate all images')
2540	return
2541
2542	# loop over image files matching glob, reading in any new ones
2543	for newImage in self.currImageList:
2544
2545	if newImage in imageFileList or self.Pause: continue # already read?
2546	for imgId in G2IO.ReadImages(G2frame,newImage):
2547	controlsDict = G2frame.PatternTree.GetItemPyData(
2548	G2gd.GetPatternTreeItemId(G2frame,imgId, 'Image Controls'))
2549	ImageMasks = G2frame.PatternTree.GetItemPyData(
2550	G2gd.GetPatternTreeItemId(G2frame,imgId, 'Masks'))
2551	if self.params['Mode'] == 'table': # look up parameter values from table
2552	self.ResetFromTable(controlsDict['distance'])
2553	# update controls from master
2554	controlsDict.update(self.ImageControls)
2555	# update masks from master w/o Thresholds
2556	ImageMasks.update(self.ImageMasks)
2557	# now integrate the image
2558	img = G2frame.PatternTree.GetItemText(imgId)
2559	self.IntegrateImage(img)
2560	self.G2frame.oldImagefile = '' # mark image as changed; reread as needed
2561	wx.Yield()
2562	self.ShowMatchingFiles(self.params['filter'])
2563	wx.Yield()
2564	self.Pause = G2frame.PauseIntegration
2565	print 'pause',self.Pause
2566	if self.Pause:
2567	self.btnstart.SetLabel('Resume')
2568	if self.timer.IsRunning(): self.timer.Stop()
2569	print('\nPausing autointegration\n')
2570	self.Status.SetStatusText('Press Resume to continue integration or Reset to prepare to reintegrate all images')
2571	break
2572
2573	if GSASIIpath.GetConfigValue('debug'):
2574	import datetime
2575	print ("Timer tick at {:%d %b %Y %H:%M:%S}\n".format(datetime.datetime.now()))
2576	self.PreventReEntryTimer = False
2577
2578	def DefineEvaluator(dlg):
2579	'''Creates a function that provides interpolated values for a given distance value
2580	'''
2581	def Evaluator(dist):
2582	'''Interpolate image parameters for a supplied distance value
2583
2584	:param float dist: distance to use for interpolation
2585	:returns: a list with 3 items:
2586
2587	* a dict with parameter values,
2588	* the closest imctrl and
2589	* the closest maskfile (or None)
2590	'''
2591	x = np.array([float(i) for i in parms[0]])
2592	closest = abs(x-dist).argmin()
2593	closeX = x[closest]
2594	D = {'distance':dist}
2595	imctfile = IMfileList[closest]
2596	if parms[-1][closest].lower() != '(none)':
2597	maskfile = parms[-1][closest]
2598	else:
2599	maskfile = None
2600	for c in range(1,cols-1):
2601	lbl = ParmList[c]
2602	if lbl in nonInterpVars:
2603	if lbl in ['outChannels',]:
2604	D[lbl] = int(float(parms[c][closest]))
2605	else:
2606	D[lbl] = float(parms[c][closest])
2607	else:
2608	y = np.array([float(i) for i in parms[c]])
2609	D[lbl] = np.interp(dist,x,y)
2610	# full integration when angular range is 0
2611	D['fullIntegrate'] = (D['LRazimuth_min'] == D['LRazimuth_max'])
2612	# conversion for paired values
2613	for a,b in ('center_x','center_y'),('LRazimuth_min','LRazimuth_max'),('IOtth_min','IOtth_max'):
2614	r = a.split('_')[0]
2615	D[r] = [D[a],D[b]]
2616	if r in ['LRazimuth',]:
2617	D[r] = [int(D[a]),int(D[b])]
2618	del D[a]
2619	del D[b]
2620	return D,imctfile,maskfile
2621	# save local copies of values needed in Evaluator
2622	parms = dlg.ReadImageParmTable()
2623	IMfileList = dlg.IMfileList
2624	cols = dlg.list.GetColumnCount()
2625	ParmList = dlg.ParmList
2626	nonInterpVars = dlg.nonInterpVars
2627	return Evaluator
2628
2629	class IntegParmTable(wx.Dialog):
2630	'''Creates a dialog window with a table of integration parameters.
2631	:meth:`ShowModal` will return wx.ID_OK if the process has been successful.
2632	In this case, :func:`DefineEvaluator` should be called to obtain a function that
2633	creates a dictionary with interpolated parameter values.
2634	'''
2635	ParmList = ('distance','center_x','center_y','wavelength','tilt','rotation','DetDepth',
2636	'LRazimuth_min','LRazimuth_max','IOtth_min','IOtth_max','outChannels',
2637	'maskfile',
2638	)
2639	nonInterpVars = ('tilt','rotation','LRazimuth_min','LRazimuth_max','IOtth_min','IOtth_max',
2640	'outChannels') # values in this list are taken from nearest rather than interpolated
2641	HeaderList = ('Det Dist','X cntr','Y cntr','wavelength','tilt','rotation','DetDepth',
2642	'Azimuth min','Azimuth max','2Th min','2Th max','Int. pts',
2643	'Mask File',
2644	)
2645	def __init__(self,G2frame,parms=None,IMfileList=None):
2646	self.G2frame = G2frame
2647	wx.Dialog.__init__(self,G2frame,style=wx.RESIZE_BORDER\|wx.DEFAULT_DIALOG_STYLE)
2648	if parms:
2649	self.parms = parms # list of values by column
2650	self.IMfileList = IMfileList # list of .imctrl file names for each entry in table
2651	else:
2652	self.parms = [] # list of values by column
2653	self.IMfileList = [] # list of .imctrl file names for each entry in table
2654	files = []
2655	try:
2656	pth = G2G.GetImportPath(G2frame)
2657	if not pth: pth = '.'
2658	dlg = wx.FileDialog(self, 'Read previous table or build new table by selecting image control files', pth,
2659	style=wx.OPEN\| wx.MULTIPLE,
2660	wildcard='Integration table (.imtbl)\|.imtbl\|image control files (.imctrl)\|*.imctrl')
2661	dlg.CenterOnParent()
2662	if dlg.ShowModal() == wx.ID_OK:
2663	files = dlg.GetPaths()
2664	self.parms,self.IMfileList = self.ReadFiles(files)
2665	finally:
2666	dlg.Destroy()
2667	if not files:
2668	wx.CallAfter(self.EndModal,wx.ID_CANCEL)
2669	return
2670	mainSizer = wx.BoxSizer(wx.VERTICAL)
2671	self.list = ImgIntLstCtrl(self, wx.ID_ANY,
2672	style=wx.LC_REPORT
2673	\| wx.BORDER_SUNKEN
2674	#\| wx.BORDER_NONE
2675	)
2676	mainSizer.Add(self.list,1,wx.EXPAND,1)
2677	btnsizer = wx.BoxSizer(wx.HORIZONTAL)
2678	btn = wx.Button(self, wx.ID_OK)
2679	btnsizer.Add(btn)
2680	btn = wx.Button(self, wx.ID_ANY,'Save as file')
2681	btn.Bind(wx.EVT_BUTTON,self._onSave)
2682	btnsizer.Add(btn)
2683	btn = wx.Button(self, wx.ID_CLOSE,'Quit')
2684	btn.Bind(wx.EVT_BUTTON,self._onClose)
2685	btnsizer.Add(btn)
2686	mainSizer.Add(btnsizer, 0, wx.ALIGN_CENTER\|wx.ALL, 5)
2687	self.SetSizer(mainSizer)
2688	self.list.FillList(self.parms)
2689	mainSizer.Layout()
2690	mainSizer.Fit(self)
2691
2692	def ReadFiles(self,files):
2693	'''Reads a list of .imctrl files or a single .imtbl file
2694	'''
2695	tmpDict = {}
2696	if not files: return
2697	# option 1, a dump from a previous save
2698	if os.path.splitext(files[0])[1] == '.imtbl':
2699	fp = open(files[0],'r')
2700	S = fp.readline()
2701	while S:
2702	if S[0] != '#':
2703	[key,val] = S[:-1].split(':',1)
2704	tmpDict[key] = eval(val)
2705	S = fp.readline()
2706	fp.close()
2707	# delete entries
2708	m1 = [i for i,f in enumerate(tmpDict['filenames']) if not os.path.exists(f)]
2709	if m1:
2710	print('\nimctrl file not found:')
2711	for i in m1: print('\t#'+str(i)+': '+tmpDict['filenames'][i])
2712	m2 = [i for i,f in enumerate(tmpDict['maskfile']) if not (os.path.exists(f) or f.startswith('('))]
2713	if m2:
2714	print('\nmask file not found')
2715	for i in m2: print('\t#'+str(i)+': '+tmpDict['maskfile'][i])
2716	m3 = [i for i,d in enumerate(tmpDict['distance']) if d < 0]
2717	if m3:
2718	print('\nDropping entries due to negative distance: '+str(m3))
2719	m = sorted(set(m1 + m2 + m3))
2720	m.reverse()
2721	for c in m:
2722	for key in tmpDict:
2723	del tmpDict[key][c]
2724	fileList = tmpDict.get('filenames','[]')
2725	parms = []
2726	for key in self.ParmList:
2727	try:
2728	float(tmpDict[key][0])
2729	parms.append([str(G2py3.FormatSigFigs(val,sigfigs=5)) for val in tmpDict[key]])
2730	except ValueError:
2731	parms.append(tmpDict[key])
2732	return parms,fileList
2733	# option 2, read in a list of files
2734	for file in files: # read all files; place in dict by distance
2735	imgDict = Read_imctrl(file)
2736	tmpDict[imgDict.get('distance')] = imgDict
2737	parms = [[] for key in self.ParmList]
2738	fileList = []
2739	for d in sorted(tmpDict):
2740	fileList.append(tmpDict[d].get('filename'))
2741	if d is None: continue
2742	if d < 0: continue
2743	for i,key in enumerate(self.ParmList):
2744	val = tmpDict[d].get(key)
2745	try:
2746	val = str(G2py3.FormatSigFigs(val,sigfigs=5))
2747	except:
2748	val = str(val)
2749	parms[i].append(val)
2750	return parms,fileList
2751
2752	def ReadImageParmTable(self):
2753	'''Reads possibly edited values from the ListCtrl table and returns a list
2754	of values for each column.
2755	'''
2756	rows = self.list.GetItemCount()
2757	cols = self.list.GetColumnCount()
2758	parms = []
2759	for c in range(cols):
2760	lbl = self.ParmList[c]
2761	parms.append([])
2762	for r in range(rows):
2763	parms[c].append(self.list.GetItem(r,c).GetText())
2764	return parms
2765
2766	def _onClose(self,event):
2767	'Called when Cancel button is pressed'
2768	self.EndModal(wx.ID_CANCEL)
2769
2770	def _onSave(self,event):
2771	'Called when save button is pressed; creates a .imtbl file'
2772	fil = ''
2773	if self.G2frame.GSASprojectfile:
2774	fil = os.path.splitext(self.G2frame.GSASprojectfile)[0]+'.imtbl'
2775	dir,f = os.path.split(fil)
2776	pth = G2G.GetExportPath(self.G2frame)
2777	try:
2778	dlg = wx.FileDialog(self, 'Save table data as',
2779	defaultDir=pth, defaultFile=f, style=wx.SAVE,
2780	wildcard='G2 Image Param Table file (.imtbl)\|.imtbl')
2781	dlg.CenterOnParent()
2782	if dlg.ShowModal() != wx.ID_OK: return
2783	fil = dlg.GetPath()
2784	fil = os.path.splitext(fil)[0]+'.imtbl'
2785	finally:
2786	dlg.Destroy()
2787	parms = self.ReadImageParmTable()
2788	print('Writing image parameter table as '+fil)
2789	fp = open(fil,'w')
2790	for c in range(len(parms)-1):
2791	lbl = self.ParmList[c]
2792	fp.write(lbl+': '+str([eval(i) for i in parms[c]])+'\n')
2793	lbl = self.ParmList[c+1]
2794	fp.write(lbl+': '+str(parms[c+1])+'\n')
2795	lbl = 'filenames'
2796	fp.write(lbl+': '+str(self.IMfileList)+'\n')
2797	fp.close()
2798
2799	class ImgIntLstCtrl(wx.ListCtrl, listmix.ListCtrlAutoWidthMixin,listmix.TextEditMixin):
2800	'''Creates a custom ListCtrl for editing Image Integration parameters
2801	'''
2802	def __init__(self, parent, ID, pos=wx.DefaultPosition,
2803	size=(1000,200), style=0):
2804	self.parent=parent
2805	wx.ListCtrl.__init__(self, parent, ID, pos, size, style)
2806	listmix.ListCtrlAutoWidthMixin.__init__(self)
2807	listmix.TextEditMixin.__init__(self)
2808	self.Bind(wx.EVT_LEFT_DCLICK, self.OnDouble)
2809	#self.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick)
2810	def FillList(self,parms):
2811	'Places the current parms into the table'
2812	self.ClearAll()
2813	self.rowlen = len(self.parent.ParmList)
2814	for i,lbl in enumerate(self.parent.HeaderList):
2815	self.InsertColumn(i, lbl)
2816	for r,d in enumerate(parms[0]):
2817	if float(d) < 0: continue
2818	index = self.InsertStringItem(sys.maxint, d)
2819	for j in range(1,len(parms)):
2820	self.SetStringItem(index, j, parms[j][r])
2821	for i,lbl in enumerate(self.parent.ParmList):
2822	self.SetColumnWidth(i, wx.LIST_AUTOSIZE)
2823
2824	def OnDouble(self,evt):
2825	'respond to a double-click'
2826	self.CloseEditor()
2827	fil = '(none)'
2828	pth = G2G.GetImportPath(self.parent.G2frame)
2829	if not pth: pth = '.'
2830	try:
2831	dlg = wx.FileDialog(self, 'Select mask or control file to add (Press cancel if none)', pth,
2832	style=wx.OPEN,
2833	wildcard='Add GSAS-II mask file (.immask)\|.immask\|add image control file (.imctrl)\|.imctrl')
2834	dlg.CenterOnParent()
2835	if dlg.ShowModal() == wx.ID_OK:
2836	fil = dlg.GetPath()
2837	finally:
2838	dlg.Destroy()
2839	if os.path.splitext(fil)[1] != '.imctrl':
2840	self.SetStringItem(self.curRow, self.rowlen-1, fil)
2841	self.SetColumnWidth(self.rowlen-1, wx.LIST_AUTOSIZE)
2842	else:
2843	# insert or overwrite an instrument parameter set
2844	if not os.path.exists(fil):
2845	print('Does not exist: '+fil)
2846	return
2847	imgDict = Read_imctrl(fil)
2848	dist = imgDict['distance']
2849	parms = self.parent.ReadImageParmTable()
2850	x = np.array([float(i) for i in parms[0]])
2851	closest = abs(x-dist).argmin()
2852	closeX = x[closest]
2853	# fix IMfileList
2854	for c,lbl in enumerate(self.parent.ParmList):
2855	try:
2856	vali = G2py3.FormatSigFigs(float(imgDict[lbl]),sigfigs=5)
2857	except ValueError:
2858	vali = imgDict[lbl]
2859	if abs(closeX-dist) < 1.: # distance is within 1 mm, replace
2860	parms[c][closest] = vali
2861	elif dist > closeX: # insert after
2862	parms[c].insert(closest+1,vali)
2863	else:
2864	parms[c].insert(closest,vali)
2865	if abs(closeX-dist) < 1.: # distance is within 1 mm, replace
2866	self.parent.IMfileList[closest] = fil
2867	elif dist > closeX: # insert after
2868	self.parent.IMfileList.insert(closest+1,fil)
2869	else:
2870	self.parent.IMfileList.insert(closest,fil)
2871	self.FillList(parms)
2872	# Autointegration end
2873	###########################################################################

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

Download in other formats: