Ajouter des annotations de texte ou de fichier au PDF à l'aide de Java

Ce blog est la suite de notre blog précédent dans lequel nous avons mis en évidence certaines fonctionnalités intéressantes d’Aspose.PDF Cloud SDK pour Java sur la façon d’ajouter du texte en surbrillance ou barré et d’ajouter des annotations de ligne ou de cercle dans un PDF à l’aide de l’API REST Java. Dans cet article, nous allons notamment discuter des détails concernant l’ajout d’annotations de texte, de polyligne, de squiggly et de pièces jointes dans les documents PDF à l’aide du langage de programmation Java.

Aspose.PDF Cloud est une API REST qui permet aux utilisateurs de créer, de manipuler et de restituer des fichiers PDF existants dans d’autres formats de documents pris en charge. L’API Cloud est accessible à l’aide des deux approches suivantes :

Accéder à l’API via les commandes cURL
Accéder à l’API dans le langage de programmation Java

Discutons plus en détail de l’ajout de diverses annotations aux documents PDF à l’aide de commandes cURL et de code Java.

Ajouter des annotations à l’aide de la commande cURL
Ajouter des annotations à l’aide de Java

Ajouter des annotations à l’aide de la commande cURL

Les commandes cURL sont l’un des moyens les plus simples et les plus intéressants d’accéder aux API REST. Parlons donc de l’ajout des différentes annotations à l’aide des commandes cURL. Veuillez noter que chaque API vous permet également d’accéder au stockage Cloud où les fichiers peuvent être stockés pour traitement. Par conséquent, pour garantir l’intégrité des données, nos API ne sont accessibles qu’aux personnes autorisées. Par conséquent, vous devez d’abord visiter le tableau de bord Aspose.Cloud et si vous avez un compte GitHub ou Google, inscrivez-vous simplement. Sinon, cliquez sur le bouton Créer un nouveau compte et fournissez les informations requises. Connectez-vous maintenant au tableau de bord à l’aide des informations d’identification, développez la section Applications du tableau de bord et faites défiler vers le bas jusqu’à la section Informations d’identification du client pour voir les détails de l’ID client et du secret client.

L’étape suivante consiste maintenant à générer un jeton Web JSON (JWT) afin que les API soient accessibles via l’invite de commande.

curl -v "https://api.aspose.cloud/connect/token" \
-X POST \
-d "grant_type=client_credentials&client_id=7042694c-5251-4aba-83c9-e81e7518724f&client_secret=db246d4742e8cd22e7266c9391992689" \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Accept: application/json"

Annotation de texte

Une annotation de texte est une annotation attachée à un emplacement spécifique dans un document PDF. Lorsqu’elle est fermée, l’annotation s’affiche sous forme d’icône ; lorsqu’elle est ouverte, elle doit afficher une fenêtre contextuelle contenant le texte de la note dans la police et la taille choisies par le lecteur. Pour ajouter l’annotation de texte, nous devons utiliser l’API PostPageTextAnnotation. Utilisez la commande cURL suivante pour ajouter une annotation de texte avec l’icône Note.

 curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithBookmarks.pdf/pages/1/annotations/text" \
-H  "accept: application/json" \
-H  "authorization: Bearer <JWT Token>" \
-H  "Content-Type: application/json" \
-d "[{  \"Color\": {  \"A\": 0, \"R\": 0xDA,  \"G\": 0xA5, \"B\": 0x20    },  \"Contents\": \"Hello World \",  \"Modified\": \"05/26/2021 03:10:00.000 PM\",    \"Id\": \"1\",    \"Flags\": [      \"Default\"    ],    \"Name\": \"string\",    \"Rect\": {      \"LLX\": 100,      \"LLY\": 800,      \"URX\": 100,      \"URY\": 100    },    \"PageIndex\": 1,    \"ZIndex\": 1,    \"HorizontalAlignment\": \"Center\",    \"VerticalAlignment\": \"Center\",    \"CreationDate\": \"string\",    \"Subject\": \"Subject of Annotation\",    \"Title\": \"Annotation Title\",    \"RichText\": \"string\",    \"State\": \"Undefined\",    \"Open\": true,    \"Icon\": \"Note\"  }]"

Annotation de texte en PDF — Image 1 : Annotation de texte avec icône de note dans le fichier PDF.

Les fichiers PDF d’exemple utilisés dans l’exemple ci-dessus peuvent être téléchargés à partir des liens suivants

Annotation de polyligne

Les annotations Polyline sont utilisées pour dessiner manuellement des polylignes sur une page. Elles peuvent contenir n’importe quel nombre de côtés définis par les sommets de la polyligne. Les annotations Polyline avec une couleur de remplissage transparente ne peuvent être sélectionnées qu’autour de leurs lignes visibles. Les annotations Polyline peuvent également être ajoutées à l’aide de l’API PostPagePolyLineAnnotations.

curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithTable.pdf/pages/1/annotations/polyline" \
-H  "accept: application/json" \
-H  "authorization: Bearer " \
-H  "Content-Type: application/json" \
-d "[  {       \"Color\": {      \"A\": 0,      \"R\": 122,      \"G\": 132,      \"B\": 255    },    \"Contents\": \"Hello World...\",    \"Modified\": \"05/26/2021 03:10:00.000 PM\",    \"Id\": \"1\",    \"Flags\": [      \"Default\"    ],    \"Name\": \"Polyline\",    \"Rect\": {      \"LLX\": 100,      \"LLY\": 200,      \"URX\": 150,      \"URY\": 250    },    \"PageIndex\": 1,    \"ZIndex\": 1,    \"HorizontalAlignment\": \"Center\",    \"VerticalAlignment\": \"Center\",    \"CreationDate\": \"05/26/2021 03:10:00.000 PM\",    \"Subject\": \"Subject of Annotation\",    \"Title\": \"Title of Annotation\",    \"RichText\": \"<?xml version=\\\"1.0\\\"?><body xmlns=\\\"http://www.w3.org/1999/xhtml\\\" xmlns:xfa=\\\"http://www.xfa.org/schema/xfa-data/1.0/\\\" xfa:APIVersion=\\\"Acrobat:7.0.0\\\" xfa:spec=\\\"2.0.2\\\" ><span style=\\\"text-decoration:;font-size:10.0pt\\\">Contents</span></body>\",    \"InteriorColor\": {      \"A\": 255,      \"R\": 120,      \"G\": 110,      \"B\": 255    },    \"StartingStyle\": \"Circle\",    \"EndingStyle\": \"OpenArrow\",    \"Intent\": \"PolyLineDimension\",    \"Vertices\": [      {            \"X\": 164.611,            \"Y\": 499.629          },          {            \"X\": 192.858,            \"Y\": 509.857          },          {            \"X\": 226.461,            \"Y\": 493.785          }    ]  }]"

Annotation ondulée

Les annotations soulignées ondulées ou irrégulières aident à mettre en évidence les informations contenues dans le document. Elles peuvent être ajoutées à l’aide de l’API PostPageSquigglyAnnotations. La commande ci-dessous vous aide à ajouter une annotation ondulée au document PDF.

curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithTable.pdf/pages/1/annotations/squiggly" \
-H  "accept: application/json" \
-H  "authorization: Bearer <JWT Token>" \
-H  "Content-Type: application/json" \
-d "[  {    \"Color\": {      \"A\": 255,      \"R\": 120,      \"G\": 123,      \"B\": 150    },    \"Contents\": \"A squiggly Annotation\",    \"Modified\": \"05/26/2021 03:10:00.000 PM\",    \"Id\": \"1\",    \"Flags\": [      \"Default\"    ],    \"Name\": \"First Annotation\",    \"Rect\": {      \"LLX\": 100,      \"LLY\": 300,      \"URX\": 120,      \"URY\": 330    },    \"PageIndex\": 1,    \"ZIndex\": 1,    \"HorizontalAlignment\": \"Center\",    \"VerticalAlignment\": \"Center\",    \"CreationDate\": \"05/26/2021 03:10:00.000 PM\",    \"Subject\": \"Subject \",    \"Title\": \"Title of Squiggly\",     \"Starting\": {      \"X\": 162.663,      \"Y\": 654.5    },    \"StartingStyle\": \"Circle\",    \"Ending\": {      \"X\": 230.845,      \"Y\": 654.5    },    \"EndingStyle\": \"OpenArrow\",    \"InteriorColor\": {      \"A\": 255,      \"R\": 220,      \"G\": 220,      \"B\": 220    },    \"LeaderLine\": 10,    \"LeaderLineExtension\": 5,    \"LeaderLineOffset\": 2.5,    \"ShowCaption\": true,    \"CaptionOffset\": {      \"X\": 7,      \"Y\": 8    },    \"CaptionPosition\": \"Top\",    \"Intent\": \"LineArrow\",\"RichText\": \"string\",    \"QuadPoints\": [      {        \"X\": 100,        \"Y\": 200      }    ]  }]"

Annotation de pièce jointe

Différents fichiers peuvent être ajoutés en tant qu’annotations de pièces jointes au document PDF et pour répondre à cette exigence, l’API PostPageFileAttachmentAnnotations peut être utilisée. Exécutez la commande cURL suivante pour joindre un fichier existant au document PDF. Dans notre exemple, le fichier nommé PdfWithTable.pdf (déjà disponible sur le stockage cloud) est utilisé comme pièce jointe.

curl -X POST "https://api.aspose.cloud/v3.0/pdf/PdfWithBookmarks.pdf/pages/1/annotations/fileattachment" \
-H  "accept: application/json" \
-H  "authorization: Bearer <JWT Token>" \
-H  "Content-Type: application/json" \
 -d "[  {       \"Color\": {      \"A\": 255,      \"R\": 120,      \"G\": 120,      \"B\": 120    },    \"Contents\": \"Content\",    \"Modified\": \"05/26/2021 03:10:00.000 PM\",    \"Id\": \"1\",    \"Flags\": [      \"Default\"    ],    \"Name\": \"FileAttachment\",    \"Rect\": {      \"LLX\": 100,      \"LLY\": 200,      \"URX\": 120,      \"URY\": 2200    },    \"PageIndex\": 1,    \"ZIndex\": 0,    \"HorizontalAlignment\": \"Center\",    \"VerticalAlignment\": \"Top\",    \"CreationDate\": \"05/26/2021 03:10:00.000 PM\",    \"Subject\": \"Subject\",    \"Title\": \"Title\",    \"RichText\": \"string\",    \"Icon\": \"PushPin\",    \"Opacity\": 0,    \"FileDescription\": \"string\",    \"FileName\": \"PdfWithTable.pdf\",    \"FilePath\": \"PdfWithTable.pdf\"  }]"

Ajouter des annotations à l’aide de Java

Outre les commandes cURL, une autre approche pour utiliser nos API Cloud consiste à y accéder via des SDK de programmation. Nous avons développé des SDK de programmation pour les langages de programmation les plus courants. Ainsi, pour travailler avec des annotations dans un PDF à l’aide du langage Java, essayez d’utiliser Aspose.PDF Cloud SDK for Java.

La première étape consiste à installer le SKD sur le système. Le SDK Cloud est disponible en téléchargement sur Maven et GitHub. Ajoutez maintenant les détails suivants dans votre fichier pom.xml pour télécharger et utiliser Aspose.Pdf.jar dans votre projet de build Maven.

<repositories>
 <repository>
        <id>aspose-cloud</id>
        <name>artifact.aspose-cloud-releases</name>
        <url>https://artifact.aspose.cloud/repo</url>
    </repository>   
</repositories>
<dependencies>
 <dependency>
        <groupId>com.aspose</groupId>
        <artifactId>aspose-pdf-cloud</artifactId>
        <version>21.1.0</version>
        <scope>compile</scope>
    </dependency>
 </dependencies>

Pour plus d’informations, veuillez consulter Comment installer les SDK Aspose.Cloud.

Annotations de texte

Vous trouverez ci-dessous les étapes à suivre pour ajouter des annotations de texte aux documents PDF.

La première étape consiste à créer un objet PdfApi dans lequel nous fournissons ClientID et ClientSecret comme arguments
Ensuite, nous créons l’objet Rectangle où l’annotation est ajoutée
- LLX - Coordonnée X du coin inférieur gauche.
- LLY - Y - coordonnée du coin inférieur gauche.
- URY - X - coordonnée du coin supérieur droit.
- URY - Y - coordonnée du coin supérieur droit.
Créer un objet TextAnnotation dans lequel nous définissons l’alignement à l’aide de la méthode setHorizontalAlignment(..).Définir le sujet à l’aide de la méthode setSubject(…), l’état par défaut à l’aide de la méthode setState(…), etc.
Créez ensuite l’objet ArrayList<> de type TextAnnotation et ajoutez-y l’objet TextAnnotation créé ci-dessus
Enfin, appelez postPageTextAnnotations(…) où nous passons le nom du fichier PDF d’entrée, le PageNumber et la Annotations ArrayList créée ci-dessus comme arguments

// Obtenez ClientID et ClientSecret depuis https://dashboard.aspose.cloud/
String clientId = "7042694c-5251-4aba-83c9-e81e7518724f";
String clientSecret = "db246d4742e8cd22e7266c9391992689";
				
// instance createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
				
// document PDF d'entrée
String name = "PdfWithTable.pdf";	        
			    
// Charger le fichier à partir du système local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// télécharger le fichier sur le stockage cloud
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
				
// numéro de page où l'annotation doit être ajoutée
int pageNumber = 1;

// créer un objet Rectangle où l'annotation est ajoutée
Rectangle rect = new Rectangle()
    .LLX(100.)
    .LLY(600.)
    .URX(200.)
    .URY(650.);

// Créer une liste d'indicateurs d'annotation
List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);

// Créer un objet TextAnnotation
TextAnnotation textAnnotation = new TextAnnotation();
textAnnotation.setName("Annotation Name");
textAnnotation.setRect(rect);
textAnnotation.setFlags(flags);
textAnnotation.setHorizontalAlignment(HorizontalAlignment.CENTER);

// définir le contenu à afficher dans l'annotation
textAnnotation.contents("Hello World...");
// Définir l'icône pour l'annotation
textAnnotation.icon(TextIcon.KEY);

textAnnotation.setSubject("Text Box Subj");
textAnnotation.setZindex(1);

// l'état par défaut de l'objet d'annotation
textAnnotation.setState(AnnotationState.COMPLETED);
		        
// créer un ListArray de TextAnnotation
List<TextAnnotation> annotations = new ArrayList<>();

// ajouter l'annotation de texte créée ci-dessus à l'instance de liste
annotations.add(textAnnotation);

// appeler la méthode pour ajouter une annotation au fichier PDF
AsposeResponse response = pdfApi.postPageTextAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());

Annotations de polylignes

Le SDK Cloud fournit également les mêmes fonctionnalités pour ajouter des annotations de polylignes à un document PDF. Vous trouverez ci-dessous les étapes et l’extrait de code permettant de répondre à cette exigence.

Tout d’abord, nous devons créer une instance PdfApi et télécharger le fichier source sur le stockage Cloud.
Créez une ArrayList de type Point qui définit les points auxquels les polylignes seront dessinées.
L’étape suivante consiste à créer un objet PolyLineAnnotation dans lequel nous définissons la région rectangulaire et transmettons Points ListArray à la méthode setVertices(…).
Pour définir la couleur intérieure, utilisez la méthode setInteriorColor(…) et passez l’instance Color comme argument.
Appelez maintenant les méthodes startingStyle(…) et endingStyle(…) pour définir le style de début et de fin de l’annotation. Ces méthodes prennent la valeur de l’énumération LineEnding comme arguments.
Enfin, appelez la méthode postPagePolyLineAnnotations(…) de la classe PdfApi pour restituer l’annotation à l’intérieur du document PDF.

// Obtenez ClientID et ClientSecret depuis https://dashboard.aspose.cloud/
String clientId = "a41d01ef-dfd5-4e02-ad29-bd85fe41e3e4";
String clientSecret = "d87269aade6a46cdc295b711e26809af";
				
// instance createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
				
// document PDF d'entrée
String name = "PdfWithTable.pdf";	        
			    
// Charger le fichier à partir du système local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// télécharger le fichier sur le stockage cloud
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
				
// numéro de page du fichier d'entrée où l'annotation sera ajoutée
int pageNumber = 1;

// région rectangulaire pour l'annotation
Rectangle rect = new Rectangle()
    .LLX(100.)
    .LLY(600.)
    .URX(200.)
    .URY(650.);

// spécifier les sommets pour l'annotation
List<Point> vertices = new ArrayList();
vertices.add(new Point().X(10.).Y(10.));
vertices.add(new Point().X(20.).Y(10.));
vertices.add(new Point().X(10.).Y(20.));
vertices.add(new Point().X(10.).Y(10.));

List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);

// créer un objet PolyLineAnnotation
PolyLineAnnotation annotation = new PolyLineAnnotation();
annotation.setName("Name");
annotation.setRect(rect);
annotation.setFlags(flags);
// définir l'alignement horizontal de l'annotation
annotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
annotation.contents("Rich Text in the PDF File...");
annotation.setSubject("Subj");
annotation.setZindex(1);
annotation.setTitle("Title");

// créer un objet de couleur
Color color = new Color();
color.setA(255);
color.setR(120);
color.setG(140);
color.setB(130);

// définir la couleur interne pour l'instance d'annotation
annotation.setInteriorColor(color);
		        
annotation.setVertices(vertices);
// spécifier le style de départ pour l'annotation
annotation.startingStyle(LineEnding.OPENARROW);

// définir le style de fin pour l'annotation
annotation.endingStyle(LineEnding.SQUARE);

List<PolyLineAnnotation> annotations = new ArrayList<>();
annotations.add(annotation);
		        
// appeler la méthode pour ajouter une annotation polyligne à la première page du document
AsposeResponse response = pdfApi.postPagePolyLineAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());

Annotations ondulées

Une classe distincte nommée SquigglyAnnotation est utilisée pour ajouter des annotations Squiggly au document PDF. L’extrait de code ci-dessous peut être utilisé pour ajouter des annotations Squiggly au fichier PDF disponible sur le stockage Cloud.

// Obtenez ClientID et ClientSecret depuis https://dashboard.aspose.cloud/
String clientId = "a41d01ef-dfd5-4e02-ad29-bd85fe41e3e4";
String clientSecret = "d87269aade6a46cdc295b711e26809af";
				
// instance createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
				
// document PDF d'entrée
String name = "PdfWithTable.pdf";	        
			    
// Charger le fichier à partir du système local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// télécharger le fichier sur le stockage cloud
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
				
// numéro de page du fichier d'entrée où l'annotation sera ajoutée
int pageNumber = 1;

// région rectangulaire pour l'annotation
Rectangle rect = new Rectangle()
    .LLX(100.)
    .LLY(600.)
    .URX(200.)
    .URY(650.);

// spécifier les sommets pour l'annotation
List<Point> vertices = new ArrayList();
vertices.add(new Point().X(10.).Y(10.));
vertices.add(new Point().X(20.).Y(10.));
vertices.add(new Point().X(10.).Y(20.));
vertices.add(new Point().X(10.).Y(10.));

List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);

// créer un objet SquigglyAnnotation
SquigglyAnnotation annotation = new SquigglyAnnotation();
annotation.setName("Name");
annotation.setRect(rect);
annotation.setFlags(flags);
annotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
annotation.contents("Rich Text in the PDF File...");
annotation.setSubject("Subj");
annotation.setZindex(1);
annotation.setTitle("Title");
annotation.setModified("28/05/2021 00:00:00.000 AM");
		        
// créer un objet de couleur
Color color = new Color();
color.setA(155);
color.setR(120);
color.setG(140);
color.setB(130);

// définir la couleur interne pour l'instance d'annotation
annotation.color(color);

// définir des points d'annotation		        
annotation.setQuadPoints(vertices);

List<SquigglyAnnotation> annotations = new ArrayList<>();
annotations.add(annotation);
		        
// appeler la méthode pour ajouter une annotation ondulée à la première page du document
AsposeResponse response = pdfApi.postPageSquigglyAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());

Annotations des pièces jointes

Pour ajouter l’annotation de pièce jointe, essayez d’utiliser l’extrait de code suivant. La description du code est la même que celle partagée dans les sections ci-dessus, sauf que vous devez utiliser l’objet FileAttachmentAnnotation pour répondre à cette exigence.

// Obtenez ClientID et ClientSecret depuis https://dashboard.aspose.cloud/
String clientId = "a41d01ef-dfd5-4e02-ad29-bd85fe41e3e4";
String clientSecret = "d87269aade6a46cdc295b711e26809af";
				
// instance createPdfApi
PdfApi pdfApi = new PdfApi(clientSecret,clientId);
				
// document PDF d'entrée
String name = "PdfWithTable.pdf";	        
			    
// Charger le fichier à partir du système local
File file = new File("/Users/nayyershahbaz/Downloads/" + name);
// télécharger le fichier sur le stockage cloud
FilesUploadResult uploadResponse = pdfApi.uploadFile(name, file, null);
				
// numéro de page du fichier d'entrée où l'annotation sera ajoutée
int pageNumber = 1;

// région rectangulaire pour l'annotation
Rectangle rect = new Rectangle()
    .LLX(100.)
    .LLY(100.)
    .URX(200.)
    .URY(200.);

List<AnnotationFlags> flags = new ArrayList<>();
flags.add(AnnotationFlags.DEFAULT);

// créer un objet FileAttachmentAnnotation
FileAttachmentAnnotation annotation = new FileAttachmentAnnotation();
annotation.setName("Name");
annotation.setRect(rect);
annotation.setFlags(flags);
annotation.setHorizontalAlignment(HorizontalAlignment.CENTER);
annotation.contents("Rich Text in the PDF File...");
annotation.setSubject("Subj");
annotation.setZindex(1);
annotation.setTitle("Title");
annotation.setModified("28/05/2021 00:00:00.000 AM");
		        
// chemin du fichier joint
annotation.setFilePath("images.jpeg");
// nom du fichier joint
annotation.setFileName("images.jpeg");

// créer une instance de liste de FileAttachment
List<FileAttachmentAnnotation> annotations = new ArrayList<>();
annotations.add(annotation);
		        
// appeler la méthode pour ajouter l'annotation FileAttachment à la première page du document
AsposeResponse response = pdfApi.postPageFileAttachmentAnnotations(name, pageNumber, annotations, null, null);
assertEquals(200, (int)response.getCode());

Conclusion

Dans cet article, nous avons abordé les étapes et les détails associés à l’ajout d’annotations de type Texte, Polyligne, Ondulation et Pièces jointes au document PDF. Étant donné que nos SDK Cloud sont open source, vous pouvez télécharger le code source complet depuis GitHub. Le référentiel contient également d’autres exemples utiles sur la façon d’utiliser le SDK Java Cloud pour créer et manipuler des fichiers PDF existants. Si vous avez des questions à ce sujet, n’hésitez pas à nous contacter via les forums d’assistance client gratuits.

Articles connexes

Nous vous recommandons vivement de consulter les articles suivants :

Ajouter des annotations à l’aide de la commande cURL#

Annotation de texte#

Annotation de polyligne#

Annotation ondulée#

Annotation de pièce jointe#

Ajouter des annotations à l’aide de Java#

Annotations de texte#

Annotations de polylignes#

Annotations ondulées#

Annotations des pièces jointes#

Conclusion#

Articles connexes#