o
W h # @ sl d dl Z d dlZd dlmZ d dlmZmZmZmZm Z d dl
Z
d dl m Z
d dlZd dlZd dlmZmZmZ d dlmZ d dlmZmZmZmZm Z m Z m Z d dl m Z m!Z!m"Z" d dl#m$Z$ G d d
d
Z%e% Z&G d d d Z'e e d
eddfddZ(eddddddfddZ)e ej*d ej+ddej*d ej,dej*dej+ddddddd dd f d e ej-ej.f d e ej-ej.f d e ej-ej.f d!e ej-ej.f d"ee ej-ej.f d#e ej-ej.f d$e ej-ej.f d%eee/ d&e/d'eee0e/f d(ee d)e0d*e0d+e1d,e2d-eej. f d.d/Z3e dEd1d2Z4dFd7d8Z5dGd:d;Z6dHd=d>Z7dHd?d@Z8dAedBfdCdDZ9dS )I N)Path)CallableDictListOptionalUnion)Image ImageDraw ImageFont) __version__)IS_COLAB IS_KAGGLELOGGER TryExceptops plt_settingsthreaded)
check_font
check_versionis_ascii)increment_pathc @ s. e Zd ZdZdd Zd
ddZedd Zd S ) ColorsaG
Ultralytics color palette https://docs.ultralytics.com/reference/utils/plotting/#ultralytics.utils.plotting.Colors.
This class provides methods to work with the Ultralytics color palette, including converting hex color codes to
RGB values.
Attributes:
palette (List[Tuple]): List of RGB color values.
n (int): The number of colors in the palette.
pose_palette (np.ndarray): A specific color palette array for pose estimation with dtype np.uint8.
Examples:
>>> from ultralytics.utils.plotting import Colors
>>> colors = Colors()
>>> colors(5, True) # ff6fdd or (255, 111, 221)
## Ultralytics Color Palette
| Index | Color | HEX | RGB |
|-------|-------------------------------------------------------------------|-----------|-------------------|
| 0 | | `#042aff` | (4, 42, 255) |
| 1 | | `#0bdbeb` | (11, 219, 235) |
| 2 | | `#f3f3f3` | (243, 243, 243) |
| 3 | | `#00dfb7` | (0, 223, 183) |
| 4 | | `#111f68` | (17, 31, 104) |
| 5 | | `#ff6fdd` | (255, 111, 221) |
| 6 | | `#ff444f` | (255, 68, 79) |
| 7 | | `#cced00` | (204, 237, 0) |
| 8 | | `#00f344` | (0, 243, 68) |
| 9 | | `#bd00ff` | (189, 0, 255) |
| 10 | | `#00b4ff` | (0, 180, 255) |
| 11 | | `#dd00ba` | (221, 0, 186) |
| 12 | | `#00ffff` | (0, 255, 255) |
| 13 | | `#26c000` | (38, 192, 0) |
| 14 | | `#01ffb3` | (1, 255, 179) |
| 15 | | `#7d24ff` | (125, 36, 255) |
| 16 | | `#7b0068` | (123, 0, 104) |
| 17 | | `#ff1b6c` | (255, 27, 108) |
| 18 | | `#fc6d2f` | (252, 109, 47) |
| 19 | | `#a2ff0b` | (162, 255, 11) |
## Pose Color Palette
| Index | Color | HEX | RGB |
|-------|-------------------------------------------------------------------|-----------|-------------------|
| 0 | | `#ff8000` | (255, 128, 0) |
| 1 | | `#ff9933` | (255, 153, 51) |
| 2 | | `#ffb266` | (255, 178, 102) |
| 3 | | `#e6e600` | (230, 230, 0) |
| 4 | | `#ff99ff` | (255, 153, 255) |
| 5 | | `#99ccff` | (153, 204, 255) |
| 6 | | `#ff66ff` | (255, 102, 255) |
| 7 | | `#ff33ff` | (255, 51, 255) |
| 8 | | `#66b2ff` | (102, 178, 255) |
| 9 | | `#3399ff` | (51, 153, 255) |
| 10 | | `#ff9999` | (255, 153, 153) |
| 11 | | `#ff6666` | (255, 102, 102) |
| 12 | | `#ff3333` | (255, 51, 51) |
| 13 | | `#99ff99` | (153, 255, 153) |
| 14 | | `#66ff66` | (102, 255, 102) |
| 15 | | `#33ff33` | (51, 255, 51) |
| 16 | | `#00ff00` | (0, 255, 0) |
| 17 | | `#0000ff` | (0, 0, 255) |
| 18 | | `#ff0000` | (255, 0, 0) |
| 19 | | `#ffffff` | (255, 255, 255) |
!!! note "Ultralytics Brand Colors"
For Ultralytics brand colors see [https://www.ultralytics.com/brand](https://www.ultralytics.com/brand). Please use the official Ultralytics colors for all marketing materials.
c s d} fdd|D _ t j _tjg dg dg dg dg dg d g d
g d g d g d
g dg dg dg dg dg dg dg dg dg dgtjd _dS )zEInitialize colors as hex = matplotlib.colors.TABLEAU_COLORS.values().)042AFF0BDBEBF3F3F300DFB7111F68FF6FDDFF444FCCED0000F344BD00FF00B4FFDD00BA00FFFF26C00001FFB37D24FF7B0068FF1B6CFC6D2FA2FF0Bc s g | ]
} d | qS )#)hex2rgb).0cself N/var/www/vscode/kcb/lib/python3.10/site-packages/ultralytics/utils/plotting.py
t s z#Colors.__init__..) r )r5 3 )r5 f ) r; r )r5 r7 r5 )r7 r5 )r5 r: r5 )r5 r8 r5 )r: r9 r5 )r8 r7 r5 )r5 r7 r7 )r5 r: r: )r5 r8 r8 )r7 r5 r7 )r: r5 r: )r8 r5 r8 )r r5 r )r r r5 )r5 r r r5 r5 r5 dtypeN)palettelennnparrayuint8 pose_palette)r1 hexsr2 r0 r3 __init__\ s6 zColors.__init__Fc C s2 | j t|| j }|r|d |d |d fS |S )z&Convert hex color codes to RGB values. r )r@ intrB )r1 ibgrr/ r2 r2 r3 __call__ s zColors.__call__c s t fdddD S )z?Convert hex color codes to RGB values (i.e. default PIL order).c 3 s. | ]}t d | d | d dV qdS )rJ rI NrK r. rL hr2 r3 s , z!Colors.hex2rgb..)r rI tuplerR r2 rR r3 r- s zColors.hex2rgbN)F)__name__
__module__ __qualname____doc__rH rN staticmethodr- r2 r2 r2 r3 r s G
4r c @ s e Zd ZdZd)ddZd*d
d Zd+d
dZd,ddZd-ddZd.ddZ d/d d Z
d d Z d d! Z d0d"d#Z
d1d%d&Zed0d'd(ZdS )2 Annotatora{
Ultralytics Annotator for train/val mosaics and JPGs and predictions annotations.
Attributes:
im (Image.Image or np.ndarray): The image to annotate.
pil (bool): Whether to use PIL or cv2 for drawing annotations.
font (ImageFont.truetype or ImageFont.load_default): Font used for text annotations.
lw (float): Line width for drawing.
skeleton (List[List[int]]): Skeleton structure for keypoints.
limb_color (List[int]): Color palette for limbs.
kpt_color (List[int]): Color palette for keypoints.
dark_colors (set): Set of colors considered dark for text contrast.
light_colors (set): Set of colors considered light for text contrast.
Examples:
>>> from ultralytics.utils.plotting import Annotator
>>> im0 = cv2.imread("test.png")
>>> annotator = Annotator(im0, line_width=10)
N Arial.ttfFabcc
s. t | }t|tj}|p|p| _|p&ttt|r |jn|jd d d _ jr|r/|nt
| _ j j dvrB j
d _ t j d _z$t|rPdn|}|pcttt j jd d d} tt|| _W n ty| t _Y nw ttd r fd
d j_n4|jd d krt |d
dd f }|j j sJ d|j j r|n|! _ t j d d _" j d _#ddgddgddgddgddgddgddgddgddgddgddgddgdd gddgdd gdd gd d gd dgd dgg _$t%j&g d _'t%j&g d _(h d _)h d! _*dS )"zjInitialize the Annotator class with image and line width along with color palette for keypoints and limbs.rI g~jth?> RGBRGBAr` ra zArial.Unicode.ttfgQ ? z9.2.0c s j | dd S )NrI rU )fontgetbbox)xr0 r2 r3 z$Annotator.__init__.. .NzOImage not contiguous. Apply np.ascontiguousarray(im) to Annotator input images.rJ rO
rU )rp rp rp rp rn rn rn r r r r r rO rO rO rO rO rO rO )rO rO rO rO rO r r r r r r rp rp rp rp rp rp > r r< rr r5 D r r5 rJ r o r5 rr rz rz rz r5 r5 r > r & / m O ry r5 h r { l r5 r r r5 r r5 $ } r5 * rU r5 r r rj )+r
isinstancer pilmaxroundsumsizeshapelw fromarrayimmodeconvertr Drawdrawr r
truetypestrrc Exception load_defaultr pil_versiongetsizerC ascontiguousarraydata
contiguousflags writeablecopytfsfskeletoncolorsrF
limb_color kpt_color dark_colors light_colors)
r1 r
line_width font_sizerc r example non_ascii input_is_pilr r2 r0 r3 rH sb
, "
zAnnotator.__init__r6 r6 r6 r= c C s || j v rdS || jv rdS |S )aE
Assign text color based on background color.
Args:
color (tuple, optional): The background color of the rectangle for text (B, G, R).
txt_color (tuple, optional): The color of the text (R, G, B).
Returns:
(tuple): Text color for label.
Examples:
>>> from ultralytics.utils.plotting import Annotator
>>> im0 = cv2.imread("test.png")
>>> annotator = Annotator(im0, line_width=10)
>>> annotator.get_txt_color(color=(104, 31, 17)) # return (255, 255, 255)
r r= )r r )r1 color txt_colorr2 r2 r3
get_txt_color s
zAnnotator.get_txt_color c
C s | ||}t|tjr| }| jst|s|r-|d }| jjdd |D | j |d n|d |d f}| jj
|| j |d |r| j |\}}|d |k} |d | j
jd | krg| j
jd | |d f}| jj
|d | ru|d | n|d |d | d | r|d d n|d | d f|d | jj|d | r|d | n|d f||| j d dS dS |rdd |d D }t| j
tj|td gd
|| j n't|d t|d ft|d t|d f}}
tj
| j
||
|| j tjd
|rptj|d| j| jdd \}}|d 7 }|d |k} |d | j
jd | kr)| j
jd | |d f}|d | | r7|d | n|d | f}
t
| j
||
|dtj tj| j
||d | r[|d d n|d | d fd| j|| jtjd
dS dS )a
Draw a bounding box on an image with a given label.
Args:
box (tuple): The bounding box coordinates (x1, y1, x2, y2).
label (str, optional): The text label to be displayed.
color (tuple, optional): The background color of the rectangle (B, G, R).
txt_color (tuple, optional): The color of the text (R, G, B).
rotated (bool, optional): Whether the task is oriented bounding box detection.
Examples:
>>> from ultralytics.utils.plotting import Annotator
>>> im0 = cv2.imread("test.png")
>>> annotator = Annotator(im0, line_width=10)
>>> annotator.box_label(box=[10, 20, 30, 40], label="person")
r c S g | ]}t |qS r2 rV r. br2 r2 r3 r4 / rg z'Annotator.box_label..widthoutlinerJ fillr rc c S r r2 rP r r2 r2 r3 r4 @ rg r> TrI rh thicknesslineType fontScaler N)r r torchTensortolistr r r polygonr rectanglerc r r r textcv2 polylinesrC asarrayrK LINE_AA getTextSizer r r putText) r1 boxlabelr r rotatedp1wrS outsidep2r2 r2 r3 box_label sX J6 $2 *(
zAnnotator.box_label ?c C sH | j r t| j | _t|dkr&|ddd d | jdd< |j
|j
kr2| |j
}t j
||j
t jdd }|ddddf }|d}||| }d|| d}|jdd j}|jdgd
}|ddd }||d | }|d } | }
|r|
nt|
| jj| jdd< | j r| | j dS dS ) a
Plot masks on image.
Args:
masks (torch.Tensor): Predicted masks on cuda, shape: [n, h, w]
colors (List[List[int]]): Colors for predicted masks, [[r, g, b] * n]
im_gpu (torch.Tensor): Image is in cuda, shape: [3, h, w], range: [0, 1]
alpha (float, optional): Mask transparency: 0.0 fully transparent, 1.0 opaque.
retina_masks (bool, optional): Whether to use high resolution masks or not.
r rJ rI r5 N)devicer? g o@rh dim)dimsr )r rC r r r rA permuter cpunumpyr tor tensorfloat32 unsqueezecumprodr valuesflipbyter scale_imager r ) r1 masksr im_gpualpha retina_masks masks_colorinv_alpha_masksmcsim_mask
im_mask_npr2 r2 r3 r X s* (
"zAnnotator.masks r T ?c C s |dur|n| j }| jrt| j | _|j\}}|dko!|dv } || M }t|D ]N\}
} |p<| r9| j|
nt
|
} | d | d }
}|
|d dkrx||d dkrxt | dkre| d }||k req*t j
| jt|
t|f|| dt jd q*|r?|jd }t| jD ]\}
}t||d d df t||d d df f}t||d d df t||d d df f}|dkr||d d df }||d d df }||k s||k rq|d |d dks|d |d dks|d dk s|d dk rq|d |d dks |d |d dks |d dk s |d dk r!qt j| j|||p0| j|
tt| j d t jd
q| jrK| | j dS dS ) a
Plot keypoints on the image.
Args:
kpts (torch.Tensor): Keypoints, shape [17, 3] (x, y, confidence).
shape (tuple, optional): Image shape (h, w).
radius (int, optional): Keypoint radius.
kpt_line (bool, optional): Draw lines between keypoints.
conf_thres (float, optional): Confidence threshold.
kpt_color (tuple, optional): Keypoint color (B, G, R).
Note:
- `kpt_line=True` currently only supports human pose plotting.
- Modifies self.im in-place.
- If self.pil is True, converts image to numpy array and back to PIL.
Nrj > rI rh r rJ rh rI r )r r )r r rC r r r r enumerater r r rA r circlerK r r liner ceilr )r1 kptsr radiuskpt_line
conf_thresr nkptndimis_poserL kcolor_kx_coordy_coordconfskpos1pos2conf1conf2r2 r2 r3 r | sR
&
00@HzAnnotator.kptsrJ c C s | j |||| dS )z"Add rectangle to image (PIL-only).N)r r )r1 xyr r r r2 r2 r3 r s zAnnotator.rectangletopr2 c
C sT | j r\| j|\}}|dkr|d d| 7 < |dD ];}|rF| j|\}}| jj|d |d |d | d |d | d f|d | jj|||| jd |d |7 < q d S |rtj|d| j | j
dd \}}|d7 }|d |k} |d | | r|d | n|d | f}
t| j ||
|d tj tj
| j ||d| j || j
tj d
d S ) a
Add text to an image using PIL or cv2.
Args:
xy (List[int]): Top-left coordinates for text placement.
text (str): Text to be drawn.
txt_color (tuple, optional): Text color (R, G, B).
anchor (str, optional): Text anchor position ('top' or 'bottom').
box_color (tuple, optional): Box color (R, G, B, A) with optional alpha.
bottomrJ
r r r r rh r r N)r rc r splitr r r r r r r r r r ) r1 r% r r anchor box_colorr rS r r r r2 r2 r3 r s$ 8 (&zAnnotator.textc C s. t |tjr|nt|| _t| j| _dS )z"Update self.im from a numpy array.N)r r r r r r r )r1 r r2 r2 r3 r s zAnnotator.fromarrayc C s t | jS )z Return annotated image as array.)rC r r r0 r2 r2 r3 result s zAnnotator.resultc
C s~ t t| jddddf }tstr7zt| W dS ty6 } zt
d| W Y d}~dS d}~ww |j |d dS )zShow the annotated image..Nr z.Unable to display image in Jupyter notebooks: )title) r r rC r r r r
display ImportErrorr warningshow)r1 r- r er2 r2 r3 r1 s zAnnotator.show image.jpgc C s t |t| j dS )z'Save the annotated image to 'filename'.N)r imwriterC r r )r1 filenamer2 r2 r3 save s zAnnotator.savec C s* | \}}}}|| }|| }|||| fS )ap
Calculate the dimensions and area of a bounding box.
Args:
bbox (tuple): Bounding box coordinates in the format (x_min, y_min, x_max, y_max).
Returns:
width (float): Width of the bounding box.
height (float): Height of the bounding box.
area (float): Area enclosed by the bounding box.
Examples:
>>> from ultralytics.utils.plotting import Annotator
>>> im0 = cv2.imread("test.png")
>>> annotator = Annotator(im0, line_width=10)
>>> annotator.get_bbox_dimension(bbox=[10, 20, 30, 40])
r2 )bboxx_miny_minx_maxy_maxr heightr2 r2 r3 get_bbox_dimension s z Annotator.get_bbox_dimension)NNr^ Fr_ )r r= )r r r= F)r F)r
NTr N)NNrJ )r= r& r2 N)r3 )rX rY rZ r[ rH r r r r r r r r, r1 r6 r\ r= r2 r2 r2 r3 r] s
M
@
$
<
r] r2 r c C s ddl }ddl}tjdtdd tjdtd td|d d t| d
}| dd } |j
| g d d
}|j |dddt ddt ddd t
j|d dd t
t
jdddddd
} | d j|td||d
d d d }
t|D ]} |
d j| d d t| D q{| d d! dt| k rd"k rn n| d tt| | d j t | d#d$d% n| d d& |j |d'd(| d ddd) |j |d*d+| d, ddd) d | ddddf< t!"| d- } t#$tj%d.tj&d/d0 } t'|dd1 | dd1 D ]\}}
t()| j*|
d
t|d2 q
| d
+| | d
,d3 d4D ]}d5D ]
}| | j-| .d6 q1q-|d }t
j|dd t
|rY|| dS dS )7a
Plot training labels including class histograms and box statistics.
Args:
boxes (np.ndarray): Bounding box coordinates in format [x, y, width, height].
cls (np.ndarray): Class indices.
names (dict, optional): Dictionary mapping class indices to class names.
save_dir (Path, optional): Directory to save the plot.
on_plot (Callable, optional): Function to call after plot is saved.
r Nignorez&The figure layout has changed to tight)categorymessage)r@ zPlotting labels to z
labels.jpgz... rJ i@B )re yr r< )columnsTautohist2 binsg?)pmax)corner diag_kindkinddiag_kwsplot_kwszlabels_correlogram.jpg dpirI )ro ro figsize tight_layoutr 皙?)rH rwidthc S s g | ]}|d qS )r5 r2 r. re r2 r2 r3 r4 / rg z plot_labels.. instances Z rq )rotationfontsizeclassesre rB )re rB axrH rI r r< rh )r_ r_ rh r> r5 i r off)r rJ rI rh )r& rightleftr' F)/pandasseabornwarningsfilterwarnings UserWarning
FutureWarningr inforK r DataFramepairplotdictpltsavefigclosesubplotsravelrE rC linspacerangepatches set_colorr
set_ylabelrA
set_xticksset_xticklabelslistr
set_xlabelhistplotr xywh2xyxyr r onesrE zipr r r imshowaxisspines set_visible)boxesclsnamessave_diron_plotrc rd ncre r^ rB rL imgr asfnamer2 r2 r3 plot_labels sN
"& $ " r zim.jpggR Q?rq FTc C s: t | tjs t| } t| dd}|r0|ddddf dd d|ddddf< |ddddf | | |ddddf< t |
} t | |j } |t
| d t
| d t
| d t
| d
dd|rqdndf } |r|jjd d d tt|d
}
t| ddddf j|
ddd | S )aO
Save image crop as {file} with crop size multiple {gain} and {pad} pixels. Save and/or return crop.
This function takes a bounding box and an image, and then saves a cropped portion of the image according
to the bounding box. Optionally, the crop can be squared, and the function allows for gain and padding
adjustments to the bounding box.
Args:
xyxy (torch.Tensor | list): A tensor or list representing the bounding box in xyxy format.
im (np.ndarray): The input image.
file (Path, optional): The path where the cropped image will be saved.
gain (float, optional): A multiplicative factor to increase the size of the bounding box.
pad (int, optional): The number of pixels to add to the width and height of the bounding box.
square (bool, optional): If True, the bounding box will be transformed into a square.
BGR (bool, optional): If True, the image will be saved in BGR format, otherwise in RGB.
save (bool, optional): If True, the cropped image will be saved to disk.
Returns:
(np.ndarray): The cropped image.
Examples:
>>> from ultralytics.utils.plotting import save_one_box
>>> xyxy = [50, 50, 150, 150]
>>> im = cv2.imread("image.jpg")
>>> cropped_im = save_one_box(xyxy, im, file="cropped.jpg", square=True)
r rU NrI rJ r )r rJ )r rh )r r )r rI T)parentsexist_okz.jpg._ )quality subsampling)r r r stackr xyxy2xywhviewr r r| long
clip_boxesr rK parentmkdirr r with_suffixr r r6 ) xyxyr filegainpadsquareBGRr6 r cropfr2 r2 r3 save_one_boxM s
4,D$r r> )r r8 z
images.jpgi rO r images batch_idxr bboxesconfsr r pathsr r r max_size max_subplotsr6 r returnc -
s4 t | tjr| } t |tjr| }t |tjr&| }t |tjr5| t}t |tjrA| }t |tjrM| }| jd dkr^| ddddf } | j\}}}}t || }t
|d t
| d dkr~| d9 } t
j
t | t | dfdt
jd}t|D ]+}t|| t|| }}| | ddd|||| ||| ddf< q| t || }|dk rt || }t || }t|t fd d
||fD }t|| d }t |d }t|t|d
|dt| d}t|D ]n}t|| t|| }}|j|||| || gdddd |rO|j|d |d gt|| jdd dd t |dkr~||k}|| d}|du } t |r"|| } |durw|| nd} t | r| ddddf dkr| dddgf |9 < | dddgf |9 < n|dk r| dddf |9 < | d |7 < | d |7 < | jd dk} | rt | nt | } t | t
j!" D ];\} }!|| }"t#|"}#| r| $|"|"n|"}"| s| | |kr | r |" n |" d | | d }$|j%|!|$|#| d qn&t |rH|D ] }"t#|"}#| r8| $|"|"n|"}"|j||g|" |#d d! q)t |r|| & }%t |%r|%d d"ksj|%d d"kr{|%d |9 < |%d |9 < n |dk r|%|9 }%|%d |7 < |%d |7 < tt |%D ]} | s| | |kr|j'|%| |d# qt |r~|jd |jd kr|| }&n'||g }&|( }'t
)|'*|'ddfd }(t
j+|&|'dd$}&t
,|&|(kd%d&}&t
-|j.& })tt |&D ]}} | s| | |krwt#|| }#|&| j\}*}+|*|ks |+|kr4|&| t
j},t|,||f},|,t/},n|&| t/},z0|)||| ||| ddf |, d' t
0|#d( |)||| ||| ddf |,< W q t1yv Y qw q|2|) q|
st
-|j.S |j.3| |
r|
| dS dS ))a
Plot image grid with labels, bounding boxes, masks, and keypoints.
Args:
images: Batch of images to plot. Shape: (batch_size, channels, height, width).
batch_idx: Batch indices for each detection. Shape: (num_detections,).
cls: Class labels for each detection. Shape: (num_detections,).
bboxes: Bounding boxes for each detection. Shape: (num_detections, 4) or (num_detections, 5) for rotated boxes.
confs: Confidence scores for each detection. Shape: (num_detections,).
masks: Instance segmentation masks. Shape: (num_detections, height, width) or (1, height, width).
kpts: Keypoints for each detection. Shape: (num_detections, 51).
paths: List of file paths for each image in the batch.
fname: Output filename for the plotted image grid.
names: Dictionary mapping class indices to class names.
on_plot: Optional callback function to be called after saving the plot.
max_size: Maximum size of the output image grid.
max_subplots: Maximum number of subplots in the image grid.
save: Whether to save the plotted image grid to a file.
conf_thres: Confidence threshold for displaying detections.
Returns:
(np.ndarray): Plotted image grid as a numpy array if save is False, None otherwise.
Note:
This function supports both tensor and numpy array inputs. It will automatically
convert tensor inputs to numpy arrays for processing.
rJ rh Nr r r5 r> rI c 3 s | ] }t | V qd S r> rP rW nsr2 r3 rT s z plot_images..g{Gz? rq T)r r r r r= )r rs ( ) r r )r r rK rU g?.).r ).rJ r z.1f)r r )@ r r r6 )r r+ g)\(?)r )r g ?g g?g333333?)4r r r r floatr astyperK r minrC r r fullrE rs transposemathr resizerW r] r r r r r namerA r xywhr2xyxyxyxyr| r int64r r getr r r r arangereshaperepeatwherer r boolrD r r r6 )-r r r r r r r r r r r r r r6 r bs_rS r mosaicrL re rB scalefs annotatoridxr] labelsr r is_obbjr r/ r r kpts_ image_masksnlindexr mhmwmaskr2 r r3 plot_imagesy s -
( "2"
"".
$
6*
r path/to/results.csvc C s ddl }ddlm} | rt| jnt|}|r'tjddddd\} }
g d} n3|r9tjdd d
dd\} }
g d } n!|rKtjdd d
dd\} }
g d} ntjddddd\} }
g d} |
}
t| d} t
| ssJ d| d| D ]u}
zV| |
}dd |j
D }|jdddf }t| D ]9\}}|jdd|f d}|
| j||d|
jdd d |
| j|||ddd d dd |
| j|| d d qW qu ty } ztd!|
d"| W Y d}~qud}~ww |
d# |d$ }| j|d%d& t |r || dS dS )'a
Plot training results from a results CSV file. The function supports various types of data including segmentation,
pose estimation, and classification. Plots are saved as 'results.png' in the directory where the CSV is located.
Args:
file (str, optional): Path to the CSV file containing the training results.
dir (str, optional): Directory where the CSV file is located if 'file' is not provided.
segment (bool, optional): Flag to indicate if the data is for segmentation.
pose (bool, optional): Flag to indicate if the data is for pose estimation.
classify (bool, optional): Flag to indicate if the data is for classification.
on_plot (callable, optional): Callback function to be executed after plotting. Takes filename as an argument.
Examples:
>>> from ultralytics.utils.plotting import plot_results
>>> plot_results("path/to/results.csv", segment=True)
r Ngaussian_filter1drI )rm rm TrR )rI rs rh rU ro )r rm )rI rh rU rs rm rn rq rr ri rk rO rj ro rp rb rl rp ) rm )rI rh rU rs rm rn ro rr rb rk rO rj r rp rq rl ri rs )rb rm )
rI rh rU rs rm rp rq rr rn ro z results*.csvz No results.csv files found in z, nothing to plot.c S g | ]}| qS r2 striprW r2 r2 r3 r4 L rg z plot_results..r .)markerr linewidth
markersizerh sigma:smoothr r rb )r\ zPlotting error for z: rJ z results.pngrO rP )rc
scipy.ndimager r r rm rp rq ry globrA resolveread_csvrC r r r plotstem set_titler r errorlegendrn ro )r dirsegmentposeclassifyr pdr r figr^ r filesr r r re rL r rB r2 r r2 r2 r3 plot_results$ sN
" r viridisrU nonec sR t j |d\ fddttD }tj ||||d dS )a.
Plot a scatter plot with points colored based on a 2D histogram.
Args:
v (array-like): Values for the x-axis.
f (array-like): Values for the y-axis.
bins (int, optional): Number of bins for the histogram.
cmap (str, optional): Colormap for the scatter plot.
alpha (float, optional): Alpha for the scatter plot.
edgecolors (str, optional): Edge colors for the scatter plot.
Examples:
>>> v = np.random.rand(100)
>>> f = np.random.rand(100)
>>> plt_color_scatter(v, f)
rG c
s` g | ],}t tj| d dd jd d t tj | d dd jd d f qS )T)ra rJ r )r rC digitizer rQ r rE vxedgesyedgesr2 r3 r4 s s &&z%plt_color_scatter..)r/ cmapr
edgecolorsN)rC histogram2drs rA rm scatter)r r rH r r r r r2 r r3 plt_color_scatter` s
r tune_results.csvc C s ddl }ddlm} dd }t| } || }d}dd |jD |d }|j}|dddf }t|} t
t |d }
t j
d
d d t|D ]P\} } |dd| | f }
|
| }t |
|
| d t|
|d
ddd t j|| ddd t j| d|dddid t jddd | |
dkrt g qI|| d tdt |d }t j
d d d t j||d dd d t j|||d!d"d#d$d%d& t d' t d( t d) t d t || d* dS )+a
Plot the evolution results stored in a 'tune_results.csv' file. The function generates a scatter plot for each key
in the CSV, color-coded based on fitness scores. The best-performing configurations are highlighted on the plots.
Args:
csv_file (str, optional): Path to the CSV file containing the tuning results.
Examples:
>>> plot_tune_results("path/to/tune_results.csv")
r Nr c S s* t j| dd t td| dS )z#Save one matplotlib plot to 'file'.rO rP zSaved N)rm rn ro r ri )r r2 r2 r3 _save_one_file s z)plot_tune_results.._save_one_filerJ c S r r2 r rW r2 r2 r3 r4 rg z%plot_tune_results..r )rq rq TrR r rU r )r r r zk+rk )r z = z.3gr rp )fontdictbothro )r labelsizeztune_scatter_plots.png)rq rm ofitness)r linestyler rh r r smoothedrI r zFitness vs Iteration IterationFitnessztune_fitness.png) rc r r r r rC r rC argmaxr r rA rm figurer subplotr r r r- tick_paramsyticks with_namers xlabelylabelgridr )csv_filer r r r num_metrics_columnskeysre r
r rB rL r r mur2 r2 r3 plot_tune_results sD
r , c
C s g }t | D ]2\}}|d|ddf dd\}}}t|jd df|}|t||t ||fd qt|d
}|dddf |dddf |ddddf |dddf fS )ZConvert model output to target format [batch_id, class_id, x, y, w, h, conf] for plotting.Nrm )rU rJ rJ rJ r rI r ) r r r) r r r appendcatr r r ) outputmax_dettargetsrL r r r r r r2 r2 r3 output_to_target s &"@r$ c
C s g }t | D ]-\}}|d| dd\}}}}t|jd df|} |t| ||||fd qt|d }|dddf |dddf |ddddf |dddf fS )r N)rU rJ rJ rJ rJ r rI r ) r r r) r r r r r r )
r! r" r# rL r r r r angler r2 r2 r3 output_to_rotated_target s @r& zruns/detect/expc C sR dD ] }||v r dS qt | tjr| j\}}}} |dkr| dkr|d| d|dd d }
tj| d |d d
} t||}tj t
|d d d d
\}} | } tj
ddd t|D ]}
| |
| |
| |
d q`td|
d| d| d tj|
ddd t tt|
d| d dS dS dS dS )ag
Visualize feature maps of a given model module during inference.
Args:
x (torch.Tensor): Features to be visualized.
module_type (str): Module type.
stage (int): Module stage within the model.
n (int, optional): Maximum number of feature maps to plot.
save_dir (Path, optional): Directory to save results.
> OBBPoseDetectSegmentClassify
RTDETRDecoderNrJ stager r r z
_features.pngr r ro T)rT g?)wspacehspacer` zSaving z... (/)r tight)rQ bbox_inchesz.npy)r r r r r) chunkr r rm rp r r rq subplots_adjustrs r squeezer r ri rn ro rC r6 r r r )re module_typer. rB r mr channelsr< r r blocksr^ rL r2 r2 r3 feature_visualization s,
&r< )r r FFFN)r r rU r )r )r ):r re pathlibr typingr r r r r r matplotlib.pyplotpyplotrm r rC r PILr r r
r r ultralytics.utilsr r
r r r r r ultralytics.utils.checksr r r ultralytics.utils.filesr r r r] r r zerosr rE r ndarrayr rK r r r r r r r$ r& r< r2 r2 r2 r3 s $ p?,
+
;
7