Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Metadaten von Bilddatensätzen abrufen
<a name="get-image-set-metadata"></a>

Verwenden Sie die `GetImageSetMetadata` Aktion, um [Metadaten](getting-started-concepts.md#concept-metadata) für einen bestimmten [Bildsatz](getting-started-concepts.md#concept-image-set) in abzurufen HealthImaging. Die folgenden Menüs enthalten eine Vorgehensweise für das AWS-Managementkonsole und Codebeispiele für AWS CLI und AWS SDKs. Weitere Informationen finden Sie [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html)in der * HealthImaging AWS-API-Referenz*.

**Anmerkung**  
 HealthImaging Gibt standardmäßig Metadatenattribute für die neueste Version eines Image-Sets zurück. Wenn Sie Metadaten für eine ältere Version eines Bildsatzes anzeigen möchten, geben Sie dies `versionId` in Ihrer Anfrage an.  
Bilddatensatz-Metadaten werden mit einem JSON-Objekt komprimiert `gzip` und als JSON-Objekt zurückgegeben. Daher müssen Sie das JSON-Objekt dekomprimieren, bevor Sie die normalisierten Metadaten anzeigen können. Weitere Informationen finden Sie unter [Normalisierung von Metadaten](metadata-normalization.md).  
Wenn die Metadaten eines großen Bilddatensatzes nach dem Import noch verarbeitet werden, wird `ConflictException` möglicherweise ein 409-Wert zurückgegeben. Versuchen Sie die Anfrage nach einigen Sekunden erneut, sobald die Verarbeitung abgeschlossen ist.  
Verwenden Sie `GetDICOMInstanceMetadata` HealthImaging die Darstellung eines DICOMweb Dienstes, um Metadaten (`.json`Datei) der DICOM-Instanz zurückzugeben. Weitere Informationen finden Sie unter [Metadaten der DICOM-Instanz abrufen von HealthImaging](dicomweb-retrieve-instance-metadata.md).

**Um Metadaten von Bilddatensätzen abzurufen**  
Wählen Sie ein Menü, das auf Ihren Zugriffspräferenzen für AWS basiert HealthImaging.

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

1. Öffnen Sie die [Seite Datenspeicher](https://console.aws.amazon.com/medical-imaging/home#/dataStores) der HealthImaging Konsole.

1. Wählen Sie einen Datenspeicher aus.

   Die Seite mit den **Datenspeicher-Details** wird geöffnet, und die Registerkarte **Bildsätze** ist standardmäßig ausgewählt.

1. Wählen Sie einen Bildsatz aus.

   Die Seite mit den **Bilddatensatzdetails** wird geöffnet, und die Metadaten des **Bildsatzes werden im Bereich Bilddaten-Viewer** angezeigt.

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

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

**SDK für C\+\+**  
Hilfsfunktion zum Abrufen von Bildsatz-Metadaten.  

```
//! 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();
}
```
Rufen Sie Bildsatz-Metadaten ohne Version ab.  

```
        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;
        }
```
Rufen Sie Bildsatz-Metadaten mit Version ab.  

```
        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;
        }
```
+  Einzelheiten zur API finden Sie [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageSetMetadata)unter *AWS SDK für C\+\+ API-Referenz*. 
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples) einrichten und ausführen. 

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

**AWS CLI**  
**Beispiel 1: So rufen Sie Bildsatz-Metadaten ohne Version ab**  
Im folgenden Codebeispiel für `get-image-set-metadata` werden Metadaten für einen Bildsatz abgerufen, ohne eine Version anzugeben.  
Anmerkung: Der Parameter `outfile` ist erforderlich.  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id {{12345678901234567890123456789012}} \
    --image-set-id {{ea92b0d8838c72a3f25d00d13616f87e}} \
    {{studymetadata.json.gz}}
```
Die zurückgegebenen Metadaten werden mit GZIP komprimiert und in der Datei „studymetadata.json.gz“ gespeichert. Um den Inhalt des zurückgegebenen JSON-Objekts anzuzeigen, müssen Sie es zuerst dekomprimieren.  
Ausgabe:  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
**Beispiel 2: So rufen Sie Bildsatz-Metadaten mit Version ab**  
Im folgenden Codebeispiel für `get-image-set-metadata` werden Metadaten für einen Bildsatz mit einer bestimmten Version abgerufen.  
Anmerkung: Der Parameter `outfile` ist erforderlich.  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id {{12345678901234567890123456789012}} \
    --image-set-id {{ea92b0d8838c72a3f25d00d13616f87e}} \
    --version-id {{1}} \
    {{studymetadata.json.gz}}
```
Die zurückgegebenen Metadaten werden mit GZIP komprimiert und in der Datei „studymetadata.json.gz“ gespeichert. Um den Inhalt des zurückgegebenen JSON-Objekts anzuzeigen, müssen Sie es zuerst dekomprimieren.  
Ausgabe:  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
Weitere Informationen finden Sie im *AWS HealthImaging Entwicklerhandbuch* unter [Abrufen von Bilddatensatz-Metadaten](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-metadata.html).  
+  Einzelheiten zur API finden Sie [GetImageSetMetadata](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set-metadata.html)in der *AWS CLI Befehlsreferenz*. 

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

**SDK für 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);
        }
    }
```
+  Einzelheiten zur API finden Sie [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSetMetadata)in der *AWS SDK for Java 2.x API-Referenz*. 
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples) einrichten und ausführen. 

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

**SDK für JavaScript (v3)**  
Hilfsfunktion zum Abrufen von Bildsatz-Metadaten.  

```
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;
};
```
Rufen Sie Bildsatz-Metadaten ohne Version ab.  

```
  try {
    await getImageSetMetadata(
      "metadata.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
Rufen Sie Bildsatz-Metadaten mit Version ab.  

```
  try {
    await getImageSetMetadata(
      "metadata2.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
      "1",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
+  Einzelheiten zur API finden Sie [GetImageSetMetadata](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetMetadataCommand)in der *AWS SDK für JavaScript API-Referenz*. 
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples) einrichten und ausführen. 

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

**SDK für Python (Boto3)**  
Hilfsfunktion zum Abrufen von Bildsatz-Metadaten.  

```
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
```
Rufen Sie Bildsatz-Metadaten ohne Version ab.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id, datastoreId=datastore_id
                )
```
Rufen Sie Bildsatz-Metadaten mit Version ab.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id,
                    datastoreId=datastore_id,
                    versionId=version_id,
                )
```
Der folgende Code instanziiert das MedicalImagingWrapper Objekt.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Einzelheiten zur API finden Sie [GetImageSetMetadata](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSetMetadata)in *AWS SDK for Python (Boto3) API* Reference. 
 Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples) einrichten und ausführen. 

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

**SDK für 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.
```
+  Einzelheiten zur API finden Sie [GetImageSetMetadata](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)in der *AWS API-Referenz zum SDK für SAP ABAP*. 
 Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples) einrichten und ausführen. 

------

**Beispiel für die Verfügbarkeit**  
Sie können nicht finden, was Sie brauchen? Fordern Sie über den Link **Feedback geben** in der rechten Seitenleiste dieser Seite ein Codebeispiel an.

**Syntax-Metadaten übertragen**  
 HealthImaging Behält beim Import von DICOM-Daten den ursprünglichen Wert für das Transfer-Syntaxattribut in den Metadaten des Bildsatzes bei. Die Übertragungssyntax der importierten ursprünglichen DICOM-Daten wird als gespeichert. `TransferSyntaxUID` HealthImaging verwendet`StoredTransferSyntaxUID`, um das Format anzugeben, das zur Kodierung von Bildrahmendaten im Datenspeicher verwendet wird: `1.2.840.10008.1.2.4.202` für HTJ2 K-fähige Datenspeicher (Standard) und `1.2.840.10008.1.2.4.90` für JPEG 2000-Datenspeicher mit Lossless-Unterstützung.