Separated ``hatchcolor`` from ``edgecolor``

When the *hatchcolor* parameter is specified, it will be used for the hatch.

If it is not specified, it will fall back to using :rc:`hatch.color`.

The special value 'edge' uses the patch edgecolor, with a fallback to

:rc:`patch.edgecolor` if the patch edgecolor is 'none'.

Previously, hatch colors were the same as edge colors, with a fallback to

:rc:`hatch.color` if the patch did not have an edge color.

.. plot::

:include-source: true

:alt: Four Rectangle patches, each displaying the color of hatches in different specifications of edgecolor and hatchcolor. Top left has hatchcolor='black' representing the default value when both hatchcolor and edgecolor are not set, top right has edgecolor='blue' and hatchcolor='black' which remains when the edgecolor is set again, bottom left has edgecolor='red' and hatchcolor='orange' on explicit specification and bottom right has edgecolor='green' and hatchcolor='green' when the hatchcolor is not set.

import matplotlib as mpl

import matplotlib.pyplot as plt

from matplotlib.patches import Rectangle

fig, ax = plt.subplots()

# In this case, hatchcolor is orange

patch1 = Rectangle((0.1, 0.1), 0.3, 0.3, edgecolor='red', linewidth=2,

hatch='//', hatchcolor='orange')

ax.add_patch(patch1)

# When hatchcolor is not specified, it matches edgecolor

# In this case, hatchcolor is green

patch2 = Rectangle((0.6, 0.1), 0.3, 0.3, edgecolor='green', linewidth=2,

hatch='//', facecolor='none')

ax.add_patch(patch2)

# If both hatchcolor and edgecolor are not specified

# it will default to the 'patch.edgecolor' rcParam, which is black by default

# In this case, hatchcolor is black

patch3 = Rectangle((0.1, 0.6), 0.3, 0.3, hatch='//')

ax.add_patch(patch3)

# When using `hatch.color` in the `rcParams`

# edgecolor will now not overwrite hatchcolor

# In this case, hatchcolor is black

with plt.rc_context({'hatch.color': 'black'}):

patch4 = Rectangle((0.6, 0.6), 0.3, 0.3, edgecolor='blue', linewidth=2,

hatch='//', facecolor='none')

# hatchcolor is black (it uses the `hatch.color` rcParam value)

patch4.set_edgecolor('blue')

# hatchcolor is still black (here, it does not update when edgecolor changes)

ax.add_patch(patch4)

ax.annotate("hatchcolor = 'orange'",

xy=(.5, 1.03), xycoords=patch1, ha='center', va='bottom')

ax.annotate("hatch color unspecified\nedgecolor='green'",

xy=(.5, 1.03), xycoords=patch2, ha='center', va='bottom')

ax.annotate("hatch color unspecified\nusing patch.edgecolor",

xy=(.5, 1.03), xycoords=patch3, ha='center', va='bottom')

ax.annotate("hatch.color='black'",

xy=(.5, 1.03), xycoords=patch4, ha='center', va='bottom')

plt.show()

import matplotlib.pyplot as plt

import numpy as np

from matplotlib.patches import Rectangle

fig, (ax1, ax2) = plt.subplots(1, 2)

ax1.add_patch(Rectangle((0.1, 0.5), 0.8, 0.3, hatch=".", hatchcolor='red',

edgecolor='black', lw=2))

ax1.add_patch(Rectangle((0.1, 0.1), 0.8, 0.3, hatch='x', edgecolor='orange', lw=2))

x = np.arange(1, 5)

y = np.arange(1, 5)

ax2.bar(x, y, facecolor='none', edgecolor='red', hatch='//', hatchcolor='blue')

ax2.set_xlim(0, 5)

ax2.set_ylim(0, 5)

plt.show()

self._hatch_color = None

# Temporary logic to set hatchcolor. This eager resolution is temporary

# and will be replaced by a proper mechanism in a follow-up PR.

hatch_color = mpl.rcParams['hatch.color']

if hatch_color == 'edge':

hatch_color = mpl.rcParams['patch.edgecolor']

self._hatch_color = mcolors.to_rgba(hatch_color)

#hatch.color: edge

hatch.color: edge

hatchcolor=None,

self.set_hatchcolor(hatchcolor)

self._original_hatchcolor = other._original_hatchcolor

def get_hatchcolor(self):

"""Return the hatch color."""

if self._hatch_color == 'edge':

if self._edgecolor[3] == 0: # fully transparent

return colors.to_rgba(mpl.rcParams['patch.edgecolor'])

return self.get_edgecolor()

return self._hatch_color

self.set_hatchcolor(c)

self.set_facecolor(c)

def _set_hatchcolor(self, color):

color = mpl._val_or_rc(color, 'hatch.color')

if color == 'edge':

self._hatch_color = 'edge'

else:

self._hatch_color = colors.to_rgba(color, self._alpha)

self.stale = True

def set_hatchcolor(self, color):

"""

if cbook._str_equal(color, 'edge'):

color = 'edge'

self._original_hatchcolor = color

self._set_hatchcolor(color)

self._set_hatchcolor(self._original_hatchcolor)

self._set_hatchcolor(self._original_hatchcolor)

gc.set_hatch_color(self.get_hatchcolor())

hatchcolor: ColorType | None = ...,

def get_hatchcolor(self) -> ColorType: ...

def set_hatchcolor(self, color: ColorType | Literal["edge"] | None) -> None: ...

def _validate_color_or_edge(s):

if cbook._str_equal(s, 'edge'):

return s

return validate_color(s)

"hatch.color": _validate_color_or_edge,

def _validate_color_or_edge(s: Any) -> ColorType | Literal["edge"]: ...

def test_patch_hatchcolor_inherit_logic():

with mpl.rc_context({'hatch.color': 'edge'}):

# Test for when edgecolor and hatchcolor is set

rect = Rectangle((0, 0), 1, 1, hatch='//', ec='red',

hatchcolor='yellow')

assert mcolors.same_color(rect.get_edgecolor(), 'red')

assert mcolors.same_color(rect.get_hatchcolor(), 'yellow')

# Test for explicitly setting edgecolor and then hatchcolor

rect = Rectangle((0, 0), 1, 1, hatch='//')

rect.set_edgecolor('orange')

assert mcolors.same_color(rect.get_hatchcolor(), 'orange')

rect.set_hatchcolor('cyan')

assert mcolors.same_color(rect.get_hatchcolor(), 'cyan')

# Test for explicitly setting hatchcolor and then edgecolor

rect = Rectangle((0, 0), 1, 1, hatch='//')

rect.set_hatchcolor('purple')

assert mcolors.same_color(rect.get_hatchcolor(), 'purple')

rect.set_edgecolor('green')

assert mcolors.same_color(rect.get_hatchcolor(), 'purple')

def test_patch_hatchcolor_fallback_logic():

# Test for when hatchcolor parameter is passed

rect = Rectangle((0, 0), 1, 1, hatch='//', hatchcolor='green')

assert mcolors.same_color(rect.get_hatchcolor(), 'green')

# Test that hatchcolor parameter takes precedence over rcParam

# When edgecolor is not set

with mpl.rc_context({'hatch.color': 'blue'}):

rect = Rectangle((0, 0), 1, 1, hatch='//', hatchcolor='green')

assert mcolors.same_color(rect.get_hatchcolor(), 'green')

# When edgecolor is set

with mpl.rc_context({'hatch.color': 'yellow'}):

rect = Rectangle((0, 0), 1, 1, hatch='//', hatchcolor='green', edgecolor='red')

assert mcolors.same_color(rect.get_hatchcolor(), 'green')

# Test that hatchcolor is not overridden by edgecolor when

# hatchcolor parameter is not passed and hatch.color rcParam is set to a color

# When edgecolor is not set

with mpl.rc_context({'hatch.color': 'blue'}):

rect = Rectangle((0, 0), 1, 1, hatch='//')

assert mcolors.same_color(rect.get_hatchcolor(), 'blue')

# When edgecolor is set

with mpl.rc_context({'hatch.color': 'blue'}):

rect = Rectangle((0, 0), 1, 1, hatch='//', edgecolor='red')

assert mcolors.same_color(rect.get_hatchcolor(), 'blue')

# Test that hatchcolor matches edgecolor when

# hatchcolor parameter is not passed and hatch.color rcParam is set to 'edge'

with mpl.rc_context({'hatch.color': 'edge'}):

rect = Rectangle((0, 0), 1, 1, hatch='//', edgecolor='red')

assert mcolors.same_color(rect.get_hatchcolor(), 'red')

# hatchcolor parameter is set to 'edge'

rect = Rectangle((0, 0), 1, 1, hatch='//', hatchcolor='edge', edgecolor='orange')

assert mcolors.same_color(rect.get_hatchcolor(), 'orange')

# Test for default hatchcolor when hatchcolor parameter is not passed and

# hatch.color rcParam is set to 'edge' and edgecolor is not set

rect = Rectangle((0, 0), 1, 1, hatch='//')

assert mcolors.same_color(rect.get_hatchcolor(), mpl.rcParams['patch.edgecolor'])