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

# Accesso ai set di immagini con AWS HealthImaging
<a name="accessing-image-sets"></a>

L'accesso ai dati di imaging medico in AWS in HealthImaging genere implica la ricerca di un [set di immagini](getting-started-concepts.md#concept-image-set) con una chiave univoca e l'ottenimento [dei metadati](getting-started-concepts.md#concept-metadata) e dei [frame di immagine](getting-started-concepts.md#concept-image-frame) associati (dati pixel).

**Importante**  
Durante l'importazione, HealthImaging elabora i file binari (`.dcm`file) delle istanze DICOM e li trasforma in set di immagini. Utilizza [le azioni native del HealthImaging cloud](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_Operations.html) (APIs) per gestire gli archivi di dati e i set di immagini. Usa HealthImaging la [rappresentazione dei DICOMweb servizi](dicomweb-retrieve.md) per restituire DICOMweb le risposte.

I seguenti argomenti spiegano come utilizzare le azioni native del HealthImaging Console di gestione AWS cloud in e come AWS SDKs cercare set di immagini e ottenere le proprietà, i metadati e i frame di immagini associati. AWS CLI

**Topics**
+ [Comprendere i set di immagini](understanding-image-sets.md)
+ [Ricerca di set di immagini](search-image-sets.md)
+ [Ottenere le proprietà del set di immagini](get-image-set-properties.md)
+ [Ottenere i metadati del set di immagini](get-image-set-metadata.md)
+ [Acquisizione dei dati dei pixel del set di immagini](get-image-frame.md)

# Comprendere i set di immagini
<a name="understanding-image-sets"></a>

I set di immagini sono simili a una serie DICOM e fungono da base per AWS. AWS HealthImaging I set di immagini vengono creati quando si importano i dati DICOM in. HealthImaging Il servizio tenta di organizzare i dati P10 importati in base alla gerarchia DICOM di Study, Series e Instance.

I set di immagini sono stati introdotti per i seguenti motivi:
+  Supporta un'ampia varietà di flussi di lavoro di imaging medicale (clinici e non clinici) grazie alla flessibilità. APIs 
+  Fornisci un meccanismo per archiviare e riconciliare in modo duraturo dati duplicati e incoerenti. I dati P10 importati che sono in conflitto con i set di immagini primari già presenti in un archivio verranno mantenuti come non primari. Dopo aver risolto i conflitti di metadati, questi dati possono essere resi primari. 
+  Massimizza la sicurezza dei pazienti raggruppando solo i dati correlati.
+  Incoraggia la pulizia dei dati per aumentare la visibilità delle incongruenze. Per ulteriori informazioni, consulta [Modifica dei set di immagini](modifying-image-sets.md). 
**Importante**  
L'uso clinico dei dati DICOM prima della loro pulizia può causare danni ai pazienti.

I seguenti menu descrivono i set di immagini in modo più dettagliato e forniscono esempi e diagrammi per aiutarvi a comprenderne la funzionalità e lo scopo. HealthImaging

## Cos'è un set di immagini?
<a name="what-is-image-set"></a>

Un set di immagini è un AWS concetto che definisce un meccanismo di raggruppamento astratto per l'ottimizzazione dei dati di imaging medicale correlati, molto simile a una serie DICOM. Quando importi i dati di imaging DICOM P10 in un data store AWS, HealthImaging questi vengono trasformati in set di immagini composti da [metadati](getting-started-concepts.md#concept-metadata) e [frame di immagini](getting-started-concepts.md#concept-image-frame) (dati pixel). 

**Nota**  
[I metadati del set di immagini sono normalizzati.](metadata-normalization.md) In altre parole, un insieme comune di attributi e valori corrisponde agli elementi a livello di paziente, studio e serie elencati nel [Registro degli elementi di dati DICOM](https://dicom.nema.org/medical/dicom/2022b/output/html/part06.html#table_6-1). HealthImaging utilizza i seguenti elementi DICOM per raggruppare gli oggetti DICOM P10 in entrata in set di immagini.  


**elementi DICOM utilizzati per la creazione di set di immagini**  
<a name="table-dicom-elements-image-set"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/healthimaging/latest/devguide/understanding-image-sets.html)
Durante l'importazione, alcuni set di immagini mantengono la codifica della sintassi di trasferimento originale, mentre altri vengono transcodificati in formato JPEG 2000 (K) ad alta velocità senza perdita di dati per impostazione predefinita. HTJ2 Se un set di immagini è codificato in HTJ2 K, deve essere decodificato prima della visualizzazione. Per ulteriori informazioni, consultare [Sintassi di trasferimento supportate](supported-transfer-syntaxes.md) e [Librerie di decodifica dei frame di immagini](reference-libraries.md).  
[I fotogrammi delle immagini (dati dei pixel) sono codificati in JPEG 2000 (HTJ2K) ad alta velocità e devono essere decodificati prima della visualizzazione.](reference-libraries.md)

I set di immagini sono AWS risorse, quindi vengono assegnati [Amazon Resource Names (ARNs)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Possono essere etichettati con un massimo di 50 coppie chiave-valore e concedere il controllo degli accessi [basato sui ruoli (RBAC) e il controllo degli accessi basato sugli attributi (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) [tramite IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html). Inoltre, i set di immagini dispongono di versioni, in modo che tutte le modifiche vengano [mantenute e sia possibile accedere alle versioni](list-image-set-versions.md) precedenti.

L'importazione di dati DICOM P10 produce set di immagini che contengono metadati DICOM e frame di immagini per una o più istanze di Service-Object Pair (SOP) della stessa serie DICOM.

![\[Diagramma che mostra cos'è un set di immagini in AWS HealthImaging.\]](http://docs.aws.amazon.com/it_it/healthimaging/latest/devguide/images/image-set-what-is.png)


**Nota**  
Lavori di importazione DICOM:  
Crea sempre nuovi set di immagini o incrementa la versione dei set di immagini esistenti.
Non deduplicate lo storage delle istanze SOP. Ogni importazione della stessa istanza SOP utilizza spazio di archiviazione aggiuntivo come nuovo set di immagini non primario o versione incrementata di un set di immagini primario esistente.
Organizza automaticamente le istanze SOP con metadati coerenti e non in conflitto come set di immagini primarie, che contengono istanze con elementi di metadati Patient, Study e Series coerenti.  
Se le istanze che comprendono una serie DICOM vengono importate in due o più processi di importazione e non sono in conflitto con le istanze già presenti nell'archivio dati, tutte le istanze saranno organizzate in un set di immagini primario.
Crea set di immagini non primari contenenti dati DICOM P10 in conflitto con i set di immagini primari già presenti nell'archivio dati.
Conserva i dati ricevuti più di recente come versione più recente di un set di immagini primario.  
Se le istanze che comprendono una serie DICOM sono set di immagini primari e un'istanza viene nuovamente importata, la nuova copia verrà inserita nel set di immagini principale e la versione verrà incrementata.

## Che aspetto hanno i metadati del set di immagini?
<a name="what-does-image-set-look-like"></a>

Utilizzate l'`GetImageSetMetadata`azione per recuperare i metadati del set di immagini. I metadati restituiti vengono compressi con`gzip`, quindi è necessario decomprimerli prima di visualizzarli. Per ulteriori informazioni, consulta [Ottenere i metadati del set di immagini](get-image-set-metadata.md).

L'esempio seguente mostra la struttura dei [metadati](getting-started-concepts.md#concept-metadata) del set di immagini in formato JSON.

```
{
	"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
							}
						]
					}
				}
			}
		}
	}
}
```

## Esempio di creazione di set di immagini: processi di importazione multipli
<a name="example-creation-multiple-import-jobs"></a>

L'esempio seguente mostra come più processi di importazione creino sempre nuovi set di immagini e *non si aggiungano mai* a quelli esistenti.

![\[Diagramma che mostra l'aspetto dei processi di importazione di più set di immagini. HealthImaging\]](http://docs.aws.amazon.com/it_it/healthimaging/latest/devguide/images/image-set-example-multiple-import-jobs.png)


## Esempio di creazione di un set di immagini: processo di importazione singolo con due varianti
<a name="example-creation-two-variants"></a>

L'esempio seguente mostra un singolo processo di importazione che non riuscirebbe a fondersi in un unico set di immagini perché le istanze 1 e 3 hanno un Patient diverso IDs rispetto alle istanze 2 e 4. Per risolvere questo problema, è possibile utilizzare l'`UpdateImageSetMetadata`azione per risolvere il conflitto tra l'ID del paziente e il set di immagini primarie esistente. Dopo aver risolto i conflitti, è possibile utilizzare l'`CopyImageSet`azione con l'argomento `--promoteToPrimary` per aggiungere il set di immagini al set di immagini primario.

![\[Diagramma che mostra l'aspetto di due varianti del set di immagini HealthImaging utilizzando un unico processo di importazione.\]](http://docs.aws.amazon.com/it_it/healthimaging/latest/devguide/images/image-set-example-import-two-variants.png)


## Esempio di creazione di un set di immagini: processo di importazione singolo con ottimizzazione
<a name="example-creation-optimization"></a>

L'esempio seguente mostra un singolo processo di importazione che crea due set di immagini per migliorare la produttività, anche se i nomi dei pazienti corrispondono. 

![\[Diagramma che mostra come si presenta l'ottimizzazione del set di immagini HealthImaging utilizzando un singolo processo di importazione.\]](http://docs.aws.amazon.com/it_it/healthimaging/latest/devguide/images/image-set-example-optimization.png)


# Ricerca di set di immagini
<a name="search-image-sets"></a>

Usa l'`SearchImageSets`azione per eseguire query di ricerca su tutti i [set di immagini](getting-started-concepts.md#concept-image-set) in un `ACTIVE` HealthImaging data store. I menu seguenti forniscono una procedura Console di gestione AWS e alcuni esempi di codice per and. AWS CLI AWS SDKs Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html)l'*AWS HealthImaging API Reference*.

**Nota**  
Tieni a mente i seguenti punti durante la ricerca di set di immagini.  
`SearchImageSets`accetta un singolo parametro di query di ricerca e restituisce una risposta impaginata di tutti i set di immagini che hanno i criteri corrispondenti. Tutte le interrogazioni relative all'intervallo di date devono essere inserite come. `(lowerBound, upperBound)`
Per impostazione predefinita, `SearchImageSets` utilizza il `updatedAt` campo per l'ordinamento decrescente dal più recente al meno recente.
Se hai creato il tuo data store con una chiave di proprietà del cliente, devi aggiornare la policy AWS KMS AWS KMS chiave prima di interagire con i set di immagini. Per ulteriori informazioni, consulta [Creazione di una chiave gestita dal cliente](data-encryption.md#creating-co-cmk).

**Per cercare set di immagini**  
Scegli un menu in base alle tue preferenze di accesso ad AWS HealthImaging.

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

**Nota**  
Le seguenti procedure mostrano come cercare set di immagini utilizzando i filtri `Series Instance UID` e le `Updated at` proprietà.

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

**Cerca set di immagini utilizzando il filtro delle `Series Instance UID` proprietà**

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

1. Scegli un archivio dati.

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

1. Scegliete il menu del filtro delle proprietà e selezionate`Series Instance UID`.

1. Nel campo **Inserisci il valore da cercare**, inserisci (incolla) l'UID dell'istanza della serie che ti interessa.
**Nota**  
I valori Series Instance UID devono essere identici a quelli elencati nel [Registry of DICOM Unique Identifiers](https://dicom.nema.org/dicom/2013/output/chtml/part06/chapter_A.html) (). UIDs Tieni presente che i requisiti includono una serie di numeri che contengano almeno un punto tra di loro. I periodi non sono consentiti all'inizio o alla fine di Series Instance UIDs. Le lettere e gli spazi bianchi non sono consentiti, quindi fai attenzione quando copi e incolla UIDs.

1. **Scegli il menu **Intervallo di date**, seleziona un intervallo di date per l'UID dell'istanza della serie e scegli Applica.**

1. Selezionare **Search (Cerca)**.

   Le istanze Series UIDs che rientrano nell'intervallo di date selezionato vengono restituite nell'ordine più recente per impostazione predefinita.

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

**Cerca set di immagini utilizzando il filtro delle `Updated at` proprietà**

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

1. Scegli un archivio dati.

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

1. Scegliete il menu del filtro delle proprietà e scegliete`Updated at`.

1. Scegliete il menu **Intervallo di date**, selezionate un intervallo di date del set di immagini e scegliete **Applica**.

1. Selezionare **Search (Cerca)**.

   Per impostazione predefinita, i set di immagini che rientrano nell'intervallo di date selezionato vengono restituiti nell'ordine più recente.

------

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

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

**SDK per C\$1\$1**  
La funzione di utilità per la ricerca di set di immagini.  

```
//! 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;
}
```
Caso d’uso 1: operatore EQUAL.  

```
        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;
            }
        }
```
Caso d'uso \$12: operatore BETWEEN che utilizza DICOMStudy data e DICOMStudy ora.   

```
         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;
            }
        }
```
Caso d’uso 3: operatore BETWEEN con createdAt. Gli studi relativi agli orari sono stati precedentemente resi persistenti.   

```
        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;
            }
        }
```
Caso d'uso \$14: operatore EQUAL su DICOMSeries instanceUID e BETWEEN su updatedAt e ordina la risposta in ordine ASC nel campo 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;
            }
        }
```
+  *Per i dettagli sull'API, consulta la sezione API Reference. [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/SearchImageSets)AWS SDK per C\$1\$1 * 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

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

**AWS CLI**  
**Esempio 1: come cercare set di immagini con un operatore EQUAL.**  
L’esempio di codice `search-image-sets` seguente utilizza l’operatore EQUAL per cercare set di immagini in base a un valore specifico.  

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

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

```
{
    "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"
    }]
}
```
**Esempio 2: per cercare set di immagini con un operatore BETWEEN utilizzando DICOMStudy Data e DICOMStudy ora**  
L’esempio `search-image-sets` seguente cerca set di immagini con studi DICOM generati tra il 1° gennaio 1990 (00:00) e il 1° gennaio 2023 (00:00).  
Nota: l'DICOMStudyora è facoltativa. Se non presente, 00:00 (inizio della giornata) è il valore temporale per le date fornite per l’applicazione di filtri.  

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

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

```
{
    "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"
    }]
}
```
**Esempio 3: come cercare set di immagini con un operatore BETWEEN utilizzando createdAt (in precedenza gli studi temporali erano persistenti)**  
Il seguente esempio di `search-image-sets` codice cerca set di immagini con DICOM Studies persistenti HealthImaging tra gli intervalli di tempo del fuso orario UTC.  
Nota: fornisci createdAt nel formato dell’esempio (“1985-04-12T23:20:50.52Z”).  

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

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

```
{
    "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"
    }]
}
```
**Esempio 4: cercare set di immagini con un operatore EQUAL su DICOMSeries instanceUID e BETWEEN su updatedAt e ordinare la risposta in ordine ASC nel campo updatedAt**  
Il seguente esempio di `search-image-sets` codice cerca i set di immagini con un operatore EQUAL su DICOMSeries instanceUID e BETWEEN su updatedAt e ordina la risposta in ordine ASC sul campo updatedAt.  
Nota: fornisci updatedAt nel formato dell’esempio (“1985-04-12T23:20:50.52Z”).  

```
aws medical-imaging search-image-sets \
    --datastore-id 12345678901234567890123456789012 \
    --search-criteria  file://search-criteria.json
```
Contenuto di `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"
    }
}
```
Output:  

```
{
    "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)  
+  Per i dettagli sull'API, consulta [SearchImageSets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/search-image-sets.html)*Command Reference*. 

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

**SDK per Java 2.x**  
La funzione di utilità per la ricerca di set di immagini.  

```
    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;
    }
```
Caso d’uso 1: operatore EQUAL.  

```
        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();
        }
```
Caso d'uso \$12: operatore BETWEEN che utilizza DICOMStudy data e DICOMStudy ora.   

```
        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();
        }
```
Caso d’uso 3: operatore BETWEEN con createdAt. Gli studi relativi agli orari sono stati precedentemente resi persistenti.   

```
        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();
        }
```
Caso d'uso \$14: operatore EQUAL su DICOMSeries instanceUID e BETWEEN su updatedAt e ordina la risposta in ordine ASC nel campo 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();
        }
```
+  *Per i dettagli sull'API, consulta la sezione API Reference. [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/SearchImageSets)AWS SDK for Java 2.x * 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

**SDK per JavaScript (v3)**  
La funzione di utilità per la ricerca di set di immagini.  

```
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;
};
```
Caso d’uso 1: operatore EQUAL.  

```
  const datastoreId = "12345678901234567890123456789012";

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

    await searchImageSets(datastoreId, searchCriteria);
  } catch (err) {
    console.error(err);
  }
```
Caso d'uso \$12: operatore BETWEEN che utilizza DICOMStudy data e DICOMStudy ora.   

```
  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);
  }
```
Caso d’uso 3: operatore BETWEEN con createdAt. Gli studi relativi agli orari sono stati precedentemente resi persistenti.   

```
  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);
  }
```
Caso d'uso \$14: operatore EQUAL su DICOMSeries instanceUID e BETWEEN su updatedAt e ordina la risposta in ordine ASC nel campo 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);
  }
```
+  *Per i dettagli sull'API, consulta la sezione API Reference. [SearchImageSets](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/SearchImageSetsCommand)AWS SDK per JavaScript * 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

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

**SDK per Python (Boto3)**  
La funzione di utilità per la ricerca di set di immagini.  

```
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
```
Caso d’uso 1: operatore EQUAL.  

```
        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}")
```
Caso d'uso \$12: operatore BETWEEN che utilizza DICOMStudy data e DICOMStudy ora.   

```
        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}"
        )
```
Caso d’uso 3: operatore BETWEEN con createdAt. Gli studi relativi agli orari sono stati precedentemente resi persistenti.   

```
        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}"
        )
```
Caso d'uso \$14: operatore EQUAL su DICOMSeries instanceUID e BETWEEN su updatedAt e ordina la risposta in ordine ASC nel campo 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}")
```
Il codice seguente crea un'istanza dell'oggetto. MedicalImagingWrapper   

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

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

**SDK per SAP ABAP**  

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

------

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

# Ottenere le proprietà del set di immagini
<a name="get-image-set-properties"></a>

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

**Nota**  
Per impostazione predefinita, AWS HealthImaging restituisce le proprietà per l'ultima versione di un set di immagini. Per visualizzare le proprietà di una versione precedente di un set di immagini, fornisci `versionId` la tua richiesta.  
Utilizza`GetDICOMInstance`, HealthImaging come rappresentazione di un DICOMweb servizio, per restituire un binario (`.dcm`file) di istanza DICOM. Per ulteriori informazioni, consulta [Ottenere un'istanza DICOM da HealthImaging](dicomweb-retrieve-instance.md).

**Come ottenere le proprietà del set di immagini**  
Scegli un menu in base alle tue preferenze di accesso ad AWS HealthImaging.

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

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

1. Scegli un archivio dati.

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

1. Scegliete un set di immagini.

   Viene visualizzata la pagina dei **dettagli del set** di immagini con le proprietà del set di immagini.

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

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

**AWS CLI**  
**Come ottenere le proprietà del set di immagini**  
L’esempio di codice `get-image-set` seguente ottiene le proprietà di un set di immagini.  

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

```
{
    "versionId": "1",
    "imageSetWorkflowStatus": "COPIED",
    "updatedAt": 1680027253.471,
    "imageSetId": "18f88ac7870584f58d56256646b4d92b",
    "imageSetState": "ACTIVE",
    "createdAt": 1679592510.753,
    "datastoreId": "12345678901234567890123456789012"
}
```
Per ulteriori informazioni, consulta [Ottenere le proprietà del set di immagini](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-properties.html) nella *Guida per gli AWS HealthImaging sviluppatori*.  
+  Per i dettagli sull'API, consulta [GetImageSet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set.html)*Command Reference*. 

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

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

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

**SDK per JavaScript (v3)**  

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

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

**SDK per Python (Boto3)**  

```
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
```
Il codice seguente crea un'istanza dell' MedicalImagingWrapper oggetto.   

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

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

**SDK per SAP ABAP**  

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

------

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

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

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

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

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

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

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

1. Scegli un archivio dati.

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

1. Scegliete un set di immagini.

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

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

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

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

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

    return outcome.IsSuccess();
}
```
Ottiene i metadati del set di immagini senza la versione.  

```
        if (AwsDoc::Medical_Imaging::getImageSetMetadata(dataStoreID, imageSetID, "", outputFilePath, clientConfig))
        {
            std::cout << "Successfully retrieved image set metadata." << std::endl;
            std::cout << "Metadata stored in: " << outputFilePath << std::endl;
        }
```
Ottiene i metadati del set di immagini con la versione.  

```
        if (AwsDoc::Medical_Imaging::getImageSetMetadata(dataStoreID, imageSetID, versionID, outputFilePath, clientConfig))
        {
            std::cout << "Successfully retrieved image set metadata." << std::endl;
            std::cout << "Metadata stored in: " << outputFilePath << std::endl;
        }
```
+  Per i dettagli sull'API, consulta la sezione *AWS SDK per C\$1\$1 API [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageSetMetadata)Reference*. 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

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

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

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

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

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

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

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

**SDK per Java 2.x**  

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

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

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

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

            System.out.println("Metadata downloaded to " + destinationPath);
        } catch (MedicalImagingException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
```
+  Per i dettagli sull'API, [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSetMetadata)consulta *AWS SDK for Java 2.x API Reference*. 
 C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

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

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

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

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

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

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

  return response;
};
```
Ottiene i metadati del set di immagini senza la versione.  

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

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

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

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

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


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

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

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

        except ClientError as err:
            logger.error(
                "Couldn't get image metadata. Here's why: %s: %s",
                err.response["Error"]["Code"],
                err.response["Error"]["Message"],
            )
            raise
```
Ottiene i metadati del set di immagini senza la versione.  

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

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

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

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

**SDK per SAP ABAP**  

```
    TRY.
        " iv_datastore_id = '1234567890123456789012345678901234567890'
        " iv_image_set_id = '1234567890123456789012345678901234567890'
        " iv_version_id = '1' (optional)
        IF iv_version_id IS NOT INITIAL.
          oo_result = lo_mig->getimagesetmetadata(
            iv_datastoreid = iv_datastore_id
            iv_imagesetid = iv_image_set_id
            iv_versionid = iv_version_id ).
        ELSE.
          oo_result = lo_mig->getimagesetmetadata(
            iv_datastoreid = iv_datastore_id
            iv_imagesetid = iv_image_set_id ).
        ENDIF.
        DATA(lv_metadata_blob) = oo_result->get_imagesetmetadatablob( ).
        MESSAGE 'Image set metadata retrieved.' TYPE 'I'.
      CATCH /aws1/cx_migaccessdeniedex.
        MESSAGE 'Access denied.' TYPE 'I'.
      CATCH /aws1/cx_migconflictexception.
        MESSAGE 'Conflict error.' TYPE 'I'.
      CATCH /aws1/cx_miginternalserverex.
        MESSAGE 'Internal server error.' TYPE 'I'.
      CATCH /aws1/cx_migresourcenotfoundex.
        MESSAGE 'Image set not found.' TYPE 'I'.
      CATCH /aws1/cx_migthrottlingex.
        MESSAGE 'Request throttled.' TYPE 'I'.
      CATCH /aws1/cx_migvalidationex.
        MESSAGE 'Validation error.' TYPE 'I'.
    ENDTRY.
```
+  Per i dettagli sull'API, consulta [GetImageSetMetadata AWS](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)*SDK for SAP* ABAP API reference. 
 C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

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

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

# Acquisizione dei dati dei pixel del set di immagini
<a name="get-image-frame"></a>

Una [cornice di immagine](getting-started-concepts.md#concept-image-frame) è costituita dai dati di pixel presenti all'interno di un set di immagini per creare un'immagine medica 2D. [Utilizzate l'`GetImageFrame`azione per recuperare un fotogramma di immagine JPEG 2000 senza perdita di HTJ2 dati con codifica K o nativo per un determinato set di immagini.](getting-started-concepts.md#concept-image-set) HealthImaging I seguenti menu forniscono esempi di codice per and. AWS CLI AWS SDKs Per ulteriori informazioni, [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)consulta *AWS HealthImaging API Reference*.

**Nota**  
Tieni a mente i seguenti punti quando usi l'`GetImageFrame`azione:  
Durante l'[importazione](importing-imaging-data.md), HealthImaging mantiene la codifica per alcune sintassi di trasferimento e ne transcodifica altre in HTJ2 K lossless (impostazione predefinita) o JPEG 2000 Lossless. L'`GetImageFrame`azione restituisce il fotogramma dell'immagine nella sintassi di trasferimento memorizzata dell'istanza. Non viene eseguita alcuna transcodifica durante il recupero per garantire una latenza di recupero minima. Potrebbe essere necessario decodificare i fotogrammi delle immagini prima di visualizzarli in un visualizzatore di immagini, a seconda della sintassi di trasferimento. Per ulteriori informazioni, consultare [Sintassi di trasferimento supportate](supported-transfer-syntaxes.md) e [Librerie di decodifica dei frame di immagini](reference-libraries.md).
[Per le istanze archiviate HealthImaging con uno o più fotogrammi di immagine codificati nella famiglia di sintassi di trasferimento MPEG (che include MPEG-4 AVC/H.264 and HEVC/H .265) MPEG2, l'`GetImageFrame`azione restituirà un oggetto video nella sintassi di trasferimento memorizzata.](supported-transfer-syntaxes.md)
La sintassi di trasferimento dei frame di immagine è specificata nell'elemento header response. `Content-Type HTTP` Ad esempio, una cornice di immagine codificata in HTJ2 K avrà. `Content-Type: image/jph header` Per ulteriori informazioni, [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)consulta *AWS HealthImaging API Reference*.
Puoi anche utilizzare `GetDICOMInstanceFrames` la rappresentazione HealthImaging di un DICOMweb servizio per recuperare frame di istanze DICOM (`multipart`richiesta) per visualizzatori e DICOMweb applicazioni compatibili. Per ulteriori informazioni, consulta [Ottenere frame di istanze DICOM da HealthImaging](dicomweb-retrieve-instance-frames.md).

**Come ottenere i dati dei pixel del set di immagini**  
Scegli un menu in base alle tue preferenze di accesso ad AWS HealthImaging.

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

**Nota**  
È necessario accedere ai frame delle immagini e decodificarli a livello di codice, poiché un visualizzatore di immagini non è disponibile in. Console di gestione AWS  
Per ulteriori informazioni sulla decodifica e la visualizzazione dei frame delle immagini, vedere. [Librerie di decodifica dei frame di immagini](reference-libraries.md)

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

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

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

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

**AWS CLI**  
**Come ottenere i dati dei pixel del set di immagini**  
L’esempio di codice `get-image-frame` seguente ottiene un image frame di immagine.  

```
aws medical-imaging get-image-frame \
    --datastore-id "12345678901234567890123456789012" \
    --image-set-id "98765412345612345678907890789012" \
    --image-frame-information imageFrameId=3abf5d5d7ae72f80a0ec81b2c0de3ef4 \
    imageframe.jph
```
Nota: questo esempio di codice non include l'output perché l' GetImageFrame azione restituisce un flusso di dati di pixel al file imageframe.jph. Per informazioni sulla decodifica e la visualizzazione dei frame di immagini, vedete K decoding libraries. HTJ2  
Per ulteriori informazioni, consultate [Ottenere i dati dei pixel del set di immagini](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-frame.html) nella Guida per gli *AWS HealthImaging sviluppatori*.  
+  Per i dettagli sull'API, consulta [GetImageFrame AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-frame.html)*Command Reference*. 

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

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

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

**SDK per JavaScript (v3)**  

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

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

**SDK per Python (Boto3)**  

```
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
```
Il codice seguente crea un'istanza dell' MedicalImagingWrapper oggetto.   

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

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

**SDK per SAP ABAP**  

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

------

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