# Redimensionner, rogner et appliquer des effets

Redimensionne, rogne, pivote et retourne tout le sprite, applique des effets et des ajustements de couleur, et reviens en arrière dans l'historique des annulations.

_Les raccourcis sont écrits pour Windows et Linux. Sur Mac, utilise ⌘ Cmd là où il est écrit Ctrl, et ⌥ Option pour Alt._

Le menu **Sprite** modifie le sprite dans son ensemble : sa taille, son canevas, son orientation. Les
effets et ajustements du menu **Filtre** recolorent et filtrent les pixels d'un cel ou de plusieurs.
Chacun d'eux compte pour une seule étape d'annulation.

## Taille du sprite et taille du canevas

- Sprite > Taille du sprite... (`Ctrl+Alt+I`) **met à l'échelle** le sprite vers une nouvelle
  **Largeur** et une nouvelle **Hauteur** (de 1 à 4096 pixels). Chaque cel est redimensionné par
  interpolation au plus proche voisin : les pixels restent nets et aucune nouvelle couleur n'apparaît ;
  les slices, les tilesets et la sélection sont mis à l'échelle avec lui. La largeur et la hauteur sont
  indépendantes : calcule toi-même l'autre côté pour garder les proportions.
- Sprite > Taille du canevas... (`Alt+C`) change la taille du **canevas** sans mettre le
  dessin à l'échelle. Choisis un **Ancrage** dans la grille 3×3 : l'endroit où le dessin existant se
  place dans le nouveau canevas (le centre le garde centré, le coin supérieur gauche agrandit ou
  réduit le canevas vers la droite et vers le bas). Avec l'ancrage central, une différence impaire place
  la colonne supplémentaire à droite et la ligne supplémentaire en haut, de sorte qu'en revenant à la
  taille précédente tout est annulé exactement. Un dessin qui se retrouve hors d'un canevas plus petit
  n'est pas perdu : il est conservé au-delà du bord, hors de vue, et revient si le canevas
  s'agrandit à nouveau (comme dans Aseprite). Le calque Arrière-plan est coupé au canevas, et complété
  avec la couleur d'arrière-plan quand il s'agrandit.

## Rogner

- Sprite > Rogner à la sélection fait du canevas la boîte englobante de la sélection. Il faut une sélection
  ([Sélectionner et transformer](https://pxstud.io/fr/docs/manual/guides/selection.md)). Une sélection qui dépasse du canevas l'agrandit de ce
  côté.
- Sprite > Rogner réduit le canevas au plus petit rectangle qui contient ce qui est dessiné, dans
  toutes les images. Il regarde le sprite tel qu'il est affiché : les calques masqués ne comptent pas,
  et une bordure d'une couleur unie (comme un Arrière-plan opaque) est rognée comme de la
  transparence. Quand deux bords opposés sont unis dans des couleurs différentes, ou que rien n'est
  dessiné, le sprite reste tel quel.

Comme la taille du canevas, le recadrage et le rognage conservent le dessin situé hors du nouveau
canevas au lieu de le supprimer.

## Pivoter et retourner le canevas

Sprite > Pivoter de 90° vers la droite et Sprite > Pivoter de 90° vers la gauche font tourner tout le sprite d'un quart de tour
(largeur et hauteur sont échangées), et Sprite > Retourner le canevas horizontalement et Sprite > Retourner le canevas verticalement le
retournent en miroir. Ces commandes agissent sur tous les calques et toutes les images, calques
verrouillés compris, et emportent les slices et la sélection avec elles. Le dessin situé au-delà du
bord du canevas tourne et se retourne avec le reste, donc revenir en arrière le restaure.

Pour pivoter ou retourner seulement la sélection ou un cel, utilise plutôt **Édition > Transformer**
ou les retournements du menu Calque ([Sélectionner et transformer](https://pxstud.io/fr/docs/manual/guides/selection.md#moving-and-transforming)).

## Propriétés du sprite et proportions du pixel

Fichier > Renommer le sprite... affiche le nom du sprite, sa taille et son nombre de calques et d'images, et
propose :

- **Mode colorimétrique** : RGB, Niveaux de gris ou Indexé ([Couleur et palettes](https://pxstud.io/fr/docs/manual/guides/color.md#color-modes)) ;
- **Couleur transparente**, l'index de la palette qui représente la transparence (sprites indexés) ;
- **Proportions du pixel** : 1:1, 2:1, 1:2 ou **Personnalisé** (chaque côté de 1 à 255) ;
- **données utilisateur** : une couleur, une note et des propriétés personnalisées pour le sprite ([plus bas](https://pxstud.io/fr/docs/manual/guides/document.md#user-data-and-custom-properties)).

Rien ne change tant que tu ne choisis pas **Enregistrer**, qui applique tout d'un coup ; une seule
annulation reprend ensemble le mode colorimétrique, la couleur transparente, les proportions du pixel
et les données utilisateur. **Annuler** laisse le sprite tel qu'il était.

Les **proportions du pixel** rendent les pixels non carrés, comme l'affichaient certaines vieilles
consoles et certains vieux ordinateurs : à 2:1, chaque pixel est deux fois plus large que haut. Le
canevas montre le sprite étiré ; les pixels eux-mêmes ne changent pas. Les exports restent à un pixel
de fichier par pixel de sprite, sauf si tu actives **Appliquer les proportions du pixel** dans la
boîte de dialogue d'export ([Ouvrir, importer et exporter](https://pxstud.io/fr/docs/manual/guides/import-export.md#export)). Tu peux aussi
définir les proportions du pixel quand tu crées un sprite.

## Données utilisateur et propriétés personnalisées

Tout ce qui peut être annoté a une section **Données utilisateur** dans sa boîte de dialogue de
propriétés : le sprite, un calque ou un groupe, un cel, une étiquette, un slice et un tileset
(**Propriétés du tileset**). Elle contient une **couleur** (pas pour les étiquettes, qui ont la
leur), une **note** et des **propriétés personnalisées** : des valeurs nommées qu'un jeu ou un outil
lit dans les données exportées. Les slices exportent les leurs dans le JSON de la feuille de sprites,
et les fichiers `.aseprite` les conservent toutes, donc elles reviennent à la réouverture du fichier.

Les propriétés sont regroupées par **espace de noms**. **Les tiennes** forment la liste simple ;
**Ajouter un espace de noms d'extension** crée une liste qui appartient à une extension nommée,
comme le font les extensions d'Aseprite. Dans chaque liste :

- **Ajouter une propriété** ajoute une ligne avec un nom, un type et une valeur ; **Ajouter un
  élément** fait de même à l'intérieur d'un vecteur. Les flèches déplacent une ligne vers le haut ou
  vers le bas et la corbeille la retire.
- Choisis le **type** d'une valeur : Booléen, Null, Chaîne, UUID, un nombre entier d'une taille donnée
  (Int8 à UInt64), Fixe, Flottant ou Double, Point (X, Y), Taille (L, H), Rectangle (X, Y, L, H), ou
  un **Vecteur** (une liste) ou un **Dictionnaire** (des propriétés nommées) qui contient d'autres
  lignes. Changer le type d'une ligne conserve sa valeur quand le nouveau type le permet.
- Une valeur qui ne convient pas à son type (un UInt8 de 300, un UUID de forme incorrecte, un nom
  répété) est signalée sur sa ligne, et **Enregistrer** attend qu'elle soit corrigée. Les nombres
  entiers sont vérifiés par rapport à la plage de leur type.

**Modifier en JSON** affiche les mêmes propriétés sous forme de texte, pour les copier-coller. Tout ce
qui n'est ni du texte, ni vrai/faux, ni un nombre simple s'écrit `{ "$type": "uint8", "value": 7 }` ;
les scripts utilisent la même forme avec `app.setUserData`. Pour revenir aux lignes, le JSON doit
être valide.

## Dupliquer un sprite

Sprite > Dupliquer le sprite copie le sprite, avec tous ses calques, images et slices, dans un nouveau
sprite nommé « _nom_ copy » dans le même projet.

## Effets et ajustements

Le menu Filtre propose les mêmes filtres que le menu Édition d'Aseprite (Luminosité/Contraste,
Teinte/Saturation et Courbe de couleur calculent leurs couleurs à leur façon ; voir chacun plus bas) :

- **Tons et couleurs :** Filtre > Luminosité/Contraste..., Filtre > Teinte/Saturation...,
  Filtre > Courbe de couleur..., Filtre > Niveaux..., Filtre > Seuil..., Filtre > Carte de dégradé... et
  Filtre > Balance des couleurs... ;
- **Remplacer et réduire les couleurs :** Filtre > Inverser les couleurs... (`Ctrl+I`),
  Filtre > Remplacer la couleur..., Filtre > Postériser... et Filtre > Réduire les couleurs... ;
- **Formes :** Filtre > Contour..., Filtre > Ombre portée..., Filtre > Anticrénelage... et
  Filtre > Ombrage automatique... ;
- **Filtres de voisinage :** Filtre > Antipoussière... et Filtre > Matrice de convolution....

Chacun ouvre une boîte de dialogue. Tant qu'elle est ouverte, le canevas montre un **aperçu en
direct** du cel actif ; désactive **Aperçu** pour comparer. **OK** applique l'effet en une seule étape
d'annulation, **Annuler** laisse le sprite tranquille.

**Ce qu'ils modifient.** Avec une sélection, un effet ne modifie que les pixels qu'elle contient ;
sans sélection, il modifie tout le cel. La boîte de dialogue l'indique. **Appliquer à** choisit les
cels :

| Appliquer à | Cels |
| - | - |
| **Cel actif** | Le cel sur lequel tu te trouves (par défaut, quand son calque peut être modifié). |
| **Cels sélectionnés dans la chronologie** | Les cels sélectionnés dans la chronologie. |
| **Toutes les images de ce calque** | Le cel du calque actif dans chaque image. |
| **Tous les calques de cette image** | Le cel de chaque calque dans l'image courante. |
| **Tout** | Chaque cel du sprite. |

Les effets agissent sur les calques d'image. Luminosité/Contraste, Teinte/Saturation, Courbe de
couleur, Inverser les couleurs, Remplacer la couleur et Postériser fonctionnent aussi sur les calques
de tilemap : ils modifient les tuiles que place le cel, donc chaque emplacement de ces tuiles change.
Les trois derniers choix ignorent les calques verrouillés ou masqués, ainsi que ceux que l'effet ne
peut pas traiter, et t'indiquent combien de cels ils ont laissés de côté. Les éléments de menu ne sont
grisés que si aucun calque ne peut recevoir l'effet. Quand le calque actif ne peut pas recevoir
l'effet (il est verrouillé, masqué, c'est un groupe, ou un tilemap pour les autres effets), la boîte de
dialogue démarre sur **Tout**.

Sur le calque Arrière-plan, les effets ne modifient jamais l'alpha, car il n'a pas de transparence :
les options d'alpha y sont ignorées, et Remplacer la couleur ne change que la couleur.

### Sprites indexés

Dans un sprite indexé, les ajustements de couleur (tout sauf Antipoussière, Matrice de convolution,
Réduire les couleurs, Ombre portée, Anticrénelage et Ombrage automatique, qui remappent toujours) proposent un choix **Indexé** :

- **Remplacer par le plus proche** (par défaut) modifie les pixels, puis ramène chacun à la couleur de
  palette la plus proche. La palette reste telle quelle.
- **Modifier la palette** modifie les entrées de palette qu'utilisent les cels choisis, au lieu des
  pixels. Tous les pixels qui utilisent ces entrées changent, dans n'importe quel cel, et la
  sélection est ignorée. Dans un sprite dont la palette change au fil du temps, la palette propre à
  chaque image est modifiée.

## Les effets

### Contour

Dessine un contour autour des formes, en les bordant contre les pixels transparents.

![La boîte de dialogue Contour : une couleur, Emplacement réglé sur À l'extérieur, Appliquer à réglé sur Cel actif, une matrice 3 par 3 avec les quatre voisins latéraux activés, les préréglages Cercle et Carré, et les cases Traiter aussi une couleur comme arrière-plan et Aperçu](https://pxstud.io/manual/images/guides/document-outline.light.webp)

_La boîte de dialogue Contour_

- **Couleur :** la couleur du contour ; elle démarre avec la couleur de premier plan. Dans un sprite
  indexé, choisis une entrée de la palette.
- **Emplacement :** **À l'extérieur** peint les pixels transparents qui touchent la forme, donc la
  forme grandit ; **À l'intérieur** repeint les pixels du bord de la forme elle-même, donc elle garde
  sa taille. Le bord du canevas ne compte pas comme transparent : une forme qui sort du canevas n'est
  pas contournée de ce côté.
- **Matrice :** lesquels des huit voisins comptent comme touchant. **Cercle** utilise les quatre
  voisins du dessus, du dessous et des côtés (pas les coins) ; **Carré** les utilise tous les huit.
  Clique sur une case pour la basculer.
- **Traiter aussi une couleur comme arrière-plan :** une **Couleur d'arrière-plan** qui compte comme
  vide, à l'image de la transparence, pour contourner un dessin fait sur une couleur unie.

### Postériser

**Niveaux** (2 à 32, 4 par défaut) : le nombre de paliers que garde chaque canal de couleur. Moins de
niveaux donnent une couleur plus plate et plus marquée.

### Antipoussière

Supprime les pixels isolés avec un filtre médian : chaque pixel prend la valeur médiane des pixels
qui l'entourent. **Fenêtre** définit la zone, de 1 × 1 à 9 × 9 (3 × 3 par défaut) ; les grandes
fenêtres lissent davantage.

### Matrice de convolution

Applique un filtre à noyau sur les pixels.

- **Préréglage :** Identité, Flou gaussien 3x3 (par défaut, identique au Blur 3x3 d'Aseprite), Flou par
  moyenne 3x3, Flou gaussien 5x5, Flou par moyenne 5x5, Netteté, Détection des contours, Relief, Sobel
  horizontal et Sobel vertical. Un flou gaussien donne le plus de poids aux pixels du milieu, il est
  donc plus doux qu'un flou par moyenne, qui pèse tous les pixels de la même façon. Modifier un poids
  le passe en **Personnalisé**.
- **Taille :** de 1 × 1 à 9 × 9, et la grille de poids à modifier.
- **Diviseur :** ce par quoi la somme pondérée est divisée ; **Auto (somme du noyau)** le calcule.
- **Biais :** ajouté à chaque résultat (-255 à 255).
- **Rouge**, **Vert**, **Bleu**, **Alpha :** les canaux qu'il modifie (l'alpha est désactivé par
  défaut).
- **Bords :** à la bordure du cel, **Étendus** répète les pixels du bord, **En mosaïque** boucle vers
  l'autre côté.

### Réduire les couleurs

Ramène le dessin à quelques couleurs, éventuellement tramées, sans changer le mode colorimétrique :
un moyen rapide de donner une palette limitée à un dessin peint ou importé, ou de voir ce que
donnerait une couleur indexée. La transparence est conservée.

- **Couleurs :** **Générer à partir des cels** choisit les meilleures **Couleurs** (2 à 256) parmi
  tous les cels couverts par **Appliquer à**, affichées sous forme de nuanciers ; **La palette du
  sprite** utilise la palette à la place (sans son entrée transparente).
- **Tramage** et **Quantité :** les mêmes choix que pour la conversion en indexé
  ([Modes colorimétriques](https://pxstud.io/fr/docs/manual/guides/color.md#color-modes)). Choisis un motif ordonné pour une animation.

### Luminosité/Contraste

**Luminosité** et **Contraste**, chacun de -100 à 100. La luminosité ajoute la même quantité à chaque
canal (à 100, 255 niveaux : le noir devient blanc), puis le contraste écarte les canaux du gris moyen
ou les en rapproche (à -100 tout est gris moyen, à 100 presque chaque canal vaut 0 ou 255). La version
d'Aseprite diffère : elle met la luminosité à l'échelle, donc le noir reste noir.

### Teinte/Saturation

- **Mode :** **HSV**, **HSL** ou **OKLCH**. En HSV, le troisième curseur est **Valeur**, qui rapproche
  le canal le plus lumineux du maximum ou de zéro ; en HSL et en OKLCH, c'est **Clarté**, qui rapproche
  du blanc ou du noir.
- **OKLCH** est perceptuel : tourner la teinte conserve la clarté perçue de chaque couleur, donc les
  jaunes ne deviennent pas plus lumineux et les bleus plus sombres comme ils le font en HSV ou en HSL,
  et **Saturation** met la chroma à l'échelle. Une couleur poussée au-delà de ce que l'écran peut
  afficher perd de la saturation plutôt que de décaler sa teinte ou sa clarté. Utilise-le pour
  recolorer tout un sprite en gardant ses ombrages lisibles.
- **Teinte** (-180 à 180), **Saturation**, **Valeur** ou **Clarté**, et **Alpha** (chacun de -100 à
  100\). Des valeurs positives de Clarté, de Valeur et d'Alpha parcourent cette part du chemin restant
  jusqu'au maximum : +50 fait passer le noir au gris moyen et les pixels à moitié transparents aux
  trois quarts opaques. Les valeurs négatives réduisent, donc -100 atteint le noir ou la transparence.
  Aseprite multiplie à la place, donc le noir y reste noir.

### Niveaux

Définit où se situent le noir, le blanc et les tons moyens, par canal : **Noir en entrée** et **Blanc
en entrée** (0 à 255) sont les valeurs qui deviennent les plus sombres et les plus claires ; **Tons
moyens** (gamma, 0,10 à 5) éclaircit (au-dessus de 1) ou assombrit (en dessous de 1) ce qui se trouve
entre les deux ; **Noir en sortie** et **Blanc en sortie** limitent la plage que le résultat peut
utiliser, et un blanc en sortie inférieur au noir inverse le canal. Choisis **RGB** pour modifier les
trois canaux ensemble, ou **Rouge**, **Vert** ou **Bleu** pour en modifier un seul ensuite (pas sur les
sprites en niveaux de gris, qui n'ont qu'un canal de gris).

### Seuil

Transforme chaque pixel en l'une de deux couleurs selon sa luminosité : **Niveau** (0 à 255) est la
luminosité dont un pixel a besoin pour prendre la couleur **Égal ou au-dessus** plutôt que la couleur
**En dessous** (noir et blanc par défaut). La luminosité est la même luma que celle qu'utilise Aseprite
pour les niveaux de gris. Les pixels gardent leur propre alpha.

### Carte de dégradé

Recolore le dessin selon la luminosité à travers un dégradé : les pixels les plus sombres prennent la
couleur du premier point, les plus clairs celle du dernier, et les autres ce qui se trouve entre les
deux. Ajoute des points, définis leur **Position** et leur couleur, et choisis l'espace dans lequel ils
sont **Mélangés en** : **RGB**, **OKLab** (des paliers d'aspect régulier, par défaut) ou **OKLCH**.
**Inverser** parcourt le dégradé du clair au sombre. Les pixels gardent leur propre alpha.

### Balance des couleurs

Décale la couleur d'une plage tonale : choisis **Ombres**, **Tons moyens** ou **Hautes lumières** et
déplace les curseurs **Cyan - Rouge**, **Magenta - Vert** et **Jaune - Bleu** (-100 à 100). Chaque
pixel est décalé selon son degré de clarté, de sorte que les ombres se fondent dans les tons moyens et
les tons moyens dans les hautes lumières. **Préserver la luminosité** (activé par défaut) rétablit la
clarté que le décalage a modifiée, pour que seule la couleur bouge. Sur les sprites en niveaux de gris,
il y a un seul curseur **Clarté**.

### Ombre portée

Écrit une ombre dans les cels. **Style** peut être **Ombre portée** (décalage **Horizontal** et
**Vertical**, jusqu'à 10 pixels dans chaque sens), **Halo** (sans décalage) ou **Ombre interne** (sur le
dessin, le long du bord opposé au décalage). **Étendue** l'agrandit jusqu'à 10 pixels, en une forme
**Ronde**, **Carrée** ou en **Losange**, et l'**Opacité** de la couleur règle l'intensité avec laquelle
elle apparaît. **Douceur** (jusqu'à 8 pixels) estompe son bord ; à 0, le bord est net. **Bords**
règle comment un bord adouci est dessiné : **Tramés** (par défaut : un motif de tramage de l'unique
couleur de l'ombre, qui reste en place quand le dessin bouge), **Nets** (coupé à mi-intensité) ou
**Doux** (des pixels semi-transparents). Tramés et Nets n'ajoutent aucune couleur intermédiaire. Une ombre
située hors du dessin agrandit le cel (jusqu'au bord du canevas) et se place dessous. Sur un sprite
indexé, le résultat est ramené à la palette.

**Ajouter comme effet de calque** dans cette boîte de dialogue et dans les autres ajustements garde les
mêmes réglages actifs au lieu de les écrire : voir [Effets de calque](https://pxstud.io/fr/docs/manual/guides/layers.md#layer-effects).

### Anticrénelage

Adoucit les marches d'escalier là où une couleur en rencontre une autre, comme les pixel artistes le font à la main : ce
n'est pas un flou, mais quelques couleurs intermédiaires posées à côté de chaque marche. Choisis **Couleur A** et
**Couleur B** (elles partent des couleurs de premier plan et d'arrière-plan ; les pastilles sous chacune sont les
couleurs les plus utilisées du calque). Les bords droits, les coins et les diagonales à 45 degrés restent nets. Plus le
segment droit avant une marche est long, plus de pixels reçoivent une couleur intermédiaire, jusqu'à **Couleurs
intermédiaires** (de 1 à 4, mélangées de A vers B en OKLCH). **Lisser dans** choisit le côté repeint : **Couleur B** (par
défaut : autour de la forme, idéal pour une ligne sur un fond connu), **Couleur A** (dans la forme, pour que sa
silhouette ne grandisse pas ; une ligne d'un pixel reste telle quelle) ou **Les deux**. **Intensité** règle jusqu'où le
lissage s'étend le long de chaque segment (100 : jusqu'à la moitié du segment). Avec **Couleurs** sur **Palette
uniquement**, les couleurs de palette les plus proches sont utilisées ; les sprites indexés le font toujours.

Pour lisser un contour sur un fond transparent, mets l'**Opacité** de la Couleur B à 0 (n'importe quel pixel
transparent) et coche **Toute couleur visible est A** : les intermédiaires sont les couleurs mêmes du bord qui
s'estompent. Les couleurs de palette ne peuvent pas s'estomper : avec **Palette uniquement** (et sur les sprites indexés),
elles deviennent pleines ou disparaissent. **Ajouter comme effet de calque** le garde actif ; sur un sprite avec une
profondeur de couleur, le résultat reste sur cette profondeur.

### Ombrage automatique

Ombre les aplats en une passe, comme les pixel artistes ajoutent hautes lumières et ombres à la main.
**Ombrer** vaut **Couleur de base uniquement** (les pixels de la **Couleur de base** ; les
échantillons sous **Couleurs les plus fréquentes** sont les couleurs les plus utilisées du cel) ou
**Chaque aplat** (chaque couleur reçoit sa propre rampe). La lumière vient de l'**Angle de la
lumière**, en degrés dans le sens antihoraire depuis la droite : 90 est en haut, 135 en haut à
gauche (par défaut). Les pixels proches du bord tourné vers la lumière reçoivent jusqu'à **Hautes
lumières** paliers plus clairs (de 0 à 5) et ceux proches du bord opposé jusqu'à **Ombres** paliers
plus sombres, le bord lui-même le plus marqué ; chaque palier fait **Largeur de palier** pixels de
profondeur (de 1 à 4). Une partie de 1 pixel d'épaisseur garde sa couleur et une de 2 pixels reçoit
une haute lumière et une ombre : les parties fines ne deviennent jamais entièrement sombres.

Les paliers sont calculés à partir de la couleur en OKLCH. **Décalage de teinte** tourne les hautes
lumières vers un jaune chaud et les ombres vers un bleu froid, comme le font les pixel artistes, et
**Chroma par palier** rend chaque palier plus (ou moins) coloré. **Lumière de contour** ajoute un
fin reflet le long du bord extérieur du côté ombré ; **Contour le plus sombre** peint le bord
extérieur de la forme un palier plus sombre que l'ombre la plus profonde. **Couleurs** sur **Palette
uniquement** prend les couleurs les plus proches de la palette ; les sprites indexés le font toujours.

Les échantillons sous **Paliers (du sombre au clair)** montrent le résultat. **Modifier ces
couleurs** les copie dans **Rampe**, où tu peux changer n'importe laquelle : une rampe est parcourue
pour chaque couleur qu'elle contient, dans un sens comme dans l'autre. **Utiliser les nuances de
l'encre Ombrage** copie la rampe de l'encre Ombrage (un nouvel Ombrage automatique part d'elle quand
elle contient la couleur de base). **Ajouter comme effet de calque** le garde en direct : un dessin
modifié est ombré à nouveau ; son angle de lumière peut être animé pour faire tourner la lumière au
fil d'une animation. Sur un sprite avec une profondeur de couleur, le résultat reste sur cette
profondeur.

### Courbe de couleur

Remappe les valeurs à travers une courbe que tu dessines. Choisis un **Canal** : **Valeur** (rouge,
vert et bleu à la fois), **Rouge**, **Vert**, **Bleu** ou **Alpha**. Chaque canal a sa propre courbe,
une courbe lisse qui se plie à travers les points sans les dépasser (Aseprite relie ses points par des
lignes droites). Dans un sprite en niveaux de gris, les canaux sont **Valeur** et **Alpha**.

Dans l'éditeur de courbe, clique pour ajouter un point, fais glisser un point pour le déplacer et
double-clique sur un point pour le retirer. En dessous, la liste **Points** donne l'entrée et la
sortie de chaque point sous forme de champs numériques, avec des boutons **Retirer** et **Ajouter un
point** (au milieu du plus grand intervalle), pour que la courbe puisse aussi se modifier au clavier.
**Réinitialiser le canal** redresse la courbe du canal courant. La courbe Valeur est appliquée en
premier, puis celles des canaux individuels.

### Inverser les couleurs

Inverse les canaux que tu coches : **Rouge**, **Vert** et **Bleu** sont activés, **Alpha** est
désactivé. Les pixels totalement transparents restent transparents. Dans un sprite en niveaux de gris,
il y a un seul canal **Gris** au lieu des trois couleurs (pour la Matrice de convolution aussi).

### Remplacer la couleur

Échange des couleurs contre d'autres.

- **De** et **Vers** : les couleurs (des entrées de palette dans un sprite indexé). Ou coche
  **Remplacer par du transparent**. **Ajouter une ligne** ajoute une autre paire De et Vers ;
  **Retirer la ligne** en enlève une. Toutes les lignes s'appliquent en même temps, un pixel prend la
  première ligne qui lui correspond, et une couleur remplacée n'est jamais remplacée de nouveau par une
  ligne suivante, ce qui permet d'échanger deux couleurs.
- **Tolérance** (0 à 255) : l'écart qu'un pixel peut avoir avec la couleur De tout en étant
  remplacé ; 0 ne prend que cette couleur exacte.

## Historique des annulations

Le bouton d'historique sous **Annuler** et **Rétablir** dans la barre d'outils (ou
Édition > Historique des annulations) ouvre le panneau Historique des annulations à côté de la barre d'outils : à
sa gauche quand la barre d'outils est à droite, sinon du côté où il y a de la place. Il liste chaque
étape que tu peux annuler, de la plus ancienne à la plus récente, avec **Original** (le sprite avant
l'étape la plus ancienne) en haut. L'étape courante est mise en évidence par un point plein, et les
étapes que tu as annulées (que rétablir ramènerait) sont grisées. Chaque étape affiche l'heure à
laquelle elle a été faite (et la date, si ce n'était pas aujourd'hui) ; survole-la pour voir la date et
l'heure complètes. Clique sur n'importe quelle ligne pour amener le sprite à ce point. Clique de
nouveau sur le bouton, ou appuie sur **Esc** dans le panneau, pour le fermer.

Annuler ne jette jamais de travail. Si tu annules quelques étapes puis fais une nouvelle modification,
les étapes annulées restent dans l'arbre sous forme de **branche**, dessinée à partir de l'étape où tu
as pris une autre direction. Chaque niveau de ramification a sa propre couleur. Une étape qui a des
branches a une flèche à côté d'elle : clique dessus pour les replier (l'étape indique alors combien
d'étapes sont masquées) ou les déplier. Les branches démarrent dépliées jusqu'à trois niveaux de
profondeur ; les plus profondes démarrent repliées. Clique sur n'importe quelle ligne d'une branche
pour y revenir. Rétablir suit la branche que tu as visitée le plus récemment. L'historique est conservé avec le
sprite, et l'accompagne dans les fichiers `.pxstudio` que tu télécharges : ouvre-en un et son
historique revient.

**Nomme une étape** pour la retrouver plus tard : survole-la et clique sur son bouton **...**, ou
fais un clic droit dessus (au clavier, appuie sur la touche Menu ou sur Shift+F10 sur elle), puis
choisis **Nommer l'étape...**. Une étape nommée affiche son nom devant son libellé habituel, avec une
étiquette et un bord coloré, pour qu'elle ressorte dans un long historique. Nommer une étape ne
modifie pas le sprite et n'ajoute rien à l'annulation. Les noms sont conservés avec l'historique :
après un rechargement, sur tes autres appareils avec Sync, et dans les fichiers `.pxstudio` que tu
télécharges. Le même menu propose **Renommer l'étape...** et **Retirer le nom**.

Nommer une étape garde aussi le sprite tel qu'il était à cette étape comme version nommée, sous le
même nom, dans Sprite > Historique des versions.... L'étape quitte l'historique quand elle fait partie des
plus anciennes supprimées, mais la version reste jusqu'à ce que tu la supprimes. Renommer une étape
ou retirer son nom laisse sa version telle quelle.

La ligne du bas indique la mémoire qu'utilise l'historique et le nombre d'étapes qu'il contient dans
toutes les branches, sur 1 000 au maximum. Au-delà, les étapes les plus anciennes sont supprimées en
premier. [Comment ton travail est organisé](https://pxstud.io/fr/docs/manual/concepts/how-work-is-organized.md#what-undo-covers)
explique ce que couvre l'annulation.

## Dans les scripts

Les scripts peuvent aussi faire tout cela : voir [Document](https://pxstud.io/fr/docs/scripting/document.md) et
[Ajustements](https://pxstud.io/fr/docs/scripting/adjustments.md) dans la référence de script (le contour se trouve sous
[Dessin](https://pxstud.io/fr/docs/scripting/drawing.md)).