Context Navigation

source: trunk/GSASIIimgGUI.py @ 2302

Last change on this file since 2302 was 2302, checked in by vondreele, 7 years ago
fresh binaries for binwin2.7/fellipse.pyd explicit del for various arrays in ImageIntegrate? implement one of Andrey's modifications (other covered by RBVD changes) change order of wildcard in file dialog for integration table input; .imtbl is now default
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 126.2 KB

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

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

Download in other formats: