223031012
/
DAMASK_EICMD
mirror of https://github.com/achalhp/DAMASK_EICMD.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fixed bugs in HSL2RGB and the two CIE conversions. 

streamlined interpolation.
This commit is contained in:
Philip Eisenlohr 2013-02-02 20:17:02 +00:00
parent ac562f4b8b
commit fc9ecc7ed5
1 changed files with 47 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
lib/damask/colormaps.py
View File

@ -72,7 +72,7 @@ class Color():
import numpy import numpy
if self.model != 'HSL': return if self.model != 'HSL': return
sextant = int(self.color[0]*6.0) sextant = self.color[0]*6.0
c = (1.0 - abs(2.0 * self.color[2] - 1.0))*self.color[1] c = (1.0 - abs(2.0 * self.color[2] - 1.0))*self.color[1]
x = c*(1.0 - abs(sextant%2 - 1.0)) x = c*(1.0 - abs(sextant%2 - 1.0))
m = self.color[2] - 0.5*c m = self.color[2] - 0.5*c
@ -84,7 +84,7 @@ class Color():
[m, x+m, c+m], [m, x+m, c+m],
[x+m, m, c+m], [x+m, m, c+m],
[c+m, m, x+m], [c+m, m, x+m],
][sextant],'d')) ][int(sextant)],'d'))
self.model = converted.model self.model = converted.model
self.color = converted.color self.color = converted.color
# ------------------------------------------------------------------ # ------------------------------------------------------------------
@ -192,7 +192,7 @@ class Color():
for i in xrange(len(XYZ)): for i in xrange(len(XYZ)):
if (XYZ[i] > 6./29. ): XYZ[i] = XYZ[i]**3. if (XYZ[i] > 6./29. ): XYZ[i] = XYZ[i]**3.
else: XYZ[i] = 108./2523. * (XYZ[i] - 4./29.) else: XYZ[i] = 108./841. * (XYZ[i] - 4./29.)
converted = Color('XYZ', XYZ*ref_white) converted = Color('XYZ', XYZ*ref_white)
self.model = converted.model self.model = converted.model
@ -210,7 +210,7 @@ class Color():
for i in xrange(len(XYZ)): for i in xrange(len(XYZ)):
if (XYZ[i] > 216./24389 ): XYZ[i] = XYZ[i]**(1.0/3.0) if (XYZ[i] > 216./24389 ): XYZ[i] = XYZ[i]**(1.0/3.0)
else: XYZ[i] = (24389./27. * XYZ[i] + 16.0 ) / 116.0 else: XYZ[i] = (841./108. * XYZ[i]) + 16.0/116.0
converted = Color('CIELAB', numpy.array([ 116.0 * XYZ[1] - 16.0, converted = Color('CIELAB', numpy.array([ 116.0 * XYZ[1] - 16.0,
500.0 * (XYZ[0] - XYZ[1]), 500.0 * (XYZ[0] - XYZ[1]),
@ -218,7 +218,7 @@ class Color():
self.model = converted.model self.model = converted.model
self.color = converted.color self.color = converted.color
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# convert Cie Lab to msh colorspace # convert CIE Lab to Msh colorspace
# from http://www.cs.unm.edu/~kmorel/documents/ColorMaps/DivergingColorMapWorkshop.xls # from http://www.cs.unm.edu/~kmorel/documents/ColorMaps/DivergingColorMapWorkshop.xls
def _CIELAB2MSH(self): def _CIELAB2MSH(self):
import numpy, math import numpy, math
@ -226,14 +226,16 @@ class Color():
Msh = numpy.zeros(3,'d') Msh = numpy.zeros(3,'d')
Msh[0] = math.sqrt(numpy.dot(self.color,self.color)) Msh[0] = math.sqrt(numpy.dot(self.color,self.color))
if (Msh[0] != 0.0) and (Msh[0] > 0.001): Msh[1] = math.acos( self.color[0]/Msh[0]) if (Msh[0] > 0.001):
if (self.color[1] != 0.0) and (Msh[1] > 0.001): Msh[2] = math.atan2(self.color[2],self.color[1]) Msh[1] = math.acos(self.color[0]/Msh[0])
if (self.color[1] != 0.0):
Msh[2] = math.atan2(self.color[2],self.color[1])
converted = Color('MSH', Msh) converted = Color('MSH', Msh)
self.model = converted.model self.model = converted.model
self.color = converted.color self.color = converted.color
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# convert msh colorspace to Cie Lab # convert Msh colorspace to CIE Lab
# s,h in radians # s,h in radians
# from http://www.cs.unm.edu/~kmorel/documents/ColorMaps/DivergingColorMapWorkshop.xls # from http://www.cs.unm.edu/~kmorel/documents/ColorMaps/DivergingColorMapWorkshop.xls
def _MSH2CIELAB(self): def _MSH2CIELAB(self):
@ -273,9 +275,13 @@ class Colormap():
self.left = left.asModel('MSH') self.left = left.asModel('MSH')
self.right = right.asModel('MSH') self.right = right.asModel('MSH')
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def export(self,name='uniformPerceptualColorMap',format = 'paraview', steps = 10, crop = [-1.0,1.0]): def export(self,name = 'uniformPerceptualColorMap',\
format = 'paraview',\
steps = 10,\
crop = [-1.0,1.0],
model = 'RGB'):
''' '''
RGB colormap for use in paraview or gmsh, or as raw string, or array. [RGB] colormap for use in paraview or gmsh, or as raw string, or array.
arguments: name, format, steps, crop. arguments: name, format, steps, crop.
format is one of (paraview, gmsh, raw, list). format is one of (paraview, gmsh, raw, list).
crop selects a (sub)range in [-1.0,1.0]. crop selects a (sub)range in [-1.0,1.0].
@ -286,37 +292,34 @@ class Colormap():
# ------------------------------------------------------------------ # ------------------------------------------------------------------
import copy,numpy,math import copy,numpy,math
def interpolate_color(left,right,interp): def interpolate_Msh(lo,hi,frac,model='RGB'):
def rad_dif(left,right):
return abs((left.color[2]-right.color[2])) def rad_diff(a,b):
return abs(a[2]-b[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 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. if Msh_sat[0] >= Msh_unsat[0]:
M_unsat = Msh_unsat.color[0] return Msh_sat[2]
if ( Msh_sat.color[0] >= (M_unsat-0.1) ):
return Msh_sat.color[2]
else: 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])) hSpin = Msh_sat[1]/math.sin(Msh_sat[1])*math.sqrt(Msh_unsat[0]**2.0-Msh_sat[0]**2)/Msh_sat[0]
if Msh_sat.color[2] > - math.pi/3.0: if Msh_sat[2] < - math.pi/3.0: hSpin *= -1.0
return Msh_sat.color[2] + hSpin return Msh_sat[2] + hSpin
else:
return Msh_sat.color[2] - hSpin
Msh1 = copySelf.left Msh1 = numpy.array(lo[:])
Msh2 = copySelf.right Msh2 = numpy.array(hi[:])
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): if (Msh1[1] > 0.05 and Msh2[1] > 0.05 and rad_diff(Msh1,Msh2) > math.pi/3.0):
Msh_mid[0] = max(Msh1.color[0],Msh2.color[0],88.0) M_mid = max(Msh1[0],Msh2[0],88.0)
if interp < 0.5: if frac < 0.5:
Msh2.color = [Msh_mid[0],0.0,0.0] Msh2 = numpy.array([M_mid,0.0,0.0],'d')
interp = 2.0*interp frac = 2.0*frac
else: else:
Msh1.color = [Msh_mid[0],0.0,0.0] Msh1 = numpy.array([M_mid,0.0,0.0],'d')
interp = 2.0*interp - 1.0 frac = 2.0*frac - 1.0
if (Msh1.color[1] < 0.05) and (Msh2.color[1] > 0.05): Msh1.color[2] = adjust_hue(Msh2,Msh1) if Msh1[1] < 0.05 and Msh2[1] > 0.05: Msh1[2] = adjust_hue(Msh2,Msh1)
elif (Msh2.color[1] < 0.05) and (Msh1.color[1] > 0.05): Msh2.color[2] = adjust_hue(Msh1,Msh2) elif Msh1[1] > 0.05 and Msh2[1] < 0.05: Msh2[2] = adjust_hue(Msh1,Msh2)
Msh_mid = (1.0-interp)*Msh1.color + interp*Msh2.color Msh = (1.0-frac)*Msh1 + frac*Msh2
return Color('MSH',Msh_mid).to() return Color('MSH',Msh).to(model)
def write_paraview(RGB_vector): def write_paraview(RGB_vector):
colormap ='<ColorMap name="'+str(name)+'" space="RGB">\n' colormap ='<ColorMap name="'+str(name)+'" space="RGB">\n'
@ -335,15 +338,12 @@ class Colormap():
+ '\n'.join(['%s'%('\t'.join(map(lambda x:str(x),v))) for v in RGB_vector]) + '\n'.join(['%s'%('\t'.join(map(lambda x:str(x),v))) for v in RGB_vector])
interpolationVector = [] # a list of equally spaced values(interpolator) between 0 and 1 colors = []
RGB_Matrix = []
totalSteps = int(2.0*steps/(crop[1] - crop[0])) totalSteps = int(2.0*steps/(crop[1] - crop[0]))
for i in range(totalSteps): interpolationVector.append(float(i)/(totalSteps-1))
for i in interpolationVector: for i in range(totalSteps):
copySelf = copy.deepcopy(self) color = interpolate_Msh(self.left.color,self.right.color,float(i)/(totalSteps-1),model)
color = interpolate_color(copySelf.left,copySelf.right,i) colors.append(color.color)
RGB_Matrix.append(color.color)
leftIndex = int(round((crop[0]-(-1.0))/(2.0/(totalSteps-1)))) leftIndex = int(round((crop[0]-(-1.0))/(2.0/(totalSteps-1))))
rightIndex = leftIndex + steps rightIndex = leftIndex + steps
@ -352,4 +352,4 @@ class Colormap():
'gmsh': write_gmsh, 'gmsh': write_gmsh,
'raw': write_raw, 'raw': write_raw,
'list': lambda x: x, 'list': lambda x: x,
}[format.lower()](RGB_Matrix[max(leftIndex,0):min(rightIndex,totalSteps)]) }[format.lower()](colors[max(leftIndex,0):min(rightIndex,totalSteps)])