As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Acessando conjuntos de imagens com a AWS HealthImaging
O acesso a dados de imagens médicas na AWS HealthImaging normalmente envolve pesquisar um [conjunto de imagens](getting-started-concepts.md#concept-image-set) com uma chave exclusiva e obter os [metadados](getting-started-concepts.md#concept-metadata) e [quadros de imagem](getting-started-concepts.md#concept-image-frame) associados (dados em pixels).
**Importante**
Durante a importação, HealthImaging processa os binários da instância DICOM (`.dcm`arquivos) e os transforma em conjuntos de imagens. Use [ações nativas da HealthImaging nuvem](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_Operations.html) (APIs) para gerenciar armazenamentos de dados e conjuntos de imagens. Use HealthImaging a [representação dos DICOMweb serviços](dicomweb-retrieve.md) para retornar DICOMweb respostas.
Os tópicos a seguir explicam como usar ações nativas da HealthImaging nuvem no Console de gerenciamento da AWS, AWS CLI, e AWS SDKs pesquisar conjuntos de imagens e obter suas propriedades, metadados e quadros de imagem associados.
**Topics**
+ [Noções básicas sobre conjuntos de imagem](understanding-image-sets.md)
+ [Pesquisar conjuntos de imagens](search-image-sets.md)
+ [Obtendo propriedades do conjunto de imagens](get-image-set-properties.md)
+ [Obtendo metadados do conjunto de imagens](get-image-set-metadata.md)
+ [Obtendo dados de pixels do conjunto de imagens](get-image-frame.md)
# Noções básicas sobre conjuntos de imagem
Os conjuntos de imagens AWS se assemelham a uma série DICOM e servem como base para a AWS. HealthImaging Os conjuntos de imagens são criados quando você importa seus dados DICOM para o. HealthImaging O serviço tenta organizar os dados P10 importados de acordo com a hierarquia DICOM de estudo, série e instância.
Os conjuntos de imagem foram introduzidos pelos seguintes motivos:
+ Support uma ampla variedade de fluxos de trabalho de imagens médicas (clínicos e não clínicos) por meio da flexibilidade. APIs
+ Forneça um mecanismo para armazenar e reconciliar dados duplicados e inconsistentes de forma durável. Os dados P10 importados que estejam em conflito com conjuntos de imagens primárias que já estão em um armazenamento permanecerão como não primários. Depois de resolver os conflitos de metadados, esses dados podem se tornar primários.
+ Maximize a segurança do paciente agrupando somente dados relacionados.
+ Incentive a limpeza dos dados para ajudar a aumentar a visibilidade das inconsistências. Para obter mais informações, consulte [Modificar os conjuntos de imagens](modifying-image-sets.md).
**Importante**
O uso clínico dos dados DICOM antes de serem limpos pode resultar em danos ao paciente.
Os menus a seguir descrevem conjuntos de imagens com mais detalhes e fornecem exemplos e diagramas para ajudá-lo a compreender sua funcionalidade e finalidade em. HealthImaging
## O que é um conjunto de imagens?
Um conjunto de imagens é um AWS conceito que define um mecanismo de agrupamento abstrato para otimizar dados relacionados de imagens médicas que se assemelham muito a uma série DICOM. Quando você importa seus dados de imagem DICOM P10 para um armazenamento de HealthImaging dados da AWS, eles são transformados em conjuntos de imagens compostos por [metadados](getting-started-concepts.md#concept-metadata) e [quadros de imagem](getting-started-concepts.md#concept-image-frame) (dados em pixels).
**nota**
Os metadados do conjunto de imagens são [normalizados](metadata-normalization.md). Em outras palavras, um conjunto comum de atributos e valores mapeia os elementos de nível Paciente, Estudo e Série listados no [Registro de Elementos de Dados DICOM](https://dicom.nema.org/medical/dicom/2022b/output/html/part06.html#table_6-1). HealthImaging usa os seguintes elementos DICOM ao agrupar objetos DICOM P10 de entrada em conjuntos de imagens.
**Elementos DICOM usados para criação de conjuntos de imagens**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/healthimaging/latest/devguide/understanding-image-sets.html)
Durante a importação, alguns conjuntos de imagens mantêm a codificação da sintaxe de transferência original, enquanto outros são transcodificados para JPEG 2000 (K) de alto rendimento sem perdas por padrão. HTJ2 Se um conjunto de imagens for codificado em HTJ2 K, ele deverá ser decodificado antes da visualização. Para obter mais informações, consulte [Sintaxes de transferência compatíveis](supported-transfer-syntaxes.md) e [Bibliotecas de decodificação de quadros de imagem](reference-libraries.md).
Os quadros de imagem (dados em pixels) são codificados em JPEG 2000 (HTJ2K) de alto rendimento e devem ser [decodificados](reference-libraries.md) antes da visualização.
Os conjuntos de imagens são AWS recursos, então eles são atribuídos aos [Amazon Resource Names (ARNs)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Eles podem ser marcados com até 50 pares de valor-chave e podem receber [controle de acesso por perfil (RBAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) e [controle de acesso por atributo (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html) por meio do IAM. Além disso, os conjuntos de imagens são [versionados](list-image-set-versions.md) para que todas as alterações sejam preservadas e as versões anteriores possam ser acessadas.
A importação de dados DICOM P10 resulta em conjuntos de imagens que contêm metadados DICOM e quadros de imagem para uma ou mais instâncias de par de objetos de serviço (SOP) na mesma série DICOM.
![\[Diagrama mostrando o que é um conjunto de imagens na AWS HealthImaging.\]](http://docs.aws.amazon.com/pt_br/healthimaging/latest/devguide/images/image-set-what-is.png)
**nota**
Trabalhos de importação de DICOM:
Sempre crie novos conjuntos de imagens ou incremente a versão dos conjuntos de imagens existentes.
Não desduplique o armazenamento da instância SOP. Cada importação da mesma instância SOP usa armazenamento adicional como um novo conjunto de imagens não primárias ou versão incrementada de um conjunto de imagens primárias existente.
Organize automaticamente instâncias de SOP com metadados consistentes e não conflitantes como conjuntos de imagens primárias, que contêm instâncias com elementos consistentes de metadados de pacientes, estudos e séries.
Se as instâncias que compõem uma série DICOM forem importadas em duas ou mais tarefas de importação e não entrarem em conflito com as instâncias que já estão no armazenamento de dados, todas as instâncias serão organizadas em um conjunto de imagens primárias.
Crie conjuntos de imagens não primárias contendo dados DICOM P10 que estejam em conflito com conjuntos de imagens primárias que já estão no armazenamento de dados.
Mantenha os dados recebidos mais recentemente como a versão mais recente de um conjunto de imagens primárias.
Se as instâncias que compõem uma série DICOM forem conjuntos de imagens primárias e uma instância for importada novamente, a nova cópia será inserida no conjunto de imagens primário e a versão será incrementada.
## Qual é a aparência dos metadados do conjunto de imagens?
Use a `GetImageSetMetadata` ação para recuperar os metadados do conjunto de imagens. Os metadados retornados são compactados com`gzip`, portanto, você deve descompactá-los antes de visualizá-los. Para obter mais informações, consulte [Obtendo metadados do conjunto de imagens](get-image-set-metadata.md).
O exemplo a seguir mostra a estrutura dos [metadados](getting-started-concepts.md#concept-metadata) do conjunto de imagens no 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
}
]
}
}
}
}
}
}
```
## Exemplo de criação de conjunto de imagens: vários trabalhos de importação
O exemplo a seguir mostra como várias tarefas de importação sempre criam novos conjuntos de imagens e *nunca* são adicionados aos existentes.
![\[Diagrama mostrando a aparência dos trabalhos de importação de vários conjuntos de imagens HealthImaging.\]](http://docs.aws.amazon.com/pt_br/healthimaging/latest/devguide/images/image-set-example-multiple-import-jobs.png)
## Exemplo de criação de conjunto de imagens: tarefa de importação única com duas variantes
O exemplo a seguir mostra um único trabalho de importação que não seria mesclado em um único conjunto de imagens porque as instâncias 1 e 3 têm um paciente IDs diferente das instâncias 2 e 4. Para resolver isso, você pode usar a `UpdateImageSetMetadata` ação para resolver o conflito de ID do paciente com o conjunto de imagens primárias existente. Depois que os conflitos forem resolvidos, você poderá usar a `CopyImageSet` ação com o argumento `--promoteToPrimary` para adicionar o conjunto de imagens ao conjunto de imagens primárias.
![\[Diagrama mostrando a aparência de duas variantes do conjunto de imagens HealthImaging ao usar uma única tarefa de importação.\]](http://docs.aws.amazon.com/pt_br/healthimaging/latest/devguide/images/image-set-example-import-two-variants.png)
## Exemplo de criação de conjunto de imagens: tarefa de importação única com otimização
O exemplo a seguir mostra um único trabalho de importação criando dois conjuntos de imagens para melhorar a produtividade, mesmo que os nomes dos pacientes sejam iguais.
![\[Diagrama mostrando a aparência da otimização do conjunto de imagens HealthImaging ao usar uma única tarefa de importação.\]](http://docs.aws.amazon.com/pt_br/healthimaging/latest/devguide/images/image-set-example-optimization.png)
# Pesquisar conjuntos de imagens
Use a `SearchImageSets` ação para executar consultas de pesquisa em todos os [conjuntos de imagens](getting-started-concepts.md#concept-image-set) em um armazenamento de `ACTIVE` HealthImaging dados. Os menus a seguir fornecem um procedimento para o Console de gerenciamento da AWS e exemplos de código para AWS CLI AWS SDKs e. Para obter mais informações, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_SearchImageSets.html)a *AWS HealthImaging API Reference*.
**nota**
Lembre-se dos seguintes pontos ao pesquisar conjuntos de imagens.
`SearchImageSets` aceita um único parâmetro de consulta de pesquisa e retorna uma resposta paginada de todos os conjuntos de imagens que têm os critérios correspondentes. Todas as consultas de intervalo de datas devem ser inseridas como`(lowerBound, upperBound)`.
Por padrão, `SearchImageSets` usa o `updatedAt` campo para classificar em ordem decrescente do mais novo para o mais antigo.
Se você criou seu armazenamento de dados com uma AWS KMS chave de propriedade do cliente, deverá atualizar sua política de AWS KMS chaves antes de interagir com conjuntos de imagens. Para obter mais informações sobre chaves gerenciadas pelo cliente, consulte [Criar uma chave gerenciada pelo cliente](data-encryption.md#creating-co-cmk).
**Para pesquisar conjuntos de imagens**
Escolha um menu com base na sua preferência de acesso à AWS HealthImaging.
## AWS Console
**nota**
Os procedimentos a seguir mostram como pesquisar conjuntos de imagens usando os filtros de `Updated at` propriedades `Series Instance UID` e.
------
#### [ Series Instance UID ]
**Pesquise conjuntos de imagens usando o filtro de `Series Instance UID` propriedades**
1. Abra a [página Armazenamentos de dados](https://console.aws.amazon.com/medical-imaging/home#/dataStores) do HealthImaging console.
1. Escolha um datastore.
A página **Detalhes do datastore** é aberta e a guia **Conjuntos de imagens** é selecionada por padrão.
1. Escolha o menu de filtro de propriedades e selecione`Series Instance UID`.
1. No campo **Inserir valor para pesquisar**, insira (cole) o UID da instância de série de interesse.
**nota**
Os valores de UID da instância em série devem ser idênticos aos listados no [Registro de identificadores exclusivos DICOM](https://dicom.nema.org/dicom/2013/output/chtml/part06/chapter_A.html) (). UIDs Observe que os requisitos incluem uma série de números que contêm pelo menos um ponto entre eles. Períodos não são permitidos no início ou no final da Instância em Série UIDs. Letras e espaços em branco não são permitidos, portanto, tenha cuidado ao copiar e colar. UIDs
1. Escolha o menu **Intervalo de datas**, selecione um intervalo de datas para o UID da instância de série e escolha **Aplicar**.
1. Selecione a opção **Pesquisar**.
As instâncias em série UIDs que se enquadram no intervalo de datas selecionado são retornadas na ordem mais recente por padrão.
------
#### [ Updated at ]
**Pesquise conjuntos de imagens usando o filtro de `Updated at` propriedades**
1. Abra a [página Armazenamentos de dados](https://console.aws.amazon.com/medical-imaging/home#/dataStores) do HealthImaging console.
1. Escolha um datastore.
A página **Detalhes do datastore** é aberta e a guia **Conjuntos de imagens** é selecionada por padrão.
1. Escolha o menu de filtro de propriedades e escolha`Updated at`.
1. Escolha o menu **Intervalo de datas**, selecione um intervalo de datas do conjunto de imagens e escolha **Aplicar**.
1. Selecione a opção **Pesquisar**.
Os conjuntos de imagens que se enquadram no intervalo de datas selecionado são retornados na ordem mais recente por padrão.
------
## AWS CLI and SDKs
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
A função de utilitário para pesquisar conjuntos de imagens.
```
//! 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 &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º 1: operador EQUAL.
```
Aws::Vector imageIDsForPatientID;
Aws::MedicalImaging::Model::SearchCriteria searchCriteriaEqualsPatientID;
Aws::Vector 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: operador BETWEEN usando DICOMStudy data e 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 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º 3: operador BETWEEN usando o createdAt. Os estudos de tempo foram previamente persistidos.
```
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 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 em DICOMSeries InstanceUID e BETWEEN em updatedAt e classifique a resposta em ordem ASC no 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 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 obter detalhes da API, consulte [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/SearchImageSets)a *Referência AWS SDK para C\$1\$1 da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples).
------
#### [ CLI ]
**AWS CLI**
**Exemplo 1: para pesquisar conjuntos de imagens com um operador EQUAL**
O exemplo de código `search-image-sets` a seguir usa o operador EQUAL para pesquisar conjuntos de imagens com base em um valor específico.
```
aws medical-imaging search-image-sets \
--datastore-id 12345678901234567890123456789012 \
--search-criteria file://search-criteria.json
```
Conteúdo de `search-criteria.json`
```
{
"filters": [{
"values": [{"DICOMPatientId" : "SUBJECT08701"}],
"operator": "EQUAL"
}]
}
```
Saída:
```
{
"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"
}]
}
```
**Exemplo 2: Para pesquisar conjuntos de imagens com um operador BETWEEN usando DICOMStudy data e DICOMStudy hora**
O exemplo de código `search-image-sets` a seguir pesquisa conjuntos de imagens com estudos DICOM gerados entre 1º de janeiro de 1990 (00h) e 1º de janeiro de 2023 (00h).
Observação: DICOMStudy o horário é opcional. Se não estiver presente, 00h (início do dia) é o valor da hora para as datas fornecidas para filtragem.
```
aws medical-imaging search-image-sets \
--datastore-id 12345678901234567890123456789012 \
--search-criteria file://search-criteria.json
```
Conteúdo de `search-criteria.json`
```
{
"filters": [{
"values": [{
"DICOMStudyDateAndTime": {
"DICOMStudyDate": "19900101",
"DICOMStudyTime": "000000"
}
},
{
"DICOMStudyDateAndTime": {
"DICOMStudyDate": "20230101",
"DICOMStudyTime": "000000"
}
}],
"operator": "BETWEEN"
}]
}
```
Saída:
```
{
"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"
}]
}
```
**Exemplo 3: para pesquisar conjuntos de imagens com um operador BETWEEN usando createdAt (os estudos de tempo persistiam anteriormente)**
O exemplo de `search-image-sets` código a seguir pesquisa conjuntos de imagens com estudos DICOM persistentes HealthImaging entre os intervalos de tempo no fuso horário UTC.
Observação: forneça createdAt no formato do exemplo ("1985-04-12T23:20:50.52Z").
```
aws medical-imaging search-image-sets \
--datastore-id 12345678901234567890123456789012 \
--search-criteria file://search-criteria.json
```
Conteúdo de `search-criteria.json`
```
{
"filters": [{
"values": [{
"createdAt": "1985-04-12T23:20:50.52Z"
},
{
"createdAt": "2022-04-12T23:20:50.52Z"
}],
"operator": "BETWEEN"
}]
}
```
Saída:
```
{
"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"
}]
}
```
**Exemplo 4: Para pesquisar conjuntos de imagens com um operador EQUAL em DICOMSeries InstanceUID e BETWEEN em updatedAt e classificar a resposta em ordem ASC no campo updatedAt**
O exemplo de `search-image-sets` código a seguir pesquisa conjuntos de imagens com um operador EQUAL em DICOMSeries InstanceUID e BETWEEN em updatedAt e classifica a resposta em ordem ASC no campo updatedAt.
Observação: forneça updatedAt no formato do exemplo ("1985-04-12T23:20:50.52Z").
```
aws medical-imaging search-image-sets \
--datastore-id 12345678901234567890123456789012 \
--search-criteria file://search-criteria.json
```
Conteúdo 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"
}
}
```
Saída:
```
{
"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"
}]
}
```
Para obter mais informações, consulte [Pesquisar conjuntos de imagens](https://docs.aws.amazon.com/healthimaging/latest/devguide/search-image-sets.html) no *Guia do AWS HealthImaging desenvolvedor*.
+ Para obter detalhes da API, consulte [SearchImageSets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/search-image-sets.html)na *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
A função de utilitário para pesquisar conjuntos de imagens.
```
public static List searchMedicalImagingImageSets(
MedicalImagingClient medicalImagingClient,
String datastoreId, SearchCriteria searchCriteria) {
try {
SearchImageSetsRequest datastoreRequest = SearchImageSetsRequest.builder()
.datastoreId(datastoreId)
.searchCriteria(searchCriteria)
.build();
SearchImageSetsIterable responses = medicalImagingClient
.searchImageSetsPaginator(datastoreRequest);
List 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º 1: operador EQUAL.
```
List searchFilters = Collections.singletonList(SearchFilter.builder()
.operator(Operator.EQUAL)
.values(SearchByAttributeValue.builder()
.dicomPatientId(patientId)
.build())
.build());
SearchCriteria searchCriteria = SearchCriteria.builder()
.filters(searchFilters)
.build();
List 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: operador BETWEEN usando DICOMStudy data e 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º 3: operador BETWEEN usando o createdAt. Os estudos de tempo foram previamente persistidos.
```
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 em DICOMSeries InstanceUID e BETWEEN em updatedAt e classifique a resposta em ordem ASC no 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 obter detalhes da API, consulte [SearchImageSets](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/SearchImageSets)a *Referência AWS SDK for Java 2.x da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples).
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
A função de utilitário para pesquisar conjuntos de imagens.
```
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º 1: operador EQUAL.
```
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: operador BETWEEN usando DICOMStudy data e 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º 3: operador BETWEEN usando o createdAt. Os estudos de tempo foram previamente persistidos.
```
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 em DICOMSeries InstanceUID e BETWEEN em updatedAt e classifique a resposta em ordem ASC no 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 obter detalhes da API, consulte [SearchImageSets](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/SearchImageSetsCommand)a *Referência AWS SDK para JavaScript da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples).
------
#### [ Python ]
**SDK para Python (Boto3)**
A função de utilitário para pesquisar conjuntos de imagens.
```
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º 1: operador EQUAL.
```
search_filter = {
"filters": [
{"operator": "EQUAL", "values": [{"DICOMPatientId": patient_id}]}
]
}
image_sets = self.search_image_sets(data_store_id, search_filter)
print(f"Image sets found with EQUAL operator\n{image_sets}")
```
Caso de uso \$12: operador BETWEEN usando DICOMStudy data e 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º 3: operador BETWEEN usando o createdAt. Os estudos de tempo foram previamente persistidos.
```
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 em DICOMSeries InstanceUID e BETWEEN em updatedAt e classifique a resposta em ordem ASC no 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}")
```
O código a seguir instancia o MedicalImagingWrapper objeto.
```
client = boto3.client("medical-imaging")
medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+ Para obter detalhes da API, consulte a [SearchImageSets](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/SearchImageSets)Referência da API *AWS SDK for Python (Boto3*).
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte a [SearchImageSets](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples).
------
**Exemplo de disponibilidade**
Não consegue encontrar o que precisa? Solicite um exemplo de código usando o link **Fornecer feedback** na barra lateral direita desta página.
# Obtendo propriedades do conjunto de imagens
Use a `GetImageSet` ação para retornar as propriedades de uma determinada [imagem configurada](getting-started-concepts.md#concept-image-set) HealthImaging. Os menus a seguir fornecem um procedimento para o Console de gerenciamento da AWS e exemplos de código para AWS CLI AWS SDKs e. Para obter mais informações, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSet.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSet.html)a *AWS HealthImaging API Reference*.
**nota**
Por padrão, a AWS HealthImaging retorna propriedades para a versão mais recente de um conjunto de imagens. Para visualizar as propriedades de uma versão mais antiga de um conjunto de imagens, forneça o `versionId` com sua solicitação.
Use `GetDICOMInstance` HealthImaging a representação de um DICOMweb serviço para retornar um binário de instância DICOM (`.dcm`arquivo). Para obter mais informações, consulte [Obtendo uma instância DICOM de HealthImaging](dicomweb-retrieve-instance.md).
**Para obter as propriedades do conjunto de imagens**
Escolha um menu com base na sua preferência de acesso à AWS HealthImaging.
## AWS Console
1. Abra a [página Armazenamentos de dados](https://console.aws.amazon.com/medical-imaging/home#/dataStores) do HealthImaging console.
1. Escolha um datastore.
A página **Detalhes do datastore** é aberta e a guia **Conjuntos de imagens** é selecionada por padrão.
1. Escolha um conjunto de imagem.
A página **Detalhes do conjunto de imagens** é aberta e exibe as propriedades do conjunto de imagens.
## AWS CLI and SDKs
------
#### [ CLI ]
**AWS CLI**
**Para obter as propriedades do conjunto de imagens**
O exemplo de código `get-image-set` a seguir obtém as propriedades de um conjunto de imagens.
```
aws medical-imaging get-image-set \
--datastore-id 12345678901234567890123456789012 \
--image-set-id 18f88ac7870584f58d56256646b4d92b \
--version-id 1
```
Saída:
```
{
"versionId": "1",
"imageSetWorkflowStatus": "COPIED",
"updatedAt": 1680027253.471,
"imageSetId": "18f88ac7870584f58d56256646b4d92b",
"imageSetState": "ACTIVE",
"createdAt": 1679592510.753,
"datastoreId": "12345678901234567890123456789012"
}
```
Para obter mais informações, consulte [Como obter propriedades do conjunto de imagens](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-properties.html) no *Guia do AWS HealthImaging desenvolvedor*.
+ Para obter detalhes da API, consulte [GetImageSet](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set.html)em *Referência 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 obter detalhes da API, consulte [GetImageSet](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSet)a *Referência AWS SDK for Java 2.x da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte [GetImageSet](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetCommand)a *Referência AWS SDK para JavaScript da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
O código a seguir instancia o MedicalImagingWrapper objeto.
```
client = boto3.client("medical-imaging")
medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+ Para obter detalhes da API, consulte a [GetImageSet](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSet)Referência da API *AWS SDK for Python (Boto3*).
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte a [GetImageSet](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples).
------
**Exemplo de disponibilidade**
Não consegue encontrar o que precisa? Solicite um exemplo de código usando o link **Fornecer feedback** na barra lateral direita desta página.
# Obtendo metadados do conjunto de imagens
Use a `GetImageSetMetadata` ação para recuperar [metadados](getting-started-concepts.md#concept-metadata) de uma determinada [imagem definida](getting-started-concepts.md#concept-image-set) em. HealthImaging Os menus a seguir fornecem um procedimento para o Console de gerenciamento da AWS e exemplos de código para AWS CLI AWS SDKs e. Para obter mais informações, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageSetMetadata.html)a *AWS HealthImaging API Reference*.
**nota**
Por padrão, HealthImaging retorna atributos de metadados para a versão mais recente de um conjunto de imagens. Para visualizar os metadados de uma versão mais antiga de um conjunto de imagens, forneça o `versionId` com sua solicitação.
Os metadados do conjunto de imagens são compactados com `gzip` e retornados como um objeto JSON. Portanto, você deve descompactar o objeto JSON antes de visualizar os metadados normalizados. Para obter mais informações, consulte [Normalização de metadados](metadata-normalization.md).
Se os metadados de um grande conjunto de imagens ainda estiverem sendo processados após a importação, um 409 `ConflictException` poderá ser retornado. Repita a solicitação após alguns segundos após a conclusão do processamento.
Use `GetDICOMInstanceMetadata` HealthImaging a representação de um DICOMweb serviço para retornar metadados da instância DICOM (`.json`arquivo). Para obter mais informações, consulte [Obtendo metadados da instância DICOM de HealthImaging](dicomweb-retrieve-instance-metadata.md).
**Para obter metadados do conjunto de imagens**
Escolha um menu com base na sua preferência de acesso à AWS HealthImaging.
## AWS Console
1. Abra a [página Armazenamentos de dados](https://console.aws.amazon.com/medical-imaging/home#/dataStores) do HealthImaging console.
1. Escolha um datastore.
A página **Detalhes do datastore** é aberta e a guia **Conjuntos de imagens** é selecionada por padrão.
1. Escolha um conjunto de imagem.
A página **Detalhes do conjunto de imagens** é aberta e os metadados do conjunto de imagens são exibidos na seção **Visualizador de metadados do conjunto de imagens**.
## AWS CLI and SDKs
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Função de utilitário para obter metadados do conjunto de imagens.
```
//! 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();
}
```
Obter metadados do conjunto de imagens sem versão.
```
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;
}
```
Obter metadados do conjunto de imagens com versão.
```
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 obter detalhes da API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageSetMetadata)a *Referência AWS SDK para C\$1\$1 da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples).
------
#### [ CLI ]
**AWS CLI**
**Exemplo 1: para obter os metadados de um conjunto de imagens sem versão**
O exemplo de código `get-image-set-metadata` a seguir obtém metadados para um conjunto de imagens sem especificar uma versão.
Observação: `outfile` é um parâmetro obrigatório
```
aws medical-imaging get-image-set-metadata \
--datastore-id 12345678901234567890123456789012 \
--image-set-id ea92b0d8838c72a3f25d00d13616f87e \
studymetadata.json.gz
```
Os metadados retornados são compactados com o gzip e armazenados no arquivo studymetadata.json.gz. Para visualizar o conteúdo do objeto JSON retornado, você deve primeiro descompactá-lo.
Saída:
```
{
"contentType": "application/json",
"contentEncoding": "gzip"
}
```
**Exemplo 2: para obter os metadados de um conjunto de imagens com versão**
O exemplo de código `get-image-set-metadata` a seguir obtém metadados para um conjunto de imagens com uma versão especificada.
Observação: `outfile` é um parâmetro obrigatório
```
aws medical-imaging get-image-set-metadata \
--datastore-id 12345678901234567890123456789012 \
--image-set-id ea92b0d8838c72a3f25d00d13616f87e \
--version-id 1 \
studymetadata.json.gz
```
Os metadados retornados são compactados com o gzip e armazenados no arquivo studymetadata.json.gz. Para visualizar o conteúdo do objeto JSON retornado, você deve primeiro descompactá-lo.
Saída:
```
{
"contentType": "application/json",
"contentEncoding": "gzip"
}
```
Para obter mais informações, consulte [Obter metadados do conjunto de imagens](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-set-metadata.html) no *Guia do AWS HealthImaging desenvolvedor*.
+ Para obter detalhes da API, consulte [GetImageSetMetadata](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-set-metadata.html)em *Referência 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 obter detalhes da API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageSetMetadata)a *Referência AWS SDK for Java 2.x da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/medicalimaging#code-examples).
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Função de utilitário para obter metadados do conjunto de imagens.
```
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: [ IncomingMessage {}
// }
return response;
};
```
Obter metadados do conjunto de imagens sem versão.
```
try {
await getImageSetMetadata(
"metadata.json.gzip",
"12345678901234567890123456789012",
"12345678901234567890123456789012",
);
} catch (err) {
console.log("Error", err);
}
```
Obter metadados do conjunto de imagens com versão.
```
try {
await getImageSetMetadata(
"metadata2.json.gzip",
"12345678901234567890123456789012",
"12345678901234567890123456789012",
"1",
);
} catch (err) {
console.log("Error", err);
}
```
+ Para obter detalhes da API, consulte [GetImageSetMetadata](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageSetMetadataCommand)a *Referência AWS SDK para JavaScript da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/medical-imaging#code-examples).
------
#### [ Python ]
**SDK para Python (Boto3)**
Função de utilitário para obter metadados do conjunto de imagens.
```
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
```
Obter metadados do conjunto de imagens sem versão.
```
image_set_metadata = self.health_imaging_client.get_image_set_metadata(
imageSetId=image_set_id, datastoreId=datastore_id
)
```
Obter metadados do conjunto de imagens com versão.
```
image_set_metadata = self.health_imaging_client.get_image_set_metadata(
imageSetId=image_set_id,
datastoreId=datastore_id,
versionId=version_id,
)
```
O código a seguir instancia o MedicalImagingWrapper objeto.
```
client = boto3.client("medical-imaging")
medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+ Para obter detalhes da API, consulte a [GetImageSetMetadata](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageSetMetadata)Referência da API *AWS SDK for Python (Boto3*).
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte a [GetImageSetMetadata](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples).
------
**Exemplo de disponibilidade**
Não consegue encontrar o que precisa? Solicite um exemplo de código usando o link **Fornecer feedback** na barra lateral direita desta página.
**Metadados da sintaxe de transferência**
Ao importar dados DICOM, HealthImaging mantém o valor original do atributo de sintaxe de transferência nos metadados do conjunto de imagens. A sintaxe de transferência dos dados DICOM originais importados é armazenada como. `TransferSyntaxUID` HealthImaging usa `StoredTransferSyntaxUID` para indicar o formato usado para codificar dados do quadro de imagem no armazenamento de dados: `1.2.840.10008.1.2.4.202` para armazenamentos de dados habilitados para HTJ2 K (padrão) e para armazenamentos de dados habilitados `1.2.840.10008.1.2.4.90` para JPEG 2000 Lossless.
# Obtendo dados de pixels do conjunto de imagens
Um [quadro de imagem](getting-started-concepts.md#concept-image-frame) são os dados de pixel que existem em um conjunto de imagens para formar uma imagem médica 2D. [Use a `GetImageFrame` ação para recuperar um quadro de imagem sem perdas JPEG 2000 nativo ou HTJ2 codificado em K para uma determinada imagem configurada.](getting-started-concepts.md#concept-image-set) HealthImaging Os menus a seguir fornecem exemplos de código para AWS CLI AWS SDKs e. Para obter mais informações, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)a *AWS HealthImaging API Reference*.
**nota**
Lembre-se dos seguintes pontos ao usar a `GetImageFrame` ação:
Durante a [importação](importing-imaging-data.md), HealthImaging retém a codificação de algumas sintaxes de transferência e transcodifica outras para HTJ2 K lossless (padrão) ou JPEG 2000 Lossless. A `GetImageFrame` ação retorna o quadro da imagem na sintaxe de transferência armazenada da instância. Nenhuma transcodificação é realizada durante a recuperação para garantir uma latência mínima de recuperação. Os quadros de imagem talvez precisem ser decodificados antes da visualização em um visualizador de imagens, dependendo da sintaxe de transferência. Para obter mais informações, consulte [Sintaxes de transferência compatíveis](supported-transfer-syntaxes.md) e [Bibliotecas de decodificação de quadros de imagem](reference-libraries.md).
[Para instâncias armazenadas HealthImaging com um ou mais quadros de imagem codificados na família MPEG de sintaxes de transferência (que inclui MPEG-4 AVC/H.264 and HEVC/H .265) MPEG2, a `GetImageFrame` ação retornará um objeto de vídeo na sintaxe de transferência armazenada.](supported-transfer-syntaxes.md)
A sintaxe de transferência dos quadros de imagem é especificada no elemento de resposta do `Content-Type HTTP` cabeçalho. Por exemplo, um quadro de imagem codificado em HTJ2 K terá`Content-Type: image/jph header`. Para obter mais informações, consulte [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_GetImageFrame.html)a *AWS HealthImaging API Reference*.
Você também pode usar `GetDICOMInstanceFrames` a representação HealthImaging de um DICOMweb serviço para recuperar quadros de instância DICOM (`multipart`solicitação) para visualizadores e DICOMweb aplicativos compatíveis. Para obter mais informações, consulte [Obtendo quadros de instância DICOM de HealthImaging](dicomweb-retrieve-instance-frames.md).
**Para obter dados de pixels do conjunto de imagens**
Escolha um menu com base na sua preferência de acesso à AWS HealthImaging.
## AWS Console
**nota**
Os quadros de imagem devem ser acessados e decodificados programaticamente, pois não há um visualizador de imagens disponível no Console de gerenciamento da AWS.
Para obter mais informações sobre decodificação e visualização de quadros de imagem, consulte [Bibliotecas de decodificação de quadros de imagem](reference-libraries.md).
## AWS CLI and SDKs
------
#### [ 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 obter detalhes da API, consulte [GetImageFrame](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/GetImageFrame)a *Referência AWS SDK para C\$1\$1 da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/medical-imaging/#code-examples).
------
#### [ CLI ]
**AWS CLI**
**Para obter dados de pixels do conjunto de imagens**
O exemplo de código `get-image-frame` a seguir obtém um quadro de imagem.
```
aws medical-imaging get-image-frame \
--datastore-id "12345678901234567890123456789012" \
--image-set-id "98765412345612345678907890789012" \
--image-frame-information imageFrameId=3abf5d5d7ae72f80a0ec81b2c0de3ef4 \
imageframe.jph
```
Observação: esse exemplo de código não inclui a saída porque a GetImageFrame ação retorna um fluxo de dados de pixels para o arquivo imageframe.jph. Para obter informações sobre decodificação e visualização de quadros de imagem, consulte Bibliotecas de decodificação HTJ2 K.
Para obter mais informações, consulte [Obter dados de pixels do conjunto de imagens](https://docs.aws.amazon.com/healthimaging/latest/devguide/get-image-frame.html) no *Guia do AWS HealthImaging desenvolvedor*.
+ Para obter detalhes da API, consulte [GetImageFrame](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/get-image-frame.html)na *Referência 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 obter detalhes da API, consulte [GetImageFrame](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/GetImageFrame)a *Referência AWS SDK for Java 2.x da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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: ][ IncomingMessage {}
// }
return response;
};
```
+ Para obter detalhes da API, consulte [GetImageFrame](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/GetImageFrameCommand)a *Referência AWS SDK para JavaScript da API*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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
```
O código a seguir instancia o MedicalImagingWrapper objeto.
```
client = boto3.client("medical-imaging")
medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+ Para obter detalhes da API, consulte a [GetImageFrame](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/GetImageFrame)Referência da API *AWS SDK for Python (Boto3*).
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte a [GetImageFrame](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/mig#code-examples).
------
**Exemplo de disponibilidade**
Não consegue encontrar o que precisa? Solicite um exemplo de código usando o link **Fornecer feedback** na barra lateral direita desta página.]