myokit 1.35.0__py3-none-any.whl → 1.35.2__py3-none-any.whl

myokit/_datablock.py

@@ -1148,9 +1148,13 @@ class DataBlock2d:
         data = self._2d[name]
         # Get color map
         color_map = ColorMap.get(colormap)
+
         # Get lower and upper bounds for colormap scaling
         lower = np.min(data) if lower is None else float(lower)
         upper = np.max(data) if upper is None else float(upper)
+        if upper < lower:  # pragma: no cover
+            upper = lower
+
         # Create images
         frames = []
         for frame in data:
@@ -1687,8 +1691,8 @@ class ColorMap:
     @staticmethod
     def hsv_to_rgb(h, s, v):
         """
-        Converts hsv values in the range [0,1] to rgb values in the range
-        [0,255]. Adapted from Matplotlib.
+        Converts hsv values in the range [0, 1] to rgb values in the range
+        [0, 255].
         """
         r, g, b = np.empty_like(h), np.empty_like(h), np.empty_like(h)
         i = (h * 6).astype(int) % 6
@@ -1756,9 +1760,8 @@ class ColorMap:
 
 
 class ColorMapBlue(ColorMap):
-    """
-    A nice red colormap.
-    """
+    """ A plain white-to-blue colormap. """
+
     def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
         # Normalize floats
         f = ColorMap.normalize(floats, lower, upper)
@@ -1781,10 +1784,27 @@ class ColorMapBlue(ColorMap):
         return out
 
 
+class ColorMapGray(ColorMap):
+    """ A plain black-to-white colormap. """
+
+    def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
+        # Normalize floats
+        f = 255 * ColorMap.normalize(floats, lower, upper)
+        # Offset for first color in (a)rgb or rgb(a)
+        m = 1 if (alpha and rgb) else 0
+        # Number of bytes per float
+        n = 4 if alpha else 3
+        # Create output
+        out = 255 * np.ones(n * len(floats), dtype=np.uint8)
+        out[m + 0::n] = f
+        out[m + 1::n] = f
+        out[m + 2::n] = f
+        return out
+
+
 class ColorMapGreen(ColorMap):
-    """
-    A nice green colormap.
-    """
+    """ A plain white-to-green colormap. """
+
     def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
         # Normalize floats
         f = ColorMap.normalize(floats, lower, upper)
@@ -1808,9 +1828,8 @@ class ColorMapGreen(ColorMap):
 
 
 class ColorMapRed(ColorMap):
-    """
-    A nice red colormap.
-    """
+    """ A plain white-to-red colormap. """
+
     def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
         # Normalize floats
         f = ColorMap.normalize(floats, lower, upper)
@@ -1835,7 +1854,10 @@ class ColorMapRed(ColorMap):
 
 class ColorMapTraditional(ColorMap):
     """
-    Traditional hue-cycling colormap.
+    A traditional hue-cycling colormap.
+
+    Probably best not to use in publications. See e.g.
+    https://doi.org/10.1371/journal.pone.0199239
     """
     def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
         # Normalize floats
@@ -1859,6 +1881,886 @@ class ColorMapTraditional(ColorMap):
         return out
 
 
+class ColorMapCividis(ColorMap):
+    """
+    A colormap using "Cividis".
+
+    The values used by this color map are taken from supplement 3 in
+    https://doi.org/10.1371/journal.pone.0199239, by Jamie R. Nuñez,
+    Christopher R. Anderton, and Ryan S. Renslow.
+    """
+    _VALUES = np.array((
+        (0, 32, 76),
+        (0, 32, 78),
+        (0, 33, 80),
+        (0, 34, 81),
+        (0, 35, 83),
+        (0, 35, 85),
+        (0, 36, 86),
+        (0, 37, 88),
+        (0, 38, 90),
+        (0, 38, 91),
+        (0, 39, 93),
+        (0, 40, 95),
+        (0, 40, 97),
+        (0, 41, 99),
+        (0, 42, 100),
+        (0, 42, 102),
+        (0, 43, 104),
+        (0, 44, 106),
+        (0, 45, 108),
+        (0, 45, 109),
+        (0, 46, 110),
+        (0, 46, 111),
+        (0, 47, 111),
+        (0, 47, 111),
+        (0, 48, 111),
+        (0, 49, 111),
+        (0, 49, 111),
+        (0, 50, 110),
+        (0, 51, 110),
+        (0, 52, 110),
+        (0, 52, 110),
+        (1, 53, 110),
+        (6, 54, 110),
+        (10, 55, 109),
+        (14, 55, 109),
+        (18, 56, 109),
+        (21, 57, 109),
+        (23, 57, 109),
+        (26, 58, 108),
+        (28, 59, 108),
+        (30, 60, 108),
+        (32, 60, 108),
+        (34, 61, 108),
+        (36, 62, 108),
+        (38, 62, 108),
+        (39, 63, 108),
+        (41, 64, 107),
+        (43, 65, 107),
+        (44, 65, 107),
+        (46, 66, 107),
+        (47, 67, 107),
+        (49, 68, 107),
+        (50, 68, 107),
+        (51, 69, 107),
+        (53, 70, 107),
+        (54, 70, 107),
+        (55, 71, 107),
+        (56, 72, 107),
+        (58, 73, 107),
+        (59, 73, 107),
+        (60, 74, 107),
+        (61, 75, 107),
+        (62, 75, 107),
+        (64, 76, 107),
+        (65, 77, 107),
+        (66, 78, 107),
+        (67, 78, 107),
+        (68, 79, 107),
+        (69, 80, 107),
+        (70, 80, 107),
+        (71, 81, 107),
+        (72, 82, 107),
+        (73, 83, 107),
+        (74, 83, 107),
+        (75, 84, 107),
+        (76, 85, 107),
+        (77, 85, 107),
+        (78, 86, 107),
+        (79, 87, 108),
+        (80, 88, 108),
+        (81, 88, 108),
+        (82, 89, 108),
+        (83, 90, 108),
+        (84, 90, 108),
+        (85, 91, 108),
+        (86, 92, 108),
+        (87, 93, 109),
+        (88, 93, 109),
+        (89, 94, 109),
+        (90, 95, 109),
+        (91, 95, 109),
+        (92, 96, 109),
+        (93, 97, 110),
+        (94, 98, 110),
+        (95, 98, 110),
+        (95, 99, 110),
+        (96, 100, 110),
+        (97, 101, 111),
+        (98, 101, 111),
+        (99, 102, 111),
+        (100, 103, 111),
+        (101, 103, 111),
+        (102, 104, 112),
+        (103, 105, 112),
+        (104, 106, 112),
+        (104, 106, 112),
+        (105, 107, 113),
+        (106, 108, 113),
+        (107, 109, 113),
+        (108, 109, 114),
+        (109, 110, 114),
+        (110, 111, 114),
+        (111, 111, 114),
+        (111, 112, 115),
+        (112, 113, 115),
+        (113, 114, 115),
+        (114, 114, 116),
+        (115, 115, 116),
+        (116, 116, 117),
+        (117, 117, 117),
+        (117, 117, 117),
+        (118, 118, 118),
+        (119, 119, 118),
+        (120, 120, 118),
+        (121, 120, 119),
+        (122, 121, 119),
+        (123, 122, 119),
+        (123, 123, 120),
+        (124, 123, 120),
+        (125, 124, 120),
+        (126, 125, 120),
+        (127, 126, 120),
+        (128, 126, 120),
+        (129, 127, 120),
+        (130, 128, 120),
+        (131, 129, 120),
+        (132, 129, 120),
+        (133, 130, 120),
+        (134, 131, 120),
+        (135, 132, 120),
+        (136, 133, 120),
+        (137, 133, 120),
+        (138, 134, 120),
+        (139, 135, 120),
+        (140, 136, 120),
+        (141, 136, 120),
+        (142, 137, 120),
+        (143, 138, 120),
+        (144, 139, 120),
+        (145, 140, 120),
+        (146, 140, 120),
+        (147, 141, 120),
+        (148, 142, 120),
+        (149, 143, 120),
+        (150, 143, 119),
+        (151, 144, 119),
+        (152, 145, 119),
+        (153, 146, 119),
+        (154, 147, 119),
+        (155, 147, 119),
+        (156, 148, 119),
+        (157, 149, 119),
+        (158, 150, 118),
+        (159, 151, 118),
+        (160, 152, 118),
+        (161, 152, 118),
+        (162, 153, 118),
+        (163, 154, 117),
+        (164, 155, 117),
+        (165, 156, 117),
+        (166, 156, 117),
+        (167, 157, 117),
+        (168, 158, 116),
+        (169, 159, 116),
+        (170, 160, 116),
+        (171, 161, 116),
+        (172, 161, 115),
+        (173, 162, 115),
+        (174, 163, 115),
+        (175, 164, 115),
+        (176, 165, 114),
+        (177, 166, 114),
+        (178, 166, 114),
+        (180, 167, 113),
+        (181, 168, 113),
+        (182, 169, 113),
+        (183, 170, 112),
+        (184, 171, 112),
+        (185, 171, 112),
+        (186, 172, 111),
+        (187, 173, 111),
+        (188, 174, 110),
+        (189, 175, 110),
+        (190, 176, 110),
+        (191, 177, 109),
+        (192, 177, 109),
+        (193, 178, 108),
+        (194, 179, 108),
+        (196, 180, 108),
+        (197, 181, 107),
+        (198, 182, 107),
+        (199, 183, 106),
+        (200, 184, 106),
+        (201, 184, 105),
+        (202, 185, 105),
+        (203, 186, 104),
+        (204, 187, 104),
+        (205, 188, 103),
+        (206, 189, 103),
+        (207, 190, 102),
+        (209, 191, 102),
+        (210, 192, 101),
+        (211, 192, 101),
+        (212, 193, 100),
+        (213, 194, 99),
+        (214, 195, 99),
+        (215, 196, 98),
+        (216, 197, 98),
+        (217, 198, 97),
+        (219, 199, 96),
+        (220, 200, 96),
+        (221, 201, 95),
+        (222, 202, 94),
+        (223, 203, 93),
+        (224, 203, 93),
+        (225, 204, 92),
+        (227, 205, 91),
+        (228, 206, 91),
+        (229, 207, 90),
+        (230, 208, 89),
+        (231, 209, 88),
+        (232, 210, 87),
+        (233, 211, 86),
+        (235, 212, 86),
+        (236, 213, 85),
+        (237, 214, 84),
+        (238, 215, 83),
+        (239, 216, 82),
+        (240, 217, 81),
+        (242, 218, 80),
+        (243, 219, 79),
+        (244, 220, 78),
+        (245, 221, 77),
+        (246, 222, 76),
+        (247, 223, 75),
+        (249, 224, 73),
+        (250, 224, 72),
+        (251, 225, 71),
+        (252, 226, 70),
+        (253, 227, 69),
+        (255, 228, 67),
+        (255, 229, 66),
+        (255, 230, 66),
+        (255, 231, 67),
+        (255, 232, 68),
+        (255, 233, 69),
+    ))
+
+    def __init__(self):
+        self._n = len(self._VALUES)
+
+    def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
+        # Normalize floats
+        f = ColorMap.normalize(floats, lower, upper)
+        # Get RGB
+        val = self._VALUES[
+            np.minimum(np.round(f * self._n).astype(int), self._n - 1)]
+        # Color order
+        rgb = (sys.byteorder == 'big') if rgb is None else rgb
+        # Offset for first color in (a)rgb or rgb(a)
+        m = 1 if (alpha and rgb) else 0
+        # Number of bytes per float
+        n = 4 if alpha else 3
+        # Create output
+        out = 255 * np.ones(n * len(floats), dtype=np.uint8)
+        out[m + 0::n] = val[:, 0] if rgb else val[:, 2]
+        out[m + 1::n] = val[:, 1]
+        out[m + 2::n] = val[:, 2] if rgb else val[:, 0]
+        return out
+
+
+class ColorMapViridis(ColorMap):
+    """
+    A colormap using "Viridis".
+
+    The values used by this color map are taken from
+    https://github.com/BIDS/colormap/blob/master/colormaps.py
+    and were distributed under a CC0 license.
+
+    Viridis was designed by Eric Firing, Nathaniel J. Smith, and Stefan van der
+    Walt.
+    """
+    _VALUES = np.array((
+        (68, 1, 84),
+        (69, 2, 86),
+        (69, 4, 87),
+        (69, 5, 89),
+        (70, 7, 90),
+        (70, 8, 92),
+        (70, 10, 93),
+        (71, 11, 95),
+        (71, 13, 96),
+        (71, 14, 98),
+        (71, 16, 99),
+        (72, 17, 100),
+        (72, 19, 102),
+        (72, 20, 103),
+        (72, 22, 104),
+        (72, 23, 106),
+        (72, 24, 107),
+        (72, 26, 108),
+        (72, 27, 109),
+        (72, 28, 110),
+        (72, 30, 112),
+        (73, 31, 113),
+        (72, 32, 114),
+        (72, 34, 115),
+        (72, 35, 116),
+        (72, 36, 117),
+        (72, 37, 118),
+        (72, 39, 119),
+        (72, 40, 120),
+        (72, 41, 121),
+        (72, 42, 122),
+        (72, 44, 123),
+        (71, 45, 124),
+        (71, 46, 125),
+        (71, 47, 125),
+        (71, 49, 126),
+        (70, 50, 127),
+        (70, 51, 128),
+        (70, 52, 128),
+        (70, 54, 129),
+        (69, 55, 130),
+        (69, 56, 130),
+        (69, 57, 131),
+        (68, 58, 132),
+        (68, 60, 132),
+        (67, 61, 133),
+        (67, 62, 133),
+        (67, 63, 134),
+        (66, 64, 134),
+        (66, 66, 135),
+        (65, 67, 135),
+        (65, 68, 136),
+        (65, 69, 136),
+        (64, 70, 136),
+        (64, 71, 137),
+        (63, 73, 137),
+        (63, 74, 138),
+        (62, 75, 138),
+        (62, 76, 138),
+        (61, 77, 138),
+        (61, 78, 139),
+        (60, 79, 139),
+        (60, 80, 139),
+        (59, 81, 139),
+        (59, 83, 140),
+        (58, 84, 140),
+        (58, 85, 140),
+        (57, 86, 140),
+        (57, 87, 140),
+        (56, 88, 141),
+        (56, 89, 141),
+        (55, 90, 141),
+        (55, 91, 141),
+        (54, 92, 141),
+        (54, 93, 141),
+        (53, 94, 141),
+        (53, 95, 142),
+        (52, 96, 142),
+        (52, 97, 142),
+        (52, 98, 142),
+        (51, 99, 142),
+        (51, 100, 142),
+        (50, 101, 142),
+        (50, 102, 142),
+        (49, 103, 142),
+        (49, 104, 142),
+        (48, 105, 142),
+        (48, 106, 142),
+        (48, 107, 143),
+        (47, 108, 143),
+        (47, 109, 143),
+        (46, 110, 143),
+        (46, 111, 143),
+        (45, 112, 143),
+        (45, 113, 143),
+        (45, 114, 143),
+        (44, 115, 143),
+        (44, 116, 143),
+        (43, 117, 143),
+        (43, 118, 143),
+        (43, 119, 143),
+        (42, 120, 143),
+        (42, 121, 143),
+        (42, 122, 143),
+        (41, 123, 143),
+        (41, 123, 143),
+        (40, 124, 143),
+        (40, 125, 143),
+        (40, 126, 143),
+        (39, 127, 143),
+        (39, 128, 143),
+        (39, 129, 143),
+        (38, 130, 143),
+        (38, 131, 143),
+        (37, 132, 143),
+        (37, 133, 142),
+        (37, 134, 142),
+        (36, 135, 142),
+        (36, 136, 142),
+        (36, 137, 142),
+        (35, 138, 142),
+        (35, 139, 142),
+        (35, 139, 142),
+        (34, 140, 142),
+        (34, 141, 142),
+        (34, 142, 141),
+        (33, 143, 141),
+        (33, 144, 141),
+        (33, 145, 141),
+        (32, 146, 141),
+        (32, 147, 141),
+        (32, 148, 140),
+        (32, 149, 140),
+        (31, 150, 140),
+        (31, 151, 140),
+        (31, 152, 139),
+        (31, 153, 139),
+        (31, 154, 139),
+        (31, 155, 139),
+        (31, 156, 138),
+        (31, 156, 138),
+        (31, 157, 138),
+        (31, 158, 137),
+        (31, 159, 137),
+        (31, 160, 137),
+        (31, 161, 136),
+        (31, 162, 136),
+        (32, 163, 135),
+        (32, 164, 135),
+        (32, 165, 134),
+        (33, 166, 134),
+        (33, 167, 134),
+        (34, 168, 133),
+        (34, 169, 133),
+        (35, 170, 132),
+        (36, 170, 131),
+        (37, 171, 131),
+        (38, 172, 130),
+        (38, 173, 130),
+        (39, 174, 129),
+        (40, 175, 128),
+        (41, 176, 128),
+        (43, 177, 127),
+        (44, 178, 126),
+        (45, 179, 126),
+        (46, 180, 125),
+        (48, 180, 124),
+        (49, 181, 123),
+        (50, 182, 123),
+        (52, 183, 122),
+        (53, 184, 121),
+        (55, 185, 120),
+        (56, 186, 119),
+        (58, 187, 118),
+        (60, 187, 118),
+        (61, 188, 117),
+        (63, 189, 116),
+        (65, 190, 115),
+        (67, 191, 114),
+        (68, 192, 113),
+        (70, 193, 112),
+        (72, 193, 111),
+        (74, 194, 110),
+        (76, 195, 109),
+        (78, 196, 108),
+        (80, 197, 106),
+        (82, 197, 105),
+        (84, 198, 104),
+        (86, 199, 103),
+        (88, 200, 102),
+        (90, 200, 101),
+        (92, 201, 99),
+        (95, 202, 98),
+        (97, 203, 97),
+        (99, 203, 95),
+        (101, 204, 94),
+        (103, 205, 93),
+        (106, 206, 91),
+        (108, 206, 90),
+        (110, 207, 89),
+        (113, 208, 87),
+        (115, 208, 86),
+        (117, 209, 84),
+        (120, 210, 83),
+        (122, 210, 81),
+        (125, 211, 80),
+        (127, 212, 78),
+        (130, 212, 77),
+        (132, 213, 75),
+        (135, 213, 74),
+        (137, 214, 72),
+        (140, 215, 71),
+        (142, 215, 69),
+        (145, 216, 67),
+        (147, 216, 66),
+        (150, 217, 64),
+        (153, 217, 62),
+        (155, 218, 61),
+        (158, 218, 59),
+        (160, 219, 57),
+        (163, 219, 55),
+        (166, 220, 54),
+        (168, 220, 52),
+        (171, 221, 50),
+        (174, 221, 49),
+        (176, 222, 47),
+        (179, 222, 45),
+        (182, 222, 43),
+        (184, 223, 42),
+        (187, 223, 40),
+        (190, 224, 38),
+        (192, 224, 37),
+        (195, 224, 35),
+        (198, 225, 34),
+        (201, 225, 32),
+        (203, 225, 31),
+        (206, 226, 29),
+        (209, 226, 28),
+        (211, 226, 27),
+        (214, 227, 26),
+        (216, 227, 26),
+        (219, 227, 25),
+        (222, 228, 25),
+        (224, 228, 24),
+        (227, 228, 24),
+        (229, 229, 25),
+        (232, 229, 25),
+        (235, 229, 26),
+        (237, 230, 27),
+        (240, 230, 28),
+        (242, 230, 29),
+        (245, 231, 30),
+        (247, 231, 32),
+        (249, 231, 33),
+        (252, 232, 35),
+        (254, 232, 37),
+    ))
+
+    def __init__(self):
+        self._n = len(self._VALUES)
+
+    def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
+        # Normalize floats
+        f = ColorMap.normalize(floats, lower, upper)
+        # Get RGB
+        val = self._VALUES[
+            np.minimum(np.round(f * self._n).astype(int), self._n - 1)]
+        # Color order
+        rgb = (sys.byteorder == 'big') if rgb is None else rgb
+        # Offset for first color in (a)rgb or rgb(a)
+        m = 1 if (alpha and rgb) else 0
+        # Number of bytes per float
+        n = 4 if alpha else 3
+        # Create output
+        out = 255 * np.ones(n * len(floats), dtype=np.uint8)
+        out[m + 0::n] = val[:, 0] if rgb else val[:, 2]
+        out[m + 1::n] = val[:, 1]
+        out[m + 2::n] = val[:, 2] if rgb else val[:, 0]
+        return out
+
+
+class ColorMapInferno(ColorMap):
+    """
+    A colormap using "Viridis".
+
+    The values used by this color map are taken from
+    https://github.com/BIDS/colormap/blob/master/colormaps.py
+    and were distributed under a CC0 license.
+
+    Viridis was designed by Eric Firing, Nathaniel J. Smith, and Stefan van der
+    Walt.
+    """
+    _VALUES = np.array((
+        (0, 0, 4),
+        (1, 0, 5),
+        (1, 1, 6),
+        (1, 1, 8),
+        (2, 1, 10),
+        (2, 2, 12),
+        (2, 2, 14),
+        (3, 2, 16),
+        (4, 3, 18),
+        (4, 3, 21),
+        (5, 4, 23),
+        (6, 4, 25),
+        (7, 5, 27),
+        (8, 6, 29),
+        (9, 6, 32),
+        (10, 7, 34),
+        (11, 7, 36),
+        (12, 8, 38),
+        (13, 8, 41),
+        (14, 9, 43),
+        (16, 9, 45),
+        (17, 10, 48),
+        (18, 10, 50),
+        (20, 11, 53),
+        (21, 11, 55),
+        (22, 11, 58),
+        (24, 12, 60),
+        (25, 12, 62),
+        (27, 12, 65),
+        (28, 12, 67),
+        (30, 12, 70),
+        (31, 12, 72),
+        (33, 12, 74),
+        (35, 12, 77),
+        (36, 12, 79),
+        (38, 12, 81),
+        (40, 11, 83),
+        (42, 11, 85),
+        (43, 11, 87),
+        (45, 11, 89),
+        (47, 10, 91),
+        (49, 10, 93),
+        (51, 10, 94),
+        (52, 10, 96),
+        (54, 9, 97),
+        (56, 9, 98),
+        (58, 9, 99),
+        (59, 9, 100),
+        (61, 9, 101),
+        (63, 9, 102),
+        (64, 10, 103),
+        (66, 10, 104),
+        (68, 10, 105),
+        (69, 10, 105),
+        (71, 11, 106),
+        (73, 11, 107),
+        (74, 12, 107),
+        (76, 12, 108),
+        (78, 13, 108),
+        (79, 13, 108),
+        (81, 14, 109),
+        (83, 14, 109),
+        (84, 15, 109),
+        (86, 15, 110),
+        (87, 16, 110),
+        (89, 17, 110),
+        (91, 17, 110),
+        (92, 18, 110),
+        (94, 18, 111),
+        (95, 19, 111),
+        (97, 20, 111),
+        (99, 20, 111),
+        (100, 21, 111),
+        (102, 21, 111),
+        (103, 22, 111),
+        (105, 23, 111),
+        (107, 23, 111),
+        (108, 24, 111),
+        (110, 24, 111),
+        (111, 25, 111),
+        (113, 25, 110),
+        (115, 26, 110),
+        (116, 27, 110),
+        (118, 27, 110),
+        (119, 28, 110),
+        (121, 28, 110),
+        (123, 29, 109),
+        (124, 29, 109),
+        (126, 30, 109),
+        (127, 31, 109),
+        (129, 31, 108),
+        (130, 32, 108),
+        (132, 32, 108),
+        (134, 33, 107),
+        (135, 33, 107),
+        (137, 34, 107),
+        (138, 34, 106),
+        (140, 35, 106),
+        (142, 36, 105),
+        (143, 36, 105),
+        (145, 37, 105),
+        (146, 37, 104),
+        (148, 38, 104),
+        (150, 38, 103),
+        (151, 39, 102),
+        (153, 40, 102),
+        (154, 40, 101),
+        (156, 41, 101),
+        (158, 41, 100),
+        (159, 42, 100),
+        (161, 43, 99),
+        (162, 43, 98),
+        (164, 44, 98),
+        (165, 45, 97),
+        (167, 45, 96),
+        (169, 46, 95),
+        (170, 46, 95),
+        (172, 47, 94),
+        (173, 48, 93),
+        (175, 49, 92),
+        (176, 49, 92),
+        (178, 50, 91),
+        (179, 51, 90),
+        (181, 51, 89),
+        (182, 52, 88),
+        (184, 53, 87),
+        (185, 54, 86),
+        (187, 54, 85),
+        (188, 55, 85),
+        (190, 56, 84),
+        (191, 57, 83),
+        (193, 58, 82),
+        (194, 59, 81),
+        (196, 60, 80),
+        (197, 60, 79),
+        (198, 61, 78),
+        (200, 62, 77),
+        (201, 63, 76),
+        (203, 64, 75),
+        (204, 65, 74),
+        (205, 66, 72),
+        (207, 67, 71),
+        (208, 68, 70),
+        (209, 69, 69),
+        (211, 70, 68),
+        (212, 72, 67),
+        (213, 73, 66),
+        (214, 74, 65),
+        (216, 75, 64),
+        (217, 76, 62),
+        (218, 77, 61),
+        (219, 79, 60),
+        (220, 80, 59),
+        (221, 81, 58),
+        (223, 82, 57),
+        (224, 84, 56),
+        (225, 85, 54),
+        (226, 86, 53),
+        (227, 88, 52),
+        (228, 89, 51),
+        (229, 90, 50),
+        (230, 92, 48),
+        (231, 93, 47),
+        (232, 95, 46),
+        (233, 96, 45),
+        (234, 98, 43),
+        (235, 99, 42),
+        (235, 101, 41),
+        (236, 102, 40),
+        (237, 104, 38),
+        (238, 105, 37),
+        (239, 107, 36),
+        (240, 109, 35),
+        (240, 110, 33),
+        (241, 112, 32),
+        (242, 113, 31),
+        (242, 115, 30),
+        (243, 117, 28),
+        (244, 118, 27),
+        (244, 120, 26),
+        (245, 122, 24),
+        (246, 123, 23),
+        (246, 125, 22),
+        (247, 127, 20),
+        (247, 129, 19),
+        (248, 130, 18),
+        (248, 132, 16),
+        (249, 134, 15),
+        (249, 136, 14),
+        (249, 137, 12),
+        (250, 139, 11),
+        (250, 141, 10),
+        (250, 143, 9),
+        (251, 145, 8),
+        (251, 146, 7),
+        (251, 148, 7),
+        (252, 150, 6),
+        (252, 152, 6),
+        (252, 154, 6),
+        (252, 156, 6),
+        (252, 158, 7),
+        (253, 160, 7),
+        (253, 161, 8),
+        (253, 163, 9),
+        (253, 165, 10),
+        (253, 167, 12),
+        (253, 169, 13),
+        (253, 171, 15),
+        (253, 173, 17),
+        (253, 175, 19),
+        (253, 177, 20),
+        (253, 179, 22),
+        (253, 181, 24),
+        (252, 183, 27),
+        (252, 185, 29),
+        (252, 186, 31),
+        (252, 188, 33),
+        (252, 190, 35),
+        (251, 192, 38),
+        (251, 194, 40),
+        (251, 196, 43),
+        (251, 198, 45),
+        (250, 200, 48),
+        (250, 202, 50),
+        (250, 204, 53),
+        (249, 206, 56),
+        (249, 208, 58),
+        (248, 210, 61),
+        (248, 212, 64),
+        (247, 214, 67),
+        (247, 216, 70),
+        (246, 218, 73),
+        (246, 220, 76),
+        (245, 222, 80),
+        (245, 224, 83),
+        (244, 226, 86),
+        (244, 228, 90),
+        (244, 229, 94),
+        (243, 231, 97),
+        (243, 233, 101),
+        (243, 235, 105),
+        (242, 237, 109),
+        (242, 238, 113),
+        (242, 240, 117),
+        (242, 241, 122),
+        (243, 243, 126),
+        (243, 244, 130),
+        (244, 246, 134),
+        (244, 247, 138),
+        (245, 249, 142),
+        (246, 250, 146),
+        (247, 251, 150),
+        (249, 252, 154),
+        (250, 253, 158),
+        (251, 254, 162),
+        (253, 255, 165),
+    ))
+
+    def __init__(self):
+        self._n = len(self._VALUES)
+
+    def __call__(self, floats, lower=None, upper=None, alpha=True, rgb=None):
+        # Normalize floats
+        f = ColorMap.normalize(floats, lower, upper)
+        # Get RGB
+        val = self._VALUES[
+            np.minimum(np.round(f * self._n).astype(int), self._n - 1)]
+        # Color order
+        rgb = (sys.byteorder == 'big') if rgb is None else rgb
+        # Offset for first color in (a)rgb or rgb(a)
+        m = 1 if (alpha and rgb) else 0
+        # Number of bytes per float
+        n = 4 if alpha else 3
+        # Create output
+        out = 255 * np.ones(n * len(floats), dtype=np.uint8)
+        out[m + 0::n] = val[:, 0] if rgb else val[:, 2]
+        out[m + 1::n] = val[:, 1]
+        out[m + 2::n] = val[:, 2] if rgb else val[:, 0]
+        return out
+
+
+ColorMap._colormaps['cividis'] = ColorMapCividis
+ColorMap._colormaps['inferno'] = ColorMapInferno
+ColorMap._colormaps['viridis'] = ColorMapViridis
+ColorMap._colormaps['gray'] = ColorMapGray
 ColorMap._colormaps['blue'] = ColorMapBlue
 ColorMap._colormaps['green'] = ColorMapGreen
 ColorMap._colormaps['red'] = ColorMapRed