class FeResult(object):
_name_ = '__FePost__'
re_Skey = re.compile("S[0-5]")
re_Ukey = re.compile("U[0-2]")
def __init__(self,name=_name_,datasize={'U':3,'S':6,'COORD':3}):
self.name = name
self.datasize = datasize.copy()
self.about = {'creator':pf.Version,
'created':pf.StartTime,
}
self.modeldone = False
self.labels = {}
self.nelems = 0
self.nnodes = 0
self.dofs = None
self.displ = None
self.nodid = None
self.nodes = None
self.elems = None
self.nset = None
self.nsetkey = None
self.eset = None
self.res = None
self.hdr = None
self.nodnr = 0
self.elnr = 0
def dataSize(self,key,data):
if key in self.datasize:
return self.datasize[key]
else:
return len(data)
def Abqver(self,version):
self.about.update({'abqver':version})
def Date(self,date,time):
self.about.update({'abqdate':date,'abqtime':time})
def Size(self,nelems,nnodes,length):
self.nelems = nelems
self.nnodes = nnodes
self.length = length
self.nodid = -ones((nnodes,),dtype=int32)
self.nodes = zeros((nnodes,3),dtype=float32)
self.elems = {}
self.nset = {}
self.eset = {}
def Dofs(self,data):
self.dofs = array(data)
self.displ = self.dofs[self.dofs[:6] > 0]
if self.displ.max() > 3:
self.datasize['U'] = 6
def Heading(self,head):
self.about.update({'heading':head})
def Node(self,nr,coords,normal=None):
self.nodid[self.nodnr] = nr
nn = len(coords)
self.nodes[self.nodnr][:nn] = coords
self.nodnr += 1
def Element(self,nr,typ,conn):
if typ not in self.elems:
self.elems[typ] = []
self.elems[typ].append(conn)
def Nodeset(self,key,data):
self.nsetkey = key
self.nset[key] = asarray(data)
def NodesetAdd(self,data):
self.nset[self.nsetkey] = union1d(self.nset[self.nsetkey],asarray(data))
def Elemset(self,key,data):
self.esetkey = key
self.eset[key] = asarray(data)
def ElemsetAdd(self,data):
self.eset[self.esetkey] = union1d(self.eset[self.esetkey],asarray(data))
def Finalize(self):
self.nid = inverseUniqueIndex(self.nodid)
for k in self.elems.iterkeys():
v = asarray(self.elems[k])
self.elems[k] = asarray(self.nid[v])
self.modeldone = True
# we use lists, to keep the cases in order
self.res = ODict()
self.step = None
self.inc = None
def Increment(self,step,inc,**kargs):
"""Add a new step/increment to the database.
This method can be used to add a new increment to an existing step,
or to add a new step and set the initial increment, or to just select
an existing step/inc combination.
If the step/inc combination is new, a new empty result record is created.
The result record of the specified step/inc becomes the current result.
"""
if not self.modeldone:
self.Finalize()
if step != self.step:
if step not in self.res.keys():
self.res[step] = ODict()
self.step = step
self.inc = None
res = self.res[self.step]
if inc != self.inc:
if inc not in res.keys():
res[inc] = {}
self.inc = inc
self.R = self.res[self.step][self.inc]
def EndIncrement(self):
if not self.modeldone:
self.Finalize()
self.step = self.inc = -1
def Label(self,tag,value):
self.labels[tag] = value
def NodeOutput(self,key,nodid,data):
if key not in self.R:
self.R[key] = zeros((self.nnodes,self.dataSize(key,data)),dtype=float32)
if key == 'U':
self.R[key][nodid-1][self.displ-1] = data
elif key == 'S':
n1 = self.hdr['ndi']
n2 = self.hdr['nshr']
ind = arange(len(data))
ind[n1:] += (3-n1)
#print(ind)
self.R[key][nodid-1][ind] = data
else:
self.R[key][nodid-1][:len(data)] = data
def ElemHeader(self,**kargs):
self.hdr = dict(**kargs)
def ElemOutput(self,key,data):
if self.hdr['loc'] == 'na':
self.NodeOutput(key,self.hdr['i'],data)
def Export(self):
"""Align on the last increment and export results"""
try:
self.step = self.res.keys()[-1]
self.inc = self.res[self.step].keys()[-1]
self.R = self.res[self.step][self.inc]
except:
self.step = None
self.inc = None
self.R = None
export({self.name:self, self._name_:self})
pf.message("Read %d nodes, %d elements" % (self.nnodes,self.nelems))
if self.res is None:
pf.message("No results")
else:
pf.message("Steps: %s" % self.res.keys())
def do_nothing(*arg,**kargs):
"""A do nothing function to stand in for as yet undefined functions."""
pass
TotalEnergies = do_nothing
OutputRequest = do_nothing
Coordinates = do_nothing
Displacements = do_nothing
Unknown = do_nothing
def setStepInc(self,step,inc=1):
"""Set the database pointer to a given step,inc pair.
This sets the step and inc attributes to the given values, and puts
the corresponding results in the R attribute. If the step.inc pair does
not exist, an empty results dict is set.
"""
try:
self.step = step
self.inc = inc
self.R = self.res[self.step][self.inc]
except:
self.R = {}
def getSteps(self):
"""Return all the step keys."""
return self.res.keys()
def getIncs(self,step):
"""Return all the incs for given step."""
if step in self.res:
return self.res[step].keys()
def nextStep(self):
"""Skips to the start of the next step."""
if self.step < self.getSteps()[-1]:
self.setStepInc(self.step+1)
def nextInc(self):
"""Skips to the next increment.
The next increment is either the next increment of the current step,
or the first increment of the next step.
"""
if self.inc < self.getIncs(self.step)[-1]:
self.setStepInc(self.step,self.inc+1)
else:
self.nextStep()
def prevStep(self):
"""Skips to the start of the previous step."""
if self.step > 1:
self.setStepInc(self.step-1)
def prevInc(self):
"""Skips to the previous increment.
The previous increment is either the previous increment of the current
step, or the last increment of the previous step.
"""
if self.inc > 1:
self.setStepInc(self.step,self.inc-1)
else:
if self.step > 1:
step = self.step-1
inc = self.getIncs(step)[-1]
self.setStepInc(step,inc)
def getres(self,key,domain='nodes'):
"""Return the results of the current step/inc for given key.
The key may include a component to return only a single column
of a multicolumn value.
"""
components = '012'
if self.re_Skey.match(key):
if self.datasize['S']==3:
components = '013'
else:
components = '012345'
elif self.re_Ukey.match(key):
if self.datasize['U']==2:
components = '01'
else:
components = '012'
comp = components.find(key[-1])
if comp >= 0:
key = key[:-1]
if key in self.R:
val = self.R[key]
if comp in range(val.shape[1]):
return val[:,comp]
else:
return val
else:
return None
def printSteps(self):
"""Print the steps/increments/resultcodes for which we have results."""
if self.res is not None:
for i,step in self.res.iteritems():
for j,inc in step.iteritems():
for k,v in inc.iteritems():
if isinstance(v,ndarray):
data = "%s %s" % (v.dtype.kind,str(v.shape))
else:
data = str(v)
print("Step %s, Inc %s, Res %s (%s)" % (i,j,k,data))
_I('nmod', 100, text='Number of cells along spiral'),
_I('turns', 2.5, text='Number of 360 degree turns'),
_I('rfunc', None, text='Spiral function', choices=rfuncs),
_I('coeffs', (1., 0.5, 0.2), text='Coefficients in the spiral function'),
_I('spiral3d', 0.0, text='Out of plane factor'),
_I('spread', False, text='Spread points evenly along spiral'),
_I('nwires', 1, text='Number of spirals'),
_G('sweep',
text='Sweep Data',
checked=True,
items=[
_I('cross_section',
'cross',
'select',
text='Shape of cross section',
choices=cross_sections.keys()),
_I('cross_rotate',
0.,
text='Cross section rotation angle before sweeping'),
_I('cross_upvector',
'2',
text='Cross section vector that keeps its orientation'),
_I('cross_scale', 0., text='Cross section scaling factor'),
]),
_I('flyalong', False, text='Fly along the spiral'),
]
def spiral(X, dir=[0, 1, 2], rfunc=lambda x: 1, zfunc=lambda x: 0):
"""Perform a spiral transformation on a coordinate array"""
theta = X[..., dir[0]]
'solid_square': '4:0123',
'solid_triangle': '3:012',
'swastika3': '3:012023034041',
})
input_data = [
_I('nmod',100,text='Number of cells along spiral'),
_I('turns',2.5,text='Number of 360 degree turns'),
_I('rfunc',None,text='Spiral function',choices=rfuncs),
_I('coeffs',(1.,0.5,0.2),text='Coefficients in the spiral function'),
_I('spiral3d',0.0,text='Out of plane factor'),
_I('spread',False,text='Spread points evenly along spiral'),
_I('nwires',1,text='Number of spirals'),
_G('sweep',text='Sweep Data',checked=True,items= [
_I('cross_section','cross','select',text='Shape of cross section',choices=cross_sections_2d.keys()),
_I('cross_rotate',0.,text='Cross section rotation angle before sweeping'),
_I('cross_upvector','2',text='Cross section vector that keeps its orientation'),
_I('cross_scale',0.,text='Cross section scaling factor'),
]),
_I('flyalong',False,text='Fly along the spiral'),
]
def spiral(X,dir=[0,1,2],rfunc=lambda x:1,zfunc=lambda x:0):
"""Perform a spiral transformation on a coordinate array"""
theta = X[...,dir[0]]
r = rfunc(theta) + X[...,dir[1]]
x = r * cos(theta)
y = r * sin(theta)
z = zfunc(theta) + X[...,dir[2]]
class FeResult(object):
data_size = {'U':3,'S':6,'COORD':3}
re_Skey = re.compile("S[0-5]")
def __init__(self):
self.about = {'creator':GD.Version,
'created':GD.StartTime,
}
self.modeldone = False
self.labels = {}
self.nelems = 0
self.nnodes = 0
self.dofs = None
self.displ = None
self.nodid = None
self.nodes = None
self.elems = None
self.nset = None
self.nsetkey = None
self.eset = None
self.res = None
self.hdr = None
self.nodnr = 0
self.elnr = 0
def datasize(self,key,data):
if FeResult.data_size.has_key(key):
return FeResult.data_size[key]
else:
return len(data)
def Abqver(self,version):
self.about.update({'abqver':version})
def Date(self,date,time):
self.about.update({'abqdate':date,'abqtime':time})
def Size(self,nelems,nnodes,length):
self.nelems = nelems
self.nnodes = nnodes
self.length = length
self.nodid = -ones((nnodes,),dtype=int32)
self.nodes = zeros((nnodes,3),dtype=float32)
self.elems = {}
self.nset = {}
self.eset = {}
def Dofs(self,data):
self.dofs = array(data)
self.displ = self.dofs[self.dofs[:6] > 0]
if self.displ.max() > 3:
self.data_size['U'] = 6
def Heading(self,head):
self.about.update({'heading':head})
def Node(self,nr,coords,normal=None):
self.nodid[self.nodnr] = nr
nn = len(coords)
self.nodes[self.nodnr][:nn] = coords
self.nodnr += 1
def Element(self,nr,typ,conn):
if not self.elems.has_key(typ):
self.elems[typ] = []
self.elems[typ].append(conn)
def Nodeset(self,key,data):
self.nsetkey = key
self.nset[key] = asarray(data)
def NodesetAdd(self,data):
self.nset[self.nsetkey] = union1d(self.nset[self.nsetkey],asarray(data))
def Elemset(self,key,data):
self.esetkey = key
self.eset[key] = asarray(data)
def ElemsetAdd(self,data):
self.eset[self.esetkey] = union1d(self.eset[self.esetkey],asarray(data))
def Finalize(self):
self.nid = connectivity.reverseUniqueIndex(self.nodid)
for k in self.elems.iterkeys():
v = asarray(self.elems[k])
self.elems[k] = asarray(self.nid[v])
self.modeldone = True
# we use lists, to keep the cases in order
self.res = ODict()
self.step = None
self.inc = None
def Increment(self,step,inc,**kargs):
if not self.modeldone:
self.Finalize()
if step != self.step:
if step not in self.res.keys():
self.res[step] = ODict()
self.step = step
self.inc = None
res = self.res[self.step]
if inc != self.inc:
if inc not in res.keys():
res[inc] = {}
self.inc = inc
self.R = self.res[self.step][self.inc]
def EndIncrement(self):
if not self.modeldone:
self.Finalize()
self.step = self.inc = -1
def Label(self,tag,value):
self.labels[tag] = value
def NodeOutput(self,key,nodid,data):
if not self.R.has_key(key):
self.R[key] = zeros((self.nnodes,self.datasize(key,data)),dtype=float32)
if key == 'U':
self.R[key][nodid-1][self.displ-1] = data
elif key == 'S':
n1 = self.hdr['ndi']
n2 = self.hdr['nshr']
ind = arange(len(data))
ind[n1:] += (3-n1)
#print ind
self.R[key][nodid-1][ind] = data
else:
self.R[key][nodid-1][:len(data)] = data
def ElemHeader(self,**kargs):
self.hdr = dict(**kargs)
def ElemOutput(self,key,data):
if self.hdr['loc'] == 'na':
self.NodeOutput(key,self.hdr['i'],data)
def Export(self):
"""Align on the last increment and export results"""
try:
self.step = self.res.keys()[-1]
self.inc = self.res[self.step].keys()[-1]
self.R = self.res[self.step][self.inc]
except:
self.step = None
self.inc = None
self.R = None
export({'DB':self})
GD.message("Read %d nodes, %d elements" % (self.nnodes,self.nelems))
if self.res is None:
GD.message("No results")
else:
GD.message("Steps: %s" % self.res.keys())
def do_nothing(*arg,**kargs):
"""A do nothing function to stand in for as yet undefined functions."""
pass
TotalEnergies = do_nothing
OutputRequest = do_nothing
Coordinates = do_nothing
Displacements = do_nothing
Unknown = do_nothing
def setStepInc(self,step,inc):
try:
self.step = step
self.inc = inc
self.R = self.res[self.step][self.inc]
except:
self.R = {}
def getSteps(self):
"""Return all the step keys."""
return self.res.keys()
def getIncs(self,step):
"""Return all the incs for given step."""
if self.res.has_key(step):
return self.res[step].keys()
def getres(self,key,domain='nodes'):
"""Return the results of the current step/inc for given key.
The key may include a component to return only a single column
of a multicolumn value.
"""
#print self.dofs
if self.re_Skey.match(key) and self.data_size['S']==3:
components = '013'
else:
components = '012345'
comp = components.find(key[-1])
if comp >= 0:
key = key[:-1]
if self.R.has_key(key):
val = self.R[key]
if comp in range(val.shape[1]):
return val[:,comp]
else:
return val
else:
return None
def printSteps(self):
"""Print the steps/increments/resultcodes for which we have results."""
if self.res is not None:
for i,step in self.res.iteritems():
for j,inc in step.iteritems():
for k,v in inc.iteritems():
print "Step %s, Inc %s, Res %s (%s)" % (i,j,k,str(v.shape))
dataset = [
Coords([[6., 7., 12.],[9., 5., 6.],[11., -2., 6.], [9., -4., 14.]]),
Coords([[-5., -10., -4.], [-3., -5., 2.],[-4., 0., -4.], [-4., 5, 4.],
[6., 3., -1.], [6., -9., -1.]]),
Coords([[-1., 7., -14.], [-4., 7., -8.],[-7., 5., -14.],[-8., 2., -14.],
[-7., 0, -6.], [-5., -3., -11.], [-7., -4., -11.]]),
Coords([[-1., 1., -4.], [1., 1., 2.],[2.6, 2., -4.], [2.9, 3.5, 4.],
[2., 4., -1.],[1.,3., 1.], [0., 0., 0.], [0., -3., 0.],
[2., -1.5, -2.], [1.5, -1.5, 2.], [0., -8., 0.], [-1., -8., -1.],
[3., -3., 1.]]),
]
data_items = [
['DataSet','3','select',map(str,range(len(dataset)))],
['CurveType',None,'select',method.keys()],
['Closed',False],
['Tension',0.0],
['Curl',0.5],
['InterPoints',None,'select',['points','pointsAt']],
['Nintervals',10],
['ExtendAtStart',0.0],
['ExtendAtEnd',0.0],
['Clear',True],
]
globals().update([i[:2] for i in data_items])
clear()
setDrawOptions({'bbox':'auto','view':'front'})
while not GD.dialog_timeout:
class FeResult(object):
_name_ = '__FePost__'
re_Skey = re.compile("S[0-5]")
re_Ukey = re.compile("U[0-2]")
def __init__(self, name=_name_, datasize={'U': 3, 'S': 6, 'COORD': 3}):
self.name = name
self.datasize = datasize.copy()
self.about = {
'creator': pf.Version,
'created': pf.StartTime,
}
self.modeldone = False
self.labels = {}
self.nelems = 0
self.nnodes = 0
self.dofs = None
self.displ = None
self.nodid = None
self.nodes = None
self.elems = None
self.nset = None
self.nsetkey = None
self.eset = None
self.res = None
self.hdr = None
self.nodnr = 0
self.elnr = 0
def dataSize(self, key, data):
if key in self.datasize:
return self.datasize[key]
else:
return len(data)
def Abqver(self, version):
self.about.update({'abqver': version})
def Date(self, date, time):
self.about.update({'abqdate': date, 'abqtime': time})
def Size(self, nelems, nnodes, length):
self.nelems = nelems
self.nnodes = nnodes
self.length = length
self.nodid = -ones((nnodes, ), dtype=int32)
self.nodes = zeros((nnodes, 3), dtype=float32)
self.elems = {}
self.nset = {}
self.eset = {}
def Dofs(self, data):
self.dofs = array(data)
self.displ = self.dofs[self.dofs[:6] > 0]
if self.displ.max() > 3:
self.datasize['U'] = 6
def Heading(self, head):
self.about.update({'heading': head})
def Node(self, nr, coords, normal=None):
self.nodid[self.nodnr] = nr
nn = len(coords)
self.nodes[self.nodnr][:nn] = coords
self.nodnr += 1
def Element(self, nr, typ, conn):
if typ not in self.elems:
self.elems[typ] = []
self.elems[typ].append(conn)
def Nodeset(self, key, data):
self.nsetkey = key
self.nset[key] = asarray(data)
def NodesetAdd(self, data):
self.nset[self.nsetkey] = union1d(self.nset[self.nsetkey],
asarray(data))
def Elemset(self, key, data):
self.esetkey = key
self.eset[key] = asarray(data)
def ElemsetAdd(self, data):
self.eset[self.esetkey] = union1d(self.eset[self.esetkey],
asarray(data))
def Finalize(self):
self.nid = inverseUniqueIndex(self.nodid)
for k in self.elems.iterkeys():
v = asarray(self.elems[k])
self.elems[k] = asarray(self.nid[v])
self.modeldone = True
# we use lists, to keep the cases in order
self.res = ODict()
self.step = None
self.inc = None
def Increment(self, step, inc, **kargs):
"""Add a new step/increment to the database.
This method can be used to add a new increment to an existing step,
or to add a new step and set the initial increment, or to just select
an existing step/inc combination.
If the step/inc combination is new, a new empty result record is created.
The result record of the specified step/inc becomes the current result.
"""
if not self.modeldone:
self.Finalize()
if step != self.step:
if step not in self.res.keys():
self.res[step] = ODict()
self.step = step
self.inc = None
res = self.res[self.step]
if inc != self.inc:
if inc not in res.keys():
res[inc] = {}
self.inc = inc
self.R = self.res[self.step][self.inc]
def EndIncrement(self):
if not self.modeldone:
self.Finalize()
self.step = self.inc = -1
def Label(self, tag, value):
self.labels[tag] = value
def NodeOutput(self, key, nodid, data):
if key not in self.R:
self.R[key] = zeros((self.nnodes, self.dataSize(key, data)),
dtype=float32)
if key == 'U':
self.R[key][nodid - 1][self.displ - 1] = data
elif key == 'S':
n1 = self.hdr['ndi']
n2 = self.hdr['nshr']
ind = arange(len(data))
ind[n1:] += (3 - n1)
#print(ind)
self.R[key][nodid - 1][ind] = data
else:
self.R[key][nodid - 1][:len(data)] = data
def ElemHeader(self, **kargs):
self.hdr = dict(**kargs)
def ElemOutput(self, key, data):
if self.hdr['loc'] == 'na':
self.NodeOutput(key, self.hdr['i'], data)
def Export(self):
"""Align on the last increment and export results"""
try:
self.step = self.res.keys()[-1]
self.inc = self.res[self.step].keys()[-1]
self.R = self.res[self.step][self.inc]
except:
self.step = None
self.inc = None
self.R = None
export({self.name: self, self._name_: self})
pf.message("Read %d nodes, %d elements" % (self.nnodes, self.nelems))
if self.res is None:
pf.message("No results")
else:
pf.message("Steps: %s" % self.res.keys())
def do_nothing(*arg, **kargs):
"""A do nothing function to stand in for as yet undefined functions."""
pass
TotalEnergies = do_nothing
OutputRequest = do_nothing
Coordinates = do_nothing
Displacements = do_nothing
Unknown = do_nothing
def setStepInc(self, step, inc=1):
"""Set the database pointer to a given step,inc pair.
This sets the step and inc attributes to the given values, and puts
the corresponding results in the R attribute. If the step.inc pair does
not exist, an empty results dict is set.
"""
try:
self.step = step
self.inc = inc
self.R = self.res[self.step][self.inc]
except:
self.R = {}
def getSteps(self):
"""Return all the step keys."""
return self.res.keys()
def getIncs(self, step):
"""Return all the incs for given step."""
if step in self.res:
return self.res[step].keys()
def nextStep(self):
"""Skips to the start of the next step."""
if self.step < self.getSteps()[-1]:
self.setStepInc(self.step + 1)
def nextInc(self):
"""Skips to the next increment.
The next increment is either the next increment of the current step,
or the first increment of the next step.
"""
if self.inc < self.getIncs(self.step)[-1]:
self.setStepInc(self.step, self.inc + 1)
else:
self.nextStep()
def prevStep(self):
"""Skips to the start of the previous step."""
if self.step > 1:
self.setStepInc(self.step - 1)
def prevInc(self):
"""Skips to the previous increment.
The previous increment is either the previous increment of the current
step, or the last increment of the previous step.
"""
if self.inc > 1:
self.setStepInc(self.step, self.inc - 1)
else:
if self.step > 1:
step = self.step - 1
inc = self.getIncs(step)[-1]
self.setStepInc(step, inc)
def getres(self, key, domain='nodes'):
"""Return the results of the current step/inc for given key.
The key may include a component to return only a single column
of a multicolumn value.
"""
components = '012'
if self.re_Skey.match(key):
if self.datasize['S'] == 3:
components = '013'
else:
components = '012345'
elif self.re_Ukey.match(key):
if self.datasize['U'] == 2:
components = '01'
else:
components = '012'
comp = components.find(key[-1])
if comp >= 0:
key = key[:-1]
if key in self.R:
val = self.R[key]
if comp in range(val.shape[1]):
return val[:, comp]
else:
return val
else:
return None
def printSteps(self):
"""Print the steps/increments/resultcodes for which we have results."""
if self.res is not None:
for i, step in self.res.iteritems():
for j, inc in step.iteritems():
for k, v in inc.iteritems():
if isinstance(v, ndarray):
data = "%s %s" % (v.dtype.kind, str(v.shape))
else:
data = str(v)
print("Step %s, Inc %s, Res %s (%s)" % (i, j, k, data))
Coords([[-5., -10., -4.], [-3., -5., 2.],[-4., 0., -4.], [-4., 5, 4.],
[6., 3., -1.], [6., -9., -1.]]),
Coords([[-1., 7., -14.], [-4., 7., -8.],[-7., 5., -14.],[-8., 2., -14.],
[-7., 0, -6.], [-5., -3., -11.], [-7., -4., -11.]]),
Coords([[-1., 1., -4.], [1., 1., 2.],[2.6, 2., -4.], [2.9, 3.5, 4.],
[2., 4., -1.],[1.,3., 1.], [0., 0., 0.], [0., -3., 0.],
[2., -1.5, -2.], [1.5, -1.5, 2.], [0., -8., 0.], [-1., -8., -1.],
[3., -3., 1.]]),
Coords([[0., 1., 0.],[0., 0.1, 0.],[0.1, 0., 0.], [1., 0., 0.]]),
Coords([[0., 1., 0.],[0.,0.,0.],[0.,0.,0.],[1., 0., 0.]]),
#Coords([[0., 1., 0.],[1., 0., 0.]]),
]
data_items = [
I('DataSet','0',choices=map(str,range(len(dataset)))),
I('CurveType',choices=method.keys()),
I('Closed',False),
I('EndCondition',choices=['notaknot','secder']),
I('Tension',0.0),
I('Curl',0.5),
I('Ndiv',10),
I('SpreadEvenly',False),
I('Ntot',40),
I('ExtendAtStart',0.0),
I('ExtendAtEnd',0.0),
I('Scale',[1.0,1.0,1.0]),
I('DrawAs',None,'hradio',choices=['Curve','Polyline']),
I('Clear',True),
I('ShowDirections',False),
I('CutWithPlane',False),
]
AlignedLines,
ParallelLinesOverWheel,
MotionInducedBlindness,
## FlickerInducedBlindness,
SineWave,
CirclesAndLines,
Crater,
Cussion,
CrazyCircles,
]
headers = [ getattr(f,'__doc__').split('\n')[0] for f in illusions ]
method = ODict(zip(headers,illusions))
data_items = [
['Illusion',None,'select',method.keys()],
['Explain',False,{'text':'Show explanation'}],
]
globals().update([i[:2] for i in data_items])
for i,it in enumerate(data_items):
data_items[i][1] = globals()[it[0]]
# Actions
def close():
"""Close the dialog"""
global dialog,explanation
if dialog:
dialog.close()
def run():
global image, scaled_image, viewer
flat()
lights(False)
transparent(False)
view('front')
# default image file
filename = getcfg('datadir')+'/butterfly.png'
image = None
scaled_image = None
w,h = 200,200
# image viewer widget
viewer = ImageView(filename)
transforms = ODict([
('flat', lambda F: F),
('cylindrical', lambda F: F.cylindrical([2,0,1],[2.,90./float(nx),1.]).rollAxes(-1)),
('spherical', lambda F: F.spherical(scale=[1.,90./float(nx),2.]).rollAxes(-1)),
('projected_on_cylinder', lambda F: F.projectOnCylinder(2*R,1)),
])
res = askItems([
_I('filename',filename,text='Image file',itemtype='button',func=selectImage),
viewer, # image previewing widget
_I('nx',w,text='width'),
_I('ny',h,text='height'),
_I('transform',itemtype='vradio',choices=transforms.keys()),
])
if not res:
return
globals().update(res)
if image is None:
print("Loading image")
loadImage(filename)
if image is None:
return
# Create the colors
sz = image.size()
print("Image size is (%s,%s)" % (sz.width(),sz.height()))
color,colortable = image2glcolor(image.scaled(nx,ny))
print("Converting image to color array")
# Create a 2D grid of nx*ny elements
print("Creating grid")
R = float(nx)/pi
L = float(ny)
F = Formex('4:0123').replic2(nx,ny).centered()
F = F.translate(2,R)
# Transform grid and draw
def drawTransform(transform):
print("Transforming grid")
trf = transforms[transform]
G = trf(F)
clear()
print("Drawing Colored grid")
draw(G,color=color,colormap=colortable)
drawText('Created with pyFormex',20,20,size=24)
drawTransform(transform)
zoomAll()
