colormap-1.0.6/0000755000175100001770000000000014511244171014137 5ustar runnerdocker00000000000000colormap-1.0.6/LICENSE0000644000175100001770000000271214511244163015147 0ustar runnerdocker00000000000000Copyright (c) 2014, Thomas Cokelaer All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of colormap nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. colormap-1.0.6/MANIFEST.in0000644000175100001770000000016514511244163015700 0ustar runnerdocker00000000000000include LICENSE include README.rst recursive-exclude * __pycache__ recursive-exclude * *pyc include requirements*txt colormap-1.0.6/PKG-INFO0000644000175100001770000001070214511244171015234 0ustar runnerdocker00000000000000Metadata-Version: 1.2 Name: colormap Version: 1.0.6 Summary: Utilities to ease manipulation of matplotlib colormaps and color codecs (e.g., hex2rgb) Home-page: http://github.com/cokelaer/colormap Author: Thomas Cokelaer Author-email: cokelaer@ebi.ac.uk Maintainer: Thomas Cokelaer Maintainer-email: cokelaer@ebi.ac.uk License: LGPL Download-URL: http://pypi.python.org/pypi/colormap Description: ############################# COLORMAP documentation ############################# Please see : http://colormap.readthedocs.io/ for an up-to-date documentation. .. image:: https://badge.fury.io/py/colormap.svg :target: https://pypi.python.org/pypi/colormap .. image:: https://github.com/cokelaer/colormap/actions/workflows/ci.yml/badge.svg?branch=master :target: https://github.com/cokelaer/colormap/actions/workflows/ci.yml .. image:: https://coveralls.io/repos/cokelaer/colormap/badge.png?branch=master :target: https://coveralls.io/r/cokelaer/colormap?branch=master :version: Python 3.8, 3.9, 3.10, 3.11 :contributions: Please join https://github.com/cokelaer/colormap :issues: Please use https://github.com/cokelaer/colormap/issues :notebook: Please see https://github.com/cokelaer/colormap/tree/master/notebooks What is it ? ################ **colormap** package provides simple utilities to convert colors between RGB, HEX, HLS, HUV and a class to easily build colormaps for matplotlib. All matplotlib colormaps and some R colormaps are available altogether. The plot_colormap method (see below) is handy to quickly pick up a colormaps and the test_colormap is useful to see test a new colormap. Installation ################### :: pip install colormap Example ########## * Create your own colormap from red to green colors with intermediate color as whitish (diverging map from red to green):: c = Colormap() mycmap = c.cmap( {'red':[1,1,0], 'green':[0,1,.39], 'blue':[0,1,0]}) cmap = c.test_colormap(mycmap) * Even simpler if the colormap is linear:: c = Colormap() mycmap = c.cmap_linear('red', 'white', 'green(w3c)') cmap = c.test_colormap(mycmap) .. image:: https://colormap.readthedocs.io/en/latest/_images/quickstart-6.png :width: 50% :align: center * check out the available colormaps:: c = Colormap() c.plot_colormap('diverging') .. image:: https://colormap.readthedocs.io/en/latest/_images/quickstart-4.png :width: 50% :align: center See online documentation for details: http://colormap.readthedocs.io/ changelog ######### ========= ================================================================================ Version Description ========= ================================================================================ 1.0.6 * Fix a matplotlib deprecation * Fix RTD documentation 1.0.5 * remove Python3.6 and added Python3.10 to CI action * Fix issue in setup reported in https://github.com/cokelaer/colormap/pull/14 * add requirements in MANIFEST * applied black on all files ========= ================================================================================ Keywords: hex2web,web2hex,hex2rgb,rgb2hex,rgb2hsv,hsv2rgb,rgb2hls,hls2rgb,colormap,colors Platform: Linux Platform: Unix Platform: MacOsX Platform: Windows Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Topic :: Software Development :: Libraries :: Python Modules colormap-1.0.6/README.rst0000644000175100001770000000527614511244163015641 0ustar runnerdocker00000000000000############################# COLORMAP documentation ############################# Please see : http://colormap.readthedocs.io/ for an up-to-date documentation. .. image:: https://badge.fury.io/py/colormap.svg :target: https://pypi.python.org/pypi/colormap .. image:: https://github.com/cokelaer/colormap/actions/workflows/ci.yml/badge.svg?branch=master :target: https://github.com/cokelaer/colormap/actions/workflows/ci.yml .. image:: https://coveralls.io/repos/cokelaer/colormap/badge.png?branch=master :target: https://coveralls.io/r/cokelaer/colormap?branch=master :version: Python 3.8, 3.9, 3.10, 3.11 :contributions: Please join https://github.com/cokelaer/colormap :issues: Please use https://github.com/cokelaer/colormap/issues :notebook: Please see https://github.com/cokelaer/colormap/tree/master/notebooks What is it ? ################ **colormap** package provides simple utilities to convert colors between RGB, HEX, HLS, HUV and a class to easily build colormaps for matplotlib. All matplotlib colormaps and some R colormaps are available altogether. The plot_colormap method (see below) is handy to quickly pick up a colormaps and the test_colormap is useful to see test a new colormap. Installation ################### :: pip install colormap Example ########## * Create your own colormap from red to green colors with intermediate color as whitish (diverging map from red to green):: c = Colormap() mycmap = c.cmap( {'red':[1,1,0], 'green':[0,1,.39], 'blue':[0,1,0]}) cmap = c.test_colormap(mycmap) * Even simpler if the colormap is linear:: c = Colormap() mycmap = c.cmap_linear('red', 'white', 'green(w3c)') cmap = c.test_colormap(mycmap) .. image:: https://colormap.readthedocs.io/en/latest/_images/quickstart-6.png :width: 50% :align: center * check out the available colormaps:: c = Colormap() c.plot_colormap('diverging') .. image:: https://colormap.readthedocs.io/en/latest/_images/quickstart-4.png :width: 50% :align: center See online documentation for details: http://colormap.readthedocs.io/ changelog ######### ========= ================================================================================ Version Description ========= ================================================================================ 1.0.6 * Fix a matplotlib deprecation * Fix RTD documentation 1.0.5 * remove Python3.6 and added Python3.10 to CI action * Fix issue in setup reported in https://github.com/cokelaer/colormap/pull/14 * add requirements in MANIFEST * applied black on all files ========= ================================================================================ colormap-1.0.6/requirements.txt0000644000175100001770000000002314511244163017417 0ustar runnerdocker00000000000000matplotlib easydev colormap-1.0.6/setup.cfg0000644000175100001770000000041014511244171015753 0ustar runnerdocker00000000000000[upload_docs] upload_dir = doc/build/html/ [sdist] [build_sphinx] source_dir = doc/source build_dir = doc/build all_files = 1 [tool:pytest] addopts = --durations=10 --verbose -n 1 --cov colormap --cov-report term-missing [egg_info] tag_build = tag_date = 0 colormap-1.0.6/setup.py0000644000175100001770000000502414511244163015653 0ustar runnerdocker00000000000000# -*- coding: utf-8 -*- __revision__ = "$Id: setup.py 3170 2013-01-16 14:57:19Z cokelaer $" import sys import os from setuptools import setup, find_packages import glob _MAJOR = 1 _MINOR = 0 _MICRO = 6 version = '%d.%d.%d' % (_MAJOR, _MINOR, _MICRO) release = '%d.%d' % (_MAJOR, _MINOR) metainfo = { 'authors': {'Cokelaer':('Thomas Cokelaer','cokelaer@ebi.ac.uk')}, 'version': version, 'license' : 'LGPL', 'download_url' : 'http://pypi.python.org/pypi/colormap', 'url' : "http://github.com/cokelaer/colormap", 'description':'Utilities to ease manipulation of matplotlib colormaps and color codecs (e.g., hex2rgb)', 'platforms' : ['Linux', 'Unix', 'MacOsX', 'Windows'], 'keywords' : ["hex2web", "web2hex", "hex2rgb", "rgb2hex", "rgb2hsv", "hsv2rgb", "rgb2hls", "hls2rgb", "colormap", 'colors'], 'classifiers' : [ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)', 'Operating System :: OS Independent', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Topic :: Software Development :: Libraries :: Python Modules' ] } on_rtd = os.environ.get('READTHEDOCS', None) == 'True' with open("requirements.txt", "r") as fin: install_requires = fin.read().split() if on_rtd is True: # only import and set the theme if we're building docs install_requires += ["numpydoc"] setup( name = 'colormap', version = version, maintainer = metainfo['authors']['Cokelaer'][0], maintainer_email = metainfo['authors']['Cokelaer'][1], author = metainfo['authors']['Cokelaer'][0], author_email = metainfo['authors']['Cokelaer'][1], long_description = open("README.rst").read(), keywords = metainfo['keywords'], description = metainfo['description'], license = metainfo['license'], platforms = metainfo['platforms'], url = metainfo['url'], download_url = metainfo['download_url'], classifiers = metainfo['classifiers'], # package installation package_dir = {'':'src'}, packages = ['colormap'], install_requires = install_requires, ) colormap-1.0.6/src/0000755000175100001770000000000014511244171014726 5ustar runnerdocker00000000000000colormap-1.0.6/src/colormap/0000755000175100001770000000000014511244171016542 5ustar runnerdocker00000000000000colormap-1.0.6/src/colormap/__init__.py0000644000175100001770000000174014511244163020656 0ustar runnerdocker00000000000000# -*- python -*- # -*- coding: utf-8 -*- # # This file is part of the colormap software # # Copyright (c) 2014 # # File author(s): Thomas Cokelaer # # Distributed under the GPLv3 License. # See accompanying file LICENSE.txt or copy at # http://www.gnu.org/licenses/gpl-3.0.html # # Website: https://www.github.com/cokelaer/colormap # Documentation: http://packages.python.org/colormap # ############################################################################## """main colormap module""" from __future__ import print_function from __future__ import division import pkg_resources try: version = pkg_resources.require("colormap")[0].version __version__ = version except Exception: version = "" from .xfree86 import * from . import colors from .colors import * from .get_cmap import * c = Colormap() colormap_names = c.colormaps + c.diverging_black # create an alias to test_colormap methiod test_colormap = c.test_colormap test_cmap = c.test_colormap colormap-1.0.6/src/colormap/colors.py0000644000175100001770000010105614511244163020421 0ustar runnerdocker00000000000000# -*- python -*- # -*- coding: utf-8 -*- # # This file is part of the colormap software # # Copyright (c) 2011-20134 # # File author(s): Thomas Cokelaer # # Distributed under the GPLv3 License. # See accompanying file LICENSE.txt or copy at # http://www.gnu.org/licenses/gpl-3.0.html # # Website: https://github.com/cokelaer/colormap # Documentation: http://packages.python.org/colormap # ############################################################################## """Utilities provided in this module can be found either in the standard Python module called :mod:`colorsys` or in matplotlib.colors (e.g rgb2hex) or are original to this module (e.g., rgb2huv) """ # matplotlib dependence is only inside Colormap class import colorsys from easydev.tools import check_param_in_list, swapdict, check_range from colormap.xfree86 import XFree86_colors __all__ = [ "HEX", "Color", "hex2web", "web2hex", "hex2rgb", "hex2dec", "rgb2hex", "rgb2hsv", "hsv2rgb", "rgb2hls", "hls2rgb", "yuv2rgb", "rgb2yuv", "to_intensity", "yuv2rgb_int", "rgb2yuv_int", "Colormap", ] def hex2web(hexa): """Convert hexadecimal string (6 digits) into *web* version (3 digits) .. doctest:: >>> from colormap.colors import hex2web >>> hex2web("#FFAA11") '#FA1' .. seealso:: :func:`web2hex`, :func:`hex2rgb` :func:`rgb2hex`, :func:`rgb2hsv`, :func:`hsv2rgb`, :func:`rgb2hls`, :func:`hls2rgb` """ hexa = HEX().get_standard_hex_color(hexa) return "#" + hexa[1::2] def web2hex(web): """Convert *web* hexadecimal string (3 digits) into 6 digits version .. doctest:: >>> from colormap.colors import web2hex >>> web2hex("#FA1") '#FFAA11' .. seealso:: :func:`hex2web`, :func:`hex2rgb` :func:`rgb2hex`, :func:`rgb2hsv`, :func:`hsv2rgb`, :func:`rgb2hls`, :func:`hls2rgb` """ return HEX().get_standard_hex_color(web) def hex2rgb(hexcolor, normalise=False): """This function converts a hex color triplet into RGB Valid hex code are: * #FFF * #0000FF * 0x0000FF * 0xFA1 .. doctest:: >>> from colormap.colors import hex2rgb >>> hex2rgb("#FFF", normalise=False) (255, 255, 255) >>> hex2rgb("#FFFFFF", normalise=True) (1.0, 1.0, 1.0) .. seealso:: :func:`hex2web`, :func:`web2hex`, :func:`rgb2hex`, :func:`rgb2hsv`, :func:`hsv2rgb`, :func:`rgb2hls`, :func:`hls2rgb` """ hexcolor = HEX().get_standard_hex_color(hexcolor)[1:] r, g, b = int(hexcolor[0:2], 16), int(hexcolor[2:4], 16), int(hexcolor[4:6], 16) if normalise: r, g, b = _normalise(r, g, b) return r, g, b def rgb2hex(r, g, b, normalised=False): """Convert RGB to hexadecimal color :param: can be a tuple/list/set of 3 values (R,G,B) :return: a hex vesion ofthe RGB 3-tuple .. doctest:: >>> from colormap.colors import rgb2hex >>> rgb2hex(0,0,255, normalised=False) '#0000FF' >>> rgb2hex(0,0,1, normalised=True) '#0000FF' .. seealso:: :func:`hex2web`, :func:`web2hex`, :func:`hex2rgb` , :func:`rgb2hsv`, :func:`hsv2rgb`, :func:`rgb2hls`, :func:`hls2rgb` """ if normalised: r, g, b = _denormalise(r, g, b, mode="rgb") r = int(r) g = int(g) b = int(b) check_range(r, 0, 255) check_range(g, 0, 255) check_range(b, 0, 255) return "#%02X%02X%02X" % (r, g, b) def rgb2hls(r, g, b, normalised=True): """Convert an RGB value to an HLS value. :param bool normalised: if *normalised* is True, the input RGB triplet should be in the range 0-1 (0-255 otherwise) :return: the HLS triplet. If *normalised* parameter is True, the output triplet is in the range 0-1; otherwise, H in the range 0-360 and LS in the range 0-100. .. doctest:: >>> from colormap.colors import rgb2hls >>> rgb2hls(255,255,255, normalised=False) (0.0, 1.0, 0.0) .. seealso:: :func:`hex2web`, :func:`web2hex`, :func:`hex2rgb` :func:`rgb2hex`, :func:`hsv2rgb`, :func:`hls2rgb` """ # rgb_to_hsv expects normalised values ! if normalised: upper = 1 else: upper = 255 check_range(r, 0, upper) check_range(g, 0, upper) check_range(b, 0, upper) if normalised == False: r, g, b = _normalise(r, g, b) h, l, s = colorsys.rgb_to_hls(r, g, b) return h, l, s def rgb2hsv(r, g, b, normalised=True): """Convert an RGB value to an HSV value. :param bool normalised: if *normalised* is True, the input RGB triplet should be in the range 0-1 (0-255 otherwise) :return: the HSV triplet. If *normalised* parameter is True, the output triplet is in the range 0-1; otherwise, H in the range 0-360 and LS in the range 0-100. .. doctest:: >>> from colormap.colors import rgb2hsv >>> rgb2hsv(0.5,0,1) (0.75, 1, 1) .. seealso:: :func:`hex2web`, :func:`web2hex`, :func:`hex2rgb` :func:`rgb2hex`, :func:`hsv2rgb`, :func:`rgb2hls`, :func:`hls2rgb` """ # rgb_to_hsv expects normalised values ! if normalised: upper = 1 else: upper = 255 check_range(r, 0, upper) check_range(g, 0, upper) check_range(b, 0, upper) if normalised == False: r, g, b = _normalise(r, g, b) h, s, v = colorsys.rgb_to_hsv(r, g, b) return h, s, v def hsv2rgb(h, s, v, normalised=True): """Convert a hue-saturation-value (HSV) value to a red-green-blue (RGB). :param bool normalised: If *normalised* is True, the input HSV triplet should be in the range 0-1; otherwise, H in the range 0-360 and LS in the range 0-100. :return: the RGB triplet. The output triplet is in the range 0-1 whether the input is normalised or not. .. doctest:: >>> from colormap.colors import hsv2rgb >>> hsv2rgb(0.5,1,1, normalised=True) # doctest: +SKIP (0, 1, 1) .. seealso:: :func:`hex2web`, :func:`web2hex`, :func:`hex2rgb` :func:`rgb2hex`, :func:`rgb2hsv`, :func:`rgb2hls`, :func:`hls2rgb` .. seealso:: :func:`rgb2hex` """ if normalised: upper = 1 else: upper = 100 if normalised: uppera = 1 else: uppera = 360 check_range(h, 0, uppera) check_range(s, 0, upper) check_range(v, 0, upper) if normalised == False: h, s, v = _normalise(h, s, v, mode="hsv") return colorsys.hsv_to_rgb(h, s, v) def hls2rgb(h, l, s, normalised=True): """Convert an HLS value to a RGB value. :param bool normalised: If *normalised* is True, the input HLS triplet should be in the range 0-1; otherwise, H in the range 0-360 and LS in the range 0-100. :return: the RGB triplet. The output triplet is in the range 0-1 whether the input is normalised or not. .. doctest:: >>> from colormap.colors import hls2rgb >>> hls2rgb(360, 50, 60, normalised=False) # doctest: +SKIP (0.8, 0.2, 0.2) .. seealso:: :func:`hex2web`, :func:`web2hex`, :func:`hex2rgb` :func:`rgb2hex`, :func:`rgb2hsv`, :func:`hsv2rgb`, :func:`rgb2hls`, """ if normalised: upper = 1 else: upper = 100 if normalised: uppera = 1 else: uppera = 360 check_range(h, 0, uppera) check_range(s, 0, upper) check_range(l, 0, upper) if normalised == False: h, l, s = _normalise(h, l, s, mode="hls") return colorsys.hls_to_rgb(h, l, s) def hex2dec(data): """convert hexadecimal string (data) into a float in the [0-65536] inclusive range""" if data[0] == "#": data.replace("#", "") return int(data, 16) / 255.0 def rgb2yuv(r, g, b): """Convert RGB triplet into YUV :return: YUV triplet with values between 0 and 1 `YUV wikipedia `_ .. warning:: expected input must be between 0 and 1 .. note:: the constants referenc used is Rec. 601 """ check_range(r, 0, 1) check_range(g, 0, 1) check_range(b, 0, 1) # y = int(0.299 * r + 0.587 * g + 0.114 * b) # u = int(-0.14713 * r + -0.28886 * g + 0.436 * b) # v = int(0.615 * r + -0.51499 * g + -0.10001 * b) y = 0.299 * r + 0.587 * g + 0.114 * b u = -32591.0 / 221500.0 * r + -63983.0 / 221500.0 * g + 0.436 * b v = 0.615 * r + -72201.0 / 140200 * g + -7011 / 70100.0 * b return (y, u, v) def yuv2rgb(y, u, v): """Convert YUV triplet into RGB `YUV `_ .. warning:: expected input must be between 0 and 255 (not normalised) """ check_range(y, 0, 1) check_range(u, 0, 1) check_range(v, 0, 1) A, B, C, D = 701.0 / 615.0, 25251.0 / 63983.0, 209599.0 / 361005.0, 443.0 / 218.0 r = y + A * v g = y - B * u - C * v b = y + D * u return (r, g, b) def rgb2yuv_int(r, g, b): """Convert RGB triplet into YUV `YUV wikipedia `_ .. warning:: expected input must be between 0 and 255 (not normalised) """ check_range(r, 0, 255) check_range(g, 0, 255) check_range(b, 0, 255) y = int(0.299 * r + 0.587 * g + 0.114 * b) u = int(-32591.0 / 221500.0 * r + -63983.0 / 221500.0 * g + 0.436 * b) v = int(0.615 * r + -72201.0 / 140200 * g + -7011 / 70100.0 * b) return (y, u, v) def yuv2rgb_int(y, u, v): """Convert YUV triplet into RGB `YUV `_ .. warning:: expected input must be between 0 and 255 (not normalised) """ check_range(y, 0, 255) check_range(u, 0, 255) check_range(v, 0, 255) r = int(y + 1.13983 * v) g = int(y - 0.39465 * u - 0.58060 * v) b = int(y + 2.03211 * u) return (r, g, b) def _denormalise(r, g, b, mode="rgb"): check_param_in_list(mode, ["rgb", "hls", "hsv"]) if mode == "rgb": return r * 255.0, g * 255.0, b * 255.0 elif mode in ["hls", "hsv"]: return r * 360.0, g * 100.0, b * 100.0 def _normalise(r, g, b, mode="rgb"): check_param_in_list(mode, ["rgb", "hls", "hsv"]) if mode == "rgb": return r / 255.0, g / 255.0, b / 255.0 elif mode in ["hls", "hsv"]: return r / 360.0, g / 100.0, b / 100.0 def to_intensity(n): """Return intensity :param n: value between 0 and 1 :return: value between 0 and 255; round(n*127.5+127.5) """ check_range(n, 0, 1) return int(round(n * 127.5 + 127.5)) class HEX(object): """Class to check the validity of an hexadecimal string and get standard string By standard, we mean #FFFFFF (6 digits) :: >>> h = HEX() >>> h.is_valid_hex_color("#FFFF00") True """ def __init__(self): pass def is_valid_hex_color(self, value, verbose=True): """Return True is the string can be interpreted as hexadecimal color Valid formats are * #FFF * #0000FF * 0x0000FF * 0xFA1 """ try: self.get_standard_hex_color(value) return True except Exception as err: if verbose: print(err) return False def get_standard_hex_color(self, value): """Return standard hexadecimal color By standard, we mean a string that starts with # sign followed by 6 character, e.g. #AABBFF """ if isinstance(value, str) == False: raise TypeError("value must be a string") if len(value) <= 3: raise ValueError("input string must be of type 0xFFF, 0xFFFFFF or #FFF or #FFFFFF") if value.startswith("0x") or value.startswith("0X"): value = value[2:] elif value.startswith("#"): value = value[1:] else: raise ValueError("hexa string must start with a '#' sign or '0x' string") value = value.upper() # Now, we have either FFFFFF or FFF # now check the length for x in value: if x not in "0123456789ABCDEF": raise ValueError("Found invalid hexa character {0}".format(x)) if len(value) == 6 or len(value) == 8: value = "#" + value[0:6] elif len(value) == 3: value = "#" + value[0] * 2 + value[1] * 2 + value[2] * 2 else: raise ValueError("hexa string should be 3, 6 or 8 digits. if 8 digits, last 2 are ignored") return value class Color(HEX): """Class to ease manipulation and conversion between color codes You can create an instance in many differen ways. You can either use a human-readable name as long as it is part of the `XFree86 list `_ You can also provide a hexadecimal string (either 3 or 6 digits). You can use triplets of values corresponding to the RGB, HSV or HLS conventions. Here are some examples: .. doctest:: from colormap import Color Color("red") # human XFree86 compatible representation Color("#f00") # standard 3 hex digits Color("#ff0000") # standard 6 hex digits Color(hsv=(0,1,0.5)) Color(hls=(0, 1, 0.5)) # HLS triplet Color(rgb=(1, 0, 0)) # RGB triplet Color(Color("red")) # using an instance of :class:`Color` Note that the RGB, HLS and HSV triplets use normalised values. If you need to normalise the triplet, you can use :mod:`colormap.colors._normalise` that provides a function to normalise RGB, HLS and HSV triplets:: colors._normalise(*(255, 255, 0), mode="rgb") colors._normalise(*(360, 50, 100), mode="hls") If you provide a string, it has to be a valid string from XFree86. In addition to the official names, the lower case names are valid. Besides, there are names with spaces. The equivalent names without space are also valid. Therefore the name "Spring Green", which is an official name can be provided as "Spring Green", "spring green", "springgreen" or "SpringGreen". """ # Get official color names colors = XFree86_colors.copy() # add color names without spaces aliases = dict([(x.replace(" ", ""), x) for x in colors.keys() if " " in x]) # add color names without spaces in lower cases aliases.update([(x.replace(" ", "").lower(), x) for x in colors.keys() if " " in x]) # add color names in lower case aliases.update(dict([(x.lower(), x) for x in colors.keys()])) aliases.update(dict([(x, x) for x in colors.keys()])) # keep track of all possible names color_names = sorted(list(set(list(colors.keys()) + list(aliases.keys())))) def __init__(self, name=None, rgb=None, hls=None, hsv=None): super(Color, self).__init__() self._name = None self._mode = None self._rgb = None # Does the user provided the name argument (first one) as a string ? if isinstance(name, str): # if so, it can be a valid human name (e.g., red) or an hex # assuming that valid hexadecimal starts with # or 0x, # if we can interpret the string as an hexadecimal, we are done if self.is_valid_hex_color(name, verbose=False): self.hex = name else: # if not, then, the user probably provided a valid color name # the property will check the validity. self.name = name[:] # all other input parameters are ignored elif name == None: if rgb: self.rgb = rgb elif hls: self.hls = hls elif hsv: self.hsv = hsv else: raise ValueError("You must set one of the parameter") elif isinstance(name, Color): self.rgb = name.rgb else: raise ValueError("name parameter must be a string") def _get_name(self): return self._name def _set_name(self, name): check_param_in_list(name, self.color_names) name = self.aliases[name] self._name = name # set hex and rgb at the same time based on the name self.hex = self.colors[name] name = property(_get_name, _set_name) color = property(_get_name, _set_name) def _get_hex(self): return self._hex def _set_hex(self, value): # hex is an approximation made of 255 bits so do not define rgb here if self.is_valid_hex_color(value): value = self.get_standard_hex_color(value) self._hex = value if self._hex in self.colors.values(): self._name = swapdict(self.colors, check_ambiguity=False)[self._hex] else: self._name = "undefined" self._rgb = hex2rgb(self._hex, normalise=True) else: # just to warn the user self.get_standard_hex_color(value) hex = property(_get_hex, _set_hex, doc="getter/setter the hexadecimal value.") def _get_rgb(self): return self._rgb def _set_rgb(self, value): # set name, hex and rgb self.hex = rgb2hex(*value, normalised=True) # must reset rgb with its real value (set_hex may round the rgb) # in _set_hex self._rgb = value rgb = property(_get_rgb, _set_rgb, doc="getter/setter the RGB values (3-length tuple)") def _get_hsv(self): hsv = rgb2hsv(*self.rgb) return hsv def _set_hsv(self, value): # TODO: value must be normalised self.rgb = hsv2rgb(*value) hsv = property(_get_hsv, _set_hsv, doc="getter/setter the HSV values (3-length tuple)") def _get_hls(self): hls = rgb2hls(*self.rgb) return hls def _set_hls(self, value): # hls = _normalise(*value, mode="hls") # else: hls = value self.rgb = hls2rgb(*hls) hls = property(_get_hls, _set_hls, doc="getter/setter the HLS values (3-length tuple)") def _get_lightness(self): return self.hls[1] def _set_lightness(self, lightness): h, l, s = self.hls self.hls = (h, lightness, s) lightness = property(_get_lightness, _set_lightness, doc="getter/setter the lightness in the HLS triplet") def _get_saturation_hls(self): return self.hls[2] def _set_saturation_hls(self, saturation): h, l, s = self.hls self.hls = (h, l, saturation) saturation_hls = property( _get_saturation_hls, _set_saturation_hls, doc="getter/setter the saturation in the HLS triplet" ) def _get_hue(self): return self.hls[0] def _set_hue(self, hue): h, l, s = self.hls self.hls = (hue, l, s) hue = property(_get_hue, _set_hue, doc="getter/setter the saturation in the HLS triplet") def _get_red(self): return self.rgb[0] def _set_red(self, red): r, g, b = self.rgb self.rgb = (red, g, b) red = property(_get_red, _set_red, doc="getter/setter for the red color in RGB triplet") def _get_green(self): return self.rgb[1] def _set_green(self, green): r, g, b = self.rgb self.rgb = (r, green, b) green = property(_get_green, _set_green, doc="getter/setter for the green color in RGB triplet") def _get_blue(self): return self.rgb[2] def _set_blue(self, blue): r, g, b = self.rgb self.rgb = (r, g, blue) blue = property(_get_blue, _set_blue, doc="getter/setter for the blue color in RGB triplet") def _get_value(self): return self.hsv[2] def _set_value(self, value): h, s, v = self.hsv self.hsv = (h, s, value) value = property(_get_value, _set_value, doc="getter/setter the value in the HSV triplet") def _get_yiq(self): return colorsys.rgb_to_yiq(*self.rgb) yiq = property(_get_yiq, doc="Getter for the YIQ triplet") def __str__(self): txt = "Color {0}\n".format(self.name) txt += " hexa code: {0}\n".format(self.hex) txt += " RGB code: {0}\n".format(self.rgb) txt += " RGB code (un-normalised): {0}\n\n".format([x * 255 for x in self.rgb]) txt += " HSV code: {0}\n".format(self.hsv) txt += " HSV code: (un-normalised) {0} {1} {2}\n\n".format( self.hsv[0] * 360, self.hsv[1] * 100, self.hsv[2] * 100 ) txt += " HLS code: {0}\n".format(self.hls) txt += " HLS code: (un-normalised) {0} {1} {2}\n\n".format( self.hls[0] * 360, self.hls[1] * 100, self.hls[2] * 100 ) return txt class Colormap(object): """Class to create matplotlib colormap This example show how to get the pre-defined colormap called *heat* .. plot:: :include-source: from pylab import * from colormap.colors import Colormap c = Colormap() cmap = c.get_cmap_heat() c.test_colormap(cmap) You may be more interested in building your own colormap:: # design your own colormap d = {'blue': [0,0,0,1,1,1,0], 'green':[0,1,1,1,0,0,0], 'red': [1,1,0,0,0,1,1]} cmap = c.cmap(d, reverse=False) # see the results c.test_colormap(cmap) If you want a simple linear colormap, you can use the example above, or use the :meth:`cmap_linear`. For instance for a diverging colormap from red to green (with with color in between):: cmap = c.cmap_linear("red", "white", "green") c.test_colormap(cmap) Even simpler, you can use a bicolor colormap :meth:`cmap_bicolor`. For instance for a red to green colormap:: cmap = c.cmap_bicolor("red", "green") c.test_colormap(cmap) From matplotlib documentation, colormaps falls into 4 categories: #. Sequential schemes for unipolar data that progresses from low to high #. Diverging schemes for bipolar data that emphasizes positive or negative deviations from acentral value #. Cyclic schemes meant for plotting values that wrap around at the endpoints, such as phase angle, wind direction, or time of day #. Qualitative schemes for nominal data that has no inherent ordering, where color is used only to distinguish categories :references: matplotlib documentation and examples http://matplotlib.org/examples/color/colormaps_reference.html """ def _get_colormap_mpl(self): try: from matplotlib.pyplot import colormaps as _cmaps return _cmaps() except: return [] colormaps = property(_get_colormap_mpl) def _get_sequentials(self): return [ "Blues", "BuGn", "BuPu", "GnBu", "Greens", "Greys", "OrRd", "Oranges", "PuBu", "PuBuGn", "PuRd", "Purples", "RdPu", "Reds", "YlGn", "YlGnBu", "YlOrBr", "YlOrRd", ] sequentials = property(_get_sequentials) def _get_sequentials2(self): return [ "afmhot", "autumn", "bone", "cool", "copper", "gist_heat", "gray", "hot", "pink", "spring", "summer", "winter", ] sequentials2 = property(_get_sequentials2) def _get_diverging(self): return [ "BrBG", "PRGn", "PiYG", "PuOr", "RdBu", "RdGy", "RdYlBu", "RdYlGn", "Spectral", "bwr", "coolwarm", "seismic", ] diverging = property(_get_diverging) def _get_diverging_black(self): return [ "red_black_sky", "red_black_blue", "red_black_green", "yellow_black_blue", "yellow_black_sky", "red_black_orange", "pink_black_green(w3c)", ] diverging_black = property(_get_diverging_black) def _get_qualitative(self): return ["Accent", "Dark2", "Paired", "Pastel1", "Pastel2", "Set1", "Set2", "Set3"] qualitative = property(_get_qualitative) def _get_misc(self): return [ "gist_earth", "terrain", "ocean", "gist_stern", "brg", "CMRmap", "cubehelix", "gnuplot", "gnuplot2", "gist_ncar", "nipy_spectral", "jet", "rainbow", "gist_rainbow", "hsv", "flag", "prism", ] misc = property(_get_misc) def plot_rgb_from_hex_list(self, cols): """This functions takes a list of hexadecimal values and plots the RGB curves. This can be handy to figure out the RGB functions to be used in the :meth:`get_cmap`. .. plot:: :include-source: :width: 60% from colormap.colors import Colormap c = Colormap() t = ['#FF0000FF', '#FF4D00FF', '#FF9900FF', '#FFE500FF', '#CCFF00FF', '#80FF00FF', '#33FF00FF', '#00FF19FF', '#00FF66FF', '#00FFB2FF', '#00FFFFFF', '#00B3FFFF', '#0066FFFF', '#001AFFFF', '#3300FFFF', '#7F00FFFF', '#CC00FFFF','#FF00E6FF','#FF0099FF', '#FF004DFF'] c.plot_rgb_from_hex_list(t) """ import pylab red = [hex2rgb(x)[0] / 255.0 for x in cols] blue = [hex2rgb(x)[2] / 255.0 for x in cols] green = [hex2rgb(x)[1] / 255.0 for x in cols] x = pylab.linspace(0, 1, len(cols)) pylab.clf() pylab.plot(x, red, "ro-", alpha=0.5) pylab.plot(x, green, "gs-", alpha=0.5, markersize=15) pylab.plot(x, blue, "bx-", alpha=0.5, markersize=15) pylab.ylim([-0.1, 1.1]) def cmap_bicolor(self, color1, color2, reverse=False, N=256): """Provide 3 colors in format accepted by :class:`Color` :: >>> red = Color('red') >>> white = Color('white') >>> cmap = cmap_bicolor(red, white) """ c1 = Color(color1) c2 = Color(color2) dico = {"red": [c1.red, c2.red], "green": [c1.green, c2.green], "blue": [c1.blue, c2.blue]} return self.cmap(dico, reverse=reverse, N=N) def cmap_linear(self, color1, color2, color3, reverse=False, N=256): """Provide 3 colors in format accepted by :class:`Color` :: red = Color('red') cmap = cmap_linear(red, 'white', '#0000FF') """ c1 = Color(color1) c2 = Color(color2) c3 = Color(color3) dico = { "red": [c1.red, c2.red, c3.red], "green": [c1.green, c2.green, c3.green], "blue": [c1.blue, c2.blue, c3.blue], } return self.cmap(dico, reverse=reverse, N=N) def cmap(self, colors=None, reverse=False, N=256): """Return a colormap object to be used within matplotlib :param dict colors: a dictionary that defines the RGB colors to be used in the colormap. See :meth:`get_cmap_heat` for an example. :param bool reverse: reverse the colormap is set to True (defaults to False) :param int N: Defaults to 50 """ # matplotlib colormaps if colors in self.colormaps: if reverse and colors.endswith("_r") is False: colors += "_r" from matplotlib import colormaps return colormaps[colors] # custom ones elif colors in self.diverging_black: c1, c2, c3 = colors.split("_") # special case of sky, which does not exists c3 = c3.replace("sky", "deep sky blue") return self.cmap_linear(c1, c2, c3) elif colors == "heat": return self.get_cmap_heat() elif colors == "heat_r": return self.get_cmap_heat_r() # Keep these dependencies inside the function to allow # installation of colormap without those dependencies # FIXME remove numpy dependencies import numpy as np # extracted from R, heat.colors(20) if reverse: for k in colors.keys(): colors[k].reverse() # If index not given, RGB colors are evenly-spaced in colormap. index = np.linspace(0, 1, len(colors["red"])) # Adapt color_data to the form expected by LinearSegmentedColormap. color_data = dict((key, [(x, y, y) for x, y in zip(index, value)]) for key, value in list(colors.items())) import matplotlib f = matplotlib.colors.LinearSegmentedColormap m = f("my_color_map", color_data, N) return m def get_cmap_heat(self): """Return a heat colormap matplotlib-compatible colormap This heat colormap should be equivalent to heat.colors() in R. :: >>> from colormap.colors import Colormap >>> cmap = Colormap.get_cmap_heat() You can generate the colormap based solely on this information for the RGB functions along:: d= { 'blue':[0,0,0,0,1], 'green':[0,.35,.7,1,1], 'red':[1,1,1,1,1]} cmap = Colormap.get_cmap(d) """ return self.cmap( {"blue": [0, 0, 0, 0, 1], "green": [0, 0.35, 0.7, 1, 1], "red": [1, 1, 1, 1, 1]}, reverse=False ) def get_cmap_heat_r(self): """Return a heat colormap matplotlib-compatible colormap Same as :meth:`get_cmap_heat` but reversed """ return self.cmap({"blue": [0, 0, 0, 0, 1], "green": [0, 0.35, 0.7, 1, 1], "red": [1, 1, 1, 1, 1]}, reverse=True) def get_cmap_rainbow(self): """colormap similar to rainbow colormap from R .. note:: The red is actually appearing on both sides... Yet this looks like what is coded in R 3.0.1 """ return self.cmap( {"blue": [0, 0, 0, 1, 1, 1, 0], "green": [0, 1, 1, 1, 0, 0, 0], "red": [1, 1, 0, 0, 0, 1, 1]}, reverse=False ) def get_cmap_red_green(self): return self.cmap( { "green": [0, 0.4, 0.6, 0.75, 0.8, 0.9, 1, 0.9, 0.8, 0.6], "blue": [0, 0.4, 0.6, 0.75, 0.8, 0.7, 0.6, 0.35, 0.17, 0.1], "red": [1, 1, 1, 1, 1, 0.9, 0.8, 0.6, 0.3, 0.1], }, reverse=True, ) def test_colormap(self, cmap=None): """plot one colormap for testing By default, test the :meth:`get_cmap_heat` """ if cmap is None: cmap = self.get_cmap_heat() import numpy as np from pylab import clf, pcolor, colorbar, show, linspace, axis A, B = np.meshgrid(linspace(0, 10, 100), linspace(0, 10, 100)) clf() pcolor((A - 5) ** 2 + (B - 5) ** 2, cmap=cmap) colorbar() show() axis("off") def plot_colormap(self, cmap_list=None): """cmap_list list of valid cmap or name of a set (sequential, diverging,) if none, plot all known colors .. .. plot:: .. :width:80% .. :include-source: .. from colormap import Colormap .. c = Colormap() .. c.plot_colormap('sequential') """ from pylab import subplots if isinstance(cmap_list, str): if cmap_list in ["sequentials", "sequentials2", "qualitative", "misc", "diverging", "diverging_black"]: cmap_list = getattr(self, cmap_list) else: cmap_list = [cmap_list] if isinstance(cmap_list, list) is not True: raise TypeError( """input must be a list of srtings or a single string. Each string should be found. For a user-defined cmap, use test_colormap""" ) for this in cmap_list: if this not in self.colormaps and this not in self.diverging_black: raise ValueError("unknown colormap name. Please check valid names in colormaps attribute") nrows = len(cmap_list) gradient = [x / 255.0 for x in range(0, 256)] gradient = [gradient, gradient] # np.vstack((gradient, gradient)) fig, axes = subplots(nrows=nrows) fig.subplots_adjust(top=0.95, bottom=0.05, left=0.05, right=0.8) for ax, name in zip(axes, cmap_list): ax.imshow(gradient, aspect="auto", cmap=self.cmap(name)) pos = list(ax.get_position().bounds) x_text = pos[2] + 0.08 y_text = pos[1] + pos[3] / 2.0 fig.text(x_text, y_text, name, va="center", ha="left", fontsize=10) # Turn off *all* ticks & spines, not just the ones with colormaps. for ax in axes: ax.set_axis_off() colormap-1.0.6/src/colormap/get_cmap.py0000644000175100001770000000375514511244163020706 0ustar runnerdocker00000000000000# -*- python -*- # # This file is part of colormap software # # Copyright (c) 2014L # # File author(s): Thomas Cokelaer # # Distributed under the GPLv3 License. # See accompanying file LICENSE.txt or copy at # http://www.gnu.org/licenses/gpl-3.0.html # # website: # ############################################################################## from colormap import Colormap __all__ = ["cmap_builder"] def cmap_builder(name, name2=None, name3=None): """return a colormap object compatible with matplotlib If only parameter **name** is provided, it should be a known matplotlib colormap name (e.g., jet). If **name2** is provided, then a new colormap is created going from the color **name** to the color **name2** with a linear scale. Finally, if **name3** is provided, a linear scaled colormap is built from color **name** to color **name3** with the intermediate color being the **name2** Matplotlib colormap map names """ c = Colormap() # if the colormap is already a colormap, nothing to do try: name.get_bad() return name except AttributeError: pass # an R colormap if name and name2 and name3: return c.cmap_linear(name, name2, name3) elif name and name2: return c.cmap_bicolor(name, name2) elif name == "heat": return c.get_cmap_heat() elif name == "heat_r": return c.get_cmap_heat_r() # matplotlic colormaps elif name in c.colormaps: return c.cmap(name) # some custom diverging colormaps with black in the middle. elif name in c.diverging_black: return c.cmap(name) elif name.count("_") == 2: name1, name2, name3 = name.split("_") return c.cmap_linear(name1, name2, name3) else: # valid = c.colormaps + c.diverging_black txt = "name provided {0} is not recognised. ".format(name) txt += "\n valid name can be found in colormap.colormap_names" raise ValueError(txt) colormap-1.0.6/src/colormap/xfree86.py0000644000175100001770000001131214511244163020402 0ustar runnerdocker00000000000000# -*- python -*- # -*- coding: utf-8 -*- # # This file is part of the colormap software # # Copyright (c) 2014 # # File author(s): Thomas Cokelaer # # Distributed under the GPLv3 License. # See accompanying file LICENSE.txt or copy at # http://www.gnu.org/licenses/gpl-3.0.html # # Website: https://www.github.com/cokelaer/colormap # Documentation: http://packages.python.org/colormap # ############################################################################## __all__ = ["XFree86_colors"] # TC: I have added the "green" key, which is the same as green(x11) XFree86_colors = { "Alice Blue": "#F0F8FF", "AliceBlue": "#F0F8FF", "Antique White": "#FAEBD7", "Aqua": "#00FFFF", "Aquamarine": "#7FFFD4", "Azure": "#F0FFFF", "Beige": "#F5F5DC", "Bisque": "#FFE4C4", "Black": "#000000", "Blanched Almond": "#FFEBCD", "Blue": "#0000FF", "Blue Violet": "#8A2BE2", "Brown": "#A52A2A", "Burlywood": "#DEB887", "Cadet Blue": "#5F9EA0", "Chartreuse": "#7FFF00", "Chocolate": "#D2691E", "Coral": "#FF7F50", "Cornflower": "#6495ED", "Cornsilk": "#FFF8DC", "Crimson": "#DC143C", "Cyan": "#00FFFF", "Dark Blue": "#00008B", "Dark Cyan": "#008B8B", "Dark Goldenrod": "#B8860B", "Dark Gray": "#A9A9A9", "Dark Green": "#006400", "Dark Khaki": "#BDB76B", "Dark Magenta": "#8B008B", "Dark Olive Green": "#556B2F", "Dark Orange": "#FF8C00", "Dark Orchid": "#9932CC", "Dark Red": "#8B0000", "Dark Salmon": "#E9967A", "Dark Sea Green": "#8FBC8F", "Dark Slate Blue": "#483D8B", "Dark Slate Gray": "#2F4F4F", "Dark Turquoise": "#00CED1", "Dark Violet": "#9400D3", "Deep Pink": "#FF1493", "Deep Sky Blue": "#00BFFF", "Dim Gray": "#696969", "Dodger Blue": "#1E90FF", "Firebrick": "#B22222", "Floral White": "#FFFAF0", "Forest Green": "#228B22", "Fuchsia": "#FF00FF", "Gainsboro": "#DCDCDC", "Ghost White": "#F8F8FF", "Gold": "#FFD700", "Goldenrod": "#DAA520", "Gray (X11)": "#BEBEBE", "Gray (W3C)": "#808080", "Green (X11)": "#00FF00", "Green": "#00FF00", "Green (W3C)": "#008000", "Green Yellow": "#ADFF2F", "Honeydew": "#F0FFF0", "Hot Pink": "#FF69B4", "Indian Red": "#CD5C5C", "Indigo": "#4B0082", "Ivory": "#FFFFF0", "Khaki": "#F0E68C", "Lavender": "#E6E6FA", "Lavender Blush": "#FFF0F5", "Lawn Green": "#7CFC00", "Lemon Chiffon": "#FFFACD", "Light Blue": "#ADD8E6", "Light Coral": "#F08080", "Light Cyan": "#E0FFFF", "Light Goldenrod": "#FAFAD2", "Light Gray": "#D3D3D3", "Light Green": "#90EE90", "Light Pink": "#FFB6C1", "Light Salmon": "#FFA07A", "Light Sea Green": "#20B2AA", "Light Sky Blue": "#87CEFA", "Light Slate Gray": "#778899", "Light Steel Blue": "#B0C4DE", "Light Yellow": "#FFFFE0", "Lime (W3C)": "#00FF00", "Lime Green": "#32CD32", "Linen": "#FAF0E6", "Magenta": "#FF00FF", "Maroon (X11)": "#B03060", "Maroon (W3C)": "#7F0000", "Medium Aquamarine": "#66CDAA", "Medium Blue": "#0000CD", "Medium Orchid": "#BA55D3", "Medium Purple": "#9370DB", "Medium Sea Green": "#3CB371", "Medium Slate Blue": "#7B68EE", "Medium Spring Green": "#00FA9A", "Medium Turquoise": "#48D1CC", "Medium Violet Red": "#C71585", "Midnight Blue": "#191970", "Mint Cream": "#F5FFFA", "Misty Rose": "#FFE4E1", "Moccasin": "#FFE4B5", "Navajo White": "#FFDEAD", "Navy": "#000080", "Old Lace": "#FDF5E6", "Olive": "#808000", "Olive Drab": "#6B8E23", "Orange": "#FFA500", "Orange Red": "#FF4500", "Orchid": "#DA70D6", "Pale Goldenrod": "#EEE8AA", "Pale Green": "#98FB98", "Pale Turquoise": "#AFEEEE", "Pale Violet Red": "#DB7093", "Papaya Whip": "#FFEFD5", "Peach Puff": "#FFDAB9", "Peru": "#CD853F", "Pink": "#FFC0CB", "Plum": "#DDA0DD", "Powder Blue": "#B0E0E6", "Purple (X11)": "#A020F0", "Purple (W3C)": "#7F007F", "Red": "#FF0000", "Rosy Brown": "#BC8F8F", "Royal Blue": "#4169E1", "Saddle Brown": "#8B4513", "Salmon": "#FA8072", "Sandy Brown": "#F4A460", "Sea Green": "#2E8B57", "Seashell": "#FFF5EE", "Sienna": "#A0522D", "Silver (W3C)": "#C0C0C0", "Sky Blue": "#87CEEB", "Slate Blue": "#6A5ACD", "Slate Gray": "#708090", "Snow": "#FFFAFA", "Spring Green": "#00FF7F", "Steel Blue": "#4682B4", "Tan": "#D2B48C", "Teal": "#008080", "Thistle": "#D8BFD8", "Tomato": "#FF6347", "Turquoise": "#40E0D0", "Violet": "#EE82EE", "Wheat": "#F5DEB3", "White": "#FFFFFF", "White Smoke": "#F5F5F5", "Yellow": "#FFFF00", "Yellow Green": "#9ACD32", } colormap-1.0.6/src/colormap.egg-info/0000755000175100001770000000000014511244171020234 5ustar runnerdocker00000000000000colormap-1.0.6/src/colormap.egg-info/PKG-INFO0000644000175100001770000001070214511244171021331 0ustar runnerdocker00000000000000Metadata-Version: 1.2 Name: colormap Version: 1.0.6 Summary: Utilities to ease manipulation of matplotlib colormaps and color codecs (e.g., hex2rgb) Home-page: http://github.com/cokelaer/colormap Author: Thomas Cokelaer Author-email: cokelaer@ebi.ac.uk Maintainer: Thomas Cokelaer Maintainer-email: cokelaer@ebi.ac.uk License: LGPL Download-URL: http://pypi.python.org/pypi/colormap Description: ############################# COLORMAP documentation ############################# Please see : http://colormap.readthedocs.io/ for an up-to-date documentation. .. image:: https://badge.fury.io/py/colormap.svg :target: https://pypi.python.org/pypi/colormap .. image:: https://github.com/cokelaer/colormap/actions/workflows/ci.yml/badge.svg?branch=master :target: https://github.com/cokelaer/colormap/actions/workflows/ci.yml .. image:: https://coveralls.io/repos/cokelaer/colormap/badge.png?branch=master :target: https://coveralls.io/r/cokelaer/colormap?branch=master :version: Python 3.8, 3.9, 3.10, 3.11 :contributions: Please join https://github.com/cokelaer/colormap :issues: Please use https://github.com/cokelaer/colormap/issues :notebook: Please see https://github.com/cokelaer/colormap/tree/master/notebooks What is it ? ################ **colormap** package provides simple utilities to convert colors between RGB, HEX, HLS, HUV and a class to easily build colormaps for matplotlib. All matplotlib colormaps and some R colormaps are available altogether. The plot_colormap method (see below) is handy to quickly pick up a colormaps and the test_colormap is useful to see test a new colormap. Installation ################### :: pip install colormap Example ########## * Create your own colormap from red to green colors with intermediate color as whitish (diverging map from red to green):: c = Colormap() mycmap = c.cmap( {'red':[1,1,0], 'green':[0,1,.39], 'blue':[0,1,0]}) cmap = c.test_colormap(mycmap) * Even simpler if the colormap is linear:: c = Colormap() mycmap = c.cmap_linear('red', 'white', 'green(w3c)') cmap = c.test_colormap(mycmap) .. image:: https://colormap.readthedocs.io/en/latest/_images/quickstart-6.png :width: 50% :align: center * check out the available colormaps:: c = Colormap() c.plot_colormap('diverging') .. image:: https://colormap.readthedocs.io/en/latest/_images/quickstart-4.png :width: 50% :align: center See online documentation for details: http://colormap.readthedocs.io/ changelog ######### ========= ================================================================================ Version Description ========= ================================================================================ 1.0.6 * Fix a matplotlib deprecation * Fix RTD documentation 1.0.5 * remove Python3.6 and added Python3.10 to CI action * Fix issue in setup reported in https://github.com/cokelaer/colormap/pull/14 * add requirements in MANIFEST * applied black on all files ========= ================================================================================ Keywords: hex2web,web2hex,hex2rgb,rgb2hex,rgb2hsv,hsv2rgb,rgb2hls,hls2rgb,colormap,colors Platform: Linux Platform: Unix Platform: MacOsX Platform: Windows Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Topic :: Software Development :: Libraries :: Python Modules colormap-1.0.6/src/colormap.egg-info/SOURCES.txt0000644000175100001770000000060014511244171022114 0ustar runnerdocker00000000000000LICENSE MANIFEST.in README.rst requirements.txt setup.cfg setup.py src/colormap/__init__.py src/colormap/colors.py src/colormap/get_cmap.py src/colormap/xfree86.py src/colormap.egg-info/PKG-INFO src/colormap.egg-info/SOURCES.txt src/colormap.egg-info/dependency_links.txt src/colormap.egg-info/requires.txt src/colormap.egg-info/top_level.txt test/test_colors.py test/test_get_cmap.pycolormap-1.0.6/src/colormap.egg-info/dependency_links.txt0000644000175100001770000000000114511244171024302 0ustar runnerdocker00000000000000 colormap-1.0.6/src/colormap.egg-info/requires.txt0000644000175100001770000000002314511244171022627 0ustar runnerdocker00000000000000matplotlib easydev colormap-1.0.6/src/colormap.egg-info/top_level.txt0000644000175100001770000000001114511244171022756 0ustar runnerdocker00000000000000colormap colormap-1.0.6/test/0000755000175100001770000000000014511244171015116 5ustar runnerdocker00000000000000colormap-1.0.6/test/test_colors.py0000644000175100001770000001361014511244163020032 0ustar runnerdocker00000000000000from colormap import colors from colormap.colors import * from easydev.easytest import assert_list_almost_equal def test_hex2web(): assert hex2web("#FFAA11") == "#FA1" def test_web2hex(): assert web2hex("#FA1") == "#FFAA11" def test_rgb2yuv(): assert_list_almost_equal(rgb2yuv(1,1,1) , (1,0,0)) assert_list_almost_equal(rgb2yuv_int(255,255,255) , (255,0,0)) assert_list_almost_equal(yuv2rgb(1,0,0) , (1,1,1)) assert_list_almost_equal(yuv2rgb_int(255,0,0) , (255,255,255)) def test_rgb2hsv(): assert_list_almost_equal( colors.rgb2hsv(0,1,1) , (0.5,1,1)) assert_list_almost_equal(colors.rgb2hsv(0,255,255, normalised=False) , (0.5,1,1)) assert_list_almost_equal(hsv2rgb(0.5,1,1) , (0,1,1)) assert_list_almost_equal(colors.hsv2rgb(180,100,100, normalised=False), (0,1,1)) def test_rgb2hls(): assert_list_almost_equal(colors.rgb2hls(0,1,1) , (0.5,0.5,1)) assert_list_almost_equal(colors.rgb2hls(0,255,255,normalised=False) , (0.5,0.5,1)) assert_list_almost_equal(colors.hls2rgb(0.5,0.5,1), (0,1,1)) assert_list_almost_equal(colors.hls2rgb(180, 50, 100, normalised=False), (0.,1,1)) def test_hex2dec(): assert colors.hex2dec("FF") == 1 def test_rgb2hex(): colors.rgb2hex(0,0,255) colors.rgb2hex(0,0,1) colors.rgb2hex(*(0,0,1)) try: colors.rgb2hex([0,0]) assert False except: assert True try: colors.rgb2hex(0,0,1000) assert False except: assert True try: colors.rgb2hex(0,0,-1000) assert False except: assert True try: colors.rgb2hex(0,0,10, normalised=True) assert False except: assert True def testColors(): # test constructors c = colors.Color("#FFF") c = colors.Color(rgb=(0,0,0)) c = colors.Color(hls=(0,0,0)) c = colors.Color(hsv=(0,0,0)) c = colors.Color(c) try: colors.Color() assert False except: assert True try: colors.Color(object) assert False except: assert True # test setter/getter c = colors.Color("Blue") assert c.rgb == (0, 0 ,1) assert c.hex == "#0000FF" assert_list_almost_equal( c.hsv, (0.66666666666666,1,1)) assert c.value == 1 assert_list_almost_equal(c.hls, (0.666666666666666, .5,1)) print(c) c.normalised = True c.name c.hsv c.hls print(c) assert c.rgb == (0,0,1) c.rgb = (0,0,1) c.hsv= (0,0,1) c.normalised = False # name can be changed and affects RGB/HEX c.name = "Magenta" assert c.rgb == colors._normalise(255, 0.0, 255) assert c.hex == "#FF00FF" # hex can be changed and affects name/HEX c.hex = "#F8F8FF" assert c.name == "Ghost White" # non official name #assert c.rgb == # RGB can be changed and affects name/HEX c.rgb = colors._normalise(248,248,255) assert c.name == "Ghost White" # official name assert c.hex == "#F8F8FF" assert c.name == "Ghost White" # non official but works assert c.hex == "#F8F8FF" c.saturation_hls = 0.5 assert c.saturation_hls == 0.5 c.lightness = 0.5 assert c.lightness == 0.5 c.hue = 0.5 assert c.hue == 0.5 c.hex = "#FF1F1F" assert c.name == "undefined" try: c.hex = "ZFF1F1F" assert False except: assert True c = colors.Color("red") assert c.red == 1 assert c.green == 0 assert c.blue == 0 c.blue = 0. c.green=0. c.red = 0 assert c.name == "Black" c.value c.value = 0.5 c.yiq def test_normalise(): colors._normalise(255,255,255, mode='rgb') == (1,1,1) colors._normalise(*(255,255,255), mode='rgb') == (1,1,1) colors._normalise(*(360,100,100), mode='hls') == (1,1,1) colors._denormalise(*(1,1,1), mode='rgb') == (255,255,255) colors._denormalise(*(1,1,1), mode='hls') == (360,100,100) def test_to_intensity(): to_intensity(0.5) def test_colormap(): try: from pylab import close, clf, gcf except: return c = Colormap() cmap = c.get_cmap_heat() #c.test_cmap(cmap) f = gcf() #f.close() # design your own colormap d = {'blue': [0,0,0,1,1,1,0], 'green':[0,1,1,1,0,0,0], 'red': [1,1,0,0,0,1,1]} cmap = c.cmap(d, reverse=True) cmap = c.get_cmap_rainbow() cmap = c.get_cmap_red_green() cmap = c.get_cmap_heat_r() t = ['#FF0000FF', '#FF4D00FF', '#FF9900FF', '#FFE500FF', '#CCFF00FF', '#80FF00FF', '#33FF00FF', '#00FF19FF', '#00FF66FF', '#00FFB2FF', '#00FFFFFF', '#00B3FFFF', '#0066FFFF', '#001AFFFF', '#3300FFFF', '#7F00FFFF', '#CC00FFFF','#FF00E6FF','#FF0099FF', '#FF004DFF'] # FIXME: need to find a way to close the plot. close('all') does not work # c.plot_rgb_from_hex_list(t) c.plot_colormap('misc') #c.plot_colormap('jet') c.test_colormap('jet') c.diverging c.colormaps c.sequentials c.sequentials2 c.qualitative t = ['#FF0000FF', '#FF4D00FF', '#FF9900FF','#FFE500FF', '#CCFF00FF', '#80FF00FF','#33FF00FF', '#00FF19FF', '#00FF66FF','#00FFB2FF','#00FFFFFF','#00B3FFFF', '#0066FFFF','#001AFFFF','#3300FFFF','#7F00FFFF', '#CC00FFFF','#FF00E6FF','#FF0099FF','#FF004DFF'] c.plot_rgb_from_hex_list(t) c.test_colormap() # no input plots the heat map def test_HEX(): h = HEX() h.get_standard_hex_color("0xFFF") try: h.get_standard_hex_color(22) assert False except: assert True try: h.get_standard_hex_color("r") assert False except: assert True try: h.get_standard_hex_color("rrrrrrrrrrrr") assert False except: assert True try: h.get_standard_hex_color("#AAAZZZ") assert False except: assert True try: h.get_standard_hex_color("#AAAA") assert False except: assert True colormap-1.0.6/test/test_get_cmap.py0000644000175100001770000000051314511244163020306 0ustar runnerdocker00000000000000from colormap import cmap_builder as get_cmap def test_get_cmap(): get_cmap("heat") get_cmap("heat_r") get_cmap("nipy_spectral") get_cmap("red_black_blue") try: get_cmap('dummy') assert False except: assert True get_cmap('red', 'black', 'yellow') get_cmap('red', 'black')