blocks|key|566760|text|最简单的方法是将vmin和vmax参数用于imshow+(假设您正在处理图像数据)，而不是将matplotlib.colors.Normalize子类化。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|566761|例如。|566762|import+numpy+as+np
import+matplotlib.pyplot+as+plt

data+=+np.random.random((10,10))
#+Make+the+data+range+from+about+-5+to+10
data+=+10+/+0.75+*+(data+-+0.25)

plt.imshow(data,+vmin=-10,+vmax=10)
plt.colorbar()

plt.show()|code-block|syntax|javascript|566763|​|566764|📷|atomic|566765|566766|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/7e9961d05766d9f64b3b13657bf56ba4.png|imageAlt^0|8|4|D|4|L|6|1A|R|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1C|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1D|8|@]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|R|3|N|5|6|7|1H|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z|10|-4]]]]

It's easiest to just use the <code>vmin</code> and <code>vmax</code> arguments to <code>imshow</code> (assuming you're working with image data) rather than subclassing <code>matplotlib.colors.Normalize</code>. 

E.g.

<pre><code>import numpy as np
import matplotlib.pyplot as plt

data = np.random.random((10,10))
# Make the data range from about -5 to 10
data = 10 / 0.75 * (data - 0.25)

plt.imshow(data, vmin=-10, vmax=10)
plt.colorbar()

plt.show()
</code></pre>

<img src="https://i.stack.imgur.com/A2QNK.png" alt="enter image description here">

blocks|key|783089|text|不确定你是否还在寻找答案。对我来说，尝试将Normalize子类化是不成功的。因此，我专注于手动创建一个新的数据集，刻度和刻度标签，以获得我认为您的目标的效果。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|783090|我在matplotlib中找到了scale模块，它有一个类用于根据“syslog”规则转换线形图，所以我使用它来转换数据。然后我缩放数据，使其从0到1(+Normalize通常这样做)，但我缩放正数的方式与缩放负数的方式不同。这是因为您的vmax和vmin可能不同，因此.5+->+1可能比.5+->+0覆盖更大的正范围，负范围则是如此。对我来说，创建一个计算刻度和标签值的例程更容易。|783091|下面是代码和示例图。|783092|import+numpy+as+np
import+matplotlib.pyplot+as+plt
import+matplotlib.mpl+as+mpl
import+matplotlib.scale+as+scale

NDATA+=+50
VMAX=10
VMIN=-5
LINTHRESH=1e-4

def+makeTickLables(vmin,vmax,linthresh):
++++"""
++++make+two+lists,+one+for+the+tick+positions,+and+one+for+the+labels
++++at+those+positions.+The+number+and+placement+of+positive+labels+is+
++++different+from+the+negative+labels.
++++"""
++++nvpos+=+int(np.log10(vmax))-int(np.log10(linthresh))
++++nvneg+=+int(np.log10(np.abs(vmin)))-int(np.log10(linthresh))%2B1
++++ticks+=+[]
++++labels+=+[]
++++lavmin+=+(np.log10(np.abs(vmin)))
++++lvmax+=+(np.log10(np.abs(vmax)))
++++llinthres+=+int(np.log10(linthresh))
++++#+f(x)+=+mx%2Bb
++++#+f(llinthres)+=+.5
++++#+f(lavmin)+=+0
++++m+=+.5/float(llinthres-lavmin)
++++b+=+(.5-llinthres*m-lavmin*m)/2
++++for+itick+in+range(nvneg):
++++++++labels.append(-1*float(pow(10,itick%2Bllinthres)))
++++++++ticks.append((b%2B(itick%2Bllinthres)*m))
++++#+add+vmin+tick
++++labels.append(vmin)
++++ticks.append(b%2B(lavmin)*m)

++++#+f(x)+=+mx%2Bb
++++#+f(llinthres)+=+.5
++++#+f(lvmax)+=+1
++++m+=+.5/float(lvmax-llinthres)
++++b+=+m*(lvmax-2*llinthres)+
++++for+itick+in+range(1,nvpos):
++++++++labels.append(float(pow(10,itick%2Bllinthres)))
++++++++ticks.append((b%2B(itick%2Bllinthres)*m))
++++#+add+vmax+tick
++++labels.append(vmax)
++++ticks.append(b%2B(lvmax)*m)

++++return+ticks,labels


data+=+(VMAX-VMIN)*np.random.random((NDATA,NDATA))%2BVMIN

#+define+a+scaler+object+that+can+transform+to+'symlog'
scaler+=+scale.SymmetricalLogScale.SymmetricalLogTransform(10,LINTHRESH)
datas+=+scaler.transform(data)

#+scale+datas+so+that+0+is+at+.5
#+so+two+seperate+scales,+one+for+positive+and+one+for+negative
data2+=+np.where(np.greater(data,0),
+++++++++++++++++.75%2B.25*datas/np.log10(VMAX),
+++++++++++++++++.25%2B.25*(datas)/np.log10(np.abs(VMIN))
+++++++++++++++++)

ticks,labels=makeTickLables(VMIN,VMAX,LINTHRESH)

cmap+=+mpl.cm.jet
fig+=+plt.figure()
ax+=+fig.add_subplot(111)
im+=+ax.imshow(data2,cmap=cmap,vmin=0,vmax=1)
cbar+=+plt.colorbar(im,ticks=ticks)
cbar.ax.set_yticklabels(labels)

fig.savefig('twoscales.png')|code-block|syntax|javascript|783093|​|783094|📷|atomic|783095|783096|可以随意调整脚本顶部的“常量”(例如VMAX)，以确认它运行良好。|783097|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/d45ad0402a12d083e43c3ffc22a199d4.png|imageAlt^0|L|9|0|G|5|25|9|0|0|0|0|0|1|0|0|0|I|4|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1D|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1E|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|T|3|P|5|6|7|1K|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13|14|-4]]]]

Not sure if you are still looking for an answer. For me, trying to subclass <code>Normalize</code> was unsuccessful. So I focused on manually creating a new data set, ticks and tick-labels to get the effect I think you are aiming for.

I found the <code>scale</code> module in matplotlib that has a class used to transform line plots by the 'syslog' rules, so I use that to transform the data. Then I scale the data so that it goes from 0 to 1 (what <code>Normalize</code> usually does), but I scale the positive numbers differently from the negative numbers. This is because your vmax and vmin might not be the same, so .5 -> 1 might cover a larger positive range than .5 -> 0, the negative range does. It was easier for me to create a routine to calculate the tick and label values. 

Below is the code and an example figure. 

<pre><code>import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mpl as mpl
import matplotlib.scale as scale

NDATA = 50
VMAX=10
VMIN=-5
LINTHRESH=1e-4

def makeTickLables(vmin,vmax,linthresh):
 """
 make two lists, one for the tick positions, and one for the labels
 at those positions. The number and placement of positive labels is 
 different from the negative labels.
 """
 nvpos = int(np.log10(vmax))-int(np.log10(linthresh))
 nvneg = int(np.log10(np.abs(vmin)))-int(np.log10(linthresh))+1
 ticks = []
 labels = []
 lavmin = (np.log10(np.abs(vmin)))
 lvmax = (np.log10(np.abs(vmax)))
 llinthres = int(np.log10(linthresh))
 # f(x) = mx+b
 # f(llinthres) = .5
 # f(lavmin) = 0
 m = .5/float(llinthres-lavmin)
 b = (.5-llinthres*m-lavmin*m)/2
 for itick in range(nvneg):
 labels.append(-1*float(pow(10,itick+llinthres)))
 ticks.append((b+(itick+llinthres)*m))
 # add vmin tick
 labels.append(vmin)
 ticks.append(b+(lavmin)*m)

 # f(x) = mx+b
 # f(llinthres) = .5
 # f(lvmax) = 1
 m = .5/float(lvmax-llinthres)
 b = m*(lvmax-2*llinthres) 
 for itick in range(1,nvpos):
 labels.append(float(pow(10,itick+llinthres)))
 ticks.append((b+(itick+llinthres)*m))
 # add vmax tick
 labels.append(vmax)
 ticks.append(b+(lvmax)*m)

 return ticks,labels


data = (VMAX-VMIN)*np.random.random((NDATA,NDATA))+VMIN

# define a scaler object that can transform to 'symlog'
scaler = scale.SymmetricalLogScale.SymmetricalLogTransform(10,LINTHRESH)
datas = scaler.transform(data)

# scale datas so that 0 is at .5
# so two seperate scales, one for positive and one for negative
data2 = np.where(np.greater(data,0),
 .75+.25*datas/np.log10(VMAX),
 .25+.25*(datas)/np.log10(np.abs(VMIN))
 )

ticks,labels=makeTickLables(VMIN,VMAX,LINTHRESH)

cmap = mpl.cm.jet
fig = plt.figure()
ax = fig.add_subplot(111)
im = ax.imshow(data2,cmap=cmap,vmin=0,vmax=1)
cbar = plt.colorbar(im,ticks=ticks)
cbar.ax.set_yticklabels(labels)

fig.savefig('twoscales.png')
</code></pre>

<img src="https://i.stack.imgur.com/jmhhD.png" alt="vmax=10,vmin=-5 and linthresh=1e-4">

Feel free to adjust the "constants" (eg <code>VMAX</code>) at the top of the script to confirm that it behaves well.

blocks|key|783113|text|下面是一个子类化Normalize的解决方案。使用它|type|unstyled|depth|inlineStyleRanges|entityRanges|data|783114|norm+=+MidPointNorm(midpoint=3)
imshow(X,+norm=norm)|code-block|syntax|javascript|783115|下面是类：|783116|import+numpy+as+np
from+numpy+import+ma
from+matplotlib+import+cbook
from+matplotlib.colors+import+Normalize

class+MidPointNorm(Normalize):++++
++++def+__init__(self,+midpoint=0,+vmin=None,+vmax=None,+clip=False):
++++++++Normalize.__init__(self,vmin,+vmax,+clip)
++++++++self.midpoint+=+midpoint

++++def+__call__(self,+value,+clip=None):
++++++++if+clip+is+None:
++++++++++++clip+=+self.clip

++++++++result,+is_scalar+=+self.process_value(value)

++++++++self.autoscale_None(result)
++++++++vmin,+vmax,+midpoint+=+self.vmin,+self.vmax,+self.midpoint

++++++++if+not+(vmin+<+midpoint+<+vmax):
++++++++++++raise+ValueError("midpoint+must+be+between+maxvalue+and+minvalue.")+++++++
++++++++elif+vmin+==+vmax:
++++++++++++result.fill(0)+#+Or+should+it+be+all+masked?+Or+0.5?
++++++++elif+vmin+>+vmax:
++++++++++++raise+ValueError("maxvalue+must+be+bigger+than+minvalue")
++++++++else:
++++++++++++vmin+=+float(vmin)
++++++++++++vmax+=+float(vmax)
++++++++++++if+clip:
++++++++++++++++mask+=+ma.getmask(result)
++++++++++++++++result+=+ma.array(np.clip(result.filled(vmax),+vmin,+vmax),
++++++++++++++++++++++++++++++++++mask=mask)

++++++++++++#+ma+division+is+very+slow;+we+can+take+a+shortcut
++++++++++++resdat+=+result.data

++++++++++++#First+scale+to+-1+to+1+range,+than+to+from+0+to+1.
++++++++++++resdat+-=+midpoint++++++++++++
++++++++++++resdat[resdat>0]+/=+abs(vmax+-+midpoint)++++++++++++
++++++++++++resdat[resdat<0]+/=+abs(vmin+-+midpoint)

++++++++++++resdat+/=+2.
++++++++++++resdat+%2B=+0.5
++++++++++++result+=+ma.array(resdat,+mask=result.mask,+copy=False)++++++++++++++++

++++++++if+is_scalar:
++++++++++++result+=+result[0]++++++++++++
++++++++return+result

++++def+inverse(self,+value):
++++++++if+not+self.scaled():
++++++++++++raise+ValueError("Not+invertible+until+scaled")
++++++++vmin,+vmax,+midpoint+=+self.vmin,+self.vmax,+self.midpoint

++++++++if+cbook.iterable(value):
++++++++++++val+=+ma.asarray(value)
++++++++++++val+=+2+*+(val-0.5)++
++++++++++++val[val>0]++*=+abs(vmax+-+midpoint)
++++++++++++val[val<0]+*=+abs(vmin+-+midpoint)
++++++++++++val+%2B=+midpoint
++++++++++++return+val
++++++++else:
++++++++++++val+=+2+*+(value+-+0.5)
++++++++++++if+val+<+0:+
++++++++++++++++return++val*abs(vmin-midpoint)+%2B+midpoint
++++++++++++else:
++++++++++++++++return++val*abs(vmax-midpoint)+%2B+midpoint|783117|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is a solution subclassing Normalize. To use it

<pre><code>norm = MidPointNorm(midpoint=3)
imshow(X, norm=norm)
</code></pre>

Here is the Class:

<pre><code>import numpy as np
from numpy import ma
from matplotlib import cbook
from matplotlib.colors import Normalize

class MidPointNorm(Normalize): 
 def __init__(self, midpoint=0, vmin=None, vmax=None, clip=False):
 Normalize.__init__(self,vmin, vmax, clip)
 self.midpoint = midpoint

 def __call__(self, value, clip=None):
 if clip is None:
 clip = self.clip

 result, is_scalar = self.process_value(value)

 self.autoscale_None(result)
 vmin, vmax, midpoint = self.vmin, self.vmax, self.midpoint

 if not (vmin &lt; midpoint &lt; vmax):
 raise ValueError("midpoint must be between maxvalue and minvalue.") 
 elif vmin == vmax:
 result.fill(0) # Or should it be all masked? Or 0.5?
 elif vmin &gt; vmax:
 raise ValueError("maxvalue must be bigger than minvalue")
 else:
 vmin = float(vmin)
 vmax = float(vmax)
 if clip:
 mask = ma.getmask(result)
 result = ma.array(np.clip(result.filled(vmax), vmin, vmax),
 mask=mask)

 # ma division is very slow; we can take a shortcut
 resdat = result.data

 #First scale to -1 to 1 range, than to from 0 to 1.
 resdat -= midpoint 
 resdat[resdat&gt;0] /= abs(vmax - midpoint) 
 resdat[resdat&lt;0] /= abs(vmin - midpoint)

 resdat /= 2.
 resdat += 0.5
 result = ma.array(resdat, mask=result.mask, copy=False) 

 if is_scalar:
 result = result[0] 
 return result

 def inverse(self, value):
 if not self.scaled():
 raise ValueError("Not invertible until scaled")
 vmin, vmax, midpoint = self.vmin, self.vmax, self.midpoint

 if cbook.iterable(value):
 val = ma.asarray(value)
 val = 2 * (val-0.5) 
 val[val&gt;0] *= abs(vmax - midpoint)
 val[val&lt;0] *= abs(vmin - midpoint)
 val += midpoint
 return val
 else:
 val = 2 * (value - 0.5)
 if val &lt; 0: 
 return val*abs(vmin-midpoint) + midpoint
 else:
 return val*abs(vmax-midpoint) + midpoint
</code></pre>

blocks|key|566947|text|我知道这有点晚了，但我只是经历了这个过程，想出了一个可能比子类化normalize不那么健壮，但简单得多的解决方案。我想把它分享给后人会很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|566948|函数|566949|import+numpy+as+np
import+matplotlib
import+matplotlib.pyplot+as+plt
from+mpl_toolkits.axes_grid1+import+AxesGrid

def+shiftedColorMap(cmap,+start=0,+midpoint=0.5,+stop=1.0,+name='shiftedcmap'):
++++'''
++++Function+to+offset+the+"center"+of+a+colormap.+Useful+for
++++data+with+a+negative+min+and+positive+max+and+you+want+the
++++middle+of+the+colormap's+dynamic+range+to+be+at+zero.

++++Input
++++-----
++++++cmap+:+The+matplotlib+colormap+to+be+altered
++++++start+:+Offset+from+lowest+point+in+the+colormap's+range.
++++++++++Defaults+to+0.0+(no+lower+offset).+Should+be+between
++++++++++0.0+and+`midpoint`.
++++++midpoint+:+The+new+center+of+the+colormap.+Defaults+to+
++++++++++0.5+(no+shift).+Should+be+between+0.0+and+1.0.+In
++++++++++general,+this+should+be++1+-+vmax+/+(vmax+%2B+abs(vmin))
++++++++++For+example+if+your+data+range+from+-15.0+to+%2B5.0+and
++++++++++you+want+the+center+of+the+colormap+at+0.0,+`midpoint`
++++++++++should+be+set+to++1+-+5/(5+%2B+15))+or+0.75
++++++stop+:+Offset+from+highest+point+in+the+colormap's+range.
++++++++++Defaults+to+1.0+(no+upper+offset).+Should+be+between
++++++++++`midpoint`+and+1.0.
++++'''
++++cdict+=+{
++++++++'red':+[],
++++++++'green':+[],
++++++++'blue':+[],
++++++++'alpha':+[]
++++}

++++#+regular+index+to+compute+the+colors
++++reg_index+=+np.linspace(start,+stop,+257)

++++#+shifted+index+to+match+the+data
++++shift_index+=+np.hstack([
++++++++np.linspace(0.0,+midpoint,+128,+endpoint=False),+
++++++++np.linspace(midpoint,+1.0,+129,+endpoint=True)
++++])

++++for+ri,+si+in+zip(reg_index,+shift_index):
++++++++r,+g,+b,+a+=+cmap(ri)

++++++++cdict['red'].append((si,+r,+r))
++++++++cdict['green'].append((si,+g,+g))
++++++++cdict['blue'].append((si,+b,+b))
++++++++cdict['alpha'].append((si,+a,+a))

++++newcmap+=+matplotlib.colors.LinearSegmentedColormap(name,+cdict)
++++plt.register_cmap(cmap=newcmap)

++++return+newcmap|code-block|syntax|javascript|566950|一个例子|566951|biased_data+=+np.random.random_integers(low=-15,+high=5,+size=(37,37))

orig_cmap+=+matplotlib.cm.coolwarm
shifted_cmap+=+shiftedColorMap(orig_cmap,+midpoint=0.75,+name='shifted')
shrunk_cmap+=+shiftedColorMap(orig_cmap,+start=0.15,+midpoint=0.75,+stop=0.85,+name='shrunk')

fig+=+plt.figure(figsize=(6,6))
grid+=+AxesGrid(fig,+111,+nrows_ncols=(2,+2),+axes_pad=0.5,
++++++++++++++++label_mode="1",+share_all=True,
++++++++++++++++cbar_location="right",+cbar_mode="each",
++++++++++++++++cbar_size="7%25",+cbar_pad="2%25")

#+normal+cmap
im0+=+grid[0].imshow(biased_data,+interpolation="none",+cmap=orig_cmap)
grid.cbar_axes[0].colorbar(im0)
grid[0].set_title('Default+behavior+(hard+to+see+bias)',+fontsize=8)

im1+=+grid[1].imshow(biased_data,+interpolation="none",+cmap=orig_cmap,+vmax=15,+vmin=-15)
grid.cbar_axes[1].colorbar(im1)
grid[1].set_title('Centered+zero+manually,\nbut+lost+upper+end+of+dynamic+range',+fontsize=8)

im2+=+grid[2].imshow(biased_data,+interpolation="none",+cmap=shifted_cmap)
grid.cbar_axes[2].colorbar(im2)
grid[2].set_title('Recentered+cmap+with+function',+fontsize=8)

im3+=+grid[3].imshow(biased_data,+interpolation="none",+cmap=shrunk_cmap)
grid.cbar_axes[3].colorbar(im3)
grid[3].set_title('Recentered+cmap+with+function\nand+shrunk+range',+fontsize=8)

for+ax+in+grid:
++++ax.set_yticks([])
++++ax.set_xticks([])|566952|示例的结果：|566953|​|566954|📷|atomic|offset|length|566955|566956|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/0752cb48d83592785737d21cfb4ff7a2.png|imageAlt^0|0|0|0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|18|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1C|8|@]|9|@$T|1D|U|1E|1|1F]]|A|$]]|$1|V|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13|14|-4]]]]

I know this is late to the game, but I just went through this process and came up with a solution that perhaps less robust than subclassing normalize, but much simpler. I thought it'd be good to share it here for posterity.

<h3>The function</h3>

<pre><code>import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import AxesGrid

def shiftedColorMap(cmap, start=0, midpoint=0.5, stop=1.0, name='shiftedcmap'):
 '''
 Function to offset the "center" of a colormap. Useful for
 data with a negative min and positive max and you want the
 middle of the colormap's dynamic range to be at zero.

 Input
 -----
 cmap : The matplotlib colormap to be altered
 start : Offset from lowest point in the colormap's range.
 Defaults to 0.0 (no lower offset). Should be between
 0.0 and `midpoint`.
 midpoint : The new center of the colormap. Defaults to 
 0.5 (no shift). Should be between 0.0 and 1.0. In
 general, this should be 1 - vmax / (vmax + abs(vmin))
 For example if your data range from -15.0 to +5.0 and
 you want the center of the colormap at 0.0, `midpoint`
 should be set to 1 - 5/(5 + 15)) or 0.75
 stop : Offset from highest point in the colormap's range.
 Defaults to 1.0 (no upper offset). Should be between
 `midpoint` and 1.0.
 '''
 cdict = {
 'red': [],
 'green': [],
 'blue': [],
 'alpha': []
 }

 # regular index to compute the colors
 reg_index = np.linspace(start, stop, 257)

 # shifted index to match the data
 shift_index = np.hstack([
 np.linspace(0.0, midpoint, 128, endpoint=False), 
 np.linspace(midpoint, 1.0, 129, endpoint=True)
 ])

 for ri, si in zip(reg_index, shift_index):
 r, g, b, a = cmap(ri)

 cdict['red'].append((si, r, r))
 cdict['green'].append((si, g, g))
 cdict['blue'].append((si, b, b))
 cdict['alpha'].append((si, a, a))

 newcmap = matplotlib.colors.LinearSegmentedColormap(name, cdict)
 plt.register_cmap(cmap=newcmap)

 return newcmap
</code></pre>

<h3>An example</h3>

<pre><code>biased_data = np.random.random_integers(low=-15, high=5, size=(37,37))

orig_cmap = matplotlib.cm.coolwarm
shifted_cmap = shiftedColorMap(orig_cmap, midpoint=0.75, name='shifted')
shrunk_cmap = shiftedColorMap(orig_cmap, start=0.15, midpoint=0.75, stop=0.85, name='shrunk')

fig = plt.figure(figsize=(6,6))
grid = AxesGrid(fig, 111, nrows_ncols=(2, 2), axes_pad=0.5,
 label_mode="1", share_all=True,
 cbar_location="right", cbar_mode="each",
 cbar_size="7%", cbar_pad="2%")

# normal cmap
im0 = grid[0].imshow(biased_data, interpolation="none", cmap=orig_cmap)
grid.cbar_axes[0].colorbar(im0)
grid[0].set_title('Default behavior (hard to see bias)', fontsize=8)

im1 = grid[1].imshow(biased_data, interpolation="none", cmap=orig_cmap, vmax=15, vmin=-15)
grid.cbar_axes[1].colorbar(im1)
grid[1].set_title('Centered zero manually,\nbut lost upper end of dynamic range', fontsize=8)

im2 = grid[2].imshow(biased_data, interpolation="none", cmap=shifted_cmap)
grid.cbar_axes[2].colorbar(im2)
grid[2].set_title('Recentered cmap with function', fontsize=8)

im3 = grid[3].imshow(biased_data, interpolation="none", cmap=shrunk_cmap)
grid.cbar_axes[3].colorbar(im3)
grid[3].set_title('Recentered cmap with function\nand shrunk range', fontsize=8)

for ax in grid:
 ax.set_yticks([])
 ax.set_xticks([])
</code></pre>

<h3>Results of the example:</h3>

<img src="https://i.stack.imgur.com/TlfjL.png" alt="enter image description here">

blocks|key|783256|text|如果你不介意计算出vmin，vmax和0之间的比率，这是一个非常基本的从蓝色到白色再到红色的线性映射，它根据比率z设置白色|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|783257|def+colormap(z):
++++"""custom+colourmap+for+map+plots"""

++++cdict1+=+{'red':+((0.0,+0.0,+0.0),
++++++++++++++++++++++(z,+++1.0,+1.0),
++++++++++++++++++++++(1.0,+1.0,+1.0)),
++++++++++++++'green':+((0.0,+0.0,+0.0),
++++++++++++++++++++++++(z,+++1.0,+1.0),
++++++++++++++++++++++++(1.0,+0.0,+0.0)),
++++++++++++++'blue':+((0.0,+1.0,+1.0),
+++++++++++++++++++++++(z,+++1.0,+1.0),
+++++++++++++++++++++++(1.0,+0.0,+0.0))
++++++++++++++}

++++return+LinearSegmentedColormap('BlueRed1',+cdict1)|code-block|syntax|javascript|783258|cdict格式相当简单:行是创建的渐变中的点:第一项是x值(沿渐变从0到1的比率)，第二项是前一段的结束值，第三项是下一段的起始值-如果你想要平滑的渐变，后两项总是相同的。See+the+docs获取更多详细信息。|783259|entityMap|0|LINK|mutability|MUTABLE|url|http://matplotlib.org/api/colors_api.html#matplotlib.colors.LinearSegmentedColormap^0|1K|1|0|0|2E|C|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

If you don't mind working out the ratio between vmin, vmax, and zero, this is a pretty basic linear map from blue to white to red, that sets white according to the ratio <code>z</code>:

<pre><code>def colormap(z):
 """custom colourmap for map plots"""

 cdict1 = {'red': ((0.0, 0.0, 0.0),
 (z, 1.0, 1.0),
 (1.0, 1.0, 1.0)),
 'green': ((0.0, 0.0, 0.0),
 (z, 1.0, 1.0),
 (1.0, 0.0, 0.0)),
 'blue': ((0.0, 1.0, 1.0),
 (z, 1.0, 1.0),
 (1.0, 0.0, 0.0))
 }

 return LinearSegmentedColormap('BlueRed1', cdict1)
</code></pre>

The cdict format is fairly simple: the rows are points in the gradient that gets created: the first entry is the x-value (the ratio along the gradient from 0 to 1), the second is the end value for the previous segment, and the third is the start value for the next segment - if you want smooth gradients, the latter two are always the same. <a href="http://matplotlib.org/api/colors_api.html#matplotlib.colors.LinearSegmentedColormap" rel="nofollow">See the docs</a> for more detail.

blocks|key|567054|text|我也有类似的问题，但我希望最高的值是全红的，并去掉低值的蓝色，让它看起来像是色彩条的底部被砍掉了。这对我很有效(包括可选的透明度)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|567055|def+shift_zero_bwr_colormap(z:+float,+transparent:+bool+=+True):
++++"""shifted+bwr+colormap"""
++++if+(z+<+0)+or+(z+>+1):
++++++++raise+ValueError('z+must+be+between+0+and+1')

++++cdict1+=+{'red':+((0.0,+max(-2*z%2B1,+0),+max(-2*z%2B1,+0)),
++++++++++++++++++++++(z,+++1.0,+1.0),
++++++++++++++++++++++(1.0,+1.0,+1.0)),

++++++++++++++'green':+((0.0,+max(-2*z%2B1,+0),+max(-2*z%2B1,+0)),
++++++++++++++++++++++++(z,+++1.0,+1.0),
++++++++++++++++++++++++(1.0,+max(2*z-1,0),++max(2*z-1,0))),

++++++++++++++'blue':+((0.0,+1.0,+1.0),
+++++++++++++++++++++++(z,+++1.0,+1.0),
+++++++++++++++++++++++(1.0,+max(2*z-1,0),+max(2*z-1,0))),
++++++++++++++}
++++if+transparent:
++++++++cdict1['alpha']+=+((0.0,+1-max(-2*z%2B1,+0),+1-max(-2*z%2B1,+0)),
+++++++++++++++++++++++++++(z,+++0.0,+0.0),
+++++++++++++++++++++++++++(1.0,+1-max(2*z-1,0),++1-max(2*z-1,0)))

++++return+LinearSegmentedColormap('shifted_rwb',+cdict1)

cmap+=++shift_zero_bwr_colormap(.3)

x+=+np.arange(0,+np.pi,+0.1)
y+=+np.arange(0,+2*np.pi,+0.1)
X,+Y+=+np.meshgrid(x,+y)
Z+=+np.cos(X)+*+np.sin(Y)+*+5+%2B+5
plt.plot([0,+10*np.pi],+[0,+20*np.pi],+color='c',+lw=20,+zorder=-3)
plt.imshow(Z,+interpolation='nearest',+origin='lower',+cmap=cmap)
plt.colorbar()|code-block|syntax|javascript|567056|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I had a similar problem, but I wanted the highest value to be full red and cut off low values of blue, making it look essentially like the bottom of the colorbar was chopped off. This worked for me (includes optional transparency):

<pre><code>def shift_zero_bwr_colormap(z: float, transparent: bool = True):
 """shifted bwr colormap"""
 if (z &lt; 0) or (z &gt; 1):
 raise ValueError('z must be between 0 and 1')

 cdict1 = {'red': ((0.0, max(-2*z+1, 0), max(-2*z+1, 0)),
 (z, 1.0, 1.0),
 (1.0, 1.0, 1.0)),

 'green': ((0.0, max(-2*z+1, 0), max(-2*z+1, 0)),
 (z, 1.0, 1.0),
 (1.0, max(2*z-1,0), max(2*z-1,0))),

 'blue': ((0.0, 1.0, 1.0),
 (z, 1.0, 1.0),
 (1.0, max(2*z-1,0), max(2*z-1,0))),
 }
 if transparent:
 cdict1['alpha'] = ((0.0, 1-max(-2*z+1, 0), 1-max(-2*z+1, 0)),
 (z, 0.0, 0.0),
 (1.0, 1-max(2*z-1,0), 1-max(2*z-1,0)))

 return LinearSegmentedColormap('shifted_rwb', cdict1)

cmap = shift_zero_bwr_colormap(.3)

x = np.arange(0, np.pi, 0.1)
y = np.arange(0, 2*np.pi, 0.1)
X, Y = np.meshgrid(x, y)
Z = np.cos(X) * np.sin(Y) * 5 + 5
plt.plot([0, 10*np.pi], [0, 20*np.pi], color='c', lw=20, zorder=-3)
plt.imshow(Z, interpolation='nearest', origin='lower', cmap=cmap)
plt.colorbar()
</code></pre>

blocks|key|783335|text|请注意，在matplotlib版本的3.2%2B中添加了TwoSlopeNorm类。我认为它涵盖了您的用例。它可以像这样使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|783336|from+matplotlib+import+colors
divnorm=colors.TwoSlopeNorm(vmin=-5.,+vcenter=0.,+vmax=10)
pcolormesh(your_data,+cmap="coolwarm",+norm=divnorm)|code-block|syntax|javascript|783337|在matplotlib3.1中，这个类被称为DivergingNorm。|783338|entityMap|0|LINK|mutability|MUTABLE|url|https://matplotlib.org/3.2.0/api/_as_gen/matplotlib.colors.TwoSlopeNorm.html?highlight=twoslopenorm#matplotlib.colors.TwoSlopeNorm|1|https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.colors.DivergingNorm.html^0|Q|C|0|0|0|M|D|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

Note that in matplotlib version 3.2+ the <a href="https://matplotlib.org/3.2.0/api/_as_gen/matplotlib.colors.TwoSlopeNorm.html?highlight=twoslopenorm#matplotlib.colors.TwoSlopeNorm" rel="noreferrer">TwoSlopeNorm</a> class was added. I think it covers your use case.
It can be used like this:
<pre><code>from matplotlib import colors
divnorm=colors.TwoSlopeNorm(vmin=-5., vcenter=0., vmax=10)
pcolormesh(your_data, cmap=&quot;coolwarm&quot;, norm=divnorm)
</code></pre>
In matplotlib 3.1 the class was called <a href="https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.colors.DivergingNorm.html" rel="noreferrer">DivergingNorm</a>.

I want to set the middle point of a colormap, i.e., my data goes from -5 to 10 and I want zero to be the middle point. I think the way to do it is by subclassing normalize and using the norm, but I didn't find any example and it is not clear to me, what exactly have I to implement?

Defining the midpoint of a colormap in matplotlib

我想设置色彩映射表的中间点，即我的数据从-5到10，我想要0作为中间点。我认为这样做的方法是通过子类化normalize和使用规范，但我没有找到任何示例，我也不清楚，我到底要实现什么？

问在matplotlib中定义色彩映射表的中点
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在matplotlib中定义色彩映射表的中点EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在matplotlib中定义色彩映射表的中点
EN