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.

# Zugreifen auf Bilddatensätze mit AWS HealthImaging
<a name="accessing-image-sets"></a>

Der Zugriff auf medizinische Bilddaten in AWS beinhaltet in HealthImaging der Regel die Suche nach einem [Bilddatensatz](getting-started-concepts.md#concept-image-set) mit einem eindeutigen Schlüssel und das Abrufen der zugehörigen [Metadaten](getting-started-concepts.md#concept-metadata) und [Bildrahmen](getting-started-concepts.md#concept-image-frame) (Pixeldaten).

**Wichtig**  
 HealthImaging Verarbeitet während des Imports die Binärdateien (`.dcm`Dateien) der DICOM-Instanz und wandelt sie in Bilddatensätze um. Verwenden Sie HealthImaging [Cloud-native Aktionen](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_Operations.html) (APIs), um Datenspeicher und Bilddatensätze zu verwalten. Verwenden Sie HealthImaging die [Darstellung von DICOMweb Diensten](dicomweb-retrieve.md), um DICOMweb Antworten zurückzugeben.

In den folgenden Themen wird erklärt, wie Sie HealthImaging Cloud-native Aktionen in den AWS-Managementkonsole, und verwenden AWS CLI, AWS SDKs um Bilddatensätze zu durchsuchen und die zugehörigen Eigenschaften, Metadaten und Bildrahmen abzurufen.

**Topics**
+ [Bilddatensätze verstehen](understanding-image-sets.md)
+ [Suche nach Bilddatensätzen](search-image-sets.md)
+ [Eigenschaften von Bilddatensätzen abrufen](get-image-set-properties.md)
+ [Metadaten von Bilddatensätzen abrufen](get-image-set-metadata.md)
+ [Pixeldaten des Bildsatzes abrufen](get-image-frame.md)

# Bilddatensätze verstehen
<a name="understanding-image-sets"></a>

Bilddatensätze ähneln einer AWS DICOM-Serie und dienen als Grundlage für AWS HealthImaging. Bilddatensätze werden erstellt, wenn Sie Ihre DICOM-Daten in importieren. HealthImaging Der Dienst versucht, importierte P10-Daten gemäß der DICOM-Hierarchie von Studie, Serie und Instanz zu organisieren.

Bilddatensätze wurden aus den folgenden Gründen eingeführt:
+  Support Sie flexibel APIs eine Vielzahl von Workflows für die medizinische Bildgebung (klinisch und nichtklinisch). 
+  Stellen Sie einen Mechanismus zur dauerhaften Speicherung und zum Abgleich doppelter und inkonsistenter Daten bereit. Importierte P10-Daten, die mit primären Bilddatensätzen, die sich bereits im A-Speicher befinden, in Konflikt geraten, werden als nicht primäre Daten gespeichert. Nach der Lösung von Metadatenkonflikten können diese Daten als primär eingestuft werden. 
+  Maximieren Sie die Patientensicherheit, indem Sie nur verwandte Daten gruppieren.
+  Ermutigen Sie dazu, Daten zu bereinigen, um Inkonsistenzen besser sichtbar zu machen. Weitere Informationen finden Sie unter [Ändern von Bilddatensätzen](modifying-image-sets.md). 
**Wichtig**  
Die klinische Verwendung von DICOM-Daten vor ihrer Bereinigung kann zu Schäden für den Patienten führen.

Die folgenden Menüs beschreiben Bilddatensätze ausführlicher und enthalten Beispiele und Diagramme, die Ihnen helfen, ihre Funktionalität und ihren Zweck in zu verstehen. HealthImaging

## Was ist ein Bildsatz?
<a name="what-is-image-set"></a>

Ein Bilddatensatz ist ein AWS Konzept, das einen abstrakten Gruppierungsmechanismus zur Optimierung verwandter medizinischer Bilddaten definiert, der einer DICOM-Serie sehr ähnlich ist. Wenn Sie Ihre DICOM P10-Bilddaten in einen HealthImaging AWS-Datenspeicher importieren, werden sie in Bildsätze umgewandelt, die aus [Metadaten](getting-started-concepts.md#concept-metadata) und [Bildrahmen](getting-started-concepts.md#concept-image-frame) (Pixeldaten) bestehen. 

**Anmerkung**  
[Die Metadaten des Bildsatzes sind normalisiert.](metadata-normalization.md) Mit anderen Worten, ein gemeinsamer Satz von Attributen und Werten wird Elementen auf Patienten-, Studien- und Serienebene zugeordnet, die im [Register der DICOM-Datenelemente](https://dicom.nema.org/medical/dicom/2022b/output/html/part06.html#table_6-1) aufgeführt sind. HealthImaging verwendet die folgenden DICOM-Elemente, wenn eingehende DICOM P10-Objekte zu Bilddatensätzen gruppiert werden.  


**DICOM-Elemente, die für die Erstellung von Bilddatensätzen verwendet werden**  
<a name="table-dicom-elements-image-set"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/healthimaging/latest/devguide/understanding-image-sets.html)
Während des Imports behalten einige Bilddatensätze ihre ursprüngliche Übertragungssyntaxkodierung bei, während andere standardmäßig in verlustfreies High-Throughput-JPEG 2000 (HTJ2K) transkodiert werden. Wenn ein Bilddatensatz in HTJ2 K codiert ist, muss er vor der Anzeige dekodiert werden. Weitere Informationen erhalten Sie unter [Unterstützte Übertragungssyntaxen](supported-transfer-syntaxes.md) und [Bibliotheken zur Dekodierung von Bildrahmen](reference-libraries.md).  
Bildframes (Pixeldaten) sind in JPEG 2000 (HTJ2K) mit hohem Durchsatz codiert und müssen vor der Anzeige [dekodiert](reference-libraries.md) werden.

Bilddatensätze sind AWS Ressourcen, daher werden ihnen [Amazon-Ressourcennamen (ARNs)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html) zugewiesen. Sie können mit bis zu 50 Schlüssel-Wert-Paaren gekennzeichnet werden und ihnen wird über IAM eine [rollenbasierte Zugriffskontrolle (RBAC) und eine [attributebasierte](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) Zugriffskontrolle (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) gewährt. Darüber hinaus werden Bilddatensätze [versioniert](list-image-set-versions.md), sodass alle Änderungen erhalten bleiben und auf frühere Versionen zugegriffen werden kann.

Der Import von DICOM P10-Daten führt zu Bilddatensätzen, die DICOM-Metadaten und Bildrahmen für eine oder mehrere SOP-Instanzen (Service Object Pair) in derselben DICOM-Serie enthalten.

![\[Diagramm, das zeigt, was ein Bildsatz in AWS ist HealthImaging.\]](http://docs.aws.amazon.com/de_de/healthimaging/latest/devguide/images/image-set-what-is.png)


**Anmerkung**  
DICOM-Importaufträge:  
Erstellen Sie immer neue Bildsätze oder erhöhen Sie die Version vorhandener Bildsätze.
Deduplizieren Sie den SOP-Instanzspeicher nicht. Bei jedem Import derselben SOP-Instanz wird zusätzlicher Speicherplatz als neuer, nicht primärer Imagesatz oder als inkrementierte Version eines vorhandenen primären Image-Sets verwendet.
Organisieren Sie SOP-Instanzen mit konsistenten, widersprüchlichen Metadaten automatisch als primäre Bilddatensätze, die Instanzen mit konsistenten Metadaten für Patienten, Studien und Serien enthalten.  
Wenn die Instanzen, aus denen eine DICOM-Serie besteht, in zwei oder mehr Importjobs importiert werden und die Instanzen nicht mit Instanzen kollidieren, die sich bereits im Datenspeicher befinden, werden alle Instanzen in einem primären Image-Set organisiert.
Erstellen Sie nicht primäre Bilddatensätze, die DICOM P10-Daten enthalten, die mit bereits im Datenspeicher vorhandenen primären Bilddatensätzen in Konflikt stehen.
Behalten Sie die zuletzt empfangenen Daten als neueste Version eines primären Bildsatzes bei.  
Wenn es sich bei den Instanzen, aus denen eine DICOM-Serie besteht, um primäre Bilddatensätze handelt und eine Instanz erneut importiert wird, wird die neue Kopie in den primären Imagesatz eingefügt, und die Version wird inkrementiert.

## Wie sehen Metadaten von Bilddatensätzen aus?
<a name="what-does-image-set-look-like"></a>

Verwenden Sie die `GetImageSetMetadata` Aktion, um Bildsatz-Metadaten abzurufen. Die zurückgegebenen Metadaten sind mit komprimiert`gzip`, sodass Sie sie vor der Anzeige entpacken müssen. Weitere Informationen finden Sie unter [Metadaten von Bilddatensätzen abrufen](get-image-set-metadata.md).

Das folgende Beispiel zeigt die Struktur von [Bilddatensatz-Metadaten](getting-started-concepts.md#concept-metadata) im JSON-Format.

```
{
	"SchemaVersion": "1.1",
	"DatastoreID": "2aa75d103f7f45ab977b0e93f00e6fe9",
	"ImageSetID": "46923b66d5522e4241615ecd64637584",
	"Patient": {
		"DICOM": {
			"PatientBirthDate": null,
			"PatientSex": null,
			"PatientID": "2178309",
			"PatientName": "MISTER^CT"
		}
	},
	"Study": {
		"DICOM": {
			"StudyTime": "083501",
			"PatientWeight": null
		},
		"Series": {
			"1.2.840.113619.2.30.1.1762295590.1623.978668949.887": {
				"DICOM": {
				    "Modality": "CT",
					"PatientPosition": "FFS"
				},
				"Instances": {
					"1.2.840.113619.2.30.1.1762295590.1623.978668949.888": {
						"DICOM": {
							"SourceApplicationEntityTitle": null,
							"SOPClassUID": "1.2.840.10008.5.1.4.1.1.2",
							"HighBit": 15,
							"PixelData": null,
							"Exposure": "40",
							"RescaleSlope": "1",
						"ImageFrames": [
							{
								"ID": "0d1c97c51b773198a3df44383a5fd306",
								"PixelDataChecksumFromBaseToFullResolution": [
									{
										"Width": 256,
										"Height": 188,
										"Checksum": 2598394845
									},
									{
										"Width": 512,
										"Height": 375,
										"Checksum": 1227709180
									}
								],
								"MinPixelValue": 451,
								"MaxPixelValue": 1466,
								"FrameSizeInBytes": 384000
							}
						]
					}
				}
			}
		}
	}
}
```

## Beispiel für die Erstellung eines Bildsatzes: mehrere Importaufträge
<a name="example-creation-multiple-import-jobs"></a>

Das folgende Beispiel zeigt, dass bei mehreren Importaufträgen immer neue Bilddatensätze erstellt und *niemals* zu bestehenden hinzugefügt werden.

![\[Das Diagramm zeigt, wie Importaufträge für mehrere Bilddatensätze in aussehen HealthImaging.\]](http://docs.aws.amazon.com/de_de/healthimaging/latest/devguide/images/image-set-example-multiple-import-jobs.png)


## Beispiel für die Erstellung von Bilddatensätzen: Einzelner Importauftrag mit zwei Varianten
<a name="example-creation-two-variants"></a>

Das folgende Beispiel zeigt einen einzelnen Importauftrag, der nicht zu einem einzigen Bilddatensatz zusammengeführt werden könnte, da die Instanzen 1 und 3 einen anderen Patient haben IDs als die Instanzen 2 und 4. Um dieses Problem zu lösen, können Sie die `UpdateImageSetMetadata` Aktion verwenden, um den Konflikt zwischen der Patienten-ID und dem vorhandenen primären Bilddatensatz zu lösen. Nachdem die Konflikte gelöst wurden, können Sie die `CopyImageSet` Aktion mit dem Argument verwenden, `--promoteToPrimary` um den Bilddatensatz zum primären Bilddatensatz hinzuzufügen.

![\[Diagramm, das zeigt, wie zwei Bildsatzvarianten aussehen, wenn ein einziger Importauftrag HealthImaging verwendet wird.\]](http://docs.aws.amazon.com/de_de/healthimaging/latest/devguide/images/image-set-example-import-two-variants.png)


## Beispiel für die Erstellung eines Bildsatzes: Einzelimportjob mit Optimierung
<a name="example-creation-optimization"></a>

Das folgende Beispiel zeigt einen einzelnen Importauftrag, bei dem zwei Bilddatensätze erstellt werden, um den Durchsatz zu verbessern, obwohl die Patientennamen übereinstimmen. 

![\[Das Diagramm zeigt, wie die Optimierung von Bilddatensätzen bei HealthImaging Verwendung eines einzigen Importauftrags aussieht.\]](http://docs.aws.amazon.com/de_de/healthimaging/latest/devguide/images/image-set-example-optimization.png)


# Suche nach Bilddatensätzen
<a name="search-image-sets"></a>

Verwenden Sie die `SearchImageSets` Aktion, um Suchanfragen für alle [Bildsätze](getting-started-concepts.md#concept-image-set) in einem `ACTIVE` HealthImaging Datenspeicher auszuführen. Die folgenden Menüs enthalten ein Verfahren 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_SearchImageSets.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html)in der * HealthImaging AWS-API-Referenz*.

**Anmerkung**  
Beachten Sie bei der Suche nach Bilddatensätzen die folgenden Punkte.  
`SearchImageSets`akzeptiert einen einzelnen Suchabfrageparameter und gibt eine paginierte Antwort aller Bilddatensätze zurück, die die entsprechenden Kriterien erfüllen. Alle Abfragen nach einem Zeitraum müssen als `(lowerBound, upperBound)` eingegeben werden.
`SearchImageSets`Verwendet das `updatedAt` Feld standardmäßig für die Sortierung in absteigender Reihenfolge vom neuesten zum ältesten.
Wenn Sie Ihren Datenspeicher mit einem kundeneigenen AWS KMS Schlüssel erstellt haben, müssen Sie Ihre AWS KMS Schlüsselrichtlinie aktualisieren, bevor Sie mit Bilddatensätzen interagieren können. Weitere Informationen finden Sie unter [Einen vom Kunden verwalteten Schlüssel erstellen](data-encryption.md#creating-co-cmk).

**So suchen Sie nach Bilddatensätzen**  
Wählen Sie ein Menü, das auf Ihren Zugriffspräferenzen für AWS basiert HealthImaging.

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

**Anmerkung**  
Die folgenden Verfahren zeigen, wie Bilddatensätze mithilfe der `Updated at` Eigenschaftsfilter `Series Instance UID` und durchsucht werden.

------
#### [ Series Instance UID ]

**Suchen Sie mit dem `Series Instance UID` Eigenschaftenfilter nach Bilddatensätzen**

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 das Eigenschaftenfiltermenü und wählen Sie`Series Instance UID`.

1. **Geben Sie im Feld Wert für Suche** eingeben die gewünschte Serien-Instance-UID ein (fügen Sie sie ein).
**Anmerkung**  
Die UID-Werte der Series Instance müssen mit den Werten identisch sein, die in der [Registry of DICOM Unique Identifiers](https://dicom.nema.org/dicom/2013/output/chtml/part06/chapter_A.html) () aufgeführt sind. UIDs Beachten Sie, dass die Anforderungen eine Reihe von Zahlen beinhalten, die mindestens einen Punkt dazwischen enthalten. Perioden sind zu Beginn oder am Ende einer Series Instance nicht zulässig UIDs. Buchstaben und Leerzeichen sind nicht zulässig. Seien Sie also vorsichtig beim Kopieren und Einfügen. UIDs

1. **Wählen Sie das Menü „**Datumsbereich**“, wählen Sie einen Zeitraum für die Series-Instance-UID und wählen Sie „Anwenden“.**

1. Wählen Sie **Search (Suchen)** aus.

   Serieninstanzen UIDs , die in den ausgewählten Datumsbereich fallen, werden standardmäßig in der neuesten Reihenfolge zurückgegeben.

------
#### [ Updated at ]

**Suchen Sie mithilfe des `Updated at` Eigenschaftenfilters nach Bilddatensätzen**

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 das Eigenschaftenfiltermenü und wählen Sie`Updated at`.

1. Wählen Sie das Menü „**Datumsbereich**“, wählen Sie einen Bilddatumsbereich aus und wählen Sie „**Anwenden**“.

1. Wählen Sie **Search (Suchen)** aus.

   Bilddatensätze, die in den ausgewählten Datumsbereich fallen, werden standardmäßig in der neuesten Reihenfolge zurückgegeben.

------

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

------
#### [ C\$1\$1 ]

**SDK für C\$1\$1**  
Die Hilfsfunktion für die Suche nach Bildsätzen.  

```
//! Routine which searches for image sets based on defined input attributes.
/*!
  \param dataStoreID: The HealthImaging data store ID.
  \param searchCriteria: A search criteria instance.
  \param imageSetResults: Vector to receive the image set IDs.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
  */
bool AwsDoc::Medical_Imaging::searchImageSets(const Aws::String &dataStoreID,
                                              const Aws::MedicalImaging::Model::SearchCriteria &searchCriteria,
                                              Aws::Vector<Aws::String> &imageSetResults,
                                              const Aws::Client::ClientConfiguration &clientConfig) {
    Aws::MedicalImaging::MedicalImagingClient client(clientConfig);
    Aws::MedicalImaging::Model::SearchImageSetsRequest request;
    request.SetDatastoreId(dataStoreID);
    request.SetSearchCriteria(searchCriteria);

    Aws::String nextToken; // Used for paginated results.
    bool result = true;
    do {
        if (!nextToken.empty()) {
            request.SetNextToken(nextToken);
        }

        Aws::MedicalImaging::Model::SearchImageSetsOutcome outcome = client.SearchImageSets(
                request);
        if (outcome.IsSuccess()) {
            for (auto &imageSetMetadataSummary: outcome.GetResult().GetImageSetsMetadataSummaries()) {
                imageSetResults.push_back(imageSetMetadataSummary.GetImageSetId());
            }

            nextToken = outcome.GetResult().GetNextToken();
        }
        else {
            std::cout << "Error: " << outcome.GetError().GetMessage() << std::endl;
            result = false;
        }
    } while (!nextToken.empty());

    return result;
}
```
Anwendungsfall 1: EQUAL-Operator.  

```
        Aws::Vector<Aws::String> imageIDsForPatientID;
        Aws::MedicalImaging::Model::SearchCriteria searchCriteriaEqualsPatientID;
        Aws::Vector<Aws::MedicalImaging::Model::SearchFilter> patientIDSearchFilters = {
                Aws::MedicalImaging::Model::SearchFilter().WithOperator(Aws::MedicalImaging::Model::Operator::EQUAL)
                .WithValues({Aws::MedicalImaging::Model::SearchByAttributeValue().WithDICOMPatientId(patientID)})
        };

        searchCriteriaEqualsPatientID.SetFilters(patientIDSearchFilters);
        bool result = AwsDoc::Medical_Imaging::searchImageSets(dataStoreID,
                                                               searchCriteriaEqualsPatientID,
                                                               imageIDsForPatientID,
                                                               clientConfig);
        if (result) {
            std::cout << imageIDsForPatientID.size() << " image sets found for the patient with ID '"
            <<  patientID << "'." << std::endl;
            for (auto &imageSetResult : imageIDsForPatientID) {
                std::cout << "  Image set with ID '" << imageSetResult << std::endl;
            }
        }
```
Anwendungsfall \$12: BETWEEN-Operator mit DICOMStudy Datum und DICOMStudy Uhrzeit.   

```
         Aws::MedicalImaging::Model::SearchByAttributeValue useCase2StartDate;
        useCase2StartDate.SetDICOMStudyDateAndTime(Aws::MedicalImaging::Model::DICOMStudyDateAndTime()
        .WithDICOMStudyDate("19990101")
        .WithDICOMStudyTime("000000.000"));

        Aws::MedicalImaging::Model::SearchByAttributeValue useCase2EndDate;
        useCase2EndDate.SetDICOMStudyDateAndTime(Aws::MedicalImaging::Model::DICOMStudyDateAndTime()
        .WithDICOMStudyDate(Aws::Utils::DateTime(std::chrono::system_clock::now()).ToLocalTimeString("%Y%m%d"))
        .WithDICOMStudyTime("000000.000"));

        Aws::MedicalImaging::Model::SearchFilter useCase2SearchFilter;
        useCase2SearchFilter.SetValues({useCase2StartDate, useCase2EndDate});
        useCase2SearchFilter.SetOperator(Aws::MedicalImaging::Model::Operator::BETWEEN);

        Aws::MedicalImaging::Model::SearchCriteria useCase2SearchCriteria;
        useCase2SearchCriteria.SetFilters({useCase2SearchFilter});

        Aws::Vector<Aws::String> usesCase2Results;
        result = AwsDoc::Medical_Imaging::searchImageSets(dataStoreID,
                                                          useCase2SearchCriteria,
                                                          usesCase2Results,
                                                          clientConfig);
        if (result) {
            std::cout << usesCase2Results.size() << " image sets found for between 1999/01/01 and present."
                      <<  std::endl;
            for (auto &imageSetResult : usesCase2Results) {
                std::cout << "  Image set with ID '" << imageSetResult << std::endl;
            }
        }
```
Anwendungsfall 3: BETWEEN-Operator mit createdAt. Zeitstudien wurden bisher fortgeführt.   

```
        Aws::MedicalImaging::Model::SearchByAttributeValue useCase3StartDate;
        useCase3StartDate.SetCreatedAt(Aws::Utils::DateTime("20231130T000000000Z",Aws::Utils::DateFormat::ISO_8601_BASIC));

        Aws::MedicalImaging::Model::SearchByAttributeValue useCase3EndDate;
        useCase3EndDate.SetCreatedAt(Aws::Utils::DateTime(std::chrono::system_clock::now()));

        Aws::MedicalImaging::Model::SearchFilter useCase3SearchFilter;
        useCase3SearchFilter.SetValues({useCase3StartDate, useCase3EndDate});
        useCase3SearchFilter.SetOperator(Aws::MedicalImaging::Model::Operator::BETWEEN);

        Aws::MedicalImaging::Model::SearchCriteria useCase3SearchCriteria;
        useCase3SearchCriteria.SetFilters({useCase3SearchFilter});

        Aws::Vector<Aws::String> usesCase3Results;
        result = AwsDoc::Medical_Imaging::searchImageSets(dataStoreID,
                                                          useCase3SearchCriteria,
                                                          usesCase3Results,
                                                          clientConfig);
        if (result) {
            std::cout << usesCase3Results.size() << " image sets found for created between 2023/11/30 and present."
                      <<  std::endl;
            for (auto &imageSetResult : usesCase3Results) {
                std::cout << "  Image set with ID '" << imageSetResult << std::endl;
            }
        }
```
Anwendungsfall \$14: EQUAL-Operator für DICOMSeries instanceUID und BETWEEN für updatedAt und sortiere die Antwort in ASC-Reihenfolge für das Feld updatedAt.   

```
        Aws::MedicalImaging::Model::SearchByAttributeValue useCase4StartDate;
        useCase4StartDate.SetUpdatedAt(Aws::Utils::DateTime("20231130T000000000Z",Aws::Utils::DateFormat::ISO_8601_BASIC));

        Aws::MedicalImaging::Model::SearchByAttributeValue useCase4EndDate;
        useCase4EndDate.SetUpdatedAt(Aws::Utils::DateTime(std::chrono::system_clock::now()));

        Aws::MedicalImaging::Model::SearchFilter useCase4SearchFilterBetween;
        useCase4SearchFilterBetween.SetValues({useCase4StartDate, useCase4EndDate});
        useCase4SearchFilterBetween.SetOperator(Aws::MedicalImaging::Model::Operator::BETWEEN);

        Aws::MedicalImaging::Model::SearchByAttributeValue seriesInstanceUID;
        seriesInstanceUID.SetDICOMSeriesInstanceUID(dicomSeriesInstanceUID);

        Aws::MedicalImaging::Model::SearchFilter useCase4SearchFilterEqual;
        useCase4SearchFilterEqual.SetValues({seriesInstanceUID});
        useCase4SearchFilterEqual.SetOperator(Aws::MedicalImaging::Model::Operator::EQUAL);

        Aws::MedicalImaging::Model::SearchCriteria useCase4SearchCriteria;
        useCase4SearchCriteria.SetFilters({useCase4SearchFilterBetween, useCase4SearchFilterEqual});

        Aws::MedicalImaging::Model::Sort useCase4Sort;
        useCase4Sort.SetSortField(Aws::MedicalImaging::Model::SortField::updatedAt);
        useCase4Sort.SetSortOrder(Aws::MedicalImaging::Model::SortOrder::ASC);

        useCase4SearchCriteria.SetSort(useCase4Sort);

        Aws::Vector<Aws::String> usesCase4Results;
        result = AwsDoc::Medical_Imaging::searchImageSets(dataStoreID,
                                                          useCase4SearchCriteria,
                                                          usesCase4Results,
                                                          clientConfig);
        if (result) {
            std::cout << usesCase4Results.size() << " image sets found for EQUAL operator "
            << "on DICOMSeriesInstanceUID and BETWEEN on updatedAt and sort response\n"
            <<  "in ASC order on updatedAt field." <<  std::endl;
            for (auto &imageSetResult : usesCase4Results) {
                std::cout << "  Image set with ID '" << imageSetResult << std::endl;
            }
        }
```
+  *Einzelheiten zur API finden Sie in der API-Referenz. [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/SearchImageSets)AWS SDK für C\$1\$1 * 
 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 suchen Sie nach Bilddatensätzen mit einem EQUAL-Operator**  
Im folgenden Codebeispiel für `search-image-sets` wird der EQUAL-Operator verwendet, um Bildsätze auf der Grundlage eines bestimmten Werts zu durchsuchen.  

```
aws medical-imaging search-image-sets \
    --datastore-id 12345678901234567890123456789012 \
    --search-criteria file://search-criteria.json
```
Inhalt von `search-criteria.json`  

```
{
    "filters": [{
        "values": [{"DICOMPatientId" : "SUBJECT08701"}],
        "operator": "EQUAL"
    }]
}
```
Ausgabe:  

```
{
    "imageSetsMetadataSummaries": [{
        "imageSetId": "09876543210987654321098765432109",
        "createdAt": "2022-12-06T21:40:59.429000+00:00",
        "version": 1,
        "DICOMTags": {
            "DICOMStudyId": "2011201407",
            "DICOMStudyDate": "19991122",
             "DICOMPatientSex": "F",
             "DICOMStudyInstanceUID": "1.2.840.99999999.84710745.943275268089",
             "DICOMPatientBirthDate": "19201120",
             "DICOMStudyDescription": "UNKNOWN",
             "DICOMPatientId": "SUBJECT08701",
             "DICOMPatientName": "Melissa844 Huel628",
             "DICOMNumberOfStudyRelatedInstances": 1,
             "DICOMStudyTime": "140728",
             "DICOMNumberOfStudyRelatedSeries": 1
            },
        "updatedAt": "2022-12-06T21:40:59.429000+00:00"
    }]
}
```
**Beispiel 2: Um Bilddatensätze mit einem BETWEEN-Operator unter Verwendung von DICOMStudy Datum und DICOMStudy Uhrzeit zu durchsuchen**  
Im folgenden Codebeispiel für `search-image-sets` wird nach Bildsätzen mit DICOM-Studien gesucht, die zwischen dem 1. Januar 1990 (12:00 Uhr) und dem 1. Januar 2023 (12:00 Uhr) generiert wurden.  
Hinweis: Die DICOMStudy Uhrzeit ist optional. Wenn der Parameter nicht vorhanden ist, ist 12:00 Uhr (Beginn des Tages) der Zeitwert für die Datumsangaben, die für die Filterung bereitgestellt werden.  

```
aws medical-imaging search-image-sets \
    --datastore-id 12345678901234567890123456789012 \
    --search-criteria file://search-criteria.json
```
Inhalt von `search-criteria.json`  

```
{
    "filters": [{
        "values": [{
            "DICOMStudyDateAndTime": {
                "DICOMStudyDate": "19900101",
                "DICOMStudyTime": "000000"
            }
        },
        {
            "DICOMStudyDateAndTime": {
                "DICOMStudyDate": "20230101",
                "DICOMStudyTime": "000000"
            }
        }],
        "operator": "BETWEEN"
    }]
}
```
Ausgabe:  

```
{
    "imageSetsMetadataSummaries": [{
        "imageSetId": "09876543210987654321098765432109",
        "createdAt": "2022-12-06T21:40:59.429000+00:00",
        "version": 1,
        "DICOMTags": {
            "DICOMStudyId": "2011201407",
            "DICOMStudyDate": "19991122",
            "DICOMPatientSex": "F",
            "DICOMStudyInstanceUID": "1.2.840.99999999.84710745.943275268089",
            "DICOMPatientBirthDate": "19201120",
            "DICOMStudyDescription": "UNKNOWN",
            "DICOMPatientId": "SUBJECT08701",
            "DICOMPatientName": "Melissa844 Huel628",
            "DICOMNumberOfStudyRelatedInstances": 1,
            "DICOMStudyTime": "140728",
            "DICOMNumberOfStudyRelatedSeries": 1
        },
        "updatedAt": "2022-12-06T21:40:59.429000+00:00"
    }]
}
```
**Beispiel 3: So suchen Sie Bildsätze mit einem BETWEEN-Operator mithilfe von createdAt (Zeitstudien wurden bisher fortgeführt)**  
Im folgenden `search-image-sets` Codebeispiel wird nach Bilddatensätzen gesucht, bei denen DICOM-Studien HealthImaging zwischen den Zeitbereichen in der UTC-Zeitzone persistiert wurden.  
Hinweis: Geben Sie „createdAt“ in dem im Beispiel aufgeführten Format an („1985-04-12T23:20:50.52Z“).  

```
aws medical-imaging search-image-sets \
    --datastore-id 12345678901234567890123456789012 \
    --search-criteria  file://search-criteria.json
```
Inhalt von `search-criteria.json`  

```
{
    "filters": [{
        "values": [{
            "createdAt": "1985-04-12T23:20:50.52Z"
        },
        {
            "createdAt": "2022-04-12T23:20:50.52Z"
        }],
        "operator": "BETWEEN"
    }]
}
```
Ausgabe:  

```
{
    "imageSetsMetadataSummaries": [{
        "imageSetId": "09876543210987654321098765432109",
        "createdAt": "2022-12-06T21:40:59.429000+00:00",
        "version": 1,
        "DICOMTags": {
            "DICOMStudyId": "2011201407",
            "DICOMStudyDate": "19991122",
            "DICOMPatientSex": "F",
            "DICOMStudyInstanceUID": "1.2.840.99999999.84710745.943275268089",
            "DICOMPatientBirthDate": "19201120",
            "DICOMStudyDescription": "UNKNOWN",
            "DICOMPatientId": "SUBJECT08701",
            "DICOMPatientName": "Melissa844 Huel628",
            "DICOMNumberOfStudyRelatedInstances": 1,
            "DICOMStudyTime": "140728",
            "DICOMNumberOfStudyRelatedSeries": 1
        },
        "lastUpdatedAt": "2022-12-06T21:40:59.429000+00:00"
    }]
}
```
**Beispiel 4: Um Bilddatensätze mit einem EQUAL-Operator für DICOMSeries instanceUID und BETWEEN für updatedAt zu durchsuchen und die Antwort in ASC-Reihenfolge im Feld updatedAt zu sortieren**  
Das folgende `search-image-sets` Codebeispiel sucht nach Bilddatensätzen mit einem EQUAL-Operator für DICOMSeries instanceUID und BETWEEN für updatedAt und sortiert die Antwort in ASC-Reihenfolge im Feld updatedAt.  
Hinweis: Geben Sie „updatedAt“ in dem im Beispiel aufgeführten Format an („1985-04-12T23:20:50.52Z“).  

```
aws medical-imaging search-image-sets \
    --datastore-id 12345678901234567890123456789012 \
    --search-criteria  file://search-criteria.json
```
Inhalt von `search-criteria.json`  

```
{
    "filters": [{
        "values": [{
            "updatedAt": "2024-03-11T15:00:05.074000-07:00"
        }, {
            "updatedAt": "2024-03-11T16:00:05.074000-07:00"
        }],
        "operator": "BETWEEN"
    }, {
        "values": [{
            "DICOMSeriesInstanceUID": "1.2.840.99999999.84710745.943275268089"
        }],
        "operator": "EQUAL"
    }],
    "sort": {
        "sortField": "updatedAt",
        "sortOrder": "ASC"
    }
}
```
Ausgabe:  

```
{
    "imageSetsMetadataSummaries": [{
        "imageSetId": "09876543210987654321098765432109",
        "createdAt": "2022-12-06T21:40:59.429000+00:00",
        "version": 1,
        "DICOMTags": {
            "DICOMStudyId": "2011201407",
            "DICOMStudyDate": "19991122",
            "DICOMPatientSex": "F",
            "DICOMStudyInstanceUID": "1.2.840.99999999.84710745.943275268089",
            "DICOMPatientBirthDate": "19201120",
            "DICOMStudyDescription": "UNKNOWN",
            "DICOMPatientId": "SUBJECT08701",
            "DICOMPatientName": "Melissa844 Huel628",
            "DICOMNumberOfStudyRelatedInstances": 1,
            "DICOMStudyTime": "140728",
            "DICOMNumberOfStudyRelatedSeries": 1
        },
        "lastUpdatedAt": "2022-12-06T21:40:59.429000+00:00"
    }]
}
```
[https://docs.aws.amazon.com/healthimaging/latest/devguide/search-image-sets.html](https://docs.aws.amazon.com/healthimaging/latest/devguide/search-image-sets.html)  
+  Einzelheiten zur API finden Sie [SearchImageSets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/search-image-sets.html)in der *AWS CLI Befehlsreferenz*. 

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

**SDK für Java 2.x**  
Die Hilfsfunktion für die Suche nach Bildsätzen.  

```
    public static List<ImageSetsMetadataSummary> searchMedicalImagingImageSets(
            MedicalImagingClient medicalImagingClient,
            String datastoreId, SearchCriteria searchCriteria) {
        try {
            SearchImageSetsRequest datastoreRequest = SearchImageSetsRequest.builder()
                    .datastoreId(datastoreId)
                    .searchCriteria(searchCriteria)
                    .build();
            SearchImageSetsIterable responses = medicalImagingClient
                    .searchImageSetsPaginator(datastoreRequest);
            List<ImageSetsMetadataSummary> imageSetsMetadataSummaries = new ArrayList<>();

            responses.stream().forEach(response -> imageSetsMetadataSummaries
                    .addAll(response.imageSetsMetadataSummaries()));

            return imageSetsMetadataSummaries;
        } catch (MedicalImagingException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }

        return null;
    }
```
Anwendungsfall 1: EQUAL-Operator.  

```
        List<SearchFilter> searchFilters = Collections.singletonList(SearchFilter.builder()
                .operator(Operator.EQUAL)
                .values(SearchByAttributeValue.builder()
                        .dicomPatientId(patientId)
                        .build())
                .build());

        SearchCriteria searchCriteria = SearchCriteria.builder()
                .filters(searchFilters)
                .build();

        List<ImageSetsMetadataSummary> imageSetsMetadataSummaries = searchMedicalImagingImageSets(
                medicalImagingClient,
                datastoreId, searchCriteria);
        if (imageSetsMetadataSummaries != null) {
            System.out.println("The image sets for patient " + patientId + " are:\n"
                    + imageSetsMetadataSummaries);
            System.out.println();
        }
```
Anwendungsfall \$12: BETWEEN-Operator mit DICOMStudy Datum und DICOMStudy Uhrzeit.   

```
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        searchFilters = Collections.singletonList(SearchFilter.builder()
                .operator(Operator.BETWEEN)
                .values(SearchByAttributeValue.builder()
                                .dicomStudyDateAndTime(DICOMStudyDateAndTime.builder()
                                        .dicomStudyDate("19990101")
                                        .dicomStudyTime("000000.000")
                                        .build())
                                .build(),
                        SearchByAttributeValue.builder()
                                .dicomStudyDateAndTime(DICOMStudyDateAndTime.builder()
                                        .dicomStudyDate((LocalDate.now()
                                                .format(formatter)))
                                        .dicomStudyTime("000000.000")
                                        .build())
                                .build())
                .build());

        searchCriteria = SearchCriteria.builder()
                .filters(searchFilters)
                .build();

        imageSetsMetadataSummaries = searchMedicalImagingImageSets(medicalImagingClient,
                datastoreId, searchCriteria);
        if (imageSetsMetadataSummaries != null) {
            System.out.println(
                    "The image sets searched with BETWEEN operator using DICOMStudyDate and DICOMStudyTime are:\n"
                            +
                            imageSetsMetadataSummaries);
            System.out.println();
        }
```
Anwendungsfall 3: BETWEEN-Operator mit createdAt. Zeitstudien wurden bisher fortgeführt.   

```
        searchFilters = Collections.singletonList(SearchFilter.builder()
                .operator(Operator.BETWEEN)
                .values(SearchByAttributeValue.builder()
                                .createdAt(Instant.parse("1985-04-12T23:20:50.52Z"))
                                .build(),
                        SearchByAttributeValue.builder()
                                .createdAt(Instant.now())
                                .build())
                .build());

        searchCriteria = SearchCriteria.builder()
                .filters(searchFilters)
                .build();
        imageSetsMetadataSummaries = searchMedicalImagingImageSets(medicalImagingClient,
                datastoreId, searchCriteria);
        if (imageSetsMetadataSummaries != null) {
            System.out.println("The image sets searched with BETWEEN operator using createdAt are:\n "
                    + imageSetsMetadataSummaries);
            System.out.println();
        }
```
Anwendungsfall \$14: EQUAL-Operator für DICOMSeries instanceUID und BETWEEN für updatedAt und sortiere die Antwort in ASC-Reihenfolge für das Feld updatedAt.   

```
        Instant startDate = Instant.parse("1985-04-12T23:20:50.52Z");
        Instant endDate = Instant.now();

        searchFilters = Arrays.asList(
                SearchFilter.builder()
                        .operator(Operator.EQUAL)
                        .values(SearchByAttributeValue.builder()
                                .dicomSeriesInstanceUID(seriesInstanceUID)
                                .build())
                        .build(),
                SearchFilter.builder()
                        .operator(Operator.BETWEEN)
                        .values(
                                SearchByAttributeValue.builder().updatedAt(startDate).build(),
                                SearchByAttributeValue.builder().updatedAt(endDate).build()
                        ).build());

        Sort sort = Sort.builder().sortOrder(SortOrder.ASC).sortField(SortField.UPDATED_AT).build();

        searchCriteria = SearchCriteria.builder()
                .filters(searchFilters)
                .sort(sort)
                .build();

        imageSetsMetadataSummaries = searchMedicalImagingImageSets(medicalImagingClient,
                datastoreId, searchCriteria);
        if (imageSetsMetadataSummaries != null) {
            System.out.println("The image sets searched with EQUAL operator on DICOMSeriesInstanceUID and BETWEEN on updatedAt and sort response\n" +
                    "in ASC order on updatedAt field are:\n "
                    + imageSetsMetadataSummaries);
            System.out.println();
        }
```
+  *Einzelheiten zur API finden Sie in der API-Referenz. [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/SearchImageSets)AWS SDK for Java 2.x * 
 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)**  
Die Hilfsfunktion für die Suche nach Bildsätzen.  

```
import { paginateSearchImageSets } from "@aws-sdk/client-medical-imaging";
import { medicalImagingClient } from "../libs/medicalImagingClient.js";

/**
 * @param {string} datastoreId - The data store's ID.
 * @param { import('@aws-sdk/client-medical-imaging').SearchFilter[] } filters - The search criteria filters.
 * @param { import('@aws-sdk/client-medical-imaging').Sort } sort - The search criteria sort.
 */
export const searchImageSets = async (
  datastoreId = "xxxxxxxx",
  searchCriteria = {},
) => {
  const paginatorConfig = {
    client: medicalImagingClient,
    pageSize: 50,
  };

  const commandParams = {
    datastoreId: datastoreId,
    searchCriteria: searchCriteria,
  };

  const paginator = paginateSearchImageSets(paginatorConfig, commandParams);

  const imageSetsMetadataSummaries = [];
  for await (const page of paginator) {
    // Each page contains a list of `jobSummaries`. The list is truncated if is larger than `pageSize`.
    imageSetsMetadataSummaries.push(...page.imageSetsMetadataSummaries);
    console.log(page);
  }
  // {
  //     '$metadata': {
  //         httpStatusCode: 200,
  //         requestId: 'f009ea9c-84ca-4749-b5b6-7164f00a5ada',
  //         extendedRequestId: undefined,
  //         cfId: undefined,
  //         attempts: 1,
  //         totalRetryDelay: 0
  //     },
  //     imageSetsMetadataSummaries: [
  //         {
  //             DICOMTags: [Object],
  //             createdAt: "2023-09-19T16:59:40.551Z",
  //             imageSetId: '7f75e1b5c0f40eac2b24cf712f485f50',
  //             updatedAt: "2023-09-19T16:59:40.551Z",
  //             version: 1
  //         }]
  // }

  return imageSetsMetadataSummaries;
};
```
Anwendungsfall 1: EQUAL-Operator.  

```
  const datastoreId = "12345678901234567890123456789012";

  try {
    const searchCriteria = {
      filters: [
        {
          values: [{ DICOMPatientId: "1234567" }],
          operator: "EQUAL",
        },
      ],
    };

    await searchImageSets(datastoreId, searchCriteria);
  } catch (err) {
    console.error(err);
  }
```
Anwendungsfall \$12: BETWEEN-Operator mit DICOMStudy Datum und DICOMStudy Uhrzeit.   

```
  const datastoreId = "12345678901234567890123456789012";

  try {
    const searchCriteria = {
      filters: [
        {
          values: [
            {
              DICOMStudyDateAndTime: {
                DICOMStudyDate: "19900101",
                DICOMStudyTime: "000000",
              },
            },
            {
              DICOMStudyDateAndTime: {
                DICOMStudyDate: "20230901",
                DICOMStudyTime: "000000",
              },
            },
          ],
          operator: "BETWEEN",
        },
      ],
    };

    await searchImageSets(datastoreId, searchCriteria);
  } catch (err) {
    console.error(err);
  }
```
Anwendungsfall 3: BETWEEN-Operator mit createdAt. Zeitstudien wurden bisher fortgeführt.   

```
  const datastoreId = "12345678901234567890123456789012";

  try {
    const searchCriteria = {
      filters: [
        {
          values: [
            { createdAt: new Date("1985-04-12T23:20:50.52Z") },
            { createdAt: new Date() },
          ],
          operator: "BETWEEN",
        },
      ],
    };

    await searchImageSets(datastoreId, searchCriteria);
  } catch (err) {
    console.error(err);
  }
```
Anwendungsfall \$14: EQUAL-Operator für DICOMSeries instanceUID und BETWEEN für updatedAt und sortiere die Antwort in ASC-Reihenfolge für das Feld updatedAt.   

```
  const datastoreId = "12345678901234567890123456789012";

  try {
    const searchCriteria = {
      filters: [
        {
          values: [
            { updatedAt: new Date("1985-04-12T23:20:50.52Z") },
            { updatedAt: new Date() },
          ],
          operator: "BETWEEN",
        },
        {
          values: [
            {
              DICOMSeriesInstanceUID:
                "1.1.123.123456.1.12.1.1234567890.1234.12345678.123",
            },
          ],
          operator: "EQUAL",
        },
      ],
      sort: {
        sortOrder: "ASC",
        sortField: "updatedAt",
      },
    };

    await searchImageSets(datastoreId, searchCriteria);
  } catch (err) {
    console.error(err);
  }
```
+  *Einzelheiten zur API finden Sie in der API-Referenz. [SearchImageSets](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/SearchImageSetsCommand)AWS SDK für JavaScript * 
 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)**  
Die Hilfsfunktion für die Suche nach Bildsätzen.  

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


    def search_image_sets(self, datastore_id, search_filter):
        """
        Search for image sets.

        :param datastore_id: The ID of the data store.
        :param search_filter: The search filter.
            For example: {"filters" : [{ "operator": "EQUAL", "values": [{"DICOMPatientId": "3524578"}]}]}.
        :return: The list of image sets.
        """
        try:
            paginator = self.health_imaging_client.get_paginator("search_image_sets")
            page_iterator = paginator.paginate(
                datastoreId=datastore_id, searchCriteria=search_filter
            )
            metadata_summaries = []
            for page in page_iterator:
                metadata_summaries.extend(page["imageSetsMetadataSummaries"])
        except ClientError as err:
            logger.error(
                "Couldn't search image sets. Here's why: %s: %s",
                err.response["Error"]["Code"],
                err.response["Error"]["Message"],
            )
            raise
        else:
            return metadata_summaries
```
Anwendungsfall 1: EQUAL-Operator.  

```
        search_filter = {
            "filters": [
                {"operator": "EQUAL", "values": [{"DICOMPatientId": patient_id}]}
            ]
        }

        image_sets = self.search_image_sets(data_store_id, search_filter)
        print(f"Image sets found with EQUAL operator\n{image_sets}")
```
Anwendungsfall \$12: BETWEEN-Operator mit DICOMStudy Datum und DICOMStudy Uhrzeit.   

```
        search_filter = {
            "filters": [
                {
                    "operator": "BETWEEN",
                    "values": [
                        {
                            "DICOMStudyDateAndTime": {
                                "DICOMStudyDate": "19900101",
                                "DICOMStudyTime": "000000",
                            }
                        },
                        {
                            "DICOMStudyDateAndTime": {
                                "DICOMStudyDate": "20230101",
                                "DICOMStudyTime": "000000",
                            }
                        },
                    ],
                }
            ]
        }

        image_sets = self.search_image_sets(data_store_id, search_filter)
        print(
            f"Image sets found with BETWEEN operator using DICOMStudyDate and DICOMStudyTime\n{image_sets}"
        )
```
Anwendungsfall 3: BETWEEN-Operator mit createdAt. Zeitstudien wurden bisher fortgeführt.   

```
        search_filter = {
            "filters": [
                {
                    "values": [
                        {
                            "createdAt": datetime.datetime(
                                2021, 8, 4, 14, 49, 54, 429000
                            )
                        },
                        {
                            "createdAt": datetime.datetime.now()
                            + datetime.timedelta(days=1)
                        },
                    ],
                    "operator": "BETWEEN",
                }
            ]
        }

        recent_image_sets = self.search_image_sets(data_store_id, search_filter)
        print(
            f"Image sets found with with BETWEEN operator using createdAt\n{recent_image_sets}"
        )
```
Anwendungsfall \$14: EQUAL-Operator für DICOMSeries instanceUID und BETWEEN für updatedAt und sortiere die Antwort in ASC-Reihenfolge für das Feld updatedAt.   

```
        search_filter = {
            "filters": [
                {
                    "values": [
                        {
                            "updatedAt": datetime.datetime(
                                2021, 8, 4, 14, 49, 54, 429000
                            )
                        },
                        {
                            "updatedAt": datetime.datetime.now()
                            + datetime.timedelta(days=1)
                        },
                    ],
                    "operator": "BETWEEN",
                },
                {
                    "values": [{"DICOMSeriesInstanceUID": series_instance_uid}],
                    "operator": "EQUAL",
                },
            ],
            "sort": {
                "sortOrder": "ASC",
                "sortField": "updatedAt",
            },
        }

        image_sets = self.search_image_sets(data_store_id, search_filter)
        print(
            "Image sets found with EQUAL operator on DICOMSeriesInstanceUID and BETWEEN on updatedAt and"
        )
        print(f"sort response in ASC order on updatedAt field\n{image_sets}")
```
 MedicalImagingWrapper Der folgende Code instanziiert das Objekt.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Einzelheiten zur API finden Sie [SearchImageSets](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/SearchImageSets)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'
        oo_result = lo_mig->searchimagesets(
          iv_datastoreid = iv_datastore_id
          io_searchcriteria = io_search_criteria ).
        DATA(lt_imagesets) = oo_result->get_imagesetsmetadatasums( ).
        DATA(lv_count) = lines( lt_imagesets ).
        MESSAGE |Found { lv_count } image sets.| 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 'Resource 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 [SearchImageSets](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.

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

Verwenden Sie die `GetImageSet` Aktion, um Eigenschaften für einen bestimmten [Bildsatz](getting-started-concepts.md#concept-image-set) in zurückzugeben 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_GetImageSet.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSet.html)in der * HealthImaging AWS-API-Referenz*.

**Anmerkung**  
Standardmäßig HealthImaging gibt AWS Eigenschaften für die neueste Version eines Bildsatzes zurück. Wenn Sie Eigenschaften für eine ältere Version eines Image-Sets anzeigen möchten, stellen Sie `versionId` dies Ihrer Anfrage bei.  
Verwenden Sie `GetDICOMInstance` HealthImaging die Darstellung eines DICOMweb Dienstes, um eine `.dcm` DICOM-Instanz-Binärdatei (Datei) zurückzugeben. Weitere Informationen finden Sie unter [Abrufen einer DICOM-Instanz von HealthImaging](dicomweb-retrieve-instance.md).

**So rufen Sie Bildsatzeigenschaften ab**  
Wählen Sie ein Menü, das auf Ihren Zugriffspräferenzen für AWS basiert HealthImaging.

## AWS Konsole
<a name="code-example-console-image-set-properties"></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 zeigt die Eigenschaften des Bildsatzes an.

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

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

**AWS CLI**  
**So rufen Sie Bildsatzeigenschaften ab**  
Im folgenden Codebeispiel für `get-image-set` werden die Eigenschaften für einen Bildsatz abgerufen.  

```
aws medical-imaging get-image-set \
    --datastore-id 12345678901234567890123456789012 \
    --image-set-id 18f88ac7870584f58d56256646b4d92b \
    --version-id 1
```
Ausgabe:  

```
{
    "versionId": "1",
    "imageSetWorkflowStatus": "COPIED",
    "updatedAt": 1680027253.471,
    "imageSetId": "18f88ac7870584f58d56256646b4d92b",
    "imageSetState": "ACTIVE",
    "createdAt": 1679592510.753,
    "datastoreId": "12345678901234567890123456789012"
}
```
Weitere Informationen finden Sie im *AWS HealthImaging Entwicklerhandbuch* unter [Abrufen von Bilddatensatz-Eigenschaften](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-properties.html).  
+  Einzelheiten zur API finden Sie [GetImageSet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set.html)in der *AWS CLI Befehlsreferenz*. 

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

**SDK für Java 2.x**  

```
    public static GetImageSetResponse getMedicalImageSet(MedicalImagingClient medicalImagingClient,
            String datastoreId,
            String imagesetId,
            String versionId) {
        try {
            GetImageSetRequest.Builder getImageSetRequestBuilder = GetImageSetRequest.builder()
                    .datastoreId(datastoreId)
                    .imageSetId(imagesetId);

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

            return medicalImagingClient.getImageSet(getImageSetRequestBuilder.build());
        } catch (MedicalImagingException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }

        return null;
    }
```
+  Einzelheiten zur API finden Sie [GetImageSet](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSet)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)**  

```
import { GetImageSetCommand } from "@aws-sdk/client-medical-imaging";
import { medicalImagingClient } from "../libs/medicalImagingClient.js";

/**
 * @param {string} datastoreId - The ID of the data store.
 * @param {string} imageSetId - The ID of the image set.
 * @param {string} imageSetVersion - The optional version of the image set.
 *
 */
export const getImageSet = async (
  datastoreId = "xxxxxxxxxxxxxxx",
  imageSetId = "xxxxxxxxxxxxxxx",
  imageSetVersion = "",
) => {
  const params = { datastoreId: datastoreId, imageSetId: imageSetId };
  if (imageSetVersion !== "") {
    params.imageSetVersion = imageSetVersion;
  }
  const response = await medicalImagingClient.send(
    new GetImageSetCommand(params),
  );
  console.log(response);
  // {
  //     '$metadata': {
  //     httpStatusCode: 200,
  //         requestId: '0615c161-410d-4d06-9d8c-6e1241bb0a5a',
  //         extendedRequestId: undefined,
  //         cfId: undefined,
  //         attempts: 1,
  //         totalRetryDelay: 0
  // },
  //     createdAt: 2023-09-22T14:49:26.427Z,
  //     datastoreId: 'xxxxxxxxxxxxxxx',
  //     imageSetArn: 'arn:aws:medical-imaging:us-east-1:xxxxxxxxxx:datastore/xxxxxxxxxxxxxxxxxxxx/imageset/xxxxxxxxxxxxxxxxxxxx',
  //     imageSetId: 'xxxxxxxxxxxxxxx',
  //     imageSetState: 'ACTIVE',
  //     imageSetWorkflowStatus: 'CREATED',
  //     updatedAt: 2023-09-22T14:49:26.427Z,
  //     versionId: '1'
  // }

  return response;
};
```
+  Einzelheiten zur API finden Sie [GetImageSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetCommand)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)**  

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


    def get_image_set(self, datastore_id, image_set_id, version_id=None):
        """
        Get the properties of an image set.

        :param datastore_id: The ID of the data store.
        :param image_set_id: The ID of the image set.
        :param version_id: The optional version of the image set.
        :return: The image set properties.
        """
        try:
            if version_id:
                image_set = self.health_imaging_client.get_image_set(
                    imageSetId=image_set_id,
                    datastoreId=datastore_id,
                    versionId=version_id,
                )
            else:
                image_set = self.health_imaging_client.get_image_set(
                    imageSetId=image_set_id, datastoreId=datastore_id
                )
        except ClientError as err:
            logger.error(
                "Couldn't get image set. Here's why: %s: %s",
                err.response["Error"]["Code"],
                err.response["Error"]["Message"],
            )
            raise
        else:
            return image_set
```
Der folgende Code instanziiert das MedicalImagingWrapper Objekt.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Einzelheiten zur API finden Sie [GetImageSet](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSet)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->getimageset(
            iv_datastoreid = iv_datastore_id
            iv_imagesetid = iv_image_set_id
            iv_versionid = iv_version_id ).
        ELSE.
          oo_result = lo_mig->getimageset(
            iv_datastoreid = iv_datastore_id
            iv_imagesetid = iv_image_set_id ).
        ENDIF.
        DATA(lv_state) = oo_result->get_imagesetstate( ).
        MESSAGE |Image set retrieved with state: { lv_state }.| 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 [GetImageSet](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.

# 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\$1\$1 ]

**SDK für C\$1\$1**  
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\$1\$1 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.

# Pixeldaten des Bildsatzes abrufen
<a name="get-image-frame"></a>

Ein [Bildrahmen](getting-started-concepts.md#concept-image-frame) sind die Pixeldaten, die in einem Bilddatensatz vorhanden sind, um ein medizinisches 2D-Bild zu erstellen. Verwenden Sie die `GetImageFrame` Aktion, um einen HTJ2 K-codierten oder systemeigenen, verlustfreien JPEG 2000-Bildrahmen für einen bestimmten [Bilddatensatz](getting-started-concepts.md#concept-image-set) abzurufen. HealthImaging Die folgenden Menüs enthalten Codebeispiele für und. AWS CLI AWS SDKs Weitere Informationen finden Sie [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)in der * HealthImaging AWS-API-Referenz*.

**Anmerkung**  
Beachten Sie bei der Verwendung der `GetImageFrame` Aktion die folgenden Punkte:  
 HealthImaging Behält beim [Import](importing-imaging-data.md) die Kodierung einiger Übertragungssyntaxen bei und transkodiert andere in HTJ2 K Lossless (Standard) oder JPEG 2000 Lossless. Die `GetImageFrame` Aktion gibt den Bildrahmen in der gespeicherten Übertragungssyntax der Instanz zurück. Während des Abrufs wird keine Transcodierung durchgeführt, um eine minimale Latenz beim Abrufen zu gewährleisten. Je nach Übertragungssyntax müssen Bildframes möglicherweise vor der Anzeige in einem Bildbetrachter dekodiert werden. Weitere Informationen erhalten Sie unter [Unterstützte Übertragungssyntaxen](supported-transfer-syntaxes.md) und [Bibliotheken zur Dekodierung von Bildrahmen](reference-libraries.md).
[Bei Instanzen, in HealthImaging denen ein oder mehrere Bildrahmen gespeichert sind, die in der MPEG-Familie der Übertragungssyntaxen (einschließlich MPEG-4 AVC/H.264 and HEVC/H .265) kodiert sind MPEG2, gibt die `GetImageFrame` Aktion ein Videoobjekt in der gespeicherten Übertragungssyntax zurück.](supported-transfer-syntaxes.md)
Die Übertragungssyntax von Bildrahmen ist im Header-Antwortelement angegeben. `Content-Type HTTP` Ein in HTJ2 K kodierter Bildrahmen hat `Content-Type: image/jph header` beispielsweise. Weitere Informationen finden Sie [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)in der * HealthImaging AWS-API-Referenz*.
Sie können auch die Darstellung HealthImaging eines DICOMweb Service verwenden`GetDICOMInstanceFrames`, um DICOM-Instance-Frames (`multipart`Anfrage) für DICOMweb -kompatible Viewer und Anwendungen abzurufen. Weitere Informationen finden Sie unter [DICOM-Instanz-Frames abrufen von HealthImaging](dicomweb-retrieve-instance-frames.md).

**So rufen Sie Pixeldaten des Bildersatzes ab**  
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-pixel-data"></a>

**Anmerkung**  
Auf Bildrahmen muss programmgesteuert zugegriffen und sie dekodiert werden, da in der kein Bildbetrachter verfügbar ist. AWS-Managementkonsole  
Weitere Informationen zum Dekodieren und Anzeigen von Bildrahmen finden Sie unter. [Bibliotheken zur Dekodierung von Bildrahmen](reference-libraries.md)

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

------
#### [ C\$1\$1 ]

**SDK für C\$1\$1**  

```
//! Routine which downloads an AWS HealthImaging image frame.
/*!
  \param dataStoreID: The HealthImaging data store ID.
  \param imageSetID: The image set ID.
  \param frameID: The image frame ID.
  \param jphFile: File to store the downloaded frame.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
*/
bool AwsDoc::Medical_Imaging::getImageFrame(const Aws::String &dataStoreID,
                                            const Aws::String &imageSetID,
                                            const Aws::String &frameID,
                                            const Aws::String &jphFile,
                                            const Aws::Client::ClientConfiguration &clientConfig) {
    Aws::MedicalImaging::MedicalImagingClient client(clientConfig);

    Aws::MedicalImaging::Model::GetImageFrameRequest request;
    request.SetDatastoreId(dataStoreID);
    request.SetImageSetId(imageSetID);

    Aws::MedicalImaging::Model::ImageFrameInformation imageFrameInformation;
    imageFrameInformation.SetImageFrameId(frameID);
    request.SetImageFrameInformation(imageFrameInformation);

    Aws::MedicalImaging::Model::GetImageFrameOutcome outcome = client.GetImageFrame(
            request);

    if (outcome.IsSuccess()) {
        std::cout << "Successfully retrieved image frame." << std::endl;
        auto &buffer = outcome.GetResult().GetImageFrameBlob();

        std::ofstream outfile(jphFile, std::ios::binary);
        outfile << buffer.rdbuf();
    }
    else {
        std::cout << "Error retrieving image frame." << outcome.GetError().GetMessage()
                  << std::endl;

    }

    return outcome.IsSuccess();
}
```
+  Einzelheiten zur API finden Sie [GetImageFrame](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageFrame)unter *AWS SDK für C\$1\$1 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**  
**So rufen Sie Pixeldaten des Bildersatzes ab**  
Im folgenden Codebeispiel für `get-image-frame` wird ein Image-Frame abgerufen.  

```
aws medical-imaging get-image-frame \
    --datastore-id "12345678901234567890123456789012" \
    --image-set-id "98765412345612345678907890789012" \
    --image-frame-information imageFrameId=3abf5d5d7ae72f80a0ec81b2c0de3ef4 \
    imageframe.jph
```
Hinweis: Dieses Codebeispiel beinhaltet keine Ausgabe, da die GetImageFrame Aktion einen Stream von Pixeldaten an die Datei imageframe.jph zurückgibt. Informationen zum Dekodieren und Anzeigen von Bildrahmen finden Sie unter K-Decodierungsbibliotheken. HTJ2  
Weitere Informationen finden Sie im *AWS HealthImaging Entwicklerhandbuch* unter [Abrufen von Pixeldaten von Bilddatensätzen](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-frame.html).  
+  Einzelheiten zur API finden Sie [GetImageFrame](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-frame.html)in der *AWS CLI Befehlsreferenz*. 

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

**SDK für Java 2.x**  

```
        public static void getMedicalImageSetFrame(MedicalImagingClient medicalImagingClient,
                        String destinationPath,
                        String datastoreId,
                        String imagesetId,
                        String imageFrameId) {

                try {
                        GetImageFrameRequest getImageSetMetadataRequest = GetImageFrameRequest.builder()
                                        .datastoreId(datastoreId)
                                        .imageSetId(imagesetId)
                                        .imageFrameInformation(ImageFrameInformation.builder()
                                                        .imageFrameId(imageFrameId)
                                                        .build())
                                        .build();
                        medicalImagingClient.getImageFrame(getImageSetMetadataRequest,
                                        FileSystems.getDefault().getPath(destinationPath));

                        System.out.println("Image frame downloaded to " + destinationPath);
                } catch (MedicalImagingException e) {
                        System.err.println(e.awsErrorDetails().errorMessage());
                        System.exit(1);
                }
        }
```
+  Einzelheiten zur API finden Sie [GetImageFrame](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageFrame)unter *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)**  

```
import { GetImageFrameCommand } from "@aws-sdk/client-medical-imaging";
import { medicalImagingClient } from "../libs/medicalImagingClient.js";

/**
 * @param {string} imageFrameFileName - The name of the file for the HTJ2K-encoded image frame.
 * @param {string} datastoreID - The data store's ID.
 * @param {string} imageSetID - The image set's ID.
 * @param {string} imageFrameID - The image frame's ID.
 */
export const getImageFrame = async (
  imageFrameFileName = "image.jph",
  datastoreID = "DATASTORE_ID",
  imageSetID = "IMAGE_SET_ID",
  imageFrameID = "IMAGE_FRAME_ID",
) => {
  const response = await medicalImagingClient.send(
    new GetImageFrameCommand({
      datastoreId: datastoreID,
      imageSetId: imageSetID,
      imageFrameInformation: { imageFrameId: imageFrameID },
    }),
  );
  const buffer = await response.imageFrameBlob.transformToByteArray();
  writeFileSync(imageFrameFileName, buffer);

  console.log(response);
  // {
  //     '$metadata': {
  //         httpStatusCode: 200,
  //         requestId: 'e4ab42a5-25a3-4377-873f-374ecf4380e1',
  //         extendedRequestId: undefined,
  //         cfId: undefined,
  //         attempts: 1,
  //         totalRetryDelay: 0
  //     },
  //     contentType: 'application/octet-stream',
  //     imageFrameBlob: <ref *1> IncomingMessage {}
  // }
  return response;
};
```
+  Einzelheiten zur API finden Sie [GetImageFrame](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageFrameCommand)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)**  

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


    def get_pixel_data(
        self, file_path_to_write, datastore_id, image_set_id, image_frame_id
    ):
        """
        Get an image frame's pixel data.

        :param file_path_to_write: The path to write the image frame's HTJ2K encoded pixel data.
        :param datastore_id: The ID of the data store.
        :param image_set_id: The ID of the image set.
        :param image_frame_id: The ID of the image frame.
        """
        try:
            image_frame = self.health_imaging_client.get_image_frame(
                datastoreId=datastore_id,
                imageSetId=image_set_id,
                imageFrameInformation={"imageFrameId": image_frame_id},
            )
            with open(file_path_to_write, "wb") as f:
                for chunk in image_frame["imageFrameBlob"].iter_chunks():
                    if chunk:
                        f.write(chunk)
        except ClientError as err:
            logger.error(
                "Couldn't get image frame. Here's why: %s: %s",
                err.response["Error"]["Code"],
                err.response["Error"]["Message"],
            )
            raise
```
Der folgende Code instanziiert das MedicalImagingWrapper Objekt.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Einzelheiten zur API finden Sie [GetImageFrame](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageFrame)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_image_frame_id = '1234567890123456789012345678901234567890'
        oo_result = lo_mig->getimageframe(
          iv_datastoreid = iv_datastore_id
          iv_imagesetid = iv_image_set_id
          io_imageframeinformation = NEW /aws1/cl_migimageframeinfmtion(
            iv_imageframeid = iv_image_frame_id ) ).
        DATA(lv_frame_blob) = oo_result->get_imageframeblob( ).
        MESSAGE 'Image frame 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 frame 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 [GetImageFrame](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.