File: //proc/self/root/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyc
�
�)�Uc @ s� d Z d d l Z d d l Z d d l m Z d d l j Z e j j d � Z e
e e d � \ Z Z
e d k o} e
d k Z i� d d 6d d
6d d 6d
d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d! d" 6d# d$ 6d% d& 6d' d( 6d) d* 6d+ d, 6d- d. 6d d/ 6d0 d1 6d2 d3 6d4 d5 6d6 d7 6d8 d9 6d: d; 6d< d= 6d> d? 6d@ dA 6dB dC 6dD dE 6dF dG 6dH dI 6dJ dK 6dL dM 6dN dO 6dP dQ 6dR dS 6dT dU 6dV dW 6dX dY 6dZ d[ 6d\ d] 6d^ d_ 6d` da 6db dc 6dd de 6df dg 6dh di 6dj dk 6dl dm 6dn do 6dp dq 6dr ds 6dt du 6dv dw 6dx dy 6dz d{ 6d| d} 6d~ d 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d` d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d� 6d� d 6dd6dd6dd6dd6d d
6d d 6d
d6dd6dd6dd6dd6dd6dd6Z xN e j � D]@ \ Z Z e j dk � dk r`e j dk d � Z e e e <q`q`Wd � Z d � Z e j d � Z d � Z d!d7d"� � YZ e � Z d#d$� Z d%d8d&� � YZ d'e f d(� � YZ d)e f d*� � YZ d+d9d,� � YZ d-e f d.� � YZ! d/e f d0� � YZ" d1e f d2� � YZ# e Z$ e# Z% d3� Z& d4� Z' d5e( f d6� � YZ) d S(: s�
A module for converting numbers or color arguments to *RGB* or *RGBA*
*RGB* and *RGBA* are sequences of, respectively, 3 or 4 floats in the
range 0-1.
This module includes functions and classes for color specification
conversions, and for mapping numbers to colors in a 1-D array of
colors called a colormap. Colormapping typically involves two steps:
a data array is first mapped onto the range 0-1 using an instance
of :class:`Normalize` or of a subclass; then this number in the 0-1
range is mapped to a color using an instance of a subclass of
:class:`Colormap`. Two are provided here:
:class:`LinearSegmentedColormap`, which is used to generate all
the built-in colormap instances, but is also useful for making
custom colormaps, and :class:`ListedColormap`, which is used for
generating a custom colormap from a list of color specifications.
The module also provides a single instance, *colorConverter*, of the
:class:`ColorConverter` class providing methods for converting single
color specifications or sequences of them to *RGB* or *RGBA*.
Commands which take color arguments can use several formats to specify
the colors. For the basic builtin colors, you can use a single letter
- b : blue
- g : green
- r : red
- c : cyan
- m : magenta
- y : yellow
- k : black
- w : white
Gray shades can be given as a string encoding a float in the 0-1
range, e.g.::
color = '0.75'
For a greater range of colors, you have two options. You can specify
the color using an html hex string, as in::
color = '#eeefff'
or you can pass an *R* , *G* , *B* tuple, where each of *R* , *G* , *B*
are in the range [0,1].
Finally, legal html names for colors, like 'red', 'burlywood' and
'chartreuse' are supported.
i����N( t mat .i i s #F0F8FFt aliceblues #FAEBD7t antiquewhites #00FFFFt aquas #7FFFD4t
aquamarines #F0FFFFt azures #F5F5DCt beiges #FFE4C4t bisques #000000t blacks #FFEBCDt blanchedalmonds #0000FFt blues #8A2BE2t
blueviolets #A52A2At browns #DEB887t burlywoods #5F9EA0t cadetblues #7FFF00t
chartreuses #D2691Et chocolates #FF7F50t corals #6495EDt cornflowerblues #FFF8DCt cornsilks #DC143Ct crimsont cyans #00008Bt darkblues #008B8Bt darkcyans #B8860Bt
darkgoldenrods #A9A9A9t darkgrays #006400t darkgreens #BDB76Bt darkkhakis #8B008Bt darkmagentas #556B2Ft darkolivegreens #FF8C00t
darkoranges #9932CCt
darkorchids #8B0000t darkreds #E9967At
darksalmons #8FBC8Ft darkseagreens #483D8Bt
darkslateblues #2F4F4Ft
darkslategrays #00CED1t
darkturquoises #9400D3t
darkviolets #FF1493t deeppinks #00BFFFt deepskyblues #696969t dimgrays #1E90FFt
dodgerblues #B22222t firebricks #FFFAF0t floralwhites #228B22t forestgreens #FF00FFt fuchsias #DCDCDCt gainsboros #F8F8FFt
ghostwhites #FFD700t golds #DAA520t goldenrods #808080t grays #008000t greens #ADFF2Ft greenyellows #F0FFF0t honeydews #FF69B4t hotpinks #CD5C5Ct indianreds #4B0082t indigos #FFFFF0t ivorys #F0E68Ct khakis #E6E6FAt lavenders #FFF0F5t
lavenderblushs #7CFC00t lawngreens #FFFACDt lemonchiffons #ADD8E6t lightblues #F08080t
lightcorals #E0FFFFt lightcyans #FAFAD2t lightgoldenrodyellows #90EE90t
lightgreens #D3D3D3t lightgreys #FFB6C1t lightpinks #FFA07At lightsalmons #20B2AAt
lightseagreens #87CEFAt lightskyblues #778899t lightslategrays #B0C4DEt lightsteelblues #FFFFE0t lightyellows #00FF00t limes #32CD32t limegreens #FAF0E6t linent magentas #800000t maroons #66CDAAt mediumaquamarines #0000CDt
mediumblues #BA55D3t mediumorchids #9370DBt mediumpurples #3CB371t mediumseagreens #7B68EEt mediumslateblues #00FA9At mediumspringgreens #48D1CCt mediumturquoises #C71585t mediumvioletreds #191970t midnightblues #F5FFFAt mintcreams #FFE4E1t mistyroses #FFE4B5t moccasins #FFDEADt navajowhites #000080t navys #FDF5E6t oldlaces #808000t olives #6B8E23t olivedrabs #FFA500t oranges #FF4500t orangereds #DA70D6t orchids #EEE8AAt
palegoldenrods #98FB98t palegreens #AFEEEEt
palevioletreds #FFEFD5t
papayawhips #FFDAB9t peachpuffs #CD853Ft perus #FFC0CBt pinks #DDA0DDt plums #B0E0E6t
powderblues #800080t purples #FF0000t reds #BC8F8Ft rosybrowns #4169E1t royalblues #8B4513t saddlebrowns #FA8072t salmons #FAA460t
sandybrowns #2E8B57t seagreens #FFF5EEt seashells #A0522Dt siennas #C0C0C0t silvers #87CEEBt skyblues #6A5ACDt slateblues #708090t slategrays #FFFAFAt snows #00FF7Ft springgreens #4682B4t steelblues #D2B48Ct tans #008080t teals #D8BFD8t thistles #FF6347t tomatos #40E0D0t turquoises #EE82EEt violets #F5DEB3t wheats #FFFFFFt whites #F5F5F5t
whitesmokes #FFFF00t yellows #9ACD32t yellowgreeni t greyc C s. y t j | � t SWn t k
r) t SXd S( s. Return *True* if *c* can be converted to *RGB*N( t colorConvertert to_rgbt Truet
ValueErrort False( t c( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt
is_color_like� s
c C s/ d t g | d D] } t | d � ^ q � S( sB Given an rgb or rgba sequence of 0-1 floats, return the hex strings
#%02x%02x%02xi i� ( t tuplet round( t rgbt val( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt rgb2hex� s s \A#[a-fA-F0-9]{6}\Zc C s� t | t � s t d � � n t j | � d k rF t d | � � n t g | d d !| d d !| d d !f D] } t | d � d ^ qn � S(
s|
Take a hex string *s* and return the corresponding rgb 3-tuple
Example: #efefef -> (0.93725, 0.93725, 0.93725)
s$ hex2color requires a string arguments invalid hex color string "%s"i i i i i g �o@N( t
isinstancet
basestringt TypeErrort hexColorPatternt matcht NoneR� R� t int( t st n( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt hex2color� s
t ColorConverterc B ss e Z d Z i d d 6d d 6d d 6d d 6d d
6d d 6d d 6d d
6Z i Z d � Z d d � Z d d � Z RS( s
Provides methods for converting color specifications to *RGB* or *RGBA*
Caching is used for more efficient conversion upon repeated calls
with the same argument.
Ordinarily only the single instance instantiated in this module,
*colorConverter*, is needed.
g g �?t bg �?t gt rg �?R� i t mt yt kt wc C sD y | j | SWny t k
r" ni t k
r� t | � } y | j | SWq� t k
r] q� t k
r� t d t | � f � � q� Xn Xyzt j | � rF| j � } | j j
| d � } | d k r�t j
| | � } | j
d � r� t | � } qCt | � } | d k s | d k r-t d � � n t | g d � } q�n� t j | � r�t | � d k syt | � d k r�t d t | � � � n t | d � } g | D]* } t | � d k s�| d k r�| ^ q�r�t d � � q�n t d
� � | | j | <Wn8 t t t f k
r?} t d t | � | f � � n X| S(
s�
Returns an *RGB* tuple of three floats from 0-1.
*arg* can be an *RGB* or *RGBA* sequence or a string in any of
several forms:
1) a letter from the set 'rgbcmykw'
2) a hex color string, like '#00FFFF'
3) a standard name, like 'aqua'
4) a float, like '0.4', indicating gray on a 0-1 scale
if *arg* is *RGBA*, the *A* will simply be discarded.
s2 to_rgb: arg "%s" is unhashable even inside a tuplet #i i s" gray (string) must be in range 0-1i i s% sequence length is %d; must be 3 or 4s( number in rbg sequence outside 0-1 ranges' cannot convert argument to rgb sequences to_rgb: Invalid rgb arg "%s"
%sN( t cachet KeyErrorR� R� R� t strt cbookt is_string_liket lowert colorst getR� t cnamest
startswithR� t floatt iterablet len( t selft argt arglt colort str1t flt xt exc( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� sN
$7 c C s� y | j � d k r d SWn t k
r- n Xyvt j | � rft j | � rft | � d k rg | D]* } t | � d k s� | d k ri | ^ qi r� t d � � n | d
k r� t | � S| d k s� | d k r� t d � � n | d | d | d | f S| d
\ } } } g | | | f D]* } t | � d k sH| d k r$| ^ q$r~t d � � q~n | j
| � \ } } } | d
k r�d } n | | | | f SWn5 t t f k
r�} t d t | � | f � � n Xd
S( sU
Returns an *RGBA* tuple of four floats from 0-1.
For acceptable values of *arg*, see :meth:`to_rgb`.
In addition, if *arg* is "none" (case-insensitive),
then (0,0,0,0) will be returned.
If *arg* is an *RGBA* sequence and *alpha* is not *None*,
*alpha* will replace the original *A*.
t noneg i i i s) number in rbga sequence outside 0-1 rangeg �?s alpha must be in range 0-1i i s( number in rbg sequence outside 0-1 ranges! to_rgba: Invalid rgba arg "%s"
%sN( g g g g (
R� t AttributeErrorR� R� R� R� R� R� R� R� R� R� R� ( R� R� t alphaR� R� R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt to_rgba= s0
7
@ c
C s6 y t | � } Wn' t k
r9 t d t | � � � n Xy8 | d k s[ | j � d k rq t j d d t j �SWn t k
r� n Xy) t j | j
| | � g d t j �SWn�t k
r1t | t j � r�| j
d k r| j j d k rt d � � n | j
d k r�| j d d k r�| j j d
k r�| j � d k j � se| j � d k j � rtt d � � n t j | t j � } | d
k r�| d k s�| d k r�t d � � n | | d
d
� d f <n | Sn t j | d f d t j �} x0 t | � D]" \ } } | j
| | � | | <qW| SXd
S( s
Returns a numpy array of *RGBA* tuples.
Accepts a single mpl color spec or a sequence of specs.
Special case to handle "no color": if *c* is "none" (case-insensitive),
then an empty array will be returned. Same for an empty list.
s- Cannot convert argument type %s to rgba arrayi R� i t dtypei t SUs# Color array must be two-dimensionali t fs, number in rgba sequence is outside 0-1 ranges alpha must be in 0-1 rangeNi ( i i ( R� R� R� t typeR� t npt zerosR� R� t arrayR� R� t ndarrayt ndimR� t kindt shapet ravelt anyt asarrayR� t enumerate( R� R� R� t nct resultt it cc( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt
to_rgba_arrayc s<
)
!40 ( g g g �?( g g �?g ( g �?g g ( g g �?g �?( g �?i g �?( g �?g �?i ( g g g ( g �?g �?g �?N( t __name__t
__module__t __doc__R� R� R� R� R� R� ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� � s
; &g �?c C s< t | � rV t j d d | � | } t j t j | | � d t j �d d � } | Sy t j | � } Wn t d � � n X| j } t | � d k r� | d d k r� t d � � n | d d � d f } | d d � d f } | d d � d f } | d d k s| d
d k r*t d � � n t j
t j | � | � rUt d
� � n | | d } t j | f t j � } | d t j d d | � | } t j
| | � d d
!}
| d d
!| |
d | |
| |
d | |
| |
d | |
d | d d
+| d | d <| d
| d
<t j | d d � | S( s� Create an *N* -element 1-d lookup table
*data* represented by a list of x,y0,y1 mapping correspondences.
Each element in this list represents how a value between 0 and 1
(inclusive) represented by x is mapped to a corresponding value
between 0 and 1 (inclusive). The two values of y are to allow
for discontinuous mapping functions (say as might be found in a
sawtooth) where y0 represents the value of y for values of x
<= to that given, and y1 is the value to be used for x > than
that given). The list must start with x=0, end with x=1, and
all values of x must be in increasing order. Values between
the given mapping points are determined by simple linear interpolation.
Alternatively, data can be a function mapping values between 0 - 1
to 0 - 1.
The function returns an array "result" where ``result[x*(N-1)]``
gives the closest value for values of x between 0 and 1.
i i R� s$ data must be convertable to an arrayi i s data must be nx3 formatNg i����g �?s9 data mapping points must start with x=0. and end with x=1s3 data mapping points must have x in increasing order( t callableR� t linspacet clipR� R� R� R� R� R� t sometruet sortR� t searchsorted( t Nt datat gammat xindt lutt adataR� R� t y0t y1t ind( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt makeMappingArray� s< - " !**t Colormapc B sq e Z d Z d d � Z d e d � Z d d d � Z d d d � Z d d d � Z d � Z
d � Z d
� Z RS( s� Base class for all scalar to rgb mappings
Important methods:
* :meth:`set_bad`
* :meth:`set_under`
* :meth:`set_over`
i c C s] | | _ | | _ d | _ d | _ d | _ | | _ | d | _ | d | _ t | _
d S( s�
Public class attributes:
:attr:`N` : number of rgb quantization levels
:attr:`name` : name of colormap
g i i N( g g g g ( t nameR� t _rgba_badR� t _rgba_undert
_rgba_overt _i_undert _i_overt _i_badR� t _isinit( R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt __init__� s
c
C s� | j s | j � n d
} t j | � sF d } t j | g � } n9 d } t j | d t �} | j d � } t j
| � } | j j t j
d k rt j | | d k d � t r� t j | | j d | j d | �n t j | | j d | j � } | j t � } n t j | | | j d
k | j � t j | | d k | j � | d
k r�| j | j k r�t j | | | j � n | r�| j d j t j � } n | j j � } | d
k r't | d � } t | d � } | d d k j � r| | d
d � d f <q'| | d
d
� d f <n t j d | j d d | j � } | j | d d d d d | �| d k r�t | d d
d
� f � } n | S( s
*X* is either a scalar or an array (of any dimension).
If scalar, a tuple of rgba values is returned, otherwise
an array with the new shape = oldshape+(4,). If the X-values
are integers, then they are used as indices into the array.
If they are floating point, then they must be in the
interval (0.0, 1.0).
Alpha must be a scalar between 0 and 1, or None.
If bytes is False, the rgba values will be floats on a
0-1 scale; if True, they will be uint8, 0-255.
t scalarR� t copyi t Floatg �?g�P���?i����t outi i� g NR� i R� t axist modeR� ( i (! R� t _initR� R� R� R� R� R R� t filledt getmaskR� t chart typecodest putmaskt NP_CLIP_OUTR� R� t astypeR� R� R� R� R� t _lutt uint8R� t mint maxt allt emptyt takeR� (
R� t XR� t bytest mask_badt vtypet xat xmaR� t rgba( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt __call__� sD
& # " R� c C s/ t j | | � | _ | j r+ | j � n d S( s0 Set color to be used for masked values.
N( R� R� R� R� t
_set_extremes( R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt set_bad0 s c C s/ t j | | � | _ | j r+ | j � n d S( s` Set color to be used for low out-of-range values.
Requires norm.clip = False
N( R� R� R� R� R ( R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt set_under6 s c C s/ t j | | � | _ | j r+ | j � n d S( sa Set color to be used for high out-of-range values.
Requires norm.clip = False
N( R� R� R� R� R ( R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt set_over= s c C s� | j r | j | j | j <n | j d | j | j <| j rU | j | j | j <n | j | j d | j | j <| j | j | j <d S( Ni i ( R� R R� R� R� R� R� R� ( R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR D s c C s t d � � d S( s$ Generate the lookup table, self._luts Abstract class onlyN( t NotImplementedError( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� O s c C s� | j s | j � n t j | j d d � d f | j d d � d f k � o� t j | j d d � d f | j d d � d f k � S( Ni i i ( R� R� R� t alltrueR ( R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt is_grayS s
;N(
R� R� R� R� R� R� R R R R R R� R ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� � s D t LinearSegmentedColormapc B sD e Z d Z d d d � Z d � Z d � Z e d d d � � Z RS( s� Colormap objects based on lookup tables using linear segments.
The lookup table is generated using linear interpolation for each
primary color, with the 0-1 domain divided into any number of
segments.
i g �?c C s2 t | _ t j | | | � | | _ | | _ d S( s� Create color map from linear mapping segments
segmentdata argument is a dictionary with a red, green and blue
entries. Each entry should be a list of *x*, *y0*, *y1* tuples,
forming rows in a table.
Example: suppose you want red to increase from 0 to 1 over
the bottom half, green to do the same over the middle half,
and blue over the top half. Then you would use::
cdict = {'red': [(0.0, 0.0, 0.0),
(0.5, 1.0, 1.0),
(1.0, 1.0, 1.0)],
'green': [(0.0, 0.0, 0.0),
(0.25, 0.0, 0.0),
(0.75, 1.0, 1.0),
(1.0, 1.0, 1.0)],
'blue': [(0.0, 0.0, 0.0),
(0.5, 0.0, 0.0),
(1.0, 1.0, 1.0)]}
Each row in the table for a given color is a sequence of
*x*, *y0*, *y1* tuples. In each sequence, *x* must increase
monotonically from 0 to 1. For any input value *z* falling
between *x[i]* and *x[i+1]*, the output value of a given color
will be linearly interpolated between *y1[i]* and *y0[i+1]*::
row i: x y0 y1
/
/
row i+1: x y0 y1
Hence y0 in the first row and y1 in the last row are never used.
.. seealso::
:meth:`LinearSegmentedColormap.from_list`
Static method; factory function for generating a
smoothly-varying LinearSegmentedColormap.
:func:`makeMappingArray`
For information about making a mapping array.
N( R� t
monochromeR� R� t _segmentdatat _gamma( R� R� t segmentdataR� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� ` s / c C s� t j | j d d f t j � | _ t | j | j d | j � | j d d � d f <t | j | j d | j � | j d d � d f <t | j | j d | j � | j d d � d f <t | _ | j
� d S(
Ni i Rr i����i R5 i R i ( R� t onesR� R� R R� R R R� R� R ( R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� � s % ) ) ) c C s | | _ | j � d S( sA
Set a new gamma value and regenerate color map.
N( R R� ( R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt set_gamma� s c C s? t j | � s t d � � n t j | d � rp t | d � d k rp t j | d � rp t | � \ } } n t j d d t | � � } t d g d g d g � } x� t | | � D]r \ } } t j
| � \ } } }
| d j | | | f � | d j | | | f � | d j | |
|
f � q� Wt | | | | � S( sT
Make a linear segmented colormap with *name* from a sequence
of *colors* which evenly transitions from colors[0] at val=0
to colors[-1] at val=1. *N* is the number of rgb quantization
levels.
Alternatively, a list of (value, color) tuples can be given
to divide the range unevenly.
s colors must be iterablei i g g �?Rr R5 R (
R� R� R� R� R� t zipR� R� t dictR� R� t appendR ( R� R� R� R� t valst cdictR� R� R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt from_list� s ) ( R� R� R� R� R� R! t staticmethodR' ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR Y s 5 t ListedColormapc B s& e Z d Z d d d � Z d � Z RS( s� Colormap object generated from a list of colors.
This may be most useful when indexing directly into a colormap,
but it can also be used to generate special colormaps for ordinary
mapping.
R' c C s8 | | _ t | _ | d k r0 t | j � } n� t j | j � ra | j g | | _ t | _ n� t j | j � r� t | j � | _ t | j � d k r� t | _ n t | j � | k r� t | j � | | _ n | j | 3n@ y t
| j � } Wn t k
rn X| g | | _ t | _ t j
| | | � d S( su
Make a colormap from a list of colors.
*colors*
a list of matplotlib color specifications,
or an equivalent Nx3 floating point array (*N* rgb values)
*name*
a string to identify the colormap
*N*
the number of entries in the map. The default is *None*,
in which case there is one colormap entry for each
element in the list of colors. If::
N < len(colors)
the list will be truncated at *N*. If::
N > len(colors)
the list will be extended by repetition.
i N( R� R� R R� R� R� R� R� R� t listR� R� R� R� ( R� R� R� R� R4 ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� � s*
c C s� t j g | j D] } t j | � ^ q t j � } t j | j d d f t j � | _ | | j d d � d d � f <d | j d d � d f <t | _
| j � d S( Ni i i����i����i ( R� R� R� R� R� R� R� R� R R� R� R ( R� R� R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� � s +% N( R� R� R� R� R� R� ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR) � s .t Normalizec B sP e Z d Z d d e d � Z d d � Z d � Z d � Z d � Z d � Z
RS( s2
Normalize a given value to the 0-1 range
c C s | | _ | | _ | | _ d S( s�
If *vmin* or *vmax* is not given, they are taken from the input's
minimum and maximum value respectively. If *clip* is *True* and
the given value falls outside the range, the returned value
will be 0 or 1, whichever is closer. Returns 0 if::
vmin==vmax
Works with scalars or arrays, including masked arrays. If
*clip* is *True*, masked values are set to 1; otherwise they
remain masked. Clipping silently defeats the purpose of setting
the over, under, and masked colors in the colormap, so it is
likely to lead to surprises; therefore the default is
*clip* = *False*.
N( t vmint vmaxR� ( R� R, R- R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� s c C sO | d k r | j } n t j | � rK d } t j | � j t j � } n$ d } t j | g � j t j � } | j
| � | j | j } } | | k r� t
d � � n� | | k r� d | } no t | � } t | � } | r t j | � } t j t j | j | � | | � d | �} n | | | | } | d k rK| d } n | S( NR� R� s/ minvalue must be less than or equal to maxvalueg t maski ( R� R� R� R� R R� R R� R� R� t autoscale_NoneR, R- R� R� R� ( R� t valueR� R R� R, R- R� R. ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR s.
$
c C s{ | j � s t d � � n t | j � } t | j � } t j | � rg t j | � } | | | | S| | | | Sd S( Ns Not invertible until scaled( t scaledR� R� R, R- R� R� R R� ( R� R0 R, R- R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt inverse9 s c C s( t j | � | _ t j | � | _ d S( s8
Set *vmin*, *vmax* to min, max of *A*.
N( R R R, R R- ( R� t A( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt autoscaleE s c C sL | j d k r$ t j | � | _ n | j d k rH t j | � | _ n d S( s( autoscale only None-valued vmin or vmaxN( R, R� R R R- R ( R� R3 ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR/ L s c C s | j d k o | j d k S( s return true if vmin and vmax setN( R, R� R- ( R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR1 Q s N( R� R� R� R� R� R� R R2 R4 R/ R1 ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR+ s t LogNormc B s5 e Z d Z d d � Z d � Z d � Z d � Z RS( sA
Normalize a given value to the 0-1 range on a log scale
c C s� | d k r | j } n t j | � rK d } t j | � j t j � } n$ d } t j | g � j t j � } t j
| d d t �} | j | � | j
| j } } | | k r� t d � � n� | d k r� t d � � n� | | k r� d | } n{ | r;t j | � } t j t j | j | � | | � d | �} n t j | � t j | � t j | � t j | � } | d k r�| d } n | S( NR� R� i R� s/ minvalue must be less than or equal to maxvalues values must all be positiveg R. ( R� R� R� R� R R� R R� R� R� t masked_less_equalR� R/ R, R- R� R� R� t log( R� R0 R� R R� R, R- R� R. ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR Y s0
$ 6
c C s} | j � s t d � � n | j | j } } t j | � rd t j | � } | t j | | | � S| t | | | � Sd S( Ns Not invertible until scaled(
R1 R� R, R- R� R� R R� t powert pow( R� R0 R, R- R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR2 x s c C s@ t j | d d t �} t j | � | _ t j | � | _ d S( s8
Set *vmin*, *vmax* to min, max of *A*.
i R� N( R R6 R� R R, R R- ( R� R3 ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR4 � s c C s� | j d k r" | j d k r" d St j | d d t �} | j d k r^ t j | � | _ n | j d k r� t j | � | _ n d S( s( autoscale only None-valued vmin or vmaxNi R� ( R, R� R- R R6 R� R R ( R� R3 ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR/ � s N( R� R� R� R� R R2 R4 R/ ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR5 U s
t BoundaryNormc B s/ e Z d Z e d � Z d d � Z d � Z RS( s�
Generate a colormap index based on discrete intervals.
Unlike :class:`Normalize` or :class:`LogNorm`,
:class:`BoundaryNorm` maps values to integers instead of to the
interval 0-1.
Mapping to the 0-1 interval could have been done via
piece-wise linear interpolation, but using integers seems
simpler, and reduces the number of conversions back and forth
between integer and floating point.
c C s | | _ | d | _ | d | _ t j | � | _ t | j � | _ | | _ | j d | j k rr t | _
n t | _
d S( s�
*boundaries*
a monotonically increasing sequence
*ncolors*
number of colors in the colormap to be used
If::
b[i] <= v < b[i+1]
then v is mapped to color j;
as i varies from 0 to len(boundaries)-2,
j goes from 0 to ncolors-1.
Out-of-range values are mapped to -1 if low and ncolors
if high; these are converted to valid indices by
:meth:`Colormap.__call__` .
i i����i N( R� R, R- R� R� t
boundariesR� R� t NcmapR� t _interpR� ( R� R; t ncolorsR� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� � s
c C sZ | d k r | j } n t j | � } t j | � } | j | j d � } | rn t j | | j | j � n t j | j
d t j �} x- t | j
� D] \ } } | | | | k <q� W| j r� | t | j d � | j d j t j � } n d | | | j k <| j | | | j k <t j | d | �} | j
d k rV| rVt | � } n | S( Ni R� i i����R. ( ( R� R� R R� t getmaskarrayR� R- R� R, R� R� t int16R� R; R= R� R< R� R R� R� ( R� R� R� R. t xxt iretR� R� t ret( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR � s$ 1c C s
t d � S( Ns BoundaryNorm is not invertible( R� ( R� R0 ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR2 � s N( R� R� R� R� R� R� R R2 ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR: � s t NoNormc B s# e Z d Z d d � Z d � Z RS( s�
Dummy replacement for Normalize, for the case where we
want to use indices directly in a
:class:`~matplotlib.cm.ScalarMappable` .
c C s | S( N( ( R� R0 R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR � s c C s | S( N( ( R� R0 ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR2 � s N( R� R� R� R� R R2 ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyRD � s c C s� t j | � } | j d � } | j d � } | | } d | | d k <| d d � d d � d f | k } | | d f | | d f | | | | d f <| d d � d d � d f | k } d | | d f | | d f | | | | d f <| d d � d d � d f | k } d | | d f | | d f | | | | d f <| d d � d d � d f d d | d d � d d � d f <| | d d � d d � d f <| | d d � d d � d f <| S(
sq
convert rgb values in a numpy array to hsv values
input and output arrays should have shape (M,N,3)
i����i Ni i g @g @g @g �?( R� t
empty_likeR t ptp( t arrR� t arr_maxt deltaR� t idx( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt
rgb_to_hsv� s
%0%4%4@ c C s� | d d � d d � d f } | d d � d d � d f } | d d � d d � d f } t j | � } t j | � } t j | � } | d j t j � } | d | } | d | } | d | | }
| d | d | } | d d k } | | | | <| | | | <| | | | <| d k } |
| | | <| | | | <| | | | <| d k } | | | | <| | | | <| | | | <| d k } | | | | <|
| | | <| | | | <| d k } | | | | <| | | | <| | | | <| d
k } | | | | <| | | | <|
| | | <| d k } | | | | <| | | | <| | | | <t j | � }
| |
d d � d d � d f <| |
d d � d d � d f <| |
d d � d d � d f <|
S( so
convert hsv values in a numpy array to rgb values
both input and output arrays have shape (M,N,3)
Ni i i g @g �?i i i i ( R� RE R R� ( t hsvt hR� t vR� R� R� R� R� t pt qt tRJ R� ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt
hsv_to_rgb sX t LightSourcec B s> e Z d Z d d d d d d d � Z d � Z d d � Z RS( s9
Create a light source coming from the specified azimuth and elevation.
Angles are in degrees, with the azimuth measured
clockwise from north and elevation up from the zero plane of the surface.
The :meth:`shade` is used to produce rgb values for a shaded relief image
given a data array.
i; i- i i c C s: | | _ | | _ | | _ | | _ | | _ | | _ d S( s�
Specify the azimuth (measured clockwise from south) and altitude
(measured up from the plane of the surface) of the light source
in degrees.
The color of the resulting image will be darkened
by moving the (s,v) values (in hsv colorspace) toward
(hsv_min_sat, hsv_min_val) in the shaded regions, or
lightened by sliding (s,v) toward
(hsv_max_sat hsv_max_val) in regions that are illuminated.
The default extremes are chose so that completely shaded points
are nearly black (s = 1, v = 0) and completely illuminated points
are nearly white (s = 0, v = 1).
N( t azdegt altdegt hsv_min_valt hsv_max_valt hsv_min_satt hsv_max_sat( R� RT RU RV RW RX RY ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR� & s c C sh | | | j � | j � | j � � } | j | d | �} | | d d � d d � d d � f <| S( sE
Take the input data array, convert to HSV values in the
given colormap, then adjust those color values
to given the impression of a shaded relief map with a
specified light source.
RGBA values are returned, which can then be used to
plot the shaded image with imshow.
t elevationNi i ( R R t shade_rgb( R� R� t cmapt rgb0t rgb1( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt shade= s
*%g �?c C so | j t j d } | j t j d } t j | � \ } } d t j t j t j | | � � } t j | | � } t j | � t j | � t j | � t j | � t j | | d t j � }
|
|
j
� |
j � |
j
� }
d |
d | }
t | d d � d d � d d � f � } t j
t j t j | d d � d d � d f � d k |
d k � d |
| d d � d d � d f |
| j | d d � d d � d f � | d d � d d � d f <t j
|
d k d |
| d d � d d � d
f |
| j | d d � d d � d
f � | d d � d d � d
f <t j
t j t j | d d � d d � d f � d k |
d k � d |
| d d � d d � d f |
| j | d d � d d � d f � | d d � d d � d f <t j
|
d k d |
| d d � d d � d
f |
| j | d d � d d � d
f � | d d � d d � d
f <t j
| d d � d d � d d � f d k d | d d � d d � d d � f � | d d � d d � d d � f <t j
| d d � d d � d d � f d k d | d d � d d � d d � f � | d d � d d � d d � f <t | � S( s�
Take the input RGB array (ny*nx*3) adjust their color values
to given the impression of a shaded relief map with a
specified light source using the elevation (ny*nx).
A new RGB array ((ny*nx*3)) is returned.
g �f@g �?g @g �?Ni i i g�����|�=i g ( RT R� t piRU t gradientt arctant hypott arctan2t sint cosR R RK t wheret logical_andt absRY RW RX RV RR ( R� R� RZ t fractiont azt altt dxt dyt slopet aspectt intensityRL ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyR[ L s* &8$+Cj3FCj3Fxx( R� R� R� R� R_ R[ ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyRS s
( ( ( (* R� t ret numpyR� R t matplotlib.cbookR� t __version__t splitt partst mapR� t NP_MAJORt NP_MINORR R� t itemsR� RN t findt replaceR� R� t compileR� R� R� R� R� R� R R) R+ R5 R: RD t normalizet no_normRK RR t objectRS ( ( ( sD /opt/alt/python27/lib64/python2.7/site-packages/matplotlib/colors.pyt <module>2 sT
� =�l?Q@C