Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Obtenir les métadonnées d'un ensemble d'images
<a name="get-image-set-metadata"></a>

Utilisez l'`GetImageSetMetadata`action pour récupérer [les métadonnées](getting-started-concepts.md#concept-metadata) d'une [image donnée définie](getting-started-concepts.md#concept-image-set) dans HealthImaging. Les menus suivants fournissent une procédure AWS Management Console et des exemples de code pour le AWS CLI et AWS SDKs. Pour plus d'informations, consultez [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html)le manuel de *référence des HealthImaging API AWS*.

**Note**  
Par défaut, HealthImaging renvoie les attributs de métadonnées pour la dernière version d'un ensemble d'images. Pour consulter les métadonnées d'une ancienne version d'un ensemble d'images, veuillez les `versionId` joindre à votre demande.  
Les métadonnées des ensembles d'images sont compressées `gzip` et renvoyées sous forme d'objet JSON. Par conséquent, vous devez décompresser l'objet JSON avant de visualiser les métadonnées normalisées. Pour de plus amples informations, veuillez consulter [Normalisation des métadonnées](metadata-normalization.md).  
Si les métadonnées d'un ensemble d'images volumineux sont toujours en cours de traitement après l'importation, un 409 `ConflictException` peut être renvoyé. Réessayez la demande après quelques secondes une fois le traitement terminé.  
Utilisez `GetDICOMInstanceMetadata` HealthImaging la représentation d'un DICOMweb service pour renvoyer les métadonnées d'une instance DICOM (`.json`fichier). Pour de plus amples informations, veuillez consulter [Obtenir les métadonnées d'une instance DICOM à partir de HealthImaging](dicomweb-retrieve-instance-metadata.md).

**Pour obtenir les métadonnées du jeu d'images**  
Choisissez un menu en fonction de vos préférences d'accès à AWS HealthImaging.

## AWS Console
<a name="code-example-console-image-set-get-metadata"></a>

1. Ouvrez la [page HealthImaging Stockages de données de la](https://console.aws.amazon.com/medical-imaging/home#/dataStores) console.

1. Choisissez un magasin de données.

   La page de **détails du magasin de données** s'ouvre et l'onglet **Ensembles d'images** est sélectionné par défaut.

1. Choisissez un ensemble d'images.

   La page de **détails du jeu d'images** s'ouvre et les métadonnées du jeu d'images s'affichent dans la section **Visionneuse de métadonnées du jeu d'images**.

## AWS CLI et SDKs
<a name="code-example-cli-sdk-image-set-get-metadata"></a>

------
#### [ C\+\+ ]

**SDK pour C\+\+**  
Fonction utilitaire pour obtenir les métadonnées d’un ensemble d’images.  

```
//! Routine which gets a HealthImaging image set's metadata.
/*!
  \param dataStoreID: The HealthImaging data store ID.
  \param imageSetID: The HealthImaging image set ID.
  \param versionID: The HealthImaging image set version ID, ignored if empty.
  \param outputFilePath: The path where the metadata will be stored as gzipped json.
  \param clientConfig: Aws client configuration.
  \\return bool: Function succeeded.
*/
bool AwsDoc::Medical_Imaging::getImageSetMetadata(const Aws::String &dataStoreID,
                                                  const Aws::String &imageSetID,
                                                  const Aws::String &versionID,
                                                  const Aws::String &outputFilePath,
                                                  const Aws::Client::ClientConfiguration &clientConfig) {
    Aws::MedicalImaging::Model::GetImageSetMetadataRequest request;
    request.SetDatastoreId(dataStoreID);
    request.SetImageSetId(imageSetID);
    if (!versionID.empty()) {
        request.SetVersionId(versionID);
    }
    Aws::MedicalImaging::MedicalImagingClient client(clientConfig);
    Aws::MedicalImaging::Model::GetImageSetMetadataOutcome outcome = client.GetImageSetMetadata(
            request);
    if (outcome.IsSuccess()) {
        std::ofstream file(outputFilePath, std::ios::binary);
        auto &metadata = outcome.GetResult().GetImageSetMetadataBlob();
        file << metadata.rdbuf();
    }
    else {
        std::cerr << "Failed to get image set metadata: "
                  << outcome.GetError().GetMessage() << std::endl;
    }

    return outcome.IsSuccess();
}
```
Obtenez les métadonnées d’un ensemble d’images sans version.  

```
        if (AwsDoc::Medical_Imaging::getImageSetMetadata(dataStoreID, imageSetID, "", outputFilePath, clientConfig))
        {
            std::cout << "Successfully retrieved image set metadata." << std::endl;
            std::cout << "Metadata stored in: " << outputFilePath << std::endl;
        }
```
Obtenez les métadonnées d’un ensemble d’images avec une version.  

```
        if (AwsDoc::Medical_Imaging::getImageSetMetadata(dataStoreID, imageSetID, versionID, outputFilePath, clientConfig))
        {
            std::cout << "Successfully retrieved image set metadata." << std::endl;
            std::cout << "Metadata stored in: " << outputFilePath << std::endl;
        }
```
+  Pour plus de détails sur l'API, reportez-vous [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageSetMetadata)à la section *Référence des AWS SDK pour C\+\+ API*. 
 Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

------
#### [ CLI ]

**AWS CLI**  
**Exemple 1 : pour obtenir les métadonnées d’un ensemble d’images sans version**  
L’exemple de code `get-image-set-metadata` suivant fournit les métadonnées d’un ensemble d’images sans spécifier de version.  
Remarque : `outfile` est un paramètre obligatoire  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id {{12345678901234567890123456789012}} \
    --image-set-id {{ea92b0d8838c72a3f25d00d13616f87e}} \
    {{studymetadata.json.gz}}
```
Les métadonnées renvoyées sont compressées avec gzip et stockées dans le fichier studymetadata.json.gz. Pour visualiser le contenu de l’objet JSON renvoyé, vous devez d’abord le décompresser.  
Sortie :  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
**Exemple 2 : pour obtenir les métadonnées d’un ensemble d’images avec version**  
L’exemple de code `get-image-set-metadata` suivant fournit les métadonnées d’un ensemble d’images avec une version spécifiée.  
Remarque : `outfile` est un paramètre obligatoire  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id {{12345678901234567890123456789012}} \
    --image-set-id {{ea92b0d8838c72a3f25d00d13616f87e}} \
    --version-id {{1}} \
    {{studymetadata.json.gz}}
```
Les métadonnées renvoyées sont compressées avec gzip et stockées dans le fichier studymetadata.json.gz. Pour visualiser le contenu de l’objet JSON renvoyé, vous devez d’abord le décompresser.  
Sortie :  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
Pour plus d'informations, consultez la section [Obtenir les métadonnées d'un ensemble d'images](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-metadata.html) dans le *manuel du AWS HealthImaging développeur*.  
+  Pour plus de détails sur l'API, reportez-vous [GetImageSetMetadata](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set-metadata.html)à la section *Référence des AWS CLI commandes*. 

------
#### [ Java ]

**SDK pour Java 2.x**  

```
    public static void getMedicalImageSetMetadata(MedicalImagingClient medicalImagingClient,
            String destinationPath,
            String datastoreId,
            String imagesetId,
            String versionId) {

        try {
            GetImageSetMetadataRequest.Builder getImageSetMetadataRequestBuilder = GetImageSetMetadataRequest.builder()
                    .datastoreId(datastoreId)
                    .imageSetId(imagesetId);

            if (versionId != null) {
                getImageSetMetadataRequestBuilder = getImageSetMetadataRequestBuilder.versionId(versionId);
            }

            medicalImagingClient.getImageSetMetadata(getImageSetMetadataRequestBuilder.build(),
                    FileSystems.getDefault().getPath(destinationPath));

            System.out.println("Metadata downloaded to " + destinationPath);
        } catch (MedicalImagingException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
```
+  Pour plus de détails sur l'API, reportez-vous [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSetMetadata)à la section *Référence des AWS SDK for Java 2.x API*. 
 Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

------
#### [ JavaScript ]

**SDK pour JavaScript (v3)**  
Fonction utilitaire pour obtenir les métadonnées d’un ensemble d’images.  

```
import { GetImageSetMetadataCommand } from "@aws-sdk/client-medical-imaging";
import { medicalImagingClient } from "../libs/medicalImagingClient.js";
import { writeFileSync } from "node:fs";

/**
 * @param {string} metadataFileName - The name of the file for the gzipped metadata.
 * @param {string} datastoreId - The ID of the data store.
 * @param {string} imagesetId - The ID of the image set.
 * @param {string} versionID - The optional version ID of the image set.
 */
export const getImageSetMetadata = async (
  metadataFileName = "metadata.json.gzip",
  datastoreId = "xxxxxxxxxxxxxx",
  imagesetId = "xxxxxxxxxxxxxx",
  versionID = "",
) => {
  const params = { datastoreId: datastoreId, imageSetId: imagesetId };

  if (versionID) {
    params.versionID = versionID;
  }

  const response = await medicalImagingClient.send(
    new GetImageSetMetadataCommand(params),
  );
  const buffer = await response.imageSetMetadataBlob.transformToByteArray();
  writeFileSync(metadataFileName, buffer);

  console.log(response);
  // {
  //     '$metadata': {
  //     httpStatusCode: 200,
  //         requestId: '5219b274-30ff-4986-8cab-48753de3a599',
  //         extendedRequestId: undefined,
  //         cfId: undefined,
  //         attempts: 1,
  //         totalRetryDelay: 0
  // },
  //     contentType: 'application/json',
  //     contentEncoding: 'gzip',
  //     imageSetMetadataBlob: <ref *1> IncomingMessage {}
  // }

  return response;
};
```
Obtenez les métadonnées d’un ensemble d’images sans version.  

```
  try {
    await getImageSetMetadata(
      "metadata.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
Obtenez les métadonnées d’un ensemble d’images avec une version.  

```
  try {
    await getImageSetMetadata(
      "metadata2.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
      "1",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
+  Pour plus de détails sur l'API, reportez-vous [GetImageSetMetadata](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetMetadataCommand)à la section *Référence des AWS SDK pour JavaScript API*. 
 Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

------
#### [ Python ]

**Kit SDK for Python (Boto3)**  
Fonction utilitaire pour obtenir les métadonnées d’un ensemble d’images.  

```
class MedicalImagingWrapper:
    def __init__(self, health_imaging_client):
        self.health_imaging_client = health_imaging_client


    def get_image_set_metadata(
        self, metadata_file, datastore_id, image_set_id, version_id=None
    ):
        """
        Get the metadata of an image set.

        :param metadata_file: The file to store the JSON gzipped metadata.
        :param datastore_id: The ID of the data store.
        :param image_set_id: The ID of the image set.
        :param version_id: The version of the image set.
        """
        try:
            if version_id:
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id,
                    datastoreId=datastore_id,
                    versionId=version_id,
                )
            else:

                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id, datastoreId=datastore_id
                )
            print(image_set_metadata)
            with open(metadata_file, "wb") as f:
                for chunk in image_set_metadata["imageSetMetadataBlob"].iter_chunks():
                    if chunk:
                        f.write(chunk)

        except ClientError as err:
            logger.error(
                "Couldn't get image metadata. Here's why: %s: %s",
                err.response["Error"]["Code"],
                err.response["Error"]["Message"],
            )
            raise
```
Obtenez les métadonnées d’un ensemble d’images sans version.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id, datastoreId=datastore_id
                )
```
Obtenez les métadonnées d’un ensemble d’images avec une version.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id,
                    datastoreId=datastore_id,
                    versionId=version_id,
                )
```
Le code suivant instancie l' MedicalImagingWrapper objet.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Pour plus de détails sur l'API, consultez [GetImageSetMetadata](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSetMetadata)le *AWS manuel de référence de l'API SDK for Python (Boto3*). 
 Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples). 

------
#### [ SAP ABAP ]

**Kit SDK pour SAP ABAP**  

```
    TRY.
        " iv_datastore_id = '1234567890123456789012345678901234567890'
        " iv_image_set_id = '1234567890123456789012345678901234567890'
        " iv_version_id = '1' (optional)
        IF iv_version_id IS NOT INITIAL.
          oo_result = lo_mig->getimagesetmetadata(
            iv_datastoreid = iv_datastore_id
            iv_imagesetid = iv_image_set_id
            iv_versionid = iv_version_id ).
        ELSE.
          oo_result = lo_mig->getimagesetmetadata(
            iv_datastoreid = iv_datastore_id
            iv_imagesetid = iv_image_set_id ).
        ENDIF.
        DATA(lv_metadata_blob) = oo_result->get_imagesetmetadatablob( ).
        MESSAGE 'Image set metadata retrieved.' TYPE 'I'.
      CATCH /aws1/cx_migaccessdeniedex.
        MESSAGE 'Access denied.' TYPE 'I'.
      CATCH /aws1/cx_migconflictexception.
        MESSAGE 'Conflict error.' TYPE 'I'.
      CATCH /aws1/cx_miginternalserverex.
        MESSAGE 'Internal server error.' TYPE 'I'.
      CATCH /aws1/cx_migresourcenotfoundex.
        MESSAGE 'Image set not found.' TYPE 'I'.
      CATCH /aws1/cx_migthrottlingex.
        MESSAGE 'Request throttled.' TYPE 'I'.
      CATCH /aws1/cx_migvalidationex.
        MESSAGE 'Validation error.' TYPE 'I'.
    ENDTRY.
```
+  Pour plus de détails sur l'API, reportez-vous [GetImageSetMetadata](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*. 
 Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

**Exemple de disponibilité**  
Vous n’avez pas trouvé ce dont vous avez besoin ? Demandez un exemple de code à l'aide du lien **Fournir des commentaires** dans la barre latérale droite de cette page.

**Métadonnées de syntaxe de transfert**  
Lors de l'importation de données DICOM, HealthImaging conserve la valeur d'origine de l'attribut de syntaxe de transfert dans les métadonnées du jeu d'images. La syntaxe de transfert des données DICOM d'origine importées est stockée sous le `TransferSyntaxUID` format. HealthImaging utilise `StoredTransferSyntaxUID` pour indiquer le format utilisé pour coder les données des trames d'image dans le magasin de données : `1.2.840.10008.1.2.4.202` pour les magasins de données compatibles HTJ2 K (par défaut) et `1.2.840.10008.1.2.4.90` pour les magasins de données compatibles JPEG 2000 Lossless.