Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Acceso a conjuntos de imágenes con AWS HealthImaging
<a name="accessing-image-sets"></a>

El acceso a los datos de imágenes médicas en AWS HealthImaging normalmente implica buscar un [conjunto de imágenes](getting-started-concepts.md#concept-image-set) con una clave única y obtener los [metadatos y los](getting-started-concepts.md#concept-metadata) [marcos de imágenes](getting-started-concepts.md#concept-image-frame) asociados (datos de píxeles).

**Importante**  
Durante la importación, HealthImaging procesa los `.dcm` archivos binarios de las instancias DICOM y los transforma en conjuntos de imágenes. Utilice [acciones nativas de HealthImaging la nube](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_Operations.html) (APIs) para gestionar los almacenes de datos y los conjuntos de imágenes. Utilice HealthImaging la [representación de los DICOMweb servicios](dicomweb-retrieve.md) para devolver DICOMweb las respuestas.

En los siguientes temas se explica cómo utilizar las acciones nativas de la HealthImaging nube en Consola de administración de AWS AWS CLI, y AWS SDKs cómo buscar conjuntos de imágenes y obtener sus propiedades, metadatos y marcos de imágenes asociados.

**Topics**
+ [Descripción de los conjuntos de imágenes](understanding-image-sets.md)
+ [Búsqueda de conjuntos de imágenes](search-image-sets.md)
+ [Obtención de las propiedades del conjunto de imágenes](get-image-set-properties.md)
+ [Obtención de metadatos de conjuntos de imágenes](get-image-set-metadata.md)
+ [Obtención de datos de píxeles de los conjuntos de imágenes](get-image-frame.md)

# Descripción de los conjuntos de imágenes
<a name="understanding-image-sets"></a>

Los conjuntos de imágenes AWS se parecen a los de la serie DICOM y son la base de AWS HealthImaging. Los conjuntos de imágenes se crean al importar los datos DICOM a. HealthImaging El servicio intenta organizar los datos P10 importados según la jerarquía DICOM de estudio, serie e instancia.

Los conjuntos de imágenes se introdujeron por varias razones:
+  Support una amplia variedad de flujos de trabajo de imágenes médicas (clínicos y no clínicos) mediante la flexibilidad APIs. 
+  Proporcione un mecanismo para almacenar y conciliar de forma duradera los datos duplicados e incoherentes. Los datos P10 importados que entren en conflicto con los conjuntos de imágenes principales que ya estén en un almacén se conservarán como datos no principales. Tras resolver los conflictos de metadatos, esos datos pueden pasar a ser principales. 
+  Permiten maximizar la seguridad de los pacientes agrupando únicamente los datos relacionados.
+  Fomentar la limpieza de los datos para ofrecer una mayor visibilidad de las incoherencias. Para obtener más información, consulte [Modificación de conjuntos de imágenes](modifying-image-sets.md). 
**Importante**  
El uso clínico de los datos DICOM antes de su limpieza puede ser perjudicial para el paciente.

Los siguientes menús describen los conjuntos de imágenes con más detalle y proporcionan ejemplos y diagramas para ayudarle a comprender su funcionalidad y propósito. HealthImaging

## ¿Qué son los conjuntos de imágenes?
<a name="what-is-image-set"></a>

Un conjunto de imágenes es un AWS concepto que define un mecanismo de agrupación abstracto para optimizar los datos de imágenes médicas relacionados que se parece mucho a los de la serie DICOM. Al importar los datos de imágenes del DICOM P10 a un almacén de HealthImaging datos de AWS, se transforman en conjuntos de imágenes compuestos por [metadatos](getting-started-concepts.md#concept-metadata) y [marcos de imágenes](getting-started-concepts.md#concept-image-frame) (datos de píxeles). 

**nota**  
Los metadatos de los conjuntos de imágenes están [normalizados](metadata-normalization.md). En otras palabras, un conjunto común de atributos y valores corresponde a los elementos a nivel de paciente, estudio y serie que figuran en el [Registro de elementos de datos DICOM](https://dicom.nema.org/medical/dicom/2022b/output/html/part06.html#table_6-1). HealthImaging utiliza los siguientes elementos DICOM al agrupar los objetos DICOM P10 entrantes en conjuntos de imágenes.  


**Elementos DICOM utilizados para la creación de conjuntos de imágenes**  
<a name="table-dicom-elements-image-set"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/healthimaging/latest/devguide/understanding-image-sets.html)
Durante la importación, algunos conjuntos de imágenes conservan su codificación de sintaxis de transferencia original, mientras que otros se transcodifican a JPEG 2000 (HTJ2K) de alto rendimiento sin pérdidas de forma predeterminada. Si un conjunto de imágenes está codificado en HTJ2 K, debe decodificarse antes de visualizarlo. Para obtener más información, consulte [Sintaxis de transferencia compatibles](supported-transfer-syntaxes.md) y [Bibliotecas de decodificación de marcos de imágenes](reference-libraries.md).  
Los fotogramas de imagen (datos en píxeles) están codificados en JPEG 2000 (HTJ2K) de alto rendimiento y deben [decodificarse](reference-libraries.md) antes de visualizarlos.

Los conjuntos de imágenes son AWS recursos, por lo que se les asignan [nombres de recursos de Amazon (ARNs)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Se pueden etiquetar con hasta 50 pares de clave-valor y se les puede conceder [control de acceso basado en roles (RBAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) y [control de acceso basado en atributos (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) mediante IAM. Además, los conjuntos de imágenes tienen [control de versiones](list-image-set-versions.md) para conservar todos los cambios y poder acceder a las versiones anteriores.

La importación de datos DICOM P10 da como resultado conjuntos de imágenes que contienen metadatos DICOM y marcos de imágenes para una o más instancias de pares de objetos y servicios (SOP) de la misma serie DICOM.

![\[Diagrama que muestra qué es un conjunto de imágenes en AWS HealthImaging.\]](http://docs.aws.amazon.com/es_es/healthimaging/latest/devguide/images/image-set-what-is.png)


**nota**  
Trabajos de importación DICOM:  
Cree siempre nuevos conjuntos de imágenes o incremente la versión de los conjuntos de imágenes existentes.
No deduplique el almacenamiento de instancias SOP. Cada importación de la misma instancia de SOP utiliza almacenamiento adicional como un nuevo conjunto de imágenes no principal o una versión incrementada de un conjunto de imágenes principal existente.
Organice automáticamente las instancias SOP con metadatos consistentes y no conflictivos como conjuntos de imágenes principales, que contienen instancias con elementos de metadatos consistentes de pacientes, estudios y series.  
Si las instancias que componen una serie DICOM se importan en dos o más trabajos de importación y las instancias no entran en conflicto con las que ya se encuentran en el almacén de datos, todas las instancias se organizarán en un conjunto de imágenes principal.
Cree conjuntos de imágenes no principales que contengan datos del DICOM P10 que entren en conflicto con los conjuntos de imágenes principales que ya están en el almacén de datos.
Conserve los datos recibidos más recientemente como la última versión de un conjunto de imágenes principal.  
Si las instancias que componen una serie DICOM son conjuntos de imágenes principales y se vuelve a importar una instancia, la nueva copia se insertará en el conjunto de imágenes principal y se incrementará la versión.

## ¿Qué aspecto tienen los metadatos del conjunto de imágenes?
<a name="what-does-image-set-look-like"></a>

Utilice la `GetImageSetMetadata` acción para recuperar los metadatos del conjunto de imágenes. Los metadatos devueltos se comprimen con`gzip`, por lo que debe descomprimirlos antes de verlos. Para obtener más información, consulte [Obtención de metadatos de conjuntos de imágenes](get-image-set-metadata.md).

El siguiente ejemplo muestra la estructura de los [metadatos](getting-started-concepts.md#concept-metadata) del conjunto de imágenes en 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
							}
						]
					}
				}
			}
		}
	}
}
```

## Ejemplo de creación de un conjunto de imágenes: varios trabajos de importación
<a name="example-creation-multiple-import-jobs"></a>

El ejemplo siguiente muestra cómo varios trabajos de importación crean siempre nuevos conjuntos de imágenes y *nunca* los agregan a los existentes.

![\[Diagrama que muestra el aspecto de varios trabajos de importación de conjuntos de imágenes HealthImaging.\]](http://docs.aws.amazon.com/es_es/healthimaging/latest/devguide/images/image-set-example-multiple-import-jobs.png)


## Ejemplo de creación de un conjunto de imágenes: trabajo de importación único con dos variantes
<a name="example-creation-two-variants"></a>

El siguiente ejemplo muestra un único trabajo de importación que no se combinaría en un único conjunto de imágenes porque las instancias 1 y 3 tienen un paciente IDs diferente al de las instancias 2 y 4. Para resolver este problema, puede utilizar la `UpdateImageSetMetadata` acción para resolver el conflicto de identificación del paciente con el conjunto de imágenes principal existente. Una vez resueltos los conflictos, puede utilizar la `CopyImageSet` acción con el argumento `--promoteToPrimary` para añadir el conjunto de imágenes al conjunto de imágenes principal.

![\[Diagrama que muestra el aspecto de dos variantes del conjunto de imágenes al HealthImaging utilizar un único trabajo de importación.\]](http://docs.aws.amazon.com/es_es/healthimaging/latest/devguide/images/image-set-example-import-two-variants.png)


## Ejemplo de creación de un conjunto de imágenes: trabajo de importación único con optimización
<a name="example-creation-optimization"></a>

El ejemplo siguiente muestra un único trabajo de importación que crea dos conjuntos de imágenes para mejorar el rendimiento, aunque los nombres de los pacientes coincidan. 

![\[Diagrama que muestra el aspecto de la optimización del conjunto de imágenes al HealthImaging utilizar un único trabajo de importación.\]](http://docs.aws.amazon.com/es_es/healthimaging/latest/devguide/images/image-set-example-optimization.png)


# Búsqueda de conjuntos de imágenes
<a name="search-image-sets"></a>

Utilice la `SearchImageSets` acción para ejecutar consultas de búsqueda en todos los [conjuntos de imágenes](getting-started-concepts.md#concept-image-set) de un almacén de `ACTIVE` HealthImaging datos. En los menús siguientes se proporciona un procedimiento Consola de administración de AWS y ejemplos de código para AWS CLI y AWS SDKs. Para obtener más información, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html)la *referencia de la HealthImaging API de AWS*.

**nota**  
Tenga en cuenta los siguientes puntos al buscar conjuntos de imágenes.  
`SearchImageSets` acepta un parámetro de consulta de búsqueda único y devuelve una respuesta paginada de todos los conjuntos de imágenes que cumplen los criterios de coincidencia. Todas las consultas de intervalo de fechas se deben introducir como`(lowerBound, upperBound)`.
De forma predeterminada, `SearchImageSets` utiliza el `updatedAt` campo para ordenar en orden decreciente, del más reciente al más antiguo.
Si creó el almacén de datos con una AWS KMS clave propiedad del cliente, debe actualizar la política de AWS KMS claves antes de interactuar con los conjuntos de imágenes. Para más información, consulte [Creación de claves administradas por el cliente](data-encryption.md#creating-co-cmk).

**Para buscar conjuntos de imágenes**  
Elija un menú en función de sus preferencias de acceso a AWS HealthImaging.

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

**nota**  
Los siguientes procedimientos muestran cómo buscar conjuntos de imágenes mediante los filtros `Series Instance UID` y de `Updated at` propiedades.

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

**Busque conjuntos de imágenes mediante el filtro `Series Instance UID` de propiedades**

1. Abra la [página de almacenes de datos](https://console.aws.amazon.com/medical-imaging/home#/dataStores) de la HealthImaging consola.

1. Elija un almacén de datos.

   Se abrirá la página de **detalles del almacén de datos** y, por defecto, se seleccionará la pestaña **Conjuntos de imágenes**.

1. Elija el menú de filtros de propiedades y seleccione`Series Instance UID`.

1. En el campo **Introduzca un valor para buscar**, introduzca (pegue) el UID de instancia de serie que le interese.
**nota**  
Los valores del UID de instancia de serie deben ser idénticos a los que figuran en el [registro de identificadores únicos DICOM ()](https://dicom.nema.org/dicom/2013/output/chtml/part06/chapter_A.html). UIDs Tenga en cuenta que los requisitos incluyen una serie de números que contengan al menos un punto entre ellos. No se permiten puntos al principio o al final de la instancia de la serie UIDs. No se permiten letras ni espacios en blanco, así que tenga cuidado al copiar y pegar UIDs.

1. **Seleccione el menú **Intervalo de fechas**, seleccione un intervalo de fechas para el UID de instancia de serie y seleccione Aplicar.**

1. Elija **Buscar**.

   Las instancias de la serie UIDs que se encuentran dentro del intervalo de fechas seleccionado se devuelven en el orden más reciente de forma predeterminada.

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

**Busque conjuntos de imágenes mediante el filtro `Updated at` de propiedades**

1. Abra la [página de almacenes de datos](https://console.aws.amazon.com/medical-imaging/home#/dataStores) de la HealthImaging consola.

1. Elija un almacén de datos.

   Se abrirá la página de **detalles del almacén de datos** y, por defecto, se seleccionará la pestaña **Conjuntos de imágenes**.

1. Elija el menú de filtros de propiedades y elija`Updated at`.

1. Elija el menú **Intervalo de fechas**, seleccione un intervalo de fechas establecido para la imagen y elija **Aplicar**.

1. Elija **Buscar**.

   De forma predeterminada, los conjuntos de imágenes que se encuentran dentro del intervalo de fechas seleccionado se muestran en el orden más reciente.

------

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

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

**SDK para C\$1\$1**  
La función de utilidad para buscar conjuntos de imágenes.  

```
//! 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 de uso núm. 1: operador IGUAL.  

```
        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 de uso \$12: el operador BETWEEN usa DICOMStudy fecha y DICOMStudy hora.   

```
         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 de uso núm. 3: el operador ENTRE usa CreatedAt. Los estudios de tiempo se habían mantenido previamente.   

```
        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 de uso \$14: operador EQUAL en DICOMSeries InstanceUID y BETWEEN en UpdatedAt y ordena la respuesta en orden ASC en el 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;
            }
        }
```
+  *Para obtener más información sobre la API, consulta la Referencia de la API. [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/SearchImageSets)AWS SDK para C\$1\$1 * 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

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

**AWS CLI**  
**Ejemplo 1: búsqueda de conjuntos de imágenes con un operador EQUAL**  
En el siguiente ejemplo de código `search-image-sets` se usa el operador EQUAL para buscar conjuntos de imágenes en función de un valor específico.  

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

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

```
{
    "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"
    }]
}
```
**Ejemplo 2: Para buscar conjuntos de imágenes con un operador BETWEEN mediante DICOMStudy fecha y DICOMStudy hora**  
En el siguiente ejemplo de código `search-image-sets` se buscan conjuntos de imágenes con estudios DICOM generados entre el 1 de enero de 1990 (00:00 h) y el 1 de enero de 2023 (00:00 h).  
Nota: La DICOMStudy hora es opcional. Si no está presente, el valor de hora de las fechas indicado para el filtrado es a las 00:00 h (inicio del día).  

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

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

```
{
    "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"
    }]
}
```
**Ejemplo 3: búsqueda de conjuntos de imágenes con un operador BETWEEN mediante createdAt (los estudios de tiempo se conservaban previamente)**  
El siguiente ejemplo de `search-image-sets` código busca conjuntos de imágenes cuyos estudios DICOM persistan HealthImaging entre los intervalos de tiempo de la zona horaria UTC.  
Nota: Ingrese createdAt en el formato de ejemplo (“1985-04-12T23:20:50.52Z”).  

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

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

```
{
    "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"
    }]
}
```
**Ejemplo 4: Para buscar conjuntos de imágenes con un operador EQUAL en DICOMSeries InstanceUID y BETWEEN en UpdatedAt y ordenar la respuesta en orden ASC en el campo UpdatedAt**  
El siguiente ejemplo de `search-image-sets` código busca conjuntos de imágenes con un operador EQUAL en DICOMSeries InstanceUID y BETWEEN en UpdatedAt y ordena la respuesta en orden ASC en el campo UpdatedAt.  
Nota: Introduzca updatedAt en el formato de ejemplo ("1985-04-12T23:20:50.52Z").  

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

```
{
    "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)  
+  Para obtener más información sobre la API, consulte [SearchImageSets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/search-image-sets.html)la *Referencia de AWS CLI comandos*. 

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

**SDK para Java 2.x**  
La función de utilidad para buscar conjuntos de imágenes.  

```
    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 de uso núm. 1: operador IGUAL.  

```
        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 de uso \$12: ENTRE el operador que usa DICOMStudy fecha y DICOMStudy hora.   

```
        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 de uso núm. 3: el operador ENTRE usa CreatedAt. Los estudios de tiempo se habían mantenido previamente.   

```
        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 de uso \$14: operador EQUAL en DICOMSeries InstanceUID y BETWEEN en UpdatedAt y ordena la respuesta en orden ASC en el 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();
        }
```
+  *Para obtener más información sobre la API, consulta la Referencia de la API. [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/SearchImageSets)AWS SDK for Java 2.x * 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

**SDK para JavaScript (v3)**  
La función de utilidad para buscar conjuntos de imágenes.  

```
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 de uso núm. 1: operador IGUAL.  

```
  const datastoreId = "12345678901234567890123456789012";

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

    await searchImageSets(datastoreId, searchCriteria);
  } catch (err) {
    console.error(err);
  }
```
Caso de uso \$12: el operador BETWEEN usa DICOMStudy fecha y DICOMStudy hora.   

```
  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 de uso núm. 3: el operador ENTRE usa CreatedAt. Los estudios de tiempo se habían mantenido previamente.   

```
  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 de uso \$14: operador EQUAL en DICOMSeries InstanceUID y BETWEEN en UpdatedAt y ordena la respuesta en orden ASC en el 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);
  }
```
+  *Para obtener más información sobre la API, consulta la Referencia de la API. [SearchImageSets](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/SearchImageSetsCommand)AWS SDK para JavaScript * 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

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

**SDK para Python (Boto3)**  
La función de utilidad para buscar conjuntos de imágenes.  

```
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 de uso núm. 1: operador IGUAL.  

```
        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 de uso \$12: el operador BETWEEN usa DICOMStudy fecha y DICOMStudy hora.   

```
        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 de uso núm. 3: el operador ENTRE usa CreatedAt. Los estudios de tiempo se habían mantenido previamente.   

```
        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 de uso \$14: operador EQUAL en DICOMSeries InstanceUID y BETWEEN en UpdatedAt y ordena la respuesta en orden ASC en el 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}")
```
 MedicalImagingWrapper El siguiente código crea una instancia del objeto.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Para obtener más información sobre la API, consulta [SearchImageSets](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/SearchImageSets)la *AWS Referencia de API de SDK for Python (Boto3*). 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples). 

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

**SDK para 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.
```
+  Para obtener más información sobre la API, consulte [SearchImageSets](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*. 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

**Ejemplo de disponibilidad**  
¿No encuentra lo que necesita? Solicita un ejemplo de código mediante **el enlace Enviar comentarios** en la barra lateral derecha de esta página.

# Obtención de las propiedades del conjunto de imágenes
<a name="get-image-set-properties"></a>

Utilice la `GetImageSet` acción para devolver las propiedades de un [conjunto de imágenes](getting-started-concepts.md#concept-image-set) determinado HealthImaging. Los menús siguientes proporcionan un procedimiento para el Consola de administración de AWS y ejemplos de código para el AWS CLI y AWS SDKs. Para obtener más información, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSet.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSet.html)la *referencia de la HealthImaging API de AWS*.

**nota**  
De forma predeterminada, AWS HealthImaging devuelve las propiedades de la última versión de un conjunto de imágenes. Para ver las propiedades de una versión anterior de un conjunto de imágenes, indique la `versionId` al realizar la solicitud.  
Utilice `GetDICOMInstance` HealthImaging la representación de un DICOMweb servicio para devolver un binario (`.dcm`archivo) de una instancia DICOM. Para obtener más información, consulte [Obtener una instancia DICOM de HealthImaging](dicomweb-retrieve-instance.md).

**Cómo obtener las propiedades de un conjunto de imágenes**  
Elija un menú en función de sus preferencias de acceso a AWS HealthImaging.

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

1. Abra la [página de almacenes de datos](https://console.aws.amazon.com/medical-imaging/home#/dataStores) de la HealthImaging consola.

1. Elija un almacén de datos.

   Se abrirá la página de **detalles del almacén de datos** y, por defecto, se seleccionará la pestaña **Conjuntos de imágenes**.

1. Seleccione un conjunto de imágenes.

   Se abrirá la página de **detalles del conjunto de imágenes**, que muestra las propiedades del conjunto de imágenes.

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

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

**AWS CLI**  
**Obtención de las propiedades de un conjunto de imágenes**  
En el siguiente ejemplo de código `get-image-set` se obtienen las propiedades de un conjunto de imágenes.  

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

```
{
    "versionId": "1",
    "imageSetWorkflowStatus": "COPIED",
    "updatedAt": 1680027253.471,
    "imageSetId": "18f88ac7870584f58d56256646b4d92b",
    "imageSetState": "ACTIVE",
    "createdAt": 1679592510.753,
    "datastoreId": "12345678901234567890123456789012"
}
```
Para obtener más información, consulte [Obtener las propiedades del conjunto de imágenes](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-properties.html) en la *Guía para AWS HealthImaging desarrolladores*.  
+  Para obtener más información sobre la API, consulte [GetImageSet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set.html)la *Referencia de AWS CLI comandos*. 

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

**SDK para 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;
    }
```
+  Para obtener más información sobre la API, consulte [GetImageSet](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSet)la *Referencia AWS SDK for Java 2.x de la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

**SDK para 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;
};
```
+  Para obtener más información sobre la API, consulte [GetImageSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetCommand)la *Referencia de AWS SDK para JavaScript la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

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

**SDK para 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
```
El siguiente código crea una instancia del MedicalImagingWrapper objeto.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Para obtener más información sobre la API, consulta [GetImageSet](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSet)la *AWS Referencia de API de SDK for Python (Boto3*). 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples). 

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

**SDK para 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.
```
+  Para obtener más información sobre la API, consulte [GetImageSet](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*. 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

**Ejemplo de disponibilidad**  
¿No encuentra lo que necesita? Solicita un ejemplo de código mediante **el enlace Enviar comentarios** en la barra lateral derecha de esta página.

# Obtención de metadatos de conjuntos de imágenes
<a name="get-image-set-metadata"></a>

Utilice la `GetImageSetMetadata` acción para recuperar [los metadatos](getting-started-concepts.md#concept-metadata) de un [conjunto de imágenes](getting-started-concepts.md#concept-image-set) determinado HealthImaging. Los siguientes menús proporcionan un procedimiento para el Consola de administración de AWS y ejemplos de código para el AWS CLI y AWS SDKs. Para obtener más información, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html)la *referencia de la HealthImaging API de AWS*.

**nota**  
De forma predeterminada, HealthImaging devuelve los atributos de metadatos de la última versión de un conjunto de imágenes. Para ver los metadatos de una versión anterior de un conjunto de imágenes, indique la `versionId` al realizar la solicitud.  
Los metadatos del conjunto de imágenes se comprimen con `gzip` y se devuelven como un objeto JSON. Por lo tanto, debe descomprimir el objeto JSON antes de ver los metadatos normalizados. Para obtener más información, consulte [Normalización de metadatos](metadata-normalization.md).  
Si los metadatos de un conjunto de imágenes de gran tamaño aún se están procesando después de la importación, es `ConflictException` posible que se devuelva un 409. Vuelva a intentar la solicitud transcurridos unos segundos una vez que se complete el procesamiento.  
Utilice `GetDICOMInstanceMetadata` HealthImaging la representación de un DICOMweb servicio para devolver los metadatos de la instancia DICOM (`.json`archivo). Para obtener más información, consulte [Obtener metadatos de instancias DICOM de HealthImaging](dicomweb-retrieve-instance-metadata.md).

**Cómo obtener metadatos de conjuntos de imágenes**  
Elija un menú en función de sus preferencias de acceso a AWS HealthImaging.

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

1. Abra la [página de almacenes de datos](https://console.aws.amazon.com/medical-imaging/home#/dataStores) de la HealthImaging consola.

1. Elija un almacén de datos.

   Se abrirá la página de **detalles del almacén de datos** y, por defecto, se seleccionará la pestaña **Conjuntos de imágenes**.

1. Seleccione un conjunto de imágenes.

   Se abrirá la página de **Detalles del conjunto de imágenes**, y los metadatos del conjunto de imágenes aparecerán en la sección del **Visor de metadatos de conjuntos de imágenes**.

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

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

**SDK para C\$1\$1**  
Función de utilidad para obtener metadatos del conjunto de imágenes.  

```
//! 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();
}
```
Obtener metadatos del conjunto de imágenes sin versión.  

```
        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;
        }
```
Obtener metadatos del conjunto de imágenes con la versión.  

```
        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;
        }
```
+  Para obtener más información sobre la API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageSetMetadata)la *referencia AWS SDK para C\$1\$1 de la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

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

**AWS CLI**  
**Ejemplo 1: obtención de los metadatos de un conjunto de imágenes sin versión**  
En el siguiente ejemplo de código `get-image-set-metadata` se obtienen los metadatos de un conjunto de imágenes sin especificar una versión.  
Nota: El parámetro `outfile` es obligatorio  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id 12345678901234567890123456789012 \
    --image-set-id ea92b0d8838c72a3f25d00d13616f87e \
    studymetadata.json.gz
```
Los metadatos devueltos se comprimen con gzip y se almacenan en el archivo studymetadata.json.gz. Para ver el contenido del objeto JSON devuelto, primero debe descomprimirlo.  
Salida:  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
**Ejemplo 2: obtención de los metadatos de un conjunto de imágenes con versión**  
En el siguiente ejemplo de código `get-image-set-metadata` se obtienen los metadatos de un conjunto de imágenes con una versión especificada.  
Nota: El parámetro `outfile` es obligatorio  

```
aws medical-imaging get-image-set-metadata \
    --datastore-id 12345678901234567890123456789012 \
    --image-set-id ea92b0d8838c72a3f25d00d13616f87e \
    --version-id 1 \
    studymetadata.json.gz
```
Los metadatos devueltos se comprimen con gzip y se almacenan en el archivo studymetadata.json.gz. Para ver el contenido del objeto JSON devuelto, primero debe descomprimirlo.  
Salida:  

```
{
    "contentType": "application/json",
    "contentEncoding": "gzip"
}
```
Para obtener más información, consulta [Cómo obtener metadatos de conjuntos de imágenes](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-metadata.html) en la *Guía para AWS HealthImaging desarrolladores*.  
+  Para obtener más información sobre la API, consulte [GetImageSetMetadata](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set-metadata.html)la *Referencia de AWS CLI comandos*. 

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

**SDK para 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);
        }
    }
```
+  Para obtener más información sobre la API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSetMetadata)la *Referencia AWS SDK for Java 2.x de la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

**SDK para JavaScript (v3)**  
Función de utilidad para obtener metadatos del conjunto de imágenes.  

```
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;
};
```
Obtener metadatos del conjunto de imágenes sin versión.  

```
  try {
    await getImageSetMetadata(
      "metadata.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
Obtener metadatos del conjunto de imágenes con la versión.  

```
  try {
    await getImageSetMetadata(
      "metadata2.json.gzip",
      "12345678901234567890123456789012",
      "12345678901234567890123456789012",
      "1",
    );
  } catch (err) {
    console.log("Error", err);
  }
```
+  Para obtener más información sobre la API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetMetadataCommand)la *Referencia de AWS SDK para JavaScript la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

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

**SDK para Python (Boto3)**  
Función de utilidad para obtener metadatos del conjunto de imágenes.  

```
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
```
Obtener metadatos del conjunto de imágenes sin versión.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id, datastoreId=datastore_id
                )
```
Obtener metadatos del conjunto de imágenes con la versión.  

```
                image_set_metadata = self.health_imaging_client.get_image_set_metadata(
                    imageSetId=image_set_id,
                    datastoreId=datastore_id,
                    versionId=version_id,
                )
```
El siguiente código crea una instancia del MedicalImagingWrapper objeto.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Para obtener más información sobre la API, consulta [GetImageSetMetadata](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSetMetadata)la *AWS Referencia de API de SDK for Python (Boto3*). 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples). 

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

**SDK para 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.
```
+  Para obtener más información sobre la API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*. 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

**Ejemplo de disponibilidad**  
¿No encuentra lo que necesita? Solicita un ejemplo de código mediante **el enlace Enviar comentarios** en la barra lateral derecha de esta página.

**Transfiere metadatos de sintaxis**  
Al importar datos DICOM, HealthImaging mantiene el valor original del atributo de sintaxis de transferencia en los metadatos del conjunto de imágenes. La sintaxis de transferencia de los datos DICOM originales importados se almacena como. `TransferSyntaxUID` HealthImaging se utiliza `StoredTransferSyntaxUID` para indicar el formato utilizado para codificar los datos de los marcos de imagen en el almacén de datos: `1.2.840.10008.1.2.4.202` para los almacenes de datos habilitados para HTJ2 K (predeterminado) y `1.2.840.10008.1.2.4.90` para los almacenes de datos JPEG 2000 habilitados para Lossless.

# Obtención de datos de píxeles de los conjuntos de imágenes
<a name="get-image-frame"></a>

Los conjuntos de imágenes son la información de los píxeles existentes en un [conjunto de imágenes](getting-started-concepts.md#concept-image-frame) y que forman una imagen médica en 2D. Utilice esta `GetImageFrame` acción para recuperar un marco de imagen JPEG 2000 nativo o HTJ2 codificado en K sin pérdidas para un conjunto de [imágenes](getting-started-concepts.md#concept-image-set) determinado. HealthImaging En los menús siguientes se proporcionan ejemplos de código para las letras y. AWS CLI AWS SDKs Para obtener más información, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)la *referencia de la HealthImaging API de AWS*.

**nota**  
Tenga en cuenta los siguientes puntos al utilizar la `GetImageFrame` acción:  
Durante la [importación](importing-imaging-data.md), HealthImaging conserva la codificación de algunas sintaxis de transferencia y transcodifica otras a HTJ2 K lossless (predeterminado) o JPEG 2000 Lossless. La `GetImageFrame` acción devuelve el marco de la imagen en la sintaxis de transferencia almacenada de la instancia. No se realiza ninguna transcodificación durante la recuperación para garantizar una latencia de recuperación mínima. Es posible que sea necesario decodificar los fotogramas de imagen antes de visualizarlos en un visor de imágenes, según la sintaxis de transferencia. Para obtener más información, consulte [Sintaxis de transferencia compatibles](supported-transfer-syntaxes.md) y [Bibliotecas de decodificación de marcos de imágenes](reference-libraries.md).
[En el caso de los casos almacenados HealthImaging con uno o más fotogramas de imagen codificados en la familia de sintaxis de transferencia MPEG (que incluye MPEG-4 AVC/H.264 and HEVC/H .265) MPEG2, la `GetImageFrame` acción devolverá un objeto de vídeo con la sintaxis de transferencia almacenada.](supported-transfer-syntaxes.md)
La sintaxis de transferencia de los fotogramas de imagen se especifica en el elemento de respuesta del encabezado. `Content-Type HTTP` Por ejemplo, un marco de imagen codificado en HTJ2 K. tendrá`Content-Type: image/jph header`. Para obtener más información, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)la *referencia de la HealthImaging API de AWS*.
También puede utilizar `GetDICOMInstanceFrames` HealthImaging la representación de un DICOMweb servicio para recuperar marcos de instancias DICOM (`multipart`solicitud) para aplicaciones y visores DICOMweb compatibles. Para obtener más información, consulte [Obtener marcos de instancia DICOM de HealthImaging](dicomweb-retrieve-instance-frames.md).

**Obtención de datos de píxeles de un conjunto de imágenes**  
Elija un menú en función de sus preferencias de acceso a AWS HealthImaging.

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

**nota**  
Los marcos de imágenes deben decodificarse y se debe acceder a ellos mediante programación, ya que no hay un visor de imágenes disponible en la Consola de administración de AWS.  
Para más información sobre la decodificación y la visualización de marcos de imágenes, consulte [Bibliotecas de decodificación de marcos de imágenes](reference-libraries.md).

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

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

**SDK para 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();
}
```
+  Para obtener más información sobre la API, consulte [GetImageFrame](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageFrame)la *referencia AWS SDK para C\$1\$1 de la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples). 

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

**AWS CLI**  
**Obtención de datos de píxeles de un conjunto de imágenes**  
En el siguiente ejemplo de código `get-image-frame` se obtiene un marco de una imagen.  

```
aws medical-imaging get-image-frame \
    --datastore-id "12345678901234567890123456789012" \
    --image-set-id "98765412345612345678907890789012" \
    --image-frame-information imageFrameId=3abf5d5d7ae72f80a0ec81b2c0de3ef4 \
    imageframe.jph
```
Nota: Este ejemplo de código no incluye la salida porque la GetImageFrame acción devuelve un flujo de datos de píxeles al archivo imageframe.jph. Para obtener información sobre la decodificación y la visualización de marcos de imágenes, consulte las bibliotecas de decodificación K. HTJ2  
Para obtener más información, consulte [Obtener datos de píxeles de conjuntos de imágenes](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-frame.html) en la *Guía para AWS HealthImaging desarrolladores*.  
+  Para obtener más información sobre la API, consulte [GetImageFrame](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-frame.html)la *Referencia de AWS CLI comandos*. 

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

**SDK para 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);
                }
        }
```
+  Para obtener más información sobre la API, consulte [GetImageFrame](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageFrame)la *Referencia AWS SDK for Java 2.x de la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples). 

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

**SDK para 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;
};
```
+  Para obtener más información sobre la API, consulte [GetImageFrame](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageFrameCommand)la *Referencia de AWS SDK para JavaScript la API*. 
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples). 

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

**SDK para 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
```
El siguiente código crea una instancia del MedicalImagingWrapper objeto.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Para obtener más información sobre la API, consulta [GetImageFrame](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageFrame)la *AWS Referencia de API de SDK for Python (Boto3*). 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/medical-imaging#code-examples). 

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

**SDK para 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.
```
+  Para obtener más información sobre la API, consulte [GetImageFrame](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*. 
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples). 

------

**Ejemplo de disponibilidad**  
¿No encuentra lo que necesita? Solicita un ejemplo de código mediante **el enlace Enviar comentarios** en la barra lateral derecha de esta página.