def read_data(self,widget, path=None):
chlabels = []
for c in self.chanlist:
self.pdfdata = pdf.read(self.path)
print('c',c)
self.pdfdata.data.setchannels(c)
chlabels.extend(self.pdfdata.data.channels.labellist)
print 'chlabels', chlabels
self.pdfdata = pdf.read(self.path)
if self.ne > 1: #only load value in epoch increments
pntsinepoch = self.pdfdata.data.pnts_in_file/self.ne
startepoch = int(self.builder.get_object("entry29").get_text())
endepoch = int(self.builder.get_object("entry30").get_text())
startpnt = pntsinepoch * startepoch
endpnt = pntsinepoch * endepoch
numofepochs = endepoch - startepoch
else:
startpnt = int(self.builder.get_object("entry29").get_text())
endpnt = int(self.builder.get_object("entry30").get_text())
numofepochs = 1
self.pdfdata.data.setchannellabels(chlabels)
self.pdfdata.data.getdata(startpnt,endpnt)
self.pdfdata.data.wintime = self.pdfdata.data.wintime[startpnt:endpnt]
self.pdfdata.data.numofepochs = numofepochs
self.pdfdata.data.pnts_in_file = endpnt-startpnt
self.builder.get_object("assistant1").hide()
self.callback(widget)
return self.pdfdata
sys.exit(0)
def __init__(self, datapdf):
pdfinstance=pdf.read(datapdf)
for i in range(0, size(pdfinstance.cfg.channel_data)):
if i==1: #create empty array
megchlpos=array([])
megchupos=array([])
refshpos=array([])
megchldir=array([])
megchudir=array([])
refshdir=array([])
if pdfinstance.cfg.channel_data[i].type==1: #get MEG positions in array
megchlpos=append(megchlpos,p.cfg.channel_data[i].device_data.loop_data[0].position)
megchupos=append(megchupos,p.cfg.channel_data[i].device_data.loop_data[1].position)
megchldir=append(megchldir,p.cfg.channel_data[i].device_data.loop_data[0].direction)
megchudir=append(megchudir,p.cfg.channel_data[i].device_data.loop_data[0].direction)
if pdfinstance.cfg.channel_data[i].type==3: #get ref positions in array
refshpos=append(refshpos,p.cfg.channel_data[i].device_data.loop_data[0].position)
refshdir=append(refshdir,p.cfg.channel_data[i].device_data.loop_data[0].position)
#reshape arrays
megchlpos=megchlpos.reshape(size(megchlpos)/3,3)
megchupos=megchupos.reshape(size(megchupos)/3,3)
refshpos=refshpos.reshape(size(refshpos)/3,3)
megchldir=megchldir.reshape(size(megchldir)/3,3)
megchudir=megchudir.reshape(size(megchudir)/3,3)
refshdir=refshdir.reshape(size(refshdir)/3,3)
self.megchlpos=megchlpos
self.megchupos=megchupos
self.megchldir=megchldir
self.megchudir=megchudir
def __init__(self, datapdf):
p=pdf.read(datapdf)
#self.hsa=array(p.hs.hs_point)
return
self.hsm=zeros((size(hsa),3))
for i in range(len(hsa)):
self.hsm[i,:]=( hsa[i].x, hsa[i].y, hsa[i].z);
def leadfieldthread():
fn = '/home/danc/python/data/0611/0611SEF/e,rfhp1.0Hz,n,x,baha001-1SEF,f50lp'
from pdf2py import pdf
p = pdf.read(fn)
p.data.setchannels('meg')
grid=random.randn(3,10)
lft = calc(p.data.channels,grid)
print type(lft.leadfield), shape(lft.leadfield)
def __init__(self, datapdf, chlabel):
ch=channel.index(datapdf, 'meg')
chind=ch.channelindexhdr[ch.channelsortedlabels == chlabel]
self.d=data.read(datapdf)
self.d.getdata(0, self.d.pnts_in_file, chind)
self.d.data_block=offset.correct(self.d.data_block)
print self.d.data_block.shape
self.p=pdf.read(datapdf)
self.ext = 'pymtimef'
def assistMEG(self):
def dothis():
print 1
self.assistant = self.builder.get_object("assistant1")#.show()
self.assistant.show()
#path = '/home/danc/python/data/0611SEF/e,rfhp1.0Hz,n,x,baha001-1SEF,f50lp'
path = self.fn
#self.data = pdf.read(path)
self.datadict[path] = pdf.read(path)
self.builder.get_object("entry3").set_text(str(self.datadict[path].data.pnts_in_file[0]))
def plotallpnts(self, event): # wxGlade: MyFrame.<event_handler>
print "Event handler `plotallpnts' not implemented"
r = self.postcheck()
if r == -1: #nothing posted
return
print 'plotting ',self.datapdf
self.p = pdf.read(self.datapdf[0])
print self.p
ind=hstack([self.p.hs.index_lpa,self.p.hs.index_rpa,self.p.hs.index_nasion]).reshape(3,3)
s=sensors.locations(self.datapdf[0])
plotvtk.display(self.p.hs.hs_point, s.megchlpos, ind)
def readdata(self,widget):
#self.assistant.destroy()
#self.parseddatadict = {'meg':'NA','mri':'NA'}
#path = '/home/danc/python/data/0611SEF/e,rfhp1.0Hz,n,x,baha001-1SEF,f50lp'
self.builder.get_object("assistant1").hide()
path = self.fn
if self.parseddatadict.get(path, False) != False:
self.statusbar.push(self.statusbar_cid, 'File exists in your workspace. Not loading')
return
self.dataList.clear()
#self.data = pdf.read(path)
self.parseinstance(self.datadict[path])
datatype = 'meg'
if datatype == 'meg':
#self.data = pdf.read(path)
self.datadict[path] = pdf.read(path)
self.parseddatadict[path] = self.parseddata.out
#self.datadict[path] = self.data #store the actual loaded data
chindex = []
for c in self.chanlist:
print 'c',c
self.datadict[path].data.setchannels(c)
#chindex.extend(self.datadict[path].data.channels.channelindexhdr.tolist())
chindex.extend(self.datadict[path].data.channels.indexlist)
#print chindex
#print 'start and end',int(self.builder.get_object("entry2").get_text()), \
int(self.builder.get_object("entry3").get_text())
self.datadict[path].data.getdata(int(self.builder.get_object("entry2").get_text()), \
int(self.builder.get_object("entry3").get_text()), chindex=chindex)
#from pylab import plot,show
#plot(self.data.data.data_block);show()
self.datadict[path].data.channels.getposition()
self.refreshdatasummary()
#self.parseinstance(self.datadict[path])
#self.parseddatadict[path] = self.parseddata.out
print 'datashape', shape(self.datadict[path].data.data_block)
for i in self.parseddatadict:
print 'appending model', i
iter = self.dataList.append([i, self.datadict[path]])
#self.treedata = self.parseddata.out
#make results instance
self.datadict[path].results = self.datadict[path].__class__
def load_file(self,path=None):
print 'loading file'
self.assistant.set_page_complete(self.assistant.get_nth_page(0), True)
self.pdfdata = pdf.read(path)
self.ne = self.pdfdata.hdr.header_data.total_epochs[0]
print 'ne',self.ne
if self.ne > 1: #only load value in epochs
self.builder.get_object("label32").set_text('First Epoch')
self.builder.get_object("label33").set_text('Last Epoch')
self.builder.get_object("entry29").set_text(str(0))
self.builder.get_object("entry30").set_text(str(self.ne))
else:
self.builder.get_object("entry30").set_text(str(self.pdfdata.data.pnts_in_file[0]))
self.path = path
def changed_cb(self, combobox):
model = combobox.get_model()
index = combobox.get_active()
if index > -1:
#print model[index][0], 'selected'
self.chan_sel = str(model[index][0])
file_widget = self.builder.get_object("filechooserbutton1")
ct = pdf.read(file_widget.get_filename()) #4D file read
#self.p.data.setchannels('trig') #datatype equals 'trigger'
ct.data.setchannellabels([self.chan_sel])
ct.data.getdata(0, ct.data.pnts_in_file) #read the whole file
self.builder.get_object("entry5").set_text(str(ct.data.data_block.max()/3))
self.ct = ct
return
def retrievepdf(fn):
from pdf2py import pdf
p = pdf.read(fn)
p.data.setchannels("meg")
p.data.getdata(0, p.data.pnts_in_file)
p.data.offsetcorrect(start=0, end=-1)
data = np.float32(p.data.data_block[:, :])
# chlabels = np.arange(0,np.size(p.data.data_block,1))
chlabels = p.data.channels.channelsortedlabels
sp = p.hdr.header_data.sample_period
sr = 1 / sp
# timeaxes = p.data.eventtime#np.arange(0,sp*1000, sp)
timeaxes = np.tile(p.data.eventtime, p.data.numofepochs)
timeaxes = np.arange(0, p.data.eventtime[-1] * p.data.numofepochs, sp)
print "timeaxes", timeaxes.shape
return data, timeaxes, chlabels, sr
def __init__(self, pdfdataobj, data, chind, power='off'):#, seedpoint, weight, iterations):
'''
p = pdf.read(path2pdf)
p.data.setchannels('meg')
p.data.channels.getposition()
chind = p.data.channels.sensorpos.chlpos[:,1]>0
'''
p = pdf.read(pdfdataobj)
p.data.setchannels('meg')
p.data.channels.getposition()
if size(data.shape) == 1: #make 2d
data = array([data])
numhspts = size(p.hs.hs_point,0)
d = zeros([numhspts])
for j in range(0, numhspts): #distance from 0,0,40 mm to all hs points
d[j] = euclid.distarray([0,0,40],p.hs.hs_point[j]*1000)
self.d = d
self.n = euclid.distarray([0,0,40],p.hs.index_nasion*1000)
numofgrids = ng = 6 #d.max()
startgridspacing = gs = float((self.n.max()/ng)*2) #mm
cog = centerofgrid = array([0,0,40]) #mm
iterations = 10
for i in range(0,iterations): #iterate over grids
scaledgs = gs/(i+1); print 'gs',gs
print cog,ng,scaledgs
e = grid.sphere(cog,ng,scaledgs)
self.e = e
self.lf = leadfield.calc(pdfdataobj, p.data.channels, e)
if power == 'on': #doing power localization. ABS of leadfields
self.w = calc(pdfdataobj, abs(self.lf.leadfield[:,chind,:]), data[:,chind])
else:
self.w = calc(pdfdataobj, self.lf.leadfield[:,chind,:], data[:,chind])
cog = self.lf.grid[argmax(self.w.corr_mat)]
gof = self.w.corr_mat.max()
print gof, cog
gs = scaledgs
self.bestfit = cog
self.gof = gof
def __init__(self, datapdf, index):
'''returns sensor locations from an index provided
sensors.locationsbyindex(datapdf, ch.channelindexcfg)'''
pdfinstance=pdf.read(datapdf)
self.chlpos=array([]);self.chupos=array([])
self.chldir=array([]);self.chudir=array([])
self.chname = array([])
for i in index:
self.chupos = append(self.chupos,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].position)
self.chlpos = append(self.chlpos,pdfinstance.cfg.channel_data[i].device_data.loop_data[1].position)
self.chudir = append(self.chudir,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].direction)
self.chldir = append(self.chldir,pdfinstance.cfg.channel_data[i].device_data.loop_data[1].direction)
self.chname = append(self.chname, pdfinstance.cfg.channel_data[i].name)
self.chupos=self.chupos.reshape(size(self.chupos)/3,3)
self.chlpos=self.chlpos.reshape(size(self.chlpos)/3,3)
self.chudir=self.chudir.reshape(size(self.chudir)/3,3)
self.chldir=self.chldir.reshape(size(self.chldir)/3,3)
def __init__(self, datapdf, channelinstance):
pdfinstance=pdf.read(datapdf)
chlpos=array([]);chupos=array([])
chldir=array([]);chudir=array([])
for i in channelinstance.channelindexcfg:
chlpos=append(chlpos,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].position)
chupos=append(chupos,pdfinstance.cfg.channel_data[i].device_data.loop_data[1].position)
chldir=append(chldir,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].direction)
chudir=append(chudir,pdfinstance.cfg.channel_data[i].device_data.loop_data[1].direction)
#reshape arrays
chlpos=chlpos.reshape(size(chlpos)/3,3)
chupos=chupos.reshape(size(chupos)/3,3)
chldir=chldir.reshape(size(chldir)/3,3)
chudir=chudir.reshape(size(chudir)/3,3)
self.chlpos=chlpos
self.chupos=chupos
self.chldir=chldir
self.chudir=chudir
def getdata():
sr = np.float32(100.0)
sp = 1 / sr
data = np.random.rand(10000, 100)
timeaxes = np.arange(0, sp * 1000, sp)
from pdf2py import pdf # , readwrite
fn = "/home/danc/python/data/0611SEF/e,rfhp1.0Hz,n,x,baha001-1SEF,f50lp"
# ~ sr = 290.64 #sample rate
# ~ sp = 1/sr #sample period
p = pdf.read(fn)
p.data.setchannels("meg")
p.data.getdata(0, p.data.pnts_in_file)
p.data.offsetcorrect(start=0, end=-1)
data = np.float32(p.data.data_block[:, :])
# ~ timeaxes = np.arange(0,sp*p.data.pnts_in_file, sp)
# data = np.random.rand(256,500)
chlabels = np.arange(0, 244)
return data, timeaxes, chlabels
def get_trigger_events_from_data(self,widget):#,xtrachannellabels=None):
if self.builder.get_object("togglebutton1").get_active():
self.builder.get_object("togglebutton1").set_active(False)
trigger_channels = ['TRIGGER','RESPONSE']; #default trig ch
#if xtrachannellabels != None:
#trigger_channels.append(xtrachannellabels)#adding a custom channel
#p.data.setchannellabels(['Pinky','TRIGGER', 'RESPONSE'])
print 'filename', self.builder.get_object('filechooserbutton1').get_uri()
print(widget.get_filename())
try:
self.p = pdf.read(widget.get_filename()) #4D file read
#self.p.data.setchannels('trig') #datatype equals 'trigger'
self.p.data.setchannellabels(trigger_channels)
self.p.data.getdata(0, self.p.data.pnts_in_file) #read the whole file
self.data = self.p.data.data_block #actual data array
self.srate = self.p.data.srate
self.wintime = self.p.data.wintime #timecourse
u,n,nz = trigger.vals(self.data) #u is the event value
self.event_dict = event_logic.get_ind(u,self.data) #dictionary with indices to events
print self.event_dict
self.event_list = array(u,int32)
print self.event_list
self.channellist = array([]) #ch list for custom trigger channel
for i in self.p.hdr.channel_ref_data:
try: self.channellist = append(self.channellist, i.chan_label)
except AttributeError: self.channellist = [i.chan_label]
self.event_tree(None,self.event_list,self.event_dict,treeview='treeview1')
self.builder.get_object('button1').set_sensitive(True)
except TypeError:
pass
try: self.custom_ch_ind = self.p.data.channels.labellist.index(self.chan_sel)
except: pass
def quick_load_pdf_script(self):
from pdf2py import pdf
datapath = '/home/danc/programming/python/data/'
p = pdf.read(datapath+'test/e,rfhp1.0Hz,ra')
#p = pdf.read(datapath+'0611/0611piez/e,rfhp1.0Hz')
#p = pdf.read(datapath+'data/0611/drawing3/01%01%01@01:01/2/c,rfDC')
p.data.setchannels('meg')
#p.data.setchannellabels(['A1','A69','A130'])#meg')
#p.data.setchannellabels(['A178'])
p.data.getdata(0,p.data.pnts_in_file)
self.numchannels = size(p.data.data_block,1)
self.t = p.data.wintime #eventtime
self.data = p.data.data_block
self.tstart = 0; self.tstop = len(self.t)
self.time = copy(self.t[self.tstart:self.tstop])
self.chanind = arange(self.numchannels)
self.chanlabels = p.data.channels.labellist
self.scalefact = (p.data.data_block.min()+p.data.data_block.max())/2
self.channels = p.data.channels.chanlocs
self.srate = p.hdr.header_data.sample_period
self.data_loaded_setup()
self.curchannel = 0
def prnt(self, widget):
print 'clicked'
fns = ['/home/danc/python/data/0611SEF/e,rfhp1.0Hz,n,x,baha001-1SEF,f50lp']#,'/home/danc/python/data/0611piez/SupinePiez/07%08%04@09:33/1/e,rfhp1.0Hz,ra,f50lp,o']
self.builder.get_object("entry1").set_text('it works')
self.statusbar.push(self.statusbar_cid, 'it works')
#self.memorystat(self)
#self.builder.get_object("windowTreeview").show()
for i in fns:
print 'i', i
self.fn = path = i
self.datadict[path] = pdf.read(self.fn)
self.chanlist = ['meg']
self.builder.get_object("entry2").set_text('0')
self.builder.get_object("entry3").set_text('100')
#data.var = 'meg'
#self.parseinstance(data)
#iter = self.dataList.append([data.var, 'test'])
self.readdata(self)
#tb = self.builder.get_object("toolbutton2").is_active()
if self.builder.get_object("toolbutton2").get_active() == True:
self.builder.get_object("windowTreeview").show()
else:
self.builder.get_object("windowTreeview").hide()
def __init__(self, datapdf):
'''returns unsorted meg signal sensors... A1,A2,etc'''
pdfinstance=pdf.read(datapdf)
for i in range(0, size(pdfinstance.cfg.channel_data)):
if i==1: #create empty array
megchlpos=array([])
megchupos=array([])
refshpos=array([])
megchldir=array([])
megchudir=array([])
refshdir=array([])
self.name = array([])
if pdfinstance.cfg.channel_data[i].type==1: #get MEG positions in array
#megchlpos2=append(megchlpos,pdfinstance.cfg.channel_data[pdfinstance.cfg.channel_data[223].chan_no-1].device_data.loop_data[0].position)
megchlpos=append(megchlpos,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].position)
megchupos=append(megchupos,pdfinstance.cfg.channel_data[i].device_data.loop_data[1].position)
megchldir=append(megchldir,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].direction)
megchudir=append(megchudir,pdfinstance.cfg.channel_data[i].device_data.loop_data[1].direction)
self.name = append(self.name, pdfinstance.cfg.channel_data[i].name)
if pdfinstance.cfg.channel_data[i].type==3: #get ref positions in array
refshpos=append(refshpos,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].position)
refshdir=append(refshdir,pdfinstance.cfg.channel_data[i].device_data.loop_data[0].position)
#reshape arrays
megchlpos=megchlpos.reshape(size(megchlpos)/3,3)
megchupos=megchupos.reshape(size(megchupos)/3,3)
refshpos=refshpos.reshape(size(refshpos)/3,3)
megchldir=megchldir.reshape(size(megchldir)/3,3)
megchudir=megchudir.reshape(size(megchudir)/3,3)
refshdir=refshdir.reshape(size(refshdir)/3,3)
self.megchlpos=megchlpos
self.megchupos=megchupos
self.megchldir=megchldir
self.megchudir=megchudir
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
from numpy import *
import math
from gui.wx import file
fn = file.open()
from pdf2py import pdf
p = pdf.read(fn[0])
p.data.setchannels('meg')
p.data.getdata(0,p.data.pnts_in_file)
p.data.channels.getposition()
#chA1pos = p.data.channels.chlpos[0]
centofsphere = array([0,0,.04]) #center of sphere
chlpos_ = p.data.channels.chlpos - centofsphere
chupos_ = p.data.channels.chupos - centofsphere
from meg import euclid
#Din = euclid.dist(centofsphere, p.data.channels.chlpos)
Din = euclid.dist(array([0,0,0]), chlpos_)
chmin = Din.argmin(); r_min = Din.min()
#Dout = euclid.dist(centofsphere, p.data.channels.chupos)
Dout = euclid.dist(array([0,0,0]), chupos_)
chmax = Dout.argmax(); r_max = Dout.max()
import sys
from pdf2py import lA2array,pdf
from scipy.io.numpyio import *
try:
fn = sys.argv[1]
fswitch = sys.argv[2]
fileoutput = sys.argv[3]
except IndexError:
print 'use: print_dipole.py "path to lA file" -f output_file_name'
sys.exit(-1)
p = pdf.read(fn)
p.data.setchannels('derived')
p.data.getdata(0, p.data.pnts_in_file)
x=p.data.hdr.proc_data[0]
#z=x.proc_step[1].user_data.split('\x00')
#z = remove_empty(z)
#pid = p.data.pid
#session = z[0]
#run = z[1]
#filename = z[2]
#z = x.proc_step[3].user_data.split('\x00') #channel data
#z = remove_empty(z)
dfa_info = x.proc_step[7].user_data.split('\x00')[0]
pid = p.data.pid
scan = p.data.scan
def pdfcheck(self, widget):
print 'pdfcheck'
p = pdf.read(self.builder.get_object("filechooserbutton2").get_filename())
print 'pdf to try and read', p
self.headshape = p.hs
print self.headshape,'headshape'
ballActor, profile = vtkpoints(points, color=color[color.keys()[k]], radius=radius[radius.keys()[k]])
ren.AddActor(ballActor) # Add the actors to the renderer, set the background and size
# outline = vtk.vtkOutlineFilter()
# outline.SetInput(mapBalls.GetOutput())
# outlineMapper = vtk.vtkPolyDataMapper()
# outlineMapper.SetInput(outline.GetOutput())
# outlineActor = vtk.vtkActor()
# outlineActor.SetMapper(outlineMapper)
# outlineActor.GetProperty().SetColor(1,1,1)
iren.Initialize()
ren.ResetCamera()
renWin.Render()
iren.Start()
if __name__ == "__main__":
from pdf2py import pdf
p = pdf.read("/home/danc/programming/python/data/0611/0611piez/e,rfhp1.0Hz,ra,f50lp,o")
p.data.setchannels("meg")
p.data.channels.getchannellocations()
points = p.data.channels.chlpos
dirs = p.data.channels.chudir
d = {"data": points} # ,'color':[255,0,0],'radius':[.01,.01,.01]}
display(d, color={"color": [255, 0, 0]}, radius={"radius": 0.01}, shape_type={"disks": dirs})
quit
def getleadfield(self):
from meg import leadfield
from pdf2py import pdf
p = pdf.read(self.path2pdf);p.data.setchannels('meg')
self.lf = leadfield.calc(self.path2pdf, p.data.channels, self.scaledgrid*1000)
def __init__(self, datapdf, datatemplate):
self.datapiece=tap.chunk(datapdf); print 'init datafile' #initialize datafile
self.datapiece.setparams(datatemplate, trig='TRIGGER') ; print 'init parameters'#initialize parameters
self.pdfobj=pdf.read(datatemplate)
#z = dot(self.data,ica.get_recmatrix().T)
#z = z-z[0]
labels = []
for i in arange(size(comp,1)):
labels = append(labels,'comp'+str(i))
print 'done'
results = {'weights':comp,'activations':ica.get_recmatrix(),'labellist':labels}
try: self.callback(results)
except: return results
#subplot(2,1,1)
#plot(comp);
#subplot(2,1,2)
#plot(self.data-self.data[0]);
#show()
if __name__ == "__main__":
from pdf2py import pdf
p = pdf.read('/home/danc/data/meg/0611piez/e,rfhp1.0Hz,ra,f50lp,o')
p.data.setchannels('meg')
p.data.getdata(0,p.data.pnts_in_file)
mainwindow = setup(data=p.data.data_block)
mainwindow.window.show()
print('testing')
gtk.main()
