Context Navigation

source: trunk/GSASIIimgGUI.py @ 4830

Last change on this file since 4830 was 4830, checked in by vondreele, 3 years ago
show more places in Absorb output improve image absorption calcs for cylinders now seems to work OK reorganize Image controls GUI & add option for vertical samples hide printing of LS cycles if Rrint=False in HessianLSQ implement (& not use) Klein-Nishina PDF correction Fix bug in if importer
Property svn:eol-style set to `native` Property svn:keywords set to `Date Author Revision URL Id`
File size: 197.7 KB

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

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

Download in other formats: