diff --git a/lib/damask/colormaps.py b/lib/damask/colormaps.py
index 27083151c..e47e75b4b 100644
--- a/lib/damask/colormaps.py
+++ b/lib/damask/colormaps.py
@@ -1,22 +1,71 @@
#!/usr/bin/env python
-# suggestion to have class Color and class ColorMap, both use numpy arrays...
-# Color has properties:
-# .model
-# .color
-# and methods
-# .as/toOTHER (which checks own model and does appropriate conversion)
-
-
class Color():
'''
- There should be a doc string here :)
+ Conversion of colors between different color-spaces. Colors should be given in the form
+ Color('model',[vector]).To convert and copy color from one space to other, use the methods
+ to('model') and asModel('model')spectively
'''
import numpy
- __slots__ = ['model',
+
+ __slots__ = [
+ 'model',
'color',
]
+# ------------------------------------------------------------------
+ def __init__(self,
+ model = 'RGB',
+ color = numpy.zeros(3,'d')):
+ import numpy
+
+ self.__transforms__ = \
+ {'HSL': {'index': 0, 'next': self._HSL2RGB},
+ 'RGB': {'index': 1, 'next': self._RGB2XYZ, 'prev': self._RGB2HSL},
+ 'XYZ': {'index': 2, 'next': self._XYZ2CIELAB, 'prev': self._XYZ2RGB},
+ 'CIELAB': {'index': 3, 'next': self._CIELAB2MSH, 'prev': self._CIELAB2XYZ},
+ 'MSH': {'index': 4, 'prev': self._MSH2CIELAB},
+ }
+ model = model.upper()
+ if model not in self.__transforms__.keys(): model = 'RGB'
+ if model == 'RGB' and max(color) > 1.0: # are we RGB255 ?
+ for i in range(3):
+ color[i] /= 255.0 # rescale to RGB
+
+ if model == 'HSL': # are we HSL ?
+ if abs(color[0]) > 1.0: color[0] /= 360.0 # with angular hue?
+ while color[0] >= 1.0: color[0] -= 1.0 # rewind to proper range
+ while color[0] < 0.0: color[0] += 1.0 # rewind to proper range
+
+ self.model = model
+ self.color = numpy.array(color,'d')
+# ------------------------------------------------------------------
+ def __repr__(self):
+ return 'Model: %s Color: %s'%(self.model,str(self.color))
+# ------------------------------------------------------------------
+ def __str__(self):
+ return self.__repr__()
+# ------------------------------------------------------------------
+ def to(self,toModel = 'RGB'):
+ toModel = toModel.upper()
+ if toModel not in self.__transforms__.keys(): return
+
+ sourcePos = self.__transforms__[self.model]['index']
+ targetPos = self.__transforms__[toModel]['index']
+
+ while sourcePos < targetPos:
+ self.__transforms__[self.model]['next']()
+ sourcePos += 1
+
+ while sourcePos > targetPos:
+ self.__transforms__[self.model]['prev']()
+ sourcePos -= 1
+ return self
+# ------------------------------------------------------------------
+ def asModel(self,toModel = 'RGB'):
+ print self.__class__(self.model,self.color)
+ return self.__class__(self.model,self.color).to(toModel)
+# ------------------------------------------------------------------
# convert H(ue) S(aturation) L(uminance) to R(red) G(reen) B(lue)
# with S,L,H,R,G,B running from 0 to 1
# from http://en.wikipedia.org/wiki/HSL_and_HSV
@@ -38,11 +87,11 @@ class Color():
[c+m, m, x+m],
][sextant],'d'))
self.model = converted.model
- self.color = converted.color
-
+ self.color = converted.color
+# ------------------------------------------------------------------
# convert R(ed) G(reen) B(lue) to H(ue) S(aturation) L(uminance)
# with S,L,H,R,G,B running from 0 to 1
- # from http://130.113.54.154/~monger/hsl-rgb.html
+ # from http://130.113.54.154/~monger/hsl-rgb.html
def _RGB2HSL(self):
import numpy
if self.model != 'RGB': return
@@ -75,9 +124,7 @@ class Color():
converted = Color('HSL', HSL)
self.model = converted.model
self.color = converted.color
-
-
-
+# ------------------------------------------------------------------
# convert R(ed) G(reen) B(lue) to CIE XYZ
# with all values in the range of 0 to 1
# from http://www.cs.rit.edu/~ncs/color/t_convert.html
@@ -104,9 +151,7 @@ class Color():
converted = Color('XYZ', XYZ)
self.model = converted.model
self.color = converted.color
-
-
-
+# ------------------------------------------------------------------
# convert CIE XYZ R(ed) G(reen) B(lue)
# with all values in the range of 0 to 1
# from http://www.cs.rit.edu/~ncs/color/t_convert.html
@@ -130,16 +175,14 @@ class Color():
RGB[i] = min(RGB[i],1.0)
RGB[i] = max(RGB[i],0.0)
- maxVal = max(RGB) # clipping colors according to the display gamut
+ maxVal = max(RGB) # clipping colors according to the display gamut
if (maxVal > 1.0):
RGB /= maxVal
converted = Color('RGB', RGB)
self.model = converted.model
self.color = converted.color
-
-
-
+# ------------------------------------------------------------------
# convert CIE Lab to CIE XYZ
# with XYZ in the range of 0 to 1
# from http://www.easyrgb.com/index.php?X=MATH&H=07#text7
@@ -147,7 +190,7 @@ class Color():
import numpy
if self.model != 'CIELAB': return
- ref_white = numpy.array([.95047, 1.00000, 1.08883],'d') # Observer = 2, Illuminant = D65
+ ref_white = numpy.array([.95047, 1.00000, 1.08883],'d') # Observer = 2, Illuminant = D65
XYZ = numpy.zeros(3,'d')
XYZ[1] = (self.color[0] + 16 ) / 116
@@ -163,9 +206,7 @@ class Color():
converted = Color('XYZ', XYZ*ref_white)
self.model = converted.model
self.color = converted.color
-
-
-
+# ------------------------------------------------------------------
# convert CIE XYZ to CIE Lab
# with XYZ in the range of 0 to 1
# from http://en.wikipedia.org/wiki/Lab_color_space, http://www.cs.rit.edu/~ncs/color/t_convert.html
@@ -173,7 +214,7 @@ class Color():
import numpy
if self.model != 'XYZ': return
- ref_white = numpy.array([.95047, 1.00000, 1.08883],'d') # Observer = 2, Illuminant = D65
+ ref_white = numpy.array([.95047, 1.00000, 1.08883],'d') # Observer = 2, Illuminant = D65
XYZ = self.color/ref_white
for i in xrange(len(XYZ)):
@@ -187,8 +228,7 @@ class Color():
200.0 * (XYZ[1] - XYZ[2]) ]))
self.model = converted.model
self.color = converted.color
-
-
+# ------------------------------------------------------------------
# convert Cie Lab to msh colorspace
# from http://www.cs.unm.edu/~kmorel/documents/ColorMaps/DivergingColorMapWorkshop.xls
def _CIELAB2MSH(self):
@@ -205,10 +245,9 @@ class Color():
converted = Color('MSH', Msh)
self.model = converted.model
self.color = converted.color
-
-
-
+# ------------------------------------------------------------------
# convert msh colorspace to Cie Lab
+ # s,h in radians
# from http://www.cs.unm.edu/~kmorel/documents/ColorMaps/DivergingColorMapWorkshop.xls
def _MSH2CIELAB(self):
import numpy, math
@@ -222,137 +261,126 @@ class Color():
converted = Color('CIELAB', Lab)
self.model = converted.model
self.color = converted.color
-
-
-
# ------------------------------------------------------------------
- def __init__(self,
- model = 'RGB',
- color = numpy.zeros(3,'d')):
- import numpy
-
- self.__transforms__ = \
- {'HSL': {'index': 0, 'next': self._HSL2RGB},
- 'RGB': {'index': 1, 'next': self._RGB2XYZ, 'prev': self._RGB2HSL},
- 'XYZ': {'index': 2, 'next': self._XYZ2CIELAB, 'prev': self._XYZ2RGB},
- 'CIELAB': {'index': 3, 'next': self._CIELAB2MSH, 'prev': self._CIELAB2XYZ},
- 'MSH': {'index': 4, 'prev': self._MSH2CIELAB},
- }
-
- model = model.upper()
- if model not in self.__transforms__.keys(): model = 'RGB'
- if model == 'RGB' and max(color) > 1.0: # are we RGB255 ?
- color /= 255.0 # rescale to RGB
-
- if model == 'HSL': # are we HSL ?
- if abs(color[0]) > 1.0: color[0] /= 360.0 # with angular hue?
- while color[0] >= 1.0: color[0] -= 1.0 # rewind to proper range
- while color[0] < 0.0: color[0] += 1.0 # rewind to proper range
-
- self.model = model
- self.color = numpy.array(color,'d')
-
-
- def __repr__(self):
- return 'Model: %s Color: %s'%(self.model,str(self.color))
-
- def __str__(self):
- return self.__repr__()
-
-# ------------------------------------------------------------------
- def to(self,toModel = 'RGB'):
- toModel = toModel.upper()
- if toModel not in self.__transforms__.keys(): return
-
- sourcePos = self.__transforms__[self.model]['index']
- targetPos = self.__transforms__[toModel]['index']
-
- while sourcePos < targetPos:
- self.__transforms__[self.model]['next']()
- sourcePos += 1
-
- while sourcePos > targetPos:
- self.__transforms__[self.model]['prev']()
- sourcePos -= 1
- return self
-
-
-# ------------------------------------------------------------------
- def asModel(self,toModel = 'RGB'):
- return self.__class__(self.model,self.color).to(toModel)
-
-
-
-# lorMap has properties
-# .type (seq, div)
-# .len
-# .colors (.len of class Color)
-# and methods
-# .export(type) (switches internally to output desired format)
class Colormap():
+ '''
+ perceptually uniform diverging and sequential colormaps. colormap string exportable in the respective
+ formats compatible to paraview,gmsh and raw.
+ '''
- __slots__ = ['type',
+ __slots__ = [
'left',
'right',
- ]
-
- __formats__ = ['sequential','diverging']
-
+ ]
+# ------------------------------------------------------------------
def __init__(self,
- style = 'sequential',
left = Color('RGB',[1,1,1]),
right = Color('RGB',[0,0,0]),
):
-
- style = style.lower()
- if style not in self.__formats__:
- style = self.__formats__[0]
-
+
if left.__class__.__name__ != 'Color':
left = Color()
if right.__class__.__name__ != 'Color':
right = Color()
-
-
- self.style = style
- self.left = left.asModel('MSH')
+
+ self.left = left.asModel('MSH')
self.right = right.asModel('MSH')
+# ------------------------------------------------------------------
+ def export(self,name='uniformPerceptualColorMap',format = 'paraview', steps = 10, crop = [-1,1]):
+ # export method returns colormap as a string w.r.t the specified format eg, paraview,gmsh
+ # the colormap can be cropped according to the range of specified values.
+ # No need to differentiate between sequential and diverging colormaps
+ # produces sequential colormaps if either of the colors in the Colormap-object is either white or black
+ # ------------------------------------------------------------------
+ import copy,numpy, math
+
+ def interpolate_color(left,right,interp):
+ def rad_dif(left,right):
+ return abs((left.color[2]-right.color[2]))
+ def adjust_hue(Msh_sat,Msh_unsat): # if saturation of one of the two colors is too less than the other, hue of the less
+ # saturated color is adjusted.
+ M_unsat = Msh_unsat.color[0]
+ if ( Msh_sat.color[0] >= (M_unsat-0.1) ):
+ return Msh_sat.color[2]
+ else:
+ hSpin = Msh_sat.color[1]*math.sqrt((M_unsat)**2.0-(Msh_sat.color[0])**2)/(Msh_sat.color[0]*math.sin(Msh_sat.color[1]))
+ if Msh_sat.color[2] > - math.pi/3.0:
+ return Msh_sat.color[2] + hSpin
+ else:
+ return Msh_sat.color[2] - hSpin
+
+ Msh1 = copySelf.left
+ Msh2 = copySelf.right
+ Msh_mid = [0.0,0.0,0.0]
+ if ((Msh1.color[1] > 0.05 and Msh2.color[1] > 0.05) and rad_dif(Msh1,Msh2) > math.pi/3.0):
+ Msh_mid[0] = max(Msh1.color[0],Msh2.color[0],88.0)
+ if interp < 0.5:
+ Msh2.color[0] = Msh_mid[0]
+ Msh2.color[1] = 0.0
+ Msh2.color[2] = 0.0
+ interp = 2.0*interp
+ else:
+ Msh1.color[0] = Msh_mid[0]
+ Msh1.color[1] = 0.0
+ Msh1.color[2] = 0.0
+ interp = 2.0*interp - 1.0
+ if (Msh1.color[1] < 0.05) and (Msh2.color[1] > 0.05):
+ Msh1.color[2] = adjust_hue(Msh2,Msh1)
+ elif (Msh2.color[1] < 0.05) and (Msh1.color[1] > 0.05):
+ Msh2.color[2] = adjust_hue(Msh1,Msh2)
+ for i in range(3):
+ Msh_mid[i] = (1.0-interp)*Msh1.color[i] + interp* Msh2.color[i]
+ return Color('MSH',Msh_mid).to()
-
-class Colormaps():
- '''
- Funtionality to manipulate colormaps
- '''
-
- # from http://code.activestate.com/recipes/121574-matrix-vector-multiplication/
- def matmult(self, m, v):
- nrows = len(m)
- w = [None] * nrows
- for row in range(nrows):
- w[row] = reduce(lambda x,y: x+y, map(lambda x,y: x*y, m[row], v))
- return w
-
- def write_gsmh(self,RGB_vector,name):
- colormap = open(str(name) + '.map',"w")
- colormap.write('View.ColorTable = {\n')
- for i in range(len(RGB_vector)-1):
- colormap.write('{'+str((RGB_vector[0][i])*255.0)+','+str((RGB_vector[1][i])*255.0)+','+str((RGB_vector[2][i])*255.0)+'},\n')
- colormap.write('{'+str((RGB_vector[0][-1])*255.0)+','+str((RGB_vector[1][-1])*255.0)+','+str((RGB_vector[2][-1])*255.0)+'}}')
- file.close(colormap)
-
- def write_paraview(self,RGB_vector,name):
- colormap = open(str(name) + '.xml',"w")
- colormap.write('\n')
- for i in range(len(RGB_vector[0])):
- colormap.write('\n')
- colormap.write('')
- file.close(colormap)
+ def write_paraview(RGB_vector):
+ colormap ='\n'
+ for i in range(len(RGB_vector)):
+ colormap+='\n'
+ colormap+=''
+ return colormap
+
+ def write_gmsh(RGB_vector):
+ colormap = 'View.ColorTable = {\n'
+ for i in range(len(RGB_vector)-1):
+ colormap+='{'+str((RGB_vector[i][0])*255.0)+','+str((RGB_vector[i][1])*255.0)+','+str((RGB_vector[i][2])*255.0)+'},\n'
+ colormap+='{'+str((RGB_vector[-1][0])*255.0)+','+str((RGB_vector[-1][1])*255.0)+','+str((RGB_vector[-1][2])*255.0)+'}}\n'
+ return colormap
+
+ def write_raw(RGB_vector):
+ colormap = ('ColorMap name = ' + str(name)+'\n')
+ for i in range(len(RGB_vector)):
+ colormap+=str(RGB_vector[i][0])+'\t'+str(RGB_vector[i][1])+'\t'+str(RGB_vector[i][2])+'\n'
+ return colormap
- def write_raw(self,RGB_vector,name):
- colormap = open(str(name) + '.colormap',"w")
- colormap.write('ColorMap name = ' + str(name)+'\n')
- for i in range(len(RGB_vector)):
- colormap.write(str(RGB_vector[0][i])+'\t'+str(RGB_vector[1][i])+'\t'+str(RGB_vector[2][i])+'\n')
- file.close(colormap)
+ def croppedVector(RGB_vector):
+ zeroPos = int((len(RGB_vector)-1)/2)
+ leftPos,rightPos = crop
+ maxValue = max(abs(leftPos),abs(rightPos))
+ minValue = min(abs(leftPos),abs(rightPos))
+ perUnit = (len(RGB_vector)-1)/(2*maxValue)
+ if abs(leftPos) > abs(rightPos):
+ del RGB_vector[((zeroPos + int(perUnit*minValue))+1):]
+ if abs(leftPos) < abs(rightPos):
+ del RGB_vector[:(zeroPos - int(perUnit*minValue))]
+ return RGB_vector
+
+ interpolationVector = [] # a list of equally spaced values(interpolator) between 0 and 1
+ RGB_Matrix = []
+ for i in range(steps+1): interpolationVector.append(float(i)/steps)
+ for i in interpolationVector:
+ copySelf = copy.deepcopy(self)
+ color = interpolate_color(copySelf.left,copySelf.right,i)
+ RGB_Matrix.append(color.color)
+ RGB_Matrix_cropped = croppedVector(RGB_Matrix)
+
+ if format.lower() == 'paraview':
+ colormap = write_paraview(RGB_Matrix_cropped)
+ if format.lower() == 'gmsh':
+ colormap = write_gmsh(RGB_Matrix_cropped)
+ if format.lower() == 'raw':
+ colormap = write_raw(RGB_Matrix_cropped)
+ colormapStr = str(colormap)
+
+ return colormapStr
\ No newline at end of file
diff --git a/processing/post/colormap_diverging.py b/processing/post/colormap_diverging.py
deleted file mode 100755
index 3287b15fd..000000000
--- a/processing/post/colormap_diverging.py
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/usr/bin/env python
-
-import math, string, sys
-from damask import Colormaps
-from optparse import OptionParser, Option
-
-# -----------------------------
-class extendableOption(Option):
-# -----------------------------
-# used for definition of new option parser action 'extend', which enables to take multiple option arguments
-# taken from online tutorial http://docs.python.org/library/optparse.html
-
- ACTIONS = Option.ACTIONS + ("extend",)
- STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
- TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
- ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
-
- def take_action(self, action, dest, opt, value, values, parser):
- if action == "extend":
- lvalue = value.split(",")
- values.ensure_value(dest, []).extend(lvalue)
- else:
- Option.take_action(self, action, dest, opt, value, values, parser)
-
-
-
-# --------------------------------------------------------------------
- # MAIN
-# --------------------------------------------------------------------
-
-parser = OptionParser(option_class=extendableOption, usage='%prog options [file[s]]', description = """
-Add column(s) containing Cauchy stress based on given column(s) of
-deformation gradient and first Piola--Kirchhoff stress.
-
-""" + string.replace('$Id$','\n','\\n')
-)
-
-parser.add_option('-l','--left', dest='left', type='float', nargs=3, \
- help='left color')
-parser.add_option('-r','--right', dest='right', type='float', nargs=3, \
- help='right color')
-parser.add_option('-c','--colormodel', dest='colormodel', \
- help='colormodel of left and right "RGB","RGB255","HSV","HSL" [%default]')
-parser.add_option('-o','--outtype', dest='outtype', \
- help='output file type "paraview","gmsh","raw" [%default]')
-parser.add_option('-s','--steps', dest='steps', type='int', nargs = 1, \
- help='no of interpolation steps [%default]')
-
-parser.set_defaults(colormodel = 'RGB')
-parser.set_defaults(outtype = 'paraview')
-parser.set_defaults(steps = '10')
-
-(options,filenames) = parser.parse_args()
-
-# ------------------------------------------ setup file handles ---------------------------------------
-
-files = []
-if filenames == []:
- files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
-
-
-# -----------------------------------------------------------------------------------------------------
-
-myColorMap = Colormaps()
-
-def rad_dif(Msh1,Msh2,white):
- HSL1 = myColorMap.RGB2HSL(myColorMap.XYZ2RGB(myColorMap.CIELab2XYZ(myColorMap.Msh2CIELab(Msh1),white)))
- HSL2 = myColorMap.RGB2HSL(myColorMap.XYZ2RGB(myColorMap.CIELab2XYZ(myColorMap.Msh2CIELab(Msh2),white)))
- return abs(HSL1[0]*math.pi/180.0-HSL2[0]*math.pi/180.0)
-
-def adjust_hue(Msh_sat,M_unsat):
- if ( Msh_sat[0] >= (M_unsat-0.1) ):
- return Msh_sat[2]
- else:
- hSpin = Msh_sat[1]*math.sqrt((M_unsat)**2.0-(Msh_sat[0])**2)/(Msh_sat[0]*math.sin(Msh_sat[1]))
- if Msh_sat[2] > - math.pi/3.0:
- return Msh_sat[2] + hSpin
- else:
- return Msh_sat[2] - hSpin
-
-
-def interpolate_color(RGB1,RGB2,white,interp):
- Msh1 = myColorMap.CIELab2Msh(myColorMap.XYZ2CIELab(myColorMap.RGB2XYZ(RGB1),white))
- Msh2 = myColorMap.CIELab2Msh(myColorMap.XYZ2CIELab(myColorMap.RGB2XYZ(RGB2),white))
- Msh_mid = [0.0,0.0,0.0]
- if ((Msh1[1] > 0.05 and Msh2[1] > 0.05) and rad_dif(Msh1,Msh2,white) > math.pi/3.0):
- Msh_mid[0] = max(Msh1[0],Msh2[0],88.0)
- if interp < 0.5:
- Msh2[0] = Msh_mid[0]
- Msh2[1] = 0.0
- Msh2[2] = 0.0
- interp = 2.0*interp
- else:
- Msh1[0] = Msh_mid[0]
- Msh1[1] = 0.0
- Msh1[2] = 0.0
- interp = 2.0*interp - 1.0
- if (Msh1[1] < 0.05) and (Msh2[1] > 0.05):
- Msh1[2] = adjust_hue(Msh2,Msh1[0])
- elif (Msh2[1] < 0.05) and (Msh1[1] > 0.05):
- Msh2[2] = adjust_hue(Msh1,Msh2[0])
- for i in range(3):
- Msh_mid[i] = (1.0-interp)*Msh1[i] + interp* Msh2[i]
- return myColorMap.XYZ2RGB(myColorMap.CIELab2XYZ(myColorMap.Msh2CIELab(Msh_mid),white))
-
-white = [0.950456, 1.0, 1.088754]
-interpolatorArray = []
-for i in range(options.steps+1): interpolatorArray.append(float(i)/options.steps)
-rMatrix = []
-gMatrix = []
-bMatrix = []
-for i in interpolatorArray:
- step_no = str(interpolatorArray.index(i))
- color = interpolate_color(options.left,options.right,white,i)
- rMatrix.append(color[0])
- gMatrix.append(color[1])
- bMatrix.append(color[2])
-
-colorMatrix = [rMatrix,gMatrix,bMatrix]
-
-if options.outtype.lower() == 'paraview':
- myColorMap.write_paraview(colorMatrix,filenames[0])
-
diff --git a/processing/post/colormap_sequential.py b/processing/post/colormap_sequential.py
deleted file mode 100755
index bd7e21b37..000000000
--- a/processing/post/colormap_sequential.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/usr/bin/env python
-
-import math, string, sys
-from damask import Colormaps
-from optparse import OptionParser, Option
-
-# -----------------------------
-class extendableOption(Option):
-# -----------------------------
-# used for definition of new option parser action 'extend', which enables to take multiple option arguments
-# taken from online tutorial http://docs.python.org/library/optparse.html
-
- ACTIONS = Option.ACTIONS + ("extend",)
- STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
- TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
- ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
-
- def take_action(self, action, dest, opt, value, values, parser):
- if action == "extend":
- lvalue = value.split(",")
- values.ensure_value(dest, []).extend(lvalue)
- else:
- Option.take_action(self, action, dest, opt, value, values, parser)
-
-
-
-# --------------------------------------------------------------------
- # MAIN
-# --------------------------------------------------------------------
-
-parser = OptionParser(option_class=extendableOption, usage='%prog options [file[s]]', description = """
-Add column(s) containing Cauchy stress based on given column(s) of
-deformation gradient and first Piola--Kirchhoff stress.
-
-""" + string.replace('$Id$','\n','\\n')
-)
-
-parser.add_option('-f','--farbe', dest='farbe', type='float', nargs=3, \
- help='RGB values of the desired color')
-parser.add_option('-c','--colormodel', dest='colormodel', \
- help='colormodel of left and right "RGB","RGB255","HSV","HSL" [%default]')
-parser.add_option('-o','--outtype', dest='outtype', \
- help='output file type "paraview","gmsh","raw" [%default]')
-parser.add_option('-s','--steps', dest='steps', type='int', nargs = 1, \
- help='no of interpolation steps [%default]')
-parser.add_option('-m','--maptype', dest='maptype', \
- help='Increasing or decreasing sequential map "inc","dec" [%default]')
-
-parser.set_defaults(colormodel = 'RGB')
-parser.set_defaults(outtype = 'paraview')
-parser.set_defaults(steps = '10')
-parser.set_defaults(maptype = 'dec')
-
-(options,filenames) = parser.parse_args()
-
-
-# ------------------------------------------ setup file handles ---------------------------------------
-
-files = []
-if filenames == []:
- files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
-
-
-# -----------------------------------------------------------------------------------------------------
-
-myColorMap = Colormaps()
-
-def rad_dif(Msh1,Msh2,white):
- HSL1 = myColorMap.RGB2HSL(myColorMap.XYZ2RGB(myColorMap.CIELab2XYZ(myColorMap.Msh2CIELab(Msh1),white)))
- HSL2 = myColorMap.RGB2HSL(myColorMap.XYZ2RGB(myColorMap.CIELab2XYZ(myColorMap.Msh2CIELab(Msh2),white)))
- return abs(HSL1[0]*math.pi/180.0-HSL2[0]*math.pi/180.0)
-
-def adjust_hue(Msh_sat,M_unsat):
- if ( Msh_sat[0] >= (M_unsat-0.1) ):
- return Msh_sat[2]
- else:
- hSpin = Msh_sat[1]*math.sqrt((M_unsat)**2.0-(Msh_sat[0])**2)/(Msh_sat[0]*math.sin(Msh_sat[1]))
- if Msh_sat[2] > - math.pi/3.0:
- return Msh_sat[2] + hSpin
- else:
- return Msh_sat[2] - hSpin
-
-
-def interpolate_color(RGB1,white,interp):
- Msh_mid = [0.0,0.0,0.0]
- if (options.maptype.lower() == 'dec'):
- Msh1 = myColorMap.CIELab2Msh(myColorMap.XYZ2CIELab(myColorMap.RGB2XYZ(RGB1),white))
- Msh2 = myColorMap.CIELab2Msh(myColorMap.XYZ2CIELab(myColorMap.RGB2XYZ(white),white))
- if (Msh1[1] > 0.05):
- Msh_mid[0] = max(Msh1[0],Msh2[0],88.0)
- if (Msh1[1] < 0.05):
- Msh1[2] = adjust_hue(Msh2,Msh1[0])
- if (options.maptype.lower() == 'inc'):
- Msh1 = myColorMap.CIELab2Msh(myColorMap.XYZ2CIELab(myColorMap.RGB2XYZ(white),white))
- Msh2 = myColorMap.CIELab2Msh(myColorMap.XYZ2CIELab(myColorMap.RGB2XYZ(RGB1),white))
- if (Msh2[1] > 0.05):
- Msh_mid[0] = max(Msh1[0],Msh2[0],88.0)
- if (Msh2[1] < 0.05):
- Msh2[2] = adjust_hue(Msh2,Msh1[0])
- for i in range(3):
- Msh_mid[i] = (1.0-interp)*Msh1[i] + interp* Msh2[i]
- return myColorMap.XYZ2RGB(myColorMap.CIELab2XYZ(myColorMap.Msh2CIELab(Msh_mid),white))
-
-white = [0.950456, 1.0, 1.088754]
-interpolatorArray = []
-for i in range(options.steps+1): interpolatorArray.append(float(i)/options.steps)
-rMatrix = []
-gMatrix = []
-bMatrix = []
-for i in interpolatorArray:
- step_no = str(interpolatorArray.index(i))
- color = interpolate_color(options.farbe,white,i)
- rMatrix.append(color[0])
- gMatrix.append(color[1])
- bMatrix.append(color[2])
-
-colorMatrix = [rMatrix,gMatrix,bMatrix]
-
-if options.outtype.lower() == 'paraview':
- myColorMap.write_paraview(colorMatrix,filenames[0])
-
diff --git a/processing/post/uniformPerceptualColorMap.py b/processing/post/uniformPerceptualColorMap.py
new file mode 100755
index 000000000..8daf01833
--- /dev/null
+++ b/processing/post/uniformPerceptualColorMap.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+import math, string, sys
+from damask import Color,Colormap
+from optparse import OptionParser, Option
+
+# -----------------------------
+class extendableOption(Option):
+# -----------------------------
+# used for definition of new option parser action 'extend', which enables to take multiple option arguments
+# taken from online tutorial http://docs.python.org/library/optparse.html
+
+ ACTIONS = Option.ACTIONS + ("extend",)
+ STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
+ TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
+ ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)
+
+ def take_action(self, action, dest, opt, value, values, parser):
+ if action == "extend":
+ lvalue = value.split(",")
+ values.ensure_value(dest, []).extend(lvalue)
+ else:
+ Option.take_action(self, action, dest, opt, value, values, parser)
+
+
+
+# --------------------------------------------------------------------
+ # MAIN
+# --------------------------------------------------------------------
+
+parser = OptionParser(option_class=extendableOption, usage='%prog options [file[s]]', description = """
+Add column(s) containing Cauchy stress based on given column(s) of
+deformation gradient and first Piola--Kirchhoff stress.
+
+""" + string.replace('$Id$','\n','\\n')
+)
+
+parser.add_option('-l','--left', dest='left', type='float', nargs=3, \
+ help='left color [%default]')
+parser.add_option('-r','--right', dest='right', type='float', nargs=3, \
+ help='right color [%default]')
+parser.add_option('-c','--colormodel', dest='colormodel', \
+ help='colormodel of left and right "RGB","HSL","XYZ","CIELAB","MSH" [%default]')
+parser.add_option('-f','--format', dest='format', \
+ help='output file format "paraview","gmsh","raw" [%default]')
+parser.add_option('-s','--steps', dest='steps', type='int', nargs = 1, \
+ help='no of interpolation steps [%default]')
+parser.add_option('-t','--trim', dest='trim', type='float', nargs = 2, \
+ help='trim the colormap w.r.t the given values [%default]')
+
+parser.set_defaults(colormodel = 'RGB')
+parser.set_defaults(outtype = 'paraview')
+parser.set_defaults(steps = 10)
+parser.set_defaults(trim = [-1.0,1.0])
+parser.set_defaults(left = [1.0,1.0,1.0])
+parser.set_defaults(right = [0.0,0.0,0.0])
+(options,filenames) = parser.parse_args()
+
+# ------------------------------------------ setup file handles ---------------------------------------
+
+files = []
+if filenames == []:
+ files.append({'name':'STDIN', 'input':sys.stdin, 'output':sys.stdout})
+
+# -----------------------------------------------------------------------------------------------------
+
+leftColor = Color(options.colormodel.upper(),list(options.left))
+rightColor = Color(options.colormodel.upper(),list(options.right))
+
+myColormap = Colormap(leftColor,rightColor)
+outColormap = myColormap.export(filenames[0],options.format.lower(),options.steps,list(options.trim))
+
+if options.format.lower() == 'paraview':
+ if filenames[0].endswith('.xml'):
+ outFile = open('%s'%filenames[0],'w')
+ else:
+ outFile = open('%s.xml'%filenames[0],'w')
+
+elif options.format.lower() == 'gmsh':
+ if filenames[0].endswith('.msh'):
+ outFile = open('%s'%filenames[0],'w')
+ else:
+ outFile = open('%s.msh'%filenames[0],'w')
+
+elif options.format.lower() == 'raw':
+ if filenames[0].endswith('.txt'):
+ outFile = open('%s'%filenames[0],'w')
+ else:
+ outFile = open('%s.txt'%filenames[0],'w')
+
+outFile.write(outColormap)
+outFile.close()
\ No newline at end of file
diff --git a/processing/setup/setup_processing.py b/processing/setup/setup_processing.py
index 3d43c43c1..db01cf238 100755
--- a/processing/setup/setup_processing.py
+++ b/processing/setup/setup_processing.py
@@ -99,32 +99,33 @@ bin_link = { \
'post' : [
'3Dvisualize.py',
'addCalculation.py',
+ 'addCauchy.py',
+ 'addCompatibilityMismatch.py',
+ 'addCurl.py',
+ 'addDeformedConfiguration.py',
'addDeterminant.py',
'addDeviator.py',
- 'addSpectralDecomposition.py',
'addDivergence.py',
- 'addCurl.py',
- 'addMises.py',
- 'addNorm.py',
- 'addCauchy.py',
- 'addPK2.py',
- 'addStrainTensors.py',
'addEhkl.py',
'addEuclideanDistance.py',
- 'addCompatibilityMismatch.py',
- 'addDeformedConfiguration.py',
+ 'addMises.py',
+ 'addNorm.py',
+ 'addPK2.py',
+ 'addSpectralDecomposition.py',
+ 'addStrainTensors.py',
'averageDown.py',
'binXY.py',
'deleteColumn.py',
'deleteInfo.py',
- 'showTable.py',
'filterTable.py',
'mentat_colorMap.py',
- 'postResults.py',
- 'spectral_parseLog.py',
'nodesFromCentroids.py',
- 'tagLabel.py',
+ 'postResults.py',
+ 'showTable.py',
+ 'spectral_parseLog.py',
'table2ang',
+ 'tagLabel.py',
+ 'uniformPerceptualColorMap.py'
],
}