Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Ottenere i metadati del set di immagini
<a name="get-image-set-metadata"></a>

Usa l'`GetImageSetMetadata`azione per recuperare [i metadati](getting-started-concepts.md#concept-metadata) per un determinato set di [immagini](getting-started-concepts.md#concept-image-set). HealthImaging I seguenti menu forniscono una procedura e alcuni esempi di codice per Console di gestione AWS and. AWS CLI AWS SDKs Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html)l'*AWS HealthImaging API Reference*.

**Nota**  
Per impostazione predefinita, HealthImaging restituisce gli attributi dei metadati per la versione più recente di un set di immagini. Per visualizzare i metadati per una versione precedente di un set di immagini, fornisci la tua `versionId` richiesta.  
I metadati del set di immagini vengono compressi `gzip` e restituiti come oggetto JSON. Pertanto, è necessario decomprimere l'oggetto JSON prima di visualizzare i metadati normalizzati. Per ulteriori informazioni, consulta [Normalizzazione dei metadati](metadata-normalization.md).  
Se i metadati di un set di immagini di grandi dimensioni vengono ancora elaborati dopo l'importazione, è possibile che venga restituito un 409. `ConflictException` Riprova la richiesta dopo alcuni secondi una volta completata l'elaborazione.  
Utilizza`GetDICOMInstanceMetadata`, HealthImaging come rappresentazione di un DICOMweb servizio, per restituire i metadati (file) dell'istanza DICOM. `.json` Per ulteriori informazioni, consulta [Ottenere i metadati dell'istanza DICOM da HealthImaging](dicomweb-retrieve-instance-metadata.md).

**Per ottenere i metadati del set di immagini**  
Scegli un menu in base alle tue preferenze di accesso ad AWS HealthImaging.

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

1. Apri la [pagina degli archivi dati](https://console.aws.amazon.com/medical-imaging/home#/dataStores) della HealthImaging console.

1. Scegli un archivio dati.

   Si apre la pagina dei **dettagli del Data Store** e la scheda **Set di immagini** è selezionata per impostazione predefinita.

1. Scegliete un set di immagini.

   Viene visualizzata la pagina dei **dettagli del set di immagini** e i metadati del set di immagini vengono visualizzati nella sezione **Visualizzatore di metadati del set di immagini**.

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

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

**SDK per C\+\+**  
Funzione di utilità per ottenere i metadati del set di immagini.  

```
//! 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();
}
```
Ottiene i metadati del set di immagini senza la versione.  

```
        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;
        }
```
Ottiene i metadati del set di immagini con la versione.  

```
        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;
        }
```
+  Per i dettagli sull'API, consulta la sezione *AWS SDK per C\+\+ API [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageSetMetadata)Reference*. 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

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

**AWS CLI**  
**Esempio 1: come ottenere i metadati del set di immagini senza versione.**  
L’esempio di codice `get-image-set-metadata` seguente ottiene i metadati per un set di immagini senza specificare una versione.  
Nota: `outfile` è un parametro obbligatorio.  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id {{12345678901234567890123456789012}} \
    --image-set-id {{ea92b0d8838c72a3f25d00d13616f87e}} \
    {{studymetadata.json.gz}}
```
I metadati restituiti vengono compressi con gzip e archiviati nel file studymetadata.json.gz. Per visualizzare il contenuto dell’oggetto JSON restituito, devi prima decomprimerlo.  
Output:  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
**Esempio 2: come ottenere i metadati del set di immagini con versione**  
L’esempio di codice `get-image-set-metadata` seguente ottiene i metadati per un set di immagini con una versione specificata.  
Nota: `outfile` è un parametro obbligatorio.  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id {{12345678901234567890123456789012}} \
    --image-set-id {{ea92b0d8838c72a3f25d00d13616f87e}} \
    --version-id {{1}} \
    {{studymetadata.json.gz}}
```
I metadati restituiti vengono compressi con gzip e archiviati nel file studymetadata.json.gz. Per visualizzare il contenuto dell’oggetto JSON restituito, devi prima decomprimerlo.  
Output:  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
Per ulteriori informazioni, consulta [Ottenere i metadati dei set di immagini](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-metadata.html) nella *Guida per gli AWS HealthImaging sviluppatori*.  
+  Per i dettagli sull'API, consulta [GetImageSetMetadata AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set-metadata.html)*Command Reference.* 

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

**SDK per 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);
        }
    }
```
+  Per i dettagli sull'API, [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSetMetadata)consulta *AWS SDK for Java 2.x API Reference*. 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

**SDK per JavaScript (v3)**  
Funzione di utilità per ottenere i metadati del set di immagini.  

```
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;
};
```
Ottiene i metadati del set di immagini senza la versione.  

```
  try {
    await getImageSetMetadata(
      "metadata.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
Ottiene i metadati del set di immagini con la versione.  

```
  try {
    await getImageSetMetadata(
      "metadata2.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
      "1",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
+  Per i dettagli sull'API, consulta la sezione *AWS SDK per JavaScript API [GetImageSetMetadata](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetMetadataCommand)Reference*. 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

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

**SDK per Python (Boto3)**  
Funzione di utilità per ottenere i metadati del set di immagini.  

```
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
```
Ottiene i metadati del set di immagini senza la versione.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id, datastoreId=datastore_id
                )
```
Ottiene i metadati del set di immagini con la versione.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id,
                    datastoreId=datastore_id,
                    versionId=version_id,
                )
```
Il codice seguente crea un'istanza dell' MedicalImagingWrapper oggetto.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Per i dettagli sull'API, consulta [GetImageSetMetadata AWS](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSetMetadata)*SDK for Python (Boto3) API Reference*. 
 C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples). 

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

**SDK per 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.
```
+  Per i dettagli sull'API, consulta [GetImageSetMetadata AWS](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)*SDK for SAP* ABAP API reference. 
 C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

**Esempio di disponibilità**  
Non riesci a trovare quello che ti serve? Richiedi un esempio di codice utilizzando il link **Fornisci feedback** nella barra laterale destra di questa pagina.

**Trasferisci i metadati della sintassi**  
Quando si importano dati DICOM, HealthImaging mantiene il valore originale dell'attributo di sintassi di trasferimento nei metadati del set di immagini. La sintassi di trasferimento dei dati DICOM originali importati viene memorizzata come. `TransferSyntaxUID` HealthImaging utilizza `StoredTransferSyntaxUID` per indicare il formato usato per codificare i dati dei frame di immagine nell'archivio dati: `1.2.840.10008.1.2.4.202` per gli archivi dati abilitati per HTJ2 K (impostazione predefinita) e per gli archivi dati abilitati `1.2.840.10008.1.2.4.90` per JPEG 2000 Lossless.