Context Navigation

source: trunk/GSASIIimgGUI.py @ 3172

Last change on this file since 3172 was 3172, checked in by vondreele, 5 years ago
change from wx.DefaultSize? to our defaults if window size is 'None' A TODO in Integrate for saving the x,y --> 2th,azm map between images complete fix to allowed super symmetries by lattice + pt. grp lookup also fix operator check for complete super symmetry finish cif import of super symmetry cases
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 159.0 KB

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

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

Download in other formats: